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