QCameraHWI.h revision badd74a59b9e668bb48cea5edbe77956b708223b 
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
225    bool        mAltitude;
226    bool        mLongitude;
227    bool        mLatitude;
228    bool        mTimeStamp;
229    bool        mGpsProcess;
230
231    int         mAltitude_ref;
232    long        mGPSTimestamp;
233
234} exif_values_t;
235
236namespace android {
237
238class QCameraStream;
239
240class QCameraHardwareInterface : public virtual RefBase {
241public:
242
243    QCameraHardwareInterface(int  cameraId, int mode);
244
245    /** Set the ANativeWindow to which preview frames are sent */
246    int setPreviewWindow(preview_stream_ops_t* window);
247
248    /** Set the notification and data callbacks */
249    void setCallbacks(camera_notify_callback notify_cb,
250            camera_data_callback data_cb,
251            camera_data_timestamp_callback data_cb_timestamp,
252            camera_request_memory get_memory,
253            void *user);
254
255    /**
256     * The following three functions all take a msg_type, which is a bitmask of
257     * the messages defined in include/ui/Camera.h
258     */
259
260    /**
261     * Enable a message, or set of messages.
262     */
263    void enableMsgType(int32_t msg_type);
264
265    /**
266     * Disable a message, or a set of messages.
267     *
268     * Once received a call to disableMsgType(CAMERA_MSG_VIDEO_FRAME), camera
269     * HAL should not rely on its client to call releaseRecordingFrame() to
270     * release video recording frames sent out by the cameral HAL before and
271     * after the disableMsgType(CAMERA_MSG_VIDEO_FRAME) call. Camera HAL
272     * clients must not modify/access any video recording frame after calling
273     * disableMsgType(CAMERA_MSG_VIDEO_FRAME).
274     */
275    void disableMsgType(int32_t msg_type);
276
277    /**
278     * Query whether a message, or a set of messages, is enabled.  Note that
279     * this is operates as an AND, if any of the messages queried are off, this
280     * will return false.
281     */
282    int msgTypeEnabled(int32_t msg_type);
283
284    /**
285     * Start preview mode.
286     */
287    int startPreview();
288    int startPreview2();
289
290    /**
291     * Stop a previously started preview.
292     */
293    void stopPreview();
294
295    /**
296     * Returns true if preview is enabled.
297     */
298    int previewEnabled();
299
300
301    /**
302     * Request the camera HAL to store meta data or real YUV data in the video
303     * buffers sent out via CAMERA_MSG_VIDEO_FRAME for a recording session. If
304     * it is not called, the default camera HAL behavior is to store real YUV
305     * data in the video buffers.
306     *
307     * This method should be called before startRecording() in order to be
308     * effective.
309     *
310     * If meta data is stored in the video buffers, it is up to the receiver of
311     * the video buffers to interpret the contents and to find the actual frame
312     * data with the help of the meta data in the buffer. How this is done is
313     * outside of the scope of this method.
314     *
315     * Some camera HALs may not support storing meta data in the video buffers,
316     * but all camera HALs should support storing real YUV data in the video
317     * buffers. If the camera HAL does not support storing the meta data in the
318     * video buffers when it is requested to do do, INVALID_OPERATION must be
319     * returned. It is very useful for the camera HAL to pass meta data rather
320     * than the actual frame data directly to the video encoder, since the
321     * amount of the uncompressed frame data can be very large if video size is
322     * large.
323     *
324     * @param enable if true to instruct the camera HAL to store
325     *        meta data in the video buffers; false to instruct
326     *        the camera HAL to store real YUV data in the video
327     *        buffers.
328     *
329     * @return OK on success.
330     */
331    int storeMetaDataInBuffers(int enable);
332
333    /**
334     * Start record mode. When a record image is available, a
335     * CAMERA_MSG_VIDEO_FRAME message is sent with the corresponding
336     * frame. Every record frame must be released by a camera HAL client via
337     * releaseRecordingFrame() before the client calls
338     * disableMsgType(CAMERA_MSG_VIDEO_FRAME). After the client calls
339     * disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is the camera HAL's
340     * responsibility to manage the life-cycle of the video recording frames,
341     * and the client must not modify/access any video recording frames.
342     */
343    int startRecording();
344
345    /**
346     * Stop a previously started recording.
347     */
348    void stopRecording();
349
350    /**
351     * Returns true if recording is enabled.
352     */
353    int recordingEnabled();
354
355    /**
356     * Release a record frame previously returned by CAMERA_MSG_VIDEO_FRAME.
357     *
358     * It is camera HAL client's responsibility to release video recording
359     * frames sent out by the camera HAL before the camera HAL receives a call
360     * to disableMsgType(CAMERA_MSG_VIDEO_FRAME). After it receives the call to
361     * disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is the camera HAL's
362     * responsibility to manage the life-cycle of the video recording frames.
363     */
364    void releaseRecordingFrame(const void *opaque);
365
366    /**
367     * Start auto focus, the notification callback routine is called with
368     * CAMERA_MSG_FOCUS once when focusing is complete. autoFocus() will be
369     * called again if another auto focus is needed.
370     */
371    int autoFocus();
372
373    /**
374     * Cancels auto-focus function. If the auto-focus is still in progress,
375     * this function will cancel it. Whether the auto-focus is in progress or
376     * not, this function will return the focus position to the default.  If
377     * the camera does not support auto-focus, this is a no-op.
378     */
379    int cancelAutoFocus();
380
381    /**
382     * Take a picture.
383     */
384    int takePicture();
385
386    /**
387     * Cancel a picture that was started with takePicture. Calling this method
388     * when no picture is being taken is a no-op.
389     */
390    int cancelPicture();
391
392    /**
393     * Set the camera parameters. This returns BAD_VALUE if any parameter is
394     * invalid or not supported.
395     */
396    int setParameters(const char *parms);
397
398    //status_t setParameters(const QCameraParameters& params);
399    /** Retrieve the camera parameters.  The buffer returned by the camera HAL
400        must be returned back to it with put_parameters, if put_parameters
401        is not NULL.
402     */
403    int getParameters(char **parms);
404
405    /** The camera HAL uses its own memory to pass us the parameters when we
406        call get_parameters.  Use this function to return the memory back to
407        the camera HAL, if put_parameters is not NULL.  If put_parameters
408        is NULL, then you have to use free() to release the memory.
409    */
410    void putParameters(char *);
411
412    /**
413     * Send command to camera driver.
414     */
415    int sendCommand(int32_t cmd, int32_t arg1, int32_t arg2);
416
417    /**
418     * Release the hardware resources owned by this object.  Note that this is
419     * *not* done in the destructor.
420     */
421    void release();
422
423    /**
424     * Dump state of the camera hardware
425     */
426    int dump(int fd);
427
428    //virtual sp<IMemoryHeap> getPreviewHeap() const;
429    //virtual sp<IMemoryHeap> getRawHeap() const;
430
431
432    status_t    takeLiveSnapshot();
433    status_t    takeFullSizeLiveshot();
434    bool        canTakeFullSizeLiveshot();
435
436    //virtual status_t          getBufferInfo( sp<IMemory>& Frame,
437    //size_t *alignedSize);
438    void         getPictureSize(int *picture_width, int *picture_height) const;
439    void         getPreviewSize(int *preview_width, int *preview_height) const;
440    cam_format_t getPreviewFormat() const;
441
442    cam_pad_format_t getPreviewPadding() const;
443
444    //bool     useOverlay(void);
445    //virtual status_t setOverlay(const sp<Overlay> &overlay);
446    void processEvent(mm_camera_event_t *);
447    int  getJpegQuality() const;
448    int  getNumOfSnapshots(void) const;
449    int  getNumOfSnapshots(const QCameraParameters& params);
450    int  getThumbSizesFromAspectRatio(uint32_t aspect_ratio,
451                                     int *picture_width,
452                                     int *picture_height);
453    bool isRawSnapshot();
454    bool mShutterSoundPlayed;
455    void dumpFrameToFile(struct msm_frame*, HAL_cam_dump_frm_type_t);
456
457    static QCameraHardwareInterface *createInstance(int, int);
458    status_t setZSLBurstLookBack(const QCameraParameters& params);
459    status_t setZSLBurstInterval(const QCameraParameters& params);
460    int getZSLBurstInterval(void);
461    int getZSLQueueDepth(void) const;
462    int getZSLBackLookCount(void) const;
463
464    ~QCameraHardwareInterface();
465    int initHeapMem(QCameraHalHeap_t *heap, int num_of_buf, int pmem_type,
466      int frame_len, int cbcr_off, int y_off, mm_cameara_stream_buf_t *StreamBuf,
467      mm_camera_buf_def_t *buf_def, uint8_t num_planes, uint32_t *planes);
468
469    int releaseHeapMem( QCameraHalHeap_t *heap);
470    status_t sendMappingBuf(int ext_mode, int idx, int fd, uint32_t size,
471      int cameraid, mm_camera_socket_msg_type msg_type);
472    status_t sendUnMappingBuf(int ext_mode, int idx, int cameraid,
473      mm_camera_socket_msg_type msg_type);
474
475    int allocate_ion_memory(QCameraHalHeap_t *p_camera_memory, int cnt,
476      int ion_type);
477    int deallocate_ion_memory(QCameraHalHeap_t *p_camera_memory, int cnt);
478
479    int allocate_ion_memory(QCameraStatHeap_t *p_camera_memory, int cnt,
480      int ion_type);
481    int deallocate_ion_memory(QCameraStatHeap_t *p_camera_memory, int cnt);
482
483    int cache_ops(int ion_fd, struct ion_flush_data *cache_inv_data, int type);
484
485    void dumpFrameToFile(const void * data, uint32_t size, char* name,
486      char* ext, int index);
487    preview_format_info_t getPreviewFormatInfo( );
488    bool isCameraReady();
489    bool isNoDisplayMode();
490
491private:
492    int16_t  zoomRatios[MAX_ZOOM_RATIOS];
493    struct camera_size_type default_preview_sizes[PREVIEW_TBL_MAX_SIZE];
494    struct camera_size_type default_video_sizes[VIDEO_TBL_MAX_SIZE];
495    struct camera_size_type default_hfr_sizes[HFR_TBL_MAX_SIZE];
496    struct camera_size_type default_thumbnail_sizes[THUMB_TBL_MAX_SIZE];
497    unsigned int preview_sizes_count;
498    unsigned int video_sizes_count;
499    unsigned int thumbnail_sizes_count;
500    unsigned int hfr_sizes_count;
501
502
503    bool mUseOverlay;
504
505    void loadTables();
506    void initDefaultParameters();
507    bool getMaxPictureDimension(mm_camera_dimension_t *dim);
508
509    status_t updateFocusDistances();
510
511    bool native_set_parms(mm_camera_parm_type_t type, uint16_t length, void *value);
512    bool native_set_parms( mm_camera_parm_type_t type, uint16_t length, void *value, int *result);
513
514    void hasAutoFocusSupport();
515    void debugShowPreviewFPS() const;
516    //void prepareSnapshotAndWait();
517
518    bool isPreviewRunning();
519    bool isRecordingRunning();
520    bool isSnapshotRunning();
521
522    void processChannelEvent(mm_camera_ch_event_t *, app_notify_cb_t *);
523    void processPreviewChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *);
524    void processRecordChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *);
525    void processSnapshotChannelEvent(mm_camera_ch_event_type_t channelEvent, app_notify_cb_t *);
526    void processCtrlEvent(mm_camera_ctrl_event_t *, app_notify_cb_t *);
527    void processStatsEvent(mm_camera_stats_event_t *, app_notify_cb_t *);
528    void processInfoEvent(mm_camera_info_event_t *event, app_notify_cb_t *);
529    void processprepareSnapshotEvent(cam_ctrl_status_t *);
530    void roiEvent(fd_roi_t roi, app_notify_cb_t *);
531    void zslFlashEvent(struct zsl_flash_t evt, app_notify_cb_t *);
532    void zoomEvent(cam_ctrl_status_t *status, app_notify_cb_t *);
533    void autofocusevent(cam_ctrl_status_t *status, app_notify_cb_t *);
534    void handleZoomEventForPreview(app_notify_cb_t *);
535    void handleZoomEventForSnapshot(void);
536    status_t autoFocusEvent(cam_ctrl_status_t *, app_notify_cb_t *);
537    status_t autoFocusMoveEvent(cam_ctrl_status_t *, app_notify_cb_t *);
538
539    void filterPictureSizes();
540    bool supportsSceneDetection();
541    bool supportsSelectableZoneAf();
542    bool supportsFaceDetection();
543    bool supportsRedEyeReduction();
544    bool preview_parm_config (cam_ctrl_dimension_t* dim,QCameraParameters& parm);
545
546    void stopPreviewInternal();
547    void stopRecordingInternal();
548    //void stopPreviewZSL();
549    status_t cancelPictureInternal();
550    //status_t startPreviewZSL();
551    void pausePreviewForSnapshot();
552    void pausePreviewForZSL();
553    status_t resumePreviewAfterSnapshot();
554
555    status_t runFaceDetection();
556
557    status_t           setParameters(const QCameraParameters& params);
558    QCameraParameters&  getParameters() ;
559
560    status_t setCameraMode(const QCameraParameters& params);
561    status_t setPictureSizeTable(void);
562    status_t setPreviewSizeTable(void);
563    status_t setVideoSizeTable(void);
564    status_t setPreviewSize(const QCameraParameters& params);
565    status_t setJpegThumbnailSize(const QCameraParameters& params);
566    status_t setPreviewFpsRange(const QCameraParameters& params);
567    status_t setPreviewFrameRate(const QCameraParameters& params);
568    status_t setPreviewFrameRateMode(const QCameraParameters& params);
569    status_t setVideoSize(const QCameraParameters& params);
570    status_t setPictureSize(const QCameraParameters& params);
571    status_t setJpegQuality(const QCameraParameters& params);
572    status_t setNumOfSnapshot(const QCameraParameters& params);
573    status_t setJpegRotation(int isZSL);
574    int getJpegRotation(void);
575    int getISOSpeedValue();
576    int getFlashMode();
577    status_t setAntibanding(const QCameraParameters& params);
578    status_t setEffect(const QCameraParameters& params);
579    status_t setExposureCompensation(const QCameraParameters &params);
580    status_t setAutoExposure(const QCameraParameters& params);
581    status_t setWhiteBalance(const QCameraParameters& params);
582    status_t setFlash(const QCameraParameters& params);
583    status_t setGpsLocation(const QCameraParameters& params);
584    status_t setRotation(const QCameraParameters& params);
585    status_t setZoom(const QCameraParameters& params);
586    status_t setFocusMode(const QCameraParameters& params);
587    status_t setBrightness(const QCameraParameters& params);
588    status_t setSkinToneEnhancement(const QCameraParameters& params);
589    status_t setOrientation(const QCameraParameters& params);
590    status_t setLensshadeValue(const QCameraParameters& params);
591    status_t setMCEValue(const QCameraParameters& params);
592    status_t setISOValue(const QCameraParameters& params);
593    status_t setPictureFormat(const QCameraParameters& params);
594    status_t setSharpness(const QCameraParameters& params);
595    status_t setContrast(const QCameraParameters& params);
596    status_t setSaturation(const QCameraParameters& params);
597    status_t setWaveletDenoise(const QCameraParameters& params);
598    status_t setSceneMode(const QCameraParameters& params);
599    status_t setContinuousAf(const QCameraParameters& params);
600    status_t setFaceDetection(const char *str);
601    status_t setSceneDetect(const QCameraParameters& params);
602    status_t setStrTextures(const QCameraParameters& params);
603    status_t setPreviewFormat(const QCameraParameters& params);
604    status_t setSelectableZoneAf(const QCameraParameters& params);
605    status_t setOverlayFormats(const QCameraParameters& params);
606    status_t setHighFrameRate(const QCameraParameters& params);
607    status_t setRedeyeReduction(const QCameraParameters& params);
608    status_t setAEBracket(const QCameraParameters& params);
609    status_t setFaceDetect(const QCameraParameters& params);
610    status_t setDenoise(const QCameraParameters& params);
611    status_t setAecAwbLock(const QCameraParameters & params);
612    status_t setHistogram(int histogram_en);
613    status_t setRecordingHint(const QCameraParameters& params);
614    status_t setRecordingHintValue(const int32_t value);
615    status_t setFocusAreas(const QCameraParameters& params);
616    status_t setMeteringAreas(const QCameraParameters& params);
617    status_t setFullLiveshot(void);
618    status_t setDISMode(void);
619    status_t setCaptureBurstExp(void);
620    status_t setPowerMode(const QCameraParameters& params);
621    void takePicturePrepareHardware( );
622    status_t setNoDisplayMode(const QCameraParameters& params);
623    status_t setCAFLockCancel(void);
624
625    isp3a_af_mode_t getAutoFocusMode(const QCameraParameters& params);
626    bool isValidDimension(int w, int h);
627
628    String8 create_values_str(const str_map *values, int len);
629
630    void setMyMode(int mode);
631    bool isZSLMode();
632    bool isWDenoiseEnabled();
633    void wdenoiseEvent(cam_ctrl_status_t status, void *cookie);
634    bool isLowPowerCamcorder();
635    void freePictureTable(void);
636    void freeVideoSizeTable(void);
637
638    int32_t createPreview();
639    int32_t createRecord();
640    int32_t createSnapshot();
641
642    int getHDRMode();
643    //EXIF
644    void addExifTag(exif_tag_id_t tagid, exif_tag_type_t type,
645                        uint32_t count, uint8_t copy, void *data);
646    void setExifTags();
647    void initExifData();
648    void deinitExifData();
649    void setExifTagsGPS();
650    exif_tags_info_t* getExifData(){ return mExifData; }
651    int getExifTableNumEntries() { return mExifTableNumEntries; }
652    void parseGPSCoordinate(const char *latlonString, rat_t* coord);
653    bool getHdrInfoAndSetExp( int max_num_frm, int *num_frame, int *exp);
654    void hdrEvent(cam_ctrl_status_t status, void *cookie);
655
656    int           mCameraId;
657    camera_mode_t myMode;
658
659    QCameraParameters    mParameters;
660    //sp<Overlay>         mOverlay;
661    int32_t             mMsgEnabled;
662
663    camera_notify_callback         mNotifyCb;
664    camera_data_callback           mDataCb;
665    camera_data_timestamp_callback mDataCbTimestamp;
666    camera_request_memory          mGetMemory;
667    void                           *mCallbackCookie;
668
669    sp<AshmemPool>      mMetaDataHeap;
670
671    mutable Mutex       mLock;
672    //mutable Mutex       eventLock;
673    Mutex         mCallbackLock;
674    Mutex         mPreviewMemoryLock;
675    Mutex         mRecordingMemoryLock;
676    Mutex         mAutofocusLock;
677    Mutex         mMetaDataWaitLock;
678    Mutex         mRecordFrameLock;
679    Mutex         mRecordLock;
680    Condition     mRecordWait;
681    pthread_mutex_t     mAsyncCmdMutex;
682    pthread_cond_t      mAsyncCmdWait;
683
684    QCameraStream       *mStreamDisplay;
685    QCameraStream       *mStreamRecord;
686    QCameraStream       *mStreamSnap;
687    QCameraStream       *mStreamLiveSnap;
688
689    cam_ctrl_dimension_t mDimension;
690    int  mPreviewWidth, mPreviewHeight;
691    int  videoWidth, videoHeight;
692    int  thumbnailWidth, thumbnailHeight;
693    int  maxSnapshotWidth, maxSnapshotHeight;
694    int  mPreviewFormat;
695    int  mFps;
696    int  mDebugFps;
697    int  mBrightness;
698    int  mContrast;
699    int  mBestShotMode;
700    int  mEffects;
701    int  mSkinToneEnhancement;
702    int  mDenoiseValue;
703    int  mHJR;
704    int  mRotation;
705    int  mJpegQuality;
706    int  mThumbnailQuality;
707    int  mTargetSmoothZoom;
708    int  mSmoothZoomStep;
709    int  mMaxZoom;
710    int  mCurrentZoom;
711    int  mSupportedPictureSizesCount;
712    int  mFaceDetectOn;
713    int  mDumpFrmCnt;
714    int  mDumpSkipCnt;
715    int  mFocusMode;
716
717    unsigned int mPictureSizeCount;
718    unsigned int mPreviewSizeCount;
719    int mPowerMode;
720    unsigned int mVideoSizeCount;
721
722    bool mAutoFocusRunning;
723    bool mMultiTouch;
724    bool mHasAutoFocusSupport;
725    bool mInitialized;
726    bool mDisEnabled;
727    bool strTexturesOn;
728    bool mIs3DModeOn;
729    bool mSmoothZoomRunning;
730    bool mPreparingSnapshot;
731    bool mParamStringInitialized;
732    bool mZoomSupported;
733    bool mSendMetaData;
734    bool mFullLiveshotEnabled;
735    bool mRecordingHint;
736    bool mAppRecordingHint;
737    bool mStartRecording;
738    bool mReleasedRecordingFrame;
739    int mHdrMode;
740    int mSnapshotFormat;
741    int mZslInterval;
742    bool mRestartPreview;
743
744/*for histogram*/
745    int            mStatsOn;
746    int            mCurrentHisto;
747    bool           mSendData;
748    sp<AshmemPool> mStatHeap;
749    camera_memory_t *mStatsMapped[3];
750    QCameraStatHeap_t mHistServer;
751    int32_t        mStatSize;
752
753    bool mZslLookBackMode;
754    int mZslLookBackValue;
755	int mHFRLevel;
756    bool mZslEmptyQueueFlag;
757    String8 mEffectValues;
758    String8 mIsoValues;
759    String8 mSceneModeValues;
760    String8 mSceneDetectValues;
761    String8 mFocusModeValues;
762    String8 mSelectableZoneAfValues;
763    String8 mAutoExposureValues;
764    String8 mWhitebalanceValues;
765    String8 mAntibandingValues;
766    String8 mFrameRateModeValues;
767    String8 mTouchAfAecValues;
768    String8 mPreviewSizeValues;
769    String8 mPictureSizeValues;
770    String8 mVideoSizeValues;
771    String8 mFlashValues;
772    String8 mLensShadeValues;
773    String8 mMceValues;
774    String8 mHistogramValues;
775    String8 mSkinToneEnhancementValues;
776    String8 mPictureFormatValues;
777    String8 mDenoiseValues;
778    String8 mZoomRatioValues;
779    String8 mPreviewFrameRateValues;
780    String8 mPreviewFormatValues;
781    String8 mFaceDetectionValues;
782    String8 mHfrValues;
783    String8 mHfrSizeValues;
784    String8 mRedeyeReductionValues;
785    String8 denoise_value;
786    String8 mFpsRangesSupportedValues;
787    String8 mZslValues;
788    String8 mFocusDistance;
789
790    friend class QCameraStream;
791    friend class QCameraStream_record;
792    friend class QCameraStream_preview;
793    friend class QCameraStream_Snapshot;
794
795    camera_size_type* mPictureSizes;
796    camera_size_type* mPreviewSizes;
797    camera_size_type* mVideoSizes;
798    const camera_size_type * mPictureSizesPtr;
799    HAL_camera_state_type_t mCameraState;
800
801     /* Temporary - can be removed after Honeycomb*/
802#ifdef USE_ION
803    sp<IonPool>  mPostPreviewHeap;
804#else
805    sp<PmemPool> mPostPreviewHeap;
806#endif
807     mm_cameara_stream_buf_t mPrevForPostviewBuf;
808     int mStoreMetaDataInFrame;
809     preview_stream_ops_t *mPreviewWindow;
810     Mutex                mStateLock;
811     int                  mPreviewState;
812     /*preview memory with display case: memory is allocated and freed via
813     gralloc */
814     QCameraHalMemory_t   mPreviewMemory;
815
816     /*preview memory without display case: memory is allocated
817      directly by camera */
818     QCameraHalHeap_t     mNoDispPreviewMemory;
819
820     QCameraHalHeap_t     mSnapshotMemory;
821     QCameraHalHeap_t     mThumbnailMemory;
822     QCameraHalHeap_t     mRecordingMemory;
823     QCameraHalHeap_t     mJpegMemory;
824     QCameraHalHeap_t     mRawMemory;
825     camera_frame_metadata_t mMetadata;
826     camera_face_t           mFace[MAX_ROI];
827     preview_format_info_t  mPreviewFormatInfo;
828     friend void liveshot_callback(mm_camera_ch_data_buf_t *frame,void *user_data);
829
830     //EXIF
831     exif_tags_info_t       mExifData[MAX_EXIF_TABLE_ENTRIES];  //Exif tags for JPEG encoder
832     exif_values_t          mExifValues;                        //Exif values in usable format
833     int                    mExifTableNumEntries;            //NUmber of entries in mExifData
834     int                 mNoDisplayMode;
835     int                 mIsoValue;
836};
837
838}; // namespace android
839
840#endif
841