Added safe operations for OMX_SENSORSELECT enum
[unified-camera-hal:unified-camera-hal.git] / src / adapters / omx / OMXCameraAdapter.cpp
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 "OMXCameraAdapter.h"
25
26 #include <signal.h>
27 #include <math.h>
28 #include <fcntl.h>
29
30 #include <cutils/properties.h>
31
32 // TODO: Remove this.
33 #if __ANDROID_API__ == 14
34 #include <system/camera.h>
35 #endif
36
37 #include "../../utils/ErrorUtils.h"
38
39 #include "../../Device.h"
40 #include "../../TICameraParameters.h"
41 #include "../../ErrorNotifierInterface.h"
42
43
44
45
46 namespace Ti {
47 namespace Camera {
48
49
50
51
52 #define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false ))
53 static int mDebugFps = 0;
54 static int mDebugFcs = 0;
55
56 // TODO: Remove this.
57 #define HERE(Msg) {CAMHAL_LOGEB("--===line %d, %s===--\n", __LINE__, Msg);}
58
59 //frames skipped before recalculating the framerate
60 #define FPS_PERIOD 30
61
62 static android::Mutex gAdapterLock;
63
64
65
66
67 status_t OMXCameraAdapter::initialize(CameraProperties::Properties* caps)
68 {
69     LOG_FUNCTION_NAME;
70
71     char value[PROPERTY_VALUE_MAX];
72     property_get("debug.camera.showfps", value, "0");
73     mDebugFps = atoi(value);
74     property_get("debug.camera.framecounts", value, "0");
75     mDebugFcs = atoi(value);
76
77     TIMM_OSAL_ERRORTYPE osalError = OMX_ErrorNone;
78     OMX_ERRORTYPE eError = OMX_ErrorNone;
79     status_t ret = NO_ERROR;
80
81     mLocalVersionParam.s.nVersionMajor = 0x1;
82     mLocalVersionParam.s.nVersionMinor = 0x1;
83     mLocalVersionParam.s.nRevision = 0x0 ;
84     mLocalVersionParam.s.nStep =  0x0;
85
86     mPending3Asettings = 0;//E3AsettingsAll;
87     mPendingCaptureSettings = 0;
88     mPendingPreviewSettings = 0;
89
90     if ( 0 != mInitSem.Count() )
91         {
92         CAMHAL_ERROR << "Error mInitSem semaphore count:" << mInitSem.Count();
93         LOG_FUNCTION_NAME_EXIT;
94         return NO_INIT;
95         }
96
97     ///Update the preview and image capture port indexes
98     mCameraAdapterParameters.mPrevPortIndex = OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW;
99     // temp changed in order to build OMX_CAMERA_PORT_VIDEO_OUT_IMAGE;
100     mCameraAdapterParameters.mImagePortIndex = OMX_CAMERA_PORT_IMAGE_OUT_IMAGE;
101     mCameraAdapterParameters.mMeasurementPortIndex = OMX_CAMERA_PORT_VIDEO_OUT_MEASUREMENT;
102     //currently not supported use preview port instead
103     mCameraAdapterParameters.mVideoPortIndex = OMX_CAMERA_PORT_VIDEO_OUT_VIDEO;
104
105     eError = OMX_Init();
106     if (eError != OMX_ErrorNone) {
107         CAMHAL_ERROR << "OMX_Init() failed, error:" << eError;
108         return Utils::ErrorUtils::omxToAndroidError(eError);
109     }
110     mOmxInitialized = true;
111
112     // Initialize the callback handles
113     OMX_CALLBACKTYPE callbacks;
114     callbacks.EventHandler    = Camera::OMXCameraAdapterEventHandler;
115     callbacks.EmptyBufferDone = Camera::OMXCameraAdapterEmptyBufferDone;
116     callbacks.FillBufferDone  = Camera::OMXCameraAdapterFillBufferDone;
117
118     ///Get the handle to the OMX Component
119     eError = OMXCameraAdapter::OMXCameraGetHandle(&mCameraAdapterParameters.mHandleComp, this, callbacks);
120     if(eError != OMX_ErrorNone) {
121         CAMHAL_ERROR << "OMXCameraGetHandle() failed, error:" << eError;
122     }
123     GOTO_EXIT_IF((eError != OMX_ErrorNone), eError);
124
125     mComponentState = OMX_StateLoaded;
126
127     CAMHAL_VERBOSE << "mSensorIndex =" << mSensorIndex;
128
129 #ifdef CAMERAHAL_USE_DCC_FILE_DATA_SAVE
130     initDccFileDataSave(&mCameraAdapterParameters.mHandleComp, mCameraAdapterParameters.mPrevPortIndex);
131 #endif
132
133     eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
134                                   OMX_CommandPortDisable,
135                                   OMX_ALL,
136                                   NULL);
137
138     if(eError != OMX_ErrorNone) {
139          CAMHAL_ERROR << "OMX_SendCommand(OMX_CommandPortDisable) failed, error:" << eError;
140     }
141     GOTO_EXIT_IF((eError != OMX_ErrorNone), eError);
142
143     // Register for port enable event
144     ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
145                                  OMX_EventCmdComplete,
146                                  OMX_CommandPortEnable,
147                                  mCameraAdapterParameters.mPrevPortIndex,
148                                  mInitSem);
149     if(ret != NO_ERROR) {
150          CAMHAL_ERROR << "Error in registering for event:" << ret;
151          goto EXIT;
152     }
153
154     // Enable PREVIEW Port
155     eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
156                                  OMX_CommandPortEnable,
157                                  mCameraAdapterParameters.mPrevPortIndex,
158                                  NULL);
159     if(eError != OMX_ErrorNone) {
160         CAMHAL_ERROR << "OMX_SendCommand(OMX_CommandPortEnable) failed, error:" << eError;
161     }
162     GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
163
164     // Wait for the port enable event to occur
165     ret = mInitSem.WaitTimeout(OMX_CMD_TIMEOUT);
166     if ( NO_ERROR == ret ) {
167          CAMHAL_DEBUG << "Port enable event arrived";
168     } else {
169          ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp,
170                             OMX_EventCmdComplete,
171                             OMX_CommandPortEnable,
172                             mCameraAdapterParameters.mPrevPortIndex,
173                             NULL);
174          CAMHAL_ERROR << "Timeout for enabling preview port expired!";
175          goto EXIT;
176      }
177
178     // Select the sensor
179     OMX_CONFIG_SENSORSELECTTYPE sensorSelect;
180     OMX_INIT_STRUCT_PTR (&sensorSelect, OMX_CONFIG_SENSORSELECTTYPE);
181     sensorSelect.eSensor = OMX_SENSORSELECT::fromInt(mSensorIndex);
182     eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
183                             omx_enum_cast(OMX_TI_IndexConfigSensorSelect),
184                             &sensorSelect);
185     if ( OMX_ErrorNone != eError ) {
186         CAMHAL_ERROR << "Error while selecting the sensor index" << mSensorIndex << ", error:" << eError;
187         return BAD_VALUE;
188     } else {
189         CAMHAL_DEBUG <<"Sensor" << mSensorIndex << "selected successfully";
190     }
191
192 #ifdef CAMERAHAL_DEBUG
193
194     printComponentVersion(mCameraAdapterParameters.mHandleComp);
195
196 #endif
197
198     mBracketingEnabled = false;
199     mBracketingBuffersQueuedCount = 0;
200     mBracketingRange = 1;
201     mLastBracetingBufferIdx = 0;
202     mOMXStateSwitch = false;
203     mBracketingSet = false;
204     mRawCapture = false;
205
206     mCaptureSignalled = false;
207     mCaptureConfigured = false;
208     mRecording = false;
209     mWaitingForSnapshot = false;
210     mSnapshotCount = 0;
211
212     mCapMode = INITIAL_MODE;
213     mIPP = IPP_NULL;
214     mVstabEnabled = false;
215     mVnfEnabled = false;
216     mBurstFrames = 1;
217     mCapturedFrames = 0;
218     mPictureQuality = 100;
219     mCurrentZoomIdx = 0;
220     mTargetZoomIdx = 0;
221     mPreviousZoomIndx = 0;
222     mReturnZoomStatus = false;
223     mZoomInc = 1;
224     mZoomParameterIdx = 0;
225     mExposureBracketingValidEntries = 0;
226     mSensorOverclock = false;
227     mAutoConv = OMX_TI_AutoConvergenceModeMax;
228     mManualConv = 0;
229     mDeviceOrientation = 0;
230     mCapabilities = caps;
231     mZoomUpdating = false;
232     mZoomUpdate = false;
233     mGBCE = BRIGHTNESS_OFF;
234     mGLBCE = BRIGHTNESS_OFF;
235     mParameters3A.ExposureLock = OMX_FALSE;
236     mParameters3A.WhiteBalanceLock = OMX_FALSE;
237
238     mEXIFData.mGPSData.mAltitudeValid = false;
239     mEXIFData.mGPSData.mDatestampValid = false;
240     mEXIFData.mGPSData.mLatValid = false;
241     mEXIFData.mGPSData.mLongValid = false;
242     mEXIFData.mGPSData.mMapDatumValid = false;
243     mEXIFData.mGPSData.mProcMethodValid = false;
244     mEXIFData.mGPSData.mVersionIdValid = false;
245     mEXIFData.mGPSData.mTimeStampValid = false;
246     mEXIFData.mModelValid = false;
247     mEXIFData.mMakeValid = false;
248
249     if (mCapabilities->get(CameraProperties::SUPPORTED_ZOOM_STAGES) != NULL) {
250         mMaxZoomSupported = mCapabilities->getInt(CameraProperties::SUPPORTED_ZOOM_STAGES) + 1;
251     } else {
252         mMaxZoomSupported = 1;
253     }
254
255     // initialize command handling thread
256     if(mCommandHandler.get() == NULL)
257         mCommandHandler = new CommandHandler(this);
258
259     if ( NULL == mCommandHandler.get() )
260     {
261         CAMHAL_ERROR << "Couldn't create command handler";
262         return NO_MEMORY;
263     }
264
265     ret = status_t::fromInt(mCommandHandler->run("CallbackThread", android::PRIORITY_URGENT_DISPLAY));
266     if ( ret != NO_ERROR )
267     {
268         if( ret == INVALID_OPERATION){
269             CAMHAL_DEBUG << "command handler thread already runnning!!";
270             ret = NO_ERROR;
271         } else
272         {
273             CAMHAL_ERROR << "Couldn't run command handlerthread, error:" << ret;
274             return ret;
275         }
276     }
277
278     // initialize omx callback handling thread
279     if(mOMXCallbackHandler.get() == NULL)
280         mOMXCallbackHandler = new OMXCallbackHandler(this);
281
282     if ( NULL == mOMXCallbackHandler.get() )
283     {
284         CAMHAL_ERROR << "Couldn't create omx callback handler";
285         return NO_MEMORY;
286     }
287
288     ret = status_t::fromInt(mOMXCallbackHandler->run("OMXCallbackThread", android::PRIORITY_URGENT_DISPLAY));
289     if ( ret != NO_ERROR )
290     {
291         if( ret == INVALID_OPERATION){
292             CAMHAL_DEBUG << "omx callback handler thread already runnning!!";
293             ret = NO_ERROR;
294         }else
295         {
296             CAMHAL_ERROR << "Couldn't run omx callback handler thread, error:" << ret;
297             return ret;
298         }
299     }
300
301     OMX_INIT_STRUCT_PTR (&mRegionPriority, OMX_TI_CONFIG_3A_REGION_PRIORITY);
302     OMX_INIT_STRUCT_PTR (&mFacePriority, OMX_TI_CONFIG_3A_FACE_PRIORITY);
303     mRegionPriority.nPortIndex = OMX_ALL;
304     mFacePriority.nPortIndex = OMX_ALL;
305
306     //Setting this flag will that the first setParameter call will apply all 3A settings
307     //and will not conditionally apply based on current values.
308     mFirstTimeInit = true;
309
310     memset(mExposureBracketingValues, 0, EXP_BRACKET_RANGE*sizeof(int));
311     mMeasurementEnabled = false;
312     mFaceDetectionRunning = false;
313     mFaceDetectionPaused = false;
314     mFDSkip = 1;
315
316
317     memset(&mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex], 0, sizeof(OMXCameraPortParameters));
318     memset(&mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex], 0, sizeof(OMXCameraPortParameters));
319     memset(&mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mVideoPortIndex], 0, sizeof(OMXCameraPortParameters));
320
321     get3ADefaults(mParameters3A);
322
323     CAMHAL_ASSERT(!omx_enum_is_null(mParameters3A.Exposure));
324     CAMHAL_ASSERT(!omx_enum_is_null(mParameters3A.WhiteBallance));
325     CAMHAL_ASSERT(!omx_enum_is_null(mParameters3A.Flicker));
326     CAMHAL_ASSERT(!omx_enum_is_null(mParameters3A.SceneMode));
327     CAMHAL_ASSERT(!omx_enum_is_null(mParameters3A.Effect));
328     CAMHAL_ASSERT(!omx_enum_is_null(mParameters3A.Focus));
329     CAMHAL_ASSERT(!omx_enum_is_null(mParameters3A.FlashMode));
330     CAMHAL_ASSERT(!omx_enum_is_null(mParameters3A.ExposureLock));
331     CAMHAL_ASSERT(!omx_enum_is_null(mParameters3A.FocusLock));
332     CAMHAL_ASSERT(!omx_enum_is_null(mParameters3A.WhiteBalanceLock));
333
334     LOG_FUNCTION_NAME_EXIT;
335     return Utils::ErrorUtils::omxToAndroidError(eError);
336
337     EXIT:
338
339     CAMHAL_ERROR << "Exiting because of error, ret:" << ret << ", eError:" << eError;
340     performCleanupAfterError();
341     LOG_FUNCTION_NAME_EXIT;
342     return Utils::ErrorUtils::omxToAndroidError(eError);
343 }
344
345 void OMXCameraAdapter::performCleanupAfterError()
346 {
347     LOG_FUNCTION_NAME;
348
349     if(mCameraAdapterParameters.mHandleComp)
350         {
351         ///Free the OMX component handle in case of error
352         OMX_FreeHandle(mCameraAdapterParameters.mHandleComp);
353         mCameraAdapterParameters.mHandleComp = NULL;
354         }
355
356     ///De-init the OMX
357     OMX_Deinit();
358     mComponentState = OMX_StateInvalid;
359 }
360
361 OMXCameraAdapter::OMXCameraPortParameters *OMXCameraAdapter::getPortParams(CameraFrame::FrameType frameType)
362 {
363     OMXCameraAdapter::OMXCameraPortParameters *ret = NULL;
364
365     switch ( frameType )
366     {
367     case CameraFrame::PREVIEW_FRAME_SYNC:
368     case CameraFrame::SNAPSHOT_FRAME:
369     case CameraFrame::VIDEO_FRAME_SYNC:
370         ret = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
371         break;
372     case CameraFrame::FRAME_DATA_SYNC:
373         ret = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex];
374         break;
375     default:
376         break;
377     };
378
379     return ret;
380 }
381
382 status_t OMXCameraAdapter::fillThisBuffer(void* frameBuf, CameraFrame::FrameType frameType)
383 {
384     LOG_FUNCTION_NAME;
385
386     status_t ret = NO_ERROR;
387     OMXCameraPortParameters *port = NULL;
388     OMX_ERRORTYPE eError = OMX_ErrorNone;
389     BaseCameraAdapter::AdapterState state;
390     BaseCameraAdapter::getState(state);
391
392     if ( ( PREVIEW_ACTIVE & state ) != PREVIEW_ACTIVE )
393         {
394         return NO_INIT;
395         }
396
397     if ( NULL == frameBuf )
398         {
399         return BAD_VALUE;
400         }
401
402     if ( NO_ERROR == ret )
403         {
404         port = getPortParams(frameType);
405         if ( NULL == port )
406             {
407             CAMHAL_ERROR << "Invalid frameType:" << frameType;
408             ret = BAD_VALUE;
409             }
410         }
411
412     if ( NO_ERROR == ret )
413         {
414
415         for ( int i = 0 ; i < port->mNumBufs ; i++)
416             {
417             if ( port->mBufferHeader[i]->pBuffer == frameBuf )
418                 {
419                 eError = OMX_FillThisBuffer(mCameraAdapterParameters.mHandleComp, port->mBufferHeader[i]);
420                 if ( eError != OMX_ErrorNone )
421                     {
422                     CAMHAL_ERROR << "OMX_FillThisBuffer() failed, error:" << eError;
423                     goto EXIT;
424                     }
425                 mFramesWithDucati++;
426                 break;
427                 }
428             }
429
430         }
431
432     LOG_FUNCTION_NAME_EXIT;
433     return ret;
434
435 EXIT:
436     CAMHAL_ERROR << "Exiting because of error, ret:" << ret << ", eError:" << eError;
437     performCleanupAfterError();
438     //Since fillthisbuffer is called asynchronously, make sure to signal error to the app
439     if ( mErrorNotifier )
440         mErrorNotifier->errorNotify(CAMERA_ERROR_HARD);
441     LOG_FUNCTION_NAME_EXIT;
442     return (ret | Utils::ErrorUtils::omxToAndroidError(eError));
443 }
444
445
446 #ifdef CAMERAHAL_USE_S3D
447 void OMXCameraAdapter::setParamS3D(OMX_U32 port, const char *valstr)
448 {
449     OMXCameraPortParameters *cap;
450
451     LOG_FUNCTION_NAME;
452
453     cap = &mCameraAdapterParameters.mCameraPortParams[port];
454     if (valstr != NULL)
455         {
456         if (strcmp(valstr, TICameraParameters::S3D_TB_FULL) == 0)
457             {
458             cap->mFrameLayoutType = OMX_TI_StereoFrameLayoutTopBottom;
459             }
460         else if (strcmp(valstr, TICameraParameters::S3D_SS_FULL) == 0)
461             {
462             cap->mFrameLayoutType = OMX_TI_StereoFrameLayoutLeftRight;
463             }
464         else if (strcmp(valstr, TICameraParameters::S3D_TB_SUBSAMPLED) == 0)
465             {
466             cap->mFrameLayoutType = OMX_TI_StereoFrameLayoutTopBottomSubsample;
467             }
468         else if (strcmp(valstr, TICameraParameters::S3D_SS_SUBSAMPLED) == 0)
469             {
470             cap->mFrameLayoutType = OMX_TI_StereoFrameLayoutLeftRightSubsample;
471             }
472         else
473             {
474             cap->mFrameLayoutType = OMX_TI_StereoFrameLayout2D;
475             }
476         }
477     else
478         {
479         cap->mFrameLayoutType = OMX_TI_StereoFrameLayout2D;
480         }
481
482     LOG_FUNCTION_NAME_EXIT;
483 }
484 #endif
485
486
487 status_t OMXCameraAdapter::fillImageBuffer(const ImageBuffer & buffer)
488 {
489     LOG_FUNCTION_NAME;
490
491     CAMHAL_ASSERT(!buffer.isNull());
492
493     {
494         BaseCameraAdapter::AdapterState state;
495         BaseCameraAdapter::getState(state);
496
497         // TODO: Assert here?
498         if ( (PREVIEW_ACTIVE & state) != PREVIEW_ACTIVE )
499         {
500             CAMHAL_ERROR << "No PREVIEW_ACTIVE flag is set, abort filling image buffer.";
501             return NO_INIT;
502         }
503     }
504
505     if ( mCapturedFrames < 1 && !mBracketingEnabled )
506     {
507         // signal end of image capture
508         if ( mEndImageCaptureCallback)
509             mEndImageCaptureCallback(mEndCaptureData);
510         return NO_ERROR;
511     }
512
513     const int bufferIndex = device()->imageBufferIndexForBuffer(buffer);
514     CAMHAL_ASSERT(bufferIndex != -1) << "Invalid image buffer passed:" << buffer;
515     CAMHAL_ASSERT(bufferIndex < _imagePort().mNumBufs);
516
517     ImageBufferInfo & bufferInfo = device()->mutableImageBufferInfoForIndex(bufferIndex);
518     CAMHAL_ASSERT(bufferInfo.owner == BufferOwner_Adapter);
519
520     OMX_BUFFERHEADERTYPE * const bufferHeader = _imagePort().mBufferHeader[bufferIndex];
521     CAMHAL_ASSERT(bufferHeader->pBuffer == bufferToOmxBuffer(buffer));
522
523     const OMX_ERRORTYPE omxError = OMX_FillThisBuffer(mCameraAdapterParameters.mHandleComp, bufferHeader);
524     if ( omxError != OMX_ErrorNone )
525     {
526         CAMHAL_ERROR << "OMX_FillThisBuffer() failed, error:" << omxError;
527         if ( mErrorNotifier )
528             mErrorNotifier->errorNotify(Utils::ErrorUtils::omxToAndroidError(omxError));
529         return Utils::ErrorUtils::omxToAndroidError(omxError);
530     }
531
532     bufferInfo.owner = BufferOwner_Hardware;
533
534     mFramesWithDucati++;
535
536     return NO_ERROR;
537 }
538
539
540 status_t OMXCameraAdapter::setParameters(const android::CameraParameters &params)
541 {
542     LOG_FUNCTION_NAME;
543
544     int mode = 0;
545     status_t ret = NO_ERROR;
546     int minFramerate, maxFramerate, frameRate;
547     const char *valstr = NULL;
548     int w, h;
549
550     BaseCameraAdapter::AdapterState state;
551     BaseCameraAdapter::getState(state);
552
553     ///@todo Include more camera parameters
554     const PixelFormat previewPixelFormat = PixelFormat::fromCameraFormat(params.getPreviewFormat());
555     OMX_COLOR_FORMATTYPE pixFormat = omxColorFormatFromPixelFormat(previewPixelFormat);
556     if ( pixFormat == OMX_COLOR_FormatUnused )
557         pixFormat = OMX_COLOR_FormatCbYCrY;
558
559     OMXCameraPortParameters *cap;
560     cap = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
561
562     params.getPreviewSize(&w, &h);
563     frameRate = params.getPreviewFrameRate();
564     params.getPreviewFpsRange(&minFramerate, &maxFramerate);
565     minFramerate /= Device::VFR_SCALE;
566     maxFramerate /= Device::VFR_SCALE;
567     if ( ( 0 < minFramerate ) && ( 0 < maxFramerate ) ) {
568         if ( minFramerate > maxFramerate ) {
569             CAMHAL_ERROR << "Min FPS set higher than MAX. So setting MIN and MAX to the higher value";
570             maxFramerate = minFramerate;
571         }
572
573         if ( 0 >= frameRate ) {
574             frameRate = maxFramerate;
575         }
576
577         if ( ( cap->mMinFrameRate != (OMX_U32) minFramerate ) ||
578              ( cap->mMaxFrameRate != (OMX_U32) maxFramerate ) ) {
579             cap->mMinFrameRate = minFramerate;
580             cap->mMaxFrameRate = maxFramerate;
581             setVFramerate(cap->mMinFrameRate, cap->mMaxFrameRate);
582         }
583     }
584
585     if ( 0 < frameRate )
586         {
587         cap->mColorFormat = pixFormat;
588         cap->mWidth = w;
589         cap->mHeight = h;
590         cap->mFrameRate = frameRate;
591
592         CAMHAL_VERBOSE << "Prev: cap.mColorFormat =" << cap->mColorFormat;
593         CAMHAL_VERBOSE << "Prev: cap.mWidth =" << cap->mWidth;
594         CAMHAL_VERBOSE << "Prev: cap.mHeight =" << cap->mHeight;
595         CAMHAL_VERBOSE << "Prev: cap.mFrameRate =" << cap->mFrameRate;
596
597         //TODO: Add an additional parameter for video resolution
598        //use preview resolution for now
599         cap = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
600         cap->mColorFormat = pixFormat;
601         cap->mWidth = w;
602         cap->mHeight = h;
603         cap->mFrameRate = frameRate;
604
605         CAMHAL_VERBOSE << "Video: cap.mColorFormat =" << cap->mColorFormat;
606         CAMHAL_VERBOSE << "Video: cap.mWidth =" << cap->mWidth;
607         CAMHAL_VERBOSE << "Video: cap.mHeight =" << cap->mHeight;
608         CAMHAL_VERBOSE << "Video: cap.mFrameRate =" << cap->mFrameRate;
609
610         ///mStride is set from setBufs() while passing the APIs
611         cap->mStride = 4096;
612         cap->mBufSize = cap->mStride * cap->mHeight;
613         }
614
615     if ( ( cap->mWidth >= 1920 ) &&
616          ( cap->mHeight >= 1080 ) &&
617          ( cap->mFrameRate >= FRAME_RATE_FULL_HD ) &&
618          ( !mSensorOverclock ) )
619         {
620         mOMXStateSwitch = true;
621         }
622     else if ( ( ( cap->mWidth < 1920 ) ||
623                ( cap->mHeight < 1080 ) ||
624                ( cap->mFrameRate < FRAME_RATE_FULL_HD ) ) &&
625                ( mSensorOverclock ) )
626         {
627         mOMXStateSwitch = true;
628         }
629
630     if ( (valstr = params.get(TICameraParameters::KEY_MEASUREMENT_ENABLE)) != NULL )
631         {
632         if (strcmp(valstr, (const char *) TICameraParameters::MEASUREMENT_ENABLE) == 0)
633             {
634             mMeasurementEnabled = true;
635             }
636         else if (strcmp(valstr, (const char *) TICameraParameters::MEASUREMENT_DISABLE) == 0)
637             {
638             mMeasurementEnabled = false;
639             }
640         else
641             {
642             mMeasurementEnabled = false;
643             }
644         }
645     else
646         {
647         //Disable measurement data by default
648         mMeasurementEnabled = false;
649         }
650
651 #ifdef CAMERAHAL_USE_S3D
652     setParamS3D(mCameraAdapterParameters.mPrevPortIndex,
653                params.get(TICameraParameters::KEY_S3D_PRV_FRAME_LAYOUT));
654 #endif
655
656     ret |= setParametersCapture(params, state);
657
658     ret |= setParameters3A(params, state);
659
660     ret |= setParametersAlgo(params, state);
661
662     ret |= setParametersFocus(params, state);
663
664     ret |= setParametersFD(params, state);
665
666     ret |= setParametersZoom(params, state);
667
668     ret |= setParametersEXIF(params, state);
669
670     mParams = params;
671     mFirstTimeInit = false;
672
673     LOG_FUNCTION_NAME_EXIT;
674     return ret;
675 }
676
677 void saveFile(unsigned char   *buff, int width, int height, int format) {
678     static int      counter = 1;
679     int             fd = -1;
680     char            fn[256];
681
682     LOG_FUNCTION_NAME;
683
684     fn[0] = 0;
685     sprintf(fn, "/preview%03d.yuv", counter);
686     fd = open(fn, O_CREAT | O_WRONLY | O_SYNC | O_TRUNC, 0777);
687     if(fd < 0) {
688         CAMHAL_ERROR << "Unable to open file" << fn << Utils::Log::NoSpaceOnce() << ": error:" << strerror(fd);
689         return;
690     }
691
692     CAMHAL_VERBOSE << "Copying from" << buff << Utils::Log::NoSpaceOnce() << ", size =" << Utils::Size(width, height);
693
694     //method currently supports only nv12 dumping
695     int stride = width;
696     uint8_t *bf = (uint8_t*) buff;
697     for(int i=0;i<height;i++)
698         {
699         write(fd, bf, width);
700         bf += 4096;
701         }
702
703     for(int i=0;i<height/2;i++)
704         {
705         write(fd, bf, stride);
706         bf += 4096;
707         }
708
709     close(fd);
710
711     counter++;
712
713     LOG_FUNCTION_NAME_EXIT;
714 }
715
716 void OMXCameraAdapter::getParameters(android::CameraParameters& params)
717 {
718     LOG_FUNCTION_NAME;
719
720     status_t ret = NO_ERROR;
721     OMX_CONFIG_EXPOSUREVALUETYPE exp;
722     OMX_ERRORTYPE eError = OMX_ErrorNone;
723     BaseCameraAdapter::AdapterState state;
724     BaseCameraAdapter::getState(state);
725     const char *valstr = NULL;
726
727     if( mParameters3A.SceneMode != OMX_Manual ) {
728        const char *valstr_supported = NULL;
729
730        if (mCapabilities) {
731            const SceneModesEntry* entry = NULL;
732            entry = getSceneModeEntry(mCapabilities->get(CameraProperties::CAMERA_NAME),
733                                     mParameters3A.SceneMode);
734            if(entry) {
735                mParameters3A.Focus = entry->focus;
736                mParameters3A.FlashMode = entry->flash;
737                mParameters3A.WhiteBallance = entry->wb;
738            }
739        }
740
741        valstr = getLUTvalue_OMXtoHAL(mParameters3A.WhiteBallance, WBalLUT);
742        valstr_supported = mParams.get(android::CameraParameters::KEY_SUPPORTED_WHITE_BALANCE);
743        if (valstr && valstr_supported && strstr(valstr_supported, valstr))
744            params.set(android::CameraParameters::KEY_WHITE_BALANCE , valstr);
745
746        valstr = getLUTvalue_OMXtoHAL(mParameters3A.FlashMode, FlashLUT);
747        valstr_supported = mParams.get(android::CameraParameters::KEY_SUPPORTED_FLASH_MODES);
748        if (valstr && valstr_supported && strstr(valstr_supported, valstr))
749            params.set(android::CameraParameters::KEY_FLASH_MODE, valstr);
750
751        if ((mParameters3A.Focus == OMX_IMAGE_FocusControlAuto) &&
752            (mCapMode != OMXCameraAdapter::VIDEO_MODE)) {
753            valstr = android::CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE;
754        } else {
755            valstr = getLUTvalue_OMXtoHAL(mParameters3A.Focus, FocusLUT);
756        }
757        valstr_supported = mParams.get(android::CameraParameters::KEY_SUPPORTED_FOCUS_MODES);
758        if (valstr && valstr_supported && strstr(valstr_supported, valstr))
759            params.set(android::CameraParameters::KEY_FOCUS_MODE, valstr);
760     }
761
762     //Query focus distances only when focus is running
763     if ( ( AF_ACTIVE & state ) ||
764          ( NULL == mParameters.get(android::CameraParameters::KEY_FOCUS_DISTANCES) ) )
765         {
766         updateFocusDistances(params);
767         }
768     else
769         {
770         params.set(android::CameraParameters::KEY_FOCUS_DISTANCES,
771                    mParameters.get(android::CameraParameters::KEY_FOCUS_DISTANCES));
772         }
773
774     OMX_INIT_STRUCT_PTR (&exp, OMX_CONFIG_EXPOSUREVALUETYPE);
775     exp.nPortIndex = OMX_ALL;
776
777     eError = OMX_GetConfig(mCameraAdapterParameters.mHandleComp,
778                            OMX_IndexConfigCommonExposureValue,
779                            &exp);
780     if ( OMX_ErrorNone == eError )
781         {
782         params.set(TICameraParameters::KEY_CURRENT_ISO, exp.nSensitivity);
783         }
784     else
785         {
786         CAMHAL_ERROR << "OMX error while retrieving current ISO value:" << eError;
787         }
788
789     {
790     android::AutoMutex lock(mZoomLock);
791     //Immediate zoom should not be avaialable while smooth zoom is running
792     if ( ZOOM_ACTIVE & state )
793         {
794         if ( mZoomParameterIdx != mCurrentZoomIdx )
795             {
796             mZoomParameterIdx += mZoomInc;
797             }
798         params.set(android::CameraParameters::KEY_ZOOM, mZoomParameterIdx);
799         if ( ( mCurrentZoomIdx == mTargetZoomIdx ) &&
800              ( mZoomParameterIdx == mCurrentZoomIdx ) )
801             {
802
803             if ( NO_ERROR == ret )
804                 {
805
806                 ret =  BaseCameraAdapter::setState(CAMERA_STOP_SMOOTH_ZOOM);
807
808                 if ( NO_ERROR == ret )
809                     {
810                     ret = BaseCameraAdapter::commitState();
811                     }
812                 else
813                     {
814                     ret |= BaseCameraAdapter::rollbackState();
815                     }
816
817                 }
818
819             }
820
821         CAMHAL_DEBUG << "CameraParameters Zoom:" << mCurrentZoomIdx;
822         }
823     else
824         {
825         params.set(android::CameraParameters::KEY_ZOOM, mCurrentZoomIdx);
826         }
827     }
828
829     //Populate current lock status
830     if ( mUserSetExpLock || mParameters3A.ExposureLock ) {
831         params.set(android::CameraParameters::KEY_AUTO_EXPOSURE_LOCK,
832                 android::CameraParameters::TRUE);
833     } else {
834         params.set(android::CameraParameters::KEY_AUTO_EXPOSURE_LOCK,
835                 android::CameraParameters::FALSE);
836     }
837
838     if ( mUserSetWbLock || mParameters3A.WhiteBalanceLock ) {
839         params.set(android::CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK,
840                 android::CameraParameters::TRUE);
841     } else {
842         params.set(android::CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK,
843                 android::CameraParameters::FALSE);
844     }
845
846     LOG_FUNCTION_NAME_EXIT;
847 }
848
849 status_t OMXCameraAdapter::setSensorQuirks(int orientation,
850                                            OMXCameraPortParameters &portParams,
851                                            bool &portConfigured)
852 {
853     status_t overclockStatus = NO_ERROR;
854     int sensorID = -1;
855     size_t overclockWidth;
856     size_t overclockHeight;
857     OMX_ERRORTYPE eError = OMX_ErrorNone;
858     OMX_PARAM_PORTDEFINITIONTYPE portCheck;
859
860     LOG_FUNCTION_NAME;
861
862     portConfigured = false;
863     OMX_INIT_STRUCT_PTR (&portCheck, OMX_PARAM_PORTDEFINITIONTYPE);
864
865     portCheck.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
866
867     eError = OMX_GetParameter (mCameraAdapterParameters.mHandleComp,
868                                OMX_IndexParamPortDefinition,
869                                &portCheck);
870
871     if ( eError != OMX_ErrorNone ) {
872         CAMHAL_ERROR << "OMX_GetParameter() failed, error:" << eError;
873         return Utils::ErrorUtils::omxToAndroidError(eError);
874     }
875
876     if ( ( orientation == 90 ) || ( orientation == 270 ) ) {
877         overclockWidth = 1080;
878         overclockHeight = 1920;
879     } else {
880         overclockWidth = 1920;
881         overclockHeight = 1080;
882     }
883
884     sensorID = mCapabilities->getInt(CameraProperties::CAMERA_SENSOR_ID);
885     if( ( ( sensorID == SENSORID_IMX060 ) &&
886           ( portParams.mWidth >= overclockWidth ) &&
887           ( portParams.mHeight >= overclockHeight ) &&
888           ( portParams.mFrameRate >= FRAME_RATE_FULL_HD ) ) ||
889         ( ( sensorID == SENSORID_OV5640 ) &&
890           ( portParams.mWidth >= overclockWidth ) &&
891           ( portParams.mHeight >= overclockHeight ) ) ) {
892         overclockStatus = setSensorOverclock(true);
893     } else {
894
895         //WA: If the next port resolution doesn't require
896         //    sensor overclocking, but the previous resolution
897         //    needed it, then we have to first set new port
898         //    resolution and then disable sensor overclocking.
899         if( ( ( sensorID == SENSORID_IMX060 ) &&
900               ( portCheck.format.video.nFrameWidth >= overclockWidth ) &&
901               ( portCheck.format.video.nFrameHeight >= overclockHeight ) &&
902               ( ( portCheck.format.video.xFramerate >> 16 ) >= FRAME_RATE_FULL_HD ) ) ||
903             ( ( sensorID == SENSORID_OV5640 ) &&
904               ( portCheck.format.video.nFrameWidth >= overclockWidth ) &&
905               ( portCheck.format.video.nFrameHeight >= overclockHeight ) ) ) {
906             status_t ret = setFormat(mCameraAdapterParameters.mPrevPortIndex,
907                                      portParams);
908             if ( NO_ERROR != ret ) {
909                 return ret;
910             }
911
912             // Another WA: Setting the port definition will reset the VFR
913             //             configuration.
914             setVFramerate(portParams.mMinFrameRate, portParams.mMaxFrameRate);
915
916             portConfigured = true;
917         }
918
919         overclockStatus = setSensorOverclock(false);
920     }
921
922     LOG_FUNCTION_NAME_EXIT;
923
924     return overclockStatus;
925 }
926
927 status_t OMXCameraAdapter::setFormat(OMX_U32 port, OMXCameraPortParameters &portParams)
928 {
929     LOG_FUNCTION_NAME;
930
931     status_t ret = NO_ERROR;
932     size_t bufferCount;
933     OMX_ERRORTYPE eError = OMX_ErrorNone;
934     OMX_PARAM_PORTDEFINITIONTYPE portCheck;
935
936     OMX_INIT_STRUCT_PTR (&portCheck, OMX_PARAM_PORTDEFINITIONTYPE);
937
938     portCheck.nPortIndex = port;
939
940     eError = OMX_GetParameter (mCameraAdapterParameters.mHandleComp,
941                                 OMX_IndexParamPortDefinition, &portCheck);
942     if (eError!=OMX_ErrorNone) {
943         CAMHAL_ERROR << "OMX_GetParameter(OMX_IndexParamPortDefinition) failed, error:" << eError;
944     }
945     GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
946
947     if (OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW == port) {
948         portCheck.format.video.nFrameWidth      = portParams.mWidth;
949         portCheck.format.video.nFrameHeight     = portParams.mHeight;
950         portCheck.format.video.eColorFormat     = portParams.mColorFormat;
951         portCheck.format.video.nStride          = portParams.mStride;
952
953         portCheck.format.video.xFramerate       = portParams.mFrameRate<<16;
954         portCheck.nBufferSize                   = portParams.mStride * portParams.mHeight;
955         portCheck.nBufferCountActual = portParams.mNumBufs;
956         mFocusThreshold = FOCUS_THRESHOLD * portParams.mFrameRate;
957         // Used for RAW capture
958     } else if (OMX_CAMERA_PORT_VIDEO_OUT_VIDEO == port) {
959         portCheck.format.video.nFrameWidth      = portParams.mWidth;
960         portCheck.format.video.nFrameHeight     = portParams.mHeight;
961         portCheck.format.video.eColorFormat     = OMX_COLOR_FormatRawBayer10bit; // portParams.mColorFormat;
962         portCheck.nBufferCountActual            = 1; // portParams.mNumBufs;
963     } else if (OMX_CAMERA_PORT_IMAGE_OUT_IMAGE == port) {
964         portCheck.format.image.nFrameWidth      = portParams.mWidth;
965         portCheck.format.image.nFrameHeight     = portParams.mHeight;
966         if (OMX_COLOR_FormatUnused == portParams.mColorFormat && mCodingMode == CodingJPEG) {
967             portCheck.format.image.eColorFormat       = OMX_COLOR_FormatCbYCrY;
968             portCheck.format.image.eCompressionFormat = OMX_IMAGE_CodingJPEG;
969         } else if (OMX_COLOR_FormatUnused == portParams.mColorFormat && mCodingMode == CodingJPS) {
970             portCheck.format.image.eColorFormat       = OMX_COLOR_FormatCbYCrY;
971             portCheck.format.image.eCompressionFormat = omx_enum_cast(OMX_TI_IMAGE_CodingJPS);
972         } else if (OMX_COLOR_FormatUnused == portParams.mColorFormat && mCodingMode == CodingMPO) {
973             portCheck.format.image.eColorFormat       = OMX_COLOR_FormatCbYCrY;
974             portCheck.format.image.eCompressionFormat = omx_enum_cast(OMX_TI_IMAGE_CodingMPO);
975         } else {
976             portCheck.format.image.eColorFormat       = portParams.mColorFormat;
977             portCheck.format.image.eCompressionFormat = OMX_IMAGE_CodingUnused;
978         }
979
980         //Stride for 1D tiler buffer is zero
981         portCheck.format.image.nStride          =  0;
982         portCheck.nBufferSize                   =  portParams.mStride * portParams.mWidth * portParams.mHeight;
983         portCheck.nBufferCountActual = portParams.mNumBufs;
984     } else {
985         CAMHAL_ERROR << "Unsupported port index:" << port;
986     }
987
988 #ifdef CAMERAHAL_USE_S3D
989     if (( mSensorIndex == OMX_TI_StereoSensor ) && (OMX_CAMERA_PORT_VIDEO_OUT_VIDEO != port)) {
990         ret = setS3DFrameLayout(port);
991         if ( NO_ERROR != ret )
992             {
993             CAMHAL_ERROR << "Error configuring stereo 3D frame layout:" << ret;
994             return ret;
995             }
996         }
997 #endif
998
999     eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp,
1000             OMX_IndexParamPortDefinition, &portCheck);
1001     if (eError!=OMX_ErrorNone) {
1002         CAMHAL_ERROR << "OMX_SetParameter(OMX_IndexParamPortDefinition) failed, error:" << eError;
1003     }
1004     GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
1005
1006     /* check if parameters are set correctly by calling GetParameter() */
1007     eError = OMX_GetParameter(mCameraAdapterParameters.mHandleComp,
1008             OMX_IndexParamPortDefinition, &portCheck);
1009     if (eError!=OMX_ErrorNone) {
1010         CAMHAL_ERROR << "OMX_GetParameter(OMX_IndexParamPortDefinition) failed, error:" << eError;
1011     }
1012     GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
1013
1014     portParams.mBufSize = portCheck.nBufferSize;
1015     portParams.mStride = portCheck.format.image.nStride;
1016
1017     if (OMX_CAMERA_PORT_IMAGE_OUT_IMAGE == port) {
1018         CAMHAL_DEBUG << "*** IMG Width =" << portCheck.format.image.nFrameWidth;
1019         CAMHAL_DEBUG << "*** IMG Height =" << portCheck.format.image.nFrameHeight;
1020
1021         CAMHAL_DEBUG << "*** IMG IMG FMT =" << portCheck.format.image.eColorFormat;
1022         CAMHAL_DEBUG << "*** IMG portCheck.nBufferSize =" << portCheck.nBufferSize;
1023         CAMHAL_DEBUG << "*** IMG portCheck.nBufferCountMin =" << portCheck.nBufferCountMin;
1024         CAMHAL_DEBUG << "*** IMG portCheck.nBufferCountActual =" << portCheck.nBufferCountActual;
1025         CAMHAL_DEBUG << "*** IMG portCheck.format.image.nStride =" << portCheck.format.image.nStride;
1026     } else if (OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW == port) {
1027         CAMHAL_DEBUG << "*** PRV Width =" << portCheck.format.video.nFrameWidth;
1028         CAMHAL_DEBUG << "*** PRV Height =" << portCheck.format.video.nFrameHeight;
1029
1030         CAMHAL_DEBUG << "*** PRV IMG FMT =" << portCheck.format.video.eColorFormat;
1031         CAMHAL_DEBUG << "*** PRV portCheck.nBufferSize =" << portCheck.nBufferSize;
1032         CAMHAL_DEBUG << "*** PRV portCheck.nBufferCountMin =" << portCheck.nBufferCountMin;
1033         CAMHAL_DEBUG << "*** PRV portCheck.nBufferCountActual =" << portCheck.nBufferCountActual;
1034         CAMHAL_DEBUG << "*** PRV portCheck.format.video.nStride =" << portCheck.format.video.nStride;
1035     } else {
1036         CAMHAL_DEBUG << "*** VID Width =" << portCheck.format.video.nFrameWidth;
1037         CAMHAL_DEBUG << "*** VID Height =" << portCheck.format.video.nFrameHeight;
1038
1039         CAMHAL_DEBUG << "*** VID IMG FMT =" << portCheck.format.video.eColorFormat;
1040         CAMHAL_DEBUG << "*** VID portCheck.nBufferSize =" << portCheck.nBufferSize;
1041         CAMHAL_DEBUG << "*** VID portCheck.nBufferCountMin =" << portCheck.nBufferCountMin;
1042         CAMHAL_DEBUG << "*** VID portCheck.nBufferCountActual =" << portCheck.nBufferCountActual;
1043         CAMHAL_DEBUG << "*** VID portCheck.format.video.nStride =" << portCheck.format.video.nStride;
1044     }
1045
1046     LOG_FUNCTION_NAME_EXIT;
1047
1048     return Utils::ErrorUtils::omxToAndroidError(eError);
1049
1050     EXIT:
1051
1052     CAMHAL_ERROR << "Exiting because of error:" << eError;
1053
1054     LOG_FUNCTION_NAME_EXIT;
1055
1056     return Utils::ErrorUtils::omxToAndroidError(eError);
1057 }
1058
1059 status_t OMXCameraAdapter::flushBuffers()
1060 {
1061     LOG_FUNCTION_NAME;
1062
1063     status_t ret = NO_ERROR;
1064     OMX_ERRORTYPE eError = OMX_ErrorNone;
1065
1066     if ( 0 != mFlushSem.Count() )
1067         {
1068         CAMHAL_ERROR << "Error mFlushSem semaphore count:" << mFlushSem.Count();
1069         LOG_FUNCTION_NAME_EXIT;
1070         return NO_INIT;
1071         }
1072
1073     OMXCameraPortParameters * mPreviewData = NULL;
1074     mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
1075
1076     ///Register for the FLUSH event
1077     ///This method just inserts a message in Event Q, which is checked in the callback
1078     ///The sempahore passed is signalled by the callback
1079     ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
1080                                 OMX_EventCmdComplete,
1081                                 OMX_CommandFlush,
1082                                 OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW,
1083                                 mFlushSem);
1084     if(ret!=NO_ERROR)
1085         {
1086         CAMHAL_ERROR << "Error in registering for event:" << ret;
1087         goto EXIT;
1088         }
1089
1090     ///Send FLUSH command to preview port
1091     eError = OMX_SendCommand (mCameraAdapterParameters.mHandleComp,
1092                               OMX_CommandFlush,
1093                               mCameraAdapterParameters.mPrevPortIndex,
1094                               NULL);
1095
1096     if(eError!=OMX_ErrorNone)
1097         {
1098         CAMHAL_ERROR << "OMX_SendCommand(OMX_CommandFlush) failed, error:" << eError;
1099         }
1100     GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
1101
1102     CAMHAL_DEBUG << "Waiting for flush event";
1103
1104     ///Wait for the FLUSH event to occur
1105     ret = mFlushSem.WaitTimeout(OMX_CMD_TIMEOUT);
1106
1107     //If somethiing bad happened while we wait
1108     if (mComponentState == OMX_StateInvalid)
1109       {
1110         CAMHAL_ERROR << "Invalid State after Flush Exitting!!!";
1111         goto EXIT;
1112       }
1113
1114     if ( NO_ERROR == ret )
1115         {
1116         CAMHAL_DEBUG << "Flush event received";
1117         }
1118     else
1119         {
1120         ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp,
1121                            OMX_EventCmdComplete,
1122                            OMX_CommandFlush,
1123                            OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW,
1124                            NULL);
1125         CAMHAL_ERROR << "Flush event timeout expired";
1126         goto EXIT;
1127         }
1128
1129     mOMXCallbackHandler->flush();
1130
1131     LOG_FUNCTION_NAME_EXIT;
1132
1133     return (ret | Utils::ErrorUtils::omxToAndroidError(eError));
1134
1135     EXIT:
1136     CAMHAL_ERROR << "Exiting because of error, ret =" << ret << ", eError =" << eError;
1137     performCleanupAfterError();
1138     LOG_FUNCTION_NAME_EXIT;
1139     return (ret | Utils::ErrorUtils::omxToAndroidError(eError));
1140 }
1141
1142 ///API to give the buffers to Adapter
1143 status_t OMXCameraAdapter::useBuffers(CameraMode mode, void* bufArr, int num, size_t length, unsigned int queueable)
1144 {
1145     OMX_ERRORTYPE eError = OMX_ErrorNone;
1146     status_t ret = NO_ERROR;
1147
1148     LOG_FUNCTION_NAME;
1149
1150     switch(mode)
1151         {
1152         case CAMERA_PREVIEW:
1153             mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex].mNumBufs =  num;
1154             mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex].mMaxQueueable = queueable;
1155             ret = UseBuffersPreview(bufArr, num);
1156             break;
1157
1158         case CAMERA_MEASUREMENT:
1159             mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex].mNumBufs = num;
1160             mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex].mMaxQueueable = queueable;
1161             ret = UseBuffersPreviewData(bufArr, num);
1162             break;
1163
1164         }
1165
1166     LOG_FUNCTION_NAME_EXIT;
1167
1168     return ret;
1169 }
1170
1171
1172 status_t OMXCameraAdapter::UseBuffersPreviewData(void* bufArr, int num)
1173 {
1174     LOG_FUNCTION_NAME;
1175
1176     status_t ret = NO_ERROR;
1177     OMX_ERRORTYPE eError = OMX_ErrorNone;
1178     OMXCameraPortParameters * measurementData = NULL;
1179     uint32_t *buffers;
1180
1181     android::AutoMutex lock( mPreviewDataBufferLock);
1182
1183     if ( mComponentState != OMX_StateLoaded )
1184         {
1185         CAMHAL_ERROR << "Calling UseBuffersPreviewData() when not in LOADED state";
1186         return BAD_VALUE;
1187         }
1188
1189     if ( NULL == bufArr )
1190         {
1191         CAMHAL_ERROR << "NULL pointer passed for buffArr";
1192         return BAD_VALUE;
1193         }
1194
1195     if ( 0 != mUsePreviewDataSem.Count() )
1196         {
1197         CAMHAL_ERROR << "Error mUsePreviewDataSem semaphore count:" << mUsePreviewDataSem.Count();
1198         LOG_FUNCTION_NAME_EXIT;
1199         return NO_INIT;
1200         }
1201
1202     if ( NO_ERROR == ret )
1203         {
1204         measurementData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex];
1205         measurementData->mNumBufs = num ;
1206         buffers= (uint32_t*) bufArr;
1207         }
1208
1209     if ( NO_ERROR == ret )
1210         {
1211          ///Register for port enable event on measurement port
1212         ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
1213                                       OMX_EventCmdComplete,
1214                                       OMX_CommandPortEnable,
1215                                       mCameraAdapterParameters.mMeasurementPortIndex,
1216                                       mUsePreviewDataSem);
1217
1218         if ( ret == NO_ERROR )
1219             {
1220             CAMHAL_DEBUG << "Registering for event";
1221             }
1222         else
1223             {
1224             CAMHAL_ERROR << "Error in registering for event:" << ret;
1225             goto EXIT;
1226             }
1227         }
1228
1229     if ( NO_ERROR == ret )
1230         {
1231          ///Enable MEASUREMENT Port
1232          eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
1233                                       OMX_CommandPortEnable,
1234                                       mCameraAdapterParameters.mMeasurementPortIndex,
1235                                       NULL);
1236
1237             if ( eError == OMX_ErrorNone )
1238                 {
1239                 CAMHAL_DEBUG << "OMX_SendCommand(OMX_CommandPortEnable) done";
1240                 }
1241             else
1242                 {
1243                 CAMHAL_ERROR << "OMX_SendCommand(OMX_CommandPortEnable) failed, error:" << eError;
1244                 goto EXIT;
1245                 }
1246         }
1247
1248     if ( NO_ERROR == ret )
1249         {
1250         ret = mUsePreviewDataSem.WaitTimeout(OMX_CMD_TIMEOUT);
1251
1252         //If somethiing bad happened while we wait
1253         if (mComponentState == OMX_StateInvalid)
1254           {
1255             CAMHAL_ERROR << "Invalid State after measurement port enable Exitting!!!";
1256             goto EXIT;
1257           }
1258
1259         if ( NO_ERROR == ret )
1260             {
1261             CAMHAL_DEBUG << "Port enable event arrived on measurement port";
1262             }
1263         else
1264             {
1265             ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp,
1266                                OMX_EventCmdComplete,
1267                                OMX_CommandPortEnable,
1268                                mCameraAdapterParameters.mMeasurementPortIndex,
1269                                NULL);
1270             CAMHAL_ERROR << "Timeout expoired during port enable on measurement port";
1271             goto EXIT;
1272             }
1273
1274         CAMHAL_DEBUG << "Port enable event arrived on measurement port";
1275         }
1276
1277     LOG_FUNCTION_NAME_EXIT;
1278
1279     return ret;
1280 EXIT:
1281     CAMHAL_ERROR << "Exiting because of error, ret =" << ret << ", eError =" << eError;
1282     performCleanupAfterError();
1283     LOG_FUNCTION_NAME_EXIT;
1284     return (ret | Utils::ErrorUtils::omxToAndroidError(eError));
1285 }
1286
1287 status_t OMXCameraAdapter::switchToExecuting()
1288 {
1289   status_t ret = NO_ERROR;
1290   Utils::Message msg;
1291
1292   LOG_FUNCTION_NAME;
1293
1294   mStateSwitchLock.lock();
1295   msg.command = CommandHandler::CAMERA_SWITCH_TO_EXECUTING;
1296   msg.arg1 = mErrorNotifier;
1297   ret = mCommandHandler->put(&msg);
1298
1299   LOG_FUNCTION_NAME_EXIT;
1300
1301   return ret;
1302 }
1303
1304 status_t OMXCameraAdapter::doSwitchToExecuting()
1305 {
1306   status_t ret = NO_ERROR;
1307   OMX_ERRORTYPE eError = OMX_ErrorNone;
1308   LOG_FUNCTION_NAME;
1309
1310   if ( (mComponentState == OMX_StateExecuting) || (mComponentState == OMX_StateInvalid) ){
1311     CAMHAL_DEBUG << "Already in OMX_Executing state or OMX_StateInvalid state";
1312     mStateSwitchLock.unlock();
1313     return NO_ERROR;
1314   }
1315
1316   if ( 0 != mSwitchToExecSem.Count() ){
1317     CAMHAL_ERROR << "Error mSwitchToExecSem semaphore count:" << mSwitchToExecSem.Count();
1318     goto EXIT;
1319   }
1320
1321   ///Register for Preview port DISABLE  event
1322   ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
1323                          OMX_EventCmdComplete,
1324                          OMX_CommandPortDisable,
1325                          mCameraAdapterParameters.mPrevPortIndex,
1326                          mSwitchToExecSem);
1327   if ( NO_ERROR != ret ){
1328     CAMHAL_ERROR << "Error in registering Port Disable for event:" << ret;
1329     goto EXIT;
1330   }
1331   ///Disable Preview Port
1332   eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
1333                            OMX_CommandPortDisable,
1334                            mCameraAdapterParameters.mPrevPortIndex,
1335                            NULL);
1336   // TODO: Check for the returned eError?
1337
1338   ret = mSwitchToExecSem.WaitTimeout(OMX_CMD_TIMEOUT);
1339   if (ret != NO_ERROR){
1340     CAMHAL_ERROR << "Timeout PREVIEW PORT DISABLE:" << ret;
1341   }
1342
1343   CAMHAL_VERBOSE << "PREV PORT DISABLED:" << eError;
1344
1345   ///Register for IDLE state switch event
1346   ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
1347                          OMX_EventCmdComplete,
1348                          OMX_CommandStateSet,
1349                          OMX_StateIdle,
1350                          mSwitchToExecSem);
1351   if(ret!=NO_ERROR)
1352     {
1353       CAMHAL_ERROR << "Error in IDLE STATE SWITCH:" << ret;
1354       goto EXIT;
1355     }
1356   eError = OMX_SendCommand (mCameraAdapterParameters.mHandleComp ,
1357                             OMX_CommandStateSet,
1358                             OMX_StateIdle,
1359                             NULL);
1360   GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
1361   ret = mSwitchToExecSem.WaitTimeout(OMX_CMD_TIMEOUT);
1362   if (ret != NO_ERROR){
1363     CAMHAL_ERROR << "Timeout IDLE STATE SWITCH:" << ret;
1364     goto EXIT;
1365   }
1366   mComponentState = OMX_StateIdle;
1367   CAMHAL_VERBOSE << "OMX_SendCommand(OMX_StateIdle) done";
1368
1369   ///Register for EXECUTING state switch event
1370   ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
1371                          OMX_EventCmdComplete,
1372                          OMX_CommandStateSet,
1373                          OMX_StateExecuting,
1374                          mSwitchToExecSem);
1375   if(ret!=NO_ERROR)
1376     {
1377       CAMHAL_ERROR << "Error in EXECUTING STATE SWITCH:" << ret;
1378       goto EXIT;
1379     }
1380   eError = OMX_SendCommand (mCameraAdapterParameters.mHandleComp ,
1381                             OMX_CommandStateSet,
1382                             OMX_StateExecuting,
1383                             NULL);
1384   GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
1385   ret = mSwitchToExecSem.WaitTimeout(OMX_CMD_TIMEOUT);
1386   if (ret != NO_ERROR){
1387     CAMHAL_ERROR << "Timeout EXEC STATE SWITCH:" << ret;
1388     goto EXIT;
1389   }
1390   mComponentState = OMX_StateExecuting;
1391   CAMHAL_VERBOSE << "OMX_SendCommand(OMX_StateExecuting) done";
1392
1393   mStateSwitchLock.unlock();
1394
1395   LOG_FUNCTION_NAME_EXIT;
1396   return ret;
1397
1398  EXIT:
1399   CAMHAL_ERROR << "Exiting because of error, ret =" << ret << ", eError =" << eError;
1400   performCleanupAfterError();
1401   mStateSwitchLock.unlock();
1402   LOG_FUNCTION_NAME_EXIT;
1403   return (ret | Utils::ErrorUtils::omxToAndroidError(eError));
1404 }
1405
1406 status_t OMXCameraAdapter::switchToLoaded()
1407 {
1408     status_t ret = NO_ERROR;
1409     OMX_ERRORTYPE eError = OMX_ErrorNone;
1410
1411     LOG_FUNCTION_NAME;
1412
1413     android::AutoMutex lock(mStateSwitchLock);
1414
1415     if ( mComponentState == OMX_StateLoaded  || mComponentState == OMX_StateInvalid)
1416         {
1417         CAMHAL_DEBUG << "Already in OMX_Loaded state or OMX_StateInvalid state";
1418         return NO_ERROR;
1419         }
1420
1421     if ( 0 != mSwitchToLoadedSem.Count() )
1422         {
1423         CAMHAL_ERROR << "Error mSwitchToLoadedSem semaphore count:" << mSwitchToLoadedSem.Count();
1424         goto EXIT;
1425         }
1426
1427     ///Register for EXECUTING state transition.
1428     ///This method just inserts a message in Event Q, which is checked in the callback
1429     ///The sempahore passed is signalled by the callback
1430     ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
1431                            OMX_EventCmdComplete,
1432                            OMX_CommandStateSet,
1433                            OMX_StateIdle,
1434                            mSwitchToLoadedSem);
1435
1436     if(ret!=NO_ERROR)
1437         {
1438         CAMHAL_ERROR << "Error in registering for event:" << ret;
1439         goto EXIT;
1440         }
1441
1442     eError = OMX_SendCommand (mCameraAdapterParameters.mHandleComp,
1443                               OMX_CommandStateSet,
1444                               OMX_StateIdle,
1445                               NULL);
1446
1447     if(eError!=OMX_ErrorNone)
1448         {
1449         CAMHAL_ERROR << "OMX_SendCommand(OMX_StateIdle) failed, error:" << eError;
1450         }
1451
1452     GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
1453
1454     ///Wait for the EXECUTING ->IDLE transition to arrive
1455
1456     CAMHAL_DEBUG << "EXECUTING->IDLE state changed";
1457     ret = mSwitchToLoadedSem.WaitTimeout(OMX_CMD_TIMEOUT);
1458
1459     //If somethiing bad happened while we wait
1460     if (mComponentState == OMX_StateInvalid)
1461       {
1462         CAMHAL_ERROR << "Invalid State after EXECUTING->IDLE Exitting!!!";
1463         goto EXIT;
1464       }
1465
1466     if ( NO_ERROR == ret )
1467         {
1468         CAMHAL_DEBUG << "EXECUTING->IDLE state changed";
1469         }
1470     else
1471         {
1472         ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp,
1473                            OMX_EventCmdComplete,
1474                            OMX_CommandStateSet,
1475                            OMX_StateIdle,
1476                            NULL);
1477         CAMHAL_ERROR << "Timeout expired on EXECUTING->IDLE state change";
1478         goto EXIT;
1479         }
1480
1481     ///Register for LOADED state transition.
1482     ///This method just inserts a message in Event Q, which is checked in the callback
1483     ///The sempahore passed is signalled by the callback
1484     ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
1485                            OMX_EventCmdComplete,
1486                            OMX_CommandStateSet,
1487                            OMX_StateLoaded,
1488                            mSwitchToLoadedSem);
1489
1490     if(ret!=NO_ERROR)
1491         {
1492         CAMHAL_ERROR << "Error in registering for event:" << ret;
1493         goto EXIT;
1494         }
1495
1496     eError = OMX_SendCommand (mCameraAdapterParameters.mHandleComp,
1497                               OMX_CommandStateSet,
1498                               OMX_StateLoaded,
1499                               NULL);
1500
1501     if(eError!=OMX_ErrorNone)
1502         {
1503         CAMHAL_ERROR << "OMX_SendCommand(OMX_StateLoaded) failed, error:" << eError;
1504         }
1505     GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
1506
1507     CAMHAL_DEBUG << "Switching IDLE->LOADED state";
1508     ret = mSwitchToLoadedSem.WaitTimeout(OMX_CMD_TIMEOUT);
1509
1510     //If somethiing bad happened while we wait
1511     if (mComponentState == OMX_StateInvalid)
1512       {
1513         CAMHAL_ERROR << "Invalid State after IDLE->LOADED Exitting!!!";
1514         goto EXIT;
1515       }
1516
1517     if ( NO_ERROR == ret )
1518         {
1519         CAMHAL_DEBUG << "IDLE->LOADED state changed";
1520         }
1521     else
1522         {
1523         ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp,
1524                            OMX_EventCmdComplete,
1525                            OMX_CommandStateSet,
1526                            OMX_StateLoaded,
1527                            NULL);
1528         CAMHAL_ERROR << "Timeout expired on IDLE->LOADED state change";
1529         goto EXIT;
1530         }
1531
1532     mComponentState = OMX_StateLoaded;
1533
1534     ///Register for Preview port ENABLE event
1535     ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
1536                            OMX_EventCmdComplete,
1537                            OMX_CommandPortEnable,
1538                            mCameraAdapterParameters.mPrevPortIndex,
1539                            mSwitchToLoadedSem);
1540
1541     if ( NO_ERROR != ret )
1542         {
1543         CAMHAL_ERROR << "Error in registering for event:" << ret;
1544         goto EXIT;
1545         }
1546
1547     ///Enable Preview Port
1548     eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
1549                              OMX_CommandPortEnable,
1550                              mCameraAdapterParameters.mPrevPortIndex,
1551                              NULL);
1552
1553
1554     if ( eError != OMX_ErrorNone )
1555     {
1556         CAMHAL_DEBUG << "OMX_SendCommand(OMX_CommandPortEnable) failed for preview port, error:" << eError;
1557         GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
1558     }
1559
1560     CAMHAL_DEBUG << "Enabling Preview port";
1561     ///Wait for state to switch to idle
1562     ret = mSwitchToLoadedSem.WaitTimeout(OMX_CMD_TIMEOUT);
1563
1564     //If somethiing bad happened while we wait
1565     if (mComponentState == OMX_StateInvalid)
1566       {
1567         CAMHAL_ERROR << "Invalid State after Enabling Preview port Exitting!!!";
1568         goto EXIT;
1569       }
1570
1571     if ( NO_ERROR == ret )
1572         {
1573         CAMHAL_DEBUG << "Preview port enabled!";
1574         }
1575     else
1576         {
1577         ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp,
1578                            OMX_EventCmdComplete,
1579                            OMX_CommandPortEnable,
1580                            mCameraAdapterParameters.mPrevPortIndex,
1581                            NULL);
1582         CAMHAL_ERROR << "Preview enable timedout";
1583
1584         goto EXIT;
1585         }
1586
1587     return (ret | Utils::ErrorUtils::omxToAndroidError(eError));
1588
1589 EXIT:
1590     CAMHAL_ERROR << "Exiting because of error, ret =" << ret << ", eError =" << eError;
1591     performCleanupAfterError();
1592     LOG_FUNCTION_NAME_EXIT;
1593     return (ret | Utils::ErrorUtils::omxToAndroidError(eError));
1594 }
1595
1596 status_t OMXCameraAdapter::UseBuffersPreview(void* bufArr, int num)
1597 {
1598     status_t ret = NO_ERROR;
1599     OMX_ERRORTYPE eError = OMX_ErrorNone;
1600     int tmpHeight, tmpWidth;
1601
1602     LOG_FUNCTION_NAME;
1603
1604     if(!bufArr)
1605         {
1606         CAMHAL_ERROR << "NULL pointer passed for buffArr";
1607         LOG_FUNCTION_NAME_EXIT;
1608         return BAD_VALUE;
1609         }
1610
1611     OMXCameraPortParameters * mPreviewData = NULL;
1612     OMXCameraPortParameters *measurementData = NULL;
1613     mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
1614     measurementData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex];
1615     mPreviewData->mNumBufs = num ;
1616     uint32_t *buffers = (uint32_t*)bufArr;
1617
1618     if ( 0 != mUsePreviewSem.Count() )
1619         {
1620         CAMHAL_ERROR << "Error mUsePreviewSem semaphore count:" << mUsePreviewSem.Count();
1621         LOG_FUNCTION_NAME_EXIT;
1622         return NO_INIT;
1623         }
1624
1625     if(mPreviewData->mNumBufs != num)
1626         {
1627         CAMHAL_ERROR << "Current number of buffers doesnt equal new num of buffers passed!";
1628         LOG_FUNCTION_NAME_EXIT;
1629         return BAD_VALUE;
1630         }
1631
1632     mStateSwitchLock.lock();
1633
1634     if ( mComponentState == OMX_StateLoaded ) {
1635
1636         if (mPendingPreviewSettings & SetLDC) {
1637             mPendingPreviewSettings &= ~SetLDC;
1638             ret = setLDC(mIPP);
1639             if ( NO_ERROR != ret ) {
1640                 CAMHAL_ERROR << "setLDC() failed, error:" << ret;
1641             }
1642         }
1643
1644         if (mPendingPreviewSettings & SetNSF) {
1645             mPendingPreviewSettings &= ~SetNSF;
1646             ret = setNSF(mIPP);
1647             if ( NO_ERROR != ret ) {
1648                 CAMHAL_ERROR << "setNSF() failed, error:" << ret;
1649             }
1650         }
1651
1652         if (mPendingPreviewSettings & SetCapMode) {
1653             mPendingPreviewSettings &= ~SetCapMode;
1654             ret = setCaptureMode(mCapMode);
1655             if ( NO_ERROR != ret ) {
1656                 CAMHAL_ERROR << "setCaptureMode() failed, error:" << ret;
1657             }
1658         }
1659
1660         if(mCapMode == OMXCameraAdapter::VIDEO_MODE) {
1661
1662             if (mPendingPreviewSettings & SetVNF) {
1663                 mPendingPreviewSettings &= ~SetVNF;
1664                 ret = enableVideoNoiseFilter(mVnfEnabled);
1665                 if ( NO_ERROR != ret){
1666                     CAMHAL_ERROR << "Failed configuring VNF, error:" << ret;
1667                 }
1668             }
1669
1670             if (mPendingPreviewSettings & SetVSTAB) {
1671                 mPendingPreviewSettings &= ~SetVSTAB;
1672                 ret = enableVideoStabilization(mVstabEnabled);
1673                 if ( NO_ERROR != ret) {
1674                     CAMHAL_ERROR << "Failed configuring VSTAB, error:" << ret;
1675                 }
1676             }
1677
1678         }
1679     }
1680
1681     ret = setSensorOrientation(mSensorOrientation);
1682     if ( NO_ERROR != ret )
1683         {
1684         CAMHAL_ERROR << "Failed configuring Sensor Orientation, error:" << ret;
1685         mSensorOrientation = 0;
1686         }
1687
1688     if ( mComponentState == OMX_StateLoaded )
1689         {
1690         ///Register for IDLE state switch event
1691         ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
1692                                OMX_EventCmdComplete,
1693                                OMX_CommandStateSet,
1694                                OMX_StateIdle,
1695                                mUsePreviewSem);
1696
1697         if(ret!=NO_ERROR)
1698             {
1699             CAMHAL_ERROR << "Error in registering for event:" << ret;
1700             goto EXIT;
1701             }
1702
1703         ///Once we get the buffers, move component state to idle state and pass the buffers to OMX comp using UseBuffer
1704         eError = OMX_SendCommand (mCameraAdapterParameters.mHandleComp ,
1705                                   OMX_CommandStateSet,
1706                                   OMX_StateIdle,
1707                                   NULL);
1708
1709         if ( eError != OMX_ErrorNone )
1710         {
1711             CAMHAL_ERROR << "OMX_SendCommand(OMX_StateIdle) failed, error:" << eError;
1712             goto EXIT;
1713         }
1714
1715         mComponentState = OMX_StateIdle;
1716         }
1717     else
1718         {
1719             ///Register for Preview port ENABLE event
1720             ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
1721                                    OMX_EventCmdComplete,
1722                                    OMX_CommandPortEnable,
1723                                    mCameraAdapterParameters.mPrevPortIndex,
1724                                    mUsePreviewSem);
1725
1726             if ( NO_ERROR != ret )
1727                 {
1728                 CAMHAL_ERROR << "Error in registering for event:" << ret;
1729                 goto EXIT;
1730                 }
1731
1732             ///Enable Preview Port
1733             eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
1734                                      OMX_CommandPortEnable,
1735                                      mCameraAdapterParameters.mPrevPortIndex,
1736                                      NULL);
1737         }
1738
1739
1740     ///Configure DOMX to use either gralloc handles or vptrs
1741     OMX_TI_PARAMUSENATIVEBUFFER domxUseGrallocHandles;
1742     OMX_INIT_STRUCT_PTR (&domxUseGrallocHandles, OMX_TI_PARAMUSENATIVEBUFFER);
1743
1744     domxUseGrallocHandles.nPortIndex = mCameraAdapterParameters.mPrevPortIndex;
1745     domxUseGrallocHandles.bEnable = OMX_TRUE;
1746
1747     eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp,
1748                                 omx_enum_cast(OMX_TI_IndexUseNativeBuffers),
1749                                 &domxUseGrallocHandles);
1750     if(eError!=OMX_ErrorNone)
1751         {
1752         CAMHAL_ERROR << "OMX_SetParameter(OMX_TI_IndexUseNativeBuffers) failed, error:" << eError;
1753         }
1754     GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
1755
1756     OMX_BUFFERHEADERTYPE *pBufferHdr;
1757     for(int index=0;index<num;index++) {
1758
1759         CAMHAL_DEBUG << "OMX_UseBuffer()" << buffers[index];
1760         eError = OMX_UseBuffer( mCameraAdapterParameters.mHandleComp,
1761                                 &pBufferHdr,
1762                                 mCameraAdapterParameters.mPrevPortIndex,
1763                                 0,
1764                                 mPreviewData->mBufSize,
1765                                 (OMX_U8*)buffers[index]);
1766         if(eError!=OMX_ErrorNone)
1767             {
1768             CAMHAL_ERROR << "OMX_UseBuffer() failed, error:" << eError;
1769             }
1770         GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
1771
1772         //pBufferHdr->pAppPrivate =  (OMX_PTR)pBufferHdr;
1773         pBufferHdr->nSize = sizeof(OMX_BUFFERHEADERTYPE);
1774         pBufferHdr->nVersion.s.nVersionMajor = 1 ;
1775         pBufferHdr->nVersion.s.nVersionMinor = 1 ;
1776         pBufferHdr->nVersion.s.nRevision = 0 ;
1777         pBufferHdr->nVersion.s.nStep =  0;
1778         mPreviewData->mBufferHeader[index] = pBufferHdr;
1779     }
1780
1781     if ( mMeasurementEnabled )
1782         {
1783
1784         for( int i = 0; i < num; i++ )
1785             {
1786             OMX_BUFFERHEADERTYPE *pBufHdr;
1787             eError = OMX_UseBuffer( mCameraAdapterParameters.mHandleComp,
1788                                     &pBufHdr,
1789                                     mCameraAdapterParameters.mMeasurementPortIndex,
1790                                     0,
1791                                     measurementData->mBufSize,
1792                                     (OMX_U8*)(mPreviewDataBuffers[i]));
1793
1794              if ( eError == OMX_ErrorNone )
1795                 {
1796                 pBufHdr->nSize = sizeof(OMX_BUFFERHEADERTYPE);
1797                 pBufHdr->nVersion.s.nVersionMajor = 1 ;
1798                 pBufHdr->nVersion.s.nVersionMinor = 1 ;
1799                 pBufHdr->nVersion.s.nRevision = 0 ;
1800                 pBufHdr->nVersion.s.nStep =  0;
1801                 measurementData->mBufferHeader[i] = pBufHdr;
1802                 }
1803             else
1804                 {
1805                 CAMHAL_ERROR << "OMX_UseBuffer() failed, error:" << eError;
1806                 ret = BAD_VALUE;
1807                 break;
1808                 }
1809             }
1810
1811         }
1812
1813     CAMHAL_DEBUG << "Registering preview buffers";
1814
1815     ret = mUsePreviewSem.WaitTimeout(OMX_CMD_TIMEOUT);
1816
1817     //If somethiing bad happened while we wait
1818     if (mComponentState == OMX_StateInvalid)
1819       {
1820         CAMHAL_ERROR << "Invalid State after Registering preview buffers Exitting!!!";
1821         goto EXIT;
1822       }
1823
1824     if ( NO_ERROR == ret )
1825         {
1826         CAMHAL_DEBUG << "Preview buffer registration successfull";
1827         }
1828     else
1829         {
1830         if ( mComponentState == OMX_StateLoaded )
1831             {
1832             ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp,
1833                                OMX_EventCmdComplete,
1834                                OMX_CommandStateSet,
1835                                OMX_StateIdle,
1836                                NULL);
1837             }
1838         else
1839             {
1840             ret |= SignalEvent(mCameraAdapterParameters.mHandleComp,
1841                                OMX_EventCmdComplete,
1842                                OMX_CommandPortEnable,
1843                                mCameraAdapterParameters.mPrevPortIndex,
1844                                NULL);
1845             }
1846         CAMHAL_ERROR << "Timeout expired on preview buffer registration";
1847         goto EXIT;
1848         }
1849
1850     LOG_FUNCTION_NAME_EXIT;
1851
1852     return (ret | Utils::ErrorUtils::omxToAndroidError(eError));
1853
1854     ///If there is any failure, we reach here.
1855     ///Here, we do any resource freeing and convert from OMX error code to Camera Hal error code
1856 EXIT:
1857     mStateSwitchLock.unlock();
1858
1859     CAMHAL_ERROR << "Exiting because of error, ret =" << ret << ", eError =" << eError;
1860     performCleanupAfterError();
1861
1862     LOG_FUNCTION_NAME_EXIT;
1863
1864     return (ret | Utils::ErrorUtils::omxToAndroidError(eError));
1865 }
1866
1867 status_t OMXCameraAdapter::startPreview()
1868 {
1869     status_t ret = NO_ERROR;
1870     OMX_ERRORTYPE eError = OMX_ErrorNone;
1871     OMXCameraPortParameters *mPreviewData = NULL;
1872     OMXCameraPortParameters *measurementData = NULL;
1873     OMX_CONFIG_EXTRADATATYPE extraDataControl;
1874
1875     LOG_FUNCTION_NAME;
1876
1877     if( 0 != mStartPreviewSem.Count() )
1878         {
1879         CAMHAL_ERROR << "Error mStartPreviewSem semaphore count:" << mStartPreviewSem.Count();
1880         ret = NO_INIT;
1881         goto EXIT;
1882         }
1883
1884     // Enable Ancillary data. The nDCCStatus field is used to signify
1885     // whether the preview frame is a snapshot
1886     if ( OMX_ErrorNone == eError) {
1887         OMX_INIT_STRUCT_PTR (&extraDataControl, OMX_CONFIG_EXTRADATATYPE);
1888         extraDataControl.nPortIndex = OMX_ALL;
1889         extraDataControl.eExtraDataType = OMX_AncillaryData;
1890         extraDataControl.bEnable = OMX_TRUE;
1891
1892         eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
1893                                omx_enum_cast(OMX_IndexConfigOtherExtraDataControl),
1894                                &extraDataControl);
1895         GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
1896     }
1897
1898     mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
1899     measurementData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex];
1900
1901     if( OMX_StateIdle == mComponentState )
1902         {
1903         ///Register for EXECUTING state transition.
1904         ///This method just inserts a message in Event Q, which is checked in the callback
1905         ///The sempahore passed is signalled by the callback
1906         ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
1907                                OMX_EventCmdComplete,
1908                                OMX_CommandStateSet,
1909                                OMX_StateExecuting,
1910                                mStartPreviewSem);
1911
1912         if(ret!=NO_ERROR)
1913             {
1914             CAMHAL_ERROR << "Error in registering for event:" << ret;
1915             goto EXIT;
1916             }
1917
1918         ///Switch to EXECUTING state
1919         eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
1920                                  OMX_CommandStateSet,
1921                                  OMX_StateExecuting,
1922                                  NULL);
1923
1924         if(eError!=OMX_ErrorNone)
1925             {
1926             CAMHAL_ERROR << "OMX_SendCommand(OMX_StateExecuting) failed, error:" << eError;
1927             }
1928
1929         CAMHAL_DEBUG << "+Waiting for component to go into EXECUTING state";
1930         ret = mStartPreviewSem.WaitTimeout(OMX_CMD_TIMEOUT);
1931
1932         //If somethiing bad happened while we wait
1933         if (mComponentState == OMX_StateInvalid)
1934           {
1935             CAMHAL_ERROR << "Invalid State after IDLE_EXECUTING Exitting!!!";
1936             goto EXIT;
1937           }
1938
1939         if ( NO_ERROR == ret )
1940             {
1941             CAMHAL_DEBUG << "+Great. Component went into executing state!!";
1942             }
1943         else
1944             {
1945             ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp,
1946                                OMX_EventCmdComplete,
1947                                OMX_CommandStateSet,
1948                                OMX_StateExecuting,
1949                                NULL);
1950             CAMHAL_DEBUG << "Timeout expired on executing state switch!";
1951             goto EXIT;
1952             }
1953
1954         mComponentState = OMX_StateExecuting;
1955
1956         }
1957
1958     mStateSwitchLock.unlock();
1959
1960     //Queue all the buffers on preview port
1961     for(int index=0;index< mPreviewData->mMaxQueueable;index++)
1962         {
1963         CAMHAL_DEBUG << "Queuing buffer on Preview port:" << mPreviewData->mBufferHeader[index]->pBuffer;
1964         eError = OMX_FillThisBuffer(mCameraAdapterParameters.mHandleComp,
1965                     (OMX_BUFFERHEADERTYPE*)mPreviewData->mBufferHeader[index]);
1966         if(eError!=OMX_ErrorNone)
1967             {
1968             CAMHAL_ERROR << "OMX_FillThisBuffer() failed, error:" << eError;
1969             }
1970         mFramesWithDucati++;
1971         GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
1972         }
1973
1974     if ( mMeasurementEnabled )
1975         {
1976
1977         for(int index=0;index< mPreviewData->mNumBufs;index++)
1978             {
1979             CAMHAL_DEBUG << "Queuing buffer on Measurement port:" << measurementData->mBufferHeader[index]->pBuffer;
1980             eError = OMX_FillThisBuffer(mCameraAdapterParameters.mHandleComp,
1981                             (OMX_BUFFERHEADERTYPE*) measurementData->mBufferHeader[index]);
1982             if(eError!=OMX_ErrorNone)
1983                 {
1984                 CAMHAL_ERROR << "OMX_FillThisBuffer() failed, error:" << eError;
1985                 }
1986             GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
1987             }
1988
1989         }
1990
1991     //reset frame rate estimates
1992     mFPS = 0.0f;
1993     mLastFPS = 0.0f;
1994     // start frame count from 0. i.e first frame after
1995     // startPreview will be the 0th reference frame
1996     // this way we will wait for second frame until
1997     // takePicture/autoFocus is allowed to run. we
1998     // are seeing SetConfig/GetConfig fail after
1999     // calling after the first frame and not failing
2000     // after the second frame
2001     mFrameCount = -1;
2002     mLastFrameCount = 0;
2003     mIter = 1;
2004     mLastFPSTime = systemTime();
2005
2006     LOG_FUNCTION_NAME_EXIT;
2007
2008     return (ret | Utils::ErrorUtils::omxToAndroidError(eError));
2009
2010     EXIT:
2011
2012     CAMHAL_ERROR << "Exiting because of error, ret =" << ret << ", eError =" << eError;
2013     performCleanupAfterError();
2014     mStateSwitchLock.unlock();
2015     LOG_FUNCTION_NAME_EXIT;
2016
2017     return (ret | Utils::ErrorUtils::omxToAndroidError(eError));
2018
2019 }
2020
2021 status_t OMXCameraAdapter::stopPreview()
2022 {
2023     LOG_FUNCTION_NAME;
2024
2025     OMX_ERRORTYPE eError = OMX_ErrorNone;
2026     status_t ret = NO_ERROR;
2027
2028     OMXCameraPortParameters *mCaptureData , *mPreviewData, *measurementData;
2029     mCaptureData = mPreviewData = measurementData = NULL;
2030
2031     mPreviewData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex];
2032     mCaptureData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex];
2033     measurementData = &mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mMeasurementPortIndex];
2034
2035     if ( mComponentState != OMX_StateExecuting )
2036         {
2037         CAMHAL_ERROR << "Calling StopPreview() when not in EXECUTING state";
2038         LOG_FUNCTION_NAME_EXIT;
2039         return NO_INIT;
2040         }
2041
2042     {
2043         android::AutoMutex lock(mFrameCountMutex);
2044         // we should wait for the first frame to come before trying to stopPreview...if not
2045         // we might put OMXCamera in a bad state (IDLE->LOADED timeout). Seeing this a lot
2046         // after a capture
2047         if (mFrameCount < 1) {
2048             // I want to wait for at least two frames....
2049             mFrameCount = -1;
2050
2051             // first frame may time some time to come...so wait for an adequate amount of time
2052             // which 2 * OMX_CAPTURE_TIMEOUT * 1000 will cover.
2053             ret = status_t::fromInt(mFirstFrameCondition.waitRelative(mFrameCountMutex,
2054                     (nsecs_t) 2 * OMX_CAPTURE_TIMEOUT * 1000));
2055         }
2056         // even if we timeout waiting for the first frame...go ahead with trying to stop preview
2057         // signal anybody that might be waiting
2058         mFrameCount = 0;
2059         mFirstFrameCondition.broadcast();
2060     }
2061
2062     ret = cancelAutoFocus();
2063     if(ret!=NO_ERROR)
2064     {
2065         CAMHAL_ERROR << "Error canceling autofocus:" << ret;
2066         // Error, but we probably still want to continue to stop preview
2067     }
2068
2069     OMX_CONFIG_FOCUSASSISTTYPE focusAssist;
2070     OMX_INIT_STRUCT_PTR (&focusAssist, OMX_CONFIG_FOCUSASSISTTYPE);
2071     focusAssist.nPortIndex = OMX_ALL;
2072     focusAssist.bFocusAssist = OMX_FALSE;
2073     CAMHAL_DEBUG << "Configuring AF Assist mode:" << focusAssist.bFocusAssist;
2074     eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
2075                             omx_enum_cast(OMX_IndexConfigFocusAssist),
2076                             &focusAssist);
2077     if ( OMX_ErrorNone != eError )
2078         {
2079         CAMHAL_ERROR << "Error while configuring AF Assist mode:" << eError;
2080         }
2081     else
2082         {
2083         CAMHAL_DEBUG << "Camera AF Assist  mode configured successfully";
2084         }
2085
2086     if ( 0 != mStopPreviewSem.Count() )
2087         {
2088         CAMHAL_ERROR << "Error mStopPreviewSem semaphore count:" << mStopPreviewSem.Count();
2089         LOG_FUNCTION_NAME_EXIT;
2090         return NO_INIT;
2091         }
2092
2093     ret = disableImagePort();
2094     if ( NO_ERROR != ret ) {
2095         CAMHAL_ERROR << "disable image port failed:" << ret;
2096         goto EXIT;
2097     }
2098
2099     CAMHAL_DEBUG << "Average framerate:" << mFPS;
2100
2101     //Avoid state switching of the OMX Component
2102     ret = flushBuffers();
2103     if ( NO_ERROR != ret )
2104         {
2105         CAMHAL_ERROR << "Flush Buffers failed:" << ret;
2106         goto EXIT;
2107         }
2108
2109     ///Register for Preview port Disable event
2110     ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
2111                            OMX_EventCmdComplete,
2112                            OMX_CommandPortDisable,
2113                            mCameraAdapterParameters.mPrevPortIndex,
2114                            mStopPreviewSem);
2115
2116     ///Disable Preview Port
2117     eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
2118                              OMX_CommandPortDisable,
2119                              mCameraAdapterParameters.mPrevPortIndex,
2120                              NULL);
2121
2122     ///Free the OMX Buffers
2123     for ( int i = 0 ; i < mPreviewData->mNumBufs ; i++ )
2124         {
2125         eError = OMX_FreeBuffer(mCameraAdapterParameters.mHandleComp,
2126                                 mCameraAdapterParameters.mPrevPortIndex,
2127                                 mPreviewData->mBufferHeader[i]);
2128
2129         if(eError!=OMX_ErrorNone)
2130             {
2131             CAMHAL_ERROR << "OMX_FreeBuffer() failed, error:" << eError;
2132             }
2133         GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
2134         }
2135
2136     if ( mMeasurementEnabled )
2137         {
2138             for ( int i = 0 ; i < measurementData->mNumBufs ; i++ )
2139                 {
2140                 eError = OMX_FreeBuffer(mCameraAdapterParameters.mHandleComp,
2141                                         mCameraAdapterParameters.mMeasurementPortIndex,
2142                                         measurementData->mBufferHeader[i]);
2143                 if(eError!=OMX_ErrorNone)
2144                     {
2145                     CAMHAL_ERROR << "OMX_FreeBuffer() failed, error:" << eError;
2146                     }
2147                 GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
2148                 }
2149
2150             {
2151             android::AutoMutex lock(mPreviewDataBufferLock);
2152             mPreviewDataBuffersAvailable.clear();
2153             }
2154         }
2155
2156     CAMHAL_DEBUG << "Disabling preview port";
2157     ret = mStopPreviewSem.WaitTimeout(OMX_CMD_TIMEOUT);
2158
2159     //If somethiing bad happened while we wait
2160     if (mComponentState == OMX_StateInvalid)
2161       {
2162         CAMHAL_ERROR << "Invalid State after Disabling preview port Exitting!!!";
2163         goto EXIT;
2164       }
2165
2166     if ( NO_ERROR == ret )
2167         {
2168         CAMHAL_DEBUG << "Preview port disabled";
2169         }
2170     else
2171         {
2172         ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp,
2173                            OMX_EventCmdComplete,
2174                            OMX_CommandPortDisable,
2175                            mCameraAdapterParameters.mPrevPortIndex,
2176                            NULL);
2177         CAMHAL_ERROR << "Timeout expired on preview port disable";
2178         goto EXIT;
2179         }
2180
2181         {
2182         android::AutoMutex lock(mPreviewBufferLock);
2183         ///Clear all the available preview buffers
2184         mPreviewBuffersAvailable.clear();
2185         }
2186
2187     switchToLoaded();
2188
2189
2190     mFirstTimeInit = true;
2191     mPendingCaptureSettings = 0;
2192     mFramesWithDucati = 0;
2193     mFramesWithDisplay = 0;
2194     mFramesWithEncoder = 0;
2195
2196 #ifdef CAMERAHAL_USE_DCC_FILE_DATA_SAVE
2197     saveDccFileDataSave();
2198 #endif
2199
2200     LOG_FUNCTION_NAME_EXIT;
2201
2202     return (ret | Utils::ErrorUtils::omxToAndroidError(eError));
2203
2204 EXIT:
2205     CAMHAL_ERROR << "Exiting because of error, ret =" << ret << ", eError =" << eError;
2206     {
2207     android::AutoMutex lock(mPreviewBufferLock);
2208     ///Clear all the available preview buffers
2209     mPreviewBuffersAvailable.clear();
2210     }
2211     performCleanupAfterError();
2212     LOG_FUNCTION_NAME_EXIT;
2213     return (ret | Utils::ErrorUtils::omxToAndroidError(eError));
2214
2215 }
2216
2217 status_t OMXCameraAdapter::setSensorOverclock(bool enable)
2218 {
2219     status_t ret = NO_ERROR;
2220     OMX_ERRORTYPE eError = OMX_ErrorNone;
2221     OMX_CONFIG_BOOLEANTYPE bOMX;
2222
2223     LOG_FUNCTION_NAME;
2224
2225     if ( OMX_StateLoaded != mComponentState )
2226         {
2227         CAMHAL_DEBUG << "OMX component is not in loaded state";
2228         return ret;
2229         }
2230
2231     if ( NO_ERROR == ret )
2232         {
2233         OMX_INIT_STRUCT_PTR (&bOMX, OMX_CONFIG_BOOLEANTYPE);
2234
2235         if ( enable )
2236             {
2237             bOMX.bEnabled = OMX_TRUE;
2238             }
2239         else
2240             {
2241             bOMX.bEnabled = OMX_FALSE;
2242             }
2243
2244         CAMHAL_DEBUG << "Configuring Sensor overclock mode:" << bOMX.bEnabled;
2245         eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp,
2246                                 omx_enum_cast(OMX_TI_IndexParamSensorOverClockMode),
2247                                 &bOMX);
2248         if ( OMX_ErrorNone != eError )
2249             {
2250             CAMHAL_ERROR << "Error while setting Sensor overclock:" << eError;
2251             }
2252         else
2253             {
2254             mSensorOverclock = enable;
2255             }
2256         }
2257
2258     LOG_FUNCTION_NAME_EXIT;
2259
2260     return Utils::ErrorUtils::omxToAndroidError(eError);
2261 }
2262
2263 status_t OMXCameraAdapter::printComponentVersion(OMX_HANDLETYPE handle)
2264 {
2265     status_t ret = NO_ERROR;
2266     OMX_ERRORTYPE eError = OMX_ErrorNone;
2267     OMX_VERSIONTYPE compVersion;
2268     char compName[OMX_MAX_STRINGNAME_SIZE];
2269     char *currentUUID = NULL;
2270     size_t offset = 0;
2271
2272     LOG_FUNCTION_NAME;
2273
2274     if ( NULL == handle )
2275         {
2276         CAMHAL_ERROR << "Invalid OMX Handle:" << handle;
2277         ret = BAD_VALUE;
2278         }
2279
2280     mCompUUID[0] = 0;
2281
2282     if ( NO_ERROR == ret )
2283         {
2284         eError = OMX_GetComponentVersion(handle,
2285                                       compName,
2286                                       &compVersion,
2287                                       &mCompRevision,
2288                                       &mCompUUID
2289                                     );
2290         if ( OMX_ErrorNone != eError )
2291             {
2292             CAMHAL_ERROR << "OMX_GetComponentVersion() failed, error:" << eError;
2293             ret = BAD_VALUE;
2294             }
2295         }
2296
2297     if ( NO_ERROR == ret )
2298         {
2299         CAMHAL_VERBOSE << "OMX Component name:" << compName;
2300         CAMHAL_VERBOSE << "OMX Component version:" << compVersion.nVersion;
2301         CAMHAL_VERBOSE << "Spec version:" << mCompRevision.nVersion;
2302         // TODO: Is it safe to print UUID as string?
2303         CAMHAL_VERBOSE << "Git Commit ID:" << mCompUUID;
2304         currentUUID = ( char * ) mCompUUID;
2305         }
2306
2307     if ( NULL != currentUUID )
2308         {
2309         // TODO: Not safe.
2310         offset = strlen( ( const char * ) mCompUUID) + 1;
2311         if ( (int)currentUUID + (int)offset - (int)mCompUUID < OMX_MAX_STRINGNAME_SIZE )
2312             {
2313             currentUUID += offset;
2314             CAMHAL_VERBOSE << "Git Branch:" << currentUUID;
2315             }
2316         else
2317             {
2318             ret = BAD_VALUE;
2319             }
2320     }
2321
2322     if ( NO_ERROR == ret )
2323         {
2324         // TODO: Not safe.
2325         offset = strlen( ( const char * ) currentUUID) + 1;
2326
2327         if ( (int)currentUUID + (int)offset - (int)mCompUUID < OMX_MAX_STRINGNAME_SIZE )
2328             {
2329             currentUUID += offset;
2330             CAMHAL_VERBOSE << "Build date and time:" << currentUUID;
2331             }
2332         else
2333             {
2334             ret = BAD_VALUE;
2335             }
2336         }
2337
2338     if ( NO_ERROR == ret )
2339         {
2340         // TODO: Not safe.
2341         offset = strlen( ( const char * ) currentUUID) + 1;
2342
2343         if ( (int)currentUUID + (int)offset - (int)mCompUUID < OMX_MAX_STRINGNAME_SIZE )
2344             {
2345             currentUUID += offset;
2346             CAMHAL_VERBOSE << "Build description:" << currentUUID;
2347             }
2348         else
2349             {
2350             ret = BAD_VALUE;
2351             }
2352         }
2353
2354     LOG_FUNCTION_NAME_EXIT;
2355
2356     return ret;
2357 }
2358
2359 #ifdef CAMERAHAL_USE_S3D
2360 status_t OMXCameraAdapter::setS3DFrameLayout(OMX_U32 port) const
2361 {
2362     OMX_ERRORTYPE eError = OMX_ErrorNone;
2363     OMX_TI_FRAMELAYOUTTYPE frameLayout;
2364     const OMXCameraPortParameters *cap =
2365         &mCameraAdapterParameters.mCameraPortParams[port];
2366
2367     LOG_FUNCTION_NAME;
2368
2369     OMX_INIT_STRUCT_PTR (&frameLayout, OMX_TI_FRAMELAYOUTTYPE);
2370     frameLayout.nPortIndex = port;
2371     eError = OMX_GetParameter(mCameraAdapterParameters.mHandleComp,
2372                                 omx_enum_cast(OMX_TI_IndexParamStereoFrmLayout),
2373                                 &frameLayout);
2374     if (eError != OMX_ErrorNone)
2375         {
2376         CAMHAL_ERROR << "Error while getting S3D frame layout:" << eError;
2377         return BAD_VALUE;
2378         }
2379
2380     if (cap->mFrameLayoutType == OMX_TI_StereoFrameLayoutTopBottomSubsample)
2381         {
2382         frameLayout.eFrameLayout = OMX_TI_StereoFrameLayoutTopBottom;
2383         frameLayout.nSubsampleRatio = 2;
2384         }
2385     else if (cap->mFrameLayoutType ==
2386                 OMX_TI_StereoFrameLayoutLeftRightSubsample)
2387         {
2388         frameLayout.eFrameLayout = OMX_TI_StereoFrameLayoutLeftRight;
2389         frameLayout.nSubsampleRatio = 2;
2390         }
2391     else
2392         {
2393         frameLayout.eFrameLayout = cap->mFrameLayoutType;
2394         frameLayout.nSubsampleRatio = 1;
2395         }
2396     frameLayout.nSubsampleRatio = frameLayout.nSubsampleRatio << 7;
2397
2398     eError = OMX_SetParameter(mCameraAdapterParameters.mHandleComp,
2399                                 omx_enum_cast(OMX_TI_IndexParamStereoFrmLayout),
2400                                 &frameLayout);
2401     if (eError != OMX_ErrorNone)
2402         {
2403         CAMHAL_ERROR << "Error while setting S3D frame layout:" << eError;
2404         return BAD_VALUE;
2405         }
2406     else
2407         {
2408         CAMHAL_DEBUG << "S3D frame layout" << frameLayout.eFrameLayout
2409                 << "applied successfully on port" << port;
2410         }
2411
2412     LOG_FUNCTION_NAME_EXIT;
2413
2414     return NO_ERROR;
2415 }
2416 #endif
2417
2418
2419 status_t OMXCameraAdapter::autoFocus()
2420 {
2421     status_t ret = NO_ERROR;
2422     Utils::Message msg;
2423
2424     LOG_FUNCTION_NAME;
2425
2426     {
2427         android::AutoMutex lock(mFrameCountMutex);
2428         if (mFrameCount < 1) {
2429             // first frame may time some time to come...so wait for an adequate amount of time
2430             // which 2 * OMX_CAPTURE_TIMEOUT * 1000 will cover.
2431             ret = status_t::fromInt(mFirstFrameCondition.waitRelative(mFrameCountMutex,
2432                                                     (nsecs_t) 2 * OMX_CAPTURE_TIMEOUT * 1000));
2433             if ((NO_ERROR != ret) || (mFrameCount == 0)) {
2434                 goto EXIT;
2435             }
2436         }
2437     }
2438
2439     msg.command = CommandHandler::CAMERA_PERFORM_AUTOFOCUS;
2440     msg.arg1 = mErrorNotifier;
2441     ret = mCommandHandler->put(&msg);
2442
2443  EXIT:
2444
2445     LOG_FUNCTION_NAME_EXIT;
2446
2447     return ret;
2448 }
2449
2450 status_t OMXCameraAdapter::takePicture()
2451 {
2452     status_t ret = NO_ERROR;
2453     Utils::Message msg;
2454
2455     LOG_FUNCTION_NAME;
2456
2457     {
2458         android::AutoMutex lock(mFrameCountMutex);
2459         if (mFrameCount < 1) {
2460             // first frame may time some time to come...so wait for an adequate amount of time
2461             // which 2 * OMX_CAPTURE_TIMEOUT * 1000 will cover.
2462             ret = status_t::fromInt(mFirstFrameCondition.waitRelative(mFrameCountMutex,
2463                                                    (nsecs_t) 2 * OMX_CAPTURE_TIMEOUT * 1000));
2464             if ((NO_ERROR != ret) || (mFrameCount == 0)) {
2465                 goto EXIT;
2466             }
2467         }
2468     }
2469
2470     msg.command = CommandHandler::CAMERA_START_IMAGE_CAPTURE;
2471     msg.arg1 = mErrorNotifier;
2472     ret = mCommandHandler->put(&msg);
2473
2474  EXIT:
2475     LOG_FUNCTION_NAME_EXIT;