OMX3A.cpp revision d9c52eb4fa1e27ffd33f22d9987f60a8a714b7bf 
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    sp<CameraArea> focusArea = NULL;
503
504    LOG_FUNCTION_NAME;
505
506    BaseCameraAdapter::AdapterState state;
507    BaseCameraAdapter::getState(state);
508
509    if ( OMX_StateInvalid == mComponentState )
510        {
511        CAMHAL_LOGEA("OMX component is in invalid state");
512        return NO_INIT;
513        }
514
515        {
516        Mutex::Autolock lock(mFocusAreasLock);
517
518        if ( !mFocusAreas.isEmpty() )
519            {
520            focusArea = mFocusAreas.itemAt(0);
521            }
522        }
523
524    ///Face detection takes precedence over touch AF
525    if ( mFaceDetectionRunning )
526        {
527        //Disable region priority first
528        setAlgoPriority(REGION_PRIORITY, FOCUS_ALGO, false);
529
530        //Enable face algorithm priority for focus
531        setAlgoPriority(FACE_PRIORITY, FOCUS_ALGO , true);
532
533        //Do normal focus afterwards
534        ////FIXME: Check if the extended focus control is needed? this overrides caf
535        //focusControl.eFocusControl = ( OMX_IMAGE_FOCUSCONTROLTYPE ) OMX_IMAGE_FocusControlExtended;
536        }
537    else if ( ( NULL != focusArea.get() ) && ( focusArea->isValid() ) )
538        {
539
540        //Disable face priority first
541        setAlgoPriority(FACE_PRIORITY, FOCUS_ALGO, false);
542
543        //Enable region algorithm priority
544        setAlgoPriority(REGION_PRIORITY, FOCUS_ALGO, true);
545
546        setTouchFocus();
547
548        //Do normal focus afterwards
549        //FIXME: Check if the extended focus control is needed? this overrides caf
550        //focus.eFocusControl = ( OMX_IMAGE_FOCUSCONTROLTYPE ) OMX_IMAGE_FocusControlExtended;
551
552        }
553    else
554        {
555
556        //Disable both region and face priority
557        setAlgoPriority(REGION_PRIORITY, FOCUS_ALGO, false);
558
559        setAlgoPriority(FACE_PRIORITY, FOCUS_ALGO, false);
560
561        }
562
563    if ( NO_ERROR == ret && ((state & AF_ACTIVE) == 0) )
564        {
565        OMX_INIT_STRUCT_PTR (&focus, OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE);
566        focus.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
567        focus.eFocusControl = (OMX_IMAGE_FOCUSCONTROLTYPE)Gen3A.Focus;
568
569        CAMHAL_LOGDB("Configuring focus mode 0x%x", focus.eFocusControl);
570        eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp, OMX_IndexConfigFocusControl, &focus);
571        if ( OMX_ErrorNone != eError )
572            {
573            CAMHAL_LOGEB("Error while configuring focus mode 0x%x", eError);
574            }
575        else
576            {
577            CAMHAL_LOGDA("Camera focus mode configured successfully");
578            }
579        }
580
581    LOG_FUNCTION_NAME_EXIT;
582
583    return ErrorUtils::omxToAndroidError(eError);
584}
585
586status_t OMXCameraAdapter::setScene(Gen3A_settings& Gen3A)
587{
588    OMX_ERRORTYPE eError = OMX_ErrorNone;
589    OMX_CONFIG_SCENEMODETYPE scene;
590
591    LOG_FUNCTION_NAME;
592
593    if ( OMX_StateInvalid == mComponentState )
594        {
595        CAMHAL_LOGEA("OMX component is in invalid state");
596        return NO_INIT;
597        }
598
599    OMX_INIT_STRUCT_PTR (&scene, OMX_CONFIG_SCENEMODETYPE);
600    scene.nPortIndex = OMX_ALL;
601    scene.eSceneMode = ( OMX_SCENEMODETYPE ) Gen3A.SceneMode;
602
603    CAMHAL_LOGDB("Configuring scene mode 0x%x", scene.eSceneMode);
604    eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
605                            ( OMX_INDEXTYPE ) OMX_TI_IndexConfigSceneMode,
606                            &scene);
607    if ( OMX_ErrorNone != eError )
608        {
609        CAMHAL_LOGEB("Error while configuring scene mode 0x%x", eError);
610        }
611    else
612        {
613        CAMHAL_LOGDA("Camera scene configured successfully");
614        }
615
616    LOG_FUNCTION_NAME_EXIT;
617
618    return ErrorUtils::omxToAndroidError(eError);
619}
620
621status_t OMXCameraAdapter::setEVCompensation(Gen3A_settings& Gen3A)
622{
623    OMX_ERRORTYPE eError = OMX_ErrorNone;
624    OMX_CONFIG_EXPOSUREVALUETYPE expValues;
625
626    LOG_FUNCTION_NAME;
627
628    if ( OMX_StateInvalid == mComponentState )
629        {
630        CAMHAL_LOGEA("OMX component is in invalid state");
631        return NO_INIT;
632        }
633
634    OMX_INIT_STRUCT_PTR (&expValues, OMX_CONFIG_EXPOSUREVALUETYPE);
635    expValues.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
636
637    OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
638                   OMX_IndexConfigCommonExposureValue,
639                   &expValues);
640    CAMHAL_LOGDB("old EV Compensation for OMX = 0x%x", (int)expValues.xEVCompensation);
641    CAMHAL_LOGDB("EV Compensation for HAL = %d", Gen3A.EVCompensation);
642
643    expValues.xEVCompensation = ( Gen3A.EVCompensation * ( 1 << Q16_OFFSET ) )  / 10;
644    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
645                            OMX_IndexConfigCommonExposureValue,
646                            &expValues);
647    CAMHAL_LOGDB("new EV Compensation for OMX = 0x%x", (int)expValues.xEVCompensation);
648    if ( OMX_ErrorNone != eError )
649        {
650        CAMHAL_LOGEB("Error while configuring EV Compensation 0x%x error = 0x%x",
651                     ( unsigned int ) expValues.xEVCompensation,
652                     eError);
653        }
654    else
655        {
656        CAMHAL_LOGDB("EV Compensation 0x%x configured successfully",
657                     ( unsigned int ) expValues.xEVCompensation);
658        }
659
660    LOG_FUNCTION_NAME_EXIT;
661
662    return ErrorUtils::omxToAndroidError(eError);
663}
664
665status_t OMXCameraAdapter::setWBMode(Gen3A_settings& Gen3A)
666{
667    OMX_ERRORTYPE eError = OMX_ErrorNone;
668    OMX_CONFIG_WHITEBALCONTROLTYPE wb;
669
670    LOG_FUNCTION_NAME;
671
672    if ( OMX_StateInvalid == mComponentState )
673        {
674        CAMHAL_LOGEA("OMX component is in invalid state");
675        return NO_INIT;
676        }
677
678    OMX_INIT_STRUCT_PTR (&wb, OMX_CONFIG_WHITEBALCONTROLTYPE);
679    wb.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
680    wb.eWhiteBalControl = ( OMX_WHITEBALCONTROLTYPE ) Gen3A.WhiteBallance;
681
682    if ( WB_FACE_PRIORITY == Gen3A.WhiteBallance )
683        {
684        //Disable Region priority and enable Face priority
685        setAlgoPriority(REGION_PRIORITY, WHITE_BALANCE_ALGO, false);
686        setAlgoPriority(FACE_PRIORITY, WHITE_BALANCE_ALGO, true);
687
688        //Then set the mode to auto
689        wb.eWhiteBalControl = OMX_WhiteBalControlAuto;
690        }
691    else
692        {
693        //Disable Face and Region priority
694        setAlgoPriority(FACE_PRIORITY, WHITE_BALANCE_ALGO, false);
695        setAlgoPriority(REGION_PRIORITY, WHITE_BALANCE_ALGO, false);
696        }
697
698    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
699                         OMX_IndexConfigCommonWhiteBalance,
700                         &wb);
701    if ( OMX_ErrorNone != eError )
702        {
703        CAMHAL_LOGEB("Error while configuring Whitebalance mode 0x%x error = 0x%x",
704                     ( unsigned int ) wb.eWhiteBalControl,
705                     eError);
706        }
707    else
708        {
709        CAMHAL_LOGDB("Whitebalance mode 0x%x configured successfully",
710                     ( unsigned int ) wb.eWhiteBalControl);
711        }
712
713    LOG_FUNCTION_NAME_EXIT;
714
715    return eError;
716}
717
718status_t OMXCameraAdapter::setFlicker(Gen3A_settings& Gen3A)
719{
720    OMX_ERRORTYPE eError = OMX_ErrorNone;
721    OMX_CONFIG_FLICKERCANCELTYPE flicker;
722
723    LOG_FUNCTION_NAME;
724
725    if ( OMX_StateInvalid == mComponentState )
726        {
727        CAMHAL_LOGEA("OMX component is in invalid state");
728        return NO_INIT;
729        }
730
731    OMX_INIT_STRUCT_PTR (&flicker, OMX_CONFIG_FLICKERCANCELTYPE);
732    flicker.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
733    flicker.eFlickerCancel = (OMX_COMMONFLICKERCANCELTYPE)Gen3A.Flicker;
734
735    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
736                            (OMX_INDEXTYPE)OMX_IndexConfigFlickerCancel,
737                            &flicker );
738    if ( OMX_ErrorNone != eError )
739        {
740        CAMHAL_LOGEB("Error while configuring Flicker mode 0x%x error = 0x%x",
741                     ( unsigned int ) flicker.eFlickerCancel,
742                     eError);
743        }
744    else
745        {
746        CAMHAL_LOGDB("Flicker mode 0x%x configured successfully",
747                     ( unsigned int ) flicker.eFlickerCancel);
748        }
749
750    LOG_FUNCTION_NAME_EXIT;
751
752    return ErrorUtils::omxToAndroidError(eError);
753}
754
755status_t OMXCameraAdapter::setBrightness(Gen3A_settings& Gen3A)
756{
757    OMX_ERRORTYPE eError = OMX_ErrorNone;
758    OMX_CONFIG_BRIGHTNESSTYPE brightness;
759
760    LOG_FUNCTION_NAME;
761
762    if ( OMX_StateInvalid == mComponentState )
763        {
764        CAMHAL_LOGEA("OMX component is in invalid state");
765        return NO_INIT;
766        }
767
768    OMX_INIT_STRUCT_PTR (&brightness, OMX_CONFIG_BRIGHTNESSTYPE);
769    brightness.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
770    brightness.nBrightness = Gen3A.Brightness;
771
772    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
773                         OMX_IndexConfigCommonBrightness,
774                         &brightness);
775    if ( OMX_ErrorNone != eError )
776        {
777        CAMHAL_LOGEB("Error while configuring Brightness 0x%x error = 0x%x",
778                     ( unsigned int ) brightness.nBrightness,
779                     eError);
780        }
781    else
782        {
783        CAMHAL_LOGDB("Brightness 0x%x configured successfully",
784                     ( unsigned int ) brightness.nBrightness);
785        }
786
787    LOG_FUNCTION_NAME_EXIT;
788
789    return ErrorUtils::omxToAndroidError(eError);
790}
791
792status_t OMXCameraAdapter::setContrast(Gen3A_settings& Gen3A)
793{
794    OMX_ERRORTYPE eError = OMX_ErrorNone;
795    OMX_CONFIG_CONTRASTTYPE contrast;
796
797    LOG_FUNCTION_NAME;
798
799    if ( OMX_StateInvalid == mComponentState )
800        {
801        CAMHAL_LOGEA("OMX component is in invalid state");
802        return NO_INIT;
803        }
804
805    OMX_INIT_STRUCT_PTR (&contrast, OMX_CONFIG_CONTRASTTYPE);
806    contrast.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
807    contrast.nContrast = Gen3A.Contrast;
808
809    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
810                         OMX_IndexConfigCommonContrast,
811                         &contrast);
812    if ( OMX_ErrorNone != eError )
813        {
814        CAMHAL_LOGEB("Error while configuring Contrast 0x%x error = 0x%x",
815                     ( unsigned int ) contrast.nContrast,
816                     eError);
817        }
818    else
819        {
820        CAMHAL_LOGDB("Contrast 0x%x configured successfully",
821                     ( unsigned int ) contrast.nContrast);
822        }
823
824    LOG_FUNCTION_NAME_EXIT;
825
826    return eError;
827}
828
829status_t OMXCameraAdapter::setSharpness(Gen3A_settings& Gen3A)
830{
831    OMX_ERRORTYPE eError = OMX_ErrorNone;
832    OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE procSharpness;
833
834    LOG_FUNCTION_NAME;
835
836    if ( OMX_StateInvalid == mComponentState )
837        {
838        CAMHAL_LOGEA("OMX component is in invalid state");
839        return NO_INIT;
840        }
841
842    OMX_INIT_STRUCT_PTR (&procSharpness, OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE);
843    procSharpness.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
844    procSharpness.nLevel = Gen3A.Sharpness;
845
846    if( procSharpness.nLevel == 0 )
847        {
848        procSharpness.bAuto = OMX_TRUE;
849        }
850    else
851        {
852        procSharpness.bAuto = OMX_FALSE;
853        }
854
855    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
856                         (OMX_INDEXTYPE)OMX_IndexConfigSharpeningLevel,
857                         &procSharpness);
858    if ( OMX_ErrorNone != eError )
859        {
860        CAMHAL_LOGEB("Error while configuring Sharpness 0x%x error = 0x%x",
861                     ( unsigned int ) procSharpness.nLevel,
862                     eError);
863        }
864    else
865        {
866        CAMHAL_LOGDB("Sharpness 0x%x configured successfully",
867                     ( unsigned int ) procSharpness.nLevel);
868        }
869
870    LOG_FUNCTION_NAME_EXIT;
871
872    return ErrorUtils::omxToAndroidError(eError);
873}
874
875status_t OMXCameraAdapter::setSaturation(Gen3A_settings& Gen3A)
876{
877    OMX_ERRORTYPE eError = OMX_ErrorNone;
878    OMX_CONFIG_SATURATIONTYPE saturation;
879
880    LOG_FUNCTION_NAME;
881
882    if ( OMX_StateInvalid == mComponentState )
883        {
884        CAMHAL_LOGEA("OMX component is in invalid state");
885        return NO_INIT;
886        }
887
888    OMX_INIT_STRUCT_PTR (&saturation, OMX_CONFIG_SATURATIONTYPE);
889    saturation.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
890    saturation.nSaturation = Gen3A.Saturation;
891
892    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
893                         OMX_IndexConfigCommonSaturation,
894                         &saturation);
895    if ( OMX_ErrorNone != eError )
896        {
897        CAMHAL_LOGEB("Error while configuring Saturation 0x%x error = 0x%x",
898                     ( unsigned int ) saturation.nSaturation,
899                     eError);
900        }
901    else
902        {
903        CAMHAL_LOGDB("Saturation 0x%x configured successfully",
904                     ( unsigned int ) saturation.nSaturation);
905        }
906
907    LOG_FUNCTION_NAME_EXIT;
908
909    return ErrorUtils::omxToAndroidError(eError);
910}
911
912status_t OMXCameraAdapter::setISO(Gen3A_settings& Gen3A)
913{
914    OMX_ERRORTYPE eError = OMX_ErrorNone;
915    OMX_CONFIG_EXPOSUREVALUETYPE expValues;
916
917    LOG_FUNCTION_NAME;
918
919    if ( OMX_StateInvalid == mComponentState )
920        {
921        CAMHAL_LOGEA("OMX component is in invalid state");
922        return NO_INIT;
923        }
924
925    OMX_INIT_STRUCT_PTR (&expValues, OMX_CONFIG_EXPOSUREVALUETYPE);
926    expValues.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
927
928    OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
929                   OMX_IndexConfigCommonExposureValue,
930                   &expValues);
931
932    if( 0 == Gen3A.ISO )
933        {
934        expValues.bAutoSensitivity = OMX_TRUE;
935        }
936    else
937        {
938        expValues.bAutoSensitivity = OMX_FALSE;
939        expValues.nSensitivity = Gen3A.ISO;
940        }
941
942    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
943                         OMX_IndexConfigCommonExposureValue,
944                         &expValues);
945    if ( OMX_ErrorNone != eError )
946        {
947        CAMHAL_LOGEB("Error while configuring ISO 0x%x error = 0x%x",
948                     ( unsigned int ) expValues.nSensitivity,
949                     eError);
950        }
951    else
952        {
953        CAMHAL_LOGDB("ISO 0x%x configured successfully",
954                     ( unsigned int ) expValues.nSensitivity);
955        }
956
957    LOG_FUNCTION_NAME_EXIT;
958
959    return ErrorUtils::omxToAndroidError(eError);
960}
961
962status_t OMXCameraAdapter::setEffect(Gen3A_settings& Gen3A)
963{
964    OMX_ERRORTYPE eError = OMX_ErrorNone;
965    OMX_CONFIG_IMAGEFILTERTYPE effect;
966
967    LOG_FUNCTION_NAME;
968
969    if ( OMX_StateInvalid == mComponentState )
970        {
971        CAMHAL_LOGEA("OMX component is in invalid state");
972        return NO_INIT;
973        }
974
975    OMX_INIT_STRUCT_PTR (&effect, OMX_CONFIG_IMAGEFILTERTYPE);
976    effect.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
977    effect.eImageFilter = (OMX_IMAGEFILTERTYPE ) Gen3A.Effect;
978
979    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
980                         OMX_IndexConfigCommonImageFilter,
981                         &effect);
982    if ( OMX_ErrorNone != eError )
983        {
984        CAMHAL_LOGEB("Error while configuring Effect 0x%x error = 0x%x",
985                     ( unsigned int )  effect.eImageFilter,
986                     eError);
987        }
988    else
989        {
990        CAMHAL_LOGDB("Effect 0x%x configured successfully",
991                     ( unsigned int )  effect.eImageFilter);
992        }
993
994    LOG_FUNCTION_NAME_EXIT;
995
996    return ErrorUtils::omxToAndroidError(eError);
997}
998
999status_t OMXCameraAdapter::setWhiteBalanceLock(Gen3A_settings& Gen3A)
1000{
1001  OMX_ERRORTYPE eError = OMX_ErrorNone;
1002  OMX_IMAGE_CONFIG_LOCKTYPE lock;
1003
1004  LOG_FUNCTION_NAME
1005
1006  if ( OMX_StateInvalid == mComponentState )
1007    {
1008      CAMHAL_LOGEA("OMX component is in invalid state");
1009      return NO_INIT;
1010    }
1011
1012  OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
1013  lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1014  lock.bLock = Gen3A.WhiteBalanceLock;
1015  eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
1016                          (OMX_INDEXTYPE)OMX_IndexConfigImageWhiteBalanceLock,
1017                          &lock);
1018  if ( OMX_ErrorNone != eError )
1019    {
1020      CAMHAL_LOGEB("Error while configuring WhiteBalance Lock error = 0x%x", eError);
1021    }
1022  else
1023    {
1024      CAMHAL_LOGDB("WhiteBalance Lock configured successfully %d ", lock.bLock);
1025    }
1026  LOG_FUNCTION_NAME_EXIT
1027
1028  return ErrorUtils::omxToAndroidError(eError);
1029}
1030
1031status_t OMXCameraAdapter::setExposureLock(Gen3A_settings& Gen3A)
1032{
1033  OMX_ERRORTYPE eError = OMX_ErrorNone;
1034  OMX_IMAGE_CONFIG_LOCKTYPE lock;
1035
1036  LOG_FUNCTION_NAME
1037
1038  if ( OMX_StateInvalid == mComponentState )
1039    {
1040      CAMHAL_LOGEA("OMX component is in invalid state");
1041      return NO_INIT;
1042    }
1043
1044  OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
1045  lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1046  lock.bLock = Gen3A.ExposureLock;
1047  eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
1048                          (OMX_INDEXTYPE)OMX_IndexConfigImageExposureLock,
1049                          &lock);
1050  if ( OMX_ErrorNone != eError )
1051    {
1052      CAMHAL_LOGEB("Error while configuring Exposure Lock error = 0x%x", eError);
1053    }
1054  else
1055    {
1056      CAMHAL_LOGDB("Exposure Lock configured successfully %d ", lock.bLock);
1057    }
1058  LOG_FUNCTION_NAME_EXIT
1059
1060    return ErrorUtils::omxToAndroidError(eError);
1061}
1062
1063status_t OMXCameraAdapter::setFocusLock(Gen3A_settings& Gen3A)
1064{
1065    OMX_ERRORTYPE eError = OMX_ErrorNone;
1066    OMX_IMAGE_CONFIG_LOCKTYPE lock;
1067
1068    LOG_FUNCTION_NAME
1069
1070    if ( OMX_StateInvalid == mComponentState ) {
1071        CAMHAL_LOGEA("OMX component is in invalid state");
1072        return NO_INIT;
1073    }
1074
1075    OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
1076    lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1077
1078    lock.bLock = Gen3A.FocusLock;
1079    eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
1080                           (OMX_INDEXTYPE)OMX_IndexConfigImageFocusLock,
1081                           &lock);
1082
1083    if ( OMX_ErrorNone != eError ) {
1084        CAMHAL_LOGEB("Error while configuring Focus Lock error = 0x%x", eError);
1085    } else {
1086        CAMHAL_LOGDB("Focus Lock configured successfully %d ", lock.bLock);
1087    }
1088
1089    LOG_FUNCTION_NAME_EXIT
1090
1091    return ErrorUtils::omxToAndroidError(eError);
1092}
1093
1094status_t OMXCameraAdapter::set3ALock(OMX_BOOL toggleExp, OMX_BOOL toggleWb, OMX_BOOL toggleFocus)
1095{
1096    OMX_ERRORTYPE eError = OMX_ErrorNone;
1097    OMX_IMAGE_CONFIG_LOCKTYPE lock;
1098
1099    LOG_FUNCTION_NAME
1100
1101    if ( OMX_StateInvalid == mComponentState )
1102    {
1103      CAMHAL_LOGEA("OMX component is in invalid state");
1104      return NO_INIT;
1105    }
1106
1107    OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
1108    lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1109
1110    mParameters3A.ExposureLock = toggleExp;
1111    mParameters3A.FocusLock = toggleFocus;
1112    mParameters3A.WhiteBalanceLock = toggleWb;
1113
1114    eError = OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
1115                            (OMX_INDEXTYPE)OMX_IndexConfigImageExposureLock,
1116                            &lock);
1117
1118    if ( OMX_ErrorNone != eError )
1119    {
1120        CAMHAL_LOGEB("Error GetConfig Exposure Lock error = 0x%x", eError);
1121        goto EXIT;
1122    }
1123    else
1124    {
1125        const char *lock_state_exp = toggleExp ? TRUE : FALSE;
1126        CAMHAL_LOGDA("Exposure Lock GetConfig successfull");
1127
1128        /* Apply locks only when not applied already */
1129        if ( lock.bLock  != toggleExp )
1130        {
1131            setExposureLock(mParameters3A);
1132        }
1133
1134        mParams.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, lock_state_exp);
1135    }
1136
1137    OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
1138    lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1139    eError = OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
1140                            (OMX_INDEXTYPE)OMX_IndexConfigImageFocusLock,
1141                            &lock);
1142
1143    if ( OMX_ErrorNone != eError )
1144    {
1145        CAMHAL_LOGEB("Error GetConfig Focus Lock error = 0x%x", eError);
1146        goto EXIT;
1147    }
1148    else
1149    {
1150        CAMHAL_LOGDB("Focus Lock GetConfig successfull bLock(%d)", lock.bLock);
1151
1152        /* Apply locks only when not applied already */
1153        if ( lock.bLock  != toggleFocus )
1154        {
1155            setFocusLock(mParameters3A);
1156        }
1157    }
1158
1159    OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
1160    lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1161    eError = OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
1162                            (OMX_INDEXTYPE)OMX_IndexConfigImageWhiteBalanceLock,
1163                            &lock);
1164
1165    if ( OMX_ErrorNone != eError )
1166    {
1167        CAMHAL_LOGEB("Error GetConfig WhiteBalance Lock error = 0x%x", eError);
1168        goto EXIT;
1169    }
1170    else
1171    {
1172        const char *lock_state_wb = toggleWb ? TRUE : FALSE;
1173        CAMHAL_LOGDA("WhiteBalance Lock GetConfig successfull");
1174
1175        /* Apply locks only when not applied already */
1176        if ( lock.bLock != toggleWb )
1177        {
1178            setWhiteBalanceLock(mParameters3A);
1179        }
1180
1181        mParams.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, lock_state_wb);
1182    }
1183 EXIT:
1184    return ErrorUtils::omxToAndroidError(eError);
1185}
1186
1187status_t OMXCameraAdapter::setMeteringAreas(Gen3A_settings& Gen3A)
1188{
1189  status_t ret = NO_ERROR;
1190  OMX_ERRORTYPE eError = OMX_ErrorNone;
1191
1192  OMX_ALGOAREASTYPE **meteringAreas;
1193  OMX_TI_CONFIG_SHAREDBUFFER sharedBuffer;
1194  MemoryManager memMgr;
1195  int areasSize = 0;
1196
1197  LOG_FUNCTION_NAME
1198
1199  Mutex::Autolock lock(mMeteringAreasLock);
1200
1201  if ( OMX_StateInvalid == mComponentState )
1202    {
1203      CAMHAL_LOGEA("OMX component is in invalid state");
1204      return NO_INIT;
1205    }
1206
1207  areasSize = ((sizeof(OMX_ALGOAREASTYPE)+4095)/4096)*4096;
1208  meteringAreas = (OMX_ALGOAREASTYPE**) memMgr.allocateBuffer(0, 0, NULL, areasSize, 1);
1209
1210  OMXCameraPortParameters * mPreviewData = NULL;
1211  mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
1212
1213  if (!meteringAreas)
1214      {
1215      CAMHAL_LOGEB("Error allocating buffer for metering areas %d", eError);
1216      return -ENOMEM;
1217      }
1218
1219  OMX_INIT_STRUCT_PTR (meteringAreas[0], OMX_ALGOAREASTYPE);
1220
1221  meteringAreas[0]->nPortIndex = OMX_ALL;
1222  meteringAreas[0]->nNumAreas = mMeteringAreas.size();
1223  meteringAreas[0]->nAlgoAreaPurpose = OMX_AlgoAreaExposure;
1224
1225  for ( unsigned int n = 0; n < mMeteringAreas.size(); n++)
1226      {
1227      // transform the coordinates to 3A-type coordinates
1228      mMeteringAreas.itemAt(n)->transfrom((size_t)mPreviewData->mWidth,
1229                                      (size_t)mPreviewData->mHeight,
1230                                      (size_t&)meteringAreas[0]->tAlgoAreas[n].nTop,
1231                                      (size_t&)meteringAreas[0]->tAlgoAreas[n].nLeft,
1232                                      (size_t&)meteringAreas[0]->tAlgoAreas[n].nWidth,
1233                                      (size_t&)meteringAreas[0]->tAlgoAreas[n].nHeight);
1234
1235      meteringAreas[0]->tAlgoAreas[n].nLeft =
1236              ( meteringAreas[0]->tAlgoAreas[n].nLeft * METERING_AREAS_RANGE ) / mPreviewData->mWidth;
1237      meteringAreas[0]->tAlgoAreas[n].nTop =
1238              ( meteringAreas[0]->tAlgoAreas[n].nTop* METERING_AREAS_RANGE ) / mPreviewData->mHeight;
1239      meteringAreas[0]->tAlgoAreas[n].nWidth =
1240              ( meteringAreas[0]->tAlgoAreas[n].nWidth * METERING_AREAS_RANGE ) / mPreviewData->mWidth;
1241      meteringAreas[0]->tAlgoAreas[n].nHeight =
1242              ( meteringAreas[0]->tAlgoAreas[n].nHeight * METERING_AREAS_RANGE ) / mPreviewData->mHeight;
1243
1244      meteringAreas[0]->tAlgoAreas[n].nPriority = mMeteringAreas.itemAt(n)->getWeight();
1245
1246      CAMHAL_LOGDB("Metering area %d : top = %d left = %d width = %d height = %d prio = %d",
1247              n, (int)meteringAreas[0]->tAlgoAreas[n].nTop, (int)meteringAreas[0]->tAlgoAreas[n].nLeft,
1248              (int)meteringAreas[0]->tAlgoAreas[n].nWidth, (int)meteringAreas[0]->tAlgoAreas[n].nHeight,
1249              (int)meteringAreas[0]->tAlgoAreas[n].nPriority);
1250
1251      }
1252
1253  OMX_INIT_STRUCT_PTR (&sharedBuffer, OMX_TI_CONFIG_SHAREDBUFFER);
1254
1255  sharedBuffer.nPortIndex = OMX_ALL;
1256  sharedBuffer.nSharedBuffSize = areasSize;
1257  sharedBuffer.pSharedBuff = (OMX_U8 *) meteringAreas[0];
1258
1259  if ( NULL == sharedBuffer.pSharedBuff )
1260      {
1261      CAMHAL_LOGEA("No resources to allocate OMX shared buffer");
1262      ret = -ENOMEM;
1263      goto EXIT;
1264      }
1265
1266      eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
1267                                (OMX_INDEXTYPE) OMX_TI_IndexConfigAlgoAreas, &sharedBuffer);
1268
1269  if ( OMX_ErrorNone != eError )
1270      {
1271      CAMHAL_LOGEB("Error while setting Focus Areas configuration 0x%x", eError);
1272      ret = -EINVAL;
1273      }
1274  else
1275      {
1276      CAMHAL_LOGDA("Metering Areas SetConfig successfull.");
1277      }
1278
1279 EXIT:
1280  if (NULL != meteringAreas)
1281      {
1282      memMgr.freeBuffer((void*) meteringAreas);
1283      meteringAreas = NULL;
1284      }
1285
1286  return ret;
1287}
1288
1289status_t OMXCameraAdapter::apply3Asettings( Gen3A_settings& Gen3A )
1290{
1291    status_t ret = NO_ERROR;
1292    unsigned int currSett; // 32 bit
1293    int portIndex;
1294
1295    /*
1296     * Scenes have a priority during the process
1297     * of applying 3A related parameters.
1298     * They can override pretty much all other 3A
1299     * settings and similarly get overridden when
1300     * for instance the focus mode gets switched.
1301     * There is only one exception to this rule,
1302     * the manual a.k.a. auto scene.
1303     */
1304    if ( ( SetSceneMode & mPending3Asettings ) )
1305        {
1306        mPending3Asettings &= ~SetSceneMode;
1307        return setScene(Gen3A);
1308        }
1309    else if ( OMX_Manual != Gen3A.SceneMode )
1310        {
1311        mPending3Asettings = 0;
1312        return NO_ERROR;
1313        }
1314
1315    for( currSett = 1; currSett < E3aSettingMax; currSett <<= 1)
1316        {
1317        if( currSett & mPending3Asettings )
1318            {
1319            switch( currSett )
1320                {
1321                case SetEVCompensation:
1322                    {
1323                    ret |= setEVCompensation(Gen3A);
1324                    break;
1325                    }
1326
1327                case SetWhiteBallance:
1328                    {
1329                    ret |= setWBMode(Gen3A);
1330                    break;
1331                    }
1332
1333                case SetFlicker:
1334                    {
1335                    ret |= setFlicker(Gen3A);
1336                    break;
1337                    }
1338
1339                case SetBrightness:
1340                    {
1341                    ret |= setBrightness(Gen3A);
1342                    break;
1343                    }
1344
1345                case SetContrast:
1346                    {
1347                    ret |= setContrast(Gen3A);
1348                    break;
1349                    }
1350
1351                case SetSharpness:
1352                    {
1353                    ret |= setSharpness(Gen3A);
1354                    break;
1355                    }
1356
1357                case SetSaturation:
1358                    {
1359                    ret |= setSaturation(Gen3A);
1360                    break;
1361                    }
1362
1363                case SetISO:
1364                    {
1365                    ret |= setISO(Gen3A);
1366                    break;
1367                    }
1368
1369                case SetEffect:
1370                    {
1371                    ret |= setEffect(Gen3A);
1372                    break;
1373                    }
1374
1375                case SetFocus:
1376                    {
1377                    ret |= setFocusMode(Gen3A);
1378                    break;
1379                    }
1380
1381                case SetExpMode:
1382                    {
1383                    ret |= setExposureMode(Gen3A);
1384                    break;
1385                    }
1386
1387                case SetFlash:
1388                    {
1389                    ret |= setFlashMode(Gen3A);
1390                    break;
1391                    }
1392
1393                case SetExpLock:
1394                  {
1395                    ret |= setExposureLock(Gen3A);
1396                    break;
1397                  }
1398
1399                case SetWBLock:
1400                  {
1401                    ret |= setWhiteBalanceLock(Gen3A);
1402                    break;
1403                  }
1404                case SetMeteringAreas:
1405                  {
1406                    ret |= setMeteringAreas(Gen3A);
1407                  }
1408                  break;
1409                default:
1410                    CAMHAL_LOGEB("this setting (0x%x) is still not supported in CameraAdapter ",
1411                                 currSett);
1412                    break;
1413                }
1414                mPending3Asettings &= ~currSett;
1415            }
1416        }
1417        return ret;
1418}
1419
1420};
1421