OMX3A.cpp revision 0db9de9c050c698df5c160249e4060efa96e10a7 
1/*
2 * Copyright (C) Texas Instruments - http://www.ti.com/
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17/**
18* @file OMX3A.cpp
19*
20* This file contains functionality for handling 3A configurations.
21*
22*/
23
24#include "CameraHal.h"
25#include "OMXCameraAdapter.h"
26#include "ErrorUtils.h"
27
28#include <cutils/properties.h>
29
30#define METERING_AREAS_RANGE 0xFF
31
32static const char PARAM_SEP[] = ",";
33
34namespace Ti {
35namespace Camera {
36
37const SceneModesEntry* OMXCameraAdapter::getSceneModeEntry(const char* name,
38                                                                  OMX_SCENEMODETYPE scene) {
39    const SceneModesEntry* cameraLUT = NULL;
40    const SceneModesEntry* entry = NULL;
41    unsigned int numEntries = 0;
42
43    // 1. Find camera's scene mode LUT
44    for (unsigned int i = 0; i < ARRAY_SIZE(CameraToSensorModesLUT); i++) {
45        if (strcmp(CameraToSensorModesLUT[i].name, name) == 0) {
46            cameraLUT = CameraToSensorModesLUT[i].Table;
47            numEntries = CameraToSensorModesLUT[i].size;
48            break;
49        }
50    }
51
52    // 2. Find scene mode entry in table
53    if (!cameraLUT) {
54        goto EXIT;
55    }
56
57    for (unsigned int i = 0; i < numEntries; i++) {
58        if(cameraLUT[i].scene == scene) {
59            entry = cameraLUT + i;
60            break;
61        }
62    }
63 EXIT:
64    return entry;
65}
66
67status_t OMXCameraAdapter::setParameters3A(const android::CameraParameters &params,
68                                           BaseCameraAdapter::AdapterState state)
69{
70    status_t ret = NO_ERROR;
71    int mode = 0;
72    const char *str = NULL;
73    int varint = 0;
74    BaseCameraAdapter::AdapterState nextState;
75    BaseCameraAdapter::getNextState(nextState);
76
77    LOG_FUNCTION_NAME;
78
79    android::AutoMutex lock(m3ASettingsUpdateLock);
80
81    str = params.get(android::CameraParameters::KEY_SCENE_MODE);
82    mode = getLUTvalue_HALtoOMX( str, SceneLUT);
83    if ( mFirstTimeInit || ((str != NULL) && ( mParameters3A.SceneMode != mode )) ) {
84        if ( 0 <= mode ) {
85            mParameters3A.SceneMode = mode;
86            if ((mode == OMX_Manual) && (mFirstTimeInit == false)){//Auto mode
87                mFirstTimeInit = true;
88            }
89            if ((mode != OMX_Manual) &&
90                (state & PREVIEW_ACTIVE) && !(nextState & CAPTURE_ACTIVE)) {
91                // if setting preset scene mode, previewing, and not in the middle of capture
92                // set preset scene mode immediately instead of in next FBD
93                // for feedback params to work properly since they need to be read
94                // by application in subsequent getParameters()
95                ret |= setScene(mParameters3A);
96                // re-apply EV compensation after setting scene mode since it probably reset it
97                if(mParameters3A.EVCompensation) {
98                   setEVCompensation(mParameters3A);
99                }
100                return ret;
101            } else {
102                mPending3Asettings |= SetSceneMode;
103            }
104        } else {
105            mParameters3A.SceneMode = OMX_Manual;
106        }
107        CAMHAL_LOGVB("SceneMode %d", mParameters3A.SceneMode);
108    }
109
110#ifdef OMAP_ENHANCEMENT
111    if ( (str = params.get(TICameraParameters::KEY_EXPOSURE_MODE)) != NULL ) {
112        mode = getLUTvalue_HALtoOMX(str, ExpLUT);
113        if ( mParameters3A.Exposure != mode ) {
114            // If either the new or the old exposure mode is manual set also
115            // the SetManualExposure flag to call setManualExposureVal where
116            // the auto gain and exposure flags are configured
117            if ( mParameters3A.Exposure == OMX_ExposureControlOff ||
118                 mode == OMX_ExposureControlOff ) {
119                mPending3Asettings |= SetManualExposure;
120            }
121            mParameters3A.Exposure = mode;
122            CAMHAL_LOGDB("Exposure mode %d", mode);
123            if ( 0 <= mParameters3A.Exposure ) {
124                mPending3Asettings |= SetExpMode;
125            }
126        }
127        if ( mode == OMX_ExposureControlOff ) {
128            mode = params.getInt(TICameraParameters::KEY_MANUAL_EXPOSURE);
129            if ( mParameters3A.ManualExposure != mode ) {
130                mParameters3A.ManualExposure = mode;
131                CAMHAL_LOGDB("Manual Exposure = %d", mode);
132                mPending3Asettings |= SetManualExposure;
133            }
134            mode = params.getInt(TICameraParameters::KEY_MANUAL_EXPOSURE_RIGHT);
135            if ( mParameters3A.ManualExposureRight != mode ) {
136                mParameters3A.ManualExposureRight = mode;
137                CAMHAL_LOGDB("Manual Exposure right = %d", mode);
138                mPending3Asettings |= SetManualExposure;
139            }
140            mode = params.getInt(TICameraParameters::KEY_MANUAL_GAIN_ISO);
141            if ( mParameters3A.ManualGain != mode ) {
142                mParameters3A.ManualGain = mode;
143                CAMHAL_LOGDB("Manual Gain = %d", mode);
144                mPending3Asettings |= SetManualExposure;
145            }
146            mode = params.getInt(TICameraParameters::KEY_MANUAL_GAIN_ISO_RIGHT);
147            if ( mParameters3A.ManualGainRight != mode ) {
148                mParameters3A.ManualGainRight = mode;
149                CAMHAL_LOGDB("Manual Gain right = %d", mode);
150                mPending3Asettings |= SetManualExposure;
151            }
152        }
153    }
154#endif
155
156    str = params.get(android::CameraParameters::KEY_WHITE_BALANCE);
157    mode = getLUTvalue_HALtoOMX( str, WBalLUT);
158    if (mFirstTimeInit || ((str != NULL) && (mode != mParameters3A.WhiteBallance)))
159        {
160        mParameters3A.WhiteBallance = mode;
161        CAMHAL_LOGDB("Whitebalance mode %d", mode);
162        if ( 0 <= mParameters3A.WhiteBallance )
163            {
164            mPending3Asettings |= SetWhiteBallance;
165            }
166        }
167
168#ifdef OMAP_ENHANCEMENT
169    varint = params.getInt(TICameraParameters::KEY_CONTRAST);
170    if ( 0 <= varint )
171        {
172        if ( mFirstTimeInit ||
173             ( (mParameters3A.Contrast  + CONTRAST_OFFSET) != varint ) )
174            {
175            mParameters3A.Contrast = varint - CONTRAST_OFFSET;
176            CAMHAL_LOGDB("Contrast %d", mParameters3A.Contrast);
177            mPending3Asettings |= SetContrast;
178            }
179        }
180
181    varint = params.getInt(TICameraParameters::KEY_SHARPNESS);
182    if ( 0 <= varint )
183        {
184        if ( mFirstTimeInit ||
185             ((mParameters3A.Sharpness + SHARPNESS_OFFSET) != varint ))
186            {
187            mParameters3A.Sharpness = varint - SHARPNESS_OFFSET;
188            CAMHAL_LOGDB("Sharpness %d", mParameters3A.Sharpness);
189            mPending3Asettings |= SetSharpness;
190            }
191        }
192
193    varint = params.getInt(TICameraParameters::KEY_SATURATION);
194    if ( 0 <= varint )
195        {
196        if ( mFirstTimeInit ||
197             ((mParameters3A.Saturation + SATURATION_OFFSET) != varint ) )
198            {
199            mParameters3A.Saturation = varint - SATURATION_OFFSET;
200            CAMHAL_LOGDB("Saturation %d", mParameters3A.Saturation);
201            mPending3Asettings |= SetSaturation;
202            }
203        }
204
205    varint = params.getInt(TICameraParameters::KEY_BRIGHTNESS);
206    if ( 0 <= varint )
207        {
208        if ( mFirstTimeInit ||
209             (( mParameters3A.Brightness != varint )) )
210            {
211            mParameters3A.Brightness = (unsigned) varint;
212            CAMHAL_LOGDB("Brightness %d", mParameters3A.Brightness);
213            mPending3Asettings |= SetBrightness;
214            }
215        }
216#endif
217
218    str = params.get(android::CameraParameters::KEY_ANTIBANDING);
219    mode = getLUTvalue_HALtoOMX(str,FlickerLUT);
220    if ( mFirstTimeInit || ( ( str != NULL ) && ( mParameters3A.Flicker != mode ) ))
221        {
222        mParameters3A.Flicker = mode;
223        CAMHAL_LOGDB("Flicker %d", mParameters3A.Flicker);
224        if ( 0 <= mParameters3A.Flicker )
225            {
226            mPending3Asettings |= SetFlicker;
227            }
228        }
229
230#ifdef OMAP_ENHANCEMENT
231    str = params.get(TICameraParameters::KEY_ISO);
232    mode = getLUTvalue_HALtoOMX(str, IsoLUT);
233    CAMHAL_LOGVB("ISO mode arrived in HAL : %s", str);
234    if ( mFirstTimeInit || (  ( str != NULL ) && ( mParameters3A.ISO != mode )) )
235        {
236        mParameters3A.ISO = mode;
237        CAMHAL_LOGDB("ISO %d", mParameters3A.ISO);
238        if ( 0 <= mParameters3A.ISO )
239            {
240            mPending3Asettings |= SetISO;
241            }
242        }
243#endif
244
245    str = params.get(android::CameraParameters::KEY_FOCUS_MODE);
246    mode = getLUTvalue_HALtoOMX(str, FocusLUT);
247    if ( (mFirstTimeInit || ((str != NULL) && (mParameters3A.Focus != mode))))
248        {
249        mPending3Asettings |= SetFocus;
250
251        mParameters3A.Focus = mode;
252
253        // if focus mode is set to infinity...update focus distance immediately
254        if (mode == OMX_IMAGE_FocusControlAutoInfinity) {
255            updateFocusDistances(mParameters);
256        }
257
258        CAMHAL_LOGDB("Focus %x", mParameters3A.Focus);
259        }
260
261    str = params.get(android::CameraParameters::KEY_EXPOSURE_COMPENSATION);
262    varint = params.getInt(android::CameraParameters::KEY_EXPOSURE_COMPENSATION);
263    if ( mFirstTimeInit || (str && (mParameters3A.EVCompensation != varint))) {
264        CAMHAL_LOGDB("Setting EV Compensation to %d", varint);
265        mParameters3A.EVCompensation = varint;
266        mPending3Asettings |= SetEVCompensation;
267        }
268
269    str = params.get(android::CameraParameters::KEY_FLASH_MODE);
270    mode = getLUTvalue_HALtoOMX( str, FlashLUT);
271    if (  mFirstTimeInit || (( str != NULL ) && ( mParameters3A.FlashMode != mode )) )
272        {
273        if ( 0 <= mode )
274            {
275            mParameters3A.FlashMode = mode;
276            mPending3Asettings |= SetFlash;
277            }
278        else
279            {
280            mParameters3A.FlashMode = OMX_IMAGE_FlashControlAuto;
281            }
282        }
283
284    CAMHAL_LOGVB("Flash Setting %s", str);
285    CAMHAL_LOGVB("FlashMode %d", mParameters3A.FlashMode);
286
287    str = params.get(android::CameraParameters::KEY_EFFECT);
288    mode = getLUTvalue_HALtoOMX( str, EffLUT);
289    if (  mFirstTimeInit || (( str != NULL ) && ( mParameters3A.Effect != mode )) )
290        {
291        mParameters3A.Effect = mode;
292        CAMHAL_LOGDB("Effect %d", mParameters3A.Effect);
293        if ( 0 <= mParameters3A.Effect )
294            {
295            mPending3Asettings |= SetEffect;
296            }
297        }
298
299    str = params.get(android::CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED);
300    if ( (str != NULL) && (!strcmp(str, android::CameraParameters::TRUE)) )
301      {
302        OMX_BOOL lock = OMX_FALSE;
303        mUserSetExpLock = OMX_FALSE;
304        str = params.get(android::CameraParameters::KEY_AUTO_EXPOSURE_LOCK);
305        if (str && ((strcmp(str, android::CameraParameters::TRUE)) == 0))
306          {
307            CAMHAL_LOGVA("Locking Exposure");
308            lock = OMX_TRUE;
309            mUserSetExpLock = OMX_TRUE;
310          }
311        else
312          {
313            CAMHAL_LOGVA("UnLocking Exposure");
314          }
315
316        if (mParameters3A.ExposureLock != lock)
317          {
318            mParameters3A.ExposureLock = lock;
319            CAMHAL_LOGDB("ExposureLock %d", lock);
320            mPending3Asettings |= SetExpLock;
321          }
322      }
323
324    str = params.get(android::CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED);
325    if ( (str != NULL) && (!strcmp(str, android::CameraParameters::TRUE)) )
326      {
327        OMX_BOOL lock = OMX_FALSE;
328        mUserSetWbLock = OMX_FALSE;
329        str = params.get(android::CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK);
330        if (str && ((strcmp(str, android::CameraParameters::TRUE)) == 0))
331          {
332            CAMHAL_LOGVA("Locking WhiteBalance");
333            lock = OMX_TRUE;
334            mUserSetWbLock = OMX_TRUE;
335          }
336        else
337          {
338            CAMHAL_LOGVA("UnLocking WhiteBalance");
339          }
340        if (mParameters3A.WhiteBalanceLock != lock)
341          {
342            mParameters3A.WhiteBalanceLock = lock;
343            CAMHAL_LOGDB("WhiteBalanceLock %d", lock);
344            mPending3Asettings |= SetWBLock;
345          }
346      }
347
348    str = params.get(TICameraParameters::KEY_AUTO_FOCUS_LOCK);
349    if (str && (strcmp(str, android::CameraParameters::TRUE) == 0) && (mParameters3A.FocusLock != OMX_TRUE)) {
350        CAMHAL_LOGVA("Locking Focus");
351        mParameters3A.FocusLock = OMX_TRUE;
352        setFocusLock(mParameters3A);
353    } else if (str && (strcmp(str, android::CameraParameters::FALSE) == 0) && (mParameters3A.FocusLock != OMX_FALSE)) {
354        CAMHAL_LOGVA("UnLocking Focus");
355        mParameters3A.FocusLock = OMX_FALSE;
356        setFocusLock(mParameters3A);
357    }
358
359    str = params.get(android::CameraParameters::KEY_METERING_AREAS);
360    if ( (str != NULL) ) {
361        size_t MAX_METERING_AREAS;
362        android::Vector<android::sp<CameraArea> > tempAreas;
363
364        MAX_METERING_AREAS = atoi(params.get(android::CameraParameters::KEY_MAX_NUM_METERING_AREAS));
365
366        android::AutoMutex lock(mMeteringAreasLock);
367
368        ret = CameraArea::parseAreas(str, ( strlen(str) + 1 ), tempAreas);
369
370        CAMHAL_LOGVB("areAreasDifferent? = %d",
371                     CameraArea::areAreasDifferent(mMeteringAreas, tempAreas));
372
373        if ( (NO_ERROR == ret) && CameraArea::areAreasDifferent(mMeteringAreas, tempAreas) ) {
374            mMeteringAreas.clear();
375            mMeteringAreas = tempAreas;
376
377            if ( MAX_METERING_AREAS >= mMeteringAreas.size() ) {
378                CAMHAL_LOGDB("Setting Metering Areas %s",
379                        params.get(android::CameraParameters::KEY_METERING_AREAS));
380
381                mPending3Asettings |= SetMeteringAreas;
382            } else {
383                CAMHAL_LOGEB("Metering areas supported %d, metering areas set %d",
384                             MAX_METERING_AREAS, mMeteringAreas.size());
385                ret = -EINVAL;
386            }
387        }
388    }
389
390// TI extensions for enable/disable algos
391    declareParameter3ABool(params, TICameraParameters::KEY_ALGO_EXTERNAL_GAMMA,
392                       mParameters3A.AlgoExternalGamma, SetAlgoExternalGamma, "External Gamma");
393    declareParameter3ABool(params, TICameraParameters::KEY_ALGO_NSF1,
394                       mParameters3A.AlgoNSF1, SetAlgoNSF1, "NSF1");
395    declareParameter3ABool(params, TICameraParameters::KEY_ALGO_NSF2,
396                       mParameters3A.AlgoNSF2, SetAlgoNSF2, "NSF2");
397    declareParameter3ABool(params, TICameraParameters::KEY_ALGO_SHARPENING,
398                       mParameters3A.AlgoSharpening, SetAlgoSharpening, "Sharpening");
399    declareParameter3ABool(params, TICameraParameters::KEY_ALGO_THREELINCOLORMAP,
400                       mParameters3A.AlgoThreeLinColorMap, SetAlgoThreeLinColorMap, "ThreeLinColorMap");
401    declareParameter3ABool(params, TICameraParameters::KEY_ALGO_GIC, mParameters3A.AlgoGIC, SetAlgoGIC, "GIC");
402
403    // Gamma table
404    str = params.get(TICameraParameters::KEY_GAMMA_TABLE);
405    updateGammaTable(str);
406
407    LOG_FUNCTION_NAME_EXIT;
408
409    return ret;
410}
411
412void OMXCameraAdapter::updateGammaTable(const char* gamma)
413{
414    unsigned int plane = 0;
415    unsigned int i = 0;
416    bool gamma_changed = false;
417    const char *a = gamma;
418    OMX_TI_GAMMATABLE_ELEM_TYPE *elem[3] = { mParameters3A.mGammaTable.pR,
419                                             mParameters3A.mGammaTable.pG,
420                                             mParameters3A.mGammaTable.pB};
421
422    if (!gamma) return;
423
424    mPending3Asettings &= ~SetGammaTable;
425    memset(&mParameters3A.mGammaTable, 0, sizeof(mParameters3A.mGammaTable));
426    for (plane = 0; plane < 3; plane++) {
427        a = strchr(a, '(');
428        if (NULL != a) {
429            a++;
430            for (i = 0; i < OMX_TI_GAMMATABLE_SIZE; i++) {
431                char *b;
432                int newVal;
433                newVal = strtod(a, &b);
434                if (newVal != elem[plane][i].nOffset) {
435                    elem[plane][i].nOffset = newVal;
436                    gamma_changed = true;
437                }
438                a = strpbrk(b, ",:)");
439                if ((NULL != a) && (':' == *a)) {
440                    a++;
441                } else if ((NULL != a) && (',' == *a)){
442                    a++;
443                    break;
444                } else if ((NULL != a) && (')' == *a)){
445                    a++;
446                    break;
447                } else {
448                    CAMHAL_LOGE("Error while parsing values");
449                    gamma_changed = false;
450                    break;
451                }
452                newVal = strtod(a, &b);
453                if (newVal != elem[plane][i].nSlope) {
454                    elem[plane][i].nSlope = newVal;
455                    gamma_changed = true;
456                }
457                a = strpbrk(b, ",:)");
458                if ((NULL != a) && (',' == *a)) {
459                    a++;
460                } else if ((NULL != a) && (':' == *a)){
461                    a++;
462                    break;
463                } else if ((NULL != a) && (')' == *a)){
464                    a++;
465                    break;
466                } else {
467                    CAMHAL_LOGE("Error while parsing values");
468                    gamma_changed = false;
469                    break;
470                }
471            }
472            if ((OMX_TI_GAMMATABLE_SIZE - 1) != i) {
473                CAMHAL_LOGE("Error while parsing values (incorrect count %u)", i);
474                gamma_changed = false;
475                break;
476            }
477        } else {
478            CAMHAL_LOGE("Error while parsing planes (%u)", plane);
479            gamma_changed = false;
480            break;
481        }
482    }
483
484    if (gamma_changed) {
485        mPending3Asettings |= SetGammaTable;
486    }
487}
488
489void OMXCameraAdapter::declareParameter3ABool(const android::CameraParameters &params, const char *key,
490                                              OMX_BOOL &current_setting, E3ASettingsFlags pending,
491                                              const char *msg)
492{
493    OMX_BOOL val = OMX_TRUE;
494    const char *str = params.get(key);
495
496    if (str && ((strcmp(str, android::CameraParameters::FALSE)) == 0))
497        {
498        CAMHAL_LOGVB("Disabling %s", msg);
499        val = OMX_FALSE;
500        }
501    else
502        {
503        CAMHAL_LOGVB("Enabling %s", msg);
504        }
505    if (current_setting != val)
506        {
507        current_setting = val;
508        CAMHAL_LOGDB("%s %s", msg, current_setting ? "enabled" : "disabled");
509        mPending3Asettings |= pending;
510        }
511}
512
513int OMXCameraAdapter::getLUTvalue_HALtoOMX(const char * HalValue, LUTtype LUT)
514{
515    int LUTsize = LUT.size;
516    if( HalValue )
517        for(int i = 0; i < LUTsize; i++)
518            if( 0 == strcmp(LUT.Table[i].userDefinition, HalValue) )
519                return LUT.Table[i].omxDefinition;
520
521    return -ENOENT;
522}
523
524const char* OMXCameraAdapter::getLUTvalue_OMXtoHAL(int OMXValue, LUTtype LUT)
525{
526    int LUTsize = LUT.size;
527    for(int i = 0; i < LUTsize; i++)
528        if( LUT.Table[i].omxDefinition == OMXValue )
529            return LUT.Table[i].userDefinition;
530
531    return NULL;
532}
533
534int OMXCameraAdapter::getMultipleLUTvalue_OMXtoHAL(int OMXValue, LUTtype LUT, char * supported)
535{
536    int num = 0;
537    int remaining_size;
538    int LUTsize = LUT.size;
539    for(int i = 0; i < LUTsize; i++)
540        if( LUT.Table[i].omxDefinition == OMXValue )
541        {
542            num++;
543            if (supported[0] != '\0') {
544                strncat(supported, PARAM_SEP, 1);
545            }
546            remaining_size = ((((int)MAX_PROP_VALUE_LENGTH - 1 - (int)strlen(supported)) < 0) ? 0 : (MAX_PROP_VALUE_LENGTH - 1 - strlen(supported)));
547            strncat(supported, LUT.Table[i].userDefinition, remaining_size);
548        }
549
550    return num;
551}
552
553status_t OMXCameraAdapter::setExposureMode(Gen3A_settings& Gen3A)
554{
555    OMX_ERRORTYPE eError = OMX_ErrorNone;
556    OMX_CONFIG_EXPOSURECONTROLTYPE exp;
557
558    LOG_FUNCTION_NAME;
559
560    if ( OMX_StateInvalid == mComponentState )
561        {
562        CAMHAL_LOGEA("OMX component is in invalid state");
563        return NO_INIT;
564        }
565
566    OMX_INIT_STRUCT_PTR (&exp, OMX_CONFIG_EXPOSURECONTROLTYPE);
567    exp.nPortIndex = OMX_ALL;
568    exp.eExposureControl = (OMX_EXPOSURECONTROLTYPE)Gen3A.Exposure;
569
570    eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
571                            OMX_IndexConfigCommonExposure,
572                            &exp);
573    if ( OMX_ErrorNone != eError )
574        {
575        CAMHAL_LOGEB("Error while configuring exposure mode 0x%x", eError);
576        }
577    else
578        {
579        CAMHAL_LOGDA("Camera exposure mode configured successfully");
580        }
581
582    LOG_FUNCTION_NAME_EXIT;
583
584    return Utils::ErrorUtils::omxToAndroidError(eError);
585}
586
587static bool isFlashDisabled() {
588#if (PROPERTY_VALUE_MAX < 5)
589#error "PROPERTY_VALUE_MAX must be at least 5"
590#endif
591
592    // Ignore flash_off system property for user build.
593    char buildType[PROPERTY_VALUE_MAX];
594    if (property_get("ro.build.type", buildType, NULL) &&
595        !strcasecmp(buildType, "user")) {
596        return false;
597    }
598
599    char value[PROPERTY_VALUE_MAX];
600    if (property_get("camera.flash_off", value, NULL) &&
601        (!strcasecmp(value, android::CameraParameters::TRUE) || !strcasecmp(value, "1"))) {
602        CAMHAL_LOGW("flash is disabled for testing purpose");
603        return true;
604    }
605
606    return false;
607}
608
609status_t OMXCameraAdapter::setManualExposureVal(Gen3A_settings& Gen3A) {
610    OMX_ERRORTYPE eError = OMX_ErrorNone;
611    OMX_CONFIG_EXPOSUREVALUETYPE expVal;
612    OMX_TI_CONFIG_EXPOSUREVALUERIGHTTYPE expValRight;
613
614    LOG_FUNCTION_NAME;
615
616    if ( OMX_StateInvalid == mComponentState ) {
617        CAMHAL_LOGEA("OMX component is in invalid state");
618        return NO_INIT;
619    }
620
621    OMX_INIT_STRUCT_PTR (&expVal, OMX_CONFIG_EXPOSUREVALUETYPE);
622    OMX_INIT_STRUCT_PTR (&expValRight, OMX_TI_CONFIG_EXPOSUREVALUERIGHTTYPE);
623    expVal.nPortIndex = OMX_ALL;
624    expValRight.nPortIndex = OMX_ALL;
625
626    eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
627                   OMX_IndexConfigCommonExposureValue,
628                   &expVal);
629    if ( OMX_ErrorNone == eError ) {
630        eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
631                       (OMX_INDEXTYPE) OMX_TI_IndexConfigRightExposureValue,
632                       &expValRight);
633    }
634    if ( OMX_ErrorNone != eError ) {
635        CAMHAL_LOGEB("OMX_GetConfig error 0x%x (manual exposure values)", eError);
636        return Utils::ErrorUtils::omxToAndroidError(eError);
637    }
638
639    if ( Gen3A.Exposure != OMX_ExposureControlOff ) {
640        expVal.bAutoShutterSpeed = OMX_TRUE;
641        expVal.bAutoSensitivity = OMX_TRUE;
642    } else {
643        expVal.bAutoShutterSpeed = OMX_FALSE;
644        expVal.nShutterSpeedMsec = Gen3A.ManualExposure;
645        expValRight.nShutterSpeedMsec = Gen3A.ManualExposureRight;
646        if ( Gen3A.ManualGain <= 0 || Gen3A.ManualGainRight <= 0 ) {
647            expVal.bAutoSensitivity = OMX_TRUE;
648        } else {
649            expVal.bAutoSensitivity = OMX_FALSE;
650            expVal.nSensitivity = Gen3A.ManualGain;
651            expValRight.nSensitivity = Gen3A.ManualGainRight;
652        }
653    }
654
655    eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
656                            OMX_IndexConfigCommonExposureValue,
657                            &expVal);
658    if ( OMX_ErrorNone == eError ) {
659        eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
660                                (OMX_INDEXTYPE) OMX_TI_IndexConfigRightExposureValue,
661                                &expValRight);
662    }
663
664    if ( OMX_ErrorNone != eError ) {
665        CAMHAL_LOGEB("Error 0x%x while configuring manual exposure values", eError);
666    } else {
667        CAMHAL_LOGDA("Camera manual exposure values configured successfully");
668    }
669
670    LOG_FUNCTION_NAME_EXIT;
671
672    return Utils::ErrorUtils::omxToAndroidError(eError);
673}
674
675status_t OMXCameraAdapter::setFlashMode(Gen3A_settings& Gen3A)
676{
677    status_t ret = NO_ERROR;
678    OMX_ERRORTYPE eError = OMX_ErrorNone;
679    OMX_IMAGE_PARAM_FLASHCONTROLTYPE flash;
680    OMX_CONFIG_FOCUSASSISTTYPE focusAssist;
681
682    LOG_FUNCTION_NAME;
683
684    if ( OMX_StateInvalid == mComponentState )
685        {
686        CAMHAL_LOGEA("OMX component is in invalid state");
687        return NO_INIT;
688        }
689
690    OMX_INIT_STRUCT_PTR (&flash, OMX_IMAGE_PARAM_FLASHCONTROLTYPE);
691    flash.nPortIndex = OMX_ALL;
692
693    if (isFlashDisabled()) {
694        flash.eFlashControl = ( OMX_IMAGE_FLASHCONTROLTYPE ) OMX_IMAGE_FlashControlOff;
695    } else {
696        flash.eFlashControl = ( OMX_IMAGE_FLASHCONTROLTYPE ) Gen3A.FlashMode;
697    }
698
699    CAMHAL_LOGDB("Configuring flash mode 0x%x", flash.eFlashControl);
700    eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
701                            (OMX_INDEXTYPE) OMX_IndexConfigFlashControl,
702                            &flash);
703    if ( OMX_ErrorNone != eError )
704        {
705        CAMHAL_LOGEB("Error while configuring flash mode 0x%x", eError);
706        }
707    else
708        {
709        CAMHAL_LOGDA("Camera flash mode configured successfully");
710        }
711
712    if ( OMX_ErrorNone == eError )
713        {
714        OMX_INIT_STRUCT_PTR (&focusAssist, OMX_CONFIG_FOCUSASSISTTYPE);
715        focusAssist.nPortIndex = OMX_ALL;
716        if ( flash.eFlashControl == OMX_IMAGE_FlashControlOff )
717            {
718            focusAssist.bFocusAssist = OMX_FALSE;
719            }
720        else
721            {
722            focusAssist.bFocusAssist = OMX_TRUE;
723            }
724
725        CAMHAL_LOGDB("Configuring AF Assist mode 0x%x", focusAssist.bFocusAssist);
726        eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
727                                (OMX_INDEXTYPE) OMX_IndexConfigFocusAssist,
728                                &focusAssist);
729        if ( OMX_ErrorNone != eError )
730            {
731            CAMHAL_LOGEB("Error while configuring AF Assist mode 0x%x", eError);
732            }
733        else
734            {
735            CAMHAL_LOGDA("Camera AF Assist  mode configured successfully");
736            }
737        }
738
739    LOG_FUNCTION_NAME_EXIT;
740
741    return Utils::ErrorUtils::omxToAndroidError(eError);
742}
743
744status_t OMXCameraAdapter::getFlashMode(Gen3A_settings& Gen3A)
745{
746    status_t ret = NO_ERROR;
747    OMX_ERRORTYPE eError = OMX_ErrorNone;
748    OMX_IMAGE_PARAM_FLASHCONTROLTYPE flash;
749
750    LOG_FUNCTION_NAME;
751
752    if ( OMX_StateInvalid == mComponentState ) {
753        CAMHAL_LOGEA("OMX component is in invalid state");
754        return NO_INIT;
755    }
756
757    OMX_INIT_STRUCT_PTR (&flash, OMX_IMAGE_PARAM_FLASHCONTROLTYPE);
758    flash.nPortIndex = OMX_ALL;
759
760    eError =  OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
761                            (OMX_INDEXTYPE) OMX_IndexConfigFlashControl,
762                            &flash);
763
764    if ( OMX_ErrorNone != eError ) {
765        CAMHAL_LOGEB("Error while getting flash mode 0x%x", eError);
766    } else {
767        Gen3A.FlashMode = flash.eFlashControl;
768        CAMHAL_LOGDB("Gen3A.FlashMode 0x%x", Gen3A.FlashMode);
769    }
770
771    LOG_FUNCTION_NAME_EXIT;
772
773    return Utils::ErrorUtils::omxToAndroidError(eError);
774}
775
776status_t OMXCameraAdapter::setFocusMode(Gen3A_settings& Gen3A)
777{
778    status_t ret = NO_ERROR;
779    OMX_ERRORTYPE eError = OMX_ErrorNone;
780    OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE focus;
781    size_t top, left, width, height, weight;
782    OMX_CONFIG_BOOLEANTYPE bOMX;
783
784    LOG_FUNCTION_NAME;
785
786    BaseCameraAdapter::AdapterState state;
787    BaseCameraAdapter::getState(state);
788
789    if ( OMX_StateInvalid == mComponentState )
790        {
791        CAMHAL_LOGEA("OMX component is in invalid state");
792        return NO_INIT;
793        }
794
795
796    ///Face detection takes precedence over touch AF
797    if ( mFaceDetectionRunning )
798        {
799        //Disable region priority first
800        setAlgoPriority(REGION_PRIORITY, FOCUS_ALGO, false);
801
802        //Enable face algorithm priority for focus
803        setAlgoPriority(FACE_PRIORITY, FOCUS_ALGO , true);
804
805        //Do normal focus afterwards
806        ////FIXME: Check if the extended focus control is needed? this overrides caf
807        //focusControl.eFocusControl = ( OMX_IMAGE_FOCUSCONTROLTYPE ) OMX_IMAGE_FocusControlExtended;
808        }
809    else if ( (!mFocusAreas.isEmpty()) && (!mFocusAreas.itemAt(0)->isZeroArea()) )
810        {
811
812        //Disable face priority first
813        setAlgoPriority(FACE_PRIORITY, FOCUS_ALGO, false);
814
815        //Enable region algorithm priority
816        setAlgoPriority(REGION_PRIORITY, FOCUS_ALGO, true);
817
818
819        //Do normal focus afterwards
820        //FIXME: Check if the extended focus control is needed? this overrides caf
821        //focus.eFocusControl = ( OMX_IMAGE_FOCUSCONTROLTYPE ) OMX_IMAGE_FocusControlExtended;
822
823        }
824    else
825        {
826
827        //Disable both region and face priority
828        setAlgoPriority(REGION_PRIORITY, FOCUS_ALGO, false);
829
830        setAlgoPriority(FACE_PRIORITY, FOCUS_ALGO, false);
831
832        }
833
834    if ( NO_ERROR == ret && ((state & AF_ACTIVE) == 0) )
835        {
836        OMX_INIT_STRUCT_PTR (&bOMX, OMX_CONFIG_BOOLEANTYPE);
837
838        if ( Gen3A.Focus == OMX_IMAGE_FocusControlAutoInfinity)
839            {
840            // Don't lock at infinity, otherwise the AF cannot drive
841            // the lens at infinity position
842            if( set3ALock(mUserSetExpLock, mUserSetWbLock, OMX_FALSE) != NO_ERROR)
843                {
844                CAMHAL_LOGEA("Error Applying 3A locks");
845                } else {
846                CAMHAL_LOGDA("Focus locked. Applied focus locks successfully");
847                }
848            }
849        if ( Gen3A.Focus == OMX_IMAGE_FocusControlAuto ||
850             Gen3A.Focus == OMX_IMAGE_FocusControlAutoInfinity)
851            {
852            // Run focus scanning if switching to continuous infinity focus mode
853            bOMX.bEnabled = OMX_TRUE;
854            }
855        else
856            {
857            bOMX.bEnabled = OMX_FALSE;
858            }
859
860        eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
861                               (OMX_INDEXTYPE)OMX_TI_IndexConfigAutofocusEnable,
862                               &bOMX);
863
864        OMX_INIT_STRUCT_PTR (&focus, OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE);
865        focus.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
866        focus.eFocusControl = (OMX_IMAGE_FOCUSCONTROLTYPE)Gen3A.Focus;
867
868        CAMHAL_LOGDB("Configuring focus mode 0x%x", focus.eFocusControl);
869        eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp, OMX_IndexConfigFocusControl, &focus);
870        if ( OMX_ErrorNone != eError )
871            {
872            CAMHAL_LOGEB("Error while configuring focus mode 0x%x", eError);
873            }
874        else
875            {
876            CAMHAL_LOGDA("Camera focus mode configured successfully");
877            }
878        }
879
880    LOG_FUNCTION_NAME_EXIT;
881
882    return Utils::ErrorUtils::omxToAndroidError(eError);
883}
884
885status_t OMXCameraAdapter::getFocusMode(Gen3A_settings& Gen3A)
886{
887    status_t ret = NO_ERROR;
888    OMX_ERRORTYPE eError = OMX_ErrorNone;
889    OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE focus;
890    size_t top, left, width, height, weight;
891
892    LOG_FUNCTION_NAME;
893
894    if (OMX_StateInvalid == mComponentState) {
895        CAMHAL_LOGEA("OMX component is in invalid state");
896        return NO_INIT;
897    }
898
899    OMX_INIT_STRUCT_PTR (&focus, OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE);
900    focus.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
901    eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
902                           OMX_IndexConfigFocusControl, &focus);
903
904    if (OMX_ErrorNone != eError) {
905        CAMHAL_LOGEB("Error while configuring focus mode 0x%x", eError);
906    } else {
907        Gen3A.Focus = focus.eFocusControl;
908        CAMHAL_LOGDB("Gen3A.Focus 0x%x", Gen3A.Focus);
909    }
910
911    LOG_FUNCTION_NAME_EXIT;
912
913    return Utils::ErrorUtils::omxToAndroidError(eError);
914}
915
916status_t OMXCameraAdapter::setScene(Gen3A_settings& Gen3A)
917{
918    OMX_ERRORTYPE eError = OMX_ErrorNone;
919    OMX_CONFIG_SCENEMODETYPE scene;
920
921    LOG_FUNCTION_NAME;
922
923    if ( OMX_StateInvalid == mComponentState )
924        {
925        CAMHAL_LOGEA("OMX component is in invalid state");
926        return NO_INIT;
927        }
928
929    OMX_INIT_STRUCT_PTR (&scene, OMX_CONFIG_SCENEMODETYPE);
930    scene.nPortIndex = OMX_ALL;
931    scene.eSceneMode = ( OMX_SCENEMODETYPE ) Gen3A.SceneMode;
932
933    CAMHAL_LOGDB("Configuring scene mode 0x%x", scene.eSceneMode);
934    eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
935                            ( OMX_INDEXTYPE ) OMX_TI_IndexConfigSceneMode,
936                            &scene);
937
938    if (OMX_ErrorNone != eError) {
939        CAMHAL_LOGEB("Error while configuring scene mode 0x%x", eError);
940    } else {
941        CAMHAL_LOGDA("Camera scene configured successfully");
942        if (Gen3A.SceneMode != OMX_Manual) {
943            // Get preset scene mode feedback
944            getFocusMode(Gen3A);
945            getFlashMode(Gen3A);
946            getWBMode(Gen3A);
947
948            // TODO(XXX): Re-enable these for mainline
949            // getSharpness(Gen3A);
950            // getSaturation(Gen3A);
951            // getISO(Gen3A);
952        }
953    }
954
955    LOG_FUNCTION_NAME_EXIT;
956
957    return Utils::ErrorUtils::omxToAndroidError(eError);
958}
959
960status_t OMXCameraAdapter::setEVCompensation(Gen3A_settings& Gen3A)
961{
962    OMX_ERRORTYPE eError = OMX_ErrorNone;
963    OMX_CONFIG_EXPOSUREVALUETYPE expValues;
964
965    LOG_FUNCTION_NAME;
966
967    if ( OMX_StateInvalid == mComponentState )
968        {
969        CAMHAL_LOGEA("OMX component is in invalid state");
970        return NO_INIT;
971        }
972
973    OMX_INIT_STRUCT_PTR (&expValues, OMX_CONFIG_EXPOSUREVALUETYPE);
974    expValues.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
975
976    OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
977                   OMX_IndexConfigCommonExposureValue,
978                   &expValues);
979    CAMHAL_LOGDB("old EV Compensation for OMX = 0x%x", (int)expValues.xEVCompensation);
980    CAMHAL_LOGDB("EV Compensation for HAL = %d", Gen3A.EVCompensation);
981
982    expValues.xEVCompensation = ( Gen3A.EVCompensation * ( 1 << Q16_OFFSET ) )  / 10;
983    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
984                            OMX_IndexConfigCommonExposureValue,
985                            &expValues);
986    CAMHAL_LOGDB("new EV Compensation for OMX = 0x%x", (int)expValues.xEVCompensation);
987    if ( OMX_ErrorNone != eError )
988        {
989        CAMHAL_LOGEB("Error while configuring EV Compensation 0x%x error = 0x%x",
990                     ( unsigned int ) expValues.xEVCompensation,
991                     eError);
992        }
993    else
994        {
995        CAMHAL_LOGDB("EV Compensation 0x%x configured successfully",
996                     ( unsigned int ) expValues.xEVCompensation);
997        }
998
999    LOG_FUNCTION_NAME_EXIT;
1000
1001    return Utils::ErrorUtils::omxToAndroidError(eError);
1002}
1003
1004status_t OMXCameraAdapter::getEVCompensation(Gen3A_settings& Gen3A)
1005{
1006    OMX_ERRORTYPE eError = OMX_ErrorNone;
1007    OMX_CONFIG_EXPOSUREVALUETYPE expValues;
1008
1009    LOG_FUNCTION_NAME;
1010
1011    if ( OMX_StateInvalid == mComponentState ) {
1012        CAMHAL_LOGEA("OMX component is in invalid state");
1013        return NO_INIT;
1014    }
1015
1016    OMX_INIT_STRUCT_PTR (&expValues, OMX_CONFIG_EXPOSUREVALUETYPE);
1017    expValues.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1018
1019    OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
1020                  OMX_IndexConfigCommonExposureValue,
1021                  &expValues);
1022
1023    if ( OMX_ErrorNone != eError ) {
1024        CAMHAL_LOGEB("Error while getting EV Compensation error = 0x%x", eError);
1025    } else {
1026        Gen3A.EVCompensation = (10 * expValues.xEVCompensation) / (1 << Q16_OFFSET);
1027        CAMHAL_LOGDB("Gen3A.EVCompensation 0x%x", Gen3A.EVCompensation);
1028    }
1029
1030    LOG_FUNCTION_NAME_EXIT;
1031
1032    return Utils::ErrorUtils::omxToAndroidError(eError);
1033}
1034
1035status_t OMXCameraAdapter::setWBMode(Gen3A_settings& Gen3A)
1036{
1037    OMX_ERRORTYPE eError = OMX_ErrorNone;
1038    OMX_CONFIG_WHITEBALCONTROLTYPE wb;
1039
1040    LOG_FUNCTION_NAME;
1041
1042    if ( OMX_StateInvalid == mComponentState )
1043        {
1044        CAMHAL_LOGEA("OMX component is in invalid state");
1045        return NO_INIT;
1046        }
1047
1048    OMX_INIT_STRUCT_PTR (&wb, OMX_CONFIG_WHITEBALCONTROLTYPE);
1049    wb.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1050    wb.eWhiteBalControl = ( OMX_WHITEBALCONTROLTYPE ) Gen3A.WhiteBallance;
1051
1052    // disable face and region priorities
1053    setAlgoPriority(FACE_PRIORITY, WHITE_BALANCE_ALGO, false);
1054    setAlgoPriority(REGION_PRIORITY, WHITE_BALANCE_ALGO, false);
1055
1056    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
1057                         OMX_IndexConfigCommonWhiteBalance,
1058                         &wb);
1059    if ( OMX_ErrorNone != eError )
1060        {
1061        CAMHAL_LOGEB("Error while configuring Whitebalance mode 0x%x error = 0x%x",
1062                     ( unsigned int ) wb.eWhiteBalControl,
1063                     eError);
1064        }
1065    else
1066        {
1067        CAMHAL_LOGDB("Whitebalance mode 0x%x configured successfully",
1068                     ( unsigned int ) wb.eWhiteBalControl);
1069        }
1070
1071    LOG_FUNCTION_NAME_EXIT;
1072
1073    return eError;
1074}
1075
1076status_t OMXCameraAdapter::getWBMode(Gen3A_settings& Gen3A)
1077{
1078    OMX_ERRORTYPE eError = OMX_ErrorNone;
1079    OMX_CONFIG_WHITEBALCONTROLTYPE wb;
1080
1081    LOG_FUNCTION_NAME;
1082
1083    if ( OMX_StateInvalid == mComponentState ) {
1084        CAMHAL_LOGEA("OMX component is in invalid state");
1085        return NO_INIT;
1086    }
1087
1088    OMX_INIT_STRUCT_PTR (&wb, OMX_CONFIG_WHITEBALCONTROLTYPE);
1089    wb.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1090
1091    eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
1092                           OMX_IndexConfigCommonWhiteBalance,
1093                           &wb);
1094
1095    if (OMX_ErrorNone != eError) {
1096        CAMHAL_LOGEB("Error while getting Whitebalance mode error = 0x%x", eError);
1097    } else {
1098        Gen3A.WhiteBallance = wb.eWhiteBalControl;
1099        CAMHAL_LOGDB("Gen3A.WhiteBallance 0x%x", Gen3A.WhiteBallance);
1100    }
1101
1102    LOG_FUNCTION_NAME_EXIT;
1103
1104    return eError;
1105}
1106
1107status_t OMXCameraAdapter::setFlicker(Gen3A_settings& Gen3A)
1108{
1109    OMX_ERRORTYPE eError = OMX_ErrorNone;
1110    OMX_CONFIG_FLICKERCANCELTYPE flicker;
1111
1112    LOG_FUNCTION_NAME;
1113
1114    if ( OMX_StateInvalid == mComponentState )
1115        {
1116        CAMHAL_LOGEA("OMX component is in invalid state");
1117        return NO_INIT;
1118        }
1119
1120    OMX_INIT_STRUCT_PTR (&flicker, OMX_CONFIG_FLICKERCANCELTYPE);
1121    flicker.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1122    flicker.eFlickerCancel = (OMX_COMMONFLICKERCANCELTYPE)Gen3A.Flicker;
1123
1124    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
1125                            (OMX_INDEXTYPE)OMX_IndexConfigFlickerCancel,
1126                            &flicker );
1127    if ( OMX_ErrorNone != eError )
1128        {
1129        CAMHAL_LOGEB("Error while configuring Flicker mode 0x%x error = 0x%x",
1130                     ( unsigned int ) flicker.eFlickerCancel,
1131                     eError);
1132        }
1133    else
1134        {
1135        CAMHAL_LOGDB("Flicker mode 0x%x configured successfully",
1136                     ( unsigned int ) flicker.eFlickerCancel);
1137        }
1138
1139    LOG_FUNCTION_NAME_EXIT;
1140
1141    return Utils::ErrorUtils::omxToAndroidError(eError);
1142}
1143
1144status_t OMXCameraAdapter::setBrightness(Gen3A_settings& Gen3A)
1145{
1146    OMX_ERRORTYPE eError = OMX_ErrorNone;
1147    OMX_CONFIG_BRIGHTNESSTYPE brightness;
1148
1149    LOG_FUNCTION_NAME;
1150
1151    if ( OMX_StateInvalid == mComponentState )
1152        {
1153        CAMHAL_LOGEA("OMX component is in invalid state");
1154        return NO_INIT;
1155        }
1156
1157    OMX_INIT_STRUCT_PTR (&brightness, OMX_CONFIG_BRIGHTNESSTYPE);
1158    brightness.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1159    brightness.nBrightness = Gen3A.Brightness;
1160
1161    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
1162                         OMX_IndexConfigCommonBrightness,
1163                         &brightness);
1164    if ( OMX_ErrorNone != eError )
1165        {
1166        CAMHAL_LOGEB("Error while configuring Brightness 0x%x error = 0x%x",
1167                     ( unsigned int ) brightness.nBrightness,
1168                     eError);
1169        }
1170    else
1171        {
1172        CAMHAL_LOGDB("Brightness 0x%x configured successfully",
1173                     ( unsigned int ) brightness.nBrightness);
1174        }
1175
1176    LOG_FUNCTION_NAME_EXIT;
1177
1178    return Utils::ErrorUtils::omxToAndroidError(eError);
1179}
1180
1181status_t OMXCameraAdapter::setContrast(Gen3A_settings& Gen3A)
1182{
1183    OMX_ERRORTYPE eError = OMX_ErrorNone;
1184    OMX_CONFIG_CONTRASTTYPE contrast;
1185
1186    LOG_FUNCTION_NAME;
1187
1188    if ( OMX_StateInvalid == mComponentState )
1189        {
1190        CAMHAL_LOGEA("OMX component is in invalid state");
1191        return NO_INIT;
1192        }
1193
1194    OMX_INIT_STRUCT_PTR (&contrast, OMX_CONFIG_CONTRASTTYPE);
1195    contrast.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1196    contrast.nContrast = Gen3A.Contrast;
1197
1198    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
1199                         OMX_IndexConfigCommonContrast,
1200                         &contrast);
1201    if ( OMX_ErrorNone != eError )
1202        {
1203        CAMHAL_LOGEB("Error while configuring Contrast 0x%x error = 0x%x",
1204                     ( unsigned int ) contrast.nContrast,
1205                     eError);
1206        }
1207    else
1208        {
1209        CAMHAL_LOGDB("Contrast 0x%x configured successfully",
1210                     ( unsigned int ) contrast.nContrast);
1211        }
1212
1213    LOG_FUNCTION_NAME_EXIT;
1214
1215    return eError;
1216}
1217
1218status_t OMXCameraAdapter::setSharpness(Gen3A_settings& Gen3A)
1219{
1220    OMX_ERRORTYPE eError = OMX_ErrorNone;
1221    OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE procSharpness;
1222
1223    LOG_FUNCTION_NAME;
1224
1225    if ( OMX_StateInvalid == mComponentState )
1226        {
1227        CAMHAL_LOGEA("OMX component is in invalid state");
1228        return NO_INIT;
1229        }
1230
1231    OMX_INIT_STRUCT_PTR (&procSharpness, OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE);
1232    procSharpness.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1233    procSharpness.nLevel = Gen3A.Sharpness;
1234
1235    if( procSharpness.nLevel == 0 )
1236        {
1237        procSharpness.bAuto = OMX_TRUE;
1238        }
1239    else
1240        {
1241        procSharpness.bAuto = OMX_FALSE;
1242        }
1243
1244    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
1245                         (OMX_INDEXTYPE)OMX_IndexConfigSharpeningLevel,
1246                         &procSharpness);
1247    if ( OMX_ErrorNone != eError )
1248        {
1249        CAMHAL_LOGEB("Error while configuring Sharpness 0x%x error = 0x%x",
1250                     ( unsigned int ) procSharpness.nLevel,
1251                     eError);
1252        }
1253    else
1254        {
1255        CAMHAL_LOGDB("Sharpness 0x%x configured successfully",
1256                     ( unsigned int ) procSharpness.nLevel);
1257        }
1258
1259    LOG_FUNCTION_NAME_EXIT;
1260
1261    return Utils::ErrorUtils::omxToAndroidError(eError);
1262}
1263
1264status_t OMXCameraAdapter::getSharpness(Gen3A_settings& Gen3A)
1265{
1266    OMX_ERRORTYPE eError = OMX_ErrorNone;
1267    OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE procSharpness;
1268
1269    LOG_FUNCTION_NAME;
1270
1271    if (OMX_StateInvalid == mComponentState) {
1272        CAMHAL_LOGEA("OMX component is in invalid state");
1273        return NO_INIT;
1274    }
1275
1276    OMX_INIT_STRUCT_PTR (&procSharpness, OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE);
1277    procSharpness.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1278
1279    eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
1280                           (OMX_INDEXTYPE)OMX_IndexConfigSharpeningLevel,
1281                           &procSharpness);
1282
1283    if (OMX_ErrorNone != eError) {
1284        CAMHAL_LOGEB("Error while configuring Sharpness error = 0x%x", eError);
1285    } else {
1286        Gen3A.Sharpness = procSharpness.nLevel;
1287        CAMHAL_LOGDB("Gen3A.Sharpness 0x%x", Gen3A.Sharpness);
1288    }
1289
1290    LOG_FUNCTION_NAME_EXIT;
1291
1292    return Utils::ErrorUtils::omxToAndroidError(eError);
1293}
1294
1295status_t OMXCameraAdapter::setSaturation(Gen3A_settings& Gen3A)
1296{
1297    OMX_ERRORTYPE eError = OMX_ErrorNone;
1298    OMX_CONFIG_SATURATIONTYPE saturation;
1299
1300    LOG_FUNCTION_NAME;
1301
1302    if ( OMX_StateInvalid == mComponentState )
1303        {
1304        CAMHAL_LOGEA("OMX component is in invalid state");
1305        return NO_INIT;
1306        }
1307
1308    OMX_INIT_STRUCT_PTR (&saturation, OMX_CONFIG_SATURATIONTYPE);
1309    saturation.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1310    saturation.nSaturation = Gen3A.Saturation;
1311
1312    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
1313                         OMX_IndexConfigCommonSaturation,
1314                         &saturation);
1315    if ( OMX_ErrorNone != eError )
1316        {
1317        CAMHAL_LOGEB("Error while configuring Saturation 0x%x error = 0x%x",
1318                     ( unsigned int ) saturation.nSaturation,
1319                     eError);
1320        }
1321    else
1322        {
1323        CAMHAL_LOGDB("Saturation 0x%x configured successfully",
1324                     ( unsigned int ) saturation.nSaturation);
1325        }
1326
1327    LOG_FUNCTION_NAME_EXIT;
1328
1329    return Utils::ErrorUtils::omxToAndroidError(eError);
1330}
1331
1332status_t OMXCameraAdapter::getSaturation(Gen3A_settings& Gen3A)
1333{
1334    OMX_ERRORTYPE eError = OMX_ErrorNone;
1335    OMX_CONFIG_SATURATIONTYPE saturation;
1336
1337    LOG_FUNCTION_NAME;
1338
1339    if (OMX_StateInvalid == mComponentState) {
1340        CAMHAL_LOGEA("OMX component is in invalid state");
1341        return NO_INIT;
1342    }
1343
1344    OMX_INIT_STRUCT_PTR (&saturation, OMX_CONFIG_SATURATIONTYPE);
1345    saturation.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1346
1347    eError = OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
1348                         OMX_IndexConfigCommonSaturation,
1349                         &saturation);
1350
1351    if (OMX_ErrorNone != eError) {
1352        CAMHAL_LOGEB("Error while getting Saturation error = 0x%x", eError);
1353    } else {
1354        Gen3A.Saturation = saturation.nSaturation;
1355        CAMHAL_LOGDB("Gen3A.Saturation 0x%x", Gen3A.Saturation);
1356    }
1357
1358    LOG_FUNCTION_NAME_EXIT;
1359
1360    return Utils::ErrorUtils::omxToAndroidError(eError);
1361}
1362
1363status_t OMXCameraAdapter::setISO(Gen3A_settings& Gen3A)
1364{
1365    OMX_ERRORTYPE eError = OMX_ErrorNone;
1366    OMX_CONFIG_EXPOSUREVALUETYPE expValues;
1367    OMX_TI_CONFIG_EXPOSUREVALUERIGHTTYPE expValRight;
1368
1369    LOG_FUNCTION_NAME;
1370
1371    if ( OMX_StateInvalid == mComponentState )
1372        {
1373        CAMHAL_LOGEA("OMX component is in invalid state");
1374        return NO_INIT;
1375        }
1376
1377    // In case of manual exposure Gain is applied from setManualExposureVal
1378    if ( Gen3A.Exposure == OMX_ExposureControlOff ) {
1379        return NO_ERROR;
1380    }
1381
1382    OMX_INIT_STRUCT_PTR (&expValues, OMX_CONFIG_EXPOSUREVALUETYPE);
1383    OMX_INIT_STRUCT_PTR (&expValRight, OMX_TI_CONFIG_EXPOSUREVALUERIGHTTYPE);
1384    expValues.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1385    expValRight.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1386
1387    eError = OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
1388                    OMX_IndexConfigCommonExposureValue,
1389                    &expValues);
1390
1391    if ( OMX_ErrorNone == eError ) {
1392        eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
1393                        (OMX_INDEXTYPE) OMX_TI_IndexConfigRightExposureValue,
1394                        &expValRight);
1395    }
1396
1397    if ( OMX_ErrorNone != eError ) {
1398        CAMHAL_LOGEB("OMX_GetConfig error 0x%x (manual exposure values)", eError);
1399        return Utils::ErrorUtils::omxToAndroidError(eError);
1400    }
1401
1402    if( 0 == Gen3A.ISO ) {
1403        expValues.bAutoSensitivity = OMX_TRUE;
1404    } else {
1405        expValues.bAutoSensitivity = OMX_FALSE;
1406        expValues.nSensitivity = Gen3A.ISO;
1407        expValRight.nSensitivity = expValues.nSensitivity;
1408    }
1409
1410    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
1411                            OMX_IndexConfigCommonExposureValue,
1412                            &expValues);
1413
1414    if ( OMX_ErrorNone == eError ) {
1415        eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
1416                            (OMX_INDEXTYPE) OMX_TI_IndexConfigRightExposureValue,
1417                            &expValRight);
1418    }
1419    if ( OMX_ErrorNone != eError ) {
1420        CAMHAL_LOGEB("Error while configuring ISO 0x%x error = 0x%x",
1421                     ( unsigned int ) expValues.nSensitivity,
1422                     eError);
1423    } else {
1424        CAMHAL_LOGDB("ISO 0x%x configured successfully",
1425                     ( unsigned int ) expValues.nSensitivity);
1426    }
1427
1428    LOG_FUNCTION_NAME_EXIT;
1429
1430    return Utils::ErrorUtils::omxToAndroidError(eError);
1431}
1432
1433status_t OMXCameraAdapter::getISO(Gen3A_settings& Gen3A)
1434{
1435    OMX_ERRORTYPE eError = OMX_ErrorNone;
1436    OMX_CONFIG_EXPOSUREVALUETYPE expValues;
1437
1438    LOG_FUNCTION_NAME;
1439
1440    if (OMX_StateInvalid == mComponentState) {
1441        CAMHAL_LOGEA("OMX component is in invalid state");
1442        return NO_INIT;
1443    }
1444
1445    OMX_INIT_STRUCT_PTR (&expValues, OMX_CONFIG_EXPOSUREVALUETYPE);
1446    expValues.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1447
1448    OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
1449                   OMX_IndexConfigCommonExposureValue,
1450                   &expValues);
1451
1452    if (OMX_ErrorNone != eError) {
1453        CAMHAL_LOGEB("Error while getting ISO error = 0x%x", eError);
1454    } else {
1455        Gen3A.ISO = expValues.nSensitivity;
1456        CAMHAL_LOGDB("Gen3A.ISO %d", Gen3A.ISO);
1457    }
1458
1459    LOG_FUNCTION_NAME_EXIT;
1460
1461    return Utils::ErrorUtils::omxToAndroidError(eError);
1462}
1463
1464status_t OMXCameraAdapter::setEffect(Gen3A_settings& Gen3A)
1465{
1466    OMX_ERRORTYPE eError = OMX_ErrorNone;
1467    OMX_CONFIG_IMAGEFILTERTYPE effect;
1468
1469    LOG_FUNCTION_NAME;
1470
1471    if ( OMX_StateInvalid == mComponentState )
1472        {
1473        CAMHAL_LOGEA("OMX component is in invalid state");
1474        return NO_INIT;
1475        }
1476
1477    OMX_INIT_STRUCT_PTR (&effect, OMX_CONFIG_IMAGEFILTERTYPE);
1478    effect.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1479    effect.eImageFilter = (OMX_IMAGEFILTERTYPE ) Gen3A.Effect;
1480
1481    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
1482                         OMX_IndexConfigCommonImageFilter,
1483                         &effect);
1484    if ( OMX_ErrorNone != eError )
1485        {
1486        CAMHAL_LOGEB("Error while configuring Effect 0x%x error = 0x%x",
1487                     ( unsigned int )  effect.eImageFilter,
1488                     eError);
1489        }
1490    else
1491        {
1492        CAMHAL_LOGDB("Effect 0x%x configured successfully",
1493                     ( unsigned int )  effect.eImageFilter);
1494        }
1495
1496    LOG_FUNCTION_NAME_EXIT;
1497
1498    return Utils::ErrorUtils::omxToAndroidError(eError);
1499}
1500
1501status_t OMXCameraAdapter::setWhiteBalanceLock(Gen3A_settings& Gen3A)
1502{
1503  OMX_ERRORTYPE eError = OMX_ErrorNone;
1504  OMX_IMAGE_CONFIG_LOCKTYPE lock;
1505
1506  LOG_FUNCTION_NAME
1507
1508  if ( OMX_StateInvalid == mComponentState )
1509    {
1510      CAMHAL_LOGEA("OMX component is in invalid state");
1511      return NO_INIT;
1512    }
1513
1514  OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
1515  lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1516  lock.bLock = Gen3A.WhiteBalanceLock;
1517  eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
1518                          (OMX_INDEXTYPE)OMX_IndexConfigImageWhiteBalanceLock,
1519                          &lock);
1520  if ( OMX_ErrorNone != eError )
1521    {
1522      CAMHAL_LOGEB("Error while configuring WhiteBalance Lock error = 0x%x", eError);
1523    }
1524  else
1525    {
1526      CAMHAL_LOGDB("WhiteBalance Lock configured successfully %d ", lock.bLock);
1527    }
1528  LOG_FUNCTION_NAME_EXIT
1529
1530  return Utils::ErrorUtils::omxToAndroidError(eError);
1531}
1532
1533status_t OMXCameraAdapter::setExposureLock(Gen3A_settings& Gen3A)
1534{
1535  OMX_ERRORTYPE eError = OMX_ErrorNone;
1536  OMX_IMAGE_CONFIG_LOCKTYPE lock;
1537
1538  LOG_FUNCTION_NAME
1539
1540  if ( OMX_StateInvalid == mComponentState )
1541    {
1542      CAMHAL_LOGEA("OMX component is in invalid state");
1543      return NO_INIT;
1544    }
1545
1546  OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
1547  lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1548  lock.bLock = Gen3A.ExposureLock;
1549  eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
1550                          (OMX_INDEXTYPE)OMX_IndexConfigImageExposureLock,
1551                          &lock);
1552  if ( OMX_ErrorNone != eError )
1553    {
1554      CAMHAL_LOGEB("Error while configuring Exposure Lock error = 0x%x", eError);
1555    }
1556  else
1557    {
1558      CAMHAL_LOGDB("Exposure Lock configured successfully %d ", lock.bLock);
1559    }
1560  LOG_FUNCTION_NAME_EXIT
1561
1562    return Utils::ErrorUtils::omxToAndroidError(eError);
1563}
1564
1565status_t OMXCameraAdapter::setFocusLock(Gen3A_settings& Gen3A)
1566{
1567    OMX_ERRORTYPE eError = OMX_ErrorNone;
1568    OMX_IMAGE_CONFIG_LOCKTYPE lock;
1569
1570    LOG_FUNCTION_NAME
1571
1572    if ( OMX_StateInvalid == mComponentState ) {
1573        CAMHAL_LOGEA("OMX component is in invalid state");
1574        return NO_INIT;
1575    }
1576
1577    OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
1578    lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1579
1580    lock.bLock = Gen3A.FocusLock;
1581    eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
1582                           (OMX_INDEXTYPE)OMX_IndexConfigImageFocusLock,
1583                           &lock);
1584
1585    if ( OMX_ErrorNone != eError ) {
1586        CAMHAL_LOGEB("Error while configuring Focus Lock error = 0x%x", eError);
1587    } else {
1588        CAMHAL_LOGDB("Focus Lock configured successfully %d ", lock.bLock);
1589    }
1590
1591    LOG_FUNCTION_NAME_EXIT
1592
1593    return Utils::ErrorUtils::omxToAndroidError(eError);
1594}
1595
1596status_t OMXCameraAdapter::set3ALock(OMX_BOOL toggleExp, OMX_BOOL toggleWb, OMX_BOOL toggleFocus)
1597{
1598    OMX_ERRORTYPE eError = OMX_ErrorNone;
1599    OMX_IMAGE_CONFIG_LOCKTYPE lock;
1600
1601    LOG_FUNCTION_NAME
1602
1603    if ( OMX_StateInvalid == mComponentState )
1604    {
1605      CAMHAL_LOGEA("OMX component is in invalid state");
1606      return NO_INIT;
1607    }
1608
1609    OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
1610    lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1611
1612    mParameters3A.ExposureLock = toggleExp;
1613    mParameters3A.FocusLock = toggleFocus;
1614    mParameters3A.WhiteBalanceLock = toggleWb;
1615
1616    eError = OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
1617                            (OMX_INDEXTYPE)OMX_IndexConfigImageExposureLock,
1618                            &lock);
1619
1620    if ( OMX_ErrorNone != eError )
1621    {
1622        CAMHAL_LOGEB("Error GetConfig Exposure Lock error = 0x%x", eError);
1623        goto EXIT;
1624    }
1625    else
1626    {
1627        CAMHAL_LOGDA("Exposure Lock GetConfig successfull");
1628
1629        /* Apply locks only when not applied already */
1630        if ( lock.bLock  != toggleExp )
1631        {
1632            setExposureLock(mParameters3A);
1633        }
1634
1635    }
1636
1637    OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
1638    lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1639    eError = OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
1640                            (OMX_INDEXTYPE)OMX_IndexConfigImageFocusLock,
1641                            &lock);
1642
1643    if ( OMX_ErrorNone != eError )
1644    {
1645        CAMHAL_LOGEB("Error GetConfig Focus Lock error = 0x%x", eError);
1646        goto EXIT;
1647    }
1648    else
1649    {
1650        CAMHAL_LOGDB("Focus Lock GetConfig successfull bLock(%d)", lock.bLock);
1651
1652        /* Apply locks only when not applied already */
1653        if ( lock.bLock  != toggleFocus )
1654        {
1655            setFocusLock(mParameters3A);
1656        }
1657    }
1658
1659    OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
1660    lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1661    eError = OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
1662                            (OMX_INDEXTYPE)OMX_IndexConfigImageWhiteBalanceLock,
1663                            &lock);
1664
1665    if ( OMX_ErrorNone != eError )
1666    {
1667        CAMHAL_LOGEB("Error GetConfig WhiteBalance Lock error = 0x%x", eError);
1668        goto EXIT;
1669    }
1670    else
1671    {
1672        CAMHAL_LOGDA("WhiteBalance Lock GetConfig successfull");
1673
1674        /* Apply locks only when not applied already */
1675        if ( lock.bLock != toggleWb )
1676        {
1677            setWhiteBalanceLock(mParameters3A);
1678        }
1679
1680    }
1681 EXIT:
1682    return Utils::ErrorUtils::omxToAndroidError(eError);
1683}
1684
1685status_t OMXCameraAdapter::setMeteringAreas(Gen3A_settings& Gen3A)
1686{
1687  status_t ret = NO_ERROR;
1688  OMX_ERRORTYPE eError = OMX_ErrorNone;
1689
1690  CameraBuffer *bufferlist;
1691  OMX_ALGOAREASTYPE *meteringAreas;
1692  OMX_TI_CONFIG_SHAREDBUFFER sharedBuffer;
1693  int areasSize = 0;
1694
1695  LOG_FUNCTION_NAME
1696
1697  android::AutoMutex lock(mMeteringAreasLock);
1698
1699  if ( OMX_StateInvalid == mComponentState )
1700    {
1701      CAMHAL_LOGEA("OMX component is in invalid state");
1702      return NO_INIT;
1703    }
1704
1705  areasSize = ((sizeof(OMX_ALGOAREASTYPE)+4095)/4096)*4096;
1706  bufferlist = mMemMgr.allocateBufferList(0, 0, NULL, areasSize, 1);
1707  meteringAreas = (OMX_ALGOAREASTYPE *)bufferlist[0].opaque;
1708
1709  OMXCameraPortParameters * mPreviewData = NULL;
1710  mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
1711
1712  if (!meteringAreas)
1713      {
1714      CAMHAL_LOGEB("Error allocating buffer for metering areas %d", eError);
1715      return -ENOMEM;
1716      }
1717
1718  OMX_INIT_STRUCT_PTR (meteringAreas, OMX_ALGOAREASTYPE);
1719
1720  meteringAreas->nPortIndex = OMX_ALL;
1721  meteringAreas->nNumAreas = mMeteringAreas.size();
1722  meteringAreas->nAlgoAreaPurpose = OMX_AlgoAreaExposure;
1723
1724  for ( unsigned int n = 0; n < mMeteringAreas.size(); n++)
1725      {
1726        int widthDivisor = 1;
1727        int heightDivisor = 1;
1728
1729        if (mPreviewData->mFrameLayoutType == OMX_TI_StereoFrameLayoutTopBottom) {
1730            heightDivisor = 2;
1731        }
1732        if (mPreviewData->mFrameLayoutType == OMX_TI_StereoFrameLayoutLeftRight) {
1733            widthDivisor = 2;
1734        }
1735
1736      // transform the coordinates to 3A-type coordinates
1737      mMeteringAreas.itemAt(n)->transfrom((size_t)mPreviewData->mWidth/widthDivisor,
1738                                      (size_t)mPreviewData->mHeight/heightDivisor,
1739                                      (size_t&)meteringAreas->tAlgoAreas[n].nTop,
1740                                      (size_t&)meteringAreas->tAlgoAreas[n].nLeft,
1741                                      (size_t&)meteringAreas->tAlgoAreas[n].nWidth,
1742                                      (size_t&)meteringAreas->tAlgoAreas[n].nHeight);
1743
1744      meteringAreas->tAlgoAreas[n].nLeft =
1745              ( meteringAreas->tAlgoAreas[n].nLeft * METERING_AREAS_RANGE ) / mPreviewData->mWidth;
1746      meteringAreas->tAlgoAreas[n].nTop =
1747              ( meteringAreas->tAlgoAreas[n].nTop* METERING_AREAS_RANGE ) / mPreviewData->mHeight;
1748      meteringAreas->tAlgoAreas[n].nWidth =
1749              ( meteringAreas->tAlgoAreas[n].nWidth * METERING_AREAS_RANGE ) / mPreviewData->mWidth;
1750      meteringAreas->tAlgoAreas[n].nHeight =
1751              ( meteringAreas->tAlgoAreas[n].nHeight * METERING_AREAS_RANGE ) / mPreviewData->mHeight;
1752
1753      meteringAreas->tAlgoAreas[n].nPriority = mMeteringAreas.itemAt(n)->getWeight();
1754
1755      CAMHAL_LOGDB("Metering area %d : top = %d left = %d width = %d height = %d prio = %d",
1756              n, (int)meteringAreas->tAlgoAreas[n].nTop, (int)meteringAreas->tAlgoAreas[n].nLeft,
1757              (int)meteringAreas->tAlgoAreas[n].nWidth, (int)meteringAreas->tAlgoAreas[n].nHeight,
1758              (int)meteringAreas->tAlgoAreas[n].nPriority);
1759
1760      }
1761
1762  OMX_INIT_STRUCT_PTR (&sharedBuffer, OMX_TI_CONFIG_SHAREDBUFFER);
1763
1764  sharedBuffer.nPortIndex = OMX_ALL;
1765  sharedBuffer.nSharedBuffSize = areasSize;
1766  sharedBuffer.pSharedBuff = (OMX_U8 *)camera_buffer_get_omx_ptr (&bufferlist[0]);
1767
1768  if ( NULL == sharedBuffer.pSharedBuff )
1769      {
1770      CAMHAL_LOGEA("No resources to allocate OMX shared buffer");
1771      ret = -ENOMEM;
1772      goto EXIT;
1773      }
1774
1775      eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
1776                                (OMX_INDEXTYPE) OMX_TI_IndexConfigAlgoAreas, &sharedBuffer);
1777
1778  if ( OMX_ErrorNone != eError )
1779      {
1780      CAMHAL_LOGEB("Error while setting Focus Areas configuration 0x%x", eError);
1781      ret = -EINVAL;
1782      }
1783  else
1784      {
1785      CAMHAL_LOGDA("Metering Areas SetConfig successfull.");
1786      }
1787
1788 EXIT:
1789  if (NULL != bufferlist)
1790      {
1791      mMemMgr.freeBufferList(bufferlist);
1792      }
1793
1794  return ret;
1795}
1796
1797//TI extensions for enable/disable algos
1798status_t OMXCameraAdapter::setParameter3ABoolInvert(const OMX_INDEXTYPE omx_idx,
1799                                                    const OMX_BOOL data, const char *msg)
1800{
1801    OMX_BOOL inv_data;
1802
1803    if (OMX_TRUE == data)
1804        {
1805        inv_data = OMX_FALSE;
1806        }
1807    else if (OMX_FALSE == data)
1808        {
1809        inv_data = OMX_TRUE;
1810        }
1811    else
1812        {
1813        return BAD_VALUE;
1814        }
1815    return setParameter3ABool(omx_idx, inv_data, msg);
1816}
1817
1818status_t OMXCameraAdapter::setParameter3ABool(const OMX_INDEXTYPE omx_idx,
1819                                              const OMX_BOOL data, const char *msg)
1820{
1821  OMX_ERRORTYPE eError = OMX_ErrorNone;
1822  OMX_CONFIG_BOOLEANTYPE cfgdata;
1823
1824  LOG_FUNCTION_NAME
1825
1826  if ( OMX_StateInvalid == mComponentState )
1827    {
1828      CAMHAL_LOGEA("OMX component is in invalid state");
1829      return NO_INIT;
1830    }
1831
1832  OMX_INIT_STRUCT_PTR (&cfgdata, OMX_CONFIG_BOOLEANTYPE);
1833  cfgdata.bEnabled = data;
1834  eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
1835                          omx_idx,
1836                          &cfgdata);
1837  if ( OMX_ErrorNone != eError )
1838    {
1839      CAMHAL_LOGEB("Error while configuring %s error = 0x%x", msg, eError);
1840    }
1841  else
1842    {
1843      CAMHAL_LOGDB("%s configured successfully %d ", msg, cfgdata.bEnabled);
1844    }
1845
1846  LOG_FUNCTION_NAME_EXIT
1847
1848  return Utils::ErrorUtils::omxToAndroidError(eError);
1849}
1850
1851status_t OMXCameraAdapter::setAlgoExternalGamma(Gen3A_settings& Gen3A)
1852{
1853    return setParameter3ABool((OMX_INDEXTYPE) OMX_TI_IndexConfigExternalGamma, Gen3A.AlgoExternalGamma, "External Gamma");
1854}
1855
1856status_t OMXCameraAdapter::setAlgoNSF1(Gen3A_settings& Gen3A)
1857{
1858    return setParameter3ABoolInvert((OMX_INDEXTYPE) OMX_TI_IndexConfigDisableNSF1, Gen3A.AlgoNSF1, "NSF1");
1859}
1860
1861status_t OMXCameraAdapter::setAlgoNSF2(Gen3A_settings& Gen3A)
1862{
1863    return setParameter3ABoolInvert((OMX_INDEXTYPE) OMX_TI_IndexConfigDisableNSF2, Gen3A.AlgoNSF2, "NSF2");
1864}
1865
1866status_t OMXCameraAdapter::setAlgoSharpening(Gen3A_settings& Gen3A)
1867{
1868    return setParameter3ABoolInvert((OMX_INDEXTYPE) OMX_TI_IndexConfigDisableSharpening, Gen3A.AlgoSharpening, "Sharpening");
1869}
1870
1871status_t OMXCameraAdapter::setAlgoThreeLinColorMap(Gen3A_settings& Gen3A)
1872{
1873    return setParameter3ABoolInvert((OMX_INDEXTYPE) OMX_TI_IndexConfigDisableThreeLinColorMap, Gen3A.AlgoThreeLinColorMap, "Color Conversion");
1874}
1875
1876status_t OMXCameraAdapter::setAlgoGIC(Gen3A_settings& Gen3A)
1877{
1878    return setParameter3ABoolInvert((OMX_INDEXTYPE) OMX_TI_IndexConfigDisableGIC, Gen3A.AlgoGIC, "Green Inballance Correction");
1879}
1880
1881status_t OMXCameraAdapter::setGammaTable(Gen3A_settings& Gen3A)
1882{
1883    status_t ret = NO_ERROR;
1884    OMX_ERRORTYPE eError = OMX_ErrorNone;
1885    CameraBuffer *bufferlist = NULL;
1886    OMX_TI_CONFIG_GAMMATABLE_TYPE *gammaTable = NULL;
1887    OMX_TI_CONFIG_SHAREDBUFFER sharedBuffer;
1888    int tblSize = 0;
1889
1890    LOG_FUNCTION_NAME;
1891
1892    if ( OMX_StateInvalid == mComponentState ) {
1893        CAMHAL_LOGEA("OMX component is in invalid state");
1894        ret = NO_INIT;
1895        goto EXIT;
1896    }
1897
1898    tblSize = ((sizeof(OMX_TI_CONFIG_GAMMATABLE_TYPE)+4095)/4096)*4096;
1899    bufferlist = mMemMgr.allocateBufferList(0, 0, NULL, tblSize, 1);
1900    if (NULL == bufferlist) {
1901        CAMHAL_LOGEB("Error allocating buffer for gamma table");
1902        ret =  NO_MEMORY;
1903        goto EXIT;
1904    }
1905    gammaTable = (OMX_TI_CONFIG_GAMMATABLE_TYPE *)bufferlist[0].mapped;
1906    if (NULL == gammaTable) {
1907        CAMHAL_LOGEB("Error allocating buffer for gamma table (wrong data pointer)");
1908        ret =  NO_MEMORY;
1909        goto EXIT;
1910    }
1911
1912    memcpy(gammaTable, &mParameters3A.mGammaTable, sizeof(OMX_TI_CONFIG_GAMMATABLE_TYPE));
1913
1914#ifdef CAMERAHAL_DEBUG
1915    {
1916        android::String8 DmpR;
1917        android::String8 DmpG;
1918        android::String8 DmpB;
1919        for (unsigned int i=0; i<OMX_TI_GAMMATABLE_SIZE;i++) {
1920            DmpR.appendFormat(" %d:%d;", (int)gammaTable->pR[i].nOffset, (int)(int)gammaTable->pR[i].nSlope);
1921            DmpG.appendFormat(" %d:%d;", (int)gammaTable->pG[i].nOffset, (int)(int)gammaTable->pG[i].nSlope);
1922            DmpB.appendFormat(" %d:%d;", (int)gammaTable->pB[i].nOffset, (int)(int)gammaTable->pB[i].nSlope);
1923        }
1924        CAMHAL_LOGE("Gamma table R:%s", DmpR.string());
1925        CAMHAL_LOGE("Gamma table G:%s", DmpG.string());
1926        CAMHAL_LOGE("Gamma table B:%s", DmpB.string());
1927    }
1928#endif
1929
1930    OMX_INIT_STRUCT_PTR (&sharedBuffer, OMX_TI_CONFIG_SHAREDBUFFER);
1931    sharedBuffer.nPortIndex = OMX_ALL;
1932    sharedBuffer.nSharedBuffSize = sizeof(OMX_TI_CONFIG_GAMMATABLE_TYPE);
1933    sharedBuffer.pSharedBuff = (OMX_U8 *)camera_buffer_get_omx_ptr (&bufferlist[0]);
1934    if ( NULL == sharedBuffer.pSharedBuff ) {
1935        CAMHAL_LOGEA("No resources to allocate OMX shared buffer");
1936        ret = NO_MEMORY;
1937        goto EXIT;
1938    }
1939
1940    eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
1941                            (OMX_INDEXTYPE) OMX_TI_IndexConfigGammaTable, &sharedBuffer);
1942    if ( OMX_ErrorNone != eError ) {
1943        CAMHAL_LOGEB("Error while setting Gamma Table configuration 0x%x", eError);
1944        ret = BAD_VALUE;
1945        goto EXIT;
1946    } else {
1947        CAMHAL_LOGDA("Gamma Table SetConfig successfull.");
1948    }
1949
1950EXIT:
1951
1952    if (NULL != bufferlist) {
1953        mMemMgr.freeBufferList(bufferlist);
1954    }
1955
1956    LOG_FUNCTION_NAME_EXIT;
1957
1958    return ret;
1959}
1960
1961status_t OMXCameraAdapter::apply3Asettings( Gen3A_settings& Gen3A )
1962{
1963    status_t ret = NO_ERROR;
1964    unsigned int currSett; // 32 bit
1965    int portIndex;
1966
1967    LOG_FUNCTION_NAME;
1968
1969    android::AutoMutex lock(m3ASettingsUpdateLock);
1970
1971    /*
1972     * Scenes have a priority during the process
1973     * of applying 3A related parameters.
1974     * They can override pretty much all other 3A
1975     * settings and similarly get overridden when
1976     * for instance the focus mode gets switched.
1977     * There is only one exception to this rule,
1978     * the manual a.k.a. auto scene.
1979     */
1980    if (SetSceneMode & mPending3Asettings) {
1981        mPending3Asettings &= ~SetSceneMode;
1982        ret |= setScene(Gen3A);
1983        // re-apply EV compensation after setting scene mode since it probably reset it
1984        if(Gen3A.EVCompensation) {
1985            setEVCompensation(Gen3A);
1986        }
1987        return ret;
1988    } else if (OMX_Manual != Gen3A.SceneMode) {
1989        // only certain settings are allowed when scene mode is set
1990        mPending3Asettings &= (SetEVCompensation | SetFocus | SetWBLock |
1991                               SetExpLock | SetWhiteBallance | SetFlash);
1992        if ( mPending3Asettings == 0 ) return NO_ERROR;
1993    }
1994
1995    for( currSett = 1; currSett < E3aSettingMax; currSett <<= 1)
1996        {
1997        if( currSett & mPending3Asettings )
1998            {
1999            switch( currSett )
2000                {
2001                case SetEVCompensation:
2002                    {
2003                    ret |= setEVCompensation(Gen3A);
2004                    break;
2005                    }
2006
2007                case SetWhiteBallance:
2008                    {
2009                    ret |= setWBMode(Gen3A);
2010                    break;
2011                    }
2012
2013                case SetFlicker:
2014                    {
2015                    ret |= setFlicker(Gen3A);
2016                    break;
2017                    }
2018
2019                case SetBrightness:
2020                    {
2021                    ret |= setBrightness(Gen3A);
2022                    break;
2023                    }
2024
2025                case SetContrast:
2026                    {
2027                    ret |= setContrast(Gen3A);
2028                    break;
2029                    }
2030
2031                case SetSharpness:
2032                    {
2033                    ret |= setSharpness(Gen3A);
2034                    break;
2035                    }
2036
2037                case SetSaturation:
2038                    {
2039                    ret |= setSaturation(Gen3A);
2040                    break;
2041                    }
2042
2043                case SetISO:
2044                    {
2045                    ret |= setISO(Gen3A);
2046                    break;
2047                    }
2048
2049                case SetEffect:
2050                    {
2051                    ret |= setEffect(Gen3A);
2052                    break;
2053                    }
2054
2055                case SetFocus:
2056                    {
2057                    ret |= setFocusMode(Gen3A);
2058                    break;
2059                    }
2060
2061                case SetExpMode:
2062                    {
2063                    ret |= setExposureMode(Gen3A);
2064                    break;
2065                    }
2066
2067                case SetManualExposure: {
2068                    ret |= setManualExposureVal(Gen3A);
2069                    break;
2070                }
2071
2072                case SetFlash:
2073                    {
2074                    ret |= setFlashMode(Gen3A);
2075                    break;
2076                    }
2077
2078                case SetExpLock:
2079                  {
2080                    ret |= setExposureLock(Gen3A);
2081                    break;
2082                  }
2083
2084                case SetWBLock:
2085                  {
2086                    ret |= setWhiteBalanceLock(Gen3A);
2087                    break;
2088                  }
2089                case SetMeteringAreas:
2090                  {
2091                    ret |= setMeteringAreas(Gen3A);
2092                  }
2093                  break;
2094
2095                //TI extensions for enable/disable algos
2096                case SetAlgoExternalGamma:
2097                  {
2098                    ret |= setAlgoExternalGamma(Gen3A);
2099                  }
2100                  break;
2101
2102                case SetAlgoNSF1:
2103                  {
2104                    ret |= setAlgoNSF1(Gen3A);
2105                  }
2106                  break;
2107
2108                case SetAlgoNSF2:
2109                  {
2110                    ret |= setAlgoNSF2(Gen3A);
2111                  }
2112                  break;
2113
2114                case SetAlgoSharpening:
2115                  {
2116                    ret |= setAlgoSharpening(Gen3A);
2117                  }
2118                  break;
2119
2120                case SetAlgoThreeLinColorMap:
2121                  {
2122                    ret |= setAlgoThreeLinColorMap(Gen3A);
2123                  }
2124                  break;
2125
2126                case SetAlgoGIC:
2127                  {
2128                    ret |= setAlgoGIC(Gen3A);
2129                  }
2130                  break;
2131
2132                case SetGammaTable:
2133                  {
2134                    ret |= setGammaTable(Gen3A);
2135                  }
2136                  break;
2137
2138                default:
2139                    CAMHAL_LOGEB("this setting (0x%x) is still not supported in CameraAdapter ",
2140                                 currSett);
2141                    break;
2142                }
2143                mPending3Asettings &= ~currSett;
2144            }
2145        }
2146
2147        LOG_FUNCTION_NAME_EXIT;
2148
2149        return ret;
2150}
2151
2152} // namespace Camera
2153} // namespace Ti
2154