OMX3A.cpp revision d55379a7e975f992db1d10bba425f456447d14a8 
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::setExposureMode(Gen3A_settings& Gen3A)
297{
298    OMX_ERRORTYPE eError = OMX_ErrorNone;
299    OMX_CONFIG_EXPOSURECONTROLTYPE exp;
300
301    LOG_FUNCTION_NAME;
302
303    if ( OMX_StateInvalid == mComponentState )
304        {
305        CAMHAL_LOGEA("OMX component is in invalid state");
306        return NO_INIT;
307        }
308
309    OMX_INIT_STRUCT_PTR (&exp, OMX_CONFIG_EXPOSURECONTROLTYPE);
310    exp.nPortIndex = OMX_ALL;
311    exp.eExposureControl = (OMX_EXPOSURECONTROLTYPE)Gen3A.Exposure;
312
313///FIXME: Face priority exposure metering is not stable because of varying face sizes
314///coming from the FD module. So disabling it for now.
315#if 0
316    if ( mFaceDetectionRunning )
317        {
318        //Disable Region priority and enable Face priority
319        setAlgoPriority(REGION_PRIORITY, EXPOSURE_ALGO, false);
320        setAlgoPriority(FACE_PRIORITY, EXPOSURE_ALGO, true);
321        }
322    else
323#endif
324        {
325        //Disable Region priority and Face priority
326        setAlgoPriority(REGION_PRIORITY, EXPOSURE_ALGO, false);
327        setAlgoPriority(FACE_PRIORITY, EXPOSURE_ALGO, false);
328        }
329
330    eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
331                            OMX_IndexConfigCommonExposure,
332                            &exp);
333    if ( OMX_ErrorNone != eError )
334        {
335        CAMHAL_LOGEB("Error while configuring exposure mode 0x%x", eError);
336        }
337    else
338        {
339        CAMHAL_LOGDA("Camera exposure mode configured successfully");
340        }
341
342    LOG_FUNCTION_NAME_EXIT;
343
344    return ErrorUtils::omxToAndroidError(eError);
345}
346
347status_t OMXCameraAdapter::setFlashMode(Gen3A_settings& Gen3A)
348{
349    status_t ret = NO_ERROR;
350    OMX_ERRORTYPE eError = OMX_ErrorNone;
351    OMX_IMAGE_PARAM_FLASHCONTROLTYPE flash;
352
353    LOG_FUNCTION_NAME;
354
355    if ( OMX_StateInvalid == mComponentState )
356        {
357        CAMHAL_LOGEA("OMX component is in invalid state");
358        return NO_INIT;
359        }
360
361    OMX_INIT_STRUCT_PTR (&flash, OMX_IMAGE_PARAM_FLASHCONTROLTYPE);
362    flash.nPortIndex = OMX_ALL;
363    flash.eFlashControl = ( OMX_IMAGE_FLASHCONTROLTYPE ) Gen3A.FlashMode;
364
365    CAMHAL_LOGDB("Configuring flash mode 0x%x", flash.eFlashControl);
366    eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
367                            (OMX_INDEXTYPE) OMX_IndexConfigFlashControl,
368                            &flash);
369    if ( OMX_ErrorNone != eError )
370        {
371        CAMHAL_LOGEB("Error while configuring flash mode 0x%x", eError);
372        }
373    else
374        {
375        CAMHAL_LOGDA("Camera flash mode configured successfully");
376        }
377
378    LOG_FUNCTION_NAME_EXIT;
379
380    return ErrorUtils::omxToAndroidError(eError);
381}
382
383status_t OMXCameraAdapter::setFocusMode(Gen3A_settings& Gen3A)
384{
385    status_t ret = NO_ERROR;
386    OMX_ERRORTYPE eError = OMX_ErrorNone;
387    OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE focus;
388    size_t top, left, width, height, weight;
389    sp<CameraArea> focusArea = NULL;
390
391    LOG_FUNCTION_NAME;
392
393    if ( OMX_StateInvalid == mComponentState )
394        {
395        CAMHAL_LOGEA("OMX component is in invalid state");
396        return NO_INIT;
397        }
398
399        {
400        Mutex::Autolock lock(mFocusAreasLock);
401
402        if ( !mFocusAreas.isEmpty() )
403            {
404            focusArea = mFocusAreas.itemAt(0);
405            }
406        }
407
408    ///Face detection takes precedence over touch AF
409    if ( mFaceDetectionRunning )
410        {
411        //Disable region priority first
412        setAlgoPriority(REGION_PRIORITY, FOCUS_ALGO, false);
413
414        //Enable face algorithm priority for focus
415        setAlgoPriority(FACE_PRIORITY, FOCUS_ALGO , true);
416
417        //Do normal focus afterwards
418        ////FIXME: Check if the extended focus control is needed? this overrides caf
419        //focusControl.eFocusControl = ( OMX_IMAGE_FOCUSCONTROLTYPE ) OMX_IMAGE_FocusControlExtended;
420        }
421    else if ( ( NULL != focusArea.get() ) && ( focusArea->isValid() ) )
422        {
423
424        //Disable face priority first
425        setAlgoPriority(FACE_PRIORITY, FOCUS_ALGO, false);
426
427        //Enable region algorithm priority
428        setAlgoPriority(REGION_PRIORITY, FOCUS_ALGO, true);
429
430        //Set position
431        OMXCameraPortParameters * mPreviewData = NULL;
432        mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
433        focusArea->transfrom(mPreviewData->mWidth,
434                             mPreviewData->mHeight,
435                             top,
436                             left,
437                             width,
438                             height);
439        setTouchFocus(left,
440                      top,
441                      width,
442                      height,
443                      mPreviewData->mWidth,
444                      mPreviewData->mHeight);
445
446        //Do normal focus afterwards
447        //FIXME: Check if the extended focus control is needed? this overrides caf
448        //focus.eFocusControl = ( OMX_IMAGE_FOCUSCONTROLTYPE ) OMX_IMAGE_FocusControlExtended;
449
450        }
451    else
452        {
453
454        //Disable both region and face priority
455        setAlgoPriority(REGION_PRIORITY, FOCUS_ALGO, false);
456
457        setAlgoPriority(FACE_PRIORITY, FOCUS_ALGO, false);
458
459        }
460
461    if ( NO_ERROR == ret )
462        {
463        OMX_INIT_STRUCT_PTR (&focus, OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE);
464        focus.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
465        focus.eFocusControl = (OMX_IMAGE_FOCUSCONTROLTYPE)Gen3A.Focus;
466
467        CAMHAL_LOGDB("Configuring focus mode 0x%x", focus.eFocusControl);
468        eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp, OMX_IndexConfigFocusControl, &focus);
469        if ( OMX_ErrorNone != eError )
470            {
471            CAMHAL_LOGEB("Error while configuring focus mode 0x%x", eError);
472            }
473        else
474            {
475            CAMHAL_LOGDA("Camera focus mode configured successfully");
476            }
477        }
478
479    LOG_FUNCTION_NAME_EXIT;
480
481    return ErrorUtils::omxToAndroidError(eError);
482}
483
484status_t OMXCameraAdapter::setScene(Gen3A_settings& Gen3A)
485{
486    OMX_ERRORTYPE eError = OMX_ErrorNone;
487    OMX_CONFIG_SCENEMODETYPE scene;
488
489    LOG_FUNCTION_NAME;
490
491    if ( OMX_StateInvalid == mComponentState )
492        {
493        CAMHAL_LOGEA("OMX component is in invalid state");
494        return NO_INIT;
495        }
496
497    OMX_INIT_STRUCT_PTR (&scene, OMX_CONFIG_SCENEMODETYPE);
498    scene.nPortIndex = OMX_ALL;
499    scene.eSceneMode = ( OMX_SCENEMODETYPE ) Gen3A.SceneMode;
500
501    CAMHAL_LOGDB("Configuring scene mode 0x%x", scene.eSceneMode);
502    eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
503                            ( OMX_INDEXTYPE ) OMX_TI_IndexConfigSceneMode,
504                            &scene);
505    if ( OMX_ErrorNone != eError )
506        {
507        CAMHAL_LOGEB("Error while configuring scene mode 0x%x", eError);
508        }
509    else
510        {
511        CAMHAL_LOGDA("Camera scene configured successfully");
512        }
513
514    LOG_FUNCTION_NAME_EXIT;
515
516    return ErrorUtils::omxToAndroidError(eError);
517}
518
519status_t OMXCameraAdapter::setEVCompensation(Gen3A_settings& Gen3A)
520{
521    OMX_ERRORTYPE eError = OMX_ErrorNone;
522    OMX_CONFIG_EXPOSUREVALUETYPE expValues;
523
524    LOG_FUNCTION_NAME;
525
526    if ( OMX_StateInvalid == mComponentState )
527        {
528        CAMHAL_LOGEA("OMX component is in invalid state");
529        return NO_INIT;
530        }
531
532    OMX_INIT_STRUCT_PTR (&expValues, OMX_CONFIG_EXPOSUREVALUETYPE);
533    expValues.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
534
535    OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
536                   OMX_IndexConfigCommonExposureValue,
537                   &expValues);
538    CAMHAL_LOGDB("old EV Compensation for OMX = 0x%x", (int)expValues.xEVCompensation);
539    CAMHAL_LOGDB("EV Compensation for HAL = %d", Gen3A.EVCompensation);
540
541    expValues.xEVCompensation = ( Gen3A.EVCompensation * ( 1 << Q16_OFFSET ) )  / 10;
542    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
543                            OMX_IndexConfigCommonExposureValue,
544                            &expValues);
545    CAMHAL_LOGDB("new EV Compensation for OMX = 0x%x", (int)expValues.xEVCompensation);
546    if ( OMX_ErrorNone != eError )
547        {
548        CAMHAL_LOGEB("Error while configuring EV Compensation 0x%x error = 0x%x",
549                     ( unsigned int ) expValues.xEVCompensation,
550                     eError);
551        }
552    else
553        {
554        CAMHAL_LOGDB("EV Compensation 0x%x configured successfully",
555                     ( unsigned int ) expValues.xEVCompensation);
556        }
557
558    LOG_FUNCTION_NAME_EXIT;
559
560    return ErrorUtils::omxToAndroidError(eError);
561}
562
563status_t OMXCameraAdapter::setWBMode(Gen3A_settings& Gen3A)
564{
565    OMX_ERRORTYPE eError = OMX_ErrorNone;
566    OMX_CONFIG_WHITEBALCONTROLTYPE wb;
567
568    LOG_FUNCTION_NAME;
569
570    if ( OMX_StateInvalid == mComponentState )
571        {
572        CAMHAL_LOGEA("OMX component is in invalid state");
573        return NO_INIT;
574        }
575
576    OMX_INIT_STRUCT_PTR (&wb, OMX_CONFIG_WHITEBALCONTROLTYPE);
577    wb.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
578    wb.eWhiteBalControl = ( OMX_WHITEBALCONTROLTYPE ) Gen3A.WhiteBallance;
579
580    if ( WB_FACE_PRIORITY == Gen3A.WhiteBallance )
581        {
582        //Disable Region priority and enable Face priority
583        setAlgoPriority(REGION_PRIORITY, WHITE_BALANCE_ALGO, false);
584        setAlgoPriority(FACE_PRIORITY, WHITE_BALANCE_ALGO, true);
585
586        //Then set the mode to auto
587        wb.eWhiteBalControl = OMX_WhiteBalControlAuto;
588        }
589    else
590        {
591        //Disable Face and Region priority
592        setAlgoPriority(FACE_PRIORITY, WHITE_BALANCE_ALGO, false);
593        setAlgoPriority(REGION_PRIORITY, WHITE_BALANCE_ALGO, false);
594        }
595
596    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
597                         OMX_IndexConfigCommonWhiteBalance,
598                         &wb);
599    if ( OMX_ErrorNone != eError )
600        {
601        CAMHAL_LOGEB("Error while configuring Whitebalance mode 0x%x error = 0x%x",
602                     ( unsigned int ) wb.eWhiteBalControl,
603                     eError);
604        }
605    else
606        {
607        CAMHAL_LOGDB("Whitebalance mode 0x%x configured successfully",
608                     ( unsigned int ) wb.eWhiteBalControl);
609        }
610
611    LOG_FUNCTION_NAME_EXIT;
612
613    return eError;
614}
615
616status_t OMXCameraAdapter::setFlicker(Gen3A_settings& Gen3A)
617{
618    OMX_ERRORTYPE eError = OMX_ErrorNone;
619    OMX_CONFIG_FLICKERCANCELTYPE flicker;
620
621    LOG_FUNCTION_NAME;
622
623    if ( OMX_StateInvalid == mComponentState )
624        {
625        CAMHAL_LOGEA("OMX component is in invalid state");
626        return NO_INIT;
627        }
628
629    OMX_INIT_STRUCT_PTR (&flicker, OMX_CONFIG_FLICKERCANCELTYPE);
630    flicker.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
631    flicker.eFlickerCancel = (OMX_COMMONFLICKERCANCELTYPE)Gen3A.Flicker;
632
633    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
634                            (OMX_INDEXTYPE)OMX_IndexConfigFlickerCancel,
635                            &flicker );
636    if ( OMX_ErrorNone != eError )
637        {
638        CAMHAL_LOGEB("Error while configuring Flicker mode 0x%x error = 0x%x",
639                     ( unsigned int ) flicker.eFlickerCancel,
640                     eError);
641        }
642    else
643        {
644        CAMHAL_LOGDB("Flicker mode 0x%x configured successfully",
645                     ( unsigned int ) flicker.eFlickerCancel);
646        }
647
648    LOG_FUNCTION_NAME_EXIT;
649
650    return ErrorUtils::omxToAndroidError(eError);
651}
652
653status_t OMXCameraAdapter::setBrightness(Gen3A_settings& Gen3A)
654{
655    OMX_ERRORTYPE eError = OMX_ErrorNone;
656    OMX_CONFIG_BRIGHTNESSTYPE brightness;
657
658    LOG_FUNCTION_NAME;
659
660    if ( OMX_StateInvalid == mComponentState )
661        {
662        CAMHAL_LOGEA("OMX component is in invalid state");
663        return NO_INIT;
664        }
665
666    OMX_INIT_STRUCT_PTR (&brightness, OMX_CONFIG_BRIGHTNESSTYPE);
667    brightness.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
668    brightness.nBrightness = Gen3A.Brightness;
669
670    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
671                         OMX_IndexConfigCommonBrightness,
672                         &brightness);
673    if ( OMX_ErrorNone != eError )
674        {
675        CAMHAL_LOGEB("Error while configuring Brightness 0x%x error = 0x%x",
676                     ( unsigned int ) brightness.nBrightness,
677                     eError);
678        }
679    else
680        {
681        CAMHAL_LOGDB("Brightness 0x%x configured successfully",
682                     ( unsigned int ) brightness.nBrightness);
683        }
684
685    LOG_FUNCTION_NAME_EXIT;
686
687    return ErrorUtils::omxToAndroidError(eError);
688}
689
690status_t OMXCameraAdapter::setContrast(Gen3A_settings& Gen3A)
691{
692    OMX_ERRORTYPE eError = OMX_ErrorNone;
693    OMX_CONFIG_CONTRASTTYPE contrast;
694
695    LOG_FUNCTION_NAME;
696
697    if ( OMX_StateInvalid == mComponentState )
698        {
699        CAMHAL_LOGEA("OMX component is in invalid state");
700        return NO_INIT;
701        }
702
703    OMX_INIT_STRUCT_PTR (&contrast, OMX_CONFIG_CONTRASTTYPE);
704    contrast.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
705    contrast.nContrast = Gen3A.Contrast;
706
707    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
708                         OMX_IndexConfigCommonContrast,
709                         &contrast);
710    if ( OMX_ErrorNone != eError )
711        {
712        CAMHAL_LOGEB("Error while configuring Contrast 0x%x error = 0x%x",
713                     ( unsigned int ) contrast.nContrast,
714                     eError);
715        }
716    else
717        {
718        CAMHAL_LOGDB("Contrast 0x%x configured successfully",
719                     ( unsigned int ) contrast.nContrast);
720        }
721
722    LOG_FUNCTION_NAME_EXIT;
723
724    return eError;
725}
726
727status_t OMXCameraAdapter::setSharpness(Gen3A_settings& Gen3A)
728{
729    OMX_ERRORTYPE eError = OMX_ErrorNone;
730    OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE procSharpness;
731
732    LOG_FUNCTION_NAME;
733
734    if ( OMX_StateInvalid == mComponentState )
735        {
736        CAMHAL_LOGEA("OMX component is in invalid state");
737        return NO_INIT;
738        }
739
740    OMX_INIT_STRUCT_PTR (&procSharpness, OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE);
741    procSharpness.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
742    procSharpness.nLevel = Gen3A.Sharpness;
743
744    if( procSharpness.nLevel == 0 )
745        {
746        procSharpness.bAuto = OMX_TRUE;
747        }
748    else
749        {
750        procSharpness.bAuto = OMX_FALSE;
751        }
752
753    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
754                         (OMX_INDEXTYPE)OMX_IndexConfigSharpeningLevel,
755                         &procSharpness);
756    if ( OMX_ErrorNone != eError )
757        {
758        CAMHAL_LOGEB("Error while configuring Sharpness 0x%x error = 0x%x",
759                     ( unsigned int ) procSharpness.nLevel,
760                     eError);
761        }
762    else
763        {
764        CAMHAL_LOGDB("Sharpness 0x%x configured successfully",
765                     ( unsigned int ) procSharpness.nLevel);
766        }
767
768    LOG_FUNCTION_NAME_EXIT;
769
770    return ErrorUtils::omxToAndroidError(eError);
771}
772
773status_t OMXCameraAdapter::setSaturation(Gen3A_settings& Gen3A)
774{
775    OMX_ERRORTYPE eError = OMX_ErrorNone;
776    OMX_CONFIG_SATURATIONTYPE saturation;
777
778    LOG_FUNCTION_NAME;
779
780    if ( OMX_StateInvalid == mComponentState )
781        {
782        CAMHAL_LOGEA("OMX component is in invalid state");
783        return NO_INIT;
784        }
785
786    OMX_INIT_STRUCT_PTR (&saturation, OMX_CONFIG_SATURATIONTYPE);
787    saturation.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
788    saturation.nSaturation = Gen3A.Saturation;
789
790    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
791                         OMX_IndexConfigCommonSaturation,
792                         &saturation);
793    if ( OMX_ErrorNone != eError )
794        {
795        CAMHAL_LOGEB("Error while configuring Saturation 0x%x error = 0x%x",
796                     ( unsigned int ) saturation.nSaturation,
797                     eError);
798        }
799    else
800        {
801        CAMHAL_LOGDB("Saturation 0x%x configured successfully",
802                     ( unsigned int ) saturation.nSaturation);
803        }
804
805    LOG_FUNCTION_NAME_EXIT;
806
807    return ErrorUtils::omxToAndroidError(eError);
808}
809
810status_t OMXCameraAdapter::setISO(Gen3A_settings& Gen3A)
811{
812    OMX_ERRORTYPE eError = OMX_ErrorNone;
813    OMX_CONFIG_EXPOSUREVALUETYPE expValues;
814
815    LOG_FUNCTION_NAME;
816
817    if ( OMX_StateInvalid == mComponentState )
818        {
819        CAMHAL_LOGEA("OMX component is in invalid state");
820        return NO_INIT;
821        }
822
823    OMX_INIT_STRUCT_PTR (&expValues, OMX_CONFIG_EXPOSUREVALUETYPE);
824    expValues.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
825
826    OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
827                   OMX_IndexConfigCommonExposureValue,
828                   &expValues);
829
830    if( 0 == Gen3A.ISO )
831        {
832        expValues.bAutoSensitivity = OMX_TRUE;
833        }
834    else
835        {
836        expValues.bAutoSensitivity = OMX_FALSE;
837        expValues.nSensitivity = Gen3A.ISO;
838        }
839
840    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
841                         OMX_IndexConfigCommonExposureValue,
842                         &expValues);
843    if ( OMX_ErrorNone != eError )
844        {
845        CAMHAL_LOGEB("Error while configuring ISO 0x%x error = 0x%x",
846                     ( unsigned int ) expValues.nSensitivity,
847                     eError);
848        }
849    else
850        {
851        CAMHAL_LOGDB("ISO 0x%x configured successfully",
852                     ( unsigned int ) expValues.nSensitivity);
853        }
854
855    LOG_FUNCTION_NAME_EXIT;
856
857    return ErrorUtils::omxToAndroidError(eError);
858}
859
860status_t OMXCameraAdapter::setEffect(Gen3A_settings& Gen3A)
861{
862    OMX_ERRORTYPE eError = OMX_ErrorNone;
863    OMX_CONFIG_IMAGEFILTERTYPE effect;
864
865    LOG_FUNCTION_NAME;
866
867    if ( OMX_StateInvalid == mComponentState )
868        {
869        CAMHAL_LOGEA("OMX component is in invalid state");
870        return NO_INIT;
871        }
872
873    OMX_INIT_STRUCT_PTR (&effect, OMX_CONFIG_IMAGEFILTERTYPE);
874    effect.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
875    effect.eImageFilter = (OMX_IMAGEFILTERTYPE ) Gen3A.Effect;
876
877    eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
878                         OMX_IndexConfigCommonImageFilter,
879                         &effect);
880    if ( OMX_ErrorNone != eError )
881        {
882        CAMHAL_LOGEB("Error while configuring Effect 0x%x error = 0x%x",
883                     ( unsigned int )  effect.eImageFilter,
884                     eError);
885        }
886    else
887        {
888        CAMHAL_LOGDB("Effect 0x%x configured successfully",
889                     ( unsigned int )  effect.eImageFilter);
890        }
891
892    LOG_FUNCTION_NAME_EXIT;
893
894    return ErrorUtils::omxToAndroidError(eError);
895}
896
897status_t OMXCameraAdapter::setWhiteBalanceLock(Gen3A_settings& Gen3A)
898{
899  OMX_ERRORTYPE eError = OMX_ErrorNone;
900  OMX_IMAGE_CONFIG_LOCKTYPE lock;
901
902  LOG_FUNCTION_NAME
903
904  if ( OMX_StateInvalid == mComponentState )
905    {
906      CAMHAL_LOGEA("OMX component is in invalid state");
907      return NO_INIT;
908    }
909
910  OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
911  lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
912  lock.bLock = Gen3A.WhiteBalanceLock;
913  eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
914                          (OMX_INDEXTYPE)OMX_IndexConfigImageWhiteBalanceLock,
915                          &lock);
916  if ( OMX_ErrorNone != eError )
917    {
918      CAMHAL_LOGEB("Error while configuring WhiteBalance Lock error = 0x%x", eError);
919    }
920  else
921    {
922      CAMHAL_LOGDB("WhiteBalance Lock configured successfully %d ", lock.bLock);
923    }
924  LOG_FUNCTION_NAME_EXIT
925
926  return ErrorUtils::omxToAndroidError(eError);
927}
928
929status_t OMXCameraAdapter::setExposureLock(Gen3A_settings& Gen3A)
930{
931  OMX_ERRORTYPE eError = OMX_ErrorNone;
932  OMX_IMAGE_CONFIG_LOCKTYPE lock;
933
934  LOG_FUNCTION_NAME
935
936  if ( OMX_StateInvalid == mComponentState )
937    {
938      CAMHAL_LOGEA("OMX component is in invalid state");
939      return NO_INIT;
940    }
941
942  OMX_INIT_STRUCT_PTR (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
943  lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
944  lock.bLock = Gen3A.ExposureLock;
945  eError = OMX_SetConfig( mCameraAdapterParameters.mHandleComp,
946                          (OMX_INDEXTYPE)OMX_IndexConfigImageExposureLock,
947                          &lock);
948  if ( OMX_ErrorNone != eError )
949    {
950      CAMHAL_LOGEB("Error while configuring Exposure Lock error = 0x%x", eError);
951    }
952  else
953    {
954      CAMHAL_LOGDB("Exposure Lock configured successfully %d ", lock.bLock);
955    }
956  LOG_FUNCTION_NAME_EXIT
957
958    return ErrorUtils::omxToAndroidError(eError);
959}
960
961status_t OMXCameraAdapter::set3ALock(OMX_BOOL toggle)
962{
963  OMX_ERRORTYPE eError = OMX_ErrorNone;
964  OMX_IMAGE_CONFIG_LOCKTYPE lock;
965  char* index = FALSE;
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 (&lock, OMX_IMAGE_CONFIG_LOCKTYPE);
976  lock.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
977
978  mParameters3A.ExposureLock = toggle;
979  mParameters3A.WhiteBalanceLock = toggle;
980
981  eError = OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
982                          (OMX_INDEXTYPE)OMX_IndexConfigImageExposureLock,
983                          &lock);
984  if ( OMX_ErrorNone != eError )
985    {
986      CAMHAL_LOGEB("Error GetConfig Exposure Lock error = 0x%x", eError);
987    }
988  else
989    {
990      CAMHAL_LOGDA("Exposure Lock GetConfig successfull");
991    }
992
993  /* Apply locks only when not applied already */
994  if ( lock.bLock  != toggle )
995    {
996      setExposureLock(mParameters3A);
997    }
998
999  eError = OMX_GetConfig( mCameraAdapterParameters.mHandleComp,
1000                          (OMX_INDEXTYPE)OMX_IndexConfigImageWhiteBalanceLock,
1001                          &lock);
1002  if ( OMX_ErrorNone != eError )
1003    {
1004      CAMHAL_LOGEB("Error GetConfig WhiteBalance Lock error = 0x%x", eError);
1005    }
1006  else
1007    {
1008      CAMHAL_LOGDA("WhiteBalance Lock GetConfig successfull");
1009    }
1010
1011  /* Apply locks only when not applied already */
1012  if ( lock.bLock != toggle )
1013    {
1014      setWhiteBalanceLock(mParameters3A);
1015    }
1016
1017  const char *lock_state = toggle ? TRUE : FALSE;
1018  mParams.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, lock_state);
1019  mParams.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, lock_state);
1020
1021  return ErrorUtils::omxToAndroidError(eError);
1022
1023}
1024
1025status_t OMXCameraAdapter::apply3Asettings( Gen3A_settings& Gen3A )
1026{
1027    status_t ret = NO_ERROR;
1028    unsigned int currSett; // 32 bit
1029    int portIndex;
1030
1031    /*
1032     * Scenes have a priority during the process
1033     * of applying 3A related parameters.
1034     * They can override pretty much all other 3A
1035     * settings and similarly get overridden when
1036     * for instance the focus mode gets switched.
1037     * There is only one exception to this rule,
1038     * the manual a.k.a. auto scene.
1039     */
1040    if ( ( SetSceneMode & mPending3Asettings ) )
1041        {
1042        mPending3Asettings &= ~SetSceneMode;
1043        return setScene(Gen3A);
1044        }
1045    else if ( OMX_Manual != Gen3A.SceneMode )
1046        {
1047        mPending3Asettings = 0;
1048        return NO_ERROR;
1049        }
1050
1051    for( currSett = 1; currSett < E3aSettingMax; currSett <<= 1)
1052        {
1053        if( currSett & mPending3Asettings )
1054            {
1055            switch( currSett )
1056                {
1057                case SetEVCompensation:
1058                    {
1059                    ret |= setEVCompensation(Gen3A);
1060                    break;
1061                    }
1062
1063                case SetWhiteBallance:
1064                    {
1065                    ret |= setWBMode(Gen3A);
1066                    break;
1067                    }
1068
1069                case SetFlicker:
1070                    {
1071                    ret |= setFlicker(Gen3A);
1072                    break;
1073                    }
1074
1075                case SetBrightness:
1076                    {
1077                    ret |= setBrightness(Gen3A);
1078                    break;
1079                    }
1080
1081                case SetContrast:
1082                    {
1083                    ret |= setContrast(Gen3A);
1084                    break;
1085                    }
1086
1087                case SetSharpness:
1088                    {
1089                    ret |= setSharpness(Gen3A);
1090                    break;
1091                    }
1092
1093                case SetSaturation:
1094                    {
1095                    ret |= setSaturation(Gen3A);
1096                    break;
1097                    }
1098
1099                case SetISO:
1100                    {
1101                    ret |= setISO(Gen3A);
1102                    break;
1103                    }
1104
1105                case SetEffect:
1106                    {
1107                    ret |= setEffect(Gen3A);
1108                    break;
1109                    }
1110
1111                case SetFocus:
1112                    {
1113                    ret |= setFocusMode(Gen3A);
1114                    break;
1115                    }
1116
1117                case SetExpMode:
1118                    {
1119                    ret |= setExposureMode(Gen3A);
1120                    break;
1121                    }
1122
1123                case SetFlash:
1124                    {
1125                    ret |= setFlashMode(Gen3A);
1126                    break;
1127                    }
1128
1129                case SetExpLock:
1130                  {
1131                    ret |= setExposureLock(Gen3A);
1132                    break;
1133                  }
1134
1135                case SetWBLock:
1136                  {
1137                    ret |= setWhiteBalanceLock(Gen3A);
1138                    break;
1139                  }
1140
1141                default:
1142                    CAMHAL_LOGEB("this setting (0x%x) is still not supported in CameraAdapter ",
1143                                 currSett);
1144                    break;
1145                }
1146                mPending3Asettings &= ~currSett;
1147            }
1148        }
1149        return ret;
1150}
1151
1152};
1153