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