/* Copyright (c) 2016-2017, The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of The Linux Foundation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#define LOG_TAG "QCameraFOVControl"
#include <stdlib.h>
#include <cutils/properties.h>
#include <utils/Errors.h>
#include "QCameraFOVControl.h"
#include "QCameraDualCamSettings.h"
extern "C" {
#include "mm_camera_dbg.h"
}
namespace qcamera {
/*===========================================================================
* FUNCTION : QCameraFOVControl constructor
*
* DESCRIPTION: class constructor
*
* PARAMETERS : none
*
* RETURN : void
*
*==========================================================================*/
QCameraFOVControl::QCameraFOVControl()
{
mZoomTranslator = NULL;
memset(&mDualCamParams, 0, sizeof(dual_cam_params_t));
memset(&mFovControlConfig, 0, sizeof(fov_control_config_t));
memset(&mFovControlData, 0, sizeof(fov_control_data_t));
memset(&mFovControlResult, 0, sizeof(fov_control_result_t));
}
/*===========================================================================
* FUNCTION : QCameraFOVControl destructor
*
* DESCRIPTION: class destructor
*
* PARAMETERS : none
*
* RETURN : void
*
*==========================================================================*/
QCameraFOVControl::~QCameraFOVControl()
{
// De-initialize zoom translator lib
if (mZoomTranslator && mZoomTranslator->isInitialized()) {
mZoomTranslator->deInit();
}
}
/*===========================================================================
* FUNCTION : create
*
* DESCRIPTION: This is a static method to create FOV-control object. It calls
* private constructor of the class and only returns a valid object
* if it can successfully initialize the FOV-control.
*
* PARAMETERS :
* @capsMain : The capabilities for the main camera
* @capsAux : The capabilities for the aux camera
*
* RETURN : Valid object pointer if succeeds
* NULL if fails
*
*==========================================================================*/
QCameraFOVControl* QCameraFOVControl::create(
cam_capability_t *capsMainCam,
cam_capability_t *capsAuxCam)
{
QCameraFOVControl *pFovControl = NULL;
if (capsMainCam && capsAuxCam) {
// Create FOV control object
pFovControl = new QCameraFOVControl();
if (pFovControl) {
bool success = false;
if (pFovControl->validateAndExtractParameters(capsMainCam, capsAuxCam)) {
// Based on focal lengths, map main and aux camera to wide and tele
if (pFovControl->mDualCamParams.paramsMain.focalLengthMm <
pFovControl->mDualCamParams.paramsAux.focalLengthMm) {
pFovControl->mFovControlData.camWide = CAM_TYPE_MAIN;
pFovControl->mFovControlData.camTele = CAM_TYPE_AUX;
pFovControl->mFovControlData.camState = STATE_WIDE;
} else {
pFovControl->mFovControlData.camWide = CAM_TYPE_AUX;
pFovControl->mFovControlData.camTele = CAM_TYPE_MAIN;
pFovControl->mFovControlData.camState = STATE_TELE;
}
// Initialize the master info to main camera
pFovControl->mFovControlResult.camMasterPreview = CAM_TYPE_MAIN;
pFovControl->mFovControlResult.camMaster3A = CAM_TYPE_MAIN;
// Check if LPM is enabled
char prop[PROPERTY_VALUE_MAX];
int lpmEnable = 1;
property_get("persist.dualcam.lpm.enable", prop, "1");
lpmEnable = atoi(prop);
if ((lpmEnable == 0) || (DUALCAM_LPM_ENABLE == 0)) {
pFovControl->mFovControlData.lpmEnabled = false;
} else {
pFovControl->mFovControlData.lpmEnabled = true;
}
// Open the external zoom translation library if requested
if (FOVC_USE_EXTERNAL_ZOOM_TRANSLATOR) {
pFovControl->mZoomTranslator =
QCameraExtZoomTranslator::create();
if (!pFovControl->mZoomTranslator) {
LOGE("Unable to open zoom translation lib");
}
}
success = true;
}
if (!success) {
LOGE("FOV-control: Failed to create an object");
delete pFovControl;
pFovControl = NULL;
}
} else {
LOGE("FOV-control: Failed to allocate memory for FOV-control object");
}
}
return pFovControl;
}
/*===========================================================================
* FUNCTION : consolidateCapabilities
*
* DESCRIPTION : Combine the capabilities from main and aux cameras to return
* the consolidated capabilities.
*
* PARAMETERS :
* @capsMainCam: Capabilities for the main camera
* @capsAuxCam : Capabilities for the aux camera
*
* RETURN : Consolidated capabilities
*
*==========================================================================*/
cam_capability_t QCameraFOVControl::consolidateCapabilities(
cam_capability_t *capsMainCam,
cam_capability_t *capsAuxCam)
{
cam_capability_t capsConsolidated;
memset(&capsConsolidated, 0, sizeof(cam_capability_t));
if ((capsMainCam != NULL) &&
(capsAuxCam != NULL)) {
memcpy(&capsConsolidated, capsMainCam, sizeof(cam_capability_t));
// Consolidate preview sizes
uint32_t previewSizesTblCntMain = capsMainCam->preview_sizes_tbl_cnt;
uint32_t previewSizesTblCntAux = capsAuxCam->preview_sizes_tbl_cnt;
uint32_t previewSizesTblCntFinal = 0;
for (uint32_t i = 0; i < previewSizesTblCntMain; ++i) {
for (uint32_t j = 0; j < previewSizesTblCntAux; ++j) {
if ((capsMainCam->preview_sizes_tbl[i].width ==
capsAuxCam->preview_sizes_tbl[j].width) &&
(capsMainCam->preview_sizes_tbl[i].height ==
capsAuxCam->preview_sizes_tbl[j].height)) {
if (previewSizesTblCntFinal != i) {
capsConsolidated.preview_sizes_tbl[previewSizesTblCntFinal].width =
capsAuxCam->preview_sizes_tbl[j].width;
capsConsolidated.preview_sizes_tbl[previewSizesTblCntFinal].height =
capsMainCam->preview_sizes_tbl[j].height;
}
++previewSizesTblCntFinal;
break;
}
}
}
capsConsolidated.preview_sizes_tbl_cnt = previewSizesTblCntFinal;
// Consolidate video sizes
uint32_t videoSizesTblCntMain = capsMainCam->video_sizes_tbl_cnt;
uint32_t videoSizesTblCntAux = capsAuxCam->video_sizes_tbl_cnt;
uint32_t videoSizesTblCntFinal = 0;
for (uint32_t i = 0; i < videoSizesTblCntMain; ++i) {
for (uint32_t j = 0; j < videoSizesTblCntAux; ++j) {
if ((capsMainCam->video_sizes_tbl[i].width ==
capsAuxCam->video_sizes_tbl[j].width) &&
(capsMainCam->video_sizes_tbl[i].height ==
capsAuxCam->video_sizes_tbl[j].height)) {
if (videoSizesTblCntFinal != i) {
capsConsolidated.video_sizes_tbl[videoSizesTblCntFinal].width =
capsAuxCam->video_sizes_tbl[j].width;
capsConsolidated.video_sizes_tbl[videoSizesTblCntFinal].height =
capsMainCam->video_sizes_tbl[j].height;
}
++videoSizesTblCntFinal;
break;
}
}
}
capsConsolidated.video_sizes_tbl_cnt = videoSizesTblCntFinal;
// Consolidate livesnapshot sizes
uint32_t livesnapshotSizesTblCntMain = capsMainCam->livesnapshot_sizes_tbl_cnt;
uint32_t livesnapshotSizesTblCntAux = capsAuxCam->livesnapshot_sizes_tbl_cnt;
uint32_t livesnapshotSizesTblCntFinal = 0;
for (uint32_t i = 0; i < livesnapshotSizesTblCntMain; ++i) {
for (uint32_t j = 0; j < livesnapshotSizesTblCntAux; ++j) {
if ((capsMainCam->livesnapshot_sizes_tbl[i].width ==
capsAuxCam->livesnapshot_sizes_tbl[j].width) &&
(capsMainCam->livesnapshot_sizes_tbl[i].height ==
capsAuxCam->livesnapshot_sizes_tbl[j].height)) {
if (livesnapshotSizesTblCntFinal != i) {
capsConsolidated.livesnapshot_sizes_tbl[livesnapshotSizesTblCntFinal].width=
capsAuxCam->livesnapshot_sizes_tbl[j].width;
capsConsolidated.livesnapshot_sizes_tbl[livesnapshotSizesTblCntFinal].height=
capsMainCam->livesnapshot_sizes_tbl[j].height;
}
++livesnapshotSizesTblCntFinal;
break;
}
}
}
capsConsolidated.livesnapshot_sizes_tbl_cnt = livesnapshotSizesTblCntFinal;
// Consolidate picture size
// Find max picture dimension for main camera
cam_dimension_t maxPicDimMain;
maxPicDimMain.width = 0;
maxPicDimMain.height = 0;
for(uint32_t i = 0; i < (capsMainCam->picture_sizes_tbl_cnt - 1); ++i) {
if ((maxPicDimMain.width * maxPicDimMain.height) <
(capsMainCam->picture_sizes_tbl[i].width *
capsMainCam->picture_sizes_tbl[i].height)) {
maxPicDimMain.width = capsMainCam->picture_sizes_tbl[i].width;
maxPicDimMain.height = capsMainCam->picture_sizes_tbl[i].height;
}
}
// Find max picture dimension for aux camera
cam_dimension_t maxPicDimAux;
maxPicDimAux.width = 0;
maxPicDimAux.height = 0;
for(uint32_t i = 0; i < (capsAuxCam->picture_sizes_tbl_cnt - 1); ++i) {
if ((maxPicDimAux.width * maxPicDimAux.height) <
(capsAuxCam->picture_sizes_tbl[i].width *
capsAuxCam->picture_sizes_tbl[i].height)) {
maxPicDimAux.width = capsAuxCam->picture_sizes_tbl[i].width;
maxPicDimAux.height = capsAuxCam->picture_sizes_tbl[i].height;
}
}
LOGH("MAIN Max picture wxh %dx%d", maxPicDimMain.width, maxPicDimMain.height);
LOGH("AUX Max picture wxh %dx%d", maxPicDimAux.width, maxPicDimAux.height);
// Choose the larger of the two max picture dimensions
if ((maxPicDimAux.width * maxPicDimAux.height) >
(maxPicDimMain.width * maxPicDimMain.height)) {
capsConsolidated.picture_sizes_tbl_cnt = capsAuxCam->picture_sizes_tbl_cnt;
memcpy(capsConsolidated.picture_sizes_tbl, capsAuxCam->picture_sizes_tbl,
(capsAuxCam->picture_sizes_tbl_cnt * sizeof(cam_dimension_t)));
}
LOGH("Consolidated Max picture wxh %dx%d", capsConsolidated.picture_sizes_tbl[0].width,
capsConsolidated.picture_sizes_tbl[0].height);
// Consolidate supported preview formats
uint32_t supportedPreviewFmtCntMain = capsMainCam->supported_preview_fmt_cnt;
uint32_t supportedPreviewFmtCntAux = capsAuxCam->supported_preview_fmt_cnt;
uint32_t supportedPreviewFmtCntFinal = 0;
for (uint32_t i = 0; i < supportedPreviewFmtCntMain; ++i) {
for (uint32_t j = 0; j < supportedPreviewFmtCntAux; ++j) {
if (capsMainCam->supported_preview_fmts[i] ==
capsAuxCam->supported_preview_fmts[j]) {
if (supportedPreviewFmtCntFinal != i) {
capsConsolidated.supported_preview_fmts[supportedPreviewFmtCntFinal] =
capsAuxCam->supported_preview_fmts[j];
}
++supportedPreviewFmtCntFinal;
break;
}
}
}
capsConsolidated.supported_preview_fmt_cnt = supportedPreviewFmtCntFinal;
// Consolidate supported picture formats
uint32_t supportedPictureFmtCntMain = capsMainCam->supported_picture_fmt_cnt;
uint32_t supportedPictureFmtCntAux = capsAuxCam->supported_picture_fmt_cnt;
uint32_t supportedPictureFmtCntFinal = 0;
for (uint32_t i = 0; i < supportedPictureFmtCntMain; ++i) {
for (uint32_t j = 0; j < supportedPictureFmtCntAux; ++j) {
if (capsMainCam->supported_picture_fmts[i] ==
capsAuxCam->supported_picture_fmts[j]) {
if (supportedPictureFmtCntFinal != i) {
capsConsolidated.supported_picture_fmts[supportedPictureFmtCntFinal] =
capsAuxCam->supported_picture_fmts[j];
}
++supportedPictureFmtCntFinal;
break;
}
}
}
capsConsolidated.supported_picture_fmt_cnt = supportedPictureFmtCntFinal;
if (mZoomTranslator) {
// Copy the opaque calibration data pointer and size
mFovControlData.zoomTransInitData.calibData =
capsConsolidated.related_cam_calibration.dc_otp_params;
mFovControlData.zoomTransInitData.calibDataSize =
capsConsolidated.related_cam_calibration.dc_otp_size;
}
}
return capsConsolidated;
}
/*===========================================================================
* FUNCTION : resetVars
*
* DESCRIPTION : Reset the variables used in FOV-control.
*
* PARAMETERS : None
*
* RETURN : None
*
*==========================================================================*/
void QCameraFOVControl::resetVars()
{
// Copy the FOV-control settings for camera/camcorder from QCameraFOVControlSettings.h
if (mFovControlData.camcorderMode) {
mFovControlConfig.snapshotPPConfig.enablePostProcess =
FOVC_CAMCORDER_SNAPSHOT_PP_ENABLE;
} else {
mFovControlConfig.snapshotPPConfig.enablePostProcess = FOVC_CAM_SNAPSHOT_PP_ENABLE;
mFovControlConfig.snapshotPPConfig.zoomMin = FOVC_CAM_SNAPSHOT_PP_ZOOM_MIN;
mFovControlConfig.snapshotPPConfig.zoomMax = FOVC_CAM_SNAPSHOT_PP_ZOOM_MAX;
mFovControlConfig.snapshotPPConfig.luxMin = FOVC_CAM_SNAPSHOT_PP_LUX_MIN;
}
mFovControlConfig.auxSwitchBrightnessMin = FOVC_AUXCAM_SWITCH_LUX_MIN;
mFovControlConfig.auxSwitchFocusDistCmMin = FOVC_AUXCAM_SWITCH_FOCUS_DIST_CM_MIN;
mFovControlData.fallbackEnabled = FOVC_MAIN_CAM_FALLBACK_MECHANISM;
mFovControlConfig.zoomStableCountThreshold = FOVC_ZOOM_STABLE_COUNT_THRESHOLD;
mFovControlConfig.focusDistStableCountThreshold = FOVC_FOCUS_DIST_STABLE_COUNT_THRESHOLD;
mFovControlConfig.brightnessStableCountThreshold = FOVC_BRIGHTNESS_STABLE_COUNT_THRESHOLD;
// Reset variables
mFovControlData.zoomStableCount = 0;
mFovControlData.brightnessStableCount = 0;
mFovControlData.focusDistStableCount = 0;
mFovControlData.zoomDirection = ZOOM_STABLE;
mFovControlData.fallbackToWide = false;
mFovControlData.status3A.main.af.status = AF_INVALID;
mFovControlData.status3A.aux.af.status = AF_INVALID;
mFovControlData.afStatusMain = CAM_AF_STATE_INACTIVE;
mFovControlData.afStatusAux = CAM_AF_STATE_INACTIVE;
mFovControlData.wideCamStreaming = false;
mFovControlData.teleCamStreaming = false;
mFovControlData.spatialAlignResult.readyStatus = 0;
mFovControlData.spatialAlignResult.activeCameras = 0;
mFovControlData.spatialAlignResult.camMasterHint = 0;
mFovControlData.spatialAlignResult.shiftWide.shiftHorz = 0;
mFovControlData.spatialAlignResult.shiftWide.shiftVert = 0;
mFovControlData.spatialAlignResult.shiftTele.shiftHorz = 0;
mFovControlData.spatialAlignResult.shiftTele.shiftVert = 0;
// WA for now until the QTI solution is in place writing the spatial alignment ready status
mFovControlData.spatialAlignResult.readyStatus = 1;
}
/*===========================================================================
* FUNCTION : updateConfigSettings
*
* DESCRIPTION : Update the config settings such as margins and preview size
* and recalculate the transition parameters.
*
* PARAMETERS :
* @capsMainCam: Capabilities for the main camera
* @capsAuxCam : Capabilities for the aux camera
*
* RETURN :
* NO_ERROR : Success
* INVALID_OPERATION : Failure
*
*==========================================================================*/
int32_t QCameraFOVControl::updateConfigSettings(
parm_buffer_t* paramsMainCam,
parm_buffer_t* paramsAuxCam)
{
int32_t rc = INVALID_OPERATION;
if (paramsMainCam &&
paramsAuxCam &&
paramsMainCam->is_valid[CAM_INTF_META_STREAM_INFO] &&
paramsAuxCam->is_valid[CAM_INTF_META_STREAM_INFO]) {
cam_stream_size_info_t camMainStreamInfo;
READ_PARAM_ENTRY(paramsMainCam, CAM_INTF_META_STREAM_INFO, camMainStreamInfo);
mFovControlData.camcorderMode = false;
// Identify if in camera or camcorder mode
for (int i = 0; i < MAX_NUM_STREAMS; ++i) {
if (camMainStreamInfo.type[i] == CAM_STREAM_TYPE_VIDEO) {
mFovControlData.camcorderMode = true;
}
}
// Get the margins for the main camera. If video stream is present, the margins correspond
// to video stream. Otherwise, margins are copied from preview stream.
for (int i = 0; i < MAX_NUM_STREAMS; ++i) {
if (camMainStreamInfo.type[i] == CAM_STREAM_TYPE_VIDEO) {
mFovControlData.camMainWidthMargin = camMainStreamInfo.margins[i].widthMargins;
mFovControlData.camMainHeightMargin = camMainStreamInfo.margins[i].heightMargins;
}
if (camMainStreamInfo.type[i] == CAM_STREAM_TYPE_PREVIEW) {
// Update the preview dimension and ISP output size
mFovControlData.previewSize = camMainStreamInfo.stream_sizes[i];
mFovControlData.ispOutSize = camMainStreamInfo.stream_sz_plus_margin[i];
if (!mFovControlData.camcorderMode) {
mFovControlData.camMainWidthMargin =
camMainStreamInfo.margins[i].widthMargins;
mFovControlData.camMainHeightMargin =
camMainStreamInfo.margins[i].heightMargins;
break;
}
}
}
// Get the margins for the aux camera. If video stream is present, the margins correspond
// to the video stream. Otherwise, margins are copied from preview stream.
cam_stream_size_info_t camAuxStreamInfo;
READ_PARAM_ENTRY(paramsAuxCam, CAM_INTF_META_STREAM_INFO, camAuxStreamInfo);
for (int i = 0; i < MAX_NUM_STREAMS; ++i) {
if (camAuxStreamInfo.type[i] == CAM_STREAM_TYPE_VIDEO) {
mFovControlData.camAuxWidthMargin = camAuxStreamInfo.margins[i].widthMargins;
mFovControlData.camAuxHeightMargin = camAuxStreamInfo.margins[i].heightMargins;
}
if (camAuxStreamInfo.type[i] == CAM_STREAM_TYPE_PREVIEW) {
// Update the preview dimension
mFovControlData.previewSize = camAuxStreamInfo.stream_sizes[i];
if (!mFovControlData.camcorderMode) {
mFovControlData.camAuxWidthMargin = camAuxStreamInfo.margins[i].widthMargins;
mFovControlData.camAuxHeightMargin = camAuxStreamInfo.margins[i].heightMargins;
break;
}
}
}
#if 0 // Update to 07.01.01.253.071
// Get the sensor out dimensions
cam_dimension_t sensorDimMain = {0,0};
cam_dimension_t sensorDimAux = {0,0};
if (paramsMainCam->is_valid[CAM_INTF_PARM_RAW_DIMENSION]) {
READ_PARAM_ENTRY(paramsMainCam, CAM_INTF_PARM_RAW_DIMENSION, sensorDimMain);
}
if (paramsAuxCam->is_valid[CAM_INTF_PARM_RAW_DIMENSION]) {
READ_PARAM_ENTRY(paramsAuxCam, CAM_INTF_PARM_RAW_DIMENSION, sensorDimAux);
}
#endif // Update to 07.01.01.253.071
// Reset the internal variables
resetVars();
// Recalculate the transition parameters
if (calculateBasicFovRatio() && combineFovAdjustment()) {
calculateDualCamTransitionParams();
// Set initial camera state
float zoom = findZoomRatio(mFovControlData.zoomWide) /
(float)mFovControlData.zoomRatioTable[0];
if (zoom > mFovControlData.transitionParams.cutOverWideToTele) {
mFovControlResult.camMasterPreview = mFovControlData.camTele;
mFovControlResult.camMaster3A = mFovControlData.camTele;
mFovControlResult.activeCameras = (uint32_t)mFovControlData.camTele;
mFovControlData.camState = STATE_TELE;
LOGD("start camera state: TELE");
} else {
mFovControlResult.camMasterPreview = mFovControlData.camWide;
mFovControlResult.camMaster3A = mFovControlData.camWide;
mFovControlResult.activeCameras = (uint32_t)mFovControlData.camWide;
mFovControlData.camState = STATE_WIDE;
LOGD("start camera state: WIDE");
}
mFovControlResult.snapshotPostProcess = false;
// Deinit zoom translation lib if needed
if (mZoomTranslator && mZoomTranslator->isInitialized()) {
if (mZoomTranslator->deInit() != NO_ERROR) {
ALOGW("deinit failed for zoom translation lib");
}
}
#if 0 // Update to 07.01.01.253.071
// Initialize the zoom translation lib
if (mZoomTranslator) {
// Set the initialization data
mFovControlData.zoomTransInitData.previewDimension.width =
mFovControlData.previewSize.width;
mFovControlData.zoomTransInitData.previewDimension.height =
mFovControlData.previewSize.height;
mFovControlData.zoomTransInitData.ispOutDimension.width =
mFovControlData.ispOutSize.width;
mFovControlData.zoomTransInitData.ispOutDimension.height =
mFovControlData.ispOutSize.height;
mFovControlData.zoomTransInitData.sensorOutDimensionMain.width =
sensorDimMain.width;
mFovControlData.zoomTransInitData.sensorOutDimensionMain.height =
sensorDimMain.height;
mFovControlData.zoomTransInitData.sensorOutDimensionAux.width =
sensorDimAux.width;
mFovControlData.zoomTransInitData.sensorOutDimensionAux.height =
sensorDimAux.height;
mFovControlData.zoomTransInitData.zoomRatioTable =
mFovControlData.zoomRatioTable;
mFovControlData.zoomTransInitData.zoomRatioTableCount =
mFovControlData.zoomRatioTableCount;
mFovControlData.zoomTransInitData.mode = mFovControlData.camcorderMode ?
MODE_CAMCORDER : MODE_CAMERA;
if(mZoomTranslator->init(mFovControlData.zoomTransInitData) != NO_ERROR) {
LOGE("init failed for zoom translation lib");
// deinitialize the zoom translator and set to NULL
mZoomTranslator->deInit();
mZoomTranslator = NULL;
}
}
#endif // Update to 07.01.01.253.071
// FOV-control config is complete for the current use case
mFovControlData.configCompleted = true;
rc = NO_ERROR;
}
}
return rc;
}
/*===========================================================================
* FUNCTION : translateInputParams
*
* DESCRIPTION: Translate a subset of input parameters from main camera. As main
* and aux cameras have different properties/params, this translation
* is needed before the input parameters are sent to the aux camera.
*
* PARAMETERS :
* @paramsMainCam : Input parameters for main camera
* @paramsAuxCam : Input parameters for aux camera
*
* RETURN :
* NO_ERROR : Success
* INVALID_OPERATION : Failure
*
*==========================================================================*/
int32_t QCameraFOVControl::translateInputParams(
parm_buffer_t* paramsMainCam,
parm_buffer_t* paramsAuxCam)
{
int32_t rc = INVALID_OPERATION;
if (paramsMainCam && paramsAuxCam) {
// First copy all the parameters from main to aux and then translate the subset
memcpy(paramsAuxCam, paramsMainCam, sizeof(parm_buffer_t));
// Translate zoom
if (paramsMainCam->is_valid[CAM_INTF_PARM_ZOOM]) {
uint32_t userZoom = 0;
READ_PARAM_ENTRY(paramsMainCam, CAM_INTF_PARM_ZOOM, userZoom);
convertUserZoomToWideAndTele(userZoom);
// Update zoom values in the param buffers
uint32_t zoomMain = isMainCamFovWider() ?
mFovControlData.zoomWide : mFovControlData.zoomTele;
ADD_SET_PARAM_ENTRY_TO_BATCH(paramsMainCam, CAM_INTF_PARM_ZOOM, zoomMain);
uint32_t zoomAux = isMainCamFovWider() ?
mFovControlData.zoomTele : mFovControlData.zoomWide;
ADD_SET_PARAM_ENTRY_TO_BATCH(paramsAuxCam, CAM_INTF_PARM_ZOOM, zoomAux);
// Write the user zoom in main and aux param buffers
// The user zoom will always correspond to the wider camera
paramsMainCam->is_valid[CAM_INTF_PARM_DC_USERZOOM] = 1;
paramsAuxCam->is_valid[CAM_INTF_PARM_DC_USERZOOM] = 1;
ADD_SET_PARAM_ENTRY_TO_BATCH(paramsMainCam, CAM_INTF_PARM_DC_USERZOOM,
mFovControlData.zoomWide);
ADD_SET_PARAM_ENTRY_TO_BATCH(paramsAuxCam, CAM_INTF_PARM_DC_USERZOOM,
mFovControlData.zoomWide);
// Generate FOV-control result
generateFovControlResult();
}
// Translate focus areas
if (paramsMainCam->is_valid[CAM_INTF_PARM_AF_ROI]) {
cam_roi_info_t roiAfMain;
cam_roi_info_t roiAfAux;
READ_PARAM_ENTRY(paramsMainCam, CAM_INTF_PARM_AF_ROI, roiAfMain);
if (roiAfMain.num_roi > 0) {
roiAfAux = translateFocusAreas(roiAfMain, CAM_TYPE_AUX);
roiAfMain = translateFocusAreas(roiAfMain, CAM_TYPE_MAIN);
ADD_SET_PARAM_ENTRY_TO_BATCH(paramsAuxCam, CAM_INTF_PARM_AF_ROI, roiAfAux);
ADD_SET_PARAM_ENTRY_TO_BATCH(paramsMainCam, CAM_INTF_PARM_AF_ROI, roiAfMain);
}
}
// Translate metering areas
if (paramsMainCam->is_valid[CAM_INTF_PARM_AEC_ROI]) {
cam_set_aec_roi_t roiAecMain;
cam_set_aec_roi_t roiAecAux;
READ_PARAM_ENTRY(paramsMainCam, CAM_INTF_PARM_AEC_ROI, roiAecMain);
if (roiAecMain.aec_roi_enable == CAM_AEC_ROI_ON) {
roiAecAux = translateMeteringAreas(roiAecMain, CAM_TYPE_AUX);
roiAecMain = translateMeteringAreas(roiAecMain, CAM_TYPE_MAIN);
ADD_SET_PARAM_ENTRY_TO_BATCH(paramsAuxCam, CAM_INTF_PARM_AEC_ROI, roiAecAux);
ADD_SET_PARAM_ENTRY_TO_BATCH(paramsMainCam, CAM_INTF_PARM_AEC_ROI, roiAecMain);
}
}
rc = NO_ERROR;
}
return rc;
}
/*===========================================================================
* FUNCTION : processResultMetadata
*
* DESCRIPTION: Process the metadata from main and aux cameras to generate the
* result metadata. The result metadata should be the metadata
* coming from the master camera. If aux camera is master, the
* subset of the metadata needs to be translated to main as that's
* the only camera seen by the application.
*
* PARAMETERS :
* @metaMain : metadata for main camera
* @metaAux : metadata for aux camera
*
* RETURN :
* Result metadata for the logical camera. After successfully processing main
* and aux metadata, the result metadata points to either main or aux metadata
* based on which one was the master. In case of failure, it returns NULL.
*==========================================================================*/
metadata_buffer_t* QCameraFOVControl::processResultMetadata(
metadata_buffer_t* metaMain,
metadata_buffer_t* metaAux)
{
metadata_buffer_t* metaResult = NULL;
if (metaMain || metaAux) {
metadata_buffer_t *meta = metaMain ? metaMain : metaAux;
cam_sync_type_t masterCam = mFovControlResult.camMasterPreview;
mMutex.lock();
// Book-keep the needed metadata from main camera and aux camera
IF_META_AVAILABLE(cam_sac_output_info_t, spatialAlignOutput,
CAM_INTF_META_DC_SAC_OUTPUT_INFO, meta) {
// Get master camera hint
if (spatialAlignOutput->is_master_hint_valid) {
uint8_t master = spatialAlignOutput->master_hint;
if (master == CAM_ROLE_WIDE) {
mFovControlData.spatialAlignResult.camMasterHint = mFovControlData.camWide;
} else if (master == CAM_ROLE_TELE) {
mFovControlData.spatialAlignResult.camMasterHint = mFovControlData.camTele;
}
}
// Get master camera used for the preview in the frame corresponding to this metadata
if (spatialAlignOutput->is_master_preview_valid) {
uint8_t master = spatialAlignOutput->master_preview;
if (master == CAM_ROLE_WIDE) {
masterCam = mFovControlData.camWide;
mFovControlData.spatialAlignResult.camMasterPreview = masterCam;
} else if (master == CAM_ROLE_TELE) {
masterCam = mFovControlData.camTele;
mFovControlData.spatialAlignResult.camMasterPreview = masterCam;
}
}
// Get master camera used for 3A in the frame corresponding to this metadata
if (spatialAlignOutput->is_master_3A_valid) {
uint8_t master = spatialAlignOutput->master_3A;
if (master == CAM_ROLE_WIDE) {
mFovControlData.spatialAlignResult.camMaster3A = mFovControlData.camWide;
} else if (master == CAM_ROLE_TELE) {
mFovControlData.spatialAlignResult.camMaster3A = mFovControlData.camTele;
}
}
// Get spatial alignment ready status
if (spatialAlignOutput->is_ready_status_valid) {
mFovControlData.spatialAlignResult.readyStatus = spatialAlignOutput->ready_status;
}
}
metadata_buffer_t *metaWide = isMainCamFovWider() ? metaMain : metaAux;
metadata_buffer_t *metaTele = isMainCamFovWider() ? metaAux : metaMain;
// Get spatial alignment output info for wide camera
if (metaWide) {
IF_META_AVAILABLE(cam_sac_output_info_t, spatialAlignOutput,
CAM_INTF_META_DC_SAC_OUTPUT_INFO, metaWide) {
// Get spatial alignment output shift for wide camera
if (spatialAlignOutput->is_output_shift_valid) {
// Calculate the spatial alignment shift for the current stream dimensions based
// on the reference resolution used for the output shift.
float horzShiftFactor = (float)mFovControlData.previewSize.width /
spatialAlignOutput->reference_res_for_output_shift.width;
float vertShiftFactor = (float)mFovControlData.previewSize.height /
spatialAlignOutput->reference_res_for_output_shift.height;
mFovControlData.spatialAlignResult.shiftWide.shiftHorz =
spatialAlignOutput->output_shift.shift_horz * horzShiftFactor;
mFovControlData.spatialAlignResult.shiftWide.shiftVert =
spatialAlignOutput->output_shift.shift_vert * vertShiftFactor;
LOGD("SAC output shift for Wide: x:%d, y:%d",
mFovControlData.spatialAlignResult.shiftWide.shiftHorz,
mFovControlData.spatialAlignResult.shiftWide.shiftVert);
}
// Get the AF roi shift for wide camera
if (spatialAlignOutput->is_focus_roi_shift_valid) {
// Calculate the spatial alignment shift for the current stream dimensions based
// on the reference resolution used for the output shift.
float horzShiftFactor = (float)mFovControlData.previewSize.width /
spatialAlignOutput->reference_res_for_focus_roi_shift.width;
float vertShiftFactor = (float)mFovControlData.previewSize.height /
spatialAlignOutput->reference_res_for_focus_roi_shift.height;
mFovControlData.spatialAlignResult.shiftAfRoiWide.shiftHorz =
spatialAlignOutput->focus_roi_shift.shift_horz * horzShiftFactor;
mFovControlData.spatialAlignResult.shiftAfRoiWide.shiftVert =
spatialAlignOutput->focus_roi_shift.shift_vert * vertShiftFactor;
LOGD("SAC AF ROI shift for Wide: x:%d, y:%d",
mFovControlData.spatialAlignResult.shiftAfRoiWide.shiftHorz,
mFovControlData.spatialAlignResult.shiftAfRoiWide.shiftVert);
}
}
}
// Get spatial alignment output info for tele camera
if (metaTele) {
IF_META_AVAILABLE(cam_sac_output_info_t, spatialAlignOutput,
CAM_INTF_META_DC_SAC_OUTPUT_INFO, metaTele) {
// Get spatial alignment output shift for tele camera
if (spatialAlignOutput->is_output_shift_valid) {
// Calculate the spatial alignment shift for the current stream dimensions based
// on the reference resolution used for the output shift.
float horzShiftFactor = (float)mFovControlData.previewSize.width /
spatialAlignOutput->reference_res_for_output_shift.width;
float vertShiftFactor = (float)mFovControlData.previewSize.height /
spatialAlignOutput->reference_res_for_output_shift.height;
mFovControlData.spatialAlignResult.shiftTele.shiftHorz =
spatialAlignOutput->output_shift.shift_horz * horzShiftFactor;
mFovControlData.spatialAlignResult.shiftTele.shiftVert =
spatialAlignOutput->output_shift.shift_vert * vertShiftFactor;
LOGD("SAC output shift for Tele: x:%d, y:%d",
mFovControlData.spatialAlignResult.shiftTele.shiftHorz,
mFovControlData.spatialAlignResult.shiftTele.shiftVert);
}
// Get the AF roi shift for tele camera
if (spatialAlignOutput->is_focus_roi_shift_valid) {
// Calculate the spatial alignment shift for the current stream dimensions based
// on the reference resolution used for the output shift.
float horzShiftFactor = (float)mFovControlData.previewSize.width /
spatialAlignOutput->reference_res_for_focus_roi_shift.width;
float vertShiftFactor = (float)mFovControlData.previewSize.height /
spatialAlignOutput->reference_res_for_focus_roi_shift.height;
mFovControlData.spatialAlignResult.shiftAfRoiTele.shiftHorz =
spatialAlignOutput->focus_roi_shift.shift_horz * horzShiftFactor;
mFovControlData.spatialAlignResult.shiftAfRoiTele.shiftVert =
spatialAlignOutput->focus_roi_shift.shift_vert * vertShiftFactor;
LOGD("SAC AF ROI shift for Tele: x:%d, y:%d",
mFovControlData.spatialAlignResult.shiftAfRoiTele.shiftHorz,
mFovControlData.spatialAlignResult.shiftAfRoiTele.shiftVert);
}
}
}
// Update the camera streaming status
if (metaWide) {
mFovControlData.wideCamStreaming = true;
IF_META_AVAILABLE(uint8_t, enableLPM, CAM_INTF_META_DC_LOW_POWER_ENABLE, metaWide) {
if (*enableLPM) {
// If LPM enabled is 1, this is probably the last metadata returned
// before going into LPM state
mFovControlData.wideCamStreaming = false;
// Update active cameras requested by spatial alignment
mFovControlData.spatialAlignResult.activeCameras &= ~mFovControlData.camWide;
} else {
mFovControlData.spatialAlignResult.activeCameras |= mFovControlData.camWide;
}
}
}
if (metaTele) {
mFovControlData.teleCamStreaming = true;
IF_META_AVAILABLE(uint8_t, enableLPM, CAM_INTF_META_DC_LOW_POWER_ENABLE, metaTele) {
if (*enableLPM) {
// If LPM enabled is 1, this is probably the last metadata returned
// before going into LPM state
mFovControlData.teleCamStreaming = false;
// Update active cameras requested by spatial alignment
mFovControlData.spatialAlignResult.activeCameras &= ~mFovControlData.camTele;
} else {
mFovControlData.spatialAlignResult.activeCameras |= mFovControlData.camTele;
}
}
}
// Get AF status
if (metaMain) {
IF_META_AVAILABLE(uint32_t, afState, CAM_INTF_META_AF_STATE, metaMain) {
if ((*afState) != CAM_AF_STATE_INACTIVE) {
mFovControlData.status3A.main.af.status = AF_VALID;
} else {
mFovControlData.status3A.main.af.status = AF_INVALID;
}
mFovControlData.afStatusMain = *afState;
LOGD("AF state: Main cam: %d", mFovControlData.afStatusMain);
}
IF_META_AVAILABLE(float, luxIndex, CAM_INTF_META_AEC_LUX_INDEX, metaMain) {
mFovControlData.status3A.main.ae.luxIndex = *luxIndex;
LOGD("Lux Index: Main cam: %f", mFovControlData.status3A.main.ae.luxIndex);
}
IF_META_AVAILABLE(int32_t, objDist, CAM_INTF_META_AF_OBJ_DIST_CM, metaMain) {
mFovControlData.status3A.main.af.focusDistCm = (*objDist < 0) ? 0 : *objDist;
LOGD("Obj Dist: Main cam: %d", mFovControlData.status3A.main.af.focusDistCm);
}
}
if (metaAux) {
IF_META_AVAILABLE(uint32_t, afState, CAM_INTF_META_AF_STATE, metaAux) {
if ((*afState) != CAM_AF_STATE_INACTIVE) {
mFovControlData.status3A.aux.af.status = AF_VALID;
} else {
mFovControlData.status3A.aux.af.status = AF_INVALID;
}
mFovControlData.afStatusAux = *afState;
LOGD("AF state: Aux cam: %d", mFovControlData.afStatusAux);
}
IF_META_AVAILABLE(float, luxIndex, CAM_INTF_META_AEC_LUX_INDEX, metaAux) {
mFovControlData.status3A.aux.ae.luxIndex = *luxIndex;
LOGD("Lux Index: Aux cam: %f", mFovControlData.status3A.aux.ae.luxIndex);
}
IF_META_AVAILABLE(int32_t, objDist, CAM_INTF_META_AF_OBJ_DIST_CM, metaAux) {
mFovControlData.status3A.aux.af.focusDistCm = (*objDist < 0) ? 0 : *objDist;
LOGD("Obj Dist: Aux cam: %d", mFovControlData.status3A.aux.af.focusDistCm);
}
}
if ((masterCam == CAM_TYPE_AUX) && metaAux) {
// Translate face detection ROI from aux camera
IF_META_AVAILABLE(cam_face_detection_data_t, metaFD,
CAM_INTF_META_FACE_DETECTION, metaAux) {
cam_face_detection_data_t metaFDTranslated;
metaFDTranslated = translateRoiFD(*metaFD, CAM_TYPE_AUX);
ADD_SET_PARAM_ENTRY_TO_BATCH(metaAux, CAM_INTF_META_FACE_DETECTION,
metaFDTranslated);
}
metaResult = metaAux;
}
else if ((masterCam == CAM_TYPE_MAIN) && metaMain) {
// Translate face detection ROI from main camera
IF_META_AVAILABLE(cam_face_detection_data_t, metaFD,
CAM_INTF_META_FACE_DETECTION, metaMain) {
cam_face_detection_data_t metaFDTranslated;
metaFDTranslated = translateRoiFD(*metaFD, CAM_TYPE_MAIN);
ADD_SET_PARAM_ENTRY_TO_BATCH(metaMain, CAM_INTF_META_FACE_DETECTION,
metaFDTranslated);
}
metaResult = metaMain;
} else {
// Metadata for the master camera was dropped
metaResult = NULL;
}
// If snapshot postprocess is enabled, consolidate the AF status to be sent to the app
// when in the transition state.
// Only return focused if both are focused.
if ((mFovControlResult.snapshotPostProcess == true) &&
(mFovControlData.camState == STATE_TRANSITION) &&
metaResult) {
if (((mFovControlData.afStatusMain == CAM_AF_STATE_FOCUSED_LOCKED) ||
(mFovControlData.afStatusMain == CAM_AF_STATE_NOT_FOCUSED_LOCKED)) &&
((mFovControlData.afStatusAux == CAM_AF_STATE_FOCUSED_LOCKED) ||
(mFovControlData.afStatusAux == CAM_AF_STATE_NOT_FOCUSED_LOCKED))) {
// If both indicate focused, return focused.
// If either one indicates 'not focused', return 'not focused'.
if ((mFovControlData.afStatusMain == CAM_AF_STATE_FOCUSED_LOCKED) &&
(mFovControlData.afStatusAux == CAM_AF_STATE_FOCUSED_LOCKED)) {
ADD_SET_PARAM_ENTRY_TO_BATCH(metaResult, CAM_INTF_META_AF_STATE,
CAM_AF_STATE_FOCUSED_LOCKED);
} else {
ADD_SET_PARAM_ENTRY_TO_BATCH(metaResult, CAM_INTF_META_AF_STATE,
CAM_AF_STATE_NOT_FOCUSED_LOCKED);
}
} else {
// If either one indicates passive state or active scan, return that state
if ((mFovControlData.afStatusMain != CAM_AF_STATE_FOCUSED_LOCKED) &&
(mFovControlData.afStatusMain != CAM_AF_STATE_NOT_FOCUSED_LOCKED)) {
ADD_SET_PARAM_ENTRY_TO_BATCH(metaResult, CAM_INTF_META_AF_STATE,
mFovControlData.afStatusMain);
} else {
ADD_SET_PARAM_ENTRY_TO_BATCH(metaResult, CAM_INTF_META_AF_STATE,
mFovControlData.afStatusAux);
}
}
IF_META_AVAILABLE(uint32_t, afState, CAM_INTF_META_AF_STATE, metaResult) {
LOGD("Result AF state: %d", *afState);
}
}
mMutex.unlock();
// Generate FOV-control result only if the result meta is valid
if (metaResult) {
generateFovControlResult();
}
}
return metaResult;
}
/*===========================================================================
* FUNCTION : generateFovControlResult
*
* DESCRIPTION: Generate FOV control result
*
* PARAMETERS : None
*
* RETURN : None
*
*==========================================================================*/
void QCameraFOVControl::generateFovControlResult()
{
Mutex::Autolock lock(mMutex);
float zoom = findZoomRatio(mFovControlData.zoomWide) / (float)mFovControlData.zoomRatioTable[0];
uint32_t zoomWide = mFovControlData.zoomWide;
uint32_t zoomWidePrev = mFovControlData.zoomWidePrev;
if (mFovControlData.configCompleted == false) {
// Return as invalid result if the FOV-control configuration is not yet complete
mFovControlResult.isValid = false;
return;
}
// Update previous zoom value
mFovControlData.zoomWidePrev = mFovControlData.zoomWide;
uint32_t currentBrightness = 0;
uint32_t currentFocusDist = 0;
if (mFovControlResult.camMasterPreview == CAM_TYPE_MAIN) {
currentBrightness = mFovControlData.status3A.main.ae.luxIndex;
currentFocusDist = mFovControlData.status3A.main.af.focusDistCm;
} else if (mFovControlResult.camMasterPreview == CAM_TYPE_AUX) {
currentBrightness = mFovControlData.status3A.aux.ae.luxIndex;
currentFocusDist = mFovControlData.status3A.aux.af.focusDistCm;
}
float transitionLow = mFovControlData.transitionParams.transitionLow;
float transitionHigh = mFovControlData.transitionParams.transitionHigh;
float cutOverWideToTele = mFovControlData.transitionParams.cutOverWideToTele;
float cutOverTeleToWide = mFovControlData.transitionParams.cutOverTeleToWide;
cam_sync_type_t camWide = mFovControlData.camWide;
cam_sync_type_t camTele = mFovControlData.camTele;
uint16_t thresholdBrightness = mFovControlConfig.auxSwitchBrightnessMin;
uint16_t thresholdFocusDist = mFovControlConfig.auxSwitchFocusDistCmMin;
if (zoomWide == zoomWidePrev) {
mFovControlData.zoomDirection = ZOOM_STABLE;
++mFovControlData.zoomStableCount;
} else if (zoomWide > zoomWidePrev) {
mFovControlData.zoomDirection = ZOOM_IN;
mFovControlData.zoomStableCount = 0;
} else {
mFovControlData.zoomDirection = ZOOM_OUT;
mFovControlData.zoomStableCount = 0;
}
// Update snapshot post-process flags
if (mFovControlConfig.snapshotPPConfig.enablePostProcess &&
(zoom >= mFovControlConfig.snapshotPPConfig.zoomMin) &&
(zoom <= mFovControlConfig.snapshotPPConfig.zoomMax)) {
mFovControlResult.snapshotPostProcessZoomRange = true;
} else {
mFovControlResult.snapshotPostProcessZoomRange = false;
}
if (mFovControlResult.snapshotPostProcessZoomRange &&
(currentBrightness >= mFovControlConfig.snapshotPPConfig.luxMin) &&
(currentFocusDist >= mFovControlConfig.snapshotPPConfig.focusDistanceMin)) {
mFovControlResult.snapshotPostProcess = true;
} else {
mFovControlResult.snapshotPostProcess = false;
}
switch (mFovControlData.camState) {
case STATE_WIDE:
// If the scene continues to be bright, update stable count; reset otherwise
if (currentBrightness >= thresholdBrightness) {
++mFovControlData.brightnessStableCount;
} else {
mFovControlData.brightnessStableCount = 0;
}
// If the scene continues to be non-macro, update stable count; reset otherwise
if (currentFocusDist >= thresholdFocusDist) {
++mFovControlData.focusDistStableCount;
} else {
mFovControlData.focusDistStableCount = 0;
}
// Reset fallback to main flag if zoom is less than cutover point
if (zoom <= cutOverTeleToWide) {
mFovControlData.fallbackToWide = false;
}
// Check if the scene is good for aux (bright and far focused)
if ((currentBrightness >= thresholdBrightness) &&
(currentFocusDist >= thresholdFocusDist)) {
// Lower constraint if zooming in or if snapshot postprocessing is true
if (mFovControlResult.snapshotPostProcess ||
(((zoom >= transitionLow) ||
(sacRequestedDualZone())) &&
(mFovControlData.zoomDirection == ZOOM_IN) &&
(mFovControlData.fallbackToWide == false))) {
mFovControlData.camState = STATE_TRANSITION;
mFovControlResult.activeCameras = (camWide | camTele);
}
// Higher constraint if not zooming in
else if ((zoom > cutOverWideToTele) &&
(mFovControlData.brightnessStableCount >=
mFovControlConfig.brightnessStableCountThreshold) &&
(mFovControlData.focusDistStableCount >=
mFovControlConfig.focusDistStableCountThreshold)) {
// Enter the transition state
mFovControlData.camState = STATE_TRANSITION;
mFovControlResult.activeCameras = (camWide | camTele);
// Reset fallback to wide flag
mFovControlData.fallbackToWide = false;
// Reset zoom stable count
mFovControlData.zoomStableCount = 0;
}
}
break;
case STATE_TRANSITION:
// Reset brightness stable count
mFovControlData.brightnessStableCount = 0;
// Reset focus distance stable count
mFovControlData.focusDistStableCount = 0;
// Set the master info
// Switch to wide
if ((mFovControlResult.camMasterPreview == camTele) &&
canSwitchMasterTo(CAM_TYPE_WIDE)) {
mFovControlResult.camMasterPreview = camWide;
mFovControlResult.camMaster3A = camWide;
}
// switch to tele
else if ((mFovControlResult.camMasterPreview == camWide) &&
canSwitchMasterTo(CAM_TYPE_TELE)) {
mFovControlResult.camMasterPreview = camTele;
mFovControlResult.camMaster3A = camTele;
}
// Change the transition state if necessary.
// If fallback to wide is initiated, try to move to wide state
if (mFovControlData.fallbackEnabled && mFovControlData.fallbackToWide) {
if (mFovControlResult.camMasterPreview == camWide) {
mFovControlData.camState = STATE_WIDE;
mFovControlResult.activeCameras = camWide;
}
}
// If snapshot post processing is required, do not change the state.
else if (mFovControlResult.snapshotPostProcess == false) {
if ((zoom < transitionLow) &&
!sacRequestedDualZone() &&
(mFovControlResult.camMasterPreview == camWide)) {
mFovControlData.camState = STATE_WIDE;
mFovControlResult.activeCameras = camWide;
} else if ((zoom > transitionHigh) &&
!sacRequestedDualZone() &&
(mFovControlResult.camMasterPreview == camTele)) {
mFovControlData.camState = STATE_TELE;
mFovControlResult.activeCameras = camTele;
} else if (mFovControlData.zoomStableCount >=
mFovControlConfig.zoomStableCountThreshold) {
// If the zoom is stable put the non-master camera to LPM for power optimization
if (mFovControlResult.camMasterPreview == camWide) {
mFovControlData.camState = STATE_WIDE;
mFovControlResult.activeCameras = camWide;
} else {
mFovControlData.camState = STATE_TELE;
mFovControlResult.activeCameras = camTele;
}
}
}
break;
case STATE_TELE:
// If the scene continues to be dark, update stable count; reset otherwise
if (currentBrightness < thresholdBrightness) {
++mFovControlData.brightnessStableCount;
} else {
mFovControlData.brightnessStableCount = 0;
}
// If the scene continues to be macro, update stable count; reset otherwise
if (currentFocusDist < thresholdFocusDist) {
++mFovControlData.focusDistStableCount;
} else {
mFovControlData.focusDistStableCount = 0;
}
// Lower constraint if zooming out or if the snapshot postprocessing is true
if (mFovControlResult.snapshotPostProcess ||
(((zoom <= transitionHigh) || sacRequestedDualZone()) &&
(mFovControlData.zoomDirection == ZOOM_OUT))) {
mFovControlData.camState = STATE_TRANSITION;
mFovControlResult.activeCameras = (camWide | camTele);
}
// Higher constraint if not zooming out. Only if fallback is enabled
else if (((currentBrightness < thresholdBrightness) ||
(currentFocusDist < thresholdFocusDist)) &&
mFovControlData.fallbackEnabled) {
// Enter transition state if brightness or focus distance is below threshold
if ((mFovControlData.brightnessStableCount >=
mFovControlConfig.brightnessStableCountThreshold) ||
(mFovControlData.focusDistStableCount >=
mFovControlConfig.focusDistStableCountThreshold)) {
mFovControlData.camState = STATE_TRANSITION;
mFovControlResult.activeCameras = (camWide | camTele);
// Reset zoom stable count and set fallback flag to true
mFovControlData.zoomStableCount = 0;
mFovControlData.fallbackToWide = true;
LOGD("Low light/Macro scene - fall back to Wide from Tele");
}
}
break;
}
// Update snapshot postprocess result based on fall back to wide decision
if (mFovControlData.fallbackEnabled && mFovControlData.fallbackToWide) {
mFovControlResult.snapshotPostProcess = false;
}
mFovControlResult.isValid = true;
// Debug print for the FOV-control result
LOGD("Effective zoom: %f", zoom);
LOGD("zoom direction: %d", (uint32_t)mFovControlData.zoomDirection);
LOGD("zoomWide: %d, zoomTele: %d", zoomWide, mFovControlData.zoomTele);
LOGD("Snapshot postprocess: %d", mFovControlResult.snapshotPostProcess);
LOGD("Master camera : %s", (mFovControlResult.camMasterPreview == CAM_TYPE_MAIN) ?
"CAM_TYPE_MAIN" : "CAM_TYPE_AUX");
LOGD("Master camera for preview: %s",
(mFovControlResult.camMasterPreview == camWide ) ? "Wide" : "Tele");
LOGD("Master camera for 3A : %s",
(mFovControlResult.camMaster3A == camWide ) ? "Wide" : "Tele");
LOGD("Wide camera status : %s",
(mFovControlResult.activeCameras & camWide) ? "Active" : "LPM");
LOGD("Tele camera status : %s",
(mFovControlResult.activeCameras & camTele) ? "Active" : "LPM");
LOGD("transition state: %s", ((mFovControlData.camState == STATE_WIDE) ? "STATE_WIDE" :
((mFovControlData.camState == STATE_TELE) ? "STATE_TELE" : "STATE_TRANSITION" )));
}
/*===========================================================================
* FUNCTION : getFovControlResult
*
* DESCRIPTION: Return FOV-control result
*
* PARAMETERS : None
*
* RETURN : FOV-control result
*
*==========================================================================*/
fov_control_result_t QCameraFOVControl::getFovControlResult()
{
Mutex::Autolock lock(mMutex);
fov_control_result_t fovControlResult = mFovControlResult;
return fovControlResult;
}
/*===========================================================================
* FUNCTION : isMainCamFovWider
*
* DESCRIPTION : Check if the main camera FOV is wider than aux
*
* PARAMETERS : None
*
* RETURN :
* true : If main cam FOV is wider than tele
* false : If main cam FOV is narrower than tele
*
*==========================================================================*/
inline bool QCameraFOVControl::isMainCamFovWider()
{
if (mDualCamParams.paramsMain.focalLengthMm <
mDualCamParams.paramsAux.focalLengthMm) {
return true;
} else {
return false;
}
}
/*===========================================================================
* FUNCTION : sacRequestedDualZone
*
* DESCRIPTION : Check if Spatial alignment block requested both the cameras to be active.
* The request is valid only when LPM is enabled.
*
* PARAMETERS : None
*
* RETURN :
* true : If dual zone is requested with LPM enabled
* false : If LPM is disabled or if dual zone is not requested with LPM enabled
*
*==========================================================================*/
inline bool QCameraFOVControl::sacRequestedDualZone()
{
bool ret = false;
cam_sync_type_t camWide = mFovControlData.camWide;
cam_sync_type_t camTele = mFovControlData.camTele;
// Return true if Spatial alignment block requested both the cameras to be active
// in the case of lpm enabled
if ((mFovControlData.spatialAlignResult.activeCameras == (camWide | camTele)) &&
(mFovControlData.lpmEnabled)) {
ret = true;
}
return ret;
}
/*===========================================================================
* FUNCTION : canSwitchMasterTo
*
* DESCRIPTION : Check if the master can be switched to the camera- cam.
*
* PARAMETERS :
* @cam : cam type
*
* RETURN :
* true : If master can be switched
* false : If master cannot be switched
*
*==========================================================================*/
bool QCameraFOVControl::canSwitchMasterTo(
cam_type cam)
{
bool ret = false;
float zoom = findZoomRatio(mFovControlData.zoomWide) / (float)mFovControlData.zoomRatioTable[0];
float cutOverWideToTele = mFovControlData.transitionParams.cutOverWideToTele;
float cutOverTeleToWide = mFovControlData.transitionParams.cutOverTeleToWide;
af_status afStatusAux = mFovControlData.status3A.aux.af.status;
char prop[PROPERTY_VALUE_MAX];
int override = 0;
property_get("persist.camera.fovc.override", prop, "0");
override = atoi(prop);
if(override) {
afStatusAux = AF_VALID;
}
if (cam == CAM_TYPE_WIDE) {
if (mFovControlData.availableSpatialAlignSolns & CAM_SPATIAL_ALIGN_OEM) {
// In case of OEM Spatial alignment solution, check the spatial alignment ready
if (mFovControlData.wideCamStreaming && isSpatialAlignmentReady()) {
ret = true;
}
} else {
// In case of QTI Spatial alignment solution and no spatial alignment solution,
// check the fallback flag or if the zoom level has crossed the threhold.
if ((mFovControlData.fallbackEnabled && mFovControlData.fallbackToWide) ||
(zoom < cutOverTeleToWide)) {
if (mFovControlData.wideCamStreaming) {
ret = true;
}
}
}
} else if (cam == CAM_TYPE_TELE) {
if (mFovControlData.fallbackEnabled && mFovControlData.fallbackToWide) {
// If fallback to wide is initiated, don't switch the master to tele
ret = false;
} else if (mFovControlData.availableSpatialAlignSolns & CAM_SPATIAL_ALIGN_OEM) {
// In case of OEM Spatial alignment solution, check the spatial alignment ready and
// af status
if (mFovControlData.teleCamStreaming &&
isSpatialAlignmentReady() &&
(afStatusAux == AF_VALID)) {
ret = true;
}
} else if (mFovControlData.availableSpatialAlignSolns & CAM_SPATIAL_ALIGN_QTI) {
// In case of QTI Spatial alignment solution check the spatial alignment ready flag,
// af status and if the zoom level has crossed the threhold.
if ((zoom > cutOverWideToTele) &&
isSpatialAlignmentReady() &&
(afStatusAux == AF_VALID)) {
ret = true;
}
} else {
// In case of no spatial alignment solution check af status and
// if the zoom level has crossed the threhold.
if ((zoom > cutOverWideToTele) &&
(afStatusAux == AF_VALID)) {
ret = true;
}
}
} else {
LOGE("Request to switch to invalid cam type");
}
return ret;
}
/*===========================================================================
* FUNCTION : isSpatialAlignmentReady
*
* DESCRIPTION : Check if the spatial alignment is ready.
* For QTI solution, check ready_status flag
* For OEM solution, check camMasterHint
* If the spatial alignment solution is not needed, return true
*
* PARAMETERS : None
*
* RETURN :
* true : If spatial alignment is ready
* false : If spatial alignment is not yet ready
*
*==========================================================================*/
bool QCameraFOVControl::isSpatialAlignmentReady()
{
bool ret = true;
cam_sync_type_t camWide = mFovControlData.camWide;
cam_sync_type_t camTele = mFovControlData.camTele;
if (mFovControlData.availableSpatialAlignSolns & CAM_SPATIAL_ALIGN_OEM) {
uint8_t currentMaster = (uint8_t)mFovControlResult.camMasterPreview;
uint8_t camMasterHint = mFovControlData.spatialAlignResult.camMasterHint;
if (((currentMaster == camWide) && (camMasterHint == camTele)) ||
((currentMaster == camTele) && (camMasterHint == camWide))){
ret = true;
} else {
ret = false;
}
} else if (mFovControlData.availableSpatialAlignSolns & CAM_SPATIAL_ALIGN_QTI) {
if (mFovControlData.spatialAlignResult.readyStatus) {
ret = true;
} else {
ret = false;
}
}
char prop[PROPERTY_VALUE_MAX];
int override = 0;
property_get("persist.camera.fovc.override", prop, "0");
override = atoi(prop);
if(override) {
ret = true;
}
return ret;
}
/*===========================================================================
* FUNCTION : validateAndExtractParameters
*
* DESCRIPTION : Validates a subset of parameters from capabilities and
* saves those parameters for decision making.
*
* PARAMETERS :
* @capsMain : The capabilities for the main camera
* @capsAux : The capabilities for the aux camera
*
* RETURN :
* true : Success
* false : Failure
*
*==========================================================================*/
bool QCameraFOVControl::validateAndExtractParameters(
cam_capability_t *capsMainCam,
cam_capability_t *capsAuxCam)
{
bool rc = false;
if (capsMainCam && capsAuxCam) {
mFovControlConfig.percentMarginHysterisis = 5;
mFovControlConfig.percentMarginMain = 25;
mFovControlConfig.percentMarginAux = 15;
mFovControlConfig.waitTimeForHandoffMs = 1000;
mDualCamParams.paramsMain.sensorStreamWidth =
capsMainCam->related_cam_calibration.main_cam_specific_calibration.\
native_sensor_resolution_width;
mDualCamParams.paramsMain.sensorStreamHeight =
capsMainCam->related_cam_calibration.main_cam_specific_calibration.\
native_sensor_resolution_height;
mDualCamParams.paramsAux.sensorStreamWidth =
capsMainCam->related_cam_calibration.aux_cam_specific_calibration.\
native_sensor_resolution_width;
mDualCamParams.paramsAux.sensorStreamHeight =
capsMainCam->related_cam_calibration.aux_cam_specific_calibration.\
native_sensor_resolution_height;
mDualCamParams.paramsMain.focalLengthMm = capsMainCam->focal_length;
mDualCamParams.paramsAux.focalLengthMm = capsAuxCam->focal_length;
mDualCamParams.paramsMain.pixelPitchUm = capsMainCam->pixel_pitch_um;
mDualCamParams.paramsAux.pixelPitchUm = capsAuxCam->pixel_pitch_um;
if ((capsMainCam->min_focus_distance > 0) &&
(capsAuxCam->min_focus_distance > 0)) {
// Convert the min focus distance from diopters to cm
// and choose the max of both sensors.
uint32_t minFocusDistCmMain = (100.0f / capsMainCam->min_focus_distance);
uint32_t minFocusDistCmAux = (100.0f / capsAuxCam->min_focus_distance);
mDualCamParams.minFocusDistanceCm = (minFocusDistCmMain > minFocusDistCmAux) ?
minFocusDistCmMain : minFocusDistCmAux;
}
if (capsMainCam->related_cam_calibration.relative_position_flag == 0) {
mDualCamParams.positionAux = CAM_POSITION_RIGHT;
} else {
mDualCamParams.positionAux = CAM_POSITION_LEFT;
}
if ((capsMainCam->avail_spatial_align_solns & CAM_SPATIAL_ALIGN_QTI) ||
(capsMainCam->avail_spatial_align_solns & CAM_SPATIAL_ALIGN_OEM)) {
mFovControlData.availableSpatialAlignSolns =
capsMainCam->avail_spatial_align_solns;
} else {
LOGW("Spatial alignment not supported");
}
if (capsMainCam->zoom_supported > 0) {
mFovControlData.zoomRatioTable = capsMainCam->zoom_ratio_tbl;
mFovControlData.zoomRatioTableCount = capsMainCam->zoom_ratio_tbl_cnt;
} else {
LOGE("zoom feature not supported");
return false;
}
rc = true;
}
return rc;
}
/*===========================================================================
* FUNCTION : calculateBasicFovRatio
*
* DESCRIPTION: Calculate the FOV ratio between main and aux cameras
*
* PARAMETERS : None
*
* RETURN :
* true : Success
* false : Failure
*
*==========================================================================*/
bool QCameraFOVControl::calculateBasicFovRatio()
{
float fovWide = 0.0f;
float fovTele = 0.0f;
bool rc = false;
if ((mDualCamParams.paramsMain.focalLengthMm > 0.0f) &&
(mDualCamParams.paramsAux.focalLengthMm > 0.0f)) {
if (mDualCamParams.paramsMain.focalLengthMm <
mDualCamParams.paramsAux.focalLengthMm) {
fovWide = (mDualCamParams.paramsMain.sensorStreamWidth *
mDualCamParams.paramsMain.pixelPitchUm) /
mDualCamParams.paramsMain.focalLengthMm;
fovTele = (mDualCamParams.paramsAux.sensorStreamWidth *
mDualCamParams.paramsAux.pixelPitchUm) /
mDualCamParams.paramsAux.focalLengthMm;
} else {
fovWide = (mDualCamParams.paramsAux.sensorStreamWidth *
mDualCamParams.paramsAux.pixelPitchUm) /
mDualCamParams.paramsAux.focalLengthMm;
fovTele = (mDualCamParams.paramsMain.sensorStreamWidth *
mDualCamParams.paramsMain.pixelPitchUm) /
mDualCamParams.paramsMain.focalLengthMm;
}
if (fovTele > 0.0f) {
mFovControlData.basicFovRatio = (fovWide / fovTele);
rc = true;
}
}
LOGD("Main cam focalLengthMm : %f", mDualCamParams.paramsMain.focalLengthMm);
LOGD("Aux cam focalLengthMm : %f", mDualCamParams.paramsAux.focalLengthMm);
LOGD("Main cam sensorStreamWidth : %u", mDualCamParams.paramsMain.sensorStreamWidth);
LOGD("Main cam sensorStreamHeight: %u", mDualCamParams.paramsMain.sensorStreamHeight);
LOGD("Main cam pixelPitchUm : %f", mDualCamParams.paramsMain.pixelPitchUm);
LOGD("Main cam focalLengthMm : %f", mDualCamParams.paramsMain.focalLengthMm);
LOGD("Aux cam sensorStreamWidth : %u", mDualCamParams.paramsAux.sensorStreamWidth);
LOGD("Aux cam sensorStreamHeight : %u", mDualCamParams.paramsAux.sensorStreamHeight);
LOGD("Aux cam pixelPitchUm : %f", mDualCamParams.paramsAux.pixelPitchUm);
LOGD("Aux cam focalLengthMm : %f", mDualCamParams.paramsAux.focalLengthMm);
LOGD("fov wide : %f", fovWide);
LOGD("fov tele : %f", fovTele);
LOGD("BasicFovRatio : %f", mFovControlData.basicFovRatio);
return rc;
}
/*===========================================================================
* FUNCTION : combineFovAdjustment
*
* DESCRIPTION: Calculate the final FOV adjustment by combining basic FOV ratio
* with the margin info
*
* PARAMETERS : None
*
* RETURN :
* true : Success
* false : Failure
*
*==========================================================================*/
bool QCameraFOVControl::combineFovAdjustment()
{
float ratioMarginWidth;
float ratioMarginHeight;
float adjustedRatio;
bool rc = false;
ratioMarginWidth = (1.0 + (mFovControlData.camMainWidthMargin)) /
(1.0 + (mFovControlData.camAuxWidthMargin));
ratioMarginHeight = (1.0 + (mFovControlData.camMainHeightMargin)) /
(1.0 + (mFovControlData.camAuxHeightMargin));
adjustedRatio = (ratioMarginHeight < ratioMarginWidth) ? ratioMarginHeight : ratioMarginWidth;
if (adjustedRatio > 0.0f) {
mFovControlData.transitionParams.cutOverFactor =
(mFovControlData.basicFovRatio / adjustedRatio);
rc = true;
}
LOGD("Main cam margin for width : %f", mFovControlData.camMainWidthMargin);
LOGD("Main cam margin for height : %f", mFovControlData.camMainHeightMargin);
LOGD("Aux cam margin for width : %f", mFovControlData.camAuxWidthMargin);
LOGD("Aux cam margin for height : %f", mFovControlData.camAuxHeightMargin);
LOGD("Width margin ratio : %f", ratioMarginWidth);
LOGD("Height margin ratio : %f", ratioMarginHeight);
return rc;
}
/*===========================================================================
* FUNCTION : calculateDualCamTransitionParams
*
* DESCRIPTION: Calculate the transition parameters needed to switch the camera
* between main and aux
*
* PARAMETERS :
* @fovAdjustBasic : basic FOV ratio
* @zoomTranslationFactor: translation factor for main, aux zoom
*
* RETURN : none
*
*==========================================================================*/
void QCameraFOVControl::calculateDualCamTransitionParams()
{
float percentMarginWide;
float percentMarginTele;
if (isMainCamFovWider()) {
percentMarginWide = mFovControlConfig.percentMarginMain;
percentMarginTele = mFovControlConfig.percentMarginAux;
} else {
percentMarginWide = mFovControlConfig.percentMarginAux;
percentMarginTele = mFovControlConfig.percentMarginMain;
}
mFovControlData.transitionParams.cropRatio = mFovControlData.basicFovRatio;
mFovControlData.transitionParams.cutOverWideToTele =
mFovControlData.transitionParams.cutOverFactor +
(mFovControlConfig.percentMarginHysterisis / 100.0) * mFovControlData.basicFovRatio;
mFovControlData.transitionParams.cutOverTeleToWide =
mFovControlData.transitionParams.cutOverFactor;
mFovControlData.transitionParams.transitionHigh =
mFovControlData.transitionParams.cutOverWideToTele +
(percentMarginWide / 100.0) * mFovControlData.basicFovRatio;
mFovControlData.transitionParams.transitionLow =
mFovControlData.transitionParams.cutOverTeleToWide -
(percentMarginTele / 100.0) * mFovControlData.basicFovRatio;
if (mFovControlConfig.snapshotPPConfig.enablePostProcess) {
// Expand the transition zone if necessary to account for
// the snapshot post-process settings
if (mFovControlConfig.snapshotPPConfig.zoomMax >
mFovControlData.transitionParams.transitionHigh) {
mFovControlData.transitionParams.transitionHigh =
mFovControlConfig.snapshotPPConfig.zoomMax;
}
if (mFovControlConfig.snapshotPPConfig.zoomMin <
mFovControlData.transitionParams.transitionLow) {
mFovControlData.transitionParams.transitionLow =
mFovControlConfig.snapshotPPConfig.zoomMin;
}
// Set aux switch brightness threshold as the lower of aux switch and
// snapshot post-process thresholds
if (mFovControlConfig.snapshotPPConfig.luxMin < mFovControlConfig.auxSwitchBrightnessMin) {
mFovControlConfig.auxSwitchBrightnessMin = mFovControlConfig.snapshotPPConfig.luxMin;
}
}
LOGD("transition param: TransitionLow %f", mFovControlData.transitionParams.transitionLow);
LOGD("transition param: TeleToWide %f", mFovControlData.transitionParams.cutOverTeleToWide);
LOGD("transition param: WideToTele %f", mFovControlData.transitionParams.cutOverWideToTele);
LOGD("transition param: TransitionHigh %f", mFovControlData.transitionParams.transitionHigh);
}
/*===========================================================================
* FUNCTION : findZoomValue
*
* DESCRIPTION: For the input zoom ratio, find the zoom value.
* Zoom table contains zoom ratios where the indices
* in the zoom table indicate the corresponding zoom values.
* PARAMETERS :
* @zoomRatio : Zoom ratio
*
* RETURN : Zoom value
*
*==========================================================================*/
uint32_t QCameraFOVControl::findZoomValue(
uint32_t zoomRatio)
{
uint32_t zoom = 0;
for (uint32_t i = 0; i < mFovControlData.zoomRatioTableCount; ++i) {
if (zoomRatio <= mFovControlData.zoomRatioTable[i]) {
zoom = i;
break;
}
}
return zoom;
}
/*===========================================================================
* FUNCTION : findZoomRatio
*
* DESCRIPTION: For the input zoom value, find the zoom ratio.
* Zoom table contains zoom ratios where the indices
* in the zoom table indicate the corresponding zoom values.
* PARAMETERS :
* @zoom : zoom value
*
* RETURN : zoom ratio
*
*==========================================================================*/
uint32_t QCameraFOVControl::findZoomRatio(
uint32_t zoom)
{
return mFovControlData.zoomRatioTable[zoom];
}
/*===========================================================================
* FUNCTION : readjustZoomForTele
*
* DESCRIPTION: Calculate the zoom value for the tele camera based on zoom value
* for the wide camera
*
* PARAMETERS :
* @zoomWide : Zoom value for wide camera
*
* RETURN : Zoom value for tele camera
*
*==========================================================================*/
uint32_t QCameraFOVControl::readjustZoomForTele(
uint32_t zoomWide)
{
uint32_t zoomRatioWide;
uint32_t zoomRatioTele;
zoomRatioWide = findZoomRatio(zoomWide);
zoomRatioTele = zoomRatioWide / mFovControlData.transitionParams.cutOverFactor;
return(findZoomValue(zoomRatioTele));
}
/*===========================================================================
* FUNCTION : readjustZoomForWide
*
* DESCRIPTION: Calculate the zoom value for the wide camera based on zoom value
* for the tele camera
*
* PARAMETERS :
* @zoomTele : Zoom value for tele camera
*
* RETURN : Zoom value for wide camera
*
*==========================================================================*/
uint32_t QCameraFOVControl::readjustZoomForWide(
uint32_t zoomTele)
{
uint32_t zoomRatioWide;
uint32_t zoomRatioTele;
zoomRatioTele = findZoomRatio(zoomTele);
zoomRatioWide = zoomRatioTele * mFovControlData.transitionParams.cutOverFactor;
return(findZoomValue(zoomRatioWide));
}
/*===========================================================================
* FUNCTION : convertUserZoomToWideAndTele
*
* DESCRIPTION: Calculate the zoom value for the wide and tele cameras
* based on the input user zoom value
*
* PARAMETERS :
* @zoom : User zoom value
*
* RETURN : none
*
*==========================================================================*/
void QCameraFOVControl::convertUserZoomToWideAndTele(
uint32_t zoom)
{
Mutex::Autolock lock(mMutex);
// If the zoom translation library is present and initialized,
// use it to get wide and tele zoom values
if (mZoomTranslator && mZoomTranslator->isInitialized()) {
uint32_t zoomWide = 0;
uint32_t zoomTele = 0;
if (mZoomTranslator->getZoomValues(zoom, &zoomWide, &zoomTele) != NO_ERROR) {
LOGE("getZoomValues failed from zoom translation lib");
// Use zoom translation logic from FOV-control
mFovControlData.zoomWide = zoom;
mFovControlData.zoomTele = readjustZoomForTele(mFovControlData.zoomWide);
} else {
// Use the zoom values provided by zoom translation lib
mFovControlData.zoomWide = zoomWide;
mFovControlData.zoomTele = zoomTele;
}
} else {
mFovControlData.zoomWide = zoom;
mFovControlData.zoomTele = readjustZoomForTele(mFovControlData.zoomWide);
}
}
/*===========================================================================
* FUNCTION : translateFocusAreas
*
* DESCRIPTION: Translate the focus areas from main to aux camera.
*
* PARAMETERS :
* @roiAfMain : Focus area ROI for main camera
* @cam : Cam type
*
* RETURN : Translated focus area ROI for aux camera
*
*==========================================================================*/
cam_roi_info_t QCameraFOVControl::translateFocusAreas(
cam_roi_info_t roiAfMain,
cam_sync_type_t cam)
{
float fovRatio;
float zoomWide;
float zoomTele;
float AuxDiffRoiLeft;
float AuxDiffRoiTop;
float AuxRoiLeft;
float AuxRoiTop;
cam_roi_info_t roiAfTrans = roiAfMain;
int32_t shiftHorzAdjusted;
int32_t shiftVertAdjusted;
float zoom = findZoomRatio(mFovControlData.zoomWide) / (float)mFovControlData.zoomRatioTable[0];
zoomWide = findZoomRatio(mFovControlData.zoomWide);
zoomTele = findZoomRatio(mFovControlData.zoomTele);
if (cam == mFovControlData.camWide) {
fovRatio = 1.0f;
} else {
fovRatio = (zoomTele / zoomWide) * mFovControlData.transitionParams.cropRatio;
}
// Acquire the mutex in order to read the spatial alignment result which is written
// by another thread
mMutex.lock();
if (cam == mFovControlData.camWide) {
shiftHorzAdjusted = mFovControlData.spatialAlignResult.shiftAfRoiWide.shiftHorz;
shiftVertAdjusted = mFovControlData.spatialAlignResult.shiftAfRoiWide.shiftVert;
} else {
shiftHorzAdjusted = (mFovControlData.transitionParams.cropRatio / zoom) *
mFovControlData.spatialAlignResult.shiftAfRoiTele.shiftHorz;
shiftVertAdjusted = (mFovControlData.transitionParams.cropRatio / zoom) *
mFovControlData.spatialAlignResult.shiftAfRoiTele.shiftVert;
}
mMutex.unlock();
for (int i = 0; i < roiAfMain.num_roi; ++i) {
roiAfTrans.roi[i].width = roiAfMain.roi[i].width * fovRatio;
roiAfTrans.roi[i].height = roiAfMain.roi[i].height * fovRatio;
AuxDiffRoiLeft = (roiAfTrans.roi[i].width - roiAfMain.roi[i].width) / 2.0f;
AuxRoiLeft = roiAfMain.roi[i].left - AuxDiffRoiLeft;
AuxDiffRoiTop = (roiAfTrans.roi[i].height - roiAfMain.roi[i].height) / 2.0f;
AuxRoiTop = roiAfMain.roi[i].top - AuxDiffRoiTop;
roiAfTrans.roi[i].left = AuxRoiLeft - shiftHorzAdjusted;
roiAfTrans.roi[i].top = AuxRoiTop - shiftVertAdjusted;
// Check the ROI bounds and correct if necessory
// If ROI is out of bounds, revert to default ROI
if ((roiAfTrans.roi[i].left >= mFovControlData.previewSize.width) ||
(roiAfTrans.roi[i].top >= mFovControlData.previewSize.height) ||
(roiAfTrans.roi[i].width >= mFovControlData.previewSize.width) ||
(roiAfTrans.roi[i].height >= mFovControlData.previewSize.height)) {
// TODO : use default ROI when available from AF. This part of the code
// is still being worked upon. WA - set it to main cam ROI
roiAfTrans = roiAfMain;
LOGW("AF ROI translation failed, reverting to the default ROI");
} else {
if (roiAfTrans.roi[i].left < 0) {
roiAfTrans.roi[i].left = 0;
LOGW("AF ROI translation failed");
}
if (roiAfTrans.roi[i].top < 0) {
roiAfTrans.roi[i].top = 0;
LOGW("AF ROI translation failed");
}
if ((roiAfTrans.roi[i].left + roiAfTrans.roi[i].width) >=
mFovControlData.previewSize.width) {
roiAfTrans.roi[i].width =
mFovControlData.previewSize.width - roiAfTrans.roi[i].left;
LOGW("AF ROI translation failed");
}
if ((roiAfTrans.roi[i].top + roiAfTrans.roi[i].height) >=
mFovControlData.previewSize.height) {
roiAfTrans.roi[i].height =
mFovControlData.previewSize.height - roiAfTrans.roi[i].top;
LOGW("AF ROI translation failed");
}
}
LOGD("Translated AF ROI-%d %s: L:%d, T:%d, W:%d, H:%d", i,
(cam == CAM_TYPE_MAIN) ? "main cam" : "aux cam", roiAfTrans.roi[i].left,
roiAfTrans.roi[i].top, roiAfTrans.roi[i].width, roiAfTrans.roi[i].height);
}
return roiAfTrans;
}
/*===========================================================================
* FUNCTION : translateMeteringAreas
*
* DESCRIPTION: Translate the AEC metering areas from main to aux camera.
*
* PARAMETERS :
* @roiAfMain : AEC ROI for main camera
* @cam : Cam type
*
* RETURN : Translated AEC ROI for aux camera
*
*==========================================================================*/
cam_set_aec_roi_t QCameraFOVControl::translateMeteringAreas(
cam_set_aec_roi_t roiAecMain,
cam_sync_type_t cam)
{
float fovRatio;
float zoomWide;
float zoomTele;
float AuxDiffRoiX;
float AuxDiffRoiY;
float AuxRoiX;
float AuxRoiY;
cam_set_aec_roi_t roiAecTrans = roiAecMain;
int32_t shiftHorzAdjusted;
int32_t shiftVertAdjusted;
float zoom = findZoomRatio(mFovControlData.zoomWide) / (float)mFovControlData.zoomRatioTable[0];
zoomWide = findZoomRatio(mFovControlData.zoomWide);
zoomTele = findZoomRatio(mFovControlData.zoomTele);
if (cam == mFovControlData.camWide) {
fovRatio = 1.0f;
} else {
fovRatio = (zoomTele / zoomWide) * mFovControlData.transitionParams.cropRatio;
}
// Acquire the mutex in order to read the spatial alignment result which is written
// by another thread
mMutex.lock();
if (cam == mFovControlData.camWide) {
shiftHorzAdjusted = mFovControlData.spatialAlignResult.shiftAfRoiWide.shiftHorz;
shiftVertAdjusted = mFovControlData.spatialAlignResult.shiftAfRoiWide.shiftVert;
} else {
shiftHorzAdjusted = (mFovControlData.transitionParams.cropRatio / zoom) *
mFovControlData.spatialAlignResult.shiftAfRoiTele.shiftHorz;
shiftVertAdjusted = (mFovControlData.transitionParams.cropRatio / zoom) *
mFovControlData.spatialAlignResult.shiftAfRoiTele.shiftVert;
}
mMutex.unlock();
for (int i = 0; i < roiAecMain.num_roi; ++i) {
AuxDiffRoiX = fovRatio * ((float)roiAecMain.cam_aec_roi_position.coordinate[i].x -
(mFovControlData.previewSize.width / 2));
AuxRoiX = (mFovControlData.previewSize.width / 2) + AuxDiffRoiX;
AuxDiffRoiY = fovRatio * ((float)roiAecMain.cam_aec_roi_position.coordinate[i].y -
(mFovControlData.previewSize.height / 2));
AuxRoiY = (mFovControlData.previewSize.height / 2) + AuxDiffRoiY;
roiAecTrans.cam_aec_roi_position.coordinate[i].x = AuxRoiX - shiftHorzAdjusted;
roiAecTrans.cam_aec_roi_position.coordinate[i].y = AuxRoiY - shiftVertAdjusted;
// Check the ROI bounds and correct if necessory
if ((AuxRoiX < 0) ||
(AuxRoiY < 0)) {
roiAecTrans.cam_aec_roi_position.coordinate[i].x = 0;
roiAecTrans.cam_aec_roi_position.coordinate[i].y = 0;
LOGW("AEC ROI translation failed");
} else if ((AuxRoiX >= mFovControlData.previewSize.width) ||
(AuxRoiY >= mFovControlData.previewSize.height)) {
// Clamp the Aux AEC ROI co-ordinates to max possible value
if (AuxRoiX >= mFovControlData.previewSize.width) {
roiAecTrans.cam_aec_roi_position.coordinate[i].x =
mFovControlData.previewSize.width - 1;
}
if (AuxRoiY >= mFovControlData.previewSize.height) {
roiAecTrans.cam_aec_roi_position.coordinate[i].y =
mFovControlData.previewSize.height - 1;
}
LOGW("AEC ROI translation failed");
}
LOGD("Translated AEC ROI-%d %s: x:%d, y:%d", i,
(cam == CAM_TYPE_MAIN) ? "main cam" : "aux cam",
roiAecTrans.cam_aec_roi_position.coordinate[i].x,
roiAecTrans.cam_aec_roi_position.coordinate[i].y);
}
return roiAecTrans;
}
/*===========================================================================
* FUNCTION : translateRoiFD
*
* DESCRIPTION: Translate face detection ROI from aux metadata to main
*
* PARAMETERS :
* @faceDetectionInfo : face detection data from aux metadata. This face
* detection data is overwritten with the translated
* FD ROI.
* @cam : Cam type
*
* RETURN : none
*
*==========================================================================*/
cam_face_detection_data_t QCameraFOVControl::translateRoiFD(
cam_face_detection_data_t metaFD,
cam_sync_type_t cam)
{
cam_face_detection_data_t metaFDTranslated = metaFD;
int32_t shiftHorz = 0;
int32_t shiftVert = 0;
if (cam == mFovControlData.camWide) {
shiftHorz = mFovControlData.spatialAlignResult.shiftWide.shiftHorz;
shiftVert = mFovControlData.spatialAlignResult.shiftWide.shiftVert;
} else {
shiftHorz = mFovControlData.spatialAlignResult.shiftTele.shiftHorz;
shiftVert = mFovControlData.spatialAlignResult.shiftTele.shiftVert;
}
for (int i = 0; i < metaFDTranslated.num_faces_detected; ++i) {
metaFDTranslated.faces[i].face_boundary.left += shiftHorz;
metaFDTranslated.faces[i].face_boundary.top += shiftVert;
}
// If ROI is out of bounds, remove that FD ROI from the list
for (int i = 0; i < metaFDTranslated.num_faces_detected; ++i) {
if ((metaFDTranslated.faces[i].face_boundary.left < 0) ||
(metaFDTranslated.faces[i].face_boundary.left >= mFovControlData.previewSize.width) ||
(metaFDTranslated.faces[i].face_boundary.top < 0) ||
(metaFDTranslated.faces[i].face_boundary.top >= mFovControlData.previewSize.height) ||
((metaFDTranslated.faces[i].face_boundary.left +
metaFDTranslated.faces[i].face_boundary.width) >=
mFovControlData.previewSize.width) ||
((metaFDTranslated.faces[i].face_boundary.top +
metaFDTranslated.faces[i].face_boundary.height) >=
mFovControlData.previewSize.height)) {
// Invalid FD ROI detected
LOGD("Failed translating FD ROI %s: L:%d, T:%d, W:%d, H:%d",
(cam == CAM_TYPE_MAIN) ? "main cam" : "aux cam",
metaFDTranslated.faces[i].face_boundary.left,
metaFDTranslated.faces[i].face_boundary.top,
metaFDTranslated.faces[i].face_boundary.width,
metaFDTranslated.faces[i].face_boundary.height);
// Remove it by copying the last FD ROI at this index
if (i < (metaFDTranslated.num_faces_detected - 1)) {
metaFDTranslated.faces[i] =
metaFDTranslated.faces[metaFDTranslated.num_faces_detected - 1];
// Decrement the current index to process the newly copied FD ROI.
--i;
}
--metaFDTranslated.num_faces_detected;
}
else {
LOGD("Translated FD ROI-%d %s: L:%d, T:%d, W:%d, H:%d", i,
(cam == CAM_TYPE_MAIN) ? "main cam" : "aux cam",
metaFDTranslated.faces[i].face_boundary.left,
metaFDTranslated.faces[i].face_boundary.top,
metaFDTranslated.faces[i].face_boundary.width,
metaFDTranslated.faces[i].face_boundary.height);
}
}
return metaFDTranslated;
}
/*===========================================================================
* FUNCTION : getFrameMargins
*
* DESCRIPTION : Return frame margin data for the requested camera
*
* PARAMETERS :
* @masterCamera : Master camera id
*
* RETURN : Frame margins
*
*==========================================================================*/
cam_frame_margins_t QCameraFOVControl::getFrameMargins(
int8_t masterCamera)
{
cam_frame_margins_t frameMargins;
memset(&frameMargins, 0, sizeof(cam_frame_margins_t));
if (masterCamera == CAM_TYPE_MAIN) {
frameMargins.widthMargins = mFovControlData.camMainWidthMargin;
frameMargins.heightMargins = mFovControlData.camMainHeightMargin;
} else if (masterCamera == CAM_TYPE_AUX) {
frameMargins.widthMargins = mFovControlData.camAuxWidthMargin;
frameMargins.heightMargins = mFovControlData.camAuxHeightMargin;
}
return frameMargins;
}
}; // namespace qcamera