path: root/tests/camera2/CameraBurstTests.cpp

/*
 * 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"
 */
// Disable this test for now, as we need cleanup the usage of the deprecated tag quite a bit.
TEST_F(CameraBurstTest, DISABLED_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;

    {
        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
        }

        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));
    }

}

}
}
}