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