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