OMXAlgo.cpp revision 00479a8f1d791824870513b8b0b9edd67d2560ff 
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 OMXAlgo.cpp
19*
20* This file contains functionality for handling algorithm 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::setParametersAlgo(const CameraParameters &params,
35                                             BaseCameraAdapter::AdapterState state)
36{
37    status_t ret = NO_ERROR;
38    const char *valstr = NULL;
39    const char *oldstr = NULL;
40
41    LOG_FUNCTION_NAME;
42
43    CaptureMode capMode;
44    CAMHAL_LOGEB("Capture mode %s",  params.get(TICameraParameters::KEY_CAP_MODE));
45    if ( (valstr = params.get(TICameraParameters::KEY_CAP_MODE)) != NULL )
46        {
47        if (strcmp(valstr, (const char *) TICameraParameters::HIGH_PERFORMANCE_MODE) == 0)
48            {
49            capMode = OMXCameraAdapter::HIGH_SPEED;
50            }
51        else if (strcmp(valstr, (const char *) TICameraParameters::HIGH_QUALITY_MODE) == 0)
52            {
53            capMode = OMXCameraAdapter::HIGH_QUALITY;
54            }
55        else if (strcmp(valstr, (const char *) TICameraParameters::HIGH_QUALITY_ZSL_MODE) == 0)
56            {
57            capMode = OMXCameraAdapter::HIGH_QUALITY_ZSL;
58            }
59        else if (strcmp(valstr, (const char *) TICameraParameters::VIDEO_MODE) == 0)
60            {
61            capMode = OMXCameraAdapter::VIDEO_MODE;
62            }
63        else
64            {
65            capMode = OMXCameraAdapter::HIGH_QUALITY;
66            }
67        }
68    else
69        {
70        capMode = OMXCameraAdapter::HIGH_QUALITY_ZSL;
71
72        }
73
74    if ( mCapMode != capMode )
75        {
76        mCapMode = capMode;
77        mOMXStateSwitch = true;
78        }
79
80    CAMHAL_LOGDB("Capture Mode set %d", mCapMode);
81
82    /// Configure IPP, LDCNSF, GBCE and GLBCE only in HQ mode
83    IPPMode ipp;
84    if((mCapMode == OMXCameraAdapter::HIGH_QUALITY) || (mCapMode == OMXCameraAdapter::HIGH_QUALITY_ZSL))
85        {
86          if ( (valstr = params.get(TICameraParameters::KEY_IPP)) != NULL )
87            {
88            if (strcmp(valstr, (const char *) TICameraParameters::IPP_LDCNSF) == 0)
89                {
90                ipp = OMXCameraAdapter::IPP_LDCNSF;
91                }
92            else if (strcmp(valstr, (const char *) TICameraParameters::IPP_LDC) == 0)
93                {
94                ipp = OMXCameraAdapter::IPP_LDC;
95                }
96            else if (strcmp(valstr, (const char *) TICameraParameters::IPP_NSF) == 0)
97                {
98                ipp = OMXCameraAdapter::IPP_NSF;
99                }
100            else if (strcmp(valstr, (const char *) TICameraParameters::IPP_NONE) == 0)
101                {
102                ipp = OMXCameraAdapter::IPP_NONE;
103                }
104            else
105                {
106                ipp = OMXCameraAdapter::IPP_NONE;
107                }
108            }
109        else
110            {
111            ipp = OMXCameraAdapter::IPP_NONE;
112            }
113
114        CAMHAL_LOGVB("IPP Mode set %d", ipp);
115
116        if (((valstr = params.get(TICameraParameters::KEY_GBCE)) != NULL) )
117            {
118            // Configure GBCE only if the setting has changed since last time
119            oldstr = mParams.get(TICameraParameters::KEY_GBCE);
120            bool cmpRes = true;
121            if ( NULL != oldstr )
122                {
123                cmpRes = strcmp(valstr, oldstr) != 0;
124                }
125            else
126                {
127                cmpRes = true;
128                }
129
130
131            if( cmpRes )
132                {
133                if (strcmp(valstr, ( const char * ) TICameraParameters::GBCE_ENABLE ) == 0)
134                    {
135                    setGBCE(OMXCameraAdapter::BRIGHTNESS_ON);
136                    }
137                else if (strcmp(valstr, ( const char * ) TICameraParameters::GBCE_DISABLE ) == 0)
138                    {
139                    setGBCE(OMXCameraAdapter::BRIGHTNESS_OFF);
140                    }
141                else
142                    {
143                    setGBCE(OMXCameraAdapter::BRIGHTNESS_OFF);
144                    }
145                }
146            }
147        else
148            {
149            //Disable GBCE by default
150            setGBCE(OMXCameraAdapter::BRIGHTNESS_OFF);
151            }
152
153        if ( ( valstr = params.get(TICameraParameters::KEY_GLBCE) ) != NULL )
154            {
155            // Configure GLBCE only if the setting has changed since last time
156
157            oldstr = mParams.get(TICameraParameters::KEY_GLBCE);
158            bool cmpRes = true;
159            if ( NULL != oldstr )
160                {
161                cmpRes = strcmp(valstr, oldstr) != 0;
162                }
163            else
164                {
165                cmpRes = true;
166                }
167
168
169            if( cmpRes )
170                {
171                if (strcmp(valstr, ( const char * ) TICameraParameters::GLBCE_ENABLE ) == 0)
172                    {
173                    setGLBCE(OMXCameraAdapter::BRIGHTNESS_ON);
174                    }
175                else if (strcmp(valstr, ( const char * ) TICameraParameters::GLBCE_DISABLE ) == 0)
176                    {
177                    setGLBCE(OMXCameraAdapter::BRIGHTNESS_OFF);
178                    }
179                else
180                    {
181                    setGLBCE(OMXCameraAdapter::BRIGHTNESS_OFF);
182                    }
183                }
184            }
185        else
186            {
187            //Disable GLBCE by default
188            setGLBCE(OMXCameraAdapter::BRIGHTNESS_OFF);
189            }
190        }
191    else
192        {
193        ipp = OMXCameraAdapter::IPP_NONE;
194        }
195
196    if ( mIPP != ipp )
197        {
198        mIPP = ipp;
199        mOMXStateSwitch = true;
200        }
201
202    ///Set VNF Configuration
203    bool vnfEnabled = false;
204    if ( params.getInt(TICameraParameters::KEY_VNF)  > 0 )
205        {
206        CAMHAL_LOGDA("VNF Enabled");
207        vnfEnabled = true;
208        }
209    else
210        {
211        CAMHAL_LOGDA("VNF Disabled");
212        vnfEnabled = false;
213        }
214
215    if ( mVnfEnabled != vnfEnabled )
216        {
217        mVnfEnabled = vnfEnabled;
218        mOMXStateSwitch = true;
219        }
220
221    ///Set VSTAB Configuration
222    bool vstabEnabled = false;
223    if ( params.getInt(TICameraParameters::KEY_VSTAB)  > 0 )
224        {
225        CAMHAL_LOGDA("VSTAB Enabled");
226        vstabEnabled = true;
227        }
228    else
229        {
230        CAMHAL_LOGDA("VSTAB Disabled");
231        vstabEnabled = false;
232        }
233
234    if ( mVstabEnabled != vstabEnabled )
235        {
236        mVstabEnabled = vstabEnabled;
237        mOMXStateSwitch = true;
238        }
239
240    //A work-around for a failing call to OMX flush buffers
241    if ( ( capMode = OMXCameraAdapter::VIDEO_MODE ) &&
242         ( mVstabEnabled ) )
243        {
244        mOMXStateSwitch = true;
245        }
246
247    //Set Auto Convergence Mode
248    valstr = params.get((const char *) TICameraParameters::KEY_AUTOCONVERGENCE);
249    if ( valstr != NULL )
250        {
251        // Set ManualConvergence default value
252        OMX_S32 manualconvergence = -30;
253        if ( strcmp (valstr, (const char *) TICameraParameters::AUTOCONVERGENCE_MODE_DISABLE) == 0 )
254            {
255            setAutoConvergence(OMX_TI_AutoConvergenceModeDisable, manualconvergence);
256            }
257        else if ( strcmp (valstr, (const char *) TICameraParameters::AUTOCONVERGENCE_MODE_FRAME) == 0 )
258                {
259                setAutoConvergence(OMX_TI_AutoConvergenceModeFrame, manualconvergence);
260                }
261        else if ( strcmp (valstr, (const char *) TICameraParameters::AUTOCONVERGENCE_MODE_CENTER) == 0 )
262                {
263                setAutoConvergence(OMX_TI_AutoConvergenceModeCenter, manualconvergence);
264                }
265        else if ( strcmp (valstr, (const char *) TICameraParameters::AUTOCONVERGENCE_MODE_FFT) == 0 )
266                {
267                setAutoConvergence(OMX_TI_AutoConvergenceModeFocusFaceTouch, manualconvergence);
268                }
269        else if ( strcmp (valstr, (const char *) TICameraParameters::AUTOCONVERGENCE_MODE_MANUAL) == 0 )
270                {
271                manualconvergence = (OMX_S32)params.getInt(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES);
272                setAutoConvergence(OMX_TI_AutoConvergenceModeManual, manualconvergence);
273                }
274        CAMHAL_LOGVB("AutoConvergenceMode %s, value = %d", valstr, (int) manualconvergence);
275        }
276
277    LOG_FUNCTION_NAME_EXIT;
278
279    return ret;
280}
281
282// Get AutoConvergence
283status_t OMXCameraAdapter::getAutoConvergence(OMX_TI_AUTOCONVERGENCEMODETYPE *pACMode,
284                                              OMX_S32 *pManualConverence)
285{
286    status_t ret = NO_ERROR;
287    OMX_ERRORTYPE eError = OMX_ErrorNone;
288    OMX_TI_CONFIG_CONVERGENCETYPE ACParams;
289
290    ACParams.nSize = sizeof(OMX_TI_CONFIG_CONVERGENCETYPE);
291    ACParams.nVersion = mLocalVersionParam;
292    ACParams.nPortIndex = OMX_ALL;
293
294    LOG_FUNCTION_NAME;
295
296    eError =  OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
297                            (OMX_INDEXTYPE)OMX_TI_IndexConfigAutoConvergence,
298                            &ACParams);
299    if ( eError != OMX_ErrorNone )
300        {
301        CAMHAL_LOGEB("Error while getting AutoConvergence 0x%x", eError);
302        ret = -EINVAL;
303        }
304    else
305        {
306        *pManualConverence = ACParams.nManualConverence;
307        *pACMode = ACParams.eACMode;
308        CAMHAL_LOGDA("AutoConvergence got successfully");
309        }
310
311    LOG_FUNCTION_NAME_EXIT;
312
313    return ret;
314}
315
316// Set AutoConvergence
317status_t OMXCameraAdapter::setAutoConvergence(OMX_TI_AUTOCONVERGENCEMODETYPE pACMode,
318                                              OMX_S32 pManualConverence)
319{
320    status_t ret = NO_ERROR;
321    OMX_ERRORTYPE eError = OMX_ErrorNone;
322    OMX_TI_CONFIG_CONVERGENCETYPE ACParams;
323
324    LOG_FUNCTION_NAME;
325
326    ACParams.nSize = sizeof(OMX_TI_CONFIG_CONVERGENCETYPE);
327    ACParams.nVersion = mLocalVersionParam;
328    ACParams.nPortIndex = OMX_ALL;
329    ACParams.nManualConverence = pManualConverence;
330    ACParams.eACMode = pACMode;
331    eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
332                            (OMX_INDEXTYPE)OMX_TI_IndexConfigAutoConvergence,
333                            &ACParams);
334    if ( eError != OMX_ErrorNone )
335        {
336        CAMHAL_LOGEB("Error while setting AutoConvergence 0x%x", eError);
337        ret = -EINVAL;
338        }
339    else
340        {
341        CAMHAL_LOGDA("AutoConvergence applied successfully");
342        }
343
344    LOG_FUNCTION_NAME_EXIT;
345
346    return ret;
347}
348
349status_t OMXCameraAdapter::enableVideoNoiseFilter(bool enable)
350{
351    status_t ret = NO_ERROR;
352    OMX_ERRORTYPE eError = OMX_ErrorNone;
353    OMX_PARAM_VIDEONOISEFILTERTYPE vnfCfg;
354
355
356    LOG_FUNCTION_NAME;
357
358    if ( NO_ERROR == ret )
359        {
360        OMX_INIT_STRUCT_PTR (&vnfCfg, OMX_PARAM_VIDEONOISEFILTERTYPE);
361
362        if ( enable )
363            {
364            CAMHAL_LOGDA("VNF is enabled");
365            vnfCfg.eMode = OMX_VideoNoiseFilterModeOn;
366            }
367        else
368            {
369            CAMHAL_LOGDA("VNF is disabled");
370            vnfCfg.eMode = OMX_VideoNoiseFilterModeOff;
371            }
372
373        eError =  OMX_SetParameter(mCameraAdapterParameters.mHandleComp,
374                                   ( OMX_INDEXTYPE ) OMX_IndexParamVideoNoiseFilter,
375                                   &vnfCfg);
376        if ( OMX_ErrorNone != eError )
377            {
378            CAMHAL_LOGEB("Error while configuring video noise filter 0x%x", eError);
379            ret = -1;
380            }
381        else
382            {
383            CAMHAL_LOGDA("Video noise filter is configured successfully");
384            }
385        }
386
387    LOG_FUNCTION_NAME_EXIT;
388
389    return ret;
390}
391
392status_t OMXCameraAdapter::enableVideoStabilization(bool enable)
393{
394    status_t ret = NO_ERROR;
395    OMX_ERRORTYPE eError = OMX_ErrorNone;
396    OMX_CONFIG_FRAMESTABTYPE frameStabCfg;
397
398
399    LOG_FUNCTION_NAME;
400
401    if ( NO_ERROR == ret )
402        {
403        OMX_CONFIG_BOOLEANTYPE vstabp;
404        OMX_INIT_STRUCT_PTR (&vstabp, OMX_CONFIG_BOOLEANTYPE);
405        if(enable)
406            {
407            vstabp.bEnabled = OMX_TRUE;
408            }
409        else
410            {
411            vstabp.bEnabled = OMX_FALSE;
412            }
413
414        eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp,
415                                  (OMX_INDEXTYPE)OMX_IndexParamFrameStabilisation,
416                                  &vstabp);
417        if ( OMX_ErrorNone != eError )
418            {
419            CAMHAL_LOGEB("Error while configuring video stabilization param 0x%x", eError);
420            ret = -1;
421            }
422        else
423            {
424            CAMHAL_LOGDA("Video stabilization param configured successfully");
425            }
426
427        }
428
429    if ( NO_ERROR == ret )
430        {
431
432        OMX_INIT_STRUCT_PTR (&frameStabCfg, OMX_CONFIG_FRAMESTABTYPE);
433
434
435        eError =  OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
436                                ( OMX_INDEXTYPE ) OMX_IndexConfigCommonFrameStabilisation,
437                                &frameStabCfg);
438        if ( OMX_ErrorNone != eError )
439            {
440            CAMHAL_LOGEB("Error while getting video stabilization mode 0x%x",
441                         (unsigned int)eError);
442            ret = -1;
443            }
444
445        CAMHAL_LOGDB("VSTAB Port Index = %d", (int)frameStabCfg.nPortIndex);
446
447        frameStabCfg.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
448        if ( enable )
449            {
450            CAMHAL_LOGDA("VSTAB is enabled");
451            frameStabCfg.bStab = OMX_TRUE;
452            }
453        else
454            {
455            CAMHAL_LOGDA("VSTAB is disabled");
456            frameStabCfg.bStab = OMX_FALSE;
457
458            }
459
460        eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
461                                ( OMX_INDEXTYPE ) OMX_IndexConfigCommonFrameStabilisation,
462                                &frameStabCfg);
463        if ( OMX_ErrorNone != eError )
464            {
465            CAMHAL_LOGEB("Error while configuring video stabilization mode 0x%x", eError);
466            ret = -1;
467            }
468        else
469            {
470            CAMHAL_LOGDA("Video stabilization mode configured successfully");
471            }
472        }
473
474    LOG_FUNCTION_NAME_EXIT;
475
476    return ret;
477}
478
479status_t OMXCameraAdapter::setGBCE(OMXCameraAdapter::BrightnessMode mode)
480{
481    status_t ret = NO_ERROR;
482    OMX_ERRORTYPE eError = OMX_ErrorNone;
483    OMX_TI_CONFIG_LOCAL_AND_GLOBAL_BRIGHTNESSCONTRASTTYPE bControl;
484
485    LOG_FUNCTION_NAME;
486
487    if ( OMX_StateInvalid == mComponentState )
488        {
489        CAMHAL_LOGEA("OMX component is in invalid state");
490        ret = -EINVAL;
491        }
492
493    if ( NO_ERROR == ret )
494        {
495        OMX_INIT_STRUCT_PTR (&bControl, OMX_TI_CONFIG_LOCAL_AND_GLOBAL_BRIGHTNESSCONTRASTTYPE);
496
497        bControl.nPortIndex = OMX_ALL;
498
499        switch ( mode )
500            {
501            case OMXCameraAdapter::BRIGHTNESS_ON:
502                {
503                bControl.eControl = OMX_TI_BceModeOn;
504                break;
505                }
506            case OMXCameraAdapter::BRIGHTNESS_AUTO:
507                {
508                bControl.eControl = OMX_TI_BceModeAuto;
509                break;
510                }
511            case OMXCameraAdapter::BRIGHTNESS_OFF:
512            default:
513                {
514                bControl.eControl = OMX_TI_BceModeOff;
515                break;
516                }
517            }
518
519        eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
520                               ( OMX_INDEXTYPE ) OMX_TI_IndexConfigGlobalBrightnessContrastEnhance,
521                               &bControl);
522        if ( OMX_ErrorNone != eError )
523            {
524            CAMHAL_LOGEB("Error while setting GBCE 0x%x", eError);
525            }
526        else
527            {
528            CAMHAL_LOGDB("GBCE configured successfully 0x%x", mode);
529            }
530        }
531
532    LOG_FUNCTION_NAME_EXIT;
533
534    return ret;
535}
536
537status_t OMXCameraAdapter::setGLBCE(OMXCameraAdapter::BrightnessMode mode)
538{
539    status_t ret = NO_ERROR;
540    OMX_ERRORTYPE eError = OMX_ErrorNone;
541    OMX_TI_CONFIG_LOCAL_AND_GLOBAL_BRIGHTNESSCONTRASTTYPE bControl;
542
543    LOG_FUNCTION_NAME;
544
545    if ( OMX_StateInvalid == mComponentState )
546        {
547        CAMHAL_LOGEA("OMX component is in invalid state");
548        ret = -EINVAL;
549        }
550
551    if ( NO_ERROR == ret )
552        {
553        OMX_INIT_STRUCT_PTR (&bControl, OMX_TI_CONFIG_LOCAL_AND_GLOBAL_BRIGHTNESSCONTRASTTYPE);
554        bControl.nPortIndex = OMX_ALL;
555
556        switch ( mode )
557            {
558            case OMXCameraAdapter::BRIGHTNESS_ON:
559                {
560                bControl.eControl = OMX_TI_BceModeOn;
561                break;
562                }
563            case OMXCameraAdapter::BRIGHTNESS_AUTO:
564                {
565                bControl.eControl = OMX_TI_BceModeAuto;
566                break;
567                }
568            case OMXCameraAdapter::BRIGHTNESS_OFF:
569            default:
570                {
571                bControl.eControl = OMX_TI_BceModeOff;
572                break;
573                }
574            }
575
576        eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
577                               ( OMX_INDEXTYPE ) OMX_TI_IndexConfigLocalBrightnessContrastEnhance,
578                               &bControl);
579        if ( OMX_ErrorNone != eError )
580            {
581            CAMHAL_LOGEB("Error while configure GLBCE 0x%x", eError);
582            }
583        else
584            {
585            CAMHAL_LOGDA("GLBCE configured successfully");
586            }
587        }
588
589    LOG_FUNCTION_NAME_EXIT;
590
591    return ret;
592}
593
594status_t OMXCameraAdapter::setCaptureMode(OMXCameraAdapter::CaptureMode mode)
595{
596    status_t ret = NO_ERROR;
597    OMX_ERRORTYPE eError = OMX_ErrorNone;
598    OMX_CONFIG_CAMOPERATINGMODETYPE camMode;
599    OMX_CONFIG_BOOLEANTYPE bCAC;
600
601    LOG_FUNCTION_NAME;
602
603    OMX_INIT_STRUCT_PTR (&bCAC, OMX_CONFIG_BOOLEANTYPE);
604    bCAC.bEnabled = OMX_FALSE;
605
606    if ( NO_ERROR == ret )
607        {
608
609        OMX_INIT_STRUCT_PTR (&camMode, OMX_CONFIG_CAMOPERATINGMODETYPE);
610        if ( mSensorIndex == OMX_TI_StereoSensor )
611            {
612            CAMHAL_LOGDA("Camera mode: STEREO");
613            camMode.eCamOperatingMode = OMX_CaptureStereoImageCapture;
614            }
615        else if ( OMXCameraAdapter::HIGH_SPEED == mode )
616            {
617            CAMHAL_LOGDA("Camera mode: HIGH SPEED");
618            camMode.eCamOperatingMode = OMX_CaptureImageHighSpeedTemporalBracketing;
619            }
620        else if( OMXCameraAdapter::HIGH_QUALITY == mode )
621            {
622            CAMHAL_LOGDA("Camera mode: HIGH QUALITY");
623            camMode.eCamOperatingMode = OMX_CaptureImageProfileBase;
624            bCAC.bEnabled = OMX_TRUE;
625            }
626        else if( OMXCameraAdapter::HIGH_QUALITY_ZSL== mode )
627            {
628            CAMHAL_LOGDA("Camera mode: HIGH QUALITY_ZSL");
629            camMode.eCamOperatingMode = OMX_TI_CaptureImageProfileZeroShutterLag;
630            bCAC.bEnabled = OMX_TRUE;
631            }
632        else if( OMXCameraAdapter::VIDEO_MODE == mode )
633            {
634            CAMHAL_LOGDA("Camera mode: VIDEO MODE");
635            camMode.eCamOperatingMode = OMX_CaptureVideo;
636            }
637        else
638            {
639            CAMHAL_LOGEA("Camera mode: INVALID mode passed!");
640            return BAD_VALUE;
641            }
642
643        if(ret != -1)
644            {
645            eError =  OMX_SetParameter(mCameraAdapterParameters.mHandleComp,
646                                       ( OMX_INDEXTYPE ) OMX_IndexCameraOperatingMode,
647                                       &camMode);
648            if ( OMX_ErrorNone != eError )
649                {
650                CAMHAL_LOGEB("Error while configuring camera mode 0x%x", eError);
651                ret = -1;
652                }
653            else
654                {
655                CAMHAL_LOGDA("Camera mode configured successfully");
656                }
657            }
658
659        if(ret != -1)
660            {
661            //Configure CAC
662            eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
663                                    ( OMX_INDEXTYPE ) OMX_IndexConfigChromaticAberrationCorrection,
664                                    &bCAC);
665            if ( OMX_ErrorNone != eError )
666                {
667                CAMHAL_LOGEB("Error while configuring CAC 0x%x", eError);
668                ret = -1;
669                }
670            else
671                {
672                CAMHAL_LOGDA("CAC configured successfully");
673                }
674            }
675        }
676
677    LOG_FUNCTION_NAME_EXIT;
678
679    return ret;
680}
681
682status_t OMXCameraAdapter::setLDC(OMXCameraAdapter::IPPMode mode)
683{
684    status_t ret = NO_ERROR;
685    OMX_ERRORTYPE eError = OMX_ErrorNone;
686    OMX_CONFIG_BOOLEANTYPE bOMX;
687
688    LOG_FUNCTION_NAME;
689
690    if ( OMX_StateLoaded != mComponentState )
691        {
692        CAMHAL_LOGEA("OMX component is not in loaded state");
693        ret = -EINVAL;
694        }
695
696    if ( NO_ERROR == ret )
697        {
698        OMX_INIT_STRUCT_PTR (&bOMX, OMX_CONFIG_BOOLEANTYPE);
699
700        switch ( mode )
701            {
702            case OMXCameraAdapter::IPP_LDCNSF:
703            case OMXCameraAdapter::IPP_LDC:
704                {
705                bOMX.bEnabled = OMX_TRUE;
706                break;
707                }
708            case OMXCameraAdapter::IPP_NONE:
709            case OMXCameraAdapter::IPP_NSF:
710            default:
711                {
712                bOMX.bEnabled = OMX_FALSE;
713                break;
714                }
715            }
716
717        CAMHAL_LOGVB("Configuring LDC mode 0x%x", bOMX.bEnabled);
718        eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp,
719                                  ( OMX_INDEXTYPE ) OMX_IndexParamLensDistortionCorrection,
720                                  &bOMX);
721        if ( OMX_ErrorNone != eError )
722            {
723            CAMHAL_LOGEA("Error while setting LDC");
724            ret = -1;
725            }
726        }
727
728    LOG_FUNCTION_NAME_EXIT;
729
730    return ret;
731}
732
733status_t OMXCameraAdapter::setNSF(OMXCameraAdapter::IPPMode mode)
734{
735    status_t ret = NO_ERROR;
736    OMX_ERRORTYPE eError = OMX_ErrorNone;
737    OMX_PARAM_ISONOISEFILTERTYPE nsf;
738
739    LOG_FUNCTION_NAME;
740
741    if ( OMX_StateLoaded != mComponentState )
742        {
743        CAMHAL_LOGEA("OMX component is not in loaded state");
744        ret = -EINVAL;
745        }
746
747    if ( NO_ERROR == ret )
748        {
749        OMX_INIT_STRUCT_PTR (&nsf, OMX_PARAM_ISONOISEFILTERTYPE);
750        nsf.nPortIndex = OMX_ALL;
751
752        switch ( mode )
753            {
754            case OMXCameraAdapter::IPP_LDCNSF:
755            case OMXCameraAdapter::IPP_NSF:
756                {
757                nsf.eMode = OMX_ISONoiseFilterModeOn;
758                break;
759                }
760            case OMXCameraAdapter::IPP_LDC:
761            case OMXCameraAdapter::IPP_NONE:
762            default:
763                {
764                nsf.eMode = OMX_ISONoiseFilterModeOff;
765                break;
766                }
767            }
768
769        CAMHAL_LOGVB("Configuring NSF mode 0x%x", nsf.eMode);
770        eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp,
771                                  (OMX_INDEXTYPE)OMX_IndexParamHighISONoiseFiler,
772                                  &nsf);
773        if ( OMX_ErrorNone != eError )
774            {
775            CAMHAL_LOGEA("Error while setting NSF");
776            ret = -1;
777            }
778        }
779
780    LOG_FUNCTION_NAME_EXIT;
781
782    return ret;
783}
784
785status_t OMXCameraAdapter::setImageQuality(unsigned int quality)
786{
787    status_t ret = NO_ERROR;
788    OMX_ERRORTYPE eError = OMX_ErrorNone;
789    OMX_IMAGE_PARAM_QFACTORTYPE jpegQualityConf;
790
791    LOG_FUNCTION_NAME;
792
793    if ( OMX_StateInvalid == mComponentState )
794        {
795        CAMHAL_LOGEA("OMX component is in invalid state");
796        ret = -EINVAL;
797        }
798
799    if ( NO_ERROR == ret )
800        {
801        OMX_INIT_STRUCT(jpegQualityConf, OMX_IMAGE_PARAM_QFACTORTYPE);
802        jpegQualityConf.nQFactor = quality;
803        jpegQualityConf.nPortIndex = mCameraAdapterParameters.mImagePortIndex;
804
805        eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp,
806                                  OMX_IndexParamQFactor,
807                                  &jpegQualityConf);
808        if ( OMX_ErrorNone != eError )
809            {
810            CAMHAL_LOGEB("Error while configuring jpeg Quality 0x%x", eError);
811            ret = -1;
812            }
813        }
814
815    LOG_FUNCTION_NAME_EXIT;
816
817    return ret;
818}
819
820status_t OMXCameraAdapter::setThumbnailParams(unsigned int width,
821                                              unsigned int height,
822                                              unsigned int quality)
823{
824    status_t ret = NO_ERROR;
825    OMX_ERRORTYPE eError = OMX_ErrorNone;
826    OMX_PARAM_THUMBNAILTYPE thumbConf;
827
828    LOG_FUNCTION_NAME;
829
830    if ( OMX_StateInvalid == mComponentState )
831        {
832        CAMHAL_LOGEA("OMX component is in invalid state");
833        ret = -EINVAL;
834        }
835
836    if ( NO_ERROR == ret )
837        {
838        OMX_INIT_STRUCT(thumbConf, OMX_PARAM_THUMBNAILTYPE);
839        thumbConf.nPortIndex = mCameraAdapterParameters.mImagePortIndex;
840
841        eError = OMX_GetParameter(mCameraAdapterParameters.mHandleComp,
842                                  ( OMX_INDEXTYPE ) OMX_IndexParamThumbnail,
843                                  &thumbConf);
844        if ( OMX_ErrorNone != eError )
845            {
846            CAMHAL_LOGEB("Error while retrieving thumbnail size 0x%x", eError);
847            ret = -1;
848            }
849
850        //CTS Requirement: width or height equal to zero should
851        //result in absent EXIF thumbnail
852        if ( ( 0 == width ) || ( 0 == height ) )
853            {
854            thumbConf.nWidth = mThumbRes[0].width;
855            thumbConf.nHeight = mThumbRes[0].height;
856            thumbConf.eCompressionFormat = OMX_IMAGE_CodingUnused;
857            }
858        else
859            {
860            thumbConf.nWidth = width;
861            thumbConf.nHeight = height;
862            thumbConf.nQuality = quality;
863            thumbConf.eCompressionFormat = OMX_IMAGE_CodingJPEG;
864            }
865
866        CAMHAL_LOGDB("Thumbnail width = %d, Thumbnail Height = %d", width, height);
867
868        eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp,
869                                  ( OMX_INDEXTYPE ) OMX_IndexParamThumbnail,
870                                  &thumbConf);
871        if ( OMX_ErrorNone != eError )
872            {
873            CAMHAL_LOGEB("Error while configuring thumbnail size 0x%x", eError);
874            ret = -1;
875            }
876        }
877
878    LOG_FUNCTION_NAME_EXIT;
879
880    return ret;
881}
882
883status_t OMXCameraAdapter::setAlgoPriority(AlgoPriority priority,
884                                           Algorithm3A algo,
885                                           bool enable)
886{
887    OMX_ERRORTYPE eError = OMX_ErrorNone;
888
889    LOG_FUNCTION_NAME;
890
891    if ( OMX_StateInvalid == mComponentState ) {
892        CAMHAL_LOGEA("OMX component is in invalid state");
893        return NO_INIT;
894    }
895
896    if ( FACE_PRIORITY == priority ) {
897
898        if ( algo & WHITE_BALANCE_ALGO ) {
899            if ( enable ) {
900                mFacePriority.bAwbFaceEnable =  OMX_TRUE;
901            } else {
902                mFacePriority.bAwbFaceEnable =  OMX_FALSE;
903            }
904        }
905
906        if ( algo & EXPOSURE_ALGO ) {
907            if ( enable ) {
908                mFacePriority.bAeFaceEnable =  OMX_TRUE;
909            } else {
910                mFacePriority.bAeFaceEnable =  OMX_FALSE;
911            }
912        }
913
914        if ( algo & FOCUS_ALGO ) {
915            if ( enable ) {
916                mFacePriority.bAfFaceEnable =  OMX_TRUE;
917            } else {
918                mFacePriority.bAfFaceEnable =  OMX_FALSE;
919            }
920        }
921
922        eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
923                                ( OMX_INDEXTYPE ) OMX_TI_IndexConfigFacePriority3a,
924                                &mFacePriority);
925        if ( OMX_ErrorNone != eError ) {
926            CAMHAL_LOGEB("Error while configuring face priority 0x%x", eError);
927        } else {
928            CAMHAL_LOGDB("Face priority for algorithms set successfully 0x%x, 0x%x, 0x%x",
929                         mFacePriority.bAfFaceEnable,
930                         mFacePriority.bAeFaceEnable,
931                         mFacePriority.bAwbFaceEnable);
932        }
933
934    } else if ( REGION_PRIORITY == priority ) {
935
936        if ( algo & WHITE_BALANCE_ALGO ) {
937            if ( enable ) {
938                mRegionPriority.bAwbRegionEnable= OMX_TRUE;
939            } else {
940                mRegionPriority.bAwbRegionEnable = OMX_FALSE;
941            }
942        }
943
944        if ( algo & EXPOSURE_ALGO ) {
945            if ( enable ) {
946                mRegionPriority.bAeRegionEnable = OMX_TRUE;
947            } else {
948                mRegionPriority.bAeRegionEnable = OMX_FALSE;
949            }
950        }
951
952        if ( algo & FOCUS_ALGO ) {
953            if ( enable ) {
954                mRegionPriority.bAfRegionEnable = OMX_TRUE;
955            } else {
956                mRegionPriority.bAfRegionEnable = OMX_FALSE;
957            }
958        }
959
960        eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
961                                ( OMX_INDEXTYPE ) OMX_TI_IndexConfigRegionPriority3a,
962                                &mRegionPriority);
963        if ( OMX_ErrorNone != eError ) {
964            CAMHAL_LOGEB("Error while configuring region priority 0x%x", eError);
965        } else {
966            CAMHAL_LOGDB("Region priority for algorithms set successfully 0x%x, 0x%x, 0x%x",
967                         mRegionPriority.bAfRegionEnable,
968                         mRegionPriority.bAeRegionEnable,
969                         mRegionPriority.bAwbRegionEnable);
970        }
971
972    }
973
974    LOG_FUNCTION_NAME_EXIT;
975
976    return ErrorUtils::omxToAndroidError(eError);
977}
978
979status_t OMXCameraAdapter::setPictureRotation(unsigned int degree)
980{
981    status_t ret = NO_ERROR;
982    OMX_ERRORTYPE eError = OMX_ErrorNone;
983    OMX_CONFIG_ROTATIONTYPE rotation;
984
985    LOG_FUNCTION_NAME;
986
987    if ( OMX_StateInvalid == mComponentState )
988        {
989        CAMHAL_LOGEA("OMX component is in invalid state");
990        ret = -1;
991        }
992
993    if ( NO_ERROR == ret )
994        {
995        OMX_INIT_STRUCT(rotation, OMX_CONFIG_ROTATIONTYPE);
996        rotation.nRotation = degree;
997        rotation.nPortIndex = mCameraAdapterParameters.mImagePortIndex;
998
999        eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
1000                               OMX_IndexConfigCommonRotate,
1001                               &rotation);
1002        if ( OMX_ErrorNone != eError )
1003            {
1004            CAMHAL_LOGEB("Error while configuring rotation 0x%x", eError);
1005            }
1006        }
1007
1008    LOG_FUNCTION_NAME_EXIT;
1009
1010    return ret;
1011}
1012
1013status_t OMXCameraAdapter::setSensorOrientation(unsigned int degree)
1014{
1015    status_t ret = NO_ERROR;
1016    OMX_ERRORTYPE eError = OMX_ErrorNone;
1017    OMX_CONFIG_ROTATIONTYPE sensorOrientation;
1018    int tmpHeight, tmpWidth;
1019    OMXCameraPortParameters *mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
1020
1021    LOG_FUNCTION_NAME;
1022    if ( OMX_StateInvalid == mComponentState )
1023        {
1024        CAMHAL_LOGEA("OMX component is in invalid state");
1025        ret = -1;
1026        }
1027
1028    /* Set Temproary Port resolution.
1029    * For resolution with height > 1008,resolution cannot be set without configuring orientation.
1030    * So we first set a temp resolution. We have used VGA
1031    */
1032    tmpHeight = mPreviewData->mHeight;
1033    tmpWidth = mPreviewData->mWidth;
1034    mPreviewData->mWidth = 640;
1035    mPreviewData->mHeight = 480;
1036    ret = setFormat(OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW, *mPreviewData);
1037    if ( ret != NO_ERROR )
1038        {
1039        CAMHAL_LOGEB("setFormat() failed %d", ret);
1040        }
1041
1042    /* Now set Required Orientation*/
1043    if ( NO_ERROR == ret )
1044        {
1045        OMX_INIT_STRUCT(sensorOrientation, OMX_CONFIG_ROTATIONTYPE);
1046        sensorOrientation.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1047        eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
1048                               OMX_IndexConfigCommonRotate,
1049                               &sensorOrientation);
1050        if ( OMX_ErrorNone != eError )
1051            {
1052            CAMHAL_LOGEB("Error while Reading Sensor Orientation :  0x%x", eError);
1053            }
1054        CAMHAL_LOGVB(" Currently Sensor Orientation is set to : %d",
1055                     ( unsigned int ) sensorOrientation.nRotation);
1056        sensorOrientation.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1057        sensorOrientation.nRotation = degree;
1058        eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
1059                               OMX_IndexConfigCommonRotate,
1060                               &sensorOrientation);
1061        if ( OMX_ErrorNone != eError )
1062            {
1063            CAMHAL_LOGEB("Error while configuring rotation 0x%x", eError);
1064            }
1065        CAMHAL_LOGVA(" Read the Parameters that are set");
1066        eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
1067                               OMX_IndexConfigCommonRotate,
1068                               &sensorOrientation);
1069        if ( OMX_ErrorNone != eError )
1070            {
1071            CAMHAL_LOGEB("Error while Reading Sensor Orientation :  0x%x", eError);
1072            }
1073        CAMHAL_LOGVB(" Currently Sensor Orientation is set to : %d",
1074                     ( unsigned int ) sensorOrientation.nRotation);
1075        CAMHAL_LOGVB(" Sensor Configured for Port : %d",
1076                     ( unsigned int ) sensorOrientation.nPortIndex);
1077        }
1078
1079    /* Now set the required resolution as requested */
1080
1081    mPreviewData->mWidth = tmpWidth;
1082    mPreviewData->mHeight = tmpHeight;
1083    if ( NO_ERROR == ret )
1084        {
1085        ret = setFormat (mCameraAdapterParameters.mPrevPortIndex,
1086                         mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex]);
1087        if ( NO_ERROR != ret )
1088            {
1089            CAMHAL_LOGEB("setFormat() failed %d", ret);
1090            }
1091        }
1092
1093    LOG_FUNCTION_NAME_EXIT;
1094
1095    return ret;
1096}
1097
1098status_t OMXCameraAdapter::setVFramerate(OMX_U32 minFrameRate, OMX_U32 maxFrameRate)
1099{
1100    status_t ret = NO_ERROR;
1101    OMX_ERRORTYPE eError = OMX_ErrorNone;
1102    OMX_TI_CONFIG_VARFRMRANGETYPE vfr;
1103
1104    LOG_FUNCTION_NAME;
1105
1106    if ( OMX_StateInvalid == mComponentState )
1107        {
1108        CAMHAL_LOGEA("OMX component is in invalid state");
1109        ret = -EINVAL;
1110        }
1111
1112    if ( NO_ERROR == ret )
1113        {
1114        OMX_INIT_STRUCT_PTR (&vfr, OMX_TI_CONFIG_VARFRMRANGETYPE);
1115
1116        vfr.xMin = minFrameRate<<16;
1117        vfr.xMax = maxFrameRate<<16;
1118
1119        eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
1120                               (OMX_INDEXTYPE)OMX_TI_IndexConfigVarFrmRange,
1121                               &vfr);
1122        if(OMX_ErrorNone != eError)
1123            {
1124            CAMHAL_LOGEB("Error while setting VFR min = %d, max = %d, error = 0x%x",
1125                         ( unsigned int ) minFrameRate,
1126                         ( unsigned int ) maxFrameRate,
1127                         eError);
1128            ret = -1;
1129            }
1130        else
1131            {
1132            CAMHAL_LOGDB("VFR Configured Successfully [%d:%d]",
1133                        ( unsigned int ) minFrameRate,
1134                        ( unsigned int ) maxFrameRate);
1135            }
1136        }
1137
1138    return ret;
1139 }
1140
1141};
1142