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