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