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