33 #include <stdatomic.h>
44 #define V4L_ALLFORMATS 3
45 #define V4L_RAWFORMATS 1
46 #define V4L_COMPFORMATS 2
51 #define V4L_TS_DEFAULT 0
61 #define V4L_TS_MONO2ABS 2
68 #define V4L_TS_CONVERT_READY V4L_TS_DEFAULT
98 #if defined(__sun) || defined(__BIONIC__) || defined(__musl__)
116 struct v4l2_capability cap;
121 #define SET_WRAPPERS(prefix) do { \
122 s->open_f = prefix ## open; \
123 s->close_f = prefix ## close; \
124 s->dup_f = prefix ## dup; \
125 s->ioctl_f = prefix ## ioctl; \
126 s->read_f = prefix ## read; \
127 s->mmap_f = prefix ## mmap; \
128 s->munmap_f = prefix ## munmap; \
131 if (
s->use_libv4l2) {
142 #define v4l2_open s->open_f
143 #define v4l2_close s->close_f
144 #define v4l2_dup s->dup_f
145 #define v4l2_ioctl s->ioctl_f
146 #define v4l2_read s->read_f
147 #define v4l2_mmap s->mmap_f
148 #define v4l2_munmap s->munmap_f
162 if (
v4l2_ioctl(fd, VIDIOC_QUERYCAP, &cap) < 0) {
170 fd, cap.capabilities);
172 if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
178 if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
180 "The device does not support the streaming I/O method.\n");
193 uint32_t pixelformat)
196 struct v4l2_format fmt = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE };
199 fmt.fmt.pix.width = *
width;
200 fmt.fmt.pix.height = *
height;
201 fmt.fmt.pix.pixelformat = pixelformat;
202 fmt.fmt.pix.field = V4L2_FIELD_ANY;
209 if ((*
width != fmt.fmt.pix.width) || (*
height != fmt.fmt.pix.height)) {
211 "The V4L2 driver changed the video from %dx%d to %dx%d\n",
212 *
width, *
height, fmt.fmt.pix.width, fmt.fmt.pix.height);
213 *
width = fmt.fmt.pix.width;
214 *
height = fmt.fmt.pix.height;
217 if (pixelformat != fmt.fmt.pix.pixelformat) {
219 "The V4L2 driver changed the pixel format "
220 "from 0x%08X to 0x%08X\n",
221 pixelformat, fmt.fmt.pix.pixelformat);
225 if (fmt.fmt.pix.field == V4L2_FIELD_INTERLACED) {
227 "The V4L2 driver is using the interlaced mode\n");
242 if (std & V4L2_STD_NTSC)
248 #if HAVE_STRUCT_V4L2_FRMIVALENUM_DISCRETE
252 struct v4l2_frmsizeenum vfse = { .pixel_format = pixelformat };
254 while(!
v4l2_ioctl(
s->fd, VIDIOC_ENUM_FRAMESIZES, &vfse)) {
256 case V4L2_FRMSIZE_TYPE_DISCRETE:
258 vfse.discrete.width, vfse.discrete.height);
260 case V4L2_FRMSIZE_TYPE_CONTINUOUS:
261 case V4L2_FRMSIZE_TYPE_STEPWISE:
263 vfse.stepwise.min_width,
264 vfse.stepwise.max_width,
265 vfse.stepwise.step_width,
266 vfse.stepwise.min_height,
267 vfse.stepwise.max_height,
268 vfse.stepwise.step_height);
278 struct v4l2_fmtdesc vfd = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE };
286 if (!(vfd.flags & V4L2_FMT_FLAG_COMPRESSED) &&
290 fmt_name ? fmt_name :
"Unsupported",
292 }
else if (vfd.flags & V4L2_FMT_FLAG_COMPRESSED &&
302 #ifdef V4L2_FMT_FLAG_EMULATED
303 if (vfd.flags & V4L2_FMT_FLAG_EMULATED)
306 #if HAVE_STRUCT_V4L2_FRMIVALENUM_DISCRETE
307 list_framesizes(
ctx, vfd.pixelformat);
317 struct v4l2_standard standard;
322 for (standard.index = 0; ; standard.index++) {
323 if (
v4l2_ioctl(
s->fd, VIDIOC_ENUMSTD, &standard) < 0) {
333 standard.index, (uint64_t)standard.id, standard.name);
341 struct v4l2_requestbuffers req = {
342 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
344 .memory = V4L2_MEMORY_MMAP
357 s->buffers = req.count;
370 for (
i = 0;
i < req.count;
i++) {
371 struct v4l2_buffer buf = {
372 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
374 .memory = V4L2_MEMORY_MMAP
376 if (
v4l2_ioctl(
s->fd, VIDIOC_QUERYBUF, &buf) < 0) {
382 s->buf_len[
i] = buf.length;
383 if (
s->frame_size > 0 &&
s->buf_len[
i] <
s->frame_size) {
385 "buf_len[%d] = %d < expected frame size %d\n",
386 i,
s->buf_len[
i],
s->frame_size);
390 PROT_READ | PROT_WRITE, MAP_SHARED,
391 s->fd, buf.m.offset);
393 if (
s->buf_start[
i] == MAP_FAILED) {
419 struct v4l2_buffer buf = { 0 };
420 struct buff_data *buf_descriptor = opaque;
423 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
424 buf.memory = V4L2_MEMORY_MMAP;
425 buf.index = buf_descriptor->
index;
431 #if HAVE_CLOCK_GETTIME && defined(CLOCK_MONOTONIC)
432 static int64_t av_gettime_monotonic(
void)
445 ts <= now + 1 * AV_TIME_BASE && ts >= now - 10 *
AV_TIME_BASE) {
450 #if HAVE_CLOCK_GETTIME && defined(CLOCK_MONOTONIC)
452 now = av_gettime_monotonic();
454 (ts <= now + 1 * AV_TIME_BASE && ts >= now - 10 *
AV_TIME_BASE)) {
480 #if HAVE_CLOCK_GETTIME && defined(CLOCK_MONOTONIC)
483 int64_t nowm = av_gettime_monotonic();
485 s->last_time_m = nowm;
495 struct v4l2_buffer buf = {
496 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
497 .memory = V4L2_MEMORY_MMAP
499 struct timeval buf_ts;
505 while ((res =
v4l2_ioctl(
s->fd, VIDIOC_DQBUF, &buf)) < 0 && (errno == EINTR));
516 buf_ts = buf.timestamp;
518 if (buf.index >=
s->buffers) {
526 #ifdef V4L2_BUF_FLAG_ERROR
527 if (buf.flags & V4L2_BUF_FLAG_ERROR) {
529 "Dequeued v4l2 buffer contains corrupted data (%d bytes).\n",
538 s->frame_size = buf.bytesused;
540 if (
s->frame_size > 0 && buf.bytesused !=
s->frame_size) {
542 "Dequeued v4l2 buffer contains %d bytes, but %d were expected. Flags: 0x%08X.\n",
543 buf.bytesused,
s->frame_size, buf.flags);
557 memcpy(
pkt->
data,
s->buf_start[buf.index], buf.bytesused);
567 pkt->
data =
s->buf_start[buf.index];
571 if (!buf_descriptor) {
580 buf_descriptor->
index = buf.index;
581 buf_descriptor->
s =
s;
592 pkt->
pts = buf_ts.tv_sec * INT64_C(1000000) + buf_ts.tv_usec;
601 enum v4l2_buf_type
type;
604 for (
i = 0;
i <
s->buffers;
i++) {
605 struct v4l2_buffer buf = {
606 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
608 .memory = V4L2_MEMORY_MMAP
620 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
633 enum v4l2_buf_type
type;
636 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
641 for (
i = 0;
i <
s->buffers;
i++) {
651 struct v4l2_standard standard = { 0 };
652 struct v4l2_streamparm streamparm = { 0 };
653 struct v4l2_fract *tpf;
671 if (
v4l2_ioctl(
s->fd, VIDIOC_ENUMSTD, &standard) < 0) {
683 if (
v4l2_ioctl(
s->fd, VIDIOC_S_STD, &standard.id) < 0) {
690 "This device does not support any standard\n");
696 tpf = &standard.frameperiod;
699 if (
v4l2_ioctl(
s->fd, VIDIOC_ENUMSTD, &standard) < 0) {
706 tpf = &streamparm.parm.capture.timeperframe;
712 if (standard.id ==
s->std_id) {
714 "Current standard: %s, id: %"PRIx64
", frameperiod: %d/%d\n",
715 standard.name, (uint64_t)standard.id, tpf->numerator, tpf->denominator);
720 tpf = &streamparm.parm.capture.timeperframe;
723 streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
724 if (
v4l2_ioctl(
s->fd, VIDIOC_G_PARM, &streamparm) < 0) {
727 }
else if (framerate_q.
num && framerate_q.
den) {
728 if (streamparm.parm.capture.capability & V4L2_CAP_TIMEPERFRAME) {
729 tpf = &streamparm.parm.capture.timeperframe;
732 framerate_q.
den, framerate_q.
num);
733 tpf->numerator = framerate_q.
den;
734 tpf->denominator = framerate_q.
num;
736 if (
v4l2_ioctl(
s->fd, VIDIOC_S_PARM, &streamparm) < 0) {
743 if (framerate_q.
num != tpf->denominator ||
744 framerate_q.
den != tpf->numerator) {
746 "The driver changed the time per frame from "
748 framerate_q.
den, framerate_q.
num,
749 tpf->numerator, tpf->denominator);
753 "The driver does not permit changing the time per frame\n");
756 if (tpf->denominator > 0 && tpf->numerator > 0) {
770 uint32_t *desired_format,
777 if (*desired_format) {
786 if (!*desired_format) {
798 else if (ret !=
AVERROR(EINVAL))
804 if (*desired_format == 0) {
806 "codec '%s' (id %d), pixel format '%s' (id %d)\n",
831 uint32_t desired_format;
834 struct v4l2_input input = { 0 };
844 v4l2_log_file = fopen(
"/dev/null",
"w");
851 if (
s->channel != -1) {
854 if (
v4l2_ioctl(
s->fd, VIDIOC_S_INPUT, &
s->channel) < 0) {
861 if (
v4l2_ioctl(
s->fd, VIDIOC_G_INPUT, &
s->channel) < 0) {
869 input.index =
s->channel;
870 if (
v4l2_ioctl(
s->fd, VIDIOC_ENUMINPUT, &input) < 0) {
875 s->std_id = input.std;
877 s->channel, input.name, (uint64_t)input.std);
879 if (
s->list_format) {
885 if (
s->list_standard) {
893 if (
s->pixel_format) {
910 if (!
s->width && !
s->height) {
911 struct v4l2_format fmt = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE };
914 "Querying the device for the current frame size\n");
922 s->width = fmt.fmt.pix.width;
923 s->height = fmt.fmt.pix.height;
925 "Setting frame size to %dx%d\n",
s->width,
s->height);
942 s->pixelformat = desired_format;
950 s->width,
s->height, 1);
966 if (desired_format == V4L2_PIX_FMT_YVU420)
968 else if (desired_format == V4L2_PIX_FMT_YVU410)
984 #if FF_API_CODED_FRAME && FF_API_LAVF_AVCTX
996 #if FF_API_CODED_FRAME && FF_API_LAVF_AVCTX
998 if (
frame &&
s->interlaced) {
1024 return !strncmp(
name,
"video", 5) ||
1025 !strncmp(
name,
"radio", 5) ||
1026 !strncmp(
name,
"vbi", 3) ||
1027 !strncmp(
name,
"v4l-subdev", 10);
1034 struct dirent *entry;
1036 struct v4l2_capability cap;
1042 dir = opendir(
"/dev");
1048 while ((entry = readdir(dir))) {
1049 char device_name[256];
1054 snprintf(device_name,
sizeof(device_name),
"/dev/%s", entry->d_name);
1058 if (
v4l2_ioctl(
s->fd, VIDIOC_QUERYCAP, &cap) < 0) {
1099 #define OFFSET(x) offsetof(struct video_data, x)
1100 #define DEC AV_OPT_FLAG_DECODING_PARAM
1110 {
"list_formats",
"list available formats and exit",
OFFSET(list_format),
AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX,
DEC,
"list_formats" },
1115 {
"list_standards",
"list supported standards and exit",
OFFSET(list_standard),
AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 1,
DEC,
"list_standards" },
1116 {
"all",
"show all supported standards",
OFFSET(list_standard),
AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 0,
DEC,
"list_standards" },
1118 {
"timestamps",
"set type of timestamps for grabbed frames",
OFFSET(ts_mode),
AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 2,
DEC,
"timestamps" },
1119 {
"ts",
"set type of timestamps for grabbed frames",
OFFSET(ts_mode),
AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 2,
DEC,
"timestamps" },
1123 {
"use_libv4l2",
"use libv4l2 (v4l-utils) conversion functions",
OFFSET(use_libv4l2),
AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1,
DEC },
1136 .
name =
"video4linux2,v4l2",
#define av_assert0(cond)
assert() equivalent, that is always enabled.
#define flags(name, subs,...)
#define MKTAG(a, b, c, d)
static enum AVPixelFormat pix_fmt
#define atomic_store(object, desired)
#define atomic_load(object)
channel
Use these values when setting the channel map with ebur128_set_channel().
#define atomic_fetch_add(object, operand)
@ AV_OPT_TYPE_IMAGE_SIZE
offset must point to two consecutive integers
const AVCodecDescriptor * avcodec_descriptor_get_by_name(const char *name)
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
AVCodecID
Identify the syntax and semantics of the bitstream.
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
unsigned int avcodec_pix_fmt_to_codec_tag(enum AVPixelFormat pix_fmt)
Return a value representing the fourCC code associated to the pixel format pix_fmt,...
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
AVBufferRef * av_buffer_create(uint8_t *data, buffer_size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define AV_LOG_VERBOSE
Detailed information.
#define AV_LOG_INFO
Standard information.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
const char * av_default_item_name(void *ptr)
Return the context name.
static double av_q2d(AVRational a)
Convert an AVRational to a double.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem)
Add an element to a dynamic array.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
char * av_strdup(const char *s)
Duplicate a string.
static void * av_x_if_null(const void *p, const void *x)
Return x default pointer in case p is NULL.
int av_image_get_buffer_size(enum AVPixelFormat pix_fmt, int width, int height, int align)
Return the size in bytes of the amount of data required to store an image with the given parameters.
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
#define AV_TIME_BASE
Internal time base represented as integer.
#define LIBAVUTIL_VERSION_INT
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
#define FF_DISABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
@ AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT
int av_parse_video_rate(AVRational *rate, const char *arg)
Parse str and store the detected values in *rate.
enum AVPixelFormat av_get_pix_fmt(const char *name)
Return the pixel format corresponding to name.
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
AVPixelFormat
Pixel format.
Describe the class of an AVClass context structure.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
This struct describes the properties of a single codec described by an AVCodecID.
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
enum AVMediaType codec_type
General type of the encoded data.
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
int nb_devices
number of autodetected devices
AVDeviceInfo ** devices
list of autodetected devices
Structure describes basic parameters of the device.
char * device_description
human friendly name
char * device_name
device name, format depends on device
int flags
Flags modifying the (de)muxer behaviour.
char * url
input or output URL.
enum AVCodecID video_codec_id
Forced video codec_id.
void * priv_data
Format private data.
AVStream ** streams
A list of all streams in the file.
This structure describes decoded (raw) audio or video data.
int top_field_first
If the content is interlaced, is top field displayed first.
int interlaced_frame
The content of the picture is interlaced.
This structure stores compressed data.
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
This structure contains the data a format has to probe a file.
Rational number (pair of numerator and denominator).
AVCodecParameters * codecpar
Codec parameters associated with this stream.
AVRational avg_frame_rate
Average framerate.
attribute_deprecated AVCodecContext * codec
enum AVStreamParseType need_parsing
AVRational r_frame_rate
Real base framerate of the stream.
Opaque type representing a time filter state.
int(* ioctl_f)(int fd, unsigned long int request,...)
char * framerate
Set by a private option.
int list_standard
Set by a private option.
char * pixel_format
Set by a private option.
int(* munmap_f)(void *_start, size_t length)
ssize_t(* read_f)(int fd, void *buffer, size_t n)
atomic_int buffers_queued
int(* open_f)(const char *file, int oflag,...)
int list_format
Set by a private option.
#define av_malloc_array(a, b)
int64_t av_gettime_relative(void)
Get the current time in microseconds since some unspecified starting point.
int64_t av_gettime(void)
Get the current time in microseconds.
double ff_timefilter_eval(TimeFilter *self, double delta)
Evaluate the filter at a specified time.
double ff_timefilter_update(TimeFilter *self, double system_time, double period)
Update the filter.
TimeFilter * ff_timefilter_new(double time_base, double period, double bandwidth)
Create a new Delay Locked Loop time filter.
const struct fmt_map ff_fmt_conversion_table[]
enum AVCodecID ff_fmt_v4l2codec(uint32_t v4l2_fmt)
enum AVPixelFormat ff_fmt_v4l2ff(uint32_t v4l2_fmt, enum AVCodecID codec_id)
uint32_t ff_fmt_ff2v4l(enum AVPixelFormat pix_fmt, enum AVCodecID codec_id)
static int device_try_init(AVFormatContext *ctx, enum AVPixelFormat pix_fmt, int *width, int *height, uint32_t *desired_format, enum AVCodecID *codec_id)
static int mmap_start(AVFormatContext *ctx)
#define SET_WRAPPERS(prefix)
#define V4L_TS_MONO2ABS
Assume kernel timestamps are from the monotonic clock and convert to absolute timestamps.
static void mmap_release_buffer(void *opaque, uint8_t *data)
static const int desired_video_buffers
static const AVOption options[]
static int init_convert_timestamp(AVFormatContext *ctx, int64_t ts)
static int convert_timestamp(AVFormatContext *ctx, int64_t *ts)
static int v4l2_is_v4l_dev(const char *name)
static int v4l2_get_device_list(AVFormatContext *ctx, AVDeviceInfoList *device_list)
static const AVClass v4l2_class
static int enqueue_buffer(struct video_data *s, struct v4l2_buffer *buf)
static int mmap_init(AVFormatContext *ctx)
static int mmap_read_frame(AVFormatContext *ctx, AVPacket *pkt)
static int v4l2_read_close(AVFormatContext *ctx)
static void list_standards(AVFormatContext *ctx)
static int v4l2_read_packet(AVFormatContext *ctx, AVPacket *pkt)
#define V4L_TS_ABS
Autodetect the kind of timestamps returned by the kernel and convert to absolute (wall clock) timesta...
static int first_field(const struct video_data *s)
static void list_formats(AVFormatContext *ctx, int type)
#define V4L_TS_DEFAULT
Return timestamps to the user exactly as returned by the kernel.
static int v4l2_read_probe(const AVProbeData *p)
#define V4L_TS_CONVERT_READY
Once the kind of timestamps returned by the kernel have been detected, the value of the timefilter (N...
static int v4l2_read_header(AVFormatContext *ctx)
static int device_init(AVFormatContext *ctx, int *width, int *height, uint32_t pixelformat)
static int v4l2_set_parameters(AVFormatContext *ctx)
AVInputFormat ff_v4l2_demuxer
static void mmap_close(struct video_data *s)
static int device_open(AVFormatContext *ctx, const char *device_path)
static const uint8_t offset[127][2]