/*
* Copyright (C) 2012 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <gtest/gtest.h>
#include <inttypes.h>
#define LOG_TAG "CameraBurstTest"
//#define LOG_NDEBUG 0
#include <utils/Log.h>
#include <utils/Timers.h>
#include <cmath>
#include "CameraStreamFixture.h"
#include "TestExtensions.h"
#define CAMERA_FRAME_TIMEOUT 1000000000LL //nsecs (1 secs)
#define CAMERA_HEAP_COUNT 2 //HALBUG: 1 means registerBuffers fails
#define CAMERA_BURST_DEBUGGING 0
#define CAMERA_FRAME_BURST_COUNT 10
/* constants for the exposure test */
#define CAMERA_EXPOSURE_DOUBLE 2
#define CAMERA_EXPOSURE_DOUBLING_THRESHOLD 1.0f
#define CAMERA_EXPOSURE_DOUBLING_COUNT 4
#define CAMERA_EXPOSURE_FORMAT CAMERA_STREAM_AUTO_CPU_FORMAT
#define CAMERA_EXPOSURE_STARTING 100000 // 1/10ms, up to 51.2ms with 10 steps
#define USEC 1000LL // in ns
#define MSEC 1000000LL // in ns
#define SEC 1000000000LL // in ns
#if CAMERA_BURST_DEBUGGING
#define dout std::cout
#else
#define dout if (0) std::cout
#endif
#define WARN_UNLESS(condition) if(!(condition)) std::cerr << "Warning: "
#define WARN_LE(exp, act) WARN_UNLESS((exp) <= (act))
#define WARN_LT(exp, act) WARN_UNLESS((exp) < (act))
#define WARN_GT(exp, act) WARN_UNLESS((exp) > (act))
using namespace android;
using namespace android::camera2;
namespace android {
namespace camera2 {
namespace tests {
static CameraStreamParams STREAM_PARAMETERS = {
/*mFormat*/ CAMERA_EXPOSURE_FORMAT,
/*mHeapCount*/ CAMERA_HEAP_COUNT
};
class CameraBurstTest
: public ::testing::Test,
public CameraStreamFixture {
public:
CameraBurstTest() : CameraStreamFixture(STREAM_PARAMETERS) {
TEST_EXTENSION_FORKING_CONSTRUCTOR;
if (HasFatalFailure()) {
return;
}
CreateStream();
}
~CameraBurstTest() {
TEST_EXTENSION_FORKING_DESTRUCTOR;
if (mDevice.get()) {
mDevice->waitUntilDrained();
}
DeleteStream();
}
virtual void SetUp() {
TEST_EXTENSION_FORKING_SET_UP;
}
virtual void TearDown() {
TEST_EXTENSION_FORKING_TEAR_DOWN;
}
/* this assumes the format is YUV420sp or flexible YUV */
long long TotalBrightness(const CpuConsumer::LockedBuffer& imgBuffer,
int *underexposed,
int *overexposed) const {
const uint8_t* buf = imgBuffer.data;
size_t stride = imgBuffer.stride;
/* iterate over the Y plane only */
long long acc = 0;
*underexposed = 0;
*overexposed = 0;
for (size_t y = 0; y < imgBuffer.height; ++y) {
for (size_t x = 0; x < imgBuffer.width; ++x) {
const uint8_t p = buf[y * stride + x];
if (p == 0) {
if (underexposed) {
++*underexposed;
}
continue;
} else if (p == 255) {
if (overexposed) {
++*overexposed;
}
continue;
}
acc += p;
}
}
return acc;
}
// Parses a comma-separated string list into a Vector
template<typename T>
void ParseList(const char *src, Vector<T> &list) {
std::istringstream s(src);
while (!s.eof()) {
char c = s.peek();
if (c == ',' || c == ' ') {
s.ignore(1, EOF);
continue;
}
T val;
s >> val;
list.push_back(val);
}
}
};
TEST_F(CameraBurstTest, ManualExposureControl) {
TEST_EXTENSION_FORKING_INIT;
// Range of valid exposure times, in nanoseconds
int64_t minExp, maxExp;
{
camera_metadata_ro_entry exposureTimeRange =
GetStaticEntry(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE);
ASSERT_EQ(2u, exposureTimeRange.count);
minExp = exposureTimeRange.data.i64[0];
maxExp = exposureTimeRange.data.i64[1];
}
dout << "Min exposure is " << minExp;
dout << " max exposure is " << maxExp << std::endl;
// Calculate some set of valid exposure times for each request
int64_t exposures[CAMERA_FRAME_BURST_COUNT];
exposures[0] = CAMERA_EXPOSURE_STARTING;
for (int i = 1; i < CAMERA_FRAME_BURST_COUNT; ++i) {
exposures[i] = exposures[i-1] * CAMERA_EXPOSURE_DOUBLE;
}
// Our calculated exposure times should be in [minExp, maxExp]
EXPECT_LE(minExp, exposures[0])
<< "Minimum exposure range is too high, wanted at most "
<< exposures[0] << "ns";
EXPECT_GE(maxExp, exposures[CAMERA_FRAME_BURST_COUNT-1])
<< "Maximum exposure range is too low, wanted at least "
<< exposures[CAMERA_FRAME_BURST_COUNT-1] << "ns";
// Create a preview request, turning off all 3A
CameraMetadata previewRequest;
ASSERT_EQ(OK, mDevice->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW,
&previewRequest));
{
Vector<int32_t> outputStreamIds;
outputStreamIds.push(mStreamId);
ASSERT_EQ(OK, previewRequest.update(ANDROID_REQUEST_OUTPUT_STREAMS,
outputStreamIds));
// Disable all 3A routines
uint8_t cmOff = static_cast<uint8_t>(ANDROID_CONTROL_MODE_OFF);
ASSERT_EQ(OK, previewRequest.update(ANDROID_CONTROL_MODE,
&cmOff, 1));
int requestId = 1;
ASSERT_EQ(OK, previewRequest.update(ANDROID_REQUEST_ID,
&requestId, 1));
if (CAMERA_BURST_DEBUGGING) {
int frameCount = 0;
ASSERT_EQ(OK, previewRequest.update(ANDROID_REQUEST_FRAME_COUNT,
&frameCount, 1));
}
}
if (CAMERA_BURST_DEBUGGING) {
previewRequest.dump(STDOUT_FILENO);
}
// Submit capture requests
for (int i = 0; i < CAMERA_FRAME_BURST_COUNT; ++i) {
CameraMetadata tmpRequest = previewRequest;
ASSERT_EQ(OK, tmpRequest.update(ANDROID_SENSOR_EXPOSURE_TIME,
&exposures[i], 1));
ALOGV("Submitting capture request %d with exposure %" PRId64, i,
exposures[i]);
dout << "Capture request " << i << " exposure is "
<< (exposures[i]/1e6f) << std::endl;
ASSERT_EQ(OK, mDevice->capture(tmpRequest));
}
dout << "Buffer dimensions " << mWidth << "x" << mHeight << std::endl;
float brightnesses[CAMERA_FRAME_BURST_COUNT];
// Get each frame (metadata) and then the buffer. Calculate brightness.
for (int i = 0; i < CAMERA_FRAME_BURST_COUNT; ++i) {
ALOGV("Reading capture request %d with exposure %" PRId64, i, exposures[i]);
ASSERT_EQ(OK, mDevice->waitForNextFrame(CAMERA_FRAME_TIMEOUT));
ALOGV("Reading capture request-1 %d", i);
CaptureResult result;
ASSERT_EQ(OK, mDevice->getNextResult(&result));
ALOGV("Reading capture request-2 %d", i);
ASSERT_EQ(OK, mFrameListener->waitForFrame(CAMERA_FRAME_TIMEOUT));
ALOGV("We got the frame now");
CpuConsumer::LockedBuffer imgBuffer;
ASSERT_EQ(OK, mCpuConsumer->lockNextBuffer(&imgBuffer));
int underexposed, overexposed;
long long brightness = TotalBrightness(imgBuffer, &underexposed,
&overexposed);
float avgBrightness = brightness * 1.0f /
(mWidth * mHeight - (underexposed + overexposed));
ALOGV("Total brightness for frame %d was %lld (underexposed %d, "
"overexposed %d), avg %f", i, brightness, underexposed,
overexposed, avgBrightness);
dout << "Average brightness (frame " << i << ") was " << avgBrightness
<< " (underexposed " << underexposed << ", overexposed "
<< overexposed << ")" << std::endl;
ASSERT_EQ(OK, mCpuConsumer->unlockBuffer(imgBuffer));
brightnesses[i] = avgBrightness;
}
// Calculate max consecutive frame exposure doubling
float prev = brightnesses[0];
int doubling_count = 1;
int max_doubling_count = 0;
for (int i = 1; i < CAMERA_FRAME_BURST_COUNT; ++i) {
if (fabs(brightnesses[i] - prev*CAMERA_EXPOSURE_DOUBLE)
<= CAMERA_EXPOSURE_DOUBLING_THRESHOLD) {
doubling_count++;
}
else {
max_doubling_count = std::max(max_doubling_count, doubling_count);
doubling_count = 1;
}
prev = brightnesses[i];
}
dout << "max doubling count: " << max_doubling_count << std::endl;
/**
* Make this check warning only, since the brightness calculation is not reliable
* and we have separate test to cover this case. Plus it is pretty subtle to make
* it right without complicating the test too much.
*/
WARN_LE(CAMERA_EXPOSURE_DOUBLING_COUNT, max_doubling_count)
<< "average brightness should double at least "
<< CAMERA_EXPOSURE_DOUBLING_COUNT
<< " times over each consecutive frame as the exposure is doubled"
<< std::endl;
}
/**
* This test varies exposure time, frame duration, and sensitivity for a
* burst of captures. It picks values by default, but the selection can be
* overridden with the environment variables
* CAMERA2_TEST_VARIABLE_BURST_EXPOSURE_TIMES
* CAMERA2_TEST_VARIABLE_BURST_FRAME_DURATIONS
* CAMERA2_TEST_VARIABLE_BURST_SENSITIVITIES
* which must all be a list of comma-separated values, and each list must be
* the same length. In addition, if the environment variable
* CAMERA2_TEST_VARIABLE_BURST_DUMP_FRAMES
* is set to 1, then the YUV buffers are dumped into files named
* "camera2_test_variable_burst_frame_NNN.yuv"
*
* For example:
* $ setenv CAMERA2_TEST_VARIABLE_BURST_EXPOSURE_TIMES 10000000,20000000
* $ setenv CAMERA2_TEST_VARIABLE_BURST_FRAME_DURATIONS 40000000,40000000
* $ setenv CAMERA2_TEST_VARIABLE_BURST_SENSITIVITIES 200,100
* $ setenv CAMERA2_TEST_VARIABLE_BURST_DUMP_FRAMES 1
* $ /data/nativetest/camera2_test/camera2_test --gtest_filter="*VariableBurst"
*/
TEST_F(CameraBurstTest, VariableBurst) {
TEST_EXTENSION_FORKING_INIT;
// Bounds for checking frame duration is within range
const nsecs_t DURATION_UPPER_BOUND = 10 * MSEC;
const nsecs_t DURATION_LOWER_BOUND = 20 * MSEC;
// Threshold for considering two captures to have equivalent exposure value,
// as a ratio of the smaller EV to the larger EV.
const float EV_MATCH_BOUND = 0.95;
// Bound for two captures with equivalent exp values to have the same
// measured brightness, in 0-255 luminance.
const float BRIGHTNESS_MATCH_BOUND = 5;
// Environment variables to look for to override test settings
const char *expEnv = "CAMERA2_TEST_VARIABLE_BURST_EXPOSURE_TIMES";
const char *durationEnv = "CAMERA2_TEST_VARIABLE_BURST_FRAME_DURATIONS";
const char *sensitivityEnv = "CAMERA2_TEST_VARIABLE_BURST_SENSITIVITIES";
const char *dumpFrameEnv = "CAMERA2_TEST_VARIABLE_BURST_DUMP_FRAMES";
// Range of valid exposure times, in nanoseconds
int64_t minExp = 0, maxExp = 0;
// List of valid sensor sensitivities
Vector<int32_t> sensitivities;
// Range of valid frame durations, in nanoseconds
int64_t minDuration = 0, maxDuration = 0;
{
camera_metadata_ro_entry exposureTimeRange =
GetStaticEntry(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE);
EXPECT_EQ(2u, exposureTimeRange.count) << "Bad exposure time range tag."
"Using default values";
if (exposureTimeRange.count == 2) {
minExp = exposureTimeRange.data.i64[0];
maxExp = exposureTimeRange.data.i64[1];
}
EXPECT_LT(0, minExp) << "Minimum exposure time is 0";
EXPECT_LT(0, maxExp) << "Maximum exposure time is 0";
EXPECT_LE(minExp, maxExp) << "Minimum exposure is greater than maximum";
if (minExp == 0) {
minExp = 1 * MSEC; // Fallback minimum exposure time
}
if (maxExp == 0) {
maxExp = 10 * SEC; // Fallback maximum exposure time
}
}
camera_metadata_ro_entry hardwareLevel =
GetStaticEntry(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL);
ASSERT_EQ(1u, hardwareLevel.count);
uint8_t level = hardwareLevel.data.u8[0];
ASSERT_GE(level, ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED);
ASSERT_LE(level, ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_FULL);
if (level == ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED) {
const ::testing::TestInfo* const test_info =
::testing::UnitTest::GetInstance()->current_test_info();
std::cerr << "Skipping test "
<< test_info->test_case_name() << "."
<< test_info->name()
<< " because HAL hardware supported level is limited "
<< std::endl;
return;
}
dout << "Stream size is " << mWidth << " x " << mHeight << std::endl;
dout << "Valid exposure range is: " <<
minExp << " - " << maxExp << " ns " << std::endl;
{
camera_metadata_ro_entry sensivityRange =
GetStaticEntry(ANDROID_SENSOR_INFO_SENSITIVITY_RANGE);
EXPECT_EQ(2u, sensivityRange.count) << "No sensitivity range listed."
"Falling back to default set.";
int32_t minSensitivity = 100;
int32_t maxSensitivity = 800;
if (sensivityRange.count == 2) {
ASSERT_GT(sensivityRange.data.i32[0], 0);
ASSERT_GT(sensivityRange.data.i32[1], 0);
minSensitivity = sensivityRange.data.i32[0];
maxSensitivity = sensivityRange.data.i32[1];
}
int32_t count = (maxSensitivity - minSensitivity + 99) / 100;
sensitivities.push_back(minSensitivity);
for (int i = 1; i < count; i++) {
sensitivities.push_back(minSensitivity + i * 100);
}
sensitivities.push_back(maxSensitivity);
}
dout << "Available sensitivities: ";
for (size_t i = 0; i < sensitivities.size(); i++) {
dout << sensitivities[i] << " ";
}
dout << std::endl;
{
if (getDeviceVersion() < CAMERA_DEVICE_API_VERSION_3_2) {
camera_metadata_ro_entry availableProcessedSizes =
GetStaticEntry(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES);
camera_metadata_ro_entry availableProcessedMinFrameDurations =
GetStaticEntry(ANDROID_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS);
EXPECT_EQ(availableProcessedSizes.count,
availableProcessedMinFrameDurations.count * 2) <<
"The number of minimum frame durations doesn't match the number of "
"available sizes. Using fallback values";
if (availableProcessedSizes.count ==
availableProcessedMinFrameDurations.count * 2) {
bool gotSize = false;
for (size_t i = 0; i < availableProcessedSizes.count; i += 2) {
if (availableProcessedSizes.data.i32[i] == mWidth &&
availableProcessedSizes.data.i32[i+1] == mHeight) {
gotSize = true;
minDuration = availableProcessedMinFrameDurations.data.i64[i/2];
}
}
EXPECT_TRUE(gotSize) << "Can't find stream size in list of "
"available sizes: " << mWidth << ", " << mHeight;
}
if (minDuration == 0) {
minDuration = 1 * SEC / 30; // Fall back to 30 fps as minimum duration
}
} else {
minDuration = getMinFrameDurationFor(
HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, mWidth, mHeight);
}
ASSERT_LT(0, minDuration);
camera_metadata_ro_entry maxFrameDuration =
GetStaticEntry(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION);
EXPECT_EQ(1u, maxFrameDuration.count) << "No valid maximum frame duration";
if (maxFrameDuration.count == 1) {
maxDuration = maxFrameDuration.data.i64[0];
}
EXPECT_GT(maxDuration, 0) << "Max duration is 0 or not given, using fallback";
if (maxDuration == 0) {
maxDuration = 10 * SEC; // Fall back to 10 seconds as max duration
}
}
dout << "Available frame duration range for configured stream size: "
<< minDuration << " - " << maxDuration << " ns" << std::endl;
// Get environment variables if set
const char *expVal = getenv(expEnv);
const char *durationVal = getenv(durationEnv);
const char *sensitivityVal = getenv(sensitivityEnv);
bool gotExp = (expVal != NULL);
bool gotDuration = (durationVal != NULL);
bool gotSensitivity = (sensitivityVal != NULL);
// All or none must be provided if using override envs
ASSERT_TRUE( (gotDuration && gotExp && gotSensitivity) ||
(!gotDuration && !gotExp && !gotSensitivity) ) <<
"Incomplete set of environment variable overrides provided";
Vector<int64_t> expList, durationList;
Vector<int32_t> sensitivityList;
if (gotExp) {
ParseList(expVal, expList);
ParseList(durationVal, durationList);
ParseList(sensitivityVal, sensitivityList);
ASSERT_TRUE(
(expList.size() == durationList.size()) &&
(durationList.size() == sensitivityList.size())) <<
"Mismatched sizes in env lists, or parse error";
dout << "Using burst list from environment with " << expList.size() <<
" captures" << std::endl;
} else {
// Create a default set of controls based on the available ranges
int64_t e;
int64_t d;
int32_t s;
// Exposure ramp
e = minExp;
d = minDuration;
s = sensitivities[0];
while (e < maxExp) {
expList.push_back(e);
durationList.push_back(d);
sensitivityList.push_back(s);
e = e * 2;
}
e = maxExp;
expList.push_back(e);
durationList.push_back(d);
sensitivityList.push_back(s);
// Duration ramp
e = 30 * MSEC;
d = minDuration;
s = sensitivities[0];
while (d < maxDuration) {
// make sure exposure <= frame duration
expList.push_back(e > d ? d : e);
durationList.push_back(d);
sensitivityList.push_back(s);
d = d * 2;
}
// Sensitivity ramp
e = 30 * MSEC;
d = 30 * MSEC;
d = d > minDuration ? d : minDuration;
for (size_t i = 0; i < sensitivities.size(); i++) {
expList.push_back(e);
durationList.push_back(d);
sensitivityList.push_back(sensitivities[i]);
}
// Constant-EV ramp, duration == exposure
e = 30 * MSEC; // at ISO 100
for (size_t i = 0; i < sensitivities.size(); i++) {
int64_t e_adj = e * 100 / sensitivities[i];
expList.push_back(e_adj);
durationList.push_back(e_adj > minDuration ? e_adj : minDuration);
sensitivityList.push_back(sensitivities[i]);
}
dout << "Default burst sequence created with " << expList.size() <<
" entries" << std::endl;
}
// Validate the list, but warn only
for (size_t i = 0; i < expList.size(); i++) {
EXPECT_GE(maxExp, expList[i])
<< "Capture " << i << " exposure too long: " << expList[i];
EXPECT_LE(minExp, expList[i])
<< "Capture " << i << " exposure too short: " << expList[i];
EXPECT_GE(maxDuration, durationList[i])
<< "Capture " << i << " duration too long: " << durationList[i];
EXPECT_LE(minDuration, durationList[i])
<< "Capture " << i << " duration too short: " << durationList[i];
bool validSensitivity = false;
for (size_t j = 0; j < sensitivities.size(); j++) {
if (sensitivityList[i] == sensitivities[j]) {
validSensitivity = true;
break;
}
}
EXPECT_TRUE(validSensitivity)
<< "Capture " << i << " sensitivity not in list: " << sensitivityList[i];
}
// Check if debug yuv dumps are requested
bool dumpFrames = false;
{
const char *frameDumpVal = getenv(dumpFrameEnv);
if (frameDumpVal != NULL) {
if (frameDumpVal[0] == '1') dumpFrames = true;
}
}
dout << "Dumping YUV frames " <<
(dumpFrames ? "enabled, not checking timing" : "disabled") << std::endl;
// Create a base preview request, turning off all 3A
CameraMetadata previewRequest;
ASSERT_EQ(OK, mDevice->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW,
&previewRequest));
{
Vector<int32_t> outputStreamIds;
outputStreamIds.push(mStreamId);
ASSERT_EQ(OK, previewRequest.update(ANDROID_REQUEST_OUTPUT_STREAMS,
outputStreamIds));
// Disable all 3A routines
uint8_t cmOff = static_cast<uint8_t>(ANDROID_CONTROL_MODE_OFF);
ASSERT_EQ(OK, previewRequest.update(ANDROID_CONTROL_MODE,
&cmOff, 1));
int requestId = 1;
ASSERT_EQ(OK, previewRequest.update(ANDROID_REQUEST_ID,
&requestId, 1));
}
// Submit capture requests
for (size_t i = 0; i < expList.size(); ++i) {
CameraMetadata tmpRequest = previewRequest;
ASSERT_EQ(OK, tmpRequest.update(ANDROID_SENSOR_EXPOSURE_TIME,
&expList[i], 1));
ASSERT_EQ(OK, tmpRequest.update(ANDROID_SENSOR_FRAME_DURATION,
&durationList[i], 1));
ASSERT_EQ(OK, tmpRequest.update(ANDROID_SENSOR_SENSITIVITY,
&sensitivityList[i], 1));
ALOGV("Submitting capture %zu with exposure %" PRId64 ", frame duration %" PRId64 ", sensitivity %d",
i, expList[i], durationList[i], sensitivityList[i]);
dout << "Capture request " << i <<
": exposure is " << (expList[i]/1e6f) << " ms" <<
", frame duration is " << (durationList[i]/1e6f) << " ms" <<
", sensitivity is " << sensitivityList[i] <<
std::endl;
ASSERT_EQ(OK, mDevice->capture(tmpRequest));
}
Vector<float> brightnesses;
Vector<nsecs_t> captureTimes;
brightnesses.setCapacity(expList.size());
captureTimes.setCapacity(expList.size());
// Get each frame (metadata) and then the buffer. Calculate brightness.
for (size_t i = 0; i < expList.size(); ++i) {
ALOGV("Reading request %zu", i);
dout << "Waiting for capture " << i << ": " <<
" exposure " << (expList[i]/1e6f) << " ms," <<
" frame duration " << (durationList[i]/1e6f) << " ms," <<
" sensitivity " << sensitivityList[i] <<
std::endl;
// Set wait limit based on expected frame duration, or minimum timeout
int64_t waitLimit = CAMERA_FRAME_TIMEOUT;
if (expList[i] * 2 > waitLimit) waitLimit = expList[i] * 2;
if (durationList[i] * 2 > waitLimit) waitLimit = durationList[i] * 2;
ASSERT_EQ(OK, mDevice->waitForNextFrame(waitLimit));
ALOGV("Reading capture request-1 %zu", i);
CaptureResult result;
ASSERT_EQ(OK, mDevice->getNextResult(&result));
ALOGV("Reading capture request-2 %zu", i);
ASSERT_EQ(OK, mFrameListener->waitForFrame(CAMERA_FRAME_TIMEOUT));
ALOGV("We got the frame now");
captureTimes.push_back(systemTime());
CpuConsumer::LockedBuffer imgBuffer;
ASSERT_EQ(OK, mCpuConsumer->lockNextBuffer(&imgBuffer));
int underexposed, overexposed;
float avgBrightness = 0;
long long brightness = TotalBrightness(imgBuffer, &underexposed,
&overexposed);
int numValidPixels = mWidth * mHeight - (underexposed + overexposed);
if (numValidPixels != 0) {
avgBrightness = brightness * 1.0f / numValidPixels;
} else if (underexposed < overexposed) {
avgBrightness = 255;
}
ALOGV("Total brightness for frame %zu was %lld (underexposed %d, "
"overexposed %d), avg %f", i, brightness, underexposed,
overexposed, avgBrightness);
dout << "Average brightness (frame " << i << ") was " << avgBrightness
<< " (underexposed " << underexposed << ", overexposed "
<< overexposed << ")" << std::endl;
brightnesses.push_back(avgBrightness);
if (i != 0) {
float prevEv = static_cast<float>(expList[i - 1]) * sensitivityList[i - 1];
float currentEv = static_cast<float>(expList[i]) * sensitivityList[i];
float evRatio = (prevEv > currentEv) ? (currentEv / prevEv) :
(prevEv / currentEv);
if ( evRatio > EV_MATCH_BOUND ) {
WARN_LT(fabs(brightnesses[i] - brightnesses[i - 1]),
BRIGHTNESS_MATCH_BOUND) <<
"Capture brightness different from previous, even though "
"they have the same EV value. Ev now: " << currentEv <<
", previous: " << prevEv << ". Brightness now: " <<
brightnesses[i] << ", previous: " << brightnesses[i-1] <<
std::endl;
}
// Only check timing if not saving to disk, since that slows things
// down substantially
if (!dumpFrames) {
nsecs_t timeDelta = captureTimes[i] - captureTimes[i-1];
nsecs_t expectedDelta = expList[i] > durationList[i] ?
expList[i] : durationList[i];
WARN_LT(timeDelta, expectedDelta + DURATION_UPPER_BOUND) <<
"Capture took " << timeDelta << " ns to receive, but expected"
" frame duration was " << expectedDelta << " ns." <<
std::endl;
WARN_GT(timeDelta, expectedDelta - DURATION_LOWER_BOUND) <<
"Capture took " << timeDelta << " ns to receive, but expected"
" frame duration was " << expectedDelta << " ns." <<
std::endl;
dout << "Time delta from previous frame: " << timeDelta / 1e6 <<
" ms. Expected " << expectedDelta / 1e6 << " ms" << std::endl;
}
}
if (dumpFrames) {
String8 dumpName =
String8::format("/data/local/tmp/camera2_test_variable_burst_frame_%03zu.yuv", i);
dout << " Writing YUV dump to " << dumpName << std::endl;
DumpYuvToFile(dumpName, imgBuffer);
}
ASSERT_EQ(OK, mCpuConsumer->unlockBuffer(imgBuffer));
}
}
}
}
}