BaseCameraAdapter.cpp revision ee6bb64f60c228d711dc1d6875d8f4b0ed88b6cf
1/* 2 * Copyright (C) Texas Instruments - http://www.ti.com/ 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 18 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::returnFrame(void* frameBuf, CameraFrame::FrameType frameType) 224{ 225 status_t res = NO_ERROR; 226 size_t subscriberCount = 0; 227 int refCount = -1; 228 229 Mutex::Autolock lock(mReturnFrameLock); 230 231 if ( NULL == frameBuf ) 232 { 233 CAMHAL_LOGEA("Invalid frameBuf"); 234 return; 235 } 236 237 if ( NO_ERROR == res) 238 { 239 240 refCount = getFrameRefCount(frameBuf, frameType); 241 242 if ( 0 < refCount ) 243 { 244 245 refCount--; 246 setFrameRefCount(frameBuf, frameType, refCount); 247 248 if ( ( mRecording ) && ( CameraFrame::VIDEO_FRAME_SYNC == frameType ) ) 249 { 250 refCount += getFrameRefCount(frameBuf, CameraFrame::PREVIEW_FRAME_SYNC); 251 } 252 else if ( ( mRecording ) && ( CameraFrame::PREVIEW_FRAME_SYNC == frameType ) ) 253 { 254 refCount += getFrameRefCount(frameBuf, CameraFrame::VIDEO_FRAME_SYNC); 255 } 256 257 } 258 else 259 { 260 return; 261 } 262 } 263 264 if ( NO_ERROR == res ) 265 { 266 //check if someone is holding this buffer 267 if ( 0 == refCount ) 268 { 269 res = fillThisBuffer(frameBuf, frameType); 270 } 271 } 272 273} 274 275status_t BaseCameraAdapter::sendCommand(CameraCommands operation, int value1, int value2, int value3) 276{ 277 status_t ret = NO_ERROR; 278 struct timeval *refTimestamp; 279 BuffersDescriptor *desc = NULL; 280 CameraFrame *frame = NULL; 281 282 LOG_FUNCTION_NAME; 283 284 switch ( operation ) { 285 case CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW: 286 CAMHAL_LOGDA("Use buffers for preview"); 287 desc = ( BuffersDescriptor * ) value1; 288 289 if ( NULL == desc ) 290 { 291 CAMHAL_LOGEA("Invalid preview buffers!"); 292 return -EINVAL; 293 } 294 295 if ( ret == NO_ERROR ) 296 { 297 ret = setState(operation); 298 } 299 300 if ( ret == NO_ERROR ) 301 { 302 Mutex::Autolock lock(mPreviewBufferLock); 303 mPreviewBuffers = (int *) desc->mBuffers; 304 mPreviewBuffersLength = desc->mLength; 305 mPreviewBuffersAvailable.clear(); 306 for ( uint32_t i = 0 ; i < desc->mMaxQueueable ; i++ ) 307 { 308 mPreviewBuffersAvailable.add(mPreviewBuffers[i], 0); 309 } 310 // initial ref count for undeqeueued buffers is 1 since buffer provider 311 // is still holding on to it 312 for ( uint32_t i = desc->mMaxQueueable ; i < desc->mCount ; i++ ) 313 { 314 mPreviewBuffersAvailable.add(mPreviewBuffers[i], 1); 315 } 316 } 317 318 if ( NULL != desc ) 319 { 320 ret = useBuffers(CameraAdapter::CAMERA_PREVIEW, 321 desc->mBuffers, 322 desc->mCount, 323 desc->mLength, 324 desc->mMaxQueueable); 325 } 326 327 if ( ret == NO_ERROR ) 328 { 329 ret = commitState(); 330 } 331 else 332 { 333 ret |= rollbackState(); 334 } 335 336 break; 337 338 case CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW_DATA: 339 CAMHAL_LOGDA("Use buffers for preview data"); 340 desc = ( BuffersDescriptor * ) value1; 341 342 if ( NULL == desc ) 343 { 344 CAMHAL_LOGEA("Invalid preview data 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(mPreviewDataBufferLock); 356 mPreviewDataBuffers = (int *) desc->mBuffers; 357 mPreviewDataBuffersLength = desc->mLength; 358 mPreviewDataBuffersAvailable.clear(); 359 for ( uint32_t i = 0 ; i < desc->mMaxQueueable ; i++ ) 360 { 361 mPreviewDataBuffersAvailable.add(mPreviewDataBuffers[i], true); 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 mPreviewDataBuffersAvailable.add(mPreviewBuffers[i], 1); 368 } 369 } 370 371 if ( NULL != desc ) 372 { 373 ret = useBuffers(CameraAdapter::CAMERA_MEASUREMENT, 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_IMAGE_CAPTURE: 392 CAMHAL_LOGDA("Use buffers for image capture"); 393 desc = ( BuffersDescriptor * ) value1; 394 395 if ( NULL == desc ) 396 { 397 CAMHAL_LOGEA("Invalid capture 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(mCaptureBufferLock); 409 mCaptureBuffers = (int *) desc->mBuffers; 410 mCaptureBuffersLength = desc->mLength; 411 mCaptureBuffersAvailable.clear(); 412 for ( uint32_t i = 0 ; i < desc->mMaxQueueable ; i++ ) 413 { 414 mCaptureBuffersAvailable.add(mCaptureBuffers[i], true); 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 mCaptureBuffersAvailable.add(mPreviewBuffers[i], 1); 421 } 422 } 423 424 if ( NULL != desc ) 425 { 426 ret = useBuffers(CameraAdapter::CAMERA_IMAGE_CAPTURE, 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_START_SMOOTH_ZOOM: 445 { 446 447 if ( ret == NO_ERROR ) 448 { 449 ret = setState(operation); 450 } 451 452 if ( ret == NO_ERROR ) 453 { 454 ret = startSmoothZoom(value1); 455 } 456 457 if ( ret == NO_ERROR ) 458 { 459 ret = commitState(); 460 } 461 else 462 { 463 ret |= rollbackState(); 464 } 465 466 break; 467 468 } 469 470 case CameraAdapter::CAMERA_STOP_SMOOTH_ZOOM: 471 { 472 473 if ( ret == NO_ERROR ) 474 { 475 ret = setState(operation); 476 } 477 478 if ( ret == NO_ERROR ) 479 { 480 ret = stopSmoothZoom(); 481 } 482 483 if ( ret == NO_ERROR ) 484 { 485 ret = commitState(); 486 } 487 else 488 { 489 ret |= rollbackState(); 490 } 491 492 break; 493 494 } 495 496 case CameraAdapter::CAMERA_START_PREVIEW: 497 { 498 499 CAMHAL_LOGDA("Start Preview"); 500 501 if ( ret == NO_ERROR ) 502 { 503 ret = setState(operation); 504 } 505 506 if ( ret == NO_ERROR ) 507 { 508 ret = startPreview(); 509 } 510 511 if ( ret == NO_ERROR ) 512 { 513 ret = commitState(); 514 } 515 else 516 { 517 ret |= rollbackState(); 518 } 519 520 break; 521 522 } 523 524 case CameraAdapter::CAMERA_STOP_PREVIEW: 525 { 526 527 CAMHAL_LOGDA("Stop Preview"); 528 529 if ( ret == NO_ERROR ) 530 { 531 ret = setState(operation); 532 } 533 534 if ( ret == NO_ERROR ) 535 { 536 ret = stopPreview(); 537 } 538 539 if ( ret == NO_ERROR ) 540 { 541 ret = commitState(); 542 } 543 else 544 { 545 ret |= rollbackState(); 546 } 547 548 break; 549 550 } 551 552 case CameraAdapter::CAMERA_START_VIDEO: 553 { 554 555 CAMHAL_LOGDA("Start video recording"); 556 557 if ( ret == NO_ERROR ) 558 { 559 ret = setState(operation); 560 } 561 562 if ( ret == NO_ERROR ) 563 { 564 ret = startVideoCapture(); 565 } 566 567 if ( ret == NO_ERROR ) 568 { 569 ret = commitState(); 570 } 571 else 572 { 573 ret |= rollbackState(); 574 } 575 576 break; 577 578 } 579 580 case CameraAdapter::CAMERA_STOP_VIDEO: 581 { 582 583 CAMHAL_LOGDA("Stop video recording"); 584 585 if ( ret == NO_ERROR ) 586 { 587 ret = setState(operation); 588 } 589 590 if ( ret == NO_ERROR ) 591 { 592 ret = stopVideoCapture(); 593 } 594 595 if ( ret == NO_ERROR ) 596 { 597 ret = commitState(); 598 } 599 else 600 { 601 ret |= rollbackState(); 602 } 603 604 break; 605 606 } 607 608 case CameraAdapter::CAMERA_PREVIEW_FLUSH_BUFFERS: 609 { 610 611 if ( ret == NO_ERROR ) 612 { 613 ret = setState(operation); 614 } 615 616 if ( ret == NO_ERROR ) 617 { 618 ret = flushBuffers(); 619 } 620 621 if ( ret == NO_ERROR ) 622 { 623 ret = commitState(); 624 } 625 else 626 { 627 ret |= rollbackState(); 628 } 629 630 break; 631 632 } 633 634 case CameraAdapter::CAMERA_START_IMAGE_CAPTURE: 635 { 636 637#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 638 639 refTimestamp = ( struct timeval * ) value1; 640 if ( NULL != refTimestamp ) 641 { 642 memcpy( &mStartCapture, refTimestamp, sizeof( struct timeval )); 643 } 644 645#endif 646 647 if ( ret == NO_ERROR ) 648 { 649 ret = setState(operation); 650 } 651 652 if ( ret == NO_ERROR ) 653 { 654 ret = takePicture(); 655 } 656 657 if ( ret == NO_ERROR ) 658 { 659 ret = commitState(); 660 } 661 else 662 { 663 ret |= rollbackState(); 664 } 665 666 break; 667 668 } 669 670 case CameraAdapter::CAMERA_STOP_IMAGE_CAPTURE: 671 { 672 673 if ( ret == NO_ERROR ) 674 { 675 ret = setState(operation); 676 } 677 678 if ( ret == NO_ERROR ) 679 { 680 ret = stopImageCapture(); 681 } 682 683 if ( ret == NO_ERROR ) 684 { 685 ret = commitState(); 686 } 687 else 688 { 689 ret |= rollbackState(); 690 } 691 692 break; 693 694 } 695 696 case CameraAdapter::CAMERA_START_BRACKET_CAPTURE: 697 { 698 699#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 700 701 refTimestamp = ( struct timeval * ) value2; 702 if ( NULL != refTimestamp ) 703 { 704 memcpy( &mStartCapture, refTimestamp, sizeof( struct timeval )); 705 } 706 707#endif 708 709 if ( ret == NO_ERROR ) 710 { 711 ret = setState(operation); 712 } 713 714 if ( ret == NO_ERROR ) 715 { 716 ret = startBracketing(value1); 717 } 718 719 if ( ret == NO_ERROR ) 720 { 721 ret = commitState(); 722 } 723 else 724 { 725 ret |= rollbackState(); 726 } 727 728 break; 729 730 } 731 732 case CameraAdapter::CAMERA_STOP_BRACKET_CAPTURE: 733 { 734 735 if ( ret == NO_ERROR ) 736 { 737 ret = setState(operation); 738 } 739 740 if ( ret == NO_ERROR ) 741 { 742 ret = stopBracketing(); 743 } 744 745 if ( ret == NO_ERROR ) 746 { 747 ret = commitState(); 748 } 749 else 750 { 751 ret |= rollbackState(); 752 } 753 754 break; 755 756 } 757 758 case CameraAdapter::CAMERA_PERFORM_AUTOFOCUS: 759 760#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 761 762 refTimestamp = ( struct timeval * ) value1; 763 if ( NULL != refTimestamp ) 764 { 765 memcpy( &mStartFocus, refTimestamp, sizeof( struct timeval )); 766 } 767 768#endif 769 770 if ( ret == NO_ERROR ) 771 { 772 ret = setState(operation); 773 } 774 775 if ( ret == NO_ERROR ) 776 { 777 ret = autoFocus(); 778 } 779 780 if ( ret == NO_ERROR ) 781 { 782 ret = commitState(); 783 } 784 else 785 { 786 ret |= rollbackState(); 787 } 788 789 break; 790 791 case CameraAdapter::CAMERA_CANCEL_AUTOFOCUS: 792 793 if ( ret == NO_ERROR ) 794 { 795 ret = setState(operation); 796 } 797 798 if ( ret == NO_ERROR ) 799 { 800 ret = cancelAutoFocus(); 801 } 802 803 if ( ret == NO_ERROR ) 804 { 805 ret = commitState(); 806 } 807 else 808 { 809 ret |= rollbackState(); 810 } 811 812 break; 813 814 case CameraAdapter::CAMERA_QUERY_RESOLUTION_PREVIEW: 815 816 if ( ret == NO_ERROR ) 817 { 818 ret = setState(operation); 819 } 820 821 if ( ret == NO_ERROR ) 822 { 823 frame = ( CameraFrame * ) value1; 824 825 if ( NULL != frame ) 826 { 827 ret = getFrameSize(frame->mWidth, frame->mHeight); 828 } 829 else 830 { 831 ret = -EINVAL; 832 } 833 } 834 835 if ( ret == NO_ERROR ) 836 { 837 ret = commitState(); 838 } 839 else 840 { 841 ret |= rollbackState(); 842 } 843 844 break; 845 846 case CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE: 847 848 if ( ret == NO_ERROR ) 849 { 850 ret = setState(operation); 851 } 852 853 if ( ret == NO_ERROR ) 854 { 855 frame = ( CameraFrame * ) value1; 856 857 if ( NULL != frame ) 858 { 859 ret = getPictureBufferSize(frame->mLength, value2); 860 } 861 else 862 { 863 ret = -EINVAL; 864 } 865 } 866 867 if ( ret == NO_ERROR ) 868 { 869 ret = commitState(); 870 } 871 else 872 { 873 ret |= rollbackState(); 874 } 875 876 break; 877 878 case CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA: 879 880 if ( ret == NO_ERROR ) 881 { 882 ret = setState(operation); 883 } 884 885 if ( ret == NO_ERROR ) 886 { 887 frame = ( CameraFrame * ) value1; 888 889 if ( NULL != frame ) 890 { 891 ret = getFrameDataSize(frame->mLength, value2); 892 } 893 else 894 { 895 ret = -EINVAL; 896 } 897 } 898 899 if ( ret == NO_ERROR ) 900 { 901 ret = commitState(); 902 } 903 else 904 { 905 ret |= rollbackState(); 906 } 907 908 break; 909 910 case CameraAdapter::CAMERA_START_FD: 911 912 ret = startFaceDetection(); 913 914 break; 915 916 case CameraAdapter::CAMERA_STOP_FD: 917 918 ret = stopFaceDetection(); 919 920 break; 921 922 default: 923 CAMHAL_LOGEB("Command 0x%x unsupported!", operation); 924 break; 925 }; 926 927 LOG_FUNCTION_NAME_EXIT; 928 return ret; 929} 930 931status_t BaseCameraAdapter::notifyFocusSubscribers(bool status) 932{ 933 event_callback eventCb; 934 CameraHalEvent focusEvent; 935 status_t ret = NO_ERROR; 936 937 LOG_FUNCTION_NAME; 938 939 if ( mFocusSubscribers.size() == 0 ) { 940 CAMHAL_LOGDA("No Focus Subscribers!"); 941 return NO_INIT; 942 } 943 944#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 945 946 //dump the AF latency 947 CameraHal::PPM("Focus finished in: ", &mStartFocus); 948 949#endif 950 951 focusEvent.mEventData = new CameraHalEvent::CameraHalEventData(); 952 if ( NULL == focusEvent.mEventData.get() ) { 953 return -ENOMEM; 954 } 955 956 focusEvent.mEventType = CameraHalEvent::EVENT_FOCUS_LOCKED; 957 focusEvent.mEventData->focusEvent.focusLocked = status; 958 focusEvent.mEventData->focusEvent.focusError = !status; 959 960 for (unsigned int i = 0 ; i < mFocusSubscribers.size(); i++ ) 961 { 962 focusEvent.mCookie = (void *) mFocusSubscribers.keyAt(i); 963 eventCb = (event_callback) mFocusSubscribers.valueAt(i); 964 eventCb ( &focusEvent ); 965 } 966 967 focusEvent.mEventData.clear(); 968 969 LOG_FUNCTION_NAME_EXIT; 970 971 return ret; 972} 973 974status_t BaseCameraAdapter::notifyShutterSubscribers() 975{ 976 CameraHalEvent shutterEvent; 977 event_callback eventCb; 978 status_t ret = NO_ERROR; 979 980 LOG_FUNCTION_NAME; 981 982 if ( mShutterSubscribers.size() == 0 ) 983 { 984 CAMHAL_LOGEA("No shutter Subscribers!"); 985 return NO_INIT; 986 } 987 988 shutterEvent.mEventData = new CameraHalEvent::CameraHalEventData(); 989 if ( NULL == shutterEvent.mEventData.get() ) { 990 return -ENOMEM; 991 } 992 993 shutterEvent.mEventType = CameraHalEvent::EVENT_SHUTTER; 994 shutterEvent.mEventData->shutterEvent.shutterClosed = true; 995 996 for (unsigned int i = 0 ; i < mShutterSubscribers.size() ; i++ ) { 997 shutterEvent.mCookie = ( void * ) mShutterSubscribers.keyAt(i); 998 eventCb = ( event_callback ) mShutterSubscribers.valueAt(i); 999 1000 CAMHAL_LOGEA("Sending shutter callback"); 1001 1002 eventCb ( &shutterEvent ); 1003 } 1004 1005 shutterEvent.mEventData.clear(); 1006 1007 LOG_FUNCTION_NAME; 1008 1009 return ret; 1010} 1011 1012status_t BaseCameraAdapter::notifyZoomSubscribers(int zoomIdx, bool targetReached) 1013{ 1014 event_callback eventCb; 1015 CameraHalEvent zoomEvent; 1016 status_t ret = NO_ERROR; 1017 1018 LOG_FUNCTION_NAME; 1019 1020 if ( mZoomSubscribers.size() == 0 ) { 1021 CAMHAL_LOGDA("No zoom Subscribers!"); 1022 return NO_INIT; 1023 } 1024 1025 zoomEvent.mEventData = new CameraHalEvent::CameraHalEventData(); 1026 if ( NULL == zoomEvent.mEventData.get() ) { 1027 return -ENOMEM; 1028 } 1029 1030 zoomEvent.mEventType = CameraHalEvent::EVENT_ZOOM_INDEX_REACHED; 1031 zoomEvent.mEventData->zoomEvent.currentZoomIndex = zoomIdx; 1032 zoomEvent.mEventData->zoomEvent.targetZoomIndexReached = targetReached; 1033 1034 for (unsigned int i = 0 ; i < mZoomSubscribers.size(); i++ ) { 1035 zoomEvent.mCookie = (void *) mZoomSubscribers.keyAt(i); 1036 eventCb = (event_callback) mZoomSubscribers.valueAt(i); 1037 1038 eventCb ( &zoomEvent ); 1039 } 1040 1041 zoomEvent.mEventData.clear(); 1042 1043 LOG_FUNCTION_NAME_EXIT; 1044 1045 return ret; 1046} 1047 1048status_t BaseCameraAdapter::notifyFaceSubscribers(sp<CameraFDResult> &faces) 1049{ 1050 event_callback eventCb; 1051 CameraHalEvent faceEvent; 1052 status_t ret = NO_ERROR; 1053 1054 LOG_FUNCTION_NAME; 1055 1056 if ( mFaceSubscribers.size() == 0 ) { 1057 CAMHAL_LOGDA("No face detection subscribers!"); 1058 return NO_INIT; 1059 } 1060 1061 faceEvent.mEventData = new CameraHalEvent::CameraHalEventData(); 1062 if ( NULL == faceEvent.mEventData.get() ) { 1063 return -ENOMEM; 1064 } 1065 1066 faceEvent.mEventType = CameraHalEvent::EVENT_FACE; 1067 faceEvent.mEventData->faceEvent = faces; 1068 1069 for (unsigned int i = 0 ; i < mFaceSubscribers.size(); i++ ) { 1070 faceEvent.mCookie = (void *) mFaceSubscribers.keyAt(i); 1071 eventCb = (event_callback) mFaceSubscribers.valueAt(i); 1072 1073 eventCb ( &faceEvent ); 1074 } 1075 1076 faceEvent.mEventData.clear(); 1077 1078 LOG_FUNCTION_NAME_EXIT; 1079 1080 return ret; 1081} 1082 1083status_t BaseCameraAdapter::sendFrameToSubscribers(CameraFrame *frame) 1084{ 1085 status_t ret = NO_ERROR; 1086 frame_callback callback; 1087 uint32_t i = 0; 1088 KeyedVector<int, frame_callback> *subscribers = NULL; 1089 size_t refCount = 0; 1090 1091 if ( NULL == frame ) 1092 { 1093 CAMHAL_LOGEA("Invalid CameraFrame"); 1094 ret = -EINVAL; 1095 } 1096 1097 if ( NO_ERROR == ret ) 1098 { 1099 1100 switch(frame->mFrameType) 1101 { 1102 case CameraFrame::IMAGE_FRAME: 1103 { 1104 1105#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS 1106 1107 CameraHal::PPM("Shot to Jpeg: ", &mStartCapture); 1108 1109#endif 1110 1111 subscribers = &mImageSubscribers; 1112 break; 1113 } 1114 case CameraFrame::RAW_FRAME: 1115 { 1116 subscribers = &mRawSubscribers; 1117 break; 1118 } 1119 case CameraFrame::VIDEO_FRAME_SYNC: 1120 { 1121 subscribers = &mVideoSubscribers; 1122 break; 1123 } 1124 case CameraFrame::FRAME_DATA_SYNC: 1125 { 1126 subscribers = &mFrameDataSubscribers; 1127 break; 1128 } 1129 case CameraFrame::PREVIEW_FRAME_SYNC: 1130 case CameraFrame::SNAPSHOT_FRAME: 1131 { 1132 subscribers = &mFrameSubscribers; 1133 break; 1134 } 1135 default: 1136 { 1137 ret = -EINVAL; 1138 break; 1139 } 1140 }; 1141 1142 } 1143 1144 if ( ( NO_ERROR == ret ) && 1145 ( NULL != subscribers ) ) 1146 { 1147 Mutex::Autolock lock(mSubscriberLock); 1148 1149 refCount = subscribers->size(); 1150 CAMHAL_LOGVB("Type of Frame: 0x%x address: 0x%x refCount start %d", 1151 frame->mFrameType, 1152 ( uint32_t ) frame->mBuffer, 1153 refCount); 1154 1155 setFrameRefCount(frame->mBuffer, 1156 ( CameraFrame::FrameType ) frame->mFrameType, 1157 refCount); 1158 1159 for ( i = 0 ; i < subscribers->size(); i++ ) 1160 { 1161 frame->mCookie = ( void * ) subscribers->keyAt(i); 1162 callback = (frame_callback) subscribers->valueAt(i); 1163 callback(frame); 1164 } 1165 } 1166 1167 if ( 0 == i ) 1168 { 1169 //No subscribers for this frame 1170 ret = -1; 1171 } 1172 1173 return ret; 1174} 1175 1176int BaseCameraAdapter::getFrameRefCount(void* frameBuf, CameraFrame::FrameType frameType) 1177{ 1178 int res = -1; 1179 1180 LOG_FUNCTION_NAME; 1181 1182 switch ( frameType ) 1183 { 1184 case CameraFrame::IMAGE_FRAME: 1185 case CameraFrame::RAW_FRAME: 1186 { 1187 Mutex::Autolock lock(mCaptureBufferLock); 1188 res = mCaptureBuffersAvailable.valueFor( ( unsigned int ) frameBuf ); 1189 } 1190 break; 1191 case CameraFrame::PREVIEW_FRAME_SYNC: 1192 case CameraFrame::SNAPSHOT_FRAME: 1193 { 1194 Mutex::Autolock lock(mPreviewBufferLock); 1195 res = mPreviewBuffersAvailable.valueFor( ( unsigned int ) frameBuf ); 1196 } 1197 break; 1198 case CameraFrame::FRAME_DATA_SYNC: 1199 { 1200 Mutex::Autolock lock(mPreviewDataBufferLock); 1201 res = mPreviewDataBuffersAvailable.valueFor( ( unsigned int ) frameBuf ); 1202 } 1203 break; 1204 case CameraFrame::VIDEO_FRAME_SYNC: 1205 { 1206 Mutex::Autolock lock(mVideoBufferLock); 1207 res = mVideoBuffersAvailable.valueFor( ( unsigned int ) frameBuf ); 1208 } 1209 break; 1210 default: 1211 break; 1212 }; 1213 1214 LOG_FUNCTION_NAME_EXIT; 1215 1216 return res; 1217} 1218 1219void BaseCameraAdapter::setFrameRefCount(void* frameBuf, CameraFrame::FrameType frameType, int refCount) 1220{ 1221 1222 LOG_FUNCTION_NAME; 1223 1224 switch ( frameType ) 1225 { 1226 case CameraFrame::IMAGE_FRAME: 1227 case CameraFrame::RAW_FRAME: 1228 { 1229 Mutex::Autolock lock(mCaptureBufferLock); 1230 mCaptureBuffersAvailable.replaceValueFor( ( unsigned int ) frameBuf, refCount); 1231 } 1232 break; 1233 case CameraFrame::PREVIEW_FRAME_SYNC: 1234 case CameraFrame::SNAPSHOT_FRAME: 1235 { 1236 Mutex::Autolock lock(mPreviewBufferLock); 1237 mPreviewBuffersAvailable.replaceValueFor( ( unsigned int ) frameBuf, refCount); 1238 } 1239 break; 1240 case CameraFrame::FRAME_DATA_SYNC: 1241 { 1242 Mutex::Autolock lock(mPreviewDataBufferLock); 1243 mPreviewDataBuffersAvailable.replaceValueFor( ( unsigned int ) frameBuf, refCount); 1244 } 1245 break; 1246 case CameraFrame::VIDEO_FRAME_SYNC: 1247 { 1248 Mutex::Autolock lock(mVideoBufferLock); 1249 mVideoBuffersAvailable.replaceValueFor( ( unsigned int ) frameBuf, refCount); 1250 } 1251 break; 1252 default: 1253 break; 1254 }; 1255 1256 LOG_FUNCTION_NAME_EXIT; 1257 1258} 1259 1260status_t BaseCameraAdapter::startVideoCapture() 1261{ 1262 status_t ret = NO_ERROR; 1263 1264 LOG_FUNCTION_NAME; 1265 1266 Mutex::Autolock lock(mVideoBufferLock); 1267 1268 //If the capture is already ongoing, return from here. 1269 if ( mRecording ) 1270 { 1271 ret = NO_INIT; 1272 } 1273 1274 1275 if ( NO_ERROR == ret ) 1276 { 1277 1278 for ( unsigned int i = 0 ; i < mPreviewBuffersAvailable.size() ; i++ ) 1279 { 1280 mVideoBuffersAvailable.add(mPreviewBuffersAvailable.keyAt(i), 0); 1281 } 1282 1283 mRecording = true; 1284 } 1285 1286 LOG_FUNCTION_NAME_EXIT; 1287 1288 return ret; 1289} 1290 1291status_t BaseCameraAdapter::stopVideoCapture() 1292{ 1293 status_t ret = NO_ERROR; 1294 1295 LOG_FUNCTION_NAME; 1296 1297 if ( !mRecording ) 1298 { 1299 ret = NO_INIT; 1300 } 1301 1302 if ( NO_ERROR == ret ) 1303 { 1304 for ( unsigned int i = 0 ; i < mVideoBuffersAvailable.size() ; i++ ) 1305 { 1306 void *frameBuf = ( void * ) mVideoBuffersAvailable.keyAt(i); 1307 if( getFrameRefCount(frameBuf, CameraFrame::VIDEO_FRAME_SYNC) > 0) 1308 { 1309 returnFrame(frameBuf, CameraFrame::VIDEO_FRAME_SYNC); 1310 } 1311 } 1312 1313 mVideoBuffersAvailable.clear(); 1314 1315 mRecording = false; 1316 } 1317 1318 LOG_FUNCTION_NAME_EXIT; 1319 1320 return ret; 1321} 1322 1323//-----------------Stub implementation of the interface ------------------------------ 1324 1325status_t BaseCameraAdapter::takePicture() 1326{ 1327 status_t ret = NO_ERROR; 1328 1329 LOG_FUNCTION_NAME; 1330 1331 LOG_FUNCTION_NAME_EXIT; 1332 1333 return ret; 1334} 1335 1336status_t BaseCameraAdapter::stopImageCapture() 1337{ 1338 status_t ret = NO_ERROR; 1339 1340 LOG_FUNCTION_NAME; 1341 1342 LOG_FUNCTION_NAME_EXIT; 1343 1344 return ret; 1345} 1346 1347status_t BaseCameraAdapter::startBracketing(int range) 1348{ 1349 status_t ret = NO_ERROR; 1350 1351 LOG_FUNCTION_NAME; 1352 1353 LOG_FUNCTION_NAME_EXIT; 1354 1355 return ret; 1356} 1357 1358status_t BaseCameraAdapter::stopBracketing() 1359{ 1360 status_t ret = NO_ERROR; 1361 1362 LOG_FUNCTION_NAME; 1363 1364 LOG_FUNCTION_NAME_EXIT; 1365 1366 return ret; 1367} 1368 1369status_t BaseCameraAdapter::autoFocus() 1370{ 1371 status_t ret = NO_ERROR; 1372 1373 LOG_FUNCTION_NAME; 1374 1375 notifyFocusSubscribers(false); 1376 1377 LOG_FUNCTION_NAME_EXIT; 1378 1379 return ret; 1380} 1381 1382status_t BaseCameraAdapter::cancelAutoFocus() 1383{ 1384 status_t ret = NO_ERROR; 1385 1386 LOG_FUNCTION_NAME; 1387 1388 LOG_FUNCTION_NAME_EXIT; 1389 1390 return ret; 1391} 1392 1393status_t BaseCameraAdapter::startSmoothZoom(int targetIdx) 1394{ 1395 status_t ret = NO_ERROR; 1396 1397 LOG_FUNCTION_NAME; 1398 1399 LOG_FUNCTION_NAME_EXIT; 1400 1401 return ret; 1402} 1403 1404status_t BaseCameraAdapter::stopSmoothZoom() 1405{ 1406 status_t ret = NO_ERROR; 1407 1408 LOG_FUNCTION_NAME; 1409 1410 LOG_FUNCTION_NAME_EXIT; 1411 1412 return ret; 1413} 1414 1415status_t BaseCameraAdapter::startPreview() 1416{ 1417 status_t ret = NO_ERROR; 1418 1419 LOG_FUNCTION_NAME; 1420 1421 LOG_FUNCTION_NAME_EXIT; 1422 1423 return ret; 1424} 1425 1426status_t BaseCameraAdapter::stopPreview() 1427{ 1428 status_t ret = NO_ERROR; 1429 1430 LOG_FUNCTION_NAME; 1431 1432 LOG_FUNCTION_NAME_EXIT; 1433 1434 return ret; 1435} 1436 1437status_t BaseCameraAdapter::useBuffers(CameraMode mode, void* bufArr, int num, size_t length, unsigned int queueable) 1438{ 1439 status_t ret = NO_ERROR; 1440 1441 LOG_FUNCTION_NAME; 1442 1443 LOG_FUNCTION_NAME_EXIT; 1444 1445 return ret; 1446} 1447 1448status_t BaseCameraAdapter::fillThisBuffer(void* frameBuf, CameraFrame::FrameType frameType) 1449{ 1450 status_t ret = NO_ERROR; 1451 1452 LOG_FUNCTION_NAME; 1453 1454 LOG_FUNCTION_NAME_EXIT; 1455 1456 return ret; 1457} 1458 1459status_t BaseCameraAdapter::getFrameSize(size_t &width, size_t &height) 1460{ 1461 status_t ret = NO_ERROR; 1462 1463 LOG_FUNCTION_NAME; 1464 1465 LOG_FUNCTION_NAME_EXIT; 1466 1467 return ret; 1468} 1469 1470status_t BaseCameraAdapter::getFrameDataSize(size_t &dataFrameSize, size_t bufferCount) 1471{ 1472 status_t ret = NO_ERROR; 1473 1474 LOG_FUNCTION_NAME; 1475 1476 LOG_FUNCTION_NAME_EXIT; 1477 1478 return ret; 1479} 1480 1481status_t BaseCameraAdapter::getPictureBufferSize(size_t &length, size_t bufferCount) 1482{ 1483 status_t ret = NO_ERROR; 1484 1485 LOG_FUNCTION_NAME; 1486 1487 LOG_FUNCTION_NAME_EXIT; 1488 1489 return ret; 1490} 1491 1492status_t BaseCameraAdapter::startFaceDetection() 1493{ 1494 status_t ret = NO_ERROR; 1495 1496 LOG_FUNCTION_NAME; 1497 1498 LOG_FUNCTION_NAME_EXIT; 1499 1500 return ret; 1501} 1502 1503status_t BaseCameraAdapter::stopFaceDetection() 1504{ 1505 status_t ret = NO_ERROR; 1506 1507 LOG_FUNCTION_NAME; 1508 1509 LOG_FUNCTION_NAME_EXIT; 1510 1511 return ret; 1512} 1513 1514status_t BaseCameraAdapter::setState(CameraCommands operation) 1515{ 1516 status_t ret = NO_ERROR; 1517 1518 LOG_FUNCTION_NAME; 1519 1520 mLock.lock(); 1521 1522 switch ( mAdapterState ) 1523 { 1524 1525 case INTIALIZED_STATE: 1526 1527 switch ( operation ) 1528 { 1529 1530 case CAMERA_USE_BUFFERS_PREVIEW: 1531 CAMHAL_LOGDB("Adapter state switch INTIALIZED_STATE->LOADED_PREVIEW_STATE event = 0x%x", 1532 operation); 1533 mNextState = LOADED_PREVIEW_STATE; 1534 break; 1535 1536 //These events don't change the current state 1537 case CAMERA_QUERY_RESOLUTION_PREVIEW: 1538 case CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE: 1539 case CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA: 1540 CAMHAL_LOGDB("Adapter state switch INTIALIZED_STATE->INTIALIZED_STATE event = 0x%x", 1541 operation); 1542 mNextState = INTIALIZED_STATE; 1543 break; 1544 1545 default: 1546 CAMHAL_LOGEB("Adapter state switch INTIALIZED_STATE Invalid Op! event = 0x%x", 1547 operation); 1548 ret = INVALID_OPERATION; 1549 break; 1550 1551 } 1552 1553 break; 1554 1555 case LOADED_PREVIEW_STATE: 1556 1557 switch ( operation ) 1558 { 1559 1560 case CAMERA_START_PREVIEW: 1561 CAMHAL_LOGDB("Adapter state switch LOADED_PREVIEW_STATE->PREVIEW_STATE event = 0x%x", 1562 operation); 1563 mNextState = PREVIEW_STATE; 1564 break; 1565 1566 //These events don't change the current state 1567 case CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE: 1568 case CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA: 1569 case CAMERA_USE_BUFFERS_PREVIEW_DATA: 1570 CAMHAL_LOGDB("Adapter state switch LOADED_PREVIEW_STATE->LOADED_PREVIEW_STATE event = 0x%x", 1571 operation); 1572 mNextState = LOADED_PREVIEW_STATE; 1573 break; 1574 1575 default: 1576 CAMHAL_LOGDB("Adapter state switch LOADED_PREVIEW Invalid Op! event = 0x%x", 1577 operation); 1578 ret = INVALID_OPERATION; 1579 break; 1580 1581 } 1582 1583 break; 1584 1585 case PREVIEW_STATE: 1586 1587 switch ( operation ) 1588 { 1589 1590 case CAMERA_STOP_PREVIEW: 1591 CAMHAL_LOGDB("Adapter state switch PREVIEW_STATE->INTIALIZED_STATE event = 0x%x", 1592 operation); 1593 mNextState = INTIALIZED_STATE; 1594 break; 1595 1596 case CAMERA_PERFORM_AUTOFOCUS: 1597 CAMHAL_LOGDB("Adapter state switch PREVIEW_STATE->AF_STATE event = 0x%x", 1598 operation); 1599 mNextState = AF_STATE; 1600 break; 1601 1602 case CAMERA_START_SMOOTH_ZOOM: 1603 CAMHAL_LOGDB("Adapter state switch PREVIEW_STATE->ZOOM_STATE event = 0x%x", 1604 operation); 1605 mNextState = ZOOM_STATE; 1606 break; 1607 1608 case CAMERA_USE_BUFFERS_IMAGE_CAPTURE: 1609 CAMHAL_LOGDB("Adapter state switch PREVIEW_STATE->LOADED_CAPTURE_STATE event = 0x%x", 1610 operation); 1611 mNextState = LOADED_CAPTURE_STATE; 1612 break; 1613 1614 case CAMERA_START_VIDEO: 1615 CAMHAL_LOGDB("Adapter state switch PREVIEW_STATE->VIDEO_STATE event = 0x%x", 1616 operation); 1617 mNextState = VIDEO_STATE; 1618 break; 1619 1620 case CAMERA_CANCEL_AUTOFOCUS: 1621 case CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE: 1622 case CAMERA_STOP_SMOOTH_ZOOM: 1623 CAMHAL_LOGDB("Adapter state switch PREVIEW_ACTIVE->PREVIEW_ACTIVE event = 0x%x", 1624 operation); 1625 mNextState = PREVIEW_STATE; 1626 break; 1627 1628 default: 1629 CAMHAL_LOGEB("Adapter state switch PREVIEW_ACTIVE Invalid Op! event = 0x%x", 1630 operation); 1631 ret = INVALID_OPERATION; 1632 break; 1633 1634 } 1635 1636 break; 1637 1638 case LOADED_CAPTURE_STATE: 1639 1640 switch ( operation ) 1641 { 1642 1643 case CAMERA_START_IMAGE_CAPTURE: 1644 CAMHAL_LOGDB("Adapter state switch LOADED_CAPTURE_STATE->CAPTURE_STATE event = 0x%x", 1645 operation); 1646 mNextState = CAPTURE_STATE; 1647 break; 1648 1649 case CAMERA_START_BRACKET_CAPTURE: 1650 CAMHAL_LOGDB("Adapter state switch LOADED_CAPTURE_STATE->BRACKETING_STATE event = 0x%x", 1651 operation); 1652 mNextState = BRACKETING_STATE; 1653 break; 1654 1655 default: 1656 CAMHAL_LOGEB("Adapter state switch LOADED_CAPTURE_STATE Invalid Op! event = 0x%x", 1657 operation); 1658 ret = INVALID_OPERATION; 1659 break; 1660 1661 } 1662 1663 break; 1664 1665 case CAPTURE_STATE: 1666 1667 switch ( operation ) 1668 { 1669 case CAMERA_STOP_IMAGE_CAPTURE: 1670 CAMHAL_LOGDB("Adapter state switch CAPTURE_STATE->PREVIEW_STATE event = 0x%x", 1671 operation); 1672 mNextState = PREVIEW_STATE; 1673 break; 1674 1675 default: 1676 CAMHAL_LOGEB("Adapter state switch CAPTURE_STATE Invalid Op! event = 0x%x", 1677 operation); 1678 ret = INVALID_OPERATION; 1679 break; 1680 1681 } 1682 1683 break; 1684 1685 case BRACKETING_STATE: 1686 1687 switch ( operation ) 1688 { 1689 1690 case CAMERA_STOP_BRACKET_CAPTURE: 1691 CAMHAL_LOGDB("Adapter state switch BRACKETING_STATE->PREVIEW_STATE event = 0x%x", 1692 operation); 1693 mNextState = PREVIEW_STATE; 1694 break; 1695 1696 case CAMERA_START_IMAGE_CAPTURE: 1697 CAMHAL_LOGDB("Adapter state switch BRACKETING_STATE->CAPTURE_STATE event = 0x%x", 1698 operation); 1699 mNextState = CAPTURE_STATE; 1700 break; 1701 1702 default: 1703 CAMHAL_LOGEB("Adapter state switch BRACKETING_STATE Invalid Op! event = 0x%x", 1704 operation); 1705 ret = INVALID_OPERATION; 1706 break; 1707 1708 } 1709 1710 break; 1711 1712 case AF_STATE: 1713 1714 switch ( operation ) 1715 { 1716 1717 case CAMERA_CANCEL_AUTOFOCUS: 1718 CAMHAL_LOGDB("Adapter state switch AF_STATE->PREVIEW_STATE event = 0x%x", 1719 operation); 1720 mNextState = PREVIEW_STATE; 1721 break; 1722 1723 case CAMERA_START_SMOOTH_ZOOM: 1724 CAMHAL_LOGDB("Adapter state switch AF_STATE->AF_ZOOM_STATE event = 0x%x", 1725 operation); 1726 mNextState = AF_ZOOM_STATE; 1727 break; 1728 1729 default: 1730 CAMHAL_LOGEB("Adapter state switch AF_STATE Invalid Op! event = 0x%x", 1731 operation); 1732 ret = INVALID_OPERATION; 1733 break; 1734 1735 } 1736 1737 break; 1738 1739 case ZOOM_STATE: 1740 1741 switch ( operation ) 1742 { 1743 1744 case CAMERA_STOP_SMOOTH_ZOOM: 1745 CAMHAL_LOGDB("Adapter state switch ZOOM_STATE->PREVIEW_STATE event = 0x%x", 1746 operation); 1747 mNextState = PREVIEW_STATE; 1748 break; 1749 1750 case CAMERA_PERFORM_AUTOFOCUS: 1751 CAMHAL_LOGDB("Adapter state switch ZOOM_STATE->AF_ZOOM_STATE event = 0x%x", 1752 operation); 1753 mNextState = AF_ZOOM_STATE; 1754 break; 1755 1756 case CAMERA_START_VIDEO: 1757 CAMHAL_LOGDB("Adapter state switch ZOOM_STATE->VIDEO_ZOOM_STATE event = 0x%x", 1758 operation); 1759 mNextState = VIDEO_ZOOM_STATE; 1760 break; 1761 1762 default: 1763 CAMHAL_LOGEB("Adapter state switch ZOOM_STATE Invalid Op! event = 0x%x", 1764 operation); 1765 ret = INVALID_OPERATION; 1766 break; 1767 1768 } 1769 1770 break; 1771 1772 case VIDEO_STATE: 1773 1774 switch ( operation ) 1775 { 1776 1777 case CAMERA_STOP_VIDEO: 1778 CAMHAL_LOGDB("Adapter state switch VIDEO_STATE->PREVIEW_STATE event = 0x%x", 1779 operation); 1780 mNextState = PREVIEW_STATE; 1781 break; 1782 1783 case CAMERA_START_SMOOTH_ZOOM: 1784 CAMHAL_LOGDB("Adapter state switch VIDEO_STATE->VIDEO_ZOOM_STATE event = 0x%x", 1785 operation); 1786 mNextState = VIDEO_ZOOM_STATE; 1787 break; 1788 1789 case CAMERA_USE_BUFFERS_IMAGE_CAPTURE: 1790 CAMHAL_LOGDB("Adapter state switch VIDEO_STATE->VIDEO_LOADED_CAPTURE_STATE event = 0x%x", 1791 operation); 1792 mNextState = VIDEO_LOADED_CAPTURE_STATE; 1793 break; 1794 1795 case CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE: 1796 CAMHAL_LOGDB("Adapter state switch VIDEO_STATE->VIDEO_STATE event = 0x%x", 1797 operation); 1798 mNextState = VIDEO_STATE; 1799 break; 1800 1801 default: 1802 CAMHAL_LOGEB("Adapter state switch VIDEO_STATE Invalid Op! event = 0x%x", 1803 operation); 1804 ret = INVALID_OPERATION; 1805 break; 1806 1807 } 1808 1809 break; 1810 1811 case VIDEO_LOADED_CAPTURE_STATE: 1812 1813 switch ( operation ) 1814 { 1815 1816 case CAMERA_START_IMAGE_CAPTURE: 1817 CAMHAL_LOGDB("Adapter state switch LOADED_CAPTURE_STATE->CAPTURE_STATE event = 0x%x", 1818 operation); 1819 mNextState = VIDEO_CAPTURE_STATE; 1820 break; 1821 1822 default: 1823 CAMHAL_LOGEB("Adapter state switch LOADED_CAPTURE_STATE Invalid Op! event = 0x%x", 1824 operation); 1825 ret = INVALID_OPERATION; 1826 break; 1827 1828 } 1829 1830 break; 1831 1832 case VIDEO_CAPTURE_STATE: 1833 1834 switch ( operation ) 1835 { 1836 case CAMERA_STOP_IMAGE_CAPTURE: 1837 CAMHAL_LOGDB("Adapter state switch CAPTURE_STATE->PREVIEW_STATE event = 0x%x", 1838 operation); 1839 mNextState = VIDEO_STATE; 1840 break; 1841 1842 default: 1843 CAMHAL_LOGEB("Adapter state switch CAPTURE_STATE Invalid Op! event = 0x%x", 1844 operation); 1845 ret = INVALID_OPERATION; 1846 break; 1847 1848 } 1849 1850 break; 1851 1852 case AF_ZOOM_STATE: 1853 1854 switch ( operation ) 1855 { 1856 1857 case CAMERA_STOP_SMOOTH_ZOOM: 1858 CAMHAL_LOGDB("Adapter state switch AF_ZOOM_STATE->AF_STATE event = 0x%x", 1859 operation); 1860 mNextState = AF_STATE; 1861 break; 1862 1863 case CAMERA_CANCEL_AUTOFOCUS: 1864 CAMHAL_LOGDB("Adapter state switch AF_ZOOM_STATE->ZOOM_STATE event = 0x%x", 1865 operation); 1866 mNextState = ZOOM_STATE; 1867 break; 1868 1869 default: 1870 CAMHAL_LOGEB("Adapter state switch AF_ZOOM_STATE Invalid Op! event = 0x%x", 1871 operation); 1872 ret = INVALID_OPERATION; 1873 break; 1874 1875 } 1876 1877 break; 1878 1879 case VIDEO_ZOOM_STATE: 1880 1881 switch ( operation ) 1882 { 1883 1884 case CAMERA_STOP_SMOOTH_ZOOM: 1885 CAMHAL_LOGDB("Adapter state switch VIDEO_ZOOM_STATE->VIDEO_STATE event = 0x%x", 1886 operation); 1887 mNextState = VIDEO_STATE; 1888 break; 1889 1890 case CAMERA_STOP_VIDEO: 1891 CAMHAL_LOGDB("Adapter state switch VIDEO_ZOOM_STATE->ZOOM_STATE event = 0x%x", 1892 operation); 1893 mNextState = ZOOM_STATE; 1894 break; 1895 1896 default: 1897 CAMHAL_LOGEB("Adapter state switch VIDEO_ZOOM_STATE Invalid Op! event = 0x%x", 1898 operation); 1899 ret = INVALID_OPERATION; 1900 break; 1901 1902 } 1903 1904 break; 1905 1906 case BRACKETING_ZOOM_STATE: 1907 1908 switch ( operation ) 1909 { 1910 1911 case CAMERA_STOP_SMOOTH_ZOOM: 1912 CAMHAL_LOGDB("Adapter state switch BRACKETING_ZOOM_STATE->BRACKETING_STATE event = 0x%x", 1913 operation); 1914 mNextState = BRACKETING_STATE; 1915 break; 1916 1917 default: 1918 CAMHAL_LOGEB("Adapter state switch BRACKETING_ZOOM_STATE Invalid Op! event = 0x%x", 1919 operation); 1920 ret = INVALID_OPERATION; 1921 break; 1922 1923 } 1924 1925 break; 1926 1927 default: 1928 CAMHAL_LOGEA("Invalid Adapter state!"); 1929 ret = INVALID_OPERATION; 1930 } 1931 1932 LOG_FUNCTION_NAME_EXIT; 1933 1934 return ret; 1935} 1936 1937//State transition finished successfully. 1938//Commit the state and unlock the adapter state. 1939status_t BaseCameraAdapter::commitState() 1940{ 1941 status_t ret = NO_ERROR; 1942 1943 LOG_FUNCTION_NAME; 1944 1945 mAdapterState = mNextState; 1946 1947 mLock.unlock(); 1948 1949 LOG_FUNCTION_NAME_EXIT; 1950 1951 return ret; 1952} 1953 1954status_t BaseCameraAdapter::rollbackState() 1955{ 1956 status_t ret = NO_ERROR; 1957 1958 LOG_FUNCTION_NAME; 1959 1960 mNextState = mAdapterState; 1961 1962 mLock.unlock(); 1963 1964 LOG_FUNCTION_NAME_EXIT; 1965 1966 return ret; 1967} 1968 1969// getNextState() and getState() 1970// publicly exposed functions to retrieve the adapter states 1971// please notice that these functions are locked 1972CameraAdapter::AdapterState BaseCameraAdapter::getState() 1973{ 1974 status_t ret = NO_ERROR; 1975 1976 LOG_FUNCTION_NAME; 1977 1978 Mutex::Autolock lock(mLock); 1979 1980 LOG_FUNCTION_NAME_EXIT; 1981 1982 return mAdapterState; 1983} 1984 1985CameraAdapter::AdapterState BaseCameraAdapter::getNextState() 1986{ 1987 status_t ret = NO_ERROR; 1988 1989 LOG_FUNCTION_NAME; 1990 1991 Mutex::Autolock lock(mLock); 1992 1993 LOG_FUNCTION_NAME_EXIT; 1994 1995 return mNextState; 1996} 1997 1998// getNextState() and getState() 1999// internal protected functions to retrieve the adapter states 2000// please notice that these functions are NOT locked to help 2001// internal functions query state in the middle of state 2002// transition 2003status_t BaseCameraAdapter::getState(AdapterState &state) 2004{ 2005 status_t ret = NO_ERROR; 2006 2007 LOG_FUNCTION_NAME; 2008 2009 state = mAdapterState; 2010 2011 LOG_FUNCTION_NAME_EXIT; 2012 2013 return ret; 2014} 2015 2016status_t BaseCameraAdapter::getNextState(AdapterState &state) 2017{ 2018 status_t ret = NO_ERROR; 2019 2020 LOG_FUNCTION_NAME; 2021 2022 state = mNextState; 2023 2024 LOG_FUNCTION_NAME_EXIT; 2025 2026 return ret; 2027} 2028 2029void BaseCameraAdapter::onOrientationEvent(uint32_t orientation, uint32_t tilt) 2030{ 2031 LOG_FUNCTION_NAME; 2032 LOG_FUNCTION_NAME_EXIT; 2033} 2034//----------------------------------------------------------------------------- 2035 2036 2037 2038}; 2039 2040/*--------------------Camera Adapter Class ENDS here-----------------------------*/ 2041 2042