/libcamera/QualcommCameraHardware.h

http://github.com/CyanogenMod/android_device_zte_blade · C Header · 639 lines · 510 code · 88 blank · 41 comment · 6 complexity · 70514aa6bb66706f8211a95d84b3e6d5 MD5 · raw file

  1. /*
  2. ** Copyright 2008, Google Inc.
  3. ** Copyright (c) 2009, Code Aurora Forum. All rights reserved.
  4. ** Copyright (c) 2010, Ricardo Cerqueira
  5. **
  6. ** Licensed under the Apache License, Version 2.0 (the "License");
  7. ** you may not use this file except in compliance with the License.
  8. ** You may obtain a copy of the License at
  9. **
  10. ** http://www.apache.org/licenses/LICENSE-2.0
  11. **
  12. ** Unless required by applicable law or agreed to in writing, software
  13. ** distributed under the License is distributed on an "AS IS" BASIS,
  14. ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15. ** See the License for the specific language governing permissions and
  16. ** limitations under the License.
  17. **
  18. ** NOTICE - (RC)
  19. **
  20. ** All alterations done to this file to add support for the Z71 terminal
  21. ** are intended for use with CyanogenMod. This includes all the support
  22. ** for ov5642, and the reverse engineered bits like ioctls and EXIF
  23. ** referred to below as "Values originally from proprietary headers")
  24. ** Please do not change the EXIF header without asking me first.
  25. */
  26. #ifndef ANDROID_HARDWARE_QUALCOMM_CAMERA_HARDWARE_H
  27. #define ANDROID_HARDWARE_QUALCOMM_CAMERA_HARDWARE_H
  28. #include <camera/CameraHardwareInterface.h>
  29. #include <binder/MemoryBase.h>
  30. #include <binder/MemoryHeapBase.h>
  31. #include <stdint.h>
  32. #include <ui/Overlay.h>
  33. extern "C" {
  34. #include <linux/android_pmem.h>
  35. #include <msm_camera.h>
  36. }
  37. struct str_map {
  38. const char *const desc;
  39. int val;
  40. };
  41. typedef enum {
  42. TARGET_MSM7625,
  43. TARGET_MSM7627,
  44. TARGET_QSD8250,
  45. TARGET_MSM7630,
  46. TARGET_MAX
  47. }targetType;
  48. struct target_map {
  49. const char *targetStr;
  50. targetType targetEnum;
  51. };
  52. struct board_property{
  53. targetType target;
  54. unsigned int previewSizeMask;
  55. };
  56. /* Values originally in proprietary headers */
  57. #define MSM_CAMERA_CONTROL "/dev/msm_camera/control0"
  58. #define TRUE 1
  59. #define FALSE 0
  60. #define CAMERA_MIN_CONTRAST 0
  61. #define CAMERA_MAX_CONTRAST 4
  62. #define CAMERA_MIN_SHARPNESS 0
  63. #define CAMERA_MIN_EXPOSURE_COMPENSATION -2
  64. #define CAMERA_MAX_SHARPNESS 4
  65. #define CAMERA_MIN_SATURATION 0
  66. #define CAMERA_MAX_SATURATION 4
  67. #define CAMERA_MAX_EXPOSURE_COMPENSATION 2
  68. #define CAMERA_DEF_SHARPNESS 2
  69. #define CAMERA_DEF_CONTRAST 2
  70. #define CAMERA_DEF_SATURATION 2
  71. #define CAMERA_DEF_EXPOSURE_COMPENSATION "0"
  72. #define CAMERA_EXPOSURE_COMPENSATION_STEP 1
  73. #define CEILING16(x) (x&0xfffffff0)
  74. #define PAD_TO_WORD(x) ((x&1) ? x+1 : x)
  75. #define JPEG_EVENT_DONE 0
  76. #define CAM_CTRL_SUCCESS 1
  77. #define MINIMUM_FPS 10
  78. #define DEFAULT_FPS 15
  79. #define MAXIMUM_FPS 25
  80. typedef struct {
  81. unsigned int in1_w;
  82. unsigned int in1_h;
  83. unsigned int out1_w;
  84. unsigned int out1_h;
  85. unsigned int in2_w;
  86. unsigned int in2_h;
  87. unsigned int out2_w;
  88. unsigned int out2_h;
  89. uint8_t update_flag;
  90. } common_crop_t;
  91. typedef uint8_t cam_ctrl_type;
  92. typedef struct {
  93. unsigned short video_width;
  94. unsigned short video_height;
  95. unsigned short picture_width;
  96. unsigned short picture_height;
  97. unsigned short display_width;
  98. unsigned short display_height;
  99. unsigned short orig_picture_dx;
  100. unsigned short orig_picture_dy;
  101. unsigned short ui_thumbnail_height;
  102. unsigned short ui_thumbnail_width;
  103. unsigned short thumbnail_width;
  104. unsigned short thumbnail_height;
  105. unsigned short raw_picture_height;
  106. unsigned short raw_picture_width;
  107. unsigned short filler7;
  108. unsigned short filler8;
  109. } cam_ctrl_dimension_t;
  110. typedef struct {
  111. uint32_t timestamp; /* seconds since 1/6/1980 */
  112. double latitude; /* degrees, WGS ellipsoid */
  113. double longitude; /* degrees */
  114. int16_t altitude; /* meters */
  115. } camera_position_type;
  116. typedef uint8_t jpeg_event_t;
  117. typedef enum {
  118. CAMERA_WB_MIN_MINUS_1,
  119. CAMERA_WB_AUTO = 1, /* This list must match aeecamera.h */
  120. CAMERA_WB_CUSTOM,
  121. CAMERA_WB_INCANDESCENT,
  122. CAMERA_WB_FLUORESCENT,
  123. CAMERA_WB_DAYLIGHT,
  124. CAMERA_WB_CLOUDY_DAYLIGHT,
  125. CAMERA_WB_TWILIGHT,
  126. CAMERA_WB_SHADE,
  127. CAMERA_WB_MAX_PLUS_1
  128. } camera_wb_type;
  129. typedef enum {
  130. CAMERA_ANTIBANDING_OFF,
  131. CAMERA_ANTIBANDING_60HZ,
  132. CAMERA_ANTIBANDING_50HZ,
  133. CAMERA_ANTIBANDING_AUTO,
  134. CAMERA_MAX_ANTIBANDING,
  135. } camera_antibanding_type;
  136. typedef enum {
  137. AF_MODE_NORMAL,
  138. AF_MODE_MACRO,
  139. AF_MODE_AUTO,
  140. } isp3a_af_mode_t;
  141. enum {
  142. CAMERA_AEC_FRAME_AVERAGE,
  143. CAMERA_AEC_CENTER_WEIGHTED,
  144. CAMERA_AEC_SPOT_METERING,
  145. };
  146. enum {
  147. LED_MODE_OFF,
  148. LED_MODE_AUTO,
  149. LED_MODE_ON,
  150. };
  151. typedef enum {
  152. CAMERA_ISO_AUTO,
  153. CAMERA_ISO_DEBLUR,
  154. CAMERA_ISO_100,
  155. CAMERA_ISO_200,
  156. CAMERA_ISO_400,
  157. CAMERA_ISO_800,
  158. CAMERA_ISO_1600,
  159. } camera_iso_mode_type;
  160. struct fifo_queue {
  161. int num_of_frames;
  162. int front;
  163. struct fifo_node *node;
  164. pthread_mutex_t mut;
  165. pthread_cond_t wait;
  166. };
  167. struct fifo_node {
  168. struct msm_frame *f;
  169. struct fifo_node *next;
  170. };
  171. void enqueue(struct fifo_queue *queue, struct fifo_node *node) {
  172. struct fifo_node *cur_node=queue->node;
  173. int i;
  174. LOGE("enqueue:%p(%d)\n", node, queue->num_of_frames);
  175. node->next=NULL;
  176. if(queue->num_of_frames==0) {
  177. queue->num_of_frames++;
  178. queue->front=!!queue->num_of_frames;
  179. queue->node=node;
  180. return;
  181. }
  182. queue->num_of_frames++;
  183. queue->front=!!queue->num_of_frames;
  184. for(i=0;i<(queue->num_of_frames-2);++i) {
  185. cur_node=cur_node->next;
  186. assert(!!cur_node);
  187. }
  188. cur_node->next=node;
  189. }
  190. struct fifo_node *dequeue(struct fifo_queue *queue) {
  191. if(queue->num_of_frames==0)
  192. return NULL;
  193. struct fifo_node *node=queue->node;
  194. LOGE("dequeue:%p(%d)\n", node, queue->num_of_frames);
  195. queue->num_of_frames--;
  196. queue->front=!!queue->num_of_frames;
  197. queue->node=queue->node->next;
  198. return node;
  199. }
  200. enum camera_ops {
  201. CAMERA_SET_PARM_ENCODE_ROTATION,
  202. CAMERA_SET_PARM_DIMENSION,
  203. CAMERA_SET_PARM_ZOOM,
  204. CAMERA_SET_PARM_SENSOR_POSITION,
  205. CAMERA_SET_PARM_SHARPNESS,
  206. CAMERA_SET_PARM_LUMA_ADAPTATION,
  207. CAMERA_SET_PARM_CONTRAST,
  208. CAMERA_SET_PARM_EXPOSURE_COMPENSATION,
  209. CAMERA_SET_PARM_BRIGHTNESS,
  210. CAMERA_SET_PARM_FOCUS_RECT,
  211. CAMERA_SET_PARM_HUE,
  212. CAMERA_SET_PARM_SATURATION,
  213. CAMERA_SET_PARM_EXPOSURE,
  214. CAMERA_SET_PARM_AUTO_FOCUS,
  215. CAMERA_SET_PARM_WB,
  216. CAMERA_SET_PARM_EFFECT,
  217. CAMERA_SET_PARM_FPS,
  218. CAMERA_SET_PARM_FLASH,
  219. CAMERA_SET_PARM_NIGHTSHOT_MODE,
  220. CAMERA_SET_PARM_REFLECT,
  221. CAMERA_SET_PARM_PREVIEW_MODE,
  222. CAMERA_SET_PARM_ANTIBANDING,
  223. CAMERA_SET_PARM_RED_EYE_REDUCTION,
  224. CAMERA_SET_PARM_FOCUS_STEP,
  225. CAMERA_SET_PARM_EXPOSURE_METERING,
  226. CAMERA_SET_PARM_AUTO_EXPOSURE_MODE,
  227. CAMERA_SET_PARM_ISO,
  228. CAMERA_SET_PARM_BESTSHOT_MODE,
  229. CAMERA_SET_PARM_PREVIEW_FPS,
  230. CAMERA_SET_PARM_AF_MODE,
  231. CAMERA_SET_PARM_HISTOGRAM,
  232. CAMERA_SET_PARM_FLASH_STATE,
  233. CAMERA_SET_PARM_FRAME_TIMESTAMP,
  234. CAMERA_SET_PARM_STROBE_FLASH,
  235. CAMERA_SET_PARM_FPS_LIST,
  236. CAMERA_SET_PARM_HJR,
  237. CAMERA_SET_PARM_ROLLOFF=37,
  238. CAMERA_STOP_PREVIEW=38,
  239. CAMERA_START_PREVIEW,
  240. CAMERA_START_SNAPSHOT,
  241. CAMERA_START_VIDEO,
  242. CAMERA_STOP_SNAPSHOT=42,
  243. CAMERA_EXIT=43,
  244. CAMERA_STOP_VIDEO,
  245. CAMERA_START_RECORDING,
  246. CAMERA_STOP_RECORDING,
  247. CAMERA_GET_PARM_MAXZOOM,
  248. CAMERA_START_RAW_SNAPSHOT,
  249. CAMERA_SET_PARM_LED_MODE,
  250. CAMERA_GET_PARM_AF_SHARPNESS,
  251. CAMERA_SET_MOTION_ISO,
  252. CAMERA_AUTO_FOCUS_CANCEL,
  253. CAMERA_GET_PARM_FOCUS_STEP,
  254. CAMERA_ENABLE_AFD,
  255. CAMERA_PREPARE_SNAPSHOT,
  256. CAMERA_SET_FPS_MODE,
  257. CAMERA_SET_PARM_SCENE_MODE,
  258. };
  259. typedef enum {
  260. CAMERA_RSP_CB_SUCCESS,
  261. CAMERA_EXIT_CB_DONE,
  262. CAMERA_EXIT_CB_FAILED,
  263. CAMERA_EXIT_CB_DSP_IDLE,
  264. CAMERA_EXIT_CB_DSP_ABORT,
  265. CAMERA_EXIT_CB_ABORT,
  266. CAMERA_EXIT_CB_ERROR,
  267. CAMERA_EVT_CB_FRAME,
  268. CAMERA_EVT_CB_PICTURE,
  269. CAMERA_STATUS_CB,
  270. CAMERA_EXIT_CB_FILE_SIZE_EXCEEDED,
  271. CAMERA_EXIT_CB_BUFFER,
  272. CAMERA_EVT_CB_SNAPSHOT_DONE,
  273. CAMERA_CB_MAX,
  274. } camera_cb_type;
  275. struct cam_frame_start_parms {
  276. unsigned int unknown;
  277. struct msm_frame frame;
  278. struct msm_frame video_frame;
  279. };
  280. typedef unsigned int exif_tag_id_t;
  281. #define EXIF_RATIONAL 5
  282. #define EXIF_ASCII 2
  283. #define EXIF_BYTE 1
  284. typedef struct {
  285. int val;
  286. int otherval;
  287. } rat_t;
  288. typedef union {
  289. char * _ascii; /* At byte 16 relative to exif_tag_entry_t */
  290. rat_t * _rats;
  291. rat_t _rat;
  292. uint8_t _byte;
  293. } exif_tag_data_t;
  294. /* The entire exif_tag_entry_t struct must be 24 bytes in length */
  295. typedef unsigned int exif_tag_type_t;
  296. typedef struct {
  297. exif_tag_type_t type;
  298. uint32_t copy;
  299. uint32_t count;
  300. exif_tag_data_t data;
  301. } exif_tag_entry_t;
  302. typedef struct {
  303. exif_tag_id_t tag_id;
  304. exif_tag_entry_t tag_entry;
  305. } exif_tags_info_t;
  306. /* EXIF tag IDs */
  307. #define EXIFTAGID_GPS_LATITUDE 0x20002
  308. #define EXIFTAGID_GPS_LATITUDE_REF 0x10001
  309. #define EXIFTAGID_GPS_LONGITUDE 0x40004
  310. #define EXIFTAGID_GPS_LONGITUDE_REF 0x30003
  311. #define EXIFTAGID_GPS_ALTITUDE 0x60006
  312. #define EXIFTAGID_GPS_ALTITUDE_REF 0x50005
  313. #define EXIFTAGID_EXIF_CAMERA_MAKER 0x21010F
  314. #define EXIFTAGID_EXIF_CAMERA_MODEL 0x220110
  315. #define EXIFTAGID_EXIF_DATE_TIME_ORIGINAL 0x3A9003
  316. #define EXIFTAGID_EXIF_DATE_TIME 0x3B9004
  317. /* End of values originally in proprietary headers */
  318. namespace android {
  319. class QualcommCameraHardware : public CameraHardwareInterface {
  320. public:
  321. virtual sp<IMemoryHeap> getPreviewHeap() const;
  322. virtual sp<IMemoryHeap> getRawHeap() const;
  323. virtual void setCallbacks(notify_callback notify_cb,
  324. data_callback data_cb,
  325. data_callback_timestamp data_cb_timestamp,
  326. void* user);
  327. virtual void enableMsgType(int32_t msgType);
  328. virtual void disableMsgType(int32_t msgType);
  329. virtual bool msgTypeEnabled(int32_t msgType);
  330. virtual status_t dump(int fd, const Vector<String16>& args) const;
  331. virtual status_t startPreview();
  332. virtual void stopPreview();
  333. virtual bool previewEnabled();
  334. virtual status_t startRecording();
  335. virtual void stopRecording();
  336. virtual bool recordingEnabled();
  337. virtual void releaseRecordingFrame(const sp<IMemory>& mem);
  338. virtual status_t autoFocus();
  339. virtual status_t cancelAutoFocus();
  340. virtual status_t takePicture();
  341. virtual status_t cancelPicture();
  342. virtual status_t setParameters(const CameraParameters& params);
  343. virtual CameraParameters getParameters() const;
  344. virtual status_t sendCommand(int32_t command, int32_t arg1, int32_t arg2);
  345. virtual status_t getBufferInfo( sp<IMemory>& Frame, size_t *alignedSize);
  346. virtual void release();
  347. virtual bool useOverlay();
  348. virtual status_t setOverlay(const sp<Overlay> &overlay);
  349. static sp<CameraHardwareInterface> createInstance();
  350. static sp<QualcommCameraHardware> getInstance();
  351. void receivePreviewFrame(struct msm_frame *frame);
  352. void receiveRecordingFrame(struct msm_frame *frame);
  353. void receiveJpegPicture(void);
  354. void jpeg_set_location();
  355. void receiveJpegPictureFragment(uint8_t *buf, uint32_t size);
  356. void notifyShutter(common_crop_t *crop);
  357. void receive_camframetimeout();
  358. private:
  359. QualcommCameraHardware();
  360. virtual ~QualcommCameraHardware();
  361. status_t startPreviewInternal();
  362. void stopPreviewInternal();
  363. friend void *auto_focus_thread(void *user);
  364. void runAutoFocus();
  365. status_t cancelAutoFocusInternal();
  366. bool native_set_dimension (int camfd);
  367. bool native_jpeg_encode (void);
  368. bool native_set_parm(cam_ctrl_type type, uint16_t length, void *value);
  369. bool native_zoom_image(int fd, int srcOffset, int dstOffset, common_crop_t *crop);
  370. static wp<QualcommCameraHardware> singleton;
  371. /* These constants reflect the number of buffers that libmmcamera requires
  372. for preview and raw, and need to be updated when libmmcamera
  373. changes.
  374. */
  375. static const int kPreviewBufferCount = NUM_PREVIEW_BUFFERS;
  376. static const int kRawBufferCount = 1;
  377. static const int kJpegBufferCount = 1;
  378. int jpegPadding;
  379. CameraParameters mParameters;
  380. unsigned int frame_size;
  381. bool mCameraRunning;
  382. Mutex mCameraRunningLock;
  383. bool mPreviewInitialized;
  384. // This class represents a heap which maintains several contiguous
  385. // buffers. The heap may be backed by pmem (when pmem_pool contains
  386. // the name of a /dev/pmem* file), or by ashmem (when pmem_pool == NULL).
  387. struct MemPool : public RefBase {
  388. MemPool(int buffer_size, int num_buffers,
  389. int frame_size,
  390. const char *name);
  391. virtual ~MemPool() = 0;
  392. void completeInitialization();
  393. bool initialized() const {
  394. return mHeap != NULL && mHeap->base() != MAP_FAILED;
  395. }
  396. virtual status_t dump(int fd, const Vector<String16>& args) const;
  397. int mBufferSize;
  398. int mAlignedBufferSize;
  399. int mNumBuffers;
  400. int mFrameSize;
  401. sp<MemoryHeapBase> mHeap;
  402. sp<MemoryBase> *mBuffers;
  403. const char *mName;
  404. };
  405. struct AshmemPool : public MemPool {
  406. AshmemPool(int buffer_size, int num_buffers,
  407. int frame_size,
  408. const char *name);
  409. };
  410. struct PmemPool : public MemPool {
  411. PmemPool(const char *pmem_pool,
  412. int control_camera_fd, int flags, int pmem_type,
  413. int buffer_size, int num_buffers,
  414. int frame_size,
  415. const char *name);
  416. virtual ~PmemPool();
  417. int mFd;
  418. int mPmemType;
  419. int mCameraControlFd;
  420. uint32_t mAlignedSize;
  421. struct pmem_region mSize;
  422. };
  423. sp<PmemPool> mPreviewHeap;
  424. sp<PmemPool> mRecordHeap;
  425. sp<PmemPool> mThumbnailHeap;
  426. sp<PmemPool> mRawHeap;
  427. sp<PmemPool> mDisplayHeap;
  428. sp<AshmemPool> mJpegHeap;
  429. sp<PmemPool> mRawSnapShotPmemHeap;
  430. sp<PmemPool> mPostViewHeap;
  431. bool startCamera();
  432. bool initPreview();
  433. bool initRecord();
  434. void deinitPreview();
  435. bool initRaw(bool initJpegHeap);
  436. bool initRawSnapshot();
  437. void deinitRaw();
  438. void deinitRawSnapshot();
  439. bool mFrameThreadRunning;
  440. Mutex mFrameThreadWaitLock;
  441. Condition mFrameThreadWait;
  442. friend void *frame_thread(void *user);
  443. void runFrameThread(void *data);
  444. //720p recording video thread
  445. bool mVideoThreadExit;
  446. bool mVideoThreadRunning;
  447. Mutex mVideoThreadWaitLock;
  448. Condition mVideoThreadWait;
  449. friend void *video_thread(void *user);
  450. void runVideoThread(void *data);
  451. bool mShutterPending;
  452. Mutex mShutterLock;
  453. bool mSnapshotThreadRunning;
  454. Mutex mSnapshotThreadWaitLock;
  455. Condition mSnapshotThreadWait;
  456. friend void *snapshot_thread(void *user);
  457. void runSnapshotThread(void *data);
  458. Mutex mRawPictureHeapLock;
  459. bool mJpegThreadRunning;
  460. Mutex mJpegThreadWaitLock;
  461. Condition mJpegThreadWait;
  462. bool mInSnapshotMode;
  463. Mutex mInSnapshotModeWaitLock;
  464. Condition mInSnapshotModeWait;
  465. void debugShowPreviewFPS() const;
  466. void debugShowVideoFPS() const;
  467. int mSnapshotFormat;
  468. void filterPictureSizes();
  469. void filterPreviewSizes();
  470. void storeTargetType();
  471. void initDefaultParameters();
  472. void findSensorType();
  473. status_t setPreviewSize(const CameraParameters& params);
  474. status_t setPreviewFrameRate(const CameraParameters& params);
  475. status_t setPictureSize(const CameraParameters& params);
  476. status_t setJpegQuality(const CameraParameters& params);
  477. status_t setAntibanding(const CameraParameters& params);
  478. status_t setEffect(const CameraParameters& params);
  479. status_t setAutoExposure(const CameraParameters& params);
  480. status_t setWhiteBalance(const CameraParameters& params);
  481. status_t setFlash(const CameraParameters& params);
  482. status_t setGpsLocation(const CameraParameters& params);
  483. status_t setRotation(const CameraParameters& params);
  484. status_t setZoom(const CameraParameters& params);
  485. status_t setFocusMode(const CameraParameters& params);
  486. status_t setBrightness(const CameraParameters& params);
  487. status_t setExposureCompensation(const CameraParameters& params);
  488. status_t setOrientation(const CameraParameters& params);
  489. status_t setLensshadeValue(const CameraParameters& params);
  490. status_t setISOValue(const CameraParameters& params);
  491. status_t setPictureFormat(const CameraParameters& params);
  492. status_t setSharpness(const CameraParameters& params);
  493. status_t setContrast(const CameraParameters& params);
  494. status_t setSaturation(const CameraParameters& params);
  495. void setGpsParameters();
  496. void storePreviewFrameForPostview();
  497. bool isValidDimension(int w, int h);
  498. Mutex mLock;
  499. Mutex mCamframeTimeoutLock;
  500. bool camframe_timeout_flag;
  501. bool mReleasedRecordingFrame;
  502. void receiveRawPicture(void);
  503. void receiveRawSnapshot(void);
  504. Mutex mCallbackLock;
  505. Mutex mOverlayLock;
  506. Mutex mRecordLock;
  507. Mutex mRecordFrameLock;
  508. Condition mRecordWait;
  509. Condition mStateWait;
  510. /* mJpegSize keeps track of the size of the accumulated JPEG. We clear it
  511. when we are about to take a picture, so at any time it contains either
  512. zero, or the size of the last JPEG picture taken.
  513. */
  514. uint32_t mJpegSize;
  515. unsigned int mPreviewFrameSize;
  516. unsigned int mRecordFrameSize;
  517. int mRawSize;
  518. int mJpegMaxSize;
  519. #if DLOPEN_LIBMMCAMERA
  520. void *libmmcamera;
  521. #endif
  522. int mCameraControlFd;
  523. struct msm_camsensor_info mSensorInfo;
  524. cam_ctrl_dimension_t mDimension;
  525. bool mAutoFocusThreadRunning;
  526. Mutex mAutoFocusThreadLock;
  527. int mAutoFocusFd;
  528. Mutex mAfLock;
  529. pthread_t mFrameThread;
  530. pthread_t mVideoThread;
  531. pthread_t mSnapshotThread;
  532. common_crop_t mCrop;
  533. bool mInitialized;
  534. int mBrightness;
  535. int mHJR;
  536. struct msm_frame frames[kPreviewBufferCount];
  537. struct msm_frame *recordframes;
  538. bool mInPreviewCallback;
  539. bool mUseOverlay;
  540. sp<Overlay> mOverlay;
  541. int32_t mMsgEnabled; // camera msg to be handled
  542. notify_callback mNotifyCallback;
  543. data_callback mDataCallback;
  544. data_callback_timestamp mDataCallbackTimestamp;
  545. void *mCallbackCookie; // same for all callbacks
  546. int mDebugFps;
  547. int kPreviewBufferCountActual;
  548. int previewWidth, previewHeight;
  549. };
  550. }; // namespace android
  551. #endif