| /* |
| * 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 static android.hardware.camera2.CaptureRequest.*; |
| |
| import android.graphics.Matrix; |
| import android.graphics.Rect; |
| import android.graphics.RectF; |
| import android.hardware.camera2.CameraAccessException; |
| import android.hardware.camera2.CameraDevice; |
| import android.hardware.camera2.params.MeteringRectangle; |
| import android.location.Location; |
| import android.util.Range; |
| |
| import com.android.ex.camera2.portability.CameraCapabilities.FlashMode; |
| import com.android.ex.camera2.portability.CameraCapabilities.FocusMode; |
| import com.android.ex.camera2.portability.CameraCapabilities.SceneMode; |
| import com.android.ex.camera2.portability.CameraCapabilities.WhiteBalance; |
| import com.android.ex.camera2.portability.debug.Log; |
| import com.android.ex.camera2.utils.Camera2RequestSettingsSet; |
| |
| import java.util.List; |
| import java.util.Objects; |
| |
| /** |
| * The subclass of {@link CameraSettings} for Android Camera 2 API. |
| */ |
| public class AndroidCamera2Settings extends CameraSettings { |
| private static final Log.Tag TAG = new Log.Tag("AndCam2Set"); |
| |
| private final Builder mTemplateSettings; |
| private final Camera2RequestSettingsSet mRequestSettings; |
| /** Sensor's active array bounds. */ |
| private final Rect mActiveArray; |
| /** Crop rectangle for digital zoom (measured WRT the active array). */ |
| private final Rect mCropRectangle; |
| /** Bounds of visible preview portion (measured WRT the active array). */ |
| private Rect mVisiblePreviewRectangle; |
| |
| /** |
| * Create a settings representation that answers queries of unspecified |
| * options in the same way as the provided template would. |
| * |
| * <p>The default settings provided by the given template are only ever used |
| * for reporting back to the client app (i.e. when it queries an option |
| * it didn't explicitly set first). {@link Camera2RequestSettingsSet}s |
| * generated by an instance of this class will have any settings not |
| * modified using one of that instance's mutators forced to default, so that |
| * their effective values when submitting a capture request will be those of |
| * the template that is provided to the camera framework at that time.</p> |
| * |
| * @param camera Device from which to draw default settings |
| * (non-{@code null}). |
| * @param template Specific template to use for the defaults. |
| * @param activeArray Boundary coordinates of the sensor's active array |
| * (non-{@code null}). |
| * @param preview Dimensions of preview streams. |
| * @param photo Dimensions of captured images. |
| * |
| * @throws IllegalArgumentException If {@code camera} or {@code activeArray} |
| * is {@code null}. |
| * @throws CameraAccessException Upon internal framework/driver failure. |
| */ |
| public AndroidCamera2Settings(CameraDevice camera, int template, Rect activeArray, |
| Size preview, Size photo) throws CameraAccessException { |
| if (camera == null) { |
| throw new NullPointerException("camera must not be null"); |
| } |
| if (activeArray == null) { |
| throw new NullPointerException("activeArray must not be null"); |
| } |
| |
| mTemplateSettings = camera.createCaptureRequest(template); |
| mRequestSettings = new Camera2RequestSettingsSet(); |
| mActiveArray = activeArray; |
| mCropRectangle = new Rect(0, 0, activeArray.width(), activeArray.height()); |
| |
| mSizesLocked = false; |
| |
| Range<Integer> previewFpsRange = mTemplateSettings.get(CONTROL_AE_TARGET_FPS_RANGE); |
| if (previewFpsRange != null) { |
| setPreviewFpsRange(previewFpsRange.getLower(), previewFpsRange.getUpper()); |
| } |
| setPreviewSize(preview); |
| // TODO: mCurrentPreviewFormat |
| setPhotoSize(photo); |
| mJpegCompressQuality = queryTemplateDefaultOrMakeOneUp(JPEG_QUALITY, (byte) 0); |
| // TODO: mCurrentPhotoFormat |
| // NB: We're assuming that templates won't be zoomed in by default. |
| mCurrentZoomRatio = CameraCapabilities.ZOOM_RATIO_UNZOOMED; |
| // TODO: mCurrentZoomIndex |
| mExposureCompensationIndex = |
| queryTemplateDefaultOrMakeOneUp(CONTROL_AE_EXPOSURE_COMPENSATION, 0); |
| |
| mCurrentFlashMode = flashModeFromRequest(); |
| Integer currentFocusMode = mTemplateSettings.get(CONTROL_AF_MODE); |
| if (currentFocusMode != null) { |
| mCurrentFocusMode = AndroidCamera2Capabilities.focusModeFromInt(currentFocusMode); |
| } |
| Integer currentSceneMode = mTemplateSettings.get(CONTROL_SCENE_MODE); |
| if (currentSceneMode != null) { |
| mCurrentSceneMode = AndroidCamera2Capabilities.sceneModeFromInt(currentSceneMode); |
| } |
| Integer whiteBalance = mTemplateSettings.get(CONTROL_AWB_MODE); |
| if (whiteBalance != null) { |
| mWhiteBalance = AndroidCamera2Capabilities.whiteBalanceFromInt(whiteBalance); |
| } |
| |
| mVideoStabilizationEnabled = queryTemplateDefaultOrMakeOneUp( |
| CONTROL_VIDEO_STABILIZATION_MODE, CONTROL_VIDEO_STABILIZATION_MODE_OFF) == |
| CONTROL_VIDEO_STABILIZATION_MODE_ON; |
| mAutoExposureLocked = queryTemplateDefaultOrMakeOneUp(CONTROL_AE_LOCK, false); |
| mAutoWhiteBalanceLocked = queryTemplateDefaultOrMakeOneUp(CONTROL_AWB_LOCK, false); |
| // TODO: mRecordingHintEnabled |
| // TODO: mGpsData |
| android.util.Size exifThumbnailSize = mTemplateSettings.get(JPEG_THUMBNAIL_SIZE); |
| if (exifThumbnailSize != null) { |
| mExifThumbnailSize = |
| new Size(exifThumbnailSize.getWidth(), exifThumbnailSize.getHeight()); |
| } |
| } |
| |
| public AndroidCamera2Settings(AndroidCamera2Settings other) { |
| super(other); |
| mTemplateSettings = other.mTemplateSettings; |
| mRequestSettings = new Camera2RequestSettingsSet(other.mRequestSettings); |
| mActiveArray = other.mActiveArray; |
| mCropRectangle = new Rect(other.mCropRectangle); |
| } |
| |
| @Override |
| public CameraSettings copy() { |
| return new AndroidCamera2Settings(this); |
| } |
| |
| private <T> T queryTemplateDefaultOrMakeOneUp(Key<T> key, T defaultDefault) { |
| T val = mTemplateSettings.get(key); |
| if (val != null) { |
| return val; |
| } else { |
| // Spoof the default so matchesTemplateDefault excludes this key from generated sets. |
| // This approach beats a simple sentinel because it provides basic boolean support. |
| mTemplateSettings.set(key, defaultDefault); |
| return defaultDefault; |
| } |
| } |
| |
| private FlashMode flashModeFromRequest() { |
| Integer autoExposure = mTemplateSettings.get(CONTROL_AE_MODE); |
| if (autoExposure != null) { |
| switch (autoExposure) { |
| case CONTROL_AE_MODE_ON: |
| return FlashMode.OFF; |
| case CONTROL_AE_MODE_ON_AUTO_FLASH: |
| return FlashMode.AUTO; |
| case CONTROL_AE_MODE_ON_ALWAYS_FLASH: { |
| if (mTemplateSettings.get(FLASH_MODE) == FLASH_MODE_TORCH) { |
| return FlashMode.TORCH; |
| } else { |
| return FlashMode.ON; |
| } |
| } |
| case CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE: |
| return FlashMode.RED_EYE; |
| } |
| } |
| return null; |
| } |
| |
| @Override |
| public void setZoomRatio(float ratio) { |
| super.setZoomRatio(ratio); |
| |
| // Compute the crop rectangle to be passed to the framework |
| mCropRectangle.set(0, 0, |
| toIntConstrained( |
| mActiveArray.width() / mCurrentZoomRatio, 0, mActiveArray.width()), |
| toIntConstrained( |
| mActiveArray.height() / mCurrentZoomRatio, 0, mActiveArray.height())); |
| mCropRectangle.offsetTo((mActiveArray.width() - mCropRectangle.width()) / 2, |
| (mActiveArray.height() - mCropRectangle.height()) / 2); |
| |
| // Compute the effective crop rectangle to be used for computing focus/metering coordinates |
| mVisiblePreviewRectangle = |
| effectiveCropRectFromRequested(mCropRectangle, mCurrentPreviewSize); |
| } |
| |
| private boolean matchesTemplateDefault(Key<?> setting) { |
| if (setting == CONTROL_AE_REGIONS) { |
| return mMeteringAreas.size() == 0; |
| } else if (setting == CONTROL_AF_REGIONS) { |
| return mFocusAreas.size() == 0; |
| } else if (setting == CONTROL_AE_TARGET_FPS_RANGE) { |
| Range<Integer> defaultFpsRange = mTemplateSettings.get(CONTROL_AE_TARGET_FPS_RANGE); |
| return (mPreviewFpsRangeMin == 0 && mPreviewFpsRangeMax == 0) || |
| (defaultFpsRange != null && mPreviewFpsRangeMin == defaultFpsRange.getLower() && |
| mPreviewFpsRangeMax == defaultFpsRange.getUpper()); |
| } else if (setting == JPEG_QUALITY) { |
| return Objects.equals(mJpegCompressQuality, |
| mTemplateSettings.get(JPEG_QUALITY)); |
| } else if (setting == CONTROL_AE_EXPOSURE_COMPENSATION) { |
| return Objects.equals(mExposureCompensationIndex, |
| mTemplateSettings.get(CONTROL_AE_EXPOSURE_COMPENSATION)); |
| } else if (setting == CONTROL_VIDEO_STABILIZATION_MODE) { |
| Integer videoStabilization = mTemplateSettings.get(CONTROL_VIDEO_STABILIZATION_MODE); |
| return (videoStabilization != null && |
| (mVideoStabilizationEnabled && videoStabilization == |
| CONTROL_VIDEO_STABILIZATION_MODE_ON) || |
| (!mVideoStabilizationEnabled && videoStabilization == |
| CONTROL_VIDEO_STABILIZATION_MODE_OFF)); |
| } else if (setting == CONTROL_AE_LOCK) { |
| return Objects.equals(mAutoExposureLocked, mTemplateSettings.get(CONTROL_AE_LOCK)); |
| } else if (setting == CONTROL_AWB_LOCK) { |
| return Objects.equals(mAutoWhiteBalanceLocked, mTemplateSettings.get(CONTROL_AWB_LOCK)); |
| } else if (setting == JPEG_THUMBNAIL_SIZE) { |
| if (mExifThumbnailSize == null) { |
| // It doesn't matter if this is true or false since setting this |
| // to null in the request settings will use the default anyway. |
| return false; |
| } |
| android.util.Size defaultThumbnailSize = mTemplateSettings.get(JPEG_THUMBNAIL_SIZE); |
| return (mExifThumbnailSize.width() == 0 && mExifThumbnailSize.height() == 0) || |
| (defaultThumbnailSize != null && |
| mExifThumbnailSize.width() == defaultThumbnailSize.getWidth() && |
| mExifThumbnailSize.height() == defaultThumbnailSize.getHeight()); |
| } |
| Log.w(TAG, "Settings implementation checked default of unhandled option key"); |
| // Since this class isn't equipped to handle it, claim it matches the default to prevent |
| // updateRequestSettingOrForceToDefault from going with the user-provided preference |
| return true; |
| } |
| |
| private <T> void updateRequestSettingOrForceToDefault(Key<T> setting, T possibleChoice) { |
| mRequestSettings.set(setting, matchesTemplateDefault(setting) ? null : possibleChoice); |
| } |
| |
| public Camera2RequestSettingsSet getRequestSettings() { |
| updateRequestSettingOrForceToDefault(CONTROL_AE_REGIONS, |
| legacyAreasToMeteringRectangles(mMeteringAreas)); |
| updateRequestSettingOrForceToDefault(CONTROL_AF_REGIONS, |
| legacyAreasToMeteringRectangles(mFocusAreas)); |
| updateRequestSettingOrForceToDefault(CONTROL_AE_TARGET_FPS_RANGE, |
| new Range(mPreviewFpsRangeMin, mPreviewFpsRangeMax)); |
| // TODO: mCurrentPreviewFormat |
| updateRequestSettingOrForceToDefault(JPEG_QUALITY, mJpegCompressQuality); |
| // TODO: mCurrentPhotoFormat |
| mRequestSettings.set(SCALER_CROP_REGION, mCropRectangle); |
| // TODO: mCurrentZoomIndex |
| updateRequestSettingOrForceToDefault(CONTROL_AE_EXPOSURE_COMPENSATION, |
| mExposureCompensationIndex); |
| updateRequestFlashMode(); |
| updateRequestFocusMode(); |
| updateRequestSceneMode(); |
| updateRequestWhiteBalance(); |
| updateRequestSettingOrForceToDefault(CONTROL_VIDEO_STABILIZATION_MODE, |
| mVideoStabilizationEnabled ? |
| CONTROL_VIDEO_STABILIZATION_MODE_ON : CONTROL_VIDEO_STABILIZATION_MODE_OFF); |
| // OIS shouldn't be on if software video stabilization is. |
| mRequestSettings.set(LENS_OPTICAL_STABILIZATION_MODE, |
| mVideoStabilizationEnabled ? LENS_OPTICAL_STABILIZATION_MODE_OFF : |
| null); |
| updateRequestSettingOrForceToDefault(CONTROL_AE_LOCK, mAutoExposureLocked); |
| updateRequestSettingOrForceToDefault(CONTROL_AWB_LOCK, mAutoWhiteBalanceLocked); |
| // TODO: mRecordingHintEnabled |
| updateRequestGpsData(); |
| if (mExifThumbnailSize != null) { |
| updateRequestSettingOrForceToDefault(JPEG_THUMBNAIL_SIZE, |
| new android.util.Size( |
| mExifThumbnailSize.width(), mExifThumbnailSize.height())); |
| } else { |
| updateRequestSettingOrForceToDefault(JPEG_THUMBNAIL_SIZE, null); |
| } |
| |
| return mRequestSettings; |
| } |
| |
| private MeteringRectangle[] legacyAreasToMeteringRectangles( |
| List<android.hardware.Camera.Area> reference) { |
| MeteringRectangle[] transformed = null; |
| if (reference.size() > 0) { |
| transformed = new MeteringRectangle[reference.size()]; |
| for (int index = 0; index < reference.size(); ++index) { |
| android.hardware.Camera.Area source = reference.get(index); |
| Rect rectangle = source.rect; |
| |
| // Old API coordinates were [-1000,1000]; new ones are [0,ACTIVE_ARRAY_SIZE). |
| // We're also going from preview image--relative to sensor active array--relative. |
| double oldLeft = (rectangle.left + 1000) / 2000.0; |
| double oldTop = (rectangle.top + 1000) / 2000.0; |
| double oldRight = (rectangle.right + 1000) / 2000.0; |
| double oldBottom = (rectangle.bottom + 1000) / 2000.0; |
| int left = mCropRectangle.left + toIntConstrained( |
| mCropRectangle.width() * oldLeft, 0, mCropRectangle.width() - 1); |
| int top = mCropRectangle.top + toIntConstrained( |
| mCropRectangle.height() * oldTop, 0, mCropRectangle.height() - 1); |
| int right = mCropRectangle.left + toIntConstrained( |
| mCropRectangle.width() * oldRight, 0, mCropRectangle.width() - 1); |
| int bottom = mCropRectangle.top + toIntConstrained( |
| mCropRectangle.height() * oldBottom, 0, mCropRectangle.height() - 1); |
| transformed[index] = new MeteringRectangle(left, top, right - left, bottom - top, |
| source.weight); |
| } |
| } |
| return transformed; |
| } |
| |
| private int toIntConstrained(double original, int min, int max) { |
| original = Math.max(original, min); |
| original = Math.min(original, max); |
| return (int) original; |
| } |
| |
| private void updateRequestFlashMode() { |
| Integer aeMode = null; |
| Integer flashMode = null; |
| if (mCurrentFlashMode != null) { |
| switch (mCurrentFlashMode) { |
| case AUTO: { |
| aeMode = CONTROL_AE_MODE_ON_AUTO_FLASH; |
| break; |
| } |
| case OFF: { |
| aeMode = CONTROL_AE_MODE_ON; |
| flashMode = FLASH_MODE_OFF; |
| break; |
| } |
| case ON: { |
| aeMode = CONTROL_AE_MODE_ON_ALWAYS_FLASH; |
| flashMode = FLASH_MODE_SINGLE; |
| break; |
| } |
| case TORCH: { |
| flashMode = FLASH_MODE_TORCH; |
| break; |
| } |
| case RED_EYE: { |
| aeMode = CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE; |
| break; |
| } |
| default: { |
| Log.w(TAG, "Unable to convert to API 2 flash mode: " + mCurrentFlashMode); |
| break; |
| } |
| } |
| } |
| mRequestSettings.set(CONTROL_AE_MODE, aeMode); |
| mRequestSettings.set(FLASH_MODE, flashMode); |
| } |
| |
| private void updateRequestFocusMode() { |
| Integer mode = null; |
| if (mCurrentFocusMode != null) { |
| switch (mCurrentFocusMode) { |
| case AUTO: { |
| mode = CONTROL_AF_MODE_AUTO; |
| break; |
| } |
| case CONTINUOUS_PICTURE: { |
| mode = CONTROL_AF_MODE_CONTINUOUS_PICTURE; |
| break; |
| } |
| case CONTINUOUS_VIDEO: { |
| mode = CONTROL_AF_MODE_CONTINUOUS_VIDEO; |
| break; |
| } |
| case EXTENDED_DOF: { |
| mode = CONTROL_AF_MODE_EDOF; |
| break; |
| } |
| case FIXED: { |
| mode = CONTROL_AF_MODE_OFF; |
| break; |
| } |
| // TODO: We cannot support INFINITY |
| case MACRO: { |
| mode = CONTROL_AF_MODE_MACRO; |
| break; |
| } |
| default: { |
| Log.w(TAG, "Unable to convert to API 2 focus mode: " + mCurrentFocusMode); |
| break; |
| } |
| } |
| } |
| mRequestSettings.set(CONTROL_AF_MODE, mode); |
| } |
| |
| private void updateRequestSceneMode() { |
| Integer mode = null; |
| if (mCurrentSceneMode != null) { |
| switch (mCurrentSceneMode) { |
| case AUTO: { |
| mode = CONTROL_SCENE_MODE_DISABLED; |
| break; |
| } |
| case ACTION: { |
| mode = CONTROL_SCENE_MODE_ACTION; |
| break; |
| } |
| case BARCODE: { |
| mode = CONTROL_SCENE_MODE_BARCODE; |
| break; |
| } |
| case BEACH: { |
| mode = CONTROL_SCENE_MODE_BEACH; |
| break; |
| } |
| case CANDLELIGHT: { |
| mode = CONTROL_SCENE_MODE_CANDLELIGHT; |
| break; |
| } |
| case FIREWORKS: { |
| mode = CONTROL_SCENE_MODE_FIREWORKS; |
| break; |
| } |
| case HDR: { |
| mode = CONTROL_SCENE_MODE_HDR; |
| break; |
| } |
| case LANDSCAPE: { |
| mode = CONTROL_SCENE_MODE_LANDSCAPE; |
| break; |
| } |
| case NIGHT: { |
| mode = CONTROL_SCENE_MODE_NIGHT; |
| break; |
| } |
| // TODO: We cannot support NIGHT_PORTRAIT |
| case PARTY: { |
| mode = CONTROL_SCENE_MODE_PARTY; |
| break; |
| } |
| case PORTRAIT: { |
| mode = CONTROL_SCENE_MODE_PORTRAIT; |
| break; |
| } |
| case SNOW: { |
| mode = CONTROL_SCENE_MODE_SNOW; |
| break; |
| } |
| case SPORTS: { |
| mode = CONTROL_SCENE_MODE_SPORTS; |
| break; |
| } |
| case STEADYPHOTO: { |
| mode = CONTROL_SCENE_MODE_STEADYPHOTO; |
| break; |
| } |
| case SUNSET: { |
| mode = CONTROL_SCENE_MODE_SUNSET; |
| break; |
| } |
| case THEATRE: { |
| mode = CONTROL_SCENE_MODE_THEATRE; |
| break; |
| } |
| default: { |
| Log.w(TAG, "Unable to convert to API 2 scene mode: " + mCurrentSceneMode); |
| break; |
| } |
| } |
| } |
| mRequestSettings.set(CONTROL_SCENE_MODE, mode); |
| } |
| |
| private void updateRequestWhiteBalance() { |
| Integer mode = null; |
| if (mWhiteBalance != null) { |
| switch (mWhiteBalance) { |
| case AUTO: { |
| mode = CONTROL_AWB_MODE_AUTO; |
| break; |
| } |
| case CLOUDY_DAYLIGHT: { |
| mode = CONTROL_AWB_MODE_CLOUDY_DAYLIGHT; |
| break; |
| } |
| case DAYLIGHT: { |
| mode = CONTROL_AWB_MODE_DAYLIGHT; |
| break; |
| } |
| case FLUORESCENT: { |
| mode = CONTROL_AWB_MODE_FLUORESCENT; |
| break; |
| } |
| case INCANDESCENT: { |
| mode = CONTROL_AWB_MODE_INCANDESCENT; |
| break; |
| } |
| case SHADE: { |
| mode = CONTROL_AWB_MODE_SHADE; |
| break; |
| } |
| case TWILIGHT: { |
| mode = CONTROL_AWB_MODE_TWILIGHT; |
| break; |
| } |
| case WARM_FLUORESCENT: { |
| mode = CONTROL_AWB_MODE_WARM_FLUORESCENT; |
| break; |
| } |
| default: { |
| Log.w(TAG, "Unable to convert to API 2 white balance: " + mWhiteBalance); |
| break; |
| } |
| } |
| } |
| mRequestSettings.set(CONTROL_AWB_MODE, mode); |
| } |
| |
| private void updateRequestGpsData() { |
| if (mGpsData == null || mGpsData.processingMethod == null) { |
| // It's a hack since we always use GPS time stamp but does |
| // not use other fields sometimes. Setting processing |
| // method to null means the other fields should not be used. |
| mRequestSettings.set(JPEG_GPS_LOCATION, null); |
| } else { |
| Location location = new Location(mGpsData.processingMethod); |
| location.setTime(mGpsData.timeStamp); |
| location.setAltitude(mGpsData.altitude); |
| location.setLatitude(mGpsData.latitude); |
| location.setLongitude(mGpsData.longitude); |
| mRequestSettings.set(JPEG_GPS_LOCATION, location); |
| } |
| } |
| |
| /** |
| * Calculate the effective crop rectangle for this preview viewport; |
| * assumes the preview is centered to the sensor and scaled to fit across one of the dimensions |
| * without skewing. |
| * |
| * <p>Assumes the zoom level of the provided desired crop rectangle.</p> |
| * |
| * @param requestedCrop Desired crop rectangle, in active array space. |
| * @param previewSize Size of the preview buffer render target, in pixels (not in sensor space). |
| * @return A rectangle that serves as the preview stream's effective crop region (unzoomed), in |
| * sensor space. |
| * |
| * @throws NullPointerException |
| * If any of the args were {@code null}. |
| */ |
| private static Rect effectiveCropRectFromRequested(Rect requestedCrop, Size previewSize) { |
| float aspectRatioArray = requestedCrop.width() * 1.0f / requestedCrop.height(); |
| float aspectRatioPreview = previewSize.width() * 1.0f / previewSize.height(); |
| |
| float cropHeight, cropWidth; |
| if (aspectRatioPreview < aspectRatioArray) { |
| // The new width must be smaller than the height, so scale the width by AR |
| cropHeight = requestedCrop.height(); |
| cropWidth = cropHeight * aspectRatioPreview; |
| } else { |
| // The new height must be smaller (or equal) than the width, so scale the height by AR |
| cropWidth = requestedCrop.width(); |
| cropHeight = cropWidth / aspectRatioPreview; |
| } |
| |
| Matrix translateMatrix = new Matrix(); |
| RectF cropRect = new RectF(/*left*/0, /*top*/0, cropWidth, cropHeight); |
| |
| // Now center the crop rectangle so its center is in the center of the active array |
| translateMatrix.setTranslate(requestedCrop.exactCenterX(), requestedCrop.exactCenterY()); |
| translateMatrix.postTranslate(-cropRect.centerX(), -cropRect.centerY()); |
| |
| translateMatrix.mapRect(/*inout*/cropRect); |
| |
| // Round the rect corners towards the nearest integer values |
| Rect result = new Rect(); |
| cropRect.roundOut(result); |
| return result; |
| } |
| } |
