/* * 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