FFmpeg
v4l2_buffers.c
Go to the documentation of this file.
1 /*
2  * V4L2 buffer helper functions.
3  *
4  * Copyright (C) 2017 Alexis Ballier <aballier@gentoo.org>
5  * Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz@linaro.org>
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23 
24 #include <linux/videodev2.h>
25 #include <sys/ioctl.h>
26 #include <sys/mman.h>
27 #include <unistd.h>
28 #include <fcntl.h>
29 #include <poll.h>
30 #include "libavcodec/avcodec.h"
31 #include "libavutil/pixdesc.h"
32 #include "refstruct.h"
33 #include "v4l2_context.h"
34 #include "v4l2_buffers.h"
35 #include "v4l2_m2m.h"
36 
37 #define USEC_PER_SEC 1000000
39 
41 {
42  return V4L2_TYPE_IS_OUTPUT(buf->context->type) ?
44  container_of(buf->context, V4L2m2mContext, capture);
45 }
46 
47 static inline AVCodecContext *logger(V4L2Buffer *buf)
48 {
49  return buf_to_m2mctx(buf)->avctx;
50 }
51 
53 {
54  V4L2m2mContext *s = buf_to_m2mctx(avbuf);
55 
56  if (s->avctx->pkt_timebase.num)
57  return s->avctx->pkt_timebase;
58  return s->avctx->time_base;
59 }
60 
61 static inline void v4l2_set_pts(V4L2Buffer *out, int64_t pts)
62 {
63  int64_t v4l2_pts;
64 
65  if (pts == AV_NOPTS_VALUE)
66  pts = 0;
67 
68  /* convert pts to v4l2 timebase */
70  out->buf.timestamp.tv_usec = v4l2_pts % USEC_PER_SEC;
71  out->buf.timestamp.tv_sec = v4l2_pts / USEC_PER_SEC;
72 }
73 
74 static inline int64_t v4l2_get_pts(V4L2Buffer *avbuf)
75 {
76  int64_t v4l2_pts;
77 
78  /* convert pts back to encoder timebase */
79  v4l2_pts = (int64_t)avbuf->buf.timestamp.tv_sec * USEC_PER_SEC +
80  avbuf->buf.timestamp.tv_usec;
81 
82  return av_rescale_q(v4l2_pts, v4l2_timebase, v4l2_get_timebase(avbuf));
83 }
84 
86 {
87  enum v4l2_ycbcr_encoding ycbcr;
88  enum v4l2_colorspace cs;
89 
90  cs = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
91  buf->context->format.fmt.pix_mp.colorspace :
92  buf->context->format.fmt.pix.colorspace;
93 
94  ycbcr = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
95  buf->context->format.fmt.pix_mp.ycbcr_enc:
96  buf->context->format.fmt.pix.ycbcr_enc;
97 
98  switch(ycbcr) {
99  case V4L2_YCBCR_ENC_XV709:
100  case V4L2_YCBCR_ENC_709: return AVCOL_PRI_BT709;
101  case V4L2_YCBCR_ENC_XV601:
102  case V4L2_YCBCR_ENC_601:return AVCOL_PRI_BT470M;
103  default:
104  break;
105  }
106 
107  switch(cs) {
108  case V4L2_COLORSPACE_470_SYSTEM_BG: return AVCOL_PRI_BT470BG;
109  case V4L2_COLORSPACE_SMPTE170M: return AVCOL_PRI_SMPTE170M;
110  case V4L2_COLORSPACE_SMPTE240M: return AVCOL_PRI_SMPTE240M;
111  case V4L2_COLORSPACE_BT2020: return AVCOL_PRI_BT2020;
112  default:
113  break;
114  }
115 
116  return AVCOL_PRI_UNSPECIFIED;
117 }
118 
120 {
121  enum v4l2_quantization qt;
122 
123  qt = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
124  buf->context->format.fmt.pix_mp.quantization :
125  buf->context->format.fmt.pix.quantization;
126 
127  switch (qt) {
128  case V4L2_QUANTIZATION_LIM_RANGE: return AVCOL_RANGE_MPEG;
129  case V4L2_QUANTIZATION_FULL_RANGE: return AVCOL_RANGE_JPEG;
130  default:
131  break;
132  }
133 
135 }
136 
138 {
139  enum v4l2_ycbcr_encoding ycbcr;
140  enum v4l2_colorspace cs;
141 
142  cs = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
143  buf->context->format.fmt.pix_mp.colorspace :
144  buf->context->format.fmt.pix.colorspace;
145 
146  ycbcr = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
147  buf->context->format.fmt.pix_mp.ycbcr_enc:
148  buf->context->format.fmt.pix.ycbcr_enc;
149 
150  switch(cs) {
151  case V4L2_COLORSPACE_SRGB: return AVCOL_SPC_RGB;
152  case V4L2_COLORSPACE_REC709: return AVCOL_SPC_BT709;
153  case V4L2_COLORSPACE_470_SYSTEM_M: return AVCOL_SPC_FCC;
154  case V4L2_COLORSPACE_470_SYSTEM_BG: return AVCOL_SPC_BT470BG;
155  case V4L2_COLORSPACE_SMPTE170M: return AVCOL_SPC_SMPTE170M;
156  case V4L2_COLORSPACE_SMPTE240M: return AVCOL_SPC_SMPTE240M;
157  case V4L2_COLORSPACE_BT2020:
158  if (ycbcr == V4L2_YCBCR_ENC_BT2020_CONST_LUM)
159  return AVCOL_SPC_BT2020_CL;
160  else
161  return AVCOL_SPC_BT2020_NCL;
162  default:
163  break;
164  }
165 
166  return AVCOL_SPC_UNSPECIFIED;
167 }
168 
170 {
171  enum v4l2_ycbcr_encoding ycbcr;
172  enum v4l2_xfer_func xfer;
173  enum v4l2_colorspace cs;
174 
175  cs = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
176  buf->context->format.fmt.pix_mp.colorspace :
177  buf->context->format.fmt.pix.colorspace;
178 
179  ycbcr = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
180  buf->context->format.fmt.pix_mp.ycbcr_enc:
181  buf->context->format.fmt.pix.ycbcr_enc;
182 
183  xfer = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
184  buf->context->format.fmt.pix_mp.xfer_func:
185  buf->context->format.fmt.pix.xfer_func;
186 
187  switch (xfer) {
188  case V4L2_XFER_FUNC_709: return AVCOL_TRC_BT709;
189  case V4L2_XFER_FUNC_SRGB: return AVCOL_TRC_IEC61966_2_1;
190  default:
191  break;
192  }
193 
194  switch (cs) {
195  case V4L2_COLORSPACE_470_SYSTEM_M: return AVCOL_TRC_GAMMA22;
196  case V4L2_COLORSPACE_470_SYSTEM_BG: return AVCOL_TRC_GAMMA28;
197  case V4L2_COLORSPACE_SMPTE170M: return AVCOL_TRC_SMPTE170M;
198  case V4L2_COLORSPACE_SMPTE240M: return AVCOL_TRC_SMPTE240M;
199  default:
200  break;
201  }
202 
203  switch (ycbcr) {
204  case V4L2_YCBCR_ENC_XV709:
205  case V4L2_YCBCR_ENC_XV601: return AVCOL_TRC_BT1361_ECG;
206  default:
207  break;
208  }
209 
210  return AVCOL_TRC_UNSPECIFIED;
211 }
212 
213 static void v4l2_free_buffer(void *opaque, uint8_t *unused)
214 {
215  V4L2Buffer* avbuf = opaque;
216  V4L2m2mContext *s = buf_to_m2mctx(avbuf);
217 
218  if (atomic_fetch_sub(&avbuf->context_refcount, 1) == 1) {
219  atomic_fetch_sub_explicit(&s->refcount, 1, memory_order_acq_rel);
220 
221  if (s->reinit) {
222  if (!atomic_load(&s->refcount))
223  sem_post(&s->refsync);
224  } else {
225  if (s->draining && V4L2_TYPE_IS_OUTPUT(avbuf->context->type)) {
226  /* no need to queue more buffers to the driver */
227  avbuf->status = V4L2BUF_AVAILABLE;
228  }
229  else if (avbuf->context->streamon)
230  ff_v4l2_buffer_enqueue(avbuf);
231  }
232 
234  }
235 }
236 
238 {
240 
241  if (in->context_ref)
243  else {
244  in->context_ref = ff_refstruct_ref(s->self_ref);
245 
246  in->context_refcount = 1;
247  }
248 
249  in->status = V4L2BUF_RET_USER;
250  atomic_fetch_add_explicit(&s->refcount, 1, memory_order_relaxed);
251 
252  return 0;
253 }
254 
255 static int v4l2_buf_to_bufref(V4L2Buffer *in, int plane, AVBufferRef **buf)
256 {
257  int ret;
258 
259  if (plane >= in->num_planes)
260  return AVERROR(EINVAL);
261 
262  /* even though most encoders return 0 in data_offset encoding vp8 does require this value */
263  *buf = av_buffer_create((char *)in->plane_info[plane].mm_addr + in->planes[plane].data_offset,
264  in->plane_info[plane].length, v4l2_free_buffer, in, 0);
265  if (!*buf)
266  return AVERROR(ENOMEM);
267 
269  if (ret)
270  av_buffer_unref(buf);
271 
272  return ret;
273 }
274 
275 static int v4l2_bufref_to_buf(V4L2Buffer *out, int plane, const uint8_t* data, int size, int offset)
276 {
277  unsigned int bytesused, length;
278 
279  if (plane >= out->num_planes)
280  return AVERROR(EINVAL);
281 
282  length = out->plane_info[plane].length;
283  bytesused = FFMIN(size+offset, length);
284 
285  memcpy((uint8_t*)out->plane_info[plane].mm_addr+offset, data, FFMIN(size, length-offset));
286 
287  if (V4L2_TYPE_IS_MULTIPLANAR(out->buf.type)) {
288  out->planes[plane].bytesused = bytesused;
289  out->planes[plane].length = length;
290  } else {
291  out->buf.bytesused = bytesused;
292  out->buf.length = length;
293  }
294 
295  return 0;
296 }
297 
299 {
300  int i, ret;
301 
302  frame->format = avbuf->context->av_pix_fmt;
303 
304  for (i = 0; i < avbuf->num_planes; i++) {
305  ret = v4l2_buf_to_bufref(avbuf, i, &frame->buf[i]);
306  if (ret)
307  return ret;
308 
309  frame->linesize[i] = avbuf->plane_info[i].bytesperline;
310  frame->data[i] = frame->buf[i]->data;
311  }
312 
313  /* fixup special cases */
314  switch (avbuf->context->av_pix_fmt) {
315  case AV_PIX_FMT_NV12:
316  case AV_PIX_FMT_NV21:
317  if (avbuf->num_planes > 1)
318  break;
319  frame->linesize[1] = avbuf->plane_info[0].bytesperline;
320  frame->data[1] = frame->buf[0]->data + avbuf->plane_info[0].bytesperline * avbuf->context->format.fmt.pix_mp.height;
321  break;
322 
323  case AV_PIX_FMT_YUV420P:
324  if (avbuf->num_planes > 1)
325  break;
326  frame->linesize[1] = avbuf->plane_info[0].bytesperline >> 1;
327  frame->linesize[2] = avbuf->plane_info[0].bytesperline >> 1;
328  frame->data[1] = frame->buf[0]->data + avbuf->plane_info[0].bytesperline * avbuf->context->format.fmt.pix_mp.height;
329  frame->data[2] = frame->data[1] + ((avbuf->plane_info[0].bytesperline * avbuf->context->format.fmt.pix_mp.height) >> 2);
330  break;
331 
332  default:
333  break;
334  }
335 
336  return 0;
337 }
338 
340 {
341  int i, ret;
342  struct v4l2_format fmt = out->context->format;
343  int pixel_format = V4L2_TYPE_IS_MULTIPLANAR(fmt.type) ?
344  fmt.fmt.pix_mp.pixelformat : fmt.fmt.pix.pixelformat;
345  int height = V4L2_TYPE_IS_MULTIPLANAR(fmt.type) ?
346  fmt.fmt.pix_mp.height : fmt.fmt.pix.height;
347  int is_planar_format = 0;
348 
349  switch (pixel_format) {
350  case V4L2_PIX_FMT_YUV420M:
351  case V4L2_PIX_FMT_YVU420M:
352 #ifdef V4L2_PIX_FMT_YUV422M
353  case V4L2_PIX_FMT_YUV422M:
354 #endif
355 #ifdef V4L2_PIX_FMT_YVU422M
356  case V4L2_PIX_FMT_YVU422M:
357 #endif
358 #ifdef V4L2_PIX_FMT_YUV444M
359  case V4L2_PIX_FMT_YUV444M:
360 #endif
361 #ifdef V4L2_PIX_FMT_YVU444M
362  case V4L2_PIX_FMT_YVU444M:
363 #endif
364  case V4L2_PIX_FMT_NV12M:
365  case V4L2_PIX_FMT_NV21M:
366  case V4L2_PIX_FMT_NV12MT_16X16:
367  case V4L2_PIX_FMT_NV12MT:
368  case V4L2_PIX_FMT_NV16M:
369  case V4L2_PIX_FMT_NV61M:
370  is_planar_format = 1;
371  }
372 
373  if (!is_planar_format) {
375  int planes_nb = 0;
376  int offset = 0;
377 
378  for (i = 0; i < desc->nb_components; i++)
379  planes_nb = FFMAX(planes_nb, desc->comp[i].plane + 1);
380 
381  for (i = 0; i < planes_nb; i++) {
382  int size, h = height;
383  if (i == 1 || i == 2) {
384  h = AV_CEIL_RSHIFT(h, desc->log2_chroma_h);
385  }
386  size = frame->linesize[i] * h;
387  ret = v4l2_bufref_to_buf(out, 0, frame->data[i], size, offset);
388  if (ret)
389  return ret;
390  offset += size;
391  }
392  return 0;
393  }
394 
395  for (i = 0; i < out->num_planes; i++) {
396  ret = v4l2_bufref_to_buf(out, i, frame->buf[i]->data, frame->buf[i]->size, 0);
397  if (ret)
398  return ret;
399  }
400 
401  return 0;
402 }
403 
404 /******************************************************************************
405  *
406  * V4L2Buffer interface
407  *
408  ******************************************************************************/
409 
411 {
412  v4l2_set_pts(out, frame->pts);
413 
415 }
416 
418 {
419  int ret;
420 
422 
423  /* 1. get references to the actual data */
425  if (ret)
426  return ret;
427 
428  /* 2. get frame information */
429  if (avbuf->buf.flags & V4L2_BUF_FLAG_KEYFRAME)
430  frame->flags |= AV_FRAME_FLAG_KEY;
431  frame->color_primaries = v4l2_get_color_primaries(avbuf);
432  frame->colorspace = v4l2_get_color_space(avbuf);
433  frame->color_range = v4l2_get_color_range(avbuf);
434  frame->color_trc = v4l2_get_color_trc(avbuf);
435  frame->pts = v4l2_get_pts(avbuf);
436  frame->pkt_dts = AV_NOPTS_VALUE;
437 
438  /* these values are updated also during re-init in v4l2_process_driver_event */
439  frame->height = avbuf->context->height;
440  frame->width = avbuf->context->width;
441  frame->sample_aspect_ratio = avbuf->context->sample_aspect_ratio;
442 
443  /* 3. report errors upstream */
444  if (avbuf->buf.flags & V4L2_BUF_FLAG_ERROR) {
445  av_log(logger(avbuf), AV_LOG_ERROR, "%s: driver decode error\n", avbuf->context->name);
446  frame->decode_error_flags |= FF_DECODE_ERROR_INVALID_BITSTREAM;
447  }
448 
449  return 0;
450 }
451 
453 {
454  int ret;
455 
457  ret = v4l2_buf_to_bufref(avbuf, 0, &pkt->buf);
458  if (ret)
459  return ret;
460 
461  pkt->size = V4L2_TYPE_IS_MULTIPLANAR(avbuf->buf.type) ? avbuf->buf.m.planes[0].bytesused : avbuf->buf.bytesused;
462  pkt->data = pkt->buf->data;
463 
464  if (avbuf->buf.flags & V4L2_BUF_FLAG_KEYFRAME)
466 
467  if (avbuf->buf.flags & V4L2_BUF_FLAG_ERROR) {
468  av_log(logger(avbuf), AV_LOG_ERROR, "%s driver encode error\n", avbuf->context->name);
470  }
471 
472  pkt->dts = pkt->pts = v4l2_get_pts(avbuf);
473 
474  return 0;
475 }
476 
478 {
479  int ret;
480 
481  ret = v4l2_bufref_to_buf(out, 0, pkt->data, pkt->size, 0);
482  if (ret)
483  return ret;
484 
485  v4l2_set_pts(out, pkt->pts);
486 
487  if (pkt->flags & AV_PKT_FLAG_KEY)
488  out->flags = V4L2_BUF_FLAG_KEYFRAME;
489 
490  return 0;
491 }
492 
494 {
495  V4L2Context *ctx = avbuf->context;
496  int ret, i;
497 
498  avbuf->buf.memory = V4L2_MEMORY_MMAP;
499  avbuf->buf.type = ctx->type;
500  avbuf->buf.index = index;
501 
502  if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
503  avbuf->buf.length = VIDEO_MAX_PLANES;
504  avbuf->buf.m.planes = avbuf->planes;
505  }
506 
507  ret = ioctl(buf_to_m2mctx(avbuf)->fd, VIDIOC_QUERYBUF, &avbuf->buf);
508  if (ret < 0)
509  return AVERROR(errno);
510 
511  if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
512  avbuf->num_planes = 0;
513  /* in MP, the V4L2 API states that buf.length means num_planes */
514  for (i = 0; i < avbuf->buf.length; i++) {
515  if (avbuf->buf.m.planes[i].length)
516  avbuf->num_planes++;
517  }
518  } else
519  avbuf->num_planes = 1;
520 
521  for (i = 0; i < avbuf->num_planes; i++) {
522 
523  avbuf->plane_info[i].bytesperline = V4L2_TYPE_IS_MULTIPLANAR(ctx->type) ?
524  ctx->format.fmt.pix_mp.plane_fmt[i].bytesperline :
525  ctx->format.fmt.pix.bytesperline;
526 
527  if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
528  avbuf->plane_info[i].length = avbuf->buf.m.planes[i].length;
529  avbuf->plane_info[i].mm_addr = mmap(NULL, avbuf->buf.m.planes[i].length,
530  PROT_READ | PROT_WRITE, MAP_SHARED,
531  buf_to_m2mctx(avbuf)->fd, avbuf->buf.m.planes[i].m.mem_offset);
532  } else {
533  avbuf->plane_info[i].length = avbuf->buf.length;
534  avbuf->plane_info[i].mm_addr = mmap(NULL, avbuf->buf.length,
535  PROT_READ | PROT_WRITE, MAP_SHARED,
536  buf_to_m2mctx(avbuf)->fd, avbuf->buf.m.offset);
537  }
538 
539  if (avbuf->plane_info[i].mm_addr == MAP_FAILED)
540  return AVERROR(ENOMEM);
541  }
542 
543  avbuf->status = V4L2BUF_AVAILABLE;
544 
545  if (V4L2_TYPE_IS_OUTPUT(ctx->type))
546  return 0;
547 
548  if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
549  avbuf->buf.m.planes = avbuf->planes;
550  avbuf->buf.length = avbuf->num_planes;
551 
552  } else {
553  avbuf->buf.bytesused = avbuf->planes[0].bytesused;
554  avbuf->buf.length = avbuf->planes[0].length;
555  }
556 
557  return ff_v4l2_buffer_enqueue(avbuf);
558 }
559 
561 {
562  int ret;
563 
564  avbuf->buf.flags = avbuf->flags;
565 
566  ret = ioctl(buf_to_m2mctx(avbuf)->fd, VIDIOC_QBUF, &avbuf->buf);
567  if (ret < 0)
568  return AVERROR(errno);
569 
570  avbuf->status = V4L2BUF_IN_DRIVER;
571 
572  return 0;
573 }
V4L2Buffer::num_planes
int num_planes
Definition: v4l2_buffers.h:60
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:429
V4L2Context::av_pix_fmt
enum AVPixelFormat av_pix_fmt
AVPixelFormat corresponding to this buffer context.
Definition: v4l2_context.h:54
v4l2_get_color_space
static enum AVColorSpace v4l2_get_color_space(V4L2Buffer *buf)
Definition: v4l2_buffers.c:137
ff_refstruct_ref
void * ff_refstruct_ref(void *obj)
Create a new reference to an object managed via this API, i.e.
Definition: refstruct.c:140
AVERROR
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
AVColorTransferCharacteristic
AVColorTransferCharacteristic
Color Transfer Characteristic.
Definition: pixfmt.h:611
out
FILE * out
Definition: movenc.c:55
v4l2_buffers.h
atomic_fetch_add
#define atomic_fetch_add(object, operand)
Definition: stdatomic.h:137
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3170
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
int64_t
long long int64_t
Definition: coverity.c:34
output
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
Definition: filter_design.txt:225
ff_v4l2_buffer_buf_to_avpkt
int ff_v4l2_buffer_buf_to_avpkt(AVPacket *pkt, V4L2Buffer *avbuf)
Extracts the data from a V4L2Buffer to an AVPacket.
Definition: v4l2_buffers.c:452
V4L2m2mContext
Definition: v4l2_m2m.h:43
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
V4L2Buffer::V4L2Plane_info::length
size_t length
Definition: v4l2_buffers.h:57
pixdesc.h
v4l2_set_pts
static void v4l2_set_pts(V4L2Buffer *out, int64_t pts)
Definition: v4l2_buffers.c:61
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:717
AVPacket::data
uint8_t * data
Definition: packet.h:539
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:614
data
const char data[16]
Definition: mxf.c:149
AVCOL_SPC_RGB
@ AVCOL_SPC_RGB
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB), YZX and ST 428-1
Definition: pixfmt.h:641
USEC_PER_SEC
#define USEC_PER_SEC
Definition: v4l2_buffers.c:37
atomic_fetch_sub
#define atomic_fetch_sub(object, operand)
Definition: stdatomic.h:140
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVColorPrimaries
AVColorPrimaries
Chromaticity coordinates of the source primaries.
Definition: pixfmt.h:586
logger
static AVCodecContext * logger(V4L2Buffer *buf)
Definition: v4l2_buffers.c:47
AVCOL_SPC_BT2020_CL
@ AVCOL_SPC_BT2020_CL
ITU-R BT2020 constant luminance system.
Definition: pixfmt.h:652
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:594
v4l2_get_timebase
static AVRational v4l2_get_timebase(V4L2Buffer *avbuf)
Definition: v4l2_buffers.c:52
v4l2_bufref_to_buf
static int v4l2_bufref_to_buf(V4L2Buffer *out, int plane, const uint8_t *data, int size, int offset)
Definition: v4l2_buffers.c:275
AVCOL_SPC_BT470BG
@ AVCOL_SPC_BT470BG
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601
Definition: pixfmt.h:646
AVCOL_TRC_IEC61966_2_1
@ AVCOL_TRC_IEC61966_2_1
IEC 61966-2-1 (sRGB or sYCC)
Definition: pixfmt.h:625
v4l2_buf_increase_ref
static int v4l2_buf_increase_ref(V4L2Buffer *in)
Definition: v4l2_buffers.c:237
V4L2Buffer::buf
struct v4l2_buffer buf
Definition: v4l2_buffers.h:63
ff_v4l2_buffer_buf_to_avframe
int ff_v4l2_buffer_buf_to_avframe(AVFrame *frame, V4L2Buffer *avbuf)
Extracts the data from a V4L2Buffer to an AVFrame.
Definition: v4l2_buffers.c:417
AVCOL_TRC_GAMMA28
@ AVCOL_TRC_GAMMA28
also ITU-R BT470BG
Definition: pixfmt.h:617
pts
static int64_t pts
Definition: transcode_aac.c:644
V4L2Context::streamon
int streamon
Whether the stream has been started (VIDIOC_STREAMON has been sent).
Definition: v4l2_context.h:88
refstruct.h
AVCOL_TRC_GAMMA22
@ AVCOL_TRC_GAMMA22
also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM
Definition: pixfmt.h:616
V4L2Buffer::context
struct V4L2Context * context
Definition: v4l2_buffers.h:45
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
ff_v4l2_buffer_avframe_to_buf
int ff_v4l2_buffer_avframe_to_buf(const AVFrame *frame, V4L2Buffer *out)
Extracts the data from an AVFrame to a V4L2Buffer.
Definition: v4l2_buffers.c:410
AV_PKT_FLAG_CORRUPT
#define AV_PKT_FLAG_CORRUPT
The packet content is corrupted.
Definition: packet.h:595
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:640
V4L2Buffer
V4L2Buffer (wrapper for v4l2_buffer management)
Definition: v4l2_buffers.h:43
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVCOL_TRC_BT1361_ECG
@ AVCOL_TRC_BT1361_ECG
ITU-R BT1361 Extended Colour Gamut.
Definition: pixfmt.h:624
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
AVCOL_SPC_SMPTE170M
@ AVCOL_SPC_SMPTE170M
also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above
Definition: pixfmt.h:647
V4L2BUF_RET_USER
@ V4L2BUF_RET_USER
Definition: v4l2_buffers.h:37
ctx
AVFormatContext * ctx
Definition: movenc.c:49
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
v4l2_get_color_primaries
static enum AVColorPrimaries v4l2_get_color_primaries(V4L2Buffer *buf)
Definition: v4l2_buffers.c:85
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
AVCOL_PRI_SMPTE240M
@ AVCOL_PRI_SMPTE240M
identical to above, also called "SMPTE C" even though it uses D65
Definition: pixfmt.h:595
atomic_load
#define atomic_load(object)
Definition: stdatomic.h:93
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:589
AVCOL_PRI_BT470BG
@ AVCOL_PRI_BT470BG
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
Definition: pixfmt.h:593
AVCOL_PRI_SMPTE170M
@ AVCOL_PRI_SMPTE170M
also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
Definition: pixfmt.h:594
ff_v4l2_buffer_enqueue
int ff_v4l2_buffer_enqueue(V4L2Buffer *avbuf)
Enqueues a V4L2Buffer.
Definition: v4l2_buffers.c:560
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:522
v4l2_buffer_swframe_to_buf
static int v4l2_buffer_swframe_to_buf(const AVFrame *frame, V4L2Buffer *out)
Definition: v4l2_buffers.c:339
V4L2Context
Definition: v4l2_context.h:37
NULL
#define NULL
Definition: coverity.c:32
FF_DECODE_ERROR_INVALID_BITSTREAM
#define FF_DECODE_ERROR_INVALID_BITSTREAM
Definition: frame.h:717
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
container_of
#define container_of(ptr, type, member)
Definition: v4l2_m2m.h:35
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
V4L2Context::type
enum v4l2_buf_type type
Type of this buffer context.
Definition: v4l2_context.h:48
AVCOL_PRI_BT709
@ AVCOL_PRI_BT709
also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP 177 Annex B
Definition: pixfmt.h:588
V4L2Buffer::V4L2Plane_info::mm_addr
void * mm_addr
Definition: v4l2_buffers.h:56
v4l2_get_color_range
static enum AVColorRange v4l2_get_color_range(V4L2Buffer *buf)
Definition: v4l2_buffers.c:119
atomic_fetch_sub_explicit
#define atomic_fetch_sub_explicit(object, operand, order)
Definition: stdatomic.h:152
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:683
index
int index
Definition: gxfenc.c:90
ff_v4l2_buffer_avpkt_to_buf
int ff_v4l2_buffer_avpkt_to_buf(const AVPacket *pkt, V4L2Buffer *out)
Extracts the data from an AVPacket to a V4L2Buffer.
Definition: v4l2_buffers.c:477
av_buffer_create
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.
Definition: buffer.c:55
AVCOL_PRI_BT2020
@ AVCOL_PRI_BT2020
ITU-R BT2020.
Definition: pixfmt.h:597
V4L2Buffer::context_ref
const struct V4L2m2mContext * context_ref
Definition: v4l2_buffers.h:50
V4L2BUF_AVAILABLE
@ V4L2BUF_AVAILABLE
Definition: v4l2_buffers.h:35
V4L2Context::width
int width
Width and height of the frames it produces (in case of a capture context, e.g.
Definition: v4l2_context.h:72
AVPacket::size
int size
Definition: packet.h:540
AVCOL_TRC_SMPTE240M
@ AVCOL_TRC_SMPTE240M
Definition: pixfmt.h:619
height
#define height
Definition: dsp.h:85
V4L2Buffer::plane_info
struct V4L2Buffer::V4L2Plane_info plane_info[VIDEO_MAX_PLANES]
V4L2BUF_IN_DRIVER
@ V4L2BUF_IN_DRIVER
Definition: v4l2_buffers.h:36
size
int size
Definition: twinvq_data.h:10344
atomic_fetch_add_explicit
#define atomic_fetch_add_explicit(object, operand, order)
Definition: stdatomic.h:149
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
v4l2_get_pts
static int64_t v4l2_get_pts(V4L2Buffer *avbuf)
Definition: v4l2_buffers.c:74
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:538
v4l2_timebase
static AVRational v4l2_timebase
Definition: v4l2_buffers.c:38
offset
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
Definition: writing_filters.txt:86
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:545
V4L2Buffer::context_refcount
atomic_uint context_refcount
Definition: v4l2_buffers.h:51
AVCOL_TRC_BT709
@ AVCOL_TRC_BT709
also ITU-R BT1361
Definition: pixfmt.h:613
V4L2m2mContext::avctx
AVCodecContext * avctx
Definition: v4l2_m2m.h:52
AVCOL_SPC_SMPTE240M
@ AVCOL_SPC_SMPTE240M
derived from 170M primaries and D65 white point, 170M is derived from BT470 System M's primaries
Definition: pixfmt.h:648
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:532
AVCOL_SPC_BT2020_NCL
@ AVCOL_SPC_BT2020_NCL
ITU-R BT2020 non-constant luminance system.
Definition: pixfmt.h:651
v4l2_buffer_buf_to_swframe
static int v4l2_buffer_buf_to_swframe(AVFrame *frame, V4L2Buffer *avbuf)
Definition: v4l2_buffers.c:298
AVColorSpace
AVColorSpace
YUV colorspace type.
Definition: pixfmt.h:640
V4L2Buffer::flags
int flags
Definition: v4l2_buffers.h:66
V4L2Buffer::planes
struct v4l2_plane planes[VIDEO_MAX_PLANES]
Definition: v4l2_buffers.h:64
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
V4L2Buffer::V4L2Plane_info::bytesperline
int bytesperline
Definition: v4l2_buffers.h:55
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:622
AV_PIX_FMT_NV21
@ AV_PIX_FMT_NV21
as above, but U and V bytes are swapped
Definition: pixfmt.h:97
v4l2_context.h
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:643
v4l2_buf_to_bufref
static int v4l2_buf_to_bufref(V4L2Buffer *in, int plane, AVBufferRef **buf)
Definition: v4l2_buffers.c:255
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:700
avcodec.h
AVCOL_PRI_BT470M
@ AVCOL_PRI_BT470M
also FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
Definition: pixfmt.h:591
ret
ret
Definition: filter_design.txt:187
AV_PIX_FMT_NV12
@ AV_PIX_FMT_NV12
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:96
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
buf_to_m2mctx
static V4L2m2mContext * buf_to_m2mctx(V4L2Buffer *buf)
Definition: v4l2_buffers.c:40
V4L2Context::height
int height
Definition: v4l2_context.h:72
AVCodecContext
main external API structure.
Definition: avcodec.h:451
AVCOL_SPC_FCC
@ AVCOL_SPC_FCC
FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
Definition: pixfmt.h:645
sem_post
#define sem_post(psem)
Definition: semaphore.h:26
AVCOL_TRC_SMPTE170M
@ AVCOL_TRC_SMPTE170M
also ITU-R BT601-6 525 or 625 / ITU-R BT1358 525 or 625 / ITU-R BT1700 NTSC
Definition: pixfmt.h:618
v4l2_free_buffer
static void v4l2_free_buffer(void *opaque, uint8_t *unused)
Definition: v4l2_buffers.c:213
V4L2Context::name
const char * name
context name.
Definition: v4l2_context.h:41
desc
const char * desc
Definition: libsvtav1.c:79
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
AVPacket
This structure stores compressed data.
Definition: packet.h:516
V4L2Context::format
struct v4l2_format format
Format returned by the driver after initializing the buffer context.
Definition: v4l2_context.h:66
v4l2_m2m.h
ff_v4l2_buffer_initialize
int ff_v4l2_buffer_initialize(V4L2Buffer *avbuf, int index)
Initializes a V4L2Buffer.
Definition: v4l2_buffers.c:493
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
v4l2_get_color_trc
static enum AVColorTransferCharacteristic v4l2_get_color_trc(V4L2Buffer *buf)
Definition: v4l2_buffers.c:169
h
h
Definition: vp9dsp_template.c:2070
AVCOL_SPC_BT709
@ AVCOL_SPC_BT709
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / derived in SMPTE RP 177 Annex B
Definition: pixfmt.h:642
AVColorRange
AVColorRange
Visual content value range.
Definition: pixfmt.h:682
V4L2Context::sample_aspect_ratio
AVRational sample_aspect_ratio
Definition: v4l2_context.h:73
ff_refstruct_unref
void ff_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition: refstruct.c:120
V4L2Buffer::status
enum V4L2Buffer_status status
Definition: v4l2_buffers.h:67