Camera.h

Go to the documentation of this file.

/*
 *  Camera.h - Camera include file for the Spresense SDK
 *  Copyright 2018, 2020-2022, 2024 Sony Semiconductor Solutions Corporation
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
#ifndef __SPRESENSE_CAMERA_CLASS_H__
#define __SPRESENSE_CAMERA_CLASS_H__
 
#ifdef SUBCORE
#error "Camera library is NOT supported by SubCore."
#endif
 
#include <stdint.h>
#include <stdlib.h>
 
#include <semaphore.h>
#include <pthread.h>
#include <mqueue.h>
 
#include <nuttx/video/video.h>
 
class CameraClass;
class CamImage;
 
enum CAM_IMAGE_PIX_FMT {
  CAM_IMAGE_PIX_FMT_RGB565 = V4L2_PIX_FMT_RGB565, 
  CAM_IMAGE_PIX_FMT_YUV422 = V4L2_PIX_FMT_UYVY,   
  CAM_IMAGE_PIX_FMT_JPG    = V4L2_PIX_FMT_JPEG,   
  CAM_IMAGE_PIX_FMT_GRAY,                         
  CAM_IMAGE_PIX_FMT_NONE,                         
};
 
 
enum CamErr {
  CAM_ERR_SUCCESS               = 0,   
  CAM_ERR_NO_DEVICE             = -1,  
  CAM_ERR_ILLEGAL_DEVERR        = -2,  
  CAM_ERR_ALREADY_INITIALIZED   = -3,  
  CAM_ERR_NOT_INITIALIZED       = -4,  
  CAM_ERR_NOT_STILL_INITIALIZED = -5,  
  CAM_ERR_CANT_CREATE_THREAD    = -6,  
  CAM_ERR_INVALID_PARAM         = -7,  
  CAM_ERR_NO_MEMORY             = -8,  
  CAM_ERR_USR_INUSED            = -9,  
  CAM_ERR_NOT_PERMITTED         = -10, 
};
 
enum CAM_DEVICE_TYPE {
  CAM_DEVICE_TYPE_UNKNOWN, 
  CAM_DEVICE_TYPE_ISX012,  
  CAM_DEVICE_TYPE_ISX019,  
};
 
enum CAM_WHITE_BALANCE {
  CAM_WHITE_BALANCE_AUTO          = V4L2_WHITE_BALANCE_AUTO,          
  CAM_WHITE_BALANCE_INCANDESCENT  = V4L2_WHITE_BALANCE_INCANDESCENT,  
  CAM_WHITE_BALANCE_FLUORESCENT   = V4L2_WHITE_BALANCE_FLUORESCENT,   
  CAM_WHITE_BALANCE_DAYLIGHT      = V4L2_WHITE_BALANCE_DAYLIGHT,      
  CAM_WHITE_BALANCE_FLASH         = V4L2_WHITE_BALANCE_FLASH,         
  CAM_WHITE_BALANCE_CLOUDY        = V4L2_WHITE_BALANCE_CLOUDY,        
  CAM_WHITE_BALANCE_SHADE         = V4L2_WHITE_BALANCE_SHADE,         
};
 
#define CAM_IMGSIZE_QQVGA_H   (160)   
#define CAM_IMGSIZE_QQVGA_V   (120)   
#define CAM_IMGSIZE_QVGA_H    (320)   
#define CAM_IMGSIZE_QVGA_V    (240)   
#define CAM_IMGSIZE_VGA_H     (640)   
#define CAM_IMGSIZE_VGA_V     (480)   
#define CAM_IMGSIZE_HD_H      (1280)  
#define CAM_IMGSIZE_HD_V      (720)   
#define CAM_IMGSIZE_QUADVGA_H (1280)  
#define CAM_IMGSIZE_QUADVGA_V (960)   
#define CAM_IMGSIZE_FULLHD_H  (1920)  
#define CAM_IMGSIZE_FULLHD_V  (1080)  
#define CAM_IMGSIZE_3M_H      (2048)  
#define CAM_IMGSIZE_3M_V      (1536)  
#define CAM_IMGSIZE_5M_H      (2560)  
#define CAM_IMGSIZE_5M_V      (1920)  
enum CAM_SCENE_MODE {
  CAM_SCENE_MODE_NONE         = V4L2_SCENE_MODE_NONE,         
  CAM_SCENE_MODE_BACKLIGHT    = V4L2_SCENE_MODE_BACKLIGHT,    
  CAM_SCENE_MODE_BEACH_SNOW   = V4L2_SCENE_MODE_BEACH_SNOW,   
  CAM_SCENE_MODE_CANDLE_LIGHT = V4L2_SCENE_MODE_CANDLE_LIGHT, 
  CAM_SCENE_MODE_DAWN_DUSK    = V4L2_SCENE_MODE_DAWN_DUSK,    
  CAM_SCENE_MODE_FALL_COLORS  = V4L2_SCENE_MODE_FALL_COLORS,  
  CAM_SCENE_MODE_FIREWORKS    = V4L2_SCENE_MODE_FIREWORKS,    
  CAM_SCENE_MODE_LANDSCAPE    = V4L2_SCENE_MODE_LANDSCAPE,    
  CAM_SCENE_MODE_NIGHT        = V4L2_SCENE_MODE_NIGHT,        
  CAM_SCENE_MODE_PARTY_INDOOR = V4L2_SCENE_MODE_PARTY_INDOOR, 
  CAM_SCENE_MODE_PORTRAIT     = V4L2_SCENE_MODE_PORTRAIT,     
  CAM_SCENE_MODE_SPORTS       = V4L2_SCENE_MODE_SPORTS,       
  CAM_SCENE_MODE_SUNSET       = V4L2_SCENE_MODE_SUNSET,       
};
 
 
enum CAM_COLOR_FX {
  CAM_COLOR_FX_NONE         = V4L2_COLORFX_NONE,           
  CAM_COLOR_FX_BW           = V4L2_COLORFX_BW,             
  CAM_COLOR_FX_SEPIA        = V4L2_COLORFX_SEPIA,          
  CAM_COLOR_FX_NEGATIVE     = V4L2_COLORFX_NEGATIVE,       
  CAM_COLOR_FX_EMBOSS       = V4L2_COLORFX_EMBOSS,         
  CAM_COLOR_FX_SKETCH       = V4L2_COLORFX_SKETCH,         
  CAM_COLOR_FX_SKY_BLUE     = V4L2_COLORFX_SKY_BLUE,       
  CAM_COLOR_FX_GRASS_GREEN  = V4L2_COLORFX_GRASS_GREEN,    
  CAM_COLOR_FX_SKIN_WHITEN  = V4L2_COLORFX_SKIN_WHITEN,    
  CAM_COLOR_FX_VIVID        = V4L2_COLORFX_VIVID,          
  CAM_COLOR_FX_AQUA         = V4L2_COLORFX_AQUA,           
  CAM_COLOR_FX_ART_FREEZE   = V4L2_COLORFX_ART_FREEZE,     
  CAM_COLOR_FX_SILHOUETTE   = V4L2_COLORFX_SILHOUETTE,     
  CAM_COLOR_FX_SOLARIZATION = V4L2_COLORFX_SOLARIZATION,   
  CAM_COLOR_FX_ANTIQUE      = V4L2_COLORFX_ANTIQUE,        
  CAM_COLOR_FX_SET_CBCR     = V4L2_COLORFX_SET_CBCR,       
  CAM_COLOR_FX_PASTEL       = V4L2_COLORFX_PASTEL,         
};
 
 
#define CAM_ISO_SENSITIVITY_1     (1000)      
#define CAM_ISO_SENSITIVITY_1_2   (1200)      
#define CAM_ISO_SENSITIVITY_1_6   (1600)      
#define CAM_ISO_SENSITIVITY_2     (2000)      
#define CAM_ISO_SENSITIVITY_2_5   (2500)      
#define CAM_ISO_SENSITIVITY_3_2   (3200)      
#define CAM_ISO_SENSITIVITY_4     (4000)      
#define CAM_ISO_SENSITIVITY_5     (5000)      
#define CAM_ISO_SENSITIVITY_6     (6000)      
#define CAM_ISO_SENSITIVITY_8     (8000)      
#define CAM_ISO_SENSITIVITY_10    (10000)     
#define CAM_ISO_SENSITIVITY_12    (12000)     
#define CAM_ISO_SENSITIVITY_16    (16000)     
#define CAM_ISO_SENSITIVITY_20    (20000)     
#define CAM_ISO_SENSITIVITY_25    (25000)     
#define CAM_ISO_SENSITIVITY_32    (32000)     
#define CAM_ISO_SENSITIVITY_40    (40000)     
#define CAM_ISO_SENSITIVITY_50    (50000)     
#define CAM_ISO_SENSITIVITY_64    (64000)     
#define CAM_ISO_SENSITIVITY_80    (80000)     
#define CAM_ISO_SENSITIVITY_100   (100000)    
#define CAM_ISO_SENSITIVITY_125   (125000)    
#define CAM_ISO_SENSITIVITY_160   (160000)    
#define CAM_ISO_SENSITIVITY_200   (200000)    
#define CAM_ISO_SENSITIVITY_250   (250000)    
#define CAM_ISO_SENSITIVITY_320   (320000)    
#define CAM_ISO_SENSITIVITY_400   (400000)    
#define CAM_ISO_SENSITIVITY_500   (500000)    
#define CAM_ISO_SENSITIVITY_640   (640000)    
#define CAM_ISO_SENSITIVITY_800   (800000)    
#define CAM_ISO_SENSITIVITY_1000  (1000000)   
#define CAM_ISO_SENSITIVITY_1250  (1250000)   
#define CAM_ISO_SENSITIVITY_1600  (1600000)   
#define CAM_ISO_SENSITIVITY_2000  (2000000)   
#define CAM_ISO_SENSITIVITY_2500  (2500000)   
#define CAM_ISO_SENSITIVITY_3200  (3200000)   
#define CAM_ISO_SENSITIVITY_4000  (4000000)   
#define CAM_ISO_SENSITIVITY_5000  (5000000)   
enum CAM_HDR_MODE {
  CAM_HDR_MODE_OFF  = 0, 
  CAM_HDR_MODE_AUTO = 1, 
  CAM_HDR_MODE_ON   = 2, 
};
 
enum CAM_VIDEO_FPS {
  CAM_VIDEO_FPS_NONE, 
  CAM_VIDEO_FPS_5,    
  CAM_VIDEO_FPS_6,    
  CAM_VIDEO_FPS_7_5,  
  CAM_VIDEO_FPS_15,   
  CAM_VIDEO_FPS_30,   
  CAM_VIDEO_FPS_60,   
  CAM_VIDEO_FPS_120,  
};
 
typedef void (*camera_cb_t)(CamImage img);
 
 
class ImgBuff {
  static const int SPRESENSE_CAMIMAGE_MEM_ALIGN = 32;
 
  int ref_count;
  uint8_t *buff;
  int width;
  int height;
  int idx;
  bool is_queue;
  enum v4l2_buf_type buf_type;
 
  CAM_IMAGE_PIX_FMT pix_fmt;
 
  size_t buf_size;
  size_t actual_size;
 
  CameraClass *cam_ref;
 
  sem_t my_sem;
 
  ImgBuff();
  ImgBuff(enum v4l2_buf_type type, int w, int h, CAM_IMAGE_PIX_FMT fmt, int jpgbufsize_divisor, CameraClass *cam);
  ~ImgBuff();
 
  bool is_valid(){ return (buff != NULL); };
 
  void lock()  { if(buff!=NULL) sem_wait(&my_sem); };
  void unlock(){ if(buff!=NULL) sem_post(&my_sem); };
 
  void queued(bool q){ lock(); is_queue = q; unlock(); };
  bool is_queued(void){ bool ret; lock(); ret = is_queue; unlock(); return ret; };
 
  void incRef();
  bool decRef();
 
  bool generate_imgmem(size_t s);
  size_t calc_img_size(int w, int h, CAM_IMAGE_PIX_FMT fmt, int jpgbufsize_divisor);
  void update_actual_size(size_t sz);
 
  static void delete_inst(ImgBuff *buf);
 
  friend CameraClass;
  friend CamImage;
};
 
 
class CamImage {
 
private:
  ImgBuff *img_buff;
 
  CamImage(enum v4l2_buf_type type, int w, int h, CAM_IMAGE_PIX_FMT fmt, int jpgbufsize_divisor = 7, CameraClass *cam = NULL);
  void setActualSize(size_t sz) { img_buff->update_actual_size(sz); };
  void setPixFormat(CAM_IMAGE_PIX_FMT pix_fmt) { if(img_buff != NULL) img_buff->pix_fmt = pix_fmt; }
  void setIdx(int i){ if(img_buff != NULL) img_buff->idx = i; }
  bool isIdx(int i){ return (img_buff != NULL) ? (img_buff->idx == i) : false; }
  int getIdx(){ return (img_buff != NULL) ? img_buff->idx : -1; }
  int getType(){ return (img_buff != NULL) ? img_buff->buf_type : -1; }
  bool is_valid(){ return (img_buff != NULL); };
 
  bool check_hw_resize_param(int iw, int ih, int ow, int oh);
  bool check_resize_magnification(int in, int out);
 
 
public:
  int getWidth(){ return (img_buff != NULL) ? img_buff->width : 0; }
 
  int getHeight(){ return (img_buff != NULL) ? img_buff->height : 0; }
 
  uint8_t * getImgBuff() { return (img_buff != NULL) ? img_buff->buff : NULL; }
 
  size_t getImgSize() { return (img_buff != NULL) ? img_buff->actual_size : 0; }
 
  size_t getImgBuffSize() { return (img_buff != NULL) ? img_buff->buf_size : 0; }
 
  CAM_IMAGE_PIX_FMT getPixFormat() { return (img_buff != NULL) ? img_buff->pix_fmt : CAM_IMAGE_PIX_FMT_NONE; }
 
  CamImage() : img_buff(NULL) {};
 
  CamImage(const CamImage &obj );
 
  CamImage &operator=(const CamImage &obj );
 
  CamErr convertPixFormat(CAM_IMAGE_PIX_FMT to_fmt );
 
  CamErr resizeImageByHW(
    CamImage &img, 
    int width, 
    int height 
  );
 
 
  CamErr clipAndResizeImageByHW(
    CamImage &img,     
    int lefttop_x,     
    int lefttop_y,     
    int rightbottom_x, 
    int rightbottom_y, 
    int width,         
    int height         
  );
 
 
  bool isAvailable(void);
 
  ~CamImage();
 
 
private:
 
  friend CameraClass;
};
 
 
 
class CameraClass {
private:
  friend ImgBuff;
 
  int video_fd;
  int video_init_stat;
  int video_buf_num;
  CAM_IMAGE_PIX_FMT video_pix_fmt;
  CAM_IMAGE_PIX_FMT still_pix_fmt;
  CamImage **video_imgs;
  CamImage *still_img;
  static CameraClass *instance;
  volatile bool loop_dqbuf_en;
 
  sem_t video_cb_access_sem;
  camera_cb_t video_cb;
 
  CameraClass(const char *path);
 
  CamErr convert_errno2camerr(int err);
  CamErr set_frame_parameters( enum v4l2_buf_type type, int video_width, int video_height, int buf_num, CAM_IMAGE_PIX_FMT video_fmt );
  CamErr create_videobuff(int w, int h, int buff_num, CAM_IMAGE_PIX_FMT fmt, int jpgbufsize_divisor);
  void delete_videobuff();
  CamErr enqueue_video_buffs();
  CamErr enqueue_video_buff(CamImage *img);
  bool is_device_ready();
  CamErr set_video_frame_rate(CAM_VIDEO_FPS fps);
  CamErr set_ext_ctrls(uint16_t ctl_cls, uint16_t cid, int32_t value);
  int32_t get_ext_ctrls(uint16_t ctl_cls, uint16_t cid);
  CamErr create_stillbuff(int w, int h, CAM_IMAGE_PIX_FMT fmt, int jpgbufsize_divisor);
  CamErr create_dq_thread();
  void   delete_dq_thread();
 
  void lock_video_cb()  { sem_wait(&video_cb_access_sem); };
  void unlock_video_cb(){ sem_post(&video_cb_access_sem); };
 
  pthread_t frame_tid;
  static void frame_handle_thread(void *);
  static const int CAM_FRAME_THREAD_STACK_SIZE = 2048;
  static const int CAM_FRAME_THREAD_STACK_PRIO = 101;
 
  mqd_t frame_exchange_mq;
  static const int CAM_FRAME_MQ_SIZE = 1;
 
  pthread_t dq_tid;
  static void dqbuf_thread(void *);
  static const int CAM_DQ_THREAD_STACK_SIZE = 1024;
  static const int CAM_DQ_THREAD_STACK_PRIO = 102;
 
  int ioctl_dequeue_stream_buf(struct v4l2_buffer *buf, uint16_t type);
  CamImage *search_vimg(int index);
  void release_buf(ImgBuff *buf);
 
public:
 
  ~CameraClass();
 
  static CameraClass getInstance();
 
  int getFd() { return (video_fd < 0) ? CAM_ERR_NO_DEVICE : video_fd; }
 
  CamErr begin(
    int buff_num = 1,                       
    CAM_VIDEO_FPS fps = CAM_VIDEO_FPS_30,   
    int video_width   = CAM_IMGSIZE_QVGA_H, 
    int video_height  = CAM_IMGSIZE_QVGA_V, 
    CAM_IMAGE_PIX_FMT video_fmt = CAM_IMAGE_PIX_FMT_YUV422, 
    int jpgbufsize_divisor = 7              
  );
 
  CamErr startStreaming(
    bool enable,          
    camera_cb_t cb = NULL 
  );
 
  CamErr setAutoWhiteBalance(bool enable );
 
  CamErr setAutoExposure(bool enable );
 
  CamErr setAbsoluteExposure(int32_t exposure_time);
 
  int32_t getAbsoluteExposure(void);
 
  CamErr setAutoISOSensitive(bool enable );
 
  CamErr setAutoISOSensitivity(bool enable );
 
  CamErr setISOSensitivity(int iso_sense );
 
  int getISOSensitivity(void);
 
  CamErr setAutoWhiteBalanceMode(CAM_WHITE_BALANCE wb );
 
#if 0 /* To Be Supported */
  /*
   * @brief Set Scene Mode.
   * @details [en] Set Scene Mode. <BR>
   *          [ja] シーンモードの設定。
   * @return [en] Error code defined as #CamErr. <BR>
   *         [ja] #CamErr で定義されているエラーコード
   */
  CamErr setSceneMode(CAM_SCENE_MODE mode );
#endif
 
  CamErr setColorEffect(CAM_COLOR_FX effect  );
 
  CamErr setHDR(CAM_HDR_MODE mode  );
 
  CAM_HDR_MODE getHDR(void);
 
  CamErr setJPEGQuality(int quality);
 
  int getJPEGQuality(void);
 
  int getFrameInterval(void);
 
  CamErr setStillPictureImageFormat(
    int img_width,                                    
    int img_height,                                   
    CAM_IMAGE_PIX_FMT img_fmt = CAM_IMAGE_PIX_FMT_JPG,
    int jpgbufsize_divisor = 7              
  );
 
  CamImage takePicture();
 
  CAM_DEVICE_TYPE getDeviceType();
 
  void end();
};
 
extern CameraClass theCamera;
 
#endif // __SPRESENSE_CAMERA_CLASS_H__