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