OMXCameraAdapter.cpp revision 470b7353f563741371ebd464f6c4a662f45e65c4 
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* @file OMXCameraAdapter.cpp
19*
20* This file maps the Camera Hardware Interface to OMX.
21*
22*/
23
24#include "CameraHal.h"
25#include "OMXCameraAdapter.h"
26#include "ErrorUtils.h"
27#include "TICameraParameters.h"
28#include <signal.h>
29#include <math.h>
30
31#include <cutils/properties.h>
32#define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false ))
33static int mDebugFps = 0;
34
35#define HERE(Msg) {CAMHAL_LOGEB("--===line %d, %s===--\n", __LINE__, Msg);}
36
37namespace android {
38
39#undef LOG_TAG
40///Maintain a separate tag for OMXCameraAdapter logs to isolate issues OMX specific
41#define LOG_TAG "CameraHAL"
42
43//frames skipped before recalculating the framerate
44#define FPS_PERIOD 30
45
46static OMXCameraAdapter *gCameraAdapter = NULL;
47Mutex gAdapterLock;
48
49/*--------------------Camera Adapter Class STARTS here-----------------------------*/
50
51status_t OMXCameraAdapter::initialize(CameraProperties::Properties* caps, int sensor_index)
52{
53    LOG_FUNCTION_NAME;
54
55    char value[PROPERTY_VALUE_MAX];
56    property_get("debug.camera.showfps", value, "0");
57    mDebugFps = atoi(value);
58
59    TIMM_OSAL_ERRORTYPE osalError = OMX_ErrorNone;
60    OMX_ERRORTYPE eError = OMX_ErrorNone;
61    status_t ret = NO_ERROR;
62
63
64    mLocalVersionParam.s.nVersionMajor = 0x1;
65    mLocalVersionParam.s.nVersionMinor = 0x1;
66    mLocalVersionParam.s.nRevision = 0x0 ;
67    mLocalVersionParam.s.nStep =  0x0;
68
69    mPending3Asettings = 0;//E3AsettingsAll;
70
71    if ( 0 != mInitSem.Count() )
72        {
73        CAMHAL_LOGEB("Error mInitSem semaphore count %d", mInitSem.Count());
74        LOG_FUNCTION_NAME_EXIT;
75        return NO_INIT;
76        }
77
78    if (mComponentState != OMX_StateLoaded && mComponentState != OMX_StateInvalid) {
79       LOG_FUNCTION_NAME_EXIT;
80       return NO_INIT;
81    }
82
83    if ( mComponentState != OMX_StateExecuting ){
84        ///Update the preview and image capture port indexes
85        mCameraAdapterParameters.mPrevPortIndex = OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW;
86        // temp changed in order to build OMX_CAMERA_PORT_VIDEO_OUT_IMAGE;
87        mCameraAdapterParameters.mImagePortIndex = OMX_CAMERA_PORT_IMAGE_OUT_IMAGE;
88        mCameraAdapterParameters.mMeasurementPortIndex = OMX_CAMERA_PORT_VIDEO_OUT_MEASUREMENT;
89        //currently not supported use preview port instead
90        mCameraAdapterParameters.mVideoPortIndex = OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW;
91
92        if(!mCameraAdapterParameters.mHandleComp)
93            {
94            ///Initialize the OMX Core
95            eError = OMX_Init();
96
97            if(eError!=OMX_ErrorNone)
98                {
99                CAMHAL_LOGEB("OMX_Init -0x%x", eError);
100                }
101            GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
102
103            ///Setup key parameters to send to Ducati during init
104            OMX_CALLBACKTYPE oCallbacks;
105
106            /* Initialize the callback handles */
107            oCallbacks.EventHandler    = android::OMXCameraAdapterEventHandler;
108            oCallbacks.EmptyBufferDone = android::OMXCameraAdapterEmptyBufferDone;
109            oCallbacks.FillBufferDone  = android::OMXCameraAdapterFillBufferDone;
110
111            ///Get the handle to the OMX Component
112            mCameraAdapterParameters.mHandleComp = NULL;
113            eError = OMX_GetHandle(&(mCameraAdapterParameters.mHandleComp), //     previously used: OMX_GetHandle
114                                        (OMX_STRING)"OMX.TI.DUCATI1.VIDEO.CAMERA" ///@todo Use constant instead of hardcoded name
115                                        , this
116                                        , &oCallbacks);
117
118            if(eError!=OMX_ErrorNone)
119                {
120                CAMHAL_LOGEB("OMX_GetHandle -0x%x", eError);
121                }
122            GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
123
124
125             eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
126                                          OMX_CommandPortDisable,
127                                          OMX_ALL,
128                                          NULL);
129
130             if(eError!=OMX_ErrorNone)
131                 {
132                 CAMHAL_LOGEB("OMX_SendCommand(OMX_CommandPortDisable) -0x%x", eError);
133                 }
134
135             GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
136
137             ///Register for port enable event
138             ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
139                                         OMX_EventCmdComplete,
140                                         OMX_CommandPortEnable,
141                                         mCameraAdapterParameters.mPrevPortIndex,
142                                         mInitSem);
143             if(ret!=NO_ERROR)
144                 {
145                 CAMHAL_LOGEB("Error in registering for event %d", ret);
146                 goto EXIT;
147                 }
148
149            ///Enable PREVIEW Port
150             eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
151                                         OMX_CommandPortEnable,
152                                         mCameraAdapterParameters.mPrevPortIndex,
153                                         NULL);
154
155             if(eError!=OMX_ErrorNone)
156                 {
157                 CAMHAL_LOGEB("OMX_SendCommand(OMX_CommandPortEnable) -0x%x", eError);
158                 }
159
160             GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
161
162             //Wait for the port enable event to occur
163             ret = mInitSem.WaitTimeout(OMX_CMD_TIMEOUT);
164             if ( NO_ERROR == ret )
165                 {
166                 CAMHAL_LOGDA("-Port enable event arrived");
167                 }
168             else
169                 {
170                 ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp,
171                                    OMX_EventCmdComplete,
172                                    OMX_CommandPortEnable,
173                                    mCameraAdapterParameters.mPrevPortIndex,
174                                    NULL);
175                 CAMHAL_LOGEA("Timeout for enabling preview port expired!");
176                 goto EXIT;
177                 }
178
179            }
180        else
181            {
182            OMXCameraPortParameters * mPreviewData =
183                &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
184
185            //Apply default configs before trying to swtich to a new sensor
186            if ( NO_ERROR != setFormat(OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW, *mPreviewData) )
187                {
188                CAMHAL_LOGEB("Error 0x%x while applying defaults", ret);
189                goto EXIT;
190                }
191            }
192    }
193    ///Select the sensor
194    OMX_CONFIG_SENSORSELECTTYPE sensorSelect;
195    OMX_INIT_STRUCT_PTR (&sensorSelect, OMX_CONFIG_SENSORSELECTTYPE);
196    sensorSelect.eSensor = (OMX_SENSORSELECT)sensor_index;
197    eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, ( OMX_INDEXTYPE ) OMX_TI_IndexConfigSensorSelect, &sensorSelect);
198
199    if ( OMX_ErrorNone != eError )
200        {
201        CAMHAL_LOGEB("Error while selecting the sensor index as %d - 0x%x", sensor_index, eError);
202        return BAD_VALUE;
203        }
204    else
205        {
206        CAMHAL_LOGDB("Sensor %d selected successfully", sensor_index);
207        }
208
209    printComponentVersion(mCameraAdapterParameters.mHandleComp);
210
211    mSensorIndex = sensor_index;
212    mBracketingEnabled = false;
213    mBracketingBuffersQueuedCount = 0;
214    mBracketingRange = 1;
215    mLastBracetingBufferIdx = 0;
216    mOMXStateSwitch = false;
217
218    if ( mComponentState != OMX_StateExecuting ){
219        mCaptureSignalled = false;
220        mCaptureConfigured = false;
221        mRecording = false;
222        mWaitingForSnapshot = false;
223        mSnapshotCount = 0;
224        mComponentState = OMX_StateLoaded;
225
226        mCapMode = HIGH_QUALITY;
227        mIPP = IPP_NULL;
228        mVstabEnabled = false;
229        mVnfEnabled = false;
230        mBurstFrames = 1;
231        mCapturedFrames = 0;
232        mPictureQuality = 100;
233        mCurrentZoomIdx = 0;
234        mTargetZoomIdx = 0;
235        mReturnZoomStatus = false;
236        mZoomInc = 1;
237        mZoomParameterIdx = 0;
238        mExposureBracketingValidEntries = 0;
239        mSensorOverclock = false;
240
241        mDeviceOrientation = 0;
242        mCapabilities = caps;
243
244        mEXIFData.mGPSData.mAltitudeValid = false;
245        mEXIFData.mGPSData.mDatestampValid = false;
246        mEXIFData.mGPSData.mLatValid = false;
247        mEXIFData.mGPSData.mLongValid = false;
248        mEXIFData.mGPSData.mMapDatumValid = false;
249        mEXIFData.mGPSData.mProcMethodValid = false;
250        mEXIFData.mGPSData.mVersionIdValid = false;
251        mEXIFData.mGPSData.mTimeStampValid = false;
252        mEXIFData.mModelValid = false;
253        mEXIFData.mMakeValid = false;
254
255        // initialize command handling thread
256        if(mCommandHandler.get() == NULL)
257            mCommandHandler = new CommandHandler(this);
258
259        if ( NULL == mCommandHandler.get() )
260        {
261            CAMHAL_LOGEA("Couldn't create command handler");
262            return NO_MEMORY;
263        }
264
265        ret = mCommandHandler->run("CallbackThread", PRIORITY_URGENT_DISPLAY);
266        if ( ret != NO_ERROR )
267        {
268            if( ret == INVALID_OPERATION){
269                CAMHAL_LOGDA("command handler thread already runnning!!");
270            }else
271            {
272                CAMHAL_LOGEA("Couldn't run command handlerthread");
273                return ret;
274            }
275        }
276
277        // initialize omx callback handling thread
278        if(mOMXCallbackHandler.get() == NULL)
279            mOMXCallbackHandler = new OMXCallbackHandler(this);
280
281        if ( NULL == mOMXCallbackHandler.get() )
282        {
283            CAMHAL_LOGEA("Couldn't create omx callback handler");
284            return NO_MEMORY;
285        }
286
287        ret = mOMXCallbackHandler->run("OMXCallbackThread", PRIORITY_URGENT_DISPLAY);
288        if ( ret != NO_ERROR )
289        {
290            if( ret == INVALID_OPERATION){
291                CAMHAL_LOGDA("omx callback handler thread already runnning!!");
292            }else
293            {
294                CAMHAL_LOGEA("Couldn't run omx callback handler thread");
295                return ret;
296            }
297        }
298
299        //Remove any unhandled events
300        if ( !mEventSignalQ.isEmpty() )
301            {
302            for (unsigned int i = 0 ; i < mEventSignalQ.size() ; i++ )
303                {
304                TIUTILS::Message *msg = mEventSignalQ.itemAt(i);
305                //remove from queue and free msg
306                mEventSignalQ.removeAt(i);
307                if ( NULL != msg )
308                    {
309                    free(msg);
310                    }
311                }
312            }
313
314        OMX_INIT_STRUCT_PTR (&mRegionPriority, OMX_TI_CONFIG_3A_REGION_PRIORITY);
315        OMX_INIT_STRUCT_PTR (&mFacePriority, OMX_TI_CONFIG_3A_FACE_PRIORITY);
316        mRegionPriority.nPortIndex = OMX_ALL;
317        mFacePriority.nPortIndex = OMX_ALL;
318
319        //Setting this flag will that the first setParameter call will apply all 3A settings
320        //and will not conditionally apply based on current values.
321        mFirstTimeInit = true;
322
323        memset(mExposureBracketingValues, 0, EXP_BRACKET_RANGE*sizeof(int));
324        mMeasurementEnabled = false;
325        mFaceDetectionRunning = false;
326        mFaceDetectionPaused = false;
327
328        memset(&mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex], 0, sizeof(OMXCameraPortParameters));
329        memset(&mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex], 0, sizeof(OMXCameraPortParameters));
330
331        //Initialize 3A defaults
332        ret = apply3ADefaults(mParameters3A);
333        if ( NO_ERROR != ret )
334            {
335            goto EXIT;
336            }
337
338    }
339    LOG_FUNCTION_NAME_EXIT;
340    return ErrorUtils::omxToAndroidError(eError);
341
342    EXIT:
343
344    CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, ret, eError);
345
346    if(mCameraAdapterParameters.mHandleComp)
347        {
348        ///Free the OMX component handle in case of error
349        OMX_FreeHandle(mCameraAdapterParameters.mHandleComp);
350        }
351
352    ///De-init the OMX
353    OMX_Deinit();
354
355    LOG_FUNCTION_NAME_EXIT;
356
357    return ErrorUtils::omxToAndroidError(eError);
358}
359
360OMXCameraAdapter::OMXCameraPortParameters *OMXCameraAdapter::getPortParams(CameraFrame::FrameType frameType)
361{
362    OMXCameraAdapter::OMXCameraPortParameters *ret = NULL;
363
364    switch ( frameType )
365    {
366    case CameraFrame::IMAGE_FRAME:
367    case CameraFrame::RAW_FRAME:
368        ret = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex];
369        break;
370    case CameraFrame::PREVIEW_FRAME_SYNC:
371    case CameraFrame::SNAPSHOT_FRAME:
372    case CameraFrame::VIDEO_FRAME_SYNC:
373        ret = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
374        break;
375    case CameraFrame::FRAME_DATA_SYNC:
376        ret = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex];
377        break;
378    default:
379        break;
380    };
381
382    return ret;
383}
384
385status_t OMXCameraAdapter::fillThisBuffer(void* frameBuf, CameraFrame::FrameType frameType)
386{
387    status_t ret = NO_ERROR;
388    OMXCameraPortParameters *port = NULL;
389    OMX_ERRORTYPE eError = OMX_ErrorNone;
390    BaseCameraAdapter::AdapterState state;
391    BaseCameraAdapter::getState(state);
392
393    if ( ( PREVIEW_ACTIVE & state ) != PREVIEW_ACTIVE )
394        {
395        return NO_INIT;
396        }
397
398    if ( NULL == frameBuf )
399        {
400        return -EINVAL;
401        }
402
403    if ( (NO_ERROR == ret) &&
404         ((CameraFrame::IMAGE_FRAME == frameType) || (CameraFrame::RAW_FRAME == frameType)) &&
405         (1 > mCapturedFrames) &&
406         (!mBracketingEnabled)) {
407        // Signal end of image capture
408        if ( NULL != mEndImageCaptureCallback) {
409            mEndImageCaptureCallback(mEndCaptureData);
410        }
411        return NO_ERROR;
412     }
413
414    if ( NO_ERROR == ret )
415        {
416        port = getPortParams(frameType);
417        if ( NULL == port )
418            {
419            CAMHAL_LOGEB("Invalid frameType 0x%x", frameType);
420            ret = -EINVAL;
421            }
422        }
423
424    if ( NO_ERROR == ret )
425        {
426
427        for ( int i = 0 ; i < port->mNumBufs ; i++)
428            {
429            if ( port->mBufferHeader[i]->pBuffer == frameBuf )
430                {
431                eError = OMX_FillThisBuffer(mCameraAdapterParameters.mHandleComp, port->mBufferHeader[i]);
432                if ( eError != OMX_ErrorNone )
433                    {
434                    CAMHAL_LOGDB("OMX_FillThisBuffer 0x%x", eError);
435                    ret = ErrorUtils::omxToAndroidError(eError);
436                    }
437                break;
438                }
439            }
440
441        }
442
443    return ret;
444}
445
446status_t OMXCameraAdapter::setParameters(const CameraParameters &params)
447{
448    LOG_FUNCTION_NAME;
449
450    const char * str = NULL;
451    int mode = 0;
452    status_t ret = NO_ERROR;
453    bool updateImagePortParams = false;
454    int minFramerate, maxFramerate, frameRate;
455    const char *valstr = NULL;
456    const char *oldstr = NULL;
457    int w, h;
458    OMX_COLOR_FORMATTYPE pixFormat;
459    BaseCameraAdapter::AdapterState state;
460    BaseCameraAdapter::getState(state);
461
462    ///@todo Include more camera parameters
463    if ( (valstr = params.getPreviewFormat()) != NULL )
464        {
465        if (strcmp(valstr, (const char *) CameraParameters::PIXEL_FORMAT_YUV422I) == 0)
466            {
467            CAMHAL_LOGDA("CbYCrY format selected");
468            pixFormat = OMX_COLOR_FormatCbYCrY;
469            }
470        else if(strcmp(valstr, (const char *) CameraParameters::PIXEL_FORMAT_YUV420SP) == 0 ||
471                strcmp(valstr, (const char *) CameraParameters::PIXEL_FORMAT_YUV420P) == 0)
472            {
473            CAMHAL_LOGDA("YUV420SP format selected");
474            pixFormat = OMX_COLOR_FormatYUV420SemiPlanar;
475            }
476        else if(strcmp(valstr, (const char *) CameraParameters::PIXEL_FORMAT_RGB565) == 0)
477            {
478            CAMHAL_LOGDA("RGB565 format selected");
479            pixFormat = OMX_COLOR_Format16bitRGB565;
480            }
481        else
482            {
483            CAMHAL_LOGDA("Invalid format, CbYCrY format selected as default");
484            pixFormat = OMX_COLOR_FormatCbYCrY;
485            }
486        }
487    else
488        {
489        CAMHAL_LOGEA("Preview format is NULL, defaulting to CbYCrY");
490        pixFormat = OMX_COLOR_FormatCbYCrY;
491        }
492
493    OMXCameraPortParameters *cap;
494    cap = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
495
496    params.getPreviewSize(&w, &h);
497    frameRate = params.getPreviewFrameRate();
498    minFramerate = params.getInt(TICameraParameters::KEY_MINFRAMERATE);
499    maxFramerate = params.getInt(TICameraParameters::KEY_MAXFRAMERATE);
500    if ( ( 0 < minFramerate ) &&
501         ( 0 < maxFramerate ) )
502        {
503        if ( minFramerate > maxFramerate )
504            {
505             CAMHAL_LOGEA(" Min FPS set higher than MAX. So setting MIN and MAX to the higher value");
506             maxFramerate = minFramerate;
507            }
508
509        if ( 0 >= frameRate )
510            {
511            frameRate = maxFramerate;
512            }
513
514        if( ( cap->mMinFrameRate != minFramerate ) ||
515            ( cap->mMaxFrameRate != maxFramerate ) )
516            {
517            cap->mMinFrameRate = minFramerate;
518            cap->mMaxFrameRate = maxFramerate;
519            setVFramerate(cap->mMinFrameRate, cap->mMaxFrameRate);
520            }
521        }
522
523    if ( 0 < frameRate )
524        {
525        cap->mColorFormat = pixFormat;
526        cap->mWidth = w;
527        cap->mHeight = h;
528        cap->mFrameRate = frameRate;
529
530        CAMHAL_LOGVB("Prev: cap.mColorFormat = %d", (int)cap->mColorFormat);
531        CAMHAL_LOGVB("Prev: cap.mWidth = %d", (int)cap->mWidth);
532        CAMHAL_LOGVB("Prev: cap.mHeight = %d", (int)cap->mHeight);
533        CAMHAL_LOGVB("Prev: cap.mFrameRate = %d", (int)cap->mFrameRate);
534
535        //TODO: Add an additional parameter for video resolution
536       //use preview resolution for now
537        cap = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
538        cap->mColorFormat = pixFormat;
539        cap->mWidth = w;
540        cap->mHeight = h;
541        cap->mFrameRate = frameRate;
542
543        CAMHAL_LOGVB("Video: cap.mColorFormat = %d", (int)cap->mColorFormat);
544        CAMHAL_LOGVB("Video: cap.mWidth = %d", (int)cap->mWidth);
545        CAMHAL_LOGVB("Video: cap.mHeight = %d", (int)cap->mHeight);
546        CAMHAL_LOGVB("Video: cap.mFrameRate = %d", (int)cap->mFrameRate);
547
548        ///mStride is set from setBufs() while passing the APIs
549        cap->mStride = 4096;
550        cap->mBufSize = cap->mStride * cap->mHeight;
551        }
552
553    if ( ( cap->mWidth >= 1920 ) &&
554         ( cap->mHeight >= 1080 ) &&
555         ( cap->mFrameRate >= FRAME_RATE_FULL_HD ) &&
556         ( !mSensorOverclock ) )
557        {
558        mOMXStateSwitch = true;
559        }
560    else if ( ( ( cap->mWidth < 1920 ) ||
561               ( cap->mHeight < 1080 ) ||
562               ( cap->mFrameRate < FRAME_RATE_FULL_HD ) ) &&
563               ( mSensorOverclock ) )
564        {
565        mOMXStateSwitch = true;
566        }
567
568    if ( (valstr = params.get(TICameraParameters::KEY_MEASUREMENT_ENABLE)) != NULL )
569        {
570        if (strcmp(valstr, (const char *) TICameraParameters::MEASUREMENT_ENABLE) == 0)
571            {
572            mMeasurementEnabled = true;
573            }
574        else if (strcmp(valstr, (const char *) TICameraParameters::MEASUREMENT_DISABLE) == 0)
575            {
576            mMeasurementEnabled = false;
577            }
578        else
579            {
580            mMeasurementEnabled = false;
581            }
582        }
583    else
584        {
585        //Disable measurement data by default
586        mMeasurementEnabled = false;
587        }
588
589    ret |= setParametersCapture(params, state);
590
591    ret |= setParameters3A(params, state);
592
593    ret |= setParametersAlgo(params, state);
594
595    ret |= setParametersFocus(params, state);
596
597    ret |= setParametersFD(params, state);
598
599    ret |= setParametersZoom(params, state);
600
601    ret |= setParametersEXIF(params, state);
602
603    mParams = params;
604    mFirstTimeInit = false;
605
606    LOG_FUNCTION_NAME_EXIT;
607    return ret;
608}
609
610void saveFile(unsigned char   *buff, int width, int height, int format) {
611    static int      counter = 1;
612    int             fd = -1;
613    char            fn[256];
614
615    LOG_FUNCTION_NAME;
616
617    fn[0] = 0;
618    sprintf(fn, "/preview%03d.yuv", counter);
619    fd = open(fn, O_CREAT | O_WRONLY | O_SYNC | O_TRUNC, 0777);
620    if(fd < 0) {
621        LOGE("Unable to open file %s: %s", fn, strerror(fd));
622        return;
623    }
624
625    CAMHAL_LOGVB("Copying from 0x%x, size=%d x %d", buff, width, height);
626
627    //method currently supports only nv12 dumping
628    int stride = width;
629    uint8_t *bf = (uint8_t*) buff;
630    for(int i=0;i<height;i++)
631        {
632        write(fd, bf, width);
633        bf += 4096;
634        }
635
636    for(int i=0;i<height/2;i++)
637        {
638        write(fd, bf, stride);
639        bf += 4096;
640        }
641
642    close(fd);
643
644
645    counter++;
646
647    LOG_FUNCTION_NAME_EXIT;
648}
649
650void OMXCameraAdapter::getParameters(CameraParameters& params)
651{
652    status_t ret = NO_ERROR;
653    OMX_CONFIG_EXPOSUREVALUETYPE exp;
654    OMX_ERRORTYPE eError = OMX_ErrorNone;
655    BaseCameraAdapter::AdapterState state;
656    BaseCameraAdapter::getState(state);
657    const char *valstr = NULL;
658    LOG_FUNCTION_NAME;
659
660#ifdef PARAM_FEEDBACK
661
662    OMX_CONFIG_WHITEBALCONTROLTYPE wb;
663    OMX_CONFIG_FLICKERCANCELTYPE flicker;
664    OMX_CONFIG_SCENEMODETYPE scene;
665    OMX_IMAGE_PARAM_FLASHCONTROLTYPE flash;
666    OMX_CONFIG_BRIGHTNESSTYPE brightness;
667    OMX_CONFIG_CONTRASTTYPE contrast;
668    OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE procSharpness;
669    OMX_CONFIG_SATURATIONTYPE saturation;
670    OMX_CONFIG_IMAGEFILTERTYPE effect;
671    OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE focus;
672
673    exp.nSize = sizeof(OMX_CONFIG_EXPOSURECONTROLTYPE);
674    exp.nVersion = mLocalVersionParam;
675    exp.nPortIndex = OMX_ALL;
676
677    expValues.nSize = sizeof(OMX_CONFIG_EXPOSUREVALUETYPE);
678    expValues.nVersion = mLocalVersionParam;
679    expValues.nPortIndex = OMX_ALL;
680
681    wb.nSize = sizeof(OMX_CONFIG_WHITEBALCONTROLTYPE);
682    wb.nVersion = mLocalVersionParam;
683    wb.nPortIndex = OMX_ALL;
684
685    flicker.nSize = sizeof(OMX_CONFIG_FLICKERCANCELTYPE);
686    flicker.nVersion = mLocalVersionParam;
687    flicker.nPortIndex = OMX_ALL;
688
689    scene.nSize = sizeof(OMX_CONFIG_SCENEMODETYPE);
690    scene.nVersion = mLocalVersionParam;
691    scene.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
692
693    flash.nSize = sizeof(OMX_IMAGE_PARAM_FLASHCONTROLTYPE);
694    flash.nVersion = mLocalVersionParam;
695    flash.nPortIndex = OMX_ALL;
696
697
698    brightness.nSize = sizeof(OMX_CONFIG_BRIGHTNESSTYPE);
699    brightness.nVersion = mLocalVersionParam;
700    brightness.nPortIndex = OMX_ALL;
701
702    contrast.nSize = sizeof(OMX_CONFIG_CONTRASTTYPE);
703    contrast.nVersion = mLocalVersionParam;
704    contrast.nPortIndex = OMX_ALL;
705
706    procSharpness.nSize = sizeof( OMX_IMAGE_CONFIG_PROCESSINGLEVELTYPE );
707    procSharpness.nVersion = mLocalVersionParam;
708    procSharpness.nPortIndex = OMX_ALL;
709
710    saturation.nSize = sizeof(OMX_CONFIG_SATURATIONTYPE);
711    saturation.nVersion = mLocalVersionParam;
712    saturation.nPortIndex = OMX_ALL;
713
714    effect.nSize = sizeof(OMX_CONFIG_IMAGEFILTERTYPE);
715    effect.nVersion = mLocalVersionParam;
716    effect.nPortIndex = OMX_ALL;
717
718    focus.nSize = sizeof(OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE);
719    focus.nVersion = mLocalVersionParam;
720    focus.nPortIndex = OMX_ALL;
721
722    OMX_GetConfig( mCameraAdapterParameters.mHandleComp,OMX_IndexConfigCommonExposure, &exp);
723    OMX_GetConfig( mCameraAdapterParameters.mHandleComp, OMX_IndexConfigCommonWhiteBalance, &wb);
724    OMX_GetConfig( mCameraAdapterParameters.mHandleComp, (OMX_INDEXTYPE)OMX_IndexConfigFlickerCancel, &flicker );
725    OMX_GetConfig( mCameraAdapterParameters.mHandleComp, (OMX_INDEXTYPE)OMX_IndexParamSceneMode, &scene);
726    OMX_GetParameter( mCameraAdapterParameters.mHandleComp, (OMX_INDEXTYPE)OMX_IndexParamFlashControl, &flash);
727    OMX_GetConfig( mCameraAdapterParameters.mHandleComp, OMX_IndexConfigCommonBrightness, &brightness);
728    OMX_GetConfig( mCameraAdapterParameters.mHandleComp, OMX_IndexConfigCommonContrast, &contrast);
729    OMX_GetConfig( mCameraAdapterParameters.mHandleComp, (OMX_INDEXTYPE)OMX_IndexConfigSharpeningLevel, &procSharpness);
730    OMX_GetConfig( mCameraAdapterParameters.mHandleComp, OMX_IndexConfigCommonSaturation, &saturation);
731    OMX_GetConfig( mCameraAdapterParameters.mHandleComp, OMX_IndexConfigCommonImageFilter, &effect);
732    OMX_GetConfig( mCameraAdapterParameters.mHandleComp, OMX_IndexConfigFocusControl, &focus);
733
734    char * str = NULL;
735
736    for(int i = 0; i < ExpLUT.size; i++)
737        if( ExpLUT.Table[i].omxDefinition == exp.eExposureControl )
738            str = (char*)ExpLUT.Table[i].userDefinition;
739    params.set( TICameraParameters::KEY_EXPOSURE_MODE , str);
740
741    for(int i = 0; i < WBalLUT.size; i++)
742        if( WBalLUT.Table[i].omxDefinition == wb.eWhiteBalControl )
743            str = (char*)WBalLUT.Table[i].userDefinition;
744    params.set( CameraParameters::KEY_WHITE_BALANCE , str );
745
746    for(int i = 0; i < FlickerLUT.size; i++)
747        if( FlickerLUT.Table[i].omxDefinition == flicker.eFlickerCancel )
748            str = (char*)FlickerLUT.Table[i].userDefinition;
749    params.set( CameraParameters::KEY_ANTIBANDING , str );
750
751    for(int i = 0; i < SceneLUT.size; i++)
752        if( SceneLUT.Table[i].omxDefinition == scene.eSceneMode )
753            str = (char*)SceneLUT.Table[i].userDefinition;
754    params.set( CameraParameters::KEY_SCENE_MODE , str );
755
756    for(int i = 0; i < FlashLUT.size; i++)
757        if( FlashLUT.Table[i].omxDefinition == flash.eFlashControl )
758            str = (char*)FlashLUT.Table[i].userDefinition;
759    params.set( CameraParameters::KEY_FLASH_MODE, str );
760
761    for(int i = 0; i < EffLUT.size; i++)
762        if( EffLUT.Table[i].omxDefinition == effect.eImageFilter )
763            str = (char*)EffLUT.Table[i].userDefinition;
764    params.set( CameraParameters::KEY_EFFECT , str );
765
766    for(int i = 0; i < FocusLUT.size; i++)
767        if( FocusLUT.Table[i].omxDefinition == focus.eFocusControl )
768            str = (char*)FocusLUT.Table[i].userDefinition;
769
770    params.set( CameraParameters::KEY_FOCUS_MODE , str );
771
772    int comp = ((expValues.xEVCompensation * 10) >> Q16_OFFSET);
773
774    params.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, comp );
775    params.set( TICameraParameters::KEY_MAN_EXPOSURE, expValues.nShutterSpeedMsec);
776    params.set( TICameraParameters::KEY_BRIGHTNESS, brightness.nBrightness);
777    params.set( TICameraParameters::KEY_CONTRAST, contrast.nContrast );
778    params.set( TICameraParameters::KEY_SHARPNESS, procSharpness.nLevel);
779    params.set( TICameraParameters::KEY_SATURATION, saturation.nSaturation);
780
781#else
782
783    //Query focus distances only during CAF, Infinity
784    //or when focus is running
785    if ( ( AF_ACTIVE & state ) ||
786         ( mParameters3A.Focus == OMX_IMAGE_FocusControlAuto )  ||
787         ( mParameters3A.Focus == OMX_IMAGE_FocusControlAutoInfinity ) ||
788         ( NULL == mParameters.get(CameraParameters::KEY_FOCUS_DISTANCES) ) )
789        {
790        updateFocusDistances(params);
791        }
792    else
793        {
794        params.set(CameraParameters::KEY_FOCUS_DISTANCES,
795                   mParameters.get(CameraParameters::KEY_FOCUS_DISTANCES));
796        }
797
798    OMX_INIT_STRUCT_PTR (&exp, OMX_CONFIG_EXPOSUREVALUETYPE);
799    exp.nPortIndex = OMX_ALL;
800
801    eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
802                           OMX_IndexConfigCommonExposureValue,
803                           &exp);
804    if ( OMX_ErrorNone == eError )
805        {
806        params.set(TICameraParameters::KEY_CURRENT_ISO, exp.nSensitivity);
807        }
808    else
809        {
810        CAMHAL_LOGEB("OMX error 0x%x, while retrieving current ISO value", eError);
811        }
812
813    {
814    Mutex::Autolock lock(mZoomLock);
815    //Immediate zoom should not be avaialable while smooth zoom is running
816    if ( ZOOM_ACTIVE & state )
817        {
818        if ( mZoomParameterIdx != mCurrentZoomIdx )
819            {
820            mZoomParameterIdx += mZoomInc;
821            }
822        params.set( CameraParameters::KEY_ZOOM, mZoomParameterIdx);
823        if ( ( mCurrentZoomIdx == mTargetZoomIdx ) &&
824             ( mZoomParameterIdx == mCurrentZoomIdx ) )
825            {
826
827            if ( NO_ERROR == ret )
828                {
829
830                ret =  BaseCameraAdapter::setState(CAMERA_STOP_SMOOTH_ZOOM);
831
832                if ( NO_ERROR == ret )
833                    {
834                    ret = BaseCameraAdapter::commitState();
835                    }
836                else
837                    {
838                    ret |= BaseCameraAdapter::rollbackState();
839                    }
840
841                }
842
843            }
844
845        CAMHAL_LOGDB("CameraParameters Zoom = %d", mCurrentZoomIdx);
846        }
847    else
848        {
849        params.set( CameraParameters::KEY_ZOOM, mCurrentZoomIdx);
850        }
851    }
852
853    //Populate current lock status
854    if( (valstr = mParams.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK)) != NULL )
855      {
856        CAMHAL_LOGDB("Auto Exposure Lock get %s", mParams.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK));
857        params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, valstr);
858      }
859
860    if( (valstr = mParams.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK)) != NULL )
861      {
862        CAMHAL_LOGDB("Auto WhiteBalance Lock get %s", mParams.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK));
863        params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, valstr);
864      }
865
866#endif
867
868    LOG_FUNCTION_NAME_EXIT;
869}
870
871status_t OMXCameraAdapter::setFormat(OMX_U32 port, OMXCameraPortParameters &portParams)
872{
873    size_t bufferCount;
874
875    LOG_FUNCTION_NAME;
876
877    OMX_ERRORTYPE eError = OMX_ErrorNone;
878    OMX_PARAM_PORTDEFINITIONTYPE portCheck;
879
880    OMX_INIT_STRUCT_PTR (&portCheck, OMX_PARAM_PORTDEFINITIONTYPE);
881
882    portCheck.nPortIndex = port;
883
884    eError = OMX_GetParameter (mCameraAdapterParameters.mHandleComp,
885                                OMX_IndexParamPortDefinition, &portCheck);
886    if(eError!=OMX_ErrorNone)
887        {
888        CAMHAL_LOGEB("OMX_GetParameter - %x", eError);
889        }
890    GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
891
892    if ( OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW == port )
893        {
894        portCheck.format.video.nFrameWidth      = portParams.mWidth;
895        portCheck.format.video.nFrameHeight     = portParams.mHeight;
896        portCheck.format.video.eColorFormat     = portParams.mColorFormat;
897        portCheck.format.video.nStride          = portParams.mStride;
898        if( ( portCheck.format.video.nFrameWidth >= 1920 ) &&
899            ( portCheck.format.video.nFrameHeight >= 1080 ) &&
900            ( portParams.mFrameRate >= FRAME_RATE_FULL_HD ) )
901            {
902            setSensorOverclock(true);
903            }
904        else
905            {
906            setSensorOverclock(false);
907            }
908
909        portCheck.format.video.xFramerate       = portParams.mFrameRate<<16;
910        portCheck.nBufferSize                   = portParams.mStride * portParams.mHeight;
911        portCheck.nBufferCountActual = portParams.mNumBufs;
912        mFocusThreshold = FOCUS_THRESHOLD * portParams.mFrameRate;
913        }
914    else if ( OMX_CAMERA_PORT_IMAGE_OUT_IMAGE == port )
915        {
916        portCheck.format.image.nFrameWidth      = portParams.mWidth;
917        portCheck.format.image.nFrameHeight     = portParams.mHeight;
918        if ( OMX_COLOR_FormatUnused == portParams.mColorFormat && mCodingMode == CodingNone )
919            {
920            portCheck.format.image.eColorFormat     = OMX_COLOR_FormatCbYCrY;
921            portCheck.format.image.eCompressionFormat = OMX_IMAGE_CodingJPEG;
922            }
923        else if ( OMX_COLOR_FormatUnused == portParams.mColorFormat && mCodingMode == CodingJPS )
924            {
925            portCheck.format.image.eColorFormat       = OMX_COLOR_FormatCbYCrY;
926            portCheck.format.image.eCompressionFormat = (OMX_IMAGE_CODINGTYPE) OMX_TI_IMAGE_CodingJPS;
927            }
928        else if ( OMX_COLOR_FormatUnused == portParams.mColorFormat && mCodingMode == CodingMPO )
929            {
930            portCheck.format.image.eColorFormat       = OMX_COLOR_FormatCbYCrY;
931            portCheck.format.image.eCompressionFormat = (OMX_IMAGE_CODINGTYPE) OMX_TI_IMAGE_CodingMPO;
932            }
933        else if ( OMX_COLOR_FormatUnused == portParams.mColorFormat && mCodingMode == CodingRAWJPEG )
934            {
935            //TODO: OMX_IMAGE_CodingJPEG should be changed to OMX_IMAGE_CodingRAWJPEG when
936            // RAW format is supported
937            portCheck.format.image.eColorFormat       = OMX_COLOR_FormatCbYCrY;
938            portCheck.format.image.eCompressionFormat = OMX_IMAGE_CodingJPEG;
939            }
940        else if ( OMX_COLOR_FormatUnused == portParams.mColorFormat && mCodingMode == CodingRAWMPO )
941            {
942            //TODO: OMX_IMAGE_CodingJPEG should be changed to OMX_IMAGE_CodingRAWMPO when
943            // RAW format is supported
944            portCheck.format.image.eColorFormat       = OMX_COLOR_FormatCbYCrY;
945            portCheck.format.image.eCompressionFormat = OMX_IMAGE_CodingJPEG;
946            }
947        else
948            {
949            portCheck.format.image.eColorFormat     = portParams.mColorFormat;
950            portCheck.format.image.eCompressionFormat = OMX_IMAGE_CodingUnused;
951            }
952
953        //Stride for 1D tiler buffer is zero
954        portCheck.format.image.nStride          =  0;
955        portCheck.nBufferSize                   =  portParams.mStride * portParams.mWidth * portParams.mHeight;
956        portCheck.nBufferCountActual = portParams.mNumBufs;
957        }
958    else
959        {
960        CAMHAL_LOGEB("Unsupported port index 0x%x", (unsigned int)port);
961        }
962
963    eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp,
964                            OMX_IndexParamPortDefinition, &portCheck);
965    if(eError!=OMX_ErrorNone)
966        {
967        CAMHAL_LOGEB("OMX_SetParameter - %x", eError);
968        }
969    GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
970
971    /* check if parameters are set correctly by calling GetParameter() */
972    eError = OMX_GetParameter(mCameraAdapterParameters.mHandleComp,
973                                        OMX_IndexParamPortDefinition, &portCheck);
974    if(eError!=OMX_ErrorNone)
975        {
976        CAMHAL_LOGEB("OMX_GetParameter - %x", eError);
977        }
978    GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
979
980    portParams.mBufSize = portCheck.nBufferSize;
981
982    if ( OMX_CAMERA_PORT_IMAGE_OUT_IMAGE == port )
983        {
984        CAMHAL_LOGDB("\n *** IMG Width = %ld", portCheck.format.image.nFrameWidth);
985        CAMHAL_LOGDB("\n ***IMG Height = %ld", portCheck.format.image.nFrameHeight);
986
987        CAMHAL_LOGDB("\n ***IMG IMG FMT = %x", portCheck.format.image.eColorFormat);
988        CAMHAL_LOGDB("\n ***IMG portCheck.nBufferSize = %ld\n",portCheck.nBufferSize);
989        CAMHAL_LOGDB("\n ***IMG portCheck.nBufferCountMin = %ld\n",
990                                                portCheck.nBufferCountMin);
991        CAMHAL_LOGDB("\n ***IMG portCheck.nBufferCountActual = %ld\n",
992                                                portCheck.nBufferCountActual);
993        CAMHAL_LOGDB("\n ***IMG portCheck.format.image.nStride = %ld\n",
994                                                portCheck.format.image.nStride);
995        }
996    else
997        {
998        CAMHAL_LOGDB("\n *** PRV Width = %ld", portCheck.format.video.nFrameWidth);
999        CAMHAL_LOGDB("\n ***PRV Height = %ld", portCheck.format.video.nFrameHeight);
1000
1001        CAMHAL_LOGDB("\n ***PRV IMG FMT = %x", portCheck.format.video.eColorFormat);
1002        CAMHAL_LOGDB("\n ***PRV portCheck.nBufferSize = %ld\n",portCheck.nBufferSize);
1003        CAMHAL_LOGDB("\n ***PRV portCheck.nBufferCountMin = %ld\n",
1004                                                portCheck.nBufferCountMin);
1005        CAMHAL_LOGDB("\n ***PRV portCheck.nBufferCountActual = %ld\n",
1006                                                portCheck.nBufferCountActual);
1007        CAMHAL_LOGDB("\n ***PRV portCheck.format.video.nStride = %ld\n",
1008                                                portCheck.format.video.nStride);
1009        }
1010
1011    LOG_FUNCTION_NAME_EXIT;
1012
1013    return ErrorUtils::omxToAndroidError(eError);
1014
1015    EXIT:
1016
1017    CAMHAL_LOGEB("Exiting function %s because of eError=%x", __FUNCTION__, eError);
1018
1019    LOG_FUNCTION_NAME_EXIT;
1020
1021    return ErrorUtils::omxToAndroidError(eError);
1022}
1023
1024status_t OMXCameraAdapter::flushBuffers()
1025{
1026    status_t ret = NO_ERROR;
1027    OMX_ERRORTYPE eError = OMX_ErrorNone;
1028    TIMM_OSAL_ERRORTYPE err;
1029    TIMM_OSAL_U32 uRequestedEvents = OMXCameraAdapter::CAMERA_PORT_FLUSH;
1030    TIMM_OSAL_U32 pRetrievedEvents;
1031
1032    if ( 0 != mFlushSem.Count() )
1033        {
1034        CAMHAL_LOGEB("Error mFlushSem semaphore count %d", mFlushSem.Count());
1035        LOG_FUNCTION_NAME_EXIT;
1036        return NO_INIT;
1037        }
1038
1039    LOG_FUNCTION_NAME;
1040
1041    OMXCameraPortParameters * mPreviewData = NULL;
1042    mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
1043
1044    ///Register for the FLUSH event
1045    ///This method just inserts a message in Event Q, which is checked in the callback
1046    ///The sempahore passed is signalled by the callback
1047    ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
1048                                OMX_EventCmdComplete,
1049                                OMX_CommandFlush,
1050                                OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW,
1051                                mFlushSem);
1052    if(ret!=NO_ERROR)
1053        {
1054        CAMHAL_LOGEB("Error in registering for event %d", ret);
1055        goto EXIT;
1056        }
1057
1058    ///Send FLUSH command to preview port
1059    eError = OMX_SendCommand (mCameraAdapterParameters.mHandleComp,
1060                              OMX_CommandFlush,
1061                              mCameraAdapterParameters.mPrevPortIndex,
1062                              NULL);
1063
1064    if(eError!=OMX_ErrorNone)
1065        {
1066        CAMHAL_LOGEB("OMX_SendCommand(OMX_CommandFlush)-0x%x", eError);
1067        }
1068    GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
1069
1070    CAMHAL_LOGDA("Waiting for flush event");
1071
1072    ///Wait for the FLUSH event to occur
1073    ret = mFlushSem.WaitTimeout(OMX_CMD_TIMEOUT);
1074    if ( NO_ERROR == ret )
1075        {
1076        CAMHAL_LOGDA("Flush event received");
1077        }
1078    else
1079        {
1080        ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp,
1081                           OMX_EventCmdComplete,
1082                           OMX_CommandFlush,
1083                           OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW,
1084                           NULL);
1085        CAMHAL_LOGDA("Flush event timeout expired");
1086        goto EXIT;
1087        }
1088
1089    LOG_FUNCTION_NAME_EXIT;
1090
1091    return (ret | ErrorUtils::omxToAndroidError(eError));
1092
1093    EXIT:
1094    CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, ret, eError);
1095    LOG_FUNCTION_NAME_EXIT;
1096
1097    return (ret | ErrorUtils::omxToAndroidError(eError));
1098}
1099
1100///API to give the buffers to Adapter
1101status_t OMXCameraAdapter::useBuffers(CameraMode mode, void* bufArr, int num, size_t length, unsigned int queueable)
1102{
1103    OMX_ERRORTYPE eError = OMX_ErrorNone;
1104    status_t ret = NO_ERROR;
1105
1106    LOG_FUNCTION_NAME;
1107
1108    switch(mode)
1109        {
1110        case CAMERA_PREVIEW:
1111            mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex].mNumBufs =  num;
1112            mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex].mMaxQueueable = queueable;
1113            ret = UseBuffersPreview(bufArr, num);
1114            break;
1115
1116        case CAMERA_IMAGE_CAPTURE:
1117            mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex].mNumBufs = num;
1118            mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex].mMaxQueueable = queueable;
1119            ret = UseBuffersCapture(bufArr, num);
1120            break;
1121
1122        case CAMERA_VIDEO:
1123            mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex].mNumBufs =  num;
1124            mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex].mMaxQueueable = queueable;
1125            ret = UseBuffersPreview(bufArr, num);
1126            break;
1127
1128        case CAMERA_MEASUREMENT:
1129            mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex].mNumBufs = num;
1130            mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex].mMaxQueueable = queueable;
1131            ret = UseBuffersPreviewData(bufArr, num);
1132            break;
1133
1134        }
1135
1136    LOG_FUNCTION_NAME_EXIT;
1137
1138    return ret;
1139}
1140
1141status_t OMXCameraAdapter::UseBuffersPreviewData(void* bufArr, int num)
1142{
1143    status_t ret = NO_ERROR;
1144    OMX_ERRORTYPE eError = OMX_ErrorNone;
1145    OMXCameraPortParameters * measurementData = NULL;
1146    uint32_t *buffers;
1147    Mutex::Autolock lock( mPreviewDataBufferLock);
1148
1149    LOG_FUNCTION_NAME;
1150
1151    if ( mComponentState != OMX_StateLoaded )
1152        {
1153        CAMHAL_LOGEA("Calling UseBuffersPreviewData() when not in LOADED state");
1154        ret = BAD_VALUE;
1155        }
1156
1157    if ( NULL == bufArr )
1158        {
1159        CAMHAL_LOGEA("NULL pointer passed for buffArr");
1160        ret = BAD_VALUE;
1161        }
1162
1163    if ( 0 != mUsePreviewDataSem.Count() )
1164        {
1165        CAMHAL_LOGEB("Error mUsePreviewDataSem semaphore count %d", mUsePreviewDataSem.Count());
1166        LOG_FUNCTION_NAME_EXIT;
1167        return NO_INIT;
1168        }
1169
1170    if ( NO_ERROR == ret )
1171        {
1172        measurementData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex];
1173        measurementData->mNumBufs = num ;
1174        buffers= (uint32_t*) bufArr;
1175        }
1176
1177    if ( NO_ERROR == ret )
1178        {
1179         ///Register for port enable event on measurement port
1180        ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
1181                                      OMX_EventCmdComplete,
1182                                      OMX_CommandPortEnable,
1183                                      mCameraAdapterParameters.mMeasurementPortIndex,
1184                                      mUsePreviewDataSem);
1185
1186        if ( ret == NO_ERROR )
1187            {
1188            CAMHAL_LOGDB("Registering for event %d", ret);
1189            }
1190        else
1191            {
1192            CAMHAL_LOGEB("Error in registering for event %d", ret);
1193            ret = BAD_VALUE;
1194            }
1195        }
1196
1197    if ( NO_ERROR == ret )
1198        {
1199         ///Enable MEASUREMENT Port
1200         eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
1201                                      OMX_CommandPortEnable,
1202                                      mCameraAdapterParameters.mMeasurementPortIndex,
1203                                      NULL);
1204
1205            if ( eError == OMX_ErrorNone )
1206                {
1207                CAMHAL_LOGDB("OMX_SendCommand(OMX_CommandPortEnable) -0x%x", eError);
1208                }
1209            else
1210                {
1211                CAMHAL_LOGEB("OMX_SendCommand(OMX_CommandPortEnable) -0x%x", eError);
1212                ret = BAD_VALUE;
1213                }
1214        }
1215
1216    if ( NO_ERROR == ret )
1217        {
1218        ret = mUsePreviewDataSem.WaitTimeout(OMX_CMD_TIMEOUT);
1219
1220        if ( NO_ERROR == ret )
1221            {
1222            CAMHAL_LOGDA("Port enable event arrived on measurement port");
1223            }
1224        else
1225            {
1226            ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp,
1227                               OMX_EventCmdComplete,
1228                               OMX_CommandPortEnable,
1229                               mCameraAdapterParameters.mMeasurementPortIndex,
1230                               NULL);
1231            CAMHAL_LOGEA("Timeout expoired during port enable on measurement port");
1232            }
1233
1234        CAMHAL_LOGDA("Port enable event arrived on measurement port");
1235        }
1236
1237    LOG_FUNCTION_NAME_EXIT;
1238
1239    return ret;
1240}
1241
1242status_t OMXCameraAdapter::switchToLoaded()
1243{
1244    status_t ret = NO_ERROR;
1245    OMX_ERRORTYPE eError = OMX_ErrorNone;
1246
1247    LOG_FUNCTION_NAME;
1248
1249    if ( mComponentState == OMX_StateLoaded )
1250        {
1251        CAMHAL_LOGDA("Already in OMX_Loaded state");
1252        goto EXIT;
1253        }
1254
1255    if ( 0 != mSwitchToLoadedSem.Count() )
1256        {
1257        CAMHAL_LOGEB("Error mSwitchToLoadedSem semaphore count %d", mSwitchToLoadedSem.Count());
1258        goto EXIT;
1259        }
1260
1261    ///Register for EXECUTING state transition.
1262    ///This method just inserts a message in Event Q, which is checked in the callback
1263    ///The sempahore passed is signalled by the callback
1264    ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
1265                           OMX_EventCmdComplete,
1266                           OMX_CommandStateSet,
1267                           OMX_StateIdle,
1268                           mSwitchToLoadedSem);
1269
1270    if(ret!=NO_ERROR)
1271        {
1272        CAMHAL_LOGEB("Error in registering for event %d", ret);
1273        goto EXIT;
1274        }
1275
1276    eError = OMX_SendCommand (mCameraAdapterParameters.mHandleComp,
1277                              OMX_CommandStateSet,
1278                              OMX_StateIdle,
1279                              NULL);
1280
1281    if(eError!=OMX_ErrorNone)
1282        {
1283        CAMHAL_LOGEB("OMX_SendCommand(OMX_StateIdle) - %x", eError);
1284        }
1285
1286    GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
1287
1288    ///Wait for the EXECUTING ->IDLE transition to arrive
1289
1290    CAMHAL_LOGDA("EXECUTING->IDLE state changed");
1291    ret = mSwitchToLoadedSem.WaitTimeout(OMX_CMD_TIMEOUT);
1292    if ( NO_ERROR == ret )
1293        {
1294        CAMHAL_LOGDA("EXECUTING->IDLE state changed");
1295        }
1296    else
1297        {
1298        ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp,
1299                           OMX_EventCmdComplete,
1300                           OMX_CommandStateSet,
1301                           OMX_StateIdle,
1302                           NULL);
1303        CAMHAL_LOGEA("Timeout expired on EXECUTING->IDLE state change");
1304        goto EXIT;
1305        }
1306
1307    ///Register for LOADED state transition.
1308    ///This method just inserts a message in Event Q, which is checked in the callback
1309    ///The sempahore passed is signalled by the callback
1310    ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
1311                           OMX_EventCmdComplete,
1312                           OMX_CommandStateSet,
1313                           OMX_StateLoaded,
1314                           mSwitchToLoadedSem);
1315
1316    if(ret!=NO_ERROR)
1317        {
1318        CAMHAL_LOGEB("Error in registering for event %d", ret);
1319        goto EXIT;
1320        }
1321
1322    eError = OMX_SendCommand (mCameraAdapterParameters.mHandleComp,
1323                              OMX_CommandStateSet,
1324                              OMX_StateLoaded,
1325                              NULL);
1326
1327    if(eError!=OMX_ErrorNone)
1328        {
1329        CAMHAL_LOGEB("OMX_SendCommand(OMX_StateLoaded) - %x", eError);
1330        }
1331    GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
1332
1333    CAMHAL_LOGDA("Switching IDLE->LOADED state");
1334    ret = mSwitchToLoadedSem.WaitTimeout(OMX_CMD_TIMEOUT);
1335    if ( NO_ERROR == ret )
1336        {
1337        CAMHAL_LOGDA("IDLE->LOADED state changed");
1338        }
1339    else
1340        {
1341        ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp,
1342                           OMX_EventCmdComplete,
1343                           OMX_CommandStateSet,
1344                           OMX_StateLoaded,
1345                           NULL);
1346        CAMHAL_LOGEA("Timeout expired on IDLE->LOADED state change");
1347        goto EXIT;
1348        }
1349
1350    mComponentState = OMX_StateLoaded;
1351
1352    ///Register for Preview port ENABLE event
1353    ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
1354                           OMX_EventCmdComplete,
1355                           OMX_CommandPortEnable,
1356                           mCameraAdapterParameters.mPrevPortIndex,
1357                           mSwitchToLoadedSem);
1358
1359    if ( NO_ERROR != ret )
1360        {
1361        CAMHAL_LOGEB("Error in registering for event %d", ret);
1362        goto EXIT;
1363        }
1364
1365    ///Enable Preview Port
1366    eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
1367                             OMX_CommandPortEnable,
1368                             mCameraAdapterParameters.mPrevPortIndex,
1369                             NULL);
1370
1371    CAMHAL_LOGDB("OMX_SendCommand(OMX_CommandStateSet) 0x%x", eError);
1372
1373    GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
1374
1375    CAMHAL_LOGDA("Enabling Preview port");
1376    ///Wait for state to switch to idle
1377    ret = mSwitchToLoadedSem.WaitTimeout(OMX_CMD_TIMEOUT);
1378    if ( NO_ERROR == ret )
1379        {
1380        CAMHAL_LOGDA("Preview port enabled!");
1381        }
1382    else
1383        {
1384        ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp,
1385                           OMX_EventCmdComplete,
1386                           OMX_CommandPortEnable,
1387                           mCameraAdapterParameters.mPrevPortIndex,
1388                           NULL);
1389        CAMHAL_LOGEA("Preview enable timedout");
1390        goto EXIT;
1391        }
1392
1393    EXIT:
1394
1395    LOG_FUNCTION_NAME_EXIT;
1396
1397    return ret;
1398}
1399
1400status_t OMXCameraAdapter::UseBuffersPreview(void* bufArr, int num)
1401{
1402    status_t ret = NO_ERROR;
1403    OMX_ERRORTYPE eError = OMX_ErrorNone;
1404    int tmpHeight, tmpWidth;
1405
1406    LOG_FUNCTION_NAME;
1407
1408    ///Flag to determine whether it is 3D camera or not
1409    bool isS3d = false;
1410    const char *valstr = NULL;
1411    if ( (valstr = mParams.get(TICameraParameters::KEY_S3D_SUPPORTED)) != NULL) {
1412        isS3d = (strcmp(valstr, "true") == 0);
1413    }
1414
1415    if(!bufArr)
1416        {
1417        CAMHAL_LOGEA("NULL pointer passed for buffArr");
1418        LOG_FUNCTION_NAME_EXIT;
1419        return BAD_VALUE;
1420        }
1421
1422    OMXCameraPortParameters * mPreviewData = NULL;
1423    OMXCameraPortParameters *measurementData = NULL;
1424    mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
1425    measurementData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex];
1426    mPreviewData->mNumBufs = num ;
1427    uint32_t *buffers = (uint32_t*)bufArr;
1428
1429    if ( 0 != mUsePreviewSem.Count() )
1430        {
1431        CAMHAL_LOGEB("Error mUsePreviewSem semaphore count %d", mUsePreviewSem.Count());
1432        LOG_FUNCTION_NAME_EXIT;
1433        return NO_INIT;
1434        }
1435
1436    if(mPreviewData->mNumBufs != num)
1437        {
1438        CAMHAL_LOGEA("Current number of buffers doesnt equal new num of buffers passed!");
1439        LOG_FUNCTION_NAME_EXIT;
1440        return BAD_VALUE;
1441        }
1442
1443    if ( mComponentState == OMX_StateLoaded )
1444        {
1445
1446        ret = setLDC(mIPP);
1447        if ( NO_ERROR != ret )
1448            {
1449            CAMHAL_LOGEB("setLDC() failed %d", ret);
1450            LOG_FUNCTION_NAME_EXIT;
1451            return ret;
1452            }
1453
1454        ret = setNSF(mIPP);
1455        if ( NO_ERROR != ret )
1456            {
1457            CAMHAL_LOGEB("setNSF() failed %d", ret);
1458            LOG_FUNCTION_NAME_EXIT;
1459            return ret;
1460            }
1461
1462        ret = setCaptureMode(mCapMode);
1463        if ( NO_ERROR != ret )
1464            {
1465            CAMHAL_LOGEB("setCaptureMode() failed %d", ret);
1466            LOG_FUNCTION_NAME_EXIT;
1467            return ret;
1468            }
1469
1470        CAMHAL_LOGDB("Camera Mode = %d", mCapMode);
1471
1472        if( ( mCapMode == OMXCameraAdapter::VIDEO_MODE ) ||
1473            ( isS3d && (mCapMode == OMXCameraAdapter::HIGH_QUALITY)) )
1474            {
1475            ///Enable/Disable Video Noise Filter
1476            ret = enableVideoNoiseFilter(mVnfEnabled);
1477            if ( NO_ERROR != ret)
1478                {
1479                CAMHAL_LOGEB("Error configuring VNF %x", ret);
1480                return ret;
1481                }
1482
1483            ///Enable/Disable Video Stabilization
1484            ret = enableVideoStabilization(mVstabEnabled);
1485            if ( NO_ERROR != ret)
1486                {
1487                CAMHAL_LOGEB("Error configuring VSTAB %x", ret);
1488                return ret;
1489                }
1490            }
1491        else
1492            {
1493            ret = enableVideoNoiseFilter(false);
1494            if ( NO_ERROR != ret)
1495                {
1496                CAMHAL_LOGEB("Error configuring VNF %x", ret);
1497                return ret;
1498                }
1499            ///Enable/Disable Video Stabilization
1500            ret = enableVideoStabilization(false);
1501            if ( NO_ERROR != ret)
1502                {
1503                CAMHAL_LOGEB("Error configuring VSTAB %x", ret);
1504                return ret;
1505                }
1506            }
1507        }
1508
1509    ret = setSensorOrientation(mSensorOrientation);
1510    if ( NO_ERROR != ret )
1511        {
1512        CAMHAL_LOGEB("Error configuring Sensor Orientation %x", ret);
1513        mSensorOrientation = 0;
1514        }
1515
1516    ret = setVFramerate(mPreviewData->mMinFrameRate, mPreviewData->mMaxFrameRate);
1517    if ( ret != NO_ERROR )
1518        {
1519        CAMHAL_LOGEB("VFR configuration failed 0x%x", ret);
1520        LOG_FUNCTION_NAME_EXIT;
1521        return ret;
1522        }
1523
1524    if ( mComponentState == OMX_StateLoaded )
1525        {
1526        ///Register for IDLE state switch event
1527        ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
1528                               OMX_EventCmdComplete,
1529                               OMX_CommandStateSet,
1530                               OMX_StateIdle,
1531                               mUsePreviewSem);
1532
1533        if(ret!=NO_ERROR)
1534            {
1535            CAMHAL_LOGEB("Error in registering for event %d", ret);
1536            goto EXIT;
1537            }
1538
1539        ///Once we get the buffers, move component state to idle state and pass the buffers to OMX comp using UseBuffer
1540        eError = OMX_SendCommand (mCameraAdapterParameters.mHandleComp ,
1541                                  OMX_CommandStateSet,
1542                                  OMX_StateIdle,
1543                                  NULL);
1544
1545        CAMHAL_LOGDB("OMX_SendCommand(OMX_CommandStateSet) 0x%x", eError);
1546
1547        GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
1548
1549        mComponentState = OMX_StateIdle;
1550        }
1551    else
1552        {
1553            ///Register for Preview port ENABLE event
1554            ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
1555                                   OMX_EventCmdComplete,
1556                                   OMX_CommandPortEnable,
1557                                   mCameraAdapterParameters.mPrevPortIndex,
1558                                   mUsePreviewSem);
1559
1560            if ( NO_ERROR != ret )
1561                {
1562                CAMHAL_LOGEB("Error in registering for event %d", ret);
1563                goto EXIT;
1564                }
1565
1566            ///Enable Preview Port
1567            eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
1568                                     OMX_CommandPortEnable,
1569                                     mCameraAdapterParameters.mPrevPortIndex,
1570                                     NULL);
1571        }
1572
1573
1574    ///Configure DOMX to use either gralloc handles or vptrs
1575    OMX_TI_PARAMUSENATIVEBUFFER domxUseGrallocHandles;
1576    OMX_INIT_STRUCT_PTR (&domxUseGrallocHandles, OMX_TI_PARAMUSENATIVEBUFFER);
1577
1578    domxUseGrallocHandles.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1579    domxUseGrallocHandles.bEnable = OMX_TRUE;
1580
1581    eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp,
1582                            (OMX_INDEXTYPE)OMX_TI_IndexUseNativeBuffers, &domxUseGrallocHandles);
1583    if(eError!=OMX_ErrorNone)
1584        {
1585        CAMHAL_LOGEB("OMX_SetParameter - %x", eError);
1586        }
1587    GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
1588
1589    OMX_BUFFERHEADERTYPE *pBufferHdr;
1590    for(int index=0;index<num;index++) {
1591
1592        CAMHAL_LOGDB("OMX_UseBuffer(0x%x)", buffers[index]);
1593        eError = OMX_UseBuffer( mCameraAdapterParameters.mHandleComp,
1594                                &pBufferHdr,
1595                                mCameraAdapterParameters.mPrevPortIndex,
1596                                0,
1597                                mPreviewData->mBufSize,
1598                                (OMX_U8*)buffers[index]);
1599        if(eError!=OMX_ErrorNone)
1600            {
1601            CAMHAL_LOGEB("OMX_UseBuffer-0x%x", eError);
1602            }
1603        GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
1604
1605        //pBufferHdr->pAppPrivate =  (OMX_PTR)pBufferHdr;
1606        pBufferHdr->nSize = sizeof(OMX_BUFFERHEADERTYPE);
1607        pBufferHdr->nVersion.s.nVersionMajor = 1 ;
1608        pBufferHdr->nVersion.s.nVersionMinor = 1 ;
1609        pBufferHdr->nVersion.s.nRevision = 0 ;
1610        pBufferHdr->nVersion.s.nStep =  0;
1611        mPreviewData->mBufferHeader[index] = pBufferHdr;
1612    }
1613
1614    if ( mMeasurementEnabled )
1615        {
1616
1617        for( int i = 0; i < num; i++ )
1618            {
1619            OMX_BUFFERHEADERTYPE *pBufHdr;
1620            eError = OMX_UseBuffer( mCameraAdapterParameters.mHandleComp,
1621                                    &pBufHdr,
1622                                    mCameraAdapterParameters.mMeasurementPortIndex,
1623                                    0,
1624                                    measurementData->mBufSize,
1625                                    (OMX_U8*)(mPreviewDataBuffers[i]));
1626
1627             if ( eError == OMX_ErrorNone )
1628                {
1629                pBufHdr->nSize = sizeof(OMX_BUFFERHEADERTYPE);
1630                pBufHdr->nVersion.s.nVersionMajor = 1 ;
1631                pBufHdr->nVersion.s.nVersionMinor = 1 ;
1632                pBufHdr->nVersion.s.nRevision = 0 ;
1633                pBufHdr->nVersion.s.nStep =  0;
1634                measurementData->mBufferHeader[i] = pBufHdr;
1635                }
1636            else
1637                {
1638                CAMHAL_LOGEB("OMX_UseBuffer -0x%x", eError);
1639                ret = BAD_VALUE;
1640                break;
1641                }
1642            }
1643
1644        }
1645
1646    CAMHAL_LOGDA("Registering preview buffers");
1647
1648    ret = mUsePreviewSem.WaitTimeout(OMX_CMD_TIMEOUT);
1649    if ( NO_ERROR == ret )
1650        {
1651        CAMHAL_LOGDA("Preview buffer registration successfull");
1652        }
1653    else
1654        {
1655        if ( mComponentState == OMX_StateLoaded )
1656            {
1657            ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp,
1658                               OMX_EventCmdComplete,
1659                               OMX_CommandStateSet,
1660                               OMX_StateIdle,
1661                               NULL);
1662            }
1663        else
1664            {
1665            ret |= SignalEvent(mCameraAdapterParameters.mHandleComp,
1666                               OMX_EventCmdComplete,
1667                               OMX_CommandPortEnable,
1668                               mCameraAdapterParameters.mPrevPortIndex,
1669                               NULL);
1670            }
1671        CAMHAL_LOGEA("Timeout expired on preview buffer registration");
1672        goto EXIT;
1673        }
1674
1675    LOG_FUNCTION_NAME_EXIT;
1676
1677    return (ret | ErrorUtils::omxToAndroidError(eError));
1678
1679    ///If there is any failure, we reach here.
1680    ///Here, we do any resource freeing and convert from OMX error code to Camera Hal error code
1681    EXIT:
1682
1683    CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, ret, eError);
1684
1685    LOG_FUNCTION_NAME_EXIT;
1686
1687    return (ret | ErrorUtils::omxToAndroidError(eError));
1688}
1689
1690status_t OMXCameraAdapter::startPreview()
1691{
1692    status_t ret = NO_ERROR;
1693    OMX_ERRORTYPE eError = OMX_ErrorNone;
1694    OMXCameraPortParameters *mPreviewData = NULL;
1695    OMXCameraPortParameters *measurementData = NULL;
1696
1697    LOG_FUNCTION_NAME;
1698
1699    if( 0 != mStartPreviewSem.Count() )
1700        {
1701        CAMHAL_LOGEB("Error mStartPreviewSem semaphore count %d", mStartPreviewSem.Count());
1702        LOG_FUNCTION_NAME_EXIT;
1703        return NO_INIT;
1704        }
1705
1706    mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
1707    measurementData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex];
1708
1709    if( OMX_StateIdle == mComponentState )
1710        {
1711        ///Register for EXECUTING state transition.
1712        ///This method just inserts a message in Event Q, which is checked in the callback
1713        ///The sempahore passed is signalled by the callback
1714        ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
1715                               OMX_EventCmdComplete,
1716                               OMX_CommandStateSet,
1717                               OMX_StateExecuting,
1718                               mStartPreviewSem);
1719
1720        if(ret!=NO_ERROR)
1721            {
1722            CAMHAL_LOGEB("Error in registering for event %d", ret);
1723            goto EXIT;
1724            }
1725
1726        ///Switch to EXECUTING state
1727        eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
1728                                 OMX_CommandStateSet,
1729                                 OMX_StateExecuting,
1730                                 NULL);
1731
1732        if(eError!=OMX_ErrorNone)
1733            {
1734            CAMHAL_LOGEB("OMX_SendCommand(OMX_StateExecuting)-0x%x", eError);
1735            }
1736
1737        CAMHAL_LOGDA("+Waiting for component to go into EXECUTING state");
1738        ret = mStartPreviewSem.WaitTimeout(OMX_CMD_TIMEOUT);
1739        if ( NO_ERROR == ret )
1740            {
1741            CAMHAL_LOGDA("+Great. Component went into executing state!!");
1742            }
1743        else
1744            {
1745            ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp,
1746                               OMX_EventCmdComplete,
1747                               OMX_CommandStateSet,
1748                               OMX_StateExecuting,
1749                               NULL);
1750            CAMHAL_LOGDA("Timeout expired on executing state switch!");
1751            goto EXIT;
1752            }
1753
1754        mComponentState = OMX_StateExecuting;
1755
1756        }
1757
1758    //Queue all the buffers on preview port
1759    for(int index=0;index< mPreviewData->mMaxQueueable;index++)
1760        {
1761        CAMHAL_LOGDB("Queuing buffer on Preview port - 0x%x", (uint32_t)mPreviewData->mBufferHeader[index]->pBuffer);
1762        eError = OMX_FillThisBuffer(mCameraAdapterParameters.mHandleComp,
1763                    (OMX_BUFFERHEADERTYPE*)mPreviewData->mBufferHeader[index]);
1764        if(eError!=OMX_ErrorNone)
1765            {
1766            CAMHAL_LOGEB("OMX_FillThisBuffer-0x%x", eError);
1767            }
1768        GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
1769        }
1770
1771    if ( mMeasurementEnabled )
1772        {
1773
1774        for(int index=0;index< mPreviewData->mNumBufs;index++)
1775            {
1776            CAMHAL_LOGDB("Queuing buffer on Measurement port - 0x%x", (uint32_t) measurementData->mBufferHeader[index]->pBuffer);
1777            eError = OMX_FillThisBuffer(mCameraAdapterParameters.mHandleComp,
1778                            (OMX_BUFFERHEADERTYPE*) measurementData->mBufferHeader[index]);
1779            if(eError!=OMX_ErrorNone)
1780                {
1781                CAMHAL_LOGEB("OMX_FillThisBuffer-0x%x", eError);
1782                }
1783            GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
1784            }
1785
1786        }
1787
1788    if ( mPending3Asettings )
1789        apply3Asettings(mParameters3A);
1790
1791    //Query current focus distance after
1792    //starting the preview
1793    updateFocusDistances(mParameters);
1794
1795    //reset frame rate estimates
1796    mFPS = 0.0f;
1797    mLastFPS = 0.0f;
1798    mFrameCount = 0;
1799    mLastFrameCount = 0;
1800    mIter = 1;
1801    mLastFPSTime = systemTime();
1802
1803    LOG_FUNCTION_NAME_EXIT;
1804
1805    return ret;
1806
1807    EXIT:
1808
1809    CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, ret, eError);
1810
1811    LOG_FUNCTION_NAME_EXIT;
1812
1813    return (ret | ErrorUtils::omxToAndroidError(eError));
1814
1815}
1816
1817status_t OMXCameraAdapter::stopPreview()
1818{
1819    LOG_FUNCTION_NAME;
1820
1821    OMX_ERRORTYPE eError = OMX_ErrorNone;
1822    status_t ret = NO_ERROR;
1823
1824    OMXCameraPortParameters *mCaptureData , *mPreviewData, *measurementData;
1825    mCaptureData = mPreviewData = measurementData = NULL;
1826
1827    mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
1828    mCaptureData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex];
1829    measurementData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex];
1830
1831    if ( mComponentState != OMX_StateExecuting )
1832        {
1833        CAMHAL_LOGEA("Calling StopPreview() when not in EXECUTING state");
1834        LOG_FUNCTION_NAME_EXIT;
1835        return NO_INIT;
1836        }
1837
1838    ret = cancelAutoFocus();
1839    if(ret!=NO_ERROR)
1840    {
1841        CAMHAL_LOGEB("Error canceling autofocus %d", ret);
1842        // Error, but we probably still want to continue to stop preview
1843    }
1844
1845    //Release 3A locks
1846    ret = set3ALock(OMX_FALSE, OMX_FALSE);
1847    if(ret!=NO_ERROR)
1848      {
1849        CAMHAL_LOGEB("Error Releaseing 3A locks%d", ret);
1850      }
1851
1852    if ( 0 != mStopPreviewSem.Count() )
1853        {
1854        CAMHAL_LOGEB("Error mStopPreviewSem semaphore count %d", mStopPreviewSem.Count());
1855        LOG_FUNCTION_NAME_EXIT;
1856        return NO_INIT;
1857        }
1858
1859    CAMHAL_LOGDB("Average framerate: %f", mFPS);
1860
1861    //Avoid state switching of the OMX Component
1862    ret = flushBuffers();
1863    if ( NO_ERROR != ret )
1864        {
1865        CAMHAL_LOGEB("Flush Buffers failed 0x%x", ret);
1866        goto EXIT;
1867        }
1868
1869    ///Register for Preview port Disable event
1870    ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
1871                           OMX_EventCmdComplete,
1872                           OMX_CommandPortDisable,
1873                           mCameraAdapterParameters.mPrevPortIndex,
1874                           mStopPreviewSem);
1875
1876    ///Disable Preview Port
1877    eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
1878                             OMX_CommandPortDisable,
1879                             mCameraAdapterParameters.mPrevPortIndex,
1880                             NULL);
1881
1882    ///Free the OMX Buffers
1883    for ( int i = 0 ; i < mPreviewData->mNumBufs ; i++ )
1884        {
1885        eError = OMX_FreeBuffer(mCameraAdapterParameters.mHandleComp,
1886                                mCameraAdapterParameters.mPrevPortIndex,
1887                                mPreviewData->mBufferHeader[i]);
1888
1889        if(eError!=OMX_ErrorNone)
1890            {
1891            CAMHAL_LOGEB("OMX_FreeBuffer - %x", eError);
1892            }
1893        GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
1894        }
1895
1896    if ( mMeasurementEnabled )
1897        {
1898
1899            for ( int i = 0 ; i < measurementData->mNumBufs ; i++ )
1900                {
1901                eError = OMX_FreeBuffer(mCameraAdapterParameters.mHandleComp,
1902                                        mCameraAdapterParameters.mMeasurementPortIndex,
1903                                        measurementData->mBufferHeader[i]);
1904                if(eError!=OMX_ErrorNone)
1905                    {
1906                    CAMHAL_LOGEB("OMX_FreeBuffer - %x", eError);
1907                    }
1908                GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
1909                }
1910
1911            {
1912            Mutex::Autolock lock(mPreviewDataBufferLock);
1913            mPreviewDataBuffersAvailable.clear();
1914            }
1915
1916        }
1917
1918    CAMHAL_LOGDA("Disabling preview port");
1919    ret = mStopPreviewSem.WaitTimeout(OMX_CMD_TIMEOUT);
1920    if ( NO_ERROR == ret )
1921        {
1922        CAMHAL_LOGDA("Preview port disabled");
1923        }
1924    else
1925        {
1926        ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp,
1927                           OMX_EventCmdComplete,
1928                           OMX_CommandPortDisable,
1929                           mCameraAdapterParameters.mPrevPortIndex,
1930                           NULL);
1931        CAMHAL_LOGEA("Timeout expired on preview port disable");
1932        goto EXIT;
1933        }
1934
1935        {
1936        Mutex::Autolock lock(mPreviewBufferLock);
1937        ///Clear all the available preview buffers
1938        mPreviewBuffersAvailable.clear();
1939        }
1940
1941    switchToLoaded();
1942
1943
1944    mFirstTimeInit = true;
1945
1946    LOG_FUNCTION_NAME_EXIT;
1947
1948    return (ret | ErrorUtils::omxToAndroidError(eError));
1949
1950    EXIT:
1951
1952    {
1953    Mutex::Autolock lock(mPreviewBufferLock);
1954    ///Clear all the available preview buffers
1955    mPreviewBuffersAvailable.clear();
1956    }
1957
1958    switchToLoaded();
1959
1960    LOG_FUNCTION_NAME_EXIT;
1961
1962    return (ret | ErrorUtils::omxToAndroidError(eError));
1963
1964}
1965
1966status_t OMXCameraAdapter::setSensorOverclock(bool enable)
1967{
1968    status_t ret = NO_ERROR;
1969    OMX_ERRORTYPE eError = OMX_ErrorNone;
1970    OMX_CONFIG_BOOLEANTYPE bOMX;
1971
1972    LOG_FUNCTION_NAME;
1973
1974    if ( OMX_StateLoaded != mComponentState )
1975        {
1976        CAMHAL_LOGDA("OMX component is not in loaded state");
1977        return ret;
1978        }
1979
1980    if ( NO_ERROR == ret )
1981        {
1982        OMX_INIT_STRUCT_PTR (&bOMX, OMX_CONFIG_BOOLEANTYPE);
1983
1984        if ( enable )
1985            {
1986            bOMX.bEnabled = OMX_TRUE;
1987            }
1988        else
1989            {
1990            bOMX.bEnabled = OMX_FALSE;
1991            }
1992
1993        CAMHAL_LOGDB("Configuring Sensor overclock mode 0x%x", bOMX.bEnabled);
1994        eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp, ( OMX_INDEXTYPE ) OMX_TI_IndexParamSensorOverClockMode, &bOMX);
1995        if ( OMX_ErrorNone != eError )
1996            {
1997            CAMHAL_LOGEB("Error while setting Sensor overclock 0x%x", eError);
1998            ret = BAD_VALUE;
1999            }
2000        else
2001            {
2002            mSensorOverclock = enable;
2003            }
2004        }
2005
2006    LOG_FUNCTION_NAME_EXIT;
2007
2008    return ret;
2009}
2010
2011status_t OMXCameraAdapter::printComponentVersion(OMX_HANDLETYPE handle)
2012{
2013    status_t ret = NO_ERROR;
2014    OMX_ERRORTYPE eError = OMX_ErrorNone;
2015    OMX_VERSIONTYPE compVersion;
2016    char compName[OMX_MAX_STRINGNAME_SIZE];
2017    char *currentUUID = NULL;
2018    size_t offset = 0;
2019
2020    LOG_FUNCTION_NAME;
2021
2022    if ( NULL == handle )
2023        {
2024        CAMHAL_LOGEB("Invalid OMX Handle =0x%x",  ( unsigned int ) handle);
2025        ret = -EINVAL;
2026        }
2027
2028    mCompUUID[0] = 0;
2029
2030    if ( NO_ERROR == ret )
2031        {
2032        eError = OMX_GetComponentVersion(handle,
2033                                      compName,
2034                                      &compVersion,
2035                                      &mCompRevision,
2036                                      &mCompUUID
2037                                    );
2038        if ( OMX_ErrorNone != eError )
2039            {
2040            CAMHAL_LOGEB("OMX_GetComponentVersion returned 0x%x", eError);
2041            ret = BAD_VALUE;
2042            }
2043        }
2044
2045    if ( NO_ERROR == ret )
2046        {
2047        CAMHAL_LOGVB("OMX Component name: [%s]", compName);
2048        CAMHAL_LOGVB("OMX Component version: [%u]", ( unsigned int ) compVersion.nVersion);
2049        CAMHAL_LOGVB("Spec version: [%u]", ( unsigned int ) mCompRevision.nVersion);
2050        CAMHAL_LOGVB("Git Commit ID: [%s]", mCompUUID);
2051        currentUUID = ( char * ) mCompUUID;
2052        }
2053
2054    if ( NULL != currentUUID )
2055        {
2056        offset = strlen( ( const char * ) mCompUUID) + 1;
2057        if ( (int)currentUUID + (int)offset - (int)mCompUUID < OMX_MAX_STRINGNAME_SIZE )
2058            {
2059            currentUUID += offset;
2060            CAMHAL_LOGVB("Git Branch: [%s]", currentUUID);
2061            }
2062        else
2063            {
2064            ret = BAD_VALUE;
2065            }
2066    }
2067
2068    if ( NO_ERROR == ret )
2069        {
2070        offset = strlen( ( const char * ) currentUUID) + 1;
2071
2072        if ( (int)currentUUID + (int)offset - (int)mCompUUID < OMX_MAX_STRINGNAME_SIZE )
2073            {
2074            currentUUID += offset;
2075            CAMHAL_LOGVB("Build date and time: [%s]", currentUUID);
2076            }
2077        else
2078            {
2079            ret = BAD_VALUE;
2080            }
2081        }
2082
2083    if ( NO_ERROR == ret )
2084        {
2085        offset = strlen( ( const char * ) currentUUID) + 1;
2086
2087        if ( (int)currentUUID + (int)offset - (int)mCompUUID < OMX_MAX_STRINGNAME_SIZE )
2088            {
2089            currentUUID += offset;
2090            CAMHAL_LOGVB("Build description: [%s]", currentUUID);
2091            }
2092        else
2093            {
2094            ret = BAD_VALUE;
2095            }
2096        }
2097
2098    LOG_FUNCTION_NAME_EXIT;
2099
2100    return ret;
2101}
2102
2103status_t OMXCameraAdapter::autoFocus()
2104{
2105    status_t ret = NO_ERROR;
2106    TIUTILS::Message msg;
2107
2108    LOG_FUNCTION_NAME;
2109
2110    msg.command = CommandHandler::CAMERA_PERFORM_AUTOFOCUS;
2111    msg.arg1 = mErrorNotifier;
2112    ret = mCommandHandler->put(&msg);
2113
2114    LOG_FUNCTION_NAME;
2115
2116    return ret;
2117}
2118
2119status_t OMXCameraAdapter::takePicture()
2120{
2121    status_t ret = NO_ERROR;
2122    TIUTILS::Message msg;
2123
2124    LOG_FUNCTION_NAME;
2125
2126    msg.command = CommandHandler::CAMERA_START_IMAGE_CAPTURE;
2127    msg.arg1 = mErrorNotifier;
2128    ret = mCommandHandler->put(&msg);
2129
2130    LOG_FUNCTION_NAME_EXIT;
2131
2132    return ret;
2133}
2134
2135status_t OMXCameraAdapter::startVideoCapture()
2136{
2137    return BaseCameraAdapter::startVideoCapture();
2138}
2139
2140status_t OMXCameraAdapter::stopVideoCapture()
2141{
2142    return BaseCameraAdapter::stopVideoCapture();
2143}
2144
2145//API to get the frame size required to be allocated. This size is used to override the size passed
2146//by camera service when VSTAB/VNF is turned ON for example
2147status_t OMXCameraAdapter::getFrameSize(size_t &width, size_t &height)
2148{
2149    status_t ret = NO_ERROR;
2150    OMX_ERRORTYPE eError = OMX_ErrorNone;
2151    OMX_CONFIG_RECTTYPE tFrameDim;
2152
2153    LOG_FUNCTION_NAME;
2154
2155    OMX_INIT_STRUCT_PTR (&tFrameDim, OMX_CONFIG_RECTTYPE);
2156    tFrameDim.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
2157
2158    if ( mOMXStateSwitch )
2159        {
2160
2161        ret = switchToLoaded();
2162        if ( NO_ERROR != ret )
2163            {
2164            CAMHAL_LOGEB("switchToLoaded() failed 0x%x", ret);
2165            goto exit;
2166            }
2167
2168        mOMXStateSwitch = false;
2169        }
2170
2171    if ( OMX_StateLoaded == mComponentState )
2172        {
2173
2174        ret = setLDC(mIPP);
2175        if ( NO_ERROR != ret )
2176            {
2177            CAMHAL_LOGEB("setLDC() failed %d", ret);
2178            LOG_FUNCTION_NAME_EXIT;
2179            goto exit;
2180            }
2181
2182        ret = setNSF(mIPP);
2183        if ( NO_ERROR != ret )
2184            {
2185            CAMHAL_LOGEB("setNSF() failed %d", ret);
2186            LOG_FUNCTION_NAME_EXIT;
2187            goto exit;
2188            }
2189
2190        ret = setCaptureMode(mCapMode);
2191        if ( NO_ERROR != ret )
2192            {
2193            CAMHAL_LOGEB("setCaptureMode() failed %d", ret);
2194            }
2195
2196        if(mCapMode == OMXCameraAdapter::VIDEO_MODE)
2197            {
2198            if ( NO_ERROR == ret )
2199                {
2200                ///Enable/Disable Video Noise Filter
2201                ret = enableVideoNoiseFilter(mVnfEnabled);
2202                }
2203
2204            if ( NO_ERROR != ret)
2205                {
2206                CAMHAL_LOGEB("Error configuring VNF %x", ret);
2207                }
2208
2209            if ( NO_ERROR == ret )
2210                {
2211                ///Enable/Disable Video Stabilization
2212                ret = enableVideoStabilization(mVstabEnabled);
2213                }
2214
2215            if ( NO_ERROR != ret)
2216                {
2217                CAMHAL_LOGEB("Error configuring VSTAB %x", ret);
2218                }
2219             }
2220        else
2221            {
2222            if ( NO_ERROR == ret )
2223                {
2224                ///Enable/Disable Video Noise Filter
2225                ret = enableVideoNoiseFilter(false);
2226                }
2227
2228            if ( NO_ERROR != ret)
2229                {
2230                CAMHAL_LOGEB("Error configuring VNF %x", ret);
2231                }
2232
2233            if ( NO_ERROR == ret )
2234                {
2235                ///Enable/Disable Video Stabilization
2236                ret = enableVideoStabilization(false);
2237                }
2238
2239            if ( NO_ERROR != ret)
2240                {
2241                CAMHAL_LOGEB("Error configuring VSTAB %x", ret);
2242                }
2243            }
2244
2245        }
2246
2247    ret = setSensorOrientation(mSensorOrientation);
2248    if ( NO_ERROR != ret )
2249        {
2250        CAMHAL_LOGEB("Error configuring Sensor Orientation %x", ret);
2251        mSensorOrientation = 0;
2252        }
2253
2254    if ( NO_ERROR == ret )
2255        {
2256        eError = OMX_GetParameter(mCameraAdapterParameters.mHandleComp, ( OMX_INDEXTYPE ) OMX_TI_IndexParam2DBufferAllocDimension, &tFrameDim);
2257        if ( OMX_ErrorNone == eError)
2258            {
2259            width = tFrameDim.nWidth;
2260            height = tFrameDim.nHeight;
2261            }
2262        }
2263
2264exit:
2265
2266    CAMHAL_LOGDB("Required frame size %dx%d", width, height);
2267
2268    LOG_FUNCTION_NAME_EXIT;
2269
2270    return ret;
2271}
2272
2273status_t OMXCameraAdapter::getFrameDataSize(size_t &dataFrameSize, size_t bufferCount)
2274{
2275    status_t ret = NO_ERROR;
2276    OMX_PARAM_PORTDEFINITIONTYPE portCheck;
2277    OMX_ERRORTYPE eError = OMX_ErrorNone;
2278
2279    LOG_FUNCTION_NAME;
2280
2281    if ( OMX_StateLoaded != mComponentState )
2282        {
2283        CAMHAL_LOGEA("Calling getFrameDataSize() when not in LOADED state");
2284        dataFrameSize = 0;
2285        ret = BAD_VALUE;
2286        }
2287
2288    if ( NO_ERROR == ret  )
2289        {
2290        OMX_INIT_STRUCT_PTR(&portCheck, OMX_PARAM_PORTDEFINITIONTYPE);
2291        portCheck.nPortIndex = mCameraAdapterParameters.mMeasurementPortIndex;
2292
2293        eError = OMX_GetParameter(mCameraAdapterParameters.mHandleComp, OMX_IndexParamPortDefinition, &portCheck);
2294        if ( OMX_ErrorNone != eError )
2295            {
2296            CAMHAL_LOGEB("OMX_GetParameter on OMX_IndexParamPortDefinition returned: 0x%x", eError);
2297            dataFrameSize = 0;
2298            ret = BAD_VALUE;
2299            }
2300        }
2301
2302    if ( NO_ERROR == ret )
2303        {
2304        portCheck.nBufferCountActual = bufferCount;
2305        eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp, OMX_IndexParamPortDefinition, &portCheck);
2306        if ( OMX_ErrorNone != eError )
2307            {
2308            CAMHAL_LOGEB("OMX_SetParameter on OMX_IndexParamPortDefinition returned: 0x%x", eError);
2309            dataFrameSize = 0;
2310            ret = BAD_VALUE;
2311            }
2312        }
2313
2314    if ( NO_ERROR == ret  )
2315        {
2316        eError = OMX_GetParameter(mCameraAdapterParameters.mHandleComp, OMX_IndexParamPortDefinition, &portCheck);
2317        if ( OMX_ErrorNone != eError )
2318            {
2319            CAMHAL_LOGEB("OMX_GetParameter on OMX_IndexParamPortDefinition returned: 0x%x", eError);
2320            ret = BAD_VALUE;
2321            }
2322        else
2323            {
2324            mCameraAdapterParameters.mCameraPortParams[portCheck.nPortIndex].mBufSize = portCheck.nBufferSize;
2325            dataFrameSize = portCheck.nBufferSize;
2326            }
2327        }
2328
2329    LOG_FUNCTION_NAME_EXIT;
2330
2331    return ret;
2332}
2333
2334void OMXCameraAdapter::onOrientationEvent(uint32_t orientation, uint32_t tilt)
2335{
2336    LOG_FUNCTION_NAME;
2337
2338    static const int DEGREES_TILT_IGNORE = 45;
2339    int device_orientation = 0;
2340    int mount_orientation = 0;
2341    const char *facing_direction = NULL;
2342
2343    // if tilt angle is greater than DEGREES_TILT_IGNORE
2344    // we are going to ignore the orientation returned from
2345    // sensor. the orientation returned from sensor is not
2346    // reliable. Value of DEGREES_TILT_IGNORE may need adjusting
2347    if (tilt > DEGREES_TILT_IGNORE) {
2348        return;
2349    }
2350
2351    if (mCapabilities) {
2352        if (mCapabilities->get(CameraProperties::ORIENTATION_INDEX)) {
2353            mount_orientation = atoi(mCapabilities->get(CameraProperties::ORIENTATION_INDEX));
2354        }
2355        facing_direction = mCapabilities->get(CameraProperties::FACING_INDEX);
2356    }
2357
2358    // calculate device orientation relative to the sensor orientation
2359    // front camera display is mirrored...needs to be accounted for when orientation
2360    // is 90 or 270...since this will result in a flip on orientation otherwise
2361    if (facing_direction && !strcmp(facing_direction, TICameraParameters::FACING_FRONT) &&
2362        (orientation == 90 || orientation == 270)) {
2363        device_orientation = (orientation - mount_orientation + 360) % 360;
2364    } else {  // back-facing camera
2365        device_orientation = (orientation + mount_orientation) % 360;
2366    }
2367
2368    if (device_orientation != mDeviceOrientation) {
2369        mDeviceOrientation = device_orientation;
2370
2371        mFaceDetectionLock.lock();
2372        if (mFaceDetectionRunning) {
2373            // restart face detection with new rotation
2374            setFaceDetection(true, mDeviceOrientation);
2375        }
2376        mFaceDetectionLock.unlock();
2377    }
2378    CAMHAL_LOGVB("orientation = %d tilt = %d device_orientation = %d", orientation, tilt, mDeviceOrientation);
2379
2380    LOG_FUNCTION_NAME_EXIT;
2381}
2382
2383/* Application callback Functions */
2384/*========================================================*/
2385/* @ fn SampleTest_EventHandler :: Application callback   */
2386/*========================================================*/
2387OMX_ERRORTYPE OMXCameraAdapterEventHandler(OMX_IN OMX_HANDLETYPE hComponent,
2388                                          OMX_IN OMX_PTR pAppData,
2389                                          OMX_IN OMX_EVENTTYPE eEvent,
2390                                          OMX_IN OMX_U32 nData1,
2391                                          OMX_IN OMX_U32 nData2,
2392                                          OMX_IN OMX_PTR pEventData)
2393{
2394    LOG_FUNCTION_NAME;
2395
2396    CAMHAL_LOGDB("Event %d", eEvent);
2397
2398    OMX_ERRORTYPE ret = OMX_ErrorNone;
2399    OMXCameraAdapter *oca = (OMXCameraAdapter*)pAppData;
2400    ret = oca->OMXCameraAdapterEventHandler(hComponent, eEvent, nData1, nData2, pEventData);
2401
2402    LOG_FUNCTION_NAME_EXIT;
2403    return ret;
2404}
2405
2406/* Application callback Functions */
2407/*========================================================*/
2408/* @ fn SampleTest_EventHandler :: Application callback   */
2409/*========================================================*/
2410OMX_ERRORTYPE OMXCameraAdapter::OMXCameraAdapterEventHandler(OMX_IN OMX_HANDLETYPE hComponent,
2411                                          OMX_IN OMX_EVENTTYPE eEvent,
2412                                          OMX_IN OMX_U32 nData1,
2413                                          OMX_IN OMX_U32 nData2,
2414                                          OMX_IN OMX_PTR pEventData)
2415{
2416
2417    LOG_FUNCTION_NAME;
2418
2419    OMX_ERRORTYPE eError = OMX_ErrorNone;
2420    CAMHAL_LOGDB("+OMX_Event %x, %d %d", eEvent, (int)nData1, (int)nData2);
2421
2422    switch (eEvent) {
2423        case OMX_EventCmdComplete:
2424            CAMHAL_LOGDB("+OMX_EventCmdComplete %d %d", (int)nData1, (int)nData2);
2425
2426            if (OMX_CommandStateSet == nData1) {
2427                mCameraAdapterParameters.mState = (OMX_STATETYPE) nData2;
2428
2429            } else if (OMX_CommandFlush == nData1) {
2430                CAMHAL_LOGDB("OMX_CommandFlush received for port %d", (int)nData2);
2431
2432            } else if (OMX_CommandPortDisable == nData1) {
2433                CAMHAL_LOGDB("OMX_CommandPortDisable received for port %d", (int)nData2);
2434
2435            } else if (OMX_CommandPortEnable == nData1) {
2436                CAMHAL_LOGDB("OMX_CommandPortEnable received for port %d", (int)nData2);
2437
2438            } else if (OMX_CommandMarkBuffer == nData1) {
2439                ///This is not used currently
2440            }
2441
2442            CAMHAL_LOGDA("-OMX_EventCmdComplete");
2443        break;
2444
2445        case OMX_EventIndexSettingChanged:
2446            CAMHAL_LOGDB("OMX_EventIndexSettingChanged event received data1 0x%x, data2 0x%x",
2447                            ( unsigned int ) nData1, ( unsigned int ) nData2);
2448            break;
2449
2450        case OMX_EventError:
2451            CAMHAL_LOGDB("OMX interface failed to execute OMX command %d", (int)nData1);
2452            CAMHAL_LOGDA("See OMX_INDEXTYPE for reference");
2453            if ( NULL != mErrorNotifier && ( ( OMX_U32 ) OMX_ErrorHardware == nData1 ) && mComponentState != OMX_StateInvalid)
2454              {
2455                CAMHAL_LOGEA("***Got Fatal Error Notification***\n");
2456                mComponentState = OMX_StateInvalid;
2457                ///Report Error to App
2458                mErrorNotifier->errorNotify(CAMERA_ERROR_UNKNOWN);
2459              }
2460            break;
2461
2462        case OMX_EventMark:
2463        break;
2464
2465        case OMX_EventPortSettingsChanged:
2466        break;
2467
2468        case OMX_EventBufferFlag:
2469        break;
2470
2471        case OMX_EventResourcesAcquired:
2472        break;
2473
2474        case OMX_EventComponentResumed:
2475        break;
2476
2477        case OMX_EventDynamicResourcesAvailable:
2478        break;
2479
2480        case OMX_EventPortFormatDetected:
2481        break;
2482
2483        default:
2484        break;
2485    }
2486
2487    ///Signal to the thread(s) waiting that the event has occured
2488    SignalEvent(hComponent, eEvent, nData1, nData2, pEventData);
2489
2490   LOG_FUNCTION_NAME_EXIT;
2491   return eError;
2492
2493    EXIT:
2494
2495    CAMHAL_LOGEB("Exiting function %s because of eError=%x", __FUNCTION__, eError);
2496    LOG_FUNCTION_NAME_EXIT;
2497    return eError;
2498}
2499
2500OMX_ERRORTYPE OMXCameraAdapter::SignalEvent(OMX_IN OMX_HANDLETYPE hComponent,
2501                                          OMX_IN OMX_EVENTTYPE eEvent,
2502                                          OMX_IN OMX_U32 nData1,
2503                                          OMX_IN OMX_U32 nData2,
2504                                          OMX_IN OMX_PTR pEventData)
2505{
2506    Mutex::Autolock lock(mEventLock);
2507    TIUTILS::Message *msg;
2508
2509    LOG_FUNCTION_NAME;
2510
2511    if ( !mEventSignalQ.isEmpty() )
2512        {
2513        CAMHAL_LOGDA("Event queue not empty");
2514
2515        for ( unsigned int i = 0 ; i < mEventSignalQ.size() ; i++ )
2516            {
2517            msg = mEventSignalQ.itemAt(i);
2518            if ( NULL != msg )
2519                {
2520                if( ( msg->command != 0 || msg->command == ( unsigned int ) ( eEvent ) )
2521                    && ( !msg->arg1 || ( OMX_U32 ) msg->arg1 == nData1 )
2522                    && ( !msg->arg2 || ( OMX_U32 ) msg->arg2 == nData2 )
2523                    && msg->arg3)
2524                    {
2525                    Semaphore *sem  = (Semaphore*) msg->arg3;
2526                    CAMHAL_LOGDA("Event matched, signalling sem");
2527                    mEventSignalQ.removeAt(i);
2528                    //Signal the semaphore provided
2529                    sem->Signal();
2530                    free(msg);
2531                    break;
2532                    }
2533                }
2534            }
2535        }
2536    else
2537        {
2538        CAMHAL_LOGEA("Event queue empty!!!");
2539        }
2540
2541    LOG_FUNCTION_NAME_EXIT;
2542
2543    return OMX_ErrorNone;
2544}
2545
2546OMX_ERRORTYPE OMXCameraAdapter::RemoveEvent(OMX_IN OMX_HANDLETYPE hComponent,
2547                                            OMX_IN OMX_EVENTTYPE eEvent,
2548                                            OMX_IN OMX_U32 nData1,
2549                                            OMX_IN OMX_U32 nData2,
2550                                            OMX_IN OMX_PTR pEventData)
2551{
2552  Mutex::Autolock lock(mEventLock);
2553  TIUTILS::Message *msg;
2554  LOG_FUNCTION_NAME;
2555
2556  if ( !mEventSignalQ.isEmpty() )
2557    {
2558      CAMHAL_LOGDA("Event queue not empty");
2559
2560      for ( unsigned int i = 0 ; i < mEventSignalQ.size() ; i++ )
2561        {
2562          msg = mEventSignalQ.itemAt(i);
2563          if ( NULL != msg )
2564            {
2565              if( ( msg->command != 0 || msg->command == ( unsigned int ) ( eEvent ) )
2566                  && ( !msg->arg1 || ( OMX_U32 ) msg->arg1 == nData1 )
2567                  && ( !msg->arg2 || ( OMX_U32 ) msg->arg2 == nData2 )
2568                  && msg->arg3)
2569                {
2570                  Semaphore *sem  = (Semaphore*) msg->arg3;
2571                  CAMHAL_LOGDA("Event matched, signalling sem");
2572                  mEventSignalQ.removeAt(i);
2573                  free(msg);
2574                  break;
2575                }
2576            }
2577        }
2578    }
2579  else
2580    {
2581      CAMHAL_LOGEA("Event queue empty!!!");
2582    }
2583  LOG_FUNCTION_NAME_EXIT;
2584
2585  return OMX_ErrorNone;
2586}
2587
2588
2589status_t OMXCameraAdapter::RegisterForEvent(OMX_IN OMX_HANDLETYPE hComponent,
2590                                          OMX_IN OMX_EVENTTYPE eEvent,
2591                                          OMX_IN OMX_U32 nData1,
2592                                          OMX_IN OMX_U32 nData2,
2593                                          OMX_IN Semaphore &semaphore)
2594{
2595    status_t ret = NO_ERROR;
2596    ssize_t res;
2597    Mutex::Autolock lock(mEventLock);
2598
2599    LOG_FUNCTION_NAME;
2600    TIUTILS::Message * msg = ( struct TIUTILS::Message * ) malloc(sizeof(struct TIUTILS::Message));
2601    if ( NULL != msg )
2602        {
2603        msg->command = ( unsigned int ) eEvent;
2604        msg->arg1 = ( void * ) nData1;
2605        msg->arg2 = ( void * ) nData2;
2606        msg->arg3 = ( void * ) &semaphore;
2607        msg->arg4 =  ( void * ) hComponent;
2608        res = mEventSignalQ.add(msg);
2609        if ( NO_MEMORY == res )
2610            {
2611            CAMHAL_LOGEA("No ressources for inserting OMX events");
2612            free(msg);
2613            ret = -ENOMEM;
2614            }
2615        }
2616
2617    LOG_FUNCTION_NAME_EXIT;
2618
2619    return ret;
2620}
2621
2622/*========================================================*/
2623/* @ fn SampleTest_EmptyBufferDone :: Application callback*/
2624/*========================================================*/
2625OMX_ERRORTYPE OMXCameraAdapterEmptyBufferDone(OMX_IN OMX_HANDLETYPE hComponent,
2626                                   OMX_IN OMX_PTR pAppData,
2627                                   OMX_IN OMX_BUFFERHEADERTYPE* pBuffHeader)
2628{
2629    LOG_FUNCTION_NAME;
2630
2631    OMX_ERRORTYPE eError = OMX_ErrorNone;
2632
2633    OMXCameraAdapter *oca = (OMXCameraAdapter*)pAppData;
2634    eError = oca->OMXCameraAdapterEmptyBufferDone(hComponent, pBuffHeader);
2635
2636    LOG_FUNCTION_NAME_EXIT;
2637    return eError;
2638}
2639
2640
2641/*========================================================*/
2642/* @ fn SampleTest_EmptyBufferDone :: Application callback*/
2643/*========================================================*/
2644OMX_ERRORTYPE OMXCameraAdapter::OMXCameraAdapterEmptyBufferDone(OMX_IN OMX_HANDLETYPE hComponent,
2645                                   OMX_IN OMX_BUFFERHEADERTYPE* pBuffHeader)
2646{
2647
2648   LOG_FUNCTION_NAME;
2649
2650   LOG_FUNCTION_NAME_EXIT;
2651
2652   return OMX_ErrorNone;
2653}
2654
2655static void debugShowFPS()
2656{
2657    static int mFrameCount = 0;
2658    static int mLastFrameCount = 0;
2659    static nsecs_t mLastFpsTime = 0;
2660    static float mFps = 0;
2661    mFrameCount++;
2662    if (!(mFrameCount & 0x1F)) {
2663        nsecs_t now = systemTime();
2664        nsecs_t diff = now - mLastFpsTime;
2665        mFps = ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff;
2666        mLastFpsTime = now;
2667        mLastFrameCount = mFrameCount;
2668        LOGD("Camera %d Frames, %f FPS", mFrameCount, mFps);
2669    }
2670    // XXX: mFPS has the value we want
2671}
2672
2673/*========================================================*/
2674/* @ fn SampleTest_FillBufferDone ::  Application callback*/
2675/*========================================================*/
2676OMX_ERRORTYPE OMXCameraAdapterFillBufferDone(OMX_IN OMX_HANDLETYPE hComponent,
2677                                   OMX_IN OMX_PTR pAppData,
2678                                   OMX_IN OMX_BUFFERHEADERTYPE* pBuffHeader)
2679{
2680    TIUTILS::Message msg;
2681    OMX_ERRORTYPE eError = OMX_ErrorNone;
2682
2683    if (UNLIKELY(mDebugFps)) {
2684        debugShowFPS();
2685    }
2686
2687    OMXCameraAdapter *adapter =  ( OMXCameraAdapter * ) pAppData;
2688    if ( NULL != adapter )
2689        {
2690        msg.command = OMXCameraAdapter::OMXCallbackHandler::CAMERA_FILL_BUFFER_DONE;
2691        msg.arg1 = ( void * ) hComponent;
2692        msg.arg2 = ( void * ) pBuffHeader;
2693        adapter->mOMXCallbackHandler->put(&msg);
2694        }
2695
2696    return eError;
2697}
2698
2699/*========================================================*/
2700/* @ fn SampleTest_FillBufferDone ::  Application callback*/
2701/*========================================================*/
2702OMX_ERRORTYPE OMXCameraAdapter::OMXCameraAdapterFillBufferDone(OMX_IN OMX_HANDLETYPE hComponent,
2703                                   OMX_IN OMX_BUFFERHEADERTYPE* pBuffHeader)
2704{
2705
2706    status_t  stat = NO_ERROR;
2707    status_t  res1, res2;
2708    OMXCameraPortParameters  *pPortParam;
2709    OMX_ERRORTYPE eError = OMX_ErrorNone;
2710    CameraFrame::FrameType typeOfFrame = CameraFrame::ALL_FRAMES;
2711    unsigned int refCount = 0;
2712    BaseCameraAdapter::AdapterState state, nextState;
2713    BaseCameraAdapter::getState(state);
2714    BaseCameraAdapter::getNextState(nextState);
2715    sp<CameraFDResult> fdResult = NULL;
2716
2717    res1 = res2 = NO_ERROR;
2718    pPortParam = &(mCameraAdapterParameters.mCameraPortParams[pBuffHeader->nOutputPortIndex]);
2719    if (pBuffHeader->nOutputPortIndex == OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW)
2720        {
2721
2722        if ( ( PREVIEW_ACTIVE & state ) != PREVIEW_ACTIVE )
2723            {
2724            return OMX_ErrorNone;
2725            }
2726
2727        recalculateFPS();
2728
2729            {
2730            Mutex::Autolock lock(mFaceDetectionLock);
2731            if ( mFaceDetectionRunning && !mFaceDetectionPaused ) {
2732                detectFaces(pBuffHeader, fdResult, pPortParam->mWidth, pPortParam->mHeight);
2733                if ( NULL != fdResult.get() ) {
2734                    notifyFaceSubscribers(fdResult);
2735                    fdResult.clear();
2736                }
2737            }
2738            }
2739
2740        stat |= advanceZoom();
2741
2742        // On the fly update to 3A settings not working
2743        // Do not update 3A here if we are in the middle of a capture
2744        // or in the middle of transitioning to it
2745        if( mPending3Asettings && ((nextState & CAPTURE_ACTIVE) == 0))
2746            {
2747            apply3Asettings(mParameters3A);
2748            }
2749
2750        ///Prepare the frames to be sent - initialize CameraFrame object and reference count
2751        CameraFrame cameraFrameVideo, cameraFramePreview;
2752        if ( mRecording )
2753            {
2754            res1 = initCameraFrame(cameraFrameVideo,
2755                                   pBuffHeader,
2756                                   CameraFrame::VIDEO_FRAME_SYNC,
2757                                   pPortParam);
2758            }
2759
2760        if( mWaitingForSnapshot &&  (mCapturedFrames > 0) )
2761            {
2762            typeOfFrame = CameraFrame::SNAPSHOT_FRAME;
2763            }
2764        else
2765            {
2766            typeOfFrame = CameraFrame::PREVIEW_FRAME_SYNC;
2767            }
2768
2769        LOGV("FBD pBuffer = 0x%x", pBuffHeader->pBuffer);
2770
2771        res2 = initCameraFrame(cameraFramePreview,
2772                               pBuffHeader,
2773                               typeOfFrame,
2774                               pPortParam);
2775
2776        stat |= res1 | res2;
2777
2778        if ( mRecording )
2779            {
2780            res1  = sendFrame(cameraFrameVideo);
2781            }
2782
2783        if( mWaitingForSnapshot )
2784            {
2785            mSnapshotCount++;
2786
2787            if ( (mSnapshotCount == 1) &&
2788                 ((HIGH_SPEED == mCapMode) || (VIDEO_MODE == mCapMode)) )
2789                {
2790                notifyShutterSubscribers();
2791                }
2792            }
2793
2794        res2 = sendFrame(cameraFramePreview);
2795
2796        stat |= ( ( NO_ERROR == res1 ) || ( NO_ERROR == res2 ) ) ? ( ( int ) NO_ERROR ) : ( -1 );
2797
2798        }
2799    else if( pBuffHeader->nOutputPortIndex == OMX_CAMERA_PORT_VIDEO_OUT_MEASUREMENT )
2800        {
2801        typeOfFrame = CameraFrame::FRAME_DATA_SYNC;
2802        CameraFrame cameraFrame;
2803        stat |= initCameraFrame(cameraFrame,
2804                                pBuffHeader,
2805                                typeOfFrame,
2806                                pPortParam);
2807        stat |= sendFrame(cameraFrame);
2808       }
2809    else if( pBuffHeader->nOutputPortIndex == OMX_CAMERA_PORT_IMAGE_OUT_IMAGE )
2810        {
2811        CameraFrame cameraFrame;
2812        OMX_COLOR_FORMATTYPE pixFormat;
2813        const char *valstr = NULL;
2814
2815        pixFormat = mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex].mColorFormat;
2816        valstr = mParams.getPictureFormat();
2817
2818        if ( OMX_COLOR_FormatUnused == pixFormat )
2819            {
2820            typeOfFrame = CameraFrame::IMAGE_FRAME;
2821            }
2822        else if ( pixFormat == OMX_COLOR_FormatCbYCrY &&
2823                  ((valstr && !strcmp(valstr, CameraParameters::PIXEL_FORMAT_JPEG)) ||
2824                   !valstr) )
2825            {
2826            // signals to callbacks that this needs to be coverted to jpeg
2827            // before returning to framework
2828            typeOfFrame = CameraFrame::IMAGE_FRAME;
2829            cameraFrame.mQuirks |= CameraFrame::ENCODE_RAW_YUV422I_TO_JPEG;
2830            }
2831        else
2832            {
2833            typeOfFrame = CameraFrame::RAW_FRAME;
2834            }
2835
2836            pPortParam->mImageType = typeOfFrame;
2837
2838            if((mCapturedFrames>0) && !mCaptureSignalled)
2839                {
2840                mCaptureSignalled = true;
2841                mCaptureSem.Signal();
2842                }
2843
2844            if( ( CAPTURE_ACTIVE & state ) != CAPTURE_ACTIVE )
2845                {
2846                goto EXIT;
2847                }
2848
2849            {
2850            Mutex::Autolock lock(mBracketingLock);
2851            if ( mBracketingEnabled )
2852                {
2853                doBracketing(pBuffHeader, typeOfFrame);
2854                return eError;
2855                }
2856            }
2857
2858        if ( 1 > mCapturedFrames )
2859            {
2860            goto EXIT;
2861            }
2862
2863        CAMHAL_LOGDB("Captured Frames: %d", mCapturedFrames);
2864
2865        mCapturedFrames--;
2866
2867        stat |= initCameraFrame(cameraFrame,
2868                                pBuffHeader,
2869                                typeOfFrame,
2870                                pPortParam);
2871        stat |= sendFrame(cameraFrame);
2872        }
2873    else
2874        {
2875        CAMHAL_LOGEA("Frame received for non-(preview/capture/measure) port. This is yet to be supported");
2876        goto EXIT;
2877        }
2878
2879    if ( NO_ERROR != stat )
2880        {
2881        CAMHAL_LOGDB("sendFrameToSubscribers error: %d", stat);
2882        returnFrame(pBuffHeader->pBuffer, typeOfFrame);
2883        }
2884
2885    return eError;
2886
2887    EXIT:
2888
2889    CAMHAL_LOGEB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, stat, eError);
2890
2891    if ( NO_ERROR != stat )
2892        {
2893        if ( NULL != mErrorNotifier )
2894            {
2895            mErrorNotifier->errorNotify(CAMERA_ERROR_UNKNOWN);
2896            }
2897        }
2898
2899    return eError;
2900}
2901
2902status_t OMXCameraAdapter::recalculateFPS()
2903{
2904    float currentFPS;
2905
2906    mFrameCount++;
2907
2908    if ( ( mFrameCount % FPS_PERIOD ) == 0 )
2909        {
2910        nsecs_t now = systemTime();
2911        nsecs_t diff = now - mLastFPSTime;
2912        currentFPS =  ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff;
2913        mLastFPSTime = now;
2914        mLastFrameCount = mFrameCount;
2915
2916        if ( 1 == mIter )
2917            {
2918            mFPS = currentFPS;
2919            }
2920        else
2921            {
2922            //cumulative moving average
2923            mFPS = mLastFPS + (currentFPS - mLastFPS)/mIter;
2924            }
2925
2926        mLastFPS = mFPS;
2927        mIter++;
2928        }
2929
2930    return NO_ERROR;
2931}
2932
2933status_t OMXCameraAdapter::sendFrame(CameraFrame &frame)
2934{
2935    status_t ret = NO_ERROR;
2936
2937    LOG_FUNCTION_NAME;
2938
2939
2940    if ( NO_ERROR == ret )
2941        {
2942        ret = sendFrameToSubscribers(&frame);
2943        }
2944
2945    LOG_FUNCTION_NAME_EXIT;
2946
2947    return ret;
2948}
2949
2950status_t OMXCameraAdapter::initCameraFrame( CameraFrame &frame,
2951                                            OMX_IN OMX_BUFFERHEADERTYPE *pBuffHeader,
2952                                            int typeOfFrame,
2953                                            OMXCameraPortParameters *port)
2954{
2955    status_t ret = NO_ERROR;
2956
2957    LOG_FUNCTION_NAME;
2958
2959    if ( NULL == port)
2960        {
2961        CAMHAL_LOGEA("Invalid portParam");
2962        return -EINVAL;
2963        }
2964
2965    if ( NULL == pBuffHeader )
2966        {
2967        CAMHAL_LOGEA("Invalid Buffer header");
2968        return -EINVAL;
2969        }
2970
2971    frame.mFrameType = typeOfFrame;
2972    frame.mBuffer = pBuffHeader->pBuffer;
2973    frame.mLength = pBuffHeader->nFilledLen;
2974    frame.mAlignment = port->mStride;
2975    frame.mOffset = pBuffHeader->nOffset;
2976    frame.mWidth = port->mWidth;
2977    frame.mHeight = port->mHeight;
2978
2979    // Calculating the time source delta of Ducati & system time only once at the start of camera.
2980    // It's seen that there is a one-time constant diff between the ducati source clock &
2981    // System monotonic timer, although both derived from the same 32KHz clock.
2982    // This delta is offsetted to/from ducati timestamp to match with system time so that
2983    // video timestamps are aligned with Audio with a periodic timestamp intervals.
2984    if ( onlyOnce )
2985        {
2986        mTimeSourceDelta = (pBuffHeader->nTimeStamp * 1000) - systemTime(SYSTEM_TIME_MONOTONIC);
2987        onlyOnce = false;
2988        }
2989
2990    // Calculating the new video timestamp based on offset from ducati source.
2991    frame.mTimestamp = (pBuffHeader->nTimeStamp * 1000) - mTimeSourceDelta;
2992
2993        LOG_FUNCTION_NAME_EXIT;
2994
2995    return ret;
2996}
2997
2998bool OMXCameraAdapter::CommandHandler::Handler()
2999{
3000    TIUTILS::Message msg;
3001    volatile int forever = 1;
3002    status_t stat;
3003    ErrorNotifier *errorNotify = NULL;
3004
3005    LOG_FUNCTION_NAME;
3006
3007    while ( forever )
3008        {
3009        stat = NO_ERROR;
3010        CAMHAL_LOGDA("Handler: waiting for messsage...");
3011        TIUTILS::MessageQueue::waitForMsg(&mCommandMsgQ, NULL, NULL, -1);
3012        mCommandMsgQ.get(&msg);
3013        CAMHAL_LOGDB("msg.command = %d", msg.command);
3014        switch ( msg.command ) {
3015            case CommandHandler::CAMERA_START_IMAGE_CAPTURE:
3016            {
3017                stat = mCameraAdapter->startImageCapture();
3018                break;
3019            }
3020            case CommandHandler::CAMERA_PERFORM_AUTOFOCUS:
3021            {
3022                stat = mCameraAdapter->doAutoFocus();
3023                break;
3024            }
3025            case CommandHandler::COMMAND_EXIT:
3026            {
3027                CAMHAL_LOGEA("Exiting command handler");
3028                forever = 0;
3029                break;
3030            }
3031        }
3032
3033        if ( NO_ERROR != stat )
3034            {
3035            errorNotify = ( ErrorNotifier * ) msg.arg1;
3036            if ( NULL != errorNotify )
3037                {
3038                errorNotify->errorNotify(CAMERA_ERROR_UNKNOWN);
3039                }
3040            }
3041        }
3042
3043    LOG_FUNCTION_NAME_EXIT;
3044
3045    return false;
3046}
3047
3048bool OMXCameraAdapter::OMXCallbackHandler::Handler()
3049{
3050    TIUTILS::Message msg;
3051    volatile int forever = 1;
3052    status_t ret = NO_ERROR;
3053
3054    LOG_FUNCTION_NAME;
3055
3056    while(forever){
3057        TIUTILS::MessageQueue::waitForMsg(&mCommandMsgQ, NULL, NULL, -1);
3058        mCommandMsgQ.get(&msg);
3059        switch ( msg.command ) {
3060            case OMXCallbackHandler::CAMERA_FILL_BUFFER_DONE:
3061            {
3062                ret = mCameraAdapter->OMXCameraAdapterFillBufferDone(( OMX_HANDLETYPE ) msg.arg1,
3063                                                                     ( OMX_BUFFERHEADERTYPE *) msg.arg2);
3064                break;
3065            }
3066            case CommandHandler::COMMAND_EXIT:
3067            {
3068                CAMHAL_LOGEA("Exiting OMX callback handler");
3069                forever = 0;
3070                break;
3071            }
3072        }
3073    }
3074
3075    LOG_FUNCTION_NAME_EXIT;
3076    return false;
3077}
3078
3079OMXCameraAdapter::OMXCameraAdapter():mComponentState (OMX_StateInvalid)
3080{
3081    LOG_FUNCTION_NAME;
3082
3083    mPictureRotation = 0;
3084    // Initial values
3085    mTimeSourceDelta = 0;
3086    onlyOnce = true;
3087
3088    mDoAFSem.Create(0);
3089    mInitSem.Create(0);
3090    mFlushSem.Create(0);
3091    mUsePreviewDataSem.Create(0);
3092    mUsePreviewSem.Create(0);
3093    mUseCaptureSem.Create(0);
3094    mStartPreviewSem.Create(0);
3095    mStopPreviewSem.Create(0);
3096    mStartCaptureSem.Create(0);
3097    mStopCaptureSem.Create(0);
3098    mSwitchToLoadedSem.Create(0);
3099    mCaptureSem.Create(0);
3100
3101    mCameraAdapterParameters.mHandleComp = 0;
3102
3103    mUserSetExpLock = OMX_FALSE;
3104    mUserSetWbLock = OMX_FALSE;
3105
3106    LOG_FUNCTION_NAME_EXIT;
3107}
3108
3109OMXCameraAdapter::~OMXCameraAdapter()
3110{
3111    LOG_FUNCTION_NAME;
3112
3113    Mutex::Autolock lock(gAdapterLock);
3114
3115    //Return to OMX Loaded state
3116    switchToLoaded();
3117
3118    ///Free the handle for the Camera component
3119    if(mCameraAdapterParameters.mHandleComp)
3120        {
3121        OMX_FreeHandle(mCameraAdapterParameters.mHandleComp);
3122        }
3123
3124    ///De-init the OMX
3125    if( (mComponentState==OMX_StateLoaded) || (mComponentState==OMX_StateInvalid))
3126        {
3127        OMX_Deinit();
3128        }
3129
3130    //Remove any unhandled events
3131    if ( !mEventSignalQ.isEmpty() )
3132      {
3133        for (unsigned int i = 0 ; i < mEventSignalQ.size() ; i++ )
3134          {
3135            TIUTILS::Message *msg = mEventSignalQ.itemAt(i);
3136            //remove from queue and free msg
3137            mEventSignalQ.removeAt(i);
3138            if ( NULL != msg )
3139              {
3140                free(msg);
3141              }
3142          }
3143      }
3144
3145    //Exit and free ref to command handling thread
3146    if ( NULL != mCommandHandler.get() )
3147    {
3148        TIUTILS::Message msg;
3149        msg.command = CommandHandler::COMMAND_EXIT;
3150        msg.arg1 = mErrorNotifier;
3151        mCommandHandler->put(&msg);
3152        mCommandHandler->requestExitAndWait();
3153        mCommandHandler.clear();
3154    }
3155
3156    //Exit and free ref to callback handling thread
3157    if ( NULL != mOMXCallbackHandler.get() )
3158    {
3159        TIUTILS::Message msg;
3160        msg.command = OMXCallbackHandler::COMMAND_EXIT;
3161        mOMXCallbackHandler->put(&msg);
3162        mOMXCallbackHandler->requestExitAndWait();
3163        mOMXCallbackHandler.clear();
3164    }
3165
3166    gCameraAdapter = NULL;
3167
3168    LOG_FUNCTION_NAME_EXIT;
3169}
3170
3171extern "C" CameraAdapter* CameraAdapter_Factory()
3172{
3173    Mutex::Autolock lock(gAdapterLock);
3174
3175    LOG_FUNCTION_NAME;
3176
3177    if ( NULL == gCameraAdapter )
3178        {
3179        CAMHAL_LOGDA("Creating new Camera adapter instance");
3180        gCameraAdapter= new OMXCameraAdapter();
3181        }
3182    else
3183        {
3184        CAMHAL_LOGDA("Reusing existing Camera adapter instance");
3185        }
3186
3187    LOG_FUNCTION_NAME_EXIT;
3188
3189    return gCameraAdapter;
3190}
3191
3192extern "C" int CameraAdapter_Capabilities(CameraProperties::Properties* properties_array,
3193                                          const unsigned int starting_camera,
3194                                          const unsigned int max_camera) {
3195    int num_cameras_supported = 0;
3196    CameraProperties::Properties* properties = NULL;
3197    OMX_ERRORTYPE eError = OMX_ErrorNone;
3198    OMX_HANDLETYPE handle = NULL;
3199    OMX_TI_CAPTYPE caps;
3200
3201    LOG_FUNCTION_NAME;
3202
3203    if (!properties_array) {
3204        CAMHAL_LOGEB("invalid param: properties = 0x%p", properties_array);
3205        LOG_FUNCTION_NAME_EXIT;
3206        return -EINVAL;
3207    }
3208
3209    // OMX_Init
3210    eError = OMX_Init();
3211    if (eError != OMX_ErrorNone) {
3212        CAMHAL_LOGEB("OMX_Init -0x%x", eError);
3213        return 0;  // no cameras supported
3214    }
3215
3216    // Setup key parameters to send to Ducati during init
3217    OMX_CALLBACKTYPE oCallbacks;
3218
3219    // Initialize the callback handles
3220    oCallbacks.EventHandler    = android::OMXCameraAdapterEventHandler;
3221    oCallbacks.EmptyBufferDone = android::OMXCameraAdapterEmptyBufferDone;
3222    oCallbacks.FillBufferDone  = android::OMXCameraAdapterFillBufferDone;
3223
3224    // Get Handle
3225    eError = OMX_GetHandle(&handle, (OMX_STRING)"OMX.TI.DUCATI1.VIDEO.CAMERA", NULL, &oCallbacks);
3226    if (eError != OMX_ErrorNone) {
3227        CAMHAL_LOGEB("OMX_GetHandle -0x%x", eError);
3228        goto EXIT;
3229    }
3230
3231    // Continue selecting sensor and then querying OMX Camera for it's capabilities
3232    // When sensor select returns an error, we know to break and stop
3233    while (eError == OMX_ErrorNone &&
3234           (starting_camera + num_cameras_supported) < max_camera) {
3235        // sensor select
3236        OMX_CONFIG_SENSORSELECTTYPE sensorSelect;
3237        OMX_INIT_STRUCT_PTR (&sensorSelect, OMX_CONFIG_SENSORSELECTTYPE);
3238        sensorSelect.eSensor = (OMX_SENSORSELECT) num_cameras_supported;
3239        eError = OMX_SetConfig(handle, ( OMX_INDEXTYPE ) OMX_TI_IndexConfigSensorSelect, &sensorSelect);
3240
3241        if ( OMX_ErrorNone != eError ) {
3242            break;
3243        }
3244
3245        // get and fill capabilities
3246        properties = properties_array + starting_camera + num_cameras_supported;
3247        OMXCameraAdapter::getCaps(properties, handle);
3248
3249        // need to fill facing information
3250        // assume that only sensor 0 is back facing
3251        if (num_cameras_supported == 0) {
3252            properties->set(CameraProperties::FACING_INDEX, TICameraParameters::FACING_BACK);
3253        } else {
3254            properties->set(CameraProperties::FACING_INDEX, TICameraParameters::FACING_FRONT);
3255        }
3256
3257        num_cameras_supported++;
3258    }
3259
3260 EXIT:
3261    // clean up
3262    if(handle) {
3263        OMX_FreeHandle(handle);
3264    }
3265    OMX_Deinit();
3266
3267    LOG_FUNCTION_NAME_EXIT;
3268
3269    return num_cameras_supported;
3270}
3271
3272};
3273
3274
3275/*--------------------Camera Adapter Class ENDS here-----------------------------*/
3276
3277