OMXCameraAdapter.cpp revision ee6bb64f60c228d711dc1d6875d8f4b0ed88b6cf
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 OMXCameraAdapter.cpp 19* 20* This file maps the Camera Hardware Interface to OMX. 21* 22*/ 23 24#include "CameraHal.h" 25#include "OMXCameraAdapter.h" 26#include "ErrorUtils.h" 27#include "TICameraParameters.h" 28#include <signal.h> 29#include <math.h> 30 31#include <cutils/properties.h> 32#define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false )) 33static int mDebugFps = 0; 34 35#define HERE(Msg) {CAMHAL_LOGEB("--===line %d, %s===--\n", __LINE__, Msg);} 36 37namespace android { 38 39#undef LOG_TAG 40///Maintain a separate tag for OMXCameraAdapter logs to isolate issues OMX specific 41#define LOG_TAG "CameraHAL" 42 43//frames skipped before recalculating the framerate 44#define FPS_PERIOD 30 45 46static OMXCameraAdapter *gCameraAdapter = NULL; 47Mutex gAdapterLock; 48 49/*--------------------Camera Adapter Class STARTS here-----------------------------*/ 50 51status_t OMXCameraAdapter::initialize(CameraProperties::Properties* caps, int sensor_index) 52{ 53 LOG_FUNCTION_NAME; 54 55 char value[PROPERTY_VALUE_MAX]; 56 property_get("debug.camera.showfps", value, "0"); 57 mDebugFps = atoi(value); 58 59 TIMM_OSAL_ERRORTYPE osalError = OMX_ErrorNone; 60 OMX_ERRORTYPE eError = OMX_ErrorNone; 61 status_t ret = NO_ERROR; 62 63 64 mLocalVersionParam.s.nVersionMajor = 0x1; 65 mLocalVersionParam.s.nVersionMinor = 0x1; 66 mLocalVersionParam.s.nRevision = 0x0 ; 67 mLocalVersionParam.s.nStep = 0x0; 68 69 mPending3Asettings = 0;//E3AsettingsAll; 70 71 if ( 0 != mInitSem.Count() ) 72 { 73 CAMHAL_LOGEB("Error mInitSem semaphore count %d", mInitSem.Count()); 74 LOG_FUNCTION_NAME_EXIT; 75 return NO_INIT; 76 } 77 78 if (mComponentState != OMX_StateLoaded && mComponentState != OMX_StateInvalid) { 79 LOG_FUNCTION_NAME_EXIT; 80 return NO_INIT; 81 } 82 83 if ( mComponentState != OMX_StateExecuting ){ 84 ///Update the preview and image capture port indexes 85 mCameraAdapterParameters.mPrevPortIndex = OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW; 86 // temp changed in order to build OMX_CAMERA_PORT_VIDEO_OUT_IMAGE; 87 mCameraAdapterParameters.mImagePortIndex = OMX_CAMERA_PORT_IMAGE_OUT_IMAGE; 88 mCameraAdapterParameters.mMeasurementPortIndex = OMX_CAMERA_PORT_VIDEO_OUT_MEASUREMENT; 89 //currently not supported use preview port instead 90 mCameraAdapterParameters.mVideoPortIndex = OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW; 91 92 if(!mCameraAdapterParameters.mHandleComp) 93 { 94 ///Initialize the OMX Core 95 eError = OMX_Init(); 96 97 if(eError!=OMX_ErrorNone) 98 { 99 CAMHAL_LOGEB("OMX_Init -0x%x", eError); 100 } 101 GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); 102 103 ///Setup key parameters to send to Ducati during init 104 OMX_CALLBACKTYPE oCallbacks; 105 106 /* Initialize the callback handles */ 107 oCallbacks.EventHandler = android::OMXCameraAdapterEventHandler; 108 oCallbacks.EmptyBufferDone = android::OMXCameraAdapterEmptyBufferDone; 109 oCallbacks.FillBufferDone = android::OMXCameraAdapterFillBufferDone; 110 111 ///Get the handle to the OMX Component 112 mCameraAdapterParameters.mHandleComp = NULL; 113 eError = OMX_GetHandle(&(mCameraAdapterParameters.mHandleComp), // previously used: OMX_GetHandle 114 (OMX_STRING)"OMX.TI.DUCATI1.VIDEO.CAMERA" ///@todo Use constant instead of hardcoded name 115 , this 116 , &oCallbacks); 117 118 if(eError!=OMX_ErrorNone) 119 { 120 CAMHAL_LOGEB("OMX_GetHandle -0x%x", eError); 121 } 122 GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); 123 124 125 eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp, 126 OMX_CommandPortDisable, 127 OMX_ALL, 128 NULL); 129 130 if(eError!=OMX_ErrorNone) 131 { 132 CAMHAL_LOGEB("OMX_SendCommand(OMX_CommandPortDisable) -0x%x", eError); 133 } 134 135 GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); 136 137 ///Register for port enable event 138 ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp, 139 OMX_EventCmdComplete, 140 OMX_CommandPortEnable, 141 mCameraAdapterParameters.mPrevPortIndex, 142 mInitSem); 143 if(ret!=NO_ERROR) 144 { 145 CAMHAL_LOGEB("Error in registering for event %d", ret); 146 goto EXIT; 147 } 148 149 ///Enable PREVIEW Port 150 eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp, 151 OMX_CommandPortEnable, 152 mCameraAdapterParameters.mPrevPortIndex, 153 NULL); 154 155 if(eError!=OMX_ErrorNone) 156 { 157 CAMHAL_LOGEB("OMX_SendCommand(OMX_CommandPortEnable) -0x%x", eError); 158 } 159 160 GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); 161 162 //Wait for the port enable event to occur 163 ret = mInitSem.WaitTimeout(OMX_CMD_TIMEOUT); 164 if ( NO_ERROR == ret ) 165 { 166 CAMHAL_LOGDA("-Port enable event arrived"); 167 } 168 else 169 { 170 ret |= SignalEvent(mCameraAdapterParameters.mHandleComp, 171 OMX_EventCmdComplete, 172 OMX_CommandPortEnable, 173 mCameraAdapterParameters.mPrevPortIndex, 174 NULL); 175 CAMHAL_LOGEA("Timeout for enabling preview port expired!"); 176 goto EXIT; 177 } 178 179 } 180 else 181 { 182 OMXCameraPortParameters * mPreviewData = 183 &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex]; 184 185 //Apply default configs before trying to swtich to a new sensor 186 if ( NO_ERROR != setFormat(OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW, *mPreviewData) ) 187 { 188 CAMHAL_LOGEB("Error 0x%x while applying defaults", ret); 189 goto EXIT; 190 } 191 } 192 } 193 ///Select the sensor 194 OMX_CONFIG_SENSORSELECTTYPE sensorSelect; 195 OMX_INIT_STRUCT_PTR (&sensorSelect, OMX_CONFIG_SENSORSELECTTYPE); 196 sensorSelect.eSensor = (OMX_SENSORSELECT)sensor_index; 197 eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, ( OMX_INDEXTYPE ) OMX_TI_IndexConfigSensorSelect, &sensorSelect); 198 199 if ( OMX_ErrorNone != eError ) 200 { 201 CAMHAL_LOGEB("Error while selecting the sensor index as %d - 0x%x", sensor_index, eError); 202 return BAD_VALUE; 203 } 204 else 205 { 206 CAMHAL_LOGDB("Sensor %d selected successfully", sensor_index); 207 } 208 209 printComponentVersion(mCameraAdapterParameters.mHandleComp); 210 211 mSensorIndex = sensor_index; 212 mBracketingEnabled = false; 213 mBracketingBuffersQueuedCount = 0; 214 mBracketingRange = 1; 215 mLastBracetingBufferIdx = 0; 216 mOMXStateSwitch = false; 217 218 if ( mComponentState != OMX_StateExecuting ){ 219 mCaptureSignalled = false; 220 mCaptureConfigured = false; 221 mRecording = false; 222 mWaitingForSnapshot = false; 223 mSnapshotCount = 0; 224 mComponentState = OMX_StateLoaded; 225 226 mCapMode = HIGH_QUALITY; 227 mIPP = IPP_NULL; 228 mVstabEnabled = false; 229 mVnfEnabled = false; 230 mBurstFrames = 1; 231 mCapturedFrames = 0; 232 mPictureQuality = 100; 233 mCurrentZoomIdx = 0; 234 mTargetZoomIdx = 0; 235 mReturnZoomStatus = false; 236 mZoomInc = 1; 237 mZoomParameterIdx = 0; 238 mExposureBracketingValidEntries = 0; 239 mSensorOverclock = false; 240 241 mDeviceOrientation = 0; 242 mCapabilities = caps; 243 244 mEXIFData.mGPSData.mAltitudeValid = false; 245 mEXIFData.mGPSData.mDatestampValid = false; 246 mEXIFData.mGPSData.mLatValid = false; 247 mEXIFData.mGPSData.mLongValid = false; 248 mEXIFData.mGPSData.mMapDatumValid = false; 249 mEXIFData.mGPSData.mProcMethodValid = false; 250 mEXIFData.mGPSData.mVersionIdValid = false; 251 mEXIFData.mGPSData.mTimeStampValid = false; 252 mEXIFData.mModelValid = false; 253 mEXIFData.mMakeValid = false; 254 255 // initialize command handling thread 256 if(mCommandHandler.get() == NULL) 257 mCommandHandler = new CommandHandler(this); 258 259 if ( NULL == mCommandHandler.get() ) 260 { 261 CAMHAL_LOGEA("Couldn't create command handler"); 262 return NO_MEMORY; 263 } 264 265 ret = mCommandHandler->run("CallbackThread", PRIORITY_URGENT_DISPLAY); 266 if ( ret != NO_ERROR ) 267 { 268 if( ret == INVALID_OPERATION){ 269 CAMHAL_LOGDA("command handler thread already runnning!!"); 270 }else 271 { 272 CAMHAL_LOGEA("Couldn't run command handlerthread"); 273 return ret; 274 } 275 } 276 277 // initialize omx callback handling thread 278 if(mOMXCallbackHandler.get() == NULL) 279 mOMXCallbackHandler = new OMXCallbackHandler(this); 280 281 if ( NULL == mOMXCallbackHandler.get() ) 282 { 283 CAMHAL_LOGEA("Couldn't create omx callback handler"); 284 return NO_MEMORY; 285 } 286 287 ret = mOMXCallbackHandler->run("OMXCallbackThread", PRIORITY_URGENT_DISPLAY); 288 if ( ret != NO_ERROR ) 289 { 290 if( ret == INVALID_OPERATION){ 291 CAMHAL_LOGDA("omx callback handler thread already runnning!!"); 292 }else 293 { 294 CAMHAL_LOGEA("Couldn't run omx callback handler thread"); 295 return ret; 296 } 297 } 298 299 //Remove any unhandled events 300 if ( !mEventSignalQ.isEmpty() ) 301 { 302 for (unsigned int i = 0 ; i < mEventSignalQ.size() ; i++ ) 303 { 304 TIUTILS::Message *msg = mEventSignalQ.itemAt(i); 305 //remove from queue and free msg 306 mEventSignalQ.removeAt(i); 307 if ( NULL != msg ) 308 { 309 free(msg); 310 } 311 } 312 } 313 314 OMX_INIT_STRUCT_PTR (&mRegionPriority, OMX_TI_CONFIG_3A_REGION_PRIORITY); 315 OMX_INIT_STRUCT_PTR (&mFacePriority, OMX_TI_CONFIG_3A_FACE_PRIORITY); 316 mRegionPriority.nPortIndex = OMX_ALL; 317 mFacePriority.nPortIndex = OMX_ALL; 318 319 //Setting this flag will that the first setParameter call will apply all 3A settings 320 //and will not conditionally apply based on current values. 321 mFirstTimeInit = true; 322 323 memset(mExposureBracketingValues, 0, EXP_BRACKET_RANGE*sizeof(int)); 324 mMeasurementEnabled = false; 325 mFaceDetectionRunning = false; 326 mFaceDetectionPaused = false; 327 328 memset(&mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex], 0, sizeof(OMXCameraPortParameters)); 329 memset(&mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex], 0, sizeof(OMXCameraPortParameters)); 330 331 //Initialize 3A defaults 332 ret = apply3ADefaults(mParameters3A); 333 if ( NO_ERROR != ret ) 334 { 335 goto EXIT; 336 } 337 338 } 339 LOG_FUNCTION_NAME_EXIT; 340 return ErrorUtils::omxToAndroidError(eError); 341 342 EXIT: 343 344 CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, ret, eError); 345 346 if(mCameraAdapterParameters.mHandleComp) 347 { 348 ///Free the OMX component handle in case of error 349 OMX_FreeHandle(mCameraAdapterParameters.mHandleComp); 350 } 351 352 ///De-init the OMX 353 OMX_Deinit(); 354 355 LOG_FUNCTION_NAME_EXIT; 356 357 return ErrorUtils::omxToAndroidError(eError); 358} 359 360OMXCameraAdapter::OMXCameraPortParameters *OMXCameraAdapter::getPortParams(CameraFrame::FrameType frameType) 361{ 362 OMXCameraAdapter::OMXCameraPortParameters *ret = NULL; 363 364 switch ( frameType ) 365 { 366 case CameraFrame::IMAGE_FRAME: 367 case CameraFrame::RAW_FRAME: 368 ret = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex]; 369 break; 370 case CameraFrame::PREVIEW_FRAME_SYNC: 371 case CameraFrame::SNAPSHOT_FRAME: 372 case CameraFrame::VIDEO_FRAME_SYNC: 373 ret = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex]; 374 break; 375 case CameraFrame::FRAME_DATA_SYNC: 376 ret = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex]; 377 break; 378 default: 379 break; 380 }; 381 382 return ret; 383} 384 385status_t OMXCameraAdapter::fillThisBuffer(void* frameBuf, CameraFrame::FrameType frameType) 386{ 387 status_t ret = NO_ERROR; 388 OMXCameraPortParameters *port = NULL; 389 OMX_ERRORTYPE eError = OMX_ErrorNone; 390 BaseCameraAdapter::AdapterState state; 391 BaseCameraAdapter::getState(state); 392 393 if ( ( PREVIEW_ACTIVE & state ) != PREVIEW_ACTIVE ) 394 { 395 return NO_INIT; 396 } 397 398 if ( NULL == frameBuf ) 399 { 400 return -EINVAL; 401 } 402 403 if ( (NO_ERROR == ret) && 404 ((CameraFrame::IMAGE_FRAME == frameType) || (CameraFrame::RAW_FRAME == frameType)) && 405 (1 > mCapturedFrames) && 406 (!mBracketingEnabled)) { 407 // Signal end of image capture 408 if ( NULL != mEndImageCaptureCallback) { 409 mEndImageCaptureCallback(mEndCaptureData); 410 } 411 return NO_ERROR; 412 } 413 414 if ( NO_ERROR == ret ) 415 { 416 port = getPortParams(frameType); 417 if ( NULL == port ) 418 { 419 CAMHAL_LOGEB("Invalid frameType 0x%x", frameType); 420 ret = -EINVAL; 421 } 422 } 423 424 if ( NO_ERROR == ret ) 425 { 426 427 for ( int i = 0 ; i < port->mNumBufs ; i++) 428 { 429 if ( port->mBufferHeader[i]->pBuffer == frameBuf ) 430 { 431 eError = OMX_FillThisBuffer(mCameraAdapterParameters.mHandleComp, port->mBufferHeader[i]); 432 if ( eError != OMX_ErrorNone ) 433 { 434 CAMHAL_LOGDB("OMX_FillThisBuffer 0x%x", eError); 435 ret = ErrorUtils::omxToAndroidError(eError); 436 } 437 break; 438 } 439 } 440 441 } 442 443 return ret; 444} 445 446status_t OMXCameraAdapter::setParameters(const CameraParameters ¶ms) 447{ 448 LOG_FUNCTION_NAME; 449 450 const char * str = NULL; 451 int mode = 0; 452 status_t ret = NO_ERROR; 453 bool updateImagePortParams = false; 454 int minFramerate, maxFramerate, frameRate; 455 const char *valstr = NULL; 456 const char *oldstr = NULL; 457 int w, h; 458 OMX_COLOR_FORMATTYPE pixFormat; 459 BaseCameraAdapter::AdapterState state; 460 BaseCameraAdapter::getState(state); 461 462 ///@todo Include more camera parameters 463 if ( (valstr = params.getPreviewFormat()) != NULL ) 464 { 465 if (strcmp(valstr, (const char *) CameraParameters::PIXEL_FORMAT_YUV422I) == 0) 466 { 467 CAMHAL_LOGDA("CbYCrY format selected"); 468 pixFormat = OMX_COLOR_FormatCbYCrY; 469 } 470 else if(strcmp(valstr, (const char *) CameraParameters::PIXEL_FORMAT_YUV420SP) == 0 || 471 strcmp(valstr, (const char *) CameraParameters::PIXEL_FORMAT_YUV420P) == 0) 472 { 473 CAMHAL_LOGDA("YUV420SP format selected"); 474 pixFormat = OMX_COLOR_FormatYUV420SemiPlanar; 475 } 476 else if(strcmp(valstr, (const char *) CameraParameters::PIXEL_FORMAT_RGB565) == 0) 477 { 478 CAMHAL_LOGDA("RGB565 format selected"); 479 pixFormat = OMX_COLOR_Format16bitRGB565; 480 } 481 else 482 { 483 CAMHAL_LOGDA("Invalid format, CbYCrY format selected as default"); 484 pixFormat = OMX_COLOR_FormatCbYCrY; 485 } 486 } 487 else 488 { 489 CAMHAL_LOGEA("Preview format is NULL, defaulting to CbYCrY"); 490 pixFormat = OMX_COLOR_FormatCbYCrY; 491 } 492 493 OMXCameraPortParameters *cap; 494 cap = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex]; 495 496 params.getPreviewSize(&w, &h); 497 frameRate = params.getPreviewFrameRate(); 498 minFramerate = params.getInt(TICameraParameters::KEY_MINFRAMERATE); 499 maxFramerate = params.getInt(TICameraParameters::KEY_MAXFRAMERATE); 500 if ( ( 0 < minFramerate ) && 501 ( 0 < maxFramerate ) ) 502 { 503 if ( minFramerate > maxFramerate ) 504 { 505 CAMHAL_LOGEA(" Min FPS set higher than MAX. So setting MIN and MAX to the higher value"); 506 maxFramerate = minFramerate; 507 } 508 509 if ( 0 >= frameRate ) 510 { 511 frameRate = maxFramerate; 512 } 513 514 if( ( cap->mMinFrameRate != minFramerate ) || 515 ( cap->mMaxFrameRate != maxFramerate ) ) 516 { 517 cap->mMinFrameRate = minFramerate; 518 cap->mMaxFrameRate = maxFramerate; 519 setVFramerate(cap->mMinFrameRate, cap->mMaxFrameRate); 520 } 521 } 522 523 if ( 0 < frameRate ) 524 { 525 cap->mColorFormat = pixFormat; 526 cap->mWidth = w; 527 cap->mHeight = h; 528 cap->mFrameRate = frameRate; 529 530 CAMHAL_LOGVB("Prev: cap.mColorFormat = %d", (int)cap->mColorFormat); 531 CAMHAL_LOGVB("Prev: cap.mWidth = %d", (int)cap->mWidth); 532 CAMHAL_LOGVB("Prev: cap.mHeight = %d", (int)cap->mHeight); 533 CAMHAL_LOGVB("Prev: cap.mFrameRate = %d", (int)cap->mFrameRate); 534 535 //TODO: Add an additional parameter for video resolution 536 //use preview resolution for now 537 cap = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex]; 538 cap->mColorFormat = pixFormat; 539 cap->mWidth = w; 540 cap->mHeight = h; 541 cap->mFrameRate = frameRate; 542 543 CAMHAL_LOGVB("Video: cap.mColorFormat = %d", (int)cap->mColorFormat); 544 CAMHAL_LOGVB("Video: cap.mWidth = %d", (int)cap->mWidth); 545 CAMHAL_LOGVB("Video: cap.mHeight = %d", (int)cap->mHeight); 546 CAMHAL_LOGVB("Video: cap.mFrameRate = %d", (int)cap->mFrameRate); 547 548 ///mStride is set from setBufs() while passing the APIs 549 cap->mStride = 4096; 550 cap->mBufSize = cap->mStride * cap->mHeight; 551 } 552 553 if ( ( cap->mWidth >= 1920 ) && 554 ( cap->mHeight >= 1080 ) && 555 ( cap->mFrameRate >= FRAME_RATE_FULL_HD ) && 556 ( !mSensorOverclock ) ) 557 { 558 mOMXStateSwitch = true; 559 } 560 else if ( ( ( cap->mWidth < 1920 ) || 561 ( cap->mHeight < 1080 ) || 562 ( cap->mFrameRate < FRAME_RATE_FULL_HD ) ) && 563 ( mSensorOverclock ) ) 564 { 565 mOMXStateSwitch = true; 566 } 567 568 if ( (valstr = params.get(TICameraParameters::KEY_MEASUREMENT_ENABLE)) != NULL ) 569 { 570 if (strcmp(valstr, (const char *) TICameraParameters::MEASUREMENT_ENABLE) == 0) 571 { 572 mMeasurementEnabled = true; 573 } 574 else if (strcmp(valstr, (const char *) TICameraParameters::MEASUREMENT_DISABLE) == 0) 575 { 576 mMeasurementEnabled = false; 577 } 578 else 579 { 580 mMeasurementEnabled = false; 581 } 582 } 583 else 584 { 585 //Disable measurement data by default 586 mMeasurementEnabled = false; 587 } 588 589 ret |= setParametersCapture(params, state); 590 591 ret |= setParameters3A(params, state); 592 593 ret |= setParametersAlgo(params, state); 594 595 ret |= setParametersFocus(params, state); 596 597 ret |= setParametersFD(params, state); 598 599 ret |= setParametersZoom(params, state); 600 601 ret |= setParametersEXIF(params, state); 602 603 mParams = params; 604 mFirstTimeInit = false; 605 606 LOG_FUNCTION_NAME_EXIT; 607 return ret; 608} 609 610void saveFile(unsigned char *buff, int width, int height, int format) { 611 static int counter = 1; 612 int fd = -1; 613 char fn[256]; 614 615 LOG_FUNCTION_NAME; 616 617 fn[0] = 0; 618 sprintf(fn, "/preview%03d.yuv", counter); 619 fd = open(fn, O_CREAT | O_WRONLY | O_SYNC | O_TRUNC, 0777); 620 if(fd < 0) { 621 LOGE("Unable to open file %s: %s", fn, strerror(fd)); 622 return; 623 } 624 625 CAMHAL_LOGVB("Copying from 0x%x, size=%d x %d", buff, width, height); 626 627 //method currently supports only nv12 dumping 628 int stride = width; 629 uint8_t *bf = (uint8_t*) buff; 630 for(int i=0;i<height;i++) 631 { 632 write(fd, bf, width); 633 bf += 4096; 634 } 635 636 for(int i=0;i<height/2;i++) 637 { 638 write(fd, bf, stride); 639 bf += 4096; 640 } 641 642 close(fd); 643 644 645 counter++; 646 647 LOG_FUNCTION_NAME_EXIT; 648} 649 650void OMXCameraAdapter::getParameters(CameraParameters& params) 651{ 652 status_t ret = NO_ERROR; 653 OMX_CONFIG_EXPOSUREVALUETYPE exp; 654 OMX_ERRORTYPE eError = OMX_ErrorNone; 655 BaseCameraAdapter::AdapterState state; 656 BaseCameraAdapter::getState(state); 657 const char *valstr = NULL; 658 LOG_FUNCTION_NAME; 659 660#ifdef PARAM_FEEDBACK 661 662 OMX_CONFIG_WHITEBALCONTROLTYPE wb; 663 OMX_CONFIG_FLICKERCANCELTYPE flicker; 664 OMX_CONFIG_SCENEMODETYPE scene; 665 OMX_IMAGE_PARAM_FLASHCONTROLTYPE flash; 666 OMX_CONFIG_BRIGHTNESSTYPE brightness; 667 OMX_CONFIG_CONTRASTTYPE contrast; 668 OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE procSharpness; 669 OMX_CONFIG_SATURATIONTYPE saturation; 670 OMX_CONFIG_IMAGEFILTERTYPE effect; 671 OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE focus; 672 673 exp.nSize = sizeof(OMX_CONFIG_EXPOSURECONTROLTYPE); 674 exp.nVersion = mLocalVersionParam; 675 exp.nPortIndex = OMX_ALL; 676 677 expValues.nSize = sizeof(OMX_CONFIG_EXPOSUREVALUETYPE); 678 expValues.nVersion = mLocalVersionParam; 679 expValues.nPortIndex = OMX_ALL; 680 681 wb.nSize = sizeof(OMX_CONFIG_WHITEBALCONTROLTYPE); 682 wb.nVersion = mLocalVersionParam; 683 wb.nPortIndex = OMX_ALL; 684 685 flicker.nSize = sizeof(OMX_CONFIG_FLICKERCANCELTYPE); 686 flicker.nVersion = mLocalVersionParam; 687 flicker.nPortIndex = OMX_ALL; 688 689 scene.nSize = sizeof(OMX_CONFIG_SCENEMODETYPE); 690 scene.nVersion = mLocalVersionParam; 691 scene.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; 692 693 flash.nSize = sizeof(OMX_IMAGE_PARAM_FLASHCONTROLTYPE); 694 flash.nVersion = mLocalVersionParam; 695 flash.nPortIndex = OMX_ALL; 696 697 698 brightness.nSize = sizeof(OMX_CONFIG_BRIGHTNESSTYPE); 699 brightness.nVersion = mLocalVersionParam; 700 brightness.nPortIndex = OMX_ALL; 701 702 contrast.nSize = sizeof(OMX_CONFIG_CONTRASTTYPE); 703 contrast.nVersion = mLocalVersionParam; 704 contrast.nPortIndex = OMX_ALL; 705 706 procSharpness.nSize = sizeof( OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE ); 707 procSharpness.nVersion = mLocalVersionParam; 708 procSharpness.nPortIndex = OMX_ALL; 709 710 saturation.nSize = sizeof(OMX_CONFIG_SATURATIONTYPE); 711 saturation.nVersion = mLocalVersionParam; 712 saturation.nPortIndex = OMX_ALL; 713 714 effect.nSize = sizeof(OMX_CONFIG_IMAGEFILTERTYPE); 715 effect.nVersion = mLocalVersionParam; 716 effect.nPortIndex = OMX_ALL; 717 718 focus.nSize = sizeof(OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE); 719 focus.nVersion = mLocalVersionParam; 720 focus.nPortIndex = OMX_ALL; 721 722 OMX_GetConfig( mCameraAdapterParameters.mHandleComp,OMX_IndexConfigCommonExposure, &exp); 723 OMX_GetConfig( mCameraAdapterParameters.mHandleComp, OMX_IndexConfigCommonWhiteBalance, &wb); 724 OMX_GetConfig( mCameraAdapterParameters.mHandleComp, (OMX_INDEXTYPE)OMX_IndexConfigFlickerCancel, &flicker ); 725 OMX_GetConfig( mCameraAdapterParameters.mHandleComp, (OMX_INDEXTYPE)OMX_IndexParamSceneMode, &scene); 726 OMX_GetParameter( mCameraAdapterParameters.mHandleComp, (OMX_INDEXTYPE)OMX_IndexParamFlashControl, &flash); 727 OMX_GetConfig( mCameraAdapterParameters.mHandleComp, OMX_IndexConfigCommonBrightness, &brightness); 728 OMX_GetConfig( mCameraAdapterParameters.mHandleComp, OMX_IndexConfigCommonContrast, &contrast); 729 OMX_GetConfig( mCameraAdapterParameters.mHandleComp, (OMX_INDEXTYPE)OMX_IndexConfigSharpeningLevel, &procSharpness); 730 OMX_GetConfig( mCameraAdapterParameters.mHandleComp, OMX_IndexConfigCommonSaturation, &saturation); 731 OMX_GetConfig( mCameraAdapterParameters.mHandleComp, OMX_IndexConfigCommonImageFilter, &effect); 732 OMX_GetConfig( mCameraAdapterParameters.mHandleComp, OMX_IndexConfigFocusControl, &focus); 733 734 char * str = NULL; 735 736 for(int i = 0; i < ExpLUT.size; i++) 737 if( ExpLUT.Table[i].omxDefinition == exp.eExposureControl ) 738 str = (char*)ExpLUT.Table[i].userDefinition; 739 params.set( TICameraParameters::KEY_EXPOSURE_MODE , str); 740 741 for(int i = 0; i < WBalLUT.size; i++) 742 if( WBalLUT.Table[i].omxDefinition == wb.eWhiteBalControl ) 743 str = (char*)WBalLUT.Table[i].userDefinition; 744 params.set( CameraParameters::KEY_WHITE_BALANCE , str ); 745 746 for(int i = 0; i < FlickerLUT.size; i++) 747 if( FlickerLUT.Table[i].omxDefinition == flicker.eFlickerCancel ) 748 str = (char*)FlickerLUT.Table[i].userDefinition; 749 params.set( CameraParameters::KEY_ANTIBANDING , str ); 750 751 for(int i = 0; i < SceneLUT.size; i++) 752 if( SceneLUT.Table[i].omxDefinition == scene.eSceneMode ) 753 str = (char*)SceneLUT.Table[i].userDefinition; 754 params.set( CameraParameters::KEY_SCENE_MODE , str ); 755 756 for(int i = 0; i < FlashLUT.size; i++) 757 if( FlashLUT.Table[i].omxDefinition == flash.eFlashControl ) 758 str = (char*)FlashLUT.Table[i].userDefinition; 759 params.set( CameraParameters::KEY_FLASH_MODE, str ); 760 761 for(int i = 0; i < EffLUT.size; i++) 762 if( EffLUT.Table[i].omxDefinition == effect.eImageFilter ) 763 str = (char*)EffLUT.Table[i].userDefinition; 764 params.set( CameraParameters::KEY_EFFECT , str ); 765 766 for(int i = 0; i < FocusLUT.size; i++) 767 if( FocusLUT.Table[i].omxDefinition == focus.eFocusControl ) 768 str = (char*)FocusLUT.Table[i].userDefinition; 769 770 params.set( CameraParameters::KEY_FOCUS_MODE , str ); 771 772 int comp = ((expValues.xEVCompensation * 10) >> Q16_OFFSET); 773 774 params.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, comp ); 775 params.set( TICameraParameters::KEY_MAN_EXPOSURE, expValues.nShutterSpeedMsec); 776 params.set( TICameraParameters::KEY_BRIGHTNESS, brightness.nBrightness); 777 params.set( TICameraParameters::KEY_CONTRAST, contrast.nContrast ); 778 params.set( TICameraParameters::KEY_SHARPNESS, procSharpness.nLevel); 779 params.set( TICameraParameters::KEY_SATURATION, saturation.nSaturation); 780 781#else 782 783 //Query focus distances only during CAF, Infinity 784 //or when focus is running 785 if ( ( AF_ACTIVE & state ) || 786 ( mParameters3A.Focus == OMX_IMAGE_FocusControlAuto ) || 787 ( mParameters3A.Focus == OMX_IMAGE_FocusControlAutoInfinity ) || 788 ( NULL == mParameters.get(CameraParameters::KEY_FOCUS_DISTANCES) ) ) 789 { 790 updateFocusDistances(params); 791 } 792 else 793 { 794 params.set(CameraParameters::KEY_FOCUS_DISTANCES, 795 mParameters.get(CameraParameters::KEY_FOCUS_DISTANCES)); 796 } 797 798 OMX_INIT_STRUCT_PTR (&exp, OMX_CONFIG_EXPOSUREVALUETYPE); 799 exp.nPortIndex = OMX_ALL; 800 801 eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp, 802 OMX_IndexConfigCommonExposureValue, 803 &exp); 804 if ( OMX_ErrorNone == eError ) 805 { 806 params.set(TICameraParameters::KEY_CURRENT_ISO, exp.nSensitivity); 807 } 808 else 809 { 810 CAMHAL_LOGEB("OMX error 0x%x, while retrieving current ISO value", eError); 811 } 812 813 { 814 Mutex::Autolock lock(mZoomLock); 815 //Immediate zoom should not be avaialable while smooth zoom is running 816 if ( ZOOM_ACTIVE & state ) 817 { 818 if ( mZoomParameterIdx != mCurrentZoomIdx ) 819 { 820 mZoomParameterIdx += mZoomInc; 821 } 822 params.set( CameraParameters::KEY_ZOOM, mZoomParameterIdx); 823 if ( ( mCurrentZoomIdx == mTargetZoomIdx ) && 824 ( mZoomParameterIdx == mCurrentZoomIdx ) ) 825 { 826 827 if ( NO_ERROR == ret ) 828 { 829 830 ret = BaseCameraAdapter::setState(CAMERA_STOP_SMOOTH_ZOOM); 831 832 if ( NO_ERROR == ret ) 833 { 834 ret = BaseCameraAdapter::commitState(); 835 } 836 else 837 { 838 ret |= BaseCameraAdapter::rollbackState(); 839 } 840 841 } 842 843 } 844 845 CAMHAL_LOGDB("CameraParameters Zoom = %d", mCurrentZoomIdx); 846 } 847 else 848 { 849 params.set( CameraParameters::KEY_ZOOM, mCurrentZoomIdx); 850 } 851 } 852 853 //Populate current lock status 854 if( (valstr = mParams.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK)) != NULL ) 855 { 856 CAMHAL_LOGDB("Auto Exposure Lock get %s", mParams.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK)); 857 params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, valstr); 858 } 859 860 if( (valstr = mParams.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK)) != NULL ) 861 { 862 CAMHAL_LOGDB("Auto WhiteBalance Lock get %s", mParams.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK)); 863 params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, valstr); 864 } 865 866#endif 867 868 LOG_FUNCTION_NAME_EXIT; 869} 870 871status_t OMXCameraAdapter::setFormat(OMX_U32 port, OMXCameraPortParameters &portParams) 872{ 873 size_t bufferCount; 874 875 LOG_FUNCTION_NAME; 876 877 OMX_ERRORTYPE eError = OMX_ErrorNone; 878 OMX_PARAM_PORTDEFINITIONTYPE portCheck; 879 880 OMX_INIT_STRUCT_PTR (&portCheck, OMX_PARAM_PORTDEFINITIONTYPE); 881 882 portCheck.nPortIndex = port; 883 884 eError = OMX_GetParameter (mCameraAdapterParameters.mHandleComp, 885 OMX_IndexParamPortDefinition, &portCheck); 886 if(eError!=OMX_ErrorNone) 887 { 888 CAMHAL_LOGEB("OMX_GetParameter - %x", eError); 889 } 890 GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); 891 892 if ( OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW == port ) 893 { 894 portCheck.format.video.nFrameWidth = portParams.mWidth; 895 portCheck.format.video.nFrameHeight = portParams.mHeight; 896 portCheck.format.video.eColorFormat = portParams.mColorFormat; 897 portCheck.format.video.nStride = portParams.mStride; 898 if( ( portCheck.format.video.nFrameWidth >= 1920 ) && 899 ( portCheck.format.video.nFrameHeight >= 1080 ) && 900 ( portParams.mFrameRate >= FRAME_RATE_FULL_HD ) ) 901 { 902 setSensorOverclock(true); 903 } 904 else 905 { 906 setSensorOverclock(false); 907 } 908 909 portCheck.format.video.xFramerate = portParams.mFrameRate<<16; 910 portCheck.nBufferSize = portParams.mStride * portParams.mHeight; 911 portCheck.nBufferCountActual = portParams.mNumBufs; 912 mFocusThreshold = FOCUS_THRESHOLD * portParams.mFrameRate; 913 } 914 else if ( OMX_CAMERA_PORT_IMAGE_OUT_IMAGE == port ) 915 { 916 portCheck.format.image.nFrameWidth = portParams.mWidth; 917 portCheck.format.image.nFrameHeight = portParams.mHeight; 918 if ( OMX_COLOR_FormatUnused == portParams.mColorFormat && mCodingMode == CodingNone ) 919 { 920 portCheck.format.image.eColorFormat = OMX_COLOR_FormatCbYCrY; 921 portCheck.format.image.eCompressionFormat = OMX_IMAGE_CodingJPEG; 922 } 923 else if ( OMX_COLOR_FormatUnused == portParams.mColorFormat && mCodingMode == CodingJPS ) 924 { 925 portCheck.format.image.eColorFormat = OMX_COLOR_FormatCbYCrY; 926 portCheck.format.image.eCompressionFormat = (OMX_IMAGE_CODINGTYPE) OMX_TI_IMAGE_CodingJPS; 927 } 928 else if ( OMX_COLOR_FormatUnused == portParams.mColorFormat && mCodingMode == CodingMPO ) 929 { 930 portCheck.format.image.eColorFormat = OMX_COLOR_FormatCbYCrY; 931 portCheck.format.image.eCompressionFormat = (OMX_IMAGE_CODINGTYPE) OMX_TI_IMAGE_CodingMPO; 932 } 933 else if ( OMX_COLOR_FormatUnused == portParams.mColorFormat && mCodingMode == CodingRAWJPEG ) 934 { 935 //TODO: OMX_IMAGE_CodingJPEG should be changed to OMX_IMAGE_CodingRAWJPEG when 936 // RAW format is supported 937 portCheck.format.image.eColorFormat = OMX_COLOR_FormatCbYCrY; 938 portCheck.format.image.eCompressionFormat = OMX_IMAGE_CodingJPEG; 939 } 940 else if ( OMX_COLOR_FormatUnused == portParams.mColorFormat && mCodingMode == CodingRAWMPO ) 941 { 942 //TODO: OMX_IMAGE_CodingJPEG should be changed to OMX_IMAGE_CodingRAWMPO when 943 // RAW format is supported 944 portCheck.format.image.eColorFormat = OMX_COLOR_FormatCbYCrY; 945 portCheck.format.image.eCompressionFormat = OMX_IMAGE_CodingJPEG; 946 } 947 else 948 { 949 portCheck.format.image.eColorFormat = portParams.mColorFormat; 950 portCheck.format.image.eCompressionFormat = OMX_IMAGE_CodingUnused; 951 } 952 953 //Stride for 1D tiler buffer is zero 954 portCheck.format.image.nStride = 0; 955 portCheck.nBufferSize = portParams.mStride * portParams.mWidth * portParams.mHeight; 956 portCheck.nBufferCountActual = portParams.mNumBufs; 957 } 958 else 959 { 960 CAMHAL_LOGEB("Unsupported port index 0x%x", (unsigned int)port); 961 } 962 963 eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp, 964 OMX_IndexParamPortDefinition, &portCheck); 965 if(eError!=OMX_ErrorNone) 966 { 967 CAMHAL_LOGEB("OMX_SetParameter - %x", eError); 968 } 969 GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); 970 971 /* check if parameters are set correctly by calling GetParameter() */ 972 eError = OMX_GetParameter(mCameraAdapterParameters.mHandleComp, 973 OMX_IndexParamPortDefinition, &portCheck); 974 if(eError!=OMX_ErrorNone) 975 { 976 CAMHAL_LOGEB("OMX_GetParameter - %x", eError); 977 } 978 GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); 979 980 portParams.mBufSize = portCheck.nBufferSize; 981 982 if ( OMX_CAMERA_PORT_IMAGE_OUT_IMAGE == port ) 983 { 984 CAMHAL_LOGDB("\n *** IMG Width = %ld", portCheck.format.image.nFrameWidth); 985 CAMHAL_LOGDB("\n ***IMG Height = %ld", portCheck.format.image.nFrameHeight); 986 987 CAMHAL_LOGDB("\n ***IMG IMG FMT = %x", portCheck.format.image.eColorFormat); 988 CAMHAL_LOGDB("\n ***IMG portCheck.nBufferSize = %ld\n",portCheck.nBufferSize); 989 CAMHAL_LOGDB("\n ***IMG portCheck.nBufferCountMin = %ld\n", 990 portCheck.nBufferCountMin); 991 CAMHAL_LOGDB("\n ***IMG portCheck.nBufferCountActual = %ld\n", 992 portCheck.nBufferCountActual); 993 CAMHAL_LOGDB("\n ***IMG portCheck.format.image.nStride = %ld\n", 994 portCheck.format.image.nStride); 995 } 996 else 997 { 998 CAMHAL_LOGDB("\n *** PRV Width = %ld", portCheck.format.video.nFrameWidth); 999 CAMHAL_LOGDB("\n ***PRV Height = %ld", portCheck.format.video.nFrameHeight); 1000 1001 CAMHAL_LOGDB("\n ***PRV IMG FMT = %x", portCheck.format.video.eColorFormat); 1002 CAMHAL_LOGDB("\n ***PRV portCheck.nBufferSize = %ld\n",portCheck.nBufferSize); 1003 CAMHAL_LOGDB("\n ***PRV portCheck.nBufferCountMin = %ld\n", 1004 portCheck.nBufferCountMin); 1005 CAMHAL_LOGDB("\n ***PRV portCheck.nBufferCountActual = %ld\n", 1006 portCheck.nBufferCountActual); 1007 CAMHAL_LOGDB("\n ***PRV portCheck.format.video.nStride = %ld\n", 1008 portCheck.format.video.nStride); 1009 } 1010 1011 LOG_FUNCTION_NAME_EXIT; 1012 1013 return ErrorUtils::omxToAndroidError(eError); 1014 1015 EXIT: 1016 1017 CAMHAL_LOGEB("Exiting function %s because of eError=%x", __FUNCTION__, eError); 1018 1019 LOG_FUNCTION_NAME_EXIT; 1020 1021 return ErrorUtils::omxToAndroidError(eError); 1022} 1023 1024status_t OMXCameraAdapter::flushBuffers() 1025{ 1026 status_t ret = NO_ERROR; 1027 OMX_ERRORTYPE eError = OMX_ErrorNone; 1028 TIMM_OSAL_ERRORTYPE err; 1029 TIMM_OSAL_U32 uRequestedEvents = OMXCameraAdapter::CAMERA_PORT_FLUSH; 1030 TIMM_OSAL_U32 pRetrievedEvents; 1031 1032 if ( 0 != mFlushSem.Count() ) 1033 { 1034 CAMHAL_LOGEB("Error mFlushSem semaphore count %d", mFlushSem.Count()); 1035 LOG_FUNCTION_NAME_EXIT; 1036 return NO_INIT; 1037 } 1038 1039 LOG_FUNCTION_NAME; 1040 1041 OMXCameraPortParameters * mPreviewData = NULL; 1042 mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex]; 1043 1044 ///Register for the FLUSH event 1045 ///This method just inserts a message in Event Q, which is checked in the callback 1046 ///The sempahore passed is signalled by the callback 1047 ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp, 1048 OMX_EventCmdComplete, 1049 OMX_CommandFlush, 1050 OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW, 1051 mFlushSem); 1052 if(ret!=NO_ERROR) 1053 { 1054 CAMHAL_LOGEB("Error in registering for event %d", ret); 1055 goto EXIT; 1056 } 1057 1058 ///Send FLUSH command to preview port 1059 eError = OMX_SendCommand (mCameraAdapterParameters.mHandleComp, 1060 OMX_CommandFlush, 1061 mCameraAdapterParameters.mPrevPortIndex, 1062 NULL); 1063 1064 if(eError!=OMX_ErrorNone) 1065 { 1066 CAMHAL_LOGEB("OMX_SendCommand(OMX_CommandFlush)-0x%x", eError); 1067 } 1068 GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); 1069 1070 CAMHAL_LOGDA("Waiting for flush event"); 1071 1072 ///Wait for the FLUSH event to occur 1073 ret = mFlushSem.WaitTimeout(OMX_CMD_TIMEOUT); 1074 if ( NO_ERROR == ret ) 1075 { 1076 CAMHAL_LOGDA("Flush event received"); 1077 } 1078 else 1079 { 1080 ret |= SignalEvent(mCameraAdapterParameters.mHandleComp, 1081 OMX_EventCmdComplete, 1082 OMX_CommandFlush, 1083 OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW, 1084 NULL); 1085 CAMHAL_LOGDA("Flush event timeout expired"); 1086 goto EXIT; 1087 } 1088 1089 LOG_FUNCTION_NAME_EXIT; 1090 1091 return (ret | ErrorUtils::omxToAndroidError(eError)); 1092 1093 EXIT: 1094 CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, ret, eError); 1095 LOG_FUNCTION_NAME_EXIT; 1096 1097 return (ret | ErrorUtils::omxToAndroidError(eError)); 1098} 1099 1100///API to give the buffers to Adapter 1101status_t OMXCameraAdapter::useBuffers(CameraMode mode, void* bufArr, int num, size_t length, unsigned int queueable) 1102{ 1103 OMX_ERRORTYPE eError = OMX_ErrorNone; 1104 status_t ret = NO_ERROR; 1105 1106 LOG_FUNCTION_NAME; 1107 1108 switch(mode) 1109 { 1110 case CAMERA_PREVIEW: 1111 mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex].mNumBufs = num; 1112 mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex].mMaxQueueable = queueable; 1113 ret = UseBuffersPreview(bufArr, num); 1114 break; 1115 1116 case CAMERA_IMAGE_CAPTURE: 1117 mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex].mNumBufs = num; 1118 mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex].mMaxQueueable = queueable; 1119 ret = UseBuffersCapture(bufArr, num); 1120 break; 1121 1122 case CAMERA_VIDEO: 1123 mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex].mNumBufs = num; 1124 mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex].mMaxQueueable = queueable; 1125 ret = UseBuffersPreview(bufArr, num); 1126 break; 1127 1128 case CAMERA_MEASUREMENT: 1129 mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex].mNumBufs = num; 1130 mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex].mMaxQueueable = queueable; 1131 ret = UseBuffersPreviewData(bufArr, num); 1132 break; 1133 1134 } 1135 1136 LOG_FUNCTION_NAME_EXIT; 1137 1138 return ret; 1139} 1140 1141status_t OMXCameraAdapter::UseBuffersPreviewData(void* bufArr, int num) 1142{ 1143 status_t ret = NO_ERROR; 1144 OMX_ERRORTYPE eError = OMX_ErrorNone; 1145 OMXCameraPortParameters * measurementData = NULL; 1146 uint32_t *buffers; 1147 Mutex::Autolock lock( mPreviewDataBufferLock); 1148 1149 LOG_FUNCTION_NAME; 1150 1151 if ( mComponentState != OMX_StateLoaded ) 1152 { 1153 CAMHAL_LOGEA("Calling UseBuffersPreviewData() when not in LOADED state"); 1154 ret = BAD_VALUE; 1155 } 1156 1157 if ( NULL == bufArr ) 1158 { 1159 CAMHAL_LOGEA("NULL pointer passed for buffArr"); 1160 ret = BAD_VALUE; 1161 } 1162 1163 if ( 0 != mUsePreviewDataSem.Count() ) 1164 { 1165 CAMHAL_LOGEB("Error mUsePreviewDataSem semaphore count %d", mUsePreviewDataSem.Count()); 1166 LOG_FUNCTION_NAME_EXIT; 1167 return NO_INIT; 1168 } 1169 1170 if ( NO_ERROR == ret ) 1171 { 1172 measurementData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex]; 1173 measurementData->mNumBufs = num ; 1174 buffers= (uint32_t*) bufArr; 1175 } 1176 1177 if ( NO_ERROR == ret ) 1178 { 1179 ///Register for port enable event on measurement port 1180 ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp, 1181 OMX_EventCmdComplete, 1182 OMX_CommandPortEnable, 1183 mCameraAdapterParameters.mMeasurementPortIndex, 1184 mUsePreviewDataSem); 1185 1186 if ( ret == NO_ERROR ) 1187 { 1188 CAMHAL_LOGDB("Registering for event %d", ret); 1189 } 1190 else 1191 { 1192 CAMHAL_LOGEB("Error in registering for event %d", ret); 1193 ret = BAD_VALUE; 1194 } 1195 } 1196 1197 if ( NO_ERROR == ret ) 1198 { 1199 ///Enable MEASUREMENT Port 1200 eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp, 1201 OMX_CommandPortEnable, 1202 mCameraAdapterParameters.mMeasurementPortIndex, 1203 NULL); 1204 1205 if ( eError == OMX_ErrorNone ) 1206 { 1207 CAMHAL_LOGDB("OMX_SendCommand(OMX_CommandPortEnable) -0x%x", eError); 1208 } 1209 else 1210 { 1211 CAMHAL_LOGEB("OMX_SendCommand(OMX_CommandPortEnable) -0x%x", eError); 1212 ret = BAD_VALUE; 1213 } 1214 } 1215 1216 if ( NO_ERROR == ret ) 1217 { 1218 ret = mUsePreviewDataSem.WaitTimeout(OMX_CMD_TIMEOUT); 1219 1220 if ( NO_ERROR == ret ) 1221 { 1222 CAMHAL_LOGDA("Port enable event arrived on measurement port"); 1223 } 1224 else 1225 { 1226 ret |= SignalEvent(mCameraAdapterParameters.mHandleComp, 1227 OMX_EventCmdComplete, 1228 OMX_CommandPortEnable, 1229 mCameraAdapterParameters.mMeasurementPortIndex, 1230 NULL); 1231 CAMHAL_LOGEA("Timeout expoired during port enable on measurement port"); 1232 } 1233 1234 CAMHAL_LOGDA("Port enable event arrived on measurement port"); 1235 } 1236 1237 LOG_FUNCTION_NAME_EXIT; 1238 1239 return ret; 1240} 1241 1242status_t OMXCameraAdapter::switchToLoaded() 1243{ 1244 status_t ret = NO_ERROR; 1245 OMX_ERRORTYPE eError = OMX_ErrorNone; 1246 1247 LOG_FUNCTION_NAME; 1248 1249 if ( mComponentState == OMX_StateLoaded ) 1250 { 1251 CAMHAL_LOGDA("Already in OMX_Loaded state"); 1252 goto EXIT; 1253 } 1254 1255 if ( 0 != mSwitchToLoadedSem.Count() ) 1256 { 1257 CAMHAL_LOGEB("Error mSwitchToLoadedSem semaphore count %d", mSwitchToLoadedSem.Count()); 1258 goto EXIT; 1259 } 1260 1261 ///Register for EXECUTING state transition. 1262 ///This method just inserts a message in Event Q, which is checked in the callback 1263 ///The sempahore passed is signalled by the callback 1264 ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp, 1265 OMX_EventCmdComplete, 1266 OMX_CommandStateSet, 1267 OMX_StateIdle, 1268 mSwitchToLoadedSem); 1269 1270 if(ret!=NO_ERROR) 1271 { 1272 CAMHAL_LOGEB("Error in registering for event %d", ret); 1273 goto EXIT; 1274 } 1275 1276 eError = OMX_SendCommand (mCameraAdapterParameters.mHandleComp, 1277 OMX_CommandStateSet, 1278 OMX_StateIdle, 1279 NULL); 1280 1281 if(eError!=OMX_ErrorNone) 1282 { 1283 CAMHAL_LOGEB("OMX_SendCommand(OMX_StateIdle) - %x", eError); 1284 } 1285 1286 GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); 1287 1288 ///Wait for the EXECUTING ->IDLE transition to arrive 1289 1290 CAMHAL_LOGDA("EXECUTING->IDLE state changed"); 1291 ret = mSwitchToLoadedSem.WaitTimeout(OMX_CMD_TIMEOUT); 1292 if ( NO_ERROR == ret ) 1293 { 1294 CAMHAL_LOGDA("EXECUTING->IDLE state changed"); 1295 } 1296 else 1297 { 1298 ret |= SignalEvent(mCameraAdapterParameters.mHandleComp, 1299 OMX_EventCmdComplete, 1300 OMX_CommandStateSet, 1301 OMX_StateIdle, 1302 NULL); 1303 CAMHAL_LOGEA("Timeout expired on EXECUTING->IDLE state change"); 1304 goto EXIT; 1305 } 1306 1307 ///Register for LOADED state transition. 1308 ///This method just inserts a message in Event Q, which is checked in the callback 1309 ///The sempahore passed is signalled by the callback 1310 ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp, 1311 OMX_EventCmdComplete, 1312 OMX_CommandStateSet, 1313 OMX_StateLoaded, 1314 mSwitchToLoadedSem); 1315 1316 if(ret!=NO_ERROR) 1317 { 1318 CAMHAL_LOGEB("Error in registering for event %d", ret); 1319 goto EXIT; 1320 } 1321 1322 eError = OMX_SendCommand (mCameraAdapterParameters.mHandleComp, 1323 OMX_CommandStateSet, 1324 OMX_StateLoaded, 1325 NULL); 1326 1327 if(eError!=OMX_ErrorNone) 1328 { 1329 CAMHAL_LOGEB("OMX_SendCommand(OMX_StateLoaded) - %x", eError); 1330 } 1331 GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); 1332 1333 CAMHAL_LOGDA("Switching IDLE->LOADED state"); 1334 ret = mSwitchToLoadedSem.WaitTimeout(OMX_CMD_TIMEOUT); 1335 if ( NO_ERROR == ret ) 1336 { 1337 CAMHAL_LOGDA("IDLE->LOADED state changed"); 1338 } 1339 else 1340 { 1341 ret |= SignalEvent(mCameraAdapterParameters.mHandleComp, 1342 OMX_EventCmdComplete, 1343 OMX_CommandStateSet, 1344 OMX_StateLoaded, 1345 NULL); 1346 CAMHAL_LOGEA("Timeout expired on IDLE->LOADED state change"); 1347 goto EXIT; 1348 } 1349 1350 mComponentState = OMX_StateLoaded; 1351 1352 ///Register for Preview port ENABLE event 1353 ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp, 1354 OMX_EventCmdComplete, 1355 OMX_CommandPortEnable, 1356 mCameraAdapterParameters.mPrevPortIndex, 1357 mSwitchToLoadedSem); 1358 1359 if ( NO_ERROR != ret ) 1360 { 1361 CAMHAL_LOGEB("Error in registering for event %d", ret); 1362 goto EXIT; 1363 } 1364 1365 ///Enable Preview Port 1366 eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp, 1367 OMX_CommandPortEnable, 1368 mCameraAdapterParameters.mPrevPortIndex, 1369 NULL); 1370 1371 CAMHAL_LOGDB("OMX_SendCommand(OMX_CommandStateSet) 0x%x", eError); 1372 1373 GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); 1374 1375 CAMHAL_LOGDA("Enabling Preview port"); 1376 ///Wait for state to switch to idle 1377 ret = mSwitchToLoadedSem.WaitTimeout(OMX_CMD_TIMEOUT); 1378 if ( NO_ERROR == ret ) 1379 { 1380 CAMHAL_LOGDA("Preview port enabled!"); 1381 } 1382 else 1383 { 1384 ret |= SignalEvent(mCameraAdapterParameters.mHandleComp, 1385 OMX_EventCmdComplete, 1386 OMX_CommandPortEnable, 1387 mCameraAdapterParameters.mPrevPortIndex, 1388 NULL); 1389 CAMHAL_LOGEA("Preview enable timedout"); 1390 goto EXIT; 1391 } 1392 1393 EXIT: 1394 1395 LOG_FUNCTION_NAME_EXIT; 1396 1397 return ret; 1398} 1399 1400status_t OMXCameraAdapter::UseBuffersPreview(void* bufArr, int num) 1401{ 1402 status_t ret = NO_ERROR; 1403 OMX_ERRORTYPE eError = OMX_ErrorNone; 1404 int tmpHeight, tmpWidth; 1405 1406 LOG_FUNCTION_NAME; 1407 1408 ///Flag to determine whether it is 3D camera or not 1409 bool isS3d = false; 1410 const char *valstr = NULL; 1411 if ( (valstr = mParams.get(TICameraParameters::KEY_S3D_SUPPORTED)) != NULL) { 1412 isS3d = (strcmp(valstr, "true") == 0); 1413 } 1414 1415 if(!bufArr) 1416 { 1417 CAMHAL_LOGEA("NULL pointer passed for buffArr"); 1418 LOG_FUNCTION_NAME_EXIT; 1419 return BAD_VALUE; 1420 } 1421 1422 OMXCameraPortParameters * mPreviewData = NULL; 1423 OMXCameraPortParameters *measurementData = NULL; 1424 mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex]; 1425 measurementData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex]; 1426 mPreviewData->mNumBufs = num ; 1427 uint32_t *buffers = (uint32_t*)bufArr; 1428 1429 if ( 0 != mUsePreviewSem.Count() ) 1430 { 1431 CAMHAL_LOGEB("Error mUsePreviewSem semaphore count %d", mUsePreviewSem.Count()); 1432 LOG_FUNCTION_NAME_EXIT; 1433 return NO_INIT; 1434 } 1435 1436 if(mPreviewData->mNumBufs != num) 1437 { 1438 CAMHAL_LOGEA("Current number of buffers doesnt equal new num of buffers passed!"); 1439 LOG_FUNCTION_NAME_EXIT; 1440 return BAD_VALUE; 1441 } 1442 1443 if ( mComponentState == OMX_StateLoaded ) 1444 { 1445 1446 ret = setLDC(mIPP); 1447 if ( NO_ERROR != ret ) 1448 { 1449 CAMHAL_LOGEB("setLDC() failed %d", ret); 1450 LOG_FUNCTION_NAME_EXIT; 1451 return ret; 1452 } 1453 1454 ret = setNSF(mIPP); 1455 if ( NO_ERROR != ret ) 1456 { 1457 CAMHAL_LOGEB("setNSF() failed %d", ret); 1458 LOG_FUNCTION_NAME_EXIT; 1459 return ret; 1460 } 1461 1462 ret = setCaptureMode(mCapMode); 1463 if ( NO_ERROR != ret ) 1464 { 1465 CAMHAL_LOGEB("setCaptureMode() failed %d", ret); 1466 LOG_FUNCTION_NAME_EXIT; 1467 return ret; 1468 } 1469 1470 CAMHAL_LOGDB("Camera Mode = %d", mCapMode); 1471 1472 if( ( mCapMode == OMXCameraAdapter::VIDEO_MODE ) || 1473 ( isS3d && (mCapMode == OMXCameraAdapter::HIGH_QUALITY)) ) 1474 { 1475 ///Enable/Disable Video Noise Filter 1476 ret = enableVideoNoiseFilter(mVnfEnabled); 1477 if ( NO_ERROR != ret) 1478 { 1479 CAMHAL_LOGEB("Error configuring VNF %x", ret); 1480 return ret; 1481 } 1482 1483 ///Enable/Disable Video Stabilization 1484 ret = enableVideoStabilization(mVstabEnabled); 1485 if ( NO_ERROR != ret) 1486 { 1487 CAMHAL_LOGEB("Error configuring VSTAB %x", ret); 1488 return ret; 1489 } 1490 } 1491 else 1492 { 1493 ret = enableVideoNoiseFilter(false); 1494 if ( NO_ERROR != ret) 1495 { 1496 CAMHAL_LOGEB("Error configuring VNF %x", ret); 1497 return ret; 1498 } 1499 ///Enable/Disable Video Stabilization 1500 ret = enableVideoStabilization(false); 1501 if ( NO_ERROR != ret) 1502 { 1503 CAMHAL_LOGEB("Error configuring VSTAB %x", ret); 1504 return ret; 1505 } 1506 } 1507 } 1508 1509 ret = setSensorOrientation(mSensorOrientation); 1510 if ( NO_ERROR != ret ) 1511 { 1512 CAMHAL_LOGEB("Error configuring Sensor Orientation %x", ret); 1513 mSensorOrientation = 0; 1514 } 1515 1516 ret = setVFramerate(mPreviewData->mMinFrameRate, mPreviewData->mMaxFrameRate); 1517 if ( ret != NO_ERROR ) 1518 { 1519 CAMHAL_LOGEB("VFR configuration failed 0x%x", ret); 1520 LOG_FUNCTION_NAME_EXIT; 1521 return ret; 1522 } 1523 1524 if ( mComponentState == OMX_StateLoaded ) 1525 { 1526 ///Register for IDLE state switch event 1527 ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp, 1528 OMX_EventCmdComplete, 1529 OMX_CommandStateSet, 1530 OMX_StateIdle, 1531 mUsePreviewSem); 1532 1533 if(ret!=NO_ERROR) 1534 { 1535 CAMHAL_LOGEB("Error in registering for event %d", ret); 1536 goto EXIT; 1537 } 1538 1539 ///Once we get the buffers, move component state to idle state and pass the buffers to OMX comp using UseBuffer 1540 eError = OMX_SendCommand (mCameraAdapterParameters.mHandleComp , 1541 OMX_CommandStateSet, 1542 OMX_StateIdle, 1543 NULL); 1544 1545 CAMHAL_LOGDB("OMX_SendCommand(OMX_CommandStateSet) 0x%x", eError); 1546 1547 GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); 1548 1549 mComponentState = OMX_StateIdle; 1550 } 1551 else 1552 { 1553 ///Register for Preview port ENABLE event 1554 ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp, 1555 OMX_EventCmdComplete, 1556 OMX_CommandPortEnable, 1557 mCameraAdapterParameters.mPrevPortIndex, 1558 mUsePreviewSem); 1559 1560 if ( NO_ERROR != ret ) 1561 { 1562 CAMHAL_LOGEB("Error in registering for event %d", ret); 1563 goto EXIT; 1564 } 1565 1566 ///Enable Preview Port 1567 eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp, 1568 OMX_CommandPortEnable, 1569 mCameraAdapterParameters.mPrevPortIndex, 1570 NULL); 1571 } 1572 1573 1574 ///Configure DOMX to use either gralloc handles or vptrs 1575 OMX_TI_PARAMUSENATIVEBUFFER domxUseGrallocHandles; 1576 OMX_INIT_STRUCT_PTR (&domxUseGrallocHandles, OMX_TI_PARAMUSENATIVEBUFFER); 1577 1578 domxUseGrallocHandles.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; 1579 domxUseGrallocHandles.bEnable = OMX_TRUE; 1580 1581 eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp, 1582 (OMX_INDEXTYPE)OMX_TI_IndexUseNativeBuffers, &domxUseGrallocHandles); 1583 if(eError!=OMX_ErrorNone) 1584 { 1585 CAMHAL_LOGEB("OMX_SetParameter - %x", eError); 1586 } 1587 GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); 1588 1589 OMX_BUFFERHEADERTYPE *pBufferHdr; 1590 for(int index=0;index<num;index++) { 1591 1592 CAMHAL_LOGDB("OMX_UseBuffer(0x%x)", buffers[index]); 1593 eError = OMX_UseBuffer( mCameraAdapterParameters.mHandleComp, 1594 &pBufferHdr, 1595 mCameraAdapterParameters.mPrevPortIndex, 1596 0, 1597 mPreviewData->mBufSize, 1598 (OMX_U8*)buffers[index]); 1599 if(eError!=OMX_ErrorNone) 1600 { 1601 CAMHAL_LOGEB("OMX_UseBuffer-0x%x", eError); 1602 } 1603 GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); 1604 1605 //pBufferHdr->pAppPrivate = (OMX_PTR)pBufferHdr; 1606 pBufferHdr->nSize = sizeof(OMX_BUFFERHEADERTYPE); 1607 pBufferHdr->nVersion.s.nVersionMajor = 1 ; 1608 pBufferHdr->nVersion.s.nVersionMinor = 1 ; 1609 pBufferHdr->nVersion.s.nRevision = 0 ; 1610 pBufferHdr->nVersion.s.nStep = 0; 1611 mPreviewData->mBufferHeader[index] = pBufferHdr; 1612 } 1613 1614 if ( mMeasurementEnabled ) 1615 { 1616 1617 for( int i = 0; i < num; i++ ) 1618 { 1619 OMX_BUFFERHEADERTYPE *pBufHdr; 1620 eError = OMX_UseBuffer( mCameraAdapterParameters.mHandleComp, 1621 &pBufHdr, 1622 mCameraAdapterParameters.mMeasurementPortIndex, 1623 0, 1624 measurementData->mBufSize, 1625 (OMX_U8*)(mPreviewDataBuffers[i])); 1626 1627 if ( eError == OMX_ErrorNone ) 1628 { 1629 pBufHdr->nSize = sizeof(OMX_BUFFERHEADERTYPE); 1630 pBufHdr->nVersion.s.nVersionMajor = 1 ; 1631 pBufHdr->nVersion.s.nVersionMinor = 1 ; 1632 pBufHdr->nVersion.s.nRevision = 0 ; 1633 pBufHdr->nVersion.s.nStep = 0; 1634 measurementData->mBufferHeader[i] = pBufHdr; 1635 } 1636 else 1637 { 1638 CAMHAL_LOGEB("OMX_UseBuffer -0x%x", eError); 1639 ret = BAD_VALUE; 1640 break; 1641 } 1642 } 1643 1644 } 1645 1646 CAMHAL_LOGDA("Registering preview buffers"); 1647 1648 ret = mUsePreviewSem.WaitTimeout(OMX_CMD_TIMEOUT); 1649 if ( NO_ERROR == ret ) 1650 { 1651 CAMHAL_LOGDA("Preview buffer registration successfull"); 1652 } 1653 else 1654 { 1655 if ( mComponentState == OMX_StateLoaded ) 1656 { 1657 ret |= SignalEvent(mCameraAdapterParameters.mHandleComp, 1658 OMX_EventCmdComplete, 1659 OMX_CommandStateSet, 1660 OMX_StateIdle, 1661 NULL); 1662 } 1663 else 1664 { 1665 ret |= SignalEvent(mCameraAdapterParameters.mHandleComp, 1666 OMX_EventCmdComplete, 1667 OMX_CommandPortEnable, 1668 mCameraAdapterParameters.mPrevPortIndex, 1669 NULL); 1670 } 1671 CAMHAL_LOGEA("Timeout expired on preview buffer registration"); 1672 goto EXIT; 1673 } 1674 1675 LOG_FUNCTION_NAME_EXIT; 1676 1677 return (ret | ErrorUtils::omxToAndroidError(eError)); 1678 1679 ///If there is any failure, we reach here. 1680 ///Here, we do any resource freeing and convert from OMX error code to Camera Hal error code 1681 EXIT: 1682 1683 CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, ret, eError); 1684 1685 LOG_FUNCTION_NAME_EXIT; 1686 1687 return (ret | ErrorUtils::omxToAndroidError(eError)); 1688} 1689 1690status_t OMXCameraAdapter::startPreview() 1691{ 1692 status_t ret = NO_ERROR; 1693 OMX_ERRORTYPE eError = OMX_ErrorNone; 1694 OMXCameraPortParameters *mPreviewData = NULL; 1695 OMXCameraPortParameters *measurementData = NULL; 1696 1697 LOG_FUNCTION_NAME; 1698 1699 if( 0 != mStartPreviewSem.Count() ) 1700 { 1701 CAMHAL_LOGEB("Error mStartPreviewSem semaphore count %d", mStartPreviewSem.Count()); 1702 LOG_FUNCTION_NAME_EXIT; 1703 return NO_INIT; 1704 } 1705 1706 mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex]; 1707 measurementData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex]; 1708 1709 if( OMX_StateIdle == mComponentState ) 1710 { 1711 ///Register for EXECUTING state transition. 1712 ///This method just inserts a message in Event Q, which is checked in the callback 1713 ///The sempahore passed is signalled by the callback 1714 ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp, 1715 OMX_EventCmdComplete, 1716 OMX_CommandStateSet, 1717 OMX_StateExecuting, 1718 mStartPreviewSem); 1719 1720 if(ret!=NO_ERROR) 1721 { 1722 CAMHAL_LOGEB("Error in registering for event %d", ret); 1723 goto EXIT; 1724 } 1725 1726 ///Switch to EXECUTING state 1727 eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp, 1728 OMX_CommandStateSet, 1729 OMX_StateExecuting, 1730 NULL); 1731 1732 if(eError!=OMX_ErrorNone) 1733 { 1734 CAMHAL_LOGEB("OMX_SendCommand(OMX_StateExecuting)-0x%x", eError); 1735 } 1736 1737 CAMHAL_LOGDA("+Waiting for component to go into EXECUTING state"); 1738 ret = mStartPreviewSem.WaitTimeout(OMX_CMD_TIMEOUT); 1739 if ( NO_ERROR == ret ) 1740 { 1741 CAMHAL_LOGDA("+Great. Component went into executing state!!"); 1742 } 1743 else 1744 { 1745 ret |= SignalEvent(mCameraAdapterParameters.mHandleComp, 1746 OMX_EventCmdComplete, 1747 OMX_CommandStateSet, 1748 OMX_StateExecuting, 1749 NULL); 1750 CAMHAL_LOGDA("Timeout expired on executing state switch!"); 1751 goto EXIT; 1752 } 1753 1754 mComponentState = OMX_StateExecuting; 1755 1756 } 1757 1758 //Queue all the buffers on preview port 1759 for(int index=0;index< mPreviewData->mMaxQueueable;index++) 1760 { 1761 CAMHAL_LOGDB("Queuing buffer on Preview port - 0x%x", (uint32_t)mPreviewData->mBufferHeader[index]->pBuffer); 1762 eError = OMX_FillThisBuffer(mCameraAdapterParameters.mHandleComp, 1763 (OMX_BUFFERHEADERTYPE*)mPreviewData->mBufferHeader[index]); 1764 if(eError!=OMX_ErrorNone) 1765 { 1766 CAMHAL_LOGEB("OMX_FillThisBuffer-0x%x", eError); 1767 } 1768 GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); 1769 } 1770 1771 if ( mMeasurementEnabled ) 1772 { 1773 1774 for(int index=0;index< mPreviewData->mNumBufs;index++) 1775 { 1776 CAMHAL_LOGDB("Queuing buffer on Measurement port - 0x%x", (uint32_t) measurementData->mBufferHeader[index]->pBuffer); 1777 eError = OMX_FillThisBuffer(mCameraAdapterParameters.mHandleComp, 1778 (OMX_BUFFERHEADERTYPE*) measurementData->mBufferHeader[index]); 1779 if(eError!=OMX_ErrorNone) 1780 { 1781 CAMHAL_LOGEB("OMX_FillThisBuffer-0x%x", eError); 1782 } 1783 GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); 1784 } 1785 1786 } 1787 1788 if ( mPending3Asettings ) 1789 apply3Asettings(mParameters3A); 1790 1791 //Query current focus distance after 1792 //starting the preview 1793 updateFocusDistances(mParameters); 1794 1795 //reset frame rate estimates 1796 mFPS = 0.0f; 1797 mLastFPS = 0.0f; 1798 mFrameCount = 0; 1799 mLastFrameCount = 0; 1800 mIter = 1; 1801 mLastFPSTime = systemTime(); 1802 1803 LOG_FUNCTION_NAME_EXIT; 1804 1805 return ret; 1806 1807 EXIT: 1808 1809 CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, ret, eError); 1810 1811 LOG_FUNCTION_NAME_EXIT; 1812 1813 return (ret | ErrorUtils::omxToAndroidError(eError)); 1814 1815} 1816 1817status_t OMXCameraAdapter::stopPreview() 1818{ 1819 LOG_FUNCTION_NAME; 1820 1821 OMX_ERRORTYPE eError = OMX_ErrorNone; 1822 status_t ret = NO_ERROR; 1823 1824 OMXCameraPortParameters *mCaptureData , *mPreviewData, *measurementData; 1825 mCaptureData = mPreviewData = measurementData = NULL; 1826 1827 mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex]; 1828 mCaptureData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex]; 1829 measurementData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex]; 1830 1831 if ( mComponentState != OMX_StateExecuting ) 1832 { 1833 CAMHAL_LOGEA("Calling StopPreview() when not in EXECUTING state"); 1834 LOG_FUNCTION_NAME_EXIT; 1835 return NO_INIT; 1836 } 1837 1838 ret = cancelAutoFocus(); 1839 if(ret!=NO_ERROR) 1840 { 1841 CAMHAL_LOGEB("Error canceling autofocus %d", ret); 1842 // Error, but we probably still want to continue to stop preview 1843 } 1844 1845 //Release 3A locks 1846 ret = set3ALock(OMX_FALSE); 1847 if(ret!=NO_ERROR) 1848 { 1849 CAMHAL_LOGEB("Error Releaseing 3A locks%d", ret); 1850 } 1851 1852 if ( 0 != mStopPreviewSem.Count() ) 1853 { 1854 CAMHAL_LOGEB("Error mStopPreviewSem semaphore count %d", mStopPreviewSem.Count()); 1855 LOG_FUNCTION_NAME_EXIT; 1856 return NO_INIT; 1857 } 1858 1859 CAMHAL_LOGDB("Average framerate: %f", mFPS); 1860 1861 //Avoid state switching of the OMX Component 1862 ret = flushBuffers(); 1863 if ( NO_ERROR != ret ) 1864 { 1865 CAMHAL_LOGEB("Flush Buffers failed 0x%x", ret); 1866 goto EXIT; 1867 } 1868 1869 ///Register for Preview port Disable event 1870 ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp, 1871 OMX_EventCmdComplete, 1872 OMX_CommandPortDisable, 1873 mCameraAdapterParameters.mPrevPortIndex, 1874 mStopPreviewSem); 1875 1876 ///Disable Preview Port 1877 eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp, 1878 OMX_CommandPortDisable, 1879 mCameraAdapterParameters.mPrevPortIndex, 1880 NULL); 1881 1882 ///Free the OMX Buffers 1883 for ( int i = 0 ; i < mPreviewData->mNumBufs ; i++ ) 1884 { 1885 eError = OMX_FreeBuffer(mCameraAdapterParameters.mHandleComp, 1886 mCameraAdapterParameters.mPrevPortIndex, 1887 mPreviewData->mBufferHeader[i]); 1888 1889 if(eError!=OMX_ErrorNone) 1890 { 1891 CAMHAL_LOGEB("OMX_FreeBuffer - %x", eError); 1892 } 1893 GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); 1894 } 1895 1896 if ( mMeasurementEnabled ) 1897 { 1898 1899 for ( int i = 0 ; i < measurementData->mNumBufs ; i++ ) 1900 { 1901 eError = OMX_FreeBuffer(mCameraAdapterParameters.mHandleComp, 1902 mCameraAdapterParameters.mMeasurementPortIndex, 1903 measurementData->mBufferHeader[i]); 1904 if(eError!=OMX_ErrorNone) 1905 { 1906 CAMHAL_LOGEB("OMX_FreeBuffer - %x", eError); 1907 } 1908 GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError); 1909 } 1910 1911 { 1912 Mutex::Autolock lock(mPreviewDataBufferLock); 1913 mPreviewDataBuffersAvailable.clear(); 1914 } 1915 1916 } 1917 1918 CAMHAL_LOGDA("Disabling preview port"); 1919 ret = mStopPreviewSem.WaitTimeout(OMX_CMD_TIMEOUT); 1920 if ( NO_ERROR == ret ) 1921 { 1922 CAMHAL_LOGDA("Preview port disabled"); 1923 } 1924 else 1925 { 1926 ret |= SignalEvent(mCameraAdapterParameters.mHandleComp, 1927 OMX_EventCmdComplete, 1928 OMX_CommandPortDisable, 1929 mCameraAdapterParameters.mPrevPortIndex, 1930 NULL); 1931 CAMHAL_LOGEA("Timeout expired on preview port disable"); 1932 goto EXIT; 1933 } 1934 1935 { 1936 Mutex::Autolock lock(mPreviewBufferLock); 1937 ///Clear all the available preview buffers 1938 mPreviewBuffersAvailable.clear(); 1939 } 1940 1941 switchToLoaded(); 1942 1943 1944 mFirstTimeInit = true; 1945 1946 LOG_FUNCTION_NAME_EXIT; 1947 1948 return (ret | ErrorUtils::omxToAndroidError(eError)); 1949 1950 EXIT: 1951 1952 { 1953 Mutex::Autolock lock(mPreviewBufferLock); 1954 ///Clear all the available preview buffers 1955 mPreviewBuffersAvailable.clear(); 1956 } 1957 1958 switchToLoaded(); 1959 1960 LOG_FUNCTION_NAME_EXIT; 1961 1962 return (ret | ErrorUtils::omxToAndroidError(eError)); 1963 1964} 1965 1966status_t OMXCameraAdapter::setSensorOverclock(bool enable) 1967{ 1968 status_t ret = NO_ERROR; 1969 OMX_ERRORTYPE eError = OMX_ErrorNone; 1970 OMX_CONFIG_BOOLEANTYPE bOMX; 1971 1972 LOG_FUNCTION_NAME; 1973 1974 if ( OMX_StateLoaded != mComponentState ) 1975 { 1976 CAMHAL_LOGDA("OMX component is not in loaded state"); 1977 return ret; 1978 } 1979 1980 if ( NO_ERROR == ret ) 1981 { 1982 OMX_INIT_STRUCT_PTR (&bOMX, OMX_CONFIG_BOOLEANTYPE); 1983 1984 if ( enable ) 1985 { 1986 bOMX.bEnabled = OMX_TRUE; 1987 } 1988 else 1989 { 1990 bOMX.bEnabled = OMX_FALSE; 1991 } 1992 1993 CAMHAL_LOGDB("Configuring Sensor overclock mode 0x%x", bOMX.bEnabled); 1994 eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp, ( OMX_INDEXTYPE ) OMX_TI_IndexParamSensorOverClockMode, &bOMX); 1995 if ( OMX_ErrorNone != eError ) 1996 { 1997 CAMHAL_LOGEB("Error while setting Sensor overclock 0x%x", eError); 1998 ret = BAD_VALUE; 1999 } 2000 else 2001 { 2002 mSensorOverclock = enable; 2003 } 2004 } 2005 2006 LOG_FUNCTION_NAME_EXIT; 2007 2008 return ret; 2009} 2010 2011status_t OMXCameraAdapter::printComponentVersion(OMX_HANDLETYPE handle) 2012{ 2013 status_t ret = NO_ERROR; 2014 OMX_ERRORTYPE eError = OMX_ErrorNone; 2015 OMX_VERSIONTYPE compVersion; 2016 char compName[OMX_MAX_STRINGNAME_SIZE]; 2017 char *currentUUID = NULL; 2018 size_t offset = 0; 2019 2020 LOG_FUNCTION_NAME; 2021 2022 if ( NULL == handle ) 2023 { 2024 CAMHAL_LOGEB("Invalid OMX Handle =0x%x", ( unsigned int ) handle); 2025 ret = -EINVAL; 2026 } 2027 2028 mCompUUID[0] = 0; 2029 2030 if ( NO_ERROR == ret ) 2031 { 2032 eError = OMX_GetComponentVersion(handle, 2033 compName, 2034 &compVersion, 2035 &mCompRevision, 2036 &mCompUUID 2037 ); 2038 if ( OMX_ErrorNone != eError ) 2039 { 2040 CAMHAL_LOGEB("OMX_GetComponentVersion returned 0x%x", eError); 2041 ret = BAD_VALUE; 2042 } 2043 } 2044 2045 if ( NO_ERROR == ret ) 2046 { 2047 CAMHAL_LOGVB("OMX Component name: [%s]", compName); 2048 CAMHAL_LOGVB("OMX Component version: [%u]", ( unsigned int ) compVersion.nVersion); 2049 CAMHAL_LOGVB("Spec version: [%u]", ( unsigned int ) mCompRevision.nVersion); 2050 CAMHAL_LOGVB("Git Commit ID: [%s]", mCompUUID); 2051 currentUUID = ( char * ) mCompUUID; 2052 } 2053 2054 if ( NULL != currentUUID ) 2055 { 2056 offset = strlen( ( const char * ) mCompUUID) + 1; 2057 if ( (int)currentUUID + (int)offset - (int)mCompUUID < OMX_MAX_STRINGNAME_SIZE ) 2058 { 2059 currentUUID += offset; 2060 CAMHAL_LOGVB("Git Branch: [%s]", currentUUID); 2061 } 2062 else 2063 { 2064 ret = BAD_VALUE; 2065 } 2066 } 2067 2068 if ( NO_ERROR == ret ) 2069 { 2070 offset = strlen( ( const char * ) currentUUID) + 1; 2071 2072 if ( (int)currentUUID + (int)offset - (int)mCompUUID < OMX_MAX_STRINGNAME_SIZE ) 2073 { 2074 currentUUID += offset; 2075 CAMHAL_LOGVB("Build date and time: [%s]", currentUUID); 2076 } 2077 else 2078 { 2079 ret = BAD_VALUE; 2080 } 2081 } 2082 2083 if ( NO_ERROR == ret ) 2084 { 2085 offset = strlen( ( const char * ) currentUUID) + 1; 2086 2087 if ( (int)currentUUID + (int)offset - (int)mCompUUID < OMX_MAX_STRINGNAME_SIZE ) 2088 { 2089 currentUUID += offset; 2090 CAMHAL_LOGVB("Build description: [%s]", currentUUID); 2091 } 2092 else 2093 { 2094 ret = BAD_VALUE; 2095 } 2096 } 2097 2098 LOG_FUNCTION_NAME_EXIT; 2099 2100 return ret; 2101} 2102 2103status_t OMXCameraAdapter::autoFocus() 2104{ 2105 status_t ret = NO_ERROR; 2106 TIUTILS::Message msg; 2107 2108 LOG_FUNCTION_NAME; 2109 2110 msg.command = CommandHandler::CAMERA_PERFORM_AUTOFOCUS; 2111 msg.arg1 = mErrorNotifier; 2112 ret = mCommandHandler->put(&msg); 2113 2114 LOG_FUNCTION_NAME; 2115 2116 return ret; 2117} 2118 2119status_t OMXCameraAdapter::takePicture() 2120{ 2121 status_t ret = NO_ERROR; 2122 TIUTILS::Message msg; 2123 2124 LOG_FUNCTION_NAME; 2125 2126 msg.command = CommandHandler::CAMERA_START_IMAGE_CAPTURE; 2127 msg.arg1 = mErrorNotifier; 2128 ret = mCommandHandler->put(&msg); 2129 2130 LOG_FUNCTION_NAME_EXIT; 2131 2132 return ret; 2133} 2134 2135status_t OMXCameraAdapter::startVideoCapture() 2136{ 2137 return BaseCameraAdapter::startVideoCapture(); 2138} 2139 2140status_t OMXCameraAdapter::stopVideoCapture() 2141{ 2142 return BaseCameraAdapter::stopVideoCapture(); 2143} 2144 2145//API to get the frame size required to be allocated. This size is used to override the size passed 2146//by camera service when VSTAB/VNF is turned ON for example 2147status_t OMXCameraAdapter::getFrameSize(size_t &width, size_t &height) 2148{ 2149 status_t ret = NO_ERROR; 2150 OMX_ERRORTYPE eError = OMX_ErrorNone; 2151 OMX_CONFIG_RECTTYPE tFrameDim; 2152 2153 LOG_FUNCTION_NAME; 2154 2155 OMX_INIT_STRUCT_PTR (&tFrameDim, OMX_CONFIG_RECTTYPE); 2156 tFrameDim.nPortIndex = mCameraAdapterParameters.mPrevPortIndex; 2157 2158 if ( mOMXStateSwitch ) 2159 { 2160 2161 ret = switchToLoaded(); 2162 if ( NO_ERROR != ret ) 2163 { 2164 CAMHAL_LOGEB("switchToLoaded() failed 0x%x", ret); 2165 goto exit; 2166 } 2167 2168 mOMXStateSwitch = false; 2169 } 2170 2171 if ( OMX_StateLoaded == mComponentState ) 2172 { 2173 2174 ret = setLDC(mIPP); 2175 if ( NO_ERROR != ret ) 2176 { 2177 CAMHAL_LOGEB("setLDC() failed %d", ret); 2178 LOG_FUNCTION_NAME_EXIT; 2179 goto exit; 2180 } 2181 2182 ret = setNSF(mIPP); 2183 if ( NO_ERROR != ret ) 2184 { 2185 CAMHAL_LOGEB("setNSF() failed %d", ret); 2186 LOG_FUNCTION_NAME_EXIT; 2187 goto exit; 2188 } 2189 2190 ret = setCaptureMode(mCapMode); 2191 if ( NO_ERROR != ret ) 2192 { 2193 CAMHAL_LOGEB("setCaptureMode() failed %d", ret); 2194 } 2195 2196 if(mCapMode == OMXCameraAdapter::VIDEO_MODE) 2197 { 2198 if ( NO_ERROR == ret ) 2199 { 2200 ///Enable/Disable Video Noise Filter 2201 ret = enableVideoNoiseFilter(mVnfEnabled); 2202 } 2203 2204 if ( NO_ERROR != ret) 2205 { 2206 CAMHAL_LOGEB("Error configuring VNF %x", ret); 2207 } 2208 2209 if ( NO_ERROR == ret ) 2210 { 2211 ///Enable/Disable Video Stabilization 2212 ret = enableVideoStabilization(mVstabEnabled); 2213 } 2214 2215 if ( NO_ERROR != ret) 2216 { 2217 CAMHAL_LOGEB("Error configuring VSTAB %x", ret); 2218 } 2219 } 2220 else 2221 { 2222 if ( NO_ERROR == ret ) 2223 { 2224 ///Enable/Disable Video Noise Filter 2225 ret = enableVideoNoiseFilter(false); 2226 } 2227 2228 if ( NO_ERROR != ret) 2229 { 2230 CAMHAL_LOGEB("Error configuring VNF %x", ret); 2231 } 2232 2233 if ( NO_ERROR == ret ) 2234 { 2235 ///Enable/Disable Video Stabilization 2236 ret = enableVideoStabilization(false); 2237 } 2238 2239 if ( NO_ERROR != ret) 2240 { 2241 CAMHAL_LOGEB("Error configuring VSTAB %x", ret); 2242 } 2243 } 2244 2245 } 2246 2247 ret = setSensorOrientation(mSensorOrientation); 2248 if ( NO_ERROR != ret ) 2249 { 2250 CAMHAL_LOGEB("Error configuring Sensor Orientation %x", ret); 2251 mSensorOrientation = 0; 2252 } 2253 2254 if ( NO_ERROR == ret ) 2255 { 2256 eError = OMX_GetParameter(mCameraAdapterParameters.mHandleComp, ( OMX_INDEXTYPE ) OMX_TI_IndexParam2DBufferAllocDimension, &tFrameDim); 2257 if ( OMX_ErrorNone == eError) 2258 { 2259 width = tFrameDim.nWidth; 2260 height = tFrameDim.nHeight; 2261 } 2262 } 2263 2264exit: 2265 2266 CAMHAL_LOGDB("Required frame size %dx%d", width, height); 2267 2268 LOG_FUNCTION_NAME_EXIT; 2269 2270 return ret; 2271} 2272 2273status_t OMXCameraAdapter::getFrameDataSize(size_t &dataFrameSize, size_t bufferCount) 2274{ 2275 status_t ret = NO_ERROR; 2276 OMX_PARAM_PORTDEFINITIONTYPE portCheck; 2277 OMX_ERRORTYPE eError = OMX_ErrorNone; 2278 2279 LOG_FUNCTION_NAME; 2280 2281 if ( OMX_StateLoaded != mComponentState ) 2282 { 2283 CAMHAL_LOGEA("Calling getFrameDataSize() when not in LOADED state"); 2284 dataFrameSize = 0; 2285 ret = BAD_VALUE; 2286 } 2287 2288 if ( NO_ERROR == ret ) 2289 { 2290 OMX_INIT_STRUCT_PTR(&portCheck, OMX_PARAM_PORTDEFINITIONTYPE); 2291 portCheck.nPortIndex = mCameraAdapterParameters.mMeasurementPortIndex; 2292 2293 eError = OMX_GetParameter(mCameraAdapterParameters.mHandleComp, OMX_IndexParamPortDefinition, &portCheck); 2294 if ( OMX_ErrorNone != eError ) 2295 { 2296 CAMHAL_LOGEB("OMX_GetParameter on OMX_IndexParamPortDefinition returned: 0x%x", eError); 2297 dataFrameSize = 0; 2298 ret = BAD_VALUE; 2299 } 2300 } 2301 2302 if ( NO_ERROR == ret ) 2303 { 2304 portCheck.nBufferCountActual = bufferCount; 2305 eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp, OMX_IndexParamPortDefinition, &portCheck); 2306 if ( OMX_ErrorNone != eError ) 2307 { 2308 CAMHAL_LOGEB("OMX_SetParameter on OMX_IndexParamPortDefinition returned: 0x%x", eError); 2309 dataFrameSize = 0; 2310 ret = BAD_VALUE; 2311 } 2312 } 2313 2314 if ( NO_ERROR == ret ) 2315 { 2316 eError = OMX_GetParameter(mCameraAdapterParameters.mHandleComp, OMX_IndexParamPortDefinition, &portCheck); 2317 if ( OMX_ErrorNone != eError ) 2318 { 2319 CAMHAL_LOGEB("OMX_GetParameter on OMX_IndexParamPortDefinition returned: 0x%x", eError); 2320 ret = BAD_VALUE; 2321 } 2322 else 2323 { 2324 mCameraAdapterParameters.mCameraPortParams[portCheck.nPortIndex].mBufSize = portCheck.nBufferSize; 2325 dataFrameSize = portCheck.nBufferSize; 2326 } 2327 } 2328 2329 LOG_FUNCTION_NAME_EXIT; 2330 2331 return ret; 2332} 2333 2334void OMXCameraAdapter::onOrientationEvent(uint32_t orientation, uint32_t tilt) 2335{ 2336 LOG_FUNCTION_NAME; 2337 2338 static const int DEGREES_TILT_IGNORE = 45; 2339 int device_orientation = 0; 2340 int mount_orientation = 0; 2341 const char *facing_direction = NULL; 2342 2343 // if tilt angle is greater than DEGREES_TILT_IGNORE 2344 // we are going to ignore the orientation returned from 2345 // sensor. the orientation returned from sensor is not 2346 // reliable. Value of DEGREES_TILT_IGNORE may need adjusting 2347 if (tilt > DEGREES_TILT_IGNORE) { 2348 return; 2349 } 2350 2351 if (mCapabilities) { 2352 if (mCapabilities->get(CameraProperties::ORIENTATION_INDEX)) { 2353 mount_orientation = atoi(mCapabilities->get(CameraProperties::ORIENTATION_INDEX)); 2354 } 2355 facing_direction = mCapabilities->get(CameraProperties::FACING_INDEX); 2356 } 2357 2358 // calculate device orientation relative to the sensor orientation 2359 // front camera display is mirrored...needs to be accounted for when orientation 2360 // is 90 or 270...since this will result in a flip on orientation otherwise 2361 if (facing_direction && !strcmp(facing_direction, TICameraParameters::FACING_FRONT) && 2362 (orientation == 90 || orientation == 270)) { 2363 device_orientation = (orientation - mount_orientation + 360) % 360; 2364 } else { // back-facing camera 2365 device_orientation = (orientation + mount_orientation) % 360; 2366 } 2367 2368 if (device_orientation != mDeviceOrientation) { 2369 mDeviceOrientation = device_orientation; 2370 2371 mFaceDetectionLock.lock(); 2372 if (mFaceDetectionRunning) { 2373 // restart face detection with new rotation 2374 setFaceDetection(true, mDeviceOrientation); 2375 } 2376 mFaceDetectionLock.unlock(); 2377 } 2378 CAMHAL_LOGVB("orientation = %d tilt = %d device_orientation = %d", orientation, tilt, mDeviceOrientation); 2379 2380 LOG_FUNCTION_NAME_EXIT; 2381} 2382 2383/* Application callback Functions */ 2384/*========================================================*/ 2385/* @ fn SampleTest_EventHandler :: Application callback */ 2386/*========================================================*/ 2387OMX_ERRORTYPE OMXCameraAdapterEventHandler(OMX_IN OMX_HANDLETYPE hComponent, 2388 OMX_IN OMX_PTR pAppData, 2389 OMX_IN OMX_EVENTTYPE eEvent, 2390 OMX_IN OMX_U32 nData1, 2391 OMX_IN OMX_U32 nData2, 2392 OMX_IN OMX_PTR pEventData) 2393{ 2394 LOG_FUNCTION_NAME; 2395 2396 CAMHAL_LOGDB("Event %d", eEvent); 2397 2398 OMX_ERRORTYPE ret = OMX_ErrorNone; 2399 OMXCameraAdapter *oca = (OMXCameraAdapter*)pAppData; 2400 ret = oca->OMXCameraAdapterEventHandler(hComponent, eEvent, nData1, nData2, pEventData); 2401 2402 LOG_FUNCTION_NAME_EXIT; 2403 return ret; 2404} 2405 2406/* Application callback Functions */ 2407/*========================================================*/ 2408/* @ fn SampleTest_EventHandler :: Application callback */ 2409/*========================================================*/ 2410OMX_ERRORTYPE OMXCameraAdapter::OMXCameraAdapterEventHandler(OMX_IN OMX_HANDLETYPE hComponent, 2411 OMX_IN OMX_EVENTTYPE eEvent, 2412 OMX_IN OMX_U32 nData1, 2413 OMX_IN OMX_U32 nData2, 2414 OMX_IN OMX_PTR pEventData) 2415{ 2416 2417 LOG_FUNCTION_NAME; 2418 2419 OMX_ERRORTYPE eError = OMX_ErrorNone; 2420 CAMHAL_LOGDB("+OMX_Event %x, %d %d", eEvent, (int)nData1, (int)nData2); 2421 2422 switch (eEvent) { 2423 case OMX_EventCmdComplete: 2424 CAMHAL_LOGDB("+OMX_EventCmdComplete %d %d", (int)nData1, (int)nData2); 2425 2426 if (OMX_CommandStateSet == nData1) { 2427 mCameraAdapterParameters.mState = (OMX_STATETYPE) nData2; 2428 2429 } else if (OMX_CommandFlush == nData1) { 2430 CAMHAL_LOGDB("OMX_CommandFlush received for port %d", (int)nData2); 2431 2432 } else if (OMX_CommandPortDisable == nData1) { 2433 CAMHAL_LOGDB("OMX_CommandPortDisable received for port %d", (int)nData2); 2434 2435 } else if (OMX_CommandPortEnable == nData1) { 2436 CAMHAL_LOGDB("OMX_CommandPortEnable received for port %d", (int)nData2); 2437 2438 } else if (OMX_CommandMarkBuffer == nData1) { 2439 ///This is not used currently 2440 } 2441 2442 CAMHAL_LOGDA("-OMX_EventCmdComplete"); 2443 break; 2444 2445 case OMX_EventIndexSettingChanged: 2446 CAMHAL_LOGDB("OMX_EventIndexSettingChanged event received data1 0x%x, data2 0x%x", 2447 ( unsigned int ) nData1, ( unsigned int ) nData2); 2448 break; 2449 2450 case OMX_EventError: 2451 CAMHAL_LOGDB("OMX interface failed to execute OMX command %d", (int)nData1); 2452 CAMHAL_LOGDA("See OMX_INDEXTYPE for reference"); 2453 if ( NULL != mErrorNotifier && ( ( OMX_U32 ) OMX_ErrorHardware == nData1 ) && mComponentState != OMX_StateInvalid) 2454 { 2455 CAMHAL_LOGEA("***Got Fatal Error Notification***\n"); 2456 mComponentState = OMX_StateInvalid; 2457 ///Report Error to App 2458 mErrorNotifier->errorNotify(CAMERA_ERROR_UNKNOWN); 2459 } 2460 break; 2461 2462 case OMX_EventMark: 2463 break; 2464 2465 case OMX_EventPortSettingsChanged: 2466 break; 2467 2468 case OMX_EventBufferFlag: 2469 break; 2470 2471 case OMX_EventResourcesAcquired: 2472 break; 2473 2474 case OMX_EventComponentResumed: 2475 break; 2476 2477 case OMX_EventDynamicResourcesAvailable: 2478 break; 2479 2480 case OMX_EventPortFormatDetected: 2481 break; 2482 2483 default: 2484 break; 2485 } 2486 2487 ///Signal to the thread(s) waiting that the event has occured 2488 SignalEvent(hComponent, eEvent, nData1, nData2, pEventData); 2489 2490 LOG_FUNCTION_NAME_EXIT; 2491 return eError; 2492 2493 EXIT: 2494 2495 CAMHAL_LOGEB("Exiting function %s because of eError=%x", __FUNCTION__, eError); 2496 LOG_FUNCTION_NAME_EXIT; 2497 return eError; 2498} 2499 2500OMX_ERRORTYPE OMXCameraAdapter::SignalEvent(OMX_IN OMX_HANDLETYPE hComponent, 2501 OMX_IN OMX_EVENTTYPE eEvent, 2502 OMX_IN OMX_U32 nData1, 2503 OMX_IN OMX_U32 nData2, 2504 OMX_IN OMX_PTR pEventData) 2505{ 2506 Mutex::Autolock lock(mEventLock); 2507 TIUTILS::Message *msg; 2508 2509 LOG_FUNCTION_NAME; 2510 2511 if ( !mEventSignalQ.isEmpty() ) 2512 { 2513 CAMHAL_LOGDA("Event queue not empty"); 2514 2515 for ( unsigned int i = 0 ; i < mEventSignalQ.size() ; i++ ) 2516 { 2517 msg = mEventSignalQ.itemAt(i); 2518 if ( NULL != msg ) 2519 { 2520 if( ( msg->command != 0 || msg->command == ( unsigned int ) ( eEvent ) ) 2521 && ( !msg->arg1 || ( OMX_U32 ) msg->arg1 == nData1 ) 2522 && ( !msg->arg2 || ( OMX_U32 ) msg->arg2 == nData2 ) 2523 && msg->arg3) 2524 { 2525 Semaphore *sem = (Semaphore*) msg->arg3; 2526 CAMHAL_LOGDA("Event matched, signalling sem"); 2527 mEventSignalQ.removeAt(i); 2528 //Signal the semaphore provided 2529 sem->Signal(); 2530 free(msg); 2531 break; 2532 } 2533 } 2534 } 2535 } 2536 else 2537 { 2538 CAMHAL_LOGEA("Event queue empty!!!"); 2539 } 2540 2541 LOG_FUNCTION_NAME_EXIT; 2542 2543 return OMX_ErrorNone; 2544} 2545 2546status_t OMXCameraAdapter::RegisterForEvent(OMX_IN OMX_HANDLETYPE hComponent, 2547 OMX_IN OMX_EVENTTYPE eEvent, 2548 OMX_IN OMX_U32 nData1, 2549 OMX_IN OMX_U32 nData2, 2550 OMX_IN Semaphore &semaphore) 2551{ 2552 status_t ret = NO_ERROR; 2553 ssize_t res; 2554 Mutex::Autolock lock(mEventLock); 2555 2556 LOG_FUNCTION_NAME; 2557 2558 TIUTILS::Message * msg = ( struct TIUTILS::Message * ) malloc(sizeof(struct TIUTILS::Message)); 2559 if ( NULL != msg ) 2560 { 2561 msg->command = ( unsigned int ) eEvent; 2562 msg->arg1 = ( void * ) nData1; 2563 msg->arg2 = ( void * ) nData2; 2564 msg->arg3 = ( void * ) &semaphore; 2565 msg->arg4 = ( void * ) hComponent; 2566 res = mEventSignalQ.add(msg); 2567 if ( NO_MEMORY == res ) 2568 { 2569 CAMHAL_LOGEA("No ressources for inserting OMX events"); 2570 free(msg); 2571 ret = -ENOMEM; 2572 } 2573 } 2574 2575 LOG_FUNCTION_NAME_EXIT; 2576 2577 return ret; 2578} 2579 2580/*========================================================*/ 2581/* @ fn SampleTest_EmptyBufferDone :: Application callback*/ 2582/*========================================================*/ 2583OMX_ERRORTYPE OMXCameraAdapterEmptyBufferDone(OMX_IN OMX_HANDLETYPE hComponent, 2584 OMX_IN OMX_PTR pAppData, 2585 OMX_IN OMX_BUFFERHEADERTYPE* pBuffHeader) 2586{ 2587 LOG_FUNCTION_NAME; 2588 2589 OMX_ERRORTYPE eError = OMX_ErrorNone; 2590 2591 OMXCameraAdapter *oca = (OMXCameraAdapter*)pAppData; 2592 eError = oca->OMXCameraAdapterEmptyBufferDone(hComponent, pBuffHeader); 2593 2594 LOG_FUNCTION_NAME_EXIT; 2595 return eError; 2596} 2597 2598 2599/*========================================================*/ 2600/* @ fn SampleTest_EmptyBufferDone :: Application callback*/ 2601/*========================================================*/ 2602OMX_ERRORTYPE OMXCameraAdapter::OMXCameraAdapterEmptyBufferDone(OMX_IN OMX_HANDLETYPE hComponent, 2603 OMX_IN OMX_BUFFERHEADERTYPE* pBuffHeader) 2604{ 2605 2606 LOG_FUNCTION_NAME; 2607 2608 LOG_FUNCTION_NAME_EXIT; 2609 2610 return OMX_ErrorNone; 2611} 2612 2613static void debugShowFPS() 2614{ 2615 static int mFrameCount = 0; 2616 static int mLastFrameCount = 0; 2617 static nsecs_t mLastFpsTime = 0; 2618 static float mFps = 0; 2619 mFrameCount++; 2620 if (!(mFrameCount & 0x1F)) { 2621 nsecs_t now = systemTime(); 2622 nsecs_t diff = now - mLastFpsTime; 2623 mFps = ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff; 2624 mLastFpsTime = now; 2625 mLastFrameCount = mFrameCount; 2626 LOGD("Camera %d Frames, %f FPS", mFrameCount, mFps); 2627 } 2628 // XXX: mFPS has the value we want 2629} 2630 2631/*========================================================*/ 2632/* @ fn SampleTest_FillBufferDone :: Application callback*/ 2633/*========================================================*/ 2634OMX_ERRORTYPE OMXCameraAdapterFillBufferDone(OMX_IN OMX_HANDLETYPE hComponent, 2635 OMX_IN OMX_PTR pAppData, 2636 OMX_IN OMX_BUFFERHEADERTYPE* pBuffHeader) 2637{ 2638 TIUTILS::Message msg; 2639 OMX_ERRORTYPE eError = OMX_ErrorNone; 2640 2641 if (UNLIKELY(mDebugFps)) { 2642 debugShowFPS(); 2643 } 2644 2645 OMXCameraAdapter *adapter = ( OMXCameraAdapter * ) pAppData; 2646 if ( NULL != adapter ) 2647 { 2648 msg.command = OMXCameraAdapter::OMXCallbackHandler::CAMERA_FILL_BUFFER_DONE; 2649 msg.arg1 = ( void * ) hComponent; 2650 msg.arg2 = ( void * ) pBuffHeader; 2651 adapter->mOMXCallbackHandler->put(&msg); 2652 } 2653 2654 return eError; 2655} 2656 2657/*========================================================*/ 2658/* @ fn SampleTest_FillBufferDone :: Application callback*/ 2659/*========================================================*/ 2660OMX_ERRORTYPE OMXCameraAdapter::OMXCameraAdapterFillBufferDone(OMX_IN OMX_HANDLETYPE hComponent, 2661 OMX_IN OMX_BUFFERHEADERTYPE* pBuffHeader) 2662{ 2663 2664 status_t stat = NO_ERROR; 2665 status_t res1, res2; 2666 OMXCameraPortParameters *pPortParam; 2667 OMX_ERRORTYPE eError = OMX_ErrorNone; 2668 CameraFrame::FrameType typeOfFrame = CameraFrame::ALL_FRAMES; 2669 unsigned int refCount = 0; 2670 BaseCameraAdapter::AdapterState state; 2671 BaseCameraAdapter::getState(state); 2672 sp<CameraFDResult> fdResult = NULL; 2673 2674 res1 = res2 = NO_ERROR; 2675 pPortParam = &(mCameraAdapterParameters.mCameraPortParams[pBuffHeader->nOutputPortIndex]); 2676 if (pBuffHeader->nOutputPortIndex == OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW) 2677 { 2678 2679 if ( ( PREVIEW_ACTIVE & state ) != PREVIEW_ACTIVE ) 2680 { 2681 return OMX_ErrorNone; 2682 } 2683 2684 recalculateFPS(); 2685 2686 { 2687 Mutex::Autolock lock(mFaceDetectionLock); 2688 if ( mFaceDetectionRunning && !mFaceDetectionPaused ) { 2689 detectFaces(pBuffHeader, fdResult, pPortParam->mWidth, pPortParam->mHeight); 2690 if ( NULL != fdResult.get() ) { 2691 notifyFaceSubscribers(fdResult); 2692 fdResult.clear(); 2693 } 2694 } 2695 } 2696 2697 stat |= advanceZoom(); 2698 2699 ///On the fly update to 3A settings not working 2700 if( mPending3Asettings ) 2701 { 2702 apply3Asettings(mParameters3A); 2703 } 2704 2705 ///Prepare the frames to be sent - initialize CameraFrame object and reference count 2706 CameraFrame cameraFrameVideo, cameraFramePreview; 2707 if ( mRecording ) 2708 { 2709 res1 = initCameraFrame(cameraFrameVideo, 2710 pBuffHeader, 2711 CameraFrame::VIDEO_FRAME_SYNC, 2712 pPortParam); 2713 } 2714 2715 if( mWaitingForSnapshot && (mCapturedFrames > 0) ) 2716 { 2717 typeOfFrame = CameraFrame::SNAPSHOT_FRAME; 2718 } 2719 else 2720 { 2721 typeOfFrame = CameraFrame::PREVIEW_FRAME_SYNC; 2722 } 2723 2724 LOGV("FBD pBuffer = 0x%x", pBuffHeader->pBuffer); 2725 2726 res2 = initCameraFrame(cameraFramePreview, 2727 pBuffHeader, 2728 typeOfFrame, 2729 pPortParam); 2730 2731 stat |= res1 | res2; 2732 2733 if ( mRecording ) 2734 { 2735 res1 = sendFrame(cameraFrameVideo); 2736 } 2737 2738 if( mWaitingForSnapshot ) 2739 { 2740 mSnapshotCount++; 2741 2742 if ( (mSnapshotCount == 1) && 2743 ((HIGH_SPEED == mCapMode) || (VIDEO_MODE == mCapMode)) ) 2744 { 2745 notifyShutterSubscribers(); 2746 } 2747 } 2748 2749 res2 = sendFrame(cameraFramePreview); 2750 2751 stat |= ( ( NO_ERROR == res1 ) || ( NO_ERROR == res2 ) ) ? ( ( int ) NO_ERROR ) : ( -1 ); 2752 2753 } 2754 else if( pBuffHeader->nOutputPortIndex == OMX_CAMERA_PORT_VIDEO_OUT_MEASUREMENT ) 2755 { 2756 typeOfFrame = CameraFrame::FRAME_DATA_SYNC; 2757 CameraFrame cameraFrame; 2758 stat |= initCameraFrame(cameraFrame, 2759 pBuffHeader, 2760 typeOfFrame, 2761 pPortParam); 2762 stat |= sendFrame(cameraFrame); 2763 } 2764 else if( pBuffHeader->nOutputPortIndex == OMX_CAMERA_PORT_IMAGE_OUT_IMAGE ) 2765 { 2766 CameraFrame cameraFrame; 2767 OMX_COLOR_FORMATTYPE pixFormat; 2768 const char *valstr = NULL; 2769 2770 pixFormat = mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex].mColorFormat; 2771 valstr = mParams.getPictureFormat(); 2772 2773 if ( OMX_COLOR_FormatUnused == pixFormat ) 2774 { 2775 typeOfFrame = CameraFrame::IMAGE_FRAME; 2776 } 2777 else if ( pixFormat == OMX_COLOR_FormatCbYCrY && 2778 ((valstr && !strcmp(valstr, CameraParameters::PIXEL_FORMAT_JPEG)) || 2779 !valstr) ) 2780 { 2781 // signals to callbacks that this needs to be coverted to jpeg 2782 // before returning to framework 2783 typeOfFrame = CameraFrame::IMAGE_FRAME; 2784 cameraFrame.mQuirks |= CameraFrame::ENCODE_RAW_YUV422I_TO_JPEG; 2785 } 2786 else 2787 { 2788 typeOfFrame = CameraFrame::RAW_FRAME; 2789 } 2790 2791 pPortParam->mImageType = typeOfFrame; 2792 2793 if((mCapturedFrames>0) && !mCaptureSignalled) 2794 { 2795 mCaptureSignalled = true; 2796 mCaptureSem.Signal(); 2797 } 2798 2799 if( ( CAPTURE_ACTIVE & state ) != CAPTURE_ACTIVE ) 2800 { 2801 goto EXIT; 2802 } 2803 2804 { 2805 Mutex::Autolock lock(mBracketingLock); 2806 if ( mBracketingEnabled ) 2807 { 2808 doBracketing(pBuffHeader, typeOfFrame); 2809 return eError; 2810 } 2811 } 2812 2813 if ( 1 > mCapturedFrames ) 2814 { 2815 goto EXIT; 2816 } 2817 2818 CAMHAL_LOGDB("Captured Frames: %d", mCapturedFrames); 2819 2820 mCapturedFrames--; 2821 2822 stat |= initCameraFrame(cameraFrame, 2823 pBuffHeader, 2824 typeOfFrame, 2825 pPortParam); 2826 stat |= sendFrame(cameraFrame); 2827 } 2828 else 2829 { 2830 CAMHAL_LOGEA("Frame received for non-(preview/capture/measure) port. This is yet to be supported"); 2831 goto EXIT; 2832 } 2833 2834 if ( NO_ERROR != stat ) 2835 { 2836 CAMHAL_LOGDB("sendFrameToSubscribers error: %d", stat); 2837 returnFrame(pBuffHeader->pBuffer, typeOfFrame); 2838 } 2839 2840 return eError; 2841 2842 EXIT: 2843 2844 CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, stat, eError); 2845 2846 if ( NO_ERROR != stat ) 2847 { 2848 if ( NULL != mErrorNotifier ) 2849 { 2850 mErrorNotifier->errorNotify(CAMERA_ERROR_UNKNOWN); 2851 } 2852 } 2853 2854 return eError; 2855} 2856 2857status_t OMXCameraAdapter::recalculateFPS() 2858{ 2859 float currentFPS; 2860 2861 mFrameCount++; 2862 2863 if ( ( mFrameCount % FPS_PERIOD ) == 0 ) 2864 { 2865 nsecs_t now = systemTime(); 2866 nsecs_t diff = now - mLastFPSTime; 2867 currentFPS = ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff; 2868 mLastFPSTime = now; 2869 mLastFrameCount = mFrameCount; 2870 2871 if ( 1 == mIter ) 2872 { 2873 mFPS = currentFPS; 2874 } 2875 else 2876 { 2877 //cumulative moving average 2878 mFPS = mLastFPS + (currentFPS - mLastFPS)/mIter; 2879 } 2880 2881 mLastFPS = mFPS; 2882 mIter++; 2883 } 2884 2885 return NO_ERROR; 2886} 2887 2888status_t OMXCameraAdapter::sendFrame(CameraFrame &frame) 2889{ 2890 status_t ret = NO_ERROR; 2891 2892 LOG_FUNCTION_NAME; 2893 2894 2895 if ( NO_ERROR == ret ) 2896 { 2897 ret = sendFrameToSubscribers(&frame); 2898 } 2899 2900 LOG_FUNCTION_NAME_EXIT; 2901 2902 return ret; 2903} 2904 2905status_t OMXCameraAdapter::initCameraFrame( CameraFrame &frame, 2906 OMX_IN OMX_BUFFERHEADERTYPE *pBuffHeader, 2907 int typeOfFrame, 2908 OMXCameraPortParameters *port) 2909{ 2910 status_t ret = NO_ERROR; 2911 2912 LOG_FUNCTION_NAME; 2913 2914 if ( NULL == port) 2915 { 2916 CAMHAL_LOGEA("Invalid portParam"); 2917 return -EINVAL; 2918 } 2919 2920 if ( NULL == pBuffHeader ) 2921 { 2922 CAMHAL_LOGEA("Invalid Buffer header"); 2923 return -EINVAL; 2924 } 2925 2926 frame.mFrameType = typeOfFrame; 2927 frame.mBuffer = pBuffHeader->pBuffer; 2928 frame.mLength = pBuffHeader->nFilledLen; 2929 frame.mAlignment = port->mStride; 2930 frame.mOffset = pBuffHeader->nOffset; 2931 frame.mWidth = port->mWidth; 2932 frame.mHeight = port->mHeight; 2933 2934 // Calculating the time source delta of Ducati & system time only once at the start of camera. 2935 // It's seen that there is a one-time constant diff between the ducati source clock & 2936 // System monotonic timer, although both derived from the same 32KHz clock. 2937 // This delta is offsetted to/from ducati timestamp to match with system time so that 2938 // video timestamps are aligned with Audio with a periodic timestamp intervals. 2939 if ( onlyOnce ) 2940 { 2941 mTimeSourceDelta = (pBuffHeader->nTimeStamp * 1000) - systemTime(SYSTEM_TIME_MONOTONIC); 2942 onlyOnce = false; 2943 } 2944 2945 // Calculating the new video timestamp based on offset from ducati source. 2946 frame.mTimestamp = (pBuffHeader->nTimeStamp * 1000) - mTimeSourceDelta; 2947 2948 LOG_FUNCTION_NAME_EXIT; 2949 2950 return ret; 2951} 2952 2953bool OMXCameraAdapter::CommandHandler::Handler() 2954{ 2955 TIUTILS::Message msg; 2956 volatile int forever = 1; 2957 status_t stat; 2958 ErrorNotifier *errorNotify = NULL; 2959 2960 LOG_FUNCTION_NAME; 2961 2962 while ( forever ) 2963 { 2964 stat = NO_ERROR; 2965 CAMHAL_LOGDA("Handler: waiting for messsage..."); 2966 TIUTILS::MessageQueue::waitForMsg(&mCommandMsgQ, NULL, NULL, -1); 2967 mCommandMsgQ.get(&msg); 2968 CAMHAL_LOGDB("msg.command = %d", msg.command); 2969 switch ( msg.command ) { 2970 case CommandHandler::CAMERA_START_IMAGE_CAPTURE: 2971 { 2972 stat = mCameraAdapter->startImageCapture(); 2973 break; 2974 } 2975 case CommandHandler::CAMERA_PERFORM_AUTOFOCUS: 2976 { 2977 stat = mCameraAdapter->doAutoFocus(); 2978 break; 2979 } 2980 case CommandHandler::COMMAND_EXIT: 2981 { 2982 CAMHAL_LOGEA("Exiting command handler"); 2983 forever = 0; 2984 break; 2985 } 2986 } 2987 2988 if ( NO_ERROR != stat ) 2989 { 2990 errorNotify = ( ErrorNotifier * ) msg.arg1; 2991 if ( NULL != errorNotify ) 2992 { 2993 errorNotify->errorNotify(CAMERA_ERROR_UNKNOWN); 2994 } 2995 } 2996 } 2997 2998 LOG_FUNCTION_NAME_EXIT; 2999 3000 return false; 3001} 3002 3003bool OMXCameraAdapter::OMXCallbackHandler::Handler() 3004{ 3005 TIUTILS::Message msg; 3006 volatile int forever = 1; 3007 status_t ret = NO_ERROR; 3008 3009 LOG_FUNCTION_NAME; 3010 3011 while(forever){ 3012 TIUTILS::MessageQueue::waitForMsg(&mCommandMsgQ, NULL, NULL, -1); 3013 mCommandMsgQ.get(&msg); 3014 switch ( msg.command ) { 3015 case OMXCallbackHandler::CAMERA_FILL_BUFFER_DONE: 3016 { 3017 ret = mCameraAdapter->OMXCameraAdapterFillBufferDone(( OMX_HANDLETYPE ) msg.arg1, 3018 ( OMX_BUFFERHEADERTYPE *) msg.arg2); 3019 break; 3020 } 3021 case CommandHandler::COMMAND_EXIT: 3022 { 3023 CAMHAL_LOGEA("Exiting OMX callback handler"); 3024 forever = 0; 3025 break; 3026 } 3027 } 3028 } 3029 3030 LOG_FUNCTION_NAME_EXIT; 3031 return false; 3032} 3033 3034OMXCameraAdapter::OMXCameraAdapter():mComponentState (OMX_StateInvalid) 3035{ 3036 LOG_FUNCTION_NAME; 3037 3038 mPictureRotation = 0; 3039 // Initial values 3040 mTimeSourceDelta = 0; 3041 onlyOnce = true; 3042 3043 mDoAFSem.Create(0); 3044 mInitSem.Create(0); 3045 mFlushSem.Create(0); 3046 mUsePreviewDataSem.Create(0); 3047 mUsePreviewSem.Create(0); 3048 mUseCaptureSem.Create(0); 3049 mStartPreviewSem.Create(0); 3050 mStopPreviewSem.Create(0); 3051 mStartCaptureSem.Create(0); 3052 mStopCaptureSem.Create(0); 3053 mSwitchToLoadedSem.Create(0); 3054 mCaptureSem.Create(0); 3055 3056 mCameraAdapterParameters.mHandleComp = 0; 3057 3058 LOG_FUNCTION_NAME_EXIT; 3059} 3060 3061OMXCameraAdapter::~OMXCameraAdapter() 3062{ 3063 LOG_FUNCTION_NAME; 3064 3065 Mutex::Autolock lock(gAdapterLock); 3066 3067 //Return to OMX Loaded state 3068 switchToLoaded(); 3069 3070 ///Free the handle for the Camera component 3071 if(mCameraAdapterParameters.mHandleComp) 3072 { 3073 OMX_FreeHandle(mCameraAdapterParameters.mHandleComp); 3074 } 3075 3076 ///De-init the OMX 3077 if( (mComponentState==OMX_StateLoaded) || (mComponentState==OMX_StateInvalid)) 3078 { 3079 OMX_Deinit(); 3080 } 3081 3082 //Remove any unhandled events 3083 if ( !mEventSignalQ.isEmpty() ) 3084 { 3085 for (unsigned int i = 0 ; i < mEventSignalQ.size() ; i++ ) 3086 { 3087 TIUTILS::Message *msg = mEventSignalQ.itemAt(i); 3088 //remove from queue and free msg 3089 mEventSignalQ.removeAt(i); 3090 if ( NULL != msg ) 3091 { 3092 free(msg); 3093 } 3094 } 3095 } 3096 3097 //Exit and free ref to command handling thread 3098 if ( NULL != mCommandHandler.get() ) 3099 { 3100 TIUTILS::Message msg; 3101 msg.command = CommandHandler::COMMAND_EXIT; 3102 msg.arg1 = mErrorNotifier; 3103 mCommandHandler->put(&msg); 3104 mCommandHandler->requestExitAndWait(); 3105 mCommandHandler.clear(); 3106 } 3107 3108 //Exit and free ref to callback handling thread 3109 if ( NULL != mOMXCallbackHandler.get() ) 3110 { 3111 TIUTILS::Message msg; 3112 msg.command = OMXCallbackHandler::COMMAND_EXIT; 3113 mOMXCallbackHandler->put(&msg); 3114 mOMXCallbackHandler->requestExitAndWait(); 3115 mOMXCallbackHandler.clear(); 3116 } 3117 3118 gCameraAdapter = NULL; 3119 3120 LOG_FUNCTION_NAME_EXIT; 3121} 3122 3123extern "C" CameraAdapter* CameraAdapter_Factory() 3124{ 3125 Mutex::Autolock lock(gAdapterLock); 3126 3127 LOG_FUNCTION_NAME; 3128 3129 if ( NULL == gCameraAdapter ) 3130 { 3131 CAMHAL_LOGDA("Creating new Camera adapter instance"); 3132 gCameraAdapter= new OMXCameraAdapter(); 3133 } 3134 else 3135 { 3136 CAMHAL_LOGDA("Reusing existing Camera adapter instance"); 3137 } 3138 3139 LOG_FUNCTION_NAME_EXIT; 3140 3141 return gCameraAdapter; 3142} 3143 3144extern "C" int CameraAdapter_Capabilities(CameraProperties::Properties* properties_array, 3145 const unsigned int starting_camera, 3146 const unsigned int max_camera) { 3147 int num_cameras_supported = 0; 3148 CameraProperties::Properties* properties = NULL; 3149 OMX_ERRORTYPE eError = OMX_ErrorNone; 3150 OMX_HANDLETYPE handle = NULL; 3151 OMX_TI_CAPTYPE caps; 3152 3153 LOG_FUNCTION_NAME; 3154 3155 if (!properties_array) { 3156 CAMHAL_LOGEB("invalid param: properties = 0x%p", properties_array); 3157 LOG_FUNCTION_NAME_EXIT; 3158 return -EINVAL; 3159 } 3160 3161 // OMX_Init 3162 eError = OMX_Init(); 3163 if (eError != OMX_ErrorNone) { 3164 CAMHAL_LOGEB("OMX_Init -0x%x", eError); 3165 return 0; // no cameras supported 3166 } 3167 3168 // Setup key parameters to send to Ducati during init 3169 OMX_CALLBACKTYPE oCallbacks; 3170 3171 // Initialize the callback handles 3172 oCallbacks.EventHandler = android::OMXCameraAdapterEventHandler; 3173 oCallbacks.EmptyBufferDone = android::OMXCameraAdapterEmptyBufferDone; 3174 oCallbacks.FillBufferDone = android::OMXCameraAdapterFillBufferDone; 3175 3176 // Get Handle 3177 eError = OMX_GetHandle(&handle, (OMX_STRING)"OMX.TI.DUCATI1.VIDEO.CAMERA", NULL, &oCallbacks); 3178 if (eError != OMX_ErrorNone) { 3179 CAMHAL_LOGEB("OMX_GetHandle -0x%x", eError); 3180 goto EXIT; 3181 } 3182 3183 // Continue selecting sensor and then querying OMX Camera for it's capabilities 3184 // When sensor select returns an error, we know to break and stop 3185 while (eError == OMX_ErrorNone && 3186 (starting_camera + num_cameras_supported) < max_camera) { 3187 // sensor select 3188 OMX_CONFIG_SENSORSELECTTYPE sensorSelect; 3189 OMX_INIT_STRUCT_PTR (&sensorSelect, OMX_CONFIG_SENSORSELECTTYPE); 3190 sensorSelect.eSensor = (OMX_SENSORSELECT) num_cameras_supported; 3191 eError = OMX_SetConfig(handle, ( OMX_INDEXTYPE ) OMX_TI_IndexConfigSensorSelect, &sensorSelect); 3192 3193 if ( OMX_ErrorNone != eError ) { 3194 break; 3195 } 3196 3197 // get and fill capabilities 3198 properties = properties_array + starting_camera + num_cameras_supported; 3199 OMXCameraAdapter::getCaps(properties, handle); 3200 3201 // need to fill facing information 3202 // assume that only sensor 0 is back facing 3203 if (num_cameras_supported == 0) { 3204 properties->set(CameraProperties::FACING_INDEX, TICameraParameters::FACING_BACK); 3205 } else { 3206 properties->set(CameraProperties::FACING_INDEX, TICameraParameters::FACING_FRONT); 3207 } 3208 3209 num_cameras_supported++; 3210 } 3211 3212 EXIT: 3213 // clean up 3214 if(handle) { 3215 OMX_FreeHandle(handle); 3216 } 3217 OMX_Deinit(); 3218 3219 LOG_FUNCTION_NAME_EXIT; 3220 3221 return num_cameras_supported; 3222} 3223 3224}; 3225 3226 3227/*--------------------Camera Adapter Class ENDS here-----------------------------*/ 3228 3229