public static void setBestPreviewFPS(Camera.Parameters parameters, int minFPS, int maxFPS) {
List<int[]> supportedPreviewFpsRanges = parameters.getSupportedPreviewFpsRange();
Log.i(TAG, "Supported FPS ranges: " + toString(supportedPreviewFpsRanges));
if (supportedPreviewFpsRanges != null && !supportedPreviewFpsRanges.isEmpty()) {
int[] suitableFPSRange = null;
for (int[] fpsRange : supportedPreviewFpsRanges) {
int thisMin = fpsRange[Camera.Parameters.PREVIEW_FPS_MIN_INDEX];
int thisMax = fpsRange[Camera.Parameters.PREVIEW_FPS_MAX_INDEX];
if (thisMin >= minFPS * 1000 && thisMax <= maxFPS * 1000) {
suitableFPSRange = fpsRange;
break;
}
}
if (suitableFPSRange == null) {
Log.i(TAG, "No suitable FPS range?");
} else {
int[] currentFpsRange = new int[2];
parameters.getPreviewFpsRange(currentFpsRange);
if (Arrays.equals(currentFpsRange, suitableFPSRange)) {
Log.i(TAG, "FPS range already set to " + Arrays.toString(suitableFPSRange));
} else {
Log.i(TAG, "Setting FPS range to " + Arrays.toString(suitableFPSRange));
parameters.setPreviewFpsRange(
suitableFPSRange[Camera.Parameters.PREVIEW_FPS_MIN_INDEX],
suitableFPSRange[Camera.Parameters.PREVIEW_FPS_MAX_INDEX]);
}
}
}
}
@CalledByNative
public static CaptureFormat[] getDeviceSupportedFormats(int id) {
Camera camera;
try {
camera = Camera.open(id);
} catch (RuntimeException ex) {
Log.e(TAG, "Camera.open: " + ex);
return null;
}
Camera.Parameters parameters = camera.getParameters();
ArrayList<CaptureFormat> formatList = new ArrayList<CaptureFormat>();
// getSupportedPreview{Formats,FpsRange,PreviewSizes}() returns Lists
// with at least one element, but when the camera is in bad state, they
// can return null pointers; in that case we use a 0 entry, so we can
// retrieve as much information as possible.
List<Integer> pixelFormats = parameters.getSupportedPreviewFormats();
if (pixelFormats == null) {
pixelFormats = new ArrayList<Integer>();
}
if (pixelFormats.size() == 0) {
pixelFormats.add(ImageFormat.UNKNOWN);
}
for (Integer previewFormat : pixelFormats) {
int pixelFormat = AndroidImageFormatList.ANDROID_IMAGEFORMAT_UNKNOWN;
if (previewFormat == ImageFormat.YV12) {
pixelFormat = AndroidImageFormatList.ANDROID_IMAGEFORMAT_YV12;
} else if (previewFormat == ImageFormat.NV21) {
continue;
}
List<int[]> listFpsRange = parameters.getSupportedPreviewFpsRange();
if (listFpsRange == null) {
listFpsRange = new ArrayList<int[]>();
}
if (listFpsRange.size() == 0) {
listFpsRange.add(new int[] {0, 0});
}
for (int[] fpsRange : listFpsRange) {
List<Camera.Size> supportedSizes = parameters.getSupportedPreviewSizes();
if (supportedSizes == null) {
supportedSizes = new ArrayList<Camera.Size>();
}
if (supportedSizes.size() == 0) {
supportedSizes.add(camera.new Size(0, 0));
}
for (Camera.Size size : supportedSizes) {
formatList.add(
new CaptureFormat(size.width, size.height, (fpsRange[0] + 999) / 1000, pixelFormat));
}
}
}
camera.release();
return formatList.toArray(new CaptureFormat[formatList.size()]);
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
tv_text1 = (TextView) findViewById(id.textView1);
tv_values1 = (TextView) findViewById(id.textView2);
tv_text2 = (TextView) findViewById(id.textView3);
tv_values2 = (TextView) findViewById(id.textView4);
tv_text3 = (TextView) findViewById(id.textView5);
tv_values3 = (TextView) findViewById(id.textView6);
tv_values1.setText("");
tv_values2.setText("");
preview = (FrameLayout) findViewById(id.camera_preview);
mes = false;
// Create an instance of Camera
mCamera = getCameraInstance();
CamTestActivity.setCameraDisplayOrientation(this, 1, mCamera);
// -->GETTING THE POSSIBLE RANGE
Camera.Parameters cp = mCamera.getParameters();
List<int[]> l = cp.getSupportedPreviewFpsRange();
if (l.size() == 1) {
tv_text1.setText("FPSMin: ");
tv_values1.setText(String.valueOf(l.get(0)[Parameters.PREVIEW_FPS_MIN_INDEX] / 1000));
tv_text2.setText("FPSMax: ");
tv_values2.setText(String.valueOf(l.get(0)[Parameters.PREVIEW_FPS_MAX_INDEX] / 1000));
}
mCamera.setParameters(cp);
// <--GETTING THE POSSIBLE RANGE
// Add a listener to the Capture button
captureButton = (Button) findViewById(id.button_capture);
captureButton.setText("Start");
captureButton.setOnClickListener(
new View.OnClickListener() {
@Override
public void onClick(View v) {
changeMes();
}
});
}
/**
* Gets a list of CameraFormat by id.
*
* <p>id follows:
*
* <ul>
* <li>{@link android.hardware.Camera.CameraInfo#CAMERA_FACING_BACK}
* <li>{@link android.hardware.Camera.CameraInfo#CAMERA_FACING_FRONT}
* </ul>
*
* @param id id
* @retur list of CameraFormat
*/
public static List<CameraFormat> getSupportedFormats(final int id) {
final ArrayList<CameraFormat> formatList = new ArrayList<>();
Camera camera;
try {
camera = Camera.open(id);
} catch (Exception e) {
return formatList;
}
try {
Camera.Parameters parameters = camera.getParameters();
List<int[]> listFpsRange = parameters.getSupportedPreviewFpsRange();
int[] range = {0, 0};
if (listFpsRange != null) {
range = listFpsRange.get(listFpsRange.size() - 1);
}
List<Camera.Size> supportedSizes = parameters.getSupportedPreviewSizes();
for (Camera.Size size : supportedSizes) {
formatList.add(
new CameraFormat(
size.width,
size.height,
id,
range[Camera.Parameters.PREVIEW_FPS_MIN_INDEX] / 1000,
range[Camera.Parameters.PREVIEW_FPS_MAX_INDEX] / 1000));
}
} catch (Exception e) {
if (BuildConfig.DEBUG) {
Log.w(TAG, "", e);
}
} finally {
camera.release();
}
return formatList;
}
public void openCamera() {
if (!isCreated || camera != null) {
return;
}
// Open camera
//
try {
camera = Camera.open(currentCameraId);
} catch (NoSuchMethodError noSuchMethodError) {
camera = Camera.open();
}
try {
camera.setPreviewDisplay(getHolder());
camera.setDisplayOrientation(90);
camera.setPreviewCallback(cameraPreviewCallback);
} catch (IOException ignore) {
ignore.printStackTrace();
} catch (NullPointerException ignore) {
ignore.printStackTrace();
}
// get camera parameters
//
final Camera.Parameters parameters = camera.getParameters();
// Get Preview Size and FPS
//
final List<Camera.Size> supportedPreviewSizes = parameters.getSupportedPreviewSizes();
final List<int[]> supportedPreviewFpsRange = parameters.getSupportedPreviewFpsRange();
// set FPS
//
int[] chosenFPSRange = supportedPreviewFpsRange.get(0);
for (int[] FPSRange : supportedPreviewFpsRange) {
if (FPS > FPSRange[Camera.Parameters.PREVIEW_FPS_MIN_INDEX]
&& FPS < FPSRange[Camera.Parameters.PREVIEW_FPS_MAX_INDEX]) {
chosenFPSRange = FPSRange;
break;
}
}
parameters.setPreviewFpsRange(
chosenFPSRange[Camera.Parameters.PREVIEW_FPS_MIN_INDEX],
chosenFPSRange[Camera.Parameters.PREVIEW_FPS_MAX_INDEX]);
// set Preview Size
//
if (frameSize != null) {
parameters.setPreviewSize(frameSize.width, frameSize.height);
} else {
int firstElementWidth = supportedPreviewSizes.get(0).width;
int lastElementWidth = supportedPreviewSizes.get(supportedPreviewSizes.size() - 1).width;
Camera.Size minPreviewSize =
(lastElementWidth > firstElementWidth)
? supportedPreviewSizes.get(0)
: supportedPreviewSizes.get(supportedPreviewSizes.size() - 1);
parameters.setPreviewSize(minPreviewSize.width, minPreviewSize.height);
}
// Set parameters and start preview
//
try {
camera.setParameters(parameters);
camera.startPreview();
} catch (RuntimeException ignore) {
ignore.printStackTrace();
}
}
// Returns true on success, false otherwise.
@CalledByNative
public boolean allocate(int width, int height, int frameRate) {
Log.d(TAG, "allocate: requested (" + width + "x" + height + ")@" + frameRate + "fps");
try {
mCamera = Camera.open(mId);
} catch (RuntimeException ex) {
Log.e(TAG, "allocate: Camera.open: " + ex);
return false;
}
Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
Camera.getCameraInfo(mId, cameraInfo);
mCameraOrientation = cameraInfo.orientation;
mCameraFacing = cameraInfo.facing;
mDeviceOrientation = getDeviceOrientation();
Log.d(
TAG,
"allocate: orientation dev="
+ mDeviceOrientation
+ ", cam="
+ mCameraOrientation
+ ", facing="
+ mCameraFacing);
Camera.Parameters parameters = mCamera.getParameters();
// getSupportedPreviewFpsRange() returns a List with at least one
// element, but when camera is in bad state, it can return null pointer.
List<int[]> listFpsRange = parameters.getSupportedPreviewFpsRange();
if (listFpsRange == null || listFpsRange.size() == 0) {
Log.e(TAG, "allocate: no fps range found");
return false;
}
int frameRateInMs = frameRate * 1000;
// Use the first range as default.
int[] fpsMinMax = listFpsRange.get(0);
int newFrameRate = (fpsMinMax[0] + 999) / 1000;
for (int[] fpsRange : listFpsRange) {
if (fpsRange[0] <= frameRateInMs && frameRateInMs <= fpsRange[1]) {
fpsMinMax = fpsRange;
newFrameRate = frameRate;
break;
}
}
frameRate = newFrameRate;
Log.d(TAG, "allocate: fps set to " + frameRate);
// Calculate size.
List<Camera.Size> listCameraSize = parameters.getSupportedPreviewSizes();
int minDiff = Integer.MAX_VALUE;
int matchedWidth = width;
int matchedHeight = height;
for (Camera.Size size : listCameraSize) {
int diff = Math.abs(size.width - width) + Math.abs(size.height - height);
Log.d(TAG, "allocate: supported (" + size.width + ", " + size.height + "), diff=" + diff);
// TODO(wjia): Remove this hack (forcing width to be multiple
// of 32) by supporting stride in video frame buffer.
// Right now, VideoCaptureController requires compact YV12
// (i.e., with no padding).
if (diff < minDiff && (size.width % 32 == 0)) {
minDiff = diff;
matchedWidth = size.width;
matchedHeight = size.height;
}
}
if (minDiff == Integer.MAX_VALUE) {
Log.e(TAG, "allocate: can not find a multiple-of-32 resolution");
return false;
}
mCaptureFormat =
new CaptureFormat(matchedWidth, matchedHeight, frameRate, BuggyDeviceHack.getImageFormat());
// Hack to avoid certain capture resolutions under a minimum one,
// see http://crbug.com/305294
BuggyDeviceHack.applyMinDimensions(mCaptureFormat);
Log.d(TAG, "allocate: matched (" + mCaptureFormat.mWidth + "x" + mCaptureFormat.mHeight + ")");
if (parameters.isVideoStabilizationSupported()) {
Log.d(
TAG,
"Image stabilization supported, currently: "
+ parameters.getVideoStabilization()
+ ", setting it.");
parameters.setVideoStabilization(true);
} else {
Log.d(TAG, "Image stabilization not supported.");
}
parameters.setPreviewSize(mCaptureFormat.mWidth, mCaptureFormat.mHeight);
parameters.setPreviewFormat(mCaptureFormat.mPixelFormat);
parameters.setPreviewFpsRange(fpsMinMax[0], fpsMinMax[1]);
mCamera.setParameters(parameters);
// Set SurfaceTexture. Android Capture needs a SurfaceTexture even if
// it is not going to be used.
mGlTextures = new int[1];
// Generate one texture pointer and bind it as an external texture.
GLES20.glGenTextures(1, mGlTextures, 0);
GLES20.glBindTexture(GL_TEXTURE_EXTERNAL_OES, mGlTextures[0]);
// No mip-mapping with camera source.
GLES20.glTexParameterf(GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR);
GLES20.glTexParameterf(GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
// Clamp to edge is only option.
GLES20.glTexParameteri(
GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE);
GLES20.glTexParameteri(
GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE);
mSurfaceTexture = new SurfaceTexture(mGlTextures[0]);
mSurfaceTexture.setOnFrameAvailableListener(null);
try {
mCamera.setPreviewTexture(mSurfaceTexture);
} catch (IOException ex) {
Log.e(TAG, "allocate: " + ex);
return false;
}
int bufSize =
mCaptureFormat.mWidth
* mCaptureFormat.mHeight
* ImageFormat.getBitsPerPixel(mCaptureFormat.mPixelFormat)
/ 8;
for (int i = 0; i < NUM_CAPTURE_BUFFERS; i++) {
byte[] buffer = new byte[bufSize];
mCamera.addCallbackBuffer(buffer);
}
mExpectedFrameSize = bufSize;
return true;
}
/**
* Set the legacy parameters using the {@link LegacyRequest legacy request}.
*
* <p>The legacy request's parameters are changed as a side effect of calling this method.
*
* @param legacyRequest a non-{@code null} legacy request
*/
public static void convertRequestMetadata(LegacyRequest legacyRequest) {
CameraCharacteristics characteristics = legacyRequest.characteristics;
CaptureRequest request = legacyRequest.captureRequest;
Size previewSize = legacyRequest.previewSize;
Camera.Parameters params = legacyRequest.parameters;
Rect activeArray = characteristics.get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE);
/*
* scaler.cropRegion
*/
ParameterUtils.ZoomData zoomData;
{
zoomData =
ParameterUtils.convertScalerCropRegion(
activeArray, request.get(SCALER_CROP_REGION), previewSize, params);
if (params.isZoomSupported()) {
params.setZoom(zoomData.zoomIndex);
} else if (VERBOSE) {
Log.v(TAG, "convertRequestToMetadata - zoom is not supported");
}
}
/*
* colorCorrection.*
*/
// colorCorrection.aberrationMode
{
int aberrationMode =
ParamsUtils.getOrDefault(
request,
COLOR_CORRECTION_ABERRATION_MODE,
/*defaultValue*/ COLOR_CORRECTION_ABERRATION_MODE_FAST);
if (aberrationMode != COLOR_CORRECTION_ABERRATION_MODE_FAST) {
Log.w(
TAG,
"convertRequestToMetadata - Ignoring unsupported "
+ "colorCorrection.aberrationMode = "
+ aberrationMode);
}
}
/*
* control.ae*
*/
// control.aeAntibandingMode
{
String legacyMode;
Integer antiBandingMode = request.get(CONTROL_AE_ANTIBANDING_MODE);
if (antiBandingMode != null) {
legacyMode = convertAeAntiBandingModeToLegacy(antiBandingMode);
} else {
legacyMode =
ListUtils.listSelectFirstFrom(
params.getSupportedAntibanding(),
new String[] {
Parameters.ANTIBANDING_AUTO,
Parameters.ANTIBANDING_OFF,
Parameters.ANTIBANDING_50HZ,
Parameters.ANTIBANDING_60HZ,
});
}
if (legacyMode != null) {
params.setAntibanding(legacyMode);
}
}
/*
* control.aeRegions, afRegions
*/
{
// aeRegions
{
// Use aeRegions if available, fall back to using awbRegions if present
MeteringRectangle[] aeRegions = request.get(CONTROL_AE_REGIONS);
if (request.get(CONTROL_AWB_REGIONS) != null) {
Log.w(
TAG,
"convertRequestMetadata - control.awbRegions setting is not "
+ "supported, ignoring value");
}
int maxNumMeteringAreas = params.getMaxNumMeteringAreas();
List<Camera.Area> meteringAreaList =
convertMeteringRegionsToLegacy(
activeArray, zoomData, aeRegions, maxNumMeteringAreas, /*regionName*/ "AE");
// WAR: for b/17252693, some devices can't handle params.setFocusAreas(null).
if (maxNumMeteringAreas > 0) {
params.setMeteringAreas(meteringAreaList);
}
}
// afRegions
{
MeteringRectangle[] afRegions = request.get(CONTROL_AF_REGIONS);
int maxNumFocusAreas = params.getMaxNumFocusAreas();
List<Camera.Area> focusAreaList =
convertMeteringRegionsToLegacy(
activeArray, zoomData, afRegions, maxNumFocusAreas, /*regionName*/ "AF");
// WAR: for b/17252693, some devices can't handle params.setFocusAreas(null).
if (maxNumFocusAreas > 0) {
params.setFocusAreas(focusAreaList);
}
}
}
// control.aeTargetFpsRange
Range<Integer> aeFpsRange = request.get(CONTROL_AE_TARGET_FPS_RANGE);
if (aeFpsRange != null) {
int[] legacyFps = convertAeFpsRangeToLegacy(aeFpsRange);
// TODO - Should we enforce that all HAL1 devices must include (30, 30) FPS range?
boolean supported = false;
for (int[] range : params.getSupportedPreviewFpsRange()) {
if (legacyFps[0] == range[0] && legacyFps[1] == range[1]) {
supported = true;
break;
}
}
if (supported) {
params.setPreviewFpsRange(
legacyFps[Camera.Parameters.PREVIEW_FPS_MIN_INDEX],
legacyFps[Camera.Parameters.PREVIEW_FPS_MAX_INDEX]);
} else {
Log.w(TAG, "Unsupported FPS range set [" + legacyFps[0] + "," + legacyFps[1] + "]");
}
}
/*
* control
*/
// control.aeExposureCompensation
{
Range<Integer> compensationRange =
characteristics.get(CameraCharacteristics.CONTROL_AE_COMPENSATION_RANGE);
int compensation =
ParamsUtils.getOrDefault(request, CONTROL_AE_EXPOSURE_COMPENSATION, /*defaultValue*/ 0);
if (!compensationRange.contains(compensation)) {
Log.w(
TAG,
"convertRequestMetadata - control.aeExposureCompensation "
+ "is out of range, ignoring value");
compensation = 0;
}
params.setExposureCompensation(compensation);
}
// control.aeLock
{
Boolean aeLock =
getIfSupported(
request,
CONTROL_AE_LOCK, /*defaultValue*/
false,
params.isAutoExposureLockSupported(),
/*allowedValue*/ false);
if (aeLock != null) {
params.setAutoExposureLock(aeLock);
}
if (VERBOSE) {
Log.v(TAG, "convertRequestToMetadata - control.aeLock set to " + aeLock);
}
// TODO: Don't add control.aeLock to availableRequestKeys if it's not supported
}
// control.aeMode, flash.mode
mapAeAndFlashMode(request, /*out*/ params);
// control.afMode
{
int afMode =
ParamsUtils.getOrDefault(request, CONTROL_AF_MODE, /*defaultValue*/ CONTROL_AF_MODE_OFF);
String focusMode =
LegacyMetadataMapper.convertAfModeToLegacy(afMode, params.getSupportedFocusModes());
if (focusMode != null) {
params.setFocusMode(focusMode);
}
if (VERBOSE) {
Log.v(
TAG, "convertRequestToMetadata - control.afMode " + afMode + " mapped to " + focusMode);
}
}
// control.awbMode
{
Integer awbMode =
getIfSupported(
request,
CONTROL_AWB_MODE,
/*defaultValue*/ CONTROL_AWB_MODE_AUTO,
params.getSupportedWhiteBalance() != null,
/*allowedValue*/ CONTROL_AWB_MODE_AUTO);
String whiteBalanceMode = null;
if (awbMode != null) { // null iff AWB is not supported by camera1 api
whiteBalanceMode = convertAwbModeToLegacy(awbMode);
params.setWhiteBalance(whiteBalanceMode);
}
if (VERBOSE) {
Log.v(
TAG,
"convertRequestToMetadata - control.awbMode "
+ awbMode
+ " mapped to "
+ whiteBalanceMode);
}
}
// control.awbLock
{
Boolean awbLock =
getIfSupported(
request,
CONTROL_AWB_LOCK, /*defaultValue*/
false,
params.isAutoWhiteBalanceLockSupported(),
/*allowedValue*/ false);
if (awbLock != null) {
params.setAutoWhiteBalanceLock(awbLock);
}
// TODO: Don't add control.awbLock to availableRequestKeys if it's not supported
}
// control.captureIntent
{
int captureIntent =
ParamsUtils.getOrDefault(
request, CONTROL_CAPTURE_INTENT, /*defaultValue*/ CONTROL_CAPTURE_INTENT_PREVIEW);
captureIntent = filterSupportedCaptureIntent(captureIntent);
params.setRecordingHint(
captureIntent == CONTROL_CAPTURE_INTENT_VIDEO_RECORD
|| captureIntent == CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT);
}
// control.videoStabilizationMode
{
Integer stabMode =
getIfSupported(
request,
CONTROL_VIDEO_STABILIZATION_MODE,
/*defaultValue*/ CONTROL_VIDEO_STABILIZATION_MODE_OFF,
params.isVideoStabilizationSupported(),
/*allowedValue*/ CONTROL_VIDEO_STABILIZATION_MODE_OFF);
if (stabMode != null) {
params.setVideoStabilization(stabMode == CONTROL_VIDEO_STABILIZATION_MODE_ON);
}
}
// lens.focusDistance
{
boolean infinityFocusSupported =
ListUtils.listContains(params.getSupportedFocusModes(), Parameters.FOCUS_MODE_INFINITY);
Float focusDistance =
getIfSupported(
request,
LENS_FOCUS_DISTANCE,
/*defaultValue*/ 0f,
infinityFocusSupported, /*allowedValue*/
0f);
if (focusDistance == null || focusDistance != 0f) {
Log.w(
TAG,
"convertRequestToMetadata - Ignoring android.lens.focusDistance "
+ infinityFocusSupported
+ ", only 0.0f is supported");
}
}
// control.sceneMode, control.mode
{
// TODO: Map FACE_PRIORITY scene mode to face detection.
if (params.getSupportedSceneModes() != null) {
int controlMode =
ParamsUtils.getOrDefault(request, CONTROL_MODE, /*defaultValue*/ CONTROL_MODE_AUTO);
String modeToSet;
switch (controlMode) {
case CONTROL_MODE_USE_SCENE_MODE:
{
int sceneMode =
ParamsUtils.getOrDefault(
request, CONTROL_SCENE_MODE, /*defaultValue*/ CONTROL_SCENE_MODE_DISABLED);
String legacySceneMode = LegacyMetadataMapper.convertSceneModeToLegacy(sceneMode);
if (legacySceneMode != null) {
modeToSet = legacySceneMode;
} else {
modeToSet = Parameters.SCENE_MODE_AUTO;
Log.w(TAG, "Skipping unknown requested scene mode: " + sceneMode);
}
break;
}
case CONTROL_MODE_AUTO:
{
modeToSet = Parameters.SCENE_MODE_AUTO;
break;
}
default:
{
Log.w(TAG, "Control mode " + controlMode + " is unsupported, defaulting to AUTO");
modeToSet = Parameters.SCENE_MODE_AUTO;
}
}
params.setSceneMode(modeToSet);
}
}
// control.effectMode
{
if (params.getSupportedColorEffects() != null) {
int effectMode =
ParamsUtils.getOrDefault(
request, CONTROL_EFFECT_MODE, /*defaultValue*/ CONTROL_EFFECT_MODE_OFF);
String legacyEffectMode = LegacyMetadataMapper.convertEffectModeToLegacy(effectMode);
if (legacyEffectMode != null) {
params.setColorEffect(legacyEffectMode);
} else {
params.setColorEffect(Parameters.EFFECT_NONE);
Log.w(TAG, "Skipping unknown requested effect mode: " + effectMode);
}
}
}
/*
* sensor
*/
// sensor.testPattern
{
int testPatternMode =
ParamsUtils.getOrDefault(
request, SENSOR_TEST_PATTERN_MODE, /*defaultValue*/ SENSOR_TEST_PATTERN_MODE_OFF);
if (testPatternMode != SENSOR_TEST_PATTERN_MODE_OFF) {
Log.w(
TAG,
"convertRequestToMetadata - ignoring sensor.testPatternMode "
+ testPatternMode
+ "; only OFF is supported");
}
}
/*
* jpeg.*
*/
// jpeg.gpsLocation
{
Location location = request.get(JPEG_GPS_LOCATION);
if (location != null) {
if (checkForCompleteGpsData(location)) {
params.setGpsAltitude(location.getAltitude());
params.setGpsLatitude(location.getLatitude());
params.setGpsLongitude(location.getLongitude());
params.setGpsProcessingMethod(location.getProvider().toUpperCase());
params.setGpsTimestamp(location.getTime());
} else {
Log.w(TAG, "Incomplete GPS parameters provided in location " + location);
}
} else {
params.removeGpsData();
}
}
// jpeg.orientation
{
Integer orientation = request.get(CaptureRequest.JPEG_ORIENTATION);
params.setRotation(
ParamsUtils.getOrDefault(
request, JPEG_ORIENTATION, (orientation == null) ? 0 : orientation));
}
// jpeg.quality
{
params.setJpegQuality(
0xFF & ParamsUtils.getOrDefault(request, JPEG_QUALITY, DEFAULT_JPEG_QUALITY));
}
// jpeg.thumbnailQuality
{
params.setJpegThumbnailQuality(
0xFF & ParamsUtils.getOrDefault(request, JPEG_THUMBNAIL_QUALITY, DEFAULT_JPEG_QUALITY));
}
// jpeg.thumbnailSize
{
List<Camera.Size> sizes = params.getSupportedJpegThumbnailSizes();
if (sizes != null && sizes.size() > 0) {
Size s = request.get(JPEG_THUMBNAIL_SIZE);
boolean invalidSize =
(s == null) ? false : !ParameterUtils.containsSize(sizes, s.getWidth(), s.getHeight());
if (invalidSize) {
Log.w(TAG, "Invalid JPEG thumbnail size set " + s + ", skipping thumbnail...");
}
if (s == null || invalidSize) {
// (0,0) = "no thumbnail" in Camera API 1
params.setJpegThumbnailSize(/*width*/ 0, /*height*/ 0);
} else {
params.setJpegThumbnailSize(s.getWidth(), s.getHeight());
}
}
}
/*
* noiseReduction.*
*/
// noiseReduction.mode
{
int mode =
ParamsUtils.getOrDefault(
request, NOISE_REDUCTION_MODE, /*defaultValue*/ NOISE_REDUCTION_MODE_FAST);
if (mode != NOISE_REDUCTION_MODE_FAST) {
Log.w(
TAG,
"convertRequestToMetadata - Ignoring unsupported " + "noiseReduction.mode = " + mode);
}
}
}