1 /* 2 ** Copyright (c) 2011-2012 The Linux Foundation. All rights reserved. 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 /*#error uncomment this for compiler test!*/ 18 #define ALOG_NIDEBUG 0 19 20 #define LOG_TAG "QCameraHWI" 21 #include <utils/Log.h> 22 #include <utils/threads.h> 23 #include <cutils/properties.h> 24 #include <fcntl.h> 25 #include <sys/mman.h> 26 #include <string.h> 27 #include <dlfcn.h> 28 29 #include "QCameraHAL.h" 30 #include "QCameraHWI.h" 31 32 /* QCameraHardwareInterface class implementation goes here*/ 33 /* following code implement the contol logic of this class*/ 34 35 namespace android { 36 static void HAL_event_cb(mm_camera_event_t *evt, void *user_data) 37 { 38 QCameraHardwareInterface *obj = (QCameraHardwareInterface *)user_data; 39 if (obj) { 40 obj->processEvent(evt); 41 } else { 42 ALOGE("%s: NULL user_data", __func__); 43 } 44 } 45 46 int32_t QCameraHardwareInterface::createRecord() 47 { 48 int32_t ret = MM_CAMERA_OK; 49 ALOGV("%s : BEGIN",__func__); 50 51 /* 52 * Creating Instance of record stream. 53 */ 54 ALOGV("Mymode Record = %d",myMode); 55 mStreamRecord = QCameraStream_record::createInstance(mCameraId, 56 myMode); 57 58 if (!mStreamRecord) { 59 ALOGE("%s: error - can't creat record stream!", __func__); 60 return BAD_VALUE; 61 } 62 63 /* Store HAL object in record stream Object */ 64 mStreamRecord->setHALCameraControl(this); 65 66 /*Init Channel */ 67 ret = mStreamRecord->init(); 68 if (MM_CAMERA_OK != ret){ 69 ALOGE("%s: error - can't init Record channel!", __func__); 70 return BAD_VALUE; 71 } 72 ALOGV("%s : END",__func__); 73 return ret; 74 } 75 76 int32_t QCameraHardwareInterface::createSnapshot() 77 { 78 int32_t ret = MM_CAMERA_OK; 79 ALOGV("%s : BEGIN",__func__); 80 81 /* 82 * Creating Instance of Snapshot stream. 83 */ 84 ALOGV("Mymode Snap = %d",myMode); 85 mStreamSnap = QCameraStream_Snapshot::createInstance(mCameraId, 86 myMode); 87 if (!mStreamSnap) { 88 ALOGE("%s: error - can't creat snapshot stream!", __func__); 89 return BAD_VALUE; 90 } 91 92 /* Store HAL object in Snapshot stream Object */ 93 mStreamSnap->setHALCameraControl(this); 94 95 /*Init Channel */ 96 ret = mStreamSnap->init(); 97 if (MM_CAMERA_OK != ret){ 98 ALOGE("%s: error - can't init Snapshot channel!", __func__); 99 return BAD_VALUE; 100 } 101 ALOGV("%s : END",__func__); 102 return ret; 103 } 104 105 int32_t QCameraHardwareInterface::createPreview() 106 { 107 int32_t ret = MM_CAMERA_OK; 108 ALOGV("%s : BEGIN",__func__); 109 110 ALOGV("Mymode Preview = %d",myMode); 111 mStreamDisplay = QCameraStream_preview::createInstance(mCameraId, 112 myMode); 113 if (!mStreamDisplay) { 114 ALOGE("%s: error - can't creat preview stream!", __func__); 115 return BAD_VALUE; 116 } 117 118 mStreamDisplay->setHALCameraControl(this); 119 120 /*now init all the buffers and send to steam object*/ 121 ret = mStreamDisplay->init(); 122 if (MM_CAMERA_OK != ret){ 123 ALOGE("%s: error - can't init Preview channel!", __func__); 124 return BAD_VALUE; 125 } 126 ALOGV("%s : END",__func__); 127 return ret; 128 } 129 130 /* constructor */ 131 QCameraHardwareInterface:: 132 QCameraHardwareInterface(int cameraId, int mode) 133 : mCameraId(cameraId), 134 mParameters(), 135 mMsgEnabled(0), 136 mNotifyCb(0), 137 mDataCb(0), 138 mDataCbTimestamp(0), 139 mCallbackCookie(0), 140 //mPreviewHeap(0), 141 mStreamDisplay (NULL), mStreamRecord(NULL), mStreamSnap(NULL), 142 mFps(0), 143 mDebugFps(0), 144 mMaxZoom(0), 145 mCurrentZoom(0), 146 mSupportedPictureSizesCount(15), 147 mDumpFrmCnt(0), mDumpSkipCnt(0), 148 mPictureSizeCount(15), 149 mPreviewSizeCount(13), 150 mVideoSizeCount(0), 151 mAutoFocusRunning(false), 152 mNeedToUnlockCaf(false), 153 mHasAutoFocusSupport(false), 154 mInitialized(false), 155 mIs3DModeOn(0), 156 mSmoothZoomRunning(false), 157 mParamStringInitialized(false), 158 mFaceDetectOn(0), 159 mDisEnabled(0), 160 mZoomSupported(false), 161 mFullLiveshotEnabled(false), 162 mRecordingHint(false), 163 mAppRecordingHint(false), 164 mStatsOn(0), mCurrentHisto(-1), mSendData(false), mStatHeap(NULL), 165 mZslLookBackMode(0), 166 mZslLookBackValue(0), 167 mZslEmptyQueueFlag(false), 168 mPictureSizes(NULL), 169 mVideoSizes(NULL), 170 mCameraState(CAMERA_STATE_UNINITED), 171 mPostPreviewHeap(NULL), 172 mHdrMode(HDR_BRACKETING_OFF), 173 mStreamLiveSnap(NULL), 174 mExifTableNumEntries(0), 175 mDenoiseValue(0), 176 mSnapshotFormat(0), 177 mStartRecording(0), 178 mZslInterval(1), 179 mNoDisplayMode(0), 180 mBrightness(0), 181 mContrast(0), 182 mEffects(0), 183 mBestShotMode(0), 184 mHJR(0), 185 mSkinToneEnhancement(0), 186 mRotation(0), 187 mFocusMode(AF_MODE_MAX), 188 mPreviewFormat(CAMERA_YUV_420_NV21), 189 mRestartPreview(false), 190 mReleasedRecordingFrame(false), 191 mStateLiveshot(false), 192 isCameraOpen(false), 193 mPauseFramedispatch(false) 194 { 195 ALOGV("QCameraHardwareInterface: E"); 196 int32_t result = MM_CAMERA_E_GENERAL; 197 char value[PROPERTY_VALUE_MAX]; 198 199 pthread_mutex_init(&mAsyncCmdMutex, NULL); 200 pthread_cond_init(&mAsyncCmdWait, NULL); 201 mFlashCond = false; 202 203 property_get("persist.debug.sf.showfps", value, "0"); 204 mDebugFps = atoi(value); 205 mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED; 206 mPreviewWindow = NULL; 207 property_get("camera.hal.fps", value, "0"); 208 mFps = atoi(value); 209 210 ALOGV("Init mPreviewState = %d", mPreviewState); 211 212 property_get("persist.camera.hal.multitouchaf", value, "0"); 213 mMultiTouch = atoi(value); 214 215 property_get("persist.camera.full.liveshot", value, "0"); 216 mFullLiveshotEnabled = atoi(value); 217 218 property_get("persist.camera.hal.dis", value, "0"); 219 mDisEnabled = atoi(value); 220 221 /* Open camera stack! */ 222 result=cam_ops_open(mCameraId, MM_CAMERA_OP_MODE_NOTUSED); 223 if (result == MM_CAMERA_OK) { 224 int i; 225 mm_camera_event_type_t evt; 226 for (i = 0; i < MM_CAMERA_EVT_TYPE_MAX; i++) { 227 evt = (mm_camera_event_type_t) i; 228 if (cam_evt_is_event_supported(mCameraId, evt)){ 229 cam_evt_register_event_notify(mCameraId, 230 HAL_event_cb, (void *)this, evt); 231 } 232 } 233 } 234 ALOGV("Cam open returned %d",result); 235 if(MM_CAMERA_OK != result) { 236 ALOGE("startCamera: cam_ops_open failed: id = %d", mCameraId); 237 return; 238 } 239 240 loadTables(); 241 /* Setup Picture Size and Preview size tables */ 242 setPictureSizeTable(); 243 ALOGV("%s: Picture table size: %d", __func__, mPictureSizeCount); 244 ALOGV("%s: Picture table: ", __func__); 245 for(unsigned int i=0; i < mPictureSizeCount;i++) { 246 ALOGV(" %d %d", mPictureSizes[i].width, mPictureSizes[i].height); 247 } 248 249 setPreviewSizeTable(); 250 ALOGV("%s: Preview table size: %d", __func__, mPreviewSizeCount); 251 ALOGV("%s: Preview table: ", __func__); 252 for(unsigned int i=0; i < mPreviewSizeCount;i++) { 253 ALOGV(" %d %d", mPreviewSizes[i].width, mPreviewSizes[i].height); 254 } 255 256 setVideoSizeTable(); 257 ALOGV("%s: Video table size: %d", __func__, mVideoSizeCount); 258 ALOGV("%s: Video table: ", __func__); 259 for(unsigned int i=0; i < mVideoSizeCount;i++) { 260 ALOGV(" %d %d", mVideoSizes[i].width, mVideoSizes[i].height); 261 } 262 263 isCameraOpen = true; 264 /* set my mode - update myMode member variable due to difference in 265 enum definition between upper and lower layer*/ 266 setMyMode(mode); 267 initDefaultParameters(); 268 269 //Create Stream Objects 270 //Preview 271 result = createPreview(); 272 if(result != MM_CAMERA_OK) { 273 ALOGE("%s X: Failed to create Preview Object",__func__); 274 return; 275 } 276 277 //Record 278 result = createRecord(); 279 if(result != MM_CAMERA_OK) { 280 ALOGE("%s X: Failed to create Record Object",__func__); 281 return; 282 } 283 284 //Snapshot 285 result = createSnapshot(); 286 if(result != MM_CAMERA_OK) { 287 ALOGE("%s X: Failed to create Record Object",__func__); 288 return; 289 } 290 mCameraState = CAMERA_STATE_READY; 291 libdnr = dlopen("libmorpho_noise_reduction.so", RTLD_NOW); 292 if (libdnr) { 293 ALOGV("Open MM camera DL libmorpho_noise_reduction loaded at %p & %p ", libdnr); 294 *(void **)&LINK_morpho_DNR_ProcessFrame = dlsym(libdnr, "LINK_mm_camera_morpho_noise_reduction"); 295 } 296 else 297 ALOGE("failed to open libmorpho_noise_reduction"); 298 299 ALOGV("QCameraHardwareInterface: X"); 300 } 301 302 QCameraHardwareInterface::~QCameraHardwareInterface() 303 { 304 ALOGV("~QCameraHardwareInterface: E"); 305 int result; 306 307 switch(mPreviewState) { 308 case QCAMERA_HAL_PREVIEW_STOPPED: 309 break; 310 case QCAMERA_HAL_PREVIEW_START: 311 break; 312 case QCAMERA_HAL_PREVIEW_STARTED: 313 stopPreview(); 314 break; 315 case QCAMERA_HAL_RECORDING_STARTED: 316 stopRecordingInternal(); 317 stopPreview(); 318 break; 319 case QCAMERA_HAL_TAKE_PICTURE: 320 cancelPictureInternal(); 321 break; 322 default: 323 break; 324 } 325 mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED; 326 327 if (isCameraOpen) { 328 freePictureTable(); 329 freeVideoSizeTable(); 330 if(mStatHeap != NULL) { 331 mStatHeap.clear( ); 332 mStatHeap = NULL; 333 } 334 } 335 /* Join the threads, complete operations and then delete 336 the instances. */ 337 cam_ops_close(mCameraId); 338 if(mStreamDisplay){ 339 QCameraStream_preview::deleteInstance (mStreamDisplay); 340 mStreamDisplay = NULL; 341 } 342 if(mStreamRecord) { 343 QCameraStream_record::deleteInstance (mStreamRecord); 344 mStreamRecord = NULL; 345 } 346 if(mStreamSnap) { 347 QCameraStream_Snapshot::deleteInstance (mStreamSnap); 348 mStreamSnap = NULL; 349 } 350 if (libdnr != NULL) { 351 dlclose(libdnr); 352 libdnr = NULL; 353 ALOGV("closed libmorpho_noise_reduction.so"); 354 } 355 356 if (mStreamLiveSnap){ 357 QCameraStream_Snapshot::deleteInstance (mStreamLiveSnap); 358 mStreamLiveSnap = NULL; 359 } 360 361 pthread_mutex_destroy(&mAsyncCmdMutex); 362 pthread_cond_destroy(&mAsyncCmdWait); 363 isCameraOpen = false; 364 365 ALOGV("~QCameraHardwareInterface: X"); 366 } 367 368 bool QCameraHardwareInterface::isCameraReady() 369 { 370 ALOGV("isCameraReady mCameraState %d", mCameraState); 371 return (mCameraState == CAMERA_STATE_READY); 372 } 373 374 void QCameraHardwareInterface::release() 375 { 376 ALOGV("release: E"); 377 Mutex::Autolock l(&mLock); 378 379 switch(mPreviewState) { 380 case QCAMERA_HAL_PREVIEW_STOPPED: 381 break; 382 case QCAMERA_HAL_PREVIEW_START: 383 break; 384 case QCAMERA_HAL_PREVIEW_STARTED: 385 stopPreviewInternal(); 386 break; 387 case QCAMERA_HAL_RECORDING_STARTED: 388 stopRecordingInternal(); 389 stopPreviewInternal(); 390 break; 391 case QCAMERA_HAL_TAKE_PICTURE: 392 cancelPictureInternal(); 393 break; 394 default: 395 break; 396 } 397 #if 0 398 if (isRecordingRunning()) { 399 stopRecordingInternal(); 400 ALOGI("release: stopRecordingInternal done."); 401 } 402 if (isPreviewRunning()) { 403 stopPreview(); //stopPreviewInternal(); 404 ALOGI("release: stopPreviewInternal done."); 405 } 406 if (isSnapshotRunning()) { 407 cancelPictureInternal(); 408 ALOGI("release: cancelPictureInternal done."); 409 } 410 if (mCameraState == CAMERA_STATE_ERROR) { 411 //TBD: If Error occurs then tear down 412 ALOGI("release: Tear down."); 413 } 414 #endif 415 mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED; 416 ALOGV("release: X"); 417 } 418 419 void QCameraHardwareInterface::setCallbacks( 420 camera_notify_callback notify_cb, 421 camera_data_callback data_cb, 422 camera_data_timestamp_callback data_cb_timestamp, 423 camera_request_memory get_memory, 424 void *user) 425 { 426 ALOGV("setCallbacks: E"); 427 Mutex::Autolock lock(mLock); 428 mNotifyCb = notify_cb; 429 mDataCb = data_cb; 430 mDataCbTimestamp = data_cb_timestamp; 431 mGetMemory = get_memory; 432 mCallbackCookie = user; 433 ALOGV("setCallbacks: X"); 434 } 435 436 void QCameraHardwareInterface::enableMsgType(int32_t msgType) 437 { 438 ALOGV("enableMsgType: E, msgType =0x%x", msgType); 439 Mutex::Autolock lock(mLock); 440 mMsgEnabled |= msgType; 441 ALOGV("enableMsgType: X, msgType =0x%x, mMsgEnabled=0x%x", msgType, mMsgEnabled); 442 } 443 444 void QCameraHardwareInterface::disableMsgType(int32_t msgType) 445 { 446 ALOGV("disableMsgType: E"); 447 Mutex::Autolock lock(mLock); 448 mMsgEnabled &= ~msgType; 449 ALOGV("disableMsgType: X, msgType =0x%x, mMsgEnabled=0x%x", msgType, mMsgEnabled); 450 } 451 452 int QCameraHardwareInterface::msgTypeEnabled(int32_t msgType) 453 { 454 ALOGV("msgTypeEnabled: E"); 455 Mutex::Autolock lock(mLock); 456 return (mMsgEnabled & msgType); 457 ALOGV("msgTypeEnabled: X"); 458 } 459 #if 0 460 status_t QCameraHardwareInterface::dump(int fd, const Vector<String16>& args) const 461 { 462 ALOGI("dump: E"); 463 const size_t SIZE = 256; 464 char buffer[SIZE]; 465 String8 result; 466 AutoMutex lock(&mLock); 467 write(fd, result.string(), result.size()); 468 ALOGI("dump: E"); 469 return NO_ERROR; 470 } 471 #endif 472 473 int QCameraHardwareInterface::dump(int fd) 474 { 475 ALOGE("%s: not supported yet", __func__); 476 return -1; 477 } 478 479 status_t QCameraHardwareInterface::sendCommand(int32_t command, int32_t arg1, 480 int32_t arg2) 481 { 482 ALOGV("sendCommand: E"); 483 status_t rc = NO_ERROR; 484 Mutex::Autolock l(&mLock); 485 486 switch (command) { 487 case CAMERA_CMD_START_FACE_DETECTION: 488 if(supportsFaceDetection() == false){ 489 ALOGE("Face detection support is not available"); 490 return NO_ERROR; 491 } 492 setFaceDetection("on"); 493 return runFaceDetection(); 494 case CAMERA_CMD_STOP_FACE_DETECTION: 495 if(supportsFaceDetection() == false){ 496 ALOGE("Face detection support is not available"); 497 return NO_ERROR; 498 } 499 setFaceDetection("off"); 500 return runFaceDetection(); 501 502 #if 0 503 case CAMERA_CMD_HISTOGRAM_ON: 504 ALOGE("histogram set to on"); 505 rc = setHistogram(1); 506 break; 507 case CAMERA_CMD_HISTOGRAM_OFF: 508 ALOGE("histogram set to off"); 509 rc = setHistogram(0); 510 break; 511 case CAMERA_CMD_HISTOGRAM_SEND_DATA: 512 ALOGE("histogram send data"); 513 mSendData = true; 514 rc = NO_ERROR; 515 break; 516 case CAMERA_CMD_SEND_META_DATA: 517 mMetaDataWaitLock.lock(); 518 if(mFaceDetectOn == true) { 519 mSendMetaData = true; 520 } 521 mMetaDataWaitLock.unlock(); 522 return NO_ERROR; 523 #endif 524 #if 0 /* To Do: will enable it later */ 525 case CAMERA_CMD_START_SMOOTH_ZOOM : 526 ALOGV("HAL sendcmd start smooth zoom %d %d", arg1 , arg2); 527 /*TO DO: get MaxZoom from parameter*/ 528 int MaxZoom = 100; 529 530 switch(mCameraState ) { 531 case CAMERA_STATE_PREVIEW: 532 case CAMERA_STATE_RECORD_CMD_SENT: 533 case CAMERA_STATE_RECORD: 534 mTargetSmoothZoom = arg1; 535 mCurrentZoom = mParameters.getInt("zoom"); 536 mSmoothZoomStep = (mCurrentZoom > mTargetSmoothZoom)? -1: 1; 537 if(mCurrentZoom == mTargetSmoothZoom) { 538 ALOGV("Smoothzoom target zoom value is same as " 539 "current zoom value, return..."); 540 mNotifyCallback(CAMERA_MSG_ZOOM, 541 mCurrentZoom, 1, mCallbackCookie); 542 } else if(mCurrentZoom < 0 || mCurrentZoom > MaxZoom || 543 mTargetSmoothZoom < 0 || mTargetSmoothZoom > MaxZoom) { 544 ALOGE(" ERROR : beyond supported zoom values, break.."); 545 mNotifyCallback(CAMERA_MSG_ZOOM, 546 mCurrentZoom, 0, mCallbackCookie); 547 } else { 548 mSmoothZoomRunning = true; 549 mCurrentZoom += mSmoothZoomStep; 550 if ((mSmoothZoomStep < 0 && mCurrentZoom < mTargetSmoothZoom)|| 551 (mSmoothZoomStep > 0 && mCurrentZoom > mTargetSmoothZoom )) { 552 mCurrentZoom = mTargetSmoothZoom; 553 } 554 mParameters.set("zoom", mCurrentZoom); 555 setZoom(mParameters); 556 } 557 break; 558 default: 559 ALOGV(" No preview, no smoothzoom "); 560 break; 561 } 562 rc = NO_ERROR; 563 break; 564 565 case CAMERA_CMD_STOP_SMOOTH_ZOOM: 566 if(mSmoothZoomRunning) { 567 mSmoothZoomRunning = false; 568 /*To Do: send cmd to stop zooming*/ 569 } 570 ALOGV("HAL sendcmd stop smooth zoom"); 571 rc = NO_ERROR; 572 break; 573 #endif 574 default: 575 break; 576 } 577 ALOGV("sendCommand: X"); 578 return rc; 579 } 580 581 void QCameraHardwareInterface::setMyMode(int mode) 582 { 583 ALOGV("setMyMode: E"); 584 //if (mode & CAMERA_SUPPORT_MODE_3D) { 585 // myMode = CAMERA_MODE_3D; 586 //}else { 587 /* default mode is 2D */ 588 myMode = CAMERA_MODE_2D; 589 //} 590 591 //if (mode & CAMERA_SUPPORT_MODE_ZSL) { 592 // myMode = (camera_mode_t)(myMode |CAMERA_ZSL_MODE); 593 //}else { 594 myMode = (camera_mode_t) (myMode | CAMERA_NONZSL_MODE); 595 //} 596 ALOGV("setMyMode: Set mode to %d (passed mode: %d)", myMode, mode); 597 ALOGV("setMyMode: X"); 598 } 599 /* static factory function */ 600 QCameraHardwareInterface *QCameraHardwareInterface::createInstance(int cameraId, int mode) 601 { 602 ALOGV("createInstance: E"); 603 QCameraHardwareInterface *cam = new QCameraHardwareInterface(cameraId, mode); 604 if (cam ) { 605 if (cam->mCameraState != CAMERA_STATE_READY) { 606 ALOGE("createInstance: Failed"); 607 delete cam; 608 cam = NULL; 609 } 610 } 611 612 if (cam) { 613 //sp<CameraHardwareInterface> hardware(cam); 614 ALOGV("createInstance: X"); 615 return cam; 616 } else { 617 return NULL; 618 } 619 } 620 /* external plug in function */ 621 extern "C" void * 622 QCameraHAL_openCameraHardware(int cameraId, int mode) 623 { 624 ALOGV("QCameraHAL_openCameraHardware: E"); 625 return (void *) QCameraHardwareInterface::createInstance(cameraId, mode); 626 } 627 628 bool QCameraHardwareInterface::isPreviewRunning() { 629 ALOGV("isPreviewRunning: E"); 630 bool ret = false; 631 ALOGV("isPreviewRunning: camera state:%d", mCameraState); 632 633 if((mCameraState == CAMERA_STATE_PREVIEW) || 634 (mCameraState == CAMERA_STATE_PREVIEW_START_CMD_SENT) || 635 (mCameraState == CAMERA_STATE_RECORD) || 636 (mCameraState == CAMERA_STATE_RECORD_START_CMD_SENT) || 637 (mCameraState == CAMERA_STATE_ZSL) || 638 (mCameraState == CAMERA_STATE_ZSL_START_CMD_SENT)){ 639 return true; 640 } 641 ALOGV("isPreviewRunning: X"); 642 return ret; 643 } 644 645 bool QCameraHardwareInterface::isRecordingRunning() { 646 ALOGV("isRecordingRunning: E"); 647 bool ret = false; 648 if(QCAMERA_HAL_RECORDING_STARTED == mPreviewState) 649 ret = true; 650 //if((mCameraState == CAMERA_STATE_RECORD) || 651 // (mCameraState == CAMERA_STATE_RECORD_START_CMD_SENT)) { 652 // return true; 653 //} 654 ALOGV("isRecordingRunning: X"); 655 return ret; 656 } 657 658 bool QCameraHardwareInterface::isSnapshotRunning() { 659 ALOGV("isSnapshotRunning: E"); 660 bool ret = false; 661 //if((mCameraState == CAMERA_STATE_SNAP_CMD_ACKED) || 662 // (mCameraState == CAMERA_STATE_SNAP_START_CMD_SENT)) { 663 // return true; 664 //} 665 switch(mPreviewState) { 666 case QCAMERA_HAL_PREVIEW_STOPPED: 667 case QCAMERA_HAL_PREVIEW_START: 668 case QCAMERA_HAL_PREVIEW_STARTED: 669 case QCAMERA_HAL_RECORDING_STARTED: 670 default: 671 break; 672 case QCAMERA_HAL_TAKE_PICTURE: 673 ret = true; 674 break; 675 } 676 ALOGV("isSnapshotRunning: X"); 677 return ret; 678 } 679 680 bool QCameraHardwareInterface::isZSLMode() { 681 return (myMode & CAMERA_ZSL_MODE); 682 } 683 684 int QCameraHardwareInterface::getHDRMode() { 685 return mHdrMode; 686 } 687 688 void QCameraHardwareInterface::debugShowPreviewFPS() const 689 { 690 static int mFrameCount; 691 static int mLastFrameCount = 0; 692 static nsecs_t mLastFpsTime = 0; 693 static float mFps = 0; 694 mFrameCount++; 695 nsecs_t now = systemTime(); 696 nsecs_t diff = now - mLastFpsTime; 697 if (diff > ms2ns(250)) { 698 mFps = ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff; 699 ALOGV("Preview Frames Per Second: %.4f", mFps); 700 mLastFpsTime = now; 701 mLastFrameCount = mFrameCount; 702 } 703 } 704 705 void QCameraHardwareInterface:: 706 processPreviewChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *app_cb) { 707 ALOGV("processPreviewChannelEvent: E"); 708 switch(channelEvent) { 709 case MM_CAMERA_CH_EVT_STREAMING_ON: 710 mCameraState = 711 isZSLMode() ? CAMERA_STATE_ZSL : CAMERA_STATE_PREVIEW; 712 break; 713 case MM_CAMERA_CH_EVT_STREAMING_OFF: 714 mCameraState = CAMERA_STATE_READY; 715 break; 716 case MM_CAMERA_CH_EVT_DATA_DELIVERY_DONE: 717 break; 718 default: 719 break; 720 } 721 ALOGV("processPreviewChannelEvent: X"); 722 return; 723 } 724 725 void QCameraHardwareInterface::processRecordChannelEvent( 726 mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *app_cb) { 727 ALOGV("processRecordChannelEvent: E"); 728 switch(channelEvent) { 729 case MM_CAMERA_CH_EVT_STREAMING_ON: 730 mCameraState = CAMERA_STATE_RECORD; 731 break; 732 case MM_CAMERA_CH_EVT_STREAMING_OFF: 733 mCameraState = CAMERA_STATE_PREVIEW; 734 break; 735 case MM_CAMERA_CH_EVT_DATA_DELIVERY_DONE: 736 break; 737 default: 738 break; 739 } 740 ALOGV("processRecordChannelEvent: X"); 741 return; 742 } 743 744 void QCameraHardwareInterface:: 745 processSnapshotChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *app_cb) { 746 ALOGV("processSnapshotChannelEvent: E evt=%d state=%d", channelEvent, 747 mCameraState); 748 switch(channelEvent) { 749 case MM_CAMERA_CH_EVT_STREAMING_ON: 750 if (!mStateLiveshot) { 751 mCameraState = 752 isZSLMode() ? CAMERA_STATE_ZSL : CAMERA_STATE_SNAP_CMD_ACKED; 753 } 754 break; 755 case MM_CAMERA_CH_EVT_STREAMING_OFF: 756 if (!mStateLiveshot) { 757 mCameraState = CAMERA_STATE_READY; 758 } 759 break; 760 case MM_CAMERA_CH_EVT_DATA_DELIVERY_DONE: 761 break; 762 case MM_CAMERA_CH_EVT_DATA_REQUEST_MORE: 763 if (isZSLMode()) { 764 /* ZSL Mode: In ZSL Burst Mode, users may request for number of 765 snapshots larger than internal size of ZSL queue. So we'll need 766 process the remaining frames as they become available. 767 In such case, we'll get this event */ 768 if(NULL != mStreamSnap) 769 mStreamSnap->takePictureZSL(); 770 } 771 break; 772 default: 773 break; 774 } 775 ALOGV("processSnapshotChannelEvent: X"); 776 return; 777 } 778 779 void QCameraHardwareInterface::processChannelEvent( 780 mm_camera_ch_event_t *event, app_notify_cb_t *app_cb) 781 { 782 ALOGV("processChannelEvent: E"); 783 Mutex::Autolock lock(mLock); 784 switch(event->ch) { 785 case MM_CAMERA_CH_PREVIEW: 786 processPreviewChannelEvent(event->evt, app_cb); 787 break; 788 case MM_CAMERA_CH_VIDEO: 789 processRecordChannelEvent(event->evt, app_cb); 790 break; 791 case MM_CAMERA_CH_SNAPSHOT: 792 processSnapshotChannelEvent(event->evt, app_cb); 793 break; 794 default: 795 break; 796 } 797 ALOGV("processChannelEvent: X"); 798 return; 799 } 800 801 void QCameraHardwareInterface::processCtrlEvent(mm_camera_ctrl_event_t *event, app_notify_cb_t *app_cb) 802 { 803 ALOGV("processCtrlEvent: %d, E",event->evt); 804 Mutex::Autolock lock(mLock); 805 switch(event->evt) 806 { 807 case MM_CAMERA_CTRL_EVT_ZOOM_DONE: 808 zoomEvent(&event->status, app_cb); 809 break; 810 case MM_CAMERA_CTRL_EVT_AUTO_FOCUS_DONE: 811 autoFocusEvent(&event->status, app_cb); 812 break; 813 case MM_CAMERA_CTRL_EVT_AUTO_FOCUS_MOVE: 814 autoFocusMoveEvent(&event->status, app_cb); 815 break; 816 case MM_CAMERA_CTRL_EVT_PREP_SNAPSHOT: 817 break; 818 case MM_CAMERA_CTRL_EVT_WDN_DONE: 819 wdenoiseEvent(event->status, (void *)(event->cookie)); 820 break; 821 case MM_CAMERA_CTRL_EVT_HDR_DONE: 822 hdrEvent(event->status, (void *)(event->cookie)); 823 break; 824 case MM_CAMERA_CTRL_EVT_ERROR: 825 app_cb->notifyCb = mNotifyCb; 826 app_cb->argm_notify.msg_type = CAMERA_MSG_ERROR; 827 app_cb->argm_notify.ext1 = CAMERA_ERROR_UNKNOWN; 828 app_cb->argm_notify.cookie = mCallbackCookie; 829 break; 830 case MM_CAMERA_CTRL_EVT_SNAPSHOT_CONFIG_DONE: 831 ALOGV("%s: MM_CAMERA_CTRL_EVT_SNAPSHOT_CONFIG_DONE", __func__); 832 app_cb->notifyCb = mNotifyCb; 833 app_cb->argm_notify.msg_type = CAMERA_MSG_SHUTTER; 834 app_cb->argm_notify.ext1 = 0; 835 app_cb->argm_notify.ext2 = true; 836 app_cb->argm_notify.cookie = mCallbackCookie; 837 mShutterSoundPlayed = true; 838 default: 839 break; 840 } 841 ALOGV("processCtrlEvent: X"); 842 return; 843 } 844 845 void QCameraHardwareInterface::processStatsEvent( 846 mm_camera_stats_event_t *event, app_notify_cb_t *app_cb) 847 { 848 ALOGV("processStatsEvent: E"); 849 if (!isPreviewRunning( )) { 850 ALOGE("preview is not running"); 851 return; 852 } 853 854 switch (event->event_id) { 855 856 case MM_CAMERA_STATS_EVT_HISTO: 857 { 858 #if 0 859 ALOGE("HAL process Histo: mMsgEnabled=0x%x, mStatsOn=%d, mSendData=%d, mDataCb=%p ", 860 (mMsgEnabled & CAMERA_MSG_STATS_DATA), mStatsOn, mSendData, mDataCb); 861 int msgEnabled = mMsgEnabled; 862 /*get stats buffer based on index*/ 863 camera_preview_histogram_info* hist_info = 864 (camera_preview_histogram_info*) mHistServer.camera_memory[event->e.stats_histo.index]->data; 865 866 if(mStatsOn == QCAMERA_PARM_ENABLE && mSendData && 867 mDataCb && (msgEnabled & CAMERA_MSG_STATS_DATA) ) { 868 uint32_t *dest; 869 mSendData = false; 870 mCurrentHisto = (mCurrentHisto + 1) % 3; 871 // The first element of the array will contain the maximum hist value provided by driver. 872 *(uint32_t *)((unsigned int)(mStatsMapped[mCurrentHisto]->data)) = hist_info->max_value; 873 memcpy((uint32_t *)((unsigned int)mStatsMapped[mCurrentHisto]->data + sizeof(int32_t)), 874 (uint32_t *)hist_info->buffer,(sizeof(int32_t) * 256)); 875 876 app_cb->dataCb = mDataCb; 877 app_cb->argm_data_cb.msg_type = CAMERA_MSG_STATS_DATA; 878 app_cb->argm_data_cb.data = mStatsMapped[mCurrentHisto]; 879 app_cb->argm_data_cb.index = 0; 880 app_cb->argm_data_cb.metadata = NULL; 881 app_cb->argm_data_cb.cookie = mCallbackCookie; 882 } 883 #endif 884 break; 885 886 } 887 default: 888 break; 889 } 890 ALOGV("receiveCameraStats X"); 891 } 892 893 void QCameraHardwareInterface::processInfoEvent( 894 mm_camera_info_event_t *event, app_notify_cb_t *app_cb) { 895 ALOGV("processInfoEvent: %d, E",event->event_id); 896 //Mutex::Autolock lock(eventLock); 897 switch(event->event_id) 898 { 899 case MM_CAMERA_INFO_EVT_ROI: 900 roiEvent(event->e.roi, app_cb); 901 break; 902 default: 903 break; 904 } 905 ALOGV("processInfoEvent: X"); 906 return; 907 } 908 909 void QCameraHardwareInterface::processEvent(mm_camera_event_t *event) 910 { 911 app_notify_cb_t app_cb; 912 ALOGV("processEvent: type :%d E",event->event_type); 913 if(mPreviewState == QCAMERA_HAL_PREVIEW_STOPPED){ 914 ALOGV("Stop recording issued. Return from process Event"); 915 return; 916 } 917 memset(&app_cb, 0, sizeof(app_notify_cb_t)); 918 switch(event->event_type) 919 { 920 case MM_CAMERA_EVT_TYPE_CH: 921 processChannelEvent(&event->e.ch, &app_cb); 922 break; 923 case MM_CAMERA_EVT_TYPE_CTRL: 924 processCtrlEvent(&event->e.ctrl, &app_cb); 925 break; 926 case MM_CAMERA_EVT_TYPE_STATS: 927 processStatsEvent(&event->e.stats, &app_cb); 928 break; 929 case MM_CAMERA_EVT_TYPE_INFO: 930 processInfoEvent(&event->e.info, &app_cb); 931 break; 932 default: 933 break; 934 } 935 ALOGV(" App_cb Notify %p, datacb=%p", app_cb.notifyCb, app_cb.dataCb); 936 if (app_cb.notifyCb) { 937 app_cb.notifyCb(app_cb.argm_notify.msg_type, 938 app_cb.argm_notify.ext1, app_cb.argm_notify.ext2, 939 app_cb.argm_notify.cookie); 940 } 941 if (app_cb.dataCb) { 942 app_cb.dataCb(app_cb.argm_data_cb.msg_type, 943 app_cb.argm_data_cb.data, app_cb.argm_data_cb.index, 944 app_cb.argm_data_cb.metadata, app_cb.argm_data_cb.cookie); 945 } 946 ALOGV("processEvent: X"); 947 return; 948 } 949 950 bool QCameraHardwareInterface::preview_parm_config (cam_ctrl_dimension_t* dim, 951 QCameraParameters& parm) 952 { 953 ALOGV("preview_parm_config: E"); 954 bool matching = true; 955 int display_width = 0; /* width of display */ 956 int display_height = 0; /* height of display */ 957 uint16_t video_width = 0; /* width of the video */ 958 uint16_t video_height = 0; /* height of the video */ 959 960 /* First check if the preview resolution is the same, if not, change it*/ 961 parm.getPreviewSize(&display_width, &display_height); 962 if (display_width && display_height) { 963 matching = (display_width == dim->display_width) && 964 (display_height == dim->display_height); 965 966 if (!matching) { 967 dim->display_width = display_width; 968 dim->display_height = display_height; 969 } 970 } 971 else 972 matching = false; 973 974 cam_format_t value = getPreviewFormat(); 975 976 if(value != NOT_FOUND && value != dim->prev_format ) { 977 //Setting to Parameter requested by the Upper layer 978 dim->prev_format = value; 979 } else if (value == NOT_FOUND) { 980 //Setting to default Format. 981 dim->prev_format = CAMERA_YUV_420_NV21; 982 } 983 mPreviewFormat = dim->prev_format; 984 985 dim->prev_padding_format = getPreviewPadding( ); 986 987 dim->enc_format = CAMERA_YUV_420_NV12; 988 dim->orig_video_width = mDimension.orig_video_width; 989 dim->orig_video_height = mDimension.orig_video_height; 990 dim->video_width = mDimension.video_width; 991 dim->video_height = mDimension.video_height; 992 dim->video_chroma_width = mDimension.video_width; 993 dim->video_chroma_height = mDimension.video_height; 994 /* Reset the Main image and thumbnail formats here, 995 * since they might have been changed when video size 996 * livesnapshot was taken. */ 997 if (mSnapshotFormat == 1) 998 dim->main_img_format = CAMERA_YUV_422_NV61; 999 else 1000 dim->main_img_format = CAMERA_YUV_420_NV21; 1001 dim->thumb_format = CAMERA_YUV_420_NV21; 1002 ALOGV("preview_parm_config: X"); 1003 return matching; 1004 } 1005 1006 status_t QCameraHardwareInterface::startPreview() 1007 { 1008 status_t retVal = NO_ERROR; 1009 1010 ALOGV("%s: mPreviewState =%d", __func__, mPreviewState); 1011 Mutex::Autolock lock(mLock); 1012 1013 if(mPauseFramedispatch){ 1014 //In ZSL case after snapshot we need to restart 1015 //if stop preview not issued. 1016 stopPreviewInternal(); 1017 mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED; 1018 mPauseFramedispatch = false; 1019 } 1020 1021 switch(mPreviewState) { 1022 case QCAMERA_HAL_PREVIEW_STOPPED: 1023 case QCAMERA_HAL_TAKE_PICTURE: 1024 mPreviewState = QCAMERA_HAL_PREVIEW_START; 1025 ALOGV("%s: HAL::startPreview begin", __func__); 1026 1027 if(QCAMERA_HAL_PREVIEW_START == mPreviewState && 1028 (mPreviewWindow || isNoDisplayMode())) { 1029 ALOGD("%s: start preview now", __func__); 1030 retVal = startPreview2(); 1031 if(retVal == NO_ERROR) 1032 mPreviewState = QCAMERA_HAL_PREVIEW_STARTED; 1033 } else { 1034 ALOGV("%s: received startPreview, but preview window = null", __func__); 1035 } 1036 break; 1037 case QCAMERA_HAL_PREVIEW_START: 1038 case QCAMERA_HAL_PREVIEW_STARTED: 1039 break; 1040 case QCAMERA_HAL_RECORDING_STARTED: 1041 ALOGV("%s: cannot start preview in recording state", __func__); 1042 break; 1043 default: 1044 ALOGE("%s: unknow state %d received", __func__, mPreviewState); 1045 retVal = UNKNOWN_ERROR; 1046 break; 1047 } 1048 return retVal; 1049 } 1050 1051 status_t QCameraHardwareInterface::startPreview2() 1052 { 1053 ALOGV("startPreview2: E"); 1054 status_t ret = NO_ERROR; 1055 1056 cam_ctrl_dimension_t dim; 1057 mm_camera_dimension_t maxDim; 1058 bool initPreview = false; 1059 1060 mPauseFramedispatch = false; 1061 if (mPreviewState == QCAMERA_HAL_PREVIEW_STARTED) { //isPreviewRunning()){ 1062 ALOGE("%s:Preview already started mCameraState = %d!", __func__, mCameraState); 1063 ALOGV("%s: X", __func__); 1064 return NO_ERROR; 1065 } 1066 1067 const char *str = mParameters.get(QCameraParameters::KEY_SCENE_MODE); 1068 1069 if (mRecordingHint || mFlashCond || !strcmp(str, "hdr")) { 1070 ALOGI("%s:Setting non-ZSL mode",__func__); 1071 mParameters.set(QCameraParameters::KEY_CAMERA_MODE, 0); 1072 myMode = (camera_mode_t)(myMode & ~CAMERA_ZSL_MODE); 1073 mParameters.setPreviewFrameRateMode("frame-rate-auto"); 1074 setPreviewFrameRateMode(mParameters); 1075 } else { 1076 ALOGI("%s:Setting ZSL mode",__func__); 1077 mParameters.set(QCameraParameters::KEY_CAMERA_MODE, 1); 1078 myMode = (camera_mode_t)(myMode | CAMERA_ZSL_MODE); 1079 mParameters.setPreviewFrameRateMode("frame-rate-auto"); 1080 setPreviewFrameRateMode(mParameters); 1081 1082 } 1083 1084 /* get existing preview information, by qury mm_camera*/ 1085 memset(&dim, 0, sizeof(cam_ctrl_dimension_t)); 1086 ret = cam_config_get_parm(mCameraId, MM_CAMERA_PARM_DIMENSION,&dim); 1087 1088 if (MM_CAMERA_OK != ret) { 1089 ALOGE("%s: error - can't get preview dimension!", __func__); 1090 ALOGV("%s: X", __func__); 1091 return BAD_VALUE; 1092 } 1093 1094 /* config the parmeters and see if we need to re-init the stream*/ 1095 initPreview = preview_parm_config (&dim, mParameters); 1096 1097 if (mRecordingHint && mFullLiveshotEnabled) { 1098 #if 0 1099 /* Camcorder mode and Full resolution liveshot enabled 1100 * TBD lookup table for correct aspect ratio matching size */ 1101 memset(&maxDim, 0, sizeof(mm_camera_dimension_t)); 1102 getMaxPictureDimension(&maxDim); 1103 if (!maxDim.width || !maxDim.height) { 1104 maxDim.width = DEFAULT_LIVESHOT_WIDTH; 1105 maxDim.height = DEFAULT_LIVESHOT_HEIGHT; 1106 } 1107 /* TODO Remove this hack after adding code to get live shot dimension */ 1108 if (!mCameraId) { 1109 maxDim.width = DEFAULT_LIVESHOT_WIDTH; 1110 maxDim.height = DEFAULT_LIVESHOT_HEIGHT; 1111 } 1112 dim.picture_width = maxDim.width; 1113 dim.picture_height = maxDim.height; 1114 mParameters.setPictureSize(dim.picture_width, dim.picture_height); 1115 ALOGI("%s Setting Liveshot dimension as %d x %d", __func__, 1116 maxDim.width, maxDim.height); 1117 #endif 1118 int mPictureWidth, mPictureHeight; 1119 bool matching; 1120 /* First check if the picture resolution is the same, if not, change it*/ 1121 getPictureSize(&mPictureWidth, &mPictureHeight); 1122 1123 matching = (mPictureWidth == dim.picture_width) && 1124 (mPictureHeight == dim.picture_height); 1125 1126 if (!matching) { 1127 dim.picture_width = mPictureWidth; 1128 dim.picture_height = mPictureHeight; 1129 //For FullSize snapshot Main image Buffer is used as Thumanail. 1130 dim.ui_thumbnail_height = mPictureWidth; 1131 dim.ui_thumbnail_width = mPictureHeight; 1132 } 1133 ALOGI("%s: Fullsize Liveshaot Picture size to set: %d x %d", __func__, 1134 dim.picture_width, dim.picture_height); 1135 mParameters.setPictureSize(dim.picture_width, dim.picture_height); 1136 } 1137 1138 ret = cam_config_set_parm(mCameraId, MM_CAMERA_PARM_DIMENSION,&dim); 1139 if (MM_CAMERA_OK != ret) { 1140 ALOGE("%s X: error - can't config preview parms!", __func__); 1141 return BAD_VALUE; 1142 } 1143 1144 mStreamDisplay->setMode(myMode & CAMERA_ZSL_MODE); 1145 mStreamSnap->setMode(myMode & CAMERA_ZSL_MODE); 1146 mStreamRecord->setMode(myMode & CAMERA_ZSL_MODE); 1147 ALOGV("%s: myMode = %d", __func__, myMode); 1148 1149 ALOGV("%s: setPreviewWindow", __func__); 1150 mStreamDisplay->setPreviewWindow(mPreviewWindow); 1151 ret = cam_config_set_parm(mCameraId, MM_CAMERA_PARM_INFORM_STARTPRVIEW, NULL); 1152 if(ret<0) 1153 { 1154 ALOGE("%s: Failed to Check MM_CAMERA_PARM_INFORM_STARTPRVIEW, rc %d", __func__, ret); 1155 } 1156 1157 if(isZSLMode()) { 1158 /* Start preview streaming */ 1159 ret = mStreamDisplay->start(); 1160 if (MM_CAMERA_OK != ret){ 1161 ALOGE("%s: X -error - can't start nonZSL stream!", __func__); 1162 return BAD_VALUE; 1163 } 1164 1165 /* Start ZSL stream */ 1166 ret = mStreamSnap->start(); 1167 if (MM_CAMERA_OK != ret){ 1168 ALOGE("%s: error - can't start Snapshot stream!", __func__); 1169 mStreamDisplay->stop(); 1170 return BAD_VALUE; 1171 } 1172 }else{ 1173 ret = mStreamDisplay->start(); 1174 } 1175 1176 /*call QCameraStream_noneZSL::start() */ 1177 if (MM_CAMERA_OK != ret){ 1178 ALOGE("%s: X error - can't start stream!", __func__); 1179 return BAD_VALUE; 1180 } 1181 if(MM_CAMERA_OK == ret) 1182 mCameraState = CAMERA_STATE_PREVIEW_START_CMD_SENT; 1183 else 1184 mCameraState = CAMERA_STATE_ERROR; 1185 1186 if(mPostPreviewHeap != NULL) { 1187 mPostPreviewHeap.clear(); 1188 mPostPreviewHeap = NULL; 1189 } 1190 1191 mRestartPreview = false; 1192 1193 ALOGV("startPreview: X"); 1194 return ret; 1195 } 1196 1197 void QCameraHardwareInterface::stopPreview() 1198 { 1199 ALOGV("%s: stopPreview: E", __func__); 1200 Mutex::Autolock lock(mLock); 1201 mm_camera_util_profile("HAL: stopPreview(): E"); 1202 mFaceDetectOn = false; 1203 1204 // reset recording hint to the value passed from Apps 1205 const char * str = mParameters.get(QCameraParameters::KEY_RECORDING_HINT); 1206 if((str != NULL) && !strcmp(str, "true")){ 1207 mRecordingHint = true; 1208 } else { 1209 mRecordingHint = false; 1210 } 1211 1212 const char * str_fd = mParameters.get(QCameraParameters::KEY_FACE_DETECTION); 1213 if((str_fd != NULL) && !strcmp(str_fd, "on")){ 1214 if(supportsFaceDetection() == false){ 1215 ALOGE("Face detection support is not available"); 1216 } 1217 setFaceDetection("off"); 1218 runFaceDetection(); 1219 } 1220 1221 switch(mPreviewState) { 1222 case QCAMERA_HAL_PREVIEW_START: 1223 //mPreviewWindow = NULL; 1224 mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED; 1225 break; 1226 case QCAMERA_HAL_PREVIEW_STARTED: 1227 stopPreviewInternal(); 1228 mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED; 1229 break; 1230 case QCAMERA_HAL_RECORDING_STARTED: 1231 stopRecordingInternal(); 1232 stopPreviewInternal(); 1233 mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED; 1234 break; 1235 case QCAMERA_HAL_TAKE_PICTURE: 1236 cancelPictureInternal(); 1237 stopPreviewInternal(); 1238 mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED; 1239 break; 1240 case QCAMERA_HAL_PREVIEW_STOPPED: 1241 default: 1242 break; 1243 } 1244 ALOGV("stopPreview: X, mPreviewState = %d", mPreviewState); 1245 } 1246 1247 #if 0 //mzhu 1248 void QCameraHardwareInterface::stopPreviewZSL() 1249 { 1250 ALOGI("stopPreviewZSL: E"); 1251 1252 if(!mStreamDisplay || !mStreamSnap) { 1253 ALOGE("mStreamDisplay/mStreamSnap is null"); 1254 return; 1255 } 1256 ALOGI("stopPreview: X, mPreviewState = %d", mPreviewState); 1257 } 1258 #endif 1259 void QCameraHardwareInterface::stopPreviewInternal() 1260 { 1261 ALOGV("stopPreviewInternal: E"); 1262 status_t ret = NO_ERROR; 1263 1264 if(!mStreamDisplay) { 1265 ALOGE("mStreamDisplay is null"); 1266 return; 1267 } 1268 1269 if(isZSLMode()) { 1270 /* take care snapshot object for ZSL mode */ 1271 mStreamSnap->stop(); 1272 } 1273 mStreamDisplay->stop(); 1274 1275 mPauseFramedispatch = false; 1276 mCameraState = CAMERA_STATE_PREVIEW_STOP_CMD_SENT; 1277 ALOGV("stopPreviewInternal: X"); 1278 } 1279 1280 int QCameraHardwareInterface::previewEnabled() 1281 { 1282 ALOGV("previewEnabled: E"); 1283 Mutex::Autolock lock(mLock); 1284 ALOGV("%s: mCameraState = %d", __func__, mCameraState); 1285 if (mPauseFramedispatch) { 1286 return false; 1287 } 1288 switch(mPreviewState) { 1289 case QCAMERA_HAL_PREVIEW_STOPPED: 1290 case QCAMERA_HAL_TAKE_PICTURE: 1291 default: 1292 return false; 1293 break; 1294 case QCAMERA_HAL_PREVIEW_START: 1295 case QCAMERA_HAL_PREVIEW_STARTED: 1296 case QCAMERA_HAL_RECORDING_STARTED: 1297 return true; 1298 break; 1299 } 1300 return false; 1301 } 1302 1303 status_t QCameraHardwareInterface::startRecording() 1304 { 1305 ALOGV("startRecording: E"); 1306 status_t ret = NO_ERROR; 1307 Mutex::Autolock lock(mLock); 1308 1309 switch(mPreviewState) { 1310 case QCAMERA_HAL_PREVIEW_STOPPED: 1311 ALOGE("%s: preview has not been started", __func__); 1312 ret = UNKNOWN_ERROR; 1313 break; 1314 case QCAMERA_HAL_PREVIEW_START: 1315 ALOGE("%s: no preview native window", __func__); 1316 ret = UNKNOWN_ERROR; 1317 break; 1318 case QCAMERA_HAL_PREVIEW_STARTED: 1319 //remember recordinghint value set by app 1320 mAppRecordingHint = mRecordingHint; 1321 pausePreviewForVideo(); 1322 ret = mStreamRecord->start(); 1323 if (MM_CAMERA_OK != ret){ 1324 ALOGE("%s: error - mStreamRecord->start!", __func__); 1325 ret = BAD_VALUE; 1326 break; 1327 } 1328 if(MM_CAMERA_OK == ret) 1329 mCameraState = CAMERA_STATE_RECORD_START_CMD_SENT; 1330 else 1331 mCameraState = CAMERA_STATE_ERROR; 1332 mPreviewState = QCAMERA_HAL_RECORDING_STARTED; 1333 break; 1334 case QCAMERA_HAL_RECORDING_STARTED: 1335 ALOGV("%s: ", __func__); 1336 break; 1337 case QCAMERA_HAL_TAKE_PICTURE: 1338 default: 1339 ret = BAD_VALUE; 1340 break; 1341 } 1342 ALOGV("startRecording: X"); 1343 return ret; 1344 } 1345 1346 void QCameraHardwareInterface::stopRecording() 1347 { 1348 ALOGV("stopRecording: E"); 1349 Mutex::Autolock lock(mLock); 1350 switch(mPreviewState) { 1351 case QCAMERA_HAL_PREVIEW_STOPPED: 1352 case QCAMERA_HAL_PREVIEW_START: 1353 case QCAMERA_HAL_PREVIEW_STARTED: 1354 break; 1355 case QCAMERA_HAL_RECORDING_STARTED: 1356 mRecordingHint = mAppRecordingHint; 1357 stopRecordingInternal(); 1358 mPreviewState = QCAMERA_HAL_PREVIEW_STARTED; 1359 break; 1360 case QCAMERA_HAL_TAKE_PICTURE: 1361 default: 1362 break; 1363 } 1364 ALOGV("stopRecording: X"); 1365 1366 } 1367 void QCameraHardwareInterface::stopRecordingInternal() 1368 { 1369 ALOGV("stopRecordingInternal: E"); 1370 status_t ret = NO_ERROR; 1371 1372 if(!mStreamRecord) { 1373 ALOGE("mStreamRecord is null"); 1374 return; 1375 } 1376 1377 if(mStateLiveshot && mStreamLiveSnap != NULL) { 1378 mStreamLiveSnap->stop(); 1379 mStateLiveshot = false; 1380 } 1381 /* 1382 * call QCameraStream_record::stop() 1383 * Unregister Callback, action stop 1384 */ 1385 mStreamRecord->stop(); 1386 mCameraState = CAMERA_STATE_PREVIEW; //TODO : Apurva : Hacked for 2nd time Recording 1387 mPreviewState = QCAMERA_HAL_PREVIEW_STARTED; 1388 ALOGV("stopRecordingInternal: X"); 1389 return; 1390 } 1391 1392 int QCameraHardwareInterface::recordingEnabled() 1393 { 1394 int ret = 0; 1395 Mutex::Autolock lock(mLock); 1396 ALOGV("%s: E", __func__); 1397 switch(mPreviewState) { 1398 case QCAMERA_HAL_PREVIEW_STOPPED: 1399 case QCAMERA_HAL_PREVIEW_START: 1400 case QCAMERA_HAL_PREVIEW_STARTED: 1401 break; 1402 case QCAMERA_HAL_RECORDING_STARTED: 1403 ret = 1; 1404 break; 1405 case QCAMERA_HAL_TAKE_PICTURE: 1406 default: 1407 break; 1408 } 1409 ALOGV("%s: X, ret = %d", __func__, ret); 1410 return ret; //isRecordingRunning(); 1411 } 1412 1413 /** 1414 * Release a record frame previously returned by CAMERA_MSG_VIDEO_FRAME. 1415 */ 1416 void QCameraHardwareInterface::releaseRecordingFrame(const void *opaque) 1417 { 1418 ALOGV("%s : BEGIN",__func__); 1419 if(mStreamRecord == NULL) { 1420 ALOGE("Record stream Not Initialized"); 1421 return; 1422 } 1423 mStreamRecord->releaseRecordingFrame(opaque); 1424 ALOGV("%s : END",__func__); 1425 return; 1426 } 1427 1428 status_t QCameraHardwareInterface::autoFocusMoveEvent(cam_ctrl_status_t *status, app_notify_cb_t *app_cb) 1429 { 1430 ALOGV("autoFocusMoveEvent: E"); 1431 int ret = NO_ERROR; 1432 1433 isp3a_af_mode_t afMode = getAutoFocusMode(mParameters); 1434 1435 if (afMode == AF_MODE_CAF && mNotifyCb && ( mMsgEnabled & CAMERA_MSG_FOCUS_MOVE)){ 1436 ALOGV("%s:Issuing AF Move callback to service",__func__); 1437 1438 app_cb->notifyCb = mNotifyCb; 1439 app_cb->argm_notify.msg_type = CAMERA_MSG_FOCUS_MOVE; 1440 app_cb->argm_notify.ext2 = 0; 1441 app_cb->argm_notify.cookie = mCallbackCookie; 1442 1443 ALOGV("Auto focus state =%d", *status); 1444 if(*status == 1) { 1445 app_cb->argm_notify.ext1 = true; 1446 }else if(*status == 0){ 1447 app_cb->argm_notify.ext1 = false; 1448 }else{ 1449 app_cb->notifyCb = NULL; 1450 ALOGE("%s:Unknown AF Move Status received (%d) received",__func__,*status); 1451 } 1452 } 1453 ALOGV("autoFocusMoveEvent: X"); 1454 return ret; 1455 } 1456 1457 status_t QCameraHardwareInterface::autoFocusEvent(cam_ctrl_status_t *status, app_notify_cb_t *app_cb) 1458 { 1459 ALOGV("autoFocusEvent: E"); 1460 int ret = NO_ERROR; 1461 /************************************************************ 1462 BEGIN MUTEX CODE 1463 *************************************************************/ 1464 1465 ALOGV("%s:%d: Trying to acquire AF bit lock",__func__,__LINE__); 1466 mAutofocusLock.lock(); 1467 ALOGV("%s:%d: Acquired AF bit lock",__func__,__LINE__); 1468 1469 if(mAutoFocusRunning==false) { 1470 ALOGV("%s:AF not running, discarding stale event",__func__); 1471 mAutofocusLock.unlock(); 1472 return ret; 1473 } 1474 /* If autofocus call has been made during CAF, CAF will be locked. 1475 * We specifically need to call cancelAutoFocus to unlock CAF. 1476 * In that sense, AF is still running.*/ 1477 isp3a_af_mode_t afMode = getAutoFocusMode(mParameters); 1478 if (afMode == AF_MODE_CAF) 1479 mNeedToUnlockCaf = true; 1480 mAutoFocusRunning = false; 1481 mAutofocusLock.unlock(); 1482 1483 /************************************************************ 1484 END MUTEX CODE 1485 *************************************************************/ 1486 if(status==NULL) { 1487 ALOGE("%s:NULL ptr received for status",__func__); 1488 return BAD_VALUE; 1489 } 1490 1491 /* update focus distances after autofocus is done */ 1492 if((*status != CAM_CTRL_FAILED) && updateFocusDistances() != NO_ERROR) { 1493 ALOGE("%s: updateFocusDistances failed for %d", __FUNCTION__, mFocusMode); 1494 } 1495 1496 /*(Do?) we need to make sure that the call back is the 1497 last possible step in the execution flow since the same 1498 context might be used if a fail triggers another round 1499 of AF then the mAutoFocusRunning flag and other state 1500 variables' validity will be under question*/ 1501 1502 if (mNotifyCb && ( mMsgEnabled & CAMERA_MSG_FOCUS)){ 1503 ALOGV("%s:Issuing AF callback to service",__func__); 1504 1505 /* "Accepted" status is not appropriate it should be used for 1506 initial cmd, event reporting should only give use SUCCESS/FAIL 1507 */ 1508 1509 app_cb->notifyCb = mNotifyCb; 1510 app_cb->argm_notify.msg_type = CAMERA_MSG_FOCUS; 1511 app_cb->argm_notify.ext2 = 0; 1512 app_cb->argm_notify.cookie = mCallbackCookie; 1513 1514 ALOGV("Auto focus state =%d", *status); 1515 if(*status==CAM_CTRL_SUCCESS) { 1516 app_cb->argm_notify.ext1 = true; 1517 } 1518 else if(*status==CAM_CTRL_FAILED){ 1519 app_cb->argm_notify.ext1 = false; 1520 } 1521 else{ 1522 app_cb->notifyCb = NULL; 1523 ALOGE("%s:Unknown AF status (%d) received",__func__,*status); 1524 } 1525 1526 }/*(mNotifyCb && ( mMsgEnabled & CAMERA_MSG_FOCUS))*/ 1527 else{ 1528 ALOGE("%s:Call back not enabled",__func__); 1529 } 1530 1531 ALOGV("autoFocusEvent: X"); 1532 return ret; 1533 1534 } 1535 1536 status_t QCameraHardwareInterface::cancelPicture() 1537 { 1538 ALOGV("cancelPicture: E"); 1539 status_t ret = MM_CAMERA_OK; 1540 Mutex::Autolock lock(mLock); 1541 1542 switch(mPreviewState) { 1543 case QCAMERA_HAL_PREVIEW_STOPPED: 1544 case QCAMERA_HAL_PREVIEW_START: 1545 case QCAMERA_HAL_PREVIEW_STARTED: 1546 break; 1547 case QCAMERA_HAL_RECORDING_STARTED: 1548 if(mStateLiveshot && (mStreamLiveSnap != NULL)) { 1549 mStreamLiveSnap->stop(); 1550 mStateLiveshot = false; 1551 } 1552 break; 1553 case QCAMERA_HAL_TAKE_PICTURE: 1554 ret = cancelPictureInternal(); 1555 break; 1556 default: 1557 break; 1558 } 1559 ALOGV("cancelPicture: X"); 1560 return ret; 1561 } 1562 1563 status_t QCameraHardwareInterface::cancelPictureInternal() 1564 { 1565 ALOGV("cancelPictureInternal: E"); 1566 status_t ret = MM_CAMERA_OK; 1567 if(mCameraState != CAMERA_STATE_READY) { 1568 if(mStreamSnap) { 1569 mStreamSnap->stop(); 1570 mCameraState = CAMERA_STATE_SNAP_STOP_CMD_SENT; 1571 } 1572 } else { 1573 ALOGE("%s: Cannot process cancel picture as snapshot is already done",__func__); 1574 } 1575 ALOGV("cancelPictureInternal: X"); 1576 return ret; 1577 } 1578 1579 void QCameraHardwareInterface::pausePreviewForSnapshot() 1580 { 1581 stopPreviewInternal( ); 1582 } 1583 status_t QCameraHardwareInterface::resumePreviewAfterSnapshot() 1584 { 1585 status_t ret = NO_ERROR; 1586 ret = mStreamDisplay->start(); 1587 return ret; 1588 } 1589 1590 void liveshot_callback(mm_camera_ch_data_buf_t *recvd_frame, 1591 void *user_data) 1592 { 1593 QCameraHardwareInterface *pme = (QCameraHardwareInterface *)user_data; 1594 cam_ctrl_dimension_t dim; 1595 int mJpegMaxSize; 1596 int mNuberOfVFEOutputs = 0; 1597 status_t ret; 1598 ALOGV("%s: E", __func__); 1599 1600 if (!pme->mStateLiveshot) { 1601 ALOGE("%s: Returning Buffer. Picture Cancelled", __func__); 1602 return; 1603 } 1604 1605 ALOGV("Live Snapshot Enabled"); 1606 if (pme->mStreamLiveSnap){ 1607 ALOGE("%s:Deleting old Snapshot stream instance",__func__); 1608 QCameraStream_Snapshot::deleteInstance (pme->mStreamLiveSnap); 1609 pme->mStreamLiveSnap = NULL; 1610 } 1611 1612 pme->mStreamLiveSnap = (QCameraStream_Snapshot*)QCameraStream_Snapshot::createInstance(pme->mCameraId, 1613 pme->myMode); 1614 1615 if (!pme->mStreamLiveSnap) { 1616 ALOGE("%s: error - can't creat snapshot stream!", __func__); 1617 cam_evt_buf_done(pme->mCameraId, recvd_frame); 1618 return ; 1619 } 1620 pme->mStreamLiveSnap->setModeLiveSnapshot(true); 1621 pme->mStreamLiveSnap->setHALCameraControl(pme); 1622 1623 ret = ((QCameraStream_Snapshot*)(pme->mStreamLiveSnap))->takePictureLiveshot(recvd_frame); 1624 if (MM_CAMERA_OK != ret) { 1625 ALOGE("%s: Error : returned from takePictureLiveshot",__func__); 1626 return; 1627 } 1628 pme->setCAFLockCancel(); 1629 ALOGV("%s: X", __func__); 1630 1631 } 1632 1633 status_t QCameraHardwareInterface::takePicture() 1634 { 1635 ALOGV("takePicture: E"); 1636 status_t ret = MM_CAMERA_OK; 1637 int mNuberOfVFEOutputs = 0; 1638 Mutex::Autolock lock(mLock); 1639 bool hdr; 1640 int frm_num = 1, rc = 0; 1641 int exp[MAX_HDR_EXP_FRAME_NUM]; 1642 1643 if(QCAMERA_HAL_RECORDING_STARTED != mPreviewState){ 1644 isp3a_af_mode_t afMode = getAutoFocusMode(mParameters); 1645 if (!mFlashCond) 1646 { 1647 mFlashCond = getFlashCondition(); 1648 } 1649 ALOGV("%s: Flash Contidion %d", __func__, mFlashCond); 1650 if(mFlashCond) { 1651 mRestartPreview = true; 1652 pausePreviewForZSL(); 1653 } 1654 mFlashCond = false; 1655 } 1656 1657 rc = cam_config_set_parm(mCameraId, MM_CAMERA_PARM_LG_CAF_LOCK, NULL); 1658 if(rc<0) 1659 { 1660 ALOGE("%s: Failed to Check MM_CAMERA_PARM_LG_CAF_LOCK, rc %d", __func__, rc); 1661 } 1662 hdr = getHdrInfoAndSetExp(MAX_HDR_EXP_FRAME_NUM, &frm_num, exp); 1663 mStreamSnap->resetSnapshotCounters(); 1664 mStreamSnap->InitHdrInfoForSnapshot(hdr, frm_num, exp); 1665 switch(mPreviewState) { 1666 case QCAMERA_HAL_PREVIEW_STARTED: 1667 //set the fullsize liveshot to false 1668 mFullLiveshotEnabled = false; 1669 setFullLiveshot(); 1670 mStreamSnap->setFullSizeLiveshot(false); 1671 if (isZSLMode()) { 1672 if (mStreamSnap != NULL) { 1673 pausePreviewForZSL(); 1674 ret = mStreamSnap->takePictureZSL(); 1675 if (ret != MM_CAMERA_OK) { 1676 ALOGE("%s: Error taking ZSL snapshot!", __func__); 1677 ret = BAD_VALUE; 1678 } 1679 } 1680 else { 1681 ALOGE("%s: ZSL stream not active! Failure!!", __func__); 1682 ret = BAD_VALUE; 1683 } 1684 return ret; 1685 } 1686 /*prepare snapshot, e.g LED*/ 1687 takePicturePrepareHardware( ); 1688 /* There's an issue where we have a glimpse of corrupted data between 1689 a time we stop a preview and display the postview. It happens because 1690 when we call stopPreview we deallocate the preview buffers hence overlay 1691 displays garbage value till we enqueue postview buffer to be displayed. 1692 Hence for temporary fix, we'll do memcopy of the last frame displayed and 1693 queue it to overlay*/ 1694 // mzhu storePreviewFrameForPostview(); 1695 1696 /* stop preview */ 1697 pausePreviewForSnapshot(); 1698 1699 /* call Snapshot start() :*/ 1700 ret = mStreamSnap->start(); 1701 if (MM_CAMERA_OK != ret){ 1702 /* mzhu: fix me, restore preview */ 1703 ALOGE("%s: error - can't start Snapshot stream!", __func__); 1704 return BAD_VALUE; 1705 } 1706 1707 if(MM_CAMERA_OK == ret) 1708 mCameraState = CAMERA_STATE_SNAP_START_CMD_SENT; 1709 else 1710 mCameraState = CAMERA_STATE_ERROR; 1711 mPreviewState = QCAMERA_HAL_TAKE_PICTURE; 1712 break; 1713 case QCAMERA_HAL_TAKE_PICTURE: 1714 break; 1715 case QCAMERA_HAL_PREVIEW_STOPPED: 1716 case QCAMERA_HAL_PREVIEW_START: 1717 ret = UNKNOWN_ERROR; 1718 break; 1719 case QCAMERA_HAL_RECORDING_STARTED: 1720 if(mStateLiveshot) { 1721 ALOGE("takePicture : Duplicate TakePicture Call"); 1722 return ret; 1723 } 1724 if (canTakeFullSizeLiveshot()) { 1725 ALOGV(" Calling takeFullSizeLiveshot"); 1726 takeFullSizeLiveshot(); 1727 }else{ 1728 ret = cam_config_get_parm(mCameraId, MM_CAMERA_PARM_VFE_OUTPUT_ENABLE, 1729 &mNuberOfVFEOutputs); 1730 if (ret != MM_CAMERA_OK) { 1731 ALOGE("get parm MM_CAMERA_PARM_VFE_OUTPUT_ENABLE failed"); 1732 ret = BAD_VALUE; 1733 } 1734 if (mNuberOfVFEOutputs == 1){ 1735 (void) cam_evt_register_buf_notify(mCameraId, MM_CAMERA_CH_PREVIEW, 1736 liveshot_callback, 1737 MM_CAMERA_REG_BUF_CB_COUNT, 1738 1, 1739 this); 1740 } else { 1741 (void) cam_evt_register_buf_notify(mCameraId, MM_CAMERA_CH_VIDEO, 1742 liveshot_callback, 1743 MM_CAMERA_REG_BUF_CB_COUNT, 1744 1, 1745 this); 1746 } 1747 } 1748 mStateLiveshot = true; 1749 break; 1750 default: 1751 ret = UNKNOWN_ERROR; 1752 break; 1753 } 1754 ALOGV("takePicture: X"); 1755 return ret; 1756 } 1757 1758 bool QCameraHardwareInterface::canTakeFullSizeLiveshot() { 1759 bool ret; 1760 if (mFullLiveshotEnabled && !isLowPowerCamcorder()) { 1761 /* Full size liveshot enabled. */ 1762 1763 /* If Picture size is same as video size, switch to Video size 1764 * live snapshot */ 1765 if ((mDimension.picture_width == mVideoWidth) && 1766 (mDimension.picture_height == mVideoHeight)) { 1767 return false; 1768 } 1769 1770 if (mDisEnabled) { 1771 /* If DIS is enabled and Picture size is 1772 * less than (video size + 10% DIS Margin) 1773 * then fall back to Video size liveshot. */ 1774 if ((mDimension.picture_width < 1775 (int)(mVideoWidth * 1.1)) || 1776 (mDimension.picture_height < 1777 (int)(mVideoHeight * 1.1))) { 1778 ret = false; 1779 } else { 1780 /* Go with Full size live snapshot. */ 1781 ret = true; 1782 } 1783 } else { 1784 /* DIS Disabled. Go with Full size live snapshot */ 1785 ret = true; 1786 } 1787 } else { 1788 /* Full size liveshot disabled. Fallback to Video size liveshot. */ 1789 ret = false; 1790 } 1791 1792 return ret; 1793 } 1794 1795 status_t QCameraHardwareInterface::takeFullSizeLiveshot() 1796 { 1797 status_t ret = NO_ERROR; 1798 if (mStreamLiveSnap){ 1799 ALOGV("%s:Deleting old Snapshot stream instance",__func__); 1800 QCameraStream_Snapshot::deleteInstance (mStreamLiveSnap); 1801 mStreamLiveSnap = NULL; 1802 } 1803 mStreamLiveSnap = QCameraStream_Snapshot::createInstance(mCameraId, myMode); 1804 1805 if (!mStreamLiveSnap) { 1806 ALOGE("%s: error - can't creat snapshot stream!", __func__); 1807 /* mzhu: fix me, restore preview */ 1808 return BAD_VALUE; 1809 } 1810 1811 /* Store HAL object in snapshot stream Object */ 1812 mStreamLiveSnap->setHALCameraControl(this); 1813 1814 mStreamLiveSnap->setFullSizeLiveshot(true); 1815 1816 /* Call snapshot init*/ 1817 ret = mStreamLiveSnap->init(); 1818 if (MM_CAMERA_OK != ret){ 1819 ALOGE("%s: error - can't init Snapshot stream!", __func__); 1820 return BAD_VALUE; 1821 } 1822 1823 /* call Snapshot start() :*/ 1824 mStreamLiveSnap->resetSnapshotCounters( ); 1825 ret = mStreamLiveSnap->start(); 1826 if (MM_CAMERA_OK != ret){ 1827 /* mzhu: fix me, restore preview */ 1828 ALOGE("%s: error - can't start Snapshot stream!", __func__); 1829 return BAD_VALUE; 1830 } 1831 return ret; 1832 } 1833 1834 status_t QCameraHardwareInterface::takeLiveSnapshot() 1835 { 1836 status_t ret = NO_ERROR; 1837 ALOGV("takeLiveSnapshot: E"); 1838 mStreamRecord->takeLiveSnapshot(); 1839 ALOGV("takeLiveSnapshot: X"); 1840 return ret; 1841 } 1842 1843 status_t QCameraHardwareInterface::autoFocus() 1844 { 1845 ALOGV("autoFocus: E"); 1846 status_t ret = NO_ERROR; 1847 mFlashCond = getFlashCondition(); 1848 ALOGV("autoFocus: mFlashCond = %d", mFlashCond); 1849 Mutex::Autolock lock(mLock); 1850 ALOGV("autoFocus: Got lock"); 1851 bool status = true; 1852 isp3a_af_mode_t afMode = getAutoFocusMode(mParameters); 1853 1854 if(mAutoFocusRunning==true){ 1855 ALOGV("%s:AF already running should not have got this call",__func__); 1856 return NO_ERROR; 1857 } 1858 1859 if (afMode == AF_MODE_MAX) { 1860 /* This should never happen. We cannot send a 1861 * callback notifying error from this place because 1862 * the CameraService has called this function after 1863 * acquiring the lock. So if we try to issue a callback 1864 * from this place, the callback will try to acquire 1865 * the same lock in CameraService and it will result 1866 * in deadlock. So, let the call go in to the lower 1867 * layer. The lower layer will anyway return error if 1868 * the autofocus is not supported or if the focus 1869 * value is invalid. 1870 * Just print out the error. */ 1871 ALOGE("%s:Invalid AF mode (%d)", __func__, afMode); 1872 } 1873 1874 ALOGV("%s:AF start (mode %d)", __func__, afMode); 1875 if(MM_CAMERA_OK != cam_ops_action(mCameraId, true, 1876 MM_CAMERA_OPS_FOCUS, &afMode)) { 1877 ALOGE("%s: AF command failed err:%d error %s", 1878 __func__, errno, strerror(errno)); 1879 return UNKNOWN_ERROR; 1880 } 1881 1882 mAutoFocusRunning = true; 1883 ALOGV("autoFocus: X"); 1884 return ret; 1885 } 1886 1887 status_t QCameraHardwareInterface::cancelAutoFocus() 1888 { 1889 ALOGV("cancelAutoFocus: E"); 1890 status_t ret = NO_ERROR; 1891 Mutex::Autolock lock(mLock); 1892 1893 /************************************************************** 1894 BEGIN MUTEX CODE 1895 *************************************************************/ 1896 1897 mAutofocusLock.lock(); 1898 if(mAutoFocusRunning || mNeedToUnlockCaf) { 1899 mNeedToUnlockCaf = false; 1900 mAutoFocusRunning = false; 1901 mAutofocusLock.unlock(); 1902 1903 }else/*(!mAutoFocusRunning)*/{ 1904 1905 mAutofocusLock.unlock(); 1906 ALOGV("%s:Af not running",__func__); 1907 return NO_ERROR; 1908 } 1909 /************************************************************** 1910 END MUTEX CODE 1911 *************************************************************/ 1912 1913 1914 if(MM_CAMERA_OK!=cam_ops_action(mCameraId,false,MM_CAMERA_OPS_FOCUS,NULL )) { 1915 ALOGE("%s: AF command failed err:%d error %s",__func__, errno,strerror(errno)); 1916 } 1917 1918 ALOGV("cancelAutoFocus: X"); 1919 return NO_ERROR; 1920 } 1921 1922 #if 0 //mzhu 1923 /*========================================================================== 1924 * FUNCTION - prepareSnapshotAndWait - 1925 * 1926 * DESCRIPTION: invoke preparesnapshot and wait for it done 1927 it can be called within takepicture, so no need 1928 to grab mLock. 1929 *=========================================================================*/ 1930 void QCameraHardwareInterface::prepareSnapshotAndWait() 1931 { 1932 ALOGI("prepareSnapshotAndWait: E"); 1933 int rc = 0; 1934 /*To Do: call mm camera preparesnapshot */ 1935 if(!rc ) { 1936 mPreparingSnapshot = true; 1937 pthread_mutex_lock(&mAsyncCmdMutex); 1938 pthread_cond_wait(&mAsyncCmdWait, &mAsyncCmdMutex); 1939 pthread_mutex_unlock(&mAsyncCmdMutex); 1940 mPreparingSnapshot = false; 1941 } 1942 ALOGI("prepareSnapshotAndWait: X"); 1943 } 1944 #endif //mzhu 1945 1946 /*========================================================================== 1947 * FUNCTION - processprepareSnapshotEvent - 1948 * 1949 * DESCRIPTION: Process the event of preparesnapshot done msg 1950 unblock prepareSnapshotAndWait( ) 1951 *=========================================================================*/ 1952 void QCameraHardwareInterface::processprepareSnapshotEvent(cam_ctrl_status_t *status) 1953 { 1954 ALOGV("processprepareSnapshotEvent: E"); 1955 pthread_mutex_lock(&mAsyncCmdMutex); 1956 pthread_cond_signal(&mAsyncCmdWait); 1957 pthread_mutex_unlock(&mAsyncCmdMutex); 1958 ALOGV("processprepareSnapshotEvent: X"); 1959 } 1960 1961 void QCameraHardwareInterface::roiEvent(fd_roi_t roi,app_notify_cb_t *app_cb) 1962 { 1963 ALOGV("roiEvent: E"); 1964 1965 if(mStreamDisplay) mStreamDisplay->notifyROIEvent(roi); 1966 #if 0 //TODO: move to preview obj 1967 mCallbackLock.lock(); 1968 data_callback mcb = mDataCb; 1969 void *mdata = mCallbackCookie; 1970 int msgEnabled = mMsgEnabled; 1971 mCallbackLock.unlock(); 1972 1973 mMetaDataWaitLock.lock(); 1974 if (mFaceDetectOn == true && mSendMetaData == true) { 1975 mSendMetaData = false; 1976 int faces_detected = roi.rect_num; 1977 int max_faces_detected = MAX_ROI * 4; 1978 int array[max_faces_detected + 1]; 1979 1980 array[0] = faces_detected * 4; 1981 for (int i = 1, j = 0;j < MAX_ROI; j++, i = i + 4) { 1982 if (j < faces_detected) { 1983 array[i] = roi.faces[j].x; 1984 array[i+1] = roi.faces[j].y; 1985 array[i+2] = roi.faces[j].dx; 1986 array[i+3] = roi.faces[j].dy; 1987 } else { 1988 array[i] = -1; 1989 array[i+1] = -1; 1990 array[i+2] = -1; 1991 array[i+3] = -1; 1992 } 1993 } 1994 if(mMetaDataHeap != NULL){ 1995 ALOGV("mMetaDataHEap is non-NULL"); 1996 memcpy((uint32_t *)mMetaDataHeap->mHeap->base(), (uint32_t *)array, (sizeof(int)*(MAX_ROI*4+1))); 1997 mMetaDataWaitLock.unlock(); 1998 1999 if (mcb != NULL && (msgEnabled & CAMERA_MSG_META_DATA)) { 2000 mcb(CAMERA_MSG_META_DATA, mMetaDataHeap->mBuffers[0], mdata); 2001 } 2002 } else { 2003 mMetaDataWaitLock.unlock(); 2004 ALOGE("runPreviewThread mMetaDataHeap is NULL"); 2005 } 2006 } else { 2007 mMetaDataWaitLock.unlock(); 2008 } 2009 #endif // mzhu 2010 ALOGV("roiEvent: X"); 2011 } 2012 2013 2014 void QCameraHardwareInterface::handleZoomEventForSnapshot(void) 2015 { 2016 mm_camera_ch_crop_t v4l2_crop; 2017 2018 2019 ALOGV("%s: E", __func__); 2020 2021 memset(&v4l2_crop,0,sizeof(v4l2_crop)); 2022 v4l2_crop.ch_type=MM_CAMERA_CH_SNAPSHOT; 2023 2024 ALOGV("%s: Fetching crop info", __func__); 2025 cam_config_get_parm(mCameraId,MM_CAMERA_PARM_CROP,&v4l2_crop); 2026 2027 ALOGV("%s: Crop info received for main: %d, %d, %d, %d ", __func__, 2028 v4l2_crop.snapshot.main_crop.left, 2029 v4l2_crop.snapshot.main_crop.top, 2030 v4l2_crop.snapshot.main_crop.width, 2031 v4l2_crop.snapshot.main_crop.height); 2032 ALOGV("%s: Crop info received for thumbnail: %d, %d, %d, %d ",__func__, 2033 v4l2_crop.snapshot.thumbnail_crop.left, 2034 v4l2_crop.snapshot.thumbnail_crop.top, 2035 v4l2_crop.snapshot.thumbnail_crop.width, 2036 v4l2_crop.snapshot.thumbnail_crop.height); 2037 2038 if(mStreamSnap) { 2039 ALOGV("%s: Setting crop info for snapshot", __func__); 2040 memcpy(&(mStreamSnap->mCrop), &v4l2_crop, sizeof(v4l2_crop)); 2041 } 2042 if(mFullLiveshotEnabled && mStreamLiveSnap){ 2043 ALOGV("%s: Setting crop info for snapshot", __func__); 2044 memcpy(&(mStreamLiveSnap->mCrop), &v4l2_crop, sizeof(v4l2_crop)); 2045 } 2046 ALOGV("%s: X", __func__); 2047 } 2048 2049 void QCameraHardwareInterface::handleZoomEventForPreview(app_notify_cb_t *app_cb) 2050 { 2051 mm_camera_ch_crop_t v4l2_crop; 2052 2053 ALOGV("%s: E", __func__); 2054 2055 /*regular zooming or smooth zoom stopped*/ 2056 if (!mSmoothZoomRunning && mPreviewWindow) { 2057 memset(&v4l2_crop, 0, sizeof(v4l2_crop)); 2058 v4l2_crop.ch_type = MM_CAMERA_CH_PREVIEW; 2059 2060 ALOGV("%s: Fetching crop info", __func__); 2061 cam_config_get_parm(mCameraId,MM_CAMERA_PARM_CROP,&v4l2_crop); 2062 2063 ALOGV("%s: Crop info received: %d, %d, %d, %d ", __func__, 2064 v4l2_crop.crop.left, 2065 v4l2_crop.crop.top, 2066 v4l2_crop.crop.width, 2067 v4l2_crop.crop.height); 2068 2069 mPreviewWindow->set_crop(mPreviewWindow, 2070 v4l2_crop.crop.left, 2071 v4l2_crop.crop.top, 2072 v4l2_crop.crop.left + v4l2_crop.crop.width, 2073 v4l2_crop.crop.top + v4l2_crop.crop.height); 2074 ALOGV("%s: Done setting crop", __func__); 2075 ALOGV("%s: Currrent zoom :%d",__func__, mCurrentZoom); 2076 } 2077 2078 ALOGV("%s: X", __func__); 2079 } 2080 2081 void QCameraHardwareInterface::zoomEvent(cam_ctrl_status_t *status, app_notify_cb_t *app_cb) 2082 { 2083 ALOGV("zoomEvent: state:%d E",mPreviewState); 2084 switch (mPreviewState) { 2085 case QCAMERA_HAL_PREVIEW_STOPPED: 2086 break; 2087 case QCAMERA_HAL_PREVIEW_START: 2088 break; 2089 case QCAMERA_HAL_PREVIEW_STARTED: 2090 handleZoomEventForPreview(app_cb); 2091 if (isZSLMode()) 2092 handleZoomEventForSnapshot(); 2093 break; 2094 case QCAMERA_HAL_RECORDING_STARTED: 2095 handleZoomEventForPreview(app_cb); 2096 if (mFullLiveshotEnabled) 2097 handleZoomEventForSnapshot(); 2098 break; 2099 case QCAMERA_HAL_TAKE_PICTURE: 2100 if(isZSLMode()) 2101 handleZoomEventForPreview(app_cb); 2102 handleZoomEventForSnapshot(); 2103 break; 2104 default: 2105 break; 2106 } 2107 ALOGV("zoomEvent: X"); 2108 } 2109 2110 void QCameraHardwareInterface::dumpFrameToFile(const void * data, uint32_t size, char* name, char* ext, int index) 2111 { 2112 #if 0 2113 char buf[32], value[PROPERTY_VALUE_MAX]; 2114 int file_fd, enabled = 0; 2115 static int i = 0 ; 2116 property_get("persist.camera.dumpimage", value, "0"); 2117 enabled = atoi(value); 2118 2119 if ( data != NULL && enabled) { 2120 char * str; 2121 snprintf(buf, sizeof(buf), "/data/%s_%d.%s", name, index, ext); 2122 ALOGE("%s size =%d", buf, size); 2123 file_fd = open(buf, O_RDWR | O_CREAT, 0777); 2124 write(file_fd, data, size); 2125 close(file_fd); 2126 i++; 2127 } 2128 #endif 2129 } 2130 2131 void QCameraHardwareInterface::dumpFrameToFile(struct msm_frame* newFrame, 2132 HAL_cam_dump_frm_type_t frm_type) 2133 { 2134 #if 0 2135 int32_t enabled = 0; 2136 int frm_num; 2137 uint32_t skip_mode; 2138 char value[PROPERTY_VALUE_MAX]; 2139 char buf[32]; 2140 int main_422 = 1; 2141 property_get("persist.camera.dumpimg", value, "0"); 2142 enabled = atoi(value); 2143 2144 ALOGV(" newFrame =%p, frm_type = %d", newFrame, frm_type); 2145 if(enabled & HAL_DUMP_FRM_MASK_ALL) { 2146 if((enabled & frm_type) && newFrame) { 2147 frm_num = ((enabled & 0xffff0000) >> 16); 2148 if(frm_num == 0) frm_num = 10; /*default 10 frames*/ 2149 if(frm_num > 256) frm_num = 256; /*256 buffers cycle around*/ 2150 skip_mode = ((enabled & 0x0000ff00) >> 8); 2151 if(skip_mode == 0) skip_mode = 1; /*no -skip */ 2152 2153 if( mDumpSkipCnt % skip_mode == 0) { 2154 if (mDumpFrmCnt >= 0 && mDumpFrmCnt <= frm_num) { 2155 int w, h; 2156 int file_fd; 2157 switch (frm_type) { 2158 case HAL_DUMP_FRM_PREVIEW: 2159 w = mDimension.display_width; 2160 h = mDimension.display_height; 2161 snprintf(buf, sizeof(buf), "/data/%dp_%dx%d.yuv", mDumpFrmCnt, w, h); 2162 file_fd = open(buf, O_RDWR | O_CREAT, 0777); 2163 break; 2164 case HAL_DUMP_FRM_VIDEO: 2165 w = mVideoWidth; 2166 h = mVideoHeight; 2167 snprintf(buf, sizeof(buf),"/data/%dv_%dx%d.yuv", mDumpFrmCnt, w, h); 2168 file_fd = open(buf, O_RDWR | O_CREAT, 0777); 2169 break; 2170 case HAL_DUMP_FRM_MAIN: 2171 w = mDimension.picture_width; 2172 h = mDimension.picture_height; 2173 snprintf(buf, sizeof(buf), "/data/%dm_%dx%d.yuv", mDumpFrmCnt, w, h); 2174 file_fd = open(buf, O_RDWR | O_CREAT, 0777); 2175 if (mDimension.main_img_format == CAMERA_YUV_422_NV16 || 2176 mDimension.main_img_format == CAMERA_YUV_422_NV61) 2177 main_422 = 2; 2178 break; 2179 case HAL_DUMP_FRM_THUMBNAIL: 2180 w = mDimension.ui_thumbnail_width; 2181 h = mDimension.ui_thumbnail_height; 2182 snprintf(buf, sizeof(buf),"/data/%dt_%dx%d.yuv", mDumpFrmCnt, w, h); 2183 file_fd = open(buf, O_RDWR | O_CREAT, 0777); 2184 break; 2185 default: 2186 w = h = 0; 2187 file_fd = -1; 2188 break; 2189 } 2190 2191 if (file_fd < 0) { 2192 ALOGE("%s: cannot open file:type=%d\n", __func__, frm_type); 2193 } else { 2194 ALOGV("%s: %d %d", __func__, newFrame->y_off, newFrame->cbcr_off); 2195 write(file_fd, (const void *)(newFrame->buffer+newFrame->y_off), w * h); 2196 write(file_fd, (const void *) 2197 (newFrame->buffer + newFrame->cbcr_off), w * h / 2 * main_422); 2198 close(file_fd); 2199 ALOGV("dump %s", buf); 2200 } 2201 } else if(frm_num == 256){ 2202 mDumpFrmCnt = 0; 2203 } 2204 mDumpFrmCnt++; 2205 } 2206 mDumpSkipCnt++; 2207 } 2208 } else { 2209 mDumpFrmCnt = 0; 2210 } 2211 #endif 2212 } 2213 2214 status_t QCameraHardwareInterface::setPreviewWindow(preview_stream_ops_t* window) 2215 { 2216 status_t retVal = NO_ERROR; 2217 ALOGV(" %s: E mPreviewState = %d, mStreamDisplay = %p", __FUNCTION__, mPreviewState, mStreamDisplay); 2218 if( window == NULL) { 2219 ALOGE("%s:Received Setting NULL preview window", __func__); 2220 } 2221 Mutex::Autolock lock(mLock); 2222 switch(mPreviewState) { 2223 case QCAMERA_HAL_PREVIEW_START: 2224 mPreviewWindow = window; 2225 if(mPreviewWindow) { 2226 /* we have valid surface now, start preview */ 2227 retVal = startPreview2(); 2228 if(retVal == NO_ERROR) 2229 mPreviewState = QCAMERA_HAL_PREVIEW_STARTED; 2230 ALOGV("%s: startPreview2 done, mPreviewState = %d", __func__, mPreviewState); 2231 } else 2232 ALOGE("%s: null window received, mPreviewState = %d", __func__, mPreviewState); 2233 break; 2234 case QCAMERA_HAL_PREVIEW_STARTED: 2235 /* new window comes */ 2236 ALOGE("%s: bug, cannot handle new window in started state", __func__); 2237 //retVal = UNKNOWN_ERROR; 2238 break; 2239 case QCAMERA_HAL_PREVIEW_STOPPED: 2240 case QCAMERA_HAL_TAKE_PICTURE: 2241 mPreviewWindow = window; 2242 ALOGE("%s: mPreviewWindow = 0x%p, mStreamDisplay = 0x%p", 2243 __func__, mPreviewWindow, mStreamDisplay); 2244 if(mStreamDisplay) 2245 retVal = mStreamDisplay->setPreviewWindow(window); 2246 break; 2247 default: 2248 ALOGE("%s: bug, cannot handle new window in state %d", __func__, mPreviewState); 2249 retVal = UNKNOWN_ERROR; 2250 break; 2251 } 2252 ALOGV(" %s : X, mPreviewState = %d", __FUNCTION__, mPreviewState); 2253 return retVal; 2254 } 2255 2256 int QCameraHardwareInterface::storeMetaDataInBuffers(int enable) 2257 { 2258 /* this is a dummy func now. fix me later */ 2259 mStoreMetaDataInFrame = enable; 2260 return 0; 2261 } 2262 2263 status_t QCameraHardwareInterface::sendMappingBuf(int ext_mode, int idx, int fd, 2264 uint32_t size, int cameraid, 2265 mm_camera_socket_msg_type msg_type) 2266 { 2267 cam_sock_packet_t packet; 2268 memset(&packet, 0, sizeof(cam_sock_packet_t)); 2269 packet.msg_type = msg_type; 2270 packet.payload.frame_fd_map.ext_mode = ext_mode; 2271 packet.payload.frame_fd_map.frame_idx = idx; 2272 packet.payload.frame_fd_map.fd = fd; 2273 packet.payload.frame_fd_map.size = size; 2274 2275 if ( cam_ops_sendmsg(cameraid, &packet, sizeof(cam_sock_packet_t), packet.payload.frame_fd_map.fd) <= 0 ) { 2276 ALOGE("%s: sending frame mapping buf msg Failed", __func__); 2277 return FAILED_TRANSACTION; 2278 } 2279 return NO_ERROR; 2280 } 2281 2282 status_t QCameraHardwareInterface::sendUnMappingBuf(int ext_mode, int idx, int cameraid, 2283 mm_camera_socket_msg_type msg_type) 2284 { 2285 cam_sock_packet_t packet; 2286 memset(&packet, 0, sizeof(cam_sock_packet_t)); 2287 packet.msg_type = msg_type; 2288 packet.payload.frame_fd_unmap.ext_mode = ext_mode; 2289 packet.payload.frame_fd_unmap.frame_idx = idx; 2290 if ( cam_ops_sendmsg(cameraid, &packet, sizeof(cam_sock_packet_t), 0) <= 0 ) { 2291 ALOGE("%s: sending frame unmapping buf msg Failed", __func__); 2292 return FAILED_TRANSACTION; 2293 } 2294 return NO_ERROR; 2295 } 2296 2297 int QCameraHardwareInterface::allocate_ion_memory(QCameraHalHeap_t *p_camera_memory, int cnt, int ion_type) 2298 { 2299 int rc = 0; 2300 struct ion_handle_data handle_data; 2301 2302 p_camera_memory->main_ion_fd[cnt] = open("/dev/ion", O_RDONLY); 2303 if (p_camera_memory->main_ion_fd[cnt] < 0) { 2304 ALOGE("Ion dev open failed\n"); 2305 ALOGE("Error is %s\n", strerror(errno)); 2306 goto ION_OPEN_FAILED; 2307 } 2308 p_camera_memory->alloc[cnt].len = p_camera_memory->size; 2309 /* to make it page size aligned */ 2310 p_camera_memory->alloc[cnt].len = (p_camera_memory->alloc[cnt].len + 4095) & (~4095); 2311 p_camera_memory->alloc[cnt].align = 4096; 2312 p_camera_memory->alloc[cnt].flags = ION_FLAG_CACHED; 2313 p_camera_memory->alloc[cnt].heap_mask = ion_type; 2314 2315 rc = ioctl(p_camera_memory->main_ion_fd[cnt], ION_IOC_ALLOC, &p_camera_memory->alloc[cnt]); 2316 if (rc < 0) { 2317 ALOGE("ION allocation failed\n"); 2318 goto ION_ALLOC_FAILED; 2319 } 2320 2321 p_camera_memory->ion_info_fd[cnt].handle = p_camera_memory->alloc[cnt].handle; 2322 rc = ioctl(p_camera_memory->main_ion_fd[cnt], ION_IOC_SHARE, &p_camera_memory->ion_info_fd[cnt]); 2323 if (rc < 0) { 2324 ALOGE("ION map failed %s\n", strerror(errno)); 2325 goto ION_MAP_FAILED; 2326 } 2327 p_camera_memory->fd[cnt] = p_camera_memory->ion_info_fd[cnt].fd; 2328 return 0; 2329 2330 ION_MAP_FAILED: 2331 handle_data.handle = p_camera_memory->ion_info_fd[cnt].handle; 2332 ioctl(p_camera_memory->main_ion_fd[cnt], ION_IOC_FREE, &handle_data); 2333 ION_ALLOC_FAILED: 2334 close(p_camera_memory->main_ion_fd[cnt]); 2335 p_camera_memory->main_ion_fd[cnt] = -1; 2336 ION_OPEN_FAILED: 2337 return -1; 2338 } 2339 2340 int QCameraHardwareInterface::deallocate_ion_memory(QCameraHalHeap_t *p_camera_memory, int cnt) 2341 { 2342 struct ion_handle_data handle_data; 2343 int rc = 0; 2344 2345 if (p_camera_memory->main_ion_fd[cnt] > 0) { 2346 handle_data.handle = p_camera_memory->ion_info_fd[cnt].handle; 2347 ioctl(p_camera_memory->main_ion_fd[cnt], ION_IOC_FREE, &handle_data); 2348 close(p_camera_memory->main_ion_fd[cnt]); 2349 p_camera_memory->main_ion_fd[cnt] = -1; 2350 } 2351 return rc; 2352 } 2353 2354 int QCameraHardwareInterface::allocate_ion_memory(QCameraStatHeap_t *p_camera_memory, int cnt, int ion_type) 2355 { 2356 int rc = 0; 2357 struct ion_handle_data handle_data; 2358 2359 p_camera_memory->main_ion_fd[cnt] = open("/dev/ion", O_RDONLY); 2360 if (p_camera_memory->main_ion_fd[cnt] < 0) { 2361 ALOGE("Ion dev open failed\n"); 2362 ALOGE("Error is %s\n", strerror(errno)); 2363 goto ION_OPEN_FAILED; 2364 } 2365 p_camera_memory->alloc[cnt].len = p_camera_memory->size; 2366 /* to make it page size aligned */ 2367 p_camera_memory->alloc[cnt].len = (p_camera_memory->alloc[cnt].len + 4095) & (~4095); 2368 p_camera_memory->alloc[cnt].align = 4096; 2369 p_camera_memory->alloc[cnt].flags = ION_FLAG_CACHED; 2370 p_camera_memory->alloc[cnt].heap_mask = (0x1 << ion_type | 0x1 << ION_IOMMU_HEAP_ID); 2371 2372 rc = ioctl(p_camera_memory->main_ion_fd[cnt], ION_IOC_ALLOC, &p_camera_memory->alloc[cnt]); 2373 if (rc < 0) { 2374 ALOGE("ION allocation failed\n"); 2375 goto ION_ALLOC_FAILED; 2376 } 2377 2378 p_camera_memory->ion_info_fd[cnt].handle = p_camera_memory->alloc[cnt].handle; 2379 rc = ioctl(p_camera_memory->main_ion_fd[cnt], ION_IOC_SHARE, &p_camera_memory->ion_info_fd[cnt]); 2380 if (rc < 0) { 2381 ALOGE("ION map failed %s\n", strerror(errno)); 2382 goto ION_MAP_FAILED; 2383 } 2384 p_camera_memory->fd[cnt] = p_camera_memory->ion_info_fd[cnt].fd; 2385 return 0; 2386 2387 ION_MAP_FAILED: 2388 handle_data.handle = p_camera_memory->ion_info_fd[cnt].handle; 2389 ioctl(p_camera_memory->main_ion_fd[cnt], ION_IOC_FREE, &handle_data); 2390 ION_ALLOC_FAILED: 2391 close(p_camera_memory->main_ion_fd[cnt]); 2392 p_camera_memory->main_ion_fd[cnt] = -1; 2393 ION_OPEN_FAILED: 2394 return -1; 2395 } 2396 2397 int QCameraHardwareInterface::cache_ops(int ion_fd, 2398 struct ion_flush_data *cache_data, int type) 2399 { 2400 int rc = 0; 2401 struct ion_custom_data data; 2402 data.cmd = type; 2403 data.arg = (unsigned long)cache_data; 2404 2405 rc = ioctl(ion_fd, ION_IOC_CUSTOM, &data); 2406 if (rc < 0) 2407 ALOGE("%s: Cache Invalidate failed\n", __func__); 2408 else 2409 ALOGV("%s: Cache OPs type(%d) success", __func__); 2410 2411 return rc; 2412 } 2413 2414 int QCameraHardwareInterface::deallocate_ion_memory(QCameraStatHeap_t *p_camera_memory, int cnt) 2415 { 2416 struct ion_handle_data handle_data; 2417 int rc = 0; 2418 2419 if (p_camera_memory->main_ion_fd[cnt] > 0) { 2420 handle_data.handle = p_camera_memory->ion_info_fd[cnt].handle; 2421 ioctl(p_camera_memory->main_ion_fd[cnt], ION_IOC_FREE, &handle_data); 2422 close(p_camera_memory->main_ion_fd[cnt]); 2423 p_camera_memory->main_ion_fd[cnt] = -1; 2424 } 2425 return rc; 2426 } 2427 2428 int QCameraHardwareInterface::initHeapMem( QCameraHalHeap_t *heap, 2429 int num_of_buf, 2430 int buf_len, 2431 int y_off, 2432 int cbcr_off, 2433 int pmem_type, 2434 mm_cameara_stream_buf_t *StreamBuf, 2435 mm_camera_buf_def_t *buf_def, 2436 uint8_t num_planes, 2437 uint32_t *planes 2438 ) 2439 { 2440 int rc = 0; 2441 int i; 2442 int path; 2443 int ion_fd; 2444 struct msm_frame *frame; 2445 struct ion_flush_data cache_inv_data; 2446 ALOGV("Init Heap =%p. stream_buf =%p, pmem_type =%d, num_of_buf=%d. buf_len=%d, cbcr_off=%d", 2447 heap, StreamBuf, pmem_type, num_of_buf, buf_len, cbcr_off); 2448 if(num_of_buf > MM_CAMERA_MAX_NUM_FRAMES || heap == NULL || 2449 mGetMemory == NULL ) { 2450 ALOGE("Init Heap error"); 2451 rc = -1; 2452 return rc; 2453 } 2454 memset(heap, 0, sizeof(QCameraHalHeap_t)); 2455 for (i=0; i<MM_CAMERA_MAX_NUM_FRAMES;i++) { 2456 heap->main_ion_fd[i] = -1; 2457 heap->fd[i] = -1; 2458 } 2459 heap->buffer_count = num_of_buf; 2460 heap->size = buf_len; 2461 heap->y_offset = y_off; 2462 heap->cbcr_offset = cbcr_off; 2463 2464 if (StreamBuf != NULL) { 2465 StreamBuf->num = num_of_buf; 2466 StreamBuf->frame_len = buf_len; 2467 switch (pmem_type) { 2468 case MSM_PMEM_MAINIMG: 2469 case MSM_PMEM_RAW_MAINIMG: 2470 path = OUTPUT_TYPE_S; 2471 break; 2472 2473 case MSM_PMEM_THUMBNAIL: 2474 path = OUTPUT_TYPE_T; 2475 break; 2476 2477 default: 2478 rc = -1; 2479 return rc; 2480 } 2481 } 2482 2483 2484 for(i = 0; i < num_of_buf; i++) { 2485 #ifdef USE_ION 2486 if (isZSLMode()) 2487 rc = allocate_ion_memory(heap, i, ((0x1 << CAMERA_ZSL_ION_HEAP_ID) | 2488 (0x1 << CAMERA_ZSL_ION_FALLBACK_HEAP_ID))); 2489 else 2490 rc = allocate_ion_memory(heap, i, ((0x1 << CAMERA_ION_HEAP_ID) | 2491 (0x1 << CAMERA_ION_FALLBACK_HEAP_ID))); 2492 2493 if (rc < 0) { 2494 ALOGE("%s: ION allocation failed\n", __func__); 2495 break; 2496 } 2497 #else 2498 if (pmem_type == MSM_PMEM_MAX) 2499 heap->fd[i] = -1; 2500 else { 2501 heap->fd[i] = open("/dev/pmem_adsp", O_RDWR|O_SYNC); 2502 if ( heap->fd[i] <= 0) { 2503 rc = -1; 2504 ALOGE("Open fail: heap->fd[%d] =%d", i, heap->fd[i]); 2505 break; 2506 } 2507 } 2508 #endif 2509 heap->camera_memory[i] = mGetMemory( heap->fd[i], buf_len, 1, (void *)this); 2510 2511 if (heap->camera_memory[i] == NULL ) { 2512 ALOGE("Getmem fail %d: ", i); 2513 rc = -1; 2514 break; 2515 } 2516 2517 memset(&cache_inv_data, 0, sizeof(struct ion_flush_data)); 2518 cache_inv_data.vaddr = (void*) heap->camera_memory[i]->data; 2519 cache_inv_data.fd = heap->ion_info_fd[i].fd; 2520 cache_inv_data.handle = heap->ion_info_fd[i].handle; 2521 cache_inv_data.length = heap->alloc[i].len; 2522 ion_fd = heap->main_ion_fd[i]; 2523 if(ion_fd > 0) { 2524 if(cache_ops(ion_fd, &cache_inv_data, ION_IOC_CLEAN_INV_CACHES) < 0) 2525 ALOGE("%s: Cache Invalidate failed\n", __func__); 2526 else { 2527 ALOGV("%s: Successful cache invalidate\n", __func__); 2528 } 2529 } 2530 2531 if (StreamBuf != NULL) { 2532 frame = &(StreamBuf->frame[i]); 2533 memset(frame, 0, sizeof(struct msm_frame)); 2534 frame->fd = heap->fd[i]; 2535 frame->phy_offset = 0; 2536 frame->buffer = (uint32_t) heap->camera_memory[i]->data; 2537 frame->path = path; 2538 frame->cbcr_off = planes[0]+heap->cbcr_offset; 2539 frame->y_off = heap->y_offset; 2540 frame->fd_data = heap->ion_info_fd[i]; 2541 frame->ion_alloc = heap->alloc[i]; 2542 frame->ion_dev_fd = heap->main_ion_fd[i]; 2543 ALOGV("%s: Buffer idx: %d addr: %x fd: %d phy_offset: %d" 2544 "cbcr_off: %d y_off: %d frame_len: %d", __func__, 2545 i, (unsigned int)frame->buffer, frame->fd, 2546 frame->phy_offset, cbcr_off, y_off, frame->ion_alloc.len); 2547 2548 buf_def->buf.mp[i].frame = *frame; 2549 buf_def->buf.mp[i].frame_offset = 0; 2550 buf_def->buf.mp[i].num_planes = num_planes; 2551 /* Plane 0 needs to be set seperately. Set other planes 2552 * in a loop. */ 2553 buf_def->buf.mp[i].planes[0].length = planes[0]; 2554 buf_def->buf.mp[i].planes[0].m.userptr = frame->fd; 2555 buf_def->buf.mp[i].planes[0].data_offset = y_off; 2556 buf_def->buf.mp[i].planes[0].reserved[0] = 2557 buf_def->buf.mp[i].frame_offset; 2558 for (int j = 1; j < num_planes; j++) { 2559 buf_def->buf.mp[i].planes[j].length = planes[j]; 2560 buf_def->buf.mp[i].planes[j].m.userptr = frame->fd; 2561 buf_def->buf.mp[i].planes[j].data_offset = cbcr_off; 2562 buf_def->buf.mp[i].planes[j].reserved[0] = 2563 buf_def->buf.mp[i].planes[j-1].reserved[0] + 2564 buf_def->buf.mp[i].planes[j-1].length; 2565 } 2566 } else { 2567 } 2568 2569 ALOGV("heap->fd[%d] =%d, camera_memory=%p", i, heap->fd[i], heap->camera_memory[i]); 2570 heap->local_flag[i] = 1; 2571 } 2572 if( rc < 0) { 2573 releaseHeapMem(heap); 2574 } 2575 return rc; 2576 } 2577 2578 int QCameraHardwareInterface::releaseHeapMem( QCameraHalHeap_t *heap) 2579 { 2580 int rc = 0; 2581 ALOGV("Release %p", heap); 2582 if (heap != NULL) { 2583 2584 for (int i = 0; i < heap->buffer_count; i++) { 2585 if(heap->camera_memory[i] != NULL) { 2586 heap->camera_memory[i]->release( heap->camera_memory[i] ); 2587 heap->camera_memory[i] = NULL; 2588 } else if (heap->fd[i] <= 0) { 2589 ALOGE("impossible: amera_memory[%d] = %p, fd = %d", 2590 i, heap->camera_memory[i], heap->fd[i]); 2591 } 2592 2593 if(heap->fd[i] > 0) { 2594 close(heap->fd[i]); 2595 heap->fd[i] = -1; 2596 } 2597 #ifdef USE_ION 2598 deallocate_ion_memory(heap, i); 2599 #endif 2600 } 2601 heap->buffer_count = 0; 2602 heap->size = 0; 2603 heap->y_offset = 0; 2604 heap->cbcr_offset = 0; 2605 } 2606 return rc; 2607 } 2608 2609 preview_format_info_t QCameraHardwareInterface::getPreviewFormatInfo( ) 2610 { 2611 return mPreviewFormatInfo; 2612 } 2613 2614 void QCameraHardwareInterface::wdenoiseEvent(cam_ctrl_status_t status, void *cookie) 2615 { 2616 ALOGV("wdnEvent: preview state:%d E",mPreviewState); 2617 if (mStreamSnap != NULL) { 2618 ALOGV("notifyWDNEvent to snapshot stream"); 2619 mStreamSnap->notifyWDenoiseEvent(status, cookie); 2620 } 2621 } 2622 2623 bool QCameraHardwareInterface::isWDenoiseEnabled() 2624 { 2625 return mDenoiseValue; 2626 } 2627 2628 void QCameraHardwareInterface::takePicturePrepareHardware() 2629 { 2630 ALOGV("%s: E", __func__); 2631 2632 /* Prepare snapshot*/ 2633 cam_ops_action(mCameraId, 2634 true, 2635 MM_CAMERA_OPS_PREPARE_SNAPSHOT, 2636 this); 2637 ALOGV("%s: X", __func__); 2638 } 2639 2640 bool QCameraHardwareInterface::isNoDisplayMode() 2641 { 2642 return (mNoDisplayMode != 0); 2643 } 2644 2645 void QCameraHardwareInterface::pausePreviewForZSL() 2646 { 2647 ALOGV("%s: mRestartPreview %d", __func__, mRestartPreview); 2648 if(mRestartPreview) { 2649 ALOGE("%s: Restarting Preview",__func__); 2650 stopPreviewInternal(); 2651 mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED; 2652 startPreview2(); 2653 mPreviewState = QCAMERA_HAL_PREVIEW_STARTED; 2654 } 2655 } 2656 2657 void QCameraHardwareInterface::pausePreviewForVideo() 2658 { 2659 status_t ret = NO_ERROR; 2660 bool restart = false; 2661 cam_ctrl_dimension_t dim; 2662 2663 /* get existing preview information, by qury mm_camera*/ 2664 memset(&dim, 0, sizeof(cam_ctrl_dimension_t)); 2665 ret = cam_config_get_parm(mCameraId, MM_CAMERA_PARM_DIMENSION,&dim); 2666 2667 if (MM_CAMERA_OK != ret) { 2668 ALOGE("%s: X error- can't get preview dimension!", __func__); 2669 return; 2670 } 2671 2672 if (mRestartPreview) { 2673 mRestartPreview = false; 2674 ALOGV("%s: Restarting Preview. Video Size changed",__func__); 2675 restart |= false; 2676 } 2677 if (mRecordingHint == false) { 2678 ALOGV("%s: Restarting Preview. Hint not set",__func__); 2679 restart |= true; 2680 } 2681 2682 if(dim.video_width != mVideoWidth || dim.video_height != mVideoHeight){ 2683 ALOGV("%s: Restarting Preview. New Video Size set",__func__); 2684 restart |= true; 2685 } 2686 2687 //VFE output1 shouldn't be greater than VFE output2. 2688 if( (mPreviewWidth > mVideoWidth) || (mPreviewHeight > mVideoHeight)) { 2689 //Set preview sizes as record sizes. 2690 ALOGV("Preview size %dx%d is greater than record size %dx%d,\ 2691 resetting preview size to record size",mPreviewWidth, 2692 mPreviewHeight, mVideoWidth, mVideoHeight); 2693 mPreviewWidth = mVideoWidth; 2694 mPreviewHeight = mVideoHeight; 2695 mParameters.setPreviewSize(mPreviewWidth, mPreviewHeight); 2696 restart |= true; 2697 } 2698 if (restart) { 2699 stopPreviewInternal(); 2700 mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED; 2701 2702 // Set recording hint to true 2703 mRecordingHint = true; 2704 setRecordingHintValue(mRecordingHint); 2705 2706 mDimension.display_width = mPreviewWidth; 2707 mDimension.display_height= mPreviewHeight; 2708 mDimension.orig_video_width = mVideoWidth; 2709 mDimension.orig_video_height = mVideoHeight; 2710 mDimension.video_width = mVideoWidth; 2711 mDimension.video_height = mVideoHeight; 2712 2713 // start preview again 2714 mPreviewState = QCAMERA_HAL_PREVIEW_START; 2715 if (startPreview2() == NO_ERROR){ 2716 mPreviewState = QCAMERA_HAL_PREVIEW_STARTED; 2717 }else{ 2718 ALOGE("%s: Restart for Video Failed",__func__); 2719 } 2720 } 2721 } 2722 2723 /**/ 2724 bool QCameraHardwareInterface::getHdrInfoAndSetExp( int max_num_frm, int *num_frame, int *exp) 2725 { 2726 bool rc = false; 2727 2728 if (mHdrMode == HDR_MODE && num_frame != NULL && exp != NULL && 2729 mRecordingHint != true && 2730 mPreviewState != QCAMERA_HAL_RECORDING_STARTED ) { 2731 int ret = 0; 2732 *num_frame = 1; 2733 exp_bracketing_t temp; 2734 memset(&temp, 0, sizeof(exp_bracketing_t)); 2735 ret = cam_config_get_parm(mCameraId, MM_CAMERA_PARM_HDR, (void *)&temp ); 2736 if (ret == NO_ERROR && max_num_frm > 0) { 2737 /*set as AE Bracketing mode*/ 2738 temp.hdr_enable = false; 2739 temp.mode = HDR_MODE; 2740 temp.total_hal_frames = temp.total_frames; 2741 ret = native_set_parms(MM_CAMERA_PARM_HDR, 2742 sizeof(exp_bracketing_t), (void *)&temp); 2743 if (ret) { 2744 char *val, *exp_value, *prev_value; 2745 int i; 2746 exp_value = (char *) temp.values; 2747 i = 0; 2748 val = strtok_r(exp_value,",", &prev_value); 2749 while (val != NULL ){ 2750 exp[i++] = atoi(val); 2751 if(i >= max_num_frm ) 2752 break; 2753 val = strtok_r(NULL, ",", &prev_value); 2754 } 2755 *num_frame =temp.total_frames; 2756 rc = true; 2757 } 2758 } else { 2759 temp.total_frames = 1; 2760 } 2761 /* Application waits until this many snapshots before restarting preview */ 2762 mParameters.set("num-snaps-per-shutter", 2); 2763 } 2764 return rc; 2765 } 2766 2767 void QCameraHardwareInterface::hdrEvent(cam_ctrl_status_t status, void *cookie) 2768 { 2769 QCameraStream * snapStream = (QCameraStream *)cookie; 2770 ALOGV("HdrEvent: preview state: E"); 2771 if (snapStream != NULL && mStreamSnap != NULL) { 2772 ALOGV("HdrEvent to snapshot stream"); 2773 snapStream->notifyHdrEvent(status, cookie); 2774 } 2775 } 2776 2777 }; // namespace android 2778