Go to the documentation of this file.
33 #include <stdatomic.h>
56 #define V4L_ALLFORMATS 3
57 #define V4L_RAWFORMATS 1
58 #define V4L_COMPFORMATS 2
63 #define V4L_TS_DEFAULT 0
73 #define V4L_TS_MONO2ABS 2
80 #define V4L_TS_CONVERT_READY V4L_TS_DEFAULT
116 void *(*mmap_f)(
void *start,
size_t length,
int prot,
int flags,
int fd, int64_t
offset);
128 struct v4l2_capability cap;
133 #define SET_WRAPPERS(prefix) do { \
134 s->open_f = prefix ## open; \
135 s->close_f = prefix ## close; \
136 s->dup_f = prefix ## dup; \
137 s->ioctl_f = prefix ## ioctl; \
138 s->read_f = prefix ## read; \
139 s->mmap_f = prefix ## mmap; \
140 s->munmap_f = prefix ## munmap; \
143 if (
s->use_libv4l2) {
154 #define v4l2_open s->open_f
155 #define v4l2_close s->close_f
156 #define v4l2_dup s->dup_f
157 #define v4l2_ioctl s->ioctl_f
158 #define v4l2_read s->read_f
159 #define v4l2_mmap s->mmap_f
160 #define v4l2_munmap s->munmap_f
174 if (
v4l2_ioctl(fd, VIDIOC_QUERYCAP, &cap) < 0) {
182 fd, cap.capabilities);
184 if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
190 if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
192 "The device does not support the streaming I/O method.\n");
205 uint32_t pixelformat)
208 struct v4l2_format fmt = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE };
211 fmt.fmt.pix.width = *
width;
212 fmt.fmt.pix.height = *
height;
213 fmt.fmt.pix.pixelformat = pixelformat;
214 fmt.fmt.pix.field = V4L2_FIELD_ANY;
221 if ((*
width != fmt.fmt.pix.width) || (*
height != fmt.fmt.pix.height)) {
223 "The V4L2 driver changed the video from %dx%d to %dx%d\n",
224 *
width, *
height, fmt.fmt.pix.width, fmt.fmt.pix.height);
225 *
width = fmt.fmt.pix.width;
226 *
height = fmt.fmt.pix.height;
229 if (pixelformat != fmt.fmt.pix.pixelformat) {
231 "The V4L2 driver changed the pixel format "
232 "from 0x%08X to 0x%08X\n",
233 pixelformat, fmt.fmt.pix.pixelformat);
237 if (fmt.fmt.pix.field == V4L2_FIELD_INTERLACED) {
239 "The V4L2 driver is using the interlaced mode\n");
254 if (std & V4L2_STD_NTSC)
260 #if HAVE_STRUCT_V4L2_FRMIVALENUM_DISCRETE
264 struct v4l2_frmsizeenum vfse = { .pixel_format = pixelformat };
266 while(!
v4l2_ioctl(
s->fd, VIDIOC_ENUM_FRAMESIZES, &vfse)) {
268 case V4L2_FRMSIZE_TYPE_DISCRETE:
270 vfse.discrete.width, vfse.discrete.height);
272 case V4L2_FRMSIZE_TYPE_CONTINUOUS:
273 case V4L2_FRMSIZE_TYPE_STEPWISE:
275 vfse.stepwise.min_width,
276 vfse.stepwise.max_width,
277 vfse.stepwise.step_width,
278 vfse.stepwise.min_height,
279 vfse.stepwise.max_height,
280 vfse.stepwise.step_height);
290 struct v4l2_fmtdesc vfd = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE };
298 if (!(vfd.flags & V4L2_FMT_FLAG_COMPRESSED) &&
302 fmt_name ? fmt_name :
"Unsupported",
304 }
else if (vfd.flags & V4L2_FMT_FLAG_COMPRESSED &&
314 #ifdef V4L2_FMT_FLAG_EMULATED
315 if (vfd.flags & V4L2_FMT_FLAG_EMULATED)
318 #if HAVE_STRUCT_V4L2_FRMIVALENUM_DISCRETE
319 list_framesizes(
ctx, vfd.pixelformat);
329 struct v4l2_standard standard;
334 for (standard.index = 0; ; standard.index++) {
335 if (
v4l2_ioctl(
s->fd, VIDIOC_ENUMSTD, &standard) < 0) {
345 standard.index, (uint64_t)standard.id, standard.name);
353 struct v4l2_requestbuffers req = {
354 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
356 .memory = V4L2_MEMORY_MMAP
369 s->buffers = req.count;
382 for (
i = 0;
i < req.count;
i++) {
383 struct v4l2_buffer buf = {
384 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
386 .memory = V4L2_MEMORY_MMAP
388 if (
v4l2_ioctl(
s->fd, VIDIOC_QUERYBUF, &buf) < 0) {
394 s->buf_len[
i] = buf.length;
395 if (
s->frame_size > 0 &&
s->buf_len[
i] <
s->frame_size) {
397 "buf_len[%d] = %d < expected frame size %d\n",
398 i,
s->buf_len[
i],
s->frame_size);
402 PROT_READ | PROT_WRITE, MAP_SHARED,
403 s->fd, buf.m.offset);
405 if (
s->buf_start[
i] == MAP_FAILED) {
431 struct v4l2_buffer buf = { 0 };
432 struct buff_data *buf_descriptor = opaque;
435 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
436 buf.memory = V4L2_MEMORY_MMAP;
437 buf.index = buf_descriptor->
index;
443 #if HAVE_CLOCK_GETTIME && defined(CLOCK_MONOTONIC)
444 static int64_t av_gettime_monotonic(
void)
457 ts <= now + 1 * AV_TIME_BASE && ts >= now - 10 *
AV_TIME_BASE) {
462 #if HAVE_CLOCK_GETTIME && defined(CLOCK_MONOTONIC)
464 now = av_gettime_monotonic();
466 (ts <= now + 1 * AV_TIME_BASE && ts >= now - 10 *
AV_TIME_BASE)) {
492 #if HAVE_CLOCK_GETTIME && defined(CLOCK_MONOTONIC)
495 int64_t nowm = av_gettime_monotonic();
497 s->last_time_m = nowm;
507 struct v4l2_buffer buf = {
508 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
509 .memory = V4L2_MEMORY_MMAP
511 struct timeval buf_ts;
517 while ((res =
v4l2_ioctl(
s->fd, VIDIOC_DQBUF, &buf)) < 0 && (errno == EINTR));
528 buf_ts = buf.timestamp;
530 if (buf.index >=
s->buffers) {
538 #ifdef V4L2_BUF_FLAG_ERROR
539 if (buf.flags & V4L2_BUF_FLAG_ERROR) {
541 "Dequeued v4l2 buffer contains corrupted data (%d bytes).\n",
550 s->frame_size = buf.bytesused;
552 if (
s->frame_size > 0 && buf.bytesused !=
s->frame_size) {
554 "Dequeued v4l2 buffer contains %d bytes, but %d were expected. Flags: 0x%08X.\n",
555 buf.bytesused,
s->frame_size, buf.flags);
569 memcpy(
pkt->
data,
s->buf_start[buf.index], buf.bytesused);
579 pkt->
data =
s->buf_start[buf.index];
583 if (!buf_descriptor) {
592 buf_descriptor->
index = buf.index;
593 buf_descriptor->
s =
s;
604 pkt->
pts = buf_ts.tv_sec * INT64_C(1000000) + buf_ts.tv_usec;
613 enum v4l2_buf_type
type;
616 for (
i = 0;
i <
s->buffers;
i++) {
617 struct v4l2_buffer buf = {
618 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
620 .memory = V4L2_MEMORY_MMAP
632 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
645 enum v4l2_buf_type
type;
648 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
653 for (
i = 0;
i <
s->buffers;
i++) {
663 struct v4l2_standard standard = { 0 };
664 struct v4l2_streamparm streamparm = { 0 };
665 struct v4l2_fract *tpf;
683 if (
v4l2_ioctl(
s->fd, VIDIOC_ENUMSTD, &standard) < 0) {
695 if (
v4l2_ioctl(
s->fd, VIDIOC_S_STD, &standard.id) < 0) {
702 "This device does not support any standard\n");
708 tpf = &standard.frameperiod;
711 if (
v4l2_ioctl(
s->fd, VIDIOC_ENUMSTD, &standard) < 0) {
718 tpf = &streamparm.parm.capture.timeperframe;
724 if (standard.id ==
s->std_id) {
726 "Current standard: %s, id: %"PRIx64
", frameperiod: %d/%d\n",
727 standard.name, (uint64_t)standard.id, tpf->numerator, tpf->denominator);
732 tpf = &streamparm.parm.capture.timeperframe;
735 streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
736 if (
v4l2_ioctl(
s->fd, VIDIOC_G_PARM, &streamparm) < 0) {
739 }
else if (framerate_q.
num && framerate_q.
den) {
740 if (streamparm.parm.capture.capability & V4L2_CAP_TIMEPERFRAME) {
741 tpf = &streamparm.parm.capture.timeperframe;
744 framerate_q.
den, framerate_q.
num);
745 tpf->numerator = framerate_q.
den;
746 tpf->denominator = framerate_q.
num;
748 if (
v4l2_ioctl(
s->fd, VIDIOC_S_PARM, &streamparm) < 0) {
755 if (framerate_q.
num != tpf->denominator ||
756 framerate_q.
den != tpf->numerator) {
758 "The driver changed the time per frame from "
760 framerate_q.
den, framerate_q.
num,
761 tpf->numerator, tpf->denominator);
765 "The driver does not permit changing the time per frame\n");
768 if (tpf->denominator > 0 && tpf->numerator > 0) {
782 uint32_t *desired_format,
789 if (*desired_format) {
798 if (!*desired_format) {
816 if (*desired_format == 0) {
818 "codec '%s' (id %d), pixel format '%s' (id %d)\n",
843 uint32_t desired_format;
846 struct v4l2_input
input = { 0 };
856 v4l2_log_file = fopen(
"/dev/null",
"w");
863 if (
s->channel != -1) {
866 if (
v4l2_ioctl(
s->fd, VIDIOC_S_INPUT, &
s->channel) < 0) {
873 if (
v4l2_ioctl(
s->fd, VIDIOC_G_INPUT, &
s->channel) < 0) {
891 if (
s->list_format) {
897 if (
s->list_standard) {
905 if (
s->pixel_format) {
922 if (!
s->width && !
s->height) {
923 struct v4l2_format fmt = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE };
926 "Querying the device for the current frame size\n");
934 s->width = fmt.fmt.pix.width;
935 s->height = fmt.fmt.pix.height;
937 "Setting frame size to %dx%d\n",
s->width,
s->height);
954 s->pixelformat = desired_format;
962 s->width,
s->height, 1);
978 if (desired_format == V4L2_PIX_FMT_YVU420)
980 else if (desired_format == V4L2_PIX_FMT_YVU410)
1022 return !strncmp(
name,
"video", 5) ||
1023 !strncmp(
name,
"radio", 5) ||
1024 !strncmp(
name,
"vbi", 3) ||
1025 !strncmp(
name,
"v4l-subdev", 10);
1032 struct dirent *entry;
1038 dir = opendir(
"/dev");
1044 while ((entry = readdir(dir))) {
1046 struct v4l2_capability cap;
1048 char device_name[256];
1053 size =
snprintf(device_name,
sizeof(device_name),
"/dev/%s", entry->d_name);
1054 if (
size >=
sizeof(device_name)) {
1063 if (
v4l2_ioctl(fd, VIDIOC_QUERYCAP, &cap) < 0) {
1101 #define OFFSET(x) offsetof(struct video_data, x)
1102 #define DEC AV_OPT_FLAG_DECODING_PARAM
1112 {
"list_formats",
"list available formats and exit",
OFFSET(list_format),
AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX,
DEC,
"list_formats" },
1117 {
"list_standards",
"list supported standards and exit",
OFFSET(list_standard),
AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 1,
DEC,
"list_standards" },
1118 {
"all",
"show all supported standards",
OFFSET(list_standard),
AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 0,
DEC,
"list_standards" },
1120 {
"timestamps",
"set type of timestamps for grabbed frames",
OFFSET(ts_mode),
AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 2,
DEC,
"timestamps" },
1121 {
"ts",
"set type of timestamps for grabbed frames",
OFFSET(ts_mode),
AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 2,
DEC,
"timestamps" },
1125 {
"use_libv4l2",
"use libv4l2 (v4l-utils) conversion functions",
OFFSET(use_libv4l2),
AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1,
DEC },
1138 .
name =
"video4linux2,v4l2",
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Opaque type representing a time filter state.
int64_t av_gettime_relative(void)
Get the current time in microseconds since some unspecified starting point.
#define AV_LOG_WARNING
Something somehow does not look correct.
AVPixelFormat
Pixel format.
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
#define atomic_store(object, desired)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
enum AVMediaType codec_type
General type of the encoded data.
const AVInputFormat ff_v4l2_demuxer
static const AVClass v4l2_class
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
static int v4l2_set_parameters(AVFormatContext *ctx)
char * device_name
device name, format depends on device
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
int nb_devices
number of autodetected devices
AVStream ** streams
A list of all streams in the file.
AVRational avg_frame_rate
Average framerate.
static int mmap_init(AVFormatContext *ctx)
#define AV_LOG_VERBOSE
Detailed information.
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
enum AVCodecID video_codec_id
Forced video codec_id.
uint32_t ff_fmt_ff2v4l(enum AVPixelFormat pix_fmt, enum AVCodecID codec_id)
const struct fmt_map ff_fmt_conversion_table[]
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,...
double ff_timefilter_eval(TimeFilter *self, double delta)
Evaluate the filter at a specified time.
enum AVCodecID ff_fmt_v4l2codec(uint32_t v4l2_fmt)
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
char * framerate
Set by a private option.
TimeFilter * ff_timefilter_new(double time_base, double period, double bandwidth)
Create a new Delay Locked Loop time filter.
AVDeviceInfo ** devices
list of autodetected devices
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static int device_init(AVFormatContext *ctx, int *width, int *height, uint32_t pixelformat)
This struct describes the properties of a single codec described by an AVCodecID.
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
atomic_int buffers_queued
int flags
Flags modifying the (de)muxer behaviour.
static enum AVPixelFormat pix_fmt
static double av_q2d(AVRational a)
Convert an AVRational to a double.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
#define atomic_load(object)
AVCodecParameters * codecpar
Codec parameters associated with this stream.
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
#define LIBAVUTIL_VERSION_INT
Describe the class of an AVClass context structure.
Rational number (pair of numerator and denominator).
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without period
@ AV_OPT_TYPE_IMAGE_SIZE
offset must point to two consecutive integers
const char * av_default_item_name(void *ptr)
Return the context name.
enum AVPixelFormat ff_fmt_v4l2ff(uint32_t v4l2_fmt, enum AVCodecID codec_id)
This structure contains the data a format has to probe a file.
@ AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT
int(* open_f)(const char *file, int oflag,...)
AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
AVCodecID
Identify the syntax and semantics of the bitstream.
static int device_open(AVFormatContext *ctx, const char *device_path)
static void mmap_release_buffer(void *opaque, uint8_t *data)
static int init_convert_timestamp(AVFormatContext *ctx, int64_t ts)
static int v4l2_read_close(AVFormatContext *ctx)
static void list_formats(AVFormatContext *ctx, int type)
static int v4l2_read_probe(const AVProbeData *p)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
char * url
input or output URL.
Structure describes basic parameters of the device.
int(* ioctl_f)(int fd, int request,...)
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.
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
char * device_description
human friendly name
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some input
#define AV_LOG_INFO
Standard information.
void avpriv_stream_set_need_parsing(AVStream *st, enum AVStreamParseType type)
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
int av_parse_video_rate(AVRational *rate, const char *arg)
Parse str and store the detected values in *rate.
void ff_timefilter_destroy(TimeFilter *self)
Free all resources associated with the filter.
#define i(width, name, range_min, range_max)
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
static void mmap_close(struct video_data *s)
static int v4l2_is_v4l_dev(const char *name)
#define AV_TIME_BASE
Internal time base represented as integer.
#define av_malloc_array(a, b)
static const AVOption options[]
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
double ff_timefilter_update(TimeFilter *self, double system_time, double period)
Update the filter.
#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_get_device_list(AVFormatContext *ctx, AVDeviceInfoList *device_list)
#define V4L_TS_MONO2ABS
Assume kernel timestamps are from the monotonic clock and convert to absolute timestamps.
ssize_t(* read_f)(int fd, void *buffer, size_t n)
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
enum AVPixelFormat av_get_pix_fmt(const char *name)
Return the pixel format corresponding to name.
int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem)
Add an element to a dynamic array.
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
int list_format
Set by a private option.
#define atomic_fetch_add(object, operand)
int list_standard
Set by a private option.
static int convert_timestamp(AVFormatContext *ctx, int64_t *ts)
char * pixel_format
Set by a private option.
int(* munmap_f)(void *_start, size_t length)
AVRational r_frame_rate
Real base framerate of the stream.
int64_t av_gettime(void)
Get the current time in microseconds.
#define SET_WRAPPERS(prefix)
char * av_strdup(const char *s)
Duplicate a string.
static int read_probe(const AVProbeData *p)
static int v4l2_read_header(AVFormatContext *ctx)
static int mmap_start(AVFormatContext *ctx)
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
This structure stores compressed data.
static void list_standards(AVFormatContext *ctx)
static int v4l2_read_packet(AVFormatContext *ctx, AVPacket *pkt)
#define flags(name, subs,...)
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
#define MKTAG(a, b, c, d)
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
#define V4L_TS_DEFAULT
Return timestamps to the user exactly as returned by the kernel.
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
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...
const AVCodecDescriptor * avcodec_descriptor_get_by_name(const char *name)
static int first_field(const struct video_data *s)
void * priv_data
Format private data.
#define V4L_TS_ABS
Autodetect the kind of timestamps returned by the kernel and convert to absolute (wall clock) timesta...
static void * av_x_if_null(const void *p, const void *x)
Return x default pointer in case p is NULL.
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.
static int enqueue_buffer(struct video_data *s, struct v4l2_buffer *buf)
static int mmap_read_frame(AVFormatContext *ctx, AVPacket *pkt)
static const int desired_video_buffers
static int device_try_init(AVFormatContext *ctx, enum AVPixelFormat pix_fmt, int *width, int *height, uint32_t *desired_format, enum AVCodecID *codec_id)