/*
* Copyright (C) 2016 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 com.android.mediaframeworktest.stress;
import com.android.ex.camera2.blocking.BlockingSessionCallback;
import com.android.ex.camera2.exceptions.TimeoutRuntimeException;
import com.android.mediaframeworktest.Camera2SurfaceViewTestCase;
import com.android.mediaframeworktest.helpers.Camera2Focuser;
import com.android.mediaframeworktest.helpers.CameraTestUtils;
import com.android.mediaframeworktest.helpers.CameraTestUtils.SimpleCaptureCallback;
import android.graphics.ImageFormat;
import android.graphics.Point;
import android.hardware.camera2.CameraCharacteristics;
import android.hardware.camera2.CameraCaptureSession.CaptureCallback;
import android.hardware.camera2.CameraConstrainedHighSpeedCaptureSession;
import android.hardware.camera2.CameraDevice;
import android.hardware.camera2.CameraAccessException;
import android.hardware.camera2.CameraCaptureSession;
import android.hardware.camera2.CaptureRequest;
import android.hardware.camera2.CaptureResult;
import android.hardware.camera2.DngCreator;
import android.hardware.camera2.params.MeteringRectangle;
import android.media.Image;
import android.media.ImageReader;
import android.media.CamcorderProfile;
import android.media.MediaExtractor;
import android.media.MediaFormat;
import android.media.MediaRecorder;
import android.os.ConditionVariable;
import android.os.Environment;
import android.util.Log;
import android.util.Pair;
import android.util.Rational;
import android.util.Size;
import android.view.Surface;
import android.hardware.camera2.params.StreamConfigurationMap;
import android.test.suitebuilder.annotation.LargeTest;
import android.util.Log;
import android.util.Range;
import java.io.ByteArrayOutputStream;
import java.util.ArrayList;
import java.util.List;
import java.io.File;
import java.util.Arrays;
import java.util.HashMap;
import static com.android.mediaframeworktest.helpers.CameraTestUtils.CAPTURE_IMAGE_TIMEOUT_MS;
import static com.android.mediaframeworktest.helpers.CameraTestUtils.MAX_READER_IMAGES;
import static com.android.mediaframeworktest.helpers.CameraTestUtils.SimpleImageReaderListener;
import static com.android.mediaframeworktest.helpers.CameraTestUtils.basicValidateJpegImage;
import static com.android.mediaframeworktest.helpers.CameraTestUtils.configureCameraSession;
import static com.android.mediaframeworktest.helpers.CameraTestUtils.dumpFile;
import static com.android.mediaframeworktest.helpers.CameraTestUtils.getDataFromImage;
import static com.android.mediaframeworktest.helpers.CameraTestUtils.getValueNotNull;
import static com.android.mediaframeworktest.helpers.CameraTestUtils.makeImageReader;
import static com.android.ex.camera2.blocking.BlockingSessionCallback.SESSION_CLOSED;
import static com.android.mediaframeworktest.helpers.CameraTestUtils.CAPTURE_IMAGE_TIMEOUT_MS;
import static com.android.mediaframeworktest.helpers.CameraTestUtils.SESSION_CLOSE_TIMEOUT_MS;
import static com.android.mediaframeworktest.helpers.CameraTestUtils.SIZE_BOUND_1080P;
import static com.android.mediaframeworktest.helpers.CameraTestUtils.SIZE_BOUND_2160P;
import static com.android.mediaframeworktest.helpers.CameraTestUtils.getSupportedVideoSizes;
import com.android.ex.camera2.blocking.BlockingSessionCallback;
import com.android.mediaframeworktest.Camera2SurfaceViewTestCase;
import com.android.mediaframeworktest.helpers.CameraTestUtils;
import junit.framework.AssertionFailedError;
/**
* <p>Tests Back/Front camera switching and Camera/Video modes witching.</p>
*
* adb shell am instrument \
* -e class com.android.mediaframeworktest.stress.Camera2SwitchPreviewTest \
* -e iterations 200 \
* -e waitIntervalMs 1000 \
* -e resultToFile false \
* -r -w com.android.mediaframeworktest/.Camera2InstrumentationTestRunner
*/
public class Camera2SwitchPreviewTest extends Camera2SurfaceViewTestCase {
private static final String TAG = "SwitchPreviewTest";
private static final boolean VERBOSE = Log.isLoggable(TAG, Log.VERBOSE);
private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);
// 60 second to accommodate the possible long exposure time.
private static final int MAX_REGIONS_AE_INDEX = 0;
private static final int MAX_REGIONS_AWB_INDEX = 1;
private static final int MAX_REGIONS_AF_INDEX = 2;
private static final int WAIT_FOR_FOCUS_DONE_TIMEOUT_MS = 6000;
private static final double AE_COMPENSATION_ERROR_TOLERANCE = 0.2;
// 5 percent error margin for resulting metering regions
private static final float METERING_REGION_ERROR_PERCENT_DELTA = 0.05f;
private final String VIDEO_FILE_PATH = Environment.getExternalStorageDirectory().getPath();
private static final boolean DEBUG_DUMP = Log.isLoggable(TAG, Log.DEBUG);
private static final int RECORDING_DURATION_MS = 3000;
private static final float DURATION_MARGIN = 0.2f;
private static final double FRAME_DURATION_ERROR_TOLERANCE_MS = 3.0;
private static final int BIT_RATE_1080P = 16000000;
private static final int BIT_RATE_MIN = 64000;
private static final int BIT_RATE_MAX = 40000000;
private static final int VIDEO_FRAME_RATE = 30;
private static final int[] mCamcorderProfileList = {
CamcorderProfile.QUALITY_HIGH,
CamcorderProfile.QUALITY_2160P,
CamcorderProfile.QUALITY_1080P,
CamcorderProfile.QUALITY_720P,
CamcorderProfile.QUALITY_480P,
CamcorderProfile.QUALITY_CIF,
CamcorderProfile.QUALITY_QCIF,
CamcorderProfile.QUALITY_QVGA,
CamcorderProfile.QUALITY_LOW,
};
private static final int MAX_VIDEO_SNAPSHOT_IMAGES = 5;
private static final int BURST_VIDEO_SNAPSHOT_NUM = 3;
private static final int SLOWMO_SLOW_FACTOR = 4;
private static final int MAX_NUM_FRAME_DROP_INTERVAL_ALLOWED = 4;
private List<Size> mSupportedVideoSizes;
private Surface mRecordingSurface;
private Surface mPersistentSurface;
private MediaRecorder mMediaRecorder;
private String mOutMediaFileName;
private int mVideoFrameRate;
private Size mVideoSize;
private long mRecordingStartTime;
@Override
protected void setUp() throws Exception {
super.setUp();
}
@Override
protected void tearDown() throws Exception {
super.tearDown();
}
/**
* Test normal still preview switch.
* <p>
* Preview jpeg output streams are configured. Max still capture
* size is used for jpeg capture.
* </p>
*/
public void testPreviewSwitchBackFrontCamera() throws Exception {
List<String> mCameraColorOutputIds = cameraColorOutputCheck();
// Test iteration starts...
Log.i(TAG, "Testing preview switch back/front camera in still capture mode");
for (int iteration = 0; iteration < getIterationCount(); ++iteration) {
for (String id : mCameraColorOutputIds) {
try {
openDevice(id);
// Preview for basic still capture:
Log.v(TAG, String.format("Preview pictures: %d/%d", iteration + 1,
getIterationCount()));
stillCapturePreviewPreparer(id);
getResultPrinter().printStatus(getIterationCount(), iteration + 1, id);
} finally {
closeDevice();
closeImageReader();
}
}
}
}
/**
* <p>
* Test basic video preview switch.
* </p>
* <p>
* This test covers the typical basic use case of video preview switch.
* MediaRecorder is used to record the audio and video, CamcorderProfile is
* used to configure the MediaRecorder. Preview is set to the video size.
* </p>
*/
public void testPreviewSwitchBackFrontVideo() throws Exception {
List<String> mCameraColorOutputIds = cameraColorOutputCheck();
// Test iteration starts...
Log.i(TAG, "Testing preview switch back/front camera in video mode");
for (int iteration = 0; iteration < getIterationCount(); ++iteration) {
for (String id : mCameraColorOutputIds) {
try {
openDevice(id);
// Preview for basic video recording:
Log.v(TAG, String.format("Preview for recording videos: %d/%d", iteration + 1,
getIterationCount()));
recordingPreviewPreparer(id);
getResultPrinter().printStatus(getIterationCount(), iteration + 1, id);
} finally {
closeDevice();
releaseRecorder();
}
}
}
}
/**
* Test back camera preview switch between still capture and recording mode.
* <p>
* This test covers the basic case of preview switch camera mode, between
* still capture (photo) and recording (video) mode. The preview settings
* are same with the settings in "testPreviewSwitchBackFrontCamera" and
* "testPreviewSwitchBackFrontVideo"
* </p>
*/
public void testPreviewSwitchBackCameraVideo() throws Exception {
String id = mCameraIds[0];
openDevice(id);
if (!mStaticInfo.isColorOutputSupported()) {
Log.i(TAG, "Camera " + id +
" does not support color outputs, skipping");
return;
}
closeDevice();
// Test iteration starts...
Log.i(TAG, "Testing preview switch between still capture/video modes for back camera");
for (int iteration = 0; iteration < getIterationCount(); ++iteration) {
try {
openDevice(id);
// Preview for basic still capture:
Log.v(TAG, String.format("Preview pictures: %d/%d", iteration + 1,
getIterationCount()));
stillCapturePreviewPreparer(id);
getResultPrinter().printStatus(getIterationCount(), iteration + 1, id);
// Preview for basic video recording:
Log.v(TAG, String.format("Preview for recording videos: %d/%d", iteration + 1,
getIterationCount()));
recordingPreviewPreparer(id);
getResultPrinter().printStatus(getIterationCount(), iteration + 1, id);
} finally {
closeDevice();
closeImageReader();
}
}
}
/**
* Test front camera preview switch between still capture and recording mode.
* <p>
* This test covers the basic case of preview switch camera mode, between
* still capture (photo) and recording (video) mode. The preview settings
* are same with the settings in "testPreviewSwitchBackFrontCamera" and
* "testPreviewSwitchBackFrontVideo"
* </p>
*/
public void testPreviewSwitchFrontCameraVideo() throws Exception{
String id = mCameraIds[1];
openDevice(id);
if (!mStaticInfo.isColorOutputSupported()) {
Log.i(TAG, "Camera " + id +
" does not support color outputs, skipping");
return;
}
closeDevice();
// Test iteration starts...
Log.i(TAG, "Testing preview switch between still capture/video modes for front camera");
for (int iteration = 0; iteration < getIterationCount(); ++iteration) {
try {
openDevice(id);
// Preview for basic still capture:
Log.v(TAG, String.format("Preview pictures: %d/%d", iteration + 1,
getIterationCount()));
stillCapturePreviewPreparer(id);
getResultPrinter().printStatus(getIterationCount(), iteration + 1, id);
// Preview for basic video recording:
Log.v(TAG, String.format("Preview for recording videos: %d/%d", iteration + 1,
getIterationCount()));
recordingPreviewPreparer(id);
getResultPrinter().printStatus(getIterationCount(), iteration + 1, id);
} finally {
closeDevice();
closeImageReader();
}
}
}
private void stillCapturePreviewPreparer(String id) throws Exception{
CaptureResult result;
SimpleCaptureCallback resultListener = new SimpleCaptureCallback();
SimpleImageReaderListener imageListener = new SimpleImageReaderListener();
CaptureRequest.Builder previewRequest =
mCamera.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
CaptureRequest.Builder stillRequest =
mCamera.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
// Preview Setup:
prepareCapturePreview(previewRequest, stillRequest, resultListener, imageListener);
Thread.sleep(getTestWaitIntervalMs());
}
private void recordingPreviewPreparer(String id) throws Exception{
// Re-use the MediaRecorder object for the same camera device.
mMediaRecorder = new MediaRecorder();
initSupportedVideoSize(id);
// preview Setup:
basicRecordingPreviewTestByCamera(mCamcorderProfileList);
Thread.sleep(getTestWaitIntervalMs());
}
/**
* Initialize the supported video sizes.
*/
private void initSupportedVideoSize(String cameraId) throws Exception {
Size maxVideoSize = SIZE_BOUND_1080P;
if (CamcorderProfile.hasProfile(CamcorderProfile.QUALITY_2160P)) {
maxVideoSize = SIZE_BOUND_2160P;
}
mSupportedVideoSizes =
getSupportedVideoSizes(cameraId, mCameraManager, maxVideoSize);
}
/**
* Test camera recording preview by using each available CamcorderProfile for a
* given camera. preview size is set to the video size.
*/
private void basicRecordingPreviewTestByCamera(int[] camcorderProfileList)
throws Exception {
Size maxPreviewSize = mOrderedPreviewSizes.get(0);
List<Range<Integer> > fpsRanges = Arrays.asList(
mStaticInfo.getAeAvailableTargetFpsRangesChecked());
int cameraId = Integer.parseInt(mCamera.getId());
int maxVideoFrameRate = -1;
int profileId = camcorderProfileList[0];
if (!CamcorderProfile.hasProfile(cameraId, profileId) ||
allowedUnsupported(cameraId, profileId)) {
return;
}
CamcorderProfile profile = CamcorderProfile.get(cameraId, profileId);
Size videoSz = new Size(profile.videoFrameWidth, profile.videoFrameHeight);
Range<Integer> fpsRange = new Range(profile.videoFrameRate, profile.videoFrameRate);
if (maxVideoFrameRate < profile.videoFrameRate) {
maxVideoFrameRate = profile.videoFrameRate;
}
if (mStaticInfo.isHardwareLevelLegacy() &&
(videoSz.getWidth() > maxPreviewSize.getWidth() ||
videoSz.getHeight() > maxPreviewSize.getHeight())) {
// Skip. Legacy mode can only do recording up to max preview size
return;
}
assertTrue("Video size " + videoSz.toString() + " for profile ID " + profileId +
" must be one of the camera device supported video size!",
mSupportedVideoSizes.contains(videoSz));
assertTrue("Frame rate range " + fpsRange + " (for profile ID " + profileId +
") must be one of the camera device available FPS range!",
fpsRanges.contains(fpsRange));
if (VERBOSE) {
Log.v(TAG, "Testing camera recording with video size " + videoSz.toString());
}
// Configure preview and recording surfaces.
mOutMediaFileName = VIDEO_FILE_PATH + "/test_video.mp4";
if (DEBUG_DUMP) {
mOutMediaFileName = VIDEO_FILE_PATH + "/test_video_" + cameraId + "_"
+ videoSz.toString() + ".mp4";
}
prepareRecordingWithProfile(profile);
// prepare preview surface by using video size.
updatePreviewSurfaceWithVideo(videoSz, profile.videoFrameRate);
CaptureRequest.Builder previewRequest =
mCamera.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
CaptureRequest.Builder recordingRequest =
mCamera.createCaptureRequest(CameraDevice.TEMPLATE_RECORD);
SimpleCaptureCallback resultListener = new SimpleCaptureCallback();
SimpleImageReaderListener imageListener = new SimpleImageReaderListener();
prepareVideoPreview(previewRequest, recordingRequest, resultListener, imageListener);
// Can reuse the MediaRecorder object after reset.
mMediaRecorder.reset();
if (maxVideoFrameRate != -1) {
// At least one CamcorderProfile is present, check FPS
assertTrue("At least one CamcorderProfile must support >= 24 FPS",
maxVideoFrameRate >= 24);
}
}
private void releaseRecorder() {
if (mMediaRecorder != null) {
mMediaRecorder.release();
mMediaRecorder = null;
}
}
private List<String> cameraColorOutputCheck() throws Exception {
List<String> mCameraColorOutputIds = new ArrayList<String>();
for (String id : mCameraIds) {
openDevice(id);
if (!mStaticInfo.isColorOutputSupported()) {
Log.i(TAG, "Camera " + id +
" does not support color outputs, skipping");
continue;
}
mCameraColorOutputIds.add(id);
closeDevice();
}
return mCameraColorOutputIds;
}
/**
* Returns {@code true} if the {@link CamcorderProfile} ID is allowed to be unsupported.
*
* <p>This only allows unsupported profiles when using the LEGACY mode of the Camera API.</p>
*
* @param profileId a {@link CamcorderProfile} ID to check.
* @return {@code true} if supported.
*/
private boolean allowedUnsupported(int cameraId, int profileId) {
if (!mStaticInfo.isHardwareLevelLegacy()) {
return false;
}
switch(profileId) {
case CamcorderProfile.QUALITY_2160P:
case CamcorderProfile.QUALITY_1080P:
case CamcorderProfile.QUALITY_HIGH:
return !CamcorderProfile.hasProfile(cameraId, profileId) ||
CamcorderProfile.get(cameraId, profileId).videoFrameWidth >= 1080;
}
return false;
}
/**
* Configure MediaRecorder recording session with CamcorderProfile, prepare
* the recording surface.
*/
private void prepareRecordingWithProfile(CamcorderProfile profile)
throws Exception {
// Prepare MediaRecorder.
mMediaRecorder.setAudioSource(MediaRecorder.AudioSource.CAMCORDER);
mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.SURFACE);
mMediaRecorder.setProfile(profile);
mMediaRecorder.setOutputFile(mOutMediaFileName);
if (mPersistentSurface != null) {
mMediaRecorder.setInputSurface(mPersistentSurface);
mRecordingSurface = mPersistentSurface;
}
mMediaRecorder.prepare();
if (mPersistentSurface == null) {
mRecordingSurface = mMediaRecorder.getSurface();
}
assertNotNull("Recording surface must be non-null!", mRecordingSurface);
mVideoFrameRate = profile.videoFrameRate;
mVideoSize = new Size(profile.videoFrameWidth, profile.videoFrameHeight);
}
/**
* Update preview size with video size.
*
* <p>Preview size will be capped with max preview size.</p>
*
* @param videoSize The video size used for preview.
* @param videoFrameRate The video frame rate
*
*/
private void updatePreviewSurfaceWithVideo(Size videoSize, int videoFrameRate) throws Exception {
if (mOrderedPreviewSizes == null) {
throw new IllegalStateException("supported preview size list is not initialized yet");
}
final float FRAME_DURATION_TOLERANCE = 0.01f;
long videoFrameDuration = (long) (1e9 / videoFrameRate *
(1.0 + FRAME_DURATION_TOLERANCE));
HashMap<Size, Long> minFrameDurationMap = mStaticInfo.
getAvailableMinFrameDurationsForFormatChecked(ImageFormat.PRIVATE);
Size maxPreviewSize = mOrderedPreviewSizes.get(0);
Size previewSize = null;
if (videoSize.getWidth() > maxPreviewSize.getWidth() ||
videoSize.getHeight() > maxPreviewSize.getHeight()) {
for (Size s : mOrderedPreviewSizes) {
Long frameDuration = minFrameDurationMap.get(s);
if (mStaticInfo.isHardwareLevelLegacy()) {
// Legacy doesn't report min frame duration
frameDuration = new Long(0);
}
assertTrue("Cannot find minimum frame duration for private size" + s,
frameDuration != null);
if (frameDuration <= videoFrameDuration &&
s.getWidth() <= videoSize.getWidth() &&
s.getHeight() <= videoSize.getHeight()) {
Log.w(TAG, "Overwrite preview size from " + videoSize.toString() +
" to " + s.toString());
previewSize = s;
break;
// If all preview size doesn't work then we fallback to video size
}
}
}
if (previewSize == null) {
previewSize = videoSize;
}
updatePreviewSurface(previewSize);
}
protected void prepareVideoPreview(CaptureRequest.Builder previewRequest,
CaptureRequest.Builder recordingRequest,
CaptureCallback resultListener,
ImageReader.OnImageAvailableListener imageListener) throws Exception {
// Configure output streams with preview and jpeg streams.
List<Surface> outputSurfaces = new ArrayList<Surface>();
outputSurfaces.add(mPreviewSurface);
outputSurfaces.add(mRecordingSurface);
mSessionListener = new BlockingSessionCallback();
mSession = configureCameraSession(mCamera, outputSurfaces, mSessionListener, mHandler);
previewRequest.addTarget(mPreviewSurface);
recordingRequest.addTarget(mPreviewSurface);
recordingRequest.addTarget(mRecordingSurface);
// Start preview.
mSession.setRepeatingRequest(previewRequest.build(), null, mHandler);
}
protected void prepareCapturePreview(CaptureRequest.Builder previewRequest,
CaptureRequest.Builder stillRequest,
CaptureCallback resultListener,
ImageReader.OnImageAvailableListener imageListener) throws Exception {
Size captureSz = mOrderedStillSizes.get(0);
Size previewSz = mOrderedPreviewSizes.get(1);
if (VERBOSE) {
Log.v(TAG, String.format("Prepare single capture (%s) and preview (%s)",
captureSz.toString(), previewSz.toString()));
}
// Update preview size.
updatePreviewSurface(previewSz);
// Create ImageReader.
createImageReader(captureSz, ImageFormat.JPEG, MAX_READER_IMAGES, imageListener);
// Configure output streams with preview and jpeg streams.
List<Surface> outputSurfaces = new ArrayList<Surface>();
outputSurfaces.add(mPreviewSurface);
outputSurfaces.add(mReaderSurface);
mSessionListener = new BlockingSessionCallback();
mSession = configureCameraSession(mCamera, outputSurfaces, mSessionListener, mHandler);
// Configure the requests.
previewRequest.addTarget(mPreviewSurface);
stillRequest.addTarget(mPreviewSurface);
stillRequest.addTarget(mReaderSurface);
// Start preview.
mSession.setRepeatingRequest(previewRequest.build(), resultListener, mHandler);
}
}