Home | History | Annotate | Download | only in libcamera2
      1 /*
      2 **
      3 ** Copyright 2008, The Android Open Source Project
      4 ** Copyright 2012, Samsung Electronics Co. LTD
      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 
     19 /*!
     20  * \file      ExynosCameraHWInterface2.h
     21  * \brief     header file for Android Camera API 2.0 HAL
     22  * \author    Sungjoong Kang(sj3.kang (at) samsung.com)
     23  * \date      2012/07/10
     24  *
     25  * <b>Revision History: </b>
     26  * - 2012/05/31 : Sungjoong Kang(sj3.kang (at) samsung.com) \n
     27  *   Initial Release
     28   *
     29  * - 2012/07/10 : Sungjoong Kang(sj3.kang (at) samsung.com) \n
     30  *   2nd Release
     31  *
     32  */
     33 
     34 #ifndef EXYNOS_CAMERA_HW_INTERFACE_2_H
     35 #define EXYNOS_CAMERA_HW_INTERFACE_2_H
     36 
     37 #include <hardware/camera2.h>
     38 #include <camera/Camera.h>
     39 #include <camera/CameraParameters.h>
     40 #include <utils/List.h>
     41 #include "SignalDrivenThread.h"
     42 #include "MetadataConverter.h"
     43 #include "exynos_v4l2.h"
     44 #include "ExynosRect.h"
     45 #include "ExynosBuffer.h"
     46 #include "videodev2_exynos_camera.h"
     47 #include "gralloc_priv.h"
     48 #include "ExynosJpegEncoderForCamera.h"
     49 #include <fcntl.h>
     50 #include "fimc-is-metadata.h"
     51 #include "ion.h"
     52 #include "ExynosExif.h"
     53 #include "csc.h"
     54 #include "ExynosCamera2.h"
     55 #include "cutils/properties.h"
     56 
     57 namespace android {
     58 
     59 //#define EXYNOS_CAMERA_LOG
     60 #define ENABLE_FRAME_SYNC
     61 #define NODE_PREFIX     "/dev/video"
     62 
     63 #define NUM_MAX_STREAM_THREAD       (5)
     64 #define NUM_MAX_REQUEST_MGR_ENTRY   (5)
     65 #define NUM_MAX_CAMERA_BUFFERS      (16)
     66 #define NUM_BAYER_BUFFERS           (8)
     67 #define NUM_SCC_BUFFERS             (8)
     68 #define NUM_SCP_BUFFERS             (8)
     69 #define NUM_MIN_SENSOR_QBUF         (3)
     70 #define NUM_MAX_SUBSTREAM           (4)
     71 
     72 #define PICTURE_GSC_NODE_NUM (2)
     73 #define VIDEO_GSC_NODE_NUM (1)
     74 
     75 #define STREAM_TYPE_DIRECT   (0)
     76 #define STREAM_TYPE_INDIRECT (1)
     77 
     78 #define SIGNAL_MAIN_REQ_Q_NOT_EMPTY             (SIGNAL_THREAD_COMMON_LAST<<1)
     79 
     80 #define SIGNAL_MAIN_STREAM_OUTPUT_DONE          (SIGNAL_THREAD_COMMON_LAST<<3)
     81 #define SIGNAL_SENSOR_START_REQ_PROCESSING      (SIGNAL_THREAD_COMMON_LAST<<4)
     82 
     83 #define SIGNAL_THREAD_RELEASE                   (SIGNAL_THREAD_COMMON_LAST<<8)
     84 
     85 #define SIGNAL_STREAM_REPROCESSING_START        (SIGNAL_THREAD_COMMON_LAST<<14)
     86 #define SIGNAL_STREAM_DATA_COMING               (SIGNAL_THREAD_COMMON_LAST<<15)
     87 
     88 #define NO_TRANSITION                   (0)
     89 #define HAL_AFSTATE_INACTIVE            (1)
     90 #define HAL_AFSTATE_NEEDS_COMMAND       (2)
     91 #define HAL_AFSTATE_STARTED             (3)
     92 #define HAL_AFSTATE_SCANNING            (4)
     93 #define HAL_AFSTATE_LOCKED              (5)
     94 #define HAL_AFSTATE_FAILED              (6)
     95 #define HAL_AFSTATE_NEEDS_DETERMINATION (7)
     96 #define HAL_AFSTATE_PASSIVE_FOCUSED     (8)
     97 
     98 #define STREAM_ID_PREVIEW           (0)
     99 #define STREAM_MASK_PREVIEW         (1<<STREAM_ID_PREVIEW)
    100 #define STREAM_ID_RECORD            (1)
    101 #define STREAM_MASK_RECORD          (1<<STREAM_ID_RECORD)
    102 #define STREAM_ID_PRVCB             (2)
    103 #define STREAM_MASK_PRVCB           (1<<STREAM_ID_PRVCB)
    104 #define STREAM_ID_JPEG              (4)
    105 #define STREAM_MASK_JPEG            (1<<STREAM_ID_JPEG)
    106 #define STREAM_ID_ZSL               (5)
    107 #define STREAM_MASK_ZSL             (1<<STREAM_ID_ZSL)
    108 
    109 #define STREAM_ID_JPEG_REPROCESS    (8)
    110 #define STREAM_ID_LAST              STREAM_ID_JPEG_REPROCESS
    111 
    112 #define MASK_OUTPUT_SCP             (STREAM_MASK_PREVIEW|STREAM_MASK_RECORD|STREAM_MASK_PRVCB)
    113 #define MASK_OUTPUT_SCC             (STREAM_MASK_JPEG|STREAM_MASK_ZSL)
    114 
    115 #define SUBSTREAM_TYPE_NONE         (0)
    116 #define SUBSTREAM_TYPE_JPEG         (1)
    117 #define SUBSTREAM_TYPE_RECORD       (2)
    118 #define SUBSTREAM_TYPE_PRVCB        (3)
    119 #define FLASH_STABLE_WAIT_TIMEOUT        (10)
    120 
    121 #define SIG_WAITING_TICK            (5000)
    122 
    123 #ifdef EXYNOS_CAMERA_LOG
    124 #define CAM_LOGV(...) ((void)ALOG(LOG_VERBOSE, LOG_TAG, __VA_ARGS__))
    125 #define CAM_LOGD(...) ((void)ALOG(LOG_DEBUG, LOG_TAG, __VA_ARGS__))
    126 #define CAM_LOGW(...) ((void)ALOG(LOG_WARN, LOG_TAG, __VA_ARGS__))
    127 #define CAM_LOGE(...) ((void)ALOG(LOG_ERROR, LOG_TAG, __VA_ARGS__))
    128 #else
    129 #define CAM_LOGV(...) ((void)0)
    130 #define CAM_LOGD(...) ((void)0)
    131 #define CAM_LOGW(...) ((void)0)
    132 #define CAM_LOGE(...) ((void)0)
    133 #endif
    134 
    135 enum sensor_name {
    136     SENSOR_NAME_S5K3H2  = 1,
    137     SENSOR_NAME_S5K6A3  = 2,
    138     SENSOR_NAME_S5K4E5  = 3,
    139     SENSOR_NAME_S5K3H7  = 4,
    140     SENSOR_NAME_CUSTOM  = 5,
    141     SENSOR_NAME_END
    142 };
    143 
    144 enum is_subscenario_id {
    145 	ISS_SUB_SCENARIO_STILL,
    146 	ISS_SUB_SCENARIO_VIDEO,
    147 	ISS_SUB_SCENARIO_SCENE1,
    148 	ISS_SUB_SCENARIO_SCENE2,
    149 	ISS_SUB_SCENARIO_SCENE3,
    150 	ISS_SUB_END
    151 };
    152 
    153 int SUPPORT_THUMBNAIL_REAR_SIZE[][2] =
    154 {
    155     {160, 120},
    156     {160, 90},
    157     {144, 96}
    158 };
    159 
    160 int SUPPORT_THUMBNAIL_FRONT_SIZE[][2] =
    161 {
    162     {160, 120},
    163     {160, 160},
    164     {160, 90},
    165     {144, 96}
    166 };
    167 
    168 enum is_set_flash_command_state {
    169     IS_FLASH_STATE_NONE = 0,
    170     IS_FLASH_STATE_ON = 1,
    171     IS_FLASH_STATE_ON_WAIT,
    172     IS_FLASH_STATE_ON_DONE,
    173     IS_FLASH_STATE_AUTO_AE_AWB_LOCK,
    174     IS_FLASH_STATE_AE_AWB_LOCK_WAIT,
    175     IS_FLASH_STATE_AUTO_WAIT,
    176     IS_FLASH_STATE_AUTO_DONE,
    177     IS_FLASH_STATE_AUTO_OFF,
    178     IS_FLASH_STATE_CAPTURE,
    179     IS_FLASH_STATE_CAPTURE_WAIT,
    180     IS_FLASH_STATE_CAPTURE_JPEG,
    181     IS_FLASH_STATE_CAPTURE_END,
    182     IS_FALSH_STATE_MAX
    183 };
    184 
    185 enum is_set_command_state {
    186     IS_COMMAND_NONE = 0,
    187     IS_COMMAND_EXECUTION,
    188     IS_COMMAND_CLEAR,
    189     IS_COMMAND_MAX
    190 };
    191 
    192 typedef struct node_info {
    193     int fd;
    194     int width;
    195     int height;
    196     int format;
    197     int planes;
    198     int buffers;
    199     enum v4l2_memory memory;
    200     enum v4l2_buf_type type;
    201     ExynosBuffer buffer[NUM_MAX_CAMERA_BUFFERS];
    202     int status;
    203 } node_info_t;
    204 
    205 
    206 typedef struct camera_hw_info {
    207     int sensor_id;
    208 
    209     node_info_t sensor;
    210     node_info_t isp;
    211     node_info_t capture;
    212     node_info_t scp;
    213 
    214     /*shot*/  // temp
    215     struct camera2_shot_ext dummy_shot;
    216 
    217 } camera_hw_info_t;
    218 
    219 typedef enum request_entry_status {
    220     EMPTY,
    221     REGISTERED,
    222     REQUESTED,
    223     CAPTURED,
    224     METADONE,
    225     COMPLETED
    226 } request_entry_status_t;
    227 
    228 typedef struct request_manager_entry {
    229     request_entry_status_t      status;
    230     camera_metadata_t           *original_request;
    231     struct camera2_shot_ext     internal_shot;
    232     int                         output_stream_count;
    233 } request_manager_entry_t;
    234 
    235 // structure related to a specific function of camera
    236 typedef struct af_control_info {
    237     int    m_afTriggerTimeOut;
    238 } ctl_af_info_t;
    239 
    240 typedef struct flash_control_info {
    241     // UI flash mode indicator
    242     enum aa_aemode    i_flashMode;
    243     // AF flash
    244     bool        m_afFlashDoneFlg;
    245     // Capture flash
    246     bool        m_flashEnableFlg;
    247     int         m_flashFrameCount;
    248     int         m_flashCnt;
    249     int        m_flashTimeOut;
    250     // Flash decision
    251     // At flash auto mode only : 1 -> flash is needed, 0 -> normal case
    252     bool        m_flashDecisionResult;
    253     // torch indicator. this will be replaced by flashMode meta
    254     bool        m_flashTorchMode;
    255     // for precapture metering
    256     int        m_precaptureState;
    257     int        m_precaptureTriggerId;
    258 } ctl_flash_info_t;
    259 
    260 typedef struct ae_control_info {
    261     // pre-capture notification state
    262     enum ae_state    aeStateNoti;
    263 } ctl_ae_info_t;
    264 
    265 typedef struct scene_control_info {
    266     // pre-capture notification state
    267     enum aa_scene_mode    prevSceneMode;
    268 } ctl_scene_info_t;
    269 
    270 typedef struct request_control_info {
    271     ctl_flash_info_t flash;
    272     ctl_ae_info_t ae;
    273     ctl_af_info_t af;
    274     ctl_scene_info_t scene;
    275 } ctl_request_info_t;
    276 
    277 class RequestManager {
    278 public:
    279     RequestManager(SignalDrivenThread* main_thread);
    280     ~RequestManager();
    281     void    ResetEntry();
    282     int     GetNumEntries();
    283     bool    IsRequestQueueFull();
    284 
    285     void    RegisterRequest(camera_metadata_t *new_request, int * afMode, uint32_t * afRegion);
    286     void    DeregisterRequest(camera_metadata_t **deregistered_request);
    287     bool    PrepareFrame(size_t *num_entries, size_t *frame_size,
    288                 camera_metadata_t **prepared_frame, int afState);
    289     int     MarkProcessingRequest(ExynosBuffer * buf);
    290     void    NotifyStreamOutput(int frameCnt);
    291     void    ApplyDynamicMetadata(struct camera2_shot_ext *shot_ext);
    292     void    CheckCompleted(int index);
    293     void    UpdateIspParameters(struct camera2_shot_ext *shot_ext, int frameCnt, ctl_request_info_t *ctl_info);
    294     void    RegisterTimestamp(int frameCnt, nsecs_t *frameTime);
    295     nsecs_t  GetTimestampByFrameCnt(int frameCnt);
    296     nsecs_t  GetTimestamp(int index);
    297     uint8_t  GetOutputStreamByFrameCnt(int frameCnt);
    298     uint8_t  GetOutputStream(int index);
    299     camera2_shot_ext *  GetInternalShotExtByFrameCnt(int frameCnt);
    300     camera2_shot_ext *  GetInternalShotExt(int index);
    301     int     FindFrameCnt(struct camera2_shot_ext * shot_ext);
    302     bool    IsVdisEnable(void);
    303     int     FindEntryIndexByFrameCnt(int frameCnt);
    304     void    Dump(void);
    305     int     GetNextIndex(int index);
    306     int     GetPrevIndex(int index);
    307     void    SetDefaultParameters(int cropX);
    308     void    SetInitialSkip(int count);
    309     int     GetSkipCnt();
    310     int     GetCompletedIndex();
    311     void    pushSensorQ(int index);
    312     int     popSensorQ();
    313     void    releaseSensorQ();
    314 private:
    315 
    316     MetadataConverter               *m_metadataConverter;
    317     SignalDrivenThread              *m_mainThread;
    318     Mutex                           m_numOfEntriesLock;
    319     int                             m_numOfEntries;
    320     int                             m_entryInsertionIndex;
    321     int                             m_entryProcessingIndex;
    322     int                             m_entryFrameOutputIndex;
    323     request_manager_entry_t         entries[NUM_MAX_REQUEST_MGR_ENTRY];
    324     int                             m_completedIndex;
    325 
    326     Mutex                           m_requestMutex;
    327 
    328     //TODO : alloc dynamically
    329     char                            m_tempFrameMetadataBuf[2000];
    330     camera_metadata_t               *m_tempFrameMetadata;
    331 
    332     int                             m_sensorPipelineSkipCnt;
    333     int                             m_cropX;
    334     int                             m_lastCompletedFrameCnt;
    335     int                             m_lastAeMode;
    336     int                             m_lastAaMode;
    337     int                             m_lastAwbMode;
    338     int                             m_lastAeComp;
    339     bool                            m_vdisBubbleEn;
    340     nsecs_t                         m_lastTimeStamp;
    341     List<int>                   m_sensorQ;
    342 };
    343 
    344 
    345 typedef struct bayer_buf_entry {
    346     int     status;
    347     int     reqFrameCnt;
    348     nsecs_t timeStamp;
    349 } bayer_buf_entry_t;
    350 
    351 
    352 class BayerBufManager {
    353 public:
    354     BayerBufManager();
    355     ~BayerBufManager();
    356     int                 GetIndexForSensorEnqueue();
    357     int                 MarkSensorEnqueue(int index);
    358     int                 MarkSensorDequeue(int index, int reqFrameCnt, nsecs_t *timeStamp);
    359     int                 GetIndexForIspEnqueue(int *reqFrameCnt);
    360     int                 GetIndexForIspDequeue(int *reqFrameCnt);
    361     int                 MarkIspEnqueue(int index);
    362     int                 MarkIspDequeue(int index);
    363     int                 GetNumOnSensor();
    364     int                 GetNumOnHalFilled();
    365     int                 GetNumOnIsp();
    366 
    367 private:
    368     int                 GetNextIndex(int index);
    369 
    370     int                 sensorEnqueueHead;
    371     int                 sensorDequeueHead;
    372     int                 ispEnqueueHead;
    373     int                 ispDequeueHead;
    374     int                 numOnSensor;
    375     int                 numOnIsp;
    376     int                 numOnHalFilled;
    377     int                 numOnHalEmpty;
    378 
    379     bayer_buf_entry_t   entries[NUM_BAYER_BUFFERS];
    380 };
    381 
    382 
    383 #define NOT_AVAILABLE           (0)
    384 #define REQUIRES_DQ_FROM_SVC    (1)
    385 #define ON_DRIVER               (2)
    386 #define ON_HAL                  (3)
    387 #define ON_SERVICE              (4)
    388 
    389 #define BAYER_NOT_AVAILABLE     (0)
    390 #define BAYER_ON_SENSOR         (1)
    391 #define BAYER_ON_HAL_FILLED     (2)
    392 #define BAYER_ON_ISP            (3)
    393 #define BAYER_ON_SERVICE        (4)
    394 #define BAYER_ON_HAL_EMPTY      (5)
    395 
    396 typedef struct stream_parameters {
    397             uint32_t                width;
    398             uint32_t                height;
    399             int                     format;
    400     const   camera2_stream_ops_t*   streamOps;
    401             uint32_t                usage;
    402             int                     numHwBuffers;
    403             int                     numSvcBuffers;
    404             int                     numOwnSvcBuffers;
    405             int                     planes;
    406             int                     metaPlanes;
    407             int                     numSvcBufsInHal;
    408             buffer_handle_t         svcBufHandle[NUM_MAX_CAMERA_BUFFERS];
    409             ExynosBuffer            svcBuffers[NUM_MAX_CAMERA_BUFFERS];
    410             ExynosBuffer            metaBuffers[NUM_MAX_CAMERA_BUFFERS];
    411             int                     svcBufStatus[NUM_MAX_CAMERA_BUFFERS];
    412             int                     bufIndex;
    413             node_info_t             *node;
    414             int                     minUndequedBuffer;
    415             bool                    needsIonMap;
    416 } stream_parameters_t;
    417 
    418 typedef struct substream_parameters {
    419             int                     type;
    420             uint32_t                width;
    421             uint32_t                height;
    422             int                     format;
    423     const   camera2_stream_ops_t*   streamOps;
    424             uint32_t                usage;
    425             int                     numSvcBuffers;
    426             int                     numOwnSvcBuffers;
    427             int                     internalFormat;
    428             int                     internalPlanes;
    429             int                     svcPlanes;
    430             buffer_handle_t         svcBufHandle[NUM_MAX_CAMERA_BUFFERS];
    431             ExynosBuffer            svcBuffers[NUM_MAX_CAMERA_BUFFERS];
    432             int                     svcBufStatus[NUM_MAX_CAMERA_BUFFERS];
    433             int                     svcBufIndex;
    434             int                     numSvcBufsInHal;
    435             bool                    needBufferInit;
    436             int                     minUndequedBuffer;
    437 } substream_parameters_t;
    438 
    439 typedef struct substream_entry {
    440     int                     priority;
    441     int                     streamId;
    442 } substream_entry_t;
    443 
    444 class ExynosCameraHWInterface2 : public virtual RefBase {
    445 public:
    446     ExynosCameraHWInterface2(int cameraId, camera2_device_t *dev, ExynosCamera2 * camera, int *openInvalid);
    447     virtual             ~ExynosCameraHWInterface2();
    448 
    449     virtual void        release();
    450 
    451     inline  int         getCameraId() const;
    452 
    453     virtual int         setRequestQueueSrcOps(const camera2_request_queue_src_ops_t *request_src_ops);
    454     virtual int         notifyRequestQueueNotEmpty();
    455     virtual int         setFrameQueueDstOps(const camera2_frame_queue_dst_ops_t *frame_dst_ops);
    456     virtual int         getInProgressCount();
    457     virtual int         flushCapturesInProgress();
    458     virtual int         constructDefaultRequest(int request_template, camera_metadata_t **request);
    459     virtual int         allocateStream(uint32_t width, uint32_t height,
    460                                     int format, const camera2_stream_ops_t *stream_ops,
    461                                     uint32_t *stream_id, uint32_t *format_actual, uint32_t *usage, uint32_t *max_buffers);
    462     virtual int         registerStreamBuffers(uint32_t stream_id, int num_buffers, buffer_handle_t *buffers);
    463     virtual int         releaseStream(uint32_t stream_id);
    464     virtual int         allocateReprocessStream(uint32_t width, uint32_t height,
    465                                     uint32_t format, const camera2_stream_in_ops_t *reprocess_stream_ops,
    466                                     uint32_t *stream_id, uint32_t *consumer_usage, uint32_t *max_buffers);
    467     virtual int         allocateReprocessStreamFromStream(uint32_t output_stream_id,
    468                                 const camera2_stream_in_ops_t *reprocess_stream_ops, uint32_t *stream_id);
    469     virtual int         releaseReprocessStream(uint32_t stream_id);
    470     virtual int         triggerAction(uint32_t trigger_id, int ext1, int ext2);
    471     virtual int         setNotifyCallback(camera2_notify_callback notify_cb, void *user);
    472     virtual int         getMetadataVendorTagOps(vendor_tag_query_ops_t **ops);
    473     virtual int         dump(int fd);
    474 private:
    475 class MainThread : public SignalDrivenThread {
    476         ExynosCameraHWInterface2 *mHardware;
    477     public:
    478         MainThread(ExynosCameraHWInterface2 *hw):
    479             SignalDrivenThread(),
    480             mHardware(hw) { }
    481         ~MainThread();
    482         void threadFunctionInternal()
    483 	    {
    484             mHardware->m_mainThreadFunc(this);
    485             return;
    486         }
    487         void        release(void);
    488         bool        m_releasing;
    489     };
    490 
    491     class SensorThread : public SignalDrivenThread {
    492         ExynosCameraHWInterface2 *mHardware;
    493     public:
    494         SensorThread(ExynosCameraHWInterface2 *hw):
    495             SignalDrivenThread(),
    496             mHardware(hw) { }
    497         ~SensorThread();
    498         void threadFunctionInternal() {
    499             mHardware->m_sensorThreadFunc(this);
    500             return;
    501         }
    502         void            release(void);
    503     //private:
    504         bool            m_releasing;
    505     };
    506 
    507     class StreamThread : public SignalDrivenThread {
    508         ExynosCameraHWInterface2 *mHardware;
    509     public:
    510         StreamThread(ExynosCameraHWInterface2 *hw, uint8_t new_index):
    511             SignalDrivenThread(),
    512             mHardware(hw),
    513             m_index(new_index) { }
    514         ~StreamThread();
    515         void threadFunctionInternal() {
    516             mHardware->m_streamThreadFunc(this);
    517             return;
    518         }
    519         void        setParameter(stream_parameters_t * new_parameters);
    520         status_t    attachSubStream(int stream_id, int priority);
    521         status_t    detachSubStream(int stream_id);
    522         void        release(void);
    523         int         findBufferIndex(void * bufAddr);
    524         int         findBufferIndex(buffer_handle_t * bufHandle);
    525 
    526         uint8_t                         m_index;
    527         bool                            m_activated;
    528     //private:
    529         stream_parameters_t             m_parameters;
    530         stream_parameters_t             *m_tempParameters;
    531         substream_entry_t               m_attachedSubStreams[NUM_MAX_SUBSTREAM];
    532         bool                            m_isBufferInit;
    533         bool                            m_releasing;
    534         int                             streamType;
    535         int                             m_numRegisteredStream;
    536      };
    537 
    538     sp<MainThread>      m_mainThread;
    539     sp<SensorThread>    m_sensorThread;
    540     sp<StreamThread>    m_streamThreads[NUM_MAX_STREAM_THREAD];
    541     substream_parameters_t  m_subStreams[STREAM_ID_LAST+1];
    542 
    543 
    544 
    545     RequestManager      *m_requestManager;
    546     BayerBufManager     *m_BayerManager;
    547     ExynosCamera2       *m_camera2;
    548 
    549     void                m_mainThreadFunc(SignalDrivenThread * self);
    550     void                m_sensorThreadFunc(SignalDrivenThread * self);
    551     void                m_streamThreadFunc(SignalDrivenThread * self);
    552     void                m_streamThreadInitialize(SignalDrivenThread * self);
    553 
    554     void                m_streamFunc_direct(SignalDrivenThread *self);
    555     void                m_streamFunc_indirect(SignalDrivenThread *self);
    556 
    557     void                m_streamBufferInit(SignalDrivenThread *self);
    558 
    559     int                 m_runSubStreamFunc(StreamThread *selfThread, ExynosBuffer *srcImageBuf,
    560                             int stream_id, nsecs_t frameTimeStamp);
    561     int                 m_jpegCreator(StreamThread *selfThread, ExynosBuffer *srcImageBuf, nsecs_t frameTimeStamp);
    562     int                 m_recordCreator(StreamThread *selfThread, ExynosBuffer *srcImageBuf, nsecs_t frameTimeStamp);
    563     int                 m_prvcbCreator(StreamThread *selfThread, ExynosBuffer *srcImageBuf, nsecs_t frameTimeStamp);
    564     void                m_getAlignedYUVSize(int colorFormat, int w, int h,
    565                                                 ExynosBuffer *buf);
    566     bool                m_getRatioSize(int  src_w,  int   src_h,
    567                                              int  dst_w,  int   dst_h,
    568                                              int *crop_x, int *crop_y,
    569                                              int *crop_w, int *crop_h,
    570                                              int zoom);
    571 	int				createIonClient(ion_client ionClient);
    572 	int					deleteIonClient(ion_client ionClient);
    573 
    574     int				allocCameraMemory(ion_client ionClient, ExynosBuffer *buf, int iMemoryNum);
    575     int             allocCameraMemory(ion_client ionClient, ExynosBuffer *buf, int iMemoryNum, int cacheFlag);
    576 	void				freeCameraMemory(ExynosBuffer *buf, int iMemoryNum);
    577 	void				initCameraMemory(ExynosBuffer *buf, int iMemoryNum);
    578 
    579     void            DumpInfoWithShot(struct camera2_shot_ext * shot_ext);
    580     bool            m_checkThumbnailSize(int w, int h);
    581     bool            yuv2Jpeg(ExynosBuffer *yuvBuf,
    582                             ExynosBuffer *jpegBuf,
    583                             ExynosRect *rect);
    584     int             InitializeISPChain();
    585     void            StartISP();
    586     void            StartSCCThread(bool threadExists);
    587     int             GetAfState();
    588     void            SetAfMode(enum aa_afmode afMode);
    589     void            SetAfRegion(uint32_t * afRegion);
    590     void            OnAfTrigger(int id);
    591     void            OnAfTriggerAutoMacro(int id);
    592     void            OnAfTriggerCAFPicture(int id);
    593     void            OnAfTriggerCAFVideo(int id);
    594     void            OnPrecaptureMeteringTriggerStart(int id);
    595     void            OnAfCancel(int id);
    596     void            OnAfCancelAutoMacro(int id);
    597     void            OnAfCancelCAFPicture(int id);
    598     void            OnAfCancelCAFVideo(int id);
    599     void            OnPrecaptureMeteringNotificationISP();
    600     void            OnPrecaptureMeteringNotificationSensor();
    601     void            OnAfNotification(enum aa_afstate noti);
    602     void            OnAfNotificationAutoMacro(enum aa_afstate noti);
    603     void            OnAfNotificationCAFPicture(enum aa_afstate noti);
    604     void            OnAfNotificationCAFVideo(enum aa_afstate noti);
    605     void            SetAfStateForService(int newState);
    606     int             GetAfStateForService();
    607     exif_attribute_t    mExifInfo;
    608     void            m_setExifFixedAttribute(void);
    609     void            m_setExifChangedAttribute(exif_attribute_t *exifInfo, ExynosRect *rect,
    610                          camera2_shot_ext *currentEntry);
    611     void            m_preCaptureSetter(struct camera2_shot_ext * shot_ext);
    612     void            m_preCaptureListenerSensor(struct camera2_shot_ext * shot_ext);
    613     void            m_preCaptureListenerISP(struct camera2_shot_ext * shot_ext);
    614     void            m_preCaptureAeState(struct camera2_shot_ext * shot_ext);
    615     void            m_updateAfRegion(struct camera2_shot_ext * shot_ext);
    616     void            m_afTrigger(struct camera2_shot_ext * shot_ext, int mode);
    617     void               *m_exynosPictureCSC;
    618     void               *m_exynosVideoCSC;
    619 
    620 
    621     camera2_request_queue_src_ops_t     *m_requestQueueOps;
    622     camera2_frame_queue_dst_ops_t       *m_frameQueueOps;
    623     camera2_notify_callback             m_notifyCb;
    624     void                                *m_callbackCookie;
    625 
    626     int                                 m_numOfRemainingReqInSvc;
    627     bool                                m_isRequestQueuePending;
    628     bool                                m_isRequestQueueNull;
    629     camera2_device_t                    *m_halDevice;
    630     static gralloc_module_t const*      m_grallocHal;
    631 
    632 
    633     camera_hw_info_t                     m_camera_info;
    634 
    635 	ion_client m_ionCameraClient;
    636 
    637     bool                                m_isIspStarted;
    638 
    639     int                                 m_need_streamoff;
    640     ExynosBuffer                        m_sccLocalBuffer[NUM_MAX_CAMERA_BUFFERS];
    641     bool                                m_sccLocalBufferValid;
    642 
    643     int                                 indexToQueue[3+1];
    644 
    645     bool                                m_scp_flushing;
    646     bool                                m_closing;
    647     ExynosBuffer                        m_resizeBuf;
    648 #ifndef ENABLE_FRAME_SYNC
    649     int                                 m_currentOutputStreams;
    650 #endif
    651     int                                 m_currentReprocessOutStreams;
    652     ExynosBuffer                        m_previewCbBuf;
    653     int             				    m_cameraId;
    654     bool                                m_scp_closing;
    655     bool                                m_scp_closed;
    656     bool                                m_wideAspect;
    657     uint32_t                            currentAfRegion[4];
    658     float                               m_zoomRatio;
    659 
    660     int                                 m_vdisBubbleCnt;
    661     int                                 m_vdisDupFrame;
    662 
    663     mutable Mutex                       m_qbufLock;
    664     mutable Mutex                       m_jpegEncoderLock;
    665     int                                 m_jpegEncodingCount;
    666     mutable Mutex                       m_afModeTriggerLock;
    667 
    668     bool                                m_scpForceSuspended;
    669     int                                 m_afState;
    670     int                                 m_afTriggerId;
    671     enum aa_afmode                      m_afMode;
    672     enum aa_afmode                      m_afMode2;
    673     bool                                m_IsAfModeUpdateRequired;
    674     bool                                m_IsAfTriggerRequired;
    675     bool                                m_IsAfLockRequired;
    676     int                                 m_serviceAfState;
    677     bool                                m_AfHwStateFailed;
    678     int                                 m_afPendingTriggerId;
    679     int                                 m_afModeWaitingCnt;
    680     struct camera2_shot_ext             m_jpegMetadata;
    681     int                                 m_scpOutputSignalCnt;
    682     int                                 m_scpOutputImageCnt;
    683     int                                 m_nightCaptureCnt;
    684     int                                 m_nightCaptureFrameCnt;
    685     int                                 m_lastSceneMode;
    686     int                                 m_thumbNailW;
    687     int                                 m_thumbNailH;
    688     int                                 m_reprocessStreamId;
    689     const camera2_stream_in_ops_t *     m_reprocessOps;
    690     int                                 m_reprocessOutputStreamId;
    691     int                                 m_reprocessingFrameCnt;
    692     ctl_request_info_t        m_ctlInfo;
    693 };
    694 
    695 }; // namespace android
    696 
    697 #endif
    698