sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
57bd46d931
nuttx/drivers/video/video.c
Alin Jerpelea 128c1f1430 Merged in alinjerpelea/nuttx (pull request #934) 
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>
2019-07-04 13:30:50 +00:00

1610 lines
38 KiB
C
Raw Blame History

/****************************************************************************
* drivers/video/video.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 <nuttx/config.h>
#include <sys/ioctl.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <poll.h>
#include <nuttx/arch.h>
#include <nuttx/board.h>
#include <nuttx/kmalloc.h>
#include <arch/board/board.h>
#include <nuttx/video/video_halif.h>
#include "video_framebuff.h"
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define video_printf(format, ...) _info(format, ##__VA_ARGS__)
#define MAX_VIDEO_FILE_PATH (32)
#define VIDEO_TRUE (1)
#define VIDEO_FALSE (0)
#define VIDEO_REMAINING_CAPNUM_INFINITY (-1)
/* Debug option */
#ifdef CONFIG_DEBUG_VIDEO_ERROR
#define videoerr(format, ...) _err(format, ##__VA_ARGS__)
#else
#define videoerr(x...)
#endif
#ifdef CONFIG_DEBUG_VIDEO_WARN
#define videowarn(format, ...) _warn(format, ##__VA_ARGS__)
#else
#define videowarn(x...)
#endif
#ifdef CONFIG_DEBUG_VIDEO_INFO
#define videoinfo(format, ...) _info(format, ##__VA_ARGS__)
#else
#define videoinfo(x...)
#endif
/****************************************************************************
* Private Types
****************************************************************************/
enum video_state_e
{
VIDEO_STATE_STREAMOFF = 0, /* DMA trigger event is not received */
VIDEO_STATE_STREAMON = 1, /* DMA trigger event is received,
* but DMA is not operated.
*/
VIDEO_STATE_DMA = 2, /* On DMA */
};
enum video_state_transition_cause
{
CAUSE_VIDEO_STOP = 0, /* Stop DMA event for video stream */
CAUSE_VIDEO_START = 1, /* Start DMA event for video stream */
CAUSE_VIDEO_DQBUF = 2, /* DQBUF timing for video stream */
CAUSE_STILL_STOP = 3, /* Stop DMA event for still stream */
CAUSE_STILL_START = 4, /* Start DMA event for still stream */
};
enum video_waitend_cause_e
{
VIDEO_WAITEND_CAUSE_DMADONE = 0,
VIDEO_WAITEND_CAUSE_DQCANCEL = 1,
VIDEO_WAITEND_CAUSE_STILLSTOP = 2,
};
struct video_wait_dma_s
{
FAR sem_t dqbuf_wait_flg;
FAR vbuf_container_t *done_container; /* Save container which dma done */
enum video_waitend_cause_e waitend_cause;
};
typedef struct video_wait_dma_s video_wait_dma_t;
struct video_type_inf_s
{
sem_t lock_state;
enum video_state_e state;
int32_t remaining_capnum;
video_wait_dma_t wait_dma;
video_framebuff_t bufinf;
};
typedef struct video_type_inf_s video_type_inf_t;
struct video_mng_s
{
FAR char *devpath; /* parameter of video_initialize() */
sem_t lock_open_num;
uint8_t open_num;
FAR struct pollfd *poll_wait; /* poll(setup) information */
video_type_inf_t video_inf;
video_type_inf_t still_inf;
};
typedef struct video_mng_s video_mng_t;
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
/* Character driver methods. */
static int video_open(FAR struct file *filep);
static int video_close(FAR struct file *filep);
static int video_ioctl(FAR struct file *filep, int cmd, unsigned long arg);
static int video_poll(FAR struct file *filep,
FAR struct pollfd *fds,
bool setup);
/* Common function */
static int video_lock(FAR sem_t *sem);
static int video_unlock(FAR sem_t *sem);
static FAR video_type_inf_t *get_video_type_inf
(FAR video_mng_t *vmng, uint8_t type);
static enum video_state_e estimate_next_video_state
(FAR video_mng_t *vmng,
enum video_state_transition_cause cause);
static void change_video_state(FAR video_mng_t *vmng,
enum video_state_e next_state);
static bool is_taking_still_picture(FAR video_mng_t *vmng);
static bool is_bufsize_sufficient(FAR video_mng_t *vmng, uint32_t bufsize);
static void cleanup_resources(FAR video_mng_t *vmng);
static bool is_sem_waited(FAR sem_t *sem);
/* internal function for each cmds of ioctl */
static int video_reqbufs(FAR struct video_mng_s *vmng,
FAR struct v4l2_requestbuffers *reqbufs);
static int video_qbuf(FAR struct video_mng_s *vmng,
FAR struct v4l2_buffer *buf);
static int video_dqbuf(FAR struct video_mng_s *vmng,
FAR struct v4l2_buffer *buf);
static int video_cancel_dqbuf(FAR struct video_mng_s *vmng,
enum v4l2_buf_type type);
static int video_enum_fmt(FAR struct v4l2_fmtdesc *fmt);
static int video_enum_framesizes(FAR struct v4l2_frmsizeenum *frmsize);
static int video_s_fmt(FAR struct video_mng_s *priv,
FAR struct v4l2_format *fmt);
static int video_enum_frameintervals(FAR struct v4l2_frmivalenum *frmival);
static int video_s_parm(FAR struct video_mng_s *priv,
FAR struct v4l2_streamparm *parm);
static int video_streamon(FAR struct video_mng_s *vmng,
FAR enum v4l2_buf_type *type);
static int video_streamoff(FAR struct video_mng_s *vmng,
FAR enum v4l2_buf_type *type);
static int video_do_halfpush(bool enable);
static int video_takepict_start(FAR struct video_mng_s *vmng,
int32_t capture_num);
static int video_takepict_stop(FAR struct video_mng_s *vmng,
bool halfpush);
static int video_queryctrl(FAR struct v4l2_queryctrl *ctrl);
static int video_query_ext_ctrl(FAR struct v4l2_query_ext_ctrl *ctrl);
static int video_querymenu(FAR struct v4l2_querymenu *menu);
static int video_g_ctrl(FAR struct video_mng_s *priv,
FAR struct v4l2_control *ctrl);
static int video_s_ctrl(FAR struct video_mng_s *priv,
FAR struct v4l2_control *ctrl);
static int video_g_ext_ctrls(FAR struct video_mng_s *priv,
FAR struct v4l2_ext_controls *ctrls);
static int video_s_ext_ctrls(FAR struct video_mng_s *priv,
FAR struct v4l2_ext_controls *ctrls);
/****************************************************************************
* Private Data
****************************************************************************/
static const struct file_operations g_video_fops =
{
video_open, /* open */
video_close, /* close */
0, /* read */
0, /* write */
0, /* seek */
video_ioctl, /* ioctl */
#ifndef CONFIG_DISABLE_POLL
video_poll, /* poll */
#endif
0 /* unlink */
};
static FAR const struct video_devops_s *g_video_devops;
static bool is_initialized = false;
/****************************************************************************
* Public Data
****************************************************************************/
/****************************************************************************
* Private Functions
****************************************************************************/
static int video_lock(FAR sem_t *sem)
{
int ret;
int l_errno;
if (sem == NULL)
{
return -EINVAL;
}
while (1)
{
ret = sem_wait(sem);
if (ret == ERROR)
{
l_errno = errno;
if (l_errno == EINTR)
{
continue;
}
videoerr("sem_wait() failed:%d\n", l_errno);
}
break;
}
return ret;
}
static int video_unlock(FAR sem_t *sem)
{
if (sem == NULL)
{
return -EINVAL;
}
sem_post(sem);
return OK;
}
static FAR video_type_inf_t *get_video_type_inf
(FAR video_mng_t *vmng, uint8_t type)
{
FAR video_type_inf_t *type_inf;
switch (type)
{
case V4L2_BUF_TYPE_VIDEO_CAPTURE:
type_inf = &vmng->video_inf;
break;
case V4L2_BUF_TYPE_STILL_CAPTURE:
type_inf = &vmng->still_inf;
break;
default: /* Error case */
type_inf = NULL;
break;
}
return type_inf;
}
static enum video_state_e estimate_next_video_state
(FAR video_mng_t *vmng,
enum video_state_transition_cause cause)
{
enum video_state_e current_state = vmng->video_inf.state;
switch (cause)
{
case CAUSE_VIDEO_STOP:
return VIDEO_STATE_STREAMOFF;
case CAUSE_VIDEO_START:
if (is_taking_still_picture(vmng))
{
return VIDEO_STATE_STREAMON;
}
else
{
return VIDEO_STATE_DMA;
}
case CAUSE_STILL_STOP:
if (current_state == VIDEO_STATE_STREAMON)
{
return VIDEO_STATE_DMA;
}
else
{
return current_state;
}
case CAUSE_STILL_START:
if (current_state == VIDEO_STATE_DMA)
{
return VIDEO_STATE_STREAMON;
}
else
{
return current_state;
}
case CAUSE_VIDEO_DQBUF:
if ((current_state == VIDEO_STATE_STREAMON) &&
!is_taking_still_picture(vmng))
{
return VIDEO_STATE_DMA;
}
else
{
return current_state;
}
default:
return current_state;
}
}
static void change_video_state(FAR video_mng_t *vmng,
enum video_state_e next_state)
{
enum video_state_e current_state = vmng->video_inf.state;
enum video_state_e updated_next_state = next_state;
FAR vbuf_container_t *dma_container;
if ((current_state != VIDEO_STATE_DMA) &&
(next_state == VIDEO_STATE_DMA))
{
dma_container =
video_framebuff_get_dma_container(&vmng->video_inf.bufinf);
if (dma_container)
{
g_video_devops->set_buftype(V4L2_BUF_TYPE_VIDEO_CAPTURE);
g_video_devops->set_buf(dma_container->buf.m.userptr,
dma_container->buf.length);
}
else
{
updated_next_state = VIDEO_STATE_STREAMON;
}
}
else
{
if ((current_state == VIDEO_STATE_DMA) &&
(next_state != VIDEO_STATE_DMA))
{
g_video_devops->cancel_dma();
}
}
vmng->video_inf.state = updated_next_state;
return;
}
static bool is_taking_still_picture(FAR video_mng_t *vmng)
{
return ((vmng->still_inf.state == VIDEO_STATE_STREAMON) ||
(vmng->still_inf.state == VIDEO_STATE_DMA));
}
static bool is_bufsize_sufficient(FAR video_mng_t *vmng, uint32_t bufsize)
{
/* Depend on format, frame size, and JPEG compression quality */
return true;
}
static void initialize_streamresources(FAR video_type_inf_t *type_inf)
{
memset(type_inf, 0, sizeof(video_type_inf_t));
type_inf->remaining_capnum = VIDEO_REMAINING_CAPNUM_INFINITY;
sem_init(&type_inf->lock_state, 0, 1);
sem_init(&type_inf->wait_dma.dqbuf_wait_flg, 0, 0);
video_framebuff_init(&type_inf->bufinf);
return;
}
static void initialize_resources(FAR video_mng_t *vmng)
{
initialize_streamresources(&vmng->video_inf);
initialize_streamresources(&vmng->still_inf);
return;
}
static void cleanup_streamresources(FAR video_type_inf_t *type_inf)
{
video_framebuff_uninit(&type_inf->bufinf);
sem_destroy(&type_inf->wait_dma.dqbuf_wait_flg);
sem_destroy(&type_inf->lock_state);
memset(type_inf, 0, sizeof(video_type_inf_t));
type_inf->remaining_capnum = VIDEO_REMAINING_CAPNUM_INFINITY;
return;
}
static void cleanup_resources(FAR video_mng_t *vmng)
{
/* clean up resource */
if ((vmng->video_inf.state == VIDEO_STATE_DMA) ||
(vmng->still_inf.state == VIDEO_STATE_DMA))
{
/* If in DMA, stop */
g_video_devops->cancel_dma();
}
cleanup_streamresources(&vmng->video_inf);
cleanup_streamresources(&vmng->still_inf);
return;
}
static bool is_sem_waited(FAR sem_t *sem)
{
int ret;
int semcount;
ret = sem_getvalue(sem, &semcount);
if ((ret == OK) && (semcount < 0))
{
return true;
}
else
{
return false;
}
}
static int video_open(FAR struct file *filep)
{
FAR struct inode *inode = filep->f_inode;
FAR video_mng_t *priv = (FAR video_mng_t *)inode->i_private;
int ret = OK;
video_lock(&priv->lock_open_num);
if (priv->open_num == 0)
{
/* Only in first execution, open device */
ret = g_video_devops->open(priv);
if (ret == OK)
{
initialize_resources(priv);
}
}
/* In second or later execution, ret is initial value(=OK) */
if (ret == OK)
{
priv->open_num++;
}
video_unlock(&priv->lock_open_num);
return ret;
}
static int video_close(FAR struct file *filep)
{
FAR struct inode *inode = filep->f_inode;
FAR video_mng_t *priv = (FAR video_mng_t *)inode->i_private;
int ret = ERROR;
video_lock(&priv->lock_open_num);
if (priv->open_num == 0)
{
return OK;
}
priv->open_num--;
if (priv->open_num == 0)
{
cleanup_resources(priv);
g_video_devops->close();
}
video_unlock(&priv->lock_open_num);
return ret;
}
static int video_reqbufs(FAR struct video_mng_s *vmng,
FAR struct v4l2_requestbuffers *reqbufs)
{
int ret = OK;
FAR video_type_inf_t *type_inf;
irqstate_t flags;
if ((vmng == NULL) || (reqbufs == NULL))
{
return -EINVAL;
}
type_inf = get_video_type_inf(vmng, reqbufs->type);
if (type_inf == NULL)
{
return -EINVAL;
}
flags = enter_critical_section();
if (type_inf->state == VIDEO_STATE_DMA)
{
/* In DMA, REQBUFS is not permitted */
ret = -EPERM;
}
else
{
video_framebuff_change_mode(&type_inf->bufinf, reqbufs->mode);
ret = video_framebuff_realloc_container(&type_inf->bufinf,
reqbufs->count);
}
leave_critical_section(flags);
return ret;
}
static int video_qbuf(FAR struct video_mng_s *vmng,
FAR struct v4l2_buffer *buf)
{
FAR video_type_inf_t *type_inf;
FAR vbuf_container_t *container;
enum video_state_e next_video_state;
irqstate_t flags;
if ((vmng == NULL) || (buf == NULL))
{
return -EINVAL;
}
type_inf = get_video_type_inf(vmng, buf->type);
if (type_inf == NULL)
{
return -EINVAL;
}
if (!is_bufsize_sufficient(vmng, 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));
video_framebuff_queue_container(&type_inf->bufinf, container);
video_lock(&type_inf->lock_state);
flags = enter_critical_section();
if (type_inf->state == VIDEO_STATE_STREAMON)
{
leave_critical_section(flags);
if (buf->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
{
video_lock(&vmng->still_inf.lock_state);
next_video_state = estimate_next_video_state
(vmng, CAUSE_VIDEO_START);
change_video_state(vmng, next_video_state);
video_unlock(&vmng->still_inf.lock_state);
}
else
{
container = video_framebuff_get_dma_container(&type_inf->bufinf);
if (container)
{
g_video_devops->set_buftype(buf->type);
g_video_devops->set_buf(container->buf.m.userptr,
container->buf.length);
type_inf->state = VIDEO_STATE_DMA;
}
}
}
else
{
leave_critical_section(flags);
}
video_unlock(&type_inf->lock_state);
return OK;
}
static int video_dqbuf(FAR struct video_mng_s *vmng,
FAR struct v4l2_buffer *buf)
{
irqstate_t flags;
FAR video_type_inf_t *type_inf;
FAR vbuf_container_t *container;
sem_t *dqbuf_wait_flg;
enum video_state_e next_video_state;
if ((vmng == NULL) || (buf == NULL))
{
return -EINVAL;
}
type_inf = get_video_type_inf(vmng, buf->type);
if (type_inf == NULL)
{
return -EINVAL;
}
container = video_framebuff_dq_valid_container(&type_inf->bufinf);
if (container == NULL)
{
/* Not yet done DMA. Wait done */
dqbuf_wait_flg = &type_inf->wait_dma.dqbuf_wait_flg;
/* Loop until semaphore is unlocked by DMA done or DQCANCEL */
do
{
if (buf->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
{
/* If start DMA condition is satisfied, start DMA */
flags = enter_critical_section();
next_video_state = estimate_next_video_state
(vmng, CAUSE_VIDEO_DQBUF);
change_video_state(vmng, next_video_state);
leave_critical_section(flags);
}
sem_wait(dqbuf_wait_flg);
}
while (type_inf->wait_dma.waitend_cause ==
VIDEO_WAITEND_CAUSE_STILLSTOP);
container = type_inf->wait_dma.done_container;
if (!container)
{
/* Waking up without DMA data means abort.
* Therefore, Check cause.
*/
if (type_inf->wait_dma.waitend_cause
== VIDEO_WAITEND_CAUSE_DQCANCEL)
{
return -ECANCELED;
}
}
type_inf->wait_dma.done_container = NULL;
}
memcpy(buf, &container->buf, sizeof(struct v4l2_buffer));
video_framebuff_free_container(&type_inf->bufinf, container);
return OK;
}
static int video_cancel_dqbuf(FAR struct video_mng_s *vmng,
enum v4l2_buf_type type)
{
FAR video_type_inf_t *type_inf;
type_inf = get_video_type_inf(vmng, type);
if (type_inf == NULL)
{
return -EINVAL;
}
if (!is_sem_waited(&type_inf->wait_dma.dqbuf_wait_flg))
{
/* In not waiting DQBUF case, return OK */
return OK;
}
type_inf->wait_dma.waitend_cause = VIDEO_WAITEND_CAUSE_DQCANCEL;
/* If DMA is done before sem_post, cause is overwritten */
sem_post(&type_inf->wait_dma.dqbuf_wait_flg);
return OK;
}
static int video_enum_fmt(FAR struct v4l2_fmtdesc *fmt)
{
int ret;
if ((g_video_devops == NULL) ||
(g_video_devops->get_range_of_fmt == NULL))
{
return -EINVAL;
}
ret = g_video_devops->get_range_of_fmt(fmt);
return ret;
}
static int video_enum_framesizes(FAR struct v4l2_frmsizeenum *frmsize)
{
int ret;
if ((g_video_devops == NULL) ||
(g_video_devops->get_range_of_framesize == NULL))
{
return -EINVAL;
}
ret = g_video_devops->get_range_of_framesize(frmsize);
return ret;
}
static int video_try_fmt(FAR struct v4l2_format *fmt)
{
int ret;
if ((g_video_devops == NULL) || (g_video_devops->try_format == NULL))
{
return -EINVAL;
}
ret = g_video_devops->try_format(fmt);
return ret;
}
static int video_s_fmt(FAR struct video_mng_s *priv,
FAR struct v4l2_format *fmt)
{
int ret;
if ((g_video_devops == NULL) || (g_video_devops->set_format == NULL))
{
return -EINVAL;
}
ret = g_video_devops->set_format(fmt);
return ret;
}
static int video_enum_frameintervals(FAR struct v4l2_frmivalenum *frmival)
{
int ret;
if ((g_video_devops == NULL) ||
(g_video_devops->get_range_of_frameinterval == NULL))
{
return -EINVAL;
}
ret = g_video_devops->get_range_of_frameinterval(frmival);
return ret;
}
static int video_s_parm(FAR struct video_mng_s *priv,
FAR struct v4l2_streamparm *parm)
{
int ret;
if ((g_video_devops == NULL) ||
(g_video_devops->set_frameinterval == NULL))
{
return -EINVAL;
}
ret = g_video_devops->set_frameinterval(parm);
return ret;
}
static int video_streamon(FAR struct video_mng_s *vmng,
FAR enum v4l2_buf_type *type)
{
FAR video_type_inf_t *type_inf;
enum video_state_e next_video_state;
int ret = OK;
if ((vmng == NULL) || (type == NULL))
{
return -EINVAL;
}
type_inf = get_video_type_inf(vmng, *type);
if (type_inf == NULL)
{
return -EINVAL;
}
if (*type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
{
/* No procedure for VIDIOC_STREAMON(STILL_CAPTURE) */
return OK;
}
video_lock(&type_inf->lock_state);
if (type_inf->state != VIDEO_STATE_STREAMOFF)
{
ret = -EPERM;
}
else
{
next_video_state = estimate_next_video_state
(vmng, CAUSE_VIDEO_START);
change_video_state(vmng, next_video_state);
}
video_unlock(&type_inf->lock_state);
return ret;
}
static int video_streamoff(FAR struct video_mng_s *vmng,
FAR enum v4l2_buf_type *type)
{
FAR video_type_inf_t *type_inf;
enum video_state_e next_video_state;
irqstate_t flags;
int ret = OK;
if ((vmng == NULL) || (type == NULL))
{
return -EINVAL;
}
type_inf = get_video_type_inf(vmng, *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 == VIDEO_STATE_STREAMOFF)
{
ret = -EPERM;
}
else
{
next_video_state = estimate_next_video_state
(vmng, CAUSE_VIDEO_STOP);
change_video_state(vmng, next_video_state);
}
leave_critical_section(flags);
return ret;
}
static int video_do_halfpush(bool enable)
{
if ((g_video_devops == NULL) || (g_video_devops->do_halfpush == NULL))
{
return -EINVAL;
}
return g_video_devops->do_halfpush(enable);
}
static int video_takepict_start(FAR struct video_mng_s *vmng,
int32_t capture_num)
{
irqstate_t flags;
enum video_state_e next_video_state;
FAR vbuf_container_t *dma_container;
int ret = OK;
if (vmng == NULL)
{
return -EINVAL;
}
video_lock(&vmng->still_inf.lock_state);
if (vmng->still_inf.state != VIDEO_STATE_STREAMOFF)
{
ret = -EPERM;
}
else
{
if (capture_num > 0)
{
vmng->still_inf.remaining_capnum = capture_num;
}
else
{
vmng->still_inf.remaining_capnum = VIDEO_REMAINING_CAPNUM_INFINITY;
}
/* Control video stream prior to still stream */
flags = enter_critical_section();
next_video_state = estimate_next_video_state(vmng,
CAUSE_STILL_START);
change_video_state(vmng, next_video_state);
leave_critical_section(flags);
dma_container = video_framebuff_get_dma_container
(&vmng->still_inf.bufinf);
if (dma_container)
{
/* Start video stream DMA */
g_video_devops->set_buftype(V4L2_BUF_TYPE_STILL_CAPTURE);
g_video_devops->set_buf(dma_container->buf.m.userptr,
dma_container->buf.length);
vmng->still_inf.state = VIDEO_STATE_DMA;
}
else
{
vmng->still_inf.state = VIDEO_STATE_STREAMON;
}
}
video_unlock(&vmng->still_inf.lock_state);
return ret;
}
static int video_takepict_stop(FAR struct video_mng_s *vmng, bool halfpush)
{
int ret = OK;
irqstate_t flags;
enum video_state_e next_video_state;
if (vmng == NULL)
{
return -EINVAL;
}
video_lock(&vmng->still_inf.lock_state);
if ((vmng->still_inf.state == VIDEO_STATE_STREAMOFF) &&
(vmng->still_inf.remaining_capnum == VIDEO_REMAINING_CAPNUM_INFINITY))
{
ret = -EPERM;
}
else
{
flags = enter_critical_section();
if (vmng->still_inf.state == VIDEO_STATE_DMA)
{
g_video_devops->cancel_dma();
}
leave_critical_section(flags);
vmng->still_inf.state = VIDEO_STATE_STREAMOFF;
vmng->still_inf.remaining_capnum = VIDEO_REMAINING_CAPNUM_INFINITY;
/* Control video stream */
video_lock(&vmng->video_inf.lock_state);
next_video_state = estimate_next_video_state(vmng,
CAUSE_STILL_STOP);
change_video_state(vmng, next_video_state);
video_unlock(&vmng->video_inf.lock_state);
}
video_unlock(&vmng->still_inf.lock_state);
return ret;
}
static int video_queryctrl(FAR struct v4l2_queryctrl *ctrl)
{
int ret;
struct v4l2_query_ext_ctrl ext_ctrl;
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 = video_query_ext_ctrl(&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;
strncpy(ctrl->name, ext_ctrl.name, sizeof(ctrl->name));
return OK;
}
static int video_query_ext_ctrl(FAR struct v4l2_query_ext_ctrl *ctrl)
{
int ret;
if ((g_video_devops == NULL) ||
(g_video_devops->get_range_of_ctrlvalue == NULL))
{
return -EINVAL;
}
ret = g_video_devops->get_range_of_ctrlvalue(ctrl);
return ret;
}
static int video_querymenu(FAR struct v4l2_querymenu *menu)
{
int ret;
if ((g_video_devops == NULL) ||
(g_video_devops->get_menu_of_ctrlvalue == NULL))
{
return -EINVAL;
}
ret = g_video_devops->get_menu_of_ctrlvalue(menu);
return ret;
}
static int video_g_ctrl(FAR struct video_mng_s *priv,
FAR struct v4l2_control *ctrl)
{
int ret;
struct v4l2_ext_controls ext_controls;
struct v4l2_ext_control control;
if (ctrl == NULL)
{
return -EINVAL;
}
/* 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 = video_g_ext_ctrls(priv, &ext_controls);
if (ret == OK)
{
/* Replace gotten value to VIDIOC_G_CTRL parameter */
ctrl->value = control.value;
}
return ret;
}
static int video_s_ctrl(FAR struct video_mng_s *priv,
FAR struct v4l2_control *ctrl)
{
int ret;
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 */
ret = video_s_ext_ctrls(priv, &ext_controls);
return ret;
}
static int video_g_ext_ctrls(FAR struct video_mng_s *priv,
FAR struct v4l2_ext_controls *ctrls)
{
int ret = OK;
int cnt;
FAR struct v4l2_ext_control *control;
if ((priv == NULL) || (ctrls == NULL))
{
return -EINVAL;
}
for (cnt = 0, control = ctrls->controls;
cnt < ctrls->count;
cnt++, control++)
{
ret = g_video_devops->get_ctrlvalue(ctrls->ctrl_class, control);
if (ret < 0)
{
/* Set cnt in that error occured */
ctrls->error_idx = cnt;
return ret;
}
}
return ret;
}
static int video_s_ext_ctrls(FAR struct video_mng_s *priv,
FAR struct v4l2_ext_controls *ctrls)
{
int ret;
int cnt;
FAR struct v4l2_ext_control *control;
if ((priv == NULL) || (ctrls == NULL))
{
return -EINVAL;
}
for (cnt = 0, control = ctrls->controls;
cnt < ctrls->count;
cnt++, control++)
{
ret = g_video_devops->set_ctrlvalue(ctrls->ctrl_class, control);
if (ret < 0)
{
/* Set cnt in that error occured */
ctrls->error_idx = cnt;
return ret;
}
}
ret = g_video_devops->refresh();
if (ret < 0)
{
ctrls->error_idx = cnt;
}
return ret;
}
/****************************************************************************
* Name: video_ioctl
*
* Description:
* Standard character driver ioctl method.
*
****************************************************************************/
static int video_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
{
FAR struct inode *inode = filep->f_inode;
FAR video_mng_t *priv = (FAR video_mng_t *)inode->i_private;
int ret = OK;
switch (cmd)
{
case VIDIOC_REQBUFS:
ret = video_reqbufs(priv, (FAR struct v4l2_requestbuffers *)arg);
break;
case VIDIOC_QBUF:
ret = video_qbuf(priv, (FAR struct v4l2_buffer *)arg);
break;
case VIDIOC_DQBUF:
ret = video_dqbuf(priv, (FAR struct v4l2_buffer *)arg);
break;
case VIDIOC_CANCEL_DQBUF:
ret = video_cancel_dqbuf(priv, (FAR enum v4l2_buf_type)arg);
break;
case VIDIOC_STREAMON:
ret = video_streamon(priv, (FAR enum v4l2_buf_type *)arg);
break;
case VIDIOC_STREAMOFF:
ret = video_streamoff(priv, (FAR enum v4l2_buf_type *)arg);
break;
case VIDIOC_DO_HALFPUSH:
ret = video_do_halfpush(arg);
break;
case VIDIOC_TAKEPICT_START:
ret = video_takepict_start(priv, (int32_t)arg);
break;
case VIDIOC_TAKEPICT_STOP:
ret = video_takepict_stop(priv, arg);
break;
case VIDIOC_ENUM_FMT:
ret = video_enum_fmt((FAR struct v4l2_fmtdesc *)arg);
break;
case VIDIOC_ENUM_FRAMESIZES:
ret = video_enum_framesizes((FAR struct v4l2_frmsizeenum *)arg);
break;
case VIDIOC_TRY_FMT:
ret = video_try_fmt((FAR struct v4l2_format *)arg);
break;
case VIDIOC_S_FMT:
ret = video_s_fmt(priv, (FAR struct v4l2_format *)arg);
break;
case VIDIOC_ENUM_FRAMEINTERVALS:
ret = video_enum_frameintervals((FAR struct v4l2_frmivalenum *)arg);
break;
case VIDIOC_S_PARM:
ret = video_s_parm(priv, (FAR struct v4l2_streamparm *)arg);
break;
case VIDIOC_QUERYCTRL:
ret = video_queryctrl((FAR struct v4l2_queryctrl *)arg);
break;
case VIDIOC_QUERY_EXT_CTRL:
ret = video_query_ext_ctrl((FAR struct v4l2_query_ext_ctrl *)arg);
break;
case VIDIOC_QUERYMENU:
ret = video_querymenu((FAR struct v4l2_querymenu *)arg);
break;
case VIDIOC_G_CTRL:
ret = video_g_ctrl(priv, (FAR struct v4l2_control *)arg);
break;
case VIDIOC_S_CTRL:
ret = video_s_ctrl(priv, (FAR struct v4l2_control *)arg);
break;
case VIDIOC_G_EXT_CTRLS:
ret = video_g_ext_ctrls(priv, (FAR struct v4l2_ext_controls *)arg);
break;
case VIDIOC_S_EXT_CTRLS:
ret = video_s_ext_ctrls(priv, (FAR struct v4l2_ext_controls *)arg);
break;
default:
videoerr("Unrecognized cmd: %d\n", cmd);
ret = - ENOTTY;
break;
}
return ret;
}
static int video_poll_setup(FAR struct video_mng_s *priv,
FAR struct pollfd *fds)
{
if ((fds->events & POLLIN) == 0)
{
return -EDEADLK;
}
/* TODO: If data exists, get and sem_post If no data, wait dma */
return OK;
}
static int video_poll_teardown(FAR struct video_mng_s *priv,
FAR struct pollfd *fds)
{
/* TODO: Delete poll wait information */
return OK;
}
static int video_poll(FAR struct file *filep,
FAR struct pollfd *fds,
bool setup)
{
FAR struct inode *inode = filep->f_inode;
FAR video_mng_t *priv = inode->i_private;
if (setup)
{
return video_poll_setup(priv, fds);
}
else
{
return video_poll_teardown(priv, fds);
}
return OK;
}
static FAR void *video_register(FAR const char *devpath)
{
FAR video_mng_t *priv;
int ret;
size_t allocsize;
/* Input devpath Error Check */
if (!devpath)
{
return NULL;
}
allocsize = strnlen(devpath, MAX_VIDEO_FILE_PATH - 1/* Space for '\0' */);
if ((allocsize < 2) ||
(devpath[0] != '/') ||
((allocsize == (MAX_VIDEO_FILE_PATH - 1)) &&
(devpath[MAX_VIDEO_FILE_PATH] != '\0')))
{
return NULL;
}
/* Initialize video device structure */
priv = (FAR video_mng_t *)kmm_malloc(sizeof(video_mng_t));
if (!priv)
{
videoerr("Failed to allocate instance\n");
return NULL;
}
memset(priv, 0, sizeof(video_mng_t));
/* Save device path */
priv->devpath = (FAR char *)kmm_malloc(allocsize + 1);
if (!priv->devpath)
{
kmm_free(priv);
return NULL;
}
memcpy(priv->devpath, devpath, allocsize);
priv->devpath[allocsize] = '\0';
/* Initialize semaphore */
sem_init(&priv->lock_open_num, 0, 1);
/* Register the character driver */
ret = register_driver(priv->devpath, &g_video_fops, 0666, priv);
if (ret < 0)
{
videoerr("Failed to register driver: %d\n", ret);
kmm_free(priv->devpath);
kmm_free(priv);
return NULL;
}
return (FAR void *)priv;
}
static int video_unregister(FAR video_mng_t *v_mgr)
{
int ret = OK;
if (!v_mgr)
{
ret = -ENODEV;
}
else
{
sem_destroy(&v_mgr->lock_open_num);
unregister_driver((const char *)v_mgr->devpath);
kmm_free(v_mgr->devpath);
kmm_free(v_mgr);
}
return ret;
}
/****************************************************************************
* Public Functions
****************************************************************************/
static FAR void *video_handler;
int video_initialize(FAR const char *devpath)
{
if (is_initialized)
{
return OK;
}
video_handler = video_register(devpath);
is_initialized = true;
return OK;
}
int video_uninitialize(void)
{
if (is_initialized)
{
return OK;
}
video_unregister(video_handler);
is_initialized = false;
return OK;
}
int video_common_notify_dma_done(uint8_t err_code,
uint32_t buf_type,
uint32_t datasize,
FAR void *priv)
{
FAR video_mng_t *vmng = (FAR video_mng_t *)priv;
FAR video_type_inf_t *type_inf;
FAR vbuf_container_t *container = NULL;
type_inf = get_video_type_inf(vmng, buf_type);
if (type_inf == NULL)
{
return -EINVAL;
}
if (err_code == 0)
{
type_inf->bufinf.vbuf_dma->buf.flags = 0;
if (type_inf->remaining_capnum > 0)
{
type_inf->remaining_capnum--;
}
}
else
{
type_inf->bufinf.vbuf_dma->buf.flags = V4L2_BUF_FLAG_ERROR;
}
type_inf->bufinf.vbuf_dma->buf.bytesused = datasize;
video_framebuff_dma_done(&type_inf->bufinf);
if (is_sem_waited(&type_inf->wait_dma.dqbuf_wait_flg))
{
/* If waiting DMA done in DQBUF,
* get/save container and unlock wait
*/
type_inf->wait_dma.done_container
= video_framebuff_pop_curr_container(&type_inf->bufinf);
type_inf->wait_dma.waitend_cause
= VIDEO_WAITEND_CAUSE_DMADONE;
sem_post(&type_inf->wait_dma.dqbuf_wait_flg);
/* TODO: in poll wait, unlock wait */
}
if (type_inf->remaining_capnum == 0)
{
g_video_devops->cancel_dma();
type_inf->state = VIDEO_STATE_STREAMOFF;
/* If stop still stream, notify it to video stream */
if ((buf_type == V4L2_BUF_TYPE_STILL_CAPTURE) &&
is_sem_waited(&vmng->video_inf.wait_dma.dqbuf_wait_flg))
{
vmng->video_inf.wait_dma.waitend_cause
= VIDEO_WAITEND_CAUSE_STILLSTOP;
sem_post(&vmng->video_inf.wait_dma.dqbuf_wait_flg);
}
}
else
{
container = video_framebuff_get_dma_container(&type_inf->bufinf);
if (!container)
{
g_video_devops->cancel_dma();
type_inf->state = VIDEO_STATE_STREAMON;
}
else
{
g_video_devops->set_buf(container->buf.m.userptr,
container->buf.length);
}
}
return OK;
}
Reference in New Issue View Git Blame Copy Permalink