nuttx/drivers/video/v4l2_cap.c

/****************************************************************************
 * drivers/video/v4l2_cap.c
 *
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.  The
 * ASF licenses this file to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance with the
 * License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 ****************************************************************************/

/****************************************************************************
 * Included Files
 ****************************************************************************/

#include <debug.h>
#include <stdio.h>
#include <fcntl.h>
#include <assert.h>
#include <errno.h>
#include <poll.h>

#include <nuttx/mutex.h>
#include <nuttx/video/v4l2_cap.h>
#include <nuttx/video/video.h>

#include "video_framebuff.h"

/****************************************************************************
 * Pre-processor Definitions
 ****************************************************************************/

#define MAX_CAPTURE_FMT           (2)
#define CAPTURE_FMT_MAIN          (0)
#define CAPTURE_FMT_SUB           (1)

#define REMAINING_CAPNUM_INFINITY (-1)

/****************************************************************************
 * Private Types
 ****************************************************************************/

enum capture_state_e
{
  CAPTURE_STATE_STREAMOFF = 0, /* Capture trigger event is not received */
  CAPTURE_STATE_STREAMON  = 1, /* Capture trigger event is received,
                                * but capture is not operated.
                                */
  CAPTURE_STATE_CAPTURE   = 2, /* On capture */
};

enum capture_state_cause_e
{
  CAUSE_CAPTURE_STOP  = 0,     /* Stop  capture event for capture stream */
  CAUSE_CAPTURE_START = 1,     /* Start capture event for capture stream */
  CAUSE_CAPTURE_DQBUF = 2,     /* DQBUF timing        for video stream */
  CAUSE_STILL_STOP    = 3,     /* Stop  capture event for still stream */
  CAUSE_STILL_START   = 4,     /* Start capture event for still stream */
};

enum capture_waitend_cause_e
{
  WAITEND_CAUSE_CAPTUREDONE = 0,
  WAITEND_CAUSE_DQCANCEL    = 1,
  WAITEND_CAUSE_STILLSTOP   = 2,
};

struct video_format_s
{
  uint16_t width;
  uint16_t height;
  uint32_t pixelformat;
};

typedef struct video_format_s video_format_t;

struct capture_wait_capture_s
{
  sem_t                dqbuf_wait_flg;

  /* Save container which capture is done */

  FAR vbuf_container_t *done_container;
  enum capture_waitend_cause_e waitend_cause;
};

typedef struct capture_wait_capture_s capture_wait_capture_t;

struct capture_type_inf_s
{
  mutex_t                lock_state;
  enum capture_state_e   state;
  int32_t                remaining_capnum;
  capture_wait_capture_t wait_capture;
  uint8_t                nr_fmt;
  video_format_t         fmt[MAX_CAPTURE_FMT];
  struct v4l2_rect       clip;
  struct v4l2_fract      frame_interval;
  video_framebuff_t      bufinf;
  FAR uint8_t            *bufheap;   /* for V4L2_MEMORY_MMAP buffers */
  FAR struct pollfd      *fds;
  uint32_t               seqnum;
};

typedef struct capture_type_inf_s capture_type_inf_t;

struct capture_scene_params_s
{
  uint8_t mode;   /* enum v4l2_scene_mode */

  int32_t brightness;
  int32_t contrast;
  int32_t saturation;
  int32_t hue;
  bool    awb;
  int32_t red;
  int32_t blue;
  int32_t gamma;
  uint32_t gamma_curve_sz;
  FAR uint8_t *gamma_curve;
  int32_t ev;
  bool    hflip_video;
  bool    vflip_video;
  bool    hflip_still;
  bool    vflip_still;
  int32_t sharpness;
  enum v4l2_colorfx colorfx;
  bool    auto_brightness;
  int32_t rotate;
  enum  v4l2_exposure_auto_type ae;
  int32_t exposure_time;
  int32_t focus;
  bool    af;
  int32_t zoom;
  int32_t iris;
  enum v4l2_auto_n_preset_white_balance wb;
  int32_t wdr;
  bool    stabilization;
  enum v4l2_iso_sensitivity_auto_type iso_auto;
  int32_t iso;
  enum v4l2_exposure_metering meter;
  int32_t spot_pos;
  int32_t threea_lock;
  enum v4l2_flash_led_mode led;
  int32_t jpeg_quality;
};

typedef struct capture_scene_params_s capture_scene_params_t;

struct capture_parameter_name_s
{
  uint32_t id;
  FAR const char *name;
};

typedef struct capture_parameter_name_s capture_parameter_name_t;

struct capture_mng_s
{
  struct v4l2_s          v4l2;

  /* Parameter of capture_initialize() */

  mutex_t                lock_open_num;
  uint8_t                open_num;
  capture_type_inf_t     capture_inf;
  capture_type_inf_t     still_inf;
  FAR struct imgdata_s   *imgdata;
  FAR struct imgsensor_s *imgsensor;
  enum v4l2_scene_mode   capture_scene_mode;
  uint8_t                capture_scence_num;
  FAR capture_scene_params_t *capture_scene_param[V4L2_SCENE_MODE_MAX];
#ifndef CONFIG_DISABLE_PSEUDOFS_OPERATIONS
  bool                   unlinked;
#endif
};

typedef struct capture_mng_s capture_mng_t;

/****************************************************************************
 * Private Function Prototypes
 ****************************************************************************/

static FAR capture_type_inf_t *
get_capture_type_inf(FAR capture_mng_t *cmng, uint8_t type);
static enum capture_state_e
estimate_next_capture_state(FAR capture_mng_t *cmng,
                            enum capture_state_cause_e cause);
static void change_capture_state(FAR capture_mng_t *cmng,
                                 enum capture_state_e next_state);
static bool is_taking_still_picture(FAR capture_mng_t *cmng);
static bool is_bufsize_sufficient(FAR capture_mng_t *cmng, uint32_t bufsize);
static void cleanup_resources(FAR capture_mng_t *cmng);
static bool is_sem_waited(FAR sem_t *sem);
static int save_scene_param(FAR capture_mng_t *cmng,
                            enum v4l2_scene_mode mode,
                            uint32_t id,
                            FAR struct v4l2_ext_control *control);
static int complete_capture(uint8_t err_code, uint32_t datasize,
                            FAR const struct timeval *ts,
                            FAR void *arg);
static int validate_frame_setting(FAR capture_mng_t *cmng,
                                  enum v4l2_buf_type type,
                                  uint8_t nr_fmt,
                                  FAR video_format_t *vfmt,
                                  FAR struct v4l2_rect *clip,
                                  FAR struct v4l2_fract *interval);
static size_t get_bufsize(FAR video_format_t *vf);

/* ioctl function for each cmds of ioctl */

static int capture_querycap(FAR struct file *filep,
                            FAR struct v4l2_capability *cap);
static int capture_g_input(FAR int *num);
static int capture_enum_input(FAR struct file *filep,
                              FAR struct v4l2_input *input);
static int capture_reqbufs(FAR struct file *filep,
                           FAR struct v4l2_requestbuffers *reqbufs);
static int capture_querybuf(FAR struct file *filep,
                            FAR struct v4l2_buffer *buf);
static int capture_qbuf(FAR struct file *filep,
                        FAR struct v4l2_buffer *buf);
static int capture_dqbuf(FAR struct file *filep,
                         FAR struct v4l2_buffer *buf);
static int capture_cancel_dqbuf(FAR struct file *filep,
                                enum v4l2_buf_type type);
static int capture_g_fmt(FAR struct file *filep,
                         FAR struct v4l2_format *fmt);
static int capture_s_fmt(FAR struct file *filep,
                         FAR struct v4l2_format *fmt);
static int capture_try_fmt(FAR struct file *filep,
                           FAR struct v4l2_format *fmt);
static int capture_g_parm(FAR struct file *filep,
                          FAR struct v4l2_streamparm *parm);
static int capture_s_parm(FAR struct file *filep,
                          FAR struct v4l2_streamparm *parm);
static int capture_streamon(FAR struct file *filep,
                            FAR enum v4l2_buf_type *type);
static int capture_streamoff(FAR struct file *filep,
                             FAR enum v4l2_buf_type *type);
static int capture_do_halfpush(FAR struct file *filep,
                               bool enable);
static int capture_takepict_start(FAR struct file *filep,
                                  int32_t capture_num);
static int capture_takepict_stop(FAR struct file *filep,
                                 bool halfpush);
static int capture_s_selection(FAR struct file *filep,
                               FAR struct v4l2_selection *clip);
static int capture_g_selection(FAR struct file *filep,
                               FAR struct v4l2_selection *clip);
static int capture_queryctrl(FAR struct file *filep,
                             FAR struct v4l2_queryctrl *ctrl);
static int capture_query_ext_ctrl(FAR struct file *filep,
                                  FAR struct v4l2_query_ext_ctrl *ctrl);
static int capture_querymenu(FAR struct file *filep,
                             FAR struct v4l2_querymenu *menu);
static int capture_g_ctrl(FAR struct file *filep,
                          FAR struct v4l2_control *ctrl);
static int capture_s_ctrl(FAR struct file *filep,
                          FAR struct v4l2_control *ctrl);
static int capture_g_ext_ctrls(FAR struct file *filep,
                               FAR struct v4l2_ext_controls *ctrls);
static int capture_s_ext_ctrls(FAR struct file *filep,
                               FAR struct v4l2_ext_controls *ctrls);
static int capture_query_ext_ctrl_scene(FAR struct file *filep,
             FAR struct v4s_query_ext_ctrl_scene *ctrl);
static int capture_querymenu_scene(FAR struct file *filep,
             FAR struct v4s_querymenu_scene *menu);
static int capture_g_ext_ctrls_scene(FAR struct file *filep,
             FAR struct v4s_ext_controls_scene *ctrls);
static int capture_s_ext_ctrls_scene(FAR struct file *filep,
             FAR struct v4s_ext_controls_scene *ctrls);
static int capture_enum_fmt(FAR struct file *filep,
                            FAR struct v4l2_fmtdesc *f);
static int capture_enum_frminterval(FAR struct file *filep,
                                    FAR struct v4l2_frmivalenum *f);
static int capture_enum_frmsize(FAR struct file *filep,
                                FAR struct v4l2_frmsizeenum *f);

/* File operations function */

static int capture_open(FAR struct file *filep);
static int capture_close(FAR struct file *filep);
static int capture_mmap(FAR struct file *filep,
                        FAR struct mm_map_entry_s *map);
static int capture_poll(FAR struct file *filep,
                        FAR struct pollfd *fds, bool setup);
#ifndef CONFIG_DISABLE_PSEUDOFS_OPERATIONS
static int capture_unlink(FAR struct inode *inode);
#endif

/****************************************************************************
 * Private Data
 ****************************************************************************/

static const struct v4l2_ops_s g_capture_vops =
{
  capture_querycap,                   /* querycap */
  capture_g_input,                    /* g_input */
  capture_enum_input,                 /* enum_input */
  capture_reqbufs,                    /* reqbufs */
  capture_querybuf,                   /* querybuf */
  capture_qbuf,                       /* qbuf */
  capture_dqbuf,                      /* dqbuf */
  capture_cancel_dqbuf,               /* cancel_dqbuf */
  capture_g_fmt,                      /* g_fmt */
  capture_s_fmt,                      /* s_fmt */
  capture_try_fmt,                    /* try_fmt */
  capture_g_parm,                     /* g_parm */
  capture_s_parm,                     /* s_parm */
  capture_streamon,                   /* streamon */
  capture_streamoff,                  /* streamoff */
  capture_do_halfpush,                /* do_halfpush */
  capture_takepict_start,             /* takepict_start */
  capture_takepict_stop,              /* takepict_stop */
  capture_s_selection,                /* s_selection */
  capture_g_selection,                /* g_selection */
  capture_queryctrl,                  /* queryctrl */
  capture_query_ext_ctrl,             /* query_ext_ctrl */
  capture_querymenu,                  /* querymenu */
  capture_g_ctrl,                     /* g_ctrl */
  capture_s_ctrl,                     /* s_ctrl */
  capture_g_ext_ctrls,                /* g_ext_ctrls */
  capture_s_ext_ctrls,                /* s_ext_ctrls */
  capture_query_ext_ctrl_scene,       /* query_ext_ctrl_scene */
  capture_querymenu_scene,            /* querymenu_scene */
  capture_g_ext_ctrls_scene,          /* g_ext_ctrls_scene */
  capture_s_ext_ctrls_scene,          /* s_ext_ctrls_scene */
  capture_enum_fmt,                   /* enum_fmt */
  capture_enum_frminterval,           /* enum_frminterval */
  capture_enum_frmsize                /* enum_frmsize */
};

static const struct file_operations g_capture_fops =
{
  capture_open,               /* open */
  capture_close,              /* close */
  NULL,                       /* read */
  NULL,                       /* write */
  NULL,                       /* seek */
  NULL,                       /* ioctl */
  capture_mmap,               /* mmap */
  NULL,                       /* truncate */
  capture_poll,               /* poll */
#ifndef CONFIG_DISABLE_PSEUDOFS_OPERATIONS
  capture_unlink,             /* unlink */
#endif
};

static const capture_parameter_name_t g_capture_parameter_name[] =
{
    {
      IMGSENSOR_ID_BRIGHTNESS,           "Brightness"
    },

    {
      IMGSENSOR_ID_CONTRAST,             "Contrast"
    },

    {
      IMGSENSOR_ID_SATURATION,           "Saturation"
    },

    {
      IMGSENSOR_ID_HUE,                  "Hue"
    },

    {
      IMGSENSOR_ID_AUTO_WHITE_BALANCE,   "Automatic white balance"
    },

    {
      IMGSENSOR_ID_RED_BALANCE,          "Red balance"
    },

    {
      IMGSENSOR_ID_BLUE_BALANCE,         "Blue balance"
    },

    {
      IMGSENSOR_ID_GAMMA,                "Gamma value"
    },

    {
      IMGSENSOR_ID_GAMMA_CURVE,          "Gamma adjustment(curve)"
    },

    {
      IMGSENSOR_ID_EXPOSURE,             "Exposure value"
    },

    {
      IMGSENSOR_ID_HFLIP_VIDEO,          "Mirror horizontally(VIDEO)"
    },

    {
      IMGSENSOR_ID_VFLIP_VIDEO,          "Mirror vertically(VIDEO)"
    },

    {
      IMGSENSOR_ID_HFLIP_STILL,          "Mirror horizontally(STILL)"
    },

    {
      IMGSENSOR_ID_VFLIP_STILL,          "Mirror vertically(STILL)"
    },

    {
      IMGSENSOR_ID_SHARPNESS,            "Sharpness"
    },

    {
      IMGSENSOR_ID_COLOR_KILLER,         "Color killer"
    },

    {
      IMGSENSOR_ID_COLORFX,              "Color effect"
    },

    {
      IMGSENSOR_ID_AUTOBRIGHTNESS,       "Auto brightness"
    },

    {
      IMGSENSOR_ID_ROTATE,               "Rotate"
    },

    {
      IMGSENSOR_ID_EXPOSURE_AUTO,        "Auto Exposure"
    },

    {
      IMGSENSOR_ID_EXPOSURE_ABSOLUTE,    "Exposure time(100 usec)"
    },

    {
      IMGSENSOR_ID_FOCUS_ABSOLUTE,       "Focus(absolute value)"
    },

    {
      IMGSENSOR_ID_FOCUS_RELATIVE,       "Focus(relative value)"
    },

    {
      IMGSENSOR_ID_FOCUS_AUTO,           "Continuous Auto Focus"
    },

    {
      IMGSENSOR_ID_ZOOM_ABSOLUTE,        "Zoom(absolute value)"
    },

    {
      IMGSENSOR_ID_ZOOM_RELATIVE,        "Zoom(relative value)"
    },

    {
      IMGSENSOR_ID_ZOOM_CONTINUOUS,      "Continuous zoom"
    },

    {
      IMGSENSOR_ID_IRIS_ABSOLUTE,        "Iris(absolute value)"
    },

    {
      IMGSENSOR_ID_IRIS_RELATIVE,        "Iris(relative value)"
    },

    {
      IMGSENSOR_ID_AUTO_N_PRESET_WB,     "Preset white balance"
    },

    {
      IMGSENSOR_ID_WIDE_DYNAMIC_RANGE,   "Wide dynamic range"
    },

    {
      IMGSENSOR_ID_IMG_STABILIZATION,    "Image stabilization"
    },

    {
      IMGSENSOR_ID_ISO_SENSITIVITY,      "ISO sensitivity"
    },

    {
      IMGSENSOR_ID_ISO_SENSITIVITY_AUTO, "Automatic ISO sensitivity"
    },

    {
      IMGSENSOR_ID_EXPOSURE_METERING,    "Photometry"
    },

    {
      IMGSENSOR_ID_SPOT_POSITION,        "Spot position"
    },

    {
      IMGSENSOR_ID_3A_LOCK,              "Lock AWB/AE"
    },

    {
      IMGSENSOR_ID_AUTO_FOCUS_START,     "Start single Auto Focus"
    },

    {
      IMGSENSOR_ID_AUTO_FOCUS_STOP,      "Stop single Auto Focus"
    },

    {
      IMGSENSOR_ID_3A_PARAMETER,         "3A parameter"
    },

    {
      IMGSENSOR_ID_3A_STATUS,            "3A status"
    },

    {
      IMGSENSOR_ID_FLASH_LED_MODE,       "LED mode"
    },

    {
      IMGSENSOR_ID_JPEG_QUALITY,         "JPEG compression quality"
    }
};

static FAR struct imgsensor_s **g_capture_registered_sensor = NULL;
static size_t g_capture_registered_sensor_num;
static FAR struct imgdata_s *g_capture_data = NULL;

/****************************************************************************
 * Private Functions
 ****************************************************************************/

static FAR capture_type_inf_t *
get_capture_type_inf(FAR capture_mng_t *cmng, uint8_t type)
{
  FAR capture_type_inf_t *type_inf;

  switch (type)
    {
      case V4L2_BUF_TYPE_VIDEO_CAPTURE:
        type_inf = &cmng->capture_inf;
        break;

      case V4L2_BUF_TYPE_STILL_CAPTURE:
        type_inf = &cmng->still_inf;
        break;

      default:  /* Error case */
        type_inf = NULL;
        break;
    }

  return type_inf;
}

static enum capture_state_e
estimate_next_capture_state(FAR capture_mng_t *cmng,
                            enum capture_state_cause_e cause)
{
  enum capture_state_e current_state = cmng->capture_inf.state;

  switch (cause)
    {
      case CAUSE_CAPTURE_STOP:
        return CAPTURE_STATE_STREAMOFF;

      case CAUSE_CAPTURE_START:
        if (is_taking_still_picture(cmng))
          {
            return CAPTURE_STATE_STREAMON;
          }
        else
          {
            return CAPTURE_STATE_CAPTURE;
          }

      case CAUSE_STILL_STOP:
        if (current_state == CAPTURE_STATE_STREAMON)
          {
            return CAPTURE_STATE_CAPTURE;
          }
        else
          {
            return current_state;
          }

      case CAUSE_STILL_START:
        if (current_state == CAPTURE_STATE_CAPTURE)
          {
            return CAPTURE_STATE_STREAMON;
          }
        else
          {
            return current_state;
          }

      case CAUSE_CAPTURE_DQBUF:
        if (current_state == CAPTURE_STATE_STREAMON &&
            !is_taking_still_picture(cmng))
          {
            return CAPTURE_STATE_CAPTURE;
          }
        else
          {
            return current_state;
          }

      default:
        return current_state;
    }
}

static void convert_to_imgdatafmt(FAR video_format_t *video,
                                  FAR imgdata_format_t *data)
{
  ASSERT(video && data);

  data->width  = video->width;
  data->height = video->height;
  switch (video->pixelformat)
    {
      case V4L2_PIX_FMT_NV12:
        data->pixelformat = IMGDATA_PIX_FMT_NV12;
        break;

      case V4L2_PIX_FMT_YUV420:
        data->pixelformat = IMGDATA_PIX_FMT_YUV420P;
        break;

      case V4L2_PIX_FMT_YUYV:
        data->pixelformat = IMGDATA_PIX_FMT_YUYV;
        break;

      case V4L2_PIX_FMT_UYVY:
        data->pixelformat = IMGDATA_PIX_FMT_UYVY;
        break;

      case V4L2_PIX_FMT_RGB565:
        data->pixelformat = IMGDATA_PIX_FMT_RGB565;
        break;

      case V4L2_PIX_FMT_JPEG:
        data->pixelformat = IMGDATA_PIX_FMT_JPEG;
        break;

      default: /* V4L2_PIX_FMT_JPEG_WITH_SUBIMG */
        data->pixelformat = IMGDATA_PIX_FMT_JPEG_WITH_SUBIMG;
        break;
    }
}

static void convert_to_imgsensorfmt(FAR video_format_t *video,
                                    FAR imgsensor_format_t *sensor)
{
  ASSERT(video && sensor);

  sensor->width  = video->width;
  sensor->height = video->height;
  switch (video->pixelformat)
    {
      case V4L2_PIX_FMT_NV12:
        sensor->pixelformat = IMGSENSOR_PIX_FMT_NV12;
        break;

      case V4L2_PIX_FMT_YUV420:
        sensor->pixelformat = IMGSENSOR_PIX_FMT_YUV420P;
        break;

      case V4L2_PIX_FMT_YUYV:
        sensor->pixelformat = IMGSENSOR_PIX_FMT_YUYV;
        break;

      case V4L2_PIX_FMT_UYVY:
        sensor->pixelformat = IMGSENSOR_PIX_FMT_UYVY;
        break;

      case V4L2_PIX_FMT_RGB565:
        sensor->pixelformat = IMGSENSOR_PIX_FMT_RGB565;
        break;

      case V4L2_PIX_FMT_JPEG:
        sensor->pixelformat = IMGSENSOR_PIX_FMT_JPEG;
        break;

      default: /* V4L2_PIX_FMT_JPEG_WITH_SUBIMG */
        sensor->pixelformat = IMGSENSOR_PIX_FMT_JPEG_WITH_SUBIMG;
        break;
    }
}

static void convert_to_imgdatainterval(FAR struct v4l2_fract *video,
                                       FAR imgdata_interval_t *data)
{
  ASSERT(video && data);

  data->numerator   = video->numerator;
  data->denominator = video->denominator;
}

static void convert_to_imgsensorinterval(FAR struct v4l2_fract *video,
                                         FAR imgsensor_interval_t *sensor)
{
  ASSERT(video && sensor);

  sensor->numerator   = video->numerator;
  sensor->denominator = video->denominator;
}

static bool is_clipped(FAR struct v4l2_rect *clip)
{
  bool ret = false;

  if (clip)
    {
      if (clip->left  != 0 || clip->top    != 0 ||
          clip->width != 0 || clip->height != 0)
        {
          ret = true;
        }
    }

  return ret;
}

static void get_clipped_format(uint8_t nr_fmt,
                               FAR video_format_t *fmt,
                               FAR struct v4l2_rect *clip,
                               FAR video_format_t *c_fmt)
{
  DEBUGASSERT(fmt && c_fmt);

  if (is_clipped(clip))
    {
      c_fmt[CAPTURE_FMT_MAIN].width  = clip->width;
      c_fmt[CAPTURE_FMT_MAIN].height = clip->height;
      c_fmt[CAPTURE_FMT_MAIN].pixelformat =
        fmt[CAPTURE_FMT_MAIN].pixelformat;

      if (nr_fmt > 1)
        {
          /* Clipped size of  thumbnail is
           * small as ratio of main size and thumbnail size.
           */

          memcpy(&c_fmt[CAPTURE_FMT_SUB],
                 &fmt[CAPTURE_FMT_SUB],
                 sizeof(video_format_t));

          c_fmt[CAPTURE_FMT_SUB].width =
            (uint32_t)c_fmt[CAPTURE_FMT_SUB].width *
            clip->width / fmt[CAPTURE_FMT_MAIN].width;

          c_fmt[CAPTURE_FMT_SUB].height =
            (uint32_t)c_fmt[CAPTURE_FMT_SUB].height *
            clip->height / fmt[CAPTURE_FMT_MAIN].height;
        }
    }
  else
    {
      memcpy(c_fmt, fmt, nr_fmt * sizeof(video_format_t));
    }
}

static int start_capture(FAR struct capture_mng_s *cmng,
                         enum v4l2_buf_type type,
                         uint8_t nr_fmt,
                         FAR video_format_t *fmt,
                         FAR struct v4l2_rect *clip,
                         FAR struct v4l2_fract *interval,
                         uintptr_t bufaddr, uint32_t bufsize)
{
  video_format_t c_fmt[MAX_CAPTURE_FMT];
  imgdata_format_t df[MAX_CAPTURE_FMT];
  imgsensor_format_t sf[MAX_CAPTURE_FMT];
  imgdata_interval_t di;
  imgsensor_interval_t si;

  ASSERT(fmt && interval && cmng->imgsensor && cmng->imgdata);

  get_clipped_format(nr_fmt, fmt, clip, c_fmt);

  convert_to_imgdatafmt(&c_fmt[CAPTURE_FMT_MAIN], &df[IMGDATA_FMT_MAIN]);
  convert_to_imgdatafmt(&c_fmt[CAPTURE_FMT_SUB], &df[IMGDATA_FMT_SUB]);
  convert_to_imgdatainterval(interval, &di);
  convert_to_imgsensorfmt(&fmt[CAPTURE_FMT_MAIN], &sf[IMGSENSOR_FMT_MAIN]);
  convert_to_imgsensorfmt(&fmt[CAPTURE_FMT_SUB], &sf[IMGSENSOR_FMT_SUB]);
  convert_to_imgsensorinterval(interval, &si);

  IMGDATA_SET_BUF(cmng->imgdata,
     nr_fmt, df, (FAR uint8_t *)bufaddr, bufsize);
  IMGDATA_START_CAPTURE(cmng->imgdata,
     nr_fmt, df, &di, complete_capture, cmng);
  IMGSENSOR_START_CAPTURE(cmng->imgsensor,
     type == V4L2_BUF_TYPE_VIDEO_CAPTURE ?
     IMGSENSOR_STREAM_TYPE_VIDEO : IMGSENSOR_STREAM_TYPE_STILL,
     nr_fmt, sf, &si);
  return OK;
}

static void stop_capture(FAR struct capture_mng_s *cmng,
                         enum v4l2_buf_type type)
{
  ASSERT(cmng->imgsensor && cmng->imgdata);

  IMGDATA_STOP_CAPTURE(cmng->imgdata);
  IMGSENSOR_STOP_CAPTURE(cmng->imgsensor,
    type == V4L2_BUF_TYPE_VIDEO_CAPTURE ?
    IMGSENSOR_STREAM_TYPE_VIDEO : IMGSENSOR_STREAM_TYPE_STILL);
}

static void change_capture_state(FAR capture_mng_t *cmng,
                                 enum capture_state_e next_state)
{
  enum capture_state_e current_state = cmng->capture_inf.state;
  enum capture_state_e updated_next_state = next_state;

  if (current_state != CAPTURE_STATE_CAPTURE &&
      next_state    == CAPTURE_STATE_CAPTURE)
    {
      FAR vbuf_container_t *container =
        video_framebuff_get_vacant_container(&cmng->capture_inf.bufinf);
      if (container != NULL)
        {
          cmng->capture_inf.seqnum = 0;
          start_capture(cmng,
                        V4L2_BUF_TYPE_VIDEO_CAPTURE,
                        cmng->capture_inf.nr_fmt,
                        cmng->capture_inf.fmt,
                        &cmng->capture_inf.clip,
                        &cmng->capture_inf.frame_interval,
                        container->buf.m.userptr,
                        container->buf.length);
        }
      else
        {
          updated_next_state = CAPTURE_STATE_STREAMON;
        }
    }
  else if (current_state == CAPTURE_STATE_CAPTURE &&
           next_state    != CAPTURE_STATE_CAPTURE)
    {
          stop_capture(cmng, V4L2_BUF_TYPE_VIDEO_CAPTURE);
    }

  cmng->capture_inf.state = updated_next_state;
}

static bool is_taking_still_picture(FAR capture_mng_t *cmng)
{
  return cmng->still_inf.state == CAPTURE_STATE_STREAMON ||
         cmng->still_inf.state == CAPTURE_STATE_CAPTURE;
}

static bool is_bufsize_sufficient(FAR capture_mng_t *cmng, uint32_t bufsize)
{
  /* Depend on format, frame size, and JPEG compression quality */

  return true;
}

static void initialize_frame_setting(FAR struct imgsensor_s *imgsensor,
                                     FAR uint8_t *nr_fmt,
                                     FAR video_format_t *fmt,
                                     FAR struct v4l2_fract *interval)
{
  ASSERT(nr_fmt && fmt && interval);

  /* Initial setting : QVGA YUV4:2:2 15FPS */

  *nr_fmt = 1;
  if (imgsensor && imgsensor->frmsizes)
    {
      if (imgsensor->frmsizes[0].type == V4L2_FRMSIZE_TYPE_DISCRETE)
        {
          fmt[CAPTURE_FMT_MAIN].width =
            imgsensor->frmsizes[0].discrete.width;
          fmt[CAPTURE_FMT_MAIN].height =
            imgsensor->frmsizes[0].discrete.height;
        }
      else
        {
          fmt[CAPTURE_FMT_MAIN].width =
            imgsensor->frmsizes[0].stepwise.min_width;
          fmt[CAPTURE_FMT_MAIN].height =
            imgsensor->frmsizes[0].stepwise.min_height;
        }
    }
  else
    {
      fmt[CAPTURE_FMT_MAIN].width  = VIDEO_HSIZE_QVGA;
      fmt[CAPTURE_FMT_MAIN].height = VIDEO_VSIZE_QVGA;
    }

  if (imgsensor && imgsensor->fmtdescs)
    {
      fmt[CAPTURE_FMT_MAIN].pixelformat = imgsensor->fmtdescs[0].pixelformat;
    }
  else
    {
      fmt[CAPTURE_FMT_MAIN].pixelformat = V4L2_PIX_FMT_UYVY;
    }

  if (imgsensor && imgsensor->frmintervals)
    {
      if (imgsensor->frmintervals[0].type == V4L2_FRMIVAL_TYPE_DISCRETE)
        {
          interval->denominator =
            imgsensor->frmintervals[0].discrete.denominator;
          interval->numerator =
            imgsensor->frmintervals[0].discrete.numerator;
        }
      else
        {
          interval->denominator =
            imgsensor->frmintervals[0].stepwise.min.denominator;
          interval->numerator =
            imgsensor->frmintervals[0].stepwise.min.numerator;
        }
    }
  else
    {
      interval->denominator = 15;
      interval->numerator   = 1;
    }
}

static void initialize_streamresources(FAR capture_type_inf_t *type_inf,
                                       FAR capture_mng_t *cmng)
{
  memset(type_inf, 0, sizeof(capture_type_inf_t));
  type_inf->remaining_capnum = REMAINING_CAPNUM_INFINITY;
  nxmutex_init(&type_inf->lock_state);
  nxsem_init(&type_inf->wait_capture.dqbuf_wait_flg, 0, 0);
  initialize_frame_setting(cmng->imgsensor, &type_inf->nr_fmt,
                           type_inf->fmt,
                           &type_inf->frame_interval);
  video_framebuff_init(&type_inf->bufinf);
}

static int32_t get_default_value(FAR capture_mng_t *cmng, uint32_t id)
{
  imgsensor_supported_value_t value;
  int ret;

  if (cmng->imgsensor == NULL)
    {
      /* Don't care(unsupported parameter) */

      return 0;
    }

  ret = IMGSENSOR_GET_SUPPORTED_VALUE(cmng->imgsensor, id, &value);
  if (ret != OK)
    {
      /* Don't care(unsupported parameter) */

      return 0;
    }

  switch (value.type)
    {
      case IMGSENSOR_CTRL_TYPE_INTEGER_MENU:
        return value.u.discrete.default_value;

      case IMGSENSOR_CTRL_TYPE_U8:
      case IMGSENSOR_CTRL_TYPE_U16:
      case IMGSENSOR_CTRL_TYPE_U32:

        /* Don't care */

        return 0;

      default:
        return value.u.range.default_value;
    }
}

static int32_t initialize_scene_gamma(FAR capture_mng_t *cmng,
                                      FAR uint8_t **gamma)
{
  imgsensor_supported_value_t sup_val;
  imgsensor_value_t val;
  int32_t sz;
  int ret;

  *gamma = NULL;

  ASSERT(cmng->imgsensor);

  ret = IMGSENSOR_GET_SUPPORTED_VALUE(cmng->imgsensor,
          IMGSENSOR_ID_GAMMA_CURVE, &sup_val);
  if (ret != OK)
    {
      /* Unsupported parameter */

      return 0;
    }

  switch (sup_val.type)
    {
      case IMGSENSOR_CTRL_TYPE_U8:
        sz = sup_val.u.elems.nr_elems * sizeof(uint8_t);
        if (sz / sizeof(uint8_t) != sup_val.u.elems.nr_elems)
          {
            /* Multiplication overflow */

            return 0;
          }

        break;

      case IMGSENSOR_CTRL_TYPE_U16:
        sz = sup_val.u.elems.nr_elems * sizeof(uint16_t);
        if (sz / sizeof(uint16_t) != sup_val.u.elems.nr_elems)
          {
            /* Multiplication overflow */

            return 0;
          }

        break;

      default: /* IMGSENSOR_CTRL_TYPE_U32 */
        sz = sup_val.u.elems.nr_elems * sizeof(uint32_t);
        if (sz / sizeof(uint32_t) != sup_val.u.elems.nr_elems)
          {
            /* Multiplication overflow */

            return 0;
          }

        break;
    }

  *gamma = kmm_malloc(sz);
  val.p_u8 = (FAR uint8_t *)*gamma;
  IMGSENSOR_GET_VALUE(cmng->imgsensor, IMGSENSOR_ID_GAMMA_CURVE, sz, &val);
  return sz;
}

static int initialize_scene_parameter(FAR capture_mng_t *cmng,
                                      enum v4l2_scene_mode mode,
                                      FAR capture_scene_params_t **vsp)
{
  FAR capture_scene_params_t *sp =
    kmm_malloc(sizeof(capture_scene_params_t));

  if (!sp)
    {
      return -ENOMEM;
    }

  sp->mode            = mode;
  sp->brightness      = get_default_value(cmng, IMGSENSOR_ID_BRIGHTNESS);
  sp->contrast        = get_default_value(cmng, IMGSENSOR_ID_CONTRAST);
  sp->saturation      = get_default_value(cmng, IMGSENSOR_ID_SATURATION);
  sp->hue             = get_default_value(cmng, IMGSENSOR_ID_HUE);
  sp->awb             = get_default_value(cmng,
                                          IMGSENSOR_ID_AUTO_WHITE_BALANCE);
  sp->red             = get_default_value(cmng, IMGSENSOR_ID_RED_BALANCE);
  sp->blue            = get_default_value(cmng, IMGSENSOR_ID_BLUE_BALANCE);
  sp->gamma           = get_default_value(cmng, IMGSENSOR_ID_GAMMA);
  sp->gamma_curve_sz  = initialize_scene_gamma(cmng, &sp->gamma_curve);
  sp->ev              = get_default_value(cmng, IMGSENSOR_ID_EXPOSURE);
  sp->hflip_video     = get_default_value(cmng, IMGSENSOR_ID_HFLIP_VIDEO);
  sp->vflip_video     = get_default_value(cmng, IMGSENSOR_ID_VFLIP_VIDEO);
  sp->hflip_still     = get_default_value(cmng, IMGSENSOR_ID_HFLIP_STILL);
  sp->vflip_still     = get_default_value(cmng, IMGSENSOR_ID_VFLIP_STILL);
  sp->sharpness       = get_default_value(cmng, IMGSENSOR_ID_SHARPNESS);
  sp->colorfx         = get_default_value(cmng, IMGSENSOR_ID_COLORFX);
  sp->auto_brightness = get_default_value(cmng, IMGSENSOR_ID_AUTOBRIGHTNESS);
  sp->rotate          = get_default_value(cmng, IMGSENSOR_ID_ROTATE);
  sp->ae              = get_default_value(cmng, IMGSENSOR_ID_EXPOSURE_AUTO);
  sp->exposure_time   = get_default_value(cmng,
                                         IMGSENSOR_ID_EXPOSURE_ABSOLUTE);
  sp->focus           = get_default_value(cmng, IMGSENSOR_ID_FOCUS_ABSOLUTE);
  sp->af              = get_default_value(cmng, IMGSENSOR_ID_FOCUS_AUTO);
  sp->zoom            = get_default_value(cmng, IMGSENSOR_ID_ZOOM_ABSOLUTE);
  sp->iris            = get_default_value(cmng, IMGSENSOR_ID_IRIS_ABSOLUTE);
  sp->wb              = get_default_value(cmng,
                                          IMGSENSOR_ID_AUTO_N_PRESET_WB);
  sp->wdr             = get_default_value(cmng,
                                          IMGSENSOR_ID_WIDE_DYNAMIC_RANGE);
  sp->stabilization   = get_default_value(cmng,
                                          IMGSENSOR_ID_IMG_STABILIZATION);
  sp->iso_auto        = get_default_value(cmng,
                                          IMGSENSOR_ID_ISO_SENSITIVITY_AUTO);
  sp->iso             = get_default_value(cmng,
                                          IMGSENSOR_ID_ISO_SENSITIVITY);
  sp->meter           = get_default_value(cmng,
                                          IMGSENSOR_ID_EXPOSURE_METERING);
  sp->threea_lock     = get_default_value(cmng, IMGSENSOR_ID_3A_LOCK);
  sp->led             = get_default_value(cmng, IMGSENSOR_ID_FLASH_LED_MODE);
  sp->jpeg_quality    = get_default_value(cmng, IMGSENSOR_ID_JPEG_QUALITY);

  *vsp = sp;

  return OK;
}

static void initialize_scenes_parameter(FAR capture_mng_t *cmng)
{
  memset(cmng->capture_scene_param,
         0, sizeof(cmng->capture_scene_param));

  initialize_scene_parameter(cmng, V4L2_SCENE_MODE_NONE,
      &cmng->capture_scene_param[cmng->capture_scence_num++]);
#ifdef CONFIG_VIDEO_SCENE_BACKLIGHT
  initialize_scene_parameter(cmng, V4L2_SCENE_MODE_BACKLIGHT,
           &cmng->capture_scene_param[cmng->capture_scence_num++]);
#endif /* CONFIG_VIDEO_SCENE_BACKLIGHT */
#ifdef CONFIG_VIDEO_SCENE_BEACHSNOW
  initialize_scene_parameter(cmng, V4L2_SCENE_MODE_BEACH_SNOW,
              &cmng->capture_scene_param[cmng->capture_scence_num++]);
#endif /* CONFIG_VIDEO_SCENE_BEACHSNOW */
#ifdef CONFIG_VIDEO_SCENE_CANDLELIGHT
  initialize_scene_parameter(cmng, V4L2_SCENE_MODE_CANDLE_LIGHT,
                &cmng->capture_scene_param[cmng->capture_scence_num++]);
#endif /* CONFIG_VIDEO_SCENE_CANDLELIGHT */
#ifdef CONFIG_VIDEO_SCENE_DAWNDUSK
  initialize_scene_parameter(cmng, V4L2_SCENE_MODE_DAWN_DUSK,
             &cmng->capture_scene_param[cmng->capture_scence_num++]);
#endif /* CONFIG_VIDEO_SCENE_DAWNDUSK */
#ifdef CONFIG_VIDEO_SCENE_FALLCOLORS
  initialize_scene_parameter(cmng, V4L2_SCENE_MODE_FALL_COLORS,
               &cmng->capture_scene_param[cmng->capture_scence_num++]);
#endif /* CONFIG_VIDEO_SCENE_FALLCOLORS */
#ifdef CONFIG_VIDEO_SCENE_FIREWORKS
  initialize_scene_parameter(cmng, V4L2_SCENE_MODE_FIREWORKS,
              &cmng->capture_scene_param[cmng->capture_scence_num++]);
#endif /* CONFIG_VIDEO_SCENE_FIREWORKS */
#ifdef CONFIG_VIDEO_SCENE_LANDSCAPE
  initialize_scene_parameter(cmng, V4L2_SCENE_MODE_LANDSCAPE,
              &cmng->capture_scene_param[cmng->capture_scence_num++]);
#endif /* CONFIG_VIDEO_SCENE_LANDSCAPE */
#ifdef CONFIG_VIDEO_SCENE_NIGHT
  initialize_scene_parameter(cmng, V4L2_SCENE_MODE_NIGHT,
          &cmng->capture_scene_param[cmng->capture_scence_num++]);
#endif /* CONFIG_VIDEO_SCENE_NIGHT */
#ifdef CONFIG_VIDEO_SCENE_PARTYINDOOR
  initialize_scene_parameter(cmng, V4L2_SCENE_MODE_PARTY_INDOOR,
                &cmng->capture_scene_param[cmng->capture_scence_num++]);
#endif /* CONFIG_VIDEO_SCENE_PARTYINDOOR */
#ifdef CONFIG_VIDEO_SCENE_PORTRAIT
  initialize_scene_parameter(cmng, V4L2_SCENE_MODE_PORTRAIT,
             &cmng->capture_scene_param[cmng->capture_scence_num++]);
#endif /* CONFIG_VIDEO_SCENE_PORTRAIT */
#ifdef CONFIG_VIDEO_SCENE_SPORTS
  initialize_scene_parameter(cmng, V4L2_SCENE_MODE_SPORTS,
           &cmng->capture_scene_param[cmng->capture_scence_num++]);
#endif /* CONFIG_VIDEO_SCENE_SPORTS */
#ifdef CONFIG_VIDEO_SCENE_SUNSET
  initialize_scene_parameter(cmng, V4L2_SCENE_MODE_SUNSET,
           &cmng->capture_scene_param[cmng->capture_scence_num++]);
#endif /* CONFIG_VIDEO_SCENE_SUNSET */
#ifdef CONFIG_VIDEO_SCENE_TEXT
  initialize_scene_parameter(cmng, V4L2_SCENE_MODE_TEXT,
         &cmng->capture_scene_param[cmng->capture_scence_num++]);
#endif /* CONFIG_VIDEO_SCENE_TEXT */
}

static void initialize_resources(FAR capture_mng_t *cmng)
{
  initialize_streamresources(&cmng->capture_inf, cmng);
  initialize_streamresources(&cmng->still_inf, cmng);
  initialize_scenes_parameter(cmng);
}

static void cleanup_streamresources(FAR capture_type_inf_t *type_inf,
                                    FAR capture_mng_t *cmng)
{
  video_framebuff_uninit(&type_inf->bufinf);
  nxsem_destroy(&type_inf->wait_capture.dqbuf_wait_flg);
  nxmutex_destroy(&type_inf->lock_state);
  if (type_inf->bufheap != NULL)
    {
      if (cmng->imgdata->ops->free)
        {
          cmng->imgdata->ops->free(cmng->imgdata, type_inf->bufheap);
        }
      else
        {
          kumm_free(type_inf->bufheap);
        }

      type_inf->bufheap = NULL;
    }
}

static void cleanup_scene_parameter(FAR capture_scene_params_t **vsp)
{
  FAR capture_scene_params_t *sp = *vsp;
  ASSERT(sp);

  if (sp->gamma_curve != NULL)
    {
      kmm_free(sp->gamma_curve);
      sp->gamma_curve = NULL;
      sp->gamma_curve_sz = 0;
    }

  kmm_free(sp);
  *vsp = NULL;
}

static void cleanup_scenes_parameter(FAR capture_mng_t *cmng)
{
  int i;

  for (i = 0; i < cmng->capture_scence_num; i++)
    {
      cleanup_scene_parameter(&cmng->capture_scene_param[i]);
    }

  cmng->capture_scence_num = 0;
}

static void cleanup_resources(FAR capture_mng_t *cmng)
{
  /* If in capture, stop */

  if (cmng->capture_inf.state == CAPTURE_STATE_CAPTURE)
    {
      stop_capture(cmng, V4L2_BUF_TYPE_VIDEO_CAPTURE);
    }

  if (cmng->still_inf.state == CAPTURE_STATE_CAPTURE)
    {
      stop_capture(cmng, V4L2_BUF_TYPE_STILL_CAPTURE);
    }

  /* Clean up resource */

  cleanup_streamresources(&cmng->capture_inf, cmng);
  cleanup_streamresources(&cmng->still_inf, cmng);
  cleanup_scenes_parameter(cmng);
}

static bool is_sem_waited(FAR sem_t *sem)
{
  int semcount;

  return nxsem_get_value(sem, &semcount) == OK && semcount < 0;
}

static int validate_frame_setting(FAR capture_mng_t *cmng,
                                  enum v4l2_buf_type type,
                                  uint8_t nr_fmt,
                                  FAR video_format_t *vfmt,
                                  FAR struct v4l2_rect *clip,
                                  FAR struct v4l2_fract *interval)
{
  video_format_t c_fmt[MAX_CAPTURE_FMT];
  imgdata_format_t df[MAX_CAPTURE_FMT];
  imgsensor_format_t sf[MAX_CAPTURE_FMT];
  imgdata_interval_t di;
  imgsensor_interval_t si;
  int ret;

  ASSERT(vfmt && interval && cmng->imgsensor && cmng->imgdata);

  /* Return OK only in case both image data driver and
   * image sensor driver support.
   */

  get_clipped_format(nr_fmt, vfmt, clip, c_fmt);

  convert_to_imgdatafmt(&c_fmt[CAPTURE_FMT_MAIN], &df[IMGDATA_FMT_MAIN]);
  convert_to_imgdatafmt(&c_fmt[CAPTURE_FMT_SUB], &df[IMGDATA_FMT_SUB]);
  convert_to_imgdatainterval(interval, &di);
  convert_to_imgsensorfmt(&vfmt[CAPTURE_FMT_MAIN], &sf[IMGSENSOR_FMT_MAIN]);
  convert_to_imgsensorfmt(&vfmt[CAPTURE_FMT_SUB], &sf[IMGSENSOR_FMT_SUB]);
  convert_to_imgsensorinterval(interval, &si);

  ret = IMGSENSOR_VALIDATE_FRAME_SETTING(cmng->imgsensor,
            type == V4L2_BUF_TYPE_VIDEO_CAPTURE ?
              IMGSENSOR_STREAM_TYPE_VIDEO : IMGSENSOR_STREAM_TYPE_STILL,
            nr_fmt, sf, &si);
  if (ret != OK)
    {
      return ret;
    }

  return IMGDATA_VALIDATE_FRAME_SETTING(cmng->imgdata, nr_fmt, df, &di);
}

static size_t get_bufsize(FAR video_format_t *vf)
{
  uint32_t width  = vf->width;
  uint32_t height = vf->height;
  size_t ret = width * height;

  switch (vf->pixelformat)
    {
      case V4L2_PIX_FMT_NV12:
      case V4L2_PIX_FMT_YUV420:
        return ret * 3 / 2;
      case V4L2_PIX_FMT_YUYV:
      case V4L2_PIX_FMT_UYVY:
      case V4L2_PIX_FMT_RGB565:
      case V4L2_PIX_FMT_JPEG:
      default:
        return ret * 2;
    }
}

static size_t get_heapsize(FAR capture_type_inf_t *type_inf)
{
  return type_inf->bufinf.container_size *
         get_bufsize(&type_inf->fmt[CAPTURE_FMT_MAIN]);
}

static bool validate_clip_range(int32_t pos, uint32_t c_sz, uint16_t frm_sz)
{
  return pos >= 0 && c_sz <= frm_sz && pos + c_sz <= frm_sz;
}

static bool validate_clip_setting(FAR struct v4l2_rect *clip,
                                  FAR video_format_t *fmt)
{
  DEBUGASSERT(clip && fmt);

  /* Not permit the setting which do not fit inside frame size. */

  return validate_clip_range(clip->left, clip->width,  fmt->width) &&
         validate_clip_range(clip->top,  clip->height, fmt->height);
}

static void set_parameter_name(uint32_t id, FAR char *name)
{
  int size =
    sizeof(g_capture_parameter_name) / sizeof(capture_parameter_name_t);
  int cnt;

  for (cnt = 0; cnt < size; cnt++)
    {
      if (g_capture_parameter_name[cnt].id == id)
        {
          break;
        }
    }

  ASSERT(cnt < size);

  /* copy size = 32 is due to V4L2 specification. */

  strlcpy(name, g_capture_parameter_name[cnt].name, 32);
}

static int set_intvalue(FAR struct capture_mng_s *cmng,
                        uint32_t id, int32_t value32)
{
  imgsensor_value_t value;

  ASSERT(cmng->imgsensor);

  value.value32 = value32;
  return IMGSENSOR_SET_VALUE(cmng->imgsensor, id, sizeof(int32_t), value);
}

static int set_pvalue(FAR struct capture_mng_s *cmng,
                      uint32_t id, int size, void *pval)
{
  imgsensor_value_t value;

  ASSERT(cmng->imgsensor);

  value.p_u8 = (FAR uint8_t *)pval;
  return IMGSENSOR_SET_VALUE(cmng->imgsensor, id, size, value);
}

static capture_scene_params_t *search_scene_param(FAR capture_mng_t *cmng,
                                                  enum v4l2_scene_mode mode)
{
  int i;

  for (i = 0; i < cmng->capture_scence_num; i++)
    {
      if (cmng->capture_scene_param[i]->mode == mode)
        {
          return cmng->capture_scene_param[i];
        }
    }

  return NULL;
}

static int reflect_scene_parameter(FAR capture_mng_t *cmng,
                                   enum v4l2_scene_mode mode)
{
  capture_scene_params_t *sp;

  sp = search_scene_param(cmng, mode);
  if (sp == NULL)
    {
      /* Unsupported scene mode */

      return -EINVAL;
    }

  set_intvalue(cmng, IMGSENSOR_ID_BRIGHTNESS, sp->brightness);
  set_intvalue(cmng, IMGSENSOR_ID_CONTRAST, sp->contrast);
  set_intvalue(cmng, IMGSENSOR_ID_SATURATION, sp->saturation);
  set_intvalue(cmng, IMGSENSOR_ID_HUE , sp->hue);
  set_intvalue(cmng, IMGSENSOR_ID_AUTO_WHITE_BALANCE, sp->awb);
  set_intvalue(cmng, IMGSENSOR_ID_RED_BALANCE , sp->red);
  set_intvalue(cmng, IMGSENSOR_ID_BLUE_BALANCE, sp->blue);
  set_intvalue(cmng, IMGSENSOR_ID_GAMMA, sp->gamma);
  set_pvalue(cmng, IMGSENSOR_ID_GAMMA_CURVE,
             sp->gamma_curve_sz, sp->gamma_curve);
  set_intvalue(cmng, IMGSENSOR_ID_EXPOSURE, sp->ev);
  set_intvalue(cmng, IMGSENSOR_ID_HFLIP_VIDEO, sp->hflip_video);
  set_intvalue(cmng, IMGSENSOR_ID_VFLIP_VIDEO, sp->vflip_video);
  set_intvalue(cmng, IMGSENSOR_ID_HFLIP_STILL, sp->hflip_still);
  set_intvalue(cmng, IMGSENSOR_ID_VFLIP_STILL, sp->vflip_still);
  set_intvalue(cmng, IMGSENSOR_ID_SHARPNESS, sp->sharpness);
  set_intvalue(cmng, IMGSENSOR_ID_COLORFX, sp->colorfx);
  set_intvalue(cmng, IMGSENSOR_ID_AUTOBRIGHTNESS, sp->auto_brightness);
  set_intvalue(cmng, IMGSENSOR_ID_ROTATE, sp->rotate);
  set_intvalue(cmng, IMGSENSOR_ID_EXPOSURE_AUTO, sp->ae);
  if (sp->ae == V4L2_EXPOSURE_MANUAL ||
      sp->ae == V4L2_EXPOSURE_SHUTTER_PRIORITY)
    {
      set_intvalue(cmng, IMGSENSOR_ID_EXPOSURE_ABSOLUTE, sp->exposure_time);
    }

  set_intvalue(cmng, IMGSENSOR_ID_FOCUS_ABSOLUTE, sp->focus);
  set_intvalue(cmng, IMGSENSOR_ID_FOCUS_AUTO, sp->af);
  set_intvalue(cmng, IMGSENSOR_ID_ZOOM_ABSOLUTE, sp->zoom);
  if (sp->ae == V4L2_EXPOSURE_MANUAL ||
      sp->ae == V4L2_EXPOSURE_APERTURE_PRIORITY)
    {
      set_intvalue(cmng, IMGSENSOR_ID_IRIS_ABSOLUTE, sp->iris);
    }

  set_intvalue(cmng, IMGSENSOR_ID_AUTO_N_PRESET_WB, sp->wb);
  set_intvalue(cmng, IMGSENSOR_ID_WIDE_DYNAMIC_RANGE, sp->wdr);
  set_intvalue(cmng, IMGSENSOR_ID_IMG_STABILIZATION, sp->stabilization);
  set_intvalue(cmng, IMGSENSOR_ID_ISO_SENSITIVITY_AUTO, sp->iso_auto);
  if (sp->iso_auto == V4L2_ISO_SENSITIVITY_MANUAL)
    {
      set_intvalue(cmng, IMGSENSOR_ID_ISO_SENSITIVITY, sp->iso);
    }

  set_intvalue(cmng, IMGSENSOR_ID_EXPOSURE_METERING, sp->meter);
  set_intvalue(cmng, IMGSENSOR_ID_3A_LOCK, sp->threea_lock);
  set_intvalue(cmng, IMGSENSOR_ID_FLASH_LED_MODE, sp->led);
  set_intvalue(cmng, IMGSENSOR_ID_JPEG_QUALITY, sp->jpeg_quality);

  cmng->capture_scene_mode = mode;
  return OK;
}

static int read_scene_param(FAR struct capture_mng_s *cmng,
                            enum v4l2_scene_mode mode,
                            uint32_t id,
                            FAR struct v4l2_ext_control *control)
{
  imgsensor_supported_value_t value;
  capture_scene_params_t *sp;
  int ret = OK;

  ASSERT(cmng->imgsensor);

  if (control == NULL)
    {
      return -EINVAL;
    }

  sp = search_scene_param(cmng, mode);
  if (sp == NULL)
    {
      /* Unsupported scene mode */

      return -EINVAL;
    }

  ret = IMGSENSOR_GET_SUPPORTED_VALUE(cmng->imgsensor, id, &value);
  if (ret < 0)
    {
      /* Unsupported camera parameter */

      return ret;
    }

  switch (id)
    {
      case IMGSENSOR_ID_BRIGHTNESS:
        control->value = sp->brightness;
        break;

      case IMGSENSOR_ID_CONTRAST:
        control->value = sp->contrast;
        break;

      case IMGSENSOR_ID_SATURATION:
        control->value = sp->saturation;
        break;

      case IMGSENSOR_ID_HUE:
        control->value = sp->hue;
        break;

      case IMGSENSOR_ID_AUTO_WHITE_BALANCE:
        control->value = sp->awb;
        break;

      case IMGSENSOR_ID_RED_BALANCE:
        control->value = sp->red;
        break;

      case IMGSENSOR_ID_BLUE_BALANCE:
        control->value = sp->blue;
        break;

      case IMGSENSOR_ID_GAMMA:
        control->value = sp->gamma;
        break;

      case IMGSENSOR_ID_GAMMA_CURVE:
        memcpy(control->p_u8,
               sp->gamma_curve,
               sp->gamma_curve_sz);
        break;

      case IMGSENSOR_ID_EXPOSURE:
        control->value = sp->ev;
        break;

      case IMGSENSOR_ID_HFLIP_VIDEO:
        control->value = sp->hflip_video;
        break;

      case IMGSENSOR_ID_VFLIP_VIDEO:
        control->value = sp->vflip_video;
        break;

      case IMGSENSOR_ID_HFLIP_STILL:
        control->value = sp->hflip_still;
        break;

      case IMGSENSOR_ID_VFLIP_STILL:
        control->value = sp->vflip_still;
        break;

      case IMGSENSOR_ID_SHARPNESS:
        control->value = sp->sharpness;
        break;

      case IMGSENSOR_ID_COLOR_KILLER:
        control->value = sp->colorfx == V4L2_COLORFX_BW;
        break;

      case IMGSENSOR_ID_COLORFX:
        control->value = sp->colorfx;
        break;

      case IMGSENSOR_ID_AUTOBRIGHTNESS:
        control->value = sp->auto_brightness;
        break;

      case IMGSENSOR_ID_ROTATE:
        control->value = sp->rotate;
        break;

      case IMGSENSOR_ID_EXPOSURE_AUTO:
        control->value = sp->ae;
        break;

      case IMGSENSOR_ID_EXPOSURE_ABSOLUTE:
        control->value = sp->exposure_time;
        break;

      case IMGSENSOR_ID_FOCUS_ABSOLUTE:
        control->value = sp->focus;
        break;

      case IMGSENSOR_ID_FOCUS_AUTO:
        control->value = sp->af;
        break;

      case IMGSENSOR_ID_ZOOM_ABSOLUTE:
        control->value = sp->zoom;
        break;

      case IMGSENSOR_ID_IRIS_ABSOLUTE:
        control->value = sp->iris;
        break;

      case IMGSENSOR_ID_AUTO_N_PRESET_WB:
        control->value = sp->wb;
        break;

      case IMGSENSOR_ID_WIDE_DYNAMIC_RANGE:
        control->value = sp->wdr;
        break;

      case IMGSENSOR_ID_IMG_STABILIZATION:
        control->value = sp->stabilization;
        break;

      case IMGSENSOR_ID_ISO_SENSITIVITY:
        control->value = sp->iso;
        break;

      case IMGSENSOR_ID_ISO_SENSITIVITY_AUTO:
        control->value = sp->iso_auto;
        break;

      case IMGSENSOR_ID_EXPOSURE_METERING:
        control->value = sp->meter;
        break;

      case IMGSENSOR_ID_SPOT_POSITION:
        control->value = sp->spot_pos;
        break;

      case IMGSENSOR_ID_3A_LOCK:
        control->value = sp->threea_lock;
        break;

      case IMGSENSOR_ID_FLASH_LED_MODE:
        control->value = sp->led;
        break;

      case IMGSENSOR_ID_JPEG_QUALITY:
        control->value = sp->jpeg_quality;
        break;

      default:
        ret = -EINVAL;
        break;
    }

  return ret;
}

static int check_range(int64_t value,
                       int64_t min,
                       int64_t max,
                       uint64_t step)
{
  if (value < min || value > max ||
      (value - min) % step != 0)
    {
      return -EINVAL;
    }

  return OK;
}

static int save_scene_param(FAR capture_mng_t *cmng,
                            enum v4l2_scene_mode mode,
                            uint32_t id,
                            FAR struct v4l2_ext_control *control)
{
  imgsensor_supported_value_t value;
  FAR imgsensor_capability_range_t *range = &value.u.range;
  FAR imgsensor_capability_discrete_t *disc = &value.u.discrete;
  FAR imgsensor_capability_elems_t *elem = &value.u.elems;
  FAR capture_scene_params_t *sp;
  int ret;
  int i;

  ASSERT(cmng->imgsensor);

  sp = search_scene_param(cmng, mode);
  if (sp == NULL)
    {
      /* Unsupported scene mode */

      return -EINVAL;
    }

  ret = IMGSENSOR_GET_SUPPORTED_VALUE(cmng->imgsensor, id, &value);
  if (ret < 0)
    {
      /* Unsupported camera parameter */

      return ret;
    }

  switch (value.type)
    {
      case IMGSENSOR_CTRL_TYPE_INTEGER_MENU:
        for (i = 0; i < disc->nr_values; i++)
          {
            if (control->value == disc->values[i])
              {
                break;
              }
          }

        if (i >= disc->nr_values)
          {
            return -EINVAL;
          }

        break;

      case IMGSENSOR_CTRL_TYPE_U8:
        if (control->size < elem->nr_elems * sizeof(uint8_t))
          {
            return -EINVAL;
          }

        for (i = 0; i < elem->nr_elems; i++)
          {
            ret = check_range(control->p_u8[i],
                              elem->minimum,
                              elem->maximum,
                              elem->step);
            if (ret != OK)
              {
                return ret;
              }
          }

        break;

      case IMGSENSOR_CTRL_TYPE_U16:
        if (control->size < elem->nr_elems * sizeof(uint16_t))
          {
            return -EINVAL;
          }

        for (i = 0; i < elem->nr_elems; i++)
          {
            ret = check_range(control->p_u16[i],
                              elem->minimum,
                              elem->maximum,
                              elem->step);
            if (ret != OK)
              {
                return ret;
              }
          }

        break;

      case IMGSENSOR_CTRL_TYPE_U32:
        if (control->size < elem->nr_elems * sizeof(uint32_t))
          {
            return -EINVAL;
          }

        for (i = 0; i < elem->nr_elems; i++)
          {
            ret = check_range(control->p_u32[i],
                              elem->minimum,
                              elem->maximum,
                              elem->step);
            if (ret != OK)
              {
                return ret;
              }
          }

        break;

      default:
        ret = check_range(control->value,
                          range->minimum,
                          range->maximum,
                          range->step);
        if (ret != OK)
          {
            return ret;
          }

        break;
    }

  switch (id)
    {
      case IMGSENSOR_ID_BRIGHTNESS:
        sp->brightness = control->value;
        break;

      case IMGSENSOR_ID_CONTRAST:
        sp->contrast = control->value;
        break;

      case IMGSENSOR_ID_SATURATION:
        sp->saturation = control->value;
        break;

      case IMGSENSOR_ID_HUE:
        sp->hue = control->value;
        break;

      case IMGSENSOR_ID_AUTO_WHITE_BALANCE:
        sp->awb = control->value;
        break;

      case IMGSENSOR_ID_RED_BALANCE:
        sp->red = control->value;
        break;

      case IMGSENSOR_ID_BLUE_BALANCE:
        sp->blue = control->value;
        break;

      case IMGSENSOR_ID_GAMMA:
        sp->gamma = control->value;
        break;

      case IMGSENSOR_ID_GAMMA_CURVE:
        memcpy(sp->gamma_curve,
               control->p_u8,
               sp->gamma_curve_sz);
        break;

      case IMGSENSOR_ID_EXPOSURE:
        sp->ev = control->value;
        break;

      case IMGSENSOR_ID_HFLIP_VIDEO:
        sp->hflip_video = control->value;
        break;

      case IMGSENSOR_ID_VFLIP_VIDEO:
        sp->vflip_video = control->value;
        break;

      case IMGSENSOR_ID_HFLIP_STILL:
        sp->hflip_still = control->value;
        break;

      case IMGSENSOR_ID_VFLIP_STILL:
        sp->vflip_still = control->value;
        break;

      case IMGSENSOR_ID_SHARPNESS:
        sp->sharpness = control->value;
        break;

      case IMGSENSOR_ID_COLOR_KILLER:
        sp->colorfx = control->value ? V4L2_COLORFX_BW : V4L2_COLORFX_NONE;
        break;

      case IMGSENSOR_ID_COLORFX:
        sp->colorfx = control->value;
        break;

      case IMGSENSOR_ID_AUTOBRIGHTNESS:
        sp->auto_brightness = control->value;
        break;

      case IMGSENSOR_ID_ROTATE:
        sp->rotate = control->value;
        break;

      case IMGSENSOR_ID_EXPOSURE_AUTO:
        sp->ae = control->value;
        break;

      case IMGSENSOR_ID_EXPOSURE_ABSOLUTE:
        sp->exposure_time = control->value;
        break;

      case IMGSENSOR_ID_FOCUS_ABSOLUTE:
        sp->focus = control->value;
        break;

      case IMGSENSOR_ID_FOCUS_AUTO:
        sp->af = control->value;
        break;

      case IMGSENSOR_ID_ZOOM_ABSOLUTE:
        sp->zoom = control->value;
        break;

      case IMGSENSOR_ID_IRIS_ABSOLUTE:
        sp->iris = control->value;
        break;

      case IMGSENSOR_ID_AUTO_N_PRESET_WB:
        sp->wb = control->value;
        break;

      case IMGSENSOR_ID_WIDE_DYNAMIC_RANGE:
        sp->wdr = control->value;
        break;

      case IMGSENSOR_ID_IMG_STABILIZATION:
        sp->stabilization = control->value;
        break;

      case IMGSENSOR_ID_ISO_SENSITIVITY:
        sp->iso = control->value;
        break;

      case IMGSENSOR_ID_ISO_SENSITIVITY_AUTO:
        sp->iso_auto = control->value;
        break;

      case IMGSENSOR_ID_EXPOSURE_METERING:
        sp->meter = control->value;
        break;

      case IMGSENSOR_ID_SPOT_POSITION:
        sp->spot_pos = control->value;
        break;

      case IMGSENSOR_ID_3A_LOCK:
        sp->threea_lock = control->value;
        break;

      case IMGSENSOR_ID_FLASH_LED_MODE:
        sp->led = control->value;
        break;

      case IMGSENSOR_ID_JPEG_QUALITY:
        sp->jpeg_quality = control->value;
        break;

      default:
        return -EINVAL;
    }

  return OK;
}

/* Callback function which device driver call when capture has done. */

static int complete_capture(uint8_t err_code,
                            uint32_t datasize,
                            FAR const struct timeval *ts,
                            FAR void *arg)
{
  FAR capture_mng_t *cmng = (FAR capture_mng_t *)arg;
  FAR capture_type_inf_t *type_inf;
  FAR vbuf_container_t *container = NULL;
  enum v4l2_buf_type buf_type;
  irqstate_t           flags;
  imgdata_format_t df[MAX_CAPTURE_FMT];
  video_format_t c_fmt[MAX_CAPTURE_FMT];

  flags = enter_critical_section();

  buf_type = cmng->still_inf.state == CAPTURE_STATE_CAPTURE ?
               V4L2_BUF_TYPE_STILL_CAPTURE : V4L2_BUF_TYPE_VIDEO_CAPTURE;

  type_inf = get_capture_type_inf(cmng, buf_type);
  if (type_inf == NULL)
    {
      leave_critical_section(flags);
      return -EINVAL;
    }

  poll_notify(&type_inf->fds, 1, POLLIN);

  if (err_code == 0)
    {
      type_inf->bufinf.vbuf_next->buf.flags = 0;
      if (type_inf->remaining_capnum > 0)
        {
          type_inf->remaining_capnum--;
        }
    }
  else
    {
      type_inf->bufinf.vbuf_next->buf.flags = V4L2_BUF_FLAG_ERROR;
    }

  type_inf->bufinf.vbuf_next->buf.bytesused = datasize;
  if (ts != NULL)
    {
      type_inf->bufinf.vbuf_next->buf.timestamp = *ts;
    }

  video_framebuff_capture_done(&type_inf->bufinf);

  if (is_sem_waited(&type_inf->wait_capture.dqbuf_wait_flg))
    {
      /* If waiting capture in DQBUF,
       * get/save container and unlock wait
       */

      type_inf->wait_capture.done_container =
        video_framebuff_pop_curr_container(&type_inf->bufinf);
      type_inf->wait_capture.waitend_cause = WAITEND_CAUSE_CAPTUREDONE;
      nxsem_post(&type_inf->wait_capture.dqbuf_wait_flg);
    }

  if (type_inf->remaining_capnum == 0)
    {
      stop_capture(cmng, buf_type);
      type_inf->state = CAPTURE_STATE_STREAMOFF;

      /* If stop still stream, notify it to video stream */

      if (buf_type == V4L2_BUF_TYPE_STILL_CAPTURE &&
          is_sem_waited(&cmng->capture_inf.wait_capture.dqbuf_wait_flg))
        {
          cmng->capture_inf.wait_capture.waitend_cause =
            WAITEND_CAUSE_STILLSTOP;
          nxsem_post(&cmng->capture_inf.wait_capture.dqbuf_wait_flg);
        }
    }
  else
    {
      container = video_framebuff_get_vacant_container(&type_inf->bufinf);
      if (container == NULL)
        {
          stop_capture(cmng, buf_type);
          type_inf->state = CAPTURE_STATE_STREAMON;
        }
      else
        {
          get_clipped_format(type_inf->nr_fmt,
                             type_inf->fmt,
                             &type_inf->clip,
                             c_fmt);

          convert_to_imgdatafmt(&c_fmt[CAPTURE_FMT_MAIN],
                                &df[IMGDATA_FMT_MAIN]);
          convert_to_imgdatafmt(&c_fmt[CAPTURE_FMT_SUB],
                                &df[IMGDATA_FMT_SUB]);

          IMGDATA_SET_BUF(cmng->imgdata,
            type_inf->nr_fmt,
            df,
            (FAR uint8_t *)container->buf.m.userptr,
            container->buf.length);
          container->buf.sequence = type_inf->seqnum++;
        }
    }

  leave_critical_section(flags);
  return OK;
}

static FAR struct imgsensor_s *
get_connected_imgsensor(FAR struct imgsensor_s **sensors,
                        size_t sensor_num)
{
  FAR struct imgsensor_s *sensor = NULL;
  int i;

  for (i = 0; i < sensor_num; i++)
    {
      if (sensors[i] &&
          IMGSENSOR_IS_AVAILABLE(sensors[i]))
        {
          sensor = sensors[i];
          break;
        }
    }

  return sensor;
}

/****************************************************************************
 * Ioctl Functions
 ****************************************************************************/

static int capture_querycap(FAR struct file *filep,
                            FAR struct v4l2_capability *cap)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;
  FAR const char *name;

  if (cmng == NULL || cap == NULL)
    {
      return -EINVAL;
    }

  ASSERT(cmng->imgsensor);

  name = IMGSENSOR_GET_DRIVER_NAME(cmng->imgsensor);
  if (name == NULL)
    {
      return -ENOTTY;
    }

  memset(cap, 0, sizeof(struct v4l2_capability));

  /* cap->driver needs to be NULL-terminated. */

  strlcpy((FAR char *)cap->driver, name, sizeof(cap->driver));
  cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;

  return OK;
}

static int capture_g_input(FAR int *num)
{
  *num = 0;
  return OK;
}

static int capture_enum_input(FAR struct file *filep,
                              FAR struct v4l2_input *input)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;
  FAR const char *name;

  if (cmng == NULL || input->index > 0)
    {
      return -EINVAL;
    }

  ASSERT(cmng->imgsensor);

  name = IMGSENSOR_GET_DRIVER_NAME(cmng->imgsensor);
  if (name == NULL)
    {
      return -ENOTTY;
    }

  memset(input, 0, sizeof(struct v4l2_input));
  strlcpy((FAR char *)input->name, name, sizeof(input->name));
  input->type = V4L2_INPUT_TYPE_CAMERA;

  return OK;
}

static int capture_reqbufs(FAR struct file *filep,
                           FAR struct v4l2_requestbuffers *reqbufs)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;
  FAR capture_type_inf_t *type_inf;
  struct imgdata_s *imgdata;
  irqstate_t flags;
  int ret = OK;

  if (cmng == NULL || reqbufs == NULL)
    {
      return -EINVAL;
    }

  imgdata  = cmng->imgdata;
  type_inf = get_capture_type_inf(cmng, reqbufs->type);
  if (type_inf == NULL)
    {
      return -EINVAL;
    }

  flags = enter_critical_section();

  if (type_inf->state == CAPTURE_STATE_CAPTURE)
    {
      /* In capture, REQBUFS is not permitted */

      ret = -EPERM;
    }
  else
    {
      if (reqbufs->count > V4L2_REQBUFS_COUNT_MAX)
        {
          reqbufs->count = V4L2_REQBUFS_COUNT_MAX;
        }

      video_framebuff_change_mode(&type_inf->bufinf, reqbufs->mode);
      ret = video_framebuff_realloc_container(&type_inf->bufinf,
                                              reqbufs->count);
      if (ret == OK && reqbufs->memory == V4L2_MEMORY_MMAP)
        {
          if (type_inf->bufheap != NULL)
            {
              if (imgdata->ops->free)
                {
                    imgdata->ops->free(imgdata, type_inf->bufheap);
                }
              else
                {
                  kumm_free(type_inf->bufheap);
                }
            }

          if (imgdata->ops->alloc)
            {
              type_inf->bufheap = imgdata->ops->alloc(imgdata, 32,
                reqbufs->count *
                get_bufsize(&type_inf->fmt[CAPTURE_FMT_MAIN]));
            }
          else
            {
              type_inf->bufheap = kumm_memalign(32, reqbufs->count *
                get_bufsize(&type_inf->fmt[CAPTURE_FMT_MAIN]));
            }

          if (type_inf->bufheap == NULL)
            {
              ret = -ENOMEM;
            }
        }
    }

  leave_critical_section(flags);
  return ret;
}

static int capture_querybuf(FAR struct file *filep,
                            FAR struct v4l2_buffer *buf)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;
  FAR capture_type_inf_t *type_inf;

  if (cmng == NULL || buf == NULL || buf->memory != V4L2_MEMORY_MMAP)
    {
      return -EINVAL;
    }

  type_inf = get_capture_type_inf(cmng, buf->type);
  if (type_inf == NULL)
    {
      return -EINVAL;
    }

  if (buf->index >= type_inf->bufinf.container_size)
    {
      return -EINVAL;
    }

  buf->length = get_bufsize(&type_inf->fmt[CAPTURE_FMT_MAIN]);
  buf->m.offset = buf->length * buf->index;

  return OK;
}

static int capture_qbuf(FAR struct file *filep,
                        FAR struct v4l2_buffer *buf)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;
  FAR capture_type_inf_t *type_inf;
  FAR vbuf_container_t *container;
  enum capture_state_e next_capture_state;
  irqstate_t flags;

  if (cmng == NULL || buf == NULL)
    {
      return -EINVAL;
    }

  type_inf = get_capture_type_inf(cmng, buf->type);
  if (type_inf == NULL)
    {
      return -EINVAL;
    }

  if (!is_bufsize_sufficient(cmng, buf->length))
    {
      return -EINVAL;
    }

  container = video_framebuff_get_container(&type_inf->bufinf);
  if (container == NULL)
    {
      return -ENOMEM;
    }

  memcpy(&container->buf, buf, sizeof(struct v4l2_buffer));
  if (buf->memory == V4L2_MEMORY_MMAP)
    {
      /* only use userptr inside the container */

      container->buf.length = get_bufsize(&type_inf->fmt[CAPTURE_FMT_MAIN]);
      container->buf.m.userptr = (unsigned long)(type_inf->bufheap +
                                 container->buf.length * buf->index);
    }

  video_framebuff_queue_container(&type_inf->bufinf, container);

  nxmutex_lock(&type_inf->lock_state);
  flags = enter_critical_section();
  if (type_inf->state == CAPTURE_STATE_STREAMON)
    {
      leave_critical_section(flags);

      if (buf->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
        {
          nxmutex_lock(&cmng->still_inf.lock_state);
          next_capture_state =
            estimate_next_capture_state(cmng, CAUSE_CAPTURE_START);
          change_capture_state(cmng, next_capture_state);
          nxmutex_unlock(&cmng->still_inf.lock_state);
        }
      else
        {
          container =
            video_framebuff_get_vacant_container(&type_inf->bufinf);
          if (container != NULL)
            {
              type_inf->seqnum = 0;
              start_capture(cmng,
                            buf->type,
                            type_inf->nr_fmt,
                            type_inf->fmt,
                            &type_inf->clip,
                            &type_inf->frame_interval,
                            container->buf.m.userptr,
                            container->buf.length);
              type_inf->state = CAPTURE_STATE_CAPTURE;
            }
        }
    }
  else
    {
      leave_critical_section(flags);
    }

  nxmutex_unlock(&type_inf->lock_state);
  return OK;
}

static int capture_dqbuf(FAR struct file *filep,
                         FAR struct v4l2_buffer *buf)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;
  FAR capture_type_inf_t *type_inf;
  FAR vbuf_container_t *container;
  FAR sem_t *dqbuf_wait_flg;
  enum capture_state_e next_capture_state;
  irqstate_t flags;

  if (cmng == NULL || buf == NULL)
    {
      return -EINVAL;
    }

  type_inf = get_capture_type_inf(cmng, buf->type);
  if (type_inf == NULL)
    {
      return -EINVAL;
    }

  container = video_framebuff_dq_valid_container(&type_inf->bufinf);
  if (container == NULL)
    {
      if (filep->f_oflags & O_NONBLOCK)
        {
          return -EAGAIN;
        }

      /* Not yet done capture. Wait done */

      dqbuf_wait_flg = &type_inf->wait_capture.dqbuf_wait_flg;

      /* Loop until semaphore is unlocked by capture done or DQCANCEL */

      do
        {
          if (buf->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
            {
              /* If start capture condition is satisfied, start capture */

              flags = enter_critical_section();
              next_capture_state =
                estimate_next_capture_state(cmng, CAUSE_CAPTURE_DQBUF);
              change_capture_state(cmng, next_capture_state);
              leave_critical_section(flags);
            }

          nxsem_wait_uninterruptible(dqbuf_wait_flg);
        }
      while (type_inf->wait_capture.waitend_cause ==
             WAITEND_CAUSE_STILLSTOP);

      container = type_inf->wait_capture.done_container;
      if (container == NULL)
        {
          /* Waking up without captured data means abort.
           * Therefore, Check cause.
           */

          DEBUGASSERT(type_inf->wait_capture.waitend_cause ==
                      WAITEND_CAUSE_DQCANCEL);
          return -ECANCELED;
        }

      type_inf->wait_capture.done_container = NULL;
    }

  memcpy(buf, &container->buf, sizeof(struct v4l2_buffer));
  video_framebuff_free_container(&type_inf->bufinf, container);

  return OK;
}

static int capture_cancel_dqbuf(FAR struct file *filep,
                                enum v4l2_buf_type type)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;
  FAR capture_type_inf_t *type_inf;

  if (cmng == NULL)
    {
      return -EINVAL;
    }

  type_inf = get_capture_type_inf(cmng, type);
  if (type_inf == NULL)
    {
      return -EINVAL;
    }

  if (!is_sem_waited(&type_inf->wait_capture.dqbuf_wait_flg))
    {
      /* In not waiting DQBUF case, return OK */

      return OK;
    }

  type_inf->wait_capture.waitend_cause = WAITEND_CAUSE_DQCANCEL;

  /* If capture is done before nxsem_post, cause is overwritten */

  return nxsem_post(&type_inf->wait_capture.dqbuf_wait_flg);
}

static int capture_g_fmt(FAR struct file *filep,
                         FAR struct v4l2_format *fmt)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;
  FAR capture_type_inf_t *type_inf;

  if (cmng == NULL)
    {
      return -EINVAL;
    }

  type_inf = get_capture_type_inf(cmng, fmt->type);
  if (type_inf == NULL)
    {
      return -EINVAL;
    }

  memset(&fmt->fmt, 0, sizeof(fmt->fmt));
  fmt->fmt.pix.width = type_inf->fmt[CAPTURE_FMT_MAIN].width;
  fmt->fmt.pix.height = type_inf->fmt[CAPTURE_FMT_MAIN].height;
  fmt->fmt.pix.pixelformat = type_inf->fmt[CAPTURE_FMT_MAIN].pixelformat;

  return OK;
}

static int capture_s_fmt(FAR struct file *filep,
                         FAR struct v4l2_format *fmt)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;
  FAR capture_type_inf_t *type_inf;
  int ret;

  if (cmng == NULL)
    {
      return -EINVAL;
    }

  ret = capture_try_fmt(filep, fmt);
  if (ret != 0)
    {
      return ret;
    }

  type_inf = get_capture_type_inf(cmng, fmt->type);
  if (type_inf == NULL)
    {
      return -EINVAL;
    }

  if (type_inf->state != CAPTURE_STATE_STREAMOFF)
    {
      return -EBUSY;
    }

  switch (fmt->fmt.pix.pixelformat)
    {
      case V4L2_PIX_FMT_SUBIMG_UYVY:
      case V4L2_PIX_FMT_SUBIMG_RGB565:
        if (type_inf->fmt[CAPTURE_FMT_MAIN].pixelformat !=
            V4L2_PIX_FMT_JPEG_WITH_SUBIMG)
          {
            return -EPERM;
          }

        type_inf->fmt[CAPTURE_FMT_SUB].width  = fmt->fmt.pix.width;
        type_inf->fmt[CAPTURE_FMT_SUB].height = fmt->fmt.pix.height;
        type_inf->fmt[CAPTURE_FMT_SUB].pixelformat =
            fmt->fmt.pix.pixelformat == V4L2_PIX_FMT_SUBIMG_UYVY ?
              V4L2_PIX_FMT_UYVY : V4L2_PIX_FMT_RGB565;
        type_inf->nr_fmt = 2;
        break;

      default:
        type_inf->fmt[CAPTURE_FMT_MAIN].width  = fmt->fmt.pix.width;
        type_inf->fmt[CAPTURE_FMT_MAIN].height = fmt->fmt.pix.height;
        type_inf->fmt[CAPTURE_FMT_MAIN].pixelformat =
                                          fmt->fmt.pix.pixelformat;
        type_inf->nr_fmt = 1;
        break;
    }

  return OK;
}

static int capture_try_fmt(FAR struct file *filep,
                           FAR struct v4l2_format *fmt)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;
  FAR capture_type_inf_t *type_inf;
  video_format_t vf[MAX_CAPTURE_FMT];
  uint8_t nr_fmt;

  if (cmng == NULL || fmt == NULL)
    {
      return -EINVAL;
    }

  ASSERT(cmng->imgsensor && cmng->imgdata);

  type_inf = get_capture_type_inf(cmng, fmt->type);
  if (type_inf == NULL)
    {
      return -EINVAL;
    }

  switch (fmt->fmt.pix.pixelformat)
    {
      case V4L2_PIX_FMT_SUBIMG_UYVY:
      case V4L2_PIX_FMT_SUBIMG_RGB565:
        if (type_inf->fmt[CAPTURE_FMT_MAIN].pixelformat !=
            V4L2_PIX_FMT_JPEG_WITH_SUBIMG)
          {
            return -EPERM;
          }

        /* Validate both main image and subimage. */

        nr_fmt = 2;
        memcpy(&vf[CAPTURE_FMT_MAIN],
               &type_inf->fmt[CAPTURE_FMT_MAIN],
               sizeof(video_format_t));
        vf[CAPTURE_FMT_SUB].width       = fmt->fmt.pix.width;
        vf[CAPTURE_FMT_SUB].height      = fmt->fmt.pix.height;
        vf[CAPTURE_FMT_SUB].pixelformat =
            fmt->fmt.pix.pixelformat == V4L2_PIX_FMT_SUBIMG_UYVY ?
              V4L2_PIX_FMT_UYVY : V4L2_PIX_FMT_RGB565;
        break;
      case V4L2_PIX_FMT_NV12:
      case V4L2_PIX_FMT_YUV420:
      case V4L2_PIX_FMT_YUYV:
      case V4L2_PIX_FMT_UYVY:
      case V4L2_PIX_FMT_RGB565:
      case V4L2_PIX_FMT_JPEG:
      case V4L2_PIX_FMT_JPEG_WITH_SUBIMG:
        nr_fmt = 1;
        vf[CAPTURE_FMT_MAIN].width       = fmt->fmt.pix.width;
        vf[CAPTURE_FMT_MAIN].height      = fmt->fmt.pix.height;
        vf[CAPTURE_FMT_MAIN].pixelformat = fmt->fmt.pix.pixelformat;
        break;

      default:
        return -EINVAL;
    }

  return validate_frame_setting(cmng,
                                fmt->type,
                                nr_fmt,
                                vf,
                                &type_inf->clip,
                                &type_inf->frame_interval);
}

static int capture_g_parm(FAR struct file *filep,
                          FAR struct v4l2_streamparm *parm)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;
  FAR capture_type_inf_t *type_inf;
  int ret = -EINVAL;

  if (cmng == NULL || parm == NULL)
    {
      return -EINVAL;
    }

  DEBUGASSERT(cmng->imgsensor);

  type_inf = get_capture_type_inf(cmng, parm->type);
  if (type_inf == NULL)
    {
      return -EINVAL;
    }

  memset(&parm->parm, 0, sizeof(parm->parm));

  if (type_inf->state == CAPTURE_STATE_CAPTURE)
    {
      /* If capture is started and lower driver has the get_frame_interval(),
       * query lower driver.
       */

      ret = IMGSENSOR_GET_FRAME_INTERVAL(cmng->imgsensor, parm->type,
              (imgsensor_interval_t *)&parm->parm.capture.timeperframe);
    }

  if (ret != OK)
    {
      /* In no capture state or error case, return stored value. */

      memcpy(&parm->parm.capture.timeperframe,
             &type_inf->frame_interval,
             sizeof(struct v4l2_fract));
    }

  parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
  return OK;
}

static int capture_s_parm(FAR struct file *filep,
                          FAR struct v4l2_streamparm *parm)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;
  FAR capture_type_inf_t *type_inf;
  int ret;

  if (cmng == NULL || parm == NULL)
    {
      return -EINVAL;
    }

  ASSERT(cmng->imgsensor && cmng->imgdata);

  type_inf = get_capture_type_inf(cmng, parm->type);
  if (type_inf == NULL)
    {
      return -EINVAL;
    }

  if (type_inf->state != CAPTURE_STATE_STREAMOFF)
    {
      return -EBUSY;
    }

  ret = validate_frame_setting(cmng,
                               parm->type,
                               type_inf->nr_fmt,
                               type_inf->fmt,
                               &type_inf->clip,
                               &parm->parm.capture.timeperframe);
  if (ret != OK)
    {
      return ret;
    }

  memcpy(&type_inf->frame_interval,
         &parm->parm.capture.timeperframe,
         sizeof(struct v4l2_fract));

  return ret;
}

static int capture_streamon(FAR struct file *filep,
                            FAR enum v4l2_buf_type *type)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;
  FAR capture_type_inf_t *type_inf;
  enum capture_state_e next_capture_state;
  int ret = OK;

  if (cmng == NULL || type == NULL)
    {
      return -EINVAL;
    }

  type_inf = get_capture_type_inf(cmng, *type);
  if (type_inf == NULL)
    {
      return -EINVAL;
    }

  if (*type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
    {
      /* No procedure for VIDIOC_STREAMON(STILL_CAPTURE) */

      return OK;
    }

  nxmutex_lock(&type_inf->lock_state);

  if (type_inf->state != CAPTURE_STATE_STREAMOFF)
    {
      ret = -EPERM;
    }
  else
    {
      next_capture_state =
        estimate_next_capture_state(cmng, CAUSE_CAPTURE_START);
      change_capture_state(cmng, next_capture_state);
    }

  nxmutex_unlock(&type_inf->lock_state);
  return ret;
}

static int capture_streamoff(FAR struct file *filep,
                             FAR enum v4l2_buf_type *type)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;
  FAR capture_type_inf_t *type_inf;
  enum capture_state_e next_capture_state;
  irqstate_t flags;
  int ret = OK;

  if (cmng == NULL || type == NULL)
    {
      return -EINVAL;
    }

  type_inf = get_capture_type_inf(cmng, *type);
  if (type_inf == NULL)
    {
      return -EINVAL;
    }

  if (*type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
    {
      /* No procedure for VIDIOC_STREAMOFF(STILL_CAPTURE) */

      return OK;
    }

  flags = enter_critical_section();

  if (type_inf->state == CAPTURE_STATE_STREAMOFF)
    {
      ret = -EPERM;
    }
  else
    {
      next_capture_state =
        estimate_next_capture_state(cmng, CAUSE_CAPTURE_STOP);
      change_capture_state(cmng, next_capture_state);
    }

  leave_critical_section(flags);

  return ret;
}

static int capture_do_halfpush(FAR struct file *filep, bool enable)
{
  struct v4l2_ext_controls ext_controls;
  struct v4l2_ext_control  control[2];

  /* Replace to VIDIOC_S_EXT_CTRLS format */

  control[0].id    = V4L2_CID_3A_LOCK;
  control[0].value = enable ?
                     V4L2_LOCK_EXPOSURE | V4L2_LOCK_WHITE_BALANCE : 0;
  control[1].id    = V4L2_CID_AUTO_FOCUS_START;
  control[1].value = enable ? true : false;

  ext_controls.ctrl_class = V4L2_CTRL_CLASS_CAMERA;
  ext_controls.count      = 2;
  ext_controls.controls   = control;

  /* Execute VIDIOC_S_EXT_CTRLS */

  return capture_s_ext_ctrls(filep, &ext_controls);
}

static int capture_takepict_start(FAR struct file *filep,
                                  int32_t capture_num)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;
  enum capture_state_e next_capture_state;
  FAR vbuf_container_t *container;
  irqstate_t flags;
  int ret = OK;

  if (cmng == NULL)
    {
      return -EINVAL;
    }

  nxmutex_lock(&cmng->still_inf.lock_state);

  if (cmng->still_inf.state != CAPTURE_STATE_STREAMOFF)
    {
      ret = -EPERM;
    }
  else
    {
      if (capture_num > 0)
        {
          cmng->still_inf.remaining_capnum = capture_num;
        }
      else
        {
          cmng->still_inf.remaining_capnum = REMAINING_CAPNUM_INFINITY;
        }

      /* Control video stream prior to still stream */

      flags = enter_critical_section();

      next_capture_state = estimate_next_capture_state(cmng,
                                                   CAUSE_STILL_START);
      change_capture_state(cmng, next_capture_state);

      leave_critical_section(flags);

      container =
        video_framebuff_get_vacant_container(&cmng->still_inf.bufinf);
      if (container != NULL)
        {
          /* Start still stream capture */

          start_capture(cmng,
                        V4L2_BUF_TYPE_STILL_CAPTURE,
                        cmng->still_inf.nr_fmt,
                        cmng->still_inf.fmt,
                        &cmng->still_inf.clip,
                        &cmng->still_inf.frame_interval,
                        container->buf.m.userptr,
                        container->buf.length);

          cmng->still_inf.state = CAPTURE_STATE_CAPTURE;
        }
      else
        {
          cmng->still_inf.state = CAPTURE_STATE_STREAMON;
        }
    }

  nxmutex_unlock(&cmng->still_inf.lock_state);
  return ret;
}

static int capture_takepict_stop(FAR struct file *filep,
                                 bool halfpush)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;
  enum capture_state_e next_capture_state;
  irqstate_t flags;
  int ret = OK;

  if (cmng == NULL)
    {
      return -EINVAL;
    }

  nxmutex_lock(&cmng->still_inf.lock_state);

  if (cmng->still_inf.state == CAPTURE_STATE_STREAMOFF &&
      cmng->still_inf.remaining_capnum == REMAINING_CAPNUM_INFINITY)
    {
      ret = -EPERM;
    }
  else
    {
      flags = enter_critical_section();
      if (cmng->still_inf.state == CAPTURE_STATE_CAPTURE)
        {
          stop_capture(cmng, V4L2_BUF_TYPE_STILL_CAPTURE);
        }

      leave_critical_section(flags);

      cmng->still_inf.state = CAPTURE_STATE_STREAMOFF;
      cmng->still_inf.remaining_capnum = REMAINING_CAPNUM_INFINITY;

      /* Control video stream */

      nxmutex_lock(&cmng->capture_inf.lock_state);
      next_capture_state = estimate_next_capture_state(cmng,
                                                   CAUSE_STILL_STOP);
      change_capture_state(cmng, next_capture_state);
      nxmutex_unlock(&cmng->capture_inf.lock_state);
    }

  nxmutex_unlock(&cmng->still_inf.lock_state);
  return ret;
}

static int capture_s_selection(FAR struct file *filep,
                               FAR struct v4l2_selection *clip)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;
  FAR capture_type_inf_t *type_inf;
  uint32_t p_u32[IMGSENSOR_CLIP_NELEM];
  imgsensor_value_t val;
  uint32_t id;
  int ret;

  if (cmng == NULL || clip == NULL)
    {
      return -EINVAL;
    }

  ASSERT(cmng->imgsensor);

  type_inf = get_capture_type_inf(cmng, clip->type);
  if (type_inf == NULL)
    {
      return -EINVAL;
    }

  if (type_inf->state != CAPTURE_STATE_STREAMOFF)
    {
      return -EBUSY;
    }

  if (!validate_clip_setting(&clip->r, type_inf->fmt))
    {
      return -EINVAL;
    }

  ret = validate_frame_setting(cmng,
                               clip->type,
                               type_inf->nr_fmt,
                               type_inf->fmt,
                               &clip->r,
                               &type_inf->frame_interval);
  if (ret != OK)
    {
      return ret;
    }

  id = clip->type == V4L2_BUF_TYPE_VIDEO_CAPTURE ?
       IMGSENSOR_ID_CLIP_VIDEO : IMGSENSOR_ID_CLIP_STILL;

  p_u32[IMGSENSOR_CLIP_INDEX_LEFT]   = clip->r.left;
  p_u32[IMGSENSOR_CLIP_INDEX_TOP]    = clip->r.top;
  p_u32[IMGSENSOR_CLIP_INDEX_WIDTH]  = clip->r.width;
  p_u32[IMGSENSOR_CLIP_INDEX_HEIGHT] = clip->r.height;

  val.p_u32 = p_u32;
  ret = IMGSENSOR_SET_VALUE(cmng->imgsensor, id, sizeof(p_u32), val);
  if (ret != OK)
    {
      return ret;
    }

  memcpy(&type_inf->clip, &clip->r, sizeof(struct v4l2_rect));
  return ret;
}

static int capture_g_selection(FAR struct file *filep,
                               FAR struct v4l2_selection *clip)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;
  FAR capture_type_inf_t *type_inf;

  if (cmng == NULL || clip == NULL)
    {
      return -EINVAL;
    }

  type_inf = get_capture_type_inf(cmng, clip->type);
  if (type_inf == NULL)
    {
      return -EINVAL;
    }

  memcpy(&clip->r, &type_inf->clip, sizeof(struct v4l2_rect));
  return OK;
}

static int capture_queryctrl(FAR struct file *filep,
                             FAR struct v4l2_queryctrl *ctrl)
{
  struct v4l2_query_ext_ctrl ext_ctrl;
  int ret;

  if (ctrl == NULL)
    {
      return -EINVAL;
    }

  /* Replace to VIDIOC_QUERY_EXT_CTRL format */

  ext_ctrl.ctrl_class = ctrl->ctrl_class;
  ext_ctrl.id         = ctrl->id;

  ret = capture_query_ext_ctrl(filep, &ext_ctrl);
  if (ret != OK)
    {
      return ret;
    }

  if (ext_ctrl.type == V4L2_CTRL_TYPE_INTEGER64 ||
      ext_ctrl.type == V4L2_CTRL_TYPE_U8 ||
      ext_ctrl.type == V4L2_CTRL_TYPE_U16 ||
      ext_ctrl.type == V4L2_CTRL_TYPE_U32)
    {
      /* Unsupported type in VIDIOC_QUERYCTRL */

      return -EINVAL;
    }

  /* Replace gotten value to VIDIOC_QUERYCTRL */

  ctrl->type          = ext_ctrl.type;
  ctrl->minimum       = ext_ctrl.minimum;
  ctrl->maximum       = ext_ctrl.maximum;
  ctrl->step          = ext_ctrl.step;
  ctrl->default_value = ext_ctrl.default_value;
  ctrl->flags         = ext_ctrl.flags;
  strlcpy(ctrl->name, ext_ctrl.name, sizeof(ctrl->name));

  return OK;
}

static int capture_query_ext_ctrl(FAR struct file *filep,
                                  FAR struct v4l2_query_ext_ctrl *attr)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;
  imgsensor_supported_value_t value;
  imgsensor_capability_range_t *range = &value.u.range;
  imgsensor_capability_discrete_t *disc = &value.u.discrete;
  imgsensor_capability_elems_t *elem = &value.u.elems;
  int ret;

  if (cmng == NULL || attr == NULL)
    {
      return -EINVAL;
    }

  ASSERT(cmng->imgsensor);

  attr->flags      = 0;
  attr->elem_size  = 0;
  attr->elems      = 1;
  attr->nr_of_dims = 0;
  memset(attr->dims, 0, sizeof(attr->dims));

  if (attr->id == V4L2_CID_SCENE_MODE)
    {
      /* Scene mode is processed in only video driver. */

      attr->type          = V4L2_CTRL_TYPE_INTEGER_MENU;
      attr->minimum       = 0;
      attr->maximum       = cmng->capture_scence_num - 1;
      attr->step          = 1;
      attr->default_value = 0;
      attr->flags         = 0;
      strlcpy(attr->name, "Scene Mode", 32);
    }
  else
    {
      ret = IMGSENSOR_GET_SUPPORTED_VALUE(cmng->imgsensor, attr->id, &value);
      if (ret < 0)
        {
          return ret;
        }

      attr->type = value.type;
      attr->flags = 0;

      switch (value.type)
        {
          case IMGSENSOR_CTRL_TYPE_INTEGER_MENU:
            attr->minimum       = 0;
            attr->maximum       = disc->nr_values - 1;
            attr->step          = 1;
            attr->default_value = disc->default_value;
            break;

          case IMGSENSOR_CTRL_TYPE_U8:
          case IMGSENSOR_CTRL_TYPE_U16:
          case IMGSENSOR_CTRL_TYPE_U32:
            attr->minimum = elem->minimum;
            attr->maximum = elem->maximum;
            attr->step    = elem->step;
            attr->elems   = elem->nr_elems;
            break;

          default:
            attr->minimum       = range->minimum;
            attr->maximum       = range->maximum;
            attr->step          = range->step;
            attr->default_value = range->default_value;
            break;
        }

      set_parameter_name(attr->id, attr->name);
    }

  return OK;
}

static int capture_querymenu(FAR struct file *filep,
                             FAR struct v4l2_querymenu *menu)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;
  imgsensor_supported_value_t value;
  int ret;

  if (cmng == NULL || menu == NULL)
    {
      return -EINVAL;
    }

  ASSERT(cmng->imgsensor);

  if (menu->id == V4L2_CID_SCENE_MODE)
    {
      /* Scene mode is processed in only video driver. */

      if (menu->index > cmng->capture_scence_num - 1)
        {
          return -EINVAL;
        }

      menu->value = cmng->capture_scene_param[menu->index]->mode;
    }
  else
    {
      ret = IMGSENSOR_GET_SUPPORTED_VALUE(cmng->imgsensor,
                                          menu->id,
                                          &value);
      if (ret < 0)
        {
          return ret;
        }

      if (value.type != IMGSENSOR_CTRL_TYPE_INTEGER_MENU)
        {
          /* VIDIOC_QUERYMENU is used only for
           * IMGSENSOR_CTRL_TYPE_INTEGER_MENU.
           */

          return -EINVAL;
        }

      if (menu->index >= value.u.discrete.nr_values)
        {
          return -EINVAL;
        }

      menu->value = value.u.discrete.values[menu->index];
    }

  return OK;
}

static int capture_g_ctrl(FAR struct file *filep,
                          FAR struct v4l2_control *ctrl)
{
  struct v4l2_ext_controls ext_controls;
  struct v4l2_ext_control control;
  int ret;

  if (ctrl == NULL)
    {
      return -EINVAL;
    }

  memset(&ext_controls, 0, sizeof(struct v4l2_ext_controls));
  memset(&control, 0, sizeof(struct v4l2_ext_control));

  /* Replace to VIDIOC_G_EXT_CTRLS format */

  control.id = ctrl->id;

  ext_controls.ctrl_class = V4L2_CTRL_CLASS_USER;
  ext_controls.count      = 1;
  ext_controls.controls   = &control;

  /* Execute VIDIOC_G_EXT_CTRLS */

  ret = capture_g_ext_ctrls(filep, &ext_controls);
  if (ret == OK)
    {
      /* Replace gotten value to VIDIOC_G_CTRL parameter */

      ctrl->value = control.value;
    }

  return ret;
}

static int capture_s_ctrl(FAR struct file *filep,
                          FAR struct v4l2_control *ctrl)
{
  struct v4l2_ext_controls ext_controls;
  struct v4l2_ext_control control;

  if (ctrl == NULL)
    {
      return -EINVAL;
    }

  /* Replace to VIDIOC_S_EXT_CTRLS format */

  control.id    = ctrl->id;
  control.value = ctrl->value;

  ext_controls.ctrl_class = V4L2_CTRL_CLASS_USER;
  ext_controls.count      = 1;
  ext_controls.controls   = &control;

  /* Execute VIDIOC_S_EXT_CTRLS */

  return capture_s_ext_ctrls(filep, &ext_controls);
}

static int capture_g_ext_ctrls(FAR struct file *filep,
                               FAR struct v4l2_ext_controls *ctrls)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;
  FAR struct v4l2_ext_control *control;
  int ret = OK;
  int cnt;

  if (cmng == NULL || ctrls == NULL)
    {
      return -EINVAL;
    }

  ASSERT(cmng->imgsensor);

  for (cnt = 0, control = ctrls->controls;
       cnt < ctrls->count;
       cnt++, control++)
    {
      if (control->id == V4L2_CID_SCENE_MODE)
        {
          control->value = cmng->capture_scene_mode;
        }
      else
        {
          ret = IMGSENSOR_GET_VALUE(cmng->imgsensor,
                  control->id,
                  control->size,
                  (imgsensor_value_t *)&control->value64);
          if (ret < 0)
            {
              /* Set cnt in that error occurred */

              ctrls->error_idx = cnt;
              return ret;
            }
        }
    }

  return ret;
}

static int capture_s_ext_ctrls(FAR struct file *filep,
                               FAR struct v4l2_ext_controls *ctrls)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;
  FAR struct v4l2_ext_control *control;
  int ret = OK;
  int cnt;

  if (cmng == NULL || ctrls == NULL)
    {
      return -EINVAL;
    }

  ASSERT(cmng->imgsensor);

  for (cnt = 0, control = ctrls->controls;
       cnt < ctrls->count;
       cnt++, control++)
    {
      if (control->id == V4L2_CID_SCENE_MODE)
        {
          ret = reflect_scene_parameter(cmng, control->value);
        }
      else
        {
          ret = IMGSENSOR_SET_VALUE(cmng->imgsensor,
                  control->id,
                  control->size,
                  (imgsensor_value_t)control->value64);
          if (ret == 0)
            {
              if (cmng->capture_scene_mode == V4L2_SCENE_MODE_NONE)
                {
                  save_scene_param(cmng, V4L2_SCENE_MODE_NONE,
                    control->id,
                    control);
                }
            }
        }

      if (ret < 0)
        {
          /* Set cnt in that error occurred */

          ctrls->error_idx = cnt;
          return ret;
        }
    }

  return ret;
}

static int capture_query_ext_ctrl_scene(FAR struct file *filep,
             FAR struct v4s_query_ext_ctrl_scene *attr)
{
  if (attr == NULL)
    {
      return -EINVAL;
    }

  return capture_query_ext_ctrl(filep, &attr->control);
}

static int capture_querymenu_scene(FAR struct file *filep,
             FAR struct v4s_querymenu_scene *menu)
{
  if (menu == NULL)
    {
      return -EINVAL;
    }

  return capture_querymenu(filep, &menu->menu);
}

static int capture_s_ext_ctrls_scene(FAR struct file *filep,
             FAR struct v4s_ext_controls_scene *ctrls)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;
  FAR struct v4l2_ext_control *control;
  int ret = OK;
  int cnt;

  if (cmng == NULL || ctrls == NULL)
    {
      return -EINVAL;
    }

  for (cnt = 0, control = ctrls->control.controls;
       cnt < ctrls->control.count;
       cnt++, control++)
    {
      ret = save_scene_param(cmng, ctrls->mode, control->id, control);
      if (ret != OK)
        {
          ctrls->control.error_idx = cnt;
          return ret;
        }
    }

  return ret;
}

static int capture_g_ext_ctrls_scene(FAR struct file *filep,
             FAR struct v4s_ext_controls_scene *ctrls)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;
  FAR struct v4l2_ext_control *control;
  int ret = OK;
  int cnt;

  if (cmng == NULL || ctrls == NULL)
    {
      return -EINVAL;
    }

  for (cnt = 0, control = ctrls->control.controls;
       cnt < ctrls->control.count;
       cnt++, control++)
    {
      ret = read_scene_param(cmng, ctrls->mode,
               control->id,
               control);
      if (ret != OK)
        {
          ctrls->control.error_idx = cnt;
          return ret;
        }
    }

  return ret;
}

static int capture_enum_fmt(FAR struct file *filep,
                            FAR struct v4l2_fmtdesc *f)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;

  if (cmng == NULL || f == NULL)
    {
      return -EINVAL;
    }

  if (cmng->imgsensor && cmng->imgsensor->fmtdescs)
    {
      if (f->index > cmng->imgsensor->fmtdescs_num)
        {
          return -EINVAL;
        }
      else
        {
          f->pixelformat = cmng->imgsensor->fmtdescs[f->index].pixelformat;
          strlcpy(f->description,
                  cmng->imgsensor->fmtdescs[f->index].description,
                  sizeof(f->description));
        }
    }
  else
    {
      if (f->index > 0)
        {
          return -EINVAL;
        }

      f->pixelformat = V4L2_PIX_FMT_UYVY;
    }

  return 0;
}

static int capture_enum_frmsize(FAR struct file *filep,
                                FAR struct v4l2_frmsizeenum *f)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;

  if (cmng == NULL || f == NULL)
    {
      return -EINVAL;
    }

  if (cmng->imgsensor && cmng->imgsensor->frmsizes)
    {
      if (f->index > cmng->imgsensor->frmsizes_num)
        {
          return -EINVAL;
        }
      else
        {
          f->type = cmng->imgsensor->frmsizes[f->index].type;
          if (f->type == V4L2_FRMSIZE_TYPE_DISCRETE)
            {
              f->discrete = cmng->imgsensor->frmsizes[f->index].discrete;
            }
          else
            {
              f->stepwise = cmng->imgsensor->frmsizes[f->index].stepwise;
            }
        }
    }
  else
    {
      if (f->index > 0)
        {
          return -EINVAL;
        }

      f->type = V4L2_FRMIVAL_TYPE_DISCRETE;
      f->discrete.width = VIDEO_HSIZE_QVGA;
      f->discrete.height = VIDEO_VSIZE_QVGA;
    }

  return 0;
}

static int capture_enum_frminterval(FAR struct file *filep,
                                    FAR struct v4l2_frmivalenum *f)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;

  if (cmng == NULL || f == NULL)
    {
      return -EINVAL;
    }

  if (cmng->imgsensor && cmng->imgsensor->frmintervals)
    {
      if (f->index > cmng->imgsensor->frmintervals_num)
        {
          return -EINVAL;
        }
      else
        {
          f->type = cmng->imgsensor->frmintervals[f->index].type;
          if (f->type == V4L2_FRMIVAL_TYPE_DISCRETE)
            {
              f->discrete = cmng->imgsensor->frmintervals[f->index].discrete;
            }
          else
            {
              f->stepwise = cmng->imgsensor->frmintervals[f->index].stepwise;
            }
        }
    }
  else
    {
      if (f->index > 0)
        {
          return -EINVAL;
        }

      f->type = V4L2_FRMIVAL_TYPE_DISCRETE;
      f->discrete.denominator = 15;
      f->discrete.numerator = 1;
    }

  return 0;
}

/****************************************************************************
 * File Opterations Functions
 ****************************************************************************/

static int capture_open(FAR struct file *filep)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;
  int ret = OK;

  if (cmng == NULL)
    {
      return -EINVAL;
    }

  nxmutex_lock(&cmng->lock_open_num);
  if (cmng->open_num == 0)
    {
      /* Only in first execution, open device */

      ret = IMGSENSOR_INIT(cmng->imgsensor);
      if (ret == OK)
        {
          ret = IMGDATA_INIT(cmng->imgdata);
          if (ret == OK)
            {
              initialize_resources(cmng);
            }
        }
      else
        {
          ret = -ENODEV;
        }
    }

  /* In second or later execution, ret is initial value(=OK) */

  if (ret == OK)
    {
      cmng->open_num++;
    }

  nxmutex_unlock(&cmng->lock_open_num);
  return ret;
}

static int capture_close(FAR struct file *filep)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;

  if (cmng == NULL)
    {
      return -EINVAL;
    }

  nxmutex_lock(&cmng->lock_open_num);

  if (--cmng->open_num == 0)
    {
      cleanup_resources(cmng);
      IMGSENSOR_UNINIT(cmng->imgsensor);
      IMGDATA_UNINIT(cmng->imgdata);
#ifndef CONFIG_DISABLE_PSEUDOFS_OPERATIONS
      if (cmng->unlinked)
        {
          nxmutex_unlock(&cmng->lock_open_num);
          nxmutex_destroy(&cmng->lock_open_num);
          kmm_free(cmng);
          inode->i_private = NULL;
          return OK;
        }

#endif
    }

  nxmutex_unlock(&cmng->lock_open_num);
  return OK;
}

static int capture_mmap(FAR struct file *filep,
                        FAR struct mm_map_entry_s *map)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;
  FAR capture_type_inf_t *type_inf;
  size_t heapsize;
  int ret = -EINVAL;

  if (cmng == NULL)
    {
      return -EINVAL;
    }

  type_inf = &cmng->capture_inf;
  heapsize = get_heapsize(type_inf);

  if (map->offset >= 0 && map->offset < heapsize &&
      map->length && map->offset + map->length <= heapsize)
    {
      map->vaddr = type_inf->bufheap + map->offset;
      ret = OK;
    }

  return ret;
}

static int capture_poll(FAR struct file *filep,
                        FAR struct pollfd *fds, bool setup)
{
  FAR struct inode *inode = filep->f_inode;
  FAR capture_mng_t *cmng = inode->i_private;
  FAR capture_type_inf_t *type_inf;
  enum v4l2_buf_type buf_type;
  irqstate_t flags;

  if (cmng == NULL)
    {
      return -EINVAL;
    }

  buf_type = cmng->still_inf.state == CAPTURE_STATE_CAPTURE ?
               V4L2_BUF_TYPE_STILL_CAPTURE : V4L2_BUF_TYPE_VIDEO_CAPTURE;

  type_inf = get_capture_type_inf(cmng, buf_type);
  if (type_inf == NULL)
    {
      return -EINVAL;
    }

  flags = enter_critical_section();

  if (setup)
    {
      if (type_inf->fds == NULL)
        {
          type_inf->fds = fds;
          fds->priv     = &type_inf->fds;
          if (!video_framebuff_is_empty(&type_inf->bufinf))
            {
              poll_notify(&fds, 1, POLLIN);
            }
        }
      else
        {
          leave_critical_section(flags);
          return -EBUSY;
        }
    }
  else if (fds->priv)
    {
      type_inf->fds = NULL;
      fds->priv     = NULL;
    }

  leave_critical_section(flags);

  return OK;
}

#ifndef CONFIG_DISABLE_PSEUDOFS_OPERATIONS
static int capture_unlink(FAR struct inode *inode)
{
  FAR capture_mng_t *cmng = inode->i_private;

  if (cmng == NULL)
    {
      return -EINVAL;
    }

  nxmutex_lock(&cmng->lock_open_num);
  if (cmng->open_num == 0)
    {
      nxmutex_unlock(&cmng->lock_open_num);
      nxmutex_destroy(&cmng->lock_open_num);
      kmm_free(cmng);
      inode->i_private = NULL;
    }
  else
    {
      cmng->unlinked = true;
      nxmutex_unlock(&cmng->lock_open_num);
    }

  return OK;
}
#endif

/****************************************************************************
 * Public Functions
 ****************************************************************************/

int capture_initialize(FAR const char *devpath)
{
  return capture_register(devpath,
                          g_capture_data,
                          g_capture_registered_sensor,
                          g_capture_registered_sensor_num);
}

int capture_uninitialize(FAR const char *devpath)
{
  return capture_unregister(devpath);
}

int capture_register(FAR const char *devpath,
                     FAR struct imgdata_s *data,
                     FAR struct imgsensor_s **sensors,
                     size_t sensor_num)
{
  FAR capture_mng_t *cmng;
  int ret;

  /* Input devpath Error Check */

  if (devpath == NULL || data == NULL)
    {
      return -EINVAL;
    }

  /* Initialize capture device structure */

  cmng = kmm_zalloc(sizeof(capture_mng_t));
  if (cmng == NULL)
    {
      verr("Failed to allocate instance\n");
      return -ENOMEM;
    }

  cmng->v4l2.vops = &g_capture_vops;
  cmng->v4l2.fops = &g_capture_fops;

  cmng->imgdata   = data;
  cmng->imgsensor = get_connected_imgsensor(sensors, sensor_num);
  if (cmng->imgsensor == NULL)
    {
      kmm_free(cmng);
      return -EINVAL;
    }

  /* Initialize mutex */

  nxmutex_init(&cmng->lock_open_num);

  /* Register the character driver */

  ret = video_register(devpath, (FAR struct v4l2_s *)cmng);
  if (ret < 0)
    {
      verr("Failed to register driver: %d\n", ret);
      nxmutex_destroy(&cmng->lock_open_num);
      kmm_free(cmng);
      return ret;
    }

  return OK;
}

int capture_unregister(FAR const char *devpath)
{
  return unregister_driver(devpath);
}

int imgsensor_register(FAR struct imgsensor_s *sensor)
{
  FAR struct imgsensor_s **new_addr;
  int ret = -ENOMEM;

  new_addr = kmm_realloc(g_capture_registered_sensor, sizeof(sensor) *
                         (g_capture_registered_sensor_num + 1));
  if (new_addr != NULL)
    {
      new_addr[g_capture_registered_sensor_num++] = sensor;
      g_capture_registered_sensor = new_addr;
      ret = OK;
    }

  return ret;
}

void imgdata_register(FAR struct imgdata_s *data)
{
  g_capture_data = data;
}