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