| /* |
| * Copyright (C) 2014 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. |
| */ |
| |
| package android.hardware.camera2.cts; |
| |
| import static android.hardware.camera2.cts.CameraTestUtils.*; |
| |
| import android.graphics.ImageFormat; |
| import android.graphics.Rect; |
| import android.hardware.camera2.CameraCharacteristics; |
| import android.hardware.camera2.CameraDevice; |
| import android.hardware.camera2.CaptureRequest; |
| import android.hardware.camera2.CaptureRequest.Builder; |
| import android.hardware.camera2.CaptureResult; |
| import android.hardware.camera2.cts.CameraTestUtils.SimpleCaptureCallback; |
| import android.hardware.camera2.cts.CameraTestUtils.SimpleImageReaderListener; |
| import android.hardware.camera2.cts.testcases.Camera2SurfaceViewTestCase; |
| import android.hardware.camera2.params.StreamConfigurationMap; |
| import android.media.Image; |
| import android.util.Log; |
| import android.util.Range; |
| import android.util.Size; |
| |
| import java.util.ArrayList; |
| |
| /** |
| * Basic tests for burst capture in RAW formats. |
| */ |
| public class BurstCaptureRawTest extends Camera2SurfaceViewTestCase { |
| private static final String TAG = "BurstCaptureRawTest"; |
| private static final int RAW_FORMATS[] = { |
| ImageFormat.RAW10, ImageFormat.RAW12, ImageFormat.RAW_SENSOR }; |
| private static final int NONSTALL_RAW_FORMATS[] = { |
| ImageFormat.RAW10, ImageFormat.RAW12 }; |
| private static final long EXPOSURE_MULTIPLIERS[] = { |
| 1, 3, 5 }; |
| private static final int SENSITIVITY_MLTIPLIERS[] = { |
| 1, 3, 5 }; |
| private static final int MAX_FRAMES_BURST = |
| EXPOSURE_MULTIPLIERS.length * SENSITIVITY_MLTIPLIERS.length; |
| |
| @Override |
| protected void setUp() throws Exception { |
| super.setUp(); |
| } |
| |
| @Override |
| protected void tearDown() throws Exception { |
| super.tearDown(); |
| } |
| |
| /** |
| * Verify raw sensor size information is correctly configured. |
| */ |
| public void testRawSensorSize() throws Exception { |
| Log.i(TAG, "Begin testRawSensorSize"); |
| for (String id : mCameraIds) { |
| try { |
| openDevice(id); |
| |
| ArrayList<Integer> supportedRawList = new ArrayList<Integer>(RAW_FORMATS.length); |
| if (!checkCapability(supportedRawList, RAW_FORMATS)) { |
| Log.i(TAG, "Capability is not supported on camera " + id |
| + ". Skip the test."); |
| continue; |
| } |
| |
| Size[] rawSizes = mStaticInfo.getRawOutputSizesChecked(); |
| assertTrue("No capture sizes available for RAW format!", rawSizes.length != 0); |
| |
| // Check happens in getRawDimensChecked. |
| Size rawSize = mStaticInfo.getRawDimensChecked(); |
| } finally { |
| closeDevice(); |
| } |
| } |
| Log.i(TAG, "End testRawSensorSize"); |
| } |
| |
| /** |
| * Round [exposure, gain] down, rather than to the nearest, in RAW 10/16 |
| * <p> |
| * Verify the value of metadata (exposure and sensitivity) is rounded down if the request cannot |
| * be honored. |
| * </p> |
| */ |
| public void testMetadataRoundDown() throws Exception { |
| Log.i(TAG, "Begin testMetadataRoundDown"); |
| |
| performTestRoutine(new TestMetaDataRoundDownRoutine(), RAW_FORMATS); |
| |
| Log.i(TAG, "End testMetadataRoundDown"); |
| } |
| |
| /** |
| * Manual and Auto setting test in RAW formats |
| * <p> |
| * Make sure switching between manual and auto setting would not make the capture results out of |
| * sync. |
| * </p> |
| */ |
| public void testManualAutoSwitch() throws Exception { |
| Log.i(TAG, "Begin testManualAutoSwitch"); |
| |
| performTestRoutine(new TestManualAutoSwitch(), RAW_FORMATS); |
| |
| Log.i(TAG, "End testManualAutoSwitch"); |
| } |
| |
| /** |
| * Per frame timestamp test in non-stalled RAW formats |
| */ |
| public void testTimestamp() throws Exception { |
| Log.i(TAG, "Begin testTimestamp"); |
| |
| performTestRoutine(new TestTimestamp(), NONSTALL_RAW_FORMATS); |
| |
| Log.i(TAG, "End testTimestamp"); |
| } |
| |
| /* |
| * Below are private infrastructure for all tests |
| */ |
| |
| /** |
| * A structure encapsulates all the parameters for setting up preview, and RAW capture. |
| */ |
| class CaptureSetup |
| { |
| public CaptureSetup(Size previewCaptureSize, Size rawCaptureSize, |
| CaptureRequest.Builder previewRequestBuilder, |
| CaptureRequest.Builder rawRequestBuilder, |
| SimpleCaptureCallback previewCaptureCallback, |
| SimpleCaptureCallback rawCaptureCallback, |
| SimpleImageReaderListener rawReaderListener) |
| { |
| mPreviewCaptureSize = previewCaptureSize; |
| mRawCaptureSize = rawCaptureSize; |
| mPreviewRequestBuilder = previewRequestBuilder; |
| mRawRequestBuilder = rawRequestBuilder; |
| mPreviewCaptureCallback = previewCaptureCallback; |
| mRawCaptureCallback = rawCaptureCallback; |
| mRawReaderListener = rawReaderListener; |
| } |
| |
| public Size getPreviewCaptureSize() |
| { |
| return mPreviewCaptureSize; |
| } |
| |
| public Size getRawCaptureSize() |
| { |
| return mRawCaptureSize; |
| } |
| |
| public CaptureRequest.Builder getPreviewRequestBuilder() |
| { |
| return mPreviewRequestBuilder; |
| } |
| |
| public CaptureRequest.Builder getRawRequestBuilder() { |
| return mRawRequestBuilder; |
| } |
| |
| public SimpleCaptureCallback getPreviewCaptureCallback() { |
| return mPreviewCaptureCallback; |
| } |
| |
| public SimpleCaptureCallback getRawCaptureCallback() { |
| return mRawCaptureCallback; |
| } |
| |
| public SimpleImageReaderListener getRawReaderListener() { |
| return mRawReaderListener; |
| } |
| |
| private Size mPreviewCaptureSize; |
| private Size mRawCaptureSize; |
| private CaptureRequest.Builder mPreviewRequestBuilder; |
| private CaptureRequest.Builder mRawRequestBuilder; |
| |
| /** all the non-testing requests are sent to here */ |
| private SimpleCaptureCallback mPreviewCaptureCallback; |
| /** all the testing requests are sent to here */ |
| private SimpleCaptureCallback mRawCaptureCallback; |
| /** all the testing framebuffers are sent to here */ |
| private SimpleImageReaderListener mRawReaderListener; |
| } |
| |
| /** |
| * Interface for the test routines that are being called by performTestRoutines(). Implement |
| * different test cases in execute(). |
| */ |
| interface TestRoutine { |
| public void execute(CaptureRequest.Builder rawBurstBuilder, |
| SimpleCaptureCallback rawCaptureCallback, |
| SimpleImageReaderListener rawReaderListener, int rawFormat) throws Exception; |
| } |
| |
| /** |
| * Implementation of metadata round down test. |
| */ |
| class TestMetaDataRoundDownRoutine implements TestRoutine |
| { |
| @Override |
| public void execute(CaptureRequest.Builder rawBurstBuilder, |
| SimpleCaptureCallback rawCaptureCallback, |
| SimpleImageReaderListener rawReaderListener, int rawFormat) throws Exception |
| { |
| // build burst capture |
| ArrayList<CaptureRequest> rawRequestList = createBurstRequest(rawBurstBuilder); |
| |
| // submit captrue |
| Log.i(TAG, "Submitting Burst Request."); |
| mSession.captureBurst(rawRequestList, rawCaptureCallback, mHandler); |
| |
| // verify metadata |
| for (int i = 0; i < MAX_FRAMES_BURST; i++) { |
| CaptureResult result = rawCaptureCallback.getCaptureResult( |
| CAPTURE_IMAGE_TIMEOUT_MS); |
| |
| long resultExposure = result.get(CaptureResult.SENSOR_EXPOSURE_TIME); |
| int resultSensitivity = result.get(CaptureResult.SENSOR_SENSITIVITY); |
| long desiredExposure = rawRequestList.get(i).get( |
| CaptureRequest.SENSOR_EXPOSURE_TIME); |
| int desiredSensitivity = rawRequestList.get(i).get( |
| CaptureRequest.SENSOR_SENSITIVITY); |
| |
| Log.i(TAG, String.format( |
| "Received capture result, exposure = %d, sensitivity = %d. " |
| + "Requested exposure = %d, sensitivity = %d.", |
| resultExposure, |
| resultSensitivity, desiredExposure, desiredSensitivity)); |
| |
| mCollector.expectTrue( |
| String.format("Exposure value is greater than requested: " |
| + "requested = %d, result = %d.", |
| desiredExposure, resultExposure), |
| resultExposure <= desiredExposure); |
| |
| mCollector.expectTrue( |
| String.format("Sensitivity value is greater than requested: " |
| + "requested = %d, result = %d.", |
| desiredSensitivity, resultSensitivity), |
| resultSensitivity <= desiredSensitivity); |
| } |
| } |
| } |
| |
| /** |
| * Implementation of manual-auto switching test. |
| */ |
| class TestManualAutoSwitch implements TestRoutine |
| { |
| @Override |
| public void execute(CaptureRequest.Builder rawBurstBuilder, |
| SimpleCaptureCallback rawCaptureCallback, |
| SimpleImageReaderListener rawReaderListener, int rawFormat) throws Exception |
| { |
| // create a capture request builder to preserve all the original values |
| CaptureRequest.Builder originBuilder = mCamera.createCaptureRequest( |
| CameraDevice.TEMPLATE_STILL_CAPTURE); |
| copyBurstRequetBuilder(originBuilder, rawBurstBuilder); |
| |
| // build burst capture |
| ArrayList<CaptureRequest> rawRequestList = createBurstRequest(rawBurstBuilder); |
| |
| // submit captrue but ignore |
| mSession.captureBurst(rawRequestList, rawCaptureCallback, mHandler); |
| |
| // drain the capture result |
| drainQueues(rawReaderListener, rawCaptureCallback); |
| |
| // reset and build capture with 3A |
| copyBurstRequetBuilder(rawBurstBuilder, originBuilder); |
| rawRequestList = createBurstRequestWith3A(rawBurstBuilder); |
| |
| // submit captrue but ignore |
| mSession.captureBurst(rawRequestList, rawCaptureCallback, mHandler); |
| |
| // drain the capture result |
| drainQueues(rawReaderListener, rawCaptureCallback); |
| |
| // reset and rebuild manual raw burst capture |
| copyBurstRequetBuilder(rawBurstBuilder, originBuilder); |
| rawRequestList = createBurstRequest(rawBurstBuilder); |
| |
| // submit capture |
| Log.i(TAG, "Submitting Burst Request."); |
| mSession.captureBurst(rawRequestList, rawCaptureCallback, mHandler); |
| |
| // verify metadata |
| for (int i = 0; i < MAX_FRAMES_BURST; i++) { |
| CaptureResult result = rawCaptureCallback.getCaptureResult( |
| CAPTURE_IMAGE_TIMEOUT_MS); |
| |
| long resultExposure = result.get(CaptureResult.SENSOR_EXPOSURE_TIME); |
| int resultSensitivity = result.get(CaptureResult.SENSOR_SENSITIVITY); |
| int resultEdgeMode = result.get(CaptureResult.EDGE_MODE); |
| int resultNoiseReductionMode = result.get( |
| CaptureResult.NOISE_REDUCTION_MODE); |
| long desiredExposure = rawRequestList.get(i).get( |
| CaptureRequest.SENSOR_EXPOSURE_TIME); |
| int desiredSensitivity = rawRequestList.get(i).get( |
| CaptureRequest.SENSOR_SENSITIVITY); |
| |
| Log.i(TAG, String.format( |
| "Received capture result, exposure = %d, sensitivity = %d. " |
| + "Requested exposure = %d, sensitivity = %d.", |
| resultExposure, |
| resultSensitivity, desiredExposure, desiredSensitivity)); |
| |
| mCollector.expectTrue(String.format("Edge mode is not turned off."), |
| resultEdgeMode == CaptureRequest.EDGE_MODE_OFF); |
| |
| mCollector.expectTrue(String.format("Noise reduction is not turned off."), |
| resultNoiseReductionMode |
| == CaptureRequest.NOISE_REDUCTION_MODE_OFF); |
| |
| mCollector.expectTrue( |
| String.format("Exposure value is greater than requested: " |
| + "requested = %d, result = %d.", |
| desiredExposure, resultExposure), |
| resultExposure <= desiredExposure); |
| |
| mCollector.expectTrue( |
| String.format("Sensitivity value is greater than requested: " |
| + "requested = %d, result = %d.", |
| desiredSensitivity, resultSensitivity), |
| resultSensitivity <= desiredSensitivity); |
| } |
| |
| } |
| } |
| |
| /** |
| * Implementation of timestamp test |
| */ |
| class TestTimestamp implements TestRoutine |
| { |
| private final double THRESHOLD = 5000000.0; // 5ms |
| private final long EXPOSURE_MULTIPLIERS_PRIVATE[] = { |
| 1, 1, 1 }; |
| private final int SENSITIVITY_MLTIPLIERS_PRIVATE[] = { |
| 1, 1, 1 }; |
| private final int MAX_FRAMES_BURST_PRIVATE = |
| EXPOSURE_MULTIPLIERS_PRIVATE.length * SENSITIVITY_MLTIPLIERS_PRIVATE.length; |
| |
| @Override |
| public void execute(Builder rawBurstBuilder, SimpleCaptureCallback rawCaptureCallback, |
| SimpleImageReaderListener rawReaderListener, int rawFormat) throws Exception { |
| // prepare some local variables |
| ArrayList<Long> sensorTime = new ArrayList<Long>(MAX_FRAMES_BURST_PRIVATE); |
| |
| // build burst capture |
| ArrayList<CaptureRequest> rawRequestList = createBurstRequest(rawBurstBuilder, |
| EXPOSURE_MULTIPLIERS_PRIVATE, SENSITIVITY_MLTIPLIERS_PRIVATE); |
| |
| // submit capture while recording timestamp |
| Log.i(TAG, "Submitting Burst Request."); |
| mSession.captureBurst(rawRequestList, rawCaptureCallback, mHandler); |
| |
| // receive frames while recording timestamp |
| for (int i = 0; i < MAX_FRAMES_BURST_PRIVATE; i++) { |
| CaptureResult result = rawCaptureCallback.getCaptureResult( |
| CAPTURE_IMAGE_TIMEOUT_MS); |
| long resultExposure = result.get(CaptureResult.SENSOR_EXPOSURE_TIME); |
| int resultSensitivity = result.get(CaptureResult.SENSOR_SENSITIVITY); |
| long resultTimestamp = result.get(CaptureResult.SENSOR_TIMESTAMP); |
| Log.i(TAG, String.format( |
| "Received capture result, exposure = %d, sensitivity = %d, timestamp = %d", |
| resultExposure, resultSensitivity, resultTimestamp)); |
| |
| sensorTime.add(resultTimestamp); |
| } |
| |
| // compare sensor time and compute the difference |
| ArrayList<Long> deltaList = new ArrayList<Long>(); |
| for (int i = 1; i < MAX_FRAMES_BURST_PRIVATE; i++) |
| { |
| deltaList.add(sensorTime.get(i) - sensorTime.get(i - 1)); |
| } |
| |
| // compute the average and standard deviation of the differences |
| double average = 0.0; |
| for (int i = 0; i < deltaList.size(); i++) |
| { |
| average += deltaList.get(i); |
| } |
| average /= deltaList.size(); |
| |
| double stddev = 0.0; |
| for (int i = 0; i < deltaList.size(); i++) |
| { |
| double diff = deltaList.get(i) - average; |
| stddev += diff * diff; |
| } |
| stddev = Math.sqrt(stddev / deltaList.size()); |
| |
| Log.i(TAG, String.format("average = %.2f, stddev = %.2f", average, stddev)); |
| |
| StringBuilder sensorTimestampMessage = new StringBuilder(); |
| for (int i = 0; i < sensorTime.size(); i++) |
| { |
| sensorTimestampMessage.append("frame ["); |
| sensorTimestampMessage.append(i); |
| sensorTimestampMessage.append("] SENSOR_TIMESTAMP = "); |
| sensorTimestampMessage.append(sensorTime.get(i)); |
| sensorTimestampMessage.append("\n"); |
| } |
| |
| mCollector.expectLessOrEqual( |
| "The standard deviation of frame interval is larger then threshold: " + |
| String.format("stddev = %.2f, threshold = %.2f.\n", stddev, THRESHOLD) + |
| sensorTimestampMessage.toString(), |
| THRESHOLD, stddev); |
| } |
| } |
| |
| /** |
| * Check sensor capability prior to the test. |
| * |
| * @return true if the it is has the capability to execute the test. |
| */ |
| private boolean checkCapability(ArrayList<Integer> supportedRawList, int[] testedFormats) { |
| // make sure the sensor has manual support |
| if (!mStaticInfo.isCapabilitySupported( |
| CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_FULL)) { |
| Log.w(TAG, "Full hardware level is not supported"); |
| return false; |
| } |
| |
| // get the list of supported RAW format |
| StreamConfigurationMap config = mStaticInfo.getValueFromKeyNonNull( |
| CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP); |
| |
| // check for the RAW support |
| supportedRawList.clear(); |
| for (int rawFormat : testedFormats) { |
| if (!config.isOutputSupportedFor(rawFormat)) { |
| continue; |
| } |
| supportedRawList.add(rawFormat); |
| } |
| |
| if (supportedRawList.size() == 0) |
| { |
| Log.w(TAG, "RAW output is not supported!"); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /** |
| * Return the sensor format to human readable string. |
| * |
| * @param format Sensor image format. |
| * @return Human readable string. |
| */ |
| private String imageFormatToString(int format) { |
| switch (format) { |
| case ImageFormat.RAW10: |
| return "RAW10"; |
| case ImageFormat.RAW12: |
| return "RAW12"; |
| case ImageFormat.RAW_SENSOR: |
| return "RAW_SENSOR"; |
| } |
| |
| return "Unknown"; |
| } |
| |
| /** |
| * Setting up various classes prior to the request, e.g.: capture size, builder, callback and |
| * listener |
| * |
| * @return initialized variables that can be directly fed into prepareCaptureAndStartPreview(). |
| */ |
| private CaptureSetup initCaptureSetupForPreviewAndRaw() throws Exception |
| { |
| // capture size |
| Size previewSize = mOrderedPreviewSizes.get(0); |
| Size rawSize = mStaticInfo.getRawDimensChecked(); |
| |
| // builder |
| CaptureRequest.Builder previewCaptureBuilder = mCamera.createCaptureRequest( |
| CameraDevice.TEMPLATE_PREVIEW); |
| CaptureRequest.Builder rawCaptureBuilder = mCamera.createCaptureRequest( |
| CameraDevice.TEMPLATE_STILL_CAPTURE); |
| |
| // callback |
| SimpleCaptureCallback previewCaptureCallback = new SimpleCaptureCallback(); |
| SimpleCaptureCallback rawCaptureCallback = new SimpleCaptureCallback(); |
| SimpleImageReaderListener rawReaderListener = new SimpleImageReaderListener(); |
| |
| CaptureSetup setup = new CaptureSetup(previewSize, rawSize, previewCaptureBuilder, |
| rawCaptureBuilder, previewCaptureCallback, rawCaptureCallback, rawReaderListener); |
| |
| return setup; |
| } |
| |
| /** |
| * Construct an array of burst request with manual exposure and sensitivity. |
| * <p> |
| * For each capture request, 3A and post processing (noise reduction, sharpening, etc) will be |
| * turned off. Then exposure and sensitivity value will be configured, which are determined by |
| * EXPOSURE_MULIPLIERS and SENSITIVITY_MULTIPLIERS. |
| * </p> |
| * |
| * @param rawBurstBuilder The builder needs to have targets setup. |
| * @return An array list capture request for burst. |
| */ |
| private ArrayList<CaptureRequest> createBurstRequest(CaptureRequest.Builder rawBurstBuilder) |
| { |
| return createBurstRequest(rawBurstBuilder, EXPOSURE_MULTIPLIERS, SENSITIVITY_MLTIPLIERS); |
| } |
| |
| private ArrayList<CaptureRequest> createBurstRequest(CaptureRequest.Builder rawBurstBuilder, |
| long[] exposureMultipliers, int[] sensitivityMultipliers) { |
| // set manual mode |
| rawBurstBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_OFF); |
| rawBurstBuilder.set(CaptureRequest.CONTROL_AWB_MODE, CaptureRequest.CONTROL_AWB_MODE_OFF); |
| rawBurstBuilder.set(CaptureRequest.NOISE_REDUCTION_MODE, |
| CaptureRequest.NOISE_REDUCTION_MODE_OFF); |
| rawBurstBuilder.set(CaptureRequest.EDGE_MODE, CaptureRequest.EDGE_MODE_OFF); |
| // exposure has higher priority over frame duration; therefore the frame readout time: |
| // exposure time + overhead |
| rawBurstBuilder.set(CaptureRequest.SENSOR_FRAME_DURATION, 0L); |
| |
| // get the exposure and sensitivity range |
| Range<Long> exposureRangeNs = new Range<Long>(mStaticInfo.getExposureMinimumOrDefault(), |
| mStaticInfo.getExposureMaximumOrDefault()); |
| |
| Range<Integer> isoRange = new Range<Integer>(mStaticInfo.getSensitivityMinimumOrDefault(), |
| mStaticInfo.getSensitivityMaximumOrDefault()); |
| |
| Log.i(TAG, String.format("Exposure time - max: %d, min: %d.", exposureRangeNs.getUpper(), |
| exposureRangeNs.getLower())); |
| Log.i(TAG, String.format("Sensitivity - max: %d, min: %d.", isoRange.getUpper(), |
| isoRange.getLower())); |
| |
| // building burst request |
| int maxFramesBurst = exposureMultipliers.length * sensitivityMultipliers.length; |
| Log.i(TAG, String.format("Setting up burst = %d frames.", maxFramesBurst)); |
| ArrayList<CaptureRequest> rawRequestList = new ArrayList<CaptureRequest>(maxFramesBurst); |
| |
| for (int i = 0; i < exposureMultipliers.length; i++) { |
| for (int j = 0; j < sensitivityMultipliers.length; j++) { |
| long desiredExposure = Math.min( |
| exposureRangeNs.getLower() * exposureMultipliers[i], |
| exposureRangeNs.getUpper()); |
| |
| int desiredSensitivity = |
| Math.min(isoRange.getLower() * sensitivityMultipliers[j], |
| isoRange.getUpper()); |
| |
| rawBurstBuilder.set(CaptureRequest.SENSOR_EXPOSURE_TIME, desiredExposure); |
| rawBurstBuilder.set(CaptureRequest.SENSOR_SENSITIVITY, desiredSensitivity); |
| |
| rawRequestList.add(rawBurstBuilder.build()); |
| } |
| } |
| return rawRequestList; |
| } |
| |
| /** |
| * Construct an array of burst request with 3A |
| * <p> |
| * For each capture request, 3A and post processing (noise reduction, sharpening, etc) will be |
| * turned on. |
| * </p> |
| * |
| * @param rawBurstBuilder The builder needs to have targets setup. |
| * @return An array list capture request for burst. |
| */ |
| private ArrayList<CaptureRequest> createBurstRequestWith3A( |
| CaptureRequest.Builder rawBurstBuilder) |
| { |
| // set 3A mode to simulate regular still capture |
| rawBurstBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON); |
| rawBurstBuilder.set(CaptureRequest.CONTROL_AWB_MODE, CaptureRequest.CONTROL_AWB_MODE_AUTO); |
| rawBurstBuilder.set(CaptureRequest.NOISE_REDUCTION_MODE, |
| CaptureRequest.NOISE_REDUCTION_MODE_HIGH_QUALITY); |
| rawBurstBuilder.set(CaptureRequest.EDGE_MODE, CaptureRequest.EDGE_MODE_HIGH_QUALITY); |
| |
| // building burst request |
| Log.i(TAG, String.format("Setting up burst = %d frames.", MAX_FRAMES_BURST)); |
| ArrayList<CaptureRequest> rawRequestList = new ArrayList<CaptureRequest>(MAX_FRAMES_BURST); |
| |
| for (int i = 0; i < MAX_FRAMES_BURST; i++) { |
| rawRequestList.add(rawBurstBuilder.build()); |
| } |
| |
| return rawRequestList; |
| } |
| |
| /** |
| * An utility method to copy capture request builders. This is used for recovery purpose to |
| * reverse the changes we made to the builder. |
| * |
| * @param dst the builder to write into. |
| * @param src the builder that needs to be copied. |
| */ |
| private void copyBurstRequetBuilder(CaptureRequest.Builder dst, CaptureRequest.Builder src) |
| { |
| dst.set(CaptureRequest.CONTROL_AE_MODE, src.get(CaptureRequest.CONTROL_AE_MODE)); |
| dst.set(CaptureRequest.CONTROL_AWB_MODE, src.get(CaptureRequest.CONTROL_AWB_MODE)); |
| dst.set(CaptureRequest.NOISE_REDUCTION_MODE, src.get(CaptureRequest.NOISE_REDUCTION_MODE)); |
| dst.set(CaptureRequest.EDGE_MODE, src.get(CaptureRequest.EDGE_MODE)); |
| dst.set(CaptureRequest.SENSOR_FRAME_DURATION, |
| src.get(CaptureRequest.SENSOR_FRAME_DURATION)); |
| dst.set(CaptureRequest.SENSOR_EXPOSURE_TIME, src.get(CaptureRequest.SENSOR_EXPOSURE_TIME)); |
| dst.set(CaptureRequest.SENSOR_SENSITIVITY, src.get(CaptureRequest.SENSOR_SENSITIVITY)); |
| } |
| |
| /** |
| * Draining the image reader and capture callback queue |
| * |
| * @param readerListener Image reader listener needs to be drained. |
| * @param captureCallback Capture callback needs to be drained. |
| * @throws Exception Exception from the queue. |
| */ |
| private void drainQueues(SimpleImageReaderListener readerListener, |
| SimpleCaptureCallback captureCallback) throws Exception |
| { |
| for (int i = 0; i < MAX_FRAMES_BURST; i++) { |
| Image image = readerListener.getImage(CAPTURE_IMAGE_TIMEOUT_MS); |
| image.close(); |
| |
| CaptureResult result = captureCallback.getCaptureResult( |
| CAPTURE_IMAGE_TIMEOUT_MS); |
| long timestamp = result.get(CaptureResult.SENSOR_TIMESTAMP); |
| Log.d(TAG, String.format("timestamp = %d", timestamp)); |
| } |
| } |
| |
| /** |
| * Stop preview and remove the target surfaces inside the CaptureRequest.Builder. |
| * |
| * @param previewBuilder Configured builder for preview. |
| * @param rawBurstBuilder Configured builder for RAW. |
| * @throws Exception Exceptions from stopPreview. |
| */ |
| private void stopPreviewAndClearSurface(CaptureRequest.Builder previewBuilder, |
| CaptureRequest.Builder rawBurstBuilder) throws Exception |
| { |
| previewBuilder.removeTarget(mPreviewSurface); |
| rawBurstBuilder.removeTarget(mPreviewSurface); |
| rawBurstBuilder.removeTarget(mReaderSurface); |
| |
| stopPreview(); |
| } |
| |
| private void performTestRoutine(TestRoutine routine, int[] testedFormats) throws Exception |
| { |
| final int PREPARE_TIMEOUT_MS = 10000; |
| for (String id : mCameraIds) { |
| try { |
| openDevice(id); |
| |
| ArrayList<Integer> supportedRawList = new ArrayList<Integer>(RAW_FORMATS.length); |
| if (!checkCapability(supportedRawList, testedFormats)) { |
| Log.i(TAG, "Capability is not supported on camera " + id |
| + ". Skip the test."); |
| continue; |
| } |
| |
| // test each supported RAW format |
| for (int rawFormat : supportedRawList) { |
| Log.i(TAG, "Testing format " + imageFormatToString(rawFormat) + "."); |
| |
| // prepare preview and still RAW capture |
| CaptureSetup captureSetup = initCaptureSetupForPreviewAndRaw(); |
| |
| Size previewCaptureSize = captureSetup.getPreviewCaptureSize(); |
| Size rawCaptureSize = captureSetup.getRawCaptureSize(); |
| |
| CaptureRequest.Builder previewBuilder = captureSetup.getPreviewRequestBuilder(); |
| CaptureRequest.Builder rawBurstBuilder = captureSetup.getRawRequestBuilder(); |
| |
| SimpleCaptureCallback previewCaptureCallback = |
| captureSetup.getPreviewCaptureCallback(); |
| SimpleCaptureCallback rawCaptureCallback = captureSetup.getRawCaptureCallback(); |
| SimpleImageReaderListener rawReaderListener = captureSetup |
| .getRawReaderListener(); |
| |
| // start preview and prepare RAW capture |
| prepareCaptureAndStartPreview(previewBuilder, rawBurstBuilder, |
| previewCaptureSize, rawCaptureSize, rawFormat, previewCaptureCallback, |
| MAX_FRAMES_BURST, rawReaderListener); |
| |
| // Prepare still surface to prevent large allocations slow down capture |
| mSession.prepare(mReaderSurface); |
| mSessionListener.waitForSurfacePrepared( |
| mSession, mReaderSurface, PREPARE_TIMEOUT_MS); |
| |
| // execute test routine |
| routine.execute(rawBurstBuilder, rawCaptureCallback, rawReaderListener, |
| rawFormat); |
| |
| // clear out the surface and camera session |
| stopPreviewAndClearSurface(previewBuilder, rawBurstBuilder); |
| closeImageReader(); |
| } |
| } finally { |
| closeDevice(); |
| } |
| } |
| } |
| } |
