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#undef LOG_TAG
25
26#define LOG_TAG "CameraHAL"
27
28#include "CameraHal.h"
29#include "OMXCameraAdapter.h"
30#include "ErrorUtils.h"
31
32#include <cutils/properties.h>
33
34#undef TRUE
35#undef FALSE
36#define TRUE "true"
37#define FALSE "false"
38
39#define METERING_AREAS_RANGE 0xFF
40
41namespace android {
42const SceneModesEntry* OMXCameraAdapter::getSceneModeEntry(const char* name,
43                                                                  OMX_SCENEMODETYPE scene) {
44    const SceneModesEntry* cameraLUT = NULL;
45    const SceneModesEntry* entry = NULL;
46    unsigned int numEntries = 0;
47
48    // 1. Find camera's scene mode LUT
49    for (unsigned int i = 0; i < ARRAY_SIZE(CameraToSensorModesLUT); i++) {
50        if (strcmp(CameraToSensorModesLUT[i].name, name) == 0) {
51            cameraLUT = CameraToSensorModesLUT[i].Table;
52            numEntries = CameraToSensorModesLUT[i].size;
53            break;
54        }
55    }
56
57    // 2. Find scene mode entry in table
58    if (!cameraLUT) {
59        goto EXIT;
60    }
61
62    for (unsigned int i = 0; i < numEntries; i++) {
63        if(cameraLUT[i].scene == scene) {
64            entry = cameraLUT + i;
65            break;
66        }
67    }
68 EXIT:
69    return entry;
70}
71
72status_t OMXCameraAdapter::setParameters3A(const CameraParameters &params,
73                                           BaseCameraAdapter::AdapterState state)
74{
75    status_t ret = NO_ERROR;
76    int mode = 0;
77    const char *str = NULL;
78    int varint = 0;
79    BaseCameraAdapter::AdapterState nextState;
80    BaseCameraAdapter::getNextState(nextState);
81
82    LOG_FUNCTION_NAME;
83
84    Mutex::Autolock lock(m3ASettingsUpdateLock);
85
86    str = params.get(CameraParameters::KEY_SCENE_MODE);
87    mode = getLUTvalue_HALtoOMX( str, SceneLUT);
88    if ( mFirstTimeInit || ((str != NULL) && ( mParameters3A.SceneMode != mode )) ) {
89        if ( 0 <= mode ) {
90            mParameters3A.SceneMode = mode;
91            if ((mode == OMX_Manual) && (mFirstTimeInit == false)){//Auto mode
92                mFirstTimeInit = true;
93            }
94            if ((mode != OMX_Manual) &&
95                (state & PREVIEW_ACTIVE) && !(nextState & CAPTURE_ACTIVE)) {
96                // if setting preset scene mode, previewing, and not in the middle of capture
97                // set preset scene mode immediately instead of in next FBD
98                // for feedback params to work properly since they need to be read
99                // by application in subsequent getParameters()
100                ret |= setScene(mParameters3A);
101                // re-apply EV compensation after setting scene mode since it probably reset it
102                if(mParameters3A.EVCompensation) {
103                   setEVCompensation(mParameters3A);
104                }
105                return ret;
106            } else {
107                mPending3Asettings |= SetSceneMode;
108            }
109        } else {
110            mParameters3A.SceneMode = OMX_Manual;
111        }
112        CAMHAL_LOGVB("SceneMode %d", mParameters3A.SceneMode);
113    }
114
115#ifdef OMAP_ENHANCEMENT
116
117    str = params.get(TICameraParameters::KEY_EXPOSURE_MODE);
118    mode = getLUTvalue_HALtoOMX( str, ExpLUT);
119    if ( ( str != NULL ) && ( mParameters3A.Exposure != mode ))
120        {
121        mParameters3A.Exposure = mode;
122        CAMHAL_LOGDB("Exposure mode %d", mode);
123        if ( 0 <= mParameters3A.Exposure )
124            {
125            mPending3Asettings |= SetExpMode;
126            }
127        }
128
129#endif
130
131    str = params.get(CameraParameters::KEY_WHITE_BALANCE);
132    mode = getLUTvalue_HALtoOMX( str, WBalLUT);
133    if (mFirstTimeInit || ((str != NULL) && (mode != mParameters3A.WhiteBallance)))
134        {
135        mParameters3A.WhiteBallance = mode;
136        CAMHAL_LOGDB("Whitebalance mode %d", mode);
137        if ( 0 <= mParameters3A.WhiteBallance )
138            {
139            mPending3Asettings |= SetWhiteBallance;
140            }
141        }
142
143#ifdef OMAP_ENHANCEMENT
144
145    varint = params.getInt(TICameraParameters::KEY_CONTRAST);
146    if ( 0 <= varint )
147        {
148        if ( mFirstTimeInit ||
149             ( (mParameters3A.Contrast  + CONTRAST_OFFSET) != varint ) )
150            {
151            mParameters3A.Contrast = varint - CONTRAST_OFFSET;
152            CAMHAL_LOGDB("Contrast %d", mParameters3A.Contrast);
153            mPending3Asettings |= SetContrast;
154            }
155        }
156
157    varint = params.getInt(TICameraParameters::KEY_SHARPNESS);
158    if ( 0 <= varint )
159        {
160        if ( mFirstTimeInit ||
161             ((mParameters3A.Sharpness + SHARPNESS_OFFSET) != varint ))
162            {
163            mParameters3A.Sharpness = varint - SHARPNESS_OFFSET;
164            CAMHAL_LOGDB("Sharpness %d", mParameters3A.Sharpness);
165            mPending3Asettings |= SetSharpness;
166            }
167        }
168
169    varint = params.getInt(TICameraParameters::KEY_SATURATION);
170    if ( 0 <= varint )
171        {
172        if ( mFirstTimeInit ||
173             ((mParameters3A.Saturation + SATURATION_OFFSET) != varint ) )
174            {
175            mParameters3A.Saturation = varint - SATURATION_OFFSET;
176            CAMHAL_LOGDB("Saturation %d", mParameters3A.Saturation);
177            mPending3Asettings |= SetSaturation;
178            }
179        }
180
181    varint = params.getInt(TICameraParameters::KEY_BRIGHTNESS);
182    if ( 0 <= varint )
183        {
184        if ( mFirstTimeInit ||
185             (( mParameters3A.Brightness != varint )) )
186            {
187            mParameters3A.Brightness = (unsigned) varint;
188            CAMHAL_LOGDB("Brightness %d", mParameters3A.Brightness);
189            mPending3Asettings |= SetBrightness;
190            }
191        }
192
193#endif
194
195    str = params.get(CameraParameters::KEY_ANTIBANDING);
196    mode = getLUTvalue_HALtoOMX(str,FlickerLUT);
197    if ( mFirstTimeInit || ( ( str != NULL ) && ( mParameters3A.Flicker != mode ) ))
198        {
199        mParameters3A.Flicker = mode;
200        CAMHAL_LOGDB("Flicker %d", mParameters3A.Flicker);
201        if ( 0 <= mParameters3A.Flicker )
202            {
203            mPending3Asettings |= SetFlicker;
204            }
205        }
206
207#ifdef OMAP_ENHANCEMENT
208
209    str = params.get(TICameraParameters::KEY_ISO);
210    mode = getLUTvalue_HALtoOMX(str, IsoLUT);
211    CAMHAL_LOGVB("ISO mode arrived in HAL : %s", str);
212    if ( mFirstTimeInit || (  ( str != NULL ) && ( mParameters3A.ISO != mode )) )
213        {
214        mParameters3A.ISO = mode;
215        CAMHAL_LOGDB("ISO %d", mParameters3A.ISO);
216        if ( 0 <= mParameters3A.ISO )
217            {
218            mPending3Asettings |= SetISO;
219            }
220        }
221
222#endif
223
224    str = params.get(CameraParameters::KEY_FOCUS_MODE);
225    mode = getLUTvalue_HALtoOMX(str, FocusLUT);
226    if ( (mFirstTimeInit || ((str != NULL) && (mParameters3A.Focus != mode))))
227        {
228        mPending3Asettings |= SetFocus;
229
230        mParameters3A.Focus = mode;
231
232        // if focus mode is set to infinity...update focus distance immediately
233        if (mode == OMX_IMAGE_FocusControlAutoInfinity) {
234            updateFocusDistances(mParameters);
235        }
236
237        CAMHAL_LOGDB("Focus %x", mParameters3A.Focus);
238        }
239
240    str = params.get(CameraParameters::KEY_EXPOSURE_COMPENSATION);
241    varint = params.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION);
242    if ( mFirstTimeInit ||
243          (( str != NULL ) &&
244                  (mParameters3A.EVCompensation != varint )))
245        {
246        CAMHAL_LOGDB("Setting EV Compensation to %d", varint);
247
248        mParameters3A.EVCompensation = varint;
249        mPending3Asettings |= SetEVCompensation;
250        }
251
252    str = params.get(CameraParameters::KEY_FLASH_MODE);
253    mode = getLUTvalue_HALtoOMX( str, FlashLUT);
254    if (  mFirstTimeInit || (( str != NULL ) && ( mParameters3A.FlashMode != mode )) )
255        {
256        if ( 0 <= mode )
257            {
258            mParameters3A.FlashMode = mode;
259            mPending3Asettings |= SetFlash;
260            }
261        else
262            {
263            mParameters3A.FlashMode = OMX_Manual;
264            }
265        }
266
267    CAMHAL_LOGVB("Flash Setting %s", str);
268    CAMHAL_LOGVB("FlashMode %d", mParameters3A.FlashMode);
269
270    str = params.get(CameraParameters::KEY_EFFECT);
271    mode = getLUTvalue_HALtoOMX( str, EffLUT);
272    if (  mFirstTimeInit || (( str != NULL ) && ( mParameters3A.Effect != mode )) )
273        {
274        mParameters3A.Effect = mode;
275        CAMHAL_LOGDB("Effect %d", mParameters3A.Effect);
276        if ( 0 <= mParameters3A.Effect )
277            {
278            mPending3Asettings |= SetEffect;
279            }
280        }
281
282    str = params.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED);
283    if ( (str != NULL) && (!strcmp(str, "true")) )
284      {
285        OMX_BOOL lock = OMX_FALSE;
286        mUserSetExpLock = OMX_FALSE;
287        str = params.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK);
288        if (str && ((strcmp(str, "true")) == 0))
289          {
290            CAMHAL_LOGVA("Locking Exposure");
291            lock = OMX_TRUE;
292            mUserSetExpLock = OMX_TRUE;
293          }
294        else
295          {
296            CAMHAL_LOGVA("UnLocking Exposure");
297          }
298
299        if (mParameters3A.ExposureLock != lock)
300          {
301            mParameters3A.ExposureLock = lock;
302            CAMHAL_LOGDB("ExposureLock %d", lock);
303            mPending3Asettings |= SetExpLock;
304          }
305      }
306
307    str = params.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED);
308    if ( (str != NULL) && (!strcmp(str, "true")) )
309      {
310        OMX_BOOL lock = OMX_FALSE;
311        mUserSetWbLock = OMX_FALSE;
312        str = params.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK);
313        if (str && ((strcmp(str, "true")) == 0))
314          {
315            CAMHAL_LOGVA("Locking WhiteBalance");
316            lock = OMX_TRUE;
317            mUserSetWbLock = OMX_TRUE;
318          }
319        else
320          {
321            CAMHAL_LOGVA("UnLocking WhiteBalance");
322          }
323        if (mParameters3A.WhiteBalanceLock != lock)
324          {
325            mParameters3A.WhiteBalanceLock = lock;
326            CAMHAL_LOGDB("WhiteBalanceLock %d", lock);
327            mPending3Asettings |= SetWBLock;
328          }
329      }
330
331    str = params.get(TICameraParameters::KEY_AUTO_FOCUS_LOCK);
332    if (str && (strcmp(str, TRUE) == 0) && (mParameters3A.FocusLock != OMX_TRUE)) {
333        CAMHAL_LOGVA("Locking Focus");
334        mParameters3A.FocusLock = OMX_TRUE;
335        setFocusLock(mParameters3A);
336    } else if (str && (strcmp(str, FALSE) == 0) && (mParameters3A.FocusLock != OMX_FALSE)) {
337        CAMHAL_LOGVA("UnLocking Focus");
338        mParameters3A.FocusLock = OMX_FALSE;
339        setFocusLock(mParameters3A);
340    }
341
342    str = params.get(CameraParameters::KEY_METERING_AREAS);
343    if ( (str != NULL) ) {
344        size_t MAX_METERING_AREAS;
345        Vector< sp<CameraArea> > tempAreas;
346
347        MAX_METERING_AREAS = atoi(params.get(CameraParameters::KEY_MAX_NUM_METERING_AREAS));
348
349        Mutex::Autolock lock(mMeteringAreasLock);
350
351        ret = CameraArea::parseAreas(str, ( strlen(str) + 1 ), tempAreas);
352
353        CAMHAL_LOGVB("areAreasDifferent? = %d",
354                     CameraArea::areAreasDifferent(mMeteringAreas, tempAreas));
355
356        if ( (NO_ERROR == ret) && CameraArea::areAreasDifferent(mMeteringAreas, tempAreas) ) {
357            mMeteringAreas.clear();
358            mMeteringAreas = tempAreas;
359
360            if ( MAX_METERING_AREAS >= mMeteringAreas.size() ) {
361                CAMHAL_LOGDB("Setting Metering Areas %s",
362                        params.get(CameraParameters::KEY_METERING_AREAS));
363
364                mPending3Asettings |= SetMeteringAreas;
365            } else {
366                CAMHAL_LOGEB("Metering areas supported %d, metering areas set %d",
367                             MAX_METERING_AREAS, mMeteringAreas.size());
368                ret = -EINVAL;
369            }
370        }
371    }
372
373    LOG_FUNCTION_NAME_EXIT;
374
375    return ret;
376}
377
378int OMXCameraAdapter::getLUTvalue_HALtoOMX(const char * HalValue, LUTtype LUT)
379{
380    int LUTsize = LUT.size;
381    if( HalValue )
382        for(int i = 0; i < LUTsize; i++)
383            if( 0 == strcmp(LUT.Table[i].userDefinition, HalValue) )
384                return LUT.Table[i].omxDefinition;
385
386    return -ENOENT;
387}
388
389const char* OMXCameraAdapter::getLUTvalue_OMXtoHAL(int OMXValue, LUTtype LUT)
390{
391    int LUTsize = LUT.size;
392    for(int i = 0; i < LUTsize; i++)
393        if( LUT.Table[i].omxDefinition == OMXValue )
394            return LUT.Table[i].userDefinition;
395
396    return NULL;
397}
398
399status_t OMXCameraAdapter::init3AParams(Gen3A_settings &Gen3A)
400{
401    LOG_FUNCTION_NAME;
402
403    Gen3A.Effect = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_EFFECT, EffLUT);
404    Gen3A.FlashMode = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_FLASH_MODE, FlashLUT);
405    Gen3A.SceneMode = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_SCENE_MODE, SceneLUT);
406    Gen3A.EVCompensation = atoi(OMXCameraAdapter::DEFAULT_EV_COMPENSATION);
407    Gen3A.Focus = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_FOCUS_MODE, FocusLUT);
408    Gen3A.ISO = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_ISO_MODE, IsoLUT);
409    Gen3A.Flicker = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_ANTIBANDING, FlickerLUT);
410    Gen3A.Brightness = atoi(OMXCameraAdapter::DEFAULT_BRIGHTNESS);
411    Gen3A.Saturation = atoi(OMXCameraAdapter::DEFAULT_SATURATION) - SATURATION_OFFSET;
412    Gen3A.Sharpness = atoi(OMXCameraAdapter::DEFAULT_SHARPNESS) - SHARPNESS_OFFSET;
413    Gen3A.Contrast = atoi(OMXCameraAdapter::DEFAULT_CONTRAST) - CONTRAST_OFFSET;
414    Gen3A.WhiteBallance = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_WB, WBalLUT);
415    Gen3A.Exposure = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_EXPOSURE_MODE, ExpLUT);
416    Gen3A.ExposureLock = OMX_FALSE;
417    Gen3A.FocusLock = OMX_FALSE;
418    Gen3A.WhiteBalanceLock = OMX_FALSE;
419
420    LOG_FUNCTION_NAME_EXIT;
421
422    return NO_ERROR;
423}
424
425status_t OMXCameraAdapter::setExposureMode(Gen3A_settings& Gen3A)
426{
427    OMX_ERRORTYPE eError = OMX_ErrorNone;
428    OMX_CONFIG_EXPOSURECONTROLTYPE exp;
429
430    LOG_FUNCTION_NAME;
431
432    if ( OMX_StateInvalid == mComponentState )
433        {
434        CAMHAL_LOGEA("OMX component is in invalid state");
435        return NO_INIT;
436        }
437
438    OMX_INIT_STRUCT_PTR (&exp, OMX_CONFIG_EXPOSURECONTROLTYPE);
439    exp.nPortIndex = OMX_ALL;
440    exp.eExposureControl = (OMX_EXPOSURECONTROLTYPE)Gen3A.Exposure;
441
442    eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
443                            OMX_IndexConfigCommonExposure,
444                            &exp);
445    if ( OMX_ErrorNone != eError )
446        {
447        CAMHAL_LOGEB("Error while configuring exposure mode 0x%x", eError);
448        }
449    else
450        {
451        CAMHAL_LOGDA("Camera exposure mode configured successfully");
452        }
453
454    LOG_FUNCTION_NAME_EXIT;
455
456    return ErrorUtils::omxToAndroidError(eError);
457}
458
459static bool isFlashDisabled() {
460#if (PROPERTY_VALUE_MAX < 5)
461#error "PROPERTY_VALUE_MAX must be at least 5"
462#endif
463
464    // Ignore flash_off system property for user build.
465    char buildType[PROPERTY_VALUE_MAX];
466    if (property_get("ro.build.type", buildType, NULL) &&
467        !strcasecmp(buildType, "user")) {
468        return false;
469    }
470
471    char value[PROPERTY_VALUE_MAX];
472    if (property_get("camera.flash_off", value, NULL) &&
473        (!strcasecmp(value, "true") || !strcasecmp(value, "1"))) {
474        ALOGW("flash is disabled for testing purpose");
475        return true;
476    }
477
478    return false;
479}
480
481status_t OMXCameraAdapter::setFlashMode(Gen3A_settings& Gen3A)
482{
483    status_t ret = NO_ERROR;
484    OMX_ERRORTYPE eError = OMX_ErrorNone;
485    OMX_IMAGE_PARAM_FLASHCONTROLTYPE flash;
486    OMX_CONFIG_FOCUSASSISTTYPE focusAssist;
487
488    LOG_FUNCTION_NAME;
489
490    if ( OMX_StateInvalid == mComponentState )
491        {
492        CAMHAL_LOGEA("OMX component is in invalid state");
493        return NO_INIT;
494        }
495
496    OMX_INIT_STRUCT_PTR (&flash, OMX_IMAGE_PARAM_FLASHCONTROLTYPE);
497    flash.nPortIndex = OMX_ALL;
498
499    if (isFlashDisabled()) {
500        flash.eFlashControl = ( OMX_IMAGE_FLASHCONTROLTYPE ) OMX_IMAGE_FlashControlOff;
501    } else {
502        flash.eFlashControl = ( OMX_IMAGE_FLASHCONTROLTYPE ) Gen3A.FlashMode;
503    }
504
505    CAMHAL_LOGDB("Configuring flash mode 0x%x", flash.eFlashControl);
506    eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
507                            (OMX_INDEXTYPE) OMX_IndexConfigFlashControl,
508                            &flash);
509    if ( OMX_ErrorNone != eError )
510        {
511        CAMHAL_LOGEB("Error while configuring flash mode 0x%x", eError);
512        }
513    else
514        {
515        CAMHAL_LOGDA("Camera flash mode configured successfully");
516        }
517
518    if ( OMX_ErrorNone == eError )
519        {
520        OMX_INIT_STRUCT_PTR (&focusAssist, OMX_CONFIG_FOCUSASSISTTYPE);
521        focusAssist.nPortIndex = OMX_ALL;
522        if ( flash.eFlashControl == OMX_IMAGE_FlashControlOff )
523            {
524            focusAssist.bFocusAssist = OMX_FALSE;
525            }
526        else
527            {
528            focusAssist.bFocusAssist = OMX_TRUE;
529            }
530
531        CAMHAL_LOGDB("Configuring AF Assist mode 0x%x", focusAssist.bFocusAssist);
532        eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
533                                (OMX_INDEXTYPE) OMX_IndexConfigFocusAssist,
534                                &focusAssist);
535        if ( OMX_ErrorNone != eError )
536            {
537            CAMHAL_LOGEB("Error while configuring AF Assist mode 0x%x", eError);
538            }
539        else
540            {
541            CAMHAL_LOGDA("Camera AF Assist  mode configured successfully");
542            }
543        }
544
545    LOG_FUNCTION_NAME_EXIT;
546
547    return ErrorUtils::omxToAndroidError(eError);
548}
549
550status_t OMXCameraAdapter::getFlashMode(Gen3A_settings& Gen3A)
551{
552    status_t ret = NO_ERROR;
553    OMX_ERRORTYPE eError = OMX_ErrorNone;
554    OMX_IMAGE_PARAM_FLASHCONTROLTYPE flash;
555
556    LOG_FUNCTION_NAME;
557
558    if ( OMX_StateInvalid == mComponentState ) {
559        CAMHAL_LOGEA("OMX component is in invalid state");
560        return NO_INIT;
561    }
562
563    OMX_INIT_STRUCT_PTR (&flash, OMX_IMAGE_PARAM_FLASHCONTROLTYPE);
564    flash.nPortIndex = OMX_ALL;
565
566    eError =  OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
567                            (OMX_INDEXTYPE) OMX_IndexConfigFlashControl,
568                            &flash);
569
570    if ( OMX_ErrorNone != eError ) {
571        CAMHAL_LOGEB("Error while getting flash mode 0x%x", eError);
572    } else {
573        Gen3A.FlashMode = flash.eFlashControl;
574        CAMHAL_LOGDB("Gen3A.FlashMode 0x%x", Gen3A.FlashMode);
575    }
576
577    LOG_FUNCTION_NAME_EXIT;
578
579    return ErrorUtils::omxToAndroidError(eError);
580}
581
582status_t OMXCameraAdapter::setFocusMode(Gen3A_settings& Gen3A)
583{
584    status_t ret = NO_ERROR;
585    OMX_ERRORTYPE eError = OMX_ErrorNone;
586    OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE focus;
587    size_t top, left, width, height, weight;
588    OMX_CONFIG_BOOLEANTYPE bOMX;
589
590    LOG_FUNCTION_NAME;
591
592    BaseCameraAdapter::AdapterState state;
593    BaseCameraAdapter::getState(state);
594
595    if ( OMX_StateInvalid == mComponentState )
596        {
597        CAMHAL_LOGEA("OMX component is in invalid state");
598        return NO_INIT;
599        }
600
601
602    ///Face detection takes precedence over touch AF
603    if ( mFaceDetectionRunning )
604        {
605        //Disable region priority first
606        setAlgoPriority(REGION_PRIORITY, FOCUS_ALGO, false);
607
608        //Enable face algorithm priority for focus
609        setAlgoPriority(FACE_PRIORITY, FOCUS_ALGO , true);
610
611        //Do normal focus afterwards
612        ////FIXME: Check if the extended focus control is needed? this overrides caf
613        //focusControl.eFocusControl = ( OMX_IMAGE_FOCUSCONTROLTYPE ) OMX_IMAGE_FocusControlExtended;
614        }
615    else if ( (!mFocusAreas.isEmpty()) && (!mFocusAreas.itemAt(0)->isZeroArea()) )
616        {
617
618        //Disable face priority first
619        setAlgoPriority(FACE_PRIORITY, FOCUS_ALGO, false);
620
621        //Enable region algorithm priority
622        setAlgoPriority(REGION_PRIORITY, FOCUS_ALGO, true);
623
624
625        //Do normal focus afterwards
626        //FIXME: Check if the extended focus control is needed? this overrides caf
627        //focus.eFocusControl = ( OMX_IMAGE_FOCUSCONTROLTYPE ) OMX_IMAGE_FocusControlExtended;
628
629        }
630    else
631        {
632
633        //Disable both region and face priority
634        setAlgoPriority(REGION_PRIORITY, FOCUS_ALGO, false);
635
636        setAlgoPriority(FACE_PRIORITY, FOCUS_ALGO, false);
637
638        }
639
640    if ( NO_ERROR == ret && ((state & AF_ACTIVE) == 0) )
641        {
642        OMX_INIT_STRUCT_PTR (&bOMX, OMX_CONFIG_BOOLEANTYPE);
643
644        if ( Gen3A.Focus == OMX_IMAGE_FocusControlAutoInfinity)
645            {
646            // Don't lock at infinity, otherwise the AF cannot drive
647            // the lens at infinity position
648            if( set3ALock(mUserSetExpLock, mUserSetWbLock, OMX_FALSE) != NO_ERROR)
649                {
650                CAMHAL_LOGEA("Error Applying 3A locks");
651                } else {
652                CAMHAL_LOGDA("Focus locked. Applied focus locks successfully");
653                }
654            }
655        if ( Gen3A.Focus == OMX_IMAGE_FocusControlAuto ||
656             Gen3A.Focus == OMX_IMAGE_FocusControlAutoInfinity)
657            {
658            // Run focus scanning if switching to continuous infinity focus mode
659            bOMX.bEnabled = OMX_TRUE;
660            }
661        else
662            {
663            bOMX.bEnabled = OMX_FALSE;
664            }
665
666        eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
667                               (OMX_INDEXTYPE)OMX_TI_IndexConfigAutofocusEnable,
668                               &bOMX);
669
670        OMX_INIT_STRUCT_PTR (&focus, OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE);
671        focus.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
672        focus.eFocusControl = (OMX_IMAGE_FOCUSCONTROLTYPE)Gen3A.Focus;
673
674        CAMHAL_LOGDB("Configuring focus mode 0x%x", focus.eFocusControl);
675        eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp, OMX_IndexConfigFocusControl, &focus);
676        if ( OMX_ErrorNone != eError )
677            {
678            CAMHAL_LOGEB("Error while configuring focus mode 0x%x", eError);
679            }
680        else
681            {
682            CAMHAL_LOGDA("Camera focus mode configured successfully");
683            }
684        }
685
686    LOG_FUNCTION_NAME_EXIT;
687
688    return ErrorUtils::omxToAndroidError(eError);
689}
690
691status_t OMXCameraAdapter::getFocusMode(Gen3A_settings& Gen3A)
692{
693    status_t ret = NO_ERROR;
694    OMX_ERRORTYPE eError = OMX_ErrorNone;
695    OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE focus;
696    size_t top, left, width, height, weight;
697
698    LOG_FUNCTION_NAME;
699
700    if (OMX_StateInvalid == mComponentState) {
701        CAMHAL_LOGEA("OMX component is in invalid state");
702        return NO_INIT;
703    }
704
705    OMX_INIT_STRUCT_PTR (&focus, OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE);
706    focus.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
707    eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
708                           OMX_IndexConfigFocusControl, &focus);
709
710    if (OMX_ErrorNone != eError) {
711        CAMHAL_LOGEB("Error while configuring focus mode 0x%x", eError);
712    } else {
713        Gen3A.Focus = focus.eFocusControl;
714        CAMHAL_LOGDB("Gen3A.Focus 0x%x", Gen3A.Focus);
715    }
716
717    LOG_FUNCTION_NAME_EXIT;
718
719    return ErrorUtils::omxToAndroidError(eError);
720}
721
722status_t OMXCameraAdapter::setScene(Gen3A_settings& Gen3A)
723{
724    OMX_ERRORTYPE eError = OMX_ErrorNone;
725    OMX_CONFIG_SCENEMODETYPE scene;
726
727    LOG_FUNCTION_NAME;
728
729    if ( OMX_StateInvalid == mComponentState )
730        {
731        CAMHAL_LOGEA("OMX component is in invalid state");
732        return NO_INIT;
733        }
734
735    OMX_INIT_STRUCT_PTR (&scene, OMX_CONFIG_SCENEMODETYPE);
736    scene.nPortIndex = OMX_ALL;
737    scene.eSceneMode = ( OMX_SCENEMODETYPE ) Gen3A.SceneMode;
738
739    CAMHAL_LOGDB("Configuring scene mode 0x%x", scene.eSceneMode);
740    eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
741                            ( OMX_INDEXTYPE ) OMX_TI_IndexConfigSceneMode,
742                            &scene);
743
744    if (OMX_ErrorNone != eError) {
745        CAMHAL_LOGEB("Error while configuring scene mode 0x%x", eError);
746    } else {
747        CAMHAL_LOGDA("Camera scene configured successfully");
748        if (Gen3A.SceneMode != OMX_Manual) {
749            // Get preset scene mode feedback
750            getFocusMode(Gen3A);
751            getFlashMode(Gen3A);
752            getWBMode(Gen3A);
753
754            // TODO(XXX): Re-enable these for mainline
755            // getSharpness(Gen3A);
756            // getSaturation(Gen3A);
757            // getISO(Gen3A);
758        }
759    }
760
761    LOG_FUNCTION_NAME_EXIT;
762
763    return ErrorUtils::omxToAndroidError(eError);
764}
765
766status_t OMXCameraAdapter::setEVCompensation(Gen3A_settings& Gen3A)
767{
768    OMX_ERRORTYPE eError = OMX_ErrorNone;
769    OMX_CONFIG_EXPOSUREVALUETYPE expValues;
770
771    LOG_FUNCTION_NAME;
772
773    if ( OMX_StateInvalid == mComponentState )
774        {
775        CAMHAL_LOGEA("OMX component is in invalid state");
776        return NO_INIT;
777        }
778
779    OMX_INIT_STRUCT_PTR (&expValues, OMX_CONFIG_EXPOSUREVALUETYPE);
780    expValues.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
781
782    OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
783                   OMX_IndexConfigCommonExposureValue,
784                   &expValues);
785    CAMHAL_LOGDB("old EV Compensation for OMX = 0x%x", (int)expValues.xEVCompensation);
786    CAMHAL_LOGDB("EV Compensation for HAL = %d", Gen3A.EVCompensation);
787
788    expValues.xEVCompensation = ( Gen3A.EVCompensation * ( 1 << Q16_OFFSET ) )  / 10;
789    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
790                            OMX_IndexConfigCommonExposureValue,
791                            &expValues);
792    CAMHAL_LOGDB("new EV Compensation for OMX = 0x%x", (int)expValues.xEVCompensation);
793    if ( OMX_ErrorNone != eError )
794        {
795        CAMHAL_LOGEB("Error while configuring EV Compensation 0x%x error = 0x%x",
796                     ( unsigned int ) expValues.xEVCompensation,
797                     eError);
798        }
799    else
800        {
801        CAMHAL_LOGDB("EV Compensation 0x%x configured successfully",
802                     ( unsigned int ) expValues.xEVCompensation);
803        }
804
805    LOG_FUNCTION_NAME_EXIT;
806
807    return ErrorUtils::omxToAndroidError(eError);
808}
809
810status_t OMXCameraAdapter::getEVCompensation(Gen3A_settings& Gen3A)
811{
812    OMX_ERRORTYPE eError = OMX_ErrorNone;
813    OMX_CONFIG_EXPOSUREVALUETYPE expValues;
814
815    LOG_FUNCTION_NAME;
816
817    if ( OMX_StateInvalid == mComponentState ) {
818        CAMHAL_LOGEA("OMX component is in invalid state");
819        return NO_INIT;
820    }
821
822    OMX_INIT_STRUCT_PTR (&expValues, OMX_CONFIG_EXPOSUREVALUETYPE);
823    expValues.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
824
825    OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
826                  OMX_IndexConfigCommonExposureValue,
827                  &expValues);
828
829    if ( OMX_ErrorNone != eError ) {
830        CAMHAL_LOGEB("Error while getting EV Compensation error = 0x%x", eError);
831    } else {
832        Gen3A.EVCompensation = (10 * expValues.xEVCompensation) / (1 << Q16_OFFSET);
833        CAMHAL_LOGDB("Gen3A.EVCompensation 0x%x", Gen3A.EVCompensation);
834    }
835
836    LOG_FUNCTION_NAME_EXIT;
837
838    return ErrorUtils::omxToAndroidError(eError);
839}
840
841status_t OMXCameraAdapter::setWBMode(Gen3A_settings& Gen3A)
842{
843    OMX_ERRORTYPE eError = OMX_ErrorNone;
844    OMX_CONFIG_WHITEBALCONTROLTYPE wb;
845
846    LOG_FUNCTION_NAME;
847
848    if ( OMX_StateInvalid == mComponentState )
849        {
850        CAMHAL_LOGEA("OMX component is in invalid state");
851        return NO_INIT;
852        }
853
854    OMX_INIT_STRUCT_PTR (&wb, OMX_CONFIG_WHITEBALCONTROLTYPE);
855    wb.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
856    wb.eWhiteBalControl = ( OMX_WHITEBALCONTROLTYPE ) Gen3A.WhiteBallance;
857
858    if ( WB_FACE_PRIORITY == Gen3A.WhiteBallance )
859        {
860        //Disable Region priority and enable Face priority
861        setAlgoPriority(REGION_PRIORITY, WHITE_BALANCE_ALGO, false);
862        setAlgoPriority(FACE_PRIORITY, WHITE_BALANCE_ALGO, true);
863
864        //Then set the mode to auto
865        wb.eWhiteBalControl = OMX_WhiteBalControlAuto;
866        }
867    else
868        {
869        //Disable Face and Region priority
870        setAlgoPriority(FACE_PRIORITY, WHITE_BALANCE_ALGO, false);
871        setAlgoPriority(REGION_PRIORITY, WHITE_BALANCE_ALGO, false);
872        }
873
874    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
875                         OMX_IndexConfigCommonWhiteBalance,
876                         &wb);
877    if ( OMX_ErrorNone != eError )
878        {
879        CAMHAL_LOGEB("Error while configuring Whitebalance mode 0x%x error = 0x%x",
880                     ( unsigned int ) wb.eWhiteBalControl,
881                     eError);
882        }
883    else
884        {
885        CAMHAL_LOGDB("Whitebalance mode 0x%x configured successfully",
886                     ( unsigned int ) wb.eWhiteBalControl);
887        }
888
889    LOG_FUNCTION_NAME_EXIT;
890
891    return eError;
892}
893
894status_t OMXCameraAdapter::getWBMode(Gen3A_settings& Gen3A)
895{
896    OMX_ERRORTYPE eError = OMX_ErrorNone;
897    OMX_CONFIG_WHITEBALCONTROLTYPE wb;
898
899    LOG_FUNCTION_NAME;
900
901    if ( OMX_StateInvalid == mComponentState ) {
902        CAMHAL_LOGEA("OMX component is in invalid state");
903        return NO_INIT;
904    }
905
906    OMX_INIT_STRUCT_PTR (&wb, OMX_CONFIG_WHITEBALCONTROLTYPE);
907    wb.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
908
909    eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
910                           OMX_IndexConfigCommonWhiteBalance,
911                           &wb);
912
913    if (OMX_ErrorNone != eError) {
914        CAMHAL_LOGEB("Error while getting Whitebalance mode error = 0x%x", eError);
915    } else {
916        Gen3A.WhiteBallance = wb.eWhiteBalControl;
917        CAMHAL_LOGDB("Gen3A.WhiteBallance 0x%x", Gen3A.WhiteBallance);
918    }
919
920    LOG_FUNCTION_NAME_EXIT;
921
922    return eError;
923}
924
925status_t OMXCameraAdapter::setFlicker(Gen3A_settings& Gen3A)
926{
927    OMX_ERRORTYPE eError = OMX_ErrorNone;
928    OMX_CONFIG_FLICKERCANCELTYPE flicker;
929
930    LOG_FUNCTION_NAME;
931
932    if ( OMX_StateInvalid == mComponentState )
933        {
934        CAMHAL_LOGEA("OMX component is in invalid state");
935        return NO_INIT;
936        }
937
938    OMX_INIT_STRUCT_PTR (&flicker, OMX_CONFIG_FLICKERCANCELTYPE);
939    flicker.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
940    flicker.eFlickerCancel = (OMX_COMMONFLICKERCANCELTYPE)Gen3A.Flicker;
941
942    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
943                            (OMX_INDEXTYPE)OMX_IndexConfigFlickerCancel,
944                            &flicker );
945    if ( OMX_ErrorNone != eError )
946        {
947        CAMHAL_LOGEB("Error while configuring Flicker mode 0x%x error = 0x%x",
948                     ( unsigned int ) flicker.eFlickerCancel,
949                     eError);
950        }
951    else
952        {
953        CAMHAL_LOGDB("Flicker mode 0x%x configured successfully",
954                     ( unsigned int ) flicker.eFlickerCancel);
955        }
956
957    LOG_FUNCTION_NAME_EXIT;
958
959    return ErrorUtils::omxToAndroidError(eError);
960}
961
962status_t OMXCameraAdapter::setBrightness(Gen3A_settings& Gen3A)
963{
964    OMX_ERRORTYPE eError = OMX_ErrorNone;
965    OMX_CONFIG_BRIGHTNESSTYPE brightness;
966
967    LOG_FUNCTION_NAME;
968
969    if ( OMX_StateInvalid == mComponentState )
970        {
971        CAMHAL_LOGEA("OMX component is in invalid state");
972        return NO_INIT;
973        }
974
975    OMX_INIT_STRUCT_PTR (&brightness, OMX_CONFIG_BRIGHTNESSTYPE);
976    brightness.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
977    brightness.nBrightness = Gen3A.Brightness;
978
979    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
980                         OMX_IndexConfigCommonBrightness,
981                         &brightness);
982    if ( OMX_ErrorNone != eError )
983        {
984        CAMHAL_LOGEB("Error while configuring Brightness 0x%x error = 0x%x",
985                     ( unsigned int ) brightness.nBrightness,
986                     eError);
987        }
988    else
989        {
990        CAMHAL_LOGDB("Brightness 0x%x configured successfully",
991                     ( unsigned int ) brightness.nBrightness);
992        }
993
994    LOG_FUNCTION_NAME_EXIT;
995
996    return ErrorUtils::omxToAndroidError(eError);
997}
998
999status_t OMXCameraAdapter::setContrast(Gen3A_settings& Gen3A)
1000{
1001    OMX_ERRORTYPE eError = OMX_ErrorNone;
1002    OMX_CONFIG_CONTRASTTYPE contrast;
1003
1004    LOG_FUNCTION_NAME;
1005
1006    if ( OMX_StateInvalid == mComponentState )
1007        {
1008        CAMHAL_LOGEA("OMX component is in invalid state");
1009        return NO_INIT;
1010        }
1011
1012    OMX_INIT_STRUCT_PTR (&contrast, OMX_CONFIG_CONTRASTTYPE);
1013    contrast.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1014    contrast.nContrast = Gen3A.Contrast;
1015
1016    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
1017                         OMX_IndexConfigCommonContrast,
1018                         &contrast);
1019    if ( OMX_ErrorNone != eError )
1020        {
1021        CAMHAL_LOGEB("Error while configuring Contrast 0x%x error = 0x%x",
1022                     ( unsigned int ) contrast.nContrast,
1023                     eError);
1024        }
1025    else
1026        {
1027        CAMHAL_LOGDB("Contrast 0x%x configured successfully",
1028                     ( unsigned int ) contrast.nContrast);
1029        }
1030
1031    LOG_FUNCTION_NAME_EXIT;
1032
1033    return eError;
1034}
1035
1036status_t OMXCameraAdapter::setSharpness(Gen3A_settings& Gen3A)
1037{
1038    OMX_ERRORTYPE eError = OMX_ErrorNone;
1039    OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE procSharpness;
1040
1041    LOG_FUNCTION_NAME;
1042
1043    if ( OMX_StateInvalid == mComponentState )
1044        {
1045        CAMHAL_LOGEA("OMX component is in invalid state");
1046        return NO_INIT;
1047        }
1048
1049    OMX_INIT_STRUCT_PTR (&procSharpness, OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE);
1050    procSharpness.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1051    procSharpness.nLevel = Gen3A.Sharpness;
1052
1053    if( procSharpness.nLevel == 0 )
1054        {
1055        procSharpness.bAuto = OMX_TRUE;
1056        }
1057    else
1058        {
1059        procSharpness.bAuto = OMX_FALSE;
1060        }
1061
1062    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
1063                         (OMX_INDEXTYPE)OMX_IndexConfigSharpeningLevel,
1064                         &procSharpness);
1065    if ( OMX_ErrorNone != eError )
1066        {
1067        CAMHAL_LOGEB("Error while configuring Sharpness 0x%x error = 0x%x",
1068                     ( unsigned int ) procSharpness.nLevel,
1069                     eError);
1070        }
1071    else
1072        {
1073        CAMHAL_LOGDB("Sharpness 0x%x configured successfully",
1074                     ( unsigned int ) procSharpness.nLevel);
1075        }
1076
1077    LOG_FUNCTION_NAME_EXIT;
1078
1079    return ErrorUtils::omxToAndroidError(eError);
1080}
1081
1082status_t OMXCameraAdapter::getSharpness(Gen3A_settings& Gen3A)
1083{
1084    OMX_ERRORTYPE eError = OMX_ErrorNone;
1085    OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE procSharpness;
1086
1087    LOG_FUNCTION_NAME;
1088
1089    if (OMX_StateInvalid == mComponentState) {
1090        CAMHAL_LOGEA("OMX component is in invalid state");
1091        return NO_INIT;
1092    }
1093
1094    OMX_INIT_STRUCT_PTR (&procSharpness, OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE);
1095    procSharpness.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1096
1097    eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
1098                           (OMX_INDEXTYPE)OMX_IndexConfigSharpeningLevel,
1099                           &procSharpness);
1100
1101    if (OMX_ErrorNone != eError) {
1102        CAMHAL_LOGEB("Error while configuring Sharpness error = 0x%x", eError);
1103    } else {
1104        Gen3A.Sharpness = procSharpness.nLevel;
1105        CAMHAL_LOGDB("Gen3A.Sharpness 0x%x", Gen3A.Sharpness);
1106    }
1107
1108    LOG_FUNCTION_NAME_EXIT;
1109
1110    return ErrorUtils::omxToAndroidError(eError);
1111}
1112
1113status_t OMXCameraAdapter::setSaturation(Gen3A_settings& Gen3A)
1114{
1115    OMX_ERRORTYPE eError = OMX_ErrorNone;
1116    OMX_CONFIG_SATURATIONTYPE saturation;
1117
1118    LOG_FUNCTION_NAME;
1119
1120    if ( OMX_StateInvalid == mComponentState )
1121        {
1122        CAMHAL_LOGEA("OMX component is in invalid state");
1123        return NO_INIT;
1124        }
1125
1126    OMX_INIT_STRUCT_PTR (&saturation, OMX_CONFIG_SATURATIONTYPE);
1127    saturation.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1128    saturation.nSaturation = Gen3A.Saturation;
1129
1130    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
1131                         OMX_IndexConfigCommonSaturation,
1132                         &saturation);
1133    if ( OMX_ErrorNone != eError )
1134        {
1135        CAMHAL_LOGEB("Error while configuring Saturation 0x%x error = 0x%x",
1136                     ( unsigned int ) saturation.nSaturation,
1137                     eError);
1138        }
1139    else
1140        {
1141        CAMHAL_LOGDB("Saturation 0x%x configured successfully",
1142                     ( unsigned int ) saturation.nSaturation);
1143        }
1144
1145    LOG_FUNCTION_NAME_EXIT;
1146
1147    return ErrorUtils::omxToAndroidError(eError);
1148}
1149
1150status_t OMXCameraAdapter::getSaturation(Gen3A_settings& Gen3A)
1151{
1152    OMX_ERRORTYPE eError = OMX_ErrorNone;
1153    OMX_CONFIG_SATURATIONTYPE saturation;
1154
1155    LOG_FUNCTION_NAME;
1156
1157    if (OMX_StateInvalid == mComponentState) {
1158        CAMHAL_LOGEA("OMX component is in invalid state");
1159        return NO_INIT;
1160    }
1161
1162    OMX_INIT_STRUCT_PTR (&saturation, OMX_CONFIG_SATURATIONTYPE);
1163    saturation.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1164
1165    eError = OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
1166                         OMX_IndexConfigCommonSaturation,
1167                         &saturation);
1168
1169    if (OMX_ErrorNone != eError) {
1170        CAMHAL_LOGEB("Error while getting Saturation error = 0x%x", eError);
1171    } else {
1172        Gen3A.Saturation = saturation.nSaturation;
1173        CAMHAL_LOGDB("Gen3A.Saturation 0x%x", Gen3A.Saturation);
1174    }
1175
1176    LOG_FUNCTION_NAME_EXIT;
1177
1178    return ErrorUtils::omxToAndroidError(eError);
1179}
1180
1181status_t OMXCameraAdapter::setISO(Gen3A_settings& Gen3A)
1182{
1183    OMX_ERRORTYPE eError = OMX_ErrorNone;
1184    OMX_CONFIG_EXPOSUREVALUETYPE expValues;
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 (&expValues, OMX_CONFIG_EXPOSUREVALUETYPE);
1195    expValues.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1196
1197    OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
1198                   OMX_IndexConfigCommonExposureValue,
1199                   &expValues);
1200
1201    if( 0 == Gen3A.ISO )
1202        {
1203        expValues.bAutoSensitivity = OMX_TRUE;
1204        }
1205    else
1206        {
1207        expValues.bAutoSensitivity = OMX_FALSE;
1208        expValues.nSensitivity = Gen3A.ISO;
1209        }
1210
1211    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
1212                         OMX_IndexConfigCommonExposureValue,
1213                         &expValues);
1214    if ( OMX_ErrorNone != eError )
1215        {
1216        CAMHAL_LOGEB("Error while configuring ISO 0x%x error = 0x%x",
1217                     ( unsigned int ) expValues.nSensitivity,
1218                     eError);
1219        }
1220    else
1221        {
1222        CAMHAL_LOGDB("ISO 0x%x configured successfully",
1223                     ( unsigned int ) expValues.nSensitivity);
1224        }
1225
1226    LOG_FUNCTION_NAME_EXIT;
1227
1228    return ErrorUtils::omxToAndroidError(eError);
1229}
1230
1231status_t OMXCameraAdapter::getISO(Gen3A_settings& Gen3A)
1232{
1233    OMX_ERRORTYPE eError = OMX_ErrorNone;
1234    OMX_CONFIG_EXPOSUREVALUETYPE expValues;
1235
1236    LOG_FUNCTION_NAME;
1237
1238    if (OMX_StateInvalid == mComponentState) {
1239        CAMHAL_LOGEA("OMX component is in invalid state");
1240        return NO_INIT;
1241    }
1242
1243    OMX_INIT_STRUCT_PTR (&expValues, OMX_CONFIG_EXPOSUREVALUETYPE);
1244    expValues.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1245
1246    OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
1247                   OMX_IndexConfigCommonExposureValue,
1248                   &expValues);
1249
1250    if (OMX_ErrorNone != eError) {
1251        CAMHAL_LOGEB("Error while getting ISO error = 0x%x", eError);
1252    } else {
1253        Gen3A.ISO = expValues.nSensitivity;
1254        CAMHAL_LOGDB("Gen3A.ISO %d", Gen3A.ISO);
1255    }
1256
1257    LOG_FUNCTION_NAME_EXIT;
1258
1259    return ErrorUtils::omxToAndroidError(eError);
1260}
1261
1262status_t OMXCameraAdapter::setEffect(Gen3A_settings& Gen3A)
1263{
1264    OMX_ERRORTYPE eError = OMX_ErrorNone;
1265    OMX_CONFIG_IMAGEFILTERTYPE effect;
1266
1267    LOG_FUNCTION_NAME;
1268
1269    if ( OMX_StateInvalid == mComponentState )
1270        {
1271        CAMHAL_LOGEA("OMX component is in invalid state");
1272        return NO_INIT;
1273        }
1274
1275    OMX_INIT_STRUCT_PTR (&effect, OMX_CONFIG_IMAGEFILTERTYPE);
1276    effect.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1277    effect.eImageFilter = (OMX_IMAGEFILTERTYPE ) Gen3A.Effect;
1278
1279    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
1280                         OMX_IndexConfigCommonImageFilter,
1281                         &effect);
1282    if ( OMX_ErrorNone != eError )
1283        {
1284        CAMHAL_LOGEB("Error while configuring Effect 0x%x error = 0x%x",
1285                     ( unsigned int )  effect.eImageFilter,
1286                     eError);
1287        }
1288    else
1289        {
1290        CAMHAL_LOGDB("Effect 0x%x configured successfully",
1291                     ( unsigned int )  effect.eImageFilter);
1292        }
1293
1294    LOG_FUNCTION_NAME_EXIT;
1295
1296    return ErrorUtils::omxToAndroidError(eError);
1297}
1298
1299status_t OMXCameraAdapter::setWhiteBalanceLock(Gen3A_settings& Gen3A)
1300{
1301  OMX_ERRORTYPE eError = OMX_ErrorNone;
1302  OMX_IMAGE_CONFIG_LOCKTYPE lock;
1303
1304  LOG_FUNCTION_NAME
1305
1306  if ( OMX_StateInvalid == mComponentState )
1307    {
1308      CAMHAL_LOGEA("OMX component is in invalid state");
1309      return NO_INIT;
1310    }
1311
1312  OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
1313  lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1314  lock.bLock = Gen3A.WhiteBalanceLock;
1315  eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
1316                          (OMX_INDEXTYPE)OMX_IndexConfigImageWhiteBalanceLock,
1317                          &lock);
1318  if ( OMX_ErrorNone != eError )
1319    {
1320      CAMHAL_LOGEB("Error while configuring WhiteBalance Lock error = 0x%x", eError);
1321    }
1322  else
1323    {
1324      CAMHAL_LOGDB("WhiteBalance Lock configured successfully %d ", lock.bLock);
1325    }
1326  LOG_FUNCTION_NAME_EXIT
1327
1328  return ErrorUtils::omxToAndroidError(eError);
1329}
1330
1331status_t OMXCameraAdapter::setExposureLock(Gen3A_settings& Gen3A)
1332{
1333  OMX_ERRORTYPE eError = OMX_ErrorNone;
1334  OMX_IMAGE_CONFIG_LOCKTYPE lock;
1335
1336  LOG_FUNCTION_NAME
1337
1338  if ( OMX_StateInvalid == mComponentState )
1339    {
1340      CAMHAL_LOGEA("OMX component is in invalid state");
1341      return NO_INIT;
1342    }
1343
1344  OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
1345  lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1346  lock.bLock = Gen3A.ExposureLock;
1347  eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
1348                          (OMX_INDEXTYPE)OMX_IndexConfigImageExposureLock,
1349                          &lock);
1350  if ( OMX_ErrorNone != eError )
1351    {
1352      CAMHAL_LOGEB("Error while configuring Exposure Lock error = 0x%x", eError);
1353    }
1354  else
1355    {
1356      CAMHAL_LOGDB("Exposure Lock configured successfully %d ", lock.bLock);
1357    }
1358  LOG_FUNCTION_NAME_EXIT
1359
1360    return ErrorUtils::omxToAndroidError(eError);
1361}
1362
1363status_t OMXCameraAdapter::setFocusLock(Gen3A_settings& Gen3A)
1364{
1365    OMX_ERRORTYPE eError = OMX_ErrorNone;
1366    OMX_IMAGE_CONFIG_LOCKTYPE lock;
1367
1368    LOG_FUNCTION_NAME
1369
1370    if ( OMX_StateInvalid == mComponentState ) {
1371        CAMHAL_LOGEA("OMX component is in invalid state");
1372        return NO_INIT;
1373    }
1374
1375    OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
1376    lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1377
1378    lock.bLock = Gen3A.FocusLock;
1379    eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
1380                           (OMX_INDEXTYPE)OMX_IndexConfigImageFocusLock,
1381                           &lock);
1382
1383    if ( OMX_ErrorNone != eError ) {
1384        CAMHAL_LOGEB("Error while configuring Focus Lock error = 0x%x", eError);
1385    } else {
1386        CAMHAL_LOGDB("Focus Lock configured successfully %d ", lock.bLock);
1387    }
1388
1389    LOG_FUNCTION_NAME_EXIT
1390
1391    return ErrorUtils::omxToAndroidError(eError);
1392}
1393
1394status_t OMXCameraAdapter::set3ALock(OMX_BOOL toggleExp, OMX_BOOL toggleWb, OMX_BOOL toggleFocus)
1395{
1396    OMX_ERRORTYPE eError = OMX_ErrorNone;
1397    OMX_IMAGE_CONFIG_LOCKTYPE lock;
1398
1399    LOG_FUNCTION_NAME
1400
1401    if ( OMX_StateInvalid == mComponentState )
1402    {
1403      CAMHAL_LOGEA("OMX component is in invalid state");
1404      return NO_INIT;
1405    }
1406
1407    OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
1408    lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1409
1410    mParameters3A.ExposureLock = toggleExp;
1411    mParameters3A.FocusLock = toggleFocus;
1412    mParameters3A.WhiteBalanceLock = toggleWb;
1413
1414    eError = OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
1415                            (OMX_INDEXTYPE)OMX_IndexConfigImageExposureLock,
1416                            &lock);
1417
1418    if ( OMX_ErrorNone != eError )
1419    {
1420        CAMHAL_LOGEB("Error GetConfig Exposure Lock error = 0x%x", eError);
1421        goto EXIT;
1422    }
1423    else
1424    {
1425        const char *lock_state_exp = toggleExp ? TRUE : FALSE;
1426        CAMHAL_LOGDA("Exposure Lock GetConfig successfull");
1427
1428        /* Apply locks only when not applied already */
1429        if ( lock.bLock  != toggleExp )
1430        {
1431            setExposureLock(mParameters3A);
1432        }
1433
1434        mParams.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, lock_state_exp);
1435    }
1436
1437    OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
1438    lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1439    eError = OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
1440                            (OMX_INDEXTYPE)OMX_IndexConfigImageFocusLock,
1441                            &lock);
1442
1443    if ( OMX_ErrorNone != eError )
1444    {
1445        CAMHAL_LOGEB("Error GetConfig Focus Lock error = 0x%x", eError);
1446        goto EXIT;
1447    }
1448    else
1449    {
1450        CAMHAL_LOGDB("Focus Lock GetConfig successfull bLock(%d)", lock.bLock);
1451
1452        /* Apply locks only when not applied already */
1453        if ( lock.bLock  != toggleFocus )
1454        {
1455            setFocusLock(mParameters3A);
1456        }
1457    }
1458
1459    OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
1460    lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1461    eError = OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
1462                            (OMX_INDEXTYPE)OMX_IndexConfigImageWhiteBalanceLock,
1463                            &lock);
1464
1465    if ( OMX_ErrorNone != eError )
1466    {
1467        CAMHAL_LOGEB("Error GetConfig WhiteBalance Lock error = 0x%x", eError);
1468        goto EXIT;
1469    }
1470    else
1471    {
1472        const char *lock_state_wb = toggleWb ? TRUE : FALSE;
1473        CAMHAL_LOGDA("WhiteBalance Lock GetConfig successfull");
1474
1475        /* Apply locks only when not applied already */
1476        if ( lock.bLock != toggleWb )
1477        {
1478            setWhiteBalanceLock(mParameters3A);
1479        }
1480
1481        mParams.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, lock_state_wb);
1482    }
1483 EXIT:
1484    return ErrorUtils::omxToAndroidError(eError);
1485}
1486
1487status_t OMXCameraAdapter::setMeteringAreas(Gen3A_settings& Gen3A)
1488{
1489  status_t ret = NO_ERROR;
1490  OMX_ERRORTYPE eError = OMX_ErrorNone;
1491
1492  OMX_ALGOAREASTYPE **meteringAreas;
1493  OMX_TI_CONFIG_SHAREDBUFFER sharedBuffer;
1494  MemoryManager memMgr;
1495  int areasSize = 0;
1496
1497  LOG_FUNCTION_NAME
1498
1499  Mutex::Autolock lock(mMeteringAreasLock);
1500
1501  if ( OMX_StateInvalid == mComponentState )
1502    {
1503      CAMHAL_LOGEA("OMX component is in invalid state");
1504      return NO_INIT;
1505    }
1506
1507  areasSize = ((sizeof(OMX_ALGOAREASTYPE)+4095)/4096)*4096;
1508  meteringAreas = (OMX_ALGOAREASTYPE**) memMgr.allocateBuffer(0, 0, NULL, areasSize, 1);
1509
1510  OMXCameraPortParameters * mPreviewData = NULL;
1511  mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
1512
1513  if (!meteringAreas)
1514      {
1515      CAMHAL_LOGEB("Error allocating buffer for metering areas %d", eError);
1516      return -ENOMEM;
1517      }
1518
1519  OMX_INIT_STRUCT_PTR (meteringAreas[0], OMX_ALGOAREASTYPE);
1520
1521  meteringAreas[0]->nPortIndex = OMX_ALL;
1522  meteringAreas[0]->nNumAreas = mMeteringAreas.size();
1523  meteringAreas[0]->nAlgoAreaPurpose = OMX_AlgoAreaExposure;
1524
1525  for ( unsigned int n = 0; n < mMeteringAreas.size(); n++)
1526      {
1527      // transform the coordinates to 3A-type coordinates
1528      mMeteringAreas.itemAt(n)->transfrom((size_t)mPreviewData->mWidth,
1529                                      (size_t)mPreviewData->mHeight,
1530                                      (size_t&)meteringAreas[0]->tAlgoAreas[n].nTop,
1531                                      (size_t&)meteringAreas[0]->tAlgoAreas[n].nLeft,
1532                                      (size_t&)meteringAreas[0]->tAlgoAreas[n].nWidth,
1533                                      (size_t&)meteringAreas[0]->tAlgoAreas[n].nHeight);
1534
1535      meteringAreas[0]->tAlgoAreas[n].nLeft =
1536              ( meteringAreas[0]->tAlgoAreas[n].nLeft * METERING_AREAS_RANGE ) / mPreviewData->mWidth;
1537      meteringAreas[0]->tAlgoAreas[n].nTop =
1538              ( meteringAreas[0]->tAlgoAreas[n].nTop* METERING_AREAS_RANGE ) / mPreviewData->mHeight;
1539      meteringAreas[0]->tAlgoAreas[n].nWidth =
1540              ( meteringAreas[0]->tAlgoAreas[n].nWidth * METERING_AREAS_RANGE ) / mPreviewData->mWidth;
1541      meteringAreas[0]->tAlgoAreas[n].nHeight =
1542              ( meteringAreas[0]->tAlgoAreas[n].nHeight * METERING_AREAS_RANGE ) / mPreviewData->mHeight;
1543
1544      meteringAreas[0]->tAlgoAreas[n].nPriority = mMeteringAreas.itemAt(n)->getWeight();
1545
1546      CAMHAL_LOGDB("Metering area %d : top = %d left = %d width = %d height = %d prio = %d",
1547              n, (int)meteringAreas[0]->tAlgoAreas[n].nTop, (int)meteringAreas[0]->tAlgoAreas[n].nLeft,
1548              (int)meteringAreas[0]->tAlgoAreas[n].nWidth, (int)meteringAreas[0]->tAlgoAreas[n].nHeight,
1549              (int)meteringAreas[0]->tAlgoAreas[n].nPriority);
1550
1551      }
1552
1553  OMX_INIT_STRUCT_PTR (&sharedBuffer, OMX_TI_CONFIG_SHAREDBUFFER);
1554
1555  sharedBuffer.nPortIndex = OMX_ALL;
1556  sharedBuffer.nSharedBuffSize = areasSize;
1557  sharedBuffer.pSharedBuff = (OMX_U8 *) meteringAreas[0];
1558
1559  if ( NULL == sharedBuffer.pSharedBuff )
1560      {
1561      CAMHAL_LOGEA("No resources to allocate OMX shared buffer");
1562      ret = -ENOMEM;
1563      goto EXIT;
1564      }
1565
1566      eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
1567                                (OMX_INDEXTYPE) OMX_TI_IndexConfigAlgoAreas, &sharedBuffer);
1568
1569  if ( OMX_ErrorNone != eError )
1570      {
1571      CAMHAL_LOGEB("Error while setting Focus Areas configuration 0x%x", eError);
1572      ret = -EINVAL;
1573      }
1574  else
1575      {
1576      CAMHAL_LOGDA("Metering Areas SetConfig successfull.");
1577      }
1578
1579 EXIT:
1580  if (NULL != meteringAreas)
1581      {
1582      memMgr.freeBuffer((void*) meteringAreas);
1583      meteringAreas = NULL;
1584      }
1585
1586  return ret;
1587}
1588
1589status_t OMXCameraAdapter::apply3Asettings( Gen3A_settings& Gen3A )
1590{
1591    status_t ret = NO_ERROR;
1592    unsigned int currSett; // 32 bit
1593    int portIndex;
1594
1595    LOG_FUNCTION_NAME;
1596
1597    Mutex::Autolock lock(m3ASettingsUpdateLock);
1598
1599    /*
1600     * Scenes have a priority during the process
1601     * of applying 3A related parameters.
1602     * They can override pretty much all other 3A
1603     * settings and similarly get overridden when
1604     * for instance the focus mode gets switched.
1605     * There is only one exception to this rule,
1606     * the manual a.k.a. auto scene.
1607     */
1608    if (SetSceneMode & mPending3Asettings) {
1609        mPending3Asettings &= ~SetSceneMode;
1610        ret |= setScene(Gen3A);
1611        // re-apply EV compensation after setting scene mode since it probably reset it
1612        if(Gen3A.EVCompensation) {
1613            setEVCompensation(Gen3A);
1614        }
1615        return ret;
1616    } else if (OMX_Manual != Gen3A.SceneMode) {
1617        // only certain settings are allowed when scene mode is set
1618        mPending3Asettings &= (SetEVCompensation | SetFocus | SetWBLock |
1619                               SetExpLock | SetWhiteBallance | SetFlash);
1620        if ( mPending3Asettings == 0 ) return NO_ERROR;
1621    }
1622
1623    for( currSett = 1; currSett < E3aSettingMax; currSett <<= 1)
1624        {
1625        if( currSett & mPending3Asettings )
1626            {
1627            switch( currSett )
1628                {
1629                case SetEVCompensation:
1630                    {
1631                    ret |= setEVCompensation(Gen3A);
1632                    break;
1633                    }
1634
1635                case SetWhiteBallance:
1636                    {
1637                    ret |= setWBMode(Gen3A);
1638                    break;
1639                    }
1640
1641                case SetFlicker:
1642                    {
1643                    ret |= setFlicker(Gen3A);
1644                    break;
1645                    }
1646
1647                case SetBrightness:
1648                    {
1649                    ret |= setBrightness(Gen3A);
1650                    break;
1651                    }
1652
1653                case SetContrast:
1654                    {
1655                    ret |= setContrast(Gen3A);
1656                    break;
1657                    }
1658
1659                case SetSharpness:
1660                    {
1661                    ret |= setSharpness(Gen3A);
1662                    break;
1663                    }
1664
1665                case SetSaturation:
1666                    {
1667                    ret |= setSaturation(Gen3A);
1668                    break;
1669                    }
1670
1671                case SetISO:
1672                    {
1673                    ret |= setISO(Gen3A);
1674                    break;
1675                    }
1676
1677                case SetEffect:
1678                    {
1679                    ret |= setEffect(Gen3A);
1680                    break;
1681                    }
1682
1683                case SetFocus:
1684                    {
1685                    ret |= setFocusMode(Gen3A);
1686                    break;
1687                    }
1688
1689                case SetExpMode:
1690                    {
1691                    ret |= setExposureMode(Gen3A);
1692                    break;
1693                    }
1694
1695                case SetFlash:
1696                    {
1697                    ret |= setFlashMode(Gen3A);
1698                    break;
1699                    }
1700
1701                case SetExpLock:
1702                  {
1703                    ret |= setExposureLock(Gen3A);
1704                    break;
1705                  }
1706
1707                case SetWBLock:
1708                  {
1709                    ret |= setWhiteBalanceLock(Gen3A);
1710                    break;
1711                  }
1712                case SetMeteringAreas:
1713                  {
1714                    ret |= setMeteringAreas(Gen3A);
1715                  }
1716                  break;
1717                default:
1718                    CAMHAL_LOGEB("this setting (0x%x) is still not supported in CameraAdapter ",
1719                                 currSett);
1720                    break;
1721                }
1722                mPending3Asettings &= ~currSett;
1723            }
1724        }
1725
1726        LOG_FUNCTION_NAME_EXIT;
1727
1728        return ret;
1729}
1730
1731};
1732