| /* |
| * 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, // 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); |
| 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); |
| |
| 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; |
| |
| public: |
| |
| 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 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 |
