* (http://v4l2spec.bytesex.org/v4l2spec/capture.c)
*
* Thanks to Michael Niedermayer for providing the mapping between
- * V4L2_PIX_FMT_* and PIX_FMT_*
+ * V4L2_PIX_FMT_* and AV_PIX_FMT_*
*
*
* This file is part of Libav.
#else
#include <linux/videodev2.h>
#endif
+#include "libavutil/atomic.h"
+#include "libavutil/avassert.h"
#include "libavutil/imgutils.h"
+#include "libavutil/internal.h"
#include "libavutil/log.h"
#include "libavutil/opt.h"
#include "libavutil/parseutils.h"
int top_field_first;
int buffers;
+ volatile int buffers_queued;
void **buf_start;
unsigned int *buf_len;
char *standard;
};
struct buff_data {
+ struct video_data *s;
int index;
int fd;
};
struct fmt_map {
- enum PixelFormat ff_fmt;
+ enum AVPixelFormat ff_fmt;
enum AVCodecID codec_id;
uint32_t v4l2_fmt;
};
static struct fmt_map fmt_conversion_table[] = {
//ff_fmt codec_id v4l2_fmt
- { PIX_FMT_YUV420P, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_YUV420 },
- { PIX_FMT_YUV422P, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_YUV422P },
- { PIX_FMT_YUYV422, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_YUYV },
- { PIX_FMT_UYVY422, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_UYVY },
- { PIX_FMT_YUV411P, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_YUV411P },
- { PIX_FMT_YUV410P, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_YUV410 },
- { PIX_FMT_RGB555, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_RGB555 },
- { PIX_FMT_RGB565, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_RGB565 },
- { PIX_FMT_BGR24, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_BGR24 },
- { PIX_FMT_RGB24, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_RGB24 },
- { PIX_FMT_BGRA, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_BGR32 },
- { PIX_FMT_GRAY8, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_GREY },
- { PIX_FMT_NV12, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_NV12 },
- { PIX_FMT_NONE, AV_CODEC_ID_MJPEG, V4L2_PIX_FMT_MJPEG },
- { PIX_FMT_NONE, AV_CODEC_ID_MJPEG, V4L2_PIX_FMT_JPEG },
+ { AV_PIX_FMT_YUV420P, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_YUV420 },
+ { AV_PIX_FMT_YUV422P, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_YUV422P },
+ { AV_PIX_FMT_YUYV422, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_YUYV },
+ { AV_PIX_FMT_UYVY422, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_UYVY },
+ { AV_PIX_FMT_YUV411P, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_YUV411P },
+ { AV_PIX_FMT_YUV410P, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_YUV410 },
+ { AV_PIX_FMT_RGB555, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_RGB555 },
+ { AV_PIX_FMT_RGB565, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_RGB565 },
+ { AV_PIX_FMT_BGR24, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_BGR24 },
+ { AV_PIX_FMT_RGB24, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_RGB24 },
+ { AV_PIX_FMT_BGRA, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_BGR32 },
+ { AV_PIX_FMT_GRAY8, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_GREY },
+ { AV_PIX_FMT_NV12, AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_NV12 },
+ { AV_PIX_FMT_NONE, AV_CODEC_ID_MJPEG, V4L2_PIX_FMT_MJPEG },
+ { AV_PIX_FMT_NONE, AV_CODEC_ID_MJPEG, V4L2_PIX_FMT_JPEG },
+#ifdef V4L2_PIX_FMT_H264
+ { AV_PIX_FMT_NONE, AV_CODEC_ID_H264, V4L2_PIX_FMT_H264 },
+#endif
};
static int device_open(AVFormatContext *ctx)
int fd;
int res, err;
int flags = O_RDWR;
+ char errbuf[128];
if (ctx->flags & AVFMT_FLAG_NONBLOCK) {
flags |= O_NONBLOCK;
}
- fd = open(ctx->filename, flags, 0);
+ fd = avpriv_open(ctx->filename, flags);
if (fd < 0) {
- err = errno;
+ err = AVERROR(errno);
+ av_strerror(err, errbuf, sizeof(errbuf));
av_log(ctx, AV_LOG_ERROR, "Cannot open video device %s : %s\n",
- ctx->filename, strerror(err));
+ ctx->filename, errbuf);
- return AVERROR(err);
+ return err;
}
res = ioctl(fd, VIDIOC_QUERYCAP, &cap);
if (res < 0) {
- err = errno;
+ err = AVERROR(errno);
+ av_strerror(err, errbuf, sizeof(errbuf));
av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_QUERYCAP): %s\n",
- strerror(err));
+ errbuf);
goto fail;
}
if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
av_log(ctx, AV_LOG_ERROR, "Not a video capture device.\n");
- err = ENODEV;
+ err = AVERROR(ENODEV);
goto fail;
}
if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
av_log(ctx, AV_LOG_ERROR,
"The device does not support the streaming I/O method.\n");
- err = ENOSYS;
+ err = AVERROR(ENOSYS);
goto fail;
}
fail:
close(fd);
- return AVERROR(err);
+ return err;
}
static int device_init(AVFormatContext *ctx, int *width, int *height,
return 1;
}
-static uint32_t fmt_ff2v4l(enum PixelFormat pix_fmt, enum AVCodecID codec_id)
+static uint32_t fmt_ff2v4l(enum AVPixelFormat pix_fmt, enum AVCodecID codec_id)
{
int i;
for (i = 0; i < FF_ARRAY_ELEMS(fmt_conversion_table); i++) {
if ((codec_id == AV_CODEC_ID_NONE ||
fmt_conversion_table[i].codec_id == codec_id) &&
- (pix_fmt == PIX_FMT_NONE ||
+ (pix_fmt == AV_PIX_FMT_NONE ||
fmt_conversion_table[i].ff_fmt == pix_fmt)) {
return fmt_conversion_table[i].v4l2_fmt;
}
return 0;
}
-static enum PixelFormat fmt_v4l2ff(uint32_t v4l2_fmt, enum AVCodecID codec_id)
+static enum AVPixelFormat fmt_v4l2ff(uint32_t v4l2_fmt, enum AVCodecID codec_id)
{
int i;
}
}
- return PIX_FMT_NONE;
+ return AV_PIX_FMT_NONE;
}
static enum AVCodecID fmt_v4l2codec(uint32_t v4l2_fmt)
while(!ioctl(fd, VIDIOC_ENUM_FMT, &vfd)) {
enum AVCodecID codec_id = fmt_v4l2codec(vfd.pixelformat);
- enum PixelFormat pix_fmt = fmt_v4l2ff(vfd.pixelformat, codec_id);
+ enum AVPixelFormat pix_fmt = fmt_v4l2ff(vfd.pixelformat, codec_id);
vfd.index++;
vfd.description);
} else if (vfd.flags & V4L2_FMT_FLAG_COMPRESSED &&
type & V4L_COMPFORMATS) {
- AVCodec *codec = avcodec_find_encoder(codec_id);
+ const AVCodecDescriptor *desc = avcodec_descriptor_get(codec_id);
av_log(ctx, AV_LOG_INFO, "C : %9s : %20s :",
- codec ? codec->name : "Unsupported",
+ desc ? desc->name : "Unsupported",
vfd.description);
} else {
continue;
res = ioctl(s->fd, VIDIOC_REQBUFS, &req);
if (res < 0) {
- if (errno == EINVAL) {
+ res = AVERROR(errno);
+ if (res == AVERROR(EINVAL)) {
av_log(ctx, AV_LOG_ERROR, "Device does not support mmap\n");
} else {
av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_REQBUFS)\n");
}
- return AVERROR(errno);
+ return res;
}
if (req.count < 2) {
}
s->buffers = req.count;
s->buf_start = av_malloc(sizeof(void *) * s->buffers);
- if (s->buf_start == NULL) {
+ if (!s->buf_start) {
av_log(ctx, AV_LOG_ERROR, "Cannot allocate buffer pointers\n");
return AVERROR(ENOMEM);
}
s->buf_len = av_malloc(sizeof(unsigned int) * s->buffers);
- if (s->buf_len == NULL) {
+ if (!s->buf_len) {
av_log(ctx, AV_LOG_ERROR, "Cannot allocate buffer sizes\n");
av_free(s->buf_start);
res = ioctl(s->fd, VIDIOC_QUERYBUF, &buf);
if (res < 0) {
+ res = AVERROR(errno);
av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_QUERYBUF)\n");
- return AVERROR(errno);
+ return res;
}
s->buf_len[i] = buf.length;
s->fd, buf.m.offset);
if (s->buf_start[i] == MAP_FAILED) {
- av_log(ctx, AV_LOG_ERROR, "mmap: %s\n", strerror(errno));
+ char errbuf[128];
+ res = AVERROR(errno);
+ av_strerror(res, errbuf, sizeof(errbuf));
+ av_log(ctx, AV_LOG_ERROR, "mmap: %s\n", errbuf);
- return AVERROR(errno);
+ return res;
}
}
return 0;
}
-static void mmap_release_buffer(AVPacket *pkt)
+static void mmap_release_buffer(void *opaque, uint8_t *data)
{
struct v4l2_buffer buf = { 0 };
int res, fd;
- struct buff_data *buf_descriptor = pkt->priv;
-
- if (pkt->data == NULL)
- return;
+ struct buff_data *buf_descriptor = opaque;
+ struct video_data *s = buf_descriptor->s;
+ char errbuf[128];
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
av_free(buf_descriptor);
res = ioctl(fd, VIDIOC_QBUF, &buf);
- if (res < 0)
+ if (res < 0) {
+ av_strerror(AVERROR(errno), errbuf, sizeof(errbuf));
av_log(NULL, AV_LOG_ERROR, "ioctl(VIDIOC_QBUF): %s\n",
- strerror(errno));
-
- pkt->data = NULL;
- pkt->size = 0;
+ errbuf);
+ }
+ avpriv_atomic_int_add_and_fetch(&s->buffers_queued, 1);
}
static int mmap_read_frame(AVFormatContext *ctx, AVPacket *pkt)
.type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
.memory = V4L2_MEMORY_MMAP
};
- struct buff_data *buf_descriptor;
struct pollfd p = { .fd = s->fd, .events = POLLIN };
int res;
/* FIXME: Some special treatment might be needed in case of loss of signal... */
while ((res = ioctl(s->fd, VIDIOC_DQBUF, &buf)) < 0 && (errno == EINTR));
if (res < 0) {
+ char errbuf[128];
if (errno == EAGAIN) {
pkt->size = 0;
return AVERROR(EAGAIN);
}
+ res = AVERROR(errno);
+ av_strerror(res, errbuf, sizeof(errbuf));
av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_DQBUF): %s\n",
- strerror(errno));
+ errbuf);
- return AVERROR(errno);
+ return res;
}
- assert (buf.index < s->buffers);
+
+ if (buf.index >= s->buffers) {
+ av_log(ctx, AV_LOG_ERROR, "Invalid buffer index received.\n");
+ return AVERROR(EINVAL);
+ }
+ avpriv_atomic_int_add_and_fetch(&s->buffers_queued, -1);
+ // always keep at least one buffer queued
+ av_assert0(avpriv_atomic_int_get(&s->buffers_queued) >= 1);
+
if (s->frame_size > 0 && buf.bytesused != s->frame_size) {
av_log(ctx, AV_LOG_ERROR,
"The v4l2 frame is %d bytes, but %d bytes are expected\n",
}
/* Image is at s->buff_start[buf.index] */
- pkt->data= s->buf_start[buf.index];
- pkt->size = buf.bytesused;
- pkt->pts = buf.timestamp.tv_sec * INT64_C(1000000) + buf.timestamp.tv_usec;
- pkt->destruct = mmap_release_buffer;
- buf_descriptor = av_malloc(sizeof(struct buff_data));
- if (buf_descriptor == NULL) {
- /* Something went wrong... Since av_malloc() failed, we cannot even
- * allocate a buffer for memcopying into it
- */
- av_log(ctx, AV_LOG_ERROR, "Failed to allocate a buffer descriptor\n");
+ if (avpriv_atomic_int_get(&s->buffers_queued) == FFMAX(s->buffers / 8, 1)) {
+ /* when we start getting low on queued buffers, fall back on copying data */
+ res = av_new_packet(pkt, buf.bytesused);
+ if (res < 0) {
+ av_log(ctx, AV_LOG_ERROR, "Error allocating a packet.\n");
+ return res;
+ }
+ memcpy(pkt->data, s->buf_start[buf.index], buf.bytesused);
+
res = ioctl(s->fd, VIDIOC_QBUF, &buf);
+ if (res < 0) {
+ res = AVERROR(errno);
+ av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_QBUF)\n");
+ av_packet_unref(pkt);
+ return res;
+ }
+ avpriv_atomic_int_add_and_fetch(&s->buffers_queued, 1);
+ } else {
+ struct buff_data *buf_descriptor;
- return AVERROR(ENOMEM);
+ pkt->data = s->buf_start[buf.index];
+ pkt->size = buf.bytesused;
+
+ buf_descriptor = av_malloc(sizeof(struct buff_data));
+ if (!buf_descriptor) {
+ /* Something went wrong... Since av_malloc() failed, we cannot even
+ * allocate a buffer for memcpying into it
+ */
+ av_log(ctx, AV_LOG_ERROR, "Failed to allocate a buffer descriptor\n");
+ res = ioctl(s->fd, VIDIOC_QBUF, &buf);
+
+ return AVERROR(ENOMEM);
+ }
+ buf_descriptor->fd = s->fd;
+ buf_descriptor->index = buf.index;
+ buf_descriptor->s = s;
+
+ pkt->buf = av_buffer_create(pkt->data, pkt->size, mmap_release_buffer,
+ buf_descriptor, 0);
+ if (!pkt->buf) {
+ av_freep(&buf_descriptor);
+ return AVERROR(ENOMEM);
+ }
}
- buf_descriptor->fd = s->fd;
- buf_descriptor->index = buf.index;
- pkt->priv = buf_descriptor;
+ pkt->pts = buf.timestamp.tv_sec * INT64_C(1000000) + buf.timestamp.tv_usec;
return s->buf_len[buf.index];
}
{
struct video_data *s = ctx->priv_data;
enum v4l2_buf_type type;
- int i, res;
+ int i, res, err;
+ char errbuf[128];
for (i = 0; i < s->buffers; i++) {
struct v4l2_buffer buf = {
res = ioctl(s->fd, VIDIOC_QBUF, &buf);
if (res < 0) {
+ err = AVERROR(errno);
+ av_strerror(err, errbuf, sizeof(errbuf));
av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_QBUF): %s\n",
- strerror(errno));
+ errbuf);
- return AVERROR(errno);
+ return err;
}
}
+ s->buffers_queued = s->buffers;
type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
res = ioctl(s->fd, VIDIOC_STREAMON, &type);
if (res < 0) {
+ err = AVERROR(errno);
+ av_strerror(err, errbuf, sizeof(errbuf));
av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_STREAMON): %s\n",
- strerror(errno));
+ errbuf);
- return AVERROR(errno);
+ return err;
}
return 0;
}
} else {
if (ioctl(s->fd, VIDIOC_G_PARM, &streamparm) != 0) {
+ char errbuf[128];
+ ret = AVERROR(errno);
+ av_strerror(ret, errbuf, sizeof(errbuf));
av_log(s1, AV_LOG_ERROR, "ioctl(VIDIOC_G_PARM): %s\n",
- strerror(errno));
- return AVERROR(errno);
+ errbuf);
+ return ret;
}
}
- s1->streams[0]->codec->time_base.den = tpf->denominator;
- s1->streams[0]->codec->time_base.num = tpf->numerator;
+ s1->streams[0]->avg_frame_rate.num = tpf->denominator;
+ s1->streams[0]->avg_frame_rate.den = tpf->numerator;
s->timeout = 100 +
- av_rescale_q(1, s1->streams[0]->codec->time_base,
+ av_rescale_q(1, s1->streams[0]->avg_frame_rate,
(AVRational){1, 1000});
return 0;
}
static uint32_t device_try_init(AVFormatContext *s1,
- enum PixelFormat pix_fmt,
+ enum AVPixelFormat pix_fmt,
int *width,
int *height,
enum AVCodecID *codec_id)
int res = 0;
uint32_t desired_format;
enum AVCodecID codec_id;
- enum PixelFormat pix_fmt = PIX_FMT_NONE;
+ enum AVPixelFormat pix_fmt = AV_PIX_FMT_NONE;
st = avformat_new_stream(s1, NULL);
- if (!st) {
- res = AVERROR(ENOMEM);
- goto out;
- }
+ if (!st)
+ return AVERROR(ENOMEM);
s->fd = device_open(s1);
- if (s->fd < 0) {
- res = s->fd;
- goto out;
- }
+ if (s->fd < 0)
+ return s->fd;
if (s->list_format) {
list_formats(s1, s->fd, s->list_format);
- res = AVERROR_EXIT;
- goto out;
+ return AVERROR_EXIT;
}
avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
(res = av_parse_video_size(&s->width, &s->height, s->video_size)) < 0) {
av_log(s1, AV_LOG_ERROR, "Could not parse video size '%s'.\n",
s->video_size);
- goto out;
+ return res;
}
if (s->pixel_format) {
AVCodec *codec = avcodec_find_decoder_by_name(s->pixel_format);
- if (codec)
+ if (codec) {
s1->video_codec_id = codec->id;
+ st->need_parsing = AVSTREAM_PARSE_HEADERS;
+ }
pix_fmt = av_get_pix_fmt(s->pixel_format);
- if (pix_fmt == PIX_FMT_NONE && !codec) {
+ if (pix_fmt == AV_PIX_FMT_NONE && !codec) {
av_log(s1, AV_LOG_ERROR, "No such input format: %s.\n",
s->pixel_format);
- res = AVERROR(EINVAL);
- goto out;
+ return AVERROR(EINVAL);
}
}
"Querying the device for the current frame size\n");
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (ioctl(s->fd, VIDIOC_G_FMT, &fmt) < 0) {
- av_log(s1, AV_LOG_ERROR, "ioctl(VIDIOC_G_FMT): %s\n",
- strerror(errno));
+ char errbuf[128];
res = AVERROR(errno);
- goto out;
+ av_strerror(res, errbuf, sizeof(errbuf));
+ av_log(s1, AV_LOG_ERROR, "ioctl(VIDIOC_G_FMT): %s\n",
+ errbuf);
+ return res;
}
s->width = fmt.fmt.pix.width;
"codec_id %d, pix_fmt %d.\n", s1->video_codec_id, pix_fmt);
close(s->fd);
- res = AVERROR(EIO);
- goto out;
+ return AVERROR(EIO);
}
if ((res = av_image_check_size(s->width, s->height, 0, s1) < 0))
- goto out;
+ return res;
s->frame_format = desired_format;
if ((res = v4l2_set_parameters(s1) < 0))
- goto out;
+ return res;
st->codec->pix_fmt = fmt_v4l2ff(desired_format, codec_id);
- s->frame_size =
- avpicture_get_size(st->codec->pix_fmt, s->width, s->height);
+ s->frame_size = av_image_get_buffer_size(st->codec->pix_fmt,
+ s->width, s->height, 1);
if ((res = mmap_init(s1)) ||
(res = mmap_start(s1)) < 0) {
close(s->fd);
- goto out;
+ return res;
}
s->top_field_first = first_field(s->fd);
avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
st->codec->width = s->width;
st->codec->height = s->height;
- st->codec->bit_rate = s->frame_size * 1/av_q2d(st->codec->time_base) * 8;
+ st->codec->bit_rate = s->frame_size * av_q2d(st->avg_frame_rate) * 8;
-out:
- return res;
+ return 0;
}
static int v4l2_read_packet(AVFormatContext *s1, AVPacket *pkt)
{
struct video_data *s = s1->priv_data;
+#if FF_API_CODED_FRAME
+FF_DISABLE_DEPRECATION_WARNINGS
AVFrame *frame = s1->streams[0]->codec->coded_frame;
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
int res;
av_init_packet(pkt);
return res;
}
+#if FF_API_CODED_FRAME
+FF_DISABLE_DEPRECATION_WARNINGS
if (frame && s->interlaced) {
frame->interlaced_frame = 1;
frame->top_field_first = s->top_field_first;
}
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
return pkt->size;
}
{
struct video_data *s = s1->priv_data;
+ if (avpriv_atomic_int_get(&s->buffers_queued) != s->buffers)
+ av_log(s1, AV_LOG_WARNING, "Some buffers are still owned by the caller on "
+ "close.\n");
+
mmap_close(s);
close(s->fd);
#define DEC AV_OPT_FLAG_DECODING_PARAM
static const AVOption options[] = {
{ "standard", "TV standard, used only by analog frame grabber", OFFSET(standard), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC },
- { "channel", "TV channel, used only by frame grabber", OFFSET(channel), AV_OPT_TYPE_INT, {.dbl = 0 }, 0, INT_MAX, DEC },
+ { "channel", "TV channel, used only by frame grabber", OFFSET(channel), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, DEC },
{ "video_size", "A string describing frame size, such as 640x480 or hd720.", OFFSET(video_size), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
{ "pixel_format", "Preferred pixel format", OFFSET(pixel_format), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
{ "input_format", "Preferred pixel format (for raw video) or codec name", OFFSET(pixel_format), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
{ "framerate", "", OFFSET(framerate), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
- { "list_formats", "List available formats and exit", OFFSET(list_format), AV_OPT_TYPE_INT, {.dbl = 0 }, 0, INT_MAX, DEC, "list_formats" },
- { "all", "Show all available formats", OFFSET(list_format), AV_OPT_TYPE_CONST, {.dbl = V4L_ALLFORMATS }, 0, INT_MAX, DEC, "list_formats" },
- { "raw", "Show only non-compressed formats", OFFSET(list_format), AV_OPT_TYPE_CONST, {.dbl = V4L_RAWFORMATS }, 0, INT_MAX, DEC, "list_formats" },
- { "compressed", "Show only compressed formats", OFFSET(list_format), AV_OPT_TYPE_CONST, {.dbl = V4L_COMPFORMATS }, 0, INT_MAX, DEC, "list_formats" },
+ { "list_formats", "List available formats and exit", OFFSET(list_format), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, DEC, "list_formats" },
+ { "all", "Show all available formats", OFFSET(list_format), AV_OPT_TYPE_CONST, {.i64 = V4L_ALLFORMATS }, 0, INT_MAX, DEC, "list_formats" },
+ { "raw", "Show only non-compressed formats", OFFSET(list_format), AV_OPT_TYPE_CONST, {.i64 = V4L_RAWFORMATS }, 0, INT_MAX, DEC, "list_formats" },
+ { "compressed", "Show only compressed formats", OFFSET(list_format), AV_OPT_TYPE_CONST, {.i64 = V4L_COMPFORMATS }, 0, INT_MAX, DEC, "list_formats" },
{ NULL },
};
projects / ffmpeg / blobdiff