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