diff options
8 files changed, 430 insertions, 98 deletions
diff --git a/camera2/portability/src/com/android/ex/camera2/portability/AndroidCamera2AgentImpl.java b/camera2/portability/src/com/android/ex/camera2/portability/AndroidCamera2AgentImpl.java index d139c62..913a575 100644 --- a/camera2/portability/src/com/android/ex/camera2/portability/AndroidCamera2AgentImpl.java +++ b/camera2/portability/src/com/android/ex/camera2/portability/AndroidCamera2AgentImpl.java @@ -198,6 +198,9 @@ class AndroidCamera2AgentImpl extends CameraAgent { // Available whenever setAutoFocusMoveCallback() was last invoked with a non-null argument: private CameraAFMoveCallback mPassiveAfCallback; + // Gets reset on every state change + private int mCurrentAeState = CaptureResult.CONTROL_AE_STATE_INACTIVE; + Camera2Handler(Looper looper) { super(looper); } @@ -212,7 +215,7 @@ class AndroidCamera2AgentImpl extends CameraAgent { CameraOpenCallback openCallback = (CameraOpenCallback) msg.obj; int cameraIndex = msg.arg1; - if (mCameraState.getState() != AndroidCamera2StateHolder.CAMERA_UNOPENED) { + if (mCameraState.getState() > AndroidCamera2StateHolder.CAMERA_UNOPENED) { openCallback.onDeviceOpenedAlready(cameraIndex, generateHistoryString(cameraIndex)); break; @@ -263,7 +266,7 @@ class AndroidCamera2AgentImpl extends CameraAgent { mPhotoSize = null; mCameraIndex = 0; mCameraId = null; - mCameraState.setState(AndroidCamera2StateHolder.CAMERA_UNOPENED); + changeState(AndroidCamera2StateHolder.CAMERA_UNOPENED); break; } @@ -289,19 +292,23 @@ class AndroidCamera2AgentImpl extends CameraAgent { } mOneshotPreviewingCallback = (CameraStartPreviewCallback) msg.obj; - mCameraState.setState(AndroidCamera2StateHolder.CAMERA_PREVIEW_ACTIVE); + changeState(AndroidCamera2StateHolder.CAMERA_PREVIEW_ACTIVE); try { mSession.setRepeatingRequest( mPersistentSettings.createRequest(mCamera, CameraDevice.TEMPLATE_PREVIEW, mPreviewSurface), - /*listener*/mCameraFocusStateListener, /*handler*/this); + /*listener*/mCameraResultStateListener, /*handler*/this); } catch(CameraAccessException ex) { Log.w(TAG, "Unable to start preview", ex); - mCameraState.setState(AndroidCamera2StateHolder.CAMERA_PREVIEW_READY); + changeState(AndroidCamera2StateHolder.CAMERA_PREVIEW_READY); } break; } + // FIXME: We need to tear down the CameraCaptureSession here + // (and unlock the CameraSettings object from our + // CameraProxy) so that the preview/photo sizes can be + // changed again while no preview is running. case CameraActions.STOP_PREVIEW: { if (mCameraState.getState() < AndroidCamera2StateHolder.CAMERA_PREVIEW_ACTIVE) { @@ -310,7 +317,7 @@ class AndroidCamera2AgentImpl extends CameraAgent { } mSession.stopRepeating(); - mCameraState.setState(AndroidCamera2StateHolder.CAMERA_PREVIEW_READY); + changeState(AndroidCamera2StateHolder.CAMERA_PREVIEW_READY); break; } @@ -368,19 +375,39 @@ class AndroidCamera2AgentImpl extends CameraAgent { } // The earliest we can reliably tell whether the autofocus has locked in - // response to our latest request is when our one-time capture completes. + // response to our latest request is when our one-time capture progresses. // However, it will probably take longer than that, so once that happens, // just start checking the repeating preview requests as they complete. final CameraAFCallback callback = (CameraAFCallback) msg.obj; CameraCaptureSession.CaptureListener deferredCallbackSetter = new CameraCaptureSession.CaptureListener() { + private boolean mAlreadyDispatched = false; + + @Override + public void onCaptureProgressed(CameraCaptureSession session, + CaptureRequest request, + CaptureResult result) { + checkAfState(result); + } + @Override public void onCaptureCompleted(CameraCaptureSession session, CaptureRequest request, TotalCaptureResult result) { - // Now our mCameraFocusStateListener will invoke the callback the - // first time it finds the focus motor to be locked. - mOneshotAfCallback = callback; + checkAfState(result); + } + + private void checkAfState(CaptureResult result) { + if (result.get(CaptureResult.CONTROL_AF_STATE) != null && + !mAlreadyDispatched) { + // Now our mCameraResultStateListener will invoke the callback + // the first time it finds the focus motor to be locked. + mAlreadyDispatched = true; + mOneshotAfCallback = callback; + // This is an optimization: check the AF state of this frame + // instead of simply waiting for the next. + mCameraResultStateListener.monitorControlStates(result); + } } @Override @@ -392,7 +419,7 @@ class AndroidCamera2AgentImpl extends CameraAgent { }}; // Send a one-time capture to trigger the camera driver to lock focus. - mCameraState.setState(AndroidCamera2StateHolder.CAMERA_FOCUS_LOCKED); + changeState(AndroidCamera2StateHolder.CAMERA_FOCUS_LOCKED); Camera2RequestSettingsSet trigger = new Camera2RequestSettingsSet(mPersistentSettings); trigger.set(CaptureRequest.CONTROL_AF_TRIGGER, @@ -404,7 +431,7 @@ class AndroidCamera2AgentImpl extends CameraAgent { /*listener*/deferredCallbackSetter, /*handler*/ this); } catch(CameraAccessException ex) { Log.e(TAG, "Unable to lock autofocus", ex); - mCameraState.setState(AndroidCamera2StateHolder.CAMERA_PREVIEW_ACTIVE); + changeState(AndroidCamera2StateHolder.CAMERA_PREVIEW_ACTIVE); } break; } @@ -418,7 +445,7 @@ class AndroidCamera2AgentImpl extends CameraAgent { } // Send a one-time capture to trigger the camera driver to resume scanning. - mCameraState.setState(AndroidCamera2StateHolder.CAMERA_PREVIEW_ACTIVE); + changeState(AndroidCamera2StateHolder.CAMERA_PREVIEW_ACTIVE); Camera2RequestSettingsSet cancel = new Camera2RequestSettingsSet(mPersistentSettings); cancel.set(CaptureRequest.CONTROL_AF_TRIGGER, @@ -430,8 +457,7 @@ class AndroidCamera2AgentImpl extends CameraAgent { /*listener*/null, /*handler*/this); } catch(CameraAccessException ex) { Log.e(TAG, "Unable to cancel autofocus", ex); - mCameraState.setState( - AndroidCamera2StateHolder.CAMERA_FOCUS_LOCKED); + changeState(AndroidCamera2StateHolder.CAMERA_FOCUS_LOCKED); } break; } @@ -486,8 +512,21 @@ class AndroidCamera2AgentImpl extends CameraAgent { final CaptureAvailableListener listener = (CaptureAvailableListener) msg.obj; - if (mLegacyDevice) { - // Just snap the shot + if (mLegacyDevice || + (mCurrentAeState == CaptureResult.CONTROL_AE_STATE_CONVERGED && + !mPersistentSettings.matches(CaptureRequest.CONTROL_AE_MODE, + CaptureRequest.CONTROL_AE_MODE_ON_ALWAYS_FLASH) && + !mPersistentSettings.matches(CaptureRequest.FLASH_MODE, + CaptureRequest.FLASH_MODE_SINGLE))) + { + // Legacy devices don't support the precapture state keys and instead + // perform autoexposure convergence automatically upon capture. + + // On other devices, as long as it has already converged, it determined + // that flash was not required, and we're not going to invalidate the + // current exposure levels by forcing the force on, we can save + // significant capture time by not forcing a recalculation. + Log.i(TAG, "Skipping pre-capture autoexposure convergence"); mCaptureReader.setOnImageAvailableListener(listener, /*handler*/this); try { mSession.capture( @@ -496,17 +535,42 @@ class AndroidCamera2AgentImpl extends CameraAgent { mCaptureReader.getSurface()), listener, /*handler*/this); } catch (CameraAccessException ex) { - Log.e(TAG, "Unable to initiate legacy capture", ex); + Log.e(TAG, "Unable to initiate immediate capture", ex); } } else { - // Not a legacy device, so we need to let AE converge before capturing + // We need to let AE converge before capturing. Once our one-time + // trigger capture has made it into the pipeline, we'll start checking + // for the completion of that convergence, capturing when that happens. + Log.i(TAG, "Forcing pre-capture autoexposure convergence"); CameraCaptureSession.CaptureListener deferredCallbackSetter = new CameraCaptureSession.CaptureListener() { + private boolean mAlreadyDispatched = false; + + @Override + public void onCaptureProgressed(CameraCaptureSession session, + CaptureRequest request, + CaptureResult result) { + checkAeState(result); + } + @Override public void onCaptureCompleted(CameraCaptureSession session, CaptureRequest request, TotalCaptureResult result) { - mOneshotCaptureCallback = listener; + checkAeState(result); + } + + private void checkAeState(CaptureResult result) { + if (result.get(CaptureResult.CONTROL_AE_STATE) != null && + !mAlreadyDispatched) { + // Now our mCameraResultStateListener will invoke the + // callback once the autoexposure routine has converged. + mAlreadyDispatched = true; + mOneshotCaptureCallback = listener; + // This is an optimization: check the AE state of this frame + // instead of simply waiting for the next. + mCameraResultStateListener.monitorControlStates(result); + } } @Override @@ -599,13 +663,13 @@ class AndroidCamera2AgentImpl extends CameraAgent { mSession.setRepeatingRequest( mPersistentSettings.createRequest(mCamera, CameraDevice.TEMPLATE_PREVIEW, mPreviewSurface), - /*listener*/mCameraFocusStateListener, /*handler*/this); + /*listener*/mCameraResultStateListener, /*handler*/this); } catch (CameraAccessException ex) { Log.e(TAG, "Failed to apply updated request settings", ex); } } else if (mCameraState.getState() < AndroidCamera2StateHolder.CAMERA_PREVIEW_READY) { // If we're already ready to preview, this doesn't regress our state - mCameraState.setState(AndroidCamera2StateHolder.CAMERA_CONFIGURED); + changeState(AndroidCamera2StateHolder.CAMERA_CONFIGURED); } } @@ -659,7 +723,17 @@ class AndroidCamera2AgentImpl extends CameraAgent { } catch (CameraAccessException ex) { Log.e(TAG, "Failed to close existing camera capture session", ex); } - mCameraState.setState(AndroidCamera2StateHolder.CAMERA_CONFIGURED); + changeState(AndroidCamera2StateHolder.CAMERA_CONFIGURED); + } + + private void changeState(int newState) { + if (mCameraState.getState() != newState) { + mCameraState.setState(newState); + if (newState < AndroidCamera2StateHolder.CAMERA_PREVIEW_ACTIVE) { + mCurrentAeState = CaptureResult.CONTROL_AE_STATE_INACTIVE; + mCameraResultStateListener.resetState(); + } + } } // This listener monitors our connection to and disconnection from camera devices. @@ -680,7 +754,7 @@ class AndroidCamera2AgentImpl extends CameraAgent { mLegacyDevice = props.get(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL) == CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY; - mCameraState.setState(AndroidCamera2StateHolder.CAMERA_UNCONFIGURED); + changeState(AndroidCamera2StateHolder.CAMERA_UNCONFIGURED); mOpenCallback.onCameraOpened(mCameraProxy); } catch (CameraAccessException ex) { mOpenCallback.onDeviceOpenFailure(mCameraIndex, @@ -710,7 +784,7 @@ class AndroidCamera2AgentImpl extends CameraAgent { @Override public void onConfigured(CameraCaptureSession session) { mSession = session; - mCameraState.setState(AndroidCamera2StateHolder.CAMERA_PREVIEW_READY); + changeState(AndroidCamera2StateHolder.CAMERA_PREVIEW_READY); } @Override @@ -728,49 +802,76 @@ class AndroidCamera2AgentImpl extends CameraAgent { } }}; + private abstract class CameraResultStateListener + extends CameraCaptureSession.CaptureListener { + public abstract void monitorControlStates(CaptureResult result); + + public abstract void resetState(); + } + // This listener monitors requested captures and notifies any relevant callbacks. - private CameraCaptureSession.CaptureListener mCameraFocusStateListener = - new CameraCaptureSession.CaptureListener() { + private CameraResultStateListener mCameraResultStateListener = + new CameraResultStateListener() { private int mLastAfState = -1; + private long mLastAfFrameNumber = -1; + private long mLastAeFrameNumber = -1; + + @Override + public void onCaptureProgressed(CameraCaptureSession session, CaptureRequest request, + CaptureResult result) { + monitorControlStates(result); + } @Override public void onCaptureCompleted(CameraCaptureSession session, CaptureRequest request, TotalCaptureResult result) { + monitorControlStates(result); + } + + @Override + public void monitorControlStates(CaptureResult result) { Integer afStateMaybe = result.get(CaptureResult.CONTROL_AF_STATE); if (afStateMaybe != null) { int afState = afStateMaybe; - boolean afStateChanged = false; - if (afState != mLastAfState) { + // Since we handle both partial and total results for multiple frames here, we + // might get the final callbacks for an earlier frame after receiving one or + // more that correspond to the next one. To prevent our data from oscillating, + // we never consider AF states that are older than the last one we've seen. + if (result.getFrameNumber() > mLastAfFrameNumber) { + boolean afStateChanged = afState != mLastAfState; mLastAfState = afState; - afStateChanged = true; - } - - switch (afState) { - case CaptureResult.CONTROL_AF_STATE_PASSIVE_SCAN: - case CaptureResult.CONTROL_AF_STATE_PASSIVE_FOCUSED: - case CaptureResult.CONTROL_AF_STATE_PASSIVE_UNFOCUSED: { - if (afStateChanged && mPassiveAfCallback != null) { - // A CameraAFMoveCallback is attached. If we just started to scan, - // the motor is moving; otherwise, it has settled. - mPassiveAfCallback.onAutoFocusMoving( - afState == CaptureResult.CONTROL_AF_STATE_PASSIVE_SCAN, - mCameraProxy); + mLastAfFrameNumber = result.getFrameNumber(); + + switch (afState) { + case CaptureResult.CONTROL_AF_STATE_PASSIVE_SCAN: + case CaptureResult.CONTROL_AF_STATE_PASSIVE_FOCUSED: + case CaptureResult.CONTROL_AF_STATE_PASSIVE_UNFOCUSED: { + if (afStateChanged && mPassiveAfCallback != null) { + // A CameraAFMoveCallback is attached. If we just started to + // scan, the motor is moving; otherwise, it has settled. + mPassiveAfCallback.onAutoFocusMoving( + afState == CaptureResult.CONTROL_AF_STATE_PASSIVE_SCAN, + mCameraProxy); + } + break; } - break; - } - case CaptureResult.CONTROL_AF_STATE_FOCUSED_LOCKED: - case CaptureResult.CONTROL_AF_STATE_NOT_FOCUSED_LOCKED: { - if (mOneshotAfCallback != null) { - // A call to autoFocus() was just made to request a focus lock. - // Notify the caller that the lens is now indefinitely fixed, and - // report whether the image we're now stuck with is in focus. - mOneshotAfCallback.onAutoFocus( - afState == CaptureResult.CONTROL_AF_STATE_FOCUSED_LOCKED, - mCameraProxy); - mOneshotAfCallback = null; + case CaptureResult.CONTROL_AF_STATE_FOCUSED_LOCKED: + case CaptureResult.CONTROL_AF_STATE_NOT_FOCUSED_LOCKED: { + // This check must be made regardless of whether the focus state has + // changed recently to avoid infinite waiting during autoFocus() + // when the algorithm has already either converged or failed to. + if (mOneshotAfCallback != null) { + // A call to autoFocus() was just made to request a focus lock. + // Notify the caller that the lens is now indefinitely fixed, + // and report whether the image we're stuck with is in focus. + mOneshotAfCallback.onAutoFocus( + afState == CaptureResult.CONTROL_AF_STATE_FOCUSED_LOCKED, + mCameraProxy); + mOneshotAfCallback = null; + } + break; } - break; } } } @@ -778,36 +879,55 @@ class AndroidCamera2AgentImpl extends CameraAgent { Integer aeStateMaybe = result.get(CaptureResult.CONTROL_AE_STATE); if (aeStateMaybe != null) { int aeState = aeStateMaybe; - - switch (aeState) { - case CaptureResult.CONTROL_AE_STATE_CONVERGED: - case CaptureResult.CONTROL_AE_STATE_FLASH_REQUIRED: - case CaptureResult.CONTROL_AE_STATE_LOCKED: { - if (mOneshotCaptureCallback != null) { - // A call to takePicture() was just made, and autoexposure converged - // so it's time to initiate the capture! - mCaptureReader.setOnImageAvailableListener(mOneshotCaptureCallback, - /*handler*/Camera2Handler.this); - try { - mSession.capture( - mPersistentSettings.createRequest(mCamera, - CameraDevice.TEMPLATE_STILL_CAPTURE, - mCaptureReader.getSurface()), + // Since we handle both partial and total results for multiple frames here, we + // might get the final callbacks for an earlier frame after receiving one or + // more that correspond to the next one. To prevent our data from oscillating, + // we never consider AE states that are older than the last one we've seen. + if (result.getFrameNumber() > mLastAeFrameNumber) { + mCurrentAeState = aeStateMaybe; + mLastAeFrameNumber = result.getFrameNumber(); + + switch (aeState) { + case CaptureResult.CONTROL_AE_STATE_CONVERGED: + case CaptureResult.CONTROL_AE_STATE_FLASH_REQUIRED: + case CaptureResult.CONTROL_AE_STATE_LOCKED: { + // This check must be made regardless of whether the exposure state + // has changed recently to avoid infinite waiting during + // takePicture() when the algorithm has already converged. + if (mOneshotCaptureCallback != null) { + // A call to takePicture() was just made, and autoexposure + // converged so it's time to initiate the capture! + mCaptureReader.setOnImageAvailableListener( /*listener*/mOneshotCaptureCallback, /*handler*/Camera2Handler.this); - } catch (CameraAccessException ex) { - Log.e(TAG, "Unable to initiate capture", ex); - } finally { - mOneshotCaptureCallback = null; + try { + mSession.capture( + mPersistentSettings.createRequest(mCamera, + CameraDevice.TEMPLATE_STILL_CAPTURE, + mCaptureReader.getSurface()), + /*listener*/mOneshotCaptureCallback, + /*handler*/Camera2Handler.this); + } catch (CameraAccessException ex) { + Log.e(TAG, "Unable to initiate capture", ex); + } finally { + mOneshotCaptureCallback = null; + } } + break; } - break; } } } } @Override + public void resetState() { + mLastAfState = -1; + mLastAfFrameNumber = -1; + mLastAeFrameNumber = -1; + } + + @Override public void onCaptureFailed(CameraCaptureSession session, CaptureRequest request, CaptureFailure failure) { Log.e(TAG, "Capture attempt failed with reason " + failure.getReason()); @@ -819,6 +939,8 @@ class AndroidCamera2AgentImpl extends CameraAgent { private final CameraDevice mCamera; private final CameraDeviceInfo.Characteristics mCharacteristics; private final AndroidCamera2Capabilities mCapabilities; + private CameraSettings mLastSettings; + private boolean mShutterSoundEnabled; public AndroidCamera2ProxyImpl(int cameraIndex, CameraDevice camera, CameraDeviceInfo.Characteristics characteristics, @@ -827,6 +949,8 @@ class AndroidCamera2AgentImpl extends CameraAgent { mCamera = camera; mCharacteristics = characteristics; mCapabilities = new AndroidCamera2Capabilities(properties); + mLastSettings = null; + mShutterSoundEnabled = true; } // TODO: Implement @@ -852,6 +976,26 @@ class AndroidCamera2AgentImpl extends CameraAgent { return mCapabilities; } + // FIXME: Unlock the sizes in stopPreview(), as per the corresponding + // explanation on the STOP_PREVIEW case in the handler. + @Override + public void setPreviewTexture(SurfaceTexture surfaceTexture) { + // Once the Surface has been selected, we configure the session and + // are no longer able to change the sizes. + getSettings().setSizesLocked(true); + super.setPreviewTexture(surfaceTexture); + } + + // FIXME: Unlock the sizes in stopPreview(), as per the corresponding + // explanation on the STOP_PREVIEW case in the handler. + @Override + public void setPreviewTextureSync(SurfaceTexture surfaceTexture) { + // Once the Surface has been selected, we configure the session and + // are no longer able to change the sizes. + getSettings().setSizesLocked(true); + super.setPreviewTexture(surfaceTexture); + } + // TODO: Implement @Override public void setPreviewDataCallback(Handler handler, CameraPreviewDataCallback cb) {} @@ -935,7 +1079,9 @@ class AndroidCamera2AgentImpl extends CameraAgent { handler.post(new Runnable() { @Override public void run() { - mNoisemaker.play(MediaActionSound.SHUTTER_CLICK); + if (mShutterSoundEnabled) { + mNoisemaker.play(MediaActionSound.SHUTTER_CLICK); + } shutter.onShutter(AndroidCamera2ProxyImpl.this); }}); } @@ -959,8 +1105,9 @@ class AndroidCamera2AgentImpl extends CameraAgent { mDispatchThread.runJob(new Runnable() { @Override public void run() { - mCameraState.waitForStates(AndroidCamera2StateHolder.CAMERA_PREVIEW_ACTIVE | - AndroidCamera2StateHolder.CAMERA_FOCUS_LOCKED); + // Wait until PREVIEW_ACTIVE or better + mCameraState.waitForStates( + ~(AndroidCamera2StateHolder.CAMERA_PREVIEW_ACTIVE - 1)); mCameraHandler.obtainMessage(CameraActions.CAPTURE_PHOTO, picListener) .sendToTarget(); }}); @@ -997,7 +1144,10 @@ class AndroidCamera2AgentImpl extends CameraAgent { @Override public CameraSettings getSettings() { - return mCameraHandler.buildSettings(mCapabilities); + if (mLastSettings == null) { + mLastSettings = mCameraHandler.buildSettings(mCapabilities); + } + return mLastSettings; } @Override @@ -1011,9 +1161,17 @@ class AndroidCamera2AgentImpl extends CameraAgent { return false; } - return applySettingsHelper(settings, AndroidCamera2StateHolder.CAMERA_UNCONFIGURED | - AndroidCamera2StateHolder.CAMERA_CONFIGURED | - AndroidCamera2StateHolder.CAMERA_PREVIEW_READY); + // Wait for any state that isn't OPENED + if (applySettingsHelper(settings, ~AndroidCamera2StateHolder.CAMERA_UNOPENED)) { + mLastSettings = settings; + return true; + } + return false; + } + + @Override + public void enableShutterSound(boolean enable) { + mShutterSoundEnabled = enable; } // TODO: Implement @@ -1040,19 +1198,22 @@ class AndroidCamera2AgentImpl extends CameraAgent { private static class AndroidCamera2StateHolder extends CameraStateHolder { // Usage flow: openCamera() -> applySettings() -> setPreviewTexture() -> startPreview() -> // autoFocus() -> takePicture() + // States are mutually exclusive, but must be separate bits so that they can be used with + // the StateHolder#waitForStates() and StateHolder#waitToAvoidStates() methods. + // Do not set the state to be a combination of these values! /* Camera states */ /** No camera device is opened. */ - public static final int CAMERA_UNOPENED = 1; + public static final int CAMERA_UNOPENED = 1 << 0; /** A camera is opened, but no settings have been provided. */ - public static final int CAMERA_UNCONFIGURED = 2; + public static final int CAMERA_UNCONFIGURED = 1 << 1; /** The open camera has been configured by providing it with settings. */ - public static final int CAMERA_CONFIGURED = 3; + public static final int CAMERA_CONFIGURED = 1 << 2; /** A capture session is ready to stream a preview, but still has no repeating request. */ - public static final int CAMERA_PREVIEW_READY = 4; + public static final int CAMERA_PREVIEW_READY = 1 << 3; /** A preview is currently being streamed. */ - public static final int CAMERA_PREVIEW_ACTIVE = 5; + public static final int CAMERA_PREVIEW_ACTIVE = 1 << 4; /** The lens is locked on a particular region. */ - public static final int CAMERA_FOCUS_LOCKED = 6; + public static final int CAMERA_FOCUS_LOCKED = 1 << 5; public AndroidCamera2StateHolder() { this(CAMERA_UNOPENED); @@ -1173,9 +1334,7 @@ class AndroidCamera2AgentImpl extends CameraAgent { @Override public boolean canDisableShutterSound() { - // The new API doesn't support this operation, so don't encourage people to try it. - // TODO: What kind of assumptions have callers made about this result's meaning? - return false; + return true; } private static float[] convertRectToPoly(RectF rf) { diff --git a/camera2/portability/src/com/android/ex/camera2/portability/AndroidCamera2Settings.java b/camera2/portability/src/com/android/ex/camera2/portability/AndroidCamera2Settings.java index a132d08..d668f85 100644 --- a/camera2/portability/src/com/android/ex/camera2/portability/AndroidCamera2Settings.java +++ b/camera2/portability/src/com/android/ex/camera2/portability/AndroidCamera2Settings.java @@ -18,7 +18,9 @@ package com.android.ex.camera2.portability; import static android.hardware.camera2.CaptureRequest.*; +import android.graphics.Matrix; import android.graphics.Rect; +import android.graphics.RectF; import android.hardware.camera2.CameraAccessException; import android.hardware.camera2.CameraDevice; import android.hardware.camera2.params.MeteringRectangle; @@ -43,8 +45,12 @@ public class AndroidCamera2Settings extends CameraSettings { private final Builder mTemplateSettings; private final Camera2RequestSettingsSet mRequestSettings; + /** Sensor's active array bounds. */ private final Rect mActiveArray; + /** Crop rectangle for digital zoom (measured WRT the active array). */ private final Rect mCropRectangle; + /** Bounds of visible preview portion (measured WRT the active array). */ + private Rect mVisiblePreviewRectangle; /** * Create a settings representation that answers queries of unspecified @@ -84,6 +90,8 @@ public class AndroidCamera2Settings extends CameraSettings { mActiveArray = activeArray; mCropRectangle = new Rect(0, 0, activeArray.width(), activeArray.height()); + mSizesLocked = false; + Range<Integer> previewFpsRange = mTemplateSettings.get(CONTROL_AE_TARGET_FPS_RANGE); if (previewFpsRange != null) { setPreviewFpsRange(previewFpsRange.getLower(), previewFpsRange.getUpper()); @@ -177,6 +185,8 @@ public class AndroidCamera2Settings extends CameraSettings { @Override public void setZoomRatio(float ratio) { super.setZoomRatio(ratio); + + // Compute the crop rectangle to be passed to the framework mCropRectangle.set(0, 0, toIntConstrained( mActiveArray.width() / mCurrentZoomRatio, 0, mActiveArray.width()), @@ -184,6 +194,10 @@ public class AndroidCamera2Settings extends CameraSettings { mActiveArray.height() / mCurrentZoomRatio, 0, mActiveArray.height())); mCropRectangle.offsetTo((mActiveArray.width() - mCropRectangle.width()) / 2, (mActiveArray.height() - mCropRectangle.height()) / 2); + + // Compute the effective crop rectangle to be used for computing focus/metering coordinates + mVisiblePreviewRectangle = + effectiveCropRectFromRequested(mCropRectangle, mCurrentPreviewSize); } private boolean matchesTemplateDefault(Key<?> setting) { @@ -515,4 +529,49 @@ public class AndroidCamera2Settings extends CameraSettings { mRequestSettings.set(JPEG_GPS_LOCATION, location); } } + + /** + * Calculate the effective crop rectangle for this preview viewport; + * assumes the preview is centered to the sensor and scaled to fit across one of the dimensions + * without skewing. + * + * <p>Assumes the zoom level of the provided desired crop rectangle.</p> + * + * @param requestedCrop Desired crop rectangle, in active array space. + * @param previewSize Size of the preview buffer render target, in pixels (not in sensor space). + * @return A rectangle that serves as the preview stream's effective crop region (unzoomed), in + * sensor space. + * + * @throws NullPointerException + * If any of the args were {@code null}. + */ + private static Rect effectiveCropRectFromRequested(Rect requestedCrop, Size previewSize) { + float aspectRatioArray = requestedCrop.width() * 1.0f / requestedCrop.height(); + float aspectRatioPreview = previewSize.width() * 1.0f / previewSize.height(); + + float cropHeight, cropWidth; + if (aspectRatioPreview < aspectRatioArray) { + // The new width must be smaller than the height, so scale the width by AR + cropHeight = requestedCrop.height(); + cropWidth = cropHeight * aspectRatioPreview; + } else { + // The new height must be smaller (or equal) than the width, so scale the height by AR + cropWidth = requestedCrop.width(); + cropHeight = cropWidth / aspectRatioPreview; + } + + Matrix translateMatrix = new Matrix(); + RectF cropRect = new RectF(/*left*/0, /*top*/0, cropWidth, cropHeight); + + // Now center the crop rectangle so its center is in the center of the active array + translateMatrix.setTranslate(requestedCrop.exactCenterX(), requestedCrop.exactCenterY()); + translateMatrix.postTranslate(-cropRect.centerX(), -cropRect.centerY()); + + translateMatrix.mapRect(/*inout*/cropRect); + + // Round the rect corners towards the nearest integer values + Rect result = new Rect(); + cropRect.roundOut(result); + return result; + } } diff --git a/camera2/portability/src/com/android/ex/camera2/portability/AndroidCameraAgentImpl.java b/camera2/portability/src/com/android/ex/camera2/portability/AndroidCameraAgentImpl.java index f8a2e38..358d5f6 100644 --- a/camera2/portability/src/com/android/ex/camera2/portability/AndroidCameraAgentImpl.java +++ b/camera2/portability/src/com/android/ex/camera2/portability/AndroidCameraAgentImpl.java @@ -400,6 +400,7 @@ class AndroidCameraAgentImpl extends CameraAgent { break; } + // TODO: Lock the CameraSettings object's sizes case CameraActions.SET_PREVIEW_TEXTURE_ASYNC: { setPreviewTexture(msg.obj); break; @@ -424,6 +425,7 @@ class AndroidCameraAgentImpl extends CameraAgent { break; } + // TODO: Unlock the CameraSettings object's sizes case CameraActions.STOP_PREVIEW: { mCamera.stopPreview(); break; @@ -612,11 +614,15 @@ class AndroidCameraAgentImpl extends CameraAgent { if (mCapabilities.supports(CameraCapabilities.Feature.FOCUS_AREA)) { if (settings.getFocusAreas().size() != 0) { parameters.setFocusAreas(settings.getFocusAreas()); + } else { + parameters.setFocusAreas(null); } } if (mCapabilities.supports(CameraCapabilities.Feature.METERING_AREA)) { if (settings.getMeteringAreas().size() != 0) { parameters.setMeteringAreas(settings.getMeteringAreas()); + } else { + parameters.setMeteringAreas(null); } } if (settings.getCurrentFlashMode() != CameraCapabilities.FlashMode.NO_FLASH) { diff --git a/camera2/portability/src/com/android/ex/camera2/portability/AndroidCameraSettings.java b/camera2/portability/src/com/android/ex/camera2/portability/AndroidCameraSettings.java index f5421d6..ee69b54 100644 --- a/camera2/portability/src/com/android/ex/camera2/portability/AndroidCameraSettings.java +++ b/camera2/portability/src/com/android/ex/camera2/portability/AndroidCameraSettings.java @@ -28,6 +28,8 @@ public class AndroidCameraSettings extends CameraSettings { public AndroidCameraSettings(CameraCapabilities capabilities, Camera.Parameters params) { CameraCapabilities.Stringifier stringifier = capabilities.getStringifier(); + setSizesLocked(false); + // Preview Camera.Size paramPreviewSize = params.getPreviewSize(); setPreviewSize(new Size(paramPreviewSize.width, paramPreviewSize.height)); diff --git a/camera2/portability/src/com/android/ex/camera2/portability/CameraAgent.java b/camera2/portability/src/com/android/ex/camera2/portability/CameraAgent.java index df94a41..b624b47 100644 --- a/camera2/portability/src/com/android/ex/camera2/portability/CameraAgent.java +++ b/camera2/portability/src/com/android/ex/camera2/portability/CameraAgent.java @@ -436,8 +436,24 @@ public abstract class CameraAgent { /** * Sets the {@link android.graphics.SurfaceTexture} for preview. * + * <p>Note that, once this operation has been performed, it is no longer + * possible to change the preview or photo sizes in the + * {@link CameraSettings} instance for this camera, and the mutators for + * these fields are allowed to ignore all further invocations until the + * preview is stopped with {@link #stopPreview}.</p> + * * @param surfaceTexture The {@link SurfaceTexture} for preview. - */ + * + * @see CameraSettings#setPhotoSize + * @see CameraSettings#setPreviewSize + */ + // XXX: Despite the above documentation about locking the sizes, the API + // 1 implementation doesn't currently enforce this at all, although the + // Camera class warns that preview sizes shouldn't be changed while a + // preview is running. Furthermore, the API 2 implementation doesn't yet + // unlock the sizes when stopPreview() is invoked (see related FIXME on + // the STOP_PREVIEW case in its handler; in the meantime, changing API 2 + // sizes would require closing and reopening the camera. public void setPreviewTexture(final SurfaceTexture surfaceTexture) { getDispatchThread().runJob(new Runnable() { @Override @@ -452,7 +468,15 @@ public abstract class CameraAgent { * Blocks until a {@link android.graphics.SurfaceTexture} has been set * for preview. * + * <p>Note that, once this operation has been performed, it is no longer + * possible to change the preview or photo sizes in the + * {@link CameraSettings} instance for this camera, and the mutators for + * these fields are allowed to ignore all further invocations.</p> + * * @param surfaceTexture The {@link SurfaceTexture} for preview. + * + * @see CameraSettings#setPhotoSize + * @see CameraSettings#setPreviewSize */ public void setPreviewTextureSync(final SurfaceTexture surfaceTexture) { final WaitDoneBundle bundle = new WaitDoneBundle(); diff --git a/camera2/portability/src/com/android/ex/camera2/portability/CameraSettings.java b/camera2/portability/src/com/android/ex/camera2/portability/CameraSettings.java index d0600e8..87e9adf 100644 --- a/camera2/portability/src/com/android/ex/camera2/portability/CameraSettings.java +++ b/camera2/portability/src/com/android/ex/camera2/portability/CameraSettings.java @@ -38,6 +38,7 @@ public abstract class CameraSettings { protected final Map<String, String> mGeneralSetting = new TreeMap<>(); protected final List<Camera.Area> mMeteringAreas = new ArrayList<>(); protected final List<Camera.Area> mFocusAreas = new ArrayList<>(); + protected boolean mSizesLocked; protected int mPreviewFpsRangeMin; protected int mPreviewFpsRangeMax; protected int mPreviewFrameRate; @@ -116,6 +117,7 @@ public abstract class CameraSettings { mGeneralSetting.putAll(src.mGeneralSetting); mMeteringAreas.addAll(src.mMeteringAreas); mFocusAreas.addAll(src.mFocusAreas); + mSizesLocked = src.mSizesLocked; mPreviewFpsRangeMin = src.mPreviewFpsRangeMin; mPreviewFpsRangeMax = src.mPreviewFpsRangeMax; mPreviewFrameRate = src.mPreviewFrameRate; @@ -151,6 +153,19 @@ public abstract class CameraSettings { mGeneralSetting.put(key, value); } + /** + * Changes whether classes outside this class are allowed to set the preview + * and photo capture sizes. + * + * @param locked Whether to prevent changes to these fields. + * + * @see #setPhotoSize + * @see #setPreviewSize + */ + /*package*/ void setSizesLocked(boolean locked) { + mSizesLocked = locked; + } + /** Preview **/ /** @@ -212,9 +227,16 @@ public abstract class CameraSettings { /** * @param previewSize The size to use for preview. + * @return Whether the operation was allowed (i.e. the sizes are unlocked). */ - public void setPreviewSize(Size previewSize) { + public boolean setPreviewSize(Size previewSize) { + if (mSizesLocked) { + Log.w(TAG, "Attempt to change preview size while locked"); + return false; + } + mCurrentPreviewSize = new Size(previewSize); + return true; } /** @@ -245,12 +267,17 @@ public abstract class CameraSettings { } /** - * Sets the size for the photo. - * - * @param photoSize The photo size. + * @param photoSize The size to use for preview. + * @return Whether the operation was allowed (i.e. the sizes are unlocked). */ - public void setPhotoSize(Size photoSize) { + public boolean setPhotoSize(Size photoSize) { + if (mSizesLocked) { + Log.w(TAG, "Attempt to change photo size while locked"); + return false; + } + mCurrentPhotoSize = new Size(photoSize); + return true; } /** diff --git a/camera2/utils/src/com/android/ex/camera2/utils/Camera2RequestSettingsSet.java b/camera2/utils/src/com/android/ex/camera2/utils/Camera2RequestSettingsSet.java index fac8f1a..6e1d825 100644 --- a/camera2/utils/src/com/android/ex/camera2/utils/Camera2RequestSettingsSet.java +++ b/camera2/utils/src/com/android/ex/camera2/utils/Camera2RequestSettingsSet.java @@ -146,7 +146,7 @@ public class Camera2RequestSettingsSet { * to its default value or simply unset. While {@link #get} will return * {@code null} in both these cases, this method will return {@code true} * and {@code false}, respectively.</p> - + * * @param key Which setting to look for. * @return Whether that setting has a value that will propagate with unions. * @@ -160,8 +160,23 @@ public class Camera2RequestSettingsSet { } /** + * Check whether the value of the specified setting matches the given one. + * + * <p>This method uses the {@code T} type's {@code equals} method, but is + * {@code null}-tolerant.</p> + * + * @param key Which of this class's settings to check. + * @param value Value to test for equality against. + * @return Whether they are the same. + */ + public <T> boolean matches(Key<T> key, T value) { + return Objects.equals(get(key), value); + } + + /** * Get this set of settings's revision identifier, which can be compared * against cached past values to determine whether it has been modified. + * * <p>Distinct revisions across the same object do not necessarily indicate * that the object's key/value pairs have changed at all, but the same * revision on the same object does imply that they've stayed the same.</p> diff --git a/camera2/utils/tests/src/com/android/ex/camera2/utils/Camera2UtilsTest.java b/camera2/utils/tests/src/com/android/ex/camera2/utils/Camera2UtilsTest.java index 01eda8f..7847526 100644 --- a/camera2/utils/tests/src/com/android/ex/camera2/utils/Camera2UtilsTest.java +++ b/camera2/utils/tests/src/com/android/ex/camera2/utils/Camera2UtilsTest.java @@ -23,6 +23,7 @@ import static org.junit.Assert.assertTrue; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; +import android.graphics.Rect; import android.hardware.camera2.CameraCaptureSession.CaptureListener; import android.hardware.camera2.CameraDevice; import android.hardware.camera2.CaptureRequest; @@ -234,6 +235,45 @@ public class Camera2UtilsTest extends Camera2DeviceTester { setUp.get(null); } + @Test + public void requestSettingsSetMatchesPrimitives() { + Camera2RequestSettingsSet setUp = new Camera2RequestSettingsSet(); + assertTrue(setUp.matches(CaptureRequest.CONTROL_AE_LOCK, null)); + assertFalse(setUp.matches(CaptureRequest.CONTROL_AE_LOCK, false)); + assertFalse(setUp.matches(CaptureRequest.CONTROL_AE_LOCK, true)); + + setUp.set(CaptureRequest.CONTROL_AE_LOCK, null); + assertTrue(setUp.matches(CaptureRequest.CONTROL_AE_LOCK, null)); + assertFalse(setUp.matches(CaptureRequest.CONTROL_AE_LOCK, false)); + assertFalse(setUp.matches(CaptureRequest.CONTROL_AE_LOCK, true)); + + setUp.set(CaptureRequest.CONTROL_AE_LOCK, false); + assertFalse(setUp.matches(CaptureRequest.CONTROL_AE_LOCK, null)); + assertTrue(setUp.matches(CaptureRequest.CONTROL_AE_LOCK, false)); + assertFalse(setUp.matches(CaptureRequest.CONTROL_AE_LOCK, true)); + + setUp.set(CaptureRequest.CONTROL_AE_LOCK, true); + assertFalse(setUp.matches(CaptureRequest.CONTROL_AE_LOCK, null)); + assertFalse(setUp.matches(CaptureRequest.CONTROL_AE_LOCK, false)); + assertTrue(setUp.matches(CaptureRequest.CONTROL_AE_LOCK, true)); + } + + @Test + public void requestSettingsSetMatchesReferences() { + Camera2RequestSettingsSet setUp = new Camera2RequestSettingsSet(); + assertTrue(setUp.matches(CaptureRequest.SCALER_CROP_REGION, null)); + assertFalse(setUp.matches(CaptureRequest.SCALER_CROP_REGION, new Rect(0, 0, 0, 0))); + + setUp.set(CaptureRequest.SCALER_CROP_REGION, null); + assertTrue(setUp.matches(CaptureRequest.SCALER_CROP_REGION, null)); + assertFalse(setUp.matches(CaptureRequest.SCALER_CROP_REGION, new Rect(0, 0, 0, 0))); + + setUp.set(CaptureRequest.SCALER_CROP_REGION, new Rect(0, 0, 0, 0)); + assertFalse(setUp.matches(CaptureRequest.SCALER_CROP_REGION, null)); + assertTrue(setUp.matches(CaptureRequest.SCALER_CROP_REGION, new Rect(0, 0, 0, 0))); + assertFalse(setUp.matches(CaptureRequest.SCALER_CROP_REGION, new Rect(0, 0, 1, 1))); + } + @Test(expected=NullPointerException.class) public void requestSettingsSetNullArgToCreateRequest0() throws Exception { Camera2RequestSettingsSet setUp = new Camera2RequestSettingsSet(); |