diff options
Diffstat (limited to 'camera/inc/OMXCameraAdapter/OMXCameraAdapter.h')
| -rw-r--r-- | camera/inc/OMXCameraAdapter/OMXCameraAdapter.h | 1235 |
1 files changed, 1235 insertions, 0 deletions
diff --git a/camera/inc/OMXCameraAdapter/OMXCameraAdapter.h b/camera/inc/OMXCameraAdapter/OMXCameraAdapter.h new file mode 100644 index 0000000..10590df --- /dev/null +++ b/camera/inc/OMXCameraAdapter/OMXCameraAdapter.h @@ -0,0 +1,1235 @@ +/* + * Copyright (C) Texas Instruments - http://www.ti.com/ + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + + +#ifndef OMX_CAMERA_ADAPTER_H +#define OMX_CAMERA_ADAPTER_H + +#include "CameraHal.h" +#include "OMX_Types.h" +#include "OMX_Core.h" +#include "OMX_CoreExt.h" +#include "OMX_IVCommon.h" +#include "OMX_Component.h" +#include "OMX_Index.h" +#include "OMX_IndexExt.h" +#include "OMX_TI_Index.h" +#include "OMX_TI_IVCommon.h" +#include "OMX_TI_Common.h" +#include "OMX_TI_Image.h" +#include "General3A_Settings.h" +#include "OMXSceneModeTables.h" + +#include "BaseCameraAdapter.h" +#include "Encoder_libjpeg.h" +#include "DebugUtils.h" + + +extern "C" +{ +#include "timm_osal_error.h" +#include "timm_osal_events.h" +#include "timm_osal_trace.h" +#include "timm_osal_semaphores.h" +} + + +namespace Ti { +namespace Camera { + +#define Q16_OFFSET 16 + +#define OMX_CMD_TIMEOUT 3000000 //3 sec. +#define OMX_CAPTURE_TIMEOUT 5000000 //5 sec. + +#define FOCUS_THRESHOLD 5 //[s.] + +#define MIN_JPEG_QUALITY 1 +#define MAX_JPEG_QUALITY 100 +#define EXP_BRACKET_RANGE 10 +#define ZOOM_BRACKET_RANGE 10 + +#define FOCUS_DIST_SIZE 100 +#define FOCUS_DIST_BUFFER_SIZE 500 + +#define TOUCH_DATA_SIZE 200 +#define DEFAULT_THUMB_WIDTH 160 +#define DEFAULT_THUMB_HEIGHT 120 +#define FRAME_RATE_FULL_HD 27 +#define FRAME_RATE_HIGH_HD 60 + +#define ZOOM_STAGES 61 + +#define FACE_DETECTION_BUFFER_SIZE 0x1000 +#define MAX_NUM_FACES_SUPPORTED 35 + +#define EXIF_MODEL_SIZE 100 +#define EXIF_MAKE_SIZE 100 +#define EXIF_DATE_TIME_SIZE 20 + +#define GPS_MIN_DIV 60 +#define GPS_SEC_DIV 60 +#define GPS_SEC_ACCURACY 1000 +#define GPS_TIMESTAMP_SIZE 6 +#define GPS_DATESTAMP_SIZE 11 +#define GPS_REF_SIZE 2 +#define GPS_MAPDATUM_SIZE 100 +#define GPS_PROCESSING_SIZE 100 +#define GPS_VERSION_SIZE 4 +#define GPS_NORTH_REF "N" +#define GPS_SOUTH_REF "S" +#define GPS_EAST_REF "E" +#define GPS_WEST_REF "W" + +/* Default portstartnumber of Camera component */ +#define OMX_CAMERA_DEFAULT_START_PORT_NUM 0 + +/* Define number of ports for differt domains */ +#define OMX_CAMERA_PORT_OTHER_NUM 1 +#define OMX_CAMERA_PORT_VIDEO_NUM 4 +#define OMX_CAMERA_PORT_IMAGE_NUM 1 +#define OMX_CAMERA_PORT_AUDIO_NUM 0 +#define OMX_CAMERA_NUM_PORTS (OMX_CAMERA_PORT_OTHER_NUM + OMX_CAMERA_PORT_VIDEO_NUM + OMX_CAMERA_PORT_IMAGE_NUM + OMX_CAMERA_PORT_AUDIO_NUM) + +/* Define start port number for differt domains */ +#define OMX_CAMERA_PORT_OTHER_START OMX_CAMERA_DEFAULT_START_PORT_NUM +#define OMX_CAMERA_PORT_VIDEO_START (OMX_CAMERA_PORT_OTHER_START + OMX_CAMERA_PORT_OTHER_NUM) +#define OMX_CAMERA_PORT_IMAGE_START (OMX_CAMERA_PORT_VIDEO_START + OMX_CAMERA_PORT_VIDEO_NUM) +#define OMX_CAMERA_PORT_AUDIO_START (OMX_CAMERA_PORT_IMAGE_START + OMX_CAMERA_PORT_IMAGE_NUM) + +/* Port index for camera component */ +#define OMX_CAMERA_PORT_OTHER_IN (OMX_CAMERA_PORT_OTHER_START + 0) +#define OMX_CAMERA_PORT_VIDEO_IN_VIDEO (OMX_CAMERA_PORT_VIDEO_START + 0) +#define OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW (OMX_CAMERA_PORT_VIDEO_START + 1) +#define OMX_CAMERA_PORT_VIDEO_OUT_VIDEO (OMX_CAMERA_PORT_VIDEO_START + 2) +#define OMX_CAMERA_PORT_VIDEO_OUT_MEASUREMENT (OMX_CAMERA_PORT_VIDEO_START + 3) +#define OMX_CAMERA_PORT_IMAGE_OUT_IMAGE (OMX_CAMERA_PORT_IMAGE_START + 0) + + +#define OMX_INIT_STRUCT(_s_, _name_) \ + memset(&(_s_), 0x0, sizeof(_name_)); \ + (_s_).nSize = sizeof(_name_); \ + (_s_).nVersion.s.nVersionMajor = 0x1; \ + (_s_).nVersion.s.nVersionMinor = 0x1; \ + (_s_).nVersion.s.nRevision = 0x0; \ + (_s_).nVersion.s.nStep = 0x0 + +#define OMX_INIT_STRUCT_PTR(_s_, _name_) \ + memset((_s_), 0x0, sizeof(_name_)); \ + (_s_)->nSize = sizeof(_name_); \ + (_s_)->nVersion.s.nVersionMajor = 0x1; \ + (_s_)->nVersion.s.nVersionMinor = 0x1; \ + (_s_)->nVersion.s.nRevision = 0x0; \ + (_s_)->nVersion.s.nStep = 0x0 + +#define GOTO_EXIT_IF(_CONDITION,_ERROR) { \ + if ((_CONDITION)) { \ + eError = (_ERROR); \ + goto EXIT; \ + } \ +} + +const int64_t kCameraBufferLatencyNs = 250000000LL; // 250 ms + +///OMX Specific Functions +static OMX_ERRORTYPE OMXCameraAdapterEventHandler(OMX_IN OMX_HANDLETYPE hComponent, + OMX_IN OMX_PTR pAppData, + OMX_IN OMX_EVENTTYPE eEvent, + OMX_IN OMX_U32 nData1, + OMX_IN OMX_U32 nData2, + OMX_IN OMX_PTR pEventData); + +static OMX_ERRORTYPE OMXCameraAdapterEmptyBufferDone(OMX_IN OMX_HANDLETYPE hComponent, + OMX_IN OMX_PTR pAppData, + OMX_IN OMX_BUFFERHEADERTYPE* pBuffer); + +static OMX_ERRORTYPE OMXCameraAdapterFillBufferDone(OMX_IN OMX_HANDLETYPE hComponent, + OMX_IN OMX_PTR pAppData, + OMX_IN OMX_BUFFERHEADERTYPE* pBuffHeader); + +struct CapResolution { + size_t width, height; + const char *param; +}; + +struct CapPixelformat { + OMX_COLOR_FORMATTYPE pixelformat; + const char *param; +}; + +struct CapCodingFormat { + OMX_IMAGE_CODINGTYPE imageCodingFormat; + const char *param; +}; + +struct CapU32 { + OMX_U32 num; + const char *param; +}; + +struct CapS32 { + OMX_S32 num; + const char *param; +}; + +typedef CapU32 CapFramerate; +typedef CapU32 CapISO; +typedef CapU32 CapSensorName; +typedef CapS32 CapZoom; + +/** + * Class which completely abstracts the camera hardware interaction from camera hal + * TODO: Need to list down here, all the message types that will be supported by this class + Need to implement BufferProvider interface to use AllocateBuffer of OMX if needed + */ +class OMXCameraAdapter : public BaseCameraAdapter +{ +public: + + /*--------------------Constant declarations----------------------------------------*/ + static const int32_t MAX_NO_BUFFERS = 20; + + ///@remarks OMX Camera has six ports - buffer input, time input, preview, image, video, and meta data + static const int MAX_NO_PORTS = 6; + + ///Five second timeout + static const int CAMERA_ADAPTER_TIMEOUT = 5000*1000; + + enum CaptureMode + { + INITIAL_MODE = -1, + HIGH_SPEED = 1, + HIGH_QUALITY, + VIDEO_MODE, + HIGH_QUALITY_ZSL, + CP_CAM, + VIDEO_MODE_HQ, + }; + + enum IPPMode + { + IPP_NULL = -1, + IPP_NONE = 0, + IPP_NSF, + IPP_LDC, + IPP_LDCNSF, + }; + + enum CodingMode + { + CodingJPEG = 0, + CodingJPS, + CodingMPO, + }; + + enum Algorithm3A + { + WHITE_BALANCE_ALGO = 0x1, + EXPOSURE_ALGO = 0x2, + FOCUS_ALGO = 0x4, + }; + + enum AlgoPriority + { + FACE_PRIORITY = 0, + REGION_PRIORITY, + }; + + enum BrightnessMode + { + BRIGHTNESS_OFF = 0, + BRIGHTNESS_ON, + BRIGHTNESS_AUTO, + }; + + enum CaptureSettingsFlags { + SetFormat = 1 << 0, + SetThumb = 1 << 1, + SetBurstExpBracket = 1 << 2, + SetQuality = 1 << 3, + SetRotation = 1 << 4, + ECaptureSettingMax, + ECapturesettingsAll = ( ((ECaptureSettingMax -1 ) << 1) -1 ), /// all possible flags raised + ECaptureParamSettings = SetFormat | SetThumb | SetQuality | SetBurstExpBracket, // Settings set with SetParam + ECaptureConfigSettings = (ECapturesettingsAll & ~ECaptureParamSettings) + }; + + enum PreviewSettingsFlags { + SetLDC = 1 << 0, + SetNSF = 1 << 1, + SetCapMode = 1 << 2, + SetVNF = 1 << 3, + SetVSTAB = 1 << 4, + EPreviewSettingMax, + EPreviewSettingsAll = ( ((EPreviewSettingMax -1 ) << 1) -1 ) /// all possible flags raised + }; + + enum BracketingValueMode { + BracketingValueAbsolute, + BracketingValueRelative, + BracketingValueAbsoluteForced, + BracketingValueRelativeForced, + BracketingValueCompensation, + BracketingValueCompensationForced + }; + + class GPSData + { + public: + int mLongDeg, mLongMin, mLongSec, mLongSecDiv; + char mLongRef[GPS_REF_SIZE]; + bool mLongValid; + int mLatDeg, mLatMin, mLatSec, mLatSecDiv; + char mLatRef[GPS_REF_SIZE]; + bool mLatValid; + int mAltitude; + unsigned char mAltitudeRef; + bool mAltitudeValid; + char mMapDatum[GPS_MAPDATUM_SIZE]; + bool mMapDatumValid; + char mVersionId[GPS_VERSION_SIZE]; + bool mVersionIdValid; + char mProcMethod[GPS_PROCESSING_SIZE]; + bool mProcMethodValid; + char mDatestamp[GPS_DATESTAMP_SIZE]; + bool mDatestampValid; + uint32_t mTimeStampHour; + uint32_t mTimeStampMin; + uint32_t mTimeStampSec; + bool mTimeStampValid; + }; + + class EXIFData + { + public: + GPSData mGPSData; + char mMake[EXIF_MODEL_SIZE]; + char mModel[EXIF_MAKE_SIZE]; + unsigned int mFocalNum, mFocalDen; + bool mMakeValid; + bool mModelValid; + }; + + ///Parameters specific to any port of the OMX Camera component + class OMXCameraPortParameters + { + public: + //CameraBuffer * mHostBufaddr[MAX_NO_BUFFERS]; + OMX_BUFFERHEADERTYPE *mBufferHeader[MAX_NO_BUFFERS]; + OMX_U8 mStatus[MAX_NO_BUFFERS]; + OMX_U32 mWidth; + OMX_U32 mHeight; + OMX_U32 mStride; + OMX_U8 mNumBufs; + + // defines maximum number of buffers our of mNumBufs + // queueable at given moment + OMX_U8 mMaxQueueable; + + OMX_U32 mBufSize; + OMX_COLOR_FORMATTYPE mColorFormat; + OMX_PARAM_VIDEONOISEFILTERTYPE mVNFMode; + OMX_PARAM_VIDEOYUVRANGETYPE mYUVRange; + OMX_CONFIG_BOOLEANTYPE mVidStabParam; + OMX_CONFIG_FRAMESTABTYPE mVidStabConfig; + OMX_U32 mCapFrame; + OMX_U32 mFrameRate; + OMX_U32 mMinFrameRate; + OMX_U32 mMaxFrameRate; + CameraFrame::FrameType mImageType; + OMX_TI_STEREOFRAMELAYOUTTYPE mFrameLayoutType; + CameraBufferType mBufferType; + + CameraBuffer * lookup_omx_buffer (OMX_BUFFERHEADERTYPE *pBufHeader); + enum { + IDLE = 0, // buffer is neither with HAL or Ducati + FILL, // buffer is with Ducati + DONE, // buffer is filled and sent to HAL + }; + }; + + ///Context of the OMX Camera component + class OMXCameraAdapterComponentContext + { + public: + OMX_HANDLETYPE mHandleComp; + OMX_U32 mNumPorts; + OMX_STATETYPE mState ; + OMX_U32 mVideoPortIndex; + OMX_U32 mPrevPortIndex; + OMX_U32 mImagePortIndex; + OMX_U32 mMeasurementPortIndex; + OMX_U32 mVideoInPortIndex; + OMXCameraPortParameters mCameraPortParams[MAX_NO_PORTS]; + }; + + class CachedCaptureParameters + { + public: + unsigned int mPendingCaptureSettings; + unsigned int mPictureRotation; + int mExposureBracketingValues[EXP_BRACKET_RANGE]; + int mExposureGainBracketingValues[EXP_BRACKET_RANGE]; + int mExposureGainBracketingModes[EXP_BRACKET_RANGE]; + size_t mExposureBracketingValidEntries; + OMX_BRACKETMODETYPE mExposureBracketMode; + unsigned int mBurstFrames; + bool mFlushShotConfigQueue; + }; + +public: + + OMXCameraAdapter(size_t sensor_index); + ~OMXCameraAdapter(); + + ///Initialzes the camera adapter creates any resources required + virtual status_t initialize(CameraProperties::Properties*); + + //APIs to configure Camera adapter and get the current parameter set + virtual status_t setParameters(const android::CameraParameters& params); + virtual void getParameters(android::CameraParameters& params); + + // API + status_t UseBuffersPreview(CameraBuffer *bufArr, int num); + + //API to flush the buffers + status_t flushBuffers(OMX_U32 port = OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW); + + // API + virtual status_t setFormat(OMX_U32 port, OMXCameraPortParameters &cap); + + // Function to get and populate caps from handle + static status_t getCaps(int sensorId, CameraProperties::Properties* props, OMX_HANDLETYPE handle); + static const char* getLUTvalue_OMXtoHAL(int OMXValue, LUTtype LUT); + static int getMultipleLUTvalue_OMXtoHAL(int OMXValue, LUTtype LUT, char * supported); + static int getLUTvalue_HALtoOMX(const char * HalValue, LUTtype LUT); + + OMX_ERRORTYPE OMXCameraAdapterEventHandler(OMX_IN OMX_HANDLETYPE hComponent, + OMX_IN OMX_EVENTTYPE eEvent, + OMX_IN OMX_U32 nData1, + OMX_IN OMX_U32 nData2, + OMX_IN OMX_PTR pEventData); + + OMX_ERRORTYPE OMXCameraAdapterEmptyBufferDone(OMX_IN OMX_HANDLETYPE hComponent, + OMX_IN OMX_BUFFERHEADERTYPE* pBuffer); + + OMX_ERRORTYPE OMXCameraAdapterFillBufferDone(OMX_IN OMX_HANDLETYPE hComponent, + OMX_IN OMX_BUFFERHEADERTYPE* pBuffHeader); + + static OMX_ERRORTYPE OMXCameraGetHandle(OMX_HANDLETYPE *handle, OMX_PTR pAppData, + const OMX_CALLBACKTYPE & callbacks); + +protected: + + //Parent class method implementation + virtual status_t takePicture(); + virtual status_t stopImageCapture(); + virtual status_t startBracketing(int range); + virtual status_t stopBracketing(); + virtual status_t autoFocus(); + virtual status_t cancelAutoFocus(); + virtual status_t startSmoothZoom(int targetIdx); + virtual status_t stopSmoothZoom(); + virtual status_t startVideoCapture(); + virtual status_t stopVideoCapture(); + virtual status_t startPreview(); + virtual status_t stopPreview(); + virtual status_t useBuffers(CameraMode mode, CameraBuffer * bufArr, int num, size_t length, unsigned int queueable); + virtual status_t fillThisBuffer(CameraBuffer * frameBuf, CameraFrame::FrameType frameType); + virtual status_t getFrameSize(size_t &width, size_t &height); + virtual status_t getPictureBufferSize(CameraFrame &frame, size_t bufferCount); + virtual status_t getFrameDataSize(size_t &dataFrameSize, size_t bufferCount); + virtual status_t startFaceDetection(); + virtual status_t stopFaceDetection(); + virtual status_t switchToExecuting(); + virtual void onOrientationEvent(uint32_t orientation, uint32_t tilt); + +private: + + // Caches and returns current set of parameters + CachedCaptureParameters* cacheCaptureParameters(); + + status_t doSwitchToExecuting(); + + void performCleanupAfterError(); + + status_t switchToIdle(); + + status_t switchToLoaded(bool bPortEnableRequired = false); + status_t prevPortEnable(); + + OMXCameraPortParameters *getPortParams(CameraFrame::FrameType frameType); + + OMX_ERRORTYPE SignalEvent(OMX_IN OMX_HANDLETYPE hComponent, + OMX_IN OMX_EVENTTYPE eEvent, + OMX_IN OMX_U32 nData1, + OMX_IN OMX_U32 nData2, + OMX_IN OMX_PTR pEventData); + OMX_ERRORTYPE RemoveEvent(OMX_IN OMX_HANDLETYPE hComponent, + OMX_IN OMX_EVENTTYPE eEvent, + OMX_IN OMX_U32 nData1, + OMX_IN OMX_U32 nData2, + OMX_IN OMX_PTR pEventData); + + status_t RegisterForEvent(OMX_IN OMX_HANDLETYPE hComponent, + OMX_IN OMX_EVENTTYPE eEvent, + OMX_IN OMX_U32 nData1, + OMX_IN OMX_U32 nData2, + OMX_IN Utils::Semaphore &semaphore); + + status_t setPictureRotation(unsigned int degree); + status_t setSensorOrientation(unsigned int degree); + status_t setImageQuality(unsigned int quality); + status_t setThumbnailParams(unsigned int width, unsigned int height, unsigned int quality); + status_t setSensorQuirks(int orientation, + OMXCameraPortParameters &portParams, + bool &portConfigured); + + status_t setupTunnel(uint32_t SliceHeight, uint32_t EncoderHandle, uint32_t width, uint32_t height); + status_t destroyTunnel(); + + //EXIF + status_t setParametersEXIF(const android::CameraParameters ¶ms, + BaseCameraAdapter::AdapterState state); + status_t convertGPSCoord(double coord, int °, int &min, int &sec, int &secDivisor); + status_t setupEXIF(); + status_t setupEXIF_libjpeg(ExifElementsTable*, OMX_TI_ANCILLARYDATATYPE*, + OMX_TI_WHITEBALANCERESULTTYPE*); + + //Focus functionality + status_t doAutoFocus(); + status_t stopAutoFocus(); + status_t checkFocus(OMX_PARAM_FOCUSSTATUSTYPE *eFocusStatus); + status_t returnFocusStatus(bool timeoutReached); + status_t getFocusMode(OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE &focusMode); + void handleFocusCallback(); + + + //Focus distances + status_t setParametersFocus(const android::CameraParameters ¶ms, + BaseCameraAdapter::AdapterState state); + status_t addFocusDistances(OMX_U32 &near, + OMX_U32 &optimal, + OMX_U32 &far, + android::CameraParameters& params); + status_t encodeFocusDistance(OMX_U32 dist, char *buffer, size_t length); + status_t getFocusDistances(OMX_U32 &near,OMX_U32 &optimal, OMX_U32 &far); + + //VSTAB and VNF Functionality + status_t enableVideoNoiseFilter(bool enable); + status_t enableVideoStabilization(bool enable); + + //Digital zoom + status_t setParametersZoom(const android::CameraParameters ¶ms, + BaseCameraAdapter::AdapterState state); + status_t doZoom(int index); + status_t advanceZoom(); + + //3A related parameters + status_t setParameters3A(const android::CameraParameters ¶ms, + BaseCameraAdapter::AdapterState state); + void declareParameter3ABool(const android::CameraParameters ¶ms, const char *key, + OMX_BOOL ¤t_setting, E3ASettingsFlags pending, + const char *msg); + + // scene modes + status_t setScene(Gen3A_settings& Gen3A); + // returns pointer to SceneModesEntry from the LUT for camera given 'name' and 'scene' + static const SceneModesEntry* getSceneModeEntry(const char* name, OMX_SCENEMODETYPE scene); + + + //Flash modes + status_t setFlashMode(Gen3A_settings& Gen3A); + status_t getFlashMode(Gen3A_settings& Gen3A); + + // Focus modes + status_t setFocusMode(Gen3A_settings& Gen3A); + status_t getFocusMode(Gen3A_settings& Gen3A); + + //Exposure Modes + status_t setExposureMode(Gen3A_settings& Gen3A); + status_t setManualExposureVal(Gen3A_settings& Gen3A); + status_t setEVCompensation(Gen3A_settings& Gen3A); + status_t setWBMode(Gen3A_settings& Gen3A); + status_t setFlicker(Gen3A_settings& Gen3A); + status_t setBrightness(Gen3A_settings& Gen3A); + status_t setContrast(Gen3A_settings& Gen3A); + status_t setSharpness(Gen3A_settings& Gen3A); + status_t setSaturation(Gen3A_settings& Gen3A); + status_t setISO(Gen3A_settings& Gen3A); + status_t setEffect(Gen3A_settings& Gen3A); + status_t setMeteringAreas(Gen3A_settings& Gen3A); + + //TI extensions for enable/disable algos + status_t setParameter3ABool(const OMX_INDEXTYPE omx_idx, + const OMX_BOOL data, const char *msg); + status_t setParameter3ABoolInvert(const OMX_INDEXTYPE omx_idx, + const OMX_BOOL data, const char *msg); + status_t setAlgoExternalGamma(Gen3A_settings& Gen3A); +#ifndef MOTOROLA_CAMERA + status_t setAlgoNSF1(Gen3A_settings& Gen3A); + status_t setAlgoNSF2(Gen3A_settings& Gen3A); + status_t setAlgoSharpening(Gen3A_settings& Gen3A); + status_t setAlgoThreeLinColorMap(Gen3A_settings& Gen3A); + status_t setAlgoGIC(Gen3A_settings& Gen3A); + + //Gamma table + void updateGammaTable(const char* gamma); + status_t setGammaTable(Gen3A_settings& Gen3A); +#endif + + status_t getEVCompensation(Gen3A_settings& Gen3A); + status_t getWBMode(Gen3A_settings& Gen3A); + status_t getSharpness(Gen3A_settings& Gen3A); + status_t getSaturation(Gen3A_settings& Gen3A); + status_t getISO(Gen3A_settings& Gen3A); + + // 3A locks + status_t setExposureLock(Gen3A_settings& Gen3A); + status_t setFocusLock(Gen3A_settings& Gen3A); + status_t setWhiteBalanceLock(Gen3A_settings& Gen3A); + status_t set3ALock(OMX_BOOL toggleExp, OMX_BOOL toggleWb, OMX_BOOL toggleFocus); + + //Stereo 3D + void setParamS3D(OMX_U32 port, const char *valstr); + status_t setS3DFrameLayout(OMX_U32 port) const; + + //API to set FrameRate using VFR interface + status_t setVFramerate(OMX_U32 minFrameRate,OMX_U32 maxFrameRate); + + status_t setParametersAlgo(const android::CameraParameters ¶ms, + BaseCameraAdapter::AdapterState state); + + //Noise filtering + status_t setNSF(OMXCameraAdapter::IPPMode mode); + + //LDC + status_t setLDC(OMXCameraAdapter::IPPMode mode); + + //GLBCE + status_t setGLBCE(OMXCameraAdapter::BrightnessMode mode); + + //GBCE + status_t setGBCE(OMXCameraAdapter::BrightnessMode mode); + + status_t printComponentVersion(OMX_HANDLETYPE handle); + + //Touch AF + status_t setTouchFocus(); + + //Face detection + status_t setParametersFD(const android::CameraParameters ¶ms, + BaseCameraAdapter::AdapterState state); + status_t updateFocusDistances(android::CameraParameters ¶ms); + status_t setFaceDetectionOrientation(OMX_U32 orientation); + status_t setFaceDetection(bool enable, OMX_U32 orientation); + status_t createPreviewMetadata(OMX_BUFFERHEADERTYPE* pBuffHeader, + android::sp<CameraMetadataResult> &result, + size_t previewWidth, + size_t previewHeight); + status_t encodeFaceCoordinates(const OMX_FACEDETECTIONTYPE *faceData, + camera_frame_metadata_t *metadataResult, + size_t previewWidth, + size_t previewHeight); + status_t encodePreviewMetadata(camera_frame_metadata_t *meta, const OMX_PTR plat_pvt); + + void pauseFaceDetection(bool pause); + + //3A Algorithms priority configuration + status_t setAlgoPriority(AlgoPriority priority, Algorithm3A algo, bool enable); + + //Sensor overclocking + status_t setSensorOverclock(bool enable); + + // Utility methods for OMX Capabilities + static bool _checkOmxTiCap(const OMX_TI_CAPTYPE & caps); + static bool _dumpOmxTiCap(int sensorId, const OMX_TI_CAPTYPE & caps); + + static status_t insertCapabilities(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t encodeSizeCap(OMX_TI_CAPRESTYPE&, const CapResolution *, size_t, char *, size_t); + static status_t encodeISOCap(OMX_U32, const CapISO*, size_t, char*, size_t); + static size_t encodeZoomCap(OMX_S32, const CapZoom*, size_t, char*, size_t); + static void encodeFrameRates(int minFrameRate, int maxFrameRate, const OMX_TI_CAPTYPE & caps, + const CapFramerate * fixedFrameRates, int frameRateCount, android::Vector<FpsRange> & fpsRanges); + static status_t encodeImageCodingFormatCap(OMX_IMAGE_CODINGTYPE, + const CapCodingFormat *, + size_t, + char *); + static status_t encodePixelformatCap(OMX_COLOR_FORMATTYPE, + const CapPixelformat*, + size_t, + char*, + size_t); + static status_t encodeSizeCap3D(OMX_TI_CAPRESTYPE&, + const CapResolution*, + size_t , + char * , + size_t); + static status_t insertImageSizes(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t insertPreviewSizes(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t insertThumbSizes(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t insertZoomStages(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t insertImageFormats(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t insertPreviewFormats(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t insertFramerates(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t insertEVs(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t insertISOModes(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t insertIPPModes(CameraProperties::Properties*, OMX_TI_CAPTYPE &); + static status_t insertWBModes(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t insertEffects(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t insertExpModes(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t insertManualExpRanges(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t insertSceneModes(CameraProperties::Properties*, OMX_TI_CAPTYPE &); + static status_t insertFocusModes(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t insertFlickerModes(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t insertFlashModes(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t insertSenMount(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t insertDefaults(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t insertLocks(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t insertAreas(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t insertMechanicalMisalignmentCorrection(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t insertCaptureModes(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t insertVideoSizes(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t insertFacing(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t insertFocalLength(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t insertAutoConvergenceModes(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t insertManualConvergenceRange(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t insertLayout(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t insertVideoSnapshotSupported(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + static status_t insertVNFSupported(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps); + static status_t insertVSTABSupported(CameraProperties::Properties* params, OMX_TI_CAPTYPE &caps); + static status_t insertGBCESupported(CameraProperties::Properties* params, + const OMX_TI_CAPTYPE &caps); + static status_t insertGLBCESupported(CameraProperties::Properties* params, + const OMX_TI_CAPTYPE &caps); + static status_t insertRaw(CameraProperties::Properties*, OMX_TI_CAPTYPE&); + + status_t setParametersCapture(const android::CameraParameters ¶ms, + BaseCameraAdapter::AdapterState state); + + //Exposure Bracketing + status_t initVectorShot(); + status_t setVectorShot(int *evValues, int *evValues2, int *evModes2, + size_t evCount, size_t frameCount, + bool flush, OMX_BRACKETMODETYPE bracketMode); + status_t setVectorStop(bool toPreview = false); + status_t setExposureBracketing(int *evValues, int *evValues2, + size_t evCount, size_t frameCount, + OMX_BRACKETMODETYPE bracketMode); + status_t doExposureBracketing(int *evValues, int *evValues2, + int *evModes2, + size_t evCount, size_t frameCount, + bool flush, + OMX_BRACKETMODETYPE bracketMode); + int getBracketingValueMode(const char *a, const char *b) const; + status_t parseExpRange(const char *rangeStr, int *expRange, int *gainRange, + int *expGainModes, + size_t count, size_t &validEntries); + + //Temporal Bracketing + status_t doBracketing(OMX_BUFFERHEADERTYPE *pBuffHeader, CameraFrame::FrameType typeOfFrame); + status_t sendBracketFrames(size_t &framesSent); + + // Image Capture Service + status_t startImageCapture(bool bracketing, CachedCaptureParameters*); + status_t disableImagePort(); + + //Shutter callback notifications + status_t setShutterCallback(bool enabled); + + //Sets eithter HQ or HS mode and the frame count + status_t setCaptureMode(OMXCameraAdapter::CaptureMode mode); + status_t UseBuffersCapture(CameraBuffer *bufArr, int num); + status_t UseBuffersPreviewData(CameraBuffer *bufArr, int num); + status_t UseBuffersRawCapture(CameraBuffer *bufArr, int num); + + //Used for calculation of the average frame rate during preview + status_t recalculateFPS(); + + //Sends the incoming OMX buffer header to subscribers + status_t sendCallBacks(CameraFrame frame, OMX_IN OMX_BUFFERHEADERTYPE *pBuffHeader, unsigned int mask, OMXCameraPortParameters *port); + + status_t apply3Asettings( Gen3A_settings& Gen3A ); + + // AutoConvergence + status_t setAutoConvergence(const char *valstr, const char *pValManualstr, const android::CameraParameters ¶ms); + + status_t setExtraData(bool enable, OMX_U32, OMX_EXT_EXTRADATATYPE); + OMX_OTHER_EXTRADATATYPE *getExtradata(const OMX_PTR ptrPrivate, OMX_EXTRADATATYPE type) const; + + // Meta data +#ifdef OMAP_ENHANCEMENT_CPCAM + camera_memory_t * getMetaData(const OMX_PTR plat_pvt, + camera_request_memory allocator) const; +#endif + + // Mechanical Misalignment Correction + status_t setMechanicalMisalignmentCorrection(bool enable); + + // DCC file data save + status_t initDccFileDataSave(OMX_HANDLETYPE* omxHandle, int portIndex); + status_t sniffDccFileDataSave(OMX_BUFFERHEADERTYPE* pBuffHeader); + status_t saveDccFileDataSave(); + status_t closeDccFileDataSave(); + status_t fseekDCCuseCasePos(FILE *pFile); + FILE * fopenCameraDCC(const char *dccFolderPath); + FILE * parseDCCsubDir(DIR *pDir, char *path); + +#ifdef CAMERAHAL_OMX_PROFILING + status_t storeProfilingData(OMX_BUFFERHEADERTYPE* pBuffHeader); +#endif + + // Internal buffers + status_t initInternalBuffers (OMX_U32); + status_t deinitInternalBuffers (OMX_U32); + + // Reprocess Methods -- implementation in OMXReprocess.cpp + status_t setParametersReprocess(const android::CameraParameters ¶ms, CameraBuffer* bufs, + BaseCameraAdapter::AdapterState state); + status_t startReprocess(); + status_t disableReprocess(); + status_t stopReprocess(); + status_t UseBuffersReprocess(CameraBuffer *bufArr, int num); + + class CommandHandler : public android::Thread { + public: + CommandHandler(OMXCameraAdapter* ca) + : android::Thread(false), mCameraAdapter(ca) { } + + virtual bool threadLoop() { + bool ret; + ret = Handler(); + return ret; + } + + status_t put(Utils::Message* msg){ + android::AutoMutex lock(mLock); + return mCommandMsgQ.put(msg); + } + + void clearCommandQ() + { + android::AutoMutex lock(mLock); + mCommandMsgQ.clear(); + } + + enum { + COMMAND_EXIT = -1, + CAMERA_START_IMAGE_CAPTURE = 0, + CAMERA_PERFORM_AUTOFOCUS, + CAMERA_SWITCH_TO_EXECUTING, + CAMERA_START_REPROCESS + }; + + private: + bool Handler(); + Utils::MessageQueue mCommandMsgQ; + OMXCameraAdapter* mCameraAdapter; + android::Mutex mLock; + }; + android::sp<CommandHandler> mCommandHandler; + +#ifdef MOTOROLA_CAMERA + status_t setLedFlash(int nLedFlashIntensP); + status_t setLedTorch(int nLedTorchIntensP); +#endif + +public: + +#ifdef MOTOROLA_CAMERA + status_t getOTPEeprom(unsigned char * pData, unsigned long nSize); +#endif + + class OMXCallbackHandler : public android::Thread { + public: + OMXCallbackHandler(OMXCameraAdapter* ca) + : Thread(false), mCameraAdapter(ca) + { + mIsProcessed = true; + } + + virtual bool threadLoop() { + bool ret; + ret = Handler(); + return ret; + } + + status_t put(Utils::Message* msg){ + android::AutoMutex lock(mLock); + mIsProcessed = false; + return mCommandMsgQ.put(msg); + } + + void clearCommandQ() + { + android::AutoMutex lock(mLock); + mCommandMsgQ.clear(); + } + + void flush(); + + enum { + COMMAND_EXIT = -1, + CAMERA_FILL_BUFFER_DONE, + CAMERA_FOCUS_STATUS + }; + + private: + bool Handler(); + Utils::MessageQueue mCommandMsgQ; + OMXCameraAdapter* mCameraAdapter; + android::Mutex mLock; + android::Condition mCondition; + bool mIsProcessed; + }; + + android::sp<OMXCallbackHandler> mOMXCallbackHandler; + +private: + + //AF callback + status_t setFocusCallback(bool enabled); + + //OMX Capabilities data + static const CapResolution mImageCapRes []; + static const CapResolution mImageCapResSS []; + static const CapResolution mImageCapResTB []; + static const CapResolution mPreviewRes []; + static const CapResolution mPreviewResSS []; + static const CapResolution mPreviewResTB []; + static const CapResolution mPreviewPortraitRes []; + static const CapResolution mThumbRes []; + static const CapPixelformat mPixelformats []; + static const userToOMX_LUT mFrameLayout []; + static const LUTtype mLayoutLUT; + static const CapCodingFormat mImageCodingFormat[]; + static const CapFramerate mFramerates []; + static const CapU32 mSensorNames[] ; + static const CapZoom mZoomStages []; + static const CapISO mISOStages []; + static const int SENSORID_IMX060; + static const int SENSORID_OV5650; + static const int SENSORID_OV5640; + static const int SENSORID_OV14825; + static const int SENSORID_S5K4E1GA; + static const int SENSORID_S5K6A1GX03; + static const int SENSORID_OV8830; + static const int SENSORID_OV2722; + static const int SENSORID_OV9726; +#ifdef MOTOROLA_CAMERA + static const int SENSORID_OV8820; + static const int SENSORID_MT9M114; +#endif + static const CapU32 mFacing []; + static const userToOMX_LUT mAutoConvergence []; + static const LUTtype mAutoConvergenceLUT; + static const userToOMX_LUT mBracketingModes[]; + static const LUTtype mBracketingModesLUT; + + static const int FPS_MIN; + static const int FPS_MAX; + static const int FPS_MAX_EXTENDED; + + // OMX Camera defaults + static const char DEFAULT_ANTIBANDING[]; + static const char DEFAULT_BRIGHTNESS[]; + static const char DEFAULT_CONTRAST[]; + static const char DEFAULT_EFFECT[]; + static const char DEFAULT_EV_COMPENSATION[]; + static const char DEFAULT_EV_STEP[]; + static const char DEFAULT_EXPOSURE_MODE[]; + static const char DEFAULT_FLASH_MODE[]; + static const char DEFAULT_FOCUS_MODE_PREFERRED[]; + static const char DEFAULT_FOCUS_MODE[]; + static const char DEFAULT_IPP[]; + static const char DEFAULT_ISO_MODE[]; + static const char DEFAULT_JPEG_QUALITY[]; + static const char DEFAULT_THUMBNAIL_QUALITY[]; + static const char DEFAULT_THUMBNAIL_SIZE[]; + static const char DEFAULT_PICTURE_FORMAT[]; + static const char DEFAULT_S3D_PICTURE_LAYOUT[]; + static const char DEFAULT_PICTURE_SIZE[]; + static const char DEFAULT_PICTURE_SS_SIZE[]; + static const char DEFAULT_PICTURE_TB_SIZE[]; + static const char DEFAULT_PREVIEW_FORMAT[]; + static const char DEFAULT_FRAMERATE[]; + static const char DEFAULT_S3D_PREVIEW_LAYOUT[]; + static const char DEFAULT_PREVIEW_SIZE[]; + static const char DEFAULT_PREVIEW_SS_SIZE[]; + static const char DEFAULT_PREVIEW_TB_SIZE[]; + static const char DEFAULT_NUM_PREV_BUFS[]; + static const char DEFAULT_NUM_PIC_BUFS[]; + static const char DEFAULT_SATURATION[]; + static const char DEFAULT_SCENE_MODE[]; + static const char DEFAULT_SHARPNESS[]; + static const char * DEFAULT_VSTAB; + static const char * DEFAULT_VNF; + static const char DEFAULT_WB[]; + static const char DEFAULT_ZOOM[]; + static const char DEFAULT_MAX_FD_HW_FACES[]; + static const char DEFAULT_MAX_FD_SW_FACES[]; + static const char * DEFAULT_AE_LOCK; + static const char * DEFAULT_AWB_LOCK; + static const char DEFAULT_HOR_ANGLE[]; + static const char DEFAULT_VER_ANGLE[]; + static const char DEFAULT_VIDEO_SIZE[]; + static const char DEFAULT_SENSOR_ORIENTATION[]; + static const char DEFAULT_AUTOCONVERGENCE_MODE[]; + static const char DEFAULT_MANUAL_CONVERGENCE[]; + static const char * DEFAULT_MECHANICAL_MISALIGNMENT_CORRECTION_MODE; + static const char DEFAULT_EXIF_MODEL[]; + static const char DEFAULT_EXIF_MAKE[]; + + static const size_t MAX_FOCUS_AREAS; + +#ifdef CAMERAHAL_OMX_PROFILING + + static const char DEFAULT_PROFILE_PATH[]; + int mDebugProfile; + +#endif + + OMX_VERSIONTYPE mCompRevision; + + //OMX Component UUID + OMX_UUIDTYPE mCompUUID; + + //Current Focus distances + char mFocusDistNear[FOCUS_DIST_SIZE]; + char mFocusDistOptimal[FOCUS_DIST_SIZE]; + char mFocusDistFar[FOCUS_DIST_SIZE]; + char mFocusDistBuffer[FOCUS_DIST_BUFFER_SIZE]; + + // Current Focus areas + android::Vector<android::sp<CameraArea> > mFocusAreas; + mutable android::Mutex mFocusAreasLock; + + // Current Touch convergence areas + android::Vector<android::sp<CameraArea> > mTouchAreas; + mutable android::Mutex mTouchAreasLock; + + // Current Metering areas + android::Vector<android::sp<CameraArea> > mMeteringAreas; + mutable android::Mutex mMeteringAreasLock; + + OperatingMode mCapabilitiesOpMode; + CaptureMode mCapMode; + // TODO(XXX): Do we really need this lock? Let's + // try to merge temporal bracketing and burst + // capture later + mutable android::Mutex mBurstLock; + size_t mBurstFrames; + size_t mBurstFramesAccum; + size_t mBurstFramesQueued; + size_t mCapturedFrames; + bool mFlushShotConfigQueue; + + bool mMeasurementEnabled; + + //Exposure Bracketing + int mExposureBracketingValues[EXP_BRACKET_RANGE]; + int mExposureGainBracketingValues[EXP_BRACKET_RANGE]; + int mExposureGainBracketingModes[EXP_BRACKET_RANGE]; + size_t mExposureBracketingValidEntries; + OMX_BRACKETMODETYPE mExposureBracketMode; + + //Zoom Bracketing + int mZoomBracketingValues[ZOOM_BRACKET_RANGE]; + size_t mZoomBracketingValidEntries; + + static const uint32_t FACE_DETECTION_THRESHOLD; + mutable android::Mutex mFaceDetectionLock; + //Face detection status + bool mFaceDetectionRunning; + bool mFaceDetectionPaused; + bool mFDSwitchAlgoPriority; + + camera_face_t faceDetectionLastOutput[MAX_NUM_FACES_SUPPORTED]; + int faceDetectionNumFacesLastOutput; + int metadataLastAnalogGain; + int metadataLastExposureTime; + + //Geo-tagging + EXIFData mEXIFData; + + //Image post-processing + IPPMode mIPP; + + //jpeg Picture Quality + unsigned int mPictureQuality; + + //thumbnail resolution + unsigned int mThumbWidth, mThumbHeight; + + //thumbnail quality + unsigned int mThumbQuality; + + //variables holding the estimated framerate + float mFPS, mLastFPS; + + //automatically disable AF after a given amount of frames + unsigned int mFocusThreshold; + + //This is needed for the CTS tests. They falsely assume, that during + //smooth zoom the current zoom stage will not change within the + //zoom callback scope, which in a real world situation is not always the + //case. This variable will "simulate" the expected behavior + unsigned int mZoomParameterIdx; + + //current zoom + android::Mutex mZoomLock; + unsigned int mCurrentZoomIdx, mTargetZoomIdx, mPreviousZoomIndx; + bool mZoomUpdating, mZoomUpdate; + int mZoomInc; + bool mReturnZoomStatus; + static const int32_t ZOOM_STEPS []; + + //local copy + OMX_VERSIONTYPE mLocalVersionParam; + + unsigned int mPending3Asettings; + android::Mutex m3ASettingsUpdateLock; + Gen3A_settings mParameters3A; + const char *mPictureFormatFromClient; + + BrightnessMode mGBCE; + BrightnessMode mGLBCE; + + OMX_TI_CONFIG_3A_FACE_PRIORITY mFacePriority; + OMX_TI_CONFIG_3A_REGION_PRIORITY mRegionPriority; + + android::CameraParameters mParams; + CameraProperties::Properties* mCapabilities; + unsigned int mPictureRotation; + bool mWaitingForSnapshot; + bool mCaptureConfigured; + unsigned int mPendingCaptureSettings; + unsigned int mPendingPreviewSettings; + unsigned int mPendingReprocessSettings; + OMX_TI_ANCILLARYDATATYPE* mCaptureAncillaryData; + OMX_TI_WHITEBALANCERESULTTYPE* mWhiteBalanceData; + bool mReprocConfigured; + + //Temporal bracketing management data + bool mBracketingSet; + mutable android::Mutex mBracketingLock; + bool *mBracketingBuffersQueued; + int mBracketingBuffersQueuedCount; + int mLastBracetingBufferIdx; + bool mBracketingEnabled; + bool mZoomBracketingEnabled; + size_t mBracketingRange; + int mCurrentZoomBracketing; + android::CameraParameters mParameters; + +#ifdef CAMERAHAL_TUNA + bool mIternalRecordingHint; +#endif + + bool mOmxInitialized; + OMXCameraAdapterComponentContext mCameraAdapterParameters; + bool mFirstTimeInit; + + ///Semaphores used internally + Utils::Semaphore mInitSem; + Utils::Semaphore mFlushSem; + Utils::Semaphore mUsePreviewDataSem; + Utils::Semaphore mUsePreviewSem; + Utils::Semaphore mUseCaptureSem; + Utils::Semaphore mStartPreviewSem; + Utils::Semaphore mStopPreviewSem; + Utils::Semaphore mStartCaptureSem; + Utils::Semaphore mStopCaptureSem; + Utils::Semaphore mSwitchToLoadedSem; + Utils::Semaphore mSwitchToExecSem; + Utils::Semaphore mStopReprocSem; + Utils::Semaphore mUseReprocessSem; + + mutable android::Mutex mStateSwitchLock; + mutable android::Mutex mIdleStateSwitchLock; + + android::Vector<Utils::Message *> mEventSignalQ; + android::Mutex mEventLock; + + OMX_STATETYPE mComponentState; + + OMX_TI_AUTOCONVERGENCEMODETYPE mAutoConv; + OMX_S32 mManualConv; + bool mVnfEnabled; + bool mVstabEnabled; + + int mSensorOrientation; + int mDeviceOrientation; + int mFaceOrientation; + bool mSensorOverclock; + + //Indicates if we should leave + //OMX_Executing state during + //stop-/startPreview + bool mOMXStateSwitch; + + int mFrameCount; + int mLastFrameCount; + unsigned int mIter; + nsecs_t mLastFPSTime; + android::Mutex mFrameCountMutex; + android::Condition mFirstFrameCondition; + + static const nsecs_t CANCEL_AF_TIMEOUT; + android::Mutex mCancelAFMutex; + android::Condition mCancelAFCond; + + android::Mutex mDoAFMutex; + android::Condition mDoAFCond; + + size_t mSensorIndex; + CodingMode mCodingMode; + + // Time source delta of ducati & system time + OMX_TICKS mTimeSourceDelta; + bool onlyOnce; + + Utils::Semaphore mCaptureSem; + bool mCaptureSignalled; + + OMX_BOOL mUserSetExpLock; + OMX_BOOL mUserSetWbLock; + +#ifdef CAMERAHAL_USE_RAW_IMAGE_SAVING + bool mRawCapture; + bool mYuvCapture; +#endif + + bool mSetFormatDone; + + OMX_TI_DCCDATATYPE mDccData; + android::Mutex mDccDataLock; + + int mMaxZoomSupported; + android::Mutex mImageCaptureLock; + + bool mTunnelDestroyed; + bool mPreviewPortInitialized; + + // Used for allocations that need to be sent to Ducati + MemoryManager mMemMgr; +}; + +} // namespace Camera +} // namespace Ti + +#endif //OMX_CAMERA_ADAPTER_H |