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