QCameraHWI.h revision 67ca9853f2955ad66f5a956355edd8a4a01de8fe 
1/*
2** Copyright (c) 2011-2012 Code Aurora Forum. All rights reserved.
3**
4** Licensed under the Apache License, Version 2.0 (the "License");
5** you may not use this file except in compliance with the License.
6** You may obtain a copy of the License at
7**
8**     http://www.apache.org/licenses/LICENSE-2.0
9**
10** Unless required by applicable law or agreed to in writing, software
11** distributed under the License is distributed on an "AS IS" BASIS,
12** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13** See the License for the specific language governing permissions and
14** limitations under the License.
15*/
16
17#ifndef ANDROID_HARDWARE_QCAMERA_HARDWARE_INTERFACE_H
18#define ANDROID_HARDWARE_QCAMERA_HARDWARE_INTERFACE_H
19
20
21#include <utils/threads.h>
22//#include <camera/CameraHardwareInterface.h>
23#include <hardware/camera.h>
24#include <binder/MemoryBase.h>
25#include <binder/MemoryHeapBase.h>
26//#include <binder/MemoryHeapPmem.h>
27#include <utils/threads.h>
28#include <cutils/properties.h>
29#include <camera/Camera.h>
30#include "QCameraParameters.h"
31#include <system/window.h>
32#include <system/camera.h>
33#include <hardware/camera.h>
34#include <gralloc_priv.h>
35#include <QComOMXMetadata.h>
36
37extern "C" {
38#include <linux/android_pmem.h>
39#include <linux/ion.h>
40#include <mm_camera_interface2.h>
41#include "mm_omx_jpeg_encoder.h"
42} //extern C
43
44#include "QCameraHWI_Mem.h"
45#include "QCameraStream.h"
46#include "QCamera_Intf.h"
47
48//Error codes
49#define  NOT_FOUND -1
50#define MAX_ZOOM_RATIOS 62
51
52#ifdef Q12
53#undef Q12
54#endif
55
56#define Q12 4096
57#define QCAMERA_PARM_ENABLE   1
58#define QCAMERA_PARM_DISABLE  0
59#define PREVIEW_TBL_MAX_SIZE  14
60#define VIDEO_TBL_MAX_SIZE    14
61#define THUMB_TBL_MAX_SIZE    16
62#define HFR_TBL_MAX_SIZE      2
63
64struct str_map {
65    const char *const desc;
66    int val;
67};
68
69struct preview_format_info_t {
70   int Hal_format;
71   cam_format_t mm_cam_format;
72   cam_pad_format_t padding;
73   int num_planar;
74};
75
76typedef enum {
77  CAMERA_STATE_UNINITED,
78  CAMERA_STATE_READY,
79  CAMERA_STATE_PREVIEW_START_CMD_SENT,
80  CAMERA_STATE_PREVIEW_STOP_CMD_SENT,
81  CAMERA_STATE_PREVIEW,
82  CAMERA_STATE_RECORD_START_CMD_SENT,  /*5*/
83  CAMERA_STATE_RECORD_STOP_CMD_SENT,
84  CAMERA_STATE_RECORD,
85  CAMERA_STATE_SNAP_START_CMD_SENT,
86  CAMERA_STATE_SNAP_STOP_CMD_SENT,
87  CAMERA_STATE_SNAP_CMD_ACKED,  /*10 - snapshot comd acked, snapshot not done yet*/
88  CAMERA_STATE_ZSL_START_CMD_SENT,
89  CAMERA_STATE_ZSL,
90  CAMERA_STATE_AF_START_CMD_SENT,
91  CAMERA_STATE_AF_STOP_CMD_SENT,
92  CAMERA_STATE_ERROR, /*15*/
93
94  /*Add any new state above*/
95  CAMERA_STATE_MAX
96} HAL_camera_state_type_t;
97
98enum {
99  BUFFER_NOT_OWNED,
100  BUFFER_UNLOCKED,
101  BUFFER_LOCKED,
102};
103
104typedef enum {
105  HAL_DUMP_FRM_PREVIEW = 1,
106  HAL_DUMP_FRM_VIDEO = 1<<1,
107  HAL_DUMP_FRM_MAIN = 1<<2,
108  HAL_DUMP_FRM_THUMBNAIL = 1<<3,
109
110  /*8 bits mask*/
111  HAL_DUMP_FRM_MAX = 1 << 8
112} HAL_cam_dump_frm_type_t;
113
114
115typedef enum {
116  HAL_CAM_MODE_ZSL = 1,
117
118  /*add new entry before and update the max entry*/
119  HAL_CAM_MODE_MAX = HAL_CAM_MODE_ZSL << 1,
120} qQamera_mode_t;
121
122#define HAL_DUMP_FRM_MASK_ALL ( HAL_DUMP_FRM_PREVIEW + HAL_DUMP_FRM_VIDEO + \
123    HAL_DUMP_FRM_MAIN + HAL_DUMP_FRM_THUMBNAIL)
124#define QCAMERA_HAL_PREVIEW_STOPPED    0
125#define QCAMERA_HAL_PREVIEW_START      1
126#define QCAMERA_HAL_PREVIEW_STARTED    2
127#define QCAMERA_HAL_RECORDING_STARTED  3
128#define QCAMERA_HAL_TAKE_PICTURE       4
129
130
131typedef struct {
132     int                     buffer_count;
133	 buffer_handle_t        *buffer_handle[MM_CAMERA_MAX_NUM_FRAMES];
134	 struct private_handle_t *private_buffer_handle[MM_CAMERA_MAX_NUM_FRAMES];
135	 int                     stride[MM_CAMERA_MAX_NUM_FRAMES];
136	 uint32_t                addr_offset[MM_CAMERA_MAX_NUM_FRAMES];
137	 uint8_t                 local_flag[MM_CAMERA_MAX_NUM_FRAMES];
138	 camera_memory_t        *camera_memory[MM_CAMERA_MAX_NUM_FRAMES];
139     int                     main_ion_fd[MM_CAMERA_MAX_NUM_FRAMES];
140     struct ion_fd_data      ion_info_fd[MM_CAMERA_MAX_NUM_FRAMES];
141} QCameraHalMemory_t;
142
143
144typedef struct {
145     int                     buffer_count;
146     uint32_t                size;
147     uint32_t                y_offset;
148     uint32_t                cbcr_offset;
149	 int                     fd[MM_CAMERA_MAX_NUM_FRAMES];
150	 int                     local_flag[MM_CAMERA_MAX_NUM_FRAMES];
151	 camera_memory_t*        camera_memory[MM_CAMERA_MAX_NUM_FRAMES];
152     camera_memory_t*        metadata_memory[MM_CAMERA_MAX_NUM_FRAMES];
153     int main_ion_fd[MM_CAMERA_MAX_NUM_FRAMES];
154     struct ion_allocation_data alloc[MM_CAMERA_MAX_NUM_FRAMES];
155     struct ion_fd_data ion_info_fd[MM_CAMERA_MAX_NUM_FRAMES];
156} QCameraHalHeap_t;
157
158typedef struct {
159     camera_memory_t*  camera_memory[3];
160     int main_ion_fd[3];
161     struct ion_allocation_data alloc[3];
162     struct ion_fd_data ion_info_fd[3];
163     int fd[3];
164     int size;
165} QCameraStatHeap_t;
166
167typedef struct {
168  int32_t msg_type;
169  int32_t ext1;
170  int32_t ext2;
171  void    *cookie;
172} argm_notify_t;
173
174typedef struct {
175  int32_t                  msg_type;
176  camera_memory_t         *data;
177  unsigned int             index;
178  camera_frame_metadata_t *metadata;
179  void                    *cookie;
180} argm_data_cb_t;
181
182typedef struct {
183  camera_notify_callback notifyCb;
184  camera_data_callback   dataCb;
185  argm_notify_t argm_notify;
186  argm_data_cb_t        argm_data_cb;
187} app_notify_cb_t;
188
189/* camera_area_t
190 * rectangle with weight to store the focus and metering areas.
191 * x1, y1, x2, y2: from -1000 to 1000
192 * weight: 0 to 1000
193 */
194typedef struct {
195    int x1, y1, x2, y2;
196    int weight;
197} camera_area_t;
198
199//EXIF globals
200static const char ExifAsciiPrefix[] = { 0x41, 0x53, 0x43, 0x49, 0x49, 0x0, 0x0, 0x0 };          // "ASCII\0\0\0"
201static const char ExifUndefinedPrefix[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };   // "\0\0\0\0\0\0\0\0"
202
203//EXIF detfines
204#define MAX_EXIF_TABLE_ENTRIES           14
205#define GPS_PROCESSING_METHOD_SIZE       101
206#define FOCAL_LENGTH_DECIMAL_PRECISION   100
207#define EXIF_ASCII_PREFIX_SIZE           8   //(sizeof(ExifAsciiPrefix))
208
209typedef struct{
210    //GPS tags
211    rat_t       latitude[3];
212    rat_t       longitude[3];
213    char        lonRef[2];
214    char        latRef[2];
215    rat_t       altitude;
216    rat_t       gpsTimeStamp[3];
217    char        gpsDateStamp[20];
218    char        gpsProcessingMethod[EXIF_ASCII_PREFIX_SIZE+GPS_PROCESSING_METHOD_SIZE];
219    //Other tags
220    char        dateTime[20];
221    rat_t       focalLength;
222    uint16_t    flashMode;
223    uint16_t    isoSpeed;
224    rat_t       exposure_time;
225
226    bool        mAltitude;
227    bool        mLongitude;
228    bool        mLatitude;
229    bool        mTimeStamp;
230    bool        mGpsProcess;
231
232    int         mAltitude_ref;
233    long        mGPSTimestamp;
234
235} exif_values_t;
236
237namespace android {
238
239class QCameraStream;
240
241class QCameraHardwareInterface : public virtual RefBase {
242public:
243
244    QCameraHardwareInterface(int  cameraId, int mode);
245
246    /** Set the ANativeWindow to which preview frames are sent */
247    int setPreviewWindow(preview_stream_ops_t* window);
248
249    /** Set the notification and data callbacks */
250    void setCallbacks(camera_notify_callback notify_cb,
251            camera_data_callback data_cb,
252            camera_data_timestamp_callback data_cb_timestamp,
253            camera_request_memory get_memory,
254            void *user);
255
256    /**
257     * The following three functions all take a msg_type, which is a bitmask of
258     * the messages defined in include/ui/Camera.h
259     */
260
261    /**
262     * Enable a message, or set of messages.
263     */
264    void enableMsgType(int32_t msg_type);
265
266    /**
267     * Disable a message, or a set of messages.
268     *
269     * Once received a call to disableMsgType(CAMERA_MSG_VIDEO_FRAME), camera
270     * HAL should not rely on its client to call releaseRecordingFrame() to
271     * release video recording frames sent out by the cameral HAL before and
272     * after the disableMsgType(CAMERA_MSG_VIDEO_FRAME) call. Camera HAL
273     * clients must not modify/access any video recording frame after calling
274     * disableMsgType(CAMERA_MSG_VIDEO_FRAME).
275     */
276    void disableMsgType(int32_t msg_type);
277
278    /**
279     * Query whether a message, or a set of messages, is enabled.  Note that
280     * this is operates as an AND, if any of the messages queried are off, this
281     * will return false.
282     */
283    int msgTypeEnabled(int32_t msg_type);
284
285    /**
286     * Start preview mode.
287     */
288    int startPreview();
289    int startPreview2();
290
291    /**
292     * Stop a previously started preview.
293     */
294    void stopPreview();
295
296    /**
297     * Returns true if preview is enabled.
298     */
299    int previewEnabled();
300
301
302    /**
303     * Request the camera HAL to store meta data or real YUV data in the video
304     * buffers sent out via CAMERA_MSG_VIDEO_FRAME for a recording session. If
305     * it is not called, the default camera HAL behavior is to store real YUV
306     * data in the video buffers.
307     *
308     * This method should be called before startRecording() in order to be
309     * effective.
310     *
311     * If meta data is stored in the video buffers, it is up to the receiver of
312     * the video buffers to interpret the contents and to find the actual frame
313     * data with the help of the meta data in the buffer. How this is done is
314     * outside of the scope of this method.
315     *
316     * Some camera HALs may not support storing meta data in the video buffers,
317     * but all camera HALs should support storing real YUV data in the video
318     * buffers. If the camera HAL does not support storing the meta data in the
319     * video buffers when it is requested to do do, INVALID_OPERATION must be
320     * returned. It is very useful for the camera HAL to pass meta data rather
321     * than the actual frame data directly to the video encoder, since the
322     * amount of the uncompressed frame data can be very large if video size is
323     * large.
324     *
325     * @param enable if true to instruct the camera HAL to store
326     *        meta data in the video buffers; false to instruct
327     *        the camera HAL to store real YUV data in the video
328     *        buffers.
329     *
330     * @return OK on success.
331     */
332    int storeMetaDataInBuffers(int enable);
333
334    /**
335     * Start record mode. When a record image is available, a
336     * CAMERA_MSG_VIDEO_FRAME message is sent with the corresponding
337     * frame. Every record frame must be released by a camera HAL client via
338     * releaseRecordingFrame() before the client calls
339     * disableMsgType(CAMERA_MSG_VIDEO_FRAME). After the client calls
340     * disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is the camera HAL's
341     * responsibility to manage the life-cycle of the video recording frames,
342     * and the client must not modify/access any video recording frames.
343     */
344    int startRecording();
345
346    /**
347     * Stop a previously started recording.
348     */
349    void stopRecording();
350
351    /**
352     * Returns true if recording is enabled.
353     */
354    int recordingEnabled();
355
356    /**
357     * Release a record frame previously returned by CAMERA_MSG_VIDEO_FRAME.
358     *
359     * It is camera HAL client's responsibility to release video recording
360     * frames sent out by the camera HAL before the camera HAL receives a call
361     * to disableMsgType(CAMERA_MSG_VIDEO_FRAME). After it receives the call to
362     * disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is the camera HAL's
363     * responsibility to manage the life-cycle of the video recording frames.
364     */
365    void releaseRecordingFrame(const void *opaque);
366
367    /**
368     * Start auto focus, the notification callback routine is called with
369     * CAMERA_MSG_FOCUS once when focusing is complete. autoFocus() will be
370     * called again if another auto focus is needed.
371     */
372    int autoFocus();
373
374    /**
375     * Cancels auto-focus function. If the auto-focus is still in progress,
376     * this function will cancel it. Whether the auto-focus is in progress or
377     * not, this function will return the focus position to the default.  If
378     * the camera does not support auto-focus, this is a no-op.
379     */
380    int cancelAutoFocus();
381
382    /**
383     * Take a picture.
384     */
385    int takePicture();
386
387    /**
388     * Cancel a picture that was started with takePicture. Calling this method
389     * when no picture is being taken is a no-op.
390     */
391    int cancelPicture();
392
393    /**
394     * Set the camera parameters. This returns BAD_VALUE if any parameter is
395     * invalid or not supported.
396     */
397    int setParameters(const char *parms);
398
399    //status_t setParameters(const QCameraParameters& params);
400    /** Retrieve the camera parameters.  The buffer returned by the camera HAL
401        must be returned back to it with put_parameters, if put_parameters
402        is not NULL.
403     */
404    int getParameters(char **parms);
405
406    /** The camera HAL uses its own memory to pass us the parameters when we
407        call get_parameters.  Use this function to return the memory back to
408        the camera HAL, if put_parameters is not NULL.  If put_parameters
409        is NULL, then you have to use free() to release the memory.
410    */
411    void putParameters(char *);
412
413    /**
414     * Send command to camera driver.
415     */
416    int sendCommand(int32_t cmd, int32_t arg1, int32_t arg2);
417
418    /**
419     * Release the hardware resources owned by this object.  Note that this is
420     * *not* done in the destructor.
421     */
422    void release();
423
424    /**
425     * Dump state of the camera hardware
426     */
427    int dump(int fd);
428
429    //virtual sp<IMemoryHeap> getPreviewHeap() const;
430    //virtual sp<IMemoryHeap> getRawHeap() const;
431
432
433    status_t    takeLiveSnapshot();
434    status_t    takeFullSizeLiveshot();
435    bool        canTakeFullSizeLiveshot();
436
437    //virtual status_t          getBufferInfo( sp<IMemory>& Frame,
438    //size_t *alignedSize);
439    void         getPictureSize(int *picture_width, int *picture_height) const;
440    void         getPreviewSize(int *preview_width, int *preview_height) const;
441    cam_format_t getPreviewFormat() const;
442
443    cam_pad_format_t getPreviewPadding() const;
444
445    //bool     useOverlay(void);
446    //virtual status_t setOverlay(const sp<Overlay> &overlay);
447    void processEvent(mm_camera_event_t *);
448    int  getJpegQuality() const;
449    int  getNumOfSnapshots(void) const;
450    int  getNumOfSnapshots(const QCameraParameters& params);
451    int  getThumbSizesFromAspectRatio(uint32_t aspect_ratio,
452                                     int *picture_width,
453                                     int *picture_height);
454    bool isRawSnapshot();
455    bool mShutterSoundPlayed;
456    void dumpFrameToFile(struct msm_frame*, HAL_cam_dump_frm_type_t);
457
458    static QCameraHardwareInterface *createInstance(int, int);
459    status_t setZSLBurstLookBack(const QCameraParameters& params);
460    status_t setZSLBurstInterval(const QCameraParameters& params);
461    int getZSLBurstInterval(void);
462    int getZSLQueueDepth(void) const;
463    int getZSLBackLookCount(void) const;
464
465    ~QCameraHardwareInterface();
466    int initHeapMem(QCameraHalHeap_t *heap, int num_of_buf, int pmem_type,
467      int frame_len, int cbcr_off, int y_off, mm_cameara_stream_buf_t *StreamBuf,
468      mm_camera_buf_def_t *buf_def, uint8_t num_planes, uint32_t *planes);
469
470    int releaseHeapMem( QCameraHalHeap_t *heap);
471    status_t sendMappingBuf(int ext_mode, int idx, int fd, uint32_t size,
472      int cameraid, mm_camera_socket_msg_type msg_type);
473    status_t sendUnMappingBuf(int ext_mode, int idx, int cameraid,
474      mm_camera_socket_msg_type msg_type);
475
476    int allocate_ion_memory(QCameraHalHeap_t *p_camera_memory, int cnt,
477      int ion_type);
478    int deallocate_ion_memory(QCameraHalHeap_t *p_camera_memory, int cnt);
479
480    int allocate_ion_memory(QCameraStatHeap_t *p_camera_memory, int cnt,
481      int ion_type);
482    int deallocate_ion_memory(QCameraStatHeap_t *p_camera_memory, int cnt);
483
484    int cache_ops(int ion_fd, struct ion_flush_data *cache_inv_data, int type);
485
486    void dumpFrameToFile(const void * data, uint32_t size, char* name,
487      char* ext, int index);
488    preview_format_info_t getPreviewFormatInfo( );
489    bool isCameraReady();
490    bool isNoDisplayMode();
491
492private:
493    int16_t  zoomRatios[MAX_ZOOM_RATIOS];
494    struct camera_size_type default_preview_sizes[PREVIEW_TBL_MAX_SIZE];
495    struct camera_size_type default_video_sizes[VIDEO_TBL_MAX_SIZE];
496    struct camera_size_type default_hfr_sizes[HFR_TBL_MAX_SIZE];
497    struct camera_size_type default_thumbnail_sizes[THUMB_TBL_MAX_SIZE];
498    unsigned int preview_sizes_count;
499    unsigned int video_sizes_count;
500    unsigned int thumbnail_sizes_count;
501    unsigned int hfr_sizes_count;
502
503
504    bool mUseOverlay;
505
506    void loadTables();
507    void initDefaultParameters();
508    bool getMaxPictureDimension(mm_camera_dimension_t *dim);
509
510    status_t updateFocusDistances();
511
512    bool native_set_parms(mm_camera_parm_type_t type, uint16_t length, void *value);
513    bool native_set_parms( mm_camera_parm_type_t type, uint16_t length, void *value, int *result);
514
515    void hasAutoFocusSupport();
516    void debugShowPreviewFPS() const;
517    //void prepareSnapshotAndWait();
518
519    bool isPreviewRunning();
520    bool isRecordingRunning();
521    bool isSnapshotRunning();
522
523    void processChannelEvent(mm_camera_ch_event_t *, app_notify_cb_t *);
524    void processPreviewChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *);
525    void processRecordChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *);
526    void processSnapshotChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *);
527    void processCtrlEvent(mm_camera_ctrl_event_t *, app_notify_cb_t *);
528    void processStatsEvent(mm_camera_stats_event_t *, app_notify_cb_t *);
529    void processInfoEvent(mm_camera_info_event_t *event, app_notify_cb_t *);
530    void processprepareSnapshotEvent(cam_ctrl_status_t *);
531    void roiEvent(fd_roi_t roi, app_notify_cb_t *);
532    void zslFlashEvent(struct zsl_flash_t evt, app_notify_cb_t *);
533    void zoomEvent(cam_ctrl_status_t *status, app_notify_cb_t *);
534    void autofocusevent(cam_ctrl_status_t *status, app_notify_cb_t *);
535    void handleZoomEventForPreview(app_notify_cb_t *);
536    void handleZoomEventForSnapshot(void);
537    status_t autoFocusEvent(cam_ctrl_status_t *, app_notify_cb_t *);
538    status_t autoFocusMoveEvent(cam_ctrl_status_t *, app_notify_cb_t *);
539
540    void filterPictureSizes();
541    bool supportsSceneDetection();
542    bool supportsSelectableZoneAf();
543    bool supportsFaceDetection();
544    bool supportsRedEyeReduction();
545    bool preview_parm_config (cam_ctrl_dimension_t* dim,QCameraParameters& parm);
546
547    void stopPreviewInternal();
548    void stopRecordingInternal();
549    //void stopPreviewZSL();
550    status_t cancelPictureInternal();
551    //status_t startPreviewZSL();
552    void pausePreviewForSnapshot();
553    void pausePreviewForZSL();
554    void pausePreviewForVideo();
555    status_t resumePreviewAfterSnapshot();
556
557    status_t runFaceDetection();
558
559    status_t           setParameters(const QCameraParameters& params);
560    QCameraParameters&  getParameters() ;
561
562    status_t setCameraMode(const QCameraParameters& params);
563    status_t setPictureSizeTable(void);
564    status_t setPreviewSizeTable(void);
565    status_t setVideoSizeTable(void);
566    status_t setPreviewSize(const QCameraParameters& params);
567    status_t setJpegThumbnailSize(const QCameraParameters& params);
568    status_t setPreviewFpsRange(const QCameraParameters& params);
569    status_t setPreviewFrameRate(const QCameraParameters& params);
570    status_t setPreviewFrameRateMode(const QCameraParameters& params);
571    status_t setVideoSize(const QCameraParameters& params);
572    status_t setPictureSize(const QCameraParameters& params);
573    status_t setJpegQuality(const QCameraParameters& params);
574    status_t setNumOfSnapshot(const QCameraParameters& params);
575    status_t setJpegRotation(int isZSL);
576    int getJpegRotation(void);
577    int getISOSpeedValue();
578    int getFlashMode();
579    status_t setAntibanding(const QCameraParameters& params);
580    status_t setEffect(const QCameraParameters& params);
581    status_t setExposureCompensation(const QCameraParameters &params);
582    status_t setAutoExposure(const QCameraParameters& params);
583    status_t setWhiteBalance(const QCameraParameters& params);
584    status_t setFlash(const QCameraParameters& params);
585    status_t setGpsLocation(const QCameraParameters& params);
586    status_t setRotation(const QCameraParameters& params);
587    status_t setZoom(const QCameraParameters& params);
588    status_t setFocusMode(const QCameraParameters& params);
589    status_t setBrightness(const QCameraParameters& params);
590    status_t setSkinToneEnhancement(const QCameraParameters& params);
591    status_t setOrientation(const QCameraParameters& params);
592    status_t setLensshadeValue(const QCameraParameters& params);
593    status_t setMCEValue(const QCameraParameters& params);
594    status_t setISOValue(const QCameraParameters& params);
595    status_t setPictureFormat(const QCameraParameters& params);
596    status_t setSharpness(const QCameraParameters& params);
597    status_t setContrast(const QCameraParameters& params);
598    status_t setSaturation(const QCameraParameters& params);
599    status_t setWaveletDenoise(const QCameraParameters& params);
600    status_t setSceneMode(const QCameraParameters& params);
601    status_t setContinuousAf(const QCameraParameters& params);
602    status_t setFaceDetection(const char *str);
603    status_t setSceneDetect(const QCameraParameters& params);
604    status_t setStrTextures(const QCameraParameters& params);
605    status_t setPreviewFormat(const QCameraParameters& params);
606    status_t setSelectableZoneAf(const QCameraParameters& params);
607    status_t setOverlayFormats(const QCameraParameters& params);
608    status_t setHighFrameRate(const QCameraParameters& params);
609    status_t setRedeyeReduction(const QCameraParameters& params);
610    status_t setAEBracket(const QCameraParameters& params);
611    status_t setFaceDetect(const QCameraParameters& params);
612    status_t setDenoise(const QCameraParameters& params);
613    status_t setAecAwbLock(const QCameraParameters & params);
614    status_t setHistogram(int histogram_en);
615    status_t setRecordingHint(const QCameraParameters& params);
616    status_t setRecordingHintValue(const int32_t value);
617    status_t setFocusAreas(const QCameraParameters& params);
618    status_t setMeteringAreas(const QCameraParameters& params);
619    status_t setFullLiveshot(void);
620    status_t setDISMode(void);
621    status_t setCaptureBurstExp(void);
622    status_t setPowerMode(const QCameraParameters& params);
623    void takePicturePrepareHardware( );
624    status_t setNoDisplayMode(const QCameraParameters& params);
625    status_t setCAFLockCancel(void);
626
627    isp3a_af_mode_t getAutoFocusMode(const QCameraParameters& params);
628    bool isValidDimension(int w, int h);
629
630    String8 create_values_str(const str_map *values, int len);
631
632    void setMyMode(int mode);
633    bool isZSLMode();
634    bool isWDenoiseEnabled();
635    void wdenoiseEvent(cam_ctrl_status_t status, void *cookie);
636    bool isLowPowerCamcorder();
637    void freePictureTable(void);
638    void freeVideoSizeTable(void);
639
640    int32_t createPreview();
641    int32_t createRecord();
642    int32_t createSnapshot();
643
644    int getHDRMode();
645    //EXIF
646    void addExifTag(exif_tag_id_t tagid, exif_tag_type_t type,
647                        uint32_t count, uint8_t copy, void *data);
648    void setExifTags();
649    void initExifData();
650    void deinitExifData();
651    void setExifTagsGPS();
652    exif_tags_info_t* getExifData(){ return mExifData; }
653    int getExifTableNumEntries() { return mExifTableNumEntries; }
654    void parseGPSCoordinate(const char *latlonString, rat_t* coord);
655    bool getHdrInfoAndSetExp( int max_num_frm, int *num_frame, int *exp);
656    void hdrEvent(cam_ctrl_status_t status, void *cookie);
657
658    int           mCameraId;
659    camera_mode_t myMode;
660
661    QCameraParameters    mParameters;
662    //sp<Overlay>         mOverlay;
663    int32_t             mMsgEnabled;
664
665    camera_notify_callback         mNotifyCb;
666    camera_data_callback           mDataCb;
667    camera_data_timestamp_callback mDataCbTimestamp;
668    camera_request_memory          mGetMemory;
669    void                           *mCallbackCookie;
670
671    sp<AshmemPool>      mMetaDataHeap;
672
673    mutable Mutex       mLock;
674    //mutable Mutex       eventLock;
675    Mutex         mCallbackLock;
676    Mutex         mPreviewMemoryLock;
677    Mutex         mRecordingMemoryLock;
678    Mutex         mAutofocusLock;
679    Mutex         mMetaDataWaitLock;
680    Mutex         mRecordFrameLock;
681    Mutex         mRecordLock;
682    Condition     mRecordWait;
683    pthread_mutex_t     mAsyncCmdMutex;
684    pthread_cond_t      mAsyncCmdWait;
685
686    QCameraStream       *mStreamDisplay;
687    QCameraStream       *mStreamRecord;
688    QCameraStream       *mStreamSnap;
689    QCameraStream       *mStreamLiveSnap;
690
691    cam_ctrl_dimension_t mDimension;
692    int  mPreviewWidth, mPreviewHeight;
693    int  mVideoWidth, mVideoHeight;
694    int  thumbnailWidth, thumbnailHeight;
695    int  maxSnapshotWidth, maxSnapshotHeight;
696    int  mPreviewFormat;
697    int  mFps;
698    int  mDebugFps;
699    int  mBrightness;
700    int  mContrast;
701    int  mBestShotMode;
702    int  mEffects;
703    int  mSkinToneEnhancement;
704    int  mDenoiseValue;
705    int  mHJR;
706    int  mRotation;
707    int  mJpegQuality;
708    int  mThumbnailQuality;
709    int  mTargetSmoothZoom;
710    int  mSmoothZoomStep;
711    int  mMaxZoom;
712    int  mCurrentZoom;
713    int  mSupportedPictureSizesCount;
714    int  mFaceDetectOn;
715    int  mDumpFrmCnt;
716    int  mDumpSkipCnt;
717    int  mFocusMode;
718
719    unsigned int mPictureSizeCount;
720    unsigned int mPreviewSizeCount;
721    int mPowerMode;
722    unsigned int mVideoSizeCount;
723
724    bool mAutoFocusRunning;
725    bool mNeedToUnlockCaf;
726    bool mMultiTouch;
727    bool mHasAutoFocusSupport;
728    bool mInitialized;
729    bool mDisEnabled;
730    bool strTexturesOn;
731    bool mIs3DModeOn;
732    bool mSmoothZoomRunning;
733    bool mPreparingSnapshot;
734    bool mParamStringInitialized;
735    bool mZoomSupported;
736    bool mSendMetaData;
737    bool mFullLiveshotEnabled;
738    bool mRecordingHint;
739    bool mAppRecordingHint;
740    bool mStartRecording;
741    bool mReleasedRecordingFrame;
742    int mHdrMode;
743    int mSnapshotFormat;
744    int mZslInterval;
745    bool mRestartPreview;
746
747/*for histogram*/
748    int            mStatsOn;
749    int            mCurrentHisto;
750    bool           mSendData;
751    sp<AshmemPool> mStatHeap;
752    camera_memory_t *mStatsMapped[3];
753    QCameraStatHeap_t mHistServer;
754    int32_t        mStatSize;
755
756    bool mZslLookBackMode;
757    int mZslLookBackValue;
758	int mHFRLevel;
759    bool mZslEmptyQueueFlag;
760    String8 mEffectValues;
761    String8 mIsoValues;
762    String8 mSceneModeValues;
763    String8 mSceneDetectValues;
764    String8 mFocusModeValues;
765    String8 mSelectableZoneAfValues;
766    String8 mAutoExposureValues;
767    String8 mWhitebalanceValues;
768    String8 mAntibandingValues;
769    String8 mFrameRateModeValues;
770    String8 mTouchAfAecValues;
771    String8 mPreviewSizeValues;
772    String8 mPictureSizeValues;
773    String8 mVideoSizeValues;
774    String8 mFlashValues;
775    String8 mLensShadeValues;
776    String8 mMceValues;
777    String8 mHistogramValues;
778    String8 mSkinToneEnhancementValues;
779    String8 mPictureFormatValues;
780    String8 mDenoiseValues;
781    String8 mZoomRatioValues;
782    String8 mPreviewFrameRateValues;
783    String8 mPreviewFormatValues;
784    String8 mFaceDetectionValues;
785    String8 mHfrValues;
786    String8 mHfrSizeValues;
787    String8 mRedeyeReductionValues;
788    String8 denoise_value;
789    String8 mFpsRangesSupportedValues;
790    String8 mZslValues;
791    String8 mFocusDistance;
792
793    friend class QCameraStream;
794    friend class QCameraStream_record;
795    friend class QCameraStream_preview;
796    friend class QCameraStream_Snapshot;
797
798    camera_size_type* mPictureSizes;
799    camera_size_type* mPreviewSizes;
800    camera_size_type* mVideoSizes;
801    const camera_size_type * mPictureSizesPtr;
802    HAL_camera_state_type_t mCameraState;
803
804     /* Temporary - can be removed after Honeycomb*/
805#ifdef USE_ION
806    sp<IonPool>  mPostPreviewHeap;
807#else
808    sp<PmemPool> mPostPreviewHeap;
809#endif
810     mm_cameara_stream_buf_t mPrevForPostviewBuf;
811     int mStoreMetaDataInFrame;
812     preview_stream_ops_t *mPreviewWindow;
813     Mutex                mStateLock;
814     int                  mPreviewState;
815     /*preview memory with display case: memory is allocated and freed via
816     gralloc */
817     QCameraHalMemory_t   mPreviewMemory;
818
819     /*preview memory without display case: memory is allocated
820      directly by camera */
821     QCameraHalHeap_t     mNoDispPreviewMemory;
822
823     QCameraHalHeap_t     mSnapshotMemory;
824     QCameraHalHeap_t     mThumbnailMemory;
825     QCameraHalHeap_t     mRecordingMemory;
826     QCameraHalHeap_t     mJpegMemory;
827     QCameraHalHeap_t     mRawMemory;
828     camera_frame_metadata_t mMetadata;
829     camera_face_t           mFace[MAX_ROI];
830     preview_format_info_t  mPreviewFormatInfo;
831     friend void liveshot_callback(mm_camera_ch_data_buf_t *frame,void *user_data);
832
833     //EXIF
834     exif_tags_info_t       mExifData[MAX_EXIF_TABLE_ENTRIES];  //Exif tags for JPEG encoder
835     exif_values_t          mExifValues;                        //Exif values in usable format
836     int                    mExifTableNumEntries;            //NUmber of entries in mExifData
837     int                 mNoDisplayMode;
838     int                 mIsoValue;
839};
840
841}; // namespace android
842
843#endif
844