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