| /* |
| * 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 OMX3A.cpp |
| * |
| * This file contains functionality for handling 3A configurations. |
| * |
| */ |
| |
| #include "CameraHal.h" |
| #include "OMXCameraAdapter.h" |
| #include "ErrorUtils.h" |
| |
| #include <cutils/properties.h> |
| |
| #define METERING_AREAS_RANGE 0xFF |
| |
| static const char PARAM_SEP[] = ","; |
| |
| namespace Ti { |
| namespace Camera { |
| |
| const SceneModesEntry* OMXCameraAdapter::getSceneModeEntry(const char* name, |
| OMX_SCENEMODETYPE scene) { |
| const SceneModesEntry* cameraLUT = NULL; |
| const SceneModesEntry* entry = NULL; |
| unsigned int numEntries = 0; |
| |
| // 1. Find camera's scene mode LUT |
| for (unsigned int i = 0; i < ARRAY_SIZE(CameraToSensorModesLUT); i++) { |
| if (strcmp(CameraToSensorModesLUT[i].name, name) == 0) { |
| cameraLUT = CameraToSensorModesLUT[i].Table; |
| numEntries = CameraToSensorModesLUT[i].size; |
| break; |
| } |
| } |
| |
| // 2. Find scene mode entry in table |
| if (!cameraLUT) { |
| goto EXIT; |
| } |
| |
| for (unsigned int i = 0; i < numEntries; i++) { |
| if(cameraLUT[i].scene == scene) { |
| entry = cameraLUT + i; |
| break; |
| } |
| } |
| EXIT: |
| return entry; |
| } |
| |
| status_t OMXCameraAdapter::setParameters3A(const android::CameraParameters ¶ms, |
| BaseCameraAdapter::AdapterState state) |
| { |
| status_t ret = NO_ERROR; |
| int mode = 0; |
| const char *str = NULL; |
| int varint = 0; |
| BaseCameraAdapter::AdapterState nextState; |
| BaseCameraAdapter::getNextState(nextState); |
| |
| LOG_FUNCTION_NAME; |
| |
| android::AutoMutex lock(m3ASettingsUpdateLock); |
| |
| str = params.get(android::CameraParameters::KEY_SCENE_MODE); |
| mode = getLUTvalue_HALtoOMX( str, SceneLUT); |
| if ( mFirstTimeInit || ((str != NULL) && ( mParameters3A.SceneMode != mode )) ) { |
| if ( 0 <= mode ) { |
| mParameters3A.SceneMode = mode; |
| if ((mode == OMX_Manual) && (mFirstTimeInit == false)){//Auto mode |
| mFirstTimeInit = true; |
| } |
| if ((mode != OMX_Manual) && |
| (state & PREVIEW_ACTIVE) && !(nextState & CAPTURE_ACTIVE)) { |
| // if setting preset scene mode, previewing, and not in the middle of capture |
| // set preset scene mode immediately instead of in next FBD |
| // for feedback params to work properly since they need to be read |
| // by application in subsequent getParameters() |
| ret |= setScene(mParameters3A); |
| // re-apply EV compensation after setting scene mode since it probably reset it |
| if(mParameters3A.EVCompensation) { |
| setEVCompensation(mParameters3A); |
| } |
| return ret; |
| } else { |
| mPending3Asettings |= SetSceneMode; |
| } |
| } else { |
| mParameters3A.SceneMode = OMX_Manual; |
| } |
| CAMHAL_LOGVB("SceneMode %d", mParameters3A.SceneMode); |
| } |
| |
| #ifdef OMAP_ENHANCEMENT |
| if ( (str = params.get(TICameraParameters::KEY_EXPOSURE_MODE)) != NULL ) { |
| mode = getLUTvalue_HALtoOMX(str, ExpLUT); |
| if ( mParameters3A.Exposure != mode ) { |
| // If either the new or the old exposure mode is manual set also |
| // the SetManualExposure flag to call setManualExposureVal where |
| // the auto gain and exposure flags are configured |
| if ( mParameters3A.Exposure == OMX_ExposureControlOff || |
| mode == OMX_ExposureControlOff ) { |
| mPending3Asettings |= SetManualExposure; |
| } |
| mParameters3A.Exposure = mode; |
| CAMHAL_LOGDB("Exposure mode %d", mode); |
| if ( 0 <= mParameters3A.Exposure ) { |
| mPending3Asettings |= SetExpMode; |
| } |
| } |
| if ( mode == OMX_ExposureControlOff ) { |
| mode = params.getInt(TICameraParameters::KEY_MANUAL_EXPOSURE); |
| if ( mParameters3A.ManualExposure != mode ) { |
| mParameters3A.ManualExposure = mode; |
| CAMHAL_LOGDB("Manual Exposure = %d", mode); |
| mPending3Asettings |= SetManualExposure; |
| } |
| mode = params.getInt(TICameraParameters::KEY_MANUAL_EXPOSURE_RIGHT); |
| if ( mParameters3A.ManualExposureRight != mode ) { |
| mParameters3A.ManualExposureRight = mode; |
| CAMHAL_LOGDB("Manual Exposure right = %d", mode); |
| mPending3Asettings |= SetManualExposure; |
| } |
| mode = params.getInt(TICameraParameters::KEY_MANUAL_GAIN_ISO); |
| if ( mParameters3A.ManualGain != mode ) { |
| mParameters3A.ManualGain = mode; |
| CAMHAL_LOGDB("Manual Gain = %d", mode); |
| mPending3Asettings |= SetManualExposure; |
| } |
| mode = params.getInt(TICameraParameters::KEY_MANUAL_GAIN_ISO_RIGHT); |
| if ( mParameters3A.ManualGainRight != mode ) { |
| mParameters3A.ManualGainRight = mode; |
| CAMHAL_LOGDB("Manual Gain right = %d", mode); |
| mPending3Asettings |= SetManualExposure; |
| } |
| } |
| } |
| #endif |
| |
| str = params.get(android::CameraParameters::KEY_WHITE_BALANCE); |
| mode = getLUTvalue_HALtoOMX( str, WBalLUT); |
| if (mFirstTimeInit || ((str != NULL) && (mode != mParameters3A.WhiteBallance))) |
| { |
| mParameters3A.WhiteBallance = mode; |
| CAMHAL_LOGDB("Whitebalance mode %d", mode); |
| if ( 0 <= mParameters3A.WhiteBallance ) |
| { |
| mPending3Asettings |= SetWhiteBallance; |
| } |
| } |
| |
| #ifdef OMAP_ENHANCEMENT |
| varint = params.getInt(TICameraParameters::KEY_CONTRAST); |
| if ( 0 <= varint ) |
| { |
| if ( mFirstTimeInit || |
| ( (mParameters3A.Contrast + CONTRAST_OFFSET) != varint ) ) |
| { |
| mParameters3A.Contrast = varint - CONTRAST_OFFSET; |
| CAMHAL_LOGDB("Contrast %d", mParameters3A.Contrast); |
| mPending3Asettings |= SetContrast; |
| } |
| } |
| |
| varint = params.getInt(TICameraParameters::KEY_SHARPNESS); |
| if ( 0 <= varint ) |
| { |
| if ( mFirstTimeInit || |
| ((mParameters3A.Sharpness + SHARPNESS_OFFSET) != varint )) |
| { |
| mParameters3A.Sharpness = varint - SHARPNESS_OFFSET; |
| CAMHAL_LOGDB("Sharpness %d", mParameters3A.Sharpness); |
| mPending3Asettings |= SetSharpness; |
| } |
| } |
| |
| varint = params.getInt(TICameraParameters::KEY_SATURATION); |
| if ( 0 <= varint ) |
| { |
| if ( mFirstTimeInit || |
| ((mParameters3A.Saturation + SATURATION_OFFSET) != varint ) ) |
| { |
| mParameters3A.Saturation = varint - SATURATION_OFFSET; |
| CAMHAL_LOGDB("Saturation %d", mParameters3A.Saturation); |
| mPending3Asettings |= SetSaturation; |
| } |
| } |
| |
| varint = params.getInt(TICameraParameters::KEY_BRIGHTNESS); |
| if ( 0 <= varint ) |
| { |
| if ( mFirstTimeInit || |
| (( mParameters3A.Brightness != varint )) ) |
| { |
| mParameters3A.Brightness = (unsigned) varint; |
| CAMHAL_LOGDB("Brightness %d", mParameters3A.Brightness); |
| mPending3Asettings |= SetBrightness; |
| } |
| } |
| #endif |
| |
| str = params.get(android::CameraParameters::KEY_ANTIBANDING); |
| mode = getLUTvalue_HALtoOMX(str,FlickerLUT); |
| if ( mFirstTimeInit || ( ( str != NULL ) && ( mParameters3A.Flicker != mode ) )) |
| { |
| mParameters3A.Flicker = mode; |
| CAMHAL_LOGDB("Flicker %d", mParameters3A.Flicker); |
| if ( 0 <= mParameters3A.Flicker ) |
| { |
| mPending3Asettings |= SetFlicker; |
| } |
| } |
| |
| #ifdef OMAP_ENHANCEMENT |
| str = params.get(TICameraParameters::KEY_ISO); |
| mode = getLUTvalue_HALtoOMX(str, IsoLUT); |
| CAMHAL_LOGVB("ISO mode arrived in HAL : %s", str); |
| if ( mFirstTimeInit || ( ( str != NULL ) && ( mParameters3A.ISO != mode )) ) |
| { |
| mParameters3A.ISO = mode; |
| CAMHAL_LOGDB("ISO %d", mParameters3A.ISO); |
| if ( 0 <= mParameters3A.ISO ) |
| { |
| mPending3Asettings |= SetISO; |
| } |
| } |
| #endif |
| |
| str = params.get(android::CameraParameters::KEY_FOCUS_MODE); |
| mode = getLUTvalue_HALtoOMX(str, FocusLUT); |
| if ( (mFirstTimeInit || ((str != NULL) && (mParameters3A.Focus != mode)))) |
| { |
| mPending3Asettings |= SetFocus; |
| |
| mParameters3A.Focus = mode; |
| |
| // if focus mode is set to infinity...update focus distance immediately |
| if (mode == OMX_IMAGE_FocusControlAutoInfinity) { |
| updateFocusDistances(mParameters); |
| } |
| |
| CAMHAL_LOGDB("Focus %x", mParameters3A.Focus); |
| } |
| |
| str = params.get(android::CameraParameters::KEY_EXPOSURE_COMPENSATION); |
| varint = params.getInt(android::CameraParameters::KEY_EXPOSURE_COMPENSATION); |
| if ( mFirstTimeInit || (str && (mParameters3A.EVCompensation != varint))) { |
| CAMHAL_LOGDB("Setting EV Compensation to %d", varint); |
| mParameters3A.EVCompensation = varint; |
| mPending3Asettings |= SetEVCompensation; |
| } |
| |
| str = params.get(android::CameraParameters::KEY_FLASH_MODE); |
| mode = getLUTvalue_HALtoOMX( str, FlashLUT); |
| if ( mFirstTimeInit || (( str != NULL ) && ( mParameters3A.FlashMode != mode )) ) |
| { |
| if ( 0 <= mode ) |
| { |
| mParameters3A.FlashMode = mode; |
| mPending3Asettings |= SetFlash; |
| } |
| else |
| { |
| mParameters3A.FlashMode = OMX_IMAGE_FlashControlAuto; |
| } |
| } |
| |
| CAMHAL_LOGVB("Flash Setting %s", str); |
| CAMHAL_LOGVB("FlashMode %d", mParameters3A.FlashMode); |
| |
| str = params.get(android::CameraParameters::KEY_EFFECT); |
| mode = getLUTvalue_HALtoOMX( str, EffLUT); |
| if ( mFirstTimeInit || (( str != NULL ) && ( mParameters3A.Effect != mode )) ) |
| { |
| mParameters3A.Effect = mode; |
| CAMHAL_LOGDB("Effect %d", mParameters3A.Effect); |
| if ( 0 <= mParameters3A.Effect ) |
| { |
| mPending3Asettings |= SetEffect; |
| } |
| } |
| |
| str = params.get(android::CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED); |
| if ( (str != NULL) && (!strcmp(str, android::CameraParameters::TRUE)) ) |
| { |
| OMX_BOOL lock = OMX_FALSE; |
| mUserSetExpLock = OMX_FALSE; |
| str = params.get(android::CameraParameters::KEY_AUTO_EXPOSURE_LOCK); |
| if (str && ((strcmp(str, android::CameraParameters::TRUE)) == 0)) |
| { |
| CAMHAL_LOGVA("Locking Exposure"); |
| lock = OMX_TRUE; |
| mUserSetExpLock = OMX_TRUE; |
| } |
| else |
| { |
| CAMHAL_LOGVA("UnLocking Exposure"); |
| } |
| |
| if (mParameters3A.ExposureLock != lock) |
| { |
| mParameters3A.ExposureLock = lock; |
| CAMHAL_LOGDB("ExposureLock %d", lock); |
| mPending3Asettings |= SetExpLock; |
| } |
| } |
| |
| str = params.get(android::CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED); |
| if ( (str != NULL) && (!strcmp(str, android::CameraParameters::TRUE)) ) |
| { |
| OMX_BOOL lock = OMX_FALSE; |
| mUserSetWbLock = OMX_FALSE; |
| str = params.get(android::CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK); |
| if (str && ((strcmp(str, android::CameraParameters::TRUE)) == 0)) |
| { |
| CAMHAL_LOGVA("Locking WhiteBalance"); |
| lock = OMX_TRUE; |
| mUserSetWbLock = OMX_TRUE; |
| } |
| else |
| { |
| CAMHAL_LOGVA("UnLocking WhiteBalance"); |
| } |
| if (mParameters3A.WhiteBalanceLock != lock) |
| { |
| mParameters3A.WhiteBalanceLock = lock; |
| CAMHAL_LOGDB("WhiteBalanceLock %d", lock); |
| mPending3Asettings |= SetWBLock; |
| } |
| } |
| |
| str = params.get(TICameraParameters::KEY_AUTO_FOCUS_LOCK); |
| if (str && (strcmp(str, android::CameraParameters::TRUE) == 0) && (mParameters3A.FocusLock != OMX_TRUE)) { |
| CAMHAL_LOGVA("Locking Focus"); |
| mParameters3A.FocusLock = OMX_TRUE; |
| setFocusLock(mParameters3A); |
| } else if (str && (strcmp(str, android::CameraParameters::FALSE) == 0) && (mParameters3A.FocusLock != OMX_FALSE)) { |
| CAMHAL_LOGVA("UnLocking Focus"); |
| mParameters3A.FocusLock = OMX_FALSE; |
| setFocusLock(mParameters3A); |
| } |
| |
| str = params.get(android::CameraParameters::KEY_METERING_AREAS); |
| if ( (str != NULL) ) { |
| size_t MAX_METERING_AREAS; |
| android::Vector<android::sp<CameraArea> > tempAreas; |
| |
| MAX_METERING_AREAS = atoi(params.get(android::CameraParameters::KEY_MAX_NUM_METERING_AREAS)); |
| |
| android::AutoMutex lock(mMeteringAreasLock); |
| |
| ret = CameraArea::parseAreas(str, ( strlen(str) + 1 ), tempAreas); |
| |
| CAMHAL_LOGVB("areAreasDifferent? = %d", |
| CameraArea::areAreasDifferent(mMeteringAreas, tempAreas)); |
| |
| if ( (NO_ERROR == ret) && CameraArea::areAreasDifferent(mMeteringAreas, tempAreas) ) { |
| mMeteringAreas.clear(); |
| mMeteringAreas = tempAreas; |
| |
| if ( MAX_METERING_AREAS >= mMeteringAreas.size() ) { |
| CAMHAL_LOGDB("Setting Metering Areas %s", |
| params.get(android::CameraParameters::KEY_METERING_AREAS)); |
| |
| mPending3Asettings |= SetMeteringAreas; |
| } else { |
| CAMHAL_LOGEB("Metering areas supported %d, metering areas set %d", |
| MAX_METERING_AREAS, mMeteringAreas.size()); |
| ret = -EINVAL; |
| } |
| } |
| } |
| |
| // TI extensions for enable/disable algos |
| declareParameter3ABool(params, TICameraParameters::KEY_ALGO_EXTERNAL_GAMMA, |
| mParameters3A.AlgoExternalGamma, SetAlgoExternalGamma, "External Gamma"); |
| declareParameter3ABool(params, TICameraParameters::KEY_ALGO_NSF1, |
| mParameters3A.AlgoNSF1, SetAlgoNSF1, "NSF1"); |
| declareParameter3ABool(params, TICameraParameters::KEY_ALGO_NSF2, |
| mParameters3A.AlgoNSF2, SetAlgoNSF2, "NSF2"); |
| declareParameter3ABool(params, TICameraParameters::KEY_ALGO_SHARPENING, |
| mParameters3A.AlgoSharpening, SetAlgoSharpening, "Sharpening"); |
| declareParameter3ABool(params, TICameraParameters::KEY_ALGO_THREELINCOLORMAP, |
| mParameters3A.AlgoThreeLinColorMap, SetAlgoThreeLinColorMap, "ThreeLinColorMap"); |
| declareParameter3ABool(params, TICameraParameters::KEY_ALGO_GIC, mParameters3A.AlgoGIC, SetAlgoGIC, "GIC"); |
| |
| // Gamma table |
| str = params.get(TICameraParameters::KEY_GAMMA_TABLE); |
| updateGammaTable(str); |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| void OMXCameraAdapter::updateGammaTable(const char* gamma) |
| { |
| unsigned int plane = 0; |
| unsigned int i = 0; |
| bool gamma_changed = false; |
| const char *a = gamma; |
| OMX_TI_GAMMATABLE_ELEM_TYPE *elem[3] = { mParameters3A.mGammaTable.pR, |
| mParameters3A.mGammaTable.pG, |
| mParameters3A.mGammaTable.pB}; |
| |
| if (!gamma) return; |
| |
| mPending3Asettings &= ~SetGammaTable; |
| memset(&mParameters3A.mGammaTable, 0, sizeof(mParameters3A.mGammaTable)); |
| for (plane = 0; plane < 3; plane++) { |
| a = strchr(a, '('); |
| if (NULL != a) { |
| a++; |
| for (i = 0; i < OMX_TI_GAMMATABLE_SIZE; i++) { |
| char *b; |
| int newVal; |
| newVal = strtod(a, &b); |
| if (newVal != elem[plane][i].nOffset) { |
| elem[plane][i].nOffset = newVal; |
| gamma_changed = true; |
| } |
| a = strpbrk(b, ",:)"); |
| if ((NULL != a) && (':' == *a)) { |
| a++; |
| } else if ((NULL != a) && (',' == *a)){ |
| a++; |
| break; |
| } else if ((NULL != a) && (')' == *a)){ |
| a++; |
| break; |
| } else { |
| CAMHAL_LOGE("Error while parsing values"); |
| gamma_changed = false; |
| break; |
| } |
| newVal = strtod(a, &b); |
| if (newVal != elem[plane][i].nSlope) { |
| elem[plane][i].nSlope = newVal; |
| gamma_changed = true; |
| } |
| a = strpbrk(b, ",:)"); |
| if ((NULL != a) && (',' == *a)) { |
| a++; |
| } else if ((NULL != a) && (':' == *a)){ |
| a++; |
| break; |
| } else if ((NULL != a) && (')' == *a)){ |
| a++; |
| break; |
| } else { |
| CAMHAL_LOGE("Error while parsing values"); |
| gamma_changed = false; |
| break; |
| } |
| } |
| if ((OMX_TI_GAMMATABLE_SIZE - 1) != i) { |
| CAMHAL_LOGE("Error while parsing values (incorrect count %u)", i); |
| gamma_changed = false; |
| break; |
| } |
| } else { |
| CAMHAL_LOGE("Error while parsing planes (%u)", plane); |
| gamma_changed = false; |
| break; |
| } |
| } |
| |
| if (gamma_changed) { |
| mPending3Asettings |= SetGammaTable; |
| } |
| } |
| |
| void OMXCameraAdapter::declareParameter3ABool(const android::CameraParameters ¶ms, const char *key, |
| OMX_BOOL ¤t_setting, E3ASettingsFlags pending, |
| const char *msg) |
| { |
| OMX_BOOL val = OMX_TRUE; |
| const char *str = params.get(key); |
| |
| if (str && ((strcmp(str, android::CameraParameters::FALSE)) == 0)) |
| { |
| CAMHAL_LOGVB("Disabling %s", msg); |
| val = OMX_FALSE; |
| } |
| else |
| { |
| CAMHAL_LOGVB("Enabling %s", msg); |
| } |
| if (current_setting != val) |
| { |
| current_setting = val; |
| CAMHAL_LOGDB("%s %s", msg, current_setting ? "enabled" : "disabled"); |
| mPending3Asettings |= pending; |
| } |
| } |
| |
| int OMXCameraAdapter::getLUTvalue_HALtoOMX(const char * HalValue, LUTtype LUT) |
| { |
| int LUTsize = LUT.size; |
| if( HalValue ) |
| for(int i = 0; i < LUTsize; i++) |
| if( 0 == strcmp(LUT.Table[i].userDefinition, HalValue) ) |
| return LUT.Table[i].omxDefinition; |
| |
| return -ENOENT; |
| } |
| |
| const char* OMXCameraAdapter::getLUTvalue_OMXtoHAL(int OMXValue, LUTtype LUT) |
| { |
| int LUTsize = LUT.size; |
| for(int i = 0; i < LUTsize; i++) |
| if( LUT.Table[i].omxDefinition == OMXValue ) |
| return LUT.Table[i].userDefinition; |
| |
| return NULL; |
| } |
| |
| int OMXCameraAdapter::getMultipleLUTvalue_OMXtoHAL(int OMXValue, LUTtype LUT, char * supported) |
| { |
| int num = 0; |
| int remaining_size; |
| int LUTsize = LUT.size; |
| for(int i = 0; i < LUTsize; i++) |
| if( LUT.Table[i].omxDefinition == OMXValue ) |
| { |
| num++; |
| if (supported[0] != '\0') { |
| strncat(supported, PARAM_SEP, 1); |
| } |
| remaining_size = ((((int)MAX_PROP_VALUE_LENGTH - 1 - (int)strlen(supported)) < 0) ? 0 : (MAX_PROP_VALUE_LENGTH - 1 - strlen(supported))); |
| strncat(supported, LUT.Table[i].userDefinition, remaining_size); |
| } |
| |
| return num; |
| } |
| |
| status_t OMXCameraAdapter::setExposureMode(Gen3A_settings& Gen3A) |
| { |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_CONFIG_EXPOSURECONTROLTYPE exp; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateInvalid == mComponentState ) |
| { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| return NO_INIT; |
| } |
| |
| OMX_INIT_STRUCT_PTR (&exp, OMX_CONFIG_EXPOSURECONTROLTYPE); |
| exp.nPortIndex = OMX_ALL; |
| exp.eExposureControl = (OMX_EXPOSURECONTROLTYPE)Gen3A.Exposure; |
| |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| OMX_IndexConfigCommonExposure, |
| &exp); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while configuring exposure mode 0x%x", eError); |
| } |
| else |
| { |
| CAMHAL_LOGDA("Camera exposure mode configured successfully"); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| static bool isFlashDisabled() { |
| #if (PROPERTY_VALUE_MAX < 5) |
| #error "PROPERTY_VALUE_MAX must be at least 5" |
| #endif |
| |
| // Ignore flash_off system property for user build. |
| char buildType[PROPERTY_VALUE_MAX]; |
| if (property_get("ro.build.type", buildType, NULL) && |
| !strcasecmp(buildType, "user")) { |
| return false; |
| } |
| |
| char value[PROPERTY_VALUE_MAX]; |
| if (property_get("camera.flash_off", value, NULL) && |
| (!strcasecmp(value, android::CameraParameters::TRUE) || !strcasecmp(value, "1"))) { |
| CAMHAL_LOGW("flash is disabled for testing purpose"); |
| return true; |
| } |
| |
| return false; |
| } |
| |
| status_t OMXCameraAdapter::setManualExposureVal(Gen3A_settings& Gen3A) { |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_CONFIG_EXPOSUREVALUETYPE expVal; |
| OMX_TI_CONFIG_EXPOSUREVALUERIGHTTYPE expValRight; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateInvalid == mComponentState ) { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| return NO_INIT; |
| } |
| |
| OMX_INIT_STRUCT_PTR (&expVal, OMX_CONFIG_EXPOSUREVALUETYPE); |
| OMX_INIT_STRUCT_PTR (&expValRight, OMX_TI_CONFIG_EXPOSUREVALUERIGHTTYPE); |
| expVal.nPortIndex = OMX_ALL; |
| expValRight.nPortIndex = OMX_ALL; |
| |
| eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp, |
| OMX_IndexConfigCommonExposureValue, |
| &expVal); |
| if ( OMX_ErrorNone == eError ) { |
| eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE) OMX_TI_IndexConfigRightExposureValue, |
| &expValRight); |
| } |
| if ( OMX_ErrorNone != eError ) { |
| CAMHAL_LOGEB("OMX_GetConfig error 0x%x (manual exposure values)", eError); |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| if ( Gen3A.Exposure != OMX_ExposureControlOff ) { |
| expVal.bAutoShutterSpeed = OMX_TRUE; |
| expVal.bAutoSensitivity = OMX_TRUE; |
| } else { |
| expVal.bAutoShutterSpeed = OMX_FALSE; |
| expVal.nShutterSpeedMsec = Gen3A.ManualExposure; |
| expValRight.nShutterSpeedMsec = Gen3A.ManualExposureRight; |
| if ( Gen3A.ManualGain <= 0 || Gen3A.ManualGainRight <= 0 ) { |
| expVal.bAutoSensitivity = OMX_TRUE; |
| } else { |
| expVal.bAutoSensitivity = OMX_FALSE; |
| expVal.nSensitivity = Gen3A.ManualGain; |
| expValRight.nSensitivity = Gen3A.ManualGainRight; |
| } |
| } |
| |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| OMX_IndexConfigCommonExposureValue, |
| &expVal); |
| if ( OMX_ErrorNone == eError ) { |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE) OMX_TI_IndexConfigRightExposureValue, |
| &expValRight); |
| } |
| |
| if ( OMX_ErrorNone != eError ) { |
| CAMHAL_LOGEB("Error 0x%x while configuring manual exposure values", eError); |
| } else { |
| CAMHAL_LOGDA("Camera manual exposure values configured successfully"); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| status_t OMXCameraAdapter::setFlashMode(Gen3A_settings& Gen3A) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_IMAGE_PARAM_FLASHCONTROLTYPE flash; |
| OMX_CONFIG_FOCUSASSISTTYPE focusAssist; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateInvalid == mComponentState ) |
| { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| return NO_INIT; |
| } |
| |
| OMX_INIT_STRUCT_PTR (&flash, OMX_IMAGE_PARAM_FLASHCONTROLTYPE); |
| flash.nPortIndex = OMX_ALL; |
| |
| if (isFlashDisabled()) { |
| flash.eFlashControl = ( OMX_IMAGE_FLASHCONTROLTYPE ) OMX_IMAGE_FlashControlOff; |
| } else { |
| flash.eFlashControl = ( OMX_IMAGE_FLASHCONTROLTYPE ) Gen3A.FlashMode; |
| } |
| |
| CAMHAL_LOGDB("Configuring flash mode 0x%x", flash.eFlashControl); |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE) OMX_IndexConfigFlashControl, |
| &flash); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while configuring flash mode 0x%x", eError); |
| } |
| else |
| { |
| CAMHAL_LOGDA("Camera flash mode configured successfully"); |
| } |
| |
| if ( OMX_ErrorNone == eError ) |
| { |
| OMX_INIT_STRUCT_PTR (&focusAssist, OMX_CONFIG_FOCUSASSISTTYPE); |
| focusAssist.nPortIndex = OMX_ALL; |
| if ( flash.eFlashControl == OMX_IMAGE_FlashControlOff ) |
| { |
| focusAssist.bFocusAssist = OMX_FALSE; |
| } |
| else |
| { |
| focusAssist.bFocusAssist = OMX_TRUE; |
| } |
| |
| CAMHAL_LOGDB("Configuring AF Assist mode 0x%x", focusAssist.bFocusAssist); |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE) OMX_IndexConfigFocusAssist, |
| &focusAssist); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while configuring AF Assist mode 0x%x", eError); |
| } |
| else |
| { |
| CAMHAL_LOGDA("Camera AF Assist mode configured successfully"); |
| } |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| status_t OMXCameraAdapter::getFlashMode(Gen3A_settings& Gen3A) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_IMAGE_PARAM_FLASHCONTROLTYPE flash; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateInvalid == mComponentState ) { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| return NO_INIT; |
| } |
| |
| OMX_INIT_STRUCT_PTR (&flash, OMX_IMAGE_PARAM_FLASHCONTROLTYPE); |
| flash.nPortIndex = OMX_ALL; |
| |
| eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE) OMX_IndexConfigFlashControl, |
| &flash); |
| |
| if ( OMX_ErrorNone != eError ) { |
| CAMHAL_LOGEB("Error while getting flash mode 0x%x", eError); |
| } else { |
| Gen3A.FlashMode = flash.eFlashControl; |
| CAMHAL_LOGDB("Gen3A.FlashMode 0x%x", Gen3A.FlashMode); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| status_t OMXCameraAdapter::setFocusMode(Gen3A_settings& Gen3A) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE focus; |
| size_t top, left, width, height, weight; |
| OMX_CONFIG_BOOLEANTYPE bOMX; |
| |
| LOG_FUNCTION_NAME; |
| |
| BaseCameraAdapter::AdapterState state; |
| BaseCameraAdapter::getState(state); |
| |
| if ( OMX_StateInvalid == mComponentState ) |
| { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| return NO_INIT; |
| } |
| |
| |
| ///Face detection takes precedence over touch AF |
| if ( mFaceDetectionRunning ) |
| { |
| //Disable region priority first |
| setAlgoPriority(REGION_PRIORITY, FOCUS_ALGO, false); |
| |
| //Enable face algorithm priority for focus |
| setAlgoPriority(FACE_PRIORITY, FOCUS_ALGO , true); |
| |
| //Do normal focus afterwards |
| ////FIXME: Check if the extended focus control is needed? this overrides caf |
| //focusControl.eFocusControl = ( OMX_IMAGE_FOCUSCONTROLTYPE ) OMX_IMAGE_FocusControlExtended; |
| } |
| else if ( (!mFocusAreas.isEmpty()) && (!mFocusAreas.itemAt(0)->isZeroArea()) ) |
| { |
| |
| //Disable face priority first |
| setAlgoPriority(FACE_PRIORITY, FOCUS_ALGO, false); |
| |
| //Enable region algorithm priority |
| setAlgoPriority(REGION_PRIORITY, FOCUS_ALGO, true); |
| |
| |
| //Do normal focus afterwards |
| //FIXME: Check if the extended focus control is needed? this overrides caf |
| //focus.eFocusControl = ( OMX_IMAGE_FOCUSCONTROLTYPE ) OMX_IMAGE_FocusControlExtended; |
| |
| } |
| else |
| { |
| |
| //Disable both region and face priority |
| setAlgoPriority(REGION_PRIORITY, FOCUS_ALGO, false); |
| |
| setAlgoPriority(FACE_PRIORITY, FOCUS_ALGO, false); |
| |
| } |
| |
| if ( NO_ERROR == ret && ((state & AF_ACTIVE) == 0) ) |
| { |
| OMX_INIT_STRUCT_PTR (&bOMX, OMX_CONFIG_BOOLEANTYPE); |
| |
| if ( Gen3A.Focus == OMX_IMAGE_FocusControlAutoInfinity) |
| { |
| // Don't lock at infinity, otherwise the AF cannot drive |
| // the lens at infinity position |
| if( set3ALock(mUserSetExpLock, mUserSetWbLock, OMX_FALSE) != NO_ERROR) |
| { |
| CAMHAL_LOGEA("Error Applying 3A locks"); |
| } else { |
| CAMHAL_LOGDA("Focus locked. Applied focus locks successfully"); |
| } |
| } |
| if ( Gen3A.Focus == OMX_IMAGE_FocusControlAuto || |
| Gen3A.Focus == OMX_IMAGE_FocusControlAutoInfinity) |
| { |
| // Run focus scanning if switching to continuous infinity focus mode |
| bOMX.bEnabled = OMX_TRUE; |
| } |
| else |
| { |
| bOMX.bEnabled = OMX_FALSE; |
| } |
| |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE)OMX_TI_IndexConfigAutofocusEnable, |
| &bOMX); |
| |
| OMX_INIT_STRUCT_PTR (&focus, OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE); |
| focus.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| focus.eFocusControl = (OMX_IMAGE_FOCUSCONTROLTYPE)Gen3A.Focus; |
| |
| CAMHAL_LOGDB("Configuring focus mode 0x%x", focus.eFocusControl); |
| eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp, OMX_IndexConfigFocusControl, &focus); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while configuring focus mode 0x%x", eError); |
| } |
| else |
| { |
| CAMHAL_LOGDA("Camera focus mode configured successfully"); |
| } |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| status_t OMXCameraAdapter::getFocusMode(Gen3A_settings& Gen3A) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE focus; |
| size_t top, left, width, height, weight; |
| |
| LOG_FUNCTION_NAME; |
| |
| if (OMX_StateInvalid == mComponentState) { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| return NO_INIT; |
| } |
| |
| OMX_INIT_STRUCT_PTR (&focus, OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE); |
| focus.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp, |
| OMX_IndexConfigFocusControl, &focus); |
| |
| if (OMX_ErrorNone != eError) { |
| CAMHAL_LOGEB("Error while configuring focus mode 0x%x", eError); |
| } else { |
| Gen3A.Focus = focus.eFocusControl; |
| CAMHAL_LOGDB("Gen3A.Focus 0x%x", Gen3A.Focus); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| status_t OMXCameraAdapter::setScene(Gen3A_settings& Gen3A) |
| { |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_CONFIG_SCENEMODETYPE scene; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateInvalid == mComponentState ) |
| { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| return NO_INIT; |
| } |
| |
| OMX_INIT_STRUCT_PTR (&scene, OMX_CONFIG_SCENEMODETYPE); |
| scene.nPortIndex = OMX_ALL; |
| scene.eSceneMode = ( OMX_SCENEMODETYPE ) Gen3A.SceneMode; |
| |
| CAMHAL_LOGDB("Configuring scene mode 0x%x", scene.eSceneMode); |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| ( OMX_INDEXTYPE ) OMX_TI_IndexConfigSceneMode, |
| &scene); |
| |
| if (OMX_ErrorNone != eError) { |
| CAMHAL_LOGEB("Error while configuring scene mode 0x%x", eError); |
| } else { |
| CAMHAL_LOGDA("Camera scene configured successfully"); |
| if (Gen3A.SceneMode != OMX_Manual) { |
| // Get preset scene mode feedback |
| getFocusMode(Gen3A); |
| getFlashMode(Gen3A); |
| getWBMode(Gen3A); |
| |
| // TODO(XXX): Re-enable these for mainline |
| // getSharpness(Gen3A); |
| // getSaturation(Gen3A); |
| // getISO(Gen3A); |
| } |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| status_t OMXCameraAdapter::setEVCompensation(Gen3A_settings& Gen3A) |
| { |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_CONFIG_EXPOSUREVALUETYPE expValues; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateInvalid == mComponentState ) |
| { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| return NO_INIT; |
| } |
| |
| OMX_INIT_STRUCT_PTR (&expValues, OMX_CONFIG_EXPOSUREVALUETYPE); |
| expValues.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| |
| OMX_GetConfig( mCameraAdapterParameters.mHandleComp, |
| OMX_IndexConfigCommonExposureValue, |
| &expValues); |
| CAMHAL_LOGDB("old EV Compensation for OMX = 0x%x", (int)expValues.xEVCompensation); |
| CAMHAL_LOGDB("EV Compensation for HAL = %d", Gen3A.EVCompensation); |
| |
| expValues.xEVCompensation = ( Gen3A.EVCompensation * ( 1 << Q16_OFFSET ) ) / 10; |
| eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp, |
| OMX_IndexConfigCommonExposureValue, |
| &expValues); |
| CAMHAL_LOGDB("new EV Compensation for OMX = 0x%x", (int)expValues.xEVCompensation); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while configuring EV Compensation 0x%x error = 0x%x", |
| ( unsigned int ) expValues.xEVCompensation, |
| eError); |
| } |
| else |
| { |
| CAMHAL_LOGDB("EV Compensation 0x%x configured successfully", |
| ( unsigned int ) expValues.xEVCompensation); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| status_t OMXCameraAdapter::getEVCompensation(Gen3A_settings& Gen3A) |
| { |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_CONFIG_EXPOSUREVALUETYPE expValues; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateInvalid == mComponentState ) { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| return NO_INIT; |
| } |
| |
| OMX_INIT_STRUCT_PTR (&expValues, OMX_CONFIG_EXPOSUREVALUETYPE); |
| expValues.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| |
| OMX_GetConfig(mCameraAdapterParameters.mHandleComp, |
| OMX_IndexConfigCommonExposureValue, |
| &expValues); |
| |
| if ( OMX_ErrorNone != eError ) { |
| CAMHAL_LOGEB("Error while getting EV Compensation error = 0x%x", eError); |
| } else { |
| Gen3A.EVCompensation = (10 * expValues.xEVCompensation) / (1 << Q16_OFFSET); |
| CAMHAL_LOGDB("Gen3A.EVCompensation 0x%x", Gen3A.EVCompensation); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| status_t OMXCameraAdapter::setWBMode(Gen3A_settings& Gen3A) |
| { |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_CONFIG_WHITEBALCONTROLTYPE wb; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateInvalid == mComponentState ) |
| { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| return NO_INIT; |
| } |
| |
| OMX_INIT_STRUCT_PTR (&wb, OMX_CONFIG_WHITEBALCONTROLTYPE); |
| wb.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| wb.eWhiteBalControl = ( OMX_WHITEBALCONTROLTYPE ) Gen3A.WhiteBallance; |
| |
| // disable face and region priorities |
| setAlgoPriority(FACE_PRIORITY, WHITE_BALANCE_ALGO, false); |
| setAlgoPriority(REGION_PRIORITY, WHITE_BALANCE_ALGO, false); |
| |
| eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp, |
| OMX_IndexConfigCommonWhiteBalance, |
| &wb); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while configuring Whitebalance mode 0x%x error = 0x%x", |
| ( unsigned int ) wb.eWhiteBalControl, |
| eError); |
| } |
| else |
| { |
| CAMHAL_LOGDB("Whitebalance mode 0x%x configured successfully", |
| ( unsigned int ) wb.eWhiteBalControl); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return eError; |
| } |
| |
| status_t OMXCameraAdapter::getWBMode(Gen3A_settings& Gen3A) |
| { |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_CONFIG_WHITEBALCONTROLTYPE wb; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateInvalid == mComponentState ) { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| return NO_INIT; |
| } |
| |
| OMX_INIT_STRUCT_PTR (&wb, OMX_CONFIG_WHITEBALCONTROLTYPE); |
| wb.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| |
| eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp, |
| OMX_IndexConfigCommonWhiteBalance, |
| &wb); |
| |
| if (OMX_ErrorNone != eError) { |
| CAMHAL_LOGEB("Error while getting Whitebalance mode error = 0x%x", eError); |
| } else { |
| Gen3A.WhiteBallance = wb.eWhiteBalControl; |
| CAMHAL_LOGDB("Gen3A.WhiteBallance 0x%x", Gen3A.WhiteBallance); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return eError; |
| } |
| |
| status_t OMXCameraAdapter::setFlicker(Gen3A_settings& Gen3A) |
| { |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_CONFIG_FLICKERCANCELTYPE flicker; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateInvalid == mComponentState ) |
| { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| return NO_INIT; |
| } |
| |
| OMX_INIT_STRUCT_PTR (&flicker, OMX_CONFIG_FLICKERCANCELTYPE); |
| flicker.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| flicker.eFlickerCancel = (OMX_COMMONFLICKERCANCELTYPE)Gen3A.Flicker; |
| |
| eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE)OMX_IndexConfigFlickerCancel, |
| &flicker ); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while configuring Flicker mode 0x%x error = 0x%x", |
| ( unsigned int ) flicker.eFlickerCancel, |
| eError); |
| } |
| else |
| { |
| CAMHAL_LOGDB("Flicker mode 0x%x configured successfully", |
| ( unsigned int ) flicker.eFlickerCancel); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| status_t OMXCameraAdapter::setBrightness(Gen3A_settings& Gen3A) |
| { |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_CONFIG_BRIGHTNESSTYPE brightness; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateInvalid == mComponentState ) |
| { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| return NO_INIT; |
| } |
| |
| OMX_INIT_STRUCT_PTR (&brightness, OMX_CONFIG_BRIGHTNESSTYPE); |
| brightness.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| brightness.nBrightness = Gen3A.Brightness; |
| |
| eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp, |
| OMX_IndexConfigCommonBrightness, |
| &brightness); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while configuring Brightness 0x%x error = 0x%x", |
| ( unsigned int ) brightness.nBrightness, |
| eError); |
| } |
| else |
| { |
| CAMHAL_LOGDB("Brightness 0x%x configured successfully", |
| ( unsigned int ) brightness.nBrightness); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| status_t OMXCameraAdapter::setContrast(Gen3A_settings& Gen3A) |
| { |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_CONFIG_CONTRASTTYPE contrast; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateInvalid == mComponentState ) |
| { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| return NO_INIT; |
| } |
| |
| OMX_INIT_STRUCT_PTR (&contrast, OMX_CONFIG_CONTRASTTYPE); |
| contrast.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| contrast.nContrast = Gen3A.Contrast; |
| |
| eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp, |
| OMX_IndexConfigCommonContrast, |
| &contrast); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while configuring Contrast 0x%x error = 0x%x", |
| ( unsigned int ) contrast.nContrast, |
| eError); |
| } |
| else |
| { |
| CAMHAL_LOGDB("Contrast 0x%x configured successfully", |
| ( unsigned int ) contrast.nContrast); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return eError; |
| } |
| |
| status_t OMXCameraAdapter::setSharpness(Gen3A_settings& Gen3A) |
| { |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE procSharpness; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateInvalid == mComponentState ) |
| { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| return NO_INIT; |
| } |
| |
| OMX_INIT_STRUCT_PTR (&procSharpness, OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE); |
| procSharpness.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| procSharpness.nLevel = Gen3A.Sharpness; |
| |
| if( procSharpness.nLevel == 0 ) |
| { |
| procSharpness.bAuto = OMX_TRUE; |
| } |
| else |
| { |
| procSharpness.bAuto = OMX_FALSE; |
| } |
| |
| eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE)OMX_IndexConfigSharpeningLevel, |
| &procSharpness); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while configuring Sharpness 0x%x error = 0x%x", |
| ( unsigned int ) procSharpness.nLevel, |
| eError); |
| } |
| else |
| { |
| CAMHAL_LOGDB("Sharpness 0x%x configured successfully", |
| ( unsigned int ) procSharpness.nLevel); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| status_t OMXCameraAdapter::getSharpness(Gen3A_settings& Gen3A) |
| { |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE procSharpness; |
| |
| LOG_FUNCTION_NAME; |
| |
| if (OMX_StateInvalid == mComponentState) { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| return NO_INIT; |
| } |
| |
| OMX_INIT_STRUCT_PTR (&procSharpness, OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE); |
| procSharpness.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| |
| eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE)OMX_IndexConfigSharpeningLevel, |
| &procSharpness); |
| |
| if (OMX_ErrorNone != eError) { |
| CAMHAL_LOGEB("Error while configuring Sharpness error = 0x%x", eError); |
| } else { |
| Gen3A.Sharpness = procSharpness.nLevel; |
| CAMHAL_LOGDB("Gen3A.Sharpness 0x%x", Gen3A.Sharpness); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| status_t OMXCameraAdapter::setSaturation(Gen3A_settings& Gen3A) |
| { |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_CONFIG_SATURATIONTYPE saturation; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateInvalid == mComponentState ) |
| { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| return NO_INIT; |
| } |
| |
| OMX_INIT_STRUCT_PTR (&saturation, OMX_CONFIG_SATURATIONTYPE); |
| saturation.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| saturation.nSaturation = Gen3A.Saturation; |
| |
| eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp, |
| OMX_IndexConfigCommonSaturation, |
| &saturation); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while configuring Saturation 0x%x error = 0x%x", |
| ( unsigned int ) saturation.nSaturation, |
| eError); |
| } |
| else |
| { |
| CAMHAL_LOGDB("Saturation 0x%x configured successfully", |
| ( unsigned int ) saturation.nSaturation); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| status_t OMXCameraAdapter::getSaturation(Gen3A_settings& Gen3A) |
| { |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_CONFIG_SATURATIONTYPE saturation; |
| |
| LOG_FUNCTION_NAME; |
| |
| if (OMX_StateInvalid == mComponentState) { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| return NO_INIT; |
| } |
| |
| OMX_INIT_STRUCT_PTR (&saturation, OMX_CONFIG_SATURATIONTYPE); |
| saturation.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| |
| eError = OMX_GetConfig( mCameraAdapterParameters.mHandleComp, |
| OMX_IndexConfigCommonSaturation, |
| &saturation); |
| |
| if (OMX_ErrorNone != eError) { |
| CAMHAL_LOGEB("Error while getting Saturation error = 0x%x", eError); |
| } else { |
| Gen3A.Saturation = saturation.nSaturation; |
| CAMHAL_LOGDB("Gen3A.Saturation 0x%x", Gen3A.Saturation); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| status_t OMXCameraAdapter::setISO(Gen3A_settings& Gen3A) |
| { |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_CONFIG_EXPOSUREVALUETYPE expValues; |
| OMX_TI_CONFIG_EXPOSUREVALUERIGHTTYPE expValRight; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateInvalid == mComponentState ) |
| { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| return NO_INIT; |
| } |
| |
| // In case of manual exposure Gain is applied from setManualExposureVal |
| if ( Gen3A.Exposure == OMX_ExposureControlOff ) { |
| return NO_ERROR; |
| } |
| |
| OMX_INIT_STRUCT_PTR (&expValues, OMX_CONFIG_EXPOSUREVALUETYPE); |
| OMX_INIT_STRUCT_PTR (&expValRight, OMX_TI_CONFIG_EXPOSUREVALUERIGHTTYPE); |
| expValues.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| expValRight.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| |
| eError = OMX_GetConfig( mCameraAdapterParameters.mHandleComp, |
| OMX_IndexConfigCommonExposureValue, |
| &expValues); |
| |
| if ( OMX_ErrorNone == eError ) { |
| eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE) OMX_TI_IndexConfigRightExposureValue, |
| &expValRight); |
| } |
| |
| if ( OMX_ErrorNone != eError ) { |
| CAMHAL_LOGEB("OMX_GetConfig error 0x%x (manual exposure values)", eError); |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| if( 0 == Gen3A.ISO ) { |
| expValues.bAutoSensitivity = OMX_TRUE; |
| } else { |
| expValues.bAutoSensitivity = OMX_FALSE; |
| expValues.nSensitivity = Gen3A.ISO; |
| expValRight.nSensitivity = expValues.nSensitivity; |
| } |
| |
| eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp, |
| OMX_IndexConfigCommonExposureValue, |
| &expValues); |
| |
| if ( OMX_ErrorNone == eError ) { |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE) OMX_TI_IndexConfigRightExposureValue, |
| &expValRight); |
| } |
| if ( OMX_ErrorNone != eError ) { |
| CAMHAL_LOGEB("Error while configuring ISO 0x%x error = 0x%x", |
| ( unsigned int ) expValues.nSensitivity, |
| eError); |
| } else { |
| CAMHAL_LOGDB("ISO 0x%x configured successfully", |
| ( unsigned int ) expValues.nSensitivity); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| status_t OMXCameraAdapter::getISO(Gen3A_settings& Gen3A) |
| { |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_CONFIG_EXPOSUREVALUETYPE expValues; |
| |
| LOG_FUNCTION_NAME; |
| |
| if (OMX_StateInvalid == mComponentState) { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| return NO_INIT; |
| } |
| |
| OMX_INIT_STRUCT_PTR (&expValues, OMX_CONFIG_EXPOSUREVALUETYPE); |
| expValues.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| |
| OMX_GetConfig( mCameraAdapterParameters.mHandleComp, |
| OMX_IndexConfigCommonExposureValue, |
| &expValues); |
| |
| if (OMX_ErrorNone != eError) { |
| CAMHAL_LOGEB("Error while getting ISO error = 0x%x", eError); |
| } else { |
| Gen3A.ISO = expValues.nSensitivity; |
| CAMHAL_LOGDB("Gen3A.ISO %d", Gen3A.ISO); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| status_t OMXCameraAdapter::setEffect(Gen3A_settings& Gen3A) |
| { |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_CONFIG_IMAGEFILTERTYPE effect; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateInvalid == mComponentState ) |
| { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| return NO_INIT; |
| } |
| |
| OMX_INIT_STRUCT_PTR (&effect, OMX_CONFIG_IMAGEFILTERTYPE); |
| effect.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| effect.eImageFilter = (OMX_IMAGEFILTERTYPE ) Gen3A.Effect; |
| |
| eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp, |
| OMX_IndexConfigCommonImageFilter, |
| &effect); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while configuring Effect 0x%x error = 0x%x", |
| ( unsigned int ) effect.eImageFilter, |
| eError); |
| } |
| else |
| { |
| CAMHAL_LOGDB("Effect 0x%x configured successfully", |
| ( unsigned int ) effect.eImageFilter); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| status_t OMXCameraAdapter::setWhiteBalanceLock(Gen3A_settings& Gen3A) |
| { |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_IMAGE_CONFIG_LOCKTYPE lock; |
| |
| LOG_FUNCTION_NAME |
| |
| if ( OMX_StateInvalid == mComponentState ) |
| { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| return NO_INIT; |
| } |
| |
| OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE); |
| lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| lock.bLock = Gen3A.WhiteBalanceLock; |
| eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE)OMX_IndexConfigImageWhiteBalanceLock, |
| &lock); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while configuring WhiteBalance Lock error = 0x%x", eError); |
| } |
| else |
| { |
| CAMHAL_LOGDB("WhiteBalance Lock configured successfully %d ", lock.bLock); |
| } |
| LOG_FUNCTION_NAME_EXIT |
| |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| status_t OMXCameraAdapter::setExposureLock(Gen3A_settings& Gen3A) |
| { |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_IMAGE_CONFIG_LOCKTYPE lock; |
| |
| LOG_FUNCTION_NAME |
| |
| if ( OMX_StateInvalid == mComponentState ) |
| { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| return NO_INIT; |
| } |
| |
| OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE); |
| lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| lock.bLock = Gen3A.ExposureLock; |
| eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE)OMX_IndexConfigImageExposureLock, |
| &lock); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while configuring Exposure Lock error = 0x%x", eError); |
| } |
| else |
| { |
| CAMHAL_LOGDB("Exposure Lock configured successfully %d ", lock.bLock); |
| } |
| LOG_FUNCTION_NAME_EXIT |
| |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| status_t OMXCameraAdapter::setFocusLock(Gen3A_settings& Gen3A) |
| { |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_IMAGE_CONFIG_LOCKTYPE lock; |
| |
| LOG_FUNCTION_NAME |
| |
| if ( OMX_StateInvalid == mComponentState ) { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| return NO_INIT; |
| } |
| |
| OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE); |
| lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| |
| lock.bLock = Gen3A.FocusLock; |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE)OMX_IndexConfigImageFocusLock, |
| &lock); |
| |
| if ( OMX_ErrorNone != eError ) { |
| CAMHAL_LOGEB("Error while configuring Focus Lock error = 0x%x", eError); |
| } else { |
| CAMHAL_LOGDB("Focus Lock configured successfully %d ", lock.bLock); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT |
| |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| status_t OMXCameraAdapter::set3ALock(OMX_BOOL toggleExp, OMX_BOOL toggleWb, OMX_BOOL toggleFocus) |
| { |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_IMAGE_CONFIG_LOCKTYPE lock; |
| |
| LOG_FUNCTION_NAME |
| |
| if ( OMX_StateInvalid == mComponentState ) |
| { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| return NO_INIT; |
| } |
| |
| OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE); |
| lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| |
| mParameters3A.ExposureLock = toggleExp; |
| mParameters3A.FocusLock = toggleFocus; |
| mParameters3A.WhiteBalanceLock = toggleWb; |
| |
| eError = OMX_GetConfig( mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE)OMX_IndexConfigImageExposureLock, |
| &lock); |
| |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error GetConfig Exposure Lock error = 0x%x", eError); |
| goto EXIT; |
| } |
| else |
| { |
| CAMHAL_LOGDA("Exposure Lock GetConfig successfull"); |
| |
| /* Apply locks only when not applied already */ |
| if ( lock.bLock != toggleExp ) |
| { |
| setExposureLock(mParameters3A); |
| } |
| |
| } |
| |
| OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE); |
| lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| eError = OMX_GetConfig( mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE)OMX_IndexConfigImageFocusLock, |
| &lock); |
| |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error GetConfig Focus Lock error = 0x%x", eError); |
| goto EXIT; |
| } |
| else |
| { |
| CAMHAL_LOGDB("Focus Lock GetConfig successfull bLock(%d)", lock.bLock); |
| |
| /* Apply locks only when not applied already */ |
| if ( lock.bLock != toggleFocus ) |
| { |
| setFocusLock(mParameters3A); |
| } |
| } |
| |
| OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE); |
| lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; |
| eError = OMX_GetConfig( mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE)OMX_IndexConfigImageWhiteBalanceLock, |
| &lock); |
| |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error GetConfig WhiteBalance Lock error = 0x%x", eError); |
| goto EXIT; |
| } |
| else |
| { |
| CAMHAL_LOGDA("WhiteBalance Lock GetConfig successfull"); |
| |
| /* Apply locks only when not applied already */ |
| if ( lock.bLock != toggleWb ) |
| { |
| setWhiteBalanceLock(mParameters3A); |
| } |
| |
| } |
| EXIT: |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| status_t OMXCameraAdapter::setMeteringAreas(Gen3A_settings& Gen3A) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| |
| CameraBuffer *bufferlist; |
| OMX_ALGOAREASTYPE *meteringAreas; |
| OMX_TI_CONFIG_SHAREDBUFFER sharedBuffer; |
| int areasSize = 0; |
| |
| LOG_FUNCTION_NAME |
| |
| android::AutoMutex lock(mMeteringAreasLock); |
| |
| if ( OMX_StateInvalid == mComponentState ) |
| { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| return NO_INIT; |
| } |
| |
| areasSize = ((sizeof(OMX_ALGOAREASTYPE)+4095)/4096)*4096; |
| bufferlist = mMemMgr.allocateBufferList(0, 0, NULL, areasSize, 1); |
| meteringAreas = (OMX_ALGOAREASTYPE *)bufferlist[0].opaque; |
| |
| OMXCameraPortParameters * mPreviewData = NULL; |
| mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex]; |
| |
| if (!meteringAreas) |
| { |
| CAMHAL_LOGEB("Error allocating buffer for metering areas %d", eError); |
| return -ENOMEM; |
| } |
| |
| OMX_INIT_STRUCT_PTR (meteringAreas, OMX_ALGOAREASTYPE); |
| |
| meteringAreas->nPortIndex = OMX_ALL; |
| meteringAreas->nNumAreas = mMeteringAreas.size(); |
| meteringAreas->nAlgoAreaPurpose = OMX_AlgoAreaExposure; |
| |
| for ( unsigned int n = 0; n < mMeteringAreas.size(); n++) |
| { |
| 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 |
| mMeteringAreas.itemAt(n)->transfrom((size_t)mPreviewData->mWidth/widthDivisor, |
| (size_t)mPreviewData->mHeight/heightDivisor, |
| (size_t&)meteringAreas->tAlgoAreas[n].nTop, |
| (size_t&)meteringAreas->tAlgoAreas[n].nLeft, |
| (size_t&)meteringAreas->tAlgoAreas[n].nWidth, |
| (size_t&)meteringAreas->tAlgoAreas[n].nHeight); |
| |
| meteringAreas->tAlgoAreas[n].nLeft = |
| ( meteringAreas->tAlgoAreas[n].nLeft * METERING_AREAS_RANGE ) / mPreviewData->mWidth; |
| meteringAreas->tAlgoAreas[n].nTop = |
| ( meteringAreas->tAlgoAreas[n].nTop* METERING_AREAS_RANGE ) / mPreviewData->mHeight; |
| meteringAreas->tAlgoAreas[n].nWidth = |
| ( meteringAreas->tAlgoAreas[n].nWidth * METERING_AREAS_RANGE ) / mPreviewData->mWidth; |
| meteringAreas->tAlgoAreas[n].nHeight = |
| ( meteringAreas->tAlgoAreas[n].nHeight * METERING_AREAS_RANGE ) / mPreviewData->mHeight; |
| |
| meteringAreas->tAlgoAreas[n].nPriority = mMeteringAreas.itemAt(n)->getWeight(); |
| |
| CAMHAL_LOGDB("Metering area %d : top = %d left = %d width = %d height = %d prio = %d", |
| n, (int)meteringAreas->tAlgoAreas[n].nTop, (int)meteringAreas->tAlgoAreas[n].nLeft, |
| (int)meteringAreas->tAlgoAreas[n].nWidth, (int)meteringAreas->tAlgoAreas[n].nHeight, |
| (int)meteringAreas->tAlgoAreas[n].nPriority); |
| |
| } |
| |
| OMX_INIT_STRUCT_PTR (&sharedBuffer, OMX_TI_CONFIG_SHAREDBUFFER); |
| |
| sharedBuffer.nPortIndex = OMX_ALL; |
| sharedBuffer.nSharedBuffSize = areasSize; |
| sharedBuffer.pSharedBuff = (OMX_U8 *)camera_buffer_get_omx_ptr (&bufferlist[0]); |
| |
| if ( NULL == sharedBuffer.pSharedBuff ) |
| { |
| CAMHAL_LOGEA("No resources to allocate OMX shared buffer"); |
| ret = -ENOMEM; |
| goto EXIT; |
| } |
| |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE) OMX_TI_IndexConfigAlgoAreas, &sharedBuffer); |
| |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while setting Focus Areas configuration 0x%x", eError); |
| ret = -EINVAL; |
| } |
| else |
| { |
| CAMHAL_LOGDA("Metering Areas SetConfig successfull."); |
| } |
| |
| EXIT: |
| if (NULL != bufferlist) |
| { |
| mMemMgr.freeBufferList(bufferlist); |
| } |
| |
| return ret; |
| } |
| |
| //TI extensions for enable/disable algos |
| status_t OMXCameraAdapter::setParameter3ABoolInvert(const OMX_INDEXTYPE omx_idx, |
| const OMX_BOOL data, const char *msg) |
| { |
| OMX_BOOL inv_data; |
| |
| if (OMX_TRUE == data) |
| { |
| inv_data = OMX_FALSE; |
| } |
| else if (OMX_FALSE == data) |
| { |
| inv_data = OMX_TRUE; |
| } |
| else |
| { |
| return BAD_VALUE; |
| } |
| return setParameter3ABool(omx_idx, inv_data, msg); |
| } |
| |
| status_t OMXCameraAdapter::setParameter3ABool(const OMX_INDEXTYPE omx_idx, |
| const OMX_BOOL data, const char *msg) |
| { |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| OMX_CONFIG_BOOLEANTYPE cfgdata; |
| |
| LOG_FUNCTION_NAME |
| |
| if ( OMX_StateInvalid == mComponentState ) |
| { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| return NO_INIT; |
| } |
| |
| OMX_INIT_STRUCT_PTR (&cfgdata, OMX_CONFIG_BOOLEANTYPE); |
| cfgdata.bEnabled = data; |
| eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp, |
| omx_idx, |
| &cfgdata); |
| if ( OMX_ErrorNone != eError ) |
| { |
| CAMHAL_LOGEB("Error while configuring %s error = 0x%x", msg, eError); |
| } |
| else |
| { |
| CAMHAL_LOGDB("%s configured successfully %d ", msg, cfgdata.bEnabled); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT |
| |
| return Utils::ErrorUtils::omxToAndroidError(eError); |
| } |
| |
| status_t OMXCameraAdapter::setAlgoExternalGamma(Gen3A_settings& Gen3A) |
| { |
| return setParameter3ABool((OMX_INDEXTYPE) OMX_TI_IndexConfigExternalGamma, Gen3A.AlgoExternalGamma, "External Gamma"); |
| } |
| |
| status_t OMXCameraAdapter::setAlgoNSF1(Gen3A_settings& Gen3A) |
| { |
| return setParameter3ABoolInvert((OMX_INDEXTYPE) OMX_TI_IndexConfigDisableNSF1, Gen3A.AlgoNSF1, "NSF1"); |
| } |
| |
| status_t OMXCameraAdapter::setAlgoNSF2(Gen3A_settings& Gen3A) |
| { |
| return setParameter3ABoolInvert((OMX_INDEXTYPE) OMX_TI_IndexConfigDisableNSF2, Gen3A.AlgoNSF2, "NSF2"); |
| } |
| |
| status_t OMXCameraAdapter::setAlgoSharpening(Gen3A_settings& Gen3A) |
| { |
| return setParameter3ABoolInvert((OMX_INDEXTYPE) OMX_TI_IndexConfigDisableSharpening, Gen3A.AlgoSharpening, "Sharpening"); |
| } |
| |
| status_t OMXCameraAdapter::setAlgoThreeLinColorMap(Gen3A_settings& Gen3A) |
| { |
| return setParameter3ABoolInvert((OMX_INDEXTYPE) OMX_TI_IndexConfigDisableThreeLinColorMap, Gen3A.AlgoThreeLinColorMap, "Color Conversion"); |
| } |
| |
| status_t OMXCameraAdapter::setAlgoGIC(Gen3A_settings& Gen3A) |
| { |
| return setParameter3ABoolInvert((OMX_INDEXTYPE) OMX_TI_IndexConfigDisableGIC, Gen3A.AlgoGIC, "Green Inballance Correction"); |
| } |
| |
| status_t OMXCameraAdapter::setGammaTable(Gen3A_settings& Gen3A) |
| { |
| status_t ret = NO_ERROR; |
| OMX_ERRORTYPE eError = OMX_ErrorNone; |
| CameraBuffer *bufferlist = NULL; |
| OMX_TI_CONFIG_GAMMATABLE_TYPE *gammaTable = NULL; |
| OMX_TI_CONFIG_SHAREDBUFFER sharedBuffer; |
| int tblSize = 0; |
| |
| LOG_FUNCTION_NAME; |
| |
| if ( OMX_StateInvalid == mComponentState ) { |
| CAMHAL_LOGEA("OMX component is in invalid state"); |
| ret = NO_INIT; |
| goto EXIT; |
| } |
| |
| tblSize = ((sizeof(OMX_TI_CONFIG_GAMMATABLE_TYPE)+4095)/4096)*4096; |
| bufferlist = mMemMgr.allocateBufferList(0, 0, NULL, tblSize, 1); |
| if (NULL == bufferlist) { |
| CAMHAL_LOGEB("Error allocating buffer for gamma table"); |
| ret = NO_MEMORY; |
| goto EXIT; |
| } |
| gammaTable = (OMX_TI_CONFIG_GAMMATABLE_TYPE *)bufferlist[0].mapped; |
| if (NULL == gammaTable) { |
| CAMHAL_LOGEB("Error allocating buffer for gamma table (wrong data pointer)"); |
| ret = NO_MEMORY; |
| goto EXIT; |
| } |
| |
| memcpy(gammaTable, &mParameters3A.mGammaTable, sizeof(OMX_TI_CONFIG_GAMMATABLE_TYPE)); |
| |
| #ifdef CAMERAHAL_DEBUG |
| { |
| android::String8 DmpR; |
| android::String8 DmpG; |
| android::String8 DmpB; |
| for (unsigned int i=0; i<OMX_TI_GAMMATABLE_SIZE;i++) { |
| DmpR.appendFormat(" %d:%d;", (int)gammaTable->pR[i].nOffset, (int)(int)gammaTable->pR[i].nSlope); |
| DmpG.appendFormat(" %d:%d;", (int)gammaTable->pG[i].nOffset, (int)(int)gammaTable->pG[i].nSlope); |
| DmpB.appendFormat(" %d:%d;", (int)gammaTable->pB[i].nOffset, (int)(int)gammaTable->pB[i].nSlope); |
| } |
| CAMHAL_LOGE("Gamma table R:%s", DmpR.string()); |
| CAMHAL_LOGE("Gamma table G:%s", DmpG.string()); |
| CAMHAL_LOGE("Gamma table B:%s", DmpB.string()); |
| } |
| #endif |
| |
| OMX_INIT_STRUCT_PTR (&sharedBuffer, OMX_TI_CONFIG_SHAREDBUFFER); |
| sharedBuffer.nPortIndex = OMX_ALL; |
| sharedBuffer.nSharedBuffSize = sizeof(OMX_TI_CONFIG_GAMMATABLE_TYPE); |
| sharedBuffer.pSharedBuff = (OMX_U8 *)camera_buffer_get_omx_ptr (&bufferlist[0]); |
| if ( NULL == sharedBuffer.pSharedBuff ) { |
| CAMHAL_LOGEA("No resources to allocate OMX shared buffer"); |
| ret = NO_MEMORY; |
| goto EXIT; |
| } |
| |
| eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, |
| (OMX_INDEXTYPE) OMX_TI_IndexConfigGammaTable, &sharedBuffer); |
| if ( OMX_ErrorNone != eError ) { |
| CAMHAL_LOGEB("Error while setting Gamma Table configuration 0x%x", eError); |
| ret = BAD_VALUE; |
| goto EXIT; |
| } else { |
| CAMHAL_LOGDA("Gamma Table SetConfig successfull."); |
| } |
| |
| EXIT: |
| |
| if (NULL != bufferlist) { |
| mMemMgr.freeBufferList(bufferlist); |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| status_t OMXCameraAdapter::apply3Asettings( Gen3A_settings& Gen3A ) |
| { |
| status_t ret = NO_ERROR; |
| unsigned int currSett; // 32 bit |
| int portIndex; |
| |
| LOG_FUNCTION_NAME; |
| |
| android::AutoMutex lock(m3ASettingsUpdateLock); |
| |
| /* |
| * Scenes have a priority during the process |
| * of applying 3A related parameters. |
| * They can override pretty much all other 3A |
| * settings and similarly get overridden when |
| * for instance the focus mode gets switched. |
| * There is only one exception to this rule, |
| * the manual a.k.a. auto scene. |
| */ |
| if (SetSceneMode & mPending3Asettings) { |
| mPending3Asettings &= ~SetSceneMode; |
| ret |= setScene(Gen3A); |
| // re-apply EV compensation after setting scene mode since it probably reset it |
| if(Gen3A.EVCompensation) { |
| setEVCompensation(Gen3A); |
| } |
| return ret; |
| } else if (OMX_Manual != Gen3A.SceneMode) { |
| // only certain settings are allowed when scene mode is set |
| mPending3Asettings &= (SetEVCompensation | SetFocus | SetWBLock | |
| SetExpLock | SetWhiteBallance | SetFlash); |
| if ( mPending3Asettings == 0 ) return NO_ERROR; |
| } |
| |
| for( currSett = 1; currSett < E3aSettingMax; currSett <<= 1) |
| { |
| if( currSett & mPending3Asettings ) |
| { |
| switch( currSett ) |
| { |
| case SetEVCompensation: |
| { |
| ret |= setEVCompensation(Gen3A); |
| break; |
| } |
| |
| case SetWhiteBallance: |
| { |
| ret |= setWBMode(Gen3A); |
| break; |
| } |
| |
| case SetFlicker: |
| { |
| ret |= setFlicker(Gen3A); |
| break; |
| } |
| |
| case SetBrightness: |
| { |
| ret |= setBrightness(Gen3A); |
| break; |
| } |
| |
| case SetContrast: |
| { |
| ret |= setContrast(Gen3A); |
| break; |
| } |
| |
| case SetSharpness: |
| { |
| ret |= setSharpness(Gen3A); |
| break; |
| } |
| |
| case SetSaturation: |
| { |
| ret |= setSaturation(Gen3A); |
| break; |
| } |
| |
| case SetISO: |
| { |
| ret |= setISO(Gen3A); |
| break; |
| } |
| |
| case SetEffect: |
| { |
| ret |= setEffect(Gen3A); |
| break; |
| } |
| |
| case SetFocus: |
| { |
| ret |= setFocusMode(Gen3A); |
| break; |
| } |
| |
| case SetExpMode: |
| { |
| ret |= setExposureMode(Gen3A); |
| break; |
| } |
| |
| case SetManualExposure: { |
| ret |= setManualExposureVal(Gen3A); |
| break; |
| } |
| |
| case SetFlash: |
| { |
| ret |= setFlashMode(Gen3A); |
| break; |
| } |
| |
| case SetExpLock: |
| { |
| ret |= setExposureLock(Gen3A); |
| break; |
| } |
| |
| case SetWBLock: |
| { |
| ret |= setWhiteBalanceLock(Gen3A); |
| break; |
| } |
| case SetMeteringAreas: |
| { |
| ret |= setMeteringAreas(Gen3A); |
| } |
| break; |
| |
| //TI extensions for enable/disable algos |
| case SetAlgoExternalGamma: |
| { |
| ret |= setAlgoExternalGamma(Gen3A); |
| } |
| break; |
| |
| case SetAlgoNSF1: |
| { |
| ret |= setAlgoNSF1(Gen3A); |
| } |
| break; |
| |
| case SetAlgoNSF2: |
| { |
| ret |= setAlgoNSF2(Gen3A); |
| } |
| break; |
| |
| case SetAlgoSharpening: |
| { |
| ret |= setAlgoSharpening(Gen3A); |
| } |
| break; |
| |
| case SetAlgoThreeLinColorMap: |
| { |
| ret |= setAlgoThreeLinColorMap(Gen3A); |
| } |
| break; |
| |
| case SetAlgoGIC: |
| { |
| ret |= setAlgoGIC(Gen3A); |
| } |
| break; |
| |
| case SetGammaTable: |
| { |
| ret |= setGammaTable(Gen3A); |
| } |
| break; |
| |
| default: |
| CAMHAL_LOGEB("this setting (0x%x) is still not supported in CameraAdapter ", |
| currSett); |
| break; |
| } |
| mPending3Asettings &= ~currSett; |
| } |
| } |
| |
| LOG_FUNCTION_NAME_EXIT; |
| |
| return ret; |
| } |
| |
| } // namespace Camera |
| } // namespace Ti |
