BaseCameraAdapter.cpp revision 41a31123a0fc59b8112460285d3f1ba73c5537c0
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 19#define LOG_TAG "CameraHAL" 20 21#include "BaseCameraAdapter.h" 22 23namespace android { 24 25/*--------------------Camera Adapter Class STARTS here-----------------------------*/ 26 27BaseCameraAdapter::BaseCameraAdapter() 28{ 29 mReleaseImageBuffersCallback = NULL; 30 mEndImageCaptureCallback = NULL; 31 mErrorNotifier = NULL; 32 mEndCaptureData = NULL; 33 mReleaseData = NULL; 34 mRecording = false; 35 36 mPreviewBuffers = NULL; 37 mPreviewBufferCount = 0; 38 mPreviewBuffersLength = 0; 39 40 mVideoBuffers = NULL; 41 mVideoBuffersCount = 0; 42 mVideoBuffersLength = 0; 43 44 mCaptureBuffers = NULL; 45 mCaptureBuffersCount = 0; 46 mCaptureBuffersLength = 0; 47 48 mPreviewDataBuffers = NULL; 49 mPreviewDataBuffersCount = 0; 50 mPreviewDataBuffersLength = 0; 51 52 mAdapterState = INTIALIZED_STATE; 53 54#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 55 mStartFocus.tv_sec = 0; 56 mStartFocus.tv_usec = 0; 57 mStartCapture.tv_sec = 0; 58 mStartCapture.tv_usec = 0; 59#endif 60 61} 62 63BaseCameraAdapter::~BaseCameraAdapter() 64{ 65 LOG_FUNCTION_NAME; 66 67 Mutex::Autolock lock(mSubscriberLock); 68 69 mFrameSubscribers.clear(); 70 mImageSubscribers.clear(); 71 mRawSubscribers.clear(); 72 mVideoSubscribers.clear(); 73 mFocusSubscribers.clear(); 74 mShutterSubscribers.clear(); 75 mZoomSubscribers.clear(); 76 mFaceSubscribers.clear(); 77 78 LOG_FUNCTION_NAME_EXIT; 79} 80 81status_t BaseCameraAdapter::registerImageReleaseCallback(release_image_buffers_callback callback, void *user_data) 82{ 83 status_t ret = NO_ERROR; 84 85 LOG_FUNCTION_NAME; 86 87 mReleaseImageBuffersCallback = callback; 88 mReleaseData = user_data; 89 90 LOG_FUNCTION_NAME_EXIT; 91 92 return ret; 93} 94 95status_t BaseCameraAdapter::registerEndCaptureCallback(end_image_capture_callback callback, void *user_data) 96{ 97 status_t ret = NO_ERROR; 98 99 LOG_FUNCTION_NAME; 100 101 mEndImageCaptureCallback= callback; 102 mEndCaptureData = user_data; 103 104 LOG_FUNCTION_NAME_EXIT; 105 106 return ret; 107} 108 109status_t BaseCameraAdapter::setErrorHandler(ErrorNotifier *errorNotifier) 110{ 111 status_t ret = NO_ERROR; 112 113 LOG_FUNCTION_NAME; 114 115 if ( NULL == errorNotifier ) 116 { 117 CAMHAL_LOGEA("Invalid Error Notifier reference"); 118 ret = -EINVAL; 119 } 120 121 if ( NO_ERROR == ret ) 122 { 123 mErrorNotifier = errorNotifier; 124 } 125 126 LOG_FUNCTION_NAME_EXIT; 127 128 return ret; 129} 130 131void BaseCameraAdapter::enableMsgType(int32_t msgs, frame_callback callback, event_callback eventCb, void* cookie) 132{ 133 Mutex::Autolock lock(mSubscriberLock); 134 135 LOG_FUNCTION_NAME; 136 137 if ( CameraFrame::PREVIEW_FRAME_SYNC == msgs ) 138 { 139 mFrameSubscribers.add((int) cookie, callback); 140 } 141 else if ( CameraFrame::FRAME_DATA_SYNC == msgs ) 142 { 143 mFrameDataSubscribers.add((int) cookie, callback); 144 } 145 else if ( CameraFrame::IMAGE_FRAME == msgs) 146 { 147 mImageSubscribers.add((int) cookie, callback); 148 } 149 else if ( CameraFrame::RAW_FRAME == msgs) 150 { 151 mRawSubscribers.add((int) cookie, callback); 152 } 153 else if ( CameraFrame::VIDEO_FRAME_SYNC == msgs) 154 { 155 mVideoSubscribers.add((int) cookie, callback); 156 } 157 else if ( CameraHalEvent::ALL_EVENTS == msgs) 158 { 159 mFocusSubscribers.add((int) cookie, eventCb); 160 mShutterSubscribers.add((int) cookie, eventCb); 161 mZoomSubscribers.add((int) cookie, eventCb); 162 mFaceSubscribers.add((int) cookie, eventCb); 163 } 164 else 165 { 166 CAMHAL_LOGEA("Message type subscription no supported yet!"); 167 } 168 169 LOG_FUNCTION_NAME_EXIT; 170} 171 172void BaseCameraAdapter::disableMsgType(int32_t msgs, void* cookie) 173{ 174 Mutex::Autolock lock(mSubscriberLock); 175 176 LOG_FUNCTION_NAME; 177 178 if ( CameraFrame::PREVIEW_FRAME_SYNC == msgs ) 179 { 180 mFrameSubscribers.removeItem((int) cookie); 181 } 182 else if ( CameraFrame::FRAME_DATA_SYNC == msgs ) 183 { 184 mFrameDataSubscribers.removeItem((int) cookie); 185 } 186 else if ( CameraFrame::IMAGE_FRAME == msgs) 187 { 188 mImageSubscribers.removeItem((int) cookie); 189 } 190 else if ( CameraFrame::RAW_FRAME == msgs) 191 { 192 mRawSubscribers.removeItem((int) cookie); 193 } 194 else if ( CameraFrame::VIDEO_FRAME_SYNC == msgs) 195 { 196 mVideoSubscribers.removeItem((int) cookie); 197 } 198 else if ( CameraFrame::ALL_FRAMES == msgs ) 199 { 200 mFrameSubscribers.removeItem((int) cookie); 201 mFrameDataSubscribers.removeItem((int) cookie); 202 mImageSubscribers.removeItem((int) cookie); 203 mRawSubscribers.removeItem((int) cookie); 204 mVideoSubscribers.removeItem((int) cookie); 205 } 206 else if ( CameraHalEvent::ALL_EVENTS == msgs) 207 { 208 //Subscribe only for focus 209 //TODO: Process case by case 210 mFocusSubscribers.removeItem((int) cookie); 211 mShutterSubscribers.removeItem((int) cookie); 212 mZoomSubscribers.removeItem((int) cookie); 213 mFaceSubscribers.removeItem((int) cookie); 214 } 215 else 216 { 217 CAMHAL_LOGEB("Message type 0x%x subscription no supported yet!", msgs); 218 } 219 220 LOG_FUNCTION_NAME_EXIT; 221} 222 223void BaseCameraAdapter::addFramePointers(void *frameBuf, void *buf) 224{ 225 unsigned int *pBuf = (unsigned int *)buf; 226 Mutex::Autolock lock(mSubscriberLock); 227 228 if ((frameBuf != NULL) && ( pBuf != NULL) ) 229 { 230 CameraFrame *frame = new CameraFrame; 231 frame->mBuffer = frameBuf; 232 frame->mYuv[0] = pBuf[0]; 233 frame->mYuv[1] = pBuf[1]; 234 mFrameQueue.add(frameBuf, frame); 235 236 CAMHAL_LOGVB("Adding Frame=0x%x Y=0x%x UV=0x%x", frame->mBuffer, frame->mYuv[0], frame->mYuv[1]); 237 } 238} 239 240void BaseCameraAdapter::removeFramePointers() 241{ 242 Mutex::Autolock lock(mSubscriberLock); 243 244 int size = mFrameQueue.size(); 245 CAMHAL_LOGVB("Removing %d Frames = ", size); 246 for (int i = 0; i < size; i++) 247 { 248 CameraFrame *frame = (CameraFrame *)mFrameQueue.valueAt(i); 249 CAMHAL_LOGVB("Free Frame=0x%x Y=0x%x UV=0x%x", frame->mBuffer, frame->mYuv[0], frame->mYuv[1]); 250 delete frame; 251 } 252 mFrameQueue.clear(); 253} 254 255void BaseCameraAdapter::returnFrame(void* frameBuf, CameraFrame::FrameType frameType) 256{ 257 status_t res = NO_ERROR; 258 size_t subscriberCount = 0; 259 int refCount = -1; 260 261 Mutex::Autolock lock(mReturnFrameLock); 262 263 if ( NULL == frameBuf ) 264 { 265 CAMHAL_LOGEA("Invalid frameBuf"); 266 return; 267 } 268 269 if ( NO_ERROR == res) 270 { 271 272 refCount = getFrameRefCount(frameBuf, frameType); 273 274 if(frameType == CameraFrame::PREVIEW_FRAME_SYNC) 275 { 276 mFramesWithDisplay--; 277 } 278 else if(frameType == CameraFrame::VIDEO_FRAME_SYNC) 279 { 280 mFramesWithEncoder--; 281 } 282 283 if ( 0 < refCount ) 284 { 285 286 refCount--; 287 setFrameRefCount(frameBuf, frameType, refCount); 288 289 290 if ( mRecording && (CameraFrame::VIDEO_FRAME_SYNC == frameType) ) { 291 refCount += getFrameRefCount(frameBuf, CameraFrame::PREVIEW_FRAME_SYNC); 292 } else if ( mRecording && (CameraFrame::PREVIEW_FRAME_SYNC == frameType) ) { 293 refCount += getFrameRefCount(frameBuf, CameraFrame::VIDEO_FRAME_SYNC); 294 } else if ( mRecording && (CameraFrame::SNAPSHOT_FRAME == frameType) ) { 295 refCount += getFrameRefCount(frameBuf, CameraFrame::VIDEO_FRAME_SYNC); 296 } 297 298 299 } 300 else 301 { 302 CAMHAL_LOGDA("Frame returned when ref count is already zero!!"); 303 return; 304 } 305 } 306 307 CAMHAL_LOGVB("REFCOUNT 0x%x %d", frameBuf, refCount); 308 309 if ( NO_ERROR == res ) 310 { 311 //check if someone is holding this buffer 312 if ( 0 == refCount ) 313 { 314#ifdef DEBUG_LOG 315 if(mBuffersWithDucati.indexOfKey((int)frameBuf)>=0) 316 { 317 ALOGE("Buffer already with Ducati!! 0x%x", frameBuf); 318 for(int i=0;i<mBuffersWithDucati.size();i++) ALOGE("0x%x", mBuffersWithDucati.keyAt(i)); 319 } 320 mBuffersWithDucati.add((int)frameBuf,1); 321#endif 322 res = fillThisBuffer(frameBuf, frameType); 323 } 324 } 325 326} 327 328status_t BaseCameraAdapter::sendCommand(CameraCommands operation, int value1, int value2, int value3) 329{ 330 status_t ret = NO_ERROR; 331 struct timeval *refTimestamp; 332 BuffersDescriptor *desc = NULL; 333 CameraFrame *frame = NULL; 334 335 LOG_FUNCTION_NAME; 336 337 switch ( operation ) { 338 case CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW: 339 CAMHAL_LOGDA("Use buffers for preview"); 340 desc = ( BuffersDescriptor * ) value1; 341 342 if ( NULL == desc ) 343 { 344 CAMHAL_LOGEA("Invalid preview buffers!"); 345 return -EINVAL; 346 } 347 348 if ( ret == NO_ERROR ) 349 { 350 ret = setState(operation); 351 } 352 353 if ( ret == NO_ERROR ) 354 { 355 Mutex::Autolock lock(mPreviewBufferLock); 356 mPreviewBuffers = (int *) desc->mBuffers; 357 mPreviewBuffersLength = desc->mLength; 358 mPreviewBuffersAvailable.clear(); 359 for ( uint32_t i = 0 ; i < desc->mMaxQueueable ; i++ ) 360 { 361 mPreviewBuffersAvailable.add(mPreviewBuffers[i], 0); 362 } 363 // initial ref count for undeqeueued buffers is 1 since buffer provider 364 // is still holding on to it 365 for ( uint32_t i = desc->mMaxQueueable ; i < desc->mCount ; i++ ) 366 { 367 mPreviewBuffersAvailable.add(mPreviewBuffers[i], 1); 368 } 369 } 370 371 if ( NULL != desc ) 372 { 373 ret = useBuffers(CameraAdapter::CAMERA_PREVIEW, 374 desc->mBuffers, 375 desc->mCount, 376 desc->mLength, 377 desc->mMaxQueueable); 378 } 379 380 if ( ret == NO_ERROR ) 381 { 382 ret = commitState(); 383 } 384 else 385 { 386 ret |= rollbackState(); 387 } 388 389 break; 390 391 case CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW_DATA: 392 CAMHAL_LOGDA("Use buffers for preview data"); 393 desc = ( BuffersDescriptor * ) value1; 394 395 if ( NULL == desc ) 396 { 397 CAMHAL_LOGEA("Invalid preview data buffers!"); 398 return -EINVAL; 399 } 400 401 if ( ret == NO_ERROR ) 402 { 403 ret = setState(operation); 404 } 405 406 if ( ret == NO_ERROR ) 407 { 408 Mutex::Autolock lock(mPreviewDataBufferLock); 409 mPreviewDataBuffers = (int *) desc->mBuffers; 410 mPreviewDataBuffersLength = desc->mLength; 411 mPreviewDataBuffersAvailable.clear(); 412 for ( uint32_t i = 0 ; i < desc->mMaxQueueable ; i++ ) 413 { 414 mPreviewDataBuffersAvailable.add(mPreviewDataBuffers[i], 0); 415 } 416 // initial ref count for undeqeueued buffers is 1 since buffer provider 417 // is still holding on to it 418 for ( uint32_t i = desc->mMaxQueueable ; i < desc->mCount ; i++ ) 419 { 420 mPreviewDataBuffersAvailable.add(mPreviewDataBuffers[i], 1); 421 } 422 } 423 424 if ( NULL != desc ) 425 { 426 ret = useBuffers(CameraAdapter::CAMERA_MEASUREMENT, 427 desc->mBuffers, 428 desc->mCount, 429 desc->mLength, 430 desc->mMaxQueueable); 431 } 432 433 if ( ret == NO_ERROR ) 434 { 435 ret = commitState(); 436 } 437 else 438 { 439 ret |= rollbackState(); 440 } 441 442 break; 443 444 case CameraAdapter::CAMERA_USE_BUFFERS_IMAGE_CAPTURE: 445 CAMHAL_LOGDA("Use buffers for image capture"); 446 desc = ( BuffersDescriptor * ) value1; 447 448 if ( NULL == desc ) 449 { 450 CAMHAL_LOGEA("Invalid capture buffers!"); 451 return -EINVAL; 452 } 453 454 if ( ret == NO_ERROR ) 455 { 456 ret = setState(operation); 457 } 458 459 if ( ret == NO_ERROR ) 460 { 461 Mutex::Autolock lock(mCaptureBufferLock); 462 mCaptureBuffers = (int *) desc->mBuffers; 463 mCaptureBuffersLength = desc->mLength; 464 mCaptureBuffersAvailable.clear(); 465 for ( uint32_t i = 0 ; i < desc->mMaxQueueable ; i++ ) 466 { 467 mCaptureBuffersAvailable.add(mCaptureBuffers[i], 0); 468 } 469 // initial ref count for undeqeueued buffers is 1 since buffer provider 470 // is still holding on to it 471 for ( uint32_t i = desc->mMaxQueueable ; i < desc->mCount ; i++ ) 472 { 473 mCaptureBuffersAvailable.add(mCaptureBuffers[i], 1); 474 } 475 } 476 477 if ( NULL != desc ) 478 { 479 ret = useBuffers(CameraAdapter::CAMERA_IMAGE_CAPTURE, 480 desc->mBuffers, 481 desc->mCount, 482 desc->mLength, 483 desc->mMaxQueueable); 484 } 485 486 if ( ret == NO_ERROR ) 487 { 488 ret = commitState(); 489 } 490 else 491 { 492 ret |= rollbackState(); 493 } 494 495 break; 496 497 case CameraAdapter::CAMERA_START_SMOOTH_ZOOM: 498 { 499 500 if ( ret == NO_ERROR ) 501 { 502 ret = setState(operation); 503 } 504 505 if ( ret == NO_ERROR ) 506 { 507 ret = startSmoothZoom(value1); 508 } 509 510 if ( ret == NO_ERROR ) 511 { 512 ret = commitState(); 513 } 514 else 515 { 516 ret |= rollbackState(); 517 } 518 519 break; 520 521 } 522 523 case CameraAdapter::CAMERA_STOP_SMOOTH_ZOOM: 524 { 525 526 if ( ret == NO_ERROR ) 527 { 528 ret = setState(operation); 529 } 530 531 if ( ret == NO_ERROR ) 532 { 533 ret = stopSmoothZoom(); 534 } 535 536 if ( ret == NO_ERROR ) 537 { 538 ret = commitState(); 539 } 540 else 541 { 542 ret |= rollbackState(); 543 } 544 545 break; 546 547 } 548 549 case CameraAdapter::CAMERA_START_PREVIEW: 550 { 551 552 CAMHAL_LOGDA("Start Preview"); 553 554 if ( ret == NO_ERROR ) 555 { 556 ret = setState(operation); 557 } 558 559 if ( ret == NO_ERROR ) 560 { 561 ret = startPreview(); 562 } 563 564 if ( ret == NO_ERROR ) 565 { 566 ret = commitState(); 567 } 568 else 569 { 570 ret |= rollbackState(); 571 } 572 573 break; 574 575 } 576 577 case CameraAdapter::CAMERA_STOP_PREVIEW: 578 { 579 580 CAMHAL_LOGDA("Stop Preview"); 581 582 if ( ret == NO_ERROR ) 583 { 584 ret = setState(operation); 585 } 586 587 if ( ret == NO_ERROR ) 588 { 589 ret = stopPreview(); 590 } 591 592 if ( ret == NO_ERROR ) 593 { 594 ret = commitState(); 595 } 596 else 597 { 598 ret |= rollbackState(); 599 } 600 601 break; 602 603 } 604 605 case CameraAdapter::CAMERA_START_VIDEO: 606 { 607 608 CAMHAL_LOGDA("Start video recording"); 609 610 if ( ret == NO_ERROR ) 611 { 612 ret = setState(operation); 613 } 614 615 if ( ret == NO_ERROR ) 616 { 617 ret = startVideoCapture(); 618 } 619 620 if ( ret == NO_ERROR ) 621 { 622 ret = commitState(); 623 } 624 else 625 { 626 ret |= rollbackState(); 627 } 628 629 break; 630 631 } 632 633 case CameraAdapter::CAMERA_STOP_VIDEO: 634 { 635 636 CAMHAL_LOGDA("Stop video recording"); 637 638 if ( ret == NO_ERROR ) 639 { 640 ret = setState(operation); 641 } 642 643 if ( ret == NO_ERROR ) 644 { 645 ret = stopVideoCapture(); 646 } 647 648 if ( ret == NO_ERROR ) 649 { 650 ret = commitState(); 651 } 652 else 653 { 654 ret |= rollbackState(); 655 } 656 657 break; 658 659 } 660 661 case CameraAdapter::CAMERA_PREVIEW_FLUSH_BUFFERS: 662 { 663 664 if ( ret == NO_ERROR ) 665 { 666 ret = setState(operation); 667 } 668 669 if ( ret == NO_ERROR ) 670 { 671 ret = flushBuffers(); 672 } 673 674 if ( ret == NO_ERROR ) 675 { 676 ret = commitState(); 677 } 678 else 679 { 680 ret |= rollbackState(); 681 } 682 683 break; 684 685 } 686 687 case CameraAdapter::CAMERA_START_IMAGE_CAPTURE: 688 { 689 690#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 691 692 refTimestamp = ( struct timeval * ) value1; 693 if ( NULL != refTimestamp ) 694 { 695 memcpy( &mStartCapture, refTimestamp, sizeof( struct timeval )); 696 } 697 698#endif 699 700 if ( ret == NO_ERROR ) 701 { 702 ret = setState(operation); 703 } 704 705 if ( ret == NO_ERROR ) 706 { 707 ret = takePicture(); 708 } 709 710 if ( ret == NO_ERROR ) 711 { 712 ret = commitState(); 713 } 714 else 715 { 716 ret |= rollbackState(); 717 } 718 719 break; 720 721 } 722 723 case CameraAdapter::CAMERA_STOP_IMAGE_CAPTURE: 724 { 725 726 if ( ret == NO_ERROR ) 727 { 728 ret = setState(operation); 729 } 730 731 if ( ret == NO_ERROR ) 732 { 733 ret = stopImageCapture(); 734 } 735 736 if ( ret == NO_ERROR ) 737 { 738 ret = commitState(); 739 } 740 else 741 { 742 ret |= rollbackState(); 743 } 744 745 break; 746 747 } 748 749 case CameraAdapter::CAMERA_START_BRACKET_CAPTURE: 750 { 751 752#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 753 754 refTimestamp = ( struct timeval * ) value2; 755 if ( NULL != refTimestamp ) 756 { 757 memcpy( &mStartCapture, refTimestamp, sizeof( struct timeval )); 758 } 759 760#endif 761 762 if ( ret == NO_ERROR ) 763 { 764 ret = setState(operation); 765 } 766 767 if ( ret == NO_ERROR ) 768 { 769 ret = startBracketing(value1); 770 } 771 772 if ( ret == NO_ERROR ) 773 { 774 ret = commitState(); 775 } 776 else 777 { 778 ret |= rollbackState(); 779 } 780 781 break; 782 783 } 784 785 case CameraAdapter::CAMERA_STOP_BRACKET_CAPTURE: 786 { 787 788 if ( ret == NO_ERROR ) 789 { 790 ret = setState(operation); 791 } 792 793 if ( ret == NO_ERROR ) 794 { 795 ret = stopBracketing(); 796 } 797 798 if ( ret == NO_ERROR ) 799 { 800 ret = commitState(); 801 } 802 else 803 { 804 ret |= rollbackState(); 805 } 806 807 break; 808 809 } 810 811 case CameraAdapter::CAMERA_PERFORM_AUTOFOCUS: 812 813#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 814 815 refTimestamp = ( struct timeval * ) value1; 816 if ( NULL != refTimestamp ) 817 { 818 memcpy( &mStartFocus, refTimestamp, sizeof( struct timeval )); 819 } 820 821#endif 822 823 if ( ret == NO_ERROR ) 824 { 825 ret = setState(operation); 826 } 827 828 if ( ret == NO_ERROR ) 829 { 830 ret = autoFocus(); 831 } 832 833 if ( ret == NO_ERROR ) 834 { 835 ret = commitState(); 836 } 837 else 838 { 839 ret |= rollbackState(); 840 } 841 842 break; 843 844 case CameraAdapter::CAMERA_CANCEL_AUTOFOCUS: 845 846 if ( ret == NO_ERROR ) 847 { 848 ret = setState(operation); 849 } 850 851 if ( ret == NO_ERROR ) 852 { 853 ret = cancelAutoFocus(); 854 } 855 856 if ( ret == NO_ERROR ) 857 { 858 ret = commitState(); 859 } 860 else 861 { 862 ret |= rollbackState(); 863 } 864 865 break; 866 867 case CameraAdapter::CAMERA_QUERY_RESOLUTION_PREVIEW: 868 869 if ( ret == NO_ERROR ) 870 { 871 ret = setState(operation); 872 } 873 874 if ( ret == NO_ERROR ) 875 { 876 frame = ( CameraFrame * ) value1; 877 878 if ( NULL != frame ) 879 { 880 ret = getFrameSize(frame->mWidth, frame->mHeight); 881 } 882 else 883 { 884 ret = -EINVAL; 885 } 886 } 887 888 if ( ret == NO_ERROR ) 889 { 890 ret = commitState(); 891 } 892 else 893 { 894 ret |= rollbackState(); 895 } 896 897 break; 898 899 case CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE: 900 901 if ( ret == NO_ERROR ) 902 { 903 ret = setState(operation); 904 } 905 906 if ( ret == NO_ERROR ) 907 { 908 frame = ( CameraFrame * ) value1; 909 910 if ( NULL != frame ) 911 { 912 ret = getPictureBufferSize(frame->mLength, value2); 913 } 914 else 915 { 916 ret = -EINVAL; 917 } 918 } 919 920 if ( ret == NO_ERROR ) 921 { 922 ret = commitState(); 923 } 924 else 925 { 926 ret |= rollbackState(); 927 } 928 929 break; 930 931 case CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA: 932 933 if ( ret == NO_ERROR ) 934 { 935 ret = setState(operation); 936 } 937 938 if ( ret == NO_ERROR ) 939 { 940 frame = ( CameraFrame * ) value1; 941 942 if ( NULL != frame ) 943 { 944 ret = getFrameDataSize(frame->mLength, value2); 945 } 946 else 947 { 948 ret = -EINVAL; 949 } 950 } 951 952 if ( ret == NO_ERROR ) 953 { 954 ret = commitState(); 955 } 956 else 957 { 958 ret |= rollbackState(); 959 } 960 961 break; 962 963 case CameraAdapter::CAMERA_START_FD: 964 965 ret = startFaceDetection(); 966 967 break; 968 969 case CameraAdapter::CAMERA_STOP_FD: 970 971 ret = stopFaceDetection(); 972 973 break; 974 975 case CameraAdapter::CAMERA_SWITCH_TO_EXECUTING: 976 ret = switchToExecuting(); 977 break; 978 979 default: 980 CAMHAL_LOGEB("Command 0x%x unsupported!", operation); 981 break; 982 }; 983 984 LOG_FUNCTION_NAME_EXIT; 985 return ret; 986} 987 988status_t BaseCameraAdapter::notifyFocusSubscribers(CameraHalEvent::FocusStatus status) 989{ 990 event_callback eventCb; 991 CameraHalEvent focusEvent; 992 status_t ret = NO_ERROR; 993 994 LOG_FUNCTION_NAME; 995 996 if ( mFocusSubscribers.size() == 0 ) { 997 CAMHAL_LOGDA("No Focus Subscribers!"); 998 return NO_INIT; 999 } 1000 1001#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 1002 if (status == CameraHalEvent::FOCUS_STATUS_PENDING) { 1003 gettimeofday(&mStartFocus, NULL); 1004 } else { 1005 //dump the AF latency 1006 CameraHal::PPM("Focus finished in: ", &mStartFocus); 1007 } 1008#endif 1009 1010 focusEvent.mEventData = new CameraHalEvent::CameraHalEventData(); 1011 if ( NULL == focusEvent.mEventData.get() ) { 1012 return -ENOMEM; 1013 } 1014 1015 focusEvent.mEventType = CameraHalEvent::EVENT_FOCUS_LOCKED; 1016 focusEvent.mEventData->focusEvent.focusStatus = status; 1017 1018 for (unsigned int i = 0 ; i < mFocusSubscribers.size(); i++ ) 1019 { 1020 focusEvent.mCookie = (void *) mFocusSubscribers.keyAt(i); 1021 eventCb = (event_callback) mFocusSubscribers.valueAt(i); 1022 eventCb ( &focusEvent ); 1023 } 1024 1025 focusEvent.mEventData.clear(); 1026 1027 LOG_FUNCTION_NAME_EXIT; 1028 1029 return ret; 1030} 1031 1032status_t BaseCameraAdapter::notifyShutterSubscribers() 1033{ 1034 CameraHalEvent shutterEvent; 1035 event_callback eventCb; 1036 status_t ret = NO_ERROR; 1037 1038 LOG_FUNCTION_NAME; 1039 1040 if ( mShutterSubscribers.size() == 0 ) 1041 { 1042 CAMHAL_LOGEA("No shutter Subscribers!"); 1043 return NO_INIT; 1044 } 1045 1046 shutterEvent.mEventData = new CameraHalEvent::CameraHalEventData(); 1047 if ( NULL == shutterEvent.mEventData.get() ) { 1048 return -ENOMEM; 1049 } 1050 1051 shutterEvent.mEventType = CameraHalEvent::EVENT_SHUTTER; 1052 shutterEvent.mEventData->shutterEvent.shutterClosed = true; 1053 1054 for (unsigned int i = 0 ; i < mShutterSubscribers.size() ; i++ ) { 1055 shutterEvent.mCookie = ( void * ) mShutterSubscribers.keyAt(i); 1056 eventCb = ( event_callback ) mShutterSubscribers.valueAt(i); 1057 1058 CAMHAL_LOGDA("Sending shutter callback"); 1059 1060 eventCb ( &shutterEvent ); 1061 } 1062 1063 shutterEvent.mEventData.clear(); 1064 1065 LOG_FUNCTION_NAME; 1066 1067 return ret; 1068} 1069 1070status_t BaseCameraAdapter::notifyZoomSubscribers(int zoomIdx, bool targetReached) 1071{ 1072 event_callback eventCb; 1073 CameraHalEvent zoomEvent; 1074 status_t ret = NO_ERROR; 1075 1076 LOG_FUNCTION_NAME; 1077 1078 if ( mZoomSubscribers.size() == 0 ) { 1079 CAMHAL_LOGDA("No zoom Subscribers!"); 1080 return NO_INIT; 1081 } 1082 1083 zoomEvent.mEventData = new CameraHalEvent::CameraHalEventData(); 1084 if ( NULL == zoomEvent.mEventData.get() ) { 1085 return -ENOMEM; 1086 } 1087 1088 zoomEvent.mEventType = CameraHalEvent::EVENT_ZOOM_INDEX_REACHED; 1089 zoomEvent.mEventData->zoomEvent.currentZoomIndex = zoomIdx; 1090 zoomEvent.mEventData->zoomEvent.targetZoomIndexReached = targetReached; 1091 1092 for (unsigned int i = 0 ; i < mZoomSubscribers.size(); i++ ) { 1093 zoomEvent.mCookie = (void *) mZoomSubscribers.keyAt(i); 1094 eventCb = (event_callback) mZoomSubscribers.valueAt(i); 1095 1096 eventCb ( &zoomEvent ); 1097 } 1098 1099 zoomEvent.mEventData.clear(); 1100 1101 LOG_FUNCTION_NAME_EXIT; 1102 1103 return ret; 1104} 1105 1106status_t BaseCameraAdapter::notifyFaceSubscribers(sp<CameraFDResult> &faces) 1107{ 1108 event_callback eventCb; 1109 CameraHalEvent faceEvent; 1110 status_t ret = NO_ERROR; 1111 1112 LOG_FUNCTION_NAME; 1113 1114 if ( mFaceSubscribers.size() == 0 ) { 1115 CAMHAL_LOGDA("No face detection subscribers!"); 1116 return NO_INIT; 1117 } 1118 1119 faceEvent.mEventData = new CameraHalEvent::CameraHalEventData(); 1120 if ( NULL == faceEvent.mEventData.get() ) { 1121 return -ENOMEM; 1122 } 1123 1124 faceEvent.mEventType = CameraHalEvent::EVENT_FACE; 1125 faceEvent.mEventData->faceEvent = faces; 1126 1127 for (unsigned int i = 0 ; i < mFaceSubscribers.size(); i++ ) { 1128 faceEvent.mCookie = (void *) mFaceSubscribers.keyAt(i); 1129 eventCb = (event_callback) mFaceSubscribers.valueAt(i); 1130 1131 eventCb ( &faceEvent ); 1132 } 1133 1134 faceEvent.mEventData.clear(); 1135 1136 LOG_FUNCTION_NAME_EXIT; 1137 1138 return ret; 1139} 1140 1141status_t BaseCameraAdapter::sendFrameToSubscribers(CameraFrame *frame) 1142{ 1143 status_t ret = NO_ERROR; 1144 unsigned int mask; 1145 1146 if ( NULL == frame ) 1147 { 1148 CAMHAL_LOGEA("Invalid CameraFrame"); 1149 return -EINVAL; 1150 } 1151 1152 for( mask = 1; mask < CameraFrame::ALL_FRAMES; mask <<= 1){ 1153 if( mask & frame->mFrameMask ){ 1154 switch( mask ){ 1155 1156 case CameraFrame::IMAGE_FRAME: 1157 { 1158#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 1159 CameraHal::PPM("Shot to Jpeg: ", &mStartCapture); 1160#endif 1161 ret = __sendFrameToSubscribers(frame, &mImageSubscribers, CameraFrame::IMAGE_FRAME); 1162 } 1163 break; 1164 case CameraFrame::RAW_FRAME: 1165 { 1166 ret = __sendFrameToSubscribers(frame, &mRawSubscribers, CameraFrame::RAW_FRAME); 1167 } 1168 break; 1169 case CameraFrame::PREVIEW_FRAME_SYNC: 1170 { 1171 ret = __sendFrameToSubscribers(frame, &mFrameSubscribers, CameraFrame::PREVIEW_FRAME_SYNC); 1172 } 1173 break; 1174 case CameraFrame::SNAPSHOT_FRAME: 1175 { 1176 ret = __sendFrameToSubscribers(frame, &mFrameSubscribers, CameraFrame::SNAPSHOT_FRAME); 1177 } 1178 break; 1179 case CameraFrame::VIDEO_FRAME_SYNC: 1180 { 1181 ret = __sendFrameToSubscribers(frame, &mVideoSubscribers, CameraFrame::VIDEO_FRAME_SYNC); 1182 } 1183 break; 1184 case CameraFrame::FRAME_DATA_SYNC: 1185 { 1186 ret = __sendFrameToSubscribers(frame, &mFrameDataSubscribers, CameraFrame::FRAME_DATA_SYNC); 1187 } 1188 break; 1189 default: 1190 CAMHAL_LOGEB("FRAMETYPE NOT SUPPORTED 0x%x", mask); 1191 break; 1192 }//SWITCH 1193 frame->mFrameMask &= ~mask; 1194 1195 if (ret != NO_ERROR) { 1196 goto EXIT; 1197 } 1198 }//IF 1199 }//FOR 1200 1201 EXIT: 1202 return ret; 1203} 1204 1205status_t BaseCameraAdapter::__sendFrameToSubscribers(CameraFrame* frame, 1206 KeyedVector<int, frame_callback> *subscribers, 1207 CameraFrame::FrameType frameType) 1208{ 1209 size_t refCount = 0; 1210 status_t ret = NO_ERROR; 1211 frame_callback callback = NULL; 1212 1213 frame->mFrameType = frameType; 1214 1215 if ( (frameType == CameraFrame::PREVIEW_FRAME_SYNC) || 1216 (frameType == CameraFrame::VIDEO_FRAME_SYNC) || 1217 (frameType == CameraFrame::SNAPSHOT_FRAME) ){ 1218 if (mFrameQueue.size() > 0){ 1219 CameraFrame *lframe = (CameraFrame *)mFrameQueue.valueFor(frame->mBuffer); 1220 frame->mYuv[0] = lframe->mYuv[0]; 1221 frame->mYuv[1] = lframe->mYuv[1]; 1222 } 1223 else{ 1224 CAMHAL_LOGDA("Empty Frame Queue"); 1225 return -EINVAL; 1226 } 1227 } 1228 1229 if (NULL != subscribers) { 1230 refCount = getFrameRefCount(frame->mBuffer, frameType); 1231 1232 if (refCount == 0) { 1233 CAMHAL_LOGDA("Invalid ref count of 0"); 1234 return -EINVAL; 1235 } 1236 1237 if (refCount > subscribers->size()) { 1238 CAMHAL_LOGEB("Invalid ref count for frame type: 0x%x", frameType); 1239 return -EINVAL; 1240 } 1241 1242 CAMHAL_LOGVB("Type of Frame: 0x%x address: 0x%x refCount start %d", 1243 frame->mFrameType, 1244 ( uint32_t ) frame->mBuffer, 1245 refCount); 1246 1247 for ( unsigned int i = 0 ; i < refCount; i++ ) { 1248 frame->mCookie = ( void * ) subscribers->keyAt(i); 1249 callback = (frame_callback) subscribers->valueAt(i); 1250 1251 if (!callback) { 1252 CAMHAL_LOGEB("callback not set for frame type: 0x%x", frameType); 1253 return -EINVAL; 1254 } 1255 1256 callback(frame); 1257 } 1258 } else { 1259 CAMHAL_LOGEA("Subscribers is null??"); 1260 return -EINVAL; 1261 } 1262 1263 return ret; 1264} 1265 1266int BaseCameraAdapter::setInitFrameRefCount(void* buf, unsigned int mask) 1267{ 1268 int ret = NO_ERROR; 1269 unsigned int lmask; 1270 1271 LOG_FUNCTION_NAME; 1272 1273 if (buf == NULL) 1274 { 1275 return -EINVAL; 1276 } 1277 1278 for( lmask = 1; lmask < CameraFrame::ALL_FRAMES; lmask <<= 1){ 1279 if( lmask & mask ){ 1280 switch( lmask ){ 1281 1282 case CameraFrame::IMAGE_FRAME: 1283 { 1284 setFrameRefCount(buf, CameraFrame::IMAGE_FRAME, (int) mImageSubscribers.size()); 1285 } 1286 break; 1287 case CameraFrame::RAW_FRAME: 1288 { 1289 setFrameRefCount(buf, CameraFrame::RAW_FRAME, mRawSubscribers.size()); 1290 } 1291 break; 1292 case CameraFrame::PREVIEW_FRAME_SYNC: 1293 { 1294 setFrameRefCount(buf, CameraFrame::PREVIEW_FRAME_SYNC, mFrameSubscribers.size()); 1295 } 1296 break; 1297 case CameraFrame::SNAPSHOT_FRAME: 1298 { 1299 setFrameRefCount(buf, CameraFrame::SNAPSHOT_FRAME, mFrameSubscribers.size()); 1300 } 1301 break; 1302 case CameraFrame::VIDEO_FRAME_SYNC: 1303 { 1304 setFrameRefCount(buf,CameraFrame::VIDEO_FRAME_SYNC, mVideoSubscribers.size()); 1305 } 1306 break; 1307 case CameraFrame::FRAME_DATA_SYNC: 1308 { 1309 setFrameRefCount(buf, CameraFrame::FRAME_DATA_SYNC, mFrameDataSubscribers.size()); 1310 } 1311 break; 1312 default: 1313 CAMHAL_LOGEB("FRAMETYPE NOT SUPPORTED 0x%x", lmask); 1314 break; 1315 }//SWITCH 1316 mask &= ~lmask; 1317 }//IF 1318 }//FOR 1319 LOG_FUNCTION_NAME_EXIT; 1320 return ret; 1321} 1322 1323int BaseCameraAdapter::getFrameRefCount(void* frameBuf, CameraFrame::FrameType frameType) 1324{ 1325 int res = -1; 1326 1327 LOG_FUNCTION_NAME; 1328 1329 switch ( frameType ) 1330 { 1331 case CameraFrame::IMAGE_FRAME: 1332 case CameraFrame::RAW_FRAME: 1333 { 1334 Mutex::Autolock lock(mCaptureBufferLock); 1335 res = mCaptureBuffersAvailable.valueFor( ( unsigned int ) frameBuf ); 1336 } 1337 break; 1338 case CameraFrame::PREVIEW_FRAME_SYNC: 1339 case CameraFrame::SNAPSHOT_FRAME: 1340 { 1341 Mutex::Autolock lock(mPreviewBufferLock); 1342 res = mPreviewBuffersAvailable.valueFor( ( unsigned int ) frameBuf ); 1343 } 1344 break; 1345 case CameraFrame::FRAME_DATA_SYNC: 1346 { 1347 Mutex::Autolock lock(mPreviewDataBufferLock); 1348 res = mPreviewDataBuffersAvailable.valueFor( ( unsigned int ) frameBuf ); 1349 } 1350 break; 1351 case CameraFrame::VIDEO_FRAME_SYNC: 1352 { 1353 Mutex::Autolock lock(mVideoBufferLock); 1354 res = mVideoBuffersAvailable.valueFor( ( unsigned int ) frameBuf ); 1355 } 1356 break; 1357 default: 1358 break; 1359 }; 1360 1361 LOG_FUNCTION_NAME_EXIT; 1362 1363 return res; 1364} 1365 1366void BaseCameraAdapter::setFrameRefCount(void* frameBuf, CameraFrame::FrameType frameType, int refCount) 1367{ 1368 1369 LOG_FUNCTION_NAME; 1370 1371 switch ( frameType ) 1372 { 1373 case CameraFrame::IMAGE_FRAME: 1374 case CameraFrame::RAW_FRAME: 1375 { 1376 Mutex::Autolock lock(mCaptureBufferLock); 1377 mCaptureBuffersAvailable.replaceValueFor( ( unsigned int ) frameBuf, refCount); 1378 } 1379 break; 1380 case CameraFrame::PREVIEW_FRAME_SYNC: 1381 case CameraFrame::SNAPSHOT_FRAME: 1382 { 1383 Mutex::Autolock lock(mPreviewBufferLock); 1384 mPreviewBuffersAvailable.replaceValueFor( ( unsigned int ) frameBuf, refCount); 1385 } 1386 break; 1387 case CameraFrame::FRAME_DATA_SYNC: 1388 { 1389 Mutex::Autolock lock(mPreviewDataBufferLock); 1390 mPreviewDataBuffersAvailable.replaceValueFor( ( unsigned int ) frameBuf, refCount); 1391 } 1392 break; 1393 case CameraFrame::VIDEO_FRAME_SYNC: 1394 { 1395 Mutex::Autolock lock(mVideoBufferLock); 1396 mVideoBuffersAvailable.replaceValueFor( ( unsigned int ) frameBuf, refCount); 1397 } 1398 break; 1399 default: 1400 break; 1401 }; 1402 1403 LOG_FUNCTION_NAME_EXIT; 1404 1405} 1406 1407status_t BaseCameraAdapter::startVideoCapture() 1408{ 1409 status_t ret = NO_ERROR; 1410 1411 LOG_FUNCTION_NAME; 1412 1413 Mutex::Autolock lock(mVideoBufferLock); 1414 1415 //If the capture is already ongoing, return from here. 1416 if ( mRecording ) 1417 { 1418 ret = NO_INIT; 1419 } 1420 1421 1422 if ( NO_ERROR == ret ) 1423 { 1424 1425 for ( unsigned int i = 0 ; i < mPreviewBuffersAvailable.size() ; i++ ) 1426 { 1427 mVideoBuffersAvailable.add(mPreviewBuffersAvailable.keyAt(i), 0); 1428 } 1429 1430 mRecording = true; 1431 } 1432 1433 LOG_FUNCTION_NAME_EXIT; 1434 1435 return ret; 1436} 1437 1438status_t BaseCameraAdapter::stopVideoCapture() 1439{ 1440 status_t ret = NO_ERROR; 1441 1442 LOG_FUNCTION_NAME; 1443 1444 if ( !mRecording ) 1445 { 1446 ret = NO_INIT; 1447 } 1448 1449 if ( NO_ERROR == ret ) 1450 { 1451 for ( unsigned int i = 0 ; i < mVideoBuffersAvailable.size() ; i++ ) 1452 { 1453 void *frameBuf = ( void * ) mVideoBuffersAvailable.keyAt(i); 1454 if( getFrameRefCount(frameBuf, CameraFrame::VIDEO_FRAME_SYNC) > 0) 1455 { 1456 returnFrame(frameBuf, CameraFrame::VIDEO_FRAME_SYNC); 1457 } 1458 } 1459 1460 mVideoBuffersAvailable.clear(); 1461 1462 mRecording = false; 1463 } 1464 1465 LOG_FUNCTION_NAME_EXIT; 1466 1467 return ret; 1468} 1469 1470//-----------------Stub implementation of the interface ------------------------------ 1471 1472status_t BaseCameraAdapter::takePicture() 1473{ 1474 status_t ret = NO_ERROR; 1475 1476 LOG_FUNCTION_NAME; 1477 1478 LOG_FUNCTION_NAME_EXIT; 1479 1480 return ret; 1481} 1482 1483status_t BaseCameraAdapter::stopImageCapture() 1484{ 1485 status_t ret = NO_ERROR; 1486 1487 LOG_FUNCTION_NAME; 1488 1489 LOG_FUNCTION_NAME_EXIT; 1490 1491 return ret; 1492} 1493 1494status_t BaseCameraAdapter::startBracketing(int range) 1495{ 1496 status_t ret = NO_ERROR; 1497 1498 LOG_FUNCTION_NAME; 1499 1500 LOG_FUNCTION_NAME_EXIT; 1501 1502 return ret; 1503} 1504 1505status_t BaseCameraAdapter::stopBracketing() 1506{ 1507 status_t ret = NO_ERROR; 1508 1509 LOG_FUNCTION_NAME; 1510 1511 LOG_FUNCTION_NAME_EXIT; 1512 1513 return ret; 1514} 1515 1516status_t BaseCameraAdapter::autoFocus() 1517{ 1518 status_t ret = NO_ERROR; 1519 1520 LOG_FUNCTION_NAME; 1521 1522 notifyFocusSubscribers(CameraHalEvent::FOCUS_STATUS_FAIL); 1523 1524 LOG_FUNCTION_NAME_EXIT; 1525 1526 return ret; 1527} 1528 1529status_t BaseCameraAdapter::cancelAutoFocus() 1530{ 1531 status_t ret = NO_ERROR; 1532 1533 LOG_FUNCTION_NAME; 1534 1535 LOG_FUNCTION_NAME_EXIT; 1536 1537 return ret; 1538} 1539 1540status_t BaseCameraAdapter::startSmoothZoom(int targetIdx) 1541{ 1542 status_t ret = NO_ERROR; 1543 1544 LOG_FUNCTION_NAME; 1545 1546 LOG_FUNCTION_NAME_EXIT; 1547 1548 return ret; 1549} 1550 1551status_t BaseCameraAdapter::stopSmoothZoom() 1552{ 1553 status_t ret = NO_ERROR; 1554 1555 LOG_FUNCTION_NAME; 1556 1557 LOG_FUNCTION_NAME_EXIT; 1558 1559 return ret; 1560} 1561 1562status_t BaseCameraAdapter::startPreview() 1563{ 1564 status_t ret = NO_ERROR; 1565 1566 LOG_FUNCTION_NAME; 1567 1568 LOG_FUNCTION_NAME_EXIT; 1569 1570 return ret; 1571} 1572 1573status_t BaseCameraAdapter::stopPreview() 1574{ 1575 status_t ret = NO_ERROR; 1576 1577 LOG_FUNCTION_NAME; 1578 1579 LOG_FUNCTION_NAME_EXIT; 1580 1581 return ret; 1582} 1583 1584status_t BaseCameraAdapter::useBuffers(CameraMode mode, void* bufArr, int num, size_t length, unsigned int queueable) 1585{ 1586 status_t ret = NO_ERROR; 1587 1588 LOG_FUNCTION_NAME; 1589 1590 LOG_FUNCTION_NAME_EXIT; 1591 1592 return ret; 1593} 1594 1595status_t BaseCameraAdapter::fillThisBuffer(void* frameBuf, CameraFrame::FrameType frameType) 1596{ 1597 status_t ret = NO_ERROR; 1598 1599 LOG_FUNCTION_NAME; 1600 1601 LOG_FUNCTION_NAME_EXIT; 1602 1603 return ret; 1604} 1605 1606status_t BaseCameraAdapter::getFrameSize(size_t &width, size_t &height) 1607{ 1608 status_t ret = NO_ERROR; 1609 1610 LOG_FUNCTION_NAME; 1611 1612 LOG_FUNCTION_NAME_EXIT; 1613 1614 return ret; 1615} 1616 1617status_t BaseCameraAdapter::getFrameDataSize(size_t &dataFrameSize, size_t bufferCount) 1618{ 1619 status_t ret = NO_ERROR; 1620 1621 LOG_FUNCTION_NAME; 1622 1623 LOG_FUNCTION_NAME_EXIT; 1624 1625 return ret; 1626} 1627 1628status_t BaseCameraAdapter::getPictureBufferSize(size_t &length, size_t bufferCount) 1629{ 1630 status_t ret = NO_ERROR; 1631 1632 LOG_FUNCTION_NAME; 1633 1634 LOG_FUNCTION_NAME_EXIT; 1635 1636 return ret; 1637} 1638 1639status_t BaseCameraAdapter::startFaceDetection() 1640{ 1641 status_t ret = NO_ERROR; 1642 1643 LOG_FUNCTION_NAME; 1644 1645 LOG_FUNCTION_NAME_EXIT; 1646 1647 return ret; 1648} 1649 1650status_t BaseCameraAdapter::stopFaceDetection() 1651{ 1652 status_t ret = NO_ERROR; 1653 1654 LOG_FUNCTION_NAME; 1655 1656 LOG_FUNCTION_NAME_EXIT; 1657 1658 return ret; 1659} 1660 1661status_t BaseCameraAdapter::switchToExecuting() 1662{ 1663 status_t ret = NO_ERROR; 1664 LOG_FUNCTION_NAME; 1665 LOG_FUNCTION_NAME_EXIT; 1666 return ret; 1667} 1668 1669status_t BaseCameraAdapter::setState(CameraCommands operation) 1670{ 1671 status_t ret = NO_ERROR; 1672 1673 LOG_FUNCTION_NAME; 1674 1675 mLock.lock(); 1676 1677 switch ( mAdapterState ) 1678 { 1679 1680 case INTIALIZED_STATE: 1681 1682 switch ( operation ) 1683 { 1684 1685 case CAMERA_USE_BUFFERS_PREVIEW: 1686 CAMHAL_LOGDB("Adapter state switch INTIALIZED_STATE->LOADED_PREVIEW_STATE event = 0x%x", 1687 operation); 1688 mNextState = LOADED_PREVIEW_STATE; 1689 break; 1690 1691 //These events don't change the current state 1692 case CAMERA_QUERY_RESOLUTION_PREVIEW: 1693 case CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE: 1694 case CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA: 1695 CAMHAL_LOGDB("Adapter state switch INTIALIZED_STATE->INTIALIZED_STATE event = 0x%x", 1696 operation); 1697 mNextState = INTIALIZED_STATE; 1698 break; 1699 1700 case CAMERA_CANCEL_AUTOFOCUS: 1701 case CAMERA_STOP_BRACKET_CAPTURE: 1702 case CAMERA_STOP_IMAGE_CAPTURE: 1703 ret = INVALID_OPERATION; 1704 break; 1705 1706 default: 1707 CAMHAL_LOGEB("Adapter state switch INTIALIZED_STATE Invalid Op! event = 0x%x", 1708 operation); 1709 ret = INVALID_OPERATION; 1710 break; 1711 1712 } 1713 1714 break; 1715 1716 case LOADED_PREVIEW_STATE: 1717 1718 switch ( operation ) 1719 { 1720 1721 case CAMERA_START_PREVIEW: 1722 CAMHAL_LOGDB("Adapter state switch LOADED_PREVIEW_STATE->PREVIEW_STATE event = 0x%x", 1723 operation); 1724 mNextState = PREVIEW_STATE; 1725 break; 1726 1727 //These events don't change the current state 1728 case CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE: 1729 case CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA: 1730 case CAMERA_USE_BUFFERS_PREVIEW_DATA: 1731 CAMHAL_LOGDB("Adapter state switch LOADED_PREVIEW_STATE->LOADED_PREVIEW_STATE event = 0x%x", 1732 operation); 1733 mNextState = LOADED_PREVIEW_STATE; 1734 break; 1735 1736 default: 1737 CAMHAL_LOGDB("Adapter state switch LOADED_PREVIEW Invalid Op! event = 0x%x", 1738 operation); 1739 ret = INVALID_OPERATION; 1740 break; 1741 1742 } 1743 1744 break; 1745 1746 case PREVIEW_STATE: 1747 1748 switch ( operation ) 1749 { 1750 1751 case CAMERA_STOP_PREVIEW: 1752 CAMHAL_LOGDB("Adapter state switch PREVIEW_STATE->INTIALIZED_STATE event = 0x%x", 1753 operation); 1754 mNextState = INTIALIZED_STATE; 1755 break; 1756 1757 case CAMERA_PERFORM_AUTOFOCUS: 1758 CAMHAL_LOGDB("Adapter state switch PREVIEW_STATE->AF_STATE event = 0x%x", 1759 operation); 1760 mNextState = AF_STATE; 1761 break; 1762 1763 case CAMERA_START_SMOOTH_ZOOM: 1764 CAMHAL_LOGDB("Adapter state switch PREVIEW_STATE->ZOOM_STATE event = 0x%x", 1765 operation); 1766 mNextState = ZOOM_STATE; 1767 break; 1768 1769 case CAMERA_USE_BUFFERS_IMAGE_CAPTURE: 1770 CAMHAL_LOGDB("Adapter state switch PREVIEW_STATE->LOADED_CAPTURE_STATE event = 0x%x", 1771 operation); 1772 mNextState = LOADED_CAPTURE_STATE; 1773 break; 1774 1775 case CAMERA_START_VIDEO: 1776 CAMHAL_LOGDB("Adapter state switch PREVIEW_STATE->VIDEO_STATE event = 0x%x", 1777 operation); 1778 mNextState = VIDEO_STATE; 1779 break; 1780 1781 case CAMERA_CANCEL_AUTOFOCUS: 1782 case CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE: 1783 case CAMERA_STOP_SMOOTH_ZOOM: 1784 CAMHAL_LOGDB("Adapter state switch PREVIEW_ACTIVE->PREVIEW_ACTIVE event = 0x%x", 1785 operation); 1786 mNextState = PREVIEW_STATE; 1787 break; 1788 1789 default: 1790 CAMHAL_LOGEB("Adapter state switch PREVIEW_ACTIVE Invalid Op! event = 0x%x", 1791 operation); 1792 ret = INVALID_OPERATION; 1793 break; 1794 1795 } 1796 1797 break; 1798 1799 case LOADED_CAPTURE_STATE: 1800 1801 switch ( operation ) 1802 { 1803 1804 case CAMERA_START_IMAGE_CAPTURE: 1805 CAMHAL_LOGDB("Adapter state switch LOADED_CAPTURE_STATE->CAPTURE_STATE event = 0x%x", 1806 operation); 1807 mNextState = CAPTURE_STATE; 1808 break; 1809 1810 case CAMERA_START_BRACKET_CAPTURE: 1811 CAMHAL_LOGDB("Adapter state switch LOADED_CAPTURE_STATE->BRACKETING_STATE event = 0x%x", 1812 operation); 1813 mNextState = BRACKETING_STATE; 1814 break; 1815 1816 default: 1817 CAMHAL_LOGEB("Adapter state switch LOADED_CAPTURE_STATE Invalid Op! event = 0x%x", 1818 operation); 1819 ret = INVALID_OPERATION; 1820 break; 1821 1822 } 1823 1824 break; 1825 1826 case CAPTURE_STATE: 1827 1828 switch ( operation ) 1829 { 1830 case CAMERA_STOP_IMAGE_CAPTURE: 1831 case CAMERA_STOP_BRACKET_CAPTURE: 1832 CAMHAL_LOGDB("Adapter state switch CAPTURE_STATE->PREVIEW_STATE event = 0x%x", 1833 operation); 1834 mNextState = PREVIEW_STATE; 1835 break; 1836 1837 default: 1838 CAMHAL_LOGEB("Adapter state switch CAPTURE_STATE Invalid Op! event = 0x%x", 1839 operation); 1840 ret = INVALID_OPERATION; 1841 break; 1842 1843 } 1844 1845 break; 1846 1847 case BRACKETING_STATE: 1848 1849 switch ( operation ) 1850 { 1851 1852 case CAMERA_STOP_IMAGE_CAPTURE: 1853 case CAMERA_STOP_BRACKET_CAPTURE: 1854 CAMHAL_LOGDB("Adapter state switch BRACKETING_STATE->PREVIEW_STATE event = 0x%x", 1855 operation); 1856 mNextState = PREVIEW_STATE; 1857 break; 1858 1859 case CAMERA_START_IMAGE_CAPTURE: 1860 CAMHAL_LOGDB("Adapter state switch BRACKETING_STATE->CAPTURE_STATE event = 0x%x", 1861 operation); 1862 mNextState = CAPTURE_STATE; 1863 break; 1864 1865 default: 1866 CAMHAL_LOGEB("Adapter state switch BRACKETING_STATE Invalid Op! event = 0x%x", 1867 operation); 1868 ret = INVALID_OPERATION; 1869 break; 1870 1871 } 1872 1873 break; 1874 1875 case AF_STATE: 1876 1877 switch ( operation ) 1878 { 1879 1880 case CAMERA_CANCEL_AUTOFOCUS: 1881 CAMHAL_LOGDB("Adapter state switch AF_STATE->PREVIEW_STATE event = 0x%x", 1882 operation); 1883 mNextState = PREVIEW_STATE; 1884 break; 1885 1886 case CAMERA_START_SMOOTH_ZOOM: 1887 CAMHAL_LOGDB("Adapter state switch AF_STATE->AF_ZOOM_STATE event = 0x%x", 1888 operation); 1889 mNextState = AF_ZOOM_STATE; 1890 break; 1891 1892 default: 1893 CAMHAL_LOGEB("Adapter state switch AF_STATE Invalid Op! event = 0x%x", 1894 operation); 1895 ret = INVALID_OPERATION; 1896 break; 1897 1898 } 1899 1900 break; 1901 1902 case ZOOM_STATE: 1903 1904 switch ( operation ) 1905 { 1906 1907 case CAMERA_CANCEL_AUTOFOCUS: 1908 CAMHAL_LOGDB("Adapter state switch AF_STATE->PREVIEW_STATE event = 0x%x", 1909 operation); 1910 mNextState = ZOOM_STATE; 1911 break; 1912 1913 case CAMERA_STOP_SMOOTH_ZOOM: 1914 CAMHAL_LOGDB("Adapter state switch ZOOM_STATE->PREVIEW_STATE event = 0x%x", 1915 operation); 1916 mNextState = PREVIEW_STATE; 1917 break; 1918 1919 case CAMERA_PERFORM_AUTOFOCUS: 1920 CAMHAL_LOGDB("Adapter state switch ZOOM_STATE->AF_ZOOM_STATE event = 0x%x", 1921 operation); 1922 mNextState = AF_ZOOM_STATE; 1923 break; 1924 1925 case CAMERA_START_VIDEO: 1926 CAMHAL_LOGDB("Adapter state switch ZOOM_STATE->VIDEO_ZOOM_STATE event = 0x%x", 1927 operation); 1928 mNextState = VIDEO_ZOOM_STATE; 1929 break; 1930 1931 default: 1932 CAMHAL_LOGEB("Adapter state switch ZOOM_STATE Invalid Op! event = 0x%x", 1933 operation); 1934 ret = INVALID_OPERATION; 1935 break; 1936 1937 } 1938 1939 break; 1940 1941 case VIDEO_STATE: 1942 1943 switch ( operation ) 1944 { 1945 1946 case CAMERA_STOP_VIDEO: 1947 CAMHAL_LOGDB("Adapter state switch VIDEO_STATE->PREVIEW_STATE event = 0x%x", 1948 operation); 1949 mNextState = PREVIEW_STATE; 1950 break; 1951 1952 case CAMERA_PERFORM_AUTOFOCUS: 1953 CAMHAL_LOGDB("Adapter state switch VIDEO_STATE->VIDEO_AF_STATE event = 0x%x", 1954 operation); 1955 mNextState = VIDEO_AF_STATE; 1956 break; 1957 1958 case CAMERA_START_SMOOTH_ZOOM: 1959 CAMHAL_LOGDB("Adapter state switch VIDEO_STATE->VIDEO_ZOOM_STATE event = 0x%x", 1960 operation); 1961 mNextState = VIDEO_ZOOM_STATE; 1962 break; 1963 1964 case CAMERA_USE_BUFFERS_IMAGE_CAPTURE: 1965 CAMHAL_LOGDB("Adapter state switch VIDEO_STATE->VIDEO_LOADED_CAPTURE_STATE event = 0x%x", 1966 operation); 1967 mNextState = VIDEO_LOADED_CAPTURE_STATE; 1968 break; 1969 1970 case CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE: 1971 CAMHAL_LOGDB("Adapter state switch VIDEO_STATE->VIDEO_STATE event = 0x%x", 1972 operation); 1973 mNextState = VIDEO_STATE; 1974 break; 1975 1976 default: 1977 CAMHAL_LOGEB("Adapter state switch VIDEO_STATE Invalid Op! event = 0x%x", 1978 operation); 1979 ret = INVALID_OPERATION; 1980 break; 1981 1982 } 1983 1984 break; 1985 1986 case VIDEO_AF_STATE: 1987 1988 switch ( operation ) 1989 { 1990 1991 case CAMERA_CANCEL_AUTOFOCUS: 1992 CAMHAL_LOGDB("Adapter state switch VIDEO_AF_STATE->VIDEO_STATE event = 0x%x", 1993 operation); 1994 mNextState = VIDEO_STATE; 1995 break; 1996 1997 default: 1998 CAMHAL_LOGEB("Adapter state switch VIDEO_AF_STATE Invalid Op! event = 0x%x", 1999 operation); 2000 ret = INVALID_OPERATION; 2001 break; 2002 2003 } 2004 2005 break; 2006 2007 case VIDEO_LOADED_CAPTURE_STATE: 2008 2009 switch ( operation ) 2010 { 2011 2012 case CAMERA_START_IMAGE_CAPTURE: 2013 CAMHAL_LOGDB("Adapter state switch LOADED_CAPTURE_STATE->CAPTURE_STATE event = 0x%x", 2014 operation); 2015 mNextState = VIDEO_CAPTURE_STATE; 2016 break; 2017 2018 default: 2019 CAMHAL_LOGEB("Adapter state switch LOADED_CAPTURE_STATE Invalid Op! event = 0x%x", 2020 operation); 2021 ret = INVALID_OPERATION; 2022 break; 2023 2024 } 2025 2026 break; 2027 2028 case VIDEO_CAPTURE_STATE: 2029 2030 switch ( operation ) 2031 { 2032 case CAMERA_STOP_IMAGE_CAPTURE: 2033 CAMHAL_LOGDB("Adapter state switch CAPTURE_STATE->PREVIEW_STATE event = 0x%x", 2034 operation); 2035 mNextState = VIDEO_STATE; 2036 break; 2037 2038 default: 2039 CAMHAL_LOGEB("Adapter state switch CAPTURE_STATE Invalid Op! event = 0x%x", 2040 operation); 2041 ret = INVALID_OPERATION; 2042 break; 2043 2044 } 2045 2046 break; 2047 2048 case AF_ZOOM_STATE: 2049 2050 switch ( operation ) 2051 { 2052 2053 case CAMERA_STOP_SMOOTH_ZOOM: 2054 CAMHAL_LOGDB("Adapter state switch AF_ZOOM_STATE->AF_STATE event = 0x%x", 2055 operation); 2056 mNextState = AF_STATE; 2057 break; 2058 2059 case CAMERA_CANCEL_AUTOFOCUS: 2060 CAMHAL_LOGDB("Adapter state switch AF_ZOOM_STATE->ZOOM_STATE event = 0x%x", 2061 operation); 2062 mNextState = ZOOM_STATE; 2063 break; 2064 2065 default: 2066 CAMHAL_LOGEB("Adapter state switch AF_ZOOM_STATE Invalid Op! event = 0x%x", 2067 operation); 2068 ret = INVALID_OPERATION; 2069 break; 2070 2071 } 2072 2073 break; 2074 2075 case VIDEO_ZOOM_STATE: 2076 2077 switch ( operation ) 2078 { 2079 2080 case CAMERA_STOP_SMOOTH_ZOOM: 2081 CAMHAL_LOGDB("Adapter state switch VIDEO_ZOOM_STATE->VIDEO_STATE event = 0x%x", 2082 operation); 2083 mNextState = VIDEO_STATE; 2084 break; 2085 2086 case CAMERA_STOP_VIDEO: 2087 CAMHAL_LOGDB("Adapter state switch VIDEO_ZOOM_STATE->ZOOM_STATE event = 0x%x", 2088 operation); 2089 mNextState = ZOOM_STATE; 2090 break; 2091 2092 default: 2093 CAMHAL_LOGEB("Adapter state switch VIDEO_ZOOM_STATE Invalid Op! event = 0x%x", 2094 operation); 2095 ret = INVALID_OPERATION; 2096 break; 2097 2098 } 2099 2100 break; 2101 2102 case BRACKETING_ZOOM_STATE: 2103 2104 switch ( operation ) 2105 { 2106 2107 case CAMERA_STOP_SMOOTH_ZOOM: 2108 CAMHAL_LOGDB("Adapter state switch BRACKETING_ZOOM_STATE->BRACKETING_STATE event = 0x%x", 2109 operation); 2110 mNextState = BRACKETING_STATE; 2111 break; 2112 2113 default: 2114 CAMHAL_LOGEB("Adapter state switch BRACKETING_ZOOM_STATE Invalid Op! event = 0x%x", 2115 operation); 2116 ret = INVALID_OPERATION; 2117 break; 2118 2119 } 2120 2121 break; 2122 2123 default: 2124 CAMHAL_LOGEA("Invalid Adapter state!"); 2125 ret = INVALID_OPERATION; 2126 } 2127 2128 LOG_FUNCTION_NAME_EXIT; 2129 2130 return ret; 2131} 2132 2133status_t BaseCameraAdapter::rollbackToInitializedState() 2134{ 2135 status_t ret = NO_ERROR; 2136 2137 LOG_FUNCTION_NAME; 2138 2139 while ((getState() != INTIALIZED_STATE) && (ret == NO_ERROR)) { 2140 ret = rollbackToPreviousState(); 2141 } 2142 2143 LOG_FUNCTION_NAME_EXIT; 2144 2145 return ret; 2146} 2147 2148status_t BaseCameraAdapter::rollbackToPreviousState() 2149{ 2150 status_t ret = NO_ERROR; 2151 2152 LOG_FUNCTION_NAME; 2153 2154 CameraAdapter::AdapterState currentState = getState(); 2155 2156 switch (currentState) { 2157 case INTIALIZED_STATE: 2158 return NO_ERROR; 2159 2160 case PREVIEW_STATE: 2161 ret = sendCommand(CAMERA_STOP_PREVIEW); 2162 break; 2163 2164 case CAPTURE_STATE: 2165 ret = sendCommand(CAMERA_STOP_IMAGE_CAPTURE); 2166 break; 2167 2168 case BRACKETING_STATE: 2169 ret = sendCommand(CAMERA_STOP_BRACKET_CAPTURE); 2170 break; 2171 2172 case AF_STATE: 2173 ret = sendCommand(CAMERA_CANCEL_AUTOFOCUS); 2174 break; 2175 2176 case ZOOM_STATE: 2177 ret = sendCommand(CAMERA_STOP_SMOOTH_ZOOM); 2178 break; 2179 2180 case VIDEO_STATE: 2181 ret = sendCommand(CAMERA_STOP_VIDEO); 2182 break; 2183 2184 case VIDEO_AF_STATE: 2185 ret = sendCommand(CAMERA_CANCEL_AUTOFOCUS); 2186 break; 2187 2188 case VIDEO_CAPTURE_STATE: 2189 ret = sendCommand(CAMERA_STOP_IMAGE_CAPTURE); 2190 break; 2191 2192 case AF_ZOOM_STATE: 2193 ret = sendCommand(CAMERA_STOP_SMOOTH_ZOOM); 2194 break; 2195 2196 case VIDEO_ZOOM_STATE: 2197 ret = sendCommand(CAMERA_STOP_SMOOTH_ZOOM); 2198 break; 2199 2200 case BRACKETING_ZOOM_STATE: 2201 ret = sendCommand(CAMERA_STOP_SMOOTH_ZOOM); 2202 break; 2203 2204 default: 2205 CAMHAL_LOGEA("Invalid Adapter state!"); 2206 ret = INVALID_OPERATION; 2207 } 2208 2209 LOG_FUNCTION_NAME_EXIT; 2210 2211 return ret; 2212} 2213 2214//State transition finished successfully. 2215//Commit the state and unlock the adapter state. 2216status_t BaseCameraAdapter::commitState() 2217{ 2218 status_t ret = NO_ERROR; 2219 2220 LOG_FUNCTION_NAME; 2221 2222 mAdapterState = mNextState; 2223 2224 mLock.unlock(); 2225 2226 LOG_FUNCTION_NAME_EXIT; 2227 2228 return ret; 2229} 2230 2231status_t BaseCameraAdapter::rollbackState() 2232{ 2233 status_t ret = NO_ERROR; 2234 2235 LOG_FUNCTION_NAME; 2236 2237 mNextState = mAdapterState; 2238 2239 mLock.unlock(); 2240 2241 LOG_FUNCTION_NAME_EXIT; 2242 2243 return ret; 2244} 2245 2246// getNextState() and getState() 2247// publicly exposed functions to retrieve the adapter states 2248// please notice that these functions are locked 2249CameraAdapter::AdapterState BaseCameraAdapter::getState() 2250{ 2251 status_t ret = NO_ERROR; 2252 2253 LOG_FUNCTION_NAME; 2254 2255 Mutex::Autolock lock(mLock); 2256 2257 LOG_FUNCTION_NAME_EXIT; 2258 2259 return mAdapterState; 2260} 2261 2262CameraAdapter::AdapterState BaseCameraAdapter::getNextState() 2263{ 2264 status_t ret = NO_ERROR; 2265 2266 LOG_FUNCTION_NAME; 2267 2268 Mutex::Autolock lock(mLock); 2269 2270 LOG_FUNCTION_NAME_EXIT; 2271 2272 return mNextState; 2273} 2274 2275// getNextState() and getState() 2276// internal protected functions to retrieve the adapter states 2277// please notice that these functions are NOT locked to help 2278// internal functions query state in the middle of state 2279// transition 2280status_t BaseCameraAdapter::getState(AdapterState &state) 2281{ 2282 status_t ret = NO_ERROR; 2283 2284 LOG_FUNCTION_NAME; 2285 2286 state = mAdapterState; 2287 2288 LOG_FUNCTION_NAME_EXIT; 2289 2290 return ret; 2291} 2292 2293status_t BaseCameraAdapter::getNextState(AdapterState &state) 2294{ 2295 status_t ret = NO_ERROR; 2296 2297 LOG_FUNCTION_NAME; 2298 2299 state = mNextState; 2300 2301 LOG_FUNCTION_NAME_EXIT; 2302 2303 return ret; 2304} 2305 2306void BaseCameraAdapter::onOrientationEvent(uint32_t orientation, uint32_t tilt) 2307{ 2308 LOG_FUNCTION_NAME; 2309 LOG_FUNCTION_NAME_EXIT; 2310} 2311//----------------------------------------------------------------------------- 2312 2313 2314 2315}; 2316 2317/*--------------------Camera Adapter Class ENDS here-----------------------------*/ 2318 2319