libcamera2/ExynosCameraHWInterface2.h

   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@samsung.com)
  23  * \date      2012/07/10
  24  *
  25  * <b>Revision History: </b>
  26  * - 2012/05/31 : Sungjoong Kang(sj3.kang@samsung.com) \n
  27  *   Initial Release
  28   *
  29  * - 2012/07/10 : Sungjoong Kang(sj3.kang@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 "SignalDrivenThread.h"
  41 #include "MetadataConverter.h"
  42 #include "exynos_v4l2.h"
  43 #include "ExynosRect.h"
  44 #include "ExynosBuffer.h"
  45 #include "videodev2_exynos_camera.h"
  46 #include "gralloc_priv.h"
  47 #include "ExynosJpegEncoderForCamera.h"
  48 #include <fcntl.h>
  49 #include "fimc-is-metadata.h"
  50 #include "ion.h"
  51 #include "ExynosExif.h"
  52 #include "csc.h"
  53 #include "ExynosCamera2.h"
  54
  55 namespace android {
  56
  57
  58 #define NODE_PREFIX     "/dev/video"
  59
  60 #define NUM_MAX_STREAM_THREAD       (5)
  61 #define NUM_MAX_REQUEST_MGR_ENTRY   (10)
  62 #define NUM_MAX_DEQUEUED_REQUEST NUM_MAX_REQUEST_MGR_ENTRY
  63 #define MAX_CAMERA_MEMORY_PLANE_NUM     (4)
  64 #define NUM_MAX_CAMERA_BUFFERS      (16)
  65 #define NUM_BAYER_BUFFERS           (8)
  66 #define NUM_SENSOR_QBUF             (3)
  67
  68 #define PREVIEW_GSC_NODE_NUM (1)
  69 #define PICTURE_GSC_NODE_NUM (2)
  70
  71 #define STREAM_TYPE_DIRECT   (0)
  72 #define STREAM_TYPE_INDIRECT (1)
  73
  74 #define SIGNAL_MAIN_REQ_Q_NOT_EMPTY             (SIGNAL_THREAD_COMMON_LAST<<1)
  75 #define SIGNAL_MAIN_REPROCESS_Q_NOT_EMPTY       (SIGNAL_THREAD_COMMON_LAST<<2)
  76 #define SIGNAL_MAIN_STREAM_OUTPUT_DONE          (SIGNAL_THREAD_COMMON_LAST<<3)
  77 #define SIGNAL_SENSOR_START_REQ_PROCESSING      (SIGNAL_THREAD_COMMON_LAST<<4)
  78 #define SIGNAL_STREAM_GET_BUFFER                (SIGNAL_THREAD_COMMON_LAST<<5)
  79 #define SIGNAL_STREAM_PUT_BUFFER                (SIGNAL_THREAD_COMMON_LAST<<6)
  80 #define SIGNAL_STREAM_CHANGE_PARAMETER          (SIGNAL_THREAD_COMMON_LAST<<7)
  81 #define SIGNAL_THREAD_RELEASE                   (SIGNAL_THREAD_COMMON_LAST<<8)
  82 #define SIGNAL_ISP_START_BAYER_INPUT            (SIGNAL_THREAD_COMMON_LAST<<9)
  83 #define SIGNAL_ISP_START_BAYER_DEQUEUE          (SIGNAL_THREAD_COMMON_LAST<<10)
  84
  85 #define SIGNAL_STREAM_DATA_COMING               (SIGNAL_THREAD_COMMON_LAST<<15)
  86
  87 #define NO_TRANSITION                   (0)
  88 #define HAL_AFSTATE_INACTIVE            (1)
  89 #define HAL_AFSTATE_NEEDS_COMMAND       (2)
  90 #define HAL_AFSTATE_STARTED             (3)
  91 #define HAL_AFSTATE_SCANNING            (4)
  92 #define HAL_AFSTATE_LOCKED              (5)
  93 #define HAL_AFSTATE_FAILED              (6)
  94 #define HAL_AFSTATE_NEEDS_DETERMINATION (7)
  95 #define HAL_AFSTATE_PASSIVE_FOCUSED     (8)
  96
  97 enum sensor_name {
  98     SENSOR_NAME_S5K3H2  = 1,
  99     SENSOR_NAME_S5K6A3  = 2,
 100     SENSOR_NAME_S5K4E5  = 3,
 101     SENSOR_NAME_S5K3H7  = 4,
 102     SENSOR_NAME_CUSTOM  = 5,
 103     SENSOR_NAME_END
 104 };
 105
 106
 107 typedef struct node_info {
 108     int fd;
 109     int width;
 110     int height;
 111     int format;
 112     int planes;
 113     int buffers;
 114     enum v4l2_memory memory;
 115     enum v4l2_buf_type type;
 116     ion_client ionClient;
 117     ExynosBuffer buffer[NUM_MAX_CAMERA_BUFFERS];
 118 } node_info_t;
 119
 120
 121 typedef struct camera_hw_info {
 122     int sensor_id;
 123
 124     node_info_t sensor;
 125     node_info_t isp;
 126     node_info_t capture;
 127
 128     /*shot*/  // temp
 129     struct camera2_shot_ext dummy_shot;
 130
 131 } camera_hw_info_t;
 132
 133 typedef enum request_entry_status {
 134     EMPTY,
 135     REGISTERED,
 136     REQUESTED,
 137     CAPTURED
 138 } request_entry_status_t;
 139
 140 typedef struct request_manager_entry {
 141     request_entry_status_t      status;
 142     camera_metadata_t           *original_request;
 143     struct camera2_shot_ext     internal_shot;
 144     int                         output_stream_count;
 145     bool                         dynamic_meta_vaild;
 146 } request_manager_entry_t;
 147
 148 class RequestManager {
 149 public:
 150     RequestManager(SignalDrivenThread* main_thread);
 151     ~RequestManager();
 152     int     GetNumEntries();
 153     bool    IsRequestQueueFull();
 154
 155     void    RegisterRequest(camera_metadata_t *new_request);
 156     void    DeregisterRequest(camera_metadata_t **deregistered_request);
 157     bool    PrepareFrame(size_t *num_entries, size_t *frame_size,
 158                 camera_metadata_t **prepared_frame, int afState);
 159     int     MarkProcessingRequest(ExynosBuffer * buf, int *afMode);
 160     void      NotifyStreamOutput(int frameCnt, int stream_id);
 161     void    DumpInfoWithIndex(int index);
 162     void    ApplyDynamicMetadata(struct camera2_shot_ext *shot_ext);
 163     void    CheckCompleted(int index);
 164     void    UpdateIspParameters(struct camera2_shot_ext *shot_ext, int frameCnt, bool afTrigger);
 165     void    RegisterTimestamp(int frameCnt, nsecs_t *frameTime);
 166     uint64_t  GetTimestamp(int frameCnt);
 167     int     FindFrameCnt(struct camera2_shot_ext * shot_ext);
 168     int     FindEntryIndexByFrameCnt(int frameCnt);
 169     void    Dump(void);
 170     int     GetNextIndex(int index);
 171     void    SetDefaultParameters(int cropX);
 172     void    SetInitialSkip(int count);
 173     int     GetSkipCnt();
 174     void    SetFrameIndex(int index);
 175     int    GetFrameIndex();
 176 private:
 177
 178     MetadataConverter               *m_metadataConverter;
 179     SignalDrivenThread              *m_mainThread;
 180     int                             m_numOfEntries;
 181     int                             m_entryInsertionIndex;
 182     int                             m_entryProcessingIndex;
 183     int                             m_entryFrameOutputIndex;
 184     request_manager_entry_t         entries[NUM_MAX_REQUEST_MGR_ENTRY];
 185     int                             m_completedIndex;
 186
 187     Mutex                           m_requestMutex;
 188
 189     //TODO : alloc dynamically
 190     char                            m_tempFrameMetadataBuf[2000];
 191     camera_metadata_t               *m_tempFrameMetadata;
 192
 193     int                             m_sensorPipelineSkipCnt;
 194     int                             m_cropX;
 195     int                  m_frameIndex;
 196     int                             m_lastAeMode;
 197     int                             m_lastAaMode;
 198     int                             m_lastAwbMode;
 199     int                             m_lastAeComp;
 200 };
 201
 202
 203 typedef struct bayer_buf_entry {
 204     int     status;
 205     int     reqFrameCnt;
 206     nsecs_t timeStamp;
 207 } bayer_buf_entry_t;
 208
 209
 210 class BayerBufManager {
 211 public:
 212     BayerBufManager();
 213     ~BayerBufManager();
 214     int                 GetIndexForSensorEnqueue();
 215     int                 MarkSensorEnqueue(int index);
 216     int                 MarkSensorDequeue(int index, int reqFrameCnt, nsecs_t *timeStamp);
 217     int                 GetIndexForIspEnqueue(int *reqFrameCnt);
 218     int                 GetIndexForIspDequeue(int *reqFrameCnt);
 219     int                 MarkIspEnqueue(int index);
 220     int                 MarkIspDequeue(int index);
 221     int                 GetNumOnSensor();
 222     int                 GetNumOnHalFilled();
 223     int                 GetNumOnIsp();
 224
 225 private:
 226     int                 GetNextIndex(int index);
 227
 228     int                 sensorEnqueueHead;
 229     int                 sensorDequeueHead;
 230     int                 ispEnqueueHead;
 231     int                 ispDequeueHead;
 232     int                 numOnSensor;
 233     int                 numOnIsp;
 234     int                 numOnHalFilled;
 235     int                 numOnHalEmpty;
 236
 237     bayer_buf_entry_t   entries[NUM_BAYER_BUFFERS];
 238 };
 239
 240
 241 #define NOT_AVAILABLE           (0)
 242 #define REQUIRES_DQ_FROM_SVC    (1)
 243 #define ON_DRIVER               (2)
 244 #define ON_HAL                  (3)
 245 #define ON_SERVICE              (4)
 246
 247 #define BAYER_NOT_AVAILABLE     (0)
 248 #define BAYER_ON_SENSOR         (1)
 249 #define BAYER_ON_HAL_FILLED     (2)
 250 #define BAYER_ON_ISP            (3)
 251 #define BAYER_ON_SERVICE        (4)
 252 #define BAYER_ON_HAL_EMPTY      (5)
 253
 254 typedef struct stream_parameters {
 255             int                     streamType;
 256             uint32_t                outputWidth;
 257             uint32_t                outputHeight;
 258             uint32_t                nodeWidth;
 259             uint32_t                nodeHeight;
 260             int                     outputFormat;
 261             int                     nodeFormat;
 262     const   camera2_stream_ops_t*   streamOps;
 263             uint32_t                usage;
 264             int                     numHwBuffers;
 265             int                     numSvcBuffers;
 266             int                     numOwnSvcBuffers;
 267             int                     fd;
 268             int                     svcPlanes;
 269             int                     nodePlanes;
 270     enum v4l2_memory                memory;
 271     enum v4l2_buf_type              halBuftype;
 272             int                     numSvcBufsInHal;
 273             buffer_handle_t         svcBufHandle[NUM_MAX_CAMERA_BUFFERS];
 274             ExynosBuffer            svcBuffers[NUM_MAX_CAMERA_BUFFERS];
 275             int                     svcBufStatus[NUM_MAX_CAMERA_BUFFERS];
 276             int                     svcBufIndex;
 277             ion_client              ionClient;
 278             node_info_t             node;
 279 } stream_parameters_t;
 280
 281 typedef struct record_parameters {
 282             uint32_t                outputWidth;
 283             uint32_t                outputHeight;
 284             int                     outputFormat;
 285     const   camera2_stream_ops_t*   streamOps;
 286             uint32_t                usage;
 287             int                     numSvcBuffers;
 288             int                     numOwnSvcBuffers;
 289             int                     svcPlanes;
 290             buffer_handle_t         svcBufHandle[NUM_MAX_CAMERA_BUFFERS];
 291             ExynosBuffer            svcBuffers[NUM_MAX_CAMERA_BUFFERS];
 292             int                     svcBufStatus[NUM_MAX_CAMERA_BUFFERS];
 293             int                     svcBufIndex;
 294             int                     numSvcBufsInHal;
 295 } record_parameters_t;
 296
 297 class ExynosCameraHWInterface2 : public virtual RefBase {
 298 public:
 299     ExynosCameraHWInterface2(int cameraId, camera2_device_t *dev, ExynosCamera2 * camera);
 300     virtual             ~ExynosCameraHWInterface2();
 301
 302     virtual void        release();
 303
 304     inline  int         getCameraId() const;
 305
 306     virtual int         setRequestQueueSrcOps(const camera2_request_queue_src_ops_t *request_src_ops);
 307     virtual int         notifyRequestQueueNotEmpty();
 308     virtual int         setFrameQueueDstOps(const camera2_frame_queue_dst_ops_t *frame_dst_ops);
 309     virtual int         getInProgressCount();
 310     virtual int         flushCapturesInProgress();
 311     virtual int         constructDefaultRequest(int request_template, camera_metadata_t **request);
 312     virtual int         allocateStream(uint32_t width, uint32_t height,
 313                                     int format, const camera2_stream_ops_t *stream_ops,
 314                                     uint32_t *stream_id, uint32_t *format_actual, uint32_t *usage, uint32_t *max_buffers);
 315     virtual int         registerStreamBuffers(uint32_t stream_id, int num_buffers, buffer_handle_t *buffers);
 316     virtual int         releaseStream(uint32_t stream_id);
 317     virtual int         allocateReprocessStream(uint32_t width, uint32_t height,
 318                                     uint32_t format, const camera2_stream_in_ops_t *reprocess_stream_ops,
 319                                     uint32_t *stream_id, uint32_t *consumer_usage, uint32_t *max_buffers);
 320     virtual int         releaseReprocessStream(uint32_t stream_id);
 321     virtual int         triggerAction(uint32_t trigger_id, int ext1, int ext2);
 322     virtual int         setNotifyCallback(camera2_notify_callback notify_cb, void *user);
 323     virtual int         getMetadataVendorTagOps(vendor_tag_query_ops_t **ops);
 324     virtual int         dump(int fd);
 325 private:
 326 class MainThread : public SignalDrivenThread {
 327         ExynosCameraHWInterface2 *mHardware;
 328     public:
 329         MainThread(ExynosCameraHWInterface2 *hw):
 330             SignalDrivenThread(),
 331             mHardware(hw) {
 332 //            Start("MainThread", PRIORITY_DEFAULT, 0);
 333         }
 334         ~MainThread();
 335         status_t readyToRunInternal()
 336         {
 337             return NO_ERROR;
 338         }
 339         void threadFunctionInternal()
 340         {
 341             mHardware->m_mainThreadFunc(this);
 342             return;
 343         }
 344         void        release(void);
 345     };
 346
 347     class SensorThread : public SignalDrivenThread {
 348         ExynosCameraHWInterface2 *mHardware;
 349     public:
 350         SensorThread(ExynosCameraHWInterface2 *hw):
 351             SignalDrivenThread("SensorThread", PRIORITY_DEFAULT, 0),
 352             mHardware(hw),
 353             m_isBayerOutputEnabled(false) { }
 354         ~SensorThread();
 355         status_t readyToRunInternal() {
 356             mHardware->m_sensorThreadInitialize(this);
 357             return NO_ERROR;
 358         }
 359         void threadFunctionInternal() {
 360             mHardware->m_sensorThreadFunc(this);
 361             return;
 362         }
 363         void            release(void);
 364     //private:
 365         bool            m_isBayerOutputEnabled;
 366         int             m_sensorFd;
 367     };
 368
 369     class IspThread : public SignalDrivenThread {
 370         ExynosCameraHWInterface2 *mHardware;
 371     public:
 372         IspThread(ExynosCameraHWInterface2 *hw):
 373             SignalDrivenThread("IspThread", PRIORITY_DEFAULT, 0),
 374             mHardware(hw) { }
 375         ~IspThread();
 376         status_t readyToRunInternal() {
 377             mHardware->m_ispThreadInitialize(this);
 378             return NO_ERROR;
 379         }
 380         void threadFunctionInternal() {
 381             mHardware->m_ispThreadFunc(this);
 382             return;
 383         }
 384         void            release(void);
 385     //private:
 386         int             m_ispFd;
 387     };
 388
 389     class StreamThread : public SignalDrivenThread {
 390         ExynosCameraHWInterface2 *mHardware;
 391     public:
 392         StreamThread(ExynosCameraHWInterface2 *hw, uint8_t new_index):
 393             SignalDrivenThread("StreamThread", PRIORITY_DEFAULT, 0),
 394             mHardware(hw),
 395             m_index(new_index) { }
 396         ~StreamThread();
 397         status_t readyToRunInternal() {
 398             mHardware->m_streamThreadInitialize(this);
 399             return NO_ERROR;
 400         }
 401         void threadFunctionInternal() {
 402             mHardware->m_streamThreadFunc(this);
 403             return;
 404         }
 405         void        setRecordingParameter(record_parameters_t * recordParm);
 406         void        setParameter(stream_parameters_t * new_parameters);
 407         void        applyChange(void);
 408         void        release(void);
 409         int         findBufferIndex(void * bufAddr);
 410
 411
 412         uint8_t                         m_index;
 413         bool                            m_activated;
 414     //private:
 415         stream_parameters_t             m_parameters;
 416         stream_parameters_t             *m_tempParameters;
 417         record_parameters_t             m_recordParameters;
 418         bool                            m_isBufferInit;
 419         bool                            m_releasing;
 420      };
 421
 422     sp<MainThread>      m_mainThread;
 423     sp<SensorThread>    m_sensorThread;
 424     sp<IspThread>       m_ispThread;
 425     sp<StreamThread>    m_streamThreads[NUM_MAX_STREAM_THREAD];
 426
 427
 428
 429     RequestManager      *m_requestManager;
 430     BayerBufManager     *m_BayerManager;
 431     ExynosCamera2       *m_camera2;
 432
 433     void                m_mainThreadFunc(SignalDrivenThread * self);
 434     void                m_sensorThreadFunc(SignalDrivenThread * self);
 435     void                m_sensorThreadInitialize(SignalDrivenThread * self);
 436     void                m_ispThreadFunc(SignalDrivenThread * self);
 437     void                m_ispThreadInitialize(SignalDrivenThread * self);
 438     void                m_streamThreadFunc(SignalDrivenThread * self);
 439     void                m_streamThreadInitialize(SignalDrivenThread * self);
 440
 441     void                m_getAlignedYUVSize(int colorFormat, int w, int h,
 442                                                 ExynosBuffer *buf);
 443     bool                m_getRatioSize(int  src_w,  int   src_h,
 444                                              int  dst_w,  int   dst_h,
 445                                              int *crop_x, int *crop_y,
 446                                              int *crop_w, int *crop_h,
 447                                              int zoom);
 448         int                             createIonClient(ion_client ionClient);
 449         int                                     deleteIonClient(ion_client ionClient);
 450
 451     int                         allocCameraMemory(ion_client ionClient, ExynosBuffer *buf, int iMemoryNum);
 452         void                            freeCameraMemory(ExynosBuffer *buf, int iMemoryNum);
 453         void                            initCameraMemory(ExynosBuffer *buf, int iMemoryNum);
 454
 455     void            DumpInfoWithShot(struct camera2_shot_ext * shot_ext);
 456     bool            yuv2Jpeg(ExynosBuffer *yuvBuf,
 457                             ExynosBuffer *jpegBuf,
 458                             ExynosRect *rect);
 459     void            InitializeISPChain();
 460     void            StartISP();
 461     int             GetAfState();
 462     void            SetAfMode(enum aa_afmode afMode);
 463     void            OnAfTrigger(int id);
 464     void            OnAfTriggerAutoMacro(int id);
 465     void            OnAfTriggerCAFPicture(int id);
 466     void            OnAfTriggerCAFVideo(int id);
 467     void            OnAfCancel(int id);
 468     void            OnAfCancelAutoMacro(int id);
 469     void            OnAfCancelCAFPicture(int id);
 470     void            OnAfCancelCAFVideo(int id);
 471     void            OnAfNotification(enum aa_afstate noti);
 472     void            OnAfNotificationAutoMacro(enum aa_afstate noti);
 473     void            OnAfNotificationCAFPicture(enum aa_afstate noti);
 474     void            OnAfNotificationCAFVideo(enum aa_afstate noti);
 475     void            SetAfStateForService(int newState);
 476     int             GetAfStateForService();
 477     exif_attribute_t    mExifInfo;
 478     void               *m_exynosPictureCSC;
 479     void               *m_exynosVideoCSC;
 480
 481     int                 m_jpegEncodingFrameCnt;
 482
 483     camera2_request_queue_src_ops_t     *m_requestQueueOps;
 484     camera2_frame_queue_dst_ops_t       *m_frameQueueOps;
 485     camera2_notify_callback             m_notifyCb;
 486     void                                *m_callbackCookie;
 487
 488     int                                 m_numOfRemainingReqInSvc;
 489     bool                                m_isRequestQueuePending;
 490     bool                                m_isRequestQueueNull;
 491     camera2_device_t                    *m_halDevice;
 492     static gralloc_module_t const*      m_grallocHal;
 493
 494
 495     camera_hw_info_t                     m_camera_info;
 496
 497         ion_client m_ionCameraClient;
 498
 499     bool                                m_isSensorThreadOn;
 500     bool                                m_isSensorStarted;
 501     bool                                m_isIspStarted;
 502
 503     int                                 m_need_streamoff;
 504
 505     bool                                m_initFlag1;
 506     bool                                m_initFlag2;
 507     int                                 m_ispProcessingFrameCnt;
 508
 509     int                                 indexToQueue[3+1];
 510     int                                 m_fd_scp;
 511
 512     bool                                m_scp_flushing;
 513     bool                                m_closing;
 514     ExynosBuffer                        m_resizeBuf;
 515     bool                                m_recordingEnabled;
 516     int                                 m_previewOutput;
 517     int                                 m_recordOutput;
 518     bool                                m_needsRecordBufferInit;
 519     int                                 lastFrameCnt;
 520     int                                             m_cameraId;
 521     bool                                m_scp_closing;
 522     bool                                m_scp_closed;
 523
 524     mutable Mutex    m_qbufLock;
 525
 526     int                                 m_afState;
 527     int                                 m_afTriggerId;
 528     enum aa_afmode                      m_afMode;
 529     enum aa_afmode                      m_afMode2;
 530     bool                                m_IsAfModeUpdateRequired;
 531     bool                                m_IsAfTriggerRequired;
 532     bool                                m_IsAfLockRequired;
 533     int                                 m_serviceAfState;
 534 };
 535
 536 }; // namespace android
 537
 538 #endif