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