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