sergiotarxz/nuttx
sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merged in alinjerpelea/nuttx (pull request #934)

Browse Source 
drivers: video: add basic Video Stream support

basic video stream and capture implementation based on the
spresense SDK code release

Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com>

Approved-by: Gregory Nutt <gnutt@nuttx.org>
This commit is contained in:
Alin Jerpelea 2019-07-04 13:30:50 +00:00 committed by Gregory Nutt
parent d9767b74cd
commit 128c1f1430
8 changed files with 2983 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
drivers/video/Kconfig
View File

@ -22,6 +22,12 @@ config FB_OVERLAY_BLIT
depends on FB_OVERLAY depends on FB_OVERLAY
default n default n
config VIDEO_STREAM
bool "Video Stream Support"
default n
---help---
Enable video Stream support
config VIDEO_MAX7456 config VIDEO_MAX7456
bool "Maxim 7456 Monochrome OSD" bool "Maxim 7456 Monochrome OSD"
default n default n

4
drivers/video/Make.defs
View File

@ -41,6 +41,10 @@ ifeq ($(CONFIG_VIDEO_FB),y)
CSRCS += fb.c CSRCS += fb.c
endif endif
ifeq ($(CONFIG_VIDEO_STREAM),y)
CSRCS += video.c video_framebuff.c
endif
# These video drivers depend on I2C support # These video drivers depend on I2C support
ifeq ($(CONFIG_I2C),y) ifeq ($(CONFIG_I2C),y)

1609
drivers/video/video.c Normal file
View File

File diff suppressed because it is too large Load Diff

299
drivers/video/video_framebuff.c Normal file
View File

@ -0,0 +1,299 @@
/****************************************************************************
* drivers/video/video_framebuff.c
*
* Copyright 2018 Sony Semiconductor Solutions Corporation
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name of Sony Semiconductor Solutions Corporation nor
* the names of its contributors may be used to endorse or promote
* products derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include "video_framebuff.h"
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <nuttx/irq.h>
#include <nuttx/kmalloc.h>
/****************************************************************************
* Private Functions
****************************************************************************/
static void init_buf_chain(video_framebuff_t *fbuf)
{
int i;
vbuf_container_t *tmp;
fbuf->vbuf_empty = fbuf->vbuf_alloced;
fbuf->vbuf_next_dma = NULL;
fbuf->vbuf_dma = NULL;
fbuf->vbuf_top = NULL;
fbuf->vbuf_tail = NULL;
tmp = fbuf->vbuf_alloced;
for (i = 0; i < fbuf->container_size - 1; i++)
{
tmp->next = &tmp[1];
tmp++;
}
}
static void cleanup_container(video_framebuff_t *fbuf)
{
if (fbuf->vbuf_alloced)
{
memset(fbuf->vbuf_alloced,
0,
sizeof(vbuf_container_t)*fbuf->container_size);
init_buf_chain(fbuf);
}
}
static inline int is_last_one(video_framebuff_t *fbuf)
{
return fbuf->vbuf_top == fbuf->vbuf_tail ? 1 : 0;
}
static inline vbuf_container_t *dequeue_vbuf_unsafe(video_framebuff_t *fbuf)
{
vbuf_container_t *ret = fbuf->vbuf_top;
if (is_last_one(fbuf))
{
fbuf->vbuf_top = NULL;
fbuf->vbuf_tail = NULL;
fbuf->vbuf_next_dma = NULL;
}
else
{
if (fbuf->mode == V4L2_BUF_MODE_RING)
{
fbuf->vbuf_tail->next = fbuf->vbuf_top->next;
}
fbuf->vbuf_top = fbuf->vbuf_top->next;
}
return ret;
}
/****************************************************************************
* Public Functions
****************************************************************************/
void video_framebuff_init(video_framebuff_t *fbuf)
{
fbuf->mode = V4L2_BUF_MODE_RING;
fbuf->vbuf_empty = NULL;
fbuf->vbuf_top = NULL;
fbuf->vbuf_tail = NULL;
fbuf->vbuf_next_dma = NULL;
sem_init(&fbuf->lock_empty, 0, 1);
}
void video_framebuff_uninit(video_framebuff_t *fbuf)
{
video_framebuff_realloc_container(fbuf, 0);
sem_destroy(&fbuf->lock_empty);
}
int video_framebuff_realloc_container(video_framebuff_t *fbuf, int sz)
{
if (sz > V4L2_REQBUFS_COUNT_MAX)
{
return -EINVAL;
}
if (fbuf->vbuf_alloced == NULL || fbuf->container_size != sz)
{
if (fbuf->container_size != sz)
{
if (fbuf->vbuf_alloced != NULL)
{
kmm_free(fbuf->vbuf_alloced);
}
fbuf->vbuf_alloced = NULL;
fbuf->container_size = 0;
}
if (sz > 0)
{
fbuf->vbuf_alloced
= (vbuf_container_t *)kmm_malloc(sizeof(vbuf_container_t)*sz);
if (fbuf->vbuf_alloced == NULL)
{
return -ENOMEM;
}
}
fbuf->container_size = sz;
}
cleanup_container(fbuf);
return OK;
}
vbuf_container_t *video_framebuff_get_container(video_framebuff_t *fbuf)
{
vbuf_container_t *ret;
sem_wait(&fbuf->lock_empty);
ret = fbuf->vbuf_empty;
if (ret)
{
fbuf->vbuf_empty = ret->next;
ret->next = NULL;
}
sem_post(&fbuf->lock_empty);
return ret;
}
void video_framebuff_free_container(video_framebuff_t *fbuf,
vbuf_container_t *cnt)
{
sem_wait(&fbuf->lock_empty);
cnt->next = fbuf->vbuf_empty;
fbuf->vbuf_empty = cnt;
sem_post(&fbuf->lock_empty);
}
void video_framebuff_queue_container(video_framebuff_t *fbuf,
vbuf_container_t *tgt)
{
irqstate_t flags;
flags = enter_critical_section();
if (fbuf->vbuf_top)
{
fbuf->vbuf_tail->next = tgt;
fbuf->vbuf_tail = tgt;
if (fbuf->vbuf_next_dma == NULL)
{
fbuf->vbuf_next_dma = tgt;
}
}
else
{
fbuf->vbuf_top = fbuf->vbuf_tail = tgt;
fbuf->vbuf_next_dma = tgt;
}
if (fbuf->mode == V4L2_BUF_MODE_RING)
{
fbuf->vbuf_tail->next = fbuf->vbuf_top;
}
else /* Case of V4L2_BUF_MODE_FIFO */
{
fbuf->vbuf_tail->next = NULL;
}
leave_critical_section(flags);
}
vbuf_container_t *video_framebuff_dq_valid_container(video_framebuff_t *fbuf)
{
irqstate_t flags;
vbuf_container_t *ret = NULL;
flags = enter_critical_section();
if (fbuf->vbuf_top != NULL && fbuf->vbuf_top != fbuf->vbuf_next_dma)
{
ret = dequeue_vbuf_unsafe(fbuf);
}
leave_critical_section(flags);
return ret;
}
vbuf_container_t *video_framebuff_get_dma_container(video_framebuff_t *fbuf)
{
irqstate_t flags;
vbuf_container_t *ret;
flags = enter_critical_section();
ret = fbuf->vbuf_dma = fbuf->vbuf_next_dma;
leave_critical_section(flags);
return ret;
}
void video_framebuff_dma_done(video_framebuff_t *fbuf)
{
fbuf->vbuf_dma = NULL;
if (fbuf->vbuf_next_dma)
{
fbuf->vbuf_next_dma = fbuf->vbuf_next_dma->next;
if (fbuf->vbuf_next_dma == fbuf->vbuf_top) /* RING mode case. */
{
fbuf->vbuf_top = fbuf->vbuf_top->next;
fbuf->vbuf_tail = fbuf->vbuf_tail->next;
}
}
}
void video_framebuff_change_mode(video_framebuff_t *fbuf,
enum v4l2_buf_mode mode)
{
irqstate_t flags;
flags = enter_critical_section();
if (fbuf->mode != mode)
{
if (fbuf->vbuf_tail)
{
if (mode == V4L2_BUF_MODE_RING)
{
fbuf->vbuf_tail->next = fbuf->vbuf_top;
fbuf->vbuf_next_dma = fbuf->vbuf_top;
}
else
{
fbuf->vbuf_tail->next = NULL;
fbuf->vbuf_next_dma = fbuf->vbuf_top;
}
}
fbuf->mode = mode;
}
leave_critical_section(flags);
}
vbuf_container_t *video_framebuff_pop_curr_container(video_framebuff_t *fbuf)
{
irqstate_t flags;
vbuf_container_t *ret = NULL;
flags = enter_critical_section();
if (fbuf->vbuf_top != NULL)
{
ret = dequeue_vbuf_unsafe(fbuf);
}
leave_critical_section(flags);
return ret;
}

90
drivers/video/video_framebuff.h Normal file
View File

@ -0,0 +1,90 @@
/****************************************************************************
* drivers/video/video_framebuff.h
*
* Copyright 2018 Sony Semiconductor Solutions Corporation
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name of Sony Semiconductor Solutions Corporation nor
* the names of its contributors may be used to endorse or promote
* products derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
#ifndef __VIDEO_VIDEO_FRAMEBUFF_H__
#define __VIDEO_VIDEO_FRAMEBUFF_H__
#include <nuttx/video/video.h>
#include <semaphore.h>
struct vbuf_container_s
{
struct v4l2_buffer buf; /* Buffer information */
struct vbuf_container_s *next; /* pointer to next buffer */
};
typedef struct vbuf_container_s vbuf_container_t;
struct video_framebuff_s
{
enum v4l2_buf_mode mode;
sem_t lock_empty;
int container_size;
vbuf_container_t *vbuf_alloced;
vbuf_container_t *vbuf_empty;
vbuf_container_t *vbuf_top;
vbuf_container_t *vbuf_tail;
vbuf_container_t *vbuf_dma;
vbuf_container_t *vbuf_next_dma;
};
typedef struct video_framebuff_s video_framebuff_t;
/* Buffer access interface. */
void video_framebuff_init
(video_framebuff_t *fbuf);
void video_framebuff_uninit
(video_framebuff_t *fbuf);
int video_framebuff_realloc_container
(video_framebuff_t *fbuf, int sz);
vbuf_container_t *video_framebuff_get_container
(video_framebuff_t *fbuf);
void video_framebuff_free_container
(video_framebuff_t *fbuf, vbuf_container_t *cnt);
void video_framebuff_queue_container
(video_framebuff_t *fbuf, vbuf_container_t *tgt);
vbuf_container_t *video_framebuff_dq_valid_container
(video_framebuff_t *fbuf);
vbuf_container_t *video_framebuff_get_dma_container
(video_framebuff_t *fbuf);
vbuf_container_t *video_framebuff_pop_curr_container
(video_framebuff_t *fbuf);
void video_framebuff_dma_done
(video_framebuff_t *fbuf);
void video_framebuff_change_mode
(video_framebuff_t *fbuf, enum v4l2_buf_mode mode);
#endif // __VIDEO_VIDEO_FRAMEBUFF_H__

646
include/nuttx/video/video.h Normal file
View File

@ -0,0 +1,646 @@
/****************************************************************************
* modules/include/video/video.h
*
* Copyright 2018 Sony Semiconductor Solutions Corporation
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name of Sony Semiconductor Solutions Corporation nor
* the names of its contributors may be used to endorse or promote
* products derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
#ifndef __INCLUDE_NUTTX_VIDEO_H
#define __INCLUDE_NUTTX_VIDEO_H
/****************************************************************************
* Included Files
****************************************************************************/
#include <stdint.h>
#include <sys/ioctl.h>
#include "video_controls.h"
#ifdef __cplusplus
extern "C"
{
#endif
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define _VIDIOCBASE (0x1000)
#define _VIDIOC(nr) _IOC(_VIDIOCBASE,nr)
/* Enumerate the formats supported by device */
#define VIDIOC_ENUM_FMT _VIDIOC(0x0001)
/* Enumerate the framesizes supported by device */
#define VIDIOC_ENUM_FRAMESIZES _VIDIOC(0x0002)
/* Enumerate the frameintervals supported by device */
#define VIDIOC_ENUM_FRAMEINTERVALS _VIDIOC(0x0003)
/* Try format */
#define VIDIOC_TRY_FMT _VIDIOC(0x0004)
/* Set the data format. */
#define VIDIOC_S_FMT _VIDIOC(0x0005)
/* Set the frame interval. */
#define VIDIOC_S_PARM _VIDIOC(0x0006)
/* Initiate user pointer I/O */
#define VIDIOC_REQBUFS _VIDIOC(0x0007)
/* Enqueue an empty buffer */
#define VIDIOC_QBUF _VIDIOC(0x0008)
/* Dequeue a filled buffer */
#define VIDIOC_DQBUF _VIDIOC(0x0009)
/* Start streaming */
#define VIDIOC_STREAMON _VIDIOC(0x000A)
/* Stop streaming */
#define VIDIOC_STREAMOFF _VIDIOC(0x000B)
/* Do halfpush */
#define VIDIOC_DO_HALFPUSH _VIDIOC(0x000C)
/* Start taking picture
*
* Type is int32_t, not address pointer.\n
* 0 or negative value means continuing until VIDIOC_TAKEPICT_STOP. \n
* Positive value(to be supported) means continuing
* up to a specified number of times or until VIDIOC_TAKEPICT_STOP.
*/
#define VIDIOC_TAKEPICT_START _VIDIOC(0x000D)
/* Stop taking picture */
#define VIDIOC_TAKEPICT_STOP _VIDIOC(0x000E)
/* Query control */
#define VIDIOC_QUERYCTRL _VIDIOC(0x000F)
/* Query control */
#define VIDIOC_QUERY_EXT_CTRL _VIDIOC(0x0010)
/* Query menu */
#define VIDIOC_QUERYMENU _VIDIOC(0x0011)
/* Get current control value.
* This request is a special case of VIDIOC_G_EXT_CTRLS.
* Address pointing to struct #v4l2_control
*/
#define VIDIOC_G_CTRL _VIDIOC(0x0012)
/* Set control value.
* This request is a special case of VIDIOC_S_EXT_CTRLS.
* Address pointing to struct #v4l2_control
*/
#define VIDIOC_S_CTRL _VIDIOC(0x0013)
/* Get current control value
* Address pointing to struct #v4l2_ext_controls
*/
#define VIDIOC_G_EXT_CTRLS _VIDIOC(0x0014)
/* Set control value
* Address pointing to struct #v4l2_ext_controls
*/
#define VIDIOC_S_EXT_CTRLS _VIDIOC(0x0015)
/* Cancel DQBUF
* enum #v4l2_buf_type
*/
#define VIDIOC_CANCEL_DQBUF _VIDIOC(0x0016)
#define VIDEO_HSIZE_QVGA (320) /* QVGA horizontal size */
#define VIDEO_VSIZE_QVGA (240) /* QVGA vertical size */
#define VIDEO_HSIZE_VGA (640) /* VGA horizontal size */
#define VIDEO_VSIZE_VGA (480) /* VGA vertical size */
#define VIDEO_HSIZE_QUADVGA (1280) /* QUADVGA horizontal size */
#define VIDEO_VSIZE_QUADVGA (960) /* QUADVGA vertical size */
#define VIDEO_HSIZE_HD (1280) /* HD horizontal size */
#define VIDEO_VSIZE_HD (720) /* HD vertical size */
#define VIDEO_HSIZE_FULLHD (1920) /* FULLHD horizontal size */
#define VIDEO_VSIZE_FULLHD (1080) /* FULLHD vertical size */
#define VIDEO_HSIZE_5M (2560) /* 5M horizontal size */
#define VIDEO_VSIZE_5M (1920) /* 5M vertical size */
#define VIDEO_HSIZE_3M (2048) /* 3M horizontal size */
#define VIDEO_VSIZE_3M (1536) /* 3M vertical size */
/* Four-character-code (FOURCC) */
#define v4l2_fourcc(a, b, c, d)\
((uint32_t)(a) | ((uint32_t)(b) << 8) | \
((uint32_t)(c) << 16) | ((uint32_t)(d) << 24))
#define v4l2_fourcc_be(a, b, c, d) (v4l2_fourcc(a, b, c, d) | (1 << 31))
/* YUV 4:2:2 */
#define V4L2_PIX_FMT_UYVY v4l2_fourcc('U', 'Y', 'V', 'Y')
/* RGB565 */
#define V4L2_PIX_FMT_RGB565 v4l2_fourcc('R', 'G', 'B', 'P')
/* JFIF JPEG */
#define V4L2_PIX_FMT_JPEG v4l2_fourcc('J', 'P', 'E', 'G')
/* JPEG + sub image */
#define V4L2_PIX_FMT_JPEG_WITH_SUBIMG v4l2_fourcc('J', 'S', 'U', 'B')
/* MAX length of v4l2_fmtdesc description string */
#define V4L2_FMT_DSC_MAX (32)
/* MAX length of v4l2_query_ext_ctrl dims array */
#define V4L2_CTRL_MAX_DIMS (4)
/* MAX value of VIDIOC_REQBUFS count parameter */
#define V4L2_REQBUFS_COUNT_MAX (256)
/* Buffer error flag */
#define V4L2_BUF_FLAG_ERROR (0x0001)
/****************************************************************************
* Public Types
****************************************************************************/
/* Buffer type.
* Currently, support only V4L2_BUF_TYPE_VIDEO_CAPTURE and
* V4L2_BUF_TYPE_STILL_CAPTURE.
*/
enum v4l2_buf_type
{
V4L2_BUF_TYPE_VIDEO_CAPTURE = 1, /* single-planar video capture stream */
V4L2_BUF_TYPE_VIDEO_OUTPUT = 2, /* single-planar video output stream */
V4L2_BUF_TYPE_VIDEO_OVERLAY = 3, /* video overlay */
V4L2_BUF_TYPE_VBI_CAPTURE = 4, /* raw VBI capture stream */
V4L2_BUF_TYPE_VBI_OUTPUT = 5, /* raw VBI output stream */
V4L2_BUF_TYPE_SLICED_VBI_CAPTURE = 6, /* sliced VBI capture stream */
V4L2_BUF_TYPE_SLICED_VBI_OUTPUT = 7, /* sliced VBI output stream */
V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY = 8, /* video output overlay */
V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE = 9, /* multi-planar video capture stream */
V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE = 10, /* multi-planar video output stream */
V4L2_BUF_TYPE_SDR_CAPTURE = 11, /* Software Defined Radio capture stream */
V4L2_BUF_TYPE_SDR_OUTPUT = 12, /* Software Defined Radio output stream */
V4L2_BUF_TYPE_META_CAPTURE = 13, /* metadata capture */
V4L2_BUF_TYPE_PRIVATE = 0x80, /* Deprecated, do not use */
V4L2_BUF_TYPE_STILL_CAPTURE = 0x81 /* single-planar still capture stream */
};
/* Memory I/O method. Currently, support only V4L2_MEMORY_USERPTR. */
enum v4l2_memory
{
V4L2_MEMORY_MMAP = 1, /* memory mapping I/O */
V4L2_MEMORY_USERPTR = 2, /* user pointer I/O */
V4L2_MEMORY_OVERLAY = 3, /* overlay I/O */
V4L2_MEMORY_DMABUF = 4, /* DMA shared buffer I/O */
};
/* Field order. Currently, support only V4L2_FIELD_ANY */
enum v4l2_field
{
V4L2_FIELD_ANY = 0, /* driver can choose from none, */
V4L2_FIELD_NONE = 1, /* this device has no fields ... */
V4L2_FIELD_TOP = 2, /* top field only */
V4L2_FIELD_BOTTOM = 3, /* bottom field only */
V4L2_FIELD_INTERLACED = 4, /* both fields interlaced */
V4L2_FIELD_SEQ_TB = 5, /* both fields sequential into one */
V4L2_FIELD_SEQ_BT = 6, /* same as above + bottom-top order */
V4L2_FIELD_ALTERNATE = 7, /* both fields alternating into */
V4L2_FIELD_INTERLACED_TB = 8, /* both fields interlaced, top field */
V4L2_FIELD_INTERLACED_BT = 9, /* both fields interlaced, top field */
};
/* Buffer mode */
enum v4l2_buf_mode
{
V4L2_BUF_MODE_RING = 0, /* Ring structure */
V4L2_BUF_MODE_FIFO = 1, /* FIFO structure */
};
struct v4l2_requestbuffers
{
uint32_t count; /* The number of buffers requested.
* Supported maximum is
* is V4L2_REQBUFS_COUNT_MAX(=256)
*/
uint32_t type; /* enum #v4l2_buf_type */
uint32_t memory; /* enum #v4l2_memory */
uint32_t mode; /* enum #v4l2_buf_mode */
};
typedef struct v4l2_requestbuffers v4l2_requestbuffers_t;
struct v4l2_timecode
{
uint32_t type;
uint32_t flags;
uint8_t frames;
uint8_t seconds;
uint8_t minutes;
uint8_t hours;
uint8_t userbits[4];
};
typedef struct v4l2_timecode v4l2_timecode_t;
struct v4l2_plane
{
uint32_t bytesused;
uint32_t length;
union
{
uint32_t mem_offset;
unsigned long userptr;
int fd;
} m;
uint32_t data_offset;
uint32_t reserved[11];
};
typedef struct v4l2_plane v4l2_plane_t;
/* struct v4l2_buffer
* Parameter of ioctl(VIDIOC_QBUF) and ioctl(VIDIOC_DQBUF).
* Currently, support only index, type, bytesused, memory,
* m.userptr, and length.
*/
struct v4l2_buffer
{
uint16_t index; /* buffer id */
uint16_t type; /* enum #v4l2_buf_type */
uint32_t bytesused; /* Driver sets the image size */
uint16_t flags; /* buffer flags. */
uint16_t field; /* the field order of the image */
struct v4l2_timecode timecode; /* frame timecode */
uint16_t sequence; /* frame sequence number */
uint16_t memory; /* enum #v4l2_memory */
union
{
uint32_t offset;
unsigned long userptr; /* address of buffer */
struct v4l2_plane *planes;
int fd;
} m;
uint32_t length; /* user set the buffer size */
};
typedef struct v4l2_buffer v4l2_buffer_t;
struct v4l2_fmtdesc
{
uint16_t index; /* Format number */
uint16_t type; /* enum v4l2_buf_type */
uint32_t flags;
char description[V4L2_FMT_DSC_MAX]; /* Description string */
uint32_t pixelformat; /* Format fourcc */
uint32_t subimg_pixelformat; /* Format fourcc */
};
enum v4l2_frmsizetypes
{
V4L2_FRMSIZE_TYPE_DISCRETE = 1, /* Discrete value */
V4L2_FRMSIZE_TYPE_CONTINUOUS = 2, /* Continous value */
V4L2_FRMSIZE_TYPE_STEPWISE = 3, /* Step value */
};
struct v4l2_frmsize_discrete
{
uint16_t width; /* Frame width [pixel] */
uint16_t height; /* Frame height [pixel] */
};
struct v4l2_frmsize_stepwise
{
uint16_t min_width; /* Minimum frame width [pixel] */
uint16_t max_width; /* Maximum frame width [pixel] */
uint16_t step_width; /* Frame width step size [pixel] */
uint16_t min_height; /* Minimum frame height [pixel] */
uint16_t max_height; /* Maximum frame height [pixel] */
uint16_t step_height; /* Frame height step size [pixel] */
};
struct v4l2_frmsizeenum
{
uint32_t index; /* Frame size number */
uint32_t buf_type; /* enum #v4l2_buf_type */
uint32_t pixel_format; /* Pixel format */
uint32_t type; /* Frame size type the device supports. */
union
{ /* Frame size */
struct v4l2_frmsize_discrete discrete; /* Use in type =
* V4L2_FRMSIZE_TYPE_DISCRETE
* case
*/
struct v4l2_frmsize_stepwise stepwise; /* Use in type =
* V4L2_FRMSIZE_TYPE_CONTINUOUS
* or V4L2_FRMSIZE_TYPE_STEPWISE
* case
*/
};
uint32_t subimg_pixel_format; /* Pixel format of sub image */
uint32_t subimg_type; /* Frame size type of subimage. */
union
{ /* Frame size of subimage */
struct v4l2_frmsize_discrete discrete; /* Use in subimg_type =
* V4L2_FRMSIZE_TYPE_DISCRETE
* case
*/
struct v4l2_frmsize_stepwise stepwise; /* Use in subimg_type =
* V4L2_FRMSIZE_TYPE_CONTINUOUS
* or V4L2_FRMSIZE_TYPE_STEPWISE
* case
*/
} subimg;
};
/* type of frame interval enumeration */
enum v4l2_frmivaltypes
{
V4L2_FRMIVAL_TYPE_DISCRETE = 1, /* Discrete value */
V4L2_FRMIVAL_TYPE_CONTINUOUS = 2, /* Continuous value */
V4L2_FRMIVAL_TYPE_STEPWISE = 3, /* Step value */
};
/* Fraction */
struct v4l2_fract
{
uint32_t numerator; /* numerator */
uint32_t denominator; /* denominator */
};
/* frame interval enumeration with stepwise format */
struct v4l2_frmival_stepwise
{
struct v4l2_fract min; /* Minimum frame interval [s] */
struct v4l2_fract max; /* Maximum frame interval [s] */
struct v4l2_fract step; /* Frame interval step size [s] */
};
struct v4l2_frmivalenum
{
uint32_t index; /* Frame format index */
uint32_t buf_type; /* enum #v4l2_buf_type */
uint32_t pixel_format; /* Pixel format */
uint16_t width; /* Frame width */
uint16_t height; /* Frame height */
uint32_t subimg_pixel_format; /* Pixel format for sub image */
uint16_t subimg_width; /* Frame width for sub image */
uint16_t subimg_height; /* Frame height for sub image */
uint32_t type; /* Frame interval type */
union
{ /* Frame interval */
struct v4l2_fract discrete;
struct v4l2_frmival_stepwise stepwise;
};
};
/* Single-planar format structure. */
struct v4l2_pix_format
{
uint16_t width; /* Image width in pixels */
uint16_t height; /* Image height in pixels */
uint32_t pixelformat; /* The pixel format or type of compression. */
uint16_t subimg_width; /* sub image width in pixels in case of pixelformat = V4L2_PIX_FMT_JPEG_WITH_SUBIMG */
uint16_t subimg_height; /* sub image height in pixels in case of pixelformat = V4L2_PIX_FMT_JPEG_WITH_SUBIMG */
uint32_t subimg_pixelformat; /* The pixel format of sub image in case of pixelformat = V4L2_PIX_FMT_JPEG_WITH_SUBIMG */
uint32_t field; /* enum #v4l2_field */
uint32_t bytesperline; /* for padding, zero if unused */
uint32_t sizeimage; /* Size in bytes of the buffer to hold a complete image */
uint32_t colorspace; /* Image colorspace */
uint32_t priv; /* private data, depends on pixelformat */
uint32_t flags; /* format flags (V4L2_PIX_FMT_FLAG_*) */
union
{
uint32_t ycbcr_enc; /* enum v4l2_ycbcr_encoding */
uint32_t hsv_enc; /* enum v4l2_hsv_encoding */
};
uint32_t quantization; /* enum v4l2_quantization */
uint32_t xfer_func; /* enum v4l2_xfer_func */
};
typedef struct v4l2_pix_format v4l2_pix_format_t;
struct v4l2_format
{
uint32_t type; /* enum #v4l2_buf_type. */
union
{
struct v4l2_pix_format pix; /* image format */
} fmt;
};
typedef struct v4l2_format v4l2_format_t;
struct v4l2_captureparm
{
uint32_t capability; /* Supported modes */
uint32_t capturemode; /* Current mode */
struct v4l2_fract timeperframe; /* Time per frame in seconds */
uint32_t extendedmode; /* Driver-specific extensions */
uint32_t readbuffers; /* # of buffers for read */
};
struct v4l2_streamparm
{
uint32_t type; /* enum v4l2_buf_type */
union
{
struct v4l2_captureparm capture;
} parm;
};
enum v4l2_ctrl_type
{
V4L2_CTRL_TYPE_INTEGER = 1,
V4L2_CTRL_TYPE_BOOLEAN = 2,
V4L2_CTRL_TYPE_MENU = 3,
V4L2_CTRL_TYPE_BUTTON = 4,
V4L2_CTRL_TYPE_INTEGER64 = 5,
V4L2_CTRL_TYPE_CTRL_CLASS = 6,
V4L2_CTRL_TYPE_STRING = 7,
V4L2_CTRL_TYPE_BITMASK = 8,
V4L2_CTRL_TYPE_INTEGER_MENU = 9,
V4L2_CTRL_TYPE_U8FIXEDPOINT_Q7 = 10,
V4L2_CTRL_TYPE_U16FIXEDPOINT_Q8 = 11,
V4L2_CTRL_TYPE_INTEGER_TIMES_3 = 12,
/* Compound types are >= 0x0100 */
V4L2_CTRL_COMPOUND_TYPES = 0x0100,
V4L2_CTRL_TYPE_U8 = 0x0100,
V4L2_CTRL_TYPE_U16 = 0x0101,
V4L2_CTRL_TYPE_U32 = 0x0102,
};
struct v4l2_queryctrl
{
uint16_t ctrl_class; /* Control class */
uint16_t id; /* Control id */
uint16_t type; /* enum #v4l2_ctrl_type */
char name[32]; /* Name of control */
int32_t minimum; /* Minimum value */
int32_t maximum; /* Maximum value */
uint32_t step; /* step */
int32_t default_value; /* Default value */
uint32_t flags; /* Flag */};
struct v4l2_query_ext_ctrl
{
uint16_t ctrl_class; /* Control class */
uint16_t id; /* Control id */
uint16_t type; /* enum #v4l2_ctrl_type */
char name[32]; /* Name of control */
int64_t minimum; /* Minimum value */
int64_t maximum; /* Maximum value */
uint64_t step; /* step */
int64_t default_value; /* Default value */
uint32_t flags; /* Flag */
uint32_t elem_size; /* size of each element */
uint32_t elems; /* number of elements */
uint32_t nr_of_dims; /* number of dimensions */
uint32_t dims[V4L2_CTRL_MAX_DIMS]; /* Dimensions */
};
struct v4l2_querymenu
{
uint16_t ctrl_class; /* camera control class */
uint16_t id; /* camera control id */
uint32_t index; /* index of menu. */
union
{
char name[32]; /* name of menu */
int64_t value; /* value of menu */
};
} __attribute__ ((packed));
struct v4l2_control
{
uint16_t id;
int32_t value;
};
/* structure for each control of
* ioctl(VIDIOC_G_EXT_CTRLS / VIDIOC_S_EXT_CTRLS)
*/
struct v4l2_ext_control
{
uint16_t id; /* camera control id */
uint16_t size; /* size of value(not use) */
union
{
int32_t value; /* QUERY_EXT_CTRL type = INTEGER, xxx */
int64_t value64; /* QUERY_EXT_CTRL type = INTEGER64, MENU */
char *string;
uint8_t *p_u8; /* QUERY_EXT_CTRL type = U8 */
uint16_t *p_u16; /* QUERY_EXT_CTRL type = U16 */
uint32_t *p_u32; /* QUERY_EXT_CTRL type = U32 */
void *ptr;
};
} __attribute__ ((packed));
struct v4l2_ext_controls
{
union
{
uint16_t ctrl_class; /* camera control class */
uint16_t which;
};
uint16_t count; /* number of requests */
uint16_t error_idx; /* index in that error occured */
struct v4l2_ext_control *controls; /* each control information */
};
/****************************************************************************
* Public Function Prototypes
****************************************************************************/
/* Initialize video driver.
*
* param [in] devpath: path to video device
*
* return On success, 0 is returned. On failure,
* negative value is returned.
*/
int video_initialize(FAR const char *devpath);
/* Uninitialize video driver.
*
* return On success, 0 is returned. On failure,
* negative value is returned.
*/
int video_uninitialize(void);
#ifdef __cplusplus
}
#endif
#endif /* __INCLUDE_NUTTX_VIDEO_H */

230
include/nuttx/video/video_controls.h Normal file
View File

@ -0,0 +1,230 @@
/****************************************************************************
* modules/include/video/video.h
*
* Copyright 2018 Sony Semiconductor Solutions Corporation
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name of Sony Semiconductor Solutions Corporation nor
* the names of its contributors may be used to endorse or promote
* products derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
#ifndef __INCLUDE_NUTTX_VIDEO_CONTROLS_H
#define __INCLUDE_NUTTX_VIDEO_CONTROLS_H
/****************************************************************************
* Included Files
****************************************************************************/
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
/* Control classes */
#define V4L2_CTRL_CLASS_USER (0x0000) /**< Old-style 'user' controls */
#define V4L2_CTRL_CLASS_CAMERA (0x0001) /**< Camera class controls */
#define V4L2_CTRL_CLASS_FLASH (0x0002) /**< Camera flash controls */
#define V4L2_CTRL_CLASS_JPEG (0x0003) /**< JPEG-compression controls */
/* User-class control IDs */
#define V4L2_CID_BRIGHTNESS (0) /**< Brightness */
#define V4L2_CID_CONTRAST (1) /**< Contrast */
#define V4L2_CID_SATURATION (2) /**< Saturation */
#define V4L2_CID_HUE (3) /**< Hue */
#define V4L2_CID_AUTO_WHITE_BALANCE (4) /**< AWB */
#define V4L2_CID_RED_BALANCE (5) /**< Red balance */
#define V4L2_CID_BLUE_BALANCE (6) /**< Blue balance */
#define V4L2_CID_GAMMA (7) /**< Gamma value adjustment */
#define V4L2_CID_GAMMA_CURVE (8) /**< Gamma curve adjustment */
#define V4L2_CID_EXPOSURE (9) /**< Exposure value */
#define V4L2_CID_HFLIP (10) /**< Mirror horizontally(VIDEO) */
#define V4L2_CID_VFLIP (11) /**< Mirror vertically(VIDEO) */
#define V4L2_CID_HFLIP_STILL (12) /**< Mirror horizontally(STILL) */
#define V4L2_CID_VFLIP_STILL (13) /**< Mirror vertically(STILL) */
#define V4L2_CID_SHARPNESS (14) /**< Sharpness */
#define V4L2_CID_COLOR_KILLER (15) /**< Color killer */
#define V4L2_CID_COLORFX (16) /**< Color effect */
/** enumeration for V4L2_CID_COLORFX */
enum v4l2_colorfx
{
V4L2_COLORFX_NONE = 0, /**< no effect */
V4L2_COLORFX_BW = 1, /**< Black/white */
V4L2_COLORFX_SEPIA = 2, /**< Sepia */
V4L2_COLORFX_NEGATIVE = 3, /**< positive/negative inversion */
V4L2_COLORFX_EMBOSS = 4, /**< Emboss */
V4L2_COLORFX_SKETCH = 5, /**< Sketch */
V4L2_COLORFX_SKY_BLUE = 6, /**< Sky blue */
V4L2_COLORFX_GRASS_GREEN = 7, /**< Grass green */
V4L2_COLORFX_SKIN_WHITEN = 8, /**< Skin whiten */
V4L2_COLORFX_VIVID = 9, /**< Vivid */
V4L2_COLORFX_AQUA = 10, /**< Aqua */
V4L2_COLORFX_ART_FREEZE = 11, /**< Art freeze */
V4L2_COLORFX_SILHOUETTE = 12, /**< Silhouette */
V4L2_COLORFX_SOLARIZATION = 13, /**< Solarization */
V4L2_COLORFX_ANTIQUE = 14, /**< Antique */
V4L2_COLORFX_SET_CBCR = 15, /**< Set CbCr */
V4L2_COLORFX_PASTEL = 16 /**< Pastel */
};
#define V4L2_CID_AUTOBRIGHTNESS (17) /**< Auto brightness */
#define V4L2_CID_ROTATE (18) /**< Rotation */
/** Camera class control IDs */
#define V4L2_CID_EXPOSURE_AUTO (0) /**< Auto exposure */
/** enumeration for V4L2_CID_EXPOSURE_AUTO */
enum v4l2_exposure_auto_type
{
/** exposure time:auto, iris aperture:auto */
V4L2_EXPOSURE_AUTO = 0,
/** exposure time:manual, iris aperture:manual */
V4L2_EXPOSURE_MANUAL = 1,
/** exposure time:manual, iris aperture:auto */
V4L2_EXPOSURE_SHUTTER_PRIORITY = 2,
/** exposure time:auto, iris aperture:manual */
V4L2_EXPOSURE_APERTURE_PRIORITY = 3
};
#define V4L2_CID_EXPOSURE_ABSOLUTE (1) /**< Exposure time */
#define V4L2_CID_FOCUS_ABSOLUTE (2) /** Focus */
#define V4L2_CID_FOCUS_RELATIVE (3) /** Focus */
#define V4L2_CID_FOCUS_AUTO (4) /** Auto focus */
#define V4L2_CID_ZOOM_ABSOLUTE (5) /** Zoom(absolute) */
#define V4L2_CID_ZOOM_RELATIVE (6) /** Zoom(relative) */
#define V4L2_CID_ZOOM_CONTINUOUS (7) /** Continuous zoom */
#define V4L2_CID_IRIS_ABSOLUTE (8) /** Iris(absolute) */
#define V4L2_CID_IRIS_RELATIVE (9) /** Iris(relative) */
#define V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE (10) /**< Preset white balance */
/** enumeration for V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE */
enum v4l2_auto_n_preset_white_balance
{
V4L2_WHITE_BALANCE_MANUAL = 0, /**< Manual */
V4L2_WHITE_BALANCE_AUTO = 1, /**< Automatic */
V4L2_WHITE_BALANCE_INCANDESCENT = 2, /**< Incandescent */
V4L2_WHITE_BALANCE_FLUORESCENT = 3, /**< Fluorescent */
V4L2_WHITE_BALANCE_FLUORESCENT_H = 4, /**< Fluorescent H */
V4L2_WHITE_BALANCE_HORIZON = 5, /**< Horizon */
V4L2_WHITE_BALANCE_DAYLIGHT = 6, /**< Daylight */
V4L2_WHITE_BALANCE_FLASH = 7, /**< Flash */
V4L2_WHITE_BALANCE_CLOUDY = 8, /**< Cloudy */
V4L2_WHITE_BALANCE_SHADE = 9, /**< Shade */
};
#define V4L2_CID_WIDE_DYNAMIC_RANGE (11) /**< Wide dynamic range */
#define V4L2_CID_IMAGE_STABILIZATION (12) /**< Image stabilization */
#define V4L2_CID_ISO_SENSITIVITY (13) /**< ISO sensitivity */
#define V4L2_CID_ISO_SENSITIVITY_AUTO (14) /**< Auto ISO sensitivity */
/** enumeration for V4L2_CID_ISO_SENSITIVITY_AUTO */
enum v4l2_iso_sensitivity_auto_type
{
V4L2_ISO_SENSITIVITY_MANUAL = 0, /**< Manual */
V4L2_ISO_SENSITIVITY_AUTO = 1, /**< Automatic */
};
#define V4L2_CID_EXPOSURE_METERING (15) /**< Exposure metering */
/** enumeration for V4L2_CID_EXPOSURE_METERING */
enum v4l2_exposure_metering
{
V4L2_EXPOSURE_METERING_AVERAGE = 0, /**< Average */
V4L2_EXPOSURE_METERING_CENTER_WEIGHTED = 1, /**< Center weighted */
V4L2_EXPOSURE_METERING_SPOT = 2, /**< Spot */
V4L2_EXPOSURE_METERING_MATRIX = 3, /**< Matrix */
};
#define V4L2_CID_SCENE_MODE (16) /**< Scene selection */
/** enumeration for V4L2_CID_SCENE_MODE */
enum v4l2_scene_mode
{
V4L2_SCENE_MODE_NONE = 0, /**< No scene */
V4L2_SCENE_MODE_BACKLIGHT = 1, /**< Backlight */
V4L2_SCENE_MODE_BEACH_SNOW = 2, /**< Beach snow */
V4L2_SCENE_MODE_CANDLE_LIGHT = 3, /**< Candle light */
V4L2_SCENE_MODE_DAWN_DUSK = 4, /**< Dawn dask */
V4L2_SCENE_MODE_FALL_COLORS = 5, /**< Fall colors */
V4L2_SCENE_MODE_FIREWORKS = 6, /**< Fire works */
V4L2_SCENE_MODE_LANDSCAPE = 7, /**< Landscape */
V4L2_SCENE_MODE_NIGHT = 8, /**< Night */
V4L2_SCENE_MODE_PARTY_INDOOR = 9, /**< Indoor party */
V4L2_SCENE_MODE_PORTRAIT = 10, /**< Portrait */
V4L2_SCENE_MODE_SPORTS = 11, /**< Sports */
V4L2_SCENE_MODE_SUNSET = 12, /**< Sunset */
V4L2_SCENE_MODE_TEXT = 13 /**< Text */
};
#define V4L2_CID_3A_LOCK (17) /**< Lock 3A */
#define V4L2_LOCK_EXPOSURE (1 << 0) /**< Exposure bit for
V4L2_CID_3A_LOCK */
#define V4L2_LOCK_WHITE_BALANCE (1 << 1) /**< White balance bit for
V4L2_CID_3A_LOCK */
#define V4L2_LOCK_FOCUS (1 << 2) /**< Focus bit for
V4L2_CID_3A_LOCK */
#define V4L2_CID_AUTO_FOCUS_START (18) /**< Start single AF */
#define V4L2_CID_AUTO_FOCUS_STOP (19) /**< Stop single AF */
/** Flash and privacy (indicator) light controls */
#define V4L2_CID_FLASH_LED_MODE (0)
/** enumeration for V4L2_CID_FLASH_LED_MODE */
enum v4l2_flash_led_mode
{
V4L2_FLASH_LED_MODE_NONE, /**< Not use LED */
V4L2_FLASH_LED_MODE_FLASH, /**< Flash mode */
V4L2_FLASH_LED_MODE_TORCH, /**< Torch mode */
};
/* JPEG-class control IDs */
#define V4L2_CID_JPEG_COMPRESSION_QUALITY (0) /**< JPEG quality */
#endif /* __INCLUDE_NUTTX_VIDEO_CONTROLS_H */

99
include/nuttx/video/video_halif.h Normal file
View File

@ -0,0 +1,99 @@
/****************************************************************************
* modules/include/video/video_halif.h
*
* Copyright 2018 Sony Semiconductor Solutions Corporation
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name of Sony Semiconductor Solutions Corporation nor
* the names of its contributors may be used to endorse or promote
* products derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
#ifndef __INCLUDE_NUTTX_VIDEO_HALIF_H
#define __INCLUDE_NUTTX_VIDEO_HALIF_H
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/video/video.h>
/****************************************************************************
* Public Types
****************************************************************************/
struct video_devops_s
{
CODE int (*open)(FAR void *video_priv);
CODE int (*close)(void);
CODE int (*do_halfpush)(bool enable);
CODE int (*set_buftype)(enum v4l2_buf_type type);
CODE int (*set_buf)(uint32_t bufaddr, uint32_t bufsize);
CODE int (*cancel_dma)(void);
CODE int (*get_range_of_fmt)(FAR struct v4l2_fmtdesc *format);
CODE int (*get_range_of_framesize)(FAR struct v4l2_frmsizeenum *frmsize);
CODE int (*try_format)(FAR struct v4l2_format *format);
CODE int (*set_format)(FAR struct v4l2_format *format);
CODE int (*get_range_of_frameinterval)
(FAR struct v4l2_frmivalenum *frmival);
CODE int (*set_frameinterval)(FAR struct v4l2_streamparm *parm);
CODE int (*get_range_of_ctrlvalue)(FAR struct v4l2_query_ext_ctrl *range);
CODE int (*get_menu_of_ctrlvalue)(FAR struct v4l2_querymenu *menu);
CODE int (*get_ctrlvalue)(uint16_t ctrl_class,
FAR struct v4l2_ext_control *control);
CODE int (*set_ctrlvalue)(uint16_t ctrl_class,
FAR struct v4l2_ext_control *control);
CODE int (*refresh)(void);
};
/****************************************************************************
* Public Data
****************************************************************************/
#ifdef __cplusplus
#define EXTERN extern "C"
extern "C"
{
#else
#define EXTERN extern
#endif
/****************************************************************************
* Public Functions
****************************************************************************/
int video_common_notify_dma_done(uint8_t err_code,
uint32_t buf_type,
uint32_t datasize,
FAR void *priv);
#undef EXTERN
#ifdef __cplusplus
}
#endif
#endif /* __INCLUDE_NUTTX_VIDEO_HALIF_H */