OMX3A.cpp revision 5458bdc45048501d1919b14d22456de91f7e8950 
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        size_t MAX_METERING_AREAS;
274        Vector< sp<CameraArea> > tempAreas;
275
276        MAX_METERING_AREAS = atoi(params.get(CameraParameters::KEY_MAX_NUM_METERING_AREAS));
277
278        Mutex::Autolock lock(mMeteringAreasLock);
279
280        ret = CameraArea::parseAreas(str, ( strlen(str) + 1 ), tempAreas);
281
282        CAMHAL_LOGVB("areAreasDifferent? = %d",
283                     CameraArea::areAreasDifferent(mMeteringAreas, tempAreas));
284
285        if ( (NO_ERROR == ret) && CameraArea::areAreasDifferent(mMeteringAreas, tempAreas) ) {
286            mMeteringAreas.clear();
287            mMeteringAreas = tempAreas;
288
289            if ( MAX_METERING_AREAS >= mMeteringAreas.size() ) {
290                CAMHAL_LOGDB("Setting Metering Areas %s",
291                        params.get(CameraParameters::KEY_METERING_AREAS));
292
293                mPending3Asettings |= SetMeteringAreas;
294            } else {
295                CAMHAL_LOGEB("Metering areas supported %d, metering areas set %d",
296                             MAX_METERING_AREAS, mMeteringAreas.size());
297                ret = -EINVAL;
298            }
299        }
300    }
301
302    LOG_FUNCTION_NAME_EXIT;
303
304    return ret;
305}
306
307int OMXCameraAdapter::getLUTvalue_HALtoOMX(const char * HalValue, LUTtype LUT)
308{
309    int LUTsize = LUT.size;
310    if( HalValue )
311        for(int i = 0; i < LUTsize; i++)
312            if( 0 == strcmp(LUT.Table[i].userDefinition, HalValue) )
313                return LUT.Table[i].omxDefinition;
314
315    return -ENOENT;
316}
317
318const char* OMXCameraAdapter::getLUTvalue_OMXtoHAL(int OMXValue, LUTtype LUT)
319{
320    int LUTsize = LUT.size;
321    for(int i = 0; i < LUTsize; i++)
322        if( LUT.Table[i].omxDefinition == OMXValue )
323            return LUT.Table[i].userDefinition;
324
325    return NULL;
326}
327
328status_t OMXCameraAdapter::apply3ADefaults(Gen3A_settings &Gen3A)
329{
330    status_t ret = NO_ERROR;
331
332    LOG_FUNCTION_NAME;
333
334    Gen3A.Effect = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_EFFECT, EffLUT);
335    ret |= setEffect(Gen3A);
336
337    Gen3A.FlashMode = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_FLASH_MODE, FlashLUT);
338    ret |= setFlashMode(Gen3A);
339
340    Gen3A.SceneMode = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_SCENE_MODE, SceneLUT);
341    ret |= setScene(Gen3A);
342
343    Gen3A.EVCompensation = atoi(OMXCameraAdapter::DEFAULT_EV_COMPENSATION);
344    ret |= setEVCompensation(Gen3A);
345
346    Gen3A.Focus = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_FOCUS_MODE, FocusLUT);
347    ret |= setFocusMode(Gen3A);
348
349    Gen3A.ISO = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_ISO_MODE, IsoLUT);
350    ret |= setISO(Gen3A);
351
352    Gen3A.Flicker = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_ANTIBANDING, FlickerLUT);
353    ret |= setFlicker(Gen3A);
354
355    Gen3A.Brightness = atoi(OMXCameraAdapter::DEFAULT_BRIGHTNESS);
356    ret |= setBrightness(Gen3A);
357
358    Gen3A.Saturation = atoi(OMXCameraAdapter::DEFAULT_SATURATION);
359    ret |= setSaturation(Gen3A);
360
361    Gen3A.Sharpness = atoi(OMXCameraAdapter::DEFAULT_SHARPNESS);
362    ret |= setSharpness(Gen3A);
363
364    Gen3A.Contrast = atoi(OMXCameraAdapter::DEFAULT_CONTRAST);
365    ret |= setContrast(Gen3A);
366
367    Gen3A.WhiteBallance = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_WB, WBalLUT);
368    ret |= setWBMode(Gen3A);
369
370    Gen3A.Exposure = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_EXPOSURE_MODE, ExpLUT);
371    ret |= setExposureMode(Gen3A);
372
373    Gen3A.ExposureLock = OMX_FALSE;
374    ret |= setExposureLock(Gen3A);
375
376    Gen3A.FocusLock = OMX_FALSE;
377    ret |= setFocusLock(Gen3A);
378
379    Gen3A.WhiteBalanceLock = OMX_FALSE;
380    ret |= setWhiteBalanceLock(Gen3A);
381
382    LOG_FUNCTION_NAME_EXIT;
383
384    return NO_ERROR;
385}
386
387status_t OMXCameraAdapter::setExposureMode(Gen3A_settings& Gen3A)
388{
389    OMX_ERRORTYPE eError = OMX_ErrorNone;
390    OMX_CONFIG_EXPOSURECONTROLTYPE exp;
391
392    LOG_FUNCTION_NAME;
393
394    if ( OMX_StateInvalid == mComponentState )
395        {
396        CAMHAL_LOGEA("OMX component is in invalid state");
397        return NO_INIT;
398        }
399
400    OMX_INIT_STRUCT_PTR (&exp, OMX_CONFIG_EXPOSURECONTROLTYPE);
401    exp.nPortIndex = OMX_ALL;
402    exp.eExposureControl = (OMX_EXPOSURECONTROLTYPE)Gen3A.Exposure;
403
404///FIXME: Face priority exposure metering is not stable because of varying face sizes
405///coming from the FD module. So disabling it for now.
406#if 0
407    if ( mFaceDetectionRunning )
408        {
409        //Disable Region priority and enable Face priority
410        setAlgoPriority(REGION_PRIORITY, EXPOSURE_ALGO, false);
411        setAlgoPriority(FACE_PRIORITY, EXPOSURE_ALGO, true);
412        }
413    else
414#endif
415        {
416        //Disable Region priority and Face priority
417        setAlgoPriority(REGION_PRIORITY, EXPOSURE_ALGO, false);
418        setAlgoPriority(FACE_PRIORITY, EXPOSURE_ALGO, false);
419        }
420
421    eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
422                            OMX_IndexConfigCommonExposure,
423                            &exp);
424    if ( OMX_ErrorNone != eError )
425        {
426        CAMHAL_LOGEB("Error while configuring exposure mode 0x%x", eError);
427        }
428    else
429        {
430        CAMHAL_LOGDA("Camera exposure mode configured successfully");
431        }
432
433    LOG_FUNCTION_NAME_EXIT;
434
435    return ErrorUtils::omxToAndroidError(eError);
436}
437
438status_t OMXCameraAdapter::setFlashMode(Gen3A_settings& Gen3A)
439{
440    status_t ret = NO_ERROR;
441    OMX_ERRORTYPE eError = OMX_ErrorNone;
442    OMX_IMAGE_PARAM_FLASHCONTROLTYPE flash;
443    OMX_CONFIG_FOCUSASSISTTYPE focusAssist;
444
445    LOG_FUNCTION_NAME;
446
447    if ( OMX_StateInvalid == mComponentState )
448        {
449        CAMHAL_LOGEA("OMX component is in invalid state");
450        return NO_INIT;
451        }
452
453    OMX_INIT_STRUCT_PTR (&flash, OMX_IMAGE_PARAM_FLASHCONTROLTYPE);
454    flash.nPortIndex = OMX_ALL;
455    flash.eFlashControl = ( OMX_IMAGE_FLASHCONTROLTYPE ) Gen3A.FlashMode;
456
457    CAMHAL_LOGDB("Configuring flash mode 0x%x", flash.eFlashControl);
458    eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
459                            (OMX_INDEXTYPE) OMX_IndexConfigFlashControl,
460                            &flash);
461    if ( OMX_ErrorNone != eError )
462        {
463        CAMHAL_LOGEB("Error while configuring flash mode 0x%x", eError);
464        }
465    else
466        {
467        CAMHAL_LOGDA("Camera flash mode configured successfully");
468        }
469
470    if ( OMX_ErrorNone == eError )
471        {
472        OMX_INIT_STRUCT_PTR (&focusAssist, OMX_CONFIG_FOCUSASSISTTYPE);
473        focusAssist.nPortIndex = OMX_ALL;
474        if ( flash.eFlashControl == OMX_IMAGE_FlashControlOff )
475            {
476            focusAssist.bFocusAssist = OMX_FALSE;
477            }
478        else
479            {
480            focusAssist.bFocusAssist = OMX_TRUE;
481            }
482
483        CAMHAL_LOGDB("Configuring AF Assist mode 0x%x", focusAssist.bFocusAssist);
484        eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
485                                (OMX_INDEXTYPE) OMX_IndexConfigFocusAssist,
486                                &focusAssist);
487        if ( OMX_ErrorNone != eError )
488            {
489            CAMHAL_LOGEB("Error while configuring AF Assist mode 0x%x", eError);
490            }
491        else
492            {
493            CAMHAL_LOGDA("Camera AF Assist  mode configured successfully");
494            }
495        }
496
497    LOG_FUNCTION_NAME_EXIT;
498
499    return ErrorUtils::omxToAndroidError(eError);
500}
501
502status_t OMXCameraAdapter::setFocusMode(Gen3A_settings& Gen3A)
503{
504    status_t ret = NO_ERROR;
505    OMX_ERRORTYPE eError = OMX_ErrorNone;
506    OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE focus;
507    size_t top, left, width, height, weight;
508
509    LOG_FUNCTION_NAME;
510
511    BaseCameraAdapter::AdapterState state;
512    BaseCameraAdapter::getState(state);
513
514    if ( OMX_StateInvalid == mComponentState )
515        {
516        CAMHAL_LOGEA("OMX component is in invalid state");
517        return NO_INIT;
518        }
519
520
521    ///Face detection takes precedence over touch AF
522    if ( mFaceDetectionRunning )
523        {
524        //Disable region priority first
525        setAlgoPriority(REGION_PRIORITY, FOCUS_ALGO, false);
526
527        //Enable face algorithm priority for focus
528        setAlgoPriority(FACE_PRIORITY, FOCUS_ALGO , true);
529
530        //Do normal focus afterwards
531        ////FIXME: Check if the extended focus control is needed? this overrides caf
532        //focusControl.eFocusControl = ( OMX_IMAGE_FOCUSCONTROLTYPE ) OMX_IMAGE_FocusControlExtended;
533        }
534    else if ( (!mFocusAreas.isEmpty()) && (!mFocusAreas.itemAt(0)->isZeroArea()) )
535        {
536
537        //Disable face priority first
538        setAlgoPriority(FACE_PRIORITY, FOCUS_ALGO, false);
539
540        //Enable region algorithm priority
541        setAlgoPriority(REGION_PRIORITY, FOCUS_ALGO, true);
542
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::setFocusLock(Gen3A_settings& Gen3A)
1060{
1061    OMX_ERRORTYPE eError = OMX_ErrorNone;
1062    OMX_IMAGE_CONFIG_LOCKTYPE lock;
1063
1064    LOG_FUNCTION_NAME
1065
1066    if ( OMX_StateInvalid == mComponentState ) {
1067        CAMHAL_LOGEA("OMX component is in invalid state");
1068        return NO_INIT;
1069    }
1070
1071    OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
1072    lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1073
1074    lock.bLock = Gen3A.FocusLock;
1075    eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
1076                           (OMX_INDEXTYPE)OMX_IndexConfigImageFocusLock,
1077                           &lock);
1078
1079    if ( OMX_ErrorNone != eError ) {
1080        CAMHAL_LOGEB("Error while configuring Focus Lock error = 0x%x", eError);
1081    } else {
1082        CAMHAL_LOGDB("Focus Lock configured successfully %d ", lock.bLock);
1083    }
1084
1085    LOG_FUNCTION_NAME_EXIT
1086
1087    return ErrorUtils::omxToAndroidError(eError);
1088}
1089
1090status_t OMXCameraAdapter::set3ALock(OMX_BOOL toggleExp, OMX_BOOL toggleWb, OMX_BOOL toggleFocus)
1091{
1092    OMX_ERRORTYPE eError = OMX_ErrorNone;
1093    OMX_IMAGE_CONFIG_LOCKTYPE lock;
1094
1095    LOG_FUNCTION_NAME
1096
1097    if ( OMX_StateInvalid == mComponentState )
1098    {
1099      CAMHAL_LOGEA("OMX component is in invalid state");
1100      return NO_INIT;
1101    }
1102
1103    OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
1104    lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1105
1106    mParameters3A.ExposureLock = toggleExp;
1107    mParameters3A.FocusLock = toggleFocus;
1108    mParameters3A.WhiteBalanceLock = toggleWb;
1109
1110    eError = OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
1111                            (OMX_INDEXTYPE)OMX_IndexConfigImageExposureLock,
1112                            &lock);
1113
1114    if ( OMX_ErrorNone != eError )
1115    {
1116        CAMHAL_LOGEB("Error GetConfig Exposure Lock error = 0x%x", eError);
1117        goto EXIT;
1118    }
1119    else
1120    {
1121        const char *lock_state_exp = toggleExp ? TRUE : FALSE;
1122        CAMHAL_LOGDA("Exposure Lock GetConfig successfull");
1123
1124        /* Apply locks only when not applied already */
1125        if ( lock.bLock  != toggleExp )
1126        {
1127            setExposureLock(mParameters3A);
1128        }
1129
1130        mParams.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, lock_state_exp);
1131    }
1132
1133    OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
1134    lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1135    eError = OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
1136                            (OMX_INDEXTYPE)OMX_IndexConfigImageFocusLock,
1137                            &lock);
1138
1139    if ( OMX_ErrorNone != eError )
1140    {
1141        CAMHAL_LOGEB("Error GetConfig Focus Lock error = 0x%x", eError);
1142        goto EXIT;
1143    }
1144    else
1145    {
1146        CAMHAL_LOGDB("Focus Lock GetConfig successfull bLock(%d)", lock.bLock);
1147
1148        /* Apply locks only when not applied already */
1149        if ( lock.bLock  != toggleFocus )
1150        {
1151            setFocusLock(mParameters3A);
1152        }
1153    }
1154
1155    OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
1156    lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1157    eError = OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
1158                            (OMX_INDEXTYPE)OMX_IndexConfigImageWhiteBalanceLock,
1159                            &lock);
1160
1161    if ( OMX_ErrorNone != eError )
1162    {
1163        CAMHAL_LOGEB("Error GetConfig WhiteBalance Lock error = 0x%x", eError);
1164        goto EXIT;
1165    }
1166    else
1167    {
1168        const char *lock_state_wb = toggleWb ? TRUE : FALSE;
1169        CAMHAL_LOGDA("WhiteBalance Lock GetConfig successfull");
1170
1171        /* Apply locks only when not applied already */
1172        if ( lock.bLock != toggleWb )
1173        {
1174            setWhiteBalanceLock(mParameters3A);
1175        }
1176
1177        mParams.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, lock_state_wb);
1178    }
1179 EXIT:
1180    return ErrorUtils::omxToAndroidError(eError);
1181}
1182
1183status_t OMXCameraAdapter::setMeteringAreas(Gen3A_settings& Gen3A)
1184{
1185  status_t ret = NO_ERROR;
1186  OMX_ERRORTYPE eError = OMX_ErrorNone;
1187
1188  OMX_ALGOAREASTYPE **meteringAreas;
1189  OMX_TI_CONFIG_SHAREDBUFFER sharedBuffer;
1190  MemoryManager memMgr;
1191  int areasSize = 0;
1192
1193  LOG_FUNCTION_NAME
1194
1195  Mutex::Autolock lock(mMeteringAreasLock);
1196
1197  if ( OMX_StateInvalid == mComponentState )
1198    {
1199      CAMHAL_LOGEA("OMX component is in invalid state");
1200      return NO_INIT;
1201    }
1202
1203  areasSize = ((sizeof(OMX_ALGOAREASTYPE)+4095)/4096)*4096;
1204  meteringAreas = (OMX_ALGOAREASTYPE**) memMgr.allocateBuffer(0, 0, NULL, areasSize, 1);
1205
1206  OMXCameraPortParameters * mPreviewData = NULL;
1207  mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
1208
1209  if (!meteringAreas)
1210      {
1211      CAMHAL_LOGEB("Error allocating buffer for metering areas %d", eError);
1212      return -ENOMEM;
1213      }
1214
1215  OMX_INIT_STRUCT_PTR (meteringAreas[0], OMX_ALGOAREASTYPE);
1216
1217  meteringAreas[0]->nPortIndex = OMX_ALL;
1218  meteringAreas[0]->nNumAreas = mMeteringAreas.size();
1219  meteringAreas[0]->nAlgoAreaPurpose = OMX_AlgoAreaExposure;
1220
1221  for ( unsigned int n = 0; n < mMeteringAreas.size(); n++)
1222      {
1223      // transform the coordinates to 3A-type coordinates
1224      mMeteringAreas.itemAt(n)->transfrom((size_t)mPreviewData->mWidth,
1225                                      (size_t)mPreviewData->mHeight,
1226                                      (size_t&)meteringAreas[0]->tAlgoAreas[n].nTop,
1227                                      (size_t&)meteringAreas[0]->tAlgoAreas[n].nLeft,
1228                                      (size_t&)meteringAreas[0]->tAlgoAreas[n].nWidth,
1229                                      (size_t&)meteringAreas[0]->tAlgoAreas[n].nHeight);
1230
1231      meteringAreas[0]->tAlgoAreas[n].nLeft =
1232              ( meteringAreas[0]->tAlgoAreas[n].nLeft * METERING_AREAS_RANGE ) / mPreviewData->mWidth;
1233      meteringAreas[0]->tAlgoAreas[n].nTop =
1234              ( meteringAreas[0]->tAlgoAreas[n].nTop* METERING_AREAS_RANGE ) / mPreviewData->mHeight;
1235      meteringAreas[0]->tAlgoAreas[n].nWidth =
1236              ( meteringAreas[0]->tAlgoAreas[n].nWidth * METERING_AREAS_RANGE ) / mPreviewData->mWidth;
1237      meteringAreas[0]->tAlgoAreas[n].nHeight =
1238              ( meteringAreas[0]->tAlgoAreas[n].nHeight * METERING_AREAS_RANGE ) / mPreviewData->mHeight;
1239
1240      meteringAreas[0]->tAlgoAreas[n].nPriority = mMeteringAreas.itemAt(n)->getWeight();
1241
1242      CAMHAL_LOGDB("Metering area %d : top = %d left = %d width = %d height = %d prio = %d",
1243              n, (int)meteringAreas[0]->tAlgoAreas[n].nTop, (int)meteringAreas[0]->tAlgoAreas[n].nLeft,
1244              (int)meteringAreas[0]->tAlgoAreas[n].nWidth, (int)meteringAreas[0]->tAlgoAreas[n].nHeight,
1245              (int)meteringAreas[0]->tAlgoAreas[n].nPriority);
1246
1247      }
1248
1249  OMX_INIT_STRUCT_PTR (&sharedBuffer, OMX_TI_CONFIG_SHAREDBUFFER);
1250
1251  sharedBuffer.nPortIndex = OMX_ALL;
1252  sharedBuffer.nSharedBuffSize = areasSize;
1253  sharedBuffer.pSharedBuff = (OMX_U8 *) meteringAreas[0];
1254
1255  if ( NULL == sharedBuffer.pSharedBuff )
1256      {
1257      CAMHAL_LOGEA("No resources to allocate OMX shared buffer");
1258      ret = -ENOMEM;
1259      goto EXIT;
1260      }
1261
1262      eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
1263                                (OMX_INDEXTYPE) OMX_TI_IndexConfigAlgoAreas, &sharedBuffer);
1264
1265  if ( OMX_ErrorNone != eError )
1266      {
1267      CAMHAL_LOGEB("Error while setting Focus Areas configuration 0x%x", eError);
1268      ret = -EINVAL;
1269      }
1270  else
1271      {
1272      CAMHAL_LOGDA("Metering Areas SetConfig successfull.");
1273      }
1274
1275 EXIT:
1276  if (NULL != meteringAreas)
1277      {
1278      memMgr.freeBuffer((void*) meteringAreas);
1279      meteringAreas = NULL;
1280      }
1281
1282  return ret;
1283}
1284
1285status_t OMXCameraAdapter::apply3Asettings( Gen3A_settings& Gen3A )
1286{
1287    status_t ret = NO_ERROR;
1288    unsigned int currSett; // 32 bit
1289    int portIndex;
1290
1291    /*
1292     * Scenes have a priority during the process
1293     * of applying 3A related parameters.
1294     * They can override pretty much all other 3A
1295     * settings and similarly get overridden when
1296     * for instance the focus mode gets switched.
1297     * There is only one exception to this rule,
1298     * the manual a.k.a. auto scene.
1299     */
1300    if ( ( SetSceneMode & mPending3Asettings ) )
1301        {
1302        mPending3Asettings &= ~SetSceneMode;
1303        return setScene(Gen3A);
1304        }
1305    else if ( OMX_Manual != Gen3A.SceneMode )
1306        {
1307        mPending3Asettings = 0;
1308        return NO_ERROR;
1309        }
1310
1311    for( currSett = 1; currSett < E3aSettingMax; currSett <<= 1)
1312        {
1313        if( currSett & mPending3Asettings )
1314            {
1315            switch( currSett )
1316                {
1317                case SetEVCompensation:
1318                    {
1319                    ret |= setEVCompensation(Gen3A);
1320                    break;
1321                    }
1322
1323                case SetWhiteBallance:
1324                    {
1325                    ret |= setWBMode(Gen3A);
1326                    break;
1327                    }
1328
1329                case SetFlicker:
1330                    {
1331                    ret |= setFlicker(Gen3A);
1332                    break;
1333                    }
1334
1335                case SetBrightness:
1336                    {
1337                    ret |= setBrightness(Gen3A);
1338                    break;
1339                    }
1340
1341                case SetContrast:
1342                    {
1343                    ret |= setContrast(Gen3A);
1344                    break;
1345                    }
1346
1347                case SetSharpness:
1348                    {
1349                    ret |= setSharpness(Gen3A);
1350                    break;
1351                    }
1352
1353                case SetSaturation:
1354                    {
1355                    ret |= setSaturation(Gen3A);
1356                    break;
1357                    }
1358
1359                case SetISO:
1360                    {
1361                    ret |= setISO(Gen3A);
1362                    break;
1363                    }
1364
1365                case SetEffect:
1366                    {
1367                    ret |= setEffect(Gen3A);
1368                    break;
1369                    }
1370
1371                case SetFocus:
1372                    {
1373                    ret |= setFocusMode(Gen3A);
1374                    break;
1375                    }
1376
1377                case SetExpMode:
1378                    {
1379                    ret |= setExposureMode(Gen3A);
1380                    break;
1381                    }
1382
1383                case SetFlash:
1384                    {
1385                    ret |= setFlashMode(Gen3A);
1386                    break;
1387                    }
1388
1389                case SetExpLock:
1390                  {
1391                    ret |= setExposureLock(Gen3A);
1392                    break;
1393                  }
1394
1395                case SetWBLock:
1396                  {
1397                    ret |= setWhiteBalanceLock(Gen3A);
1398                    break;
1399                  }
1400                case SetMeteringAreas:
1401                  {
1402                    ret |= setMeteringAreas(Gen3A);
1403                  }
1404                  break;
1405                default:
1406                    CAMHAL_LOGEB("this setting (0x%x) is still not supported in CameraAdapter ",
1407                                 currSett);
1408                    break;
1409                }
1410                mPending3Asettings &= ~currSett;
1411            }
1412        }
1413        return ret;
1414}
1415
1416};
1417