services/camera/libcameraservice/device3/ZoomRatioMapper.cpp - LeafOS-Project/android_frameworks_av - Gitiles

 /*
  * Copyright (C) 2019 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.
  */

 #define LOG_TAG "Camera3-ZoomRatioMapper"
 //#define LOG_NDEBUG 0

 #include <algorithm>

 #include "device3/ZoomRatioMapper.h"

 namespace android {

 namespace camera3 {

 ZoomRatioMapper::ZoomRatioMapper() : mHalSupportsZoomRatio(false) {
 }

 status_t ZoomRatioMapper::initZoomRatioInTemplate(CameraMetadata *request) {
     camera_metadata_entry_t entry;
     entry = request->find(ANDROID_CONTROL_ZOOM_RATIO);
     float defaultZoomRatio = 1.0f;
     if (entry.count == 0) {
         return request->update(ANDROID_CONTROL_ZOOM_RATIO, &defaultZoomRatio, 1);
     }
     return OK;
 }

 status_t ZoomRatioMapper::overrideZoomRatioTags(
         CameraMetadata* deviceInfo, bool* supportNativeZoomRatio) {
     if (deviceInfo == nullptr || supportNativeZoomRatio == nullptr) {
         return BAD_VALUE;
     }

     camera_metadata_entry_t entry;
     entry = deviceInfo->find(ANDROID_CONTROL_ZOOM_RATIO_RANGE);
     if (entry.count != 2 && entry.count != 0) return BAD_VALUE;

     // Hal has zoom ratio support
     if (entry.count == 2) {
         *supportNativeZoomRatio = true;
         return OK;
     }

     // Hal has no zoom ratio support
     *supportNativeZoomRatio = false;

     entry = deviceInfo->find(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM);
     if (entry.count != 1) {
         ALOGI("%s: Camera device doesn't support SCALER_AVAILABLE_MAX_DIGITAL_ZOOM key!",
                 __FUNCTION__);
         return OK;
     }

     float zoomRange[] = {1.0f, entry.data.f[0]};
     status_t res = deviceInfo->update(ANDROID_CONTROL_ZOOM_RATIO_RANGE, zoomRange, 2);
     if (res != OK) {
         ALOGE("%s: Failed to update CONTROL_ZOOM_RATIO_RANGE key: %s (%d)",
                 __FUNCTION__, strerror(-res), res);
         return res;
     }

     std::vector<int32_t> requestKeys;
     entry = deviceInfo->find(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS);
     if (entry.count > 0) {
         requestKeys.insert(requestKeys.end(), entry.data.i32, entry.data.i32 + entry.count);
     }
     requestKeys.push_back(ANDROID_CONTROL_ZOOM_RATIO);
     res = deviceInfo->update(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS,
             requestKeys.data(), requestKeys.size());
     if (res != OK) {
         ALOGE("%s: Failed to update REQUEST_AVAILABLE_REQUEST_KEYS: %s (%d)",
                 __FUNCTION__, strerror(-res), res);
         return res;
     }

     std::vector<int32_t> resultKeys;
     entry = deviceInfo->find(ANDROID_REQUEST_AVAILABLE_RESULT_KEYS);
     if (entry.count > 0) {
         resultKeys.insert(resultKeys.end(), entry.data.i32, entry.data.i32 + entry.count);
     }
     resultKeys.push_back(ANDROID_CONTROL_ZOOM_RATIO);
     res = deviceInfo->update(ANDROID_REQUEST_AVAILABLE_RESULT_KEYS,
             resultKeys.data(), resultKeys.size());
     if (res != OK) {
         ALOGE("%s: Failed to update REQUEST_AVAILABLE_RESULT_KEYS: %s (%d)",
                 __FUNCTION__, strerror(-res), res);
         return res;
     }

     std::vector<int32_t> charKeys;
     entry = deviceInfo->find(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
     if (entry.count > 0) {
         charKeys.insert(charKeys.end(), entry.data.i32, entry.data.i32 + entry.count);
     }
     charKeys.push_back(ANDROID_CONTROL_ZOOM_RATIO_RANGE);
     res = deviceInfo->update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS,
             charKeys.data(), charKeys.size());
     if (res != OK) {
         ALOGE("%s: Failed to update REQUEST_AVAILABLE_CHARACTERISTICS_KEYS: %s (%d)",
                 __FUNCTION__, strerror(-res), res);
         return res;
     }

     return OK;
 }

 status_t ZoomRatioMapper::initZoomRatioTags(const CameraMetadata* deviceInfo,
         bool supportNativeZoomRatio, bool usePrecorrectArray) {
     std::lock_guard<std::mutex> lock(mMutex);

     camera_metadata_ro_entry_t entry;

     entry = deviceInfo->find(ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE);
     if (entry.count != 4) return BAD_VALUE;
     int32_t arrayW = entry.data.i32[2];
     int32_t arrayH = entry.data.i32[3];

     entry = deviceInfo->find(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE);
     if (entry.count != 4) return BAD_VALUE;
     int32_t activeW = entry.data.i32[2];
     int32_t activeH = entry.data.i32[3];

     if (usePrecorrectArray) {
         mArrayWidth = arrayW;
         mArrayHeight = arrayH;
     } else {
         mArrayWidth = activeW;
         mArrayHeight = activeH;
     }
     mHalSupportsZoomRatio = supportNativeZoomRatio;

     ALOGV("%s: array size: %d x %d, mHalSupportsZoomRatio %d",
             __FUNCTION__, mArrayWidth, mArrayHeight, mHalSupportsZoomRatio);
     return OK;
 }

 status_t ZoomRatioMapper::updateCaptureRequest(CameraMetadata* request) {
     std::lock_guard<std::mutex> lock(mMutex);
     status_t res = OK;
     bool zoomRatioIs1 = true;
     camera_metadata_entry_t entry;

     entry = request->find(ANDROID_CONTROL_ZOOM_RATIO);
     if (entry.count == 1 && entry.data.f[0] != 1.0f) {
         zoomRatioIs1 = false;
     }

     if (mHalSupportsZoomRatio && zoomRatioIs1) {
         res = separateZoomFromCropLocked(request, false/*isResult*/);
     } else if (!mHalSupportsZoomRatio && !zoomRatioIs1) {
         res = combineZoomAndCropLocked(request, false/*isResult*/);
     }

     // If CONTROL_ZOOM_RATIO is in request, but HAL doesn't support
     // CONTROL_ZOOM_RATIO, remove it from the request.
     if (!mHalSupportsZoomRatio && entry.count == 1) {
         request->erase(ANDROID_CONTROL_ZOOM_RATIO);
     }

     return res;
 }

 status_t ZoomRatioMapper::updateCaptureResult(CameraMetadata* result, bool requestedZoomRatioIs1) {
     std::lock_guard<std::mutex> lock(mMutex);
     status_t res = OK;

     if (mHalSupportsZoomRatio && requestedZoomRatioIs1) {
         res = combineZoomAndCropLocked(result, true/*isResult*/);
     } else if (!mHalSupportsZoomRatio && !requestedZoomRatioIs1) {
         res = separateZoomFromCropLocked(result, true/*isResult*/);
     } else {
         camera_metadata_entry_t entry = result->find(ANDROID_CONTROL_ZOOM_RATIO);
         if (entry.count == 0) {
             float zoomRatio1x = 1.0f;
             result->update(ANDROID_CONTROL_ZOOM_RATIO, &zoomRatio1x, 1);
         }
     }

     return res;
 }

 float ZoomRatioMapper::deriveZoomRatio(const CameraMetadata* metadata) {
     float zoomRatio = 1.0;

     camera_metadata_ro_entry_t entry;
     entry = metadata->find(ANDROID_SCALER_CROP_REGION);
     if (entry.count != 4) return zoomRatio;

     // Center of the preCorrection/active size
     float arrayCenterX = mArrayWidth / 2.0;
     float arrayCenterY = mArrayHeight / 2.0;

     // Re-map crop region to coordinate system centered to (arrayCenterX,
     // arrayCenterY).
     float cropRegionLeft = arrayCenterX - entry.data.i32[0] ;
     float cropRegionTop = arrayCenterY - entry.data.i32[1];
     float cropRegionRight = entry.data.i32[0] + entry.data.i32[2] - arrayCenterX;
     float cropRegionBottom = entry.data.i32[1] + entry.data.i32[3] - arrayCenterY;

     // Calculate the scaling factor for left, top, bottom, right
     float zoomRatioLeft = std::max(mArrayWidth / (2 * cropRegionLeft), 1.0f);
     float zoomRatioTop = std::max(mArrayHeight / (2 * cropRegionTop), 1.0f);
     float zoomRatioRight = std::max(mArrayWidth / (2 * cropRegionRight), 1.0f);
     float zoomRatioBottom = std::max(mArrayHeight / (2 * cropRegionBottom), 1.0f);

     // Use minimum scaling factor to handle letterboxing or pillarboxing
     zoomRatio = std::min(std::min(zoomRatioLeft, zoomRatioRight),
             std::min(zoomRatioTop, zoomRatioBottom));

     ALOGV("%s: derived zoomRatio is %f", __FUNCTION__, zoomRatio);
     return zoomRatio;
 }

 status_t ZoomRatioMapper::separateZoomFromCropLocked(CameraMetadata* metadata, bool isResult) {
     status_t res;
     float zoomRatio = deriveZoomRatio(metadata);

     // Update zoomRatio metadata tag
     res = metadata->update(ANDROID_CONTROL_ZOOM_RATIO, &zoomRatio, 1);
     if (res != OK) {
         ALOGE("%s: Failed to update ANDROID_CONTROL_ZOOM_RATIO: %s(%d)",
                 __FUNCTION__, strerror(-res), res);
         return res;
     }

     // Scale regions using zoomRatio
     camera_metadata_entry_t entry;
     for (auto region : kMeteringRegionsToCorrect) {
         entry = metadata->find(region);
         for (size_t j = 0; j < entry.count; j += 5) {
             int32_t weight = entry.data.i32[j + 4];
             if (weight == 0) {
                 continue;
             }
             // Top-left is inclusively clamped
             scaleCoordinates(entry.data.i32 + j, 1, zoomRatio, ClampInclusive);
             // Bottom-right is exclusively clamped
             scaleCoordinates(entry.data.i32 + j + 2, 1, zoomRatio, ClampExclusive);
         }
     }

     for (auto rect : kRectsToCorrect) {
         entry = metadata->find(rect);
         scaleRects(entry.data.i32, entry.count / 4, zoomRatio);
     }

     if (isResult) {
         for (auto pts : kResultPointsToCorrectNoClamp) {
             entry = metadata->find(pts);
             scaleCoordinates(entry.data.i32, entry.count / 2, zoomRatio, ClampOff);
         }
     }

     return OK;
 }

 status_t ZoomRatioMapper::combineZoomAndCropLocked(CameraMetadata* metadata, bool isResult) {
     float zoomRatio = 1.0f;
     camera_metadata_entry_t entry;
     entry = metadata->find(ANDROID_CONTROL_ZOOM_RATIO);
     if (entry.count == 1) {
         zoomRatio = entry.data.f[0];
     }

     // Unscale regions with zoomRatio
     status_t res;
     for (auto region : kMeteringRegionsToCorrect) {
         entry = metadata->find(region);
         for (size_t j = 0; j < entry.count; j += 5) {
             int32_t weight = entry.data.i32[j + 4];
             if (weight == 0) {
                 continue;
             }
             // Top-left is inclusively clamped
             scaleCoordinates(entry.data.i32 + j, 1, 1.0 / zoomRatio, ClampInclusive);
             // Bottom-right is exclusively clamped
             scaleCoordinates(entry.data.i32 + j + 2, 1, 1.0 / zoomRatio, ClampExclusive);
         }
     }
     for (auto rect : kRectsToCorrect) {
         entry = metadata->find(rect);
         scaleRects(entry.data.i32, entry.count / 4, 1.0 / zoomRatio);
     }
     if (isResult) {
         for (auto pts : kResultPointsToCorrectNoClamp) {
             entry = metadata->find(pts);
             scaleCoordinates(entry.data.i32, entry.count / 2, 1.0 / zoomRatio, ClampOff);
         }
     }

     zoomRatio = 1.0;
     res = metadata->update(ANDROID_CONTROL_ZOOM_RATIO, &zoomRatio, 1);
     if (res != OK) {
         return res;
     }

     return OK;
 }

 void ZoomRatioMapper::scaleCoordinates(int32_t* coordPairs, int coordCount,
         float scaleRatio, ClampMode clamp) {
     for (int i = 0; i < coordCount * 2; i += 2) {
         float x = coordPairs[i];
         float y = coordPairs[i + 1];
         float xCentered = x - mArrayWidth / 2;
         float yCentered = y - mArrayHeight / 2;
         float scaledX = xCentered * scaleRatio;
         float scaledY = yCentered * scaleRatio;
         scaledX += mArrayWidth / 2;
         scaledY += mArrayHeight / 2;
         // Clamp to within activeArray/preCorrectionActiveArray
         coordPairs[i] = static_cast<int32_t>(scaledX);
         coordPairs[i+1] = static_cast<int32_t>(scaledY);
         if (clamp != ClampOff) {
             int32_t right, bottom;
             if (clamp == ClampInclusive) {
                 right = mArrayWidth - 1;
                 bottom = mArrayHeight - 1;
             } else {
                 right = mArrayWidth;
                 bottom = mArrayHeight;
             }
             coordPairs[i] =
                     std::min(right, std::max(0, coordPairs[i]));
             coordPairs[i+1] =
                     std::min(bottom, std::max(0, coordPairs[i+1]));
         }
         ALOGV("%s: coordinates: %d, %d", __FUNCTION__, coordPairs[i], coordPairs[i+1]);
     }
 }

 void ZoomRatioMapper::scaleRects(int32_t* rects, int rectCount,
         float scaleRatio) {
     for (int i = 0; i < rectCount * 4; i += 4) {
         // Map from (l, t, width, height) to (l, t, r, b).
         // [l, t] is inclusive, and [r, b] is exclusive.
         int32_t coords[4] = {
             rects[i],
             rects[i + 1],
             rects[i] + rects[i + 2],
             rects[i + 1] + rects[i + 3]
         };

         // top-left
         scaleCoordinates(coords, 1, scaleRatio, ClampInclusive);
         // bottom-right
         scaleCoordinates(coords+2, 1, scaleRatio, ClampExclusive);

         // Map back to (l, t, width, height)
         rects[i] = coords[0];
         rects[i + 1] = coords[1];
         rects[i + 2] = coords[2] - coords[0];
         rects[i + 3] = coords[3] - coords[1];
     }
 }

 } // namespace camera3

 } // namespace android
	/*
	* Copyright (C) 2019 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.
	*/

	#define LOG_TAG "Camera3-ZoomRatioMapper"
	//#define LOG_NDEBUG 0

	#include <algorithm>

	#include "device3/ZoomRatioMapper.h"

	namespace android {

	namespace camera3 {

	ZoomRatioMapper::ZoomRatioMapper() : mHalSupportsZoomRatio(false) {
	}

	status_t ZoomRatioMapper::initZoomRatioInTemplate(CameraMetadata *request) {
	camera_metadata_entry_t entry;
	entry = request->find(ANDROID_CONTROL_ZOOM_RATIO);
	float defaultZoomRatio = 1.0f;
	if (entry.count == 0) {
	return request->update(ANDROID_CONTROL_ZOOM_RATIO, &defaultZoomRatio, 1);
	}
	return OK;
	}

	status_t ZoomRatioMapper::overrideZoomRatioTags(
	CameraMetadata* deviceInfo, bool* supportNativeZoomRatio) {
	if (deviceInfo == nullptr \|\| supportNativeZoomRatio == nullptr) {
	return BAD_VALUE;
	}

	camera_metadata_entry_t entry;
	entry = deviceInfo->find(ANDROID_CONTROL_ZOOM_RATIO_RANGE);
	if (entry.count != 2 && entry.count != 0) return BAD_VALUE;

	// Hal has zoom ratio support
	if (entry.count == 2) {
	*supportNativeZoomRatio = true;
	return OK;
	}

	// Hal has no zoom ratio support
	*supportNativeZoomRatio = false;

	entry = deviceInfo->find(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM);
	if (entry.count != 1) {
	ALOGI("%s: Camera device doesn't support SCALER_AVAILABLE_MAX_DIGITAL_ZOOM key!",
	__FUNCTION__);
	return OK;
	}

	float zoomRange[] = {1.0f, entry.data.f[0]};
	status_t res = deviceInfo->update(ANDROID_CONTROL_ZOOM_RATIO_RANGE, zoomRange, 2);
	if (res != OK) {
	ALOGE("%s: Failed to update CONTROL_ZOOM_RATIO_RANGE key: %s (%d)",
	__FUNCTION__, strerror(-res), res);
	return res;
	}

	std::vector<int32_t> requestKeys;
	entry = deviceInfo->find(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS);
	if (entry.count > 0) {
	requestKeys.insert(requestKeys.end(), entry.data.i32, entry.data.i32 + entry.count);
	}
	requestKeys.push_back(ANDROID_CONTROL_ZOOM_RATIO);
	res = deviceInfo->update(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS,
	requestKeys.data(), requestKeys.size());
	if (res != OK) {
	ALOGE("%s: Failed to update REQUEST_AVAILABLE_REQUEST_KEYS: %s (%d)",
	__FUNCTION__, strerror(-res), res);
	return res;
	}

	std::vector<int32_t> resultKeys;
	entry = deviceInfo->find(ANDROID_REQUEST_AVAILABLE_RESULT_KEYS);
	if (entry.count > 0) {
	resultKeys.insert(resultKeys.end(), entry.data.i32, entry.data.i32 + entry.count);
	}
	resultKeys.push_back(ANDROID_CONTROL_ZOOM_RATIO);
	res = deviceInfo->update(ANDROID_REQUEST_AVAILABLE_RESULT_KEYS,
	resultKeys.data(), resultKeys.size());
	if (res != OK) {
	ALOGE("%s: Failed to update REQUEST_AVAILABLE_RESULT_KEYS: %s (%d)",
	__FUNCTION__, strerror(-res), res);
	return res;
	}

	std::vector<int32_t> charKeys;
	entry = deviceInfo->find(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
	if (entry.count > 0) {
	charKeys.insert(charKeys.end(), entry.data.i32, entry.data.i32 + entry.count);
	}
	charKeys.push_back(ANDROID_CONTROL_ZOOM_RATIO_RANGE);
	res = deviceInfo->update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS,
	charKeys.data(), charKeys.size());
	if (res != OK) {
	ALOGE("%s: Failed to update REQUEST_AVAILABLE_CHARACTERISTICS_KEYS: %s (%d)",
	__FUNCTION__, strerror(-res), res);
	return res;
	}

	return OK;
	}

	status_t ZoomRatioMapper::initZoomRatioTags(const CameraMetadata* deviceInfo,
	bool supportNativeZoomRatio, bool usePrecorrectArray) {
	std::lock_guard<std::mutex> lock(mMutex);

	camera_metadata_ro_entry_t entry;

	entry = deviceInfo->find(ANDROID_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE);
	if (entry.count != 4) return BAD_VALUE;
	int32_t arrayW = entry.data.i32[2];
	int32_t arrayH = entry.data.i32[3];

	entry = deviceInfo->find(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE);
	if (entry.count != 4) return BAD_VALUE;
	int32_t activeW = entry.data.i32[2];
	int32_t activeH = entry.data.i32[3];

	if (usePrecorrectArray) {
	mArrayWidth = arrayW;
	mArrayHeight = arrayH;
	} else {
	mArrayWidth = activeW;
	mArrayHeight = activeH;
	}
	mHalSupportsZoomRatio = supportNativeZoomRatio;

	ALOGV("%s: array size: %d x %d, mHalSupportsZoomRatio %d",
	__FUNCTION__, mArrayWidth, mArrayHeight, mHalSupportsZoomRatio);
	return OK;
	}

	status_t ZoomRatioMapper::updateCaptureRequest(CameraMetadata* request) {
	std::lock_guard<std::mutex> lock(mMutex);
	status_t res = OK;
	bool zoomRatioIs1 = true;
	camera_metadata_entry_t entry;

	entry = request->find(ANDROID_CONTROL_ZOOM_RATIO);
	if (entry.count == 1 && entry.data.f[0] != 1.0f) {
	zoomRatioIs1 = false;
	}

	if (mHalSupportsZoomRatio && zoomRatioIs1) {
	res = separateZoomFromCropLocked(request, false/isResult/);
	} else if (!mHalSupportsZoomRatio && !zoomRatioIs1) {
	res = combineZoomAndCropLocked(request, false/isResult/);
	}

	// If CONTROL_ZOOM_RATIO is in request, but HAL doesn't support
	// CONTROL_ZOOM_RATIO, remove it from the request.
	if (!mHalSupportsZoomRatio && entry.count == 1) {
	request->erase(ANDROID_CONTROL_ZOOM_RATIO);
	}

	return res;
	}

	status_t ZoomRatioMapper::updateCaptureResult(CameraMetadata* result, bool requestedZoomRatioIs1) {
	std::lock_guard<std::mutex> lock(mMutex);
	status_t res = OK;

	if (mHalSupportsZoomRatio && requestedZoomRatioIs1) {
	res = combineZoomAndCropLocked(result, true/isResult/);
	} else if (!mHalSupportsZoomRatio && !requestedZoomRatioIs1) {
	res = separateZoomFromCropLocked(result, true/isResult/);
	} else {
	camera_metadata_entry_t entry = result->find(ANDROID_CONTROL_ZOOM_RATIO);
	if (entry.count == 0) {
	float zoomRatio1x = 1.0f;
	result->update(ANDROID_CONTROL_ZOOM_RATIO, &zoomRatio1x, 1);
	}
	}

	return res;
	}

	float ZoomRatioMapper::deriveZoomRatio(const CameraMetadata* metadata) {
	float zoomRatio = 1.0;

	camera_metadata_ro_entry_t entry;
	entry = metadata->find(ANDROID_SCALER_CROP_REGION);
	if (entry.count != 4) return zoomRatio;

	// Center of the preCorrection/active size
	float arrayCenterX = mArrayWidth / 2.0;
	float arrayCenterY = mArrayHeight / 2.0;

	// Re-map crop region to coordinate system centered to (arrayCenterX,
	// arrayCenterY).
	float cropRegionLeft = arrayCenterX - entry.data.i32[0] ;
	float cropRegionTop = arrayCenterY - entry.data.i32[1];
	float cropRegionRight = entry.data.i32[0] + entry.data.i32[2] - arrayCenterX;
	float cropRegionBottom = entry.data.i32[1] + entry.data.i32[3] - arrayCenterY;

	// Calculate the scaling factor for left, top, bottom, right
	float zoomRatioLeft = std::max(mArrayWidth / (2 * cropRegionLeft), 1.0f);
	float zoomRatioTop = std::max(mArrayHeight / (2 * cropRegionTop), 1.0f);
	float zoomRatioRight = std::max(mArrayWidth / (2 * cropRegionRight), 1.0f);
	float zoomRatioBottom = std::max(mArrayHeight / (2 * cropRegionBottom), 1.0f);

	// Use minimum scaling factor to handle letterboxing or pillarboxing
	zoomRatio = std::min(std::min(zoomRatioLeft, zoomRatioRight),
	std::min(zoomRatioTop, zoomRatioBottom));

	ALOGV("%s: derived zoomRatio is %f", __FUNCTION__, zoomRatio);
	return zoomRatio;
	}

	status_t ZoomRatioMapper::separateZoomFromCropLocked(CameraMetadata* metadata, bool isResult) {
	status_t res;
	float zoomRatio = deriveZoomRatio(metadata);

	// Update zoomRatio metadata tag
	res = metadata->update(ANDROID_CONTROL_ZOOM_RATIO, &zoomRatio, 1);
	if (res != OK) {
	ALOGE("%s: Failed to update ANDROID_CONTROL_ZOOM_RATIO: %s(%d)",
	__FUNCTION__, strerror(-res), res);
	return res;
	}

	// Scale regions using zoomRatio
	camera_metadata_entry_t entry;
	for (auto region : kMeteringRegionsToCorrect) {
	entry = metadata->find(region);
	for (size_t j = 0; j < entry.count; j += 5) {
	int32_t weight = entry.data.i32[j + 4];
	if (weight == 0) {
	continue;
	}
	// Top-left is inclusively clamped
	scaleCoordinates(entry.data.i32 + j, 1, zoomRatio, ClampInclusive);
	// Bottom-right is exclusively clamped
	scaleCoordinates(entry.data.i32 + j + 2, 1, zoomRatio, ClampExclusive);
	}
	}

	for (auto rect : kRectsToCorrect) {
	entry = metadata->find(rect);
	scaleRects(entry.data.i32, entry.count / 4, zoomRatio);
	}

	if (isResult) {
	for (auto pts : kResultPointsToCorrectNoClamp) {
	entry = metadata->find(pts);
	scaleCoordinates(entry.data.i32, entry.count / 2, zoomRatio, ClampOff);
	}
	}

	return OK;
	}

	status_t ZoomRatioMapper::combineZoomAndCropLocked(CameraMetadata* metadata, bool isResult) {
	float zoomRatio = 1.0f;
	camera_metadata_entry_t entry;
	entry = metadata->find(ANDROID_CONTROL_ZOOM_RATIO);
	if (entry.count == 1) {
	zoomRatio = entry.data.f[0];
	}

	// Unscale regions with zoomRatio
	status_t res;
	for (auto region : kMeteringRegionsToCorrect) {
	entry = metadata->find(region);
	for (size_t j = 0; j < entry.count; j += 5) {
	int32_t weight = entry.data.i32[j + 4];
	if (weight == 0) {
	continue;
	}
	// Top-left is inclusively clamped
	scaleCoordinates(entry.data.i32 + j, 1, 1.0 / zoomRatio, ClampInclusive);
	// Bottom-right is exclusively clamped
	scaleCoordinates(entry.data.i32 + j + 2, 1, 1.0 / zoomRatio, ClampExclusive);
	}
	}
	for (auto rect : kRectsToCorrect) {
	entry = metadata->find(rect);
	scaleRects(entry.data.i32, entry.count / 4, 1.0 / zoomRatio);
	}
	if (isResult) {
	for (auto pts : kResultPointsToCorrectNoClamp) {
	entry = metadata->find(pts);
	scaleCoordinates(entry.data.i32, entry.count / 2, 1.0 / zoomRatio, ClampOff);
	}
	}

	zoomRatio = 1.0;
	res = metadata->update(ANDROID_CONTROL_ZOOM_RATIO, &zoomRatio, 1);
	if (res != OK) {
	return res;
	}

	return OK;
	}

	void ZoomRatioMapper::scaleCoordinates(int32_t* coordPairs, int coordCount,
	float scaleRatio, ClampMode clamp) {
	for (int i = 0; i < coordCount * 2; i += 2) {
	float x = coordPairs[i];
	float y = coordPairs[i + 1];
	float xCentered = x - mArrayWidth / 2;
	float yCentered = y - mArrayHeight / 2;
	float scaledX = xCentered * scaleRatio;
	float scaledY = yCentered * scaleRatio;
	scaledX += mArrayWidth / 2;
	scaledY += mArrayHeight / 2;
	// Clamp to within activeArray/preCorrectionActiveArray
	coordPairs[i] = static_cast<int32_t>(scaledX);
	coordPairs[i+1] = static_cast<int32_t>(scaledY);
	if (clamp != ClampOff) {
	int32_t right, bottom;
	if (clamp == ClampInclusive) {
	right = mArrayWidth - 1;
	bottom = mArrayHeight - 1;
	} else {
	right = mArrayWidth;
	bottom = mArrayHeight;
	}
	coordPairs[i] =
	std::min(right, std::max(0, coordPairs[i]));
	coordPairs[i+1] =
	std::min(bottom, std::max(0, coordPairs[i+1]));
	}
	ALOGV("%s: coordinates: %d, %d", __FUNCTION__, coordPairs[i], coordPairs[i+1]);
	}
	}

	void ZoomRatioMapper::scaleRects(int32_t* rects, int rectCount,
	float scaleRatio) {
	for (int i = 0; i < rectCount * 4; i += 4) {
	// Map from (l, t, width, height) to (l, t, r, b).
	// [l, t] is inclusive, and [r, b] is exclusive.
	int32_t coords[4] = {
	rects[i],
	rects[i + 1],
	rects[i] + rects[i + 2],
	rects[i + 1] + rects[i + 3]
	};

	// top-left
	scaleCoordinates(coords, 1, scaleRatio, ClampInclusive);
	// bottom-right
	scaleCoordinates(coords+2, 1, scaleRatio, ClampExclusive);

	// Map back to (l, t, width, height)
	rects[i] = coords[0];
	rects[i + 1] = coords[1];
	rects[i + 2] = coords[2] - coords[0];
	rects[i + 3] = coords[3] - coords[1];
	}
	}

	} // namespace camera3

	} // namespace android