/*
* Copyright (C) 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.ex.camera2.portability;
import com.android.ex.camera2.portability.debug.Log;
import java.util.ArrayList;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Set;
import java.util.TreeSet;
/**
* This class holds all the static information of a camera's capabilities.
* <p>
* The design of this class is thread-safe and can be passed around regardless
* of which thread using it.
* </p>
*/
public class CameraCapabilities {
private static Log.Tag TAG = new Log.Tag("CamCapabs");
/** Zoom ratio used for seeing sensor's full field of view. */
protected static final float ZOOM_RATIO_UNZOOMED = 1.0f;
/* All internal states are declared final and should be thread-safe. */
protected final ArrayList<int[]> mSupportedPreviewFpsRange = new ArrayList<int[]>();
protected final ArrayList<Size> mSupportedPreviewSizes = new ArrayList<Size>();
protected final TreeSet<Integer> mSupportedPreviewFormats = new TreeSet<Integer>();
protected final ArrayList<Size> mSupportedVideoSizes = new ArrayList<Size>();
protected final ArrayList<Size> mSupportedPhotoSizes = new ArrayList<Size>();
protected final TreeSet<Integer> mSupportedPhotoFormats = new TreeSet<Integer>();
protected final EnumSet<SceneMode> mSupportedSceneModes = EnumSet.noneOf(SceneMode.class);
protected final EnumSet<FlashMode> mSupportedFlashModes = EnumSet.noneOf(FlashMode.class);
protected final EnumSet<FocusMode> mSupportedFocusModes = EnumSet.noneOf(FocusMode.class);
protected final EnumSet<WhiteBalance> mSupportedWhiteBalances =
EnumSet.noneOf(WhiteBalance.class);
protected final EnumSet<Feature> mSupportedFeatures = EnumSet.noneOf(Feature.class);
protected Size mPreferredPreviewSizeForVideo;
protected int mMinExposureCompensation;
protected int mMaxExposureCompensation;
protected float mExposureCompensationStep;
protected int mMaxNumOfFacesSupported;
protected int mMaxNumOfFocusAreas;
protected int mMaxNumOfMeteringArea;
protected float mMaxZoomRatio;
protected float mHorizontalViewAngle;
protected float mVerticalViewAngle;
private final Stringifier mStringifier;
/**
* Focus modes.
*/
public enum FocusMode {
/**
* Continuous auto focus mode intended for taking pictures.
* @see {@link android.hardware.Camera.Parameters#FOCUS_MODE_AUTO}.
*/
AUTO,
/**
* Continuous auto focus mode intended for taking pictures.
* @see {@link android.hardware.Camera.Parameters#FOCUS_MODE_CONTINUOUS_PICTURE}.
*/
CONTINUOUS_PICTURE,
/**
* Continuous auto focus mode intended for video recording.
* @see {@link android.hardware.Camera.Parameters#FOCUS_MODE_CONTINUOUS_VIDEO}.
*/
CONTINUOUS_VIDEO,
/**
* Extended depth of field (EDOF).
* @see {@link android.hardware.Camera.Parameters#FOCUS_MODE_EDOF}.
*/
EXTENDED_DOF,
/**
* Focus is fixed.
* @see {@link android.hardware.Camera.Parameters#FOCUS_MODE_FIXED}.
*/
FIXED,
/**
* Focus is set at infinity.
* @see {@link android.hardware.Camera.Parameters#FOCUS_MODE_INFINITY}.
*/
// TODO: Unsupported on API 2
INFINITY,
/**
* Macro (close-up) focus mode.
* @see {@link android.hardware.Camera.Parameters#FOCUS_MODE_MACRO}.
*/
MACRO,
}
/**
* Flash modes.
*/
public enum FlashMode {
/**
* No flash.
*/
NO_FLASH,
/**
* Flash will be fired automatically when required.
* @see {@link android.hardware.Camera.Parameters#FLASH_MODE_OFF}.
*/
AUTO,
/**
* Flash will not be fired.
* @see {@link android.hardware.Camera.Parameters#FLASH_MODE_OFF}.
*/
OFF,
/**
* Flash will always be fired during snapshot.
* @see {@link android.hardware.Camera.Parameters#FLASH_MODE_ON}.
*/
ON,
/**
* Constant emission of light during preview, auto-focus and snapshot.
* @see {@link android.hardware.Camera.Parameters#FLASH_MODE_TORCH}.
*/
TORCH,
/**
* Flash will be fired in red-eye reduction mode.
* @see {@link android.hardware.Camera.Parameters#FLASH_MODE_RED_EYE}.
*/
RED_EYE,
}
/**
* Scene modes.
*/
public enum SceneMode {
/**
* No supported scene mode.
*/
NO_SCENE_MODE,
/**
* Scene mode is off.
* @see {@link android.hardware.Camera.Parameters#SCENE_MODE_AUTO}.
*/
AUTO,
/**
* Take photos of fast moving objects.
* @see {@link android.hardware.Camera.Parameters#SCENE_MODE_ACTION}.
*/
ACTION,
/**
* Applications are looking for a barcode.
* @see {@link android.hardware.Camera.Parameters#SCENE_MODE_BARCODE}.
*/
BARCODE,
/**
* Take pictures on the beach.
* @see {@link android.hardware.Camera.Parameters#SCENE_MODE_BEACH}.
*/
BEACH,
/**
* Capture the naturally warm color of scenes lit by candles.
* @see {@link android.hardware.Camera.Parameters#SCENE_MODE_CANDLELIGHT}.
*/
CANDLELIGHT,
/**
* For shooting firework displays.
* @see {@link android.hardware.Camera.Parameters#SCENE_MODE_FIREWORKS}.
*/
FIREWORKS,
/**
* Capture a scene using high dynamic range imaging techniques.
* @see {@link android.hardware.Camera.Parameters#SCENE_MODE_HDR}.
*/
// Note: Supported as a vendor tag on the Camera2 API for some LEGACY devices.
HDR,
/**
* Take pictures on distant objects.
* @see {@link android.hardware.Camera.Parameters#SCENE_MODE_LANDSCAPE}.
*/
LANDSCAPE,
/**
* Take photos at night.
* @see {@link android.hardware.Camera.Parameters#SCENE_MODE_NIGHT}.
*/
NIGHT,
/**
* Take people pictures at night.
* @see {@link android.hardware.Camera.Parameters#SCENE_MODE_NIGHT_PORTRAIT}.
*/
// TODO: Unsupported on API 2
NIGHT_PORTRAIT,
/**
* Take indoor low-light shot.
* @see {@link android.hardware.Camera.Parameters#SCENE_MODE_PARTY}.
*/
PARTY,
/**
* Take people pictures.
* @see {@link android.hardware.Camera.Parameters#SCENE_MODE_PORTRAIT}.
*/
PORTRAIT,
/**
* Take pictures on the snow.
* @see {@link android.hardware.Camera.Parameters#SCENE_MODE_SNOW}.
*/
SNOW,
/**
* Take photos of fast moving objects.
* @see {@link android.hardware.Camera.Parameters#SCENE_MODE_SPORTS}.
*/
SPORTS,
/**
* Avoid blurry pictures (for example, due to hand shake).
* @see {@link android.hardware.Camera.Parameters#SCENE_MODE_STEADYPHOTO}.
*/
STEADYPHOTO,
/**
* Take sunset photos.
* @see {@link android.hardware.Camera.Parameters#SCENE_MODE_SUNSET}.
*/
SUNSET,
/**
* Take photos in a theater.
* @see {@link android.hardware.Camera.Parameters#SCENE_MODE_THEATRE}.
*/
THEATRE,
}
/**
* White blances.
*/
public enum WhiteBalance {
/**
* @see {@link android.hardware.Camera.Parameters#WHITE_BALANCE_AUTO}.
*/
AUTO,
/**
* @see {@link android.hardware.Camera.Parameters#WHITE_BALANCE_CLOUDY_DAYLIGHT}.
*/
CLOUDY_DAYLIGHT,
/**
* @see {@link android.hardware.Camera.Parameters#WHITE_BALANCE_DAYLIGHT}.
*/
DAYLIGHT,
/**
* @see {@link android.hardware.Camera.Parameters#WHITE_BALANCE_FLUORESCENT}.
*/
FLUORESCENT,
/**
* @see {@link android.hardware.Camera.Parameters#WHITE_BALANCE_INCANDESCENT}.
*/
INCANDESCENT,
/**
* @see {@link android.hardware.Camera.Parameters#WHITE_BALANCE_SHADE}.
*/
SHADE,
/**
* @see {@link android.hardware.Camera.Parameters#WHITE_BALANCE_TWILIGHT}.
*/
TWILIGHT,
/**
* @see {@link android.hardware.Camera.Parameters#WHITE_BALANCE_WARM_FLUORESCENT}.
*/
WARM_FLUORESCENT,
}
/**
* Features.
*/
public enum Feature {
/**
* Support zoom-related methods.
*/
ZOOM,
/**
* Support for photo capturing during video recording.
*/
VIDEO_SNAPSHOT,
/**
* Support for focus area settings.
*/
FOCUS_AREA,
/**
* Support for metering area settings.
*/
METERING_AREA,
/**
* Support for automatic exposure lock.
*/
AUTO_EXPOSURE_LOCK,
/**
* Support for automatic white balance lock.
*/
AUTO_WHITE_BALANCE_LOCK,
/**
* Support for video stabilization.
*/
VIDEO_STABILIZATION,
}
/**
* A interface stringifier to convert abstract representations to API
* related string representation.
*/
public static class Stringifier {
/**
* Converts the string to hyphen-delimited lowercase for compatibility with multiple APIs.
*
* @param enumCase The name of an enum constant.
* @return The converted string.
*/
private static String toApiCase(String enumCase) {
return enumCase.toLowerCase(Locale.US).replaceAll("_", "-");
}
/**
* Converts the string to underscore-delimited uppercase to match the enum constant names.
*
* @param apiCase An API-related string representation.
* @return The converted string.
*/
private static String toEnumCase(String apiCase) {
return apiCase.toUpperCase(Locale.US).replaceAll("-", "_");
}
/**
* Converts the focus mode to API-related string representation.
*
* @param focus The focus mode to convert.
* @return The string used by the camera framework API to represent the
* focus mode.
*/
public String stringify(FocusMode focus) {
return toApiCase(focus.name());
}
/**
* Converts the API-related string representation of the focus mode to the
* abstract representation.
*
* @param val The string representation.
* @return The focus mode represented by the input string, or the focus
* mode with the lowest ordinal if it cannot be converted.
*/
public FocusMode focusModeFromString(String val) {
if (val == null) {
return FocusMode.values()[0];
}
try {
return FocusMode.valueOf(toEnumCase(val));
} catch (IllegalArgumentException ex) {
return FocusMode.values()[0];
}
}
/**
* Converts the flash mode to API-related string representation.
*
* @param flash The focus mode to convert.
* @return The string used by the camera framework API to represent the
* flash mode.
*/
public String stringify(FlashMode flash) {
return toApiCase(flash.name());
}
/**
* Converts the API-related string representation of the flash mode to the
* abstract representation.
*
* @param val The string representation.
* @return The flash mode represented by the input string, or the flash
* mode with the lowest ordinal if it cannot be converted.
*/
public FlashMode flashModeFromString(String val) {
if (val == null) {
return FlashMode.values()[0];
}
try {
return FlashMode.valueOf(toEnumCase(val));
} catch (IllegalArgumentException ex) {
return FlashMode.values()[0];
}
}
/**
* Converts the scene mode to API-related string representation.
*
* @param scene The focus mode to convert.
* @return The string used by the camera framework API to represent the
* scene mode.
*/
public String stringify(SceneMode scene) {
return toApiCase(scene.name());
}
/**
* Converts the API-related string representation of the scene mode to the
* abstract representation.
*
* @param val The string representation.
* @return The scene mode represented by the input string, or the scene
* mode with the lowest ordinal if it cannot be converted.
*/
public SceneMode sceneModeFromString(String val) {
if (val == null) {
return SceneMode.values()[0];
}
try {
return SceneMode.valueOf(toEnumCase(val));
} catch (IllegalArgumentException ex) {
return SceneMode.values()[0];
}
}
/**
* Converts the white balance to API-related string representation.
*
* @param wb The focus mode to convert.
* @return The string used by the camera framework API to represent the
* white balance.
*/
public String stringify(WhiteBalance wb) {
return toApiCase(wb.name());
}
/**
* Converts the API-related string representation of the white balance to
* the abstract representation.
*
* @param val The string representation.
* @return The white balance represented by the input string, or the
* white balance with the lowest ordinal if it cannot be
* converted.
*/
public WhiteBalance whiteBalanceFromString(String val) {
if (val == null) {
return WhiteBalance.values()[0];
}
try {
return WhiteBalance.valueOf(toEnumCase(val));
} catch (IllegalArgumentException ex) {
return WhiteBalance.values()[0];
}
}
}
/**
* Constructor.
* @param stringifier The API-specific stringifier for this instance.
*/
CameraCapabilities(Stringifier stringifier) {
mStringifier = stringifier;
}
/**
* Copy constructor.
* @param src The source instance.
*/
public CameraCapabilities(CameraCapabilities src) {
mSupportedPreviewFpsRange.addAll(src.mSupportedPreviewFpsRange);
mSupportedPreviewSizes.addAll(src.mSupportedPreviewSizes);
mSupportedPreviewFormats.addAll(src.mSupportedPreviewFormats);
mSupportedVideoSizes.addAll(src.mSupportedVideoSizes);
mSupportedPhotoSizes.addAll(src.mSupportedPhotoSizes);
mSupportedPhotoFormats.addAll(src.mSupportedPhotoFormats);
mSupportedSceneModes.addAll(src.mSupportedSceneModes);
mSupportedFlashModes.addAll(src.mSupportedFlashModes);
mSupportedFocusModes.addAll(src.mSupportedFocusModes);
mSupportedWhiteBalances.addAll(src.mSupportedWhiteBalances);
mSupportedFeatures.addAll(src.mSupportedFeatures);
mPreferredPreviewSizeForVideo = src.mPreferredPreviewSizeForVideo;
mMaxExposureCompensation = src.mMaxExposureCompensation;
mMinExposureCompensation = src.mMinExposureCompensation;
mExposureCompensationStep = src.mExposureCompensationStep;
mMaxNumOfFacesSupported = src.mMaxNumOfFacesSupported;
mMaxNumOfFocusAreas = src.mMaxNumOfFocusAreas;
mMaxNumOfMeteringArea = src.mMaxNumOfMeteringArea;
mMaxZoomRatio = src.mMaxZoomRatio;
mHorizontalViewAngle = src.mHorizontalViewAngle;
mVerticalViewAngle = src.mVerticalViewAngle;
mStringifier = src.mStringifier;
}
public float getHorizontalViewAngle() {
return mHorizontalViewAngle;
}
public float getVerticalViewAngle() {
return mVerticalViewAngle;
}
/**
* @return the supported picture formats. See {@link android.graphics.ImageFormat}.
*/
public Set<Integer> getSupportedPhotoFormats() {
return new TreeSet<Integer>(mSupportedPhotoFormats);
}
/**
* Gets the supported preview formats.
* @return The supported preview {@link android.graphics.ImageFormat}s.
*/
public Set<Integer> getSupportedPreviewFormats() {
return new TreeSet<Integer>(mSupportedPreviewFormats);
}
/**
* Gets the supported picture sizes.
*/
public List<Size> getSupportedPhotoSizes() {
return new ArrayList<Size>(mSupportedPhotoSizes);
}
/**
* @return The supported preview fps (frame-per-second) ranges. The returned
* list is sorted by maximum fps then minimum fps in a descending order.
* The values are multiplied by 1000.
*/
public final List<int[]> getSupportedPreviewFpsRange() {
return new ArrayList<int[]>(mSupportedPreviewFpsRange);
}
/**
* @return The supported preview sizes. The list is sorted by width then
* height in a descending order.
*/
public final List<Size> getSupportedPreviewSizes() {
return new ArrayList<Size>(mSupportedPreviewSizes);
}
public final Size getPreferredPreviewSizeForVideo() {
return new Size(mPreferredPreviewSizeForVideo);
}
/**
* @return The supported video frame sizes that can be used by MediaRecorder.
* The list is sorted by width then height in a descending order.
*/
public final List<Size> getSupportedVideoSizes() {
return new ArrayList<Size>(mSupportedVideoSizes);
}
/**
* @return The supported scene modes.
*/
public final Set<SceneMode> getSupportedSceneModes() {
return new HashSet<SceneMode>(mSupportedSceneModes);
}
/**
* @return Whether the scene mode is supported.
*/
public final boolean supports(SceneMode scene) {
return (scene != null && mSupportedSceneModes.contains(scene));
}
public boolean supports(final CameraSettings settings) {
if (zoomCheck(settings) && exposureCheck(settings) && focusCheck(settings) &&
flashCheck(settings) && photoSizeCheck(settings) && previewSizeCheck(settings) &&
videoStabilizationCheck(settings)) {
return true;
}
return false;
}
/**
* @return The supported flash modes.
*/
public final Set<FlashMode> getSupportedFlashModes() {
return new HashSet<FlashMode>(mSupportedFlashModes);
}
/**
* @return Whether the flash mode is supported.
*/
public final boolean supports(FlashMode flash) {
return (flash != null && mSupportedFlashModes.contains(flash));
}
/**
* @return The supported focus modes.
*/
public final Set<FocusMode> getSupportedFocusModes() {
return new HashSet<FocusMode>(mSupportedFocusModes);
}
/**
* @return Whether the focus mode is supported.
*/
public final boolean supports(FocusMode focus) {
return (focus != null && mSupportedFocusModes.contains(focus));
}
/**
* @return The supported white balanceas.
*/
public final Set<WhiteBalance> getSupportedWhiteBalance() {
return new HashSet<WhiteBalance>(mSupportedWhiteBalances);
}
/**
* @return Whether the white balance is supported.
*/
public boolean supports(WhiteBalance wb) {
return (wb != null && mSupportedWhiteBalances.contains(wb));
}
public final Set<Feature> getSupportedFeature() {
return new HashSet<Feature>(mSupportedFeatures);
}
public boolean supports(Feature ft) {
return (ft != null && mSupportedFeatures.contains(ft));
}
/**
* @return The maximal supported zoom ratio.
*/
public float getMaxZoomRatio() {
return mMaxZoomRatio;
}
/**
* @return The min exposure compensation index. The EV is the compensation
* index multiplied by the step value. If unsupported, both this method and
* {@link #getMaxExposureCompensation()} return 0.
*/
public final int getMinExposureCompensation() {
return mMinExposureCompensation;
}
/**
* @return The max exposure compensation index. The EV is the compensation
* index multiplied by the step value. If unsupported, both this method and
* {@link #getMinExposureCompensation()} return 0.
*/
public final int getMaxExposureCompensation() {
return mMaxExposureCompensation;
}
/**
* @return The exposure compensation step. The EV is the compensation index
* multiplied by the step value.
*/
public final float getExposureCompensationStep() {
return mExposureCompensationStep;
}
/**
* @return The max number of faces supported by the face detection. 0 if
* unsupported.
*/
public final int getMaxNumOfFacesSupported() {
return mMaxNumOfFacesSupported;
}
/**
* @return The stringifier used by this instance.
*/
public Stringifier getStringifier() {
return mStringifier;
}
private boolean zoomCheck(final CameraSettings settings) {
final float ratio = settings.getCurrentZoomRatio();
if (!supports(Feature.ZOOM)) {
if (ratio != ZOOM_RATIO_UNZOOMED) {
Log.v(TAG, "Zoom is not supported");
return false;
}
} else {
if (settings.getCurrentZoomRatio() > getMaxZoomRatio()) {
Log.v(TAG, "Zoom ratio is not supported: ratio = " +
settings.getCurrentZoomRatio());
return false;
}
}
return true;
}
private boolean exposureCheck(final CameraSettings settings) {
final int index = settings.getExposureCompensationIndex();
if (index > getMaxExposureCompensation() || index < getMinExposureCompensation()) {
Log.v(TAG, "Exposure compensation index is not supported. Min = " +
getMinExposureCompensation() + ", max = " + getMaxExposureCompensation() + "," +
" setting = " + index);
return false;
}
return true;
}
private boolean focusCheck(final CameraSettings settings) {
FocusMode focusMode = settings.getCurrentFocusMode();
if (!supports(focusMode)) {
if (supports(FocusMode.FIXED)) {
// Workaround for devices whose templates define defaults they don't really support
// TODO: Remove workaround (b/17177436)
Log.w(TAG, "Focus mode not supported... trying FIXED");
settings.setFocusMode(FocusMode.FIXED);
} else {
Log.v(TAG, "Focus mode not supported:" +
(focusMode != null ? focusMode.name() : "null"));
return false;
}
}
return true;
}
private boolean flashCheck(final CameraSettings settings) {
FlashMode flashMode = settings.getCurrentFlashMode();
if (!supports(flashMode)) {
Log.v(TAG,
"Flash mode not supported:" + (flashMode != null ? flashMode.name() : "null"));
return false;
}
return true;
}
private boolean photoSizeCheck(final CameraSettings settings) {
Size photoSize = settings.getCurrentPhotoSize();
if (mSupportedPhotoSizes.contains(photoSize)) {
return true;
}
Log.v(TAG, "Unsupported photo size:" + photoSize);
return false;
}
private boolean previewSizeCheck(final CameraSettings settings) {
final Size previewSize = settings.getCurrentPreviewSize();
if (mSupportedPreviewSizes.contains(previewSize)) {
return true;
}
Log.v(TAG, "Unsupported preview size:" + previewSize);
return false;
}
private boolean videoStabilizationCheck(final CameraSettings settings) {
if (!settings.isVideoStabilizationEnabled() || supports(Feature.VIDEO_STABILIZATION)) {
return true;
}
Log.v(TAG, "Video stabilization is not supported");
return false;
}
}
|
