| /* |
| * Copyright (C) Texas Instruments - http://www.ti.com/ |
| * |
| * 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. |
| */ |
| |
| /** |
| * @file OMXAlgo.cpp |
| * |
| * This file contains functionality for handling algorithm configurations. |
| * |
| */ |
| |
| #include "CameraHal.h" |
| #include "OMXCameraAdapter.h" |
| #include "ErrorUtils.h" |
| |
| #undef TRUE |
| |
| namespace Ti { |
| namespace Camera { |
| |
| status_t OMXCameraAdapter::setParametersAlgo(const android::CameraParameters ¶ms, |
| BaseCameraAdapter::AdapterState state) |
| { |
| status_t ret = NO_ERROR; |
| const char *valstr = NULL; |
| const char *valManualStr = NULL; |
| const char *oldstr = NULL; |
| OMXCameraPortParameters *cap; |
| BrightnessMode gbce = BRIGHTNESS_OFF; |
| BrightnessMode glbce = BRIGHTNESS_OFF; |
| |
| LOG_FUNCTION_NAME; |
| |
| CaptureMode capMode; |
| CAMHAL_LOGDB("Capture mode %s", params.get(TICameraParameters::KEY_CAP_MODE)); |
| if ( (valstr = params.get(TICameraParameters::KEY_CAP_MODE)) != NULL ) { |
| if (strcmp(valstr, (const char *) TICameraParameters::HIGH_PERFORMANCE_MODE) == 0) { |
| capMode = OMXCameraAdapter::HIGH_SPEED; |
| mCapabilitiesOpMode = MODE_HIGH_SPEED; |
| } else if (strcmp(valstr, (const char *) TICameraParameters::EXPOSURE_BRACKETING) == 0) { |
| capMode = OMXCameraAdapter::HIGH_SPEED; |
| mCapabilitiesOpMode = MODE_HIGH_SPEED; |
| } else if (strcmp(valstr, (const char *) TICameraParameters::ZOOM_BRACKETING) == 0) { |
| capMode = OMXCameraAdapter::HIGH_SPEED; |
| mCapabilitiesOpMode = MODE_HIGH_SPEED; |
| } else if (strcmp(valstr, (const char *) TICameraParameters::HIGH_QUALITY_MODE) == 0) { |
| capMode = OMXCameraAdapter::HIGH_QUALITY; |
| mCapabilitiesOpMode = MODE_HIGH_QUALITY; |
| } else if (strcmp(valstr, (const char *) TICameraParameters::HIGH_QUALITY_ZSL_MODE) == 0) { |
| capMode = OMXCameraAdapter::HIGH_QUALITY_ZSL; |
| mCapabilitiesOpMode = MODE_ZEROSHUTTERLAG; |
| } else if (strcmp(valstr, (const char *) TICameraParameters::VIDEO_MODE) == 0) { |
| capMode = OMXCameraAdapter::VIDEO_MODE; |
| mCapabilitiesOpMode = MODE_VIDEO; |
| } else if (strcmp(valstr, (const char *) TICameraParameters::VIDEO_MODE_HQ) == 0) { |
| capMode = OMXCameraAdapter::VIDEO_MODE_HQ; |
| mCapabilitiesOpMode = MODE_VIDEO_HIGH_QUALITY; |
| } else if (strcmp(valstr, (const char *) TICameraParameters::CP_CAM_MODE) == 0) { |
| capMode = OMXCameraAdapter::CP_CAM; |
| mCapabilitiesOpMode = MODE_CPCAM; |
| } else if (strcmp(valstr, (const char *) TICameraParameters::TEMP_BRACKETING) == 0) { |
| capMode = OMXCameraAdapter::HIGH_SPEED; |
| mCapabilitiesOpMode = MODE_HIGH_SPEED; |
| } else { |
| capMode = OMXCameraAdapter::HIGH_QUALITY; |
| mCapabilitiesOpMode = MODE_HIGH_QUALITY; |
| } |
| |
| } else { |
| capMode = OMXCameraAdapter::HIGH_QUALITY; |
| mCapabilitiesOpMode = MODE_HIGH_QUALITY; |
| } |
| |
| if ( mSensorIndex == 2 ) { |
| mCapabilitiesOpMode = MODE_STEREO; |
| } |
| |
| if ( mCapMode != capMode ) { |
| mCapMode = capMode; |
| mOMXStateSwitch = true; |
| mPendingPreviewSettings |= SetCapMode; |
| } |
| |
| CAMHAL_LOGDB("Capture Mode set %d", mCapMode); |
| |
| /// Configure IPP, LDCNSF, GBCE and GLBCE only in HQ mode |
| IPPMode ipp; |
| if((mCapMode == OMXCameraAdapter::HIGH_QUALITY) || (mCapMode == OMXCameraAdapter::HIGH_QUALITY_ZSL) |
| || (mCapMode == OMXCameraAdapter::VIDEO_MODE) |
| || (mCapMode == OMXCameraAdapter::CP_CAM)) |
| { |
| if ( (valstr = params.get(TICameraParameters::KEY_IPP)) != NULL ) |
| { |
| if (strcmp(valstr, (const char *) TICameraParameters::IPP_LDCNSF) == 0) |
| { |
| ipp = OMXCameraAdapter::IPP_LDCNSF; |
| } |
| else if (strcmp(valstr, (const char *) TICameraParameters::IPP_LDC) == 0) |
| { |
| ipp = OMXCameraAdapter::IPP_LDC; |
| } |
| else if (strcmp(valstr, (const char *) TICameraParameters::IPP_NSF) == 0) |
| { |
| ipp = OMXCameraAdapter::IPP_NSF; |
| } |
| else if (strcmp(valstr, (const char *) TICameraParameters::IPP_NONE) == 0) |
| { |
| ipp = OMXCameraAdapter::IPP_NONE; |
| } |
| else |
| { |
| ipp = OMXCameraAdapter::IPP_NONE; |
| } |
| } |
| else |
| { |
| ipp = OMXCameraAdapter::IPP_NONE; |
| } |
| |
| CAMHAL_LOGVB("IPP Mode set %d", ipp); |
| |
| if (((valstr = params.get(TICameraParameters::KEY_GBCE)) != NULL) ) { |
| if (strcmp(valstr, android::CameraParameters::TRUE ) == 0) { |
| gbce = BRIGHTNESS_ON; |
| } else { |
| gbce = BRIGHTNESS_OFF; |
| } |
| |
| if ( gbce != mGBCE ) { |
| mGBCE = gbce; |
| setGBCE(mGBCE); |
| } |
| |
| } else if(mFirstTimeInit) { |
| //Disable GBCE by default |
| setGBCE(OMXCameraAdapter::BRIGHTNESS_OFF); |
| } |
| |
| if ( ( valstr = params.get(TICameraParameters::KEY_GLBCE) ) != NULL ) { |
| |
| if (strcmp(valstr, android::CameraParameters::TRUE) == 0) { |
| glbce = BRIGHTNESS_ON; |
| } else { |
| glbce = BRIGHTNESS_OFF; |
| } |
| |
| if ( glbce != mGLBCE ) { |
| mGLBCE = glbce; |
| setGLBCE(mGLBCE); |
| } |
| |
| } else if(mFirstTimeInit) { |
| //Disable GLBCE by default |
| setGLBCE(OMXCameraAdapter::BRIGHTNESS_OFF); |
| } |
| |
| } else { |
| ipp = OMXCameraAdapter::IPP_NONE; |
| } |
| |
| if ( mIPP != ipp ) |
| { |
| mIPP = ipp; |
| mOMXStateSwitch = true; |
| mPendingPreviewSettings |= SetLDC; |
| mPendingPreviewSettings |= SetNSF; |
| } |
| |
| ///Set VNF Configuration |
| bool vnfEnabled = false; |
| valstr = params.get(TICameraParameters::KEY_VNF); |
| if (valstr && strcmp(valstr, android::CameraParameters::TRUE) == 0) |
| { |
| CAMHAL_LOGDA("VNF Enabled"); |
| vnfEnabled = true; |
| } |
| else |
| { |
| CAMHAL_LOGDA("VNF Disabled"); |
| vnfEnabled = false; |
| } |
| |
| if ( mVnfEnabled != vnfEnabled ) |
| { |
| mVnfEnabled = vnfEnabled; |
| mOMXStateSwitch = true; |
| mPendingPreviewSettings |= SetVNF; |
| } |
| |
| ///Set VSTAB Configuration |
| bool vstabEnabled = false; |
| valstr = params.get(android::CameraParameters::KEY_VIDEO_STABILIZATION); |
| if (valstr && strcmp(valstr, android::CameraParameters::TRUE) == 0) { |
| CAMHAL_LOGDA("VSTAB Enabled"); |
| vstabEnabled = true; |
| } |
| else |
| { |
| CAMHAL_LOGDA("VSTAB Disabled"); |
| vstabEnabled = false; |
| } |
| |
| if ( mVstabEnabled != vstabEnabled ) |
| { |
| mVstabEnabled = vstabEnabled; |
| mOMXStateSwitch = true; |
| mPendingPreviewSettings |= SetVSTAB; |
| } |
| |
| //A work-around for a failing call to OMX flush buffers |
| if ( ( capMode = OMXCameraAdapter::VIDEO_MODE ) && |
| ( mVstabEnabled ) ) |
| { |
| mOMXStateSwitch = true; |
| } |
| |
| #ifdef OMAP_ENHANCEMENT |
| |
| //Set Auto Convergence Mode |
| valstr = params.get((const char *) TICameraParameters::KEY_AUTOCONVERGENCE_MODE); |
| valManualStr = params.get(TICameraParameters::KEY_MANUAL_CONVERGENCE); |
| |
| cap = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex]; |
| |
| if (cap->mFrameLayoutType != OMX_TI_StereoFrameLayout2D) { |
| if ((valstr != NULL) || (valManualStr != NULL)) { |
| setAutoConvergence(valstr, valManualStr, params); |
| if (valstr != NULL) { |
| CAMHAL_LOGDB("AutoConvergenceMode %s", valstr); |
| } |
| if (valManualStr != NULL) { |
| CAMHAL_LOGDB("Manual Convergence %s", valManualStr); |
| } |
| } |
| |
| //Set Mechanical Misalignment Correction |
| valstr = params.get(TICameraParameters::KEY_MECHANICAL_MISALIGNMENT_CORRECTION); |
| if ( valstr != NULL ) { |
| setMechanicalMisalignmentCorrection(strcmp(valstr, android::CameraParameters::TRUE) == 0); |
| CAMHAL_LOGDB("Mechanical Misalignment Correction %s", valstr); |
| } |
| } |
| |
| #endif |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| // Set AutoConvergence |
| status_t OMXCameraAdapter::setAutoConvergence(const char *pValstr, const char *pValManualstr, const android::CameraParameters ¶ms) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_TI_CONFIG_CONVERGENCETYPE ACParams; |
| const char *str = NULL; |
| android::Vector<android::sp<CameraArea> > tempAreas; |
| int mode; |
| int changed = 0; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( pValManualstr != NULL ) { |
| OMX_S32 manualConvergence = (OMX_S32)strtol(pValManualstr ,0 ,0); |
| |
| if (mManualConv != manualConvergence) { |
| mManualConv = manualConvergence; |
| changed = 1; |
| } |
| } |
| |
| if ( pValstr != NULL ) { |
| mode = getLUTvalue_HALtoOMX(pValstr, mAutoConvergenceLUT); |
| |
| if ( NAME_NOT_FOUND == mode ) { |
| CAMHAL_LOGEB("Wrong convergence mode: %s", pValstr); |
| LOG_FUNCTION_NAME_EXIT; |
| return mode; |
| } |
| |
| if ( mAutoConv != static_cast<OMX_TI_AUTOCONVERGENCEMODETYPE> (mode) ) { |
| mAutoConv = static_cast<OMX_TI_AUTOCONVERGENCEMODETYPE> (mode); |
| changed = 1; |
| } |
| } |
| |
| if ( OMX_TI_AutoConvergenceModeFocusFaceTouch == mAutoConv ) { |
| android::AutoMutex lock(mTouchAreasLock); |
| |
| str = params.get(android::CameraParameters::KEY_METERING_AREAS); |
| |
| if ( NULL != str ) { |
| ret = CameraArea::parseAreas(str, ( strlen(str) + 1 ), tempAreas); |
| } else { |
| CAMHAL_LOGEB("Touch areas not received in %s", |
| android::CameraParameters::KEY_METERING_AREAS); |
| LOG_FUNCTION_NAME_EXIT; |
| return BAD_VALUE; |
| } |
| |
| if ( CameraArea::areAreasDifferent(mTouchAreas, tempAreas) ) { |
| mTouchAreas.clear(); |
| mTouchAreas = tempAreas; |
| changed = 1; |
| } |
| } |
| |
| if (!changed) { |
| LOG_FUNCTION_NAME_EXIT; |
| return NO_ERROR; |
| } |
| |
| OMXCameraPortParameters * mPreviewData; |
| mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex]; |
| |
| ACParams.nSize = (OMX_U32)sizeof(OMX_TI_CONFIG_CONVERGENCETYPE); |
| ACParams.nVersion = mLocalVersionParam; |
| ACParams.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| |
| OMX_GetConfig(mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE)OMX_TI_IndexConfigAutoConvergence, |
| &ACParams); |
| |
| ACParams.eACMode = mAutoConv; |
| ACParams.nManualConverence = mManualConv; |
| |
| if (1 == mTouchAreas.size()) { |
| int widthDivisor = 1; |
| int heightDivisor = 1; |
| |
| if (mPreviewData->mFrameLayoutType == OMX_TI_StereoFrameLayoutTopBottom) { |
| heightDivisor = 2; |
| } |
| if (mPreviewData->mFrameLayoutType == OMX_TI_StereoFrameLayoutLeftRight) { |
| widthDivisor = 2; |
| } |
| |
| // transform the coordinates to 3A-type coordinates |
| mTouchAreas.itemAt(0)->transfrom((size_t)mPreviewData->mWidth/widthDivisor, |
| (size_t)mPreviewData->mHeight/heightDivisor, |
| (size_t&) ACParams.nACProcWinStartY, |
| (size_t&) ACParams.nACProcWinStartX, |
| (size_t&) ACParams.nACProcWinWidth, |
| (size_t&) ACParams.nACProcWinHeight); |
| } |
| |
| CAMHAL_LOGDB("nSize %d", (int)ACParams.nSize); |
| CAMHAL_LOGDB("nPortIndex %d", (int)ACParams.nPortIndex); |
| CAMHAL_LOGDB("nManualConverence %d", (int)ACParams.nManualConverence); |
| CAMHAL_LOGDB("eACMode %d", (int)ACParams.eACMode); |
| CAMHAL_LOGDB("nACProcWinStartX %d", (int)ACParams.nACProcWinStartX); |
| CAMHAL_LOGDB("nACProcWinStartY %d", (int)ACParams.nACProcWinStartY); |
| CAMHAL_LOGDB("nACProcWinWidth %d", (int)ACParams.nACProcWinWidth); |
| CAMHAL_LOGDB("nACProcWinHeight %d", (int)ACParams.nACProcWinHeight); |
| CAMHAL_LOGDB("bACStatus %d", (int)ACParams.bACStatus); |
| |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE)OMX_TI_IndexConfigAutoConvergence, |
| &ACParams); |
| |
| if ( eError != OMX_ErrorNone ) { |
| CAMHAL_LOGEB("Error while setting AutoConvergence 0x%x", eError); |
| ret = BAD_VALUE; |
| } else { |
| CAMHAL_LOGDA("AutoConvergence applied successfully"); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::enableVideoNoiseFilter(bool enable) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_PARAM_VIDEONOISEFILTERTYPE vnfCfg; |
| |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( NO_ERROR == ret ) |
| { |
| OMX_INIT_STRUCT_PTR (&vnfCfg, OMX_PARAM_VIDEONOISEFILTERTYPE); |
| |
| if ( enable ) |
| { |
| CAMHAL_LOGDA("VNF is enabled"); |
| vnfCfg.eMode = OMX_VideoNoiseFilterModeOn; |
| } |
| else |
| { |
| CAMHAL_LOGDA("VNF is disabled"); |
| vnfCfg.eMode = OMX_VideoNoiseFilterModeOff; |
| } |
| |
| eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp, |
| ( OMX_INDEXTYPE ) OMX_IndexParamVideoNoiseFilter, |
| &vnfCfg); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while configuring video noise filter 0x%x", eError); |
| ret = -1; |
| } |
| else |
| { |
| CAMHAL_LOGDA("Video noise filter is configured successfully"); |
| } |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::enableVideoStabilization(bool enable) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_CONFIG_FRAMESTABTYPE frameStabCfg; |
| |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( NO_ERROR == ret ) |
| { |
| OMX_CONFIG_BOOLEANTYPE vstabp; |
| OMX_INIT_STRUCT_PTR (&vstabp, OMX_CONFIG_BOOLEANTYPE); |
| if(enable) |
| { |
| vstabp.bEnabled = OMX_TRUE; |
| } |
| else |
| { |
| vstabp.bEnabled = OMX_FALSE; |
| } |
| |
| eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE)OMX_IndexParamFrameStabilisation, |
| &vstabp); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while configuring video stabilization param 0x%x", eError); |
| ret = -1; |
| } |
| else |
| { |
| CAMHAL_LOGDA("Video stabilization param configured successfully"); |
| } |
| |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| |
| OMX_INIT_STRUCT_PTR (&frameStabCfg, OMX_CONFIG_FRAMESTABTYPE); |
| |
| |
| eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp, |
| ( OMX_INDEXTYPE ) OMX_IndexConfigCommonFrameStabilisation, |
| &frameStabCfg); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while getting video stabilization mode 0x%x", |
| (unsigned int)eError); |
| ret = -1; |
| } |
| |
| CAMHAL_LOGDB("VSTAB Port Index = %d", (int)frameStabCfg.nPortIndex); |
| |
| frameStabCfg.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| if ( enable ) |
| { |
| CAMHAL_LOGDA("VSTAB is enabled"); |
| frameStabCfg.bStab = OMX_TRUE; |
| } |
| else |
| { |
| CAMHAL_LOGDA("VSTAB is disabled"); |
| frameStabCfg.bStab = OMX_FALSE; |
| |
| } |
| |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| ( OMX_INDEXTYPE ) OMX_IndexConfigCommonFrameStabilisation, |
| &frameStabCfg); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while configuring video stabilization mode 0x%x", eError); |
| ret = -1; |
| } |
| else |
| { |
| CAMHAL_LOGDA("Video stabilization mode configured successfully"); |
| } |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::setGBCE(OMXCameraAdapter::BrightnessMode mode) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_TI_CONFIG_LOCAL_AND_GLOBAL_BRIGHTNESSCONTRASTTYPE bControl; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateInvalid == mComponentState ) |
| { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| ret = -EINVAL; |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| OMX_INIT_STRUCT_PTR (&bControl, OMX_TI_CONFIG_LOCAL_AND_GLOBAL_BRIGHTNESSCONTRASTTYPE); |
| |
| bControl.nPortIndex = OMX_ALL; |
| |
| switch ( mode ) |
| { |
| case OMXCameraAdapter::BRIGHTNESS_ON: |
| { |
| bControl.eControl = OMX_TI_BceModeOn; |
| break; |
| } |
| case OMXCameraAdapter::BRIGHTNESS_AUTO: |
| { |
| bControl.eControl = OMX_TI_BceModeAuto; |
| break; |
| } |
| case OMXCameraAdapter::BRIGHTNESS_OFF: |
| default: |
| { |
| bControl.eControl = OMX_TI_BceModeOff; |
| break; |
| } |
| } |
| |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| ( OMX_INDEXTYPE ) OMX_TI_IndexConfigGlobalBrightnessContrastEnhance, |
| &bControl); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while setting GBCE 0x%x", eError); |
| } |
| else |
| { |
| CAMHAL_LOGDB("GBCE configured successfully 0x%x", mode); |
| } |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::setGLBCE(OMXCameraAdapter::BrightnessMode mode) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_TI_CONFIG_LOCAL_AND_GLOBAL_BRIGHTNESSCONTRASTTYPE bControl; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateInvalid == mComponentState ) |
| { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| ret = -EINVAL; |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| OMX_INIT_STRUCT_PTR (&bControl, OMX_TI_CONFIG_LOCAL_AND_GLOBAL_BRIGHTNESSCONTRASTTYPE); |
| bControl.nPortIndex = OMX_ALL; |
| |
| switch ( mode ) |
| { |
| case OMXCameraAdapter::BRIGHTNESS_ON: |
| { |
| bControl.eControl = OMX_TI_BceModeOn; |
| break; |
| } |
| case OMXCameraAdapter::BRIGHTNESS_AUTO: |
| { |
| bControl.eControl = OMX_TI_BceModeAuto; |
| break; |
| } |
| case OMXCameraAdapter::BRIGHTNESS_OFF: |
| default: |
| { |
| bControl.eControl = OMX_TI_BceModeOff; |
| break; |
| } |
| } |
| |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| ( OMX_INDEXTYPE ) OMX_TI_IndexConfigLocalBrightnessContrastEnhance, |
| &bControl); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while configure GLBCE 0x%x", eError); |
| } |
| else |
| { |
| CAMHAL_LOGDA("GLBCE configured successfully"); |
| } |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::setCaptureMode(OMXCameraAdapter::CaptureMode mode) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_CONFIG_CAMOPERATINGMODETYPE camMode; |
| OMX_CONFIG_BOOLEANTYPE bCAC; |
| OMX_TI_CONFIG_SINGLEPREVIEWMODETYPE singlePrevMode; |
| |
| LOG_FUNCTION_NAME; |
| |
| //CAC is disabled by default |
| OMX_INIT_STRUCT_PTR (&bCAC, OMX_CONFIG_BOOLEANTYPE); |
| OMX_INIT_STRUCT_PTR (&singlePrevMode, OMX_TI_CONFIG_SINGLEPREVIEWMODETYPE); |
| bCAC.bEnabled = OMX_FALSE; |
| |
| if ( NO_ERROR == ret ) |
| { |
| |
| OMX_INIT_STRUCT_PTR (&camMode, OMX_CONFIG_CAMOPERATINGMODETYPE); |
| if ( mSensorIndex == OMX_TI_StereoSensor ) { |
| if ( OMXCameraAdapter::VIDEO_MODE == mode ) { |
| CAMHAL_LOGDA("Camera mode: STEREO VIDEO"); |
| camMode.eCamOperatingMode = OMX_TI_StereoVideo; |
| } else { |
| CAMHAL_LOGDA("Camera mode: STEREO"); |
| camMode.eCamOperatingMode = OMX_CaptureStereoImageCapture; |
| } |
| } else if ( OMXCameraAdapter::HIGH_SPEED == mode ) { |
| CAMHAL_LOGDA("Camera mode: HIGH SPEED"); |
| camMode.eCamOperatingMode = OMX_CaptureImageHighSpeedTemporalBracketing; |
| } else if ( OMXCameraAdapter::CP_CAM == mode ) { |
| CAMHAL_LOGDA("Camera mode: CP CAM"); |
| camMode.eCamOperatingMode = OMX_TI_CPCam; |
| // TODO(XXX): Hardcode for now until we implement re-proc pipe |
| singlePrevMode.eMode = OMX_TI_SinglePreviewMode_ImageCaptureHighSpeed; |
| } else if( OMXCameraAdapter::HIGH_QUALITY == mode ) { |
| CAMHAL_LOGDA("Camera mode: HIGH QUALITY"); |
| camMode.eCamOperatingMode = OMX_CaptureImageProfileBase; |
| } else if( OMXCameraAdapter::HIGH_QUALITY_ZSL== mode ) { |
| const char* valstr = NULL; |
| CAMHAL_LOGDA("Camera mode: HIGH QUALITY_ZSL"); |
| camMode.eCamOperatingMode = OMX_TI_CaptureImageProfileZeroShutterLag; |
| |
| #ifdef CAMERAHAL_TUNA |
| if ( !mIternalRecordingHint ) { |
| zslHistoryLen.nHistoryLen = 5; |
| } |
| #endif |
| |
| } else if( OMXCameraAdapter::VIDEO_MODE == mode ) { |
| CAMHAL_LOGDA("Camera mode: VIDEO MODE"); |
| camMode.eCamOperatingMode = OMX_CaptureVideo; |
| } else if( OMXCameraAdapter::VIDEO_MODE_HQ == mode ) { |
| CAMHAL_LOGDA("Camera mode: VIDEO MODE HQ"); |
| camMode.eCamOperatingMode = OMX_CaptureHighQualityVideo; |
| } else { |
| CAMHAL_LOGEA("Camera mode: INVALID mode passed!"); |
| return BAD_VALUE; |
| } |
| |
| if( NO_ERROR == ret ) |
| { |
| eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp, |
| ( OMX_INDEXTYPE ) OMX_IndexCameraOperatingMode, |
| &camMode); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while configuring camera mode 0x%x", eError); |
| ret = Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| else |
| { |
| CAMHAL_LOGDA("Camera mode configured successfully"); |
| } |
| } |
| |
| if((NO_ERROR == ret) && (OMXCameraAdapter::CP_CAM == mode)) { |
| //Configure Single Preview Mode |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| ( OMX_INDEXTYPE ) OMX_TI_IndexConfigSinglePreviewMode, |
| &singlePrevMode); |
| if ( OMX_ErrorNone != eError ) { |
| CAMHAL_LOGEB("Error while configuring single preview mode 0x%x", eError); |
| ret = Utils::ErrorUtils::omxToAndroidError(eError); |
| } else { |
| CAMHAL_LOGDA("single preview mode configured successfully"); |
| } |
| } |
| |
| |
| if( NO_ERROR == ret ) |
| { |
| //Configure CAC |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| ( OMX_INDEXTYPE ) OMX_IndexConfigChromaticAberrationCorrection, |
| &bCAC); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while configuring CAC 0x%x", eError); |
| ret = Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| else |
| { |
| CAMHAL_LOGDA("CAC configured successfully"); |
| } |
| } |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::setLDC(OMXCameraAdapter::IPPMode mode) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_CONFIG_BOOLEANTYPE bOMX; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateLoaded != mComponentState ) |
| { |
| CAMHAL_LOGEA("OMX component is not in loaded state"); |
| ret = -EINVAL; |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| OMX_INIT_STRUCT_PTR (&bOMX, OMX_CONFIG_BOOLEANTYPE); |
| |
| switch ( mode ) |
| { |
| case OMXCameraAdapter::IPP_LDCNSF: |
| case OMXCameraAdapter::IPP_LDC: |
| { |
| bOMX.bEnabled = OMX_TRUE; |
| break; |
| } |
| case OMXCameraAdapter::IPP_NONE: |
| case OMXCameraAdapter::IPP_NSF: |
| default: |
| { |
| bOMX.bEnabled = OMX_FALSE; |
| break; |
| } |
| } |
| |
| CAMHAL_LOGVB("Configuring LDC mode 0x%x", bOMX.bEnabled); |
| eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp, |
| ( OMX_INDEXTYPE ) OMX_IndexParamLensDistortionCorrection, |
| &bOMX); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEA("Error while setting LDC"); |
| ret = -1; |
| } |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::setNSF(OMXCameraAdapter::IPPMode mode) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_PARAM_ISONOISEFILTERTYPE nsf; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateLoaded != mComponentState ) |
| { |
| CAMHAL_LOGEA("OMX component is not in loaded state"); |
| ret = -EINVAL; |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| OMX_INIT_STRUCT_PTR (&nsf, OMX_PARAM_ISONOISEFILTERTYPE); |
| nsf.nPortIndex = OMX_ALL; |
| |
| switch ( mode ) |
| { |
| case OMXCameraAdapter::IPP_LDCNSF: |
| case OMXCameraAdapter::IPP_NSF: |
| { |
| nsf.eMode = OMX_ISONoiseFilterModeOn; |
| break; |
| } |
| case OMXCameraAdapter::IPP_LDC: |
| case OMXCameraAdapter::IPP_NONE: |
| default: |
| { |
| nsf.eMode = OMX_ISONoiseFilterModeOff; |
| break; |
| } |
| } |
| |
| CAMHAL_LOGVB("Configuring NSF mode 0x%x", nsf.eMode); |
| eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE)OMX_IndexParamHighISONoiseFiler, |
| &nsf); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEA("Error while setting NSF"); |
| ret = -1; |
| } |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::setImageQuality(unsigned int quality) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_IMAGE_PARAM_QFACTORTYPE jpegQualityConf; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateInvalid == mComponentState ) |
| { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| ret = -EINVAL; |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| OMX_INIT_STRUCT(jpegQualityConf, OMX_IMAGE_PARAM_QFACTORTYPE); |
| jpegQualityConf.nQFactor = quality; |
| jpegQualityConf.nPortIndex = mCameraAdapterParameters.mImagePortIndex; |
| |
| eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp, |
| OMX_IndexParamQFactor, |
| &jpegQualityConf); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while configuring jpeg Quality 0x%x", eError); |
| ret = -1; |
| } |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::setThumbnailParams(unsigned int width, |
| unsigned int height, |
| unsigned int quality) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_PARAM_THUMBNAILTYPE thumbConf; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateInvalid == mComponentState ) |
| { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| ret = -EINVAL; |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| OMX_INIT_STRUCT(thumbConf, OMX_PARAM_THUMBNAILTYPE); |
| thumbConf.nPortIndex = mCameraAdapterParameters.mImagePortIndex; |
| |
| eError = OMX_GetParameter(mCameraAdapterParameters.mHandleComp, |
| ( OMX_INDEXTYPE ) OMX_IndexParamThumbnail, |
| &thumbConf); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while retrieving thumbnail size 0x%x", eError); |
| ret = -1; |
| } |
| |
| //CTS Requirement: width or height equal to zero should |
| //result in absent EXIF thumbnail |
| if ( ( 0 == width ) || ( 0 == height ) ) |
| { |
| thumbConf.nWidth = mThumbRes[0].width; |
| thumbConf.nHeight = mThumbRes[0].height; |
| thumbConf.eCompressionFormat = OMX_IMAGE_CodingUnused; |
| } |
| else |
| { |
| thumbConf.nWidth = width; |
| thumbConf.nHeight = height; |
| thumbConf.nQuality = quality; |
| thumbConf.eCompressionFormat = OMX_IMAGE_CodingJPEG; |
| } |
| |
| CAMHAL_LOGDB("Thumbnail width = %d, Thumbnail Height = %d", width, height); |
| |
| eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp, |
| ( OMX_INDEXTYPE ) OMX_IndexParamThumbnail, |
| &thumbConf); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while configuring thumbnail size 0x%x", eError); |
| ret = -1; |
| } |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::setAlgoPriority(AlgoPriority priority, |
| Algorithm3A algo, |
| bool enable) |
| { |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateInvalid == mComponentState ) { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| return NO_INIT; |
| } |
| |
| if ( FACE_PRIORITY == priority ) { |
| |
| if ( algo & WHITE_BALANCE_ALGO ) { |
| if ( enable ) { |
| mFacePriority.bAwbFaceEnable = OMX_TRUE; |
| } else { |
| mFacePriority.bAwbFaceEnable = OMX_FALSE; |
| } |
| } |
| |
| if ( algo & EXPOSURE_ALGO ) { |
| if ( enable ) { |
| mFacePriority.bAeFaceEnable = OMX_TRUE; |
| } else { |
| mFacePriority.bAeFaceEnable = OMX_FALSE; |
| } |
| } |
| |
| if ( algo & FOCUS_ALGO ) { |
| if ( enable ) { |
| mFacePriority.bAfFaceEnable = OMX_TRUE; |
| } else { |
| mFacePriority.bAfFaceEnable = OMX_FALSE; |
| } |
| } |
| |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| ( OMX_INDEXTYPE ) OMX_TI_IndexConfigFacePriority3a, |
| &mFacePriority); |
| if ( OMX_ErrorNone != eError ) { |
| CAMHAL_LOGEB("Error while configuring face priority 0x%x", eError); |
| } else { |
| CAMHAL_LOGDB("Face priority for algorithms set successfully 0x%x, 0x%x, 0x%x", |
| mFacePriority.bAfFaceEnable, |
| mFacePriority.bAeFaceEnable, |
| mFacePriority.bAwbFaceEnable); |
| } |
| |
| } else if ( REGION_PRIORITY == priority ) { |
| |
| if ( algo & WHITE_BALANCE_ALGO ) { |
| if ( enable ) { |
| mRegionPriority.bAwbRegionEnable= OMX_TRUE; |
| } else { |
| mRegionPriority.bAwbRegionEnable = OMX_FALSE; |
| } |
| } |
| |
| if ( algo & EXPOSURE_ALGO ) { |
| if ( enable ) { |
| mRegionPriority.bAeRegionEnable = OMX_TRUE; |
| } else { |
| mRegionPriority.bAeRegionEnable = OMX_FALSE; |
| } |
| } |
| |
| if ( algo & FOCUS_ALGO ) { |
| if ( enable ) { |
| mRegionPriority.bAfRegionEnable = OMX_TRUE; |
| } else { |
| mRegionPriority.bAfRegionEnable = OMX_FALSE; |
| } |
| } |
| |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| ( OMX_INDEXTYPE ) OMX_TI_IndexConfigRegionPriority3a, |
| &mRegionPriority); |
| if ( OMX_ErrorNone != eError ) { |
| CAMHAL_LOGEB("Error while configuring region priority 0x%x", eError); |
| } else { |
| CAMHAL_LOGDB("Region priority for algorithms set successfully 0x%x, 0x%x, 0x%x", |
| mRegionPriority.bAfRegionEnable, |
| mRegionPriority.bAeRegionEnable, |
| mRegionPriority.bAwbRegionEnable); |
| } |
| |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| status_t OMXCameraAdapter::setPictureRotation(unsigned int degree) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_CONFIG_ROTATIONTYPE rotation; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateInvalid == mComponentState ) |
| { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| ret = -1; |
| } |
| |
| if ( NO_ERROR == ret ) |
| { |
| OMX_INIT_STRUCT(rotation, OMX_CONFIG_ROTATIONTYPE); |
| rotation.nRotation = degree; |
| rotation.nPortIndex = mCameraAdapterParameters.mImagePortIndex; |
| |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| OMX_IndexConfigCommonRotate, |
| &rotation); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while configuring rotation 0x%x", eError); |
| } |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::setSensorOrientation(unsigned int degree) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_CONFIG_ROTATIONTYPE sensorOrientation; |
| int tmpHeight, tmpWidth; |
| OMXCameraPortParameters *mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex]; |
| |
| LOG_FUNCTION_NAME; |
| if ( OMX_StateInvalid == mComponentState ) { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| ret = -1; |
| } |
| |
| /* Set Temproary Port resolution. |
| * For resolution with height >= 720, |
| * resolution cannot be set without configuring orientation. |
| * So we first set a temp resolution. We have used VGA |
| */ |
| if ( mPreviewData->mHeight >= 720 ) { |
| tmpHeight = mPreviewData->mHeight; |
| tmpWidth = mPreviewData->mWidth; |
| mPreviewData->mWidth = 640; |
| mPreviewData->mHeight = 480; |
| |
| ret = setFormat(OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW, *mPreviewData); |
| if ( NO_ERROR != ret ) { |
| CAMHAL_LOGEB("Error while configuring format 0x%x", ret); |
| return ret; |
| } |
| |
| mPreviewData->mWidth = tmpWidth; |
| mPreviewData->mHeight = tmpHeight; |
| mPreviewPortInitialized = true; |
| } |
| else if (!mPreviewPortInitialized) { |
| ret = setFormat(OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW, *mPreviewData); |
| if ( NO_ERROR != ret ) { |
| CAMHAL_LOGEB("Error while configuring format 0x%x", ret); |
| return ret; |
| } |
| mPreviewPortInitialized = true; |
| } |
| |
| /* Now set Required Orientation*/ |
| if ( NO_ERROR == ret ) { |
| OMX_INIT_STRUCT(sensorOrientation, OMX_CONFIG_ROTATIONTYPE); |
| sensorOrientation.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| sensorOrientation.nRotation = degree; |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| OMX_IndexConfigCommonRotate, |
| &sensorOrientation); |
| if ( OMX_ErrorNone != eError ) { |
| CAMHAL_LOGEB("Error while configuring rotation 0x%x", eError); |
| } |
| CAMHAL_LOGVB(" Currently Sensor Orientation is set to : %d", |
| ( unsigned int ) sensorOrientation.nRotation); |
| CAMHAL_LOGVB(" Sensor Configured for Port : %d", |
| ( unsigned int ) sensorOrientation.nPortIndex); |
| } |
| |
| /* Now set the required resolution as requested */ |
| if ( NO_ERROR == ret ) { |
| bool portConfigured = false; |
| ret = setSensorQuirks(degree, |
| mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex], |
| portConfigured); |
| if ( NO_ERROR != ret ) { |
| CAMHAL_LOGEB("Error while configuring setSensorQuirks 0x%x", ret); |
| return ret; |
| } |
| |
| if ( !portConfigured ) { |
| ret = setFormat (mCameraAdapterParameters.mPrevPortIndex, |
| mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex]); |
| if ( NO_ERROR != ret ) { |
| CAMHAL_LOGEB("Error while configuring format 0x%x", ret); |
| return ret; |
| } |
| |
| // Another WA: Setting the port definition will reset the VFR |
| // configuration. |
| setVFramerate(mPreviewData->mMinFrameRate, |
| mPreviewData->mMaxFrameRate); |
| } |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::setVFramerate(OMX_U32 minFrameRate, OMX_U32 maxFrameRate) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_TI_CONFIG_VARFRMRANGETYPE vfr; |
| OMXCameraPortParameters * mPreviewData = |
| &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex]; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateInvalid == mComponentState ) { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| ret = -EINVAL; |
| } |
| |
| if ( !mSetFormatDone ) { |
| return NO_INIT; |
| } |
| |
| if ( NO_ERROR == ret ) { |
| OMX_INIT_STRUCT_PTR (&vfr, OMX_TI_CONFIG_VARFRMRANGETYPE); |
| |
| vfr.xMin = minFrameRate<<16; |
| vfr.xMax = maxFrameRate<<16; |
| |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE)OMX_TI_IndexConfigVarFrmRange, |
| &vfr); |
| if(OMX_ErrorNone != eError) { |
| CAMHAL_LOGEB("Error while setting VFR min = %d, max = %d, error = 0x%x", |
| ( unsigned int ) minFrameRate, |
| ( unsigned int ) maxFrameRate, |
| eError); |
| ret = -1; |
| } else { |
| CAMHAL_LOGDB("VFR Configured Successfully [%d:%d]", |
| ( unsigned int ) minFrameRate, |
| ( unsigned int ) maxFrameRate); |
| } |
| } |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::setMechanicalMisalignmentCorrection(const bool enable) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_TI_CONFIG_MM mm; |
| |
| LOG_FUNCTION_NAME; |
| |
| mm.nVersion = mLocalVersionParam; |
| mm.nSize = sizeof(OMX_TI_CONFIG_MM); |
| mm.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| mm.bMM = enable ? OMX_TRUE : OMX_FALSE; |
| |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE)OMX_TI_IndexConfigMechanicalMisalignment, |
| &mm); |
| |
| if(OMX_ErrorNone != eError) { |
| CAMHAL_LOGEB("Error while enabling mechanical misalignment correction. error = 0x%x", eError); |
| ret = -1; |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| } // namespace Camera |
| } // namespace Ti |
