1236 lines
45 KiB
C++
1236 lines
45 KiB
C++
/*
|
|
* 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
|
|
int mPictureQuality;
|
|
|
|
//thumbnail resolution
|
|
int mThumbWidth, mThumbHeight;
|
|
|
|
//thumbnail quality
|
|
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;
|
|
int 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
|