blob: 1a1604c6223da506813691a65e7b82a542a44093 [file] [log] [blame]
** Copyright (c) 2011-2012, 2015, The Linux Foundation. All rights reserved.
** 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
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** See the License for the specific language governing permissions and
** limitations under the License.
#include <utils/threads.h>
//#include <camera/CameraHardwareInterface.h>
#include <hardware/camera.h>
#include <binder/MemoryBase.h>
#include <binder/MemoryHeapBase.h>
//#include <binder/MemoryHeapPmem.h>
#include <utils/threads.h>
#include <cutils/properties.h>
#include <camera/Camera.h>
#include "QCameraParameters.h"
#include <system/window.h>
#include <system/camera.h>
#include <hardware/camera.h>
#include <gralloc_priv.h>
#include <QComOMXMetadata.h>
extern "C" {
#include <linux/msm_ion.h>
#include <mm_camera_interface2.h>
#include "mm_omx_jpeg_encoder.h"
} //extern C
#include "QCameraHWI_Mem.h"
#include "QCameraStream.h"
#include "QCamera_Intf.h"
#include "hdr/include/morpho_noise_reduction_ext.h"
//Error codes
#define NOT_FOUND -1
#define MAX_ZOOM_RATIOS 62
#ifdef Q12
#undef Q12
#define Q12 4096
#define HFR_TBL_MAX_SIZE 2
struct str_map {
const char *const desc;
int val;
struct preview_format_info_t {
int Hal_format;
cam_format_t mm_cam_format;
cam_pad_format_t padding;
int num_planar;
typedef enum {
CAMERA_STATE_SNAP_CMD_ACKED, /*10 - snapshot comd acked, snapshot not done yet*/
/*Add any new state above*/
} HAL_camera_state_type_t;
enum {
typedef enum {
/*8 bits mask*/
} HAL_cam_dump_frm_type_t;
typedef enum {
/*add new entry before and update the max entry*/
} qQamera_mode_t;
typedef struct {
int buffer_count;
buffer_handle_t *buffer_handle[MM_CAMERA_MAX_NUM_FRAMES];
struct private_handle_t *private_buffer_handle[MM_CAMERA_MAX_NUM_FRAMES];
uint32_t addr_offset[MM_CAMERA_MAX_NUM_FRAMES];
uint8_t local_flag[MM_CAMERA_MAX_NUM_FRAMES];
camera_memory_t *camera_memory[MM_CAMERA_MAX_NUM_FRAMES];
int main_ion_fd[MM_CAMERA_MAX_NUM_FRAMES];
struct ion_fd_data ion_info_fd[MM_CAMERA_MAX_NUM_FRAMES];
} QCameraHalMemory_t;
typedef struct {
int buffer_count;
uint32_t size;
uint32_t y_offset;
uint32_t cbcr_offset;
int local_flag[MM_CAMERA_MAX_NUM_FRAMES];
camera_memory_t* camera_memory[MM_CAMERA_MAX_NUM_FRAMES];
camera_memory_t* metadata_memory[MM_CAMERA_MAX_NUM_FRAMES];
int main_ion_fd[MM_CAMERA_MAX_NUM_FRAMES];
struct ion_allocation_data alloc[MM_CAMERA_MAX_NUM_FRAMES];
struct ion_fd_data ion_info_fd[MM_CAMERA_MAX_NUM_FRAMES];
} QCameraHalHeap_t;
typedef struct {
camera_memory_t* camera_memory[3];
int main_ion_fd[3];
struct ion_allocation_data alloc[3];
struct ion_fd_data ion_info_fd[3];
int fd[3];
int size;
} QCameraStatHeap_t;
typedef struct {
int32_t msg_type;
int32_t ext1;
int32_t ext2;
void *cookie;
} argm_notify_t;
typedef struct {
int32_t msg_type;
camera_memory_t *data;
unsigned int index;
camera_frame_metadata_t *metadata;
void *cookie;
} argm_data_cb_t;
typedef struct {
camera_notify_callback notifyCb;
camera_data_callback dataCb;
argm_notify_t argm_notify;
argm_data_cb_t argm_data_cb;
} app_notify_cb_t;
/* camera_area_t
* rectangle with weight to store the focus and metering areas.
* x1, y1, x2, y2: from -1000 to 1000
* weight: 0 to 1000
typedef struct {
int x1, y1, x2, y2;
int weight;
} camera_area_t;
//EXIF globals
static const char ExifAsciiPrefix[] = { 0x41, 0x53, 0x43, 0x49, 0x49, 0x0, 0x0, 0x0 }; // "ASCII\0\0\0"
static const char ExifUndefinedPrefix[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; // "\0\0\0\0\0\0\0\0"
//EXIF detfines
#define EXIF_ASCII_PREFIX_SIZE 8 //(sizeof(ExifAsciiPrefix))
typedef struct{
//GPS tags
rat_t latitude[3];
rat_t longitude[3];
char lonRef[2];
char latRef[2];
rat_t altitude;
rat_t gpsTimeStamp[3];
char gpsDateStamp[20];
//Other tags
char dateTime[20];
char subsecTime[7];
rat_t focalLength;
rat_t f_number;
uint16_t flashMode;
uint16_t isoSpeed;
rat_t exposure_time;
bool mAltitude;
bool mLongitude;
bool mLatitude;
bool mTimeStamp;
bool mGpsProcess;
int mAltitude_ref;
long mGPSTimestamp;
int mWbMode;
char make[20];
char model[20];
} exif_values_t;
namespace android {
class QCameraStream;
class QCameraHardwareInterface : public virtual RefBase {
QCameraHardwareInterface(int cameraId, int mode);
/** Set the ANativeWindow to which preview frames are sent */
int setPreviewWindow(preview_stream_ops_t* window);
/** Set the notification and data callbacks */
void setCallbacks(camera_notify_callback notify_cb,
camera_data_callback data_cb,
camera_data_timestamp_callback data_cb_timestamp,
camera_request_memory get_memory,
void *user);
* The following three functions all take a msg_type, which is a bitmask of
* the messages defined in include/ui/Camera.h
* Enable a message, or set of messages.
void enableMsgType(int32_t msg_type);
* Disable a message, or a set of messages.
* Once received a call to disableMsgType(CAMERA_MSG_VIDEO_FRAME), camera
* HAL should not rely on its client to call releaseRecordingFrame() to
* release video recording frames sent out by the cameral HAL before and
* after the disableMsgType(CAMERA_MSG_VIDEO_FRAME) call. Camera HAL
* clients must not modify/access any video recording frame after calling
void disableMsgType(int32_t msg_type);
* Query whether a message, or a set of messages, is enabled. Note that
* this is operates as an AND, if any of the messages queried are off, this
* will return false.
int msgTypeEnabled(int32_t msg_type);
* Start preview mode.
int startPreview();
int startPreview2();
* Stop a previously started preview.
void stopPreview();
* Returns true if preview is enabled.
int previewEnabled();
* Request the camera HAL to store meta data or real YUV data in the video
* buffers sent out via CAMERA_MSG_VIDEO_FRAME for a recording session. If
* it is not called, the default camera HAL behavior is to store real YUV
* data in the video buffers.
* This method should be called before startRecording() in order to be
* effective.
* If meta data is stored in the video buffers, it is up to the receiver of
* the video buffers to interpret the contents and to find the actual frame
* data with the help of the meta data in the buffer. How this is done is
* outside of the scope of this method.
* Some camera HALs may not support storing meta data in the video buffers,
* but all camera HALs should support storing real YUV data in the video
* buffers. If the camera HAL does not support storing the meta data in the
* video buffers when it is requested to do do, INVALID_OPERATION must be
* returned. It is very useful for the camera HAL to pass meta data rather
* than the actual frame data directly to the video encoder, since the
* amount of the uncompressed frame data can be very large if video size is
* large.
* @param enable if true to instruct the camera HAL to store
* meta data in the video buffers; false to instruct
* the camera HAL to store real YUV data in the video
* buffers.
* @return OK on success.
int storeMetaDataInBuffers(int enable);
* Start record mode. When a record image is available, a
* CAMERA_MSG_VIDEO_FRAME message is sent with the corresponding
* frame. Every record frame must be released by a camera HAL client via
* releaseRecordingFrame() before the client calls
* disableMsgType(CAMERA_MSG_VIDEO_FRAME). After the client calls
* disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is the camera HAL's
* responsibility to manage the life-cycle of the video recording frames,
* and the client must not modify/access any video recording frames.
int startRecording();
* Stop a previously started recording.
void stopRecording();
* Returns true if recording is enabled.
int recordingEnabled();
* Release a record frame previously returned by CAMERA_MSG_VIDEO_FRAME.
* It is camera HAL client's responsibility to release video recording
* frames sent out by the camera HAL before the camera HAL receives a call
* to disableMsgType(CAMERA_MSG_VIDEO_FRAME). After it receives the call to
* disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is the camera HAL's
* responsibility to manage the life-cycle of the video recording frames.
void releaseRecordingFrame(const void *opaque);
* Start auto focus, the notification callback routine is called with
* CAMERA_MSG_FOCUS once when focusing is complete. autoFocus() will be
* called again if another auto focus is needed.
int autoFocus();
* Cancels auto-focus function. If the auto-focus is still in progress,
* this function will cancel it. Whether the auto-focus is in progress or
* not, this function will return the focus position to the default. If
* the camera does not support auto-focus, this is a no-op.
int cancelAutoFocus();
* Take a picture.
int takePicture();
* Cancel a picture that was started with takePicture. Calling this method
* when no picture is being taken is a no-op.
int cancelPicture();
* Set the camera parameters. This returns BAD_VALUE if any parameter is
* invalid or not supported.
int setParameters(const char *parms);
//status_t setParameters(const QCameraParameters& params);
/** Retrieve the camera parameters. The buffer returned by the camera HAL
must be returned back to it with put_parameters, if put_parameters
is not NULL.
int getParameters(char **parms);
/** The camera HAL uses its own memory to pass us the parameters when we
call get_parameters. Use this function to return the memory back to
the camera HAL, if put_parameters is not NULL. If put_parameters
is NULL, then you have to use free() to release the memory.
void putParameters(char *);
* Send command to camera driver.
int sendCommand(int32_t cmd, int32_t arg1, int32_t arg2);
* Release the hardware resources owned by this object. Note that this is
* *not* done in the destructor.
void release();
* Dump state of the camera hardware
int dump(int fd);
//virtual sp<IMemoryHeap> getPreviewHeap() const;
//virtual sp<IMemoryHeap> getRawHeap() const;
status_t takeLiveSnapshot();
status_t takeFullSizeLiveshot();
bool canTakeFullSizeLiveshot();
//virtual status_t getBufferInfo( sp<IMemory>& Frame,
//size_t *alignedSize);
void getPictureSize(int *picture_width, int *picture_height) const;
void getPreviewSize(int *preview_width, int *preview_height) const;
cam_format_t getPreviewFormat() const;
cam_pad_format_t getPreviewPadding() const;
//bool useOverlay(void);
//virtual status_t setOverlay(const sp<Overlay> &overlay);
void processEvent(mm_camera_event_t *);
int getJpegQuality() const;
int getNumOfSnapshots(void) const;
int getThumbSizesFromAspectRatio(uint32_t aspect_ratio,
int *picture_width,
int *picture_height);
bool isRawSnapshot();
bool mShutterSoundPlayed;
void dumpFrameToFile(struct msm_frame*, HAL_cam_dump_frm_type_t);
static QCameraHardwareInterface *createInstance(int, int);
status_t setZSLBurstLookBack(const QCameraParameters& params);
status_t setZSLBurstInterval(const QCameraParameters& params);
int getZSLBurstInterval(void);
int getZSLQueueDepth(void) const;
int getZSLBackLookCount(void) const;
int initHeapMem(QCameraHalHeap_t *heap, int num_of_buf, int pmem_type,
int frame_len, int cbcr_off, int y_off, mm_cameara_stream_buf_t *StreamBuf,
mm_camera_buf_def_t *buf_def, uint8_t num_planes, uint32_t *planes);
int releaseHeapMem( QCameraHalHeap_t *heap);
status_t sendMappingBuf(int ext_mode, int idx, int fd, uint32_t size,
int cameraid, mm_camera_socket_msg_type msg_type);
status_t sendUnMappingBuf(int ext_mode, int idx, int cameraid,
mm_camera_socket_msg_type msg_type);
int allocate_ion_memory(QCameraHalHeap_t *p_camera_memory, int cnt,
int ion_type);
int deallocate_ion_memory(QCameraHalHeap_t *p_camera_memory, int cnt);
int allocate_ion_memory(QCameraStatHeap_t *p_camera_memory, int cnt,
int ion_type);
int deallocate_ion_memory(QCameraStatHeap_t *p_camera_memory, int cnt);
int cache_ops(int ion_fd, struct ion_flush_data *cache_inv_data, int type);
void dumpFrameToFile(const void * data, uint32_t size, char* name,
char* ext, int index);
preview_format_info_t getPreviewFormatInfo( );
bool isCameraReady();
int16_t zoomRatios[MAX_ZOOM_RATIOS];
struct camera_size_type default_preview_sizes[PREVIEW_TBL_MAX_SIZE];
struct camera_size_type default_video_sizes[VIDEO_TBL_MAX_SIZE];
struct camera_size_type default_hfr_sizes[HFR_TBL_MAX_SIZE];
struct camera_size_type default_thumbnail_sizes[THUMB_TBL_MAX_SIZE];
unsigned int preview_sizes_count;
unsigned int video_sizes_count;
unsigned int thumbnail_sizes_count;
unsigned int hfr_sizes_count;
bool mUseOverlay;
void loadTables();
void initDefaultParameters();
bool getMaxPictureDimension(mm_camera_dimension_t *dim);
status_t updateFocusDistances();
bool native_set_parms(mm_camera_parm_type_t type, uint16_t length, void *value);
bool native_set_parms( mm_camera_parm_type_t type, uint16_t length, void *value, int *result);
void hasAutoFocusSupport();
void debugShowPreviewFPS() const;
//void prepareSnapshotAndWait();
bool isPreviewRunning();
bool isRecordingRunning();
bool isSnapshotRunning();
void processChannelEvent(mm_camera_ch_event_t *, app_notify_cb_t *);
void processPreviewChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *);
void processRecordChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *);
void processSnapshotChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *);
void processCtrlEvent(mm_camera_ctrl_event_t *, app_notify_cb_t *);
void processStatsEvent(mm_camera_stats_event_t *, app_notify_cb_t *);
void processInfoEvent(mm_camera_info_event_t *event, app_notify_cb_t *);
void processprepareSnapshotEvent(cam_ctrl_status_t *);
void roiEvent(fd_roi_t roi, app_notify_cb_t *);
void zoomEvent(cam_ctrl_status_t *status, app_notify_cb_t *);
void autofocusevent(cam_ctrl_status_t *status, app_notify_cb_t *);
void handleZoomEventForPreview(app_notify_cb_t *);
void handleZoomEventForSnapshot(void);
status_t autoFocusEvent(cam_ctrl_status_t *, app_notify_cb_t *);
status_t autoFocusMoveEvent(cam_ctrl_status_t *, app_notify_cb_t *);
void filterPictureSizes();
bool supportsSceneDetection();
bool supportsSelectableZoneAf();
bool supportsFaceDetection();
bool supportsRedEyeReduction();
bool preview_parm_config (cam_ctrl_dimension_t* dim,QCameraParameters& parm);
void stopPreviewInternal();
void stopRecordingInternal();
//void stopPreviewZSL();
status_t cancelPictureInternal();
//status_t startPreviewZSL();
void pausePreviewForSnapshot();
void pausePreviewForZSL();
void pausePreviewForVideo();
void prepareVideoPicture(bool disable);
status_t resumePreviewAfterSnapshot();
status_t runFaceDetection();
status_t setParameters(const QCameraParameters& params);
QCameraParameters& getParameters() ;
bool getFlashCondition(void);
status_t setCameraMode(const QCameraParameters& params);
status_t setPictureSizeTable(void);
status_t setPreviewSizeTable(void);
status_t setVideoSizeTable(void);
status_t setPreviewSize(const QCameraParameters& params);
status_t setJpegThumbnailSize(const QCameraParameters& params);
status_t setPreviewFpsRange(const QCameraParameters& params);
status_t setPreviewFrameRate(const QCameraParameters& params);
status_t setPreviewFrameRateMode(const QCameraParameters& params);
status_t setVideoSize(const QCameraParameters& params);
status_t setPictureSize(const QCameraParameters& params);
status_t setJpegQuality(const QCameraParameters& params);
status_t setNumOfSnapshot();
status_t setJpegRotation(int isZSL);
int getJpegRotation(void);
int getISOSpeedValue();
status_t setAntibanding(const QCameraParameters& params);
status_t setEffect(const QCameraParameters& params);
status_t setExposureCompensation(const QCameraParameters &params);
status_t setAutoExposure(const QCameraParameters& params);
status_t setWhiteBalance(const QCameraParameters& params);
status_t setFlash(const QCameraParameters& params);
status_t setGpsLocation(const QCameraParameters& params);
status_t setRotation(const QCameraParameters& params);
status_t setZoom(const QCameraParameters& params);
status_t setFocusMode(const QCameraParameters& params);
status_t setBrightness(const QCameraParameters& params);
status_t setSkinToneEnhancement(const QCameraParameters& params);
status_t setOrientation(const QCameraParameters& params);
status_t setLensshadeValue(const QCameraParameters& params);
status_t setMCEValue(const QCameraParameters& params);
status_t setISOValue(const QCameraParameters& params);
status_t setPictureFormat(const QCameraParameters& params);
status_t setSharpness(const QCameraParameters& params);
status_t setContrast(const QCameraParameters& params);
status_t setSaturation(const QCameraParameters& params);
status_t setWaveletDenoise(const QCameraParameters& params);
status_t setSceneMode(const QCameraParameters& params);
status_t setContinuousAf(const QCameraParameters& params);
status_t setFaceDetection(const char *str);
status_t setSceneDetect(const QCameraParameters& params);
status_t setStrTextures(const QCameraParameters& params);
status_t setPreviewFormat(const QCameraParameters& params);
status_t setSelectableZoneAf(const QCameraParameters& params);
status_t setOverlayFormats(const QCameraParameters& params);
status_t setHighFrameRate(const QCameraParameters& params);
status_t setRedeyeReduction(const QCameraParameters& params);
status_t setAEBracket(const QCameraParameters& params);
status_t setFaceDetect(const QCameraParameters& params);
status_t setDenoise(const QCameraParameters& params);
status_t setAecAwbLock(const QCameraParameters & params);
status_t setHistogram(int histogram_en);
status_t setRecordingHint(const QCameraParameters& params);
status_t setRecordingHintValue(const int32_t value);
status_t setFocusAreas(const QCameraParameters& params);
status_t setMeteringAreas(const QCameraParameters& params);
status_t setFullLiveshot(void);
status_t setDISMode(void);
status_t setCaptureBurstExp(void);
status_t setPowerMode(const QCameraParameters& params);
void takePicturePrepareHardware( );
status_t setNoDisplayMode(const QCameraParameters& params);
status_t setCAFLockCancel(void);
isp3a_af_mode_t getAutoFocusMode(const QCameraParameters& params);
bool isValidDimension(int w, int h);
String8 create_values_str(const str_map *values, int len);
void setMyMode(int mode);
bool isZSLMode();
bool isWDenoiseEnabled();
void wdenoiseEvent(cam_ctrl_status_t status, void *cookie);
bool isLowPowerCamcorder();
void freePictureTable(void);
void freeVideoSizeTable(void);
int32_t createPreview();
int32_t createRecord();
int32_t createSnapshot();
int getHDRMode();
void addExifTag(exif_tag_id_t tagid, exif_tag_type_t type,
uint32_t count, uint8_t copy, void *data);
void setExifTags();
void initExifData();
void deinitExifData();
void setExifTagsGPS();
exif_tags_info_t* getExifData(){ return mExifData; }
int getExifTableNumEntries() { return mExifTableNumEntries; }
void parseGPSCoordinate(const char *latlonString, rat_t* coord);
bool getHdrInfoAndSetExp( int max_num_frm, int *num_frame, int *exp);
void hdrEvent(cam_ctrl_status_t status, void *cookie);
int mCameraId;
camera_mode_t myMode;
bool mPauseFramedispatch;
QCameraParameters mParameters;
//sp<Overlay> mOverlay;
int32_t mMsgEnabled;
camera_notify_callback mNotifyCb;
camera_data_callback mDataCb;
camera_data_timestamp_callback mDataCbTimestamp;
camera_request_memory mGetMemory;
void *mCallbackCookie;
sp<AshmemPool> mMetaDataHeap;
mutable Mutex mLock;
//mutable Mutex eventLock;
Mutex mCallbackLock;
Mutex mPreviewMemoryLock;
Mutex mRecordingMemoryLock;
Mutex mAutofocusLock;
Mutex mMetaDataWaitLock;
Mutex mRecordFrameLock;
Mutex mRecordLock;
Condition mRecordWait;
pthread_mutex_t mAsyncCmdMutex;
pthread_cond_t mAsyncCmdWait;
QCameraStream *mStreamDisplay;
QCameraStream *mStreamRecord;
QCameraStream *mStreamSnap;
QCameraStream *mStreamLiveSnap;
cam_ctrl_dimension_t mDimension;
int mPreviewWidth, mPreviewHeight;
int mVideoWidth, mVideoHeight;
int thumbnailWidth, thumbnailHeight;
int maxSnapshotWidth, maxSnapshotHeight;
int mPreviewFormat;
int mFps;
int mDebugFps;
int mBrightness;
int mContrast;
int mBestShotMode;
int mEffects;
int mSkinToneEnhancement;
int mDenoiseValue;
int mHJR;
int mRotation;
int mJpegQuality;
int mThumbnailQuality;
int mTargetSmoothZoom;
int mSmoothZoomStep;
int mMaxZoom;
int mCurrentZoom;
int mSupportedPictureSizesCount;
int mFaceDetectOn;
int mDumpFrmCnt;
int mDumpSkipCnt;
int mFocusMode;
unsigned int mPictureSizeCount;
unsigned int mPreviewSizeCount;
int mPowerMode;
unsigned int mVideoSizeCount;
bool mAutoFocusRunning;
bool mNeedToUnlockCaf;
bool mMultiTouch;
bool mHasAutoFocusSupport;
bool mInitialized;
bool mDisEnabled;
bool strTexturesOn;
bool mIs3DModeOn;
bool mSmoothZoomRunning;
bool mPreparingSnapshot;
bool mParamStringInitialized;
bool mZoomSupported;
bool mSendMetaData;
bool mFullLiveshotEnabled;
bool mRecordingHint;
bool mAppRecordingHint;
bool mStartRecording;
bool mReleasedRecordingFrame;
bool mStateLiveshot;
int mHdrMode;
int mSnapshotFormat;
int mZslInterval;
bool mRestartPreview;
bool isCameraOpen;
led_mode_t mLedStatusForZsl;
bool mFlashCond;
/*for histogram*/
int mStatsOn;
int mCurrentHisto;
bool mSendData;
sp<AshmemPool> mStatHeap;
camera_memory_t *mStatsMapped[3];
QCameraStatHeap_t mHistServer;
int32_t mStatSize;
bool mZslLookBackMode;
int mZslLookBackValue;
int mHFRLevel;
bool mZslEmptyQueueFlag;
String8 mEffectValues;
String8 mIsoValues;
String8 mSceneModeValues;
String8 mSceneDetectValues;
String8 mFocusModeValues;
String8 mSelectableZoneAfValues;
String8 mAutoExposureValues;
String8 mWhitebalanceValues;
String8 mAntibandingValues;
String8 mFrameRateModeValues;
String8 mTouchAfAecValues;
String8 mPreviewSizeValues;
String8 mPictureSizeValues;
String8 mVideoSizeValues;
String8 mFlashValues;
String8 mLensShadeValues;
String8 mMceValues;
String8 mHistogramValues;
String8 mSkinToneEnhancementValues;
String8 mPictureFormatValues;
String8 mDenoiseValues;
String8 mZoomRatioValues;
String8 mPreviewFrameRateValues;
String8 mPreviewFormatValues;
String8 mFaceDetectionValues;
String8 mHfrValues;
String8 mHfrSizeValues;
String8 mRedeyeReductionValues;
String8 denoise_value;
String8 mFpsRangesSupportedValues;
String8 mZslValues;
String8 mFocusDistance;
friend class QCameraStream;
friend class QCameraStream_record;
friend class QCameraStream_preview;
friend class QCameraStream_Snapshot;
camera_size_type* mPictureSizes;
camera_size_type* mPreviewSizes;
camera_size_type* mVideoSizes;
const camera_size_type * mPictureSizesPtr;
HAL_camera_state_type_t mCameraState;
void *libdnr;
int (*LINK_morpho_DNR_ProcessFrame)(unsigned char* yuvImage, int width, int height, int y_level, int c_level);
/* Temporary - can be removed after Honeycomb*/
#ifdef USE_ION
sp<IonPool> mPostPreviewHeap;
sp<PmemPool> mPostPreviewHeap;
mm_cameara_stream_buf_t mPrevForPostviewBuf;
int mStoreMetaDataInFrame;
preview_stream_ops_t *mPreviewWindow;
Mutex mStateLock;
int mPreviewState;
/*preview memory with display case: memory is allocated and freed via
gralloc */
QCameraHalMemory_t mPreviewMemory;
/*preview memory without display case: memory is allocated
directly by camera */
QCameraHalHeap_t mNoDispPreviewMemory;
QCameraHalHeap_t mSnapshotMemory;
QCameraHalHeap_t mThumbnailMemory;
QCameraHalHeap_t mRecordingMemory;
QCameraHalHeap_t mJpegMemory;
QCameraHalHeap_t mRawMemory;
camera_frame_metadata_t mMetadata;
camera_face_t mFace[MAX_ROI];
preview_format_info_t mPreviewFormatInfo;
friend void liveshot_callback(mm_camera_ch_data_buf_t *frame,void *user_data);
exif_tags_info_t mExifData[MAX_EXIF_TABLE_ENTRIES]; //Exif tags for JPEG encoder
exif_values_t mExifValues; //Exif values in usable format
int mExifTableNumEntries; //NUmber of entries in mExifData
int mNoDisplayMode;
int mIsoValue;
/* Used to show the process state of snapshot_jpeg_cb*/
Mutex mSnapJpegCbLock;
Condition mSnapJpegCbWait;
bool mSnapJpegCbRunning;
bool mSnapCbDisabled;
}; // namespace android