releaseInternal() {
finishClose();
break;
case OPENED:
+ case CONFIGURED:
setState(InternalState.RELEASING);
//TODO(b/162314023): Avoid calling abortCapture to prevent the many test failures
// caused by shutdown(). We should consider re-enabling it once the cause is
@@ -625,9 +652,16 @@ public void onUseCaseUpdated(@NonNull UseCase useCase) {
@Override
public void onUseCaseReset(@NonNull UseCase useCase) {
Preconditions.checkNotNull(useCase);
- String useCaseId = getUseCaseId(useCase);
SessionConfig sessionConfig = useCase.getSessionConfig();
UseCaseConfig useCaseConfig = useCase.getCurrentConfig();
+ resetUseCase(getUseCaseId(useCase), sessionConfig, useCaseConfig);
+ }
+
+ private void resetUseCase(
+ @NonNull String useCaseId,
+ @NonNull SessionConfig sessionConfig,
+ @NonNull UseCaseConfig useCaseConfig
+ ) {
mExecutor.execute(() -> {
debugLog("Use case " + useCaseId + " RESET");
mUseCaseAttachState.updateUseCase(useCaseId, sessionConfig, useCaseConfig);
@@ -650,9 +684,8 @@ public void onUseCaseReset(@NonNull UseCase useCase) {
* This method should only be used by tests. This will post to the Camera's thread and
* block until completion.
*
- * @hide
*/
- @RestrictTo(RestrictTo.Scope.TESTS)
+ @VisibleForTesting
boolean isUseCaseAttached(@NonNull UseCase useCase) {
try {
String useCaseId = getUseCaseId(useCase);
@@ -672,6 +705,31 @@ boolean isUseCaseAttached(@NonNull UseCase useCase) {
}
}
+ @VisibleForTesting
+ boolean isMeteringRepeatingAttached() {
+ try {
+ return CallbackToFutureAdapter.getFuture(completer -> {
+ try {
+ mExecutor.execute(() -> {
+ if (mMeteringRepeatingSession == null) {
+ completer.set(false);
+ return;
+ }
+ String id = getMeteringRepeatingId(mMeteringRepeatingSession);
+ completer.set(mUseCaseAttachState.isUseCaseAttached(id));
+ });
+ } catch (RejectedExecutionException e) {
+ completer.setException(new RuntimeException(
+ "Unable to check if MeteringRepeating is attached. Camera executor "
+ + "shut down."));
+ }
+ return "isMeteringRepeatingAttached";
+ }).get();
+ } catch (InterruptedException | ExecutionException e) {
+ throw new RuntimeException("Unable to check if MeteringRepeating is attached.", e);
+ }
+ }
+
/**
* Sets the use case to be in the state where the capture session will be configured to handle
* capture requests from the use case.
@@ -692,7 +750,7 @@ public void attachUseCases(@NonNull Collection inputUseCases) {
* use count to recover the additional increment here.
*/
mCameraControlInternal.incrementUseCount();
- notifyStateAttachedToUseCases(new ArrayList<>(useCases));
+ notifyStateAttachedAndCameraControlReady(new ArrayList<>(useCases));
List useCaseInfos = new ArrayList<>(toUseCaseInfos(useCases));
try {
mExecutor.execute(() -> {
@@ -798,7 +856,7 @@ public CameraConfig getExtendedConfig() {
return mCameraConfig;
}
- private void notifyStateAttachedToUseCases(List useCases) {
+ private void notifyStateAttachedAndCameraControlReady(List useCases) {
for (UseCase useCase : useCases) {
String useCaseId = getUseCaseId(useCase);
if (mNotifyStateAttachedSet.contains(useCaseId)) {
@@ -807,6 +865,7 @@ private void notifyStateAttachedToUseCases(List useCases) {
mNotifyStateAttachedSet.add(useCaseId);
useCase.onStateAttached();
+ useCase.onCameraControlReady();
}
}
@@ -924,7 +983,20 @@ private void addOrRemoveMeteringRepeatingUseCase() {
if (mMeteringRepeatingSession == null) {
mMeteringRepeatingSession = new MeteringRepeatingSession(
mCameraInfoInternal.getCameraCharacteristicsCompat(),
- mDisplayInfoManager);
+ mDisplayInfoManager,
+ () -> {
+ if (!isMeteringRepeatingAttached()) {
+ return;
+ }
+
+ SessionConfig sessionConfigMeteringRepeating =
+ mMeteringRepeatingSession.getSessionConfig();
+ UseCaseConfig useCaseConfig =
+ mMeteringRepeatingSession.getUseCaseConfig();
+
+ resetUseCase(getMeteringRepeatingId(mMeteringRepeatingSession),
+ sessionConfigMeteringRepeating, useCaseConfig);
+ });
}
addMeteringRepeating();
} else {
@@ -958,12 +1030,13 @@ private void removeMeteringRepeating() {
private void addMeteringRepeating() {
if (mMeteringRepeatingSession != null) {
+ String id = getMeteringRepeatingId(mMeteringRepeatingSession);
mUseCaseAttachState.setUseCaseAttached(
- mMeteringRepeatingSession.getName() + mMeteringRepeatingSession.hashCode(),
+ id,
mMeteringRepeatingSession.getSessionConfig(),
mMeteringRepeatingSession.getUseCaseConfig());
mUseCaseAttachState.setUseCaseActive(
- mMeteringRepeatingSession.getName() + mMeteringRepeatingSession.hashCode(),
+ id,
mMeteringRepeatingSession.getSessionConfig(),
mMeteringRepeatingSession.getUseCaseConfig());
}
@@ -976,8 +1049,8 @@ public CameraInfoInternal getCameraInfoInternal() {
return mCameraInfoInternal;
}
- /** @hide */
- @RestrictTo(RestrictTo.Scope.TESTS)
+ @NonNull
+ @VisibleForTesting
public CameraAvailability getCameraAvailability() {
return mCameraAvailability;
}
@@ -1127,14 +1200,23 @@ void openCaptureSession() {
return;
}
- if (!validatingBuilder.build().getImplementationOptions().containsOption(
- Camera2ImplConfig.STREAM_USE_CASE_OPTION)) {
- validatingBuilder.addImplementationOption(Camera2ImplConfig.STREAM_USE_CASE_OPTION,
- StreamUseCaseUtil.getStreamUseCaseFromUseCaseConfigs(
- mUseCaseAttachState.getAttachedUseCaseConfigs(),
- mUseCaseAttachState.getAttachedSessionConfigs()));
+ // Checks if capture session is allowed to open in concurrent camera mode.
+ if (!mCameraStateRegistry.tryOpenCaptureSession(
+ mCameraDevice.getId(),
+ mCameraCoordinator.getPairedConcurrentCameraId(mCameraDevice.getId()))) {
+ debugLog("Unable to create capture session in camera operating mode = "
+ + mCameraCoordinator.getCameraOperatingMode());
+ return;
}
+ Map streamUseCaseMap = new HashMap<>();
+ StreamUseCaseUtil.populateSurfaceToStreamUseCaseMapping(
+ mUseCaseAttachState.getAttachedSessionConfigs(),
+ mUseCaseAttachState.getAttachedUseCaseConfigs(),
+ streamUseCaseMap);
+
+ mCaptureSession.setStreamUseCaseMap(streamUseCaseMap);
+
CaptureSessionInterface captureSession = mCaptureSession;
ListenableFuture openCaptureSession = captureSession.open(validatingBuilder.build(),
Preconditions.checkNotNull(mCameraDevice), mCaptureSessionOpenerBuilder.build());
@@ -1143,7 +1225,11 @@ void openCaptureSession() {
@Override
@ExecutedBy("mExecutor")
public void onSuccess(@Nullable Void result) {
- // Nothing to do.
+ // TODO(b/271182406): Apply the CONFIGURED state to non-concurrent mode.
+ if (mCameraCoordinator.getCameraOperatingMode() == CAMERA_OPERATING_MODE_CONCURRENT
+ && mState == InternalState.OPENED) {
+ setState(InternalState.CONFIGURED);
+ }
}
@Override
@@ -1347,6 +1433,11 @@ static String getUseCaseId(@NonNull UseCase useCase) {
return useCase.getName() + useCase.hashCode();
}
+ @NonNull
+ static String getMeteringRepeatingId(@NonNull MeteringRepeatingSession meteringRepeating) {
+ return meteringRepeating.getName() + meteringRepeating.hashCode();
+ }
+
@SuppressWarnings("WeakerAccess") /* synthetic accessor */
void debugLog(@NonNull String msg) {
debugLog(msg, null);
@@ -1392,6 +1483,13 @@ enum InternalState {
* capture session can be active. Capture requests should be issued during this state only.
*/
OPENED,
+ /**
+ * A stable state where the camera has been opened and capture session has been configured.
+ *
+ * It is a state only used in concurrent mode to differentiate from OPENED state for
+ * capture session configuration status.
+ */
+ CONFIGURED,
/**
* A transitional state where the camera device is currently closing.
*
@@ -1465,6 +1563,9 @@ void setState(@NonNull InternalState state, @Nullable CameraState.StateError sta
case OPENED:
publicState = State.OPEN;
break;
+ case CONFIGURED:
+ publicState = State.CONFIGURED;
+ break;
case CLOSING:
publicState = State.CLOSING;
break;
@@ -1578,7 +1679,12 @@ public void onOpened(@NonNull CameraDevice cameraDevice) {
case OPENING:
case REOPENING:
setState(InternalState.OPENED);
- openCaptureSession();
+ if (mCameraStateRegistry.tryOpenCaptureSession(
+ cameraDevice.getId(),
+ mCameraCoordinator.getPairedConcurrentCameraId(
+ mCameraDevice.getId()))) {
+ openCaptureSession();
+ }
break;
default:
throw new IllegalStateException(
@@ -1640,6 +1746,7 @@ public void onError(@NonNull CameraDevice cameraDevice, int error) {
break;
case OPENING:
case OPENED:
+ case CONFIGURED:
case REOPENING:
Logger.d(TAG, String.format("CameraDevice.onError(): %s failed with %s while "
+ "in %s state. Will attempt recovering from error.",
@@ -1656,6 +1763,7 @@ public void onError(@NonNull CameraDevice cameraDevice, int error) {
private void handleErrorOnOpen(@NonNull CameraDevice cameraDevice, int error) {
Preconditions.checkState(
mState == InternalState.OPENING || mState == InternalState.OPENED
+ || mState == InternalState.CONFIGURED
|| mState == InternalState.REOPENING,
"Attempt to handle open error from non open state: " + mState);
switch (error) {
@@ -1972,6 +2080,17 @@ boolean isCameraAvailable() {
}
}
+ final class CameraConfigureAvailable
+ implements CameraStateRegistry.OnConfigureAvailableListener {
+
+ @Override
+ public void onConfigureAvailable() {
+ if (mState == InternalState.OPENED) {
+ openCaptureSession();
+ }
+ }
+ }
+
final class ControlUpdateListenerInternal implements
CameraControlInternal.ControlUpdateCallback {
diff --git a/camera2/src/main/java/androidx/camera/camera2/internal/Camera2CameraInfoImpl.java b/camera2/src/main/java/androidx/camera/camera2/internal/Camera2CameraInfoImpl.java
index cb4f1cdf9..3729cf8de 100644
--- a/camera2/src/main/java/androidx/camera/camera2/internal/Camera2CameraInfoImpl.java
+++ b/camera2/src/main/java/androidx/camera/camera2/internal/Camera2CameraInfoImpl.java
@@ -26,8 +26,11 @@
import android.hardware.camera2.CameraMetadata;
import android.os.Build;
import android.util.Pair;
+import android.util.Range;
+import android.util.Size;
import android.view.Surface;
+import androidx.annotation.FloatRange;
import androidx.annotation.GuardedBy;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
@@ -36,19 +39,24 @@
import androidx.camera.camera2.internal.compat.CameraAccessExceptionCompat;
import androidx.camera.camera2.internal.compat.CameraCharacteristicsCompat;
import androidx.camera.camera2.internal.compat.CameraManagerCompat;
+import androidx.camera.camera2.internal.compat.StreamConfigurationMapCompat;
+import androidx.camera.camera2.internal.compat.params.DynamicRangesCompat;
import androidx.camera.camera2.internal.compat.quirk.CameraQuirks;
+import androidx.camera.camera2.internal.compat.quirk.DeviceQuirks;
+import androidx.camera.camera2.internal.compat.quirk.ZslDisablerQuirk;
import androidx.camera.camera2.internal.compat.workaround.FlashAvailabilityChecker;
import androidx.camera.camera2.interop.Camera2CameraInfo;
import androidx.camera.camera2.interop.ExperimentalCamera2Interop;
import androidx.camera.core.CameraSelector;
import androidx.camera.core.CameraState;
+import androidx.camera.core.DynamicRange;
import androidx.camera.core.ExposureState;
import androidx.camera.core.FocusMeteringAction;
import androidx.camera.core.Logger;
import androidx.camera.core.ZoomState;
-import androidx.camera.core.impl.CamcorderProfileProvider;
import androidx.camera.core.impl.CameraCaptureCallback;
import androidx.camera.core.impl.CameraInfoInternal;
+import androidx.camera.core.impl.EncoderProfilesProvider;
import androidx.camera.core.impl.ImageOutputConfig.RotationValue;
import androidx.camera.core.impl.Quirks;
import androidx.camera.core.impl.Timebase;
@@ -59,11 +67,15 @@
import androidx.lifecycle.Observer;
import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
+import java.util.Set;
import java.util.concurrent.Executor;
/**
@@ -105,7 +117,7 @@ public final class Camera2CameraInfoImpl implements CameraInfoInternal {
@NonNull
private final Quirks mCameraQuirks;
@NonNull
- private final CamcorderProfileProvider mCamera2CamcorderProfileProvider;
+ private final EncoderProfilesProvider mCamera2EncoderProfilesProvider;
@NonNull
private final CameraManagerCompat mCameraManager;
@@ -113,7 +125,7 @@ public final class Camera2CameraInfoImpl implements CameraInfoInternal {
* Constructs an instance. Before {@link #linkWithCameraControl(Camera2CameraControlImpl)} is
* called, camera control related API (torch/exposure/zoom) will return default values.
*/
- Camera2CameraInfoImpl(@NonNull String cameraId,
+ public Camera2CameraInfoImpl(@NonNull String cameraId,
@NonNull CameraManagerCompat cameraManager) throws CameraAccessExceptionCompat {
mCameraId = Preconditions.checkNotNull(cameraId);
mCameraManager = cameraManager;
@@ -121,8 +133,7 @@ public final class Camera2CameraInfoImpl implements CameraInfoInternal {
mCameraCharacteristicsCompat = cameraManager.getCameraCharacteristicsCompat(mCameraId);
mCamera2CameraInfo = new Camera2CameraInfo(this);
mCameraQuirks = CameraQuirks.get(cameraId, mCameraCharacteristicsCompat);
- mCamera2CamcorderProfileProvider = new Camera2CamcorderProfileProvider(cameraId,
- mCameraCharacteristicsCompat);
+ mCamera2EncoderProfilesProvider = new Camera2EncoderProfilesProvider(cameraId);
mCameraStateLiveData = new RedirectableLiveData<>(
CameraState.create(CameraState.Type.CLOSED));
}
@@ -178,19 +189,13 @@ public CameraCharacteristicsCompat getCameraCharacteristicsCompat() {
return mCameraCharacteristicsCompat;
}
- @Nullable
+ @CameraSelector.LensFacing
@Override
- public Integer getLensFacing() {
+ public int getLensFacing() {
Integer lensFacing = mCameraCharacteristicsCompat.get(CameraCharacteristics.LENS_FACING);
- Preconditions.checkNotNull(lensFacing);
- switch (lensFacing) {
- case CameraCharacteristics.LENS_FACING_FRONT:
- return CameraSelector.LENS_FACING_FRONT;
- case CameraCharacteristics.LENS_FACING_BACK:
- return CameraSelector.LENS_FACING_BACK;
- default:
- return null;
- }
+ Preconditions.checkArgument(lensFacing != null, "Unable to get the lens facing of the "
+ + "camera.");
+ return LensFacingUtil.getCameraSelectorLensFacing(lensFacing);
}
@Override
@@ -201,9 +206,8 @@ public int getSensorRotationDegrees(@RotationValue int relativeRotation) {
// Currently this assumes that a back-facing camera is always opposite to the screen.
// This may not be the case for all devices, so in the future we may need to handle that
// scenario.
- final Integer lensFacing = getLensFacing();
- boolean isOppositeFacingScreen =
- (lensFacing != null && CameraSelector.LENS_FACING_BACK == lensFacing);
+ final int lensFacing = getLensFacing();
+ boolean isOppositeFacingScreen = CameraSelector.LENS_FACING_BACK == lensFacing;
return CameraOrientationUtil.getRelativeImageRotation(
relativeRotationDegrees,
sensorOrientation,
@@ -264,7 +268,7 @@ private void logDeviceLevel() {
@Override
public boolean hasFlashUnit() {
- return FlashAvailabilityChecker.isFlashAvailable(mCameraCharacteristicsCompat);
+ return FlashAvailabilityChecker.isFlashAvailable(mCameraCharacteristicsCompat::get);
}
@NonNull
@@ -345,6 +349,33 @@ public String getImplementationType() {
? IMPLEMENTATION_TYPE_CAMERA2_LEGACY : IMPLEMENTATION_TYPE_CAMERA2;
}
+ @FloatRange(from = 0, fromInclusive = false)
+ @Override
+ public float getIntrinsicZoomRatio() {
+ final Integer lensFacing =
+ mCameraCharacteristicsCompat.get(CameraCharacteristics.LENS_FACING);
+ if (lensFacing == null) {
+ return INTRINSIC_ZOOM_RATIO_UNKNOWN;
+ }
+
+ int fovDegrees;
+ int defaultFovDegrees;
+ try {
+ fovDegrees =
+ FovUtil.focalLengthToViewAngleDegrees(
+ FovUtil.getDefaultFocalLength(mCameraCharacteristicsCompat),
+ FovUtil.getSensorHorizontalLength(mCameraCharacteristicsCompat));
+ defaultFovDegrees = FovUtil.getDeviceDefaultViewAngleDegrees(mCameraManager,
+ lensFacing);
+ } catch (Exception e) {
+ Logger.e(TAG, "The camera is unable to provide necessary information to resolve its "
+ + "intrinsic zoom ratio with error: " + e);
+ return INTRINSIC_ZOOM_RATIO_UNKNOWN;
+ }
+
+ return ((float) defaultFovDegrees) / fovDegrees;
+ }
+
@Override
public boolean isFocusMeteringSupported(@NonNull FocusMeteringAction action) {
synchronized (mLock) {
@@ -358,7 +389,8 @@ public boolean isFocusMeteringSupported(@NonNull FocusMeteringAction action) {
@Override
public boolean isZslSupported() {
- return Build.VERSION.SDK_INT >= 23 && isPrivateReprocessingSupported();
+ return Build.VERSION.SDK_INT >= 23 && isPrivateReprocessingSupported()
+ && (DeviceQuirks.get(ZslDisablerQuirk.class) == null);
}
@Override
@@ -370,8 +402,8 @@ public boolean isPrivateReprocessingSupported() {
/** {@inheritDoc} */
@NonNull
@Override
- public CamcorderProfileProvider getCamcorderProfileProvider() {
- return mCamera2CamcorderProfileProvider;
+ public EncoderProfilesProvider getEncoderProfilesProvider() {
+ return mCamera2EncoderProfilesProvider;
}
@NonNull
@@ -389,6 +421,33 @@ public Timebase getTimebase() {
}
}
+ @NonNull
+ @Override
+ public List getSupportedResolutions(int format) {
+ StreamConfigurationMapCompat mapCompat =
+ mCameraCharacteristicsCompat.getStreamConfigurationMapCompat();
+ Size[] size = mapCompat.getOutputSizes(format);
+ return size != null ? Arrays.asList(size) : Collections.emptyList();
+ }
+
+ @NonNull
+ @Override
+ public List getSupportedHighResolutions(int format) {
+ StreamConfigurationMapCompat mapCompat =
+ mCameraCharacteristicsCompat.getStreamConfigurationMapCompat();
+ Size[] size = mapCompat.getHighResolutionOutputSizes(format);
+ return size != null ? Arrays.asList(size) : Collections.emptyList();
+ }
+
+ @NonNull
+ @Override
+ public Set getSupportedDynamicRanges() {
+ DynamicRangesCompat dynamicRangesCompat = DynamicRangesCompat.fromCameraCharacteristics(
+ mCameraCharacteristicsCompat);
+
+ return dynamicRangesCompat.getSupportedDynamicRanges();
+ }
+
@Override
public void addSessionCaptureCallback(@NonNull Executor executor,
@NonNull CameraCaptureCallback callback) {
@@ -433,6 +492,19 @@ public Quirks getCameraQuirks() {
return mCameraQuirks;
}
+ @NonNull
+ @Override
+ public Set> getSupportedFrameRateRanges() {
+ Range[] availableTargetFpsRanges =
+ mCameraCharacteristicsCompat.get(
+ CameraCharacteristics.CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES);
+ if (availableTargetFpsRanges != null) {
+ return new HashSet<>(Arrays.asList(availableTargetFpsRanges));
+ } else {
+ return Collections.emptySet();
+ }
+ }
+
/**
* Gets the implementation of {@link Camera2CameraInfo}.
*/
diff --git a/camera2/src/main/java/androidx/camera/camera2/internal/Camera2CapturePipeline.java b/camera2/src/main/java/androidx/camera/camera2/internal/Camera2CapturePipeline.java
index 65b43a2cf..7da2f8280 100644
--- a/camera2/src/main/java/androidx/camera/camera2/internal/Camera2CapturePipeline.java
+++ b/camera2/src/main/java/androidx/camera/camera2/internal/Camera2CapturePipeline.java
@@ -43,6 +43,7 @@
import androidx.camera.camera2.impl.Camera2ImplConfig;
import androidx.camera.camera2.internal.annotation.CameraExecutor;
import androidx.camera.camera2.internal.compat.CameraCharacteristicsCompat;
+import androidx.camera.camera2.internal.compat.workaround.FlashAvailabilityChecker;
import androidx.camera.camera2.internal.compat.workaround.OverrideAeModeForStillCapture;
import androidx.camera.camera2.internal.compat.workaround.UseTorchAsFlash;
import androidx.camera.camera2.interop.ExperimentalCamera2Interop;
@@ -127,6 +128,8 @@ class Camera2CapturePipeline {
@NonNull
private final UseTorchAsFlash mUseTorchAsFlash;
+ private final boolean mHasFlashUnit;
+
@NonNull
private final Quirks mCameraQuirk;
@@ -153,6 +156,7 @@ class Camera2CapturePipeline {
mExecutor = executor;
mCameraQuirk = cameraQuirks;
mUseTorchAsFlash = new UseTorchAsFlash(cameraQuirks);
+ mHasFlashUnit = FlashAvailabilityChecker.isFlashAvailable(cameraCharacteristics::get);
}
@ExecutedBy("mExecutor")
@@ -183,11 +187,13 @@ public ListenableFuture> submitStillCaptures(
pipeline.addTask(new AfTask(mCameraControl));
}
- if (isTorchAsFlash(flashType)) {
- pipeline.addTask(new TorchTask(mCameraControl, flashMode, mExecutor));
- } else {
- pipeline.addTask(new AePreCaptureTask(mCameraControl, flashMode, aeQuirk));
- }
+ if (mHasFlashUnit) {
+ if (isTorchAsFlash(flashType)) {
+ pipeline.addTask(new TorchTask(mCameraControl, flashMode, mExecutor));
+ } else {
+ pipeline.addTask(new AePreCaptureTask(mCameraControl, flashMode, aeQuirk));
+ }
+ } // If there is no flash unit, skip the flash related task instead of failing the pipeline.
return Futures.nonCancellationPropagating(
pipeline.executeCapture(captureConfigs, flashMode));
diff --git a/camera2/src/main/java/androidx/camera/camera2/internal/Camera2CaptureRequestBuilder.java b/camera2/src/main/java/androidx/camera/camera2/internal/Camera2CaptureRequestBuilder.java
index c1de11329..60c74f072 100644
--- a/camera2/src/main/java/androidx/camera/camera2/internal/Camera2CaptureRequestBuilder.java
+++ b/camera2/src/main/java/androidx/camera/camera2/internal/Camera2CaptureRequestBuilder.java
@@ -28,6 +28,7 @@
import androidx.annotation.Nullable;
import androidx.annotation.OptIn;
import androidx.annotation.RequiresApi;
+import androidx.camera.camera2.impl.Camera2ImplConfig;
import androidx.camera.camera2.interop.CaptureRequestOptions;
import androidx.camera.camera2.interop.ExperimentalCamera2Interop;
import androidx.camera.core.Logger;
@@ -35,6 +36,7 @@
import androidx.camera.core.impl.CaptureConfig;
import androidx.camera.core.impl.Config;
import androidx.camera.core.impl.DeferrableSurface;
+import androidx.camera.core.impl.StreamSpec;
import java.util.ArrayList;
import java.util.List;
@@ -94,6 +96,21 @@ private static void applyImplementationOptionToCaptureBuilder(
}
}
+ @OptIn(markerClass = ExperimentalCamera2Interop.class)
+ private static void applyAeFpsRange(@NonNull CaptureConfig captureConfig,
+ @NonNull CaptureRequest.Builder builder) {
+ boolean containsTargetFpsRange = CaptureRequestOptions.Builder.from(
+ captureConfig.getImplementationOptions()).build().containsOption(
+ Camera2ImplConfig.createCaptureRequestOption(
+ CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE));
+ if (!containsTargetFpsRange && !captureConfig.getExpectedFrameRateRange().equals(
+ StreamSpec.FRAME_RATE_RANGE_UNSPECIFIED)) {
+ builder.set(CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE,
+ captureConfig.getExpectedFrameRateRange());
+ }
+
+ }
+
/**
* Builds a {@link CaptureRequest} from a {@link CaptureConfig} and a {@link CameraDevice}.
@@ -136,6 +153,8 @@ public static CaptureRequest build(@NonNull CaptureConfig captureConfig,
applyImplementationOptionToCaptureBuilder(builder,
captureConfig.getImplementationOptions());
+ applyAeFpsRange(captureConfig, builder);
+
if (captureConfig.getImplementationOptions().containsOption(
CaptureConfig.OPTION_ROTATION)) {
builder.set(CaptureRequest.JPEG_ORIENTATION,
diff --git a/camera2/src/main/java/androidx/camera/camera2/internal/Camera2DeviceSurfaceManager.java b/camera2/src/main/java/androidx/camera/camera2/internal/Camera2DeviceSurfaceManager.java
index 98e8758e7..7c1d95ee9 100644
--- a/camera2/src/main/java/androidx/camera/camera2/internal/Camera2DeviceSurfaceManager.java
+++ b/camera2/src/main/java/androidx/camera/camera2/internal/Camera2DeviceSurfaceManager.java
@@ -17,7 +17,9 @@
package androidx.camera.camera2.internal;
import android.content.Context;
+import android.hardware.camera2.CameraDevice;
import android.media.CamcorderProfile;
+import android.util.Pair;
import android.util.Size;
import androidx.annotation.NonNull;
@@ -29,6 +31,8 @@
import androidx.camera.core.CameraUnavailableException;
import androidx.camera.core.impl.AttachedSurfaceInfo;
import androidx.camera.core.impl.CameraDeviceSurfaceManager;
+import androidx.camera.core.impl.CameraMode;
+import androidx.camera.core.impl.StreamSpec;
import androidx.camera.core.impl.SurfaceConfig;
import androidx.camera.core.impl.UseCaseConfig;
import androidx.core.util.Preconditions;
@@ -42,7 +46,7 @@
* Camera device manager to provide the guaranteed supported stream capabilities related info for
* all camera devices
*
- * {@link android.hardware.camera2.CameraDevice#createCaptureSession} defines the default
+ *
{@link CameraDevice#createCaptureSession} defines the default
* guaranteed stream combinations for different hardware level devices. It defines what combination
* of surface configuration type and size pairs can be supported for different hardware level camera
* devices. This structure is used to store the guaranteed supported stream capabilities related
@@ -57,8 +61,6 @@ public final class Camera2DeviceSurfaceManager implements CameraDeviceSurfaceMan
/**
* Creates a new, initialized Camera2DeviceSurfaceManager.
- *
- * @hide
*/
@RestrictTo(Scope.LIBRARY)
public Camera2DeviceSurfaceManager(@NonNull Context context,
@@ -111,36 +113,10 @@ private void init(@NonNull Context context, @NonNull CameraManagerCompat cameraM
}
}
- /**
- * Check whether the input surface configuration list is under the capability of any combination
- * of this object.
- *
- * @param cameraId the camera id of the camera device to be compared
- * @param surfaceConfigList the surface configuration list to be compared
- * @return the check result that whether it could be supported
- * @throws IllegalStateException if not initialized
- */
- @Override
- public boolean checkSupported(
- @NonNull String cameraId, @Nullable List surfaceConfigList) {
- if (surfaceConfigList == null || surfaceConfigList.isEmpty()) {
- return true;
- }
-
- SupportedSurfaceCombination supportedSurfaceCombination =
- mCameraSupportedSurfaceCombinationMap.get(cameraId);
-
- boolean isSupported = false;
- if (supportedSurfaceCombination != null) {
- isSupported = supportedSurfaceCombination.checkSupported(surfaceConfigList);
- }
-
- return isSupported;
- }
-
/**
* Transform to a SurfaceConfig object with cameraId, image format and size info
*
+ * @param cameraMode the working camera mode.
* @param cameraId the camera id of the camera device to transform the object
* @param imageFormat the image format info for the surface configuration object
* @param size the size info for the surface configuration object
@@ -149,7 +125,10 @@ public boolean checkSupported(
*/
@Nullable
@Override
- public SurfaceConfig transformSurfaceConfig(@NonNull String cameraId, int imageFormat,
+ public SurfaceConfig transformSurfaceConfig(
+ @CameraMode.Mode int cameraMode,
+ @NonNull String cameraId,
+ int imageFormat,
@NonNull Size size) {
SupportedSurfaceCombination supportedSurfaceCombination =
mCameraSupportedSurfaceCombinationMap.get(cameraId);
@@ -157,21 +136,28 @@ public SurfaceConfig transformSurfaceConfig(@NonNull String cameraId, int imageF
SurfaceConfig surfaceConfig = null;
if (supportedSurfaceCombination != null) {
surfaceConfig =
- supportedSurfaceCombination.transformSurfaceConfig(imageFormat, size);
+ supportedSurfaceCombination.transformSurfaceConfig(
+ cameraMode,
+ imageFormat,
+ size);
}
return surfaceConfig;
}
/**
- * Retrieves a map of suggested resolutions for the given list of use cases.
+ * Retrieves a map of suggested stream specifications for the given list of use cases.
*
- * @param cameraId the camera id of the camera device used by the use cases
- * @param existingSurfaces list of surfaces already configured and used by the camera. The
- * resolutions for these surface can not change.
- * @param newUseCaseConfigs list of configurations of the use cases that will be given a
- * suggested resolution
- * @return map of suggested resolutions for given use cases
+ * @param cameraMode the working camera mode.
+ * @param cameraId the camera id of the camera device used by the
+ * use cases
+ * @param existingSurfaces list of surfaces already configured and used by
+ * the camera. The stream specifications for these
+ * surface can not change.
+ * @param newUseCaseConfigsSupportedSizeMap map of configurations of the use cases to the
+ * supported sizes list that will be given a
+ * suggested stream specification
+ * @return map of suggested stream specifications for given use cases
* @throws IllegalStateException if not initialized
* @throws IllegalArgumentException if {@code newUseCaseConfigs} is an empty list, if
* there isn't a supported combination of surfaces
@@ -180,11 +166,14 @@ public SurfaceConfig transformSurfaceConfig(@NonNull String cameraId, int imageF
*/
@NonNull
@Override
- public Map, Size> getSuggestedResolutions(
+ public Pair, StreamSpec>, Map>
+ getSuggestedStreamSpecs(
+ @CameraMode.Mode int cameraMode,
@NonNull String cameraId,
@NonNull List existingSurfaces,
- @NonNull List> newUseCaseConfigs) {
- Preconditions.checkArgument(!newUseCaseConfigs.isEmpty(), "No new use cases to be bound.");
+ @NonNull Map, List> newUseCaseConfigsSupportedSizeMap) {
+ Preconditions.checkArgument(!newUseCaseConfigsSupportedSizeMap.isEmpty(),
+ "No new use cases to be bound.");
SupportedSurfaceCombination supportedSurfaceCombination =
mCameraSupportedSurfaceCombinationMap.get(cameraId);
@@ -194,7 +183,9 @@ public Map, Size> getSuggestedResolutions(
+ cameraId);
}
- return supportedSurfaceCombination.getSuggestedResolutions(existingSurfaces,
- newUseCaseConfigs);
+ return supportedSurfaceCombination.getSuggestedStreamSpecifications(
+ cameraMode,
+ existingSurfaces,
+ newUseCaseConfigsSupportedSizeMap);
}
}
diff --git a/camera2/src/main/java/androidx/camera/camera2/internal/Camera2EncoderProfilesProvider.java b/camera2/src/main/java/androidx/camera/camera2/internal/Camera2EncoderProfilesProvider.java
new file mode 100644
index 000000000..86cb94c76
--- /dev/null
+++ b/camera2/src/main/java/androidx/camera/camera2/internal/Camera2EncoderProfilesProvider.java
@@ -0,0 +1,147 @@
+/*
+ * Copyright 2023 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 androidx.camera.camera2.internal;
+
+import android.media.CamcorderProfile;
+import android.media.EncoderProfiles;
+import android.os.Build;
+
+import androidx.annotation.DoNotInline;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.camera.camera2.internal.compat.quirk.DeviceQuirks;
+import androidx.camera.camera2.internal.compat.quirk.InvalidVideoProfilesQuirk;
+import androidx.camera.core.Logger;
+import androidx.camera.core.impl.EncoderProfilesProvider;
+import androidx.camera.core.impl.EncoderProfilesProxy;
+import androidx.camera.core.impl.compat.EncoderProfilesProxyCompat;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/** An implementation that provides the {@link EncoderProfilesProxy}. */
+@RequiresApi(21) // TODO(b/200306659): Remove and replace with annotation on package-info.java
+public class Camera2EncoderProfilesProvider implements EncoderProfilesProvider {
+
+ private static final String TAG = "Camera2EncoderProfilesProvider";
+
+ private final boolean mHasValidCameraId;
+ private final String mCameraId;
+ private final int mIntCameraId;
+ private final Map mEncoderProfilesCache = new HashMap<>();
+
+ public Camera2EncoderProfilesProvider(@NonNull String cameraId) {
+ mCameraId = cameraId;
+ boolean hasValidCameraId = false;
+ int intCameraId = -1;
+ try {
+ intCameraId = Integer.parseInt(cameraId);
+ hasValidCameraId = true;
+ } catch (NumberFormatException e) {
+ Logger.w(TAG, "Camera id is not an integer: " + cameraId
+ + ", unable to create Camera2EncoderProfilesProvider");
+ }
+ mHasValidCameraId = hasValidCameraId;
+ mIntCameraId = intCameraId;
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public boolean hasProfile(int quality) {
+ if (!mHasValidCameraId) {
+ return false;
+ }
+
+ return CamcorderProfile.hasProfile(mIntCameraId, quality);
+ }
+
+ /** {@inheritDoc} */
+ @Nullable
+ @Override
+ public EncoderProfilesProxy getAll(int quality) {
+ if (!mHasValidCameraId) {
+ return null;
+ }
+
+ if (!CamcorderProfile.hasProfile(mIntCameraId, quality)) {
+ return null;
+ }
+
+ // Cache the value on first query, and reuse the result in subsequent queries.
+ if (mEncoderProfilesCache.containsKey(quality)) {
+ return mEncoderProfilesCache.get(quality);
+ } else {
+ EncoderProfilesProxy profiles = getProfilesInternal(quality);
+ mEncoderProfilesCache.put(quality, profiles);
+ return profiles;
+ }
+ }
+
+ @Nullable
+ private EncoderProfilesProxy getProfilesInternal(int quality) {
+ if (Build.VERSION.SDK_INT >= 31) {
+ EncoderProfiles profiles = Api31Impl.getAll(mCameraId, quality);
+ if (profiles == null) {
+ return null;
+ }
+
+ boolean isVideoProfilesInvalid = DeviceQuirks.get(InvalidVideoProfilesQuirk.class)
+ != null;
+ if (isVideoProfilesInvalid) {
+ Logger.d(TAG, "EncoderProfiles contains invalid video profiles, use "
+ + "CamcorderProfile to create EncoderProfilesProxy.");
+ } else {
+ try {
+ return EncoderProfilesProxyCompat.from(profiles);
+ } catch (NullPointerException e) {
+ Logger.w(TAG, "Failed to create EncoderProfilesProxy, EncoderProfiles might "
+ + " contain invalid video profiles. Use CamcorderProfile instead.", e);
+ }
+ }
+ }
+
+ return createProfilesFromCamcorderProfile(quality);
+ }
+
+ @Nullable
+ @SuppressWarnings("deprecation")
+ private EncoderProfilesProxy createProfilesFromCamcorderProfile(int quality) {
+ CamcorderProfile profile = null;
+ try {
+ profile = CamcorderProfile.get(mIntCameraId, quality);
+ } catch (RuntimeException e) {
+ // CamcorderProfile.get() will throw
+ // - RuntimeException if not able to retrieve camcorder profile params.
+ // - IllegalArgumentException if quality is not valid.
+ Logger.w(TAG, "Unable to get CamcorderProfile by quality: " + quality, e);
+ }
+ return profile != null ? EncoderProfilesProxyCompat.from(profile) : null;
+ }
+
+ @RequiresApi(31)
+ static class Api31Impl {
+ @DoNotInline
+ static EncoderProfiles getAll(String cameraId, int quality) {
+ return CamcorderProfile.getAll(cameraId, quality);
+ }
+
+ // This class is not instantiable.
+ private Api31Impl() {
+ }
+ }
+}
diff --git a/camera2/src/main/java/androidx/camera/camera2/internal/Camera2SessionOptionUnpacker.java b/camera2/src/main/java/androidx/camera/camera2/internal/Camera2SessionOptionUnpacker.java
index 12349deb5..17ca148be 100644
--- a/camera2/src/main/java/androidx/camera/camera2/internal/Camera2SessionOptionUnpacker.java
+++ b/camera2/src/main/java/androidx/camera/camera2/internal/Camera2SessionOptionUnpacker.java
@@ -16,16 +16,20 @@
package androidx.camera.camera2.internal;
+import android.util.Size;
+
import androidx.annotation.NonNull;
import androidx.annotation.OptIn;
import androidx.annotation.RequiresApi;
import androidx.camera.camera2.impl.Camera2ImplConfig;
import androidx.camera.camera2.impl.CameraEventCallbacks;
import androidx.camera.camera2.internal.compat.params.OutputConfigurationCompat;
+import androidx.camera.camera2.internal.compat.workaround.PreviewPixelHDRnet;
import androidx.camera.camera2.interop.ExperimentalCamera2Interop;
import androidx.camera.core.impl.Config;
import androidx.camera.core.impl.MutableOptionsBundle;
import androidx.camera.core.impl.OptionsBundle;
+import androidx.camera.core.impl.PreviewConfig;
import androidx.camera.core.impl.SessionConfig;
import androidx.camera.core.impl.UseCaseConfig;
@@ -40,7 +44,9 @@ final class Camera2SessionOptionUnpacker implements SessionConfig.OptionUnpacker
@OptIn(markerClass = ExperimentalCamera2Interop.class)
@Override
- public void unpack(@NonNull UseCaseConfig config,
+ public void unpack(
+ @NonNull Size resolution,
+ @NonNull UseCaseConfig config,
@NonNull final SessionConfig.Builder builder) {
SessionConfig defaultSessionConfig =
config.getDefaultSessionConfig(/*valueIfMissing=*/ null);
@@ -61,6 +67,11 @@ public void unpack(@NonNull UseCaseConfig config,
// Set the any additional implementation options
builder.setImplementationOptions(implOptions);
+ // Apply quirks
+ if (config instanceof PreviewConfig) {
+ PreviewPixelHDRnet.setHDRnet(resolution, builder);
+ }
+
// Get Camera2 extended options
final Camera2ImplConfig camera2Config = new Camera2ImplConfig(config);
diff --git a/camera2/src/main/java/androidx/camera/camera2/internal/Camera2UseCaseConfigFactory.java b/camera2/src/main/java/androidx/camera/camera2/internal/Camera2UseCaseConfigFactory.java
index 1689d538b..3d271cdd7 100644
--- a/camera2/src/main/java/androidx/camera/camera2/internal/Camera2UseCaseConfigFactory.java
+++ b/camera2/src/main/java/androidx/camera/camera2/internal/Camera2UseCaseConfigFactory.java
@@ -17,6 +17,7 @@
package androidx.camera.camera2.internal;
import static androidx.camera.core.impl.ImageOutputConfig.OPTION_MAX_RESOLUTION;
+import static androidx.camera.core.impl.ImageOutputConfig.OPTION_RESOLUTION_SELECTOR;
import static androidx.camera.core.impl.ImageOutputConfig.OPTION_TARGET_ROTATION;
import static androidx.camera.core.impl.UseCaseConfig.OPTION_CAPTURE_CONFIG_UNPACKER;
import static androidx.camera.core.impl.UseCaseConfig.OPTION_DEFAULT_CAPTURE_CONFIG;
@@ -25,12 +26,10 @@
import static androidx.camera.core.impl.UseCaseConfig.OPTION_ZSL_DISABLED;
import android.content.Context;
-import android.hardware.camera2.CameraDevice;
+import android.util.Size;
import androidx.annotation.NonNull;
import androidx.annotation.RequiresApi;
-import androidx.camera.camera2.internal.compat.workaround.PreviewPixelHDRnet;
-import androidx.camera.core.ImageCapture;
import androidx.camera.core.ImageCapture.CaptureMode;
import androidx.camera.core.impl.CaptureConfig;
import androidx.camera.core.impl.Config;
@@ -38,6 +37,8 @@
import androidx.camera.core.impl.OptionsBundle;
import androidx.camera.core.impl.SessionConfig;
import androidx.camera.core.impl.UseCaseConfigFactory;
+import androidx.camera.core.resolutionselector.ResolutionSelector;
+import androidx.camera.core.resolutionselector.ResolutionStrategy;
/**
* Implementation of UseCaseConfigFactory to provide the default camera2 configurations for use
@@ -63,26 +64,8 @@ public Config getConfig(
final MutableOptionsBundle mutableConfig = MutableOptionsBundle.create();
SessionConfig.Builder sessionBuilder = new SessionConfig.Builder();
- switch (captureType) {
- case IMAGE_CAPTURE:
- sessionBuilder.setTemplateType(
- captureMode == ImageCapture.CAPTURE_MODE_ZERO_SHUTTER_LAG
- ? CameraDevice.TEMPLATE_ZERO_SHUTTER_LAG :
- CameraDevice.TEMPLATE_PREVIEW);
- break;
- case PREVIEW:
- case IMAGE_ANALYSIS:
- sessionBuilder.setTemplateType(CameraDevice.TEMPLATE_PREVIEW);
- break;
- case VIDEO_CAPTURE:
- sessionBuilder.setTemplateType(CameraDevice.TEMPLATE_RECORD);
- break;
- }
-
- if (captureType == CaptureType.PREVIEW) {
- // Set the WYSIWYG preview for CAPTURE_TYPE_PREVIEW
- PreviewPixelHDRnet.setHDRnet(sessionBuilder);
- }
+ sessionBuilder.setTemplateType(
+ TemplateTypeUtil.getSessionConfigTemplateType(captureType, captureMode));
mutableConfig.insertOption(OPTION_DEFAULT_SESSION_CONFIG, sessionBuilder.build());
@@ -90,22 +73,8 @@ public Config getConfig(
Camera2SessionOptionUnpacker.INSTANCE);
CaptureConfig.Builder captureBuilder = new CaptureConfig.Builder();
-
- switch (captureType) {
- case IMAGE_CAPTURE:
- captureBuilder.setTemplateType(
- captureMode == ImageCapture.CAPTURE_MODE_ZERO_SHUTTER_LAG
- ? CameraDevice.TEMPLATE_ZERO_SHUTTER_LAG :
- CameraDevice.TEMPLATE_STILL_CAPTURE);
- break;
- case PREVIEW:
- case IMAGE_ANALYSIS:
- captureBuilder.setTemplateType(CameraDevice.TEMPLATE_PREVIEW);
- break;
- case VIDEO_CAPTURE:
- captureBuilder.setTemplateType(CameraDevice.TEMPLATE_RECORD);
- break;
- }
+ captureBuilder.setTemplateType(
+ TemplateTypeUtil.getCaptureConfigTemplateType(captureType, captureMode));
mutableConfig.insertOption(OPTION_DEFAULT_CAPTURE_CONFIG, captureBuilder.build());
// Only CAPTURE_TYPE_IMAGE_CAPTURE has its own ImageCaptureOptionUnpacker. Other
@@ -115,14 +84,22 @@ public Config getConfig(
: Camera2CaptureOptionUnpacker.INSTANCE);
if (captureType == CaptureType.PREVIEW) {
- mutableConfig.insertOption(OPTION_MAX_RESOLUTION,
- mDisplayInfoManager.getPreviewSize());
+ Size previewSize = mDisplayInfoManager.getPreviewSize();
+ mutableConfig.insertOption(OPTION_MAX_RESOLUTION, previewSize);
+ ResolutionStrategy resolutionStrategy = new ResolutionStrategy(previewSize,
+ ResolutionStrategy.FALLBACK_RULE_CLOSEST_LOWER);
+ mutableConfig.insertOption(OPTION_RESOLUTION_SELECTOR,
+ new ResolutionSelector.Builder().setResolutionStrategy(
+ resolutionStrategy).build());
}
- int targetRotation = mDisplayInfoManager.getMaxSizeDisplay().getRotation();
+ // The default rotation value should be determined by the max non-state-off display.
+ // Calling getMaxSizeDisplay() function with parameter `true` can skips the displays with
+ // off state.
+ int targetRotation = mDisplayInfoManager.getMaxSizeDisplay(true).getRotation();
mutableConfig.insertOption(OPTION_TARGET_ROTATION, targetRotation);
- if (captureType == CaptureType.VIDEO_CAPTURE) {
+ if (captureType == CaptureType.VIDEO_CAPTURE || captureType == CaptureType.STREAM_SHARING) {
mutableConfig.insertOption(OPTION_ZSL_DISABLED, true);
}
diff --git a/camera2/src/main/java/androidx/camera/camera2/internal/CameraStateMachine.java b/camera2/src/main/java/androidx/camera/camera2/internal/CameraStateMachine.java
index 3684bb51b..a6c7b0f4a 100644
--- a/camera2/src/main/java/androidx/camera/camera2/internal/CameraStateMachine.java
+++ b/camera2/src/main/java/androidx/camera/camera2/internal/CameraStateMachine.java
@@ -62,6 +62,7 @@ public void updateState(@NonNull final CameraInternal.State newInternalState,
newPublicState = CameraState.create(CameraState.Type.OPENING, stateError);
break;
case OPEN:
+ case CONFIGURED:
newPublicState = CameraState.create(CameraState.Type.OPEN, stateError);
break;
case CLOSING:
diff --git a/camera2/src/main/java/androidx/camera/camera2/internal/CaptureSession.java b/camera2/src/main/java/androidx/camera/camera2/internal/CaptureSession.java
index d0553ae18..95dda70a1 100644
--- a/camera2/src/main/java/androidx/camera/camera2/internal/CaptureSession.java
+++ b/camera2/src/main/java/androidx/camera/camera2/internal/CaptureSession.java
@@ -22,6 +22,8 @@
import android.hardware.camera2.CameraDevice;
import android.hardware.camera2.CaptureRequest;
import android.hardware.camera2.TotalCaptureResult;
+import android.hardware.camera2.params.DynamicRangeProfiles;
+import android.os.Build;
import android.view.Surface;
import androidx.annotation.GuardedBy;
@@ -31,12 +33,15 @@
import androidx.annotation.RequiresApi;
import androidx.camera.camera2.impl.Camera2ImplConfig;
import androidx.camera.camera2.impl.CameraEventCallbacks;
+import androidx.camera.camera2.internal.compat.params.DynamicRangeConversions;
+import androidx.camera.camera2.internal.compat.params.DynamicRangesCompat;
import androidx.camera.camera2.internal.compat.params.InputConfigurationCompat;
import androidx.camera.camera2.internal.compat.params.OutputConfigurationCompat;
import androidx.camera.camera2.internal.compat.params.SessionConfigurationCompat;
import androidx.camera.camera2.internal.compat.workaround.StillCaptureFlow;
import androidx.camera.camera2.internal.compat.workaround.TorchStateReset;
import androidx.camera.camera2.interop.ExperimentalCamera2Interop;
+import androidx.camera.core.DynamicRange;
import androidx.camera.core.Logger;
import androidx.camera.core.impl.CameraCaptureCallback;
import androidx.camera.core.impl.CaptureConfig;
@@ -129,17 +134,30 @@ public void onCaptureCompleted(
@SuppressWarnings("WeakerAccess") /* synthetic accessor */
@GuardedBy("mSessionLock")
CallbackToFutureAdapter.Completer mReleaseCompleter;
+ @NonNull
+ @GuardedBy("mSessionLock")
+ Map mStreamUseCaseMap = new HashMap<>();
final StillCaptureFlow mStillCaptureFlow = new StillCaptureFlow();
final TorchStateReset mTorchStateReset = new TorchStateReset();
+ private final DynamicRangesCompat mDynamicRangesCompat;
+
/**
* Constructor for CaptureSession.
*/
- CaptureSession() {
+ CaptureSession(@NonNull DynamicRangesCompat dynamicRangesCompat) {
mState = State.INITIALIZED;
+ mDynamicRangesCompat = dynamicRangesCompat;
mCaptureSessionStateCallback = new StateCallback();
}
+ @Override
+ public void setStreamUseCaseMap(@NonNull Map streamUseCaseMap) {
+ synchronized (mSessionLock) {
+ mStreamUseCaseMap = streamUseCaseMap;
+ }
+ }
+
/**
* {@inheritDoc}
*/
@@ -314,11 +332,9 @@ private ListenableFuture openCaptureSession(@NonNull List configu
outputConfig,
mConfiguredSurfaceMap,
physicalCameraIdForAllStreams);
- if (sessionConfig.getImplementationOptions().containsOption(
- Camera2ImplConfig.STREAM_USE_CASE_OPTION)) {
+ if (mStreamUseCaseMap.containsKey(outputConfig.getSurface())) {
outputConfiguration.setStreamUseCase(
- sessionConfig.getImplementationOptions().retrieveOption(
- Camera2ImplConfig.STREAM_USE_CASE_OPTION));
+ mStreamUseCaseMap.get(outputConfig.getSurface()));
}
outputConfigList.add(outputConfiguration);
}
@@ -408,6 +424,27 @@ private OutputConfigurationCompat getOutputConfigurationCompat(
outputConfiguration.addSurface(sharedSurface);
}
}
+
+ long dynamicRangeProfile = DynamicRangeProfiles.STANDARD;
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+ DynamicRangeProfiles dynamicRangeProfiles =
+ mDynamicRangesCompat.toDynamicRangeProfiles();
+ if (dynamicRangeProfiles != null) {
+ DynamicRange requestedDynamicRange = outputConfig.getDynamicRange();
+ Long dynamicRangeProfileOrNull =
+ DynamicRangeConversions.dynamicRangeToFirstSupportedProfile(
+ requestedDynamicRange, dynamicRangeProfiles);
+ if (dynamicRangeProfileOrNull == null) {
+ Logger.e(TAG,
+ "Requested dynamic range is not supported. Defaulting to STANDARD "
+ + "dynamic range profile.\nRequested dynamic range:\n "
+ + requestedDynamicRange);
+ } else {
+ dynamicRangeProfile = dynamicRangeProfileOrNull;
+ }
+ }
+ }
+ outputConfiguration.setDynamicRangeProfile(dynamicRangeProfile);
return outputConfiguration;
}
@@ -609,6 +646,11 @@ int issueRepeatingCaptureRequests(@Nullable SessionConfig sessionConfig) {
return -1;
}
+ if (mState != State.OPENED) {
+ Logger.d(TAG, "Skipping issueRepeatingCaptureRequests due to session closed");
+ return -1;
+ }
+
CaptureConfig captureConfig = sessionConfig.getRepeatingCaptureConfig();
if (captureConfig.getSurfaces().isEmpty()) {
Logger.d(TAG, "Skipping issueRepeatingCaptureRequests for no surface.");
@@ -683,6 +725,10 @@ void issuePendingCaptureRequest() {
@SuppressWarnings("WeakerAccess") /* synthetic accessor */
int issueBurstCaptureRequest(List captureConfigs) {
synchronized (mSessionLock) {
+ if (mState != State.OPENED) {
+ Logger.d(TAG, "Skipping issueBurstCaptureRequest due to session closed");
+ return -1;
+ }
if (captureConfigs.isEmpty()) {
return -1;
}
diff --git a/camera2/src/main/java/androidx/camera/camera2/internal/CaptureSessionInterface.java b/camera2/src/main/java/androidx/camera/camera2/internal/CaptureSessionInterface.java
index 73fbb81ab..351c8f515 100644
--- a/camera2/src/main/java/androidx/camera/camera2/internal/CaptureSessionInterface.java
+++ b/camera2/src/main/java/androidx/camera/camera2/internal/CaptureSessionInterface.java
@@ -24,11 +24,13 @@
import androidx.annotation.Nullable;
import androidx.annotation.RequiresApi;
import androidx.camera.core.impl.CaptureConfig;
+import androidx.camera.core.impl.DeferrableSurface;
import androidx.camera.core.impl.SessionConfig;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.List;
+import java.util.Map;
/**
* An interface for manipulating the session to capture images from the camera which is tied to a
@@ -120,4 +122,13 @@ ListenableFuture open(@NonNull SessionConfig sessionConfig,
*/
@NonNull
ListenableFuture release(boolean abortInFlightCaptures);
+
+ /**
+ * Sets the mapping relations between surfaces and the streamUseCases of their associated
+ * streams
+ *
+ * @param streamUseCaseMap the mapping between surfaces and the streamUseCase flag of the
+ * associated streams
+ */
+ void setStreamUseCaseMap(@NonNull Map streamUseCaseMap);
}
diff --git a/camera2/src/main/java/androidx/camera/camera2/internal/DisplayInfoManager.java b/camera2/src/main/java/androidx/camera/camera2/internal/DisplayInfoManager.java
index 748e0c54d..fdf264a0e 100644
--- a/camera2/src/main/java/androidx/camera/camera2/internal/DisplayInfoManager.java
+++ b/camera2/src/main/java/androidx/camera/camera2/internal/DisplayInfoManager.java
@@ -23,9 +23,12 @@
import android.view.Display;
import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
import androidx.annotation.RequiresApi;
import androidx.annotation.VisibleForTesting;
+import androidx.camera.camera2.internal.compat.workaround.DisplaySizeCorrector;
import androidx.camera.camera2.internal.compat.workaround.MaxPreviewSize;
+import androidx.camera.core.internal.utils.SizeUtil;
/**
* A singleton class to retrieve display related information.
@@ -33,12 +36,22 @@
@RequiresApi(21) // TODO(b/200306659): Remove and replace with annotation on package-info.java
public class DisplayInfoManager {
private static final Size MAX_PREVIEW_SIZE = new Size(1920, 1080);
+ /**
+ * This is the smallest size from a device which had issue reported to CameraX.
+ */
+ private static final Size ABNORMAL_DISPLAY_SIZE_THRESHOLD = new Size(320, 240);
+ /**
+ * The fallback display size for the case that the retrieved display size is abnormally small
+ * and no correct display size can be retrieved from DisplaySizeCorrector.
+ */
+ private static final Size FALLBACK_DISPLAY_SIZE = new Size(640, 480);
private static final Object INSTANCE_LOCK = new Object();
private static volatile DisplayInfoManager sInstance;
@NonNull
private final DisplayManager mDisplayManager;
private volatile Size mPreviewSize = null;
private final MaxPreviewSize mMaxPreviewSize = new MaxPreviewSize();
+ private final DisplaySizeCorrector mDisplaySizeCorrector = new DisplaySizeCorrector();
private DisplayInfoManager(@NonNull Context context) {
mDisplayManager = (DisplayManager) context.getSystemService(Context.DISPLAY_SERVICE);
@@ -76,32 +89,55 @@ void refresh() {
/**
* Retrieves the display which has the max size among all displays.
+ *
+ * @param skipStateOffDisplay true to skip the displays with off state
*/
- @SuppressWarnings("deprecation") /* getRealSize */
@NonNull
- public Display getMaxSizeDisplay() {
+ public Display getMaxSizeDisplay(boolean skipStateOffDisplay) {
Display[] displays = mDisplayManager.getDisplays();
if (displays.length == 1) {
return displays[0];
}
- Display maxDisplay = null;
- int maxDisplaySize = -1;
- for (Display display : displays) {
- if (display.getState() != Display.STATE_OFF) {
- Point displaySize = new Point();
- display.getRealSize(displaySize);
- if (displaySize.x * displaySize.y > maxDisplaySize) {
- maxDisplaySize = displaySize.x * displaySize.y;
- maxDisplay = display;
- }
- }
+ // Try to find the max size display according to the skipStateOffDisplay parameter
+ Display maxDisplay = getMaxSizeDisplayInternal(displays, skipStateOffDisplay);
+
+ // Try to find the max size display from all displays again if no display can be found
+ // when only checking the non-state-off displays.
+ if (maxDisplay == null && skipStateOffDisplay) {
+ maxDisplay = getMaxSizeDisplayInternal(displays, false);
}
+ // If still no display found, throw IllegalArgumentException.
if (maxDisplay == null) {
throw new IllegalArgumentException("No display can be found from the input display "
+ "manager!");
}
+
+ return maxDisplay;
+ }
+
+ @Nullable
+ @SuppressWarnings("deprecation") /* getRealSize */
+ private Display getMaxSizeDisplayInternal(@NonNull Display[] displays,
+ boolean skipStateOffDisplay) {
+ Display maxDisplay = null;
+ int maxDisplaySize = -1;
+
+ for (Display display : displays) {
+ // Skips displays with state off if the input skipStateOffDisplay parameter is true
+ if (skipStateOffDisplay && display.getState() == Display.STATE_OFF) {
+ continue;
+ }
+
+ Point displaySize = new Point();
+ display.getRealSize(displaySize);
+ if (displaySize.x * displaySize.y > maxDisplaySize) {
+ maxDisplaySize = displaySize.x * displaySize.y;
+ maxDisplay = display;
+ }
+ }
+
return maxDisplay;
}
@@ -120,22 +156,46 @@ Size getPreviewSize() {
return mPreviewSize;
}
- @SuppressWarnings("deprecation") /* getRealSize */
private Size calculatePreviewSize() {
- Point displaySize = new Point();
- Display display = getMaxSizeDisplay();
- display.getRealSize(displaySize);
- Size displayViewSize;
- if (displaySize.x > displaySize.y) {
- displayViewSize = new Size(displaySize.x, displaySize.y);
- } else {
- displayViewSize = new Size(displaySize.y, displaySize.x);
- }
-
+ Size displayViewSize = getCorrectedDisplaySize();
if (displayViewSize.getWidth() * displayViewSize.getHeight()
> MAX_PREVIEW_SIZE.getWidth() * MAX_PREVIEW_SIZE.getHeight()) {
displayViewSize = MAX_PREVIEW_SIZE;
}
return mMaxPreviewSize.getMaxPreviewResolution(displayViewSize);
}
+
+ @NonNull
+ @SuppressWarnings("deprecation") /* getRealSize */
+ private Size getCorrectedDisplaySize() {
+ Point displaySize = new Point();
+ // The PREVIEW size should be determined by the max display size among all displays on
+ // the device no matter its state is on or off. The PREVIEW size is used for the
+ // guaranteed configurations tables which are related to the camera's capability. The
+ // PREVIEW size should not be affected by the display state.
+ Display display = getMaxSizeDisplay(false);
+ display.getRealSize(displaySize);
+ Size displayViewSize = new Size(displaySize.x, displaySize.y);
+
+ // Checks whether the display size is abnormally small.
+ if (SizeUtil.isSmallerByArea(displayViewSize, ABNORMAL_DISPLAY_SIZE_THRESHOLD)) {
+ // Gets the display size from DisplaySizeCorrector if the display size retrieved from
+ // DisplayManager is abnormally small.
+ displayViewSize = mDisplaySizeCorrector.getDisplaySize();
+
+ // Falls back the display size to 640x480 if DisplaySizeCorrector doesn't contain the
+ // device's display size info.
+ if (displayViewSize == null) {
+ displayViewSize = FALLBACK_DISPLAY_SIZE;
+ }
+ }
+
+ // Flips the size to landscape orientation
+ if (displayViewSize.getHeight() > displayViewSize.getWidth()) {
+ displayViewSize = new Size(/* width= */ displayViewSize.getHeight(), /* height=
+ */ displayViewSize.getWidth());
+ }
+
+ return displayViewSize;
+ }
}
diff --git a/camera2/src/main/java/androidx/camera/camera2/internal/DynamicRangeResolver.java b/camera2/src/main/java/androidx/camera/camera2/internal/DynamicRangeResolver.java
new file mode 100644
index 000000000..2a564b65b
--- /dev/null
+++ b/camera2/src/main/java/androidx/camera/camera2/internal/DynamicRangeResolver.java
@@ -0,0 +1,495 @@
+/*
+ * Copyright 2023 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 androidx.camera.camera2.internal;
+
+import static android.hardware.camera2.CameraCharacteristics.REQUEST_RECOMMENDED_TEN_BIT_DYNAMIC_RANGE_PROFILE;
+
+import static androidx.camera.core.DynamicRange.BIT_DEPTH_UNSPECIFIED;
+import static androidx.camera.core.DynamicRange.ENCODING_HDR_UNSPECIFIED;
+import static androidx.camera.core.DynamicRange.ENCODING_SDR;
+import static androidx.camera.core.DynamicRange.ENCODING_UNSPECIFIED;
+
+import android.hardware.camera2.CameraCharacteristics;
+import android.os.Build;
+import android.text.TextUtils;
+
+import androidx.annotation.DoNotInline;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.camera.camera2.internal.compat.CameraCharacteristicsCompat;
+import androidx.camera.camera2.internal.compat.params.DynamicRangeConversions;
+import androidx.camera.camera2.internal.compat.params.DynamicRangesCompat;
+import androidx.camera.core.DynamicRange;
+import androidx.camera.core.Logger;
+import androidx.camera.core.impl.AttachedSurfaceInfo;
+import androidx.camera.core.impl.UseCaseConfig;
+import androidx.core.util.Preconditions;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+/**
+ * Resolves and validates dynamic ranges based on device capabilities and constraints.
+ */
+@RequiresApi(21) // TODO(b/200306659): Remove and replace with annotation on package-info.java
+final class DynamicRangeResolver {
+ private static final String TAG = "DynamicRangeResolver";
+ private final CameraCharacteristicsCompat mCharacteristics;
+ private final DynamicRangesCompat mDynamicRangesInfo;
+ private final boolean mIs10BitSupported;
+
+ DynamicRangeResolver(@NonNull CameraCharacteristicsCompat characteristics) {
+ mCharacteristics = characteristics;
+ mDynamicRangesInfo = DynamicRangesCompat.fromCameraCharacteristics(characteristics);
+
+ int[] availableCapabilities =
+ mCharacteristics.get(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES);
+ boolean is10BitSupported = false;
+ if (availableCapabilities != null) {
+ for (int capability : availableCapabilities) {
+ if (capability == CameraCharacteristics
+ .REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT) {
+ is10BitSupported = true;
+ break;
+ }
+ }
+ }
+ mIs10BitSupported = is10BitSupported;
+ }
+
+ /**
+ * Returns whether 10-bit dynamic ranges are supported on this device.
+ */
+ boolean is10BitDynamicRangeSupported() {
+ return mIs10BitSupported;
+ }
+
+ /**
+ * Returns a set of supported dynamic ranges for the dynamic ranges requested by the list of
+ * attached and new use cases.
+ *
+ * If a new use case requests a dynamic range that isn't supported, an
+ * IllegalArgumentException will be thrown.
+ */
+ Map, DynamicRange> resolveAndValidateDynamicRanges(
+ @NonNull List existingSurfaces,
+ @NonNull List> newUseCaseConfigs,
+ @NonNull List useCasePriorityOrder) {
+ // Create an ordered set of already-attached surface's dynamic ranges. These are assumed
+ // to be valid since they are already attached.
+ Set orderedExistingDynamicRanges = new LinkedHashSet<>();
+ for (AttachedSurfaceInfo asi : existingSurfaces) {
+ orderedExistingDynamicRanges.add(asi.getDynamicRange());
+ }
+
+ // Get the supported dynamic ranges from the device
+ Set supportedDynamicRanges = mDynamicRangesInfo.getSupportedDynamicRanges();
+
+ // Collect initial dynamic range constraints. This set will potentially shrink as we add
+ // more dynamic ranges. We start with the initial set of supported dynamic ranges to
+ // denote no constraints.
+ Set combinedConstraints = new HashSet<>(supportedDynamicRanges);
+ for (DynamicRange dynamicRange : orderedExistingDynamicRanges) {
+ updateConstraints(combinedConstraints, dynamicRange, mDynamicRangesInfo);
+ }
+
+ // We want to resolve and validate dynamic ranges in the following order:
+ // 1. First validate fully defined dynamic ranges. No resolving is required here.
+ // 2. Resolve and validate partially defined dynamic ranges, such as HDR_UNSPECIFIED or
+ // dynamic ranges with concrete encodings but BIT_DEPTH_UNSPECIFIED. We can now potentially
+ // infer a dynamic range based on constraints of the fully defined dynamic ranges or
+ // the list of supported HDR dynamic ranges.
+ // 3. Finally, resolve and validate UNSPECIFIED dynamic ranges. These will resolve
+ // to dynamic ranges from the first 2 groups, or fall back to SDR if no other dynamic
+ // ranges are defined.
+ //
+ // To accomplish this, we need to partition the use cases into 3 categories.
+ List> orderedFullyDefinedUseCaseConfigs = new ArrayList<>();
+ List> orderedPartiallyDefinedUseCaseConfigs = new ArrayList<>();
+ List> orderedUndefinedUseCaseConfigs = new ArrayList<>();
+ for (int priorityIdx : useCasePriorityOrder) {
+ UseCaseConfig config = newUseCaseConfigs.get(priorityIdx);
+ DynamicRange requestedDynamicRange = config.getDynamicRange();
+ if (isFullyUnspecified(requestedDynamicRange)) {
+ orderedUndefinedUseCaseConfigs.add(config);
+ } else if (isPartiallySpecified(requestedDynamicRange)) {
+ orderedPartiallyDefinedUseCaseConfigs.add(config);
+ } else {
+ orderedFullyDefinedUseCaseConfigs.add(config);
+ }
+ }
+
+ Map, DynamicRange> resolvedDynamicRanges = new HashMap<>();
+ // Keep track of new dynamic ranges for more fine-grained error messages in exceptions.
+ // This allows us to differentiate between dynamic ranges from already-attached use cases
+ // and requested dynamic ranges from newly added use cases.
+ Set orderedNewDynamicRanges = new LinkedHashSet<>();
+ // Now resolve and validate all of the dynamic ranges in order of the 3 partitions form
+ // above.
+ List> orderedUseCaseConfigs = new ArrayList<>();
+ orderedUseCaseConfigs.addAll(orderedFullyDefinedUseCaseConfigs);
+ orderedUseCaseConfigs.addAll(orderedPartiallyDefinedUseCaseConfigs);
+ orderedUseCaseConfigs.addAll(orderedUndefinedUseCaseConfigs);
+ for (UseCaseConfig config : orderedUseCaseConfigs) {
+ DynamicRange resolvedDynamicRange = resolveDynamicRangeAndUpdateConstraints(
+ supportedDynamicRanges, orderedExistingDynamicRanges,
+ orderedNewDynamicRanges, config, combinedConstraints);
+ resolvedDynamicRanges.put(config, resolvedDynamicRange);
+ if (!orderedExistingDynamicRanges.contains(resolvedDynamicRange)) {
+ orderedNewDynamicRanges.add(resolvedDynamicRange);
+ }
+ }
+
+ return resolvedDynamicRanges;
+ }
+
+ private DynamicRange resolveDynamicRangeAndUpdateConstraints(
+ @NonNull Set supportedDynamicRanges,
+ @NonNull Set orderedExistingDynamicRanges,
+ @NonNull Set orderedNewDynamicRanges,
+ @NonNull UseCaseConfig config,
+ @NonNull Set outCombinedConstraints) {
+ DynamicRange requestedDynamicRange = config.getDynamicRange();
+ DynamicRange resolvedDynamicRange = resolveDynamicRange(requestedDynamicRange,
+ outCombinedConstraints, orderedExistingDynamicRanges, orderedNewDynamicRanges,
+ config.getTargetName());
+
+ if (resolvedDynamicRange != null) {
+ updateConstraints(outCombinedConstraints, resolvedDynamicRange, mDynamicRangesInfo);
+ } else {
+ throw new IllegalArgumentException(String.format("Unable to resolve supported "
+ + "dynamic range. The dynamic range may not be supported on the device "
+ + "or may not be allowed concurrently with other attached use cases.\n"
+ + "Use case:\n"
+ + " %s\n"
+ + "Requested dynamic range:\n"
+ + " %s\n"
+ + "Supported dynamic ranges:\n"
+ + " %s\n"
+ + "Constrained set of concurrent dynamic ranges:\n"
+ + " %s",
+ config.getTargetName(), requestedDynamicRange,
+ TextUtils.join("\n ", supportedDynamicRanges),
+ TextUtils.join("\n ", outCombinedConstraints)));
+ }
+
+ return resolvedDynamicRange;
+
+ }
+
+ /**
+ * Resolves the requested dynamic range into a fully specified dynamic range.
+ *
+ * This uses existing fully-specified dynamic ranges, new fully-specified dynamic ranges,
+ * dynamic range constraints and the list of supported dynamic ranges to exhaustively search
+ * for a dynamic range if the requested dynamic range is not fully specified, i.e., it has an
+ * UNSPECIFIED encoding or UNSPECIFIED bitrate.
+ *
+ *
Any dynamic range returned will be validated to work according to the constraints and
+ * supported dynamic ranges provided.
+ *
+ *
If no suitable dynamic range can be found, returns {@code null}.
+ */
+ @Nullable
+ private DynamicRange resolveDynamicRange(
+ @NonNull DynamicRange requestedDynamicRange,
+ @NonNull Set combinedConstraints,
+ @NonNull Set orderedExistingDynamicRanges,
+ @NonNull Set orderedNewDynamicRanges,
+ @NonNull String rangeOwnerLabel) {
+
+ // Dynamic range is already resolved if it is fully specified.
+ if (requestedDynamicRange.isFullySpecified()) {
+ if (combinedConstraints.contains(requestedDynamicRange)) {
+ return requestedDynamicRange;
+ }
+ // Requested dynamic range is full specified but unsupported. No need to continue
+ // trying to resolve.
+ return null;
+ }
+
+ // Explicitly handle the case of SDR with unspecified bit depth.
+ // SDR is only supported as 8-bit.
+ int requestedEncoding = requestedDynamicRange.getEncoding();
+ int requestedBitDepth = requestedDynamicRange.getBitDepth();
+ if (requestedEncoding == ENCODING_SDR && requestedBitDepth == BIT_DEPTH_UNSPECIFIED) {
+ if (combinedConstraints.contains(DynamicRange.SDR)) {
+ return DynamicRange.SDR;
+ }
+ // If SDR isn't supported, we can't resolve to any other dynamic range.
+ return null;
+ }
+
+ // First attempt to find another fully specified HDR dynamic range to resolve to from
+ // existing dynamic ranges
+ DynamicRange resolvedDynamicRange = findSupportedHdrMatch(requestedDynamicRange,
+ orderedExistingDynamicRanges, combinedConstraints);
+ if (resolvedDynamicRange != null) {
+ Logger.d(TAG, String.format("Resolved dynamic range for use case %s from existing "
+ + "attached surface.\n%s\n->\n%s",
+ rangeOwnerLabel, requestedDynamicRange, resolvedDynamicRange));
+ return resolvedDynamicRange;
+ }
+
+ // Attempt to find another fully specified HDR dynamic range to resolve to from
+ // new dynamic ranges
+ resolvedDynamicRange = findSupportedHdrMatch(requestedDynamicRange,
+ orderedNewDynamicRanges, combinedConstraints);
+ if (resolvedDynamicRange != null) {
+ Logger.d(TAG, String.format("Resolved dynamic range for use case %s from "
+ + "concurrently bound use case.\n%s\n->\n%s",
+ rangeOwnerLabel, requestedDynamicRange, resolvedDynamicRange));
+ return resolvedDynamicRange;
+ }
+
+ // Now that we have checked existing HDR dynamic ranges, we must resolve fully unspecified
+ // and unspecified 8-bit dynamic ranges to SDR if it is supported. This ensures the
+ // default behavior for most use cases is to choose SDR when an HDR dynamic range isn't
+ // already present or explicitly requested.
+ if (canResolveWithinConstraints(requestedDynamicRange, DynamicRange.SDR,
+ combinedConstraints)) {
+ Logger.d(TAG, String.format(
+ "Resolved dynamic range for use case %s to no "
+ + "compatible HDR dynamic ranges.\n%s\n->\n%s",
+ rangeOwnerLabel, requestedDynamicRange, DynamicRange.SDR));
+ return DynamicRange.SDR;
+ }
+
+ // For unspecified HDR encodings (10-bit or unspecified bit depth), we have a
+ // couple options: the device recommended 10-bit encoding or the mandated HLG encoding.
+ if (requestedEncoding == ENCODING_HDR_UNSPECIFIED && (
+ requestedBitDepth == DynamicRange.BIT_DEPTH_10_BIT
+ || requestedBitDepth == BIT_DEPTH_UNSPECIFIED)) {
+ Set hdrDefaultRanges = new LinkedHashSet<>();
+
+ // Attempt to use the recommended 10-bit dynamic range
+ DynamicRange recommendedRange = null;
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+ recommendedRange = Api33Impl.getRecommended10BitDynamicRange(mCharacteristics);
+ if (recommendedRange != null) {
+ hdrDefaultRanges.add(recommendedRange);
+ }
+ }
+ // Attempt to fall back to HLG since it is a mandated required 10-bit
+ // dynamic range.
+ hdrDefaultRanges.add(DynamicRange.HLG_10_BIT);
+ resolvedDynamicRange = findSupportedHdrMatch(requestedDynamicRange,
+ hdrDefaultRanges, combinedConstraints);
+ if (resolvedDynamicRange != null) {
+ Logger.d(TAG, String.format(
+ "Resolved dynamic range for use case %s from %s "
+ + "10-bit supported dynamic range.\n%s\n->\n%s",
+ rangeOwnerLabel,
+ Objects.equals(resolvedDynamicRange, recommendedRange) ? "recommended"
+ : "required",
+ requestedDynamicRange, resolvedDynamicRange));
+ return resolvedDynamicRange;
+ }
+ }
+
+ // Finally, attempt to find an HDR dynamic range for HDR or 10-bit dynamic ranges from
+ // the constraints of the other validated dynamic ranges. If there are no other dynamic
+ // ranges, this should be the full list of supported dynamic ranges.
+ // The constraints are unordered, so it may not produce an "optimal" dynamic range. This
+ // works for 8-bit, 10-bit or partially specified HDR dynamic ranges.
+ for (DynamicRange candidateRange : combinedConstraints) {
+ Preconditions.checkState(candidateRange.isFullySpecified(), "Candidate dynamic"
+ + " range must be fully specified.");
+
+ // Only consider HDR constraints
+ if (candidateRange.equals(DynamicRange.SDR)) {
+ continue;
+ }
+
+ if (canResolve(requestedDynamicRange, candidateRange)) {
+ Logger.d(TAG, String.format(
+ "Resolved dynamic range for use case %s from validated "
+ + "dynamic range constraints or supported HDR dynamic "
+ + "ranges.\n%s\n->\n%s",
+ rangeOwnerLabel, requestedDynamicRange, candidateRange));
+ return candidateRange;
+ }
+ }
+
+ // Unable to resolve dynamic range
+ return null;
+ }
+
+ /**
+ * Updates the provided dynamic range constraints by combining them with the new constraints
+ * from the new dynamic range.
+ *
+ * @param combinedConstraints The constraints that will be updated. This set must not be empty.
+ * @param newDynamicRange The new dynamic range for which we'll apply new constraints
+ * @param dynamicRangesInfo Information about dynamic ranges to retrieve new constraints.
+ */
+ private static void updateConstraints(
+ @NonNull Set combinedConstraints,
+ @NonNull DynamicRange newDynamicRange,
+ @NonNull DynamicRangesCompat dynamicRangesInfo) {
+ Preconditions.checkState(!combinedConstraints.isEmpty(), "Cannot update already-empty "
+ + "constraints.");
+ Set newConstraints =
+ dynamicRangesInfo.getDynamicRangeCaptureRequestConstraints(newDynamicRange);
+ if (!newConstraints.isEmpty()) {
+ // Retain for potential exception message
+ Set previousConstraints = new HashSet<>(combinedConstraints);
+ // Take the intersection of constraints
+ combinedConstraints.retainAll(newConstraints);
+ if (combinedConstraints.isEmpty()) {
+ // This shouldn't happen if we're diligent about checking that dynamic range
+ // is within the existing constraints before attempting to call
+ // updateConstraints. If it happens, then the dynamic ranges are not mutually
+ // compatible.
+ throw new IllegalArgumentException(String.format("Constraints of dynamic "
+ + "range cannot be combined with existing constraints.\n"
+ + "Dynamic range:\n"
+ + " %s\n"
+ + "Constraints:\n"
+ + " %s\n"
+ + "Existing constraints:\n"
+ + " %s",
+ newDynamicRange, TextUtils.join("\n ", newConstraints),
+ TextUtils.join("\n ", previousConstraints)));
+ }
+ }
+ }
+
+ @Nullable
+ private static DynamicRange findSupportedHdrMatch(@NonNull DynamicRange rangeToMatch,
+ @NonNull Collection fullySpecifiedCandidateRanges,
+ @NonNull Set constraints) {
+ // SDR can never match with HDR
+ if (rangeToMatch.getEncoding() == ENCODING_SDR) {
+ return null;
+ }
+
+ for (DynamicRange candidateRange : fullySpecifiedCandidateRanges) {
+ Preconditions.checkNotNull(candidateRange,
+ "Fully specified DynamicRange cannot be null.");
+ int candidateEncoding = candidateRange.getEncoding();
+ Preconditions.checkState(candidateRange.isFullySpecified(),
+ "Fully specified DynamicRange must have fully defined encoding.");
+ if (candidateEncoding == ENCODING_SDR) {
+ // Only consider HDR encodings
+ continue;
+ }
+
+ if (canResolveWithinConstraints(rangeToMatch, candidateRange, constraints)) {
+ return candidateRange;
+ }
+ }
+ return null;
+ }
+
+ @RequiresApi(33)
+ static final class Api33Impl {
+ private Api33Impl() {
+ // This class is not instantiable.
+ }
+
+ @DoNotInline
+ @Nullable
+ static DynamicRange getRecommended10BitDynamicRange(
+ @NonNull CameraCharacteristicsCompat characteristics) {
+ Long recommendedProfile =
+ characteristics.get(REQUEST_RECOMMENDED_TEN_BIT_DYNAMIC_RANGE_PROFILE);
+ if (recommendedProfile != null) {
+ return DynamicRangeConversions.profileToDynamicRange(recommendedProfile);
+ }
+ return null;
+ }
+ }
+
+ /**
+ * Returns {@code true} if the dynamic range is ENCODING_UNSPECIFIED and BIT_DEPTH_UNSPECIFIED.
+ */
+ private static boolean isFullyUnspecified(@NonNull DynamicRange dynamicRange) {
+ return Objects.equals(dynamicRange, DynamicRange.UNSPECIFIED);
+ }
+
+ /**
+ * Returns {@code true} if the dynamic range has an unspecified HDR encoding, a concrete
+ * encoding with unspecified bit depth, or a concrete bit depth.
+ */
+ private static boolean isPartiallySpecified(@NonNull DynamicRange dynamicRange) {
+ return dynamicRange.getEncoding() == ENCODING_HDR_UNSPECIFIED || (
+ dynamicRange.getEncoding() != ENCODING_UNSPECIFIED
+ && dynamicRange.getBitDepth() == BIT_DEPTH_UNSPECIFIED) || (
+ dynamicRange.getEncoding() == ENCODING_UNSPECIFIED
+ && dynamicRange.getBitDepth() != BIT_DEPTH_UNSPECIFIED);
+ }
+
+ /**
+ * Returns {@code true} if the test dynamic range can resolve to the candidate, fully specified
+ * dynamic range, taking into account constraints.
+ *
+ * A range can resolve if test fields are unspecified and appropriately match the fields
+ * of the fully specified dynamic range, or the test fields exactly match the fields of
+ * the fully specified dynamic range.
+ */
+ private static boolean canResolveWithinConstraints(@NonNull DynamicRange rangeToResolve,
+ @NonNull DynamicRange candidateRange,
+ @NonNull Set constraints) {
+ if (!constraints.contains(candidateRange)) {
+ Logger.d(TAG, String.format("Candidate Dynamic range is not within constraints.\n"
+ + "Dynamic range to resolve:\n"
+ + " %s\n"
+ + "Candidate dynamic range:\n"
+ + " %s",
+ rangeToResolve, candidateRange));
+ return false;
+ }
+
+ return canResolve(rangeToResolve, candidateRange);
+ }
+
+ /**
+ * Returns {@code true} if the test dynamic range can resolve to the fully specified dynamic
+ * range.
+ *
+ * A range can resolve if test fields are unspecified and appropriately match the fields
+ * of the fully specified dynamic range, or the test fields exactly match the fields of
+ * the fully specified dynamic range.
+ */
+ private static boolean canResolve(@NonNull DynamicRange testRange,
+ @NonNull DynamicRange fullySpecifiedRange) {
+ Preconditions.checkState(fullySpecifiedRange.isFullySpecified(), "Fully specified range is"
+ + " not actually fully specified.");
+ if (testRange.getEncoding() == ENCODING_HDR_UNSPECIFIED
+ && fullySpecifiedRange.getEncoding() == ENCODING_SDR) {
+ return false;
+ }
+
+ if (testRange.getEncoding() != ENCODING_HDR_UNSPECIFIED
+ && testRange.getEncoding() != ENCODING_UNSPECIFIED
+ && testRange.getEncoding() != fullySpecifiedRange.getEncoding()) {
+ return false;
+ }
+
+ return testRange.getBitDepth() == BIT_DEPTH_UNSPECIFIED
+ || testRange.getBitDepth() == fullySpecifiedRange.getBitDepth();
+ }
+}
diff --git a/camera2/src/main/java/androidx/camera/camera2/internal/FovUtil.java b/camera2/src/main/java/androidx/camera/camera2/internal/FovUtil.java
new file mode 100644
index 000000000..8aa9e6c5e
--- /dev/null
+++ b/camera2/src/main/java/androidx/camera/camera2/internal/FovUtil.java
@@ -0,0 +1,152 @@
+/*
+ * Copyright 2022 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 androidx.camera.camera2.internal;
+
+import android.graphics.Rect;
+import android.hardware.camera2.CameraCharacteristics;
+import android.util.Size;
+import android.util.SizeF;
+
+import androidx.annotation.IntRange;
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+import androidx.camera.camera2.internal.compat.CameraAccessExceptionCompat;
+import androidx.camera.camera2.internal.compat.CameraCharacteristicsCompat;
+import androidx.camera.camera2.internal.compat.CameraManagerCompat;
+import androidx.camera.core.CameraSelector;
+import androidx.camera.core.impl.utils.TransformUtils;
+import androidx.core.util.Preconditions;
+
+/**
+ * Contains utility methods related to view angle transformation.
+ */
+@RequiresApi(21) // TODO(b/200306659): Remove and replace with annotation on package-info.java
+public class FovUtil {
+
+ private static final String TAG = "FovUtil";
+
+ // Do not allow instantiation.
+ private FovUtil() {
+ }
+
+ /**
+ * Calculates view angle by focal length and sensor length.
+ *
+ *
The returned view angle is inexact and might not be hundred percent accurate comparing
+ * to the output image.
+ *
+ *
The returned view angle should between 0 and 360.
+ */
+ @IntRange(from = 0, to = 360)
+ public static int focalLengthToViewAngleDegrees(float focalLength, float sensorLength) {
+ Preconditions.checkArgument(focalLength > 0, "Focal length should be positive.");
+ Preconditions.checkArgument(sensorLength > 0, "Sensor length should be positive.");
+
+ int viewAngleDegrees = (int) Math.toDegrees(
+ 2 * Math.atan(sensorLength / (2 * focalLength)));
+ Preconditions.checkArgumentInRange(viewAngleDegrees, 0, 360, "The provided focal length "
+ + "and sensor length result in an invalid view angle degrees.");
+
+ return viewAngleDegrees;
+ }
+
+ /**
+ * Gets the angle of view of the default camera on the device.
+ *
+ *
The default cameras is the camera selected by
+ * {@link CameraSelector#DEFAULT_FRONT_CAMERA} or {@link CameraSelector#DEFAULT_BACK_CAMERA}
+ * depending on the specified lens facing.
+ */
+ public static int getDeviceDefaultViewAngleDegrees(@NonNull CameraManagerCompat cameraManager,
+ @CameraSelector.LensFacing int lensFacing) {
+ try {
+ String[] cameraIds = cameraManager.getCameraIdList();
+ for (String cameraId : cameraIds) {
+ CameraCharacteristicsCompat cameraCharacteristics =
+ cameraManager.getCameraCharacteristicsCompat(cameraId);
+ Integer cameraCharacteristicsLensFacing =
+ cameraCharacteristics.get(CameraCharacteristics.LENS_FACING);
+ Preconditions.checkNotNull(cameraCharacteristicsLensFacing,
+ "Lens facing can not be null");
+ if (cameraCharacteristicsLensFacing == LensFacingUtil.getLensFacingInt(
+ lensFacing)) {
+ return focalLengthToViewAngleDegrees(
+ getDefaultFocalLength(cameraCharacteristics),
+ getSensorHorizontalLength(cameraCharacteristics));
+ }
+ }
+ } catch (CameraAccessExceptionCompat e) {
+ throw new IllegalArgumentException("Unable to get the default focal length.");
+ }
+
+ throw new IllegalArgumentException("Unable to get the default focal length with the "
+ + "specified lens facing.");
+ }
+
+ /**
+ * Gets the length of the horizontal side of the sensor.
+ *
+ *
The horizontal side is the width of the sensor size after rotated by the sensor
+ * orientation.
+ */
+ public static float getSensorHorizontalLength(
+ @NonNull CameraCharacteristicsCompat cameraCharacteristics) {
+ SizeF sensorSize =
+ cameraCharacteristics.get(
+ CameraCharacteristics.SENSOR_INFO_PHYSICAL_SIZE);
+ final Rect activeArrayRect =
+ cameraCharacteristics.get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE);
+ Size pixelArraySize = cameraCharacteristics.get(
+ CameraCharacteristics.SENSOR_INFO_PIXEL_ARRAY_SIZE);
+ final Integer sensorOrientation =
+ cameraCharacteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);
+ Preconditions.checkNotNull(sensorSize, "The sensor size can't be null.");
+ Preconditions.checkNotNull(sensorOrientation, "The sensor orientation can't be "
+ + "null.");
+ Preconditions.checkNotNull(activeArrayRect, "The active array size can't be null.");
+ Preconditions.checkNotNull(pixelArraySize, "The pixel array size can't be null.");
+
+ Size activeArraySize = TransformUtils.rectToSize(activeArrayRect);
+ if (TransformUtils.is90or270(sensorOrientation)) {
+ sensorSize = TransformUtils.reverseSizeF(sensorSize);
+ activeArraySize = TransformUtils.reverseSize(activeArraySize);
+ pixelArraySize = TransformUtils.reverseSize(pixelArraySize);
+ }
+
+ return sensorSize.getWidth() * activeArraySize.getWidth() / pixelArraySize.getWidth();
+ }
+
+ /**
+ * Gets the default focal length from a {@link CameraCharacteristics}.
+ *
+ *
If the camera is a logical camera that consists of multiple physical cameras, the
+ * default focal length is the focal length of the physical camera that produces image at
+ * zoom ratio {@code 1.0}.
+ */
+ public static float getDefaultFocalLength(
+ @NonNull CameraCharacteristicsCompat cameraCharacteristics) {
+ final float[] focalLengths =
+ cameraCharacteristics.get(CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS);
+ Preconditions.checkNotNull(focalLengths, "The focal lengths can not be empty.");
+
+ // Assume the first focal length is the default focal length. This will not be true if the
+ // camera is a logical camera consist of multiple physical cameras and reports multiple
+ // focal lengths. However for this kind of cameras, it's suggested to use zoom ratio to
+ // do optical zoom.
+ return focalLengths[0];
+ }
+}
diff --git a/camera2/src/main/java/androidx/camera/camera2/internal/GuaranteedConfigurationsUtil.java b/camera2/src/main/java/androidx/camera/camera2/internal/GuaranteedConfigurationsUtil.java
index 00106c1ec..d18bd1b04 100644
--- a/camera2/src/main/java/androidx/camera/camera2/internal/GuaranteedConfigurationsUtil.java
+++ b/camera2/src/main/java/androidx/camera/camera2/internal/GuaranteedConfigurationsUtil.java
@@ -17,6 +17,8 @@
package androidx.camera.camera2.internal;
import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CameraMetadata;
+import android.os.Build;
import androidx.annotation.NonNull;
import androidx.annotation.RequiresApi;
@@ -400,6 +402,436 @@ public static List getLevel3SupportedCombinationList() {
return combinationList;
}
+ /**
+ * Returns the at least supported stream combinations for the ultra high resolution pixel
+ * sensor mode.
+ */
+ @NonNull
+ public static List getUltraHighResolutionSupportedCombinationList() {
+ List combinationList = new ArrayList<>();
+
+ // (YUV, ULTRA_MAXIMUM) + (PRIV, PREVIEW) + (PRIV, RECORD)
+ // Covers (YUV, ULTRA_MAXIMUM) + (PRIV, PREVIEW) in the guaranteed table.
+ SurfaceCombination surfaceCombination1 = new SurfaceCombination();
+ surfaceCombination1.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.YUV, ConfigSize.ULTRA_MAXIMUM));
+ surfaceCombination1.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.PREVIEW));
+ surfaceCombination1.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.RECORD));
+ combinationList.add(surfaceCombination1);
+
+ // (JPEG, ULTRA_MAXIMUM) + (PRIV, PREVIEW) + (PRIV, RECORD)
+ // Covers (JPEG, ULTRA_MAXIMUM) + (PRIV, PREVIEW) in the guaranteed table.
+ SurfaceCombination surfaceCombination2 = new SurfaceCombination();
+ surfaceCombination2.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.JPEG, ConfigSize.ULTRA_MAXIMUM));
+ surfaceCombination2.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.PREVIEW));
+ surfaceCombination2.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.RECORD));
+ combinationList.add(surfaceCombination2);
+
+ // (RAW, ULTRA_MAXIMUM) + (PRIV, PREVIEW) + (PRIV, RECORD)
+ // Covers (RAW, ULTRA_MAXIMUM) + (PRIV, PREVIEW) in the guaranteed table.
+ SurfaceCombination surfaceCombination3 = new SurfaceCombination();
+ surfaceCombination3.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.RAW, ConfigSize.ULTRA_MAXIMUM));
+ surfaceCombination3.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.PREVIEW));
+ surfaceCombination3.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.RECORD));
+ combinationList.add(surfaceCombination3);
+
+ // (YUV, ULTRA_MAXIMUM) + (PRIV, PREVIEW) + (JPEG, MAXIMUM)
+ SurfaceCombination surfaceCombination4 = new SurfaceCombination();
+ surfaceCombination4.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.YUV, ConfigSize.ULTRA_MAXIMUM));
+ surfaceCombination4.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.PREVIEW));
+ surfaceCombination4.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.JPEG, ConfigSize.MAXIMUM));
+ combinationList.add(surfaceCombination4);
+
+ // (JPEG, ULTRA_MAXIMUM) + (PRIV, PREVIEW) + (JPEG, MAXIMUM)
+ SurfaceCombination surfaceCombination5 = new SurfaceCombination();
+ surfaceCombination5.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.JPEG, ConfigSize.ULTRA_MAXIMUM));
+ surfaceCombination5.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.PREVIEW));
+ surfaceCombination5.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.JPEG, ConfigSize.MAXIMUM));
+ combinationList.add(surfaceCombination5);
+
+ // (RAW, ULTRA_MAXIMUM) + (PRIV, PREVIEW) + (JPEG, MAXIMUM)
+ SurfaceCombination surfaceCombination6 = new SurfaceCombination();
+ surfaceCombination6.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.RAW, ConfigSize.ULTRA_MAXIMUM));
+ surfaceCombination6.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.PREVIEW));
+ surfaceCombination6.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.JPEG, ConfigSize.MAXIMUM));
+ combinationList.add(surfaceCombination6);
+
+ // (YUV, ULTRA_MAXIMUM) + (PRIV, PREVIEW) + (YUV, MAXIMUM)
+ // Covers (YUV, ULTRA_MAXIMUM) + (PRIV, PREVIEW) + (YUV, RECORD) in the guaranteed table.
+ SurfaceCombination surfaceCombination7 = new SurfaceCombination();
+ surfaceCombination7.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.YUV, ConfigSize.ULTRA_MAXIMUM));
+ surfaceCombination7.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.PREVIEW));
+ surfaceCombination7.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.YUV, ConfigSize.MAXIMUM));
+ combinationList.add(surfaceCombination7);
+
+ // (JPEG, ULTRA_MAXIMUM) + (PRIV, PREVIEW) + (YUV, MAXIMUM)
+ // Covers (JPEG, ULTRA_MAXIMUM) + (PRIV, PREVIEW) + (YUV, RECORD) in the guaranteed table.
+ SurfaceCombination surfaceCombination8 = new SurfaceCombination();
+ surfaceCombination8.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.JPEG, ConfigSize.ULTRA_MAXIMUM));
+ surfaceCombination8.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.PREVIEW));
+ surfaceCombination8.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.YUV, ConfigSize.MAXIMUM));
+ combinationList.add(surfaceCombination8);
+
+ // (RAW, ULTRA_MAXIMUM) + (PRIV, PREVIEW) + (YUV, MAXIMUM)
+ // Covers (RAW, ULTRA_MAXIMUM) + (PRIV, PREVIEW) + (YUV, RECORD) in the guaranteed table.
+ SurfaceCombination surfaceCombination9 = new SurfaceCombination();
+ surfaceCombination9.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.RAW, ConfigSize.ULTRA_MAXIMUM));
+ surfaceCombination9.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.PREVIEW));
+ surfaceCombination9.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.YUV, ConfigSize.MAXIMUM));
+ combinationList.add(surfaceCombination9);
+
+ // (YUV, ULTRA_MAXIMUM) + (PRIV, PREVIEW) + (RAW, MAXIMUM)
+ SurfaceCombination surfaceCombination10 = new SurfaceCombination();
+ surfaceCombination10.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.YUV, ConfigSize.ULTRA_MAXIMUM));
+ surfaceCombination10.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.PREVIEW));
+ surfaceCombination10.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.RAW, ConfigSize.MAXIMUM));
+ combinationList.add(surfaceCombination10);
+
+ // (JPEG, ULTRA_MAXIMUM) + (PRIV, PREVIEW) + (RAW, MAXIMUM)
+ SurfaceCombination surfaceCombination11 = new SurfaceCombination();
+ surfaceCombination11.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.JPEG, ConfigSize.ULTRA_MAXIMUM));
+ surfaceCombination11.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.PREVIEW));
+ surfaceCombination11.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.RAW, ConfigSize.MAXIMUM));
+ combinationList.add(surfaceCombination11);
+
+ // (RAW, ULTRA_MAXIMUM) + (PRIV, PREVIEW) + (RAW, MAXIMUM)
+ SurfaceCombination surfaceCombination12 = new SurfaceCombination();
+ surfaceCombination12.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.RAW, ConfigSize.ULTRA_MAXIMUM));
+ surfaceCombination12.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.PREVIEW));
+ surfaceCombination12.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.RAW, ConfigSize.MAXIMUM));
+ combinationList.add(surfaceCombination12);
+
+ return combinationList;
+ }
+
+ /**
+ * Returns the minimally guaranteed stream combinations when one or more
+ * streams are configured as a 10-bit input.
+ */
+ @NonNull
+ public static List get10BitSupportedCombinationList() {
+ List combinationList = new ArrayList<>();
+
+ // (PRIV, MAXIMUM)
+ SurfaceCombination surfaceCombination1 = new SurfaceCombination();
+ surfaceCombination1.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.MAXIMUM));
+ combinationList.add(surfaceCombination1);
+
+ // (YUV, MAXIMUM)
+ SurfaceCombination surfaceCombination2 = new SurfaceCombination();
+ surfaceCombination2.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.YUV, ConfigSize.MAXIMUM));
+ combinationList.add(surfaceCombination2);
+
+ // (PRIV, PREVIEW) + (JPEG, MAXIMUM)
+ SurfaceCombination surfaceCombination3 = new SurfaceCombination();
+ surfaceCombination3.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.PREVIEW));
+ surfaceCombination3.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.JPEG, ConfigSize.MAXIMUM));
+ combinationList.add(surfaceCombination3);
+
+ // (PRIV, PREVIEW) + (YUV, MAXIMUM)
+ SurfaceCombination surfaceCombination4 = new SurfaceCombination();
+ surfaceCombination4.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.PREVIEW));
+ surfaceCombination4.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.YUV, ConfigSize.MAXIMUM));
+ combinationList.add(surfaceCombination4);
+
+ // (YUV, PREVIEW) + (YUV, MAXIMUM)
+ SurfaceCombination surfaceCombination5 = new SurfaceCombination();
+ surfaceCombination5.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.YUV, ConfigSize.PREVIEW));
+ surfaceCombination5.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.YUV, ConfigSize.MAXIMUM));
+ combinationList.add(surfaceCombination5);
+
+ // (PRIV, PREVIEW) + (PRIV, RECORD)
+ SurfaceCombination surfaceCombination6 = new SurfaceCombination();
+ surfaceCombination6.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.PREVIEW));
+ surfaceCombination6.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.RECORD));
+ combinationList.add(surfaceCombination6);
+
+ // (PRIV, PREVIEW) + (PRIV, RECORD) + (YUV, RECORD)
+ SurfaceCombination surfaceCombination7 = new SurfaceCombination();
+ surfaceCombination7.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.PREVIEW));
+ surfaceCombination7.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.RECORD));
+ surfaceCombination7.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.YUV, ConfigSize.RECORD));
+ combinationList.add(surfaceCombination7);
+
+ // (PRIV, PREVIEW) + (PRIV, RECORD) + (JPEG, RECORD)
+ SurfaceCombination surfaceCombination8 = new SurfaceCombination();
+ surfaceCombination8.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.PREVIEW));
+ surfaceCombination8.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.RECORD));
+ surfaceCombination8.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.JPEG, ConfigSize.RECORD));
+ combinationList.add(surfaceCombination8);
+
+ return combinationList;
+ }
+
+ /**
+ * Returns the at least supported stream combinations for concurrent cameras.
+ */
+ @NonNull
+ public static List getConcurrentSupportedCombinationList() {
+ List combinationList = new ArrayList<>();
+
+ // (YUV, s1440p)
+ SurfaceCombination surfaceCombination1 = new SurfaceCombination();
+ surfaceCombination1.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.YUV, ConfigSize.s1440p));
+ combinationList.add(surfaceCombination1);
+
+ // (PRIV, s1440p)
+ SurfaceCombination surfaceCombination2 = new SurfaceCombination();
+ surfaceCombination2.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.s1440p));
+ combinationList.add(surfaceCombination2);
+
+ // (JPEG, s1440p)
+ SurfaceCombination surfaceCombination3 = new SurfaceCombination();
+ surfaceCombination3.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.JPEG, ConfigSize.s1440p));
+ combinationList.add(surfaceCombination3);
+
+ // (YUV, s720p) + (JPEG, s1440p)
+ SurfaceCombination surfaceCombination4 = new SurfaceCombination();
+ surfaceCombination4.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.YUV, ConfigSize.s720p));
+ surfaceCombination4.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.JPEG, ConfigSize.s1440p));
+ combinationList.add(surfaceCombination4);
+
+ // (PRIV, s720p) + (JPEG, s1440p)
+ SurfaceCombination surfaceCombination5 = new SurfaceCombination();
+ surfaceCombination5.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.s720p));
+ surfaceCombination5.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.JPEG, ConfigSize.s1440p));
+ combinationList.add(surfaceCombination5);
+
+ // (YUV, s720p) + (YUV, s1440p)
+ SurfaceCombination surfaceCombination6 = new SurfaceCombination();
+ surfaceCombination6.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.YUV, ConfigSize.s720p));
+ surfaceCombination6.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.YUV, ConfigSize.s1440p));
+ combinationList.add(surfaceCombination6);
+
+ // (YUV, s720p) + (PRIV, s1440p)
+ SurfaceCombination surfaceCombination7 = new SurfaceCombination();
+ surfaceCombination7.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.YUV, ConfigSize.s720p));
+ surfaceCombination7.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.s1440p));
+ combinationList.add(surfaceCombination7);
+
+ // (PRIV, s720p) + (YUV, s1440p)
+ SurfaceCombination surfaceCombination8 = new SurfaceCombination();
+ surfaceCombination8.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.s720p));
+ surfaceCombination8.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.YUV, ConfigSize.s1440p));
+ combinationList.add(surfaceCombination8);
+
+ // (PRIV, s720p) + (PRIV, s1440p)
+ SurfaceCombination surfaceCombination9 = new SurfaceCombination();
+ surfaceCombination9.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.s720p));
+ surfaceCombination9.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.s1440p));
+ combinationList.add(surfaceCombination9);
+
+ return combinationList;
+ }
+
+ /**
+ * Returns the entire supported stream combinations for devices with Stream Use Case capability
+ */
+ @RequiresApi(api = Build.VERSION_CODES.TIRAMISU)
+ @NonNull
+ public static List getStreamUseCaseSupportedCombinationList() {
+ List combinationList = new ArrayList<>();
+
+ // (PRIV, s1440p, PREVIEW_VIDEO_STILL)
+ SurfaceCombination surfaceCombination1 = new SurfaceCombination();
+ surfaceCombination1.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.s1440p,
+ CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW_VIDEO_STILL));
+ combinationList.add(surfaceCombination1);
+
+ // (YUV, s1440p, PREVIEW_VIDEO_STILL)
+ SurfaceCombination surfaceCombination2 = new SurfaceCombination();
+ surfaceCombination2.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.YUV, ConfigSize.s1440p,
+ CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW_VIDEO_STILL));
+ combinationList.add(surfaceCombination2);
+
+ // (PRIV, RECORD, VIDEO_RECORD)
+ SurfaceCombination surfaceCombination3 = new SurfaceCombination();
+ surfaceCombination3.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.RECORD,
+ CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_RECORD));
+ combinationList.add(surfaceCombination3);
+
+ // (YUV, RECORD, VIDEO_RECORD)
+ SurfaceCombination surfaceCombination4 = new SurfaceCombination();
+ surfaceCombination4.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.YUV, ConfigSize.RECORD,
+ CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_RECORD));
+ combinationList.add(surfaceCombination4);
+
+ // (JPEG, MAXIMUM, STILL_CAPTURE)
+ SurfaceCombination surfaceCombination5 = new SurfaceCombination();
+ surfaceCombination5.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.JPEG, ConfigSize.MAXIMUM,
+ CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_STILL_CAPTURE));
+ combinationList.add(surfaceCombination5);
+
+ // (YUV, MAXIMUM, STILL_CAPTURE)
+ SurfaceCombination surfaceCombination6 = new SurfaceCombination();
+ surfaceCombination6.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.YUV, ConfigSize.MAXIMUM,
+ CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_STILL_CAPTURE));
+ combinationList.add(surfaceCombination6);
+
+ // (PRIV, PREVIEW, PREVIEW) + (JPEG, MAXIMUM, STILL_CAPTURE)
+ SurfaceCombination surfaceCombination7 = new SurfaceCombination();
+ surfaceCombination7.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.PREVIEW,
+ CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW));
+ surfaceCombination7.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.JPEG, ConfigSize.MAXIMUM,
+ CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_STILL_CAPTURE));
+ combinationList.add(surfaceCombination7);
+
+ // (PRIV, PREVIEW, PREVIEW) + (YUV, MAXIMUM, STILL_CAPTURE)
+ SurfaceCombination surfaceCombination8 = new SurfaceCombination();
+ surfaceCombination8.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.PREVIEW,
+ CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW));
+ surfaceCombination8.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.YUV, ConfigSize.MAXIMUM,
+ CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_STILL_CAPTURE));
+ combinationList.add(surfaceCombination8);
+
+ // (PRIV, PREVIEW, PREVIEW) + (PRIV, RECORD, VIDEO_RECORD)
+ SurfaceCombination surfaceCombination9 = new SurfaceCombination();
+ surfaceCombination9.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.PREVIEW,
+ CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW));
+ surfaceCombination9.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.RECORD,
+ CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_RECORD));
+ combinationList.add(surfaceCombination9);
+
+ // (PRIV, PREVIEW, PREVIEW) + (YUV, RECORD, VIDEO_RECORD)
+ SurfaceCombination surfaceCombination10 = new SurfaceCombination();
+ surfaceCombination10.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.PREVIEW,
+ CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW));
+ surfaceCombination10.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.YUV, ConfigSize.RECORD,
+ CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_RECORD));
+ combinationList.add(surfaceCombination10);
+
+ // (PRIV, PREVIEW, PREVIEW) + (YUV, PREVIEW, PREVIEW)
+ SurfaceCombination surfaceCombination11 = new SurfaceCombination();
+ surfaceCombination11.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.PREVIEW,
+ CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW));
+ surfaceCombination11.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.YUV, ConfigSize.PREVIEW,
+ CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW));
+ combinationList.add(surfaceCombination11);
+
+ // (PRIV, PREVIEW, PREVIEW) + (PRIV, RECORD, VIDEO_RECORD) + (JPEG, RECORD, STILL_CAPTURE)
+ SurfaceCombination surfaceCombination12 = new SurfaceCombination();
+ surfaceCombination12.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.PREVIEW,
+ CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW));
+ surfaceCombination12.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.RECORD,
+ CameraMetadata.CONTROL_CAPTURE_INTENT_VIDEO_RECORD));
+ surfaceCombination12.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.JPEG, ConfigSize.RECORD,
+ CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_STILL_CAPTURE));
+ combinationList.add(surfaceCombination12);
+
+ // (PRIV, PREVIEW, PREVIEW) + (YUV, RECORD, VIDEO_RECORD) + (JPEG, RECORD, STILL_CAPTURE)
+ SurfaceCombination surfaceCombination13 = new SurfaceCombination();
+ surfaceCombination13.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.PREVIEW,
+ CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW));
+ surfaceCombination13.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.YUV, ConfigSize.RECORD,
+ CameraMetadata.CONTROL_CAPTURE_INTENT_VIDEO_RECORD));
+ surfaceCombination13.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.JPEG, ConfigSize.RECORD,
+ CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_STILL_CAPTURE));
+ combinationList.add(surfaceCombination13);
+
+ // (PRIV, PREVIEW, PREVIEW) + (YUV, PREVIEW, PREVIEW) + (JPEG, MAXIMUM, STILL_CAPTURE)
+ SurfaceCombination surfaceCombination14 = new SurfaceCombination();
+ surfaceCombination14.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.PREVIEW,
+ CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW));
+ surfaceCombination14.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.YUV, ConfigSize.PREVIEW,
+ CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW));
+ surfaceCombination14.addSurfaceConfig(
+ SurfaceConfig.create(ConfigType.JPEG, ConfigSize.MAXIMUM,
+ CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_STILL_CAPTURE));
+ combinationList.add(surfaceCombination14);
+
+ return combinationList;
+ }
+
/**
* Returns the supported stream combinations based on the hardware level and capabilities of
* the device.
diff --git a/camera2/src/main/java/androidx/camera/camera2/internal/LensFacingUtil.java b/camera2/src/main/java/androidx/camera/camera2/internal/LensFacingUtil.java
new file mode 100644
index 000000000..fdcfce9fd
--- /dev/null
+++ b/camera2/src/main/java/androidx/camera/camera2/internal/LensFacingUtil.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright 2022 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 androidx.camera.camera2.internal;
+
+import android.hardware.camera2.CameraMetadata;
+
+import androidx.annotation.OptIn;
+import androidx.annotation.RequiresApi;
+import androidx.camera.core.CameraSelector;
+import androidx.camera.core.ExperimentalLensFacing;
+
+/**
+ * Contains utility methods related to lens facing.
+ */
+@RequiresApi(21) // TODO(b/200306659): Remove and replace with annotation on package-info.java
+public class LensFacingUtil {
+
+ // Do not allow instantiation.
+ private LensFacingUtil() {
+
+ }
+
+ /**
+ * Converts a lens facing direction from a {@link CameraMetadata} integer to a camera
+ * selector lens facing.
+ *
+ * @param lensFacingInteger the lens facing integer, as defined in {@link CameraMetadata}.
+ * @return the camera selector lens facing.
+ * @throws IllegalArgumentException if the specified lens facing integer can not be recognized.
+ */
+ @OptIn(markerClass = ExperimentalLensFacing.class)
+ @CameraSelector.LensFacing
+ public static int getCameraSelectorLensFacing(int lensFacingInteger) {
+ switch (lensFacingInteger) {
+ case CameraMetadata.LENS_FACING_BACK:
+ return CameraSelector.LENS_FACING_BACK;
+ case CameraMetadata.LENS_FACING_FRONT:
+ return CameraSelector.LENS_FACING_FRONT;
+ case CameraMetadata.LENS_FACING_EXTERNAL:
+ return CameraSelector.LENS_FACING_EXTERNAL;
+ default:
+ throw new IllegalArgumentException(
+ "The given lens facing integer: " + lensFacingInteger
+ + " can not be recognized.");
+ }
+ }
+
+ /**
+ * Converts a lens facing direction from a camera selector lens facing to a
+ * {@link CameraMetadata} integer.
+ *
+ * @param lensFacing the camera selector lens facing.
+ * @return The lens facing integer.
+ * @throws IllegalArgumentException if the given lens facing can not be recognized.
+ */
+ @OptIn(markerClass = ExperimentalLensFacing.class)
+ public static int getLensFacingInt(@CameraSelector.LensFacing int lensFacing) {
+ switch (lensFacing) {
+ case CameraSelector.LENS_FACING_BACK:
+ return CameraMetadata.LENS_FACING_BACK;
+ case CameraSelector.LENS_FACING_FRONT:
+ return CameraMetadata.LENS_FACING_FRONT;
+ case CameraSelector.LENS_FACING_EXTERNAL:
+ return CameraSelector.LENS_FACING_EXTERNAL;
+ default:
+ throw new IllegalArgumentException(
+ "The given lens facing: " + lensFacing + " can not be recognized.");
+ }
+ }
+}
diff --git a/camera2/src/main/java/androidx/camera/camera2/internal/MeteringRepeatingSession.java b/camera2/src/main/java/androidx/camera/camera2/internal/MeteringRepeatingSession.java
index 04688d1f0..31c646e7c 100644
--- a/camera2/src/main/java/androidx/camera/camera2/internal/MeteringRepeatingSession.java
+++ b/camera2/src/main/java/androidx/camera/camera2/internal/MeteringRepeatingSession.java
@@ -18,10 +18,7 @@
import android.graphics.ImageFormat;
import android.graphics.SurfaceTexture;
-import android.hardware.camera2.CameraCharacteristics;
import android.hardware.camera2.CameraDevice;
-import android.hardware.camera2.params.StreamConfigurationMap;
-import android.os.Build;
import android.util.Size;
import android.view.Surface;
@@ -29,6 +26,7 @@
import androidx.annotation.Nullable;
import androidx.annotation.RequiresApi;
import androidx.camera.camera2.internal.compat.CameraCharacteristicsCompat;
+import androidx.camera.camera2.internal.compat.StreamConfigurationMapCompat;
import androidx.camera.camera2.internal.compat.workaround.SupportedRepeatingSurfaceSize;
import androidx.camera.core.Logger;
import androidx.camera.core.UseCase;
@@ -38,6 +36,7 @@
import androidx.camera.core.impl.MutableOptionsBundle;
import androidx.camera.core.impl.SessionConfig;
import androidx.camera.core.impl.UseCaseConfig;
+import androidx.camera.core.impl.UseCaseConfigFactory;
import androidx.camera.core.impl.utils.executor.CameraXExecutors;
import androidx.camera.core.impl.utils.futures.FutureCallback;
import androidx.camera.core.impl.utils.futures.Futures;
@@ -59,30 +58,50 @@ class MeteringRepeatingSession {
private DeferrableSurface mDeferrableSurface;
@NonNull
- private final SessionConfig mSessionConfig;
+ private SessionConfig mSessionConfig;
@NonNull
private final MeteringRepeatingConfig mConfigWithDefaults;
+ @NonNull
+ private final Size mMeteringRepeatingSize;
+
@NonNull
private final SupportedRepeatingSurfaceSize mSupportedRepeatingSurfaceSize =
new SupportedRepeatingSurfaceSize();
+ interface SurfaceResetCallback {
+ void onSurfaceReset();
+ }
+
+ @Nullable
+ private final SurfaceResetCallback mSurfaceResetCallback;
+
/** Creates a new instance of a {@link MeteringRepeatingSession}. */
MeteringRepeatingSession(@NonNull CameraCharacteristicsCompat cameraCharacteristicsCompat,
- @NonNull DisplayInfoManager displayInfoManager) {
+ @NonNull DisplayInfoManager displayInfoManager,
+ @Nullable SurfaceResetCallback surfaceResetCallback) {
mConfigWithDefaults = new MeteringRepeatingConfig();
+ mSurfaceResetCallback = surfaceResetCallback;
+
+ mMeteringRepeatingSize = getProperPreviewSize(
+ cameraCharacteristicsCompat, displayInfoManager);
+ Logger.d(TAG, "MeteringSession SurfaceTexture size: " + mMeteringRepeatingSize);
+
+ mSessionConfig = createSessionConfig();
+ }
+ @NonNull
+ SessionConfig createSessionConfig() {
// Create the metering DeferrableSurface
SurfaceTexture surfaceTexture = new SurfaceTexture(0);
- Size meteringSurfaceSize = getProperPreviewSize(
- cameraCharacteristicsCompat, displayInfoManager);
- Logger.d(TAG, "MeteringSession SurfaceTexture size: " + meteringSurfaceSize);
- surfaceTexture.setDefaultBufferSize(meteringSurfaceSize.getWidth(),
- meteringSurfaceSize.getHeight());
+
+ surfaceTexture.setDefaultBufferSize(mMeteringRepeatingSize.getWidth(),
+ mMeteringRepeatingSize.getHeight());
Surface surface = new Surface(surfaceTexture);
- SessionConfig.Builder builder = SessionConfig.Builder.createFrom(mConfigWithDefaults);
+ SessionConfig.Builder builder = SessionConfig.Builder.createFrom(mConfigWithDefaults,
+ mMeteringRepeatingSize);
builder.setTemplateType(CameraDevice.TEMPLATE_PREVIEW);
mDeferrableSurface = new ImmediateSurface(surface);
@@ -103,7 +122,14 @@ public void onFailure(@NonNull Throwable t) {
builder.addSurface(mDeferrableSurface);
- mSessionConfig = builder.build();
+ builder.addErrorListener((sessionConfig, error) -> {
+ mSessionConfig = createSessionConfig();
+ if (mSurfaceResetCallback != null) {
+ mSurfaceResetCallback.onSurfaceReset();
+ }
+ });
+
+ return builder.build();
}
@NonNull
@@ -153,26 +179,20 @@ private static class MeteringRepeatingConfig implements UseCaseConfig {
public Config getConfig() {
return mConfig;
}
+
+ @NonNull
+ @Override
+ public UseCaseConfigFactory.CaptureType getCaptureType() {
+ return UseCaseConfigFactory.CaptureType.METERING_REPEATING;
+ }
}
@NonNull
private Size getProperPreviewSize(@NonNull CameraCharacteristicsCompat
cameraCharacteristicsCompat, @NonNull DisplayInfoManager displayInfoManager) {
- Size[] outputSizes;
- StreamConfigurationMap map = cameraCharacteristicsCompat.get(
- CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
- if (map == null) {
- Logger.e(TAG, "Can not retrieve SCALER_STREAM_CONFIGURATION_MAP.");
- return new Size(0, 0);
- }
-
- if (Build.VERSION.SDK_INT < 23) {
- // ImageFormat.PRIVATE is only public after Android level 23. Therefore, using
- // SurfaceTexture.class to get the supported output sizes before Android level 23.
- outputSizes = map.getOutputSizes(SurfaceTexture.class);
- } else {
- outputSizes = map.getOutputSizes(ImageFormat.PRIVATE);
- }
+ StreamConfigurationMapCompat mapCompat =
+ cameraCharacteristicsCompat.getStreamConfigurationMapCompat();
+ Size[] outputSizes = mapCompat.getOutputSizes(ImageFormat.PRIVATE);
if (outputSizes == null) {
Logger.e(TAG, "Can not get output size list.");
return new Size(0, 0);
@@ -213,5 +233,3 @@ private Size getProperPreviewSize(@NonNull CameraCharacteristicsCompat
}
}
-
-
diff --git a/camera2/src/main/java/androidx/camera/camera2/internal/ProcessingCaptureSession.java b/camera2/src/main/java/androidx/camera/camera2/internal/ProcessingCaptureSession.java
index 173093afb..5c9eb4bfe 100644
--- a/camera2/src/main/java/androidx/camera/camera2/internal/ProcessingCaptureSession.java
+++ b/camera2/src/main/java/androidx/camera/camera2/internal/ProcessingCaptureSession.java
@@ -26,6 +26,7 @@
import androidx.annotation.OptIn;
import androidx.annotation.RequiresApi;
import androidx.camera.camera2.impl.Camera2ImplConfig;
+import androidx.camera.camera2.internal.compat.params.DynamicRangesCompat;
import androidx.camera.camera2.interop.CaptureRequestOptions;
import androidx.camera.camera2.interop.ExperimentalCamera2Interop;
import androidx.camera.core.ImageAnalysis;
@@ -100,7 +101,7 @@ final class ProcessingCaptureSession implements CaptureSessionInterface {
private ProcessorState mProcessorState;
private static List sHeldProcessorSurfaces = new ArrayList<>();
@Nullable
- private volatile CaptureConfig mPendingCaptureConfig = null;
+ private volatile List mPendingCaptureConfigs = null;
@SuppressWarnings("WeakerAccess") /* synthetic accessor */
volatile boolean mIsExecutingStillCaptureRequest = false;
private final SessionProcessorCaptureCallback mSessionProcessorCaptureCallback;
@@ -115,7 +116,7 @@ private enum ProcessorState {
SESSION_INITIALIZED,
ON_CAPTURE_SESSION_STARTED,
ON_CAPTURE_SESSION_ENDED,
- CLOSED
+ DE_INITIALIZED
}
// For debugging only
@@ -123,9 +124,10 @@ private enum ProcessorState {
private int mInstanceId = 0;
ProcessingCaptureSession(@NonNull SessionProcessor sessionProcessor,
- @NonNull Camera2CameraInfoImpl camera2CameraInfoImpl, @NonNull Executor executor,
+ @NonNull Camera2CameraInfoImpl camera2CameraInfoImpl,
+ @NonNull DynamicRangesCompat dynamicRangesCompat, @NonNull Executor executor,
@NonNull ScheduledExecutorService scheduledExecutorService) {
- mCaptureSession = new CaptureSession();
+ mCaptureSession = new CaptureSession(dynamicRangesCompat);
mSessionProcessor = sessionProcessor;
mCamera2CameraInfoImpl = camera2CameraInfoImpl;
mExecutor = executor;
@@ -155,7 +157,7 @@ public ListenableFuture open(@NonNull SessionConfig sessionConfig,
.transformAsync(surfaceList -> {
Logger.d(TAG,
"-- getSurfaces done, start init (id=" + mInstanceId + ")");
- if (mProcessorState == ProcessorState.CLOSED) {
+ if (mProcessorState == ProcessorState.DE_INITIALIZED) {
return Futures.immediateFailedFuture(new IllegalStateException(
"SessionProcessorCaptureSession is closed."));
}
@@ -171,12 +173,6 @@ public ListenableFuture open(@NonNull SessionConfig sessionConfig,
"Surface closed", deferrableSurface));
}
- try {
- DeferrableSurfaces.incrementAll(mOutputSurfaces);
- } catch (DeferrableSurface.SurfaceClosedException e) {
- return Futures.immediateFailedFuture(e);
- }
-
OutputSurface previewOutputSurface = null;
OutputSurface captureOutputSurface = null;
OutputSurface analysisOutputSurface = null;
@@ -208,13 +204,24 @@ public ListenableFuture open(@NonNull SessionConfig sessionConfig,
}
mProcessorState = ProcessorState.SESSION_INITIALIZED;
+ try {
+ DeferrableSurfaces.incrementAll(mOutputSurfaces);
+ } catch (DeferrableSurface.SurfaceClosedException e) {
+ return Futures.immediateFailedFuture(e);
+ }
Logger.w(TAG, "== initSession (id=" + mInstanceId + ")");
- mProcessorSessionConfig = mSessionProcessor.initSession(
- mCamera2CameraInfoImpl,
- previewOutputSurface,
- captureOutputSurface,
- analysisOutputSurface
- );
+ try {
+ mProcessorSessionConfig = mSessionProcessor.initSession(
+ mCamera2CameraInfoImpl,
+ previewOutputSurface,
+ captureOutputSurface,
+ analysisOutputSurface
+ );
+ } catch (Throwable e) {
+ // Ensure we decrement the output surfaces if initSession failed.
+ DeferrableSurfaces.decrementAll(mOutputSurfaces);
+ throw e;
+ }
// DecrementAll the output surfaces when ProcessorSurface
// terminates.
@@ -251,11 +258,13 @@ public void onSuccess(@Nullable Void result) {
}
@Override
+ @SuppressWarnings("FutureReturnValueIgnored")
public void onFailure(@NonNull Throwable t) {
// Close() will invoke appropriate SessionProcessor methods
// to clear up and mark this session as CLOSED.
Logger.e(TAG, "open session failed ", t);
close();
+ release(false);
}
}, mExecutor);
return openSessionFuture;
@@ -280,33 +289,69 @@ private static void cancelRequests(@NonNull List captureConfigs)
}
}
- private boolean isStillCapture(@NonNull List captureConfigs) {
- if (captureConfigs.isEmpty()) {
- return false;
- }
- for (CaptureConfig captureConfig : captureConfigs) {
- // Don't need to consider TEMPLATE_VIDEO_SNAPSHOT case since extensions does not
- // support Video Capture yet
- if (captureConfig.getTemplateType() != CameraDevice.TEMPLATE_STILL_CAPTURE) {
- return false;
+ /**
+ * Send a trigger request. Currently only CONTROL_AF_TRIGGER and CONTROL_AE_PRECAPTURE_TRIGGER
+ * are supported.
+ */
+ void issueTriggerRequest(@NonNull CaptureConfig captureConfig) {
+ Logger.d(TAG, "issueTriggerRequest");
+ CaptureRequestOptions options =
+ CaptureRequestOptions.Builder.from(
+ captureConfig.getImplementationOptions()).build();
+
+ boolean hasTriggerParameters = false;
+ for (Config.Option option : options.listOptions()) {
+ @SuppressWarnings("unchecked")
+ CaptureRequest.Key