OMX3A.cpp revision 708ed7306c85286aa50d05ba15e0c33106e52ed0 
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
33#define TRUE "true"
34#define FALSE "false"
35
36#define METERING_AREAS_RANGE 0xFF
37
38namespace android {
39
40status_t OMXCameraAdapter::setParameters3A(const CameraParameters &params,
41                                           BaseCameraAdapter::AdapterState state)
42{
43    status_t ret = NO_ERROR;
44    int mode = 0;
45    const char *str = NULL;
46
47    LOG_FUNCTION_NAME;
48
49    str = params.get(TICameraParameters::KEY_EXPOSURE_MODE);
50    mode = getLUTvalue_HALtoOMX( str, ExpLUT);
51    if ( ( str != NULL ) && ( mParameters3A.Exposure != mode ))
52        {
53        mParameters3A.Exposure = mode;
54        CAMHAL_LOGDB("Exposure mode %d", mode);
55        if ( 0 <= mParameters3A.Exposure )
56            {
57            mPending3Asettings |= SetExpMode;
58            }
59        }
60
61    str = params.get(CameraParameters::KEY_WHITE_BALANCE);
62    mode = getLUTvalue_HALtoOMX( str, WBalLUT);
63    if (mFirstTimeInit || ((str != NULL) && (mode != mParameters3A.WhiteBallance)))
64        {
65        mParameters3A.WhiteBallance = mode;
66        CAMHAL_LOGDB("Whitebalance mode %d", mode);
67        if ( 0 <= mParameters3A.WhiteBallance )
68            {
69            mPending3Asettings |= SetWhiteBallance;
70            }
71        }
72
73    if ( 0 <= params.getInt(TICameraParameters::KEY_CONTRAST) )
74        {
75        if ( mFirstTimeInit ||
76             ( (mParameters3A.Contrast  + CONTRAST_OFFSET) !=
77                     params.getInt(TICameraParameters::KEY_CONTRAST)) )
78            {
79            mParameters3A.Contrast = params.getInt(TICameraParameters::KEY_CONTRAST) - CONTRAST_OFFSET;
80            CAMHAL_LOGDB("Contrast %d", mParameters3A.Contrast);
81            mPending3Asettings |= SetContrast;
82            }
83        }
84
85    if ( 0 <= params.getInt(TICameraParameters::KEY_SHARPNESS) )
86        {
87        if ( mFirstTimeInit ||
88             ((mParameters3A.Sharpness + SHARPNESS_OFFSET) !=
89                     params.getInt(TICameraParameters::KEY_SHARPNESS)))
90            {
91            mParameters3A.Sharpness = params.getInt(TICameraParameters::KEY_SHARPNESS) - SHARPNESS_OFFSET;
92            CAMHAL_LOGDB("Sharpness %d", mParameters3A.Sharpness);
93            mPending3Asettings |= SetSharpness;
94            }
95        }
96
97    if ( 0 <= params.getInt(TICameraParameters::KEY_SATURATION) )
98        {
99        if ( mFirstTimeInit ||
100             ((mParameters3A.Saturation + SATURATION_OFFSET) !=
101                     params.getInt(TICameraParameters::KEY_SATURATION)) )
102            {
103            mParameters3A.Saturation = params.getInt(TICameraParameters::KEY_SATURATION) - SATURATION_OFFSET;
104            CAMHAL_LOGDB("Saturation %d", mParameters3A.Saturation);
105            mPending3Asettings |= SetSaturation;
106            }
107        }
108
109    if ( 0 <= params.getInt(TICameraParameters::KEY_BRIGHTNESS) )
110        {
111        if ( mFirstTimeInit ||
112             (( mParameters3A.Brightness !=
113                     ( unsigned int ) params.getInt(TICameraParameters::KEY_BRIGHTNESS))) )
114            {
115            mParameters3A.Brightness = (unsigned)params.getInt(TICameraParameters::KEY_BRIGHTNESS);
116            CAMHAL_LOGDB("Brightness %d", mParameters3A.Brightness);
117            mPending3Asettings |= SetBrightness;
118            }
119        }
120
121    str = params.get(CameraParameters::KEY_ANTIBANDING);
122    mode = getLUTvalue_HALtoOMX(str,FlickerLUT);
123    if ( mFirstTimeInit || ( ( str != NULL ) && ( mParameters3A.Flicker != mode ) ))
124        {
125        mParameters3A.Flicker = mode;
126        CAMHAL_LOGDB("Flicker %d", mParameters3A.Flicker);
127        if ( 0 <= mParameters3A.Flicker )
128            {
129            mPending3Asettings |= SetFlicker;
130            }
131        }
132
133    str = params.get(TICameraParameters::KEY_ISO);
134    mode = getLUTvalue_HALtoOMX(str, IsoLUT);
135    CAMHAL_LOGVB("ISO mode arrived in HAL : %s", str);
136    if ( mFirstTimeInit || (  ( str != NULL ) && ( mParameters3A.ISO != mode )) )
137        {
138        mParameters3A.ISO = mode;
139        CAMHAL_LOGDB("ISO %d", mParameters3A.ISO);
140        if ( 0 <= mParameters3A.ISO )
141            {
142            mPending3Asettings |= SetISO;
143            }
144        }
145
146    str = params.get(CameraParameters::KEY_FOCUS_MODE);
147    mode = getLUTvalue_HALtoOMX(str, FocusLUT);
148    if ( (mFirstTimeInit || ((str != NULL) && (mParameters3A.Focus != mode))))
149        {
150        //Apply focus mode immediatly only if  CAF  or Inifinity are selected
151        if ( ( mode == OMX_IMAGE_FocusControlAuto ) ||
152             ( mode == OMX_IMAGE_FocusControlAutoInfinity ) )
153            {
154            mPending3Asettings |= SetFocus;
155            }
156
157        mParameters3A.Focus = mode;
158        CAMHAL_LOGDB("Focus %x", mParameters3A.Focus);
159        }
160
161    str = params.get(CameraParameters::KEY_EXPOSURE_COMPENSATION);
162    if ( mFirstTimeInit ||
163          (( str != NULL ) &&
164                  (mParameters3A.EVCompensation !=
165                          params.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION))))
166        {
167        CAMHAL_LOGDB("Setting EV Compensation to %d",
168                     params.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION));
169
170        mParameters3A.EVCompensation = params.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION);
171        mPending3Asettings |= SetEVCompensation;
172        }
173
174    str = params.get(CameraParameters::KEY_SCENE_MODE);
175    mode = getLUTvalue_HALtoOMX( str, SceneLUT);
176    if (  mFirstTimeInit || (( str != NULL ) && ( mParameters3A.SceneMode != mode )) )
177        {
178        if ( 0 <= mode )
179            {
180            mParameters3A.SceneMode = mode;
181            mPending3Asettings |= SetSceneMode;
182            }
183        else
184            {
185            mParameters3A.SceneMode = OMX_Manual;
186            }
187
188        CAMHAL_LOGDB("SceneMode %d", mParameters3A.SceneMode);
189        }
190
191    str = params.get(CameraParameters::KEY_FLASH_MODE);
192    mode = getLUTvalue_HALtoOMX( str, FlashLUT);
193    if (  mFirstTimeInit || (( str != NULL ) && ( mParameters3A.FlashMode != mode )) )
194        {
195        if ( 0 <= mode )
196            {
197            mParameters3A.FlashMode = mode;
198            mPending3Asettings |= SetFlash;
199            }
200        else
201            {
202            mParameters3A.FlashMode = OMX_Manual;
203            }
204        }
205
206    CAMHAL_LOGVB("Flash Setting %s", str);
207    CAMHAL_LOGVB("FlashMode %d", mParameters3A.FlashMode);
208
209    str = params.get(CameraParameters::KEY_EFFECT);
210    mode = getLUTvalue_HALtoOMX( str, EffLUT);
211    if (  mFirstTimeInit || (( str != NULL ) && ( mParameters3A.Effect != mode )) )
212        {
213        mParameters3A.Effect = mode;
214        CAMHAL_LOGDB("Effect %d", mParameters3A.Effect);
215        if ( 0 <= mParameters3A.Effect )
216            {
217            mPending3Asettings |= SetEffect;
218            }
219        }
220
221    str = params.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED);
222    if ( (str != NULL) && (!strcmp(str, "true")) )
223      {
224        OMX_BOOL lock = OMX_FALSE;
225        str = params.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK);
226        if ( (strcmp(str, "true")) == 0)
227          {
228            CAMHAL_LOGVA("Locking Exposure");
229            lock = OMX_TRUE;
230          }
231        else
232          {
233            CAMHAL_LOGVA("UnLocking Exposure");
234          }
235        if (mParameters3A.ExposureLock != lock)
236          {
237            mParameters3A.ExposureLock = lock;
238            CAMHAL_LOGDB("ExposureLock %d", lock);
239            mPending3Asettings |= SetExpLock;
240          }
241      }
242
243    str = params.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED);
244    if ( (str != NULL) && (!strcmp(str, "true")) )
245      {
246        OMX_BOOL lock = OMX_FALSE;
247        str = params.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK);
248        if ( (strcmp(str, "true")) == 0)
249          {
250            CAMHAL_LOGVA("Locking WhiteBalance");
251            lock = OMX_TRUE;
252          }
253        else
254          {
255            CAMHAL_LOGVA("UnLocking WhiteBalance");
256          }
257        if (mParameters3A.WhiteBalanceLock != lock)
258          {
259            mParameters3A.WhiteBalanceLock = lock;
260            CAMHAL_LOGDB("WhiteBalanceLock %d", lock);
261            mPending3Asettings |= SetWBLock;
262          }
263      }
264
265    str = params.get(CameraParameters::KEY_METERING_AREAS);
266    if ( (str != NULL) )
267        {
268        size_t MAX_METERING_AREAS;
269        MAX_METERING_AREAS = atoi(params.get(CameraParameters::KEY_MAX_NUM_METERING_AREAS));
270
271        mMeteringAreas.clear();
272
273        CameraArea::parseFocusArea(str, strlen(str), mMeteringAreas);
274
275        if ( MAX_METERING_AREAS > mMeteringAreas.size() )
276            {
277            CAMHAL_LOGDB("Setting Metering Areas %s",
278                    params.get(CameraParameters::KEY_METERING_AREAS));
279
280            mPending3Asettings |= SetMeteringAreas;
281            }
282        else
283            {
284            CAMHAL_LOGEB("Metering areas supported %d, metering areas set %d",
285                         MAX_METERING_AREAS, mMeteringAreas.size());
286            }
287        }
288
289    LOG_FUNCTION_NAME_EXIT;
290
291    return ret;
292}
293
294int OMXCameraAdapter::getLUTvalue_HALtoOMX(const char * HalValue, LUTtype LUT)
295{
296    int LUTsize = LUT.size;
297    if( HalValue )
298        for(int i = 0; i < LUTsize; i++)
299            if( 0 == strcmp(LUT.Table[i].userDefinition, HalValue) )
300                return LUT.Table[i].omxDefinition;
301
302    return -ENOENT;
303}
304
305const char* OMXCameraAdapter::getLUTvalue_OMXtoHAL(int OMXValue, LUTtype LUT)
306{
307    int LUTsize = LUT.size;
308    for(int i = 0; i < LUTsize; i++)
309        if( LUT.Table[i].omxDefinition == OMXValue )
310            return LUT.Table[i].userDefinition;
311
312    return NULL;
313}
314
315status_t OMXCameraAdapter::apply3ADefaults(Gen3A_settings &Gen3A)
316{
317    status_t ret = NO_ERROR;
318
319    LOG_FUNCTION_NAME;
320
321    Gen3A.Effect = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_EFFECT, EffLUT);
322    ret |= setEffect(Gen3A);
323
324    Gen3A.FlashMode = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_FLASH_MODE, FlashLUT);
325    ret |= setFlashMode(Gen3A);
326
327    Gen3A.SceneMode = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_SCENE_MODE, SceneLUT);
328    ret |= setScene(Gen3A);
329
330    Gen3A.EVCompensation = atoi(OMXCameraAdapter::DEFAULT_EV_COMPENSATION);
331    ret |= setEVCompensation(Gen3A);
332
333    Gen3A.Focus = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_FOCUS_MODE, FocusLUT);
334    ret |= setFocusMode(Gen3A);
335
336    Gen3A.ISO = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_ISO_MODE, IsoLUT);
337    ret |= setISO(Gen3A);
338
339    Gen3A.Flicker = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_ANTIBANDING, FlickerLUT);
340    ret |= setFlicker(Gen3A);
341
342    Gen3A.Brightness = atoi(OMXCameraAdapter::DEFAULT_BRIGHTNESS);
343    ret |= setBrightness(Gen3A);
344
345    Gen3A.Saturation = atoi(OMXCameraAdapter::DEFAULT_SATURATION);
346    ret |= setSaturation(Gen3A);
347
348    Gen3A.Sharpness = atoi(OMXCameraAdapter::DEFAULT_SHARPNESS);
349    ret |= setSharpness(Gen3A);
350
351    Gen3A.Contrast = atoi(OMXCameraAdapter::DEFAULT_CONTRAST);
352    ret |= setContrast(Gen3A);
353
354    Gen3A.WhiteBallance = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_WB, WBalLUT);
355    ret |= setWBMode(Gen3A);
356
357    Gen3A.Exposure = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_EXPOSURE_MODE, ExpLUT);
358    ret |= setExposureMode(Gen3A);
359
360    Gen3A.ExposureLock = OMX_FALSE;
361    ret |= setExposureLock(Gen3A);
362
363    Gen3A.WhiteBalanceLock = OMX_FALSE;
364    ret |= setWhiteBalanceLock(Gen3A);
365
366    LOG_FUNCTION_NAME_EXIT;
367
368    return NO_ERROR;
369}
370
371status_t OMXCameraAdapter::setExposureMode(Gen3A_settings& Gen3A)
372{
373    OMX_ERRORTYPE eError = OMX_ErrorNone;
374    OMX_CONFIG_EXPOSURECONTROLTYPE exp;
375
376    LOG_FUNCTION_NAME;
377
378    if ( OMX_StateInvalid == mComponentState )
379        {
380        CAMHAL_LOGEA("OMX component is in invalid state");
381        return NO_INIT;
382        }
383
384    OMX_INIT_STRUCT_PTR (&exp, OMX_CONFIG_EXPOSURECONTROLTYPE);
385    exp.nPortIndex = OMX_ALL;
386    exp.eExposureControl = (OMX_EXPOSURECONTROLTYPE)Gen3A.Exposure;
387
388///FIXME: Face priority exposure metering is not stable because of varying face sizes
389///coming from the FD module. So disabling it for now.
390#if 0
391    if ( mFaceDetectionRunning )
392        {
393        //Disable Region priority and enable Face priority
394        setAlgoPriority(REGION_PRIORITY, EXPOSURE_ALGO, false);
395        setAlgoPriority(FACE_PRIORITY, EXPOSURE_ALGO, true);
396        }
397    else
398#endif
399        {
400        //Disable Region priority and Face priority
401        setAlgoPriority(REGION_PRIORITY, EXPOSURE_ALGO, false);
402        setAlgoPriority(FACE_PRIORITY, EXPOSURE_ALGO, false);
403        }
404
405    eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
406                            OMX_IndexConfigCommonExposure,
407                            &exp);
408    if ( OMX_ErrorNone != eError )
409        {
410        CAMHAL_LOGEB("Error while configuring exposure mode 0x%x", eError);
411        }
412    else
413        {
414        CAMHAL_LOGDA("Camera exposure mode configured successfully");
415        }
416
417    LOG_FUNCTION_NAME_EXIT;
418
419    return ErrorUtils::omxToAndroidError(eError);
420}
421
422status_t OMXCameraAdapter::setFlashMode(Gen3A_settings& Gen3A)
423{
424    status_t ret = NO_ERROR;
425    OMX_ERRORTYPE eError = OMX_ErrorNone;
426    OMX_IMAGE_PARAM_FLASHCONTROLTYPE flash;
427
428    LOG_FUNCTION_NAME;
429
430    if ( OMX_StateInvalid == mComponentState )
431        {
432        CAMHAL_LOGEA("OMX component is in invalid state");
433        return NO_INIT;
434        }
435
436    OMX_INIT_STRUCT_PTR (&flash, OMX_IMAGE_PARAM_FLASHCONTROLTYPE);
437    flash.nPortIndex = OMX_ALL;
438    flash.eFlashControl = ( OMX_IMAGE_FLASHCONTROLTYPE ) Gen3A.FlashMode;
439
440    CAMHAL_LOGDB("Configuring flash mode 0x%x", flash.eFlashControl);
441    eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
442                            (OMX_INDEXTYPE) OMX_IndexConfigFlashControl,
443                            &flash);
444    if ( OMX_ErrorNone != eError )
445        {
446        CAMHAL_LOGEB("Error while configuring flash mode 0x%x", eError);
447        }
448    else
449        {
450        CAMHAL_LOGDA("Camera flash mode configured successfully");
451        }
452
453    LOG_FUNCTION_NAME_EXIT;
454
455    return ErrorUtils::omxToAndroidError(eError);
456}
457
458status_t OMXCameraAdapter::setFocusMode(Gen3A_settings& Gen3A)
459{
460    status_t ret = NO_ERROR;
461    OMX_ERRORTYPE eError = OMX_ErrorNone;
462    OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE focus;
463    size_t top, left, width, height, weight;
464    sp<CameraArea> focusArea = NULL;
465
466    LOG_FUNCTION_NAME;
467
468    BaseCameraAdapter::AdapterState state;
469    BaseCameraAdapter::getState(state);
470
471    if ( OMX_StateInvalid == mComponentState )
472        {
473        CAMHAL_LOGEA("OMX component is in invalid state");
474        return NO_INIT;
475        }
476
477        {
478        Mutex::Autolock lock(mFocusAreasLock);
479
480        if ( !mFocusAreas.isEmpty() )
481            {
482            focusArea = mFocusAreas.itemAt(0);
483            }
484        }
485
486    ///Face detection takes precedence over touch AF
487    if ( mFaceDetectionRunning )
488        {
489        //Disable region priority first
490        setAlgoPriority(REGION_PRIORITY, FOCUS_ALGO, false);
491
492        //Enable face algorithm priority for focus
493        setAlgoPriority(FACE_PRIORITY, FOCUS_ALGO , true);
494
495        //Do normal focus afterwards
496        ////FIXME: Check if the extended focus control is needed? this overrides caf
497        //focusControl.eFocusControl = ( OMX_IMAGE_FOCUSCONTROLTYPE ) OMX_IMAGE_FocusControlExtended;
498        }
499    else if ( ( NULL != focusArea.get() ) && ( focusArea->isValid() ) )
500        {
501
502        //Disable face priority first
503        setAlgoPriority(FACE_PRIORITY, FOCUS_ALGO, false);
504
505        //Enable region algorithm priority
506        setAlgoPriority(REGION_PRIORITY, FOCUS_ALGO, true);
507
508        setTouchFocus();
509
510        //Do normal focus afterwards
511        //FIXME: Check if the extended focus control is needed? this overrides caf
512        //focus.eFocusControl = ( OMX_IMAGE_FOCUSCONTROLTYPE ) OMX_IMAGE_FocusControlExtended;
513
514        }
515    else
516        {
517
518        //Disable both region and face priority
519        setAlgoPriority(REGION_PRIORITY, FOCUS_ALGO, false);
520
521        setAlgoPriority(FACE_PRIORITY, FOCUS_ALGO, false);
522
523        }
524
525    if ( NO_ERROR == ret && ((state & AF_ACTIVE) == 0) )
526        {
527        OMX_INIT_STRUCT_PTR (&focus, OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE);
528        focus.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
529        focus.eFocusControl = (OMX_IMAGE_FOCUSCONTROLTYPE)Gen3A.Focus;
530
531        CAMHAL_LOGDB("Configuring focus mode 0x%x", focus.eFocusControl);
532        eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp, OMX_IndexConfigFocusControl, &focus);
533        if ( OMX_ErrorNone != eError )
534            {
535            CAMHAL_LOGEB("Error while configuring focus mode 0x%x", eError);
536            }
537        else
538            {
539            CAMHAL_LOGDA("Camera focus mode configured successfully");
540            }
541        }
542
543    LOG_FUNCTION_NAME_EXIT;
544
545    return ErrorUtils::omxToAndroidError(eError);
546}
547
548status_t OMXCameraAdapter::setScene(Gen3A_settings& Gen3A)
549{
550    OMX_ERRORTYPE eError = OMX_ErrorNone;
551    OMX_CONFIG_SCENEMODETYPE scene;
552
553    LOG_FUNCTION_NAME;
554
555    if ( OMX_StateInvalid == mComponentState )
556        {
557        CAMHAL_LOGEA("OMX component is in invalid state");
558        return NO_INIT;
559        }
560
561    OMX_INIT_STRUCT_PTR (&scene, OMX_CONFIG_SCENEMODETYPE);
562    scene.nPortIndex = OMX_ALL;
563    scene.eSceneMode = ( OMX_SCENEMODETYPE ) Gen3A.SceneMode;
564
565    CAMHAL_LOGDB("Configuring scene mode 0x%x", scene.eSceneMode);
566    eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
567                            ( OMX_INDEXTYPE ) OMX_TI_IndexConfigSceneMode,
568                            &scene);
569    if ( OMX_ErrorNone != eError )
570        {
571        CAMHAL_LOGEB("Error while configuring scene mode 0x%x", eError);
572        }
573    else
574        {
575        CAMHAL_LOGDA("Camera scene configured successfully");
576        }
577
578    LOG_FUNCTION_NAME_EXIT;
579
580    return ErrorUtils::omxToAndroidError(eError);
581}
582
583status_t OMXCameraAdapter::setEVCompensation(Gen3A_settings& Gen3A)
584{
585    OMX_ERRORTYPE eError = OMX_ErrorNone;
586    OMX_CONFIG_EXPOSUREVALUETYPE expValues;
587
588    LOG_FUNCTION_NAME;
589
590    if ( OMX_StateInvalid == mComponentState )
591        {
592        CAMHAL_LOGEA("OMX component is in invalid state");
593        return NO_INIT;
594        }
595
596    OMX_INIT_STRUCT_PTR (&expValues, OMX_CONFIG_EXPOSUREVALUETYPE);
597    expValues.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
598
599    OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
600                   OMX_IndexConfigCommonExposureValue,
601                   &expValues);
602    CAMHAL_LOGDB("old EV Compensation for OMX = 0x%x", (int)expValues.xEVCompensation);
603    CAMHAL_LOGDB("EV Compensation for HAL = %d", Gen3A.EVCompensation);
604
605    expValues.xEVCompensation = ( Gen3A.EVCompensation * ( 1 << Q16_OFFSET ) )  / 10;
606    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
607                            OMX_IndexConfigCommonExposureValue,
608                            &expValues);
609    CAMHAL_LOGDB("new EV Compensation for OMX = 0x%x", (int)expValues.xEVCompensation);
610    if ( OMX_ErrorNone != eError )
611        {
612        CAMHAL_LOGEB("Error while configuring EV Compensation 0x%x error = 0x%x",
613                     ( unsigned int ) expValues.xEVCompensation,
614                     eError);
615        }
616    else
617        {
618        CAMHAL_LOGDB("EV Compensation 0x%x configured successfully",
619                     ( unsigned int ) expValues.xEVCompensation);
620        }
621
622    LOG_FUNCTION_NAME_EXIT;
623
624    return ErrorUtils::omxToAndroidError(eError);
625}
626
627status_t OMXCameraAdapter::setWBMode(Gen3A_settings& Gen3A)
628{
629    OMX_ERRORTYPE eError = OMX_ErrorNone;
630    OMX_CONFIG_WHITEBALCONTROLTYPE wb;
631
632    LOG_FUNCTION_NAME;
633
634    if ( OMX_StateInvalid == mComponentState )
635        {
636        CAMHAL_LOGEA("OMX component is in invalid state");
637        return NO_INIT;
638        }
639
640    OMX_INIT_STRUCT_PTR (&wb, OMX_CONFIG_WHITEBALCONTROLTYPE);
641    wb.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
642    wb.eWhiteBalControl = ( OMX_WHITEBALCONTROLTYPE ) Gen3A.WhiteBallance;
643
644    if ( WB_FACE_PRIORITY == Gen3A.WhiteBallance )
645        {
646        //Disable Region priority and enable Face priority
647        setAlgoPriority(REGION_PRIORITY, WHITE_BALANCE_ALGO, false);
648        setAlgoPriority(FACE_PRIORITY, WHITE_BALANCE_ALGO, true);
649
650        //Then set the mode to auto
651        wb.eWhiteBalControl = OMX_WhiteBalControlAuto;
652        }
653    else
654        {
655        //Disable Face and Region priority
656        setAlgoPriority(FACE_PRIORITY, WHITE_BALANCE_ALGO, false);
657        setAlgoPriority(REGION_PRIORITY, WHITE_BALANCE_ALGO, false);
658        }
659
660    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
661                         OMX_IndexConfigCommonWhiteBalance,
662                         &wb);
663    if ( OMX_ErrorNone != eError )
664        {
665        CAMHAL_LOGEB("Error while configuring Whitebalance mode 0x%x error = 0x%x",
666                     ( unsigned int ) wb.eWhiteBalControl,
667                     eError);
668        }
669    else
670        {
671        CAMHAL_LOGDB("Whitebalance mode 0x%x configured successfully",
672                     ( unsigned int ) wb.eWhiteBalControl);
673        }
674
675    LOG_FUNCTION_NAME_EXIT;
676
677    return eError;
678}
679
680status_t OMXCameraAdapter::setFlicker(Gen3A_settings& Gen3A)
681{
682    OMX_ERRORTYPE eError = OMX_ErrorNone;
683    OMX_CONFIG_FLICKERCANCELTYPE flicker;
684
685    LOG_FUNCTION_NAME;
686
687    if ( OMX_StateInvalid == mComponentState )
688        {
689        CAMHAL_LOGEA("OMX component is in invalid state");
690        return NO_INIT;
691        }
692
693    OMX_INIT_STRUCT_PTR (&flicker, OMX_CONFIG_FLICKERCANCELTYPE);
694    flicker.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
695    flicker.eFlickerCancel = (OMX_COMMONFLICKERCANCELTYPE)Gen3A.Flicker;
696
697    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
698                            (OMX_INDEXTYPE)OMX_IndexConfigFlickerCancel,
699                            &flicker );
700    if ( OMX_ErrorNone != eError )
701        {
702        CAMHAL_LOGEB("Error while configuring Flicker mode 0x%x error = 0x%x",
703                     ( unsigned int ) flicker.eFlickerCancel,
704                     eError);
705        }
706    else
707        {
708        CAMHAL_LOGDB("Flicker mode 0x%x configured successfully",
709                     ( unsigned int ) flicker.eFlickerCancel);
710        }
711
712    LOG_FUNCTION_NAME_EXIT;
713
714    return ErrorUtils::omxToAndroidError(eError);
715}
716
717status_t OMXCameraAdapter::setBrightness(Gen3A_settings& Gen3A)
718{
719    OMX_ERRORTYPE eError = OMX_ErrorNone;
720    OMX_CONFIG_BRIGHTNESSTYPE brightness;
721
722    LOG_FUNCTION_NAME;
723
724    if ( OMX_StateInvalid == mComponentState )
725        {
726        CAMHAL_LOGEA("OMX component is in invalid state");
727        return NO_INIT;
728        }
729
730    OMX_INIT_STRUCT_PTR (&brightness, OMX_CONFIG_BRIGHTNESSTYPE);
731    brightness.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
732    brightness.nBrightness = Gen3A.Brightness;
733
734    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
735                         OMX_IndexConfigCommonBrightness,
736                         &brightness);
737    if ( OMX_ErrorNone != eError )
738        {
739        CAMHAL_LOGEB("Error while configuring Brightness 0x%x error = 0x%x",
740                     ( unsigned int ) brightness.nBrightness,
741                     eError);
742        }
743    else
744        {
745        CAMHAL_LOGDB("Brightness 0x%x configured successfully",
746                     ( unsigned int ) brightness.nBrightness);
747        }
748
749    LOG_FUNCTION_NAME_EXIT;
750
751    return ErrorUtils::omxToAndroidError(eError);
752}
753
754status_t OMXCameraAdapter::setContrast(Gen3A_settings& Gen3A)
755{
756    OMX_ERRORTYPE eError = OMX_ErrorNone;
757    OMX_CONFIG_CONTRASTTYPE contrast;
758
759    LOG_FUNCTION_NAME;
760
761    if ( OMX_StateInvalid == mComponentState )
762        {
763        CAMHAL_LOGEA("OMX component is in invalid state");
764        return NO_INIT;
765        }
766
767    OMX_INIT_STRUCT_PTR (&contrast, OMX_CONFIG_CONTRASTTYPE);
768    contrast.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
769    contrast.nContrast = Gen3A.Contrast;
770
771    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
772                         OMX_IndexConfigCommonContrast,
773                         &contrast);
774    if ( OMX_ErrorNone != eError )
775        {
776        CAMHAL_LOGEB("Error while configuring Contrast 0x%x error = 0x%x",
777                     ( unsigned int ) contrast.nContrast,
778                     eError);
779        }
780    else
781        {
782        CAMHAL_LOGDB("Contrast 0x%x configured successfully",
783                     ( unsigned int ) contrast.nContrast);
784        }
785
786    LOG_FUNCTION_NAME_EXIT;
787
788    return eError;
789}
790
791status_t OMXCameraAdapter::setSharpness(Gen3A_settings& Gen3A)
792{
793    OMX_ERRORTYPE eError = OMX_ErrorNone;
794    OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE procSharpness;
795
796    LOG_FUNCTION_NAME;
797
798    if ( OMX_StateInvalid == mComponentState )
799        {
800        CAMHAL_LOGEA("OMX component is in invalid state");
801        return NO_INIT;
802        }
803
804    OMX_INIT_STRUCT_PTR (&procSharpness, OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE);
805    procSharpness.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
806    procSharpness.nLevel = Gen3A.Sharpness;
807
808    if( procSharpness.nLevel == 0 )
809        {
810        procSharpness.bAuto = OMX_TRUE;
811        }
812    else
813        {
814        procSharpness.bAuto = OMX_FALSE;
815        }
816
817    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
818                         (OMX_INDEXTYPE)OMX_IndexConfigSharpeningLevel,
819                         &procSharpness);
820    if ( OMX_ErrorNone != eError )
821        {
822        CAMHAL_LOGEB("Error while configuring Sharpness 0x%x error = 0x%x",
823                     ( unsigned int ) procSharpness.nLevel,
824                     eError);
825        }
826    else
827        {
828        CAMHAL_LOGDB("Sharpness 0x%x configured successfully",
829                     ( unsigned int ) procSharpness.nLevel);
830        }
831
832    LOG_FUNCTION_NAME_EXIT;
833
834    return ErrorUtils::omxToAndroidError(eError);
835}
836
837status_t OMXCameraAdapter::setSaturation(Gen3A_settings& Gen3A)
838{
839    OMX_ERRORTYPE eError = OMX_ErrorNone;
840    OMX_CONFIG_SATURATIONTYPE saturation;
841
842    LOG_FUNCTION_NAME;
843
844    if ( OMX_StateInvalid == mComponentState )
845        {
846        CAMHAL_LOGEA("OMX component is in invalid state");
847        return NO_INIT;
848        }
849
850    OMX_INIT_STRUCT_PTR (&saturation, OMX_CONFIG_SATURATIONTYPE);
851    saturation.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
852    saturation.nSaturation = Gen3A.Saturation;
853
854    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
855                         OMX_IndexConfigCommonSaturation,
856                         &saturation);
857    if ( OMX_ErrorNone != eError )
858        {
859        CAMHAL_LOGEB("Error while configuring Saturation 0x%x error = 0x%x",
860                     ( unsigned int ) saturation.nSaturation,
861                     eError);
862        }
863    else
864        {
865        CAMHAL_LOGDB("Saturation 0x%x configured successfully",
866                     ( unsigned int ) saturation.nSaturation);
867        }
868
869    LOG_FUNCTION_NAME_EXIT;
870
871    return ErrorUtils::omxToAndroidError(eError);
872}
873
874status_t OMXCameraAdapter::setISO(Gen3A_settings& Gen3A)
875{
876    OMX_ERRORTYPE eError = OMX_ErrorNone;
877    OMX_CONFIG_EXPOSUREVALUETYPE expValues;
878
879    LOG_FUNCTION_NAME;
880
881    if ( OMX_StateInvalid == mComponentState )
882        {
883        CAMHAL_LOGEA("OMX component is in invalid state");
884        return NO_INIT;
885        }
886
887    OMX_INIT_STRUCT_PTR (&expValues, OMX_CONFIG_EXPOSUREVALUETYPE);
888    expValues.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
889
890    OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
891                   OMX_IndexConfigCommonExposureValue,
892                   &expValues);
893
894    if( 0 == Gen3A.ISO )
895        {
896        expValues.bAutoSensitivity = OMX_TRUE;
897        }
898    else
899        {
900        expValues.bAutoSensitivity = OMX_FALSE;
901        expValues.nSensitivity = Gen3A.ISO;
902        }
903
904    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
905                         OMX_IndexConfigCommonExposureValue,
906                         &expValues);
907    if ( OMX_ErrorNone != eError )
908        {
909        CAMHAL_LOGEB("Error while configuring ISO 0x%x error = 0x%x",
910                     ( unsigned int ) expValues.nSensitivity,
911                     eError);
912        }
913    else
914        {
915        CAMHAL_LOGDB("ISO 0x%x configured successfully",
916                     ( unsigned int ) expValues.nSensitivity);
917        }
918
919    LOG_FUNCTION_NAME_EXIT;
920
921    return ErrorUtils::omxToAndroidError(eError);
922}
923
924status_t OMXCameraAdapter::setEffect(Gen3A_settings& Gen3A)
925{
926    OMX_ERRORTYPE eError = OMX_ErrorNone;
927    OMX_CONFIG_IMAGEFILTERTYPE effect;
928
929    LOG_FUNCTION_NAME;
930
931    if ( OMX_StateInvalid == mComponentState )
932        {
933        CAMHAL_LOGEA("OMX component is in invalid state");
934        return NO_INIT;
935        }
936
937    OMX_INIT_STRUCT_PTR (&effect, OMX_CONFIG_IMAGEFILTERTYPE);
938    effect.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
939    effect.eImageFilter = (OMX_IMAGEFILTERTYPE ) Gen3A.Effect;
940
941    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
942                         OMX_IndexConfigCommonImageFilter,
943                         &effect);
944    if ( OMX_ErrorNone != eError )
945        {
946        CAMHAL_LOGEB("Error while configuring Effect 0x%x error = 0x%x",
947                     ( unsigned int )  effect.eImageFilter,
948                     eError);
949        }
950    else
951        {
952        CAMHAL_LOGDB("Effect 0x%x configured successfully",
953                     ( unsigned int )  effect.eImageFilter);
954        }
955
956    LOG_FUNCTION_NAME_EXIT;
957
958    return ErrorUtils::omxToAndroidError(eError);
959}
960
961status_t OMXCameraAdapter::setWhiteBalanceLock(Gen3A_settings& Gen3A)
962{
963  OMX_ERRORTYPE eError = OMX_ErrorNone;
964  OMX_IMAGE_CONFIG_LOCKTYPE lock;
965
966  LOG_FUNCTION_NAME
967
968  if ( OMX_StateInvalid == mComponentState )
969    {
970      CAMHAL_LOGEA("OMX component is in invalid state");
971      return NO_INIT;
972    }
973
974  OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
975  lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
976  lock.bLock = Gen3A.WhiteBalanceLock;
977  eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
978                          (OMX_INDEXTYPE)OMX_IndexConfigImageWhiteBalanceLock,
979                          &lock);
980  if ( OMX_ErrorNone != eError )
981    {
982      CAMHAL_LOGEB("Error while configuring WhiteBalance Lock error = 0x%x", eError);
983    }
984  else
985    {
986      CAMHAL_LOGDB("WhiteBalance Lock configured successfully %d ", lock.bLock);
987    }
988  LOG_FUNCTION_NAME_EXIT
989
990  return ErrorUtils::omxToAndroidError(eError);
991}
992
993status_t OMXCameraAdapter::setExposureLock(Gen3A_settings& Gen3A)
994{
995  OMX_ERRORTYPE eError = OMX_ErrorNone;
996  OMX_IMAGE_CONFIG_LOCKTYPE lock;
997
998  LOG_FUNCTION_NAME
999
1000  if ( OMX_StateInvalid == mComponentState )
1001    {
1002      CAMHAL_LOGEA("OMX component is in invalid state");
1003      return NO_INIT;
1004    }
1005
1006  OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
1007  lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1008  lock.bLock = Gen3A.ExposureLock;
1009  eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
1010                          (OMX_INDEXTYPE)OMX_IndexConfigImageExposureLock,
1011                          &lock);
1012  if ( OMX_ErrorNone != eError )
1013    {
1014      CAMHAL_LOGEB("Error while configuring Exposure Lock error = 0x%x", eError);
1015    }
1016  else
1017    {
1018      CAMHAL_LOGDB("Exposure Lock configured successfully %d ", lock.bLock);
1019    }
1020  LOG_FUNCTION_NAME_EXIT
1021
1022    return ErrorUtils::omxToAndroidError(eError);
1023}
1024
1025status_t OMXCameraAdapter::set3ALock(OMX_BOOL toggle)
1026{
1027  OMX_ERRORTYPE eError = OMX_ErrorNone;
1028  OMX_IMAGE_CONFIG_LOCKTYPE lock;
1029  char* index = FALSE;
1030
1031  LOG_FUNCTION_NAME
1032
1033  if ( OMX_StateInvalid == mComponentState )
1034    {
1035      CAMHAL_LOGEA("OMX component is in invalid state");
1036      return NO_INIT;
1037    }
1038
1039  OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
1040  lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1041
1042  mParameters3A.ExposureLock = toggle;
1043  mParameters3A.WhiteBalanceLock = toggle;
1044
1045  eError = OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
1046                          (OMX_INDEXTYPE)OMX_IndexConfigImageExposureLock,
1047                          &lock);
1048  if ( OMX_ErrorNone != eError )
1049    {
1050      CAMHAL_LOGEB("Error GetConfig Exposure Lock error = 0x%x", eError);
1051    }
1052  else
1053    {
1054      CAMHAL_LOGDA("Exposure Lock GetConfig successfull");
1055    }
1056
1057  /* Apply locks only when not applied already */
1058  if ( lock.bLock  != toggle )
1059    {
1060      setExposureLock(mParameters3A);
1061    }
1062
1063  eError = OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
1064                          (OMX_INDEXTYPE)OMX_IndexConfigImageWhiteBalanceLock,
1065                          &lock);
1066  if ( OMX_ErrorNone != eError )
1067    {
1068      CAMHAL_LOGEB("Error GetConfig WhiteBalance Lock error = 0x%x", eError);
1069    }
1070  else
1071    {
1072      CAMHAL_LOGDA("WhiteBalance Lock GetConfig successfull");
1073    }
1074
1075  /* Apply locks only when not applied already */
1076  if ( lock.bLock != toggle )
1077    {
1078      setWhiteBalanceLock(mParameters3A);
1079    }
1080
1081  const char *lock_state = toggle ? TRUE : FALSE;
1082  mParams.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, lock_state);
1083  mParams.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, lock_state);
1084
1085  return ErrorUtils::omxToAndroidError(eError);
1086
1087}
1088
1089status_t OMXCameraAdapter::setMeteringAreas(Gen3A_settings& Gen3A)
1090{
1091  status_t ret = NO_ERROR;
1092  OMX_ERRORTYPE eError = OMX_ErrorNone;
1093
1094  OMX_ALGOAREASTYPE **meteringAreas;
1095  OMX_TI_CONFIG_SHAREDBUFFER sharedBuffer;
1096  MemoryManager memMgr;
1097  int areasSize = 0;
1098
1099  LOG_FUNCTION_NAME
1100
1101  if ( OMX_StateInvalid == mComponentState )
1102    {
1103      CAMHAL_LOGEA("OMX component is in invalid state");
1104      return NO_INIT;
1105    }
1106
1107  areasSize = ((sizeof(OMX_ALGOAREASTYPE)+4095)/4096)*4096;
1108  meteringAreas = (OMX_ALGOAREASTYPE**) memMgr.allocateBuffer(0, 0, NULL, areasSize, 1);
1109
1110  OMXCameraPortParameters * mPreviewData = NULL;
1111  mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
1112
1113  if (!meteringAreas)
1114      {
1115      CAMHAL_LOGEB("Error allocating buffer for metering areas %d", eError);
1116      return -ENOMEM;
1117      }
1118
1119  OMX_INIT_STRUCT_PTR (meteringAreas[0], OMX_ALGOAREASTYPE);
1120
1121  meteringAreas[0]->nPortIndex = OMX_ALL;
1122  meteringAreas[0]->nNumAreas = mMeteringAreas.size();
1123  meteringAreas[0]->nAlgoAreaPurpose = OMX_AlgoAreaExposure;
1124
1125  for ( unsigned int n = 0; n < mMeteringAreas.size(); n++)
1126      {
1127      // transform the coordinates to 3A-type coordinates
1128      mMeteringAreas.itemAt(n)->transfrom((size_t)mPreviewData->mWidth,
1129                                      (size_t)mPreviewData->mHeight,
1130                                      (size_t&)meteringAreas[0]->tAlgoAreas[n].nTop,
1131                                      (size_t&)meteringAreas[0]->tAlgoAreas[n].nLeft,
1132                                      (size_t&)meteringAreas[0]->tAlgoAreas[n].nWidth,
1133                                      (size_t&)meteringAreas[0]->tAlgoAreas[n].nHeight);
1134
1135      meteringAreas[0]->tAlgoAreas[n].nLeft =
1136              ( meteringAreas[0]->tAlgoAreas[n].nLeft * METERING_AREAS_RANGE ) / mPreviewData->mWidth;
1137      meteringAreas[0]->tAlgoAreas[n].nTop =
1138              ( meteringAreas[0]->tAlgoAreas[n].nTop* METERING_AREAS_RANGE ) / mPreviewData->mHeight;
1139      meteringAreas[0]->tAlgoAreas[n].nWidth =
1140              ( meteringAreas[0]->tAlgoAreas[n].nWidth * METERING_AREAS_RANGE ) / mPreviewData->mWidth;
1141      meteringAreas[0]->tAlgoAreas[n].nHeight =
1142              ( meteringAreas[0]->tAlgoAreas[n].nHeight * METERING_AREAS_RANGE ) / mPreviewData->mHeight;
1143
1144      meteringAreas[0]->tAlgoAreas[n].nPriority = mMeteringAreas.itemAt(n)->getWeight();
1145
1146      CAMHAL_LOGDB("Metering area %d : top = %d left = %d width = %d height = %d prio = %d",
1147              n, (int)meteringAreas[0]->tAlgoAreas[n].nTop, (int)meteringAreas[0]->tAlgoAreas[n].nLeft,
1148              (int)meteringAreas[0]->tAlgoAreas[n].nWidth, (int)meteringAreas[0]->tAlgoAreas[n].nHeight,
1149              (int)meteringAreas[0]->tAlgoAreas[n].nPriority);
1150
1151      }
1152
1153  OMX_INIT_STRUCT_PTR (&sharedBuffer, OMX_TI_CONFIG_SHAREDBUFFER);
1154
1155  sharedBuffer.nPortIndex = OMX_ALL;
1156  sharedBuffer.nSharedBuffSize = areasSize;
1157  sharedBuffer.pSharedBuff = (OMX_U8 *) meteringAreas[0];
1158
1159  if ( NULL == sharedBuffer.pSharedBuff )
1160      {
1161      CAMHAL_LOGEA("No resources to allocate OMX shared buffer");
1162      ret = -ENOMEM;
1163      goto EXIT;
1164      }
1165
1166      eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
1167                                (OMX_INDEXTYPE) OMX_TI_IndexConfigAlgoAreas, &sharedBuffer);
1168
1169  if ( OMX_ErrorNone != eError )
1170      {
1171      CAMHAL_LOGEB("Error while setting Focus Areas configuration 0x%x", eError);
1172      ret = -EINVAL;
1173      }
1174  else
1175      {
1176      CAMHAL_LOGDA("Metering Areas SetConfig successfull.");
1177      }
1178
1179 EXIT:
1180  if (NULL != meteringAreas)
1181      {
1182      memMgr.freeBuffer((void*) meteringAreas);
1183      meteringAreas = NULL;
1184      }
1185
1186  return ret;
1187}
1188
1189status_t OMXCameraAdapter::apply3Asettings( Gen3A_settings& Gen3A )
1190{
1191    status_t ret = NO_ERROR;
1192    unsigned int currSett; // 32 bit
1193    int portIndex;
1194
1195    /*
1196     * Scenes have a priority during the process
1197     * of applying 3A related parameters.
1198     * They can override pretty much all other 3A
1199     * settings and similarly get overridden when
1200     * for instance the focus mode gets switched.
1201     * There is only one exception to this rule,
1202     * the manual a.k.a. auto scene.
1203     */
1204    if ( ( SetSceneMode & mPending3Asettings ) )
1205        {
1206        mPending3Asettings &= ~SetSceneMode;
1207        return setScene(Gen3A);
1208        }
1209    else if ( OMX_Manual != Gen3A.SceneMode )
1210        {
1211        mPending3Asettings = 0;
1212        return NO_ERROR;
1213        }
1214
1215    for( currSett = 1; currSett < E3aSettingMax; currSett <<= 1)
1216        {
1217        if( currSett & mPending3Asettings )
1218            {
1219            switch( currSett )
1220                {
1221                case SetEVCompensation:
1222                    {
1223                    ret |= setEVCompensation(Gen3A);
1224                    break;
1225                    }
1226
1227                case SetWhiteBallance:
1228                    {
1229                    ret |= setWBMode(Gen3A);
1230                    break;
1231                    }
1232
1233                case SetFlicker:
1234                    {
1235                    ret |= setFlicker(Gen3A);
1236                    break;
1237                    }
1238
1239                case SetBrightness:
1240                    {
1241                    ret |= setBrightness(Gen3A);
1242                    break;
1243                    }
1244
1245                case SetContrast:
1246                    {
1247                    ret |= setContrast(Gen3A);
1248                    break;
1249                    }
1250
1251                case SetSharpness:
1252                    {
1253                    ret |= setSharpness(Gen3A);
1254                    break;
1255                    }
1256
1257                case SetSaturation:
1258                    {
1259                    ret |= setSaturation(Gen3A);
1260                    break;
1261                    }
1262
1263                case SetISO:
1264                    {
1265                    ret |= setISO(Gen3A);
1266                    break;
1267                    }
1268
1269                case SetEffect:
1270                    {
1271                    ret |= setEffect(Gen3A);
1272                    break;
1273                    }
1274
1275                case SetFocus:
1276                    {
1277                    ret |= setFocusMode(Gen3A);
1278                    break;
1279                    }
1280
1281                case SetExpMode:
1282                    {
1283                    ret |= setExposureMode(Gen3A);
1284                    break;
1285                    }
1286
1287                case SetFlash:
1288                    {
1289                    ret |= setFlashMode(Gen3A);
1290                    break;
1291                    }
1292
1293                case SetExpLock:
1294                  {
1295                    ret |= setExposureLock(Gen3A);
1296                    break;
1297                  }
1298
1299                case SetWBLock:
1300                  {
1301                    ret |= setWhiteBalanceLock(Gen3A);
1302                    break;
1303                  }
1304                case SetMeteringAreas:
1305                  {
1306                    ret |= setMeteringAreas(Gen3A);
1307                  }
1308
1309                default:
1310                    CAMHAL_LOGEB("this setting (0x%x) is still not supported in CameraAdapter ",
1311                                 currSett);
1312                    break;
1313                }
1314                mPending3Asettings &= ~currSett;
1315            }
1316        }
1317        return ret;
1318}
1319
1320};
1321