FFmpeg
frame.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 #include "channel_layout.h"
20 #include "avassert.h"
21 #include "buffer.h"
22 #include "common.h"
23 #include "cpu.h"
24 #include "dict.h"
25 #include "frame.h"
26 #include "imgutils.h"
27 #include "mem.h"
28 #include "samplefmt.h"
29 #include "hwcontext.h"
30 
31 #if FF_API_OLD_CHANNEL_LAYOUT
32 #define CHECK_CHANNELS_CONSISTENCY(frame) \
33  av_assert2(!(frame)->channel_layout || \
34  (frame)->channels == \
35  av_get_channel_layout_nb_channels((frame)->channel_layout))
36 #endif
37 
38 static void get_frame_defaults(AVFrame *frame)
39 {
40  memset(frame, 0, sizeof(*frame));
41 
42  frame->pts =
43  frame->pkt_dts = AV_NOPTS_VALUE;
44  frame->best_effort_timestamp = AV_NOPTS_VALUE;
45  frame->duration = 0;
46 #if FF_API_PKT_DURATION
47 FF_DISABLE_DEPRECATION_WARNINGS
48  frame->pkt_duration = 0;
49 FF_ENABLE_DEPRECATION_WARNINGS
50 #endif
51 #if FF_API_FRAME_PKT
52 FF_DISABLE_DEPRECATION_WARNINGS
53  frame->pkt_pos = -1;
54  frame->pkt_size = -1;
55 FF_ENABLE_DEPRECATION_WARNINGS
56 #endif
57  frame->time_base = (AVRational){ 0, 1 };
58  frame->key_frame = 1;
59  frame->sample_aspect_ratio = (AVRational){ 0, 1 };
60  frame->format = -1; /* unknown */
61  frame->extended_data = frame->data;
62  frame->color_primaries = AVCOL_PRI_UNSPECIFIED;
63  frame->color_trc = AVCOL_TRC_UNSPECIFIED;
64  frame->colorspace = AVCOL_SPC_UNSPECIFIED;
65  frame->color_range = AVCOL_RANGE_UNSPECIFIED;
66  frame->chroma_location = AVCHROMA_LOC_UNSPECIFIED;
67  frame->flags = 0;
68 }
69 
70 static void free_side_data(AVFrameSideData **ptr_sd)
71 {
72  AVFrameSideData *sd = *ptr_sd;
73 
74  av_buffer_unref(&sd->buf);
75  av_dict_free(&sd->metadata);
76  av_freep(ptr_sd);
77 }
78 
79 static void wipe_side_data(AVFrame *frame)
80 {
81  int i;
82 
83  for (i = 0; i < frame->nb_side_data; i++) {
84  free_side_data(&frame->side_data[i]);
85  }
86  frame->nb_side_data = 0;
87 
88  av_freep(&frame->side_data);
89 }
90 
91 AVFrame *av_frame_alloc(void)
92 {
93  AVFrame *frame = av_malloc(sizeof(*frame));
94 
95  if (!frame)
96  return NULL;
97 
98  get_frame_defaults(frame);
99 
100  return frame;
101 }
102 
103 void av_frame_free(AVFrame **frame)
104 {
105  if (!frame || !*frame)
106  return;
107 
108  av_frame_unref(*frame);
109  av_freep(frame);
110 }
111 
112 static int get_video_buffer(AVFrame *frame, int align)
113 {
114  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
115  int ret, i, padded_height, total_size;
116  int plane_padding = FFMAX(16 + 16/*STRIDE_ALIGN*/, align);
117  ptrdiff_t linesizes[4];
118  size_t sizes[4];
119 
120  if (!desc)
121  return AVERROR(EINVAL);
122 
123  if ((ret = av_image_check_size(frame->width, frame->height, 0, NULL)) < 0)
124  return ret;
125 
126  if (!frame->linesize[0]) {
127  if (align <= 0)
128  align = 32; /* STRIDE_ALIGN. Should be av_cpu_max_align() */
129 
130  for(i=1; i<=align; i+=i) {
131  ret = av_image_fill_linesizes(frame->linesize, frame->format,
132  FFALIGN(frame->width, i));
133  if (ret < 0)
134  return ret;
135  if (!(frame->linesize[0] & (align-1)))
136  break;
137  }
138 
139  for (i = 0; i < 4 && frame->linesize[i]; i++)
140  frame->linesize[i] = FFALIGN(frame->linesize[i], align);
141  }
142 
143  for (i = 0; i < 4; i++)
144  linesizes[i] = frame->linesize[i];
145 
146  padded_height = FFALIGN(frame->height, 32);
147  if ((ret = av_image_fill_plane_sizes(sizes, frame->format,
148  padded_height, linesizes)) < 0)
149  return ret;
150 
151  total_size = 4*plane_padding;
152  for (i = 0; i < 4; i++) {
153  if (sizes[i] > INT_MAX - total_size)
154  return AVERROR(EINVAL);
155  total_size += sizes[i];
156  }
157 
158  frame->buf[0] = av_buffer_alloc(total_size);
159  if (!frame->buf[0]) {
160  ret = AVERROR(ENOMEM);
161  goto fail;
162  }
163 
164  if ((ret = av_image_fill_pointers(frame->data, frame->format, padded_height,
165  frame->buf[0]->data, frame->linesize)) < 0)
166  goto fail;
167 
168  for (i = 1; i < 4; i++) {
169  if (frame->data[i])
170  frame->data[i] += i * plane_padding;
171  }
172 
173  frame->extended_data = frame->data;
174 
175  return 0;
176 fail:
177  av_frame_unref(frame);
178  return ret;
179 }
180 
181 static int get_audio_buffer(AVFrame *frame, int align)
182 {
183  int planar = av_sample_fmt_is_planar(frame->format);
184  int channels, planes;
185  int ret, i;
186 
187 #if FF_API_OLD_CHANNEL_LAYOUT
188 FF_DISABLE_DEPRECATION_WARNINGS
189  if (!frame->ch_layout.nb_channels) {
190  if (frame->channel_layout) {
191  av_channel_layout_from_mask(&frame->ch_layout, frame->channel_layout);
192  } else {
193  frame->ch_layout.nb_channels = frame->channels;
194  frame->ch_layout.order = AV_CHANNEL_ORDER_UNSPEC;
195  }
196  }
197  frame->channels = frame->ch_layout.nb_channels;
198  frame->channel_layout = frame->ch_layout.order == AV_CHANNEL_ORDER_NATIVE ?
199  frame->ch_layout.u.mask : 0;
200 FF_ENABLE_DEPRECATION_WARNINGS
201 #endif
202  channels = frame->ch_layout.nb_channels;
203  planes = planar ? channels : 1;
204  if (!frame->linesize[0]) {
205  ret = av_samples_get_buffer_size(&frame->linesize[0], channels,
206  frame->nb_samples, frame->format,
207  align);
208  if (ret < 0)
209  return ret;
210  }
211 
212  if (planes > AV_NUM_DATA_POINTERS) {
213  frame->extended_data = av_calloc(planes,
214  sizeof(*frame->extended_data));
215  frame->extended_buf = av_calloc(planes - AV_NUM_DATA_POINTERS,
216  sizeof(*frame->extended_buf));
217  if (!frame->extended_data || !frame->extended_buf) {
218  av_freep(&frame->extended_data);
219  av_freep(&frame->extended_buf);
220  return AVERROR(ENOMEM);
221  }
222  frame->nb_extended_buf = planes - AV_NUM_DATA_POINTERS;
223  } else
224  frame->extended_data = frame->data;
225 
226  for (i = 0; i < FFMIN(planes, AV_NUM_DATA_POINTERS); i++) {
227  frame->buf[i] = av_buffer_alloc(frame->linesize[0]);
228  if (!frame->buf[i]) {
229  av_frame_unref(frame);
230  return AVERROR(ENOMEM);
231  }
232  frame->extended_data[i] = frame->data[i] = frame->buf[i]->data;
233  }
234  for (i = 0; i < planes - AV_NUM_DATA_POINTERS; i++) {
235  frame->extended_buf[i] = av_buffer_alloc(frame->linesize[0]);
236  if (!frame->extended_buf[i]) {
237  av_frame_unref(frame);
238  return AVERROR(ENOMEM);
239  }
240  frame->extended_data[i + AV_NUM_DATA_POINTERS] = frame->extended_buf[i]->data;
241  }
242  return 0;
243 
244 }
245 
246 int av_frame_get_buffer(AVFrame *frame, int align)
247 {
248  if (frame->format < 0)
249  return AVERROR(EINVAL);
250 
251 FF_DISABLE_DEPRECATION_WARNINGS
252  if (frame->width > 0 && frame->height > 0)
253  return get_video_buffer(frame, align);
254  else if (frame->nb_samples > 0 &&
255  (av_channel_layout_check(&frame->ch_layout)
256 #if FF_API_OLD_CHANNEL_LAYOUT
257  || frame->channel_layout || frame->channels > 0
258 #endif
259  ))
260  return get_audio_buffer(frame, align);
261 FF_ENABLE_DEPRECATION_WARNINGS
262 
263  return AVERROR(EINVAL);
264 }
265 
266 static int frame_copy_props(AVFrame *dst, const AVFrame *src, int force_copy)
267 {
268  int ret, i;
269 
270  dst->key_frame = src->key_frame;
271  dst->pict_type = src->pict_type;
272  dst->sample_aspect_ratio = src->sample_aspect_ratio;
273  dst->crop_top = src->crop_top;
274  dst->crop_bottom = src->crop_bottom;
275  dst->crop_left = src->crop_left;
276  dst->crop_right = src->crop_right;
277  dst->pts = src->pts;
278  dst->duration = src->duration;
279  dst->repeat_pict = src->repeat_pict;
280  dst->interlaced_frame = src->interlaced_frame;
281  dst->top_field_first = src->top_field_first;
282  dst->palette_has_changed = src->palette_has_changed;
283  dst->sample_rate = src->sample_rate;
284  dst->opaque = src->opaque;
285  dst->pkt_dts = src->pkt_dts;
286 #if FF_API_FRAME_PKT
287 FF_DISABLE_DEPRECATION_WARNINGS
288  dst->pkt_pos = src->pkt_pos;
289  dst->pkt_size = src->pkt_size;
290 FF_ENABLE_DEPRECATION_WARNINGS
291 #endif
292 #if FF_API_PKT_DURATION
293 FF_DISABLE_DEPRECATION_WARNINGS
294  dst->pkt_duration = src->pkt_duration;
295 FF_ENABLE_DEPRECATION_WARNINGS
296 #endif
297  dst->time_base = src->time_base;
298 #if FF_API_REORDERED_OPAQUE
299 FF_DISABLE_DEPRECATION_WARNINGS
300  dst->reordered_opaque = src->reordered_opaque;
301 FF_ENABLE_DEPRECATION_WARNINGS
302 #endif
303  dst->quality = src->quality;
304  dst->best_effort_timestamp = src->best_effort_timestamp;
305 #if FF_API_FRAME_PICTURE_NUMBER
306 FF_DISABLE_DEPRECATION_WARNINGS
307  dst->coded_picture_number = src->coded_picture_number;
308  dst->display_picture_number = src->display_picture_number;
309 FF_ENABLE_DEPRECATION_WARNINGS
310 #endif
311  dst->flags = src->flags;
312  dst->decode_error_flags = src->decode_error_flags;
313  dst->color_primaries = src->color_primaries;
314  dst->color_trc = src->color_trc;
315  dst->colorspace = src->colorspace;
316  dst->color_range = src->color_range;
317  dst->chroma_location = src->chroma_location;
318 
319  av_dict_copy(&dst->metadata, src->metadata, 0);
320 
321  for (i = 0; i < src->nb_side_data; i++) {
322  const AVFrameSideData *sd_src = src->side_data[i];
323  AVFrameSideData *sd_dst;
324  if ( sd_src->type == AV_FRAME_DATA_PANSCAN
325  && (src->width != dst->width || src->height != dst->height))
326  continue;
327  if (force_copy) {
328  sd_dst = av_frame_new_side_data(dst, sd_src->type,
329  sd_src->size);
330  if (!sd_dst) {
331  wipe_side_data(dst);
332  return AVERROR(ENOMEM);
333  }
334  memcpy(sd_dst->data, sd_src->data, sd_src->size);
335  } else {
336  AVBufferRef *ref = av_buffer_ref(sd_src->buf);
337  sd_dst = av_frame_new_side_data_from_buf(dst, sd_src->type, ref);
338  if (!sd_dst) {
339  av_buffer_unref(&ref);
340  wipe_side_data(dst);
341  return AVERROR(ENOMEM);
342  }
343  }
344  av_dict_copy(&sd_dst->metadata, sd_src->metadata, 0);
345  }
346 
347  ret = av_buffer_replace(&dst->opaque_ref, src->opaque_ref);
348  ret |= av_buffer_replace(&dst->private_ref, src->private_ref);
349  return ret;
350 }
351 
352 int av_frame_ref(AVFrame *dst, const AVFrame *src)
353 {
354  int i, ret = 0;
355 
356  av_assert1(dst->width == 0 && dst->height == 0);
357 #if FF_API_OLD_CHANNEL_LAYOUT
358 FF_DISABLE_DEPRECATION_WARNINGS
359  av_assert1(dst->channels == 0);
360 FF_ENABLE_DEPRECATION_WARNINGS
361 #endif
362  av_assert1(dst->ch_layout.nb_channels == 0 &&
363  dst->ch_layout.order == AV_CHANNEL_ORDER_UNSPEC);
364 
365  dst->format = src->format;
366  dst->width = src->width;
367  dst->height = src->height;
368  dst->nb_samples = src->nb_samples;
369 #if FF_API_OLD_CHANNEL_LAYOUT
370 FF_DISABLE_DEPRECATION_WARNINGS
371  dst->channels = src->channels;
372  dst->channel_layout = src->channel_layout;
373  if (!av_channel_layout_check(&src->ch_layout)) {
374  if (src->channel_layout)
375  av_channel_layout_from_mask(&dst->ch_layout, src->channel_layout);
376  else {
377  dst->ch_layout.nb_channels = src->channels;
378  dst->ch_layout.order = AV_CHANNEL_ORDER_UNSPEC;
379  }
380  }
381 FF_ENABLE_DEPRECATION_WARNINGS
382 #endif
383 
384  ret = frame_copy_props(dst, src, 0);
385  if (ret < 0)
386  goto fail;
387 
388  // this check is needed only until FF_API_OLD_CHANNEL_LAYOUT is out
389  if (av_channel_layout_check(&src->ch_layout)) {
390  ret = av_channel_layout_copy(&dst->ch_layout, &src->ch_layout);
391  if (ret < 0)
392  goto fail;
393  }
394 
395  /* duplicate the frame data if it's not refcounted */
396  if (!src->buf[0]) {
397  ret = av_frame_get_buffer(dst, 0);
398  if (ret < 0)
399  goto fail;
400 
401  ret = av_frame_copy(dst, src);
402  if (ret < 0)
403  goto fail;
404 
405  return 0;
406  }
407 
408  /* ref the buffers */
409  for (i = 0; i < FF_ARRAY_ELEMS(src->buf); i++) {
410  if (!src->buf[i])
411  continue;
412  dst->buf[i] = av_buffer_ref(src->buf[i]);
413  if (!dst->buf[i]) {
414  ret = AVERROR(ENOMEM);
415  goto fail;
416  }
417  }
418 
419  if (src->extended_buf) {
420  dst->extended_buf = av_calloc(src->nb_extended_buf,
421  sizeof(*dst->extended_buf));
422  if (!dst->extended_buf) {
423  ret = AVERROR(ENOMEM);
424  goto fail;
425  }
426  dst->nb_extended_buf = src->nb_extended_buf;
427 
428  for (i = 0; i < src->nb_extended_buf; i++) {
429  dst->extended_buf[i] = av_buffer_ref(src->extended_buf[i]);
430  if (!dst->extended_buf[i]) {
431  ret = AVERROR(ENOMEM);
432  goto fail;
433  }
434  }
435  }
436 
437  if (src->hw_frames_ctx) {
438  dst->hw_frames_ctx = av_buffer_ref(src->hw_frames_ctx);
439  if (!dst->hw_frames_ctx) {
440  ret = AVERROR(ENOMEM);
441  goto fail;
442  }
443  }
444 
445  /* duplicate extended data */
446  if (src->extended_data != src->data) {
447  int ch = dst->ch_layout.nb_channels;
448 
449  if (!ch) {
450  ret = AVERROR(EINVAL);
451  goto fail;
452  }
453 
454  dst->extended_data = av_malloc_array(sizeof(*dst->extended_data), ch);
455  if (!dst->extended_data) {
456  ret = AVERROR(ENOMEM);
457  goto fail;
458  }
459  memcpy(dst->extended_data, src->extended_data, sizeof(*src->extended_data) * ch);
460  } else
461  dst->extended_data = dst->data;
462 
463  memcpy(dst->data, src->data, sizeof(src->data));
464  memcpy(dst->linesize, src->linesize, sizeof(src->linesize));
465 
466  return 0;
467 
468 fail:
469  av_frame_unref(dst);
470  return ret;
471 }
472 
473 AVFrame *av_frame_clone(const AVFrame *src)
474 {
475  AVFrame *ret = av_frame_alloc();
476 
477  if (!ret)
478  return NULL;
479 
480  if (av_frame_ref(ret, src) < 0)
481  av_frame_free(&ret);
482 
483  return ret;
484 }
485 
486 void av_frame_unref(AVFrame *frame)
487 {
488  int i;
489 
490  if (!frame)
491  return;
492 
493  wipe_side_data(frame);
494 
495  for (i = 0; i < FF_ARRAY_ELEMS(frame->buf); i++)
496  av_buffer_unref(&frame->buf[i]);
497  for (i = 0; i < frame->nb_extended_buf; i++)
498  av_buffer_unref(&frame->extended_buf[i]);
499  av_freep(&frame->extended_buf);
500  av_dict_free(&frame->metadata);
501 
502  av_buffer_unref(&frame->hw_frames_ctx);
503 
504  av_buffer_unref(&frame->opaque_ref);
505  av_buffer_unref(&frame->private_ref);
506 
507  if (frame->extended_data != frame->data)
508  av_freep(&frame->extended_data);
509 
510  av_channel_layout_uninit(&frame->ch_layout);
511 
512  get_frame_defaults(frame);
513 }
514 
515 void av_frame_move_ref(AVFrame *dst, AVFrame *src)
516 {
517  av_assert1(dst->width == 0 && dst->height == 0);
518 #if FF_API_OLD_CHANNEL_LAYOUT
519 FF_DISABLE_DEPRECATION_WARNINGS
520  av_assert1(dst->channels == 0);
521 FF_ENABLE_DEPRECATION_WARNINGS
522 #endif
523  av_assert1(dst->ch_layout.nb_channels == 0 &&
524  dst->ch_layout.order == AV_CHANNEL_ORDER_UNSPEC);
525 
526  *dst = *src;
527  if (src->extended_data == src->data)
528  dst->extended_data = dst->data;
529  get_frame_defaults(src);
530 }
531 
532 int av_frame_is_writable(AVFrame *frame)
533 {
534  int i, ret = 1;
535 
536  /* assume non-refcounted frames are not writable */
537  if (!frame->buf[0])
538  return 0;
539 
540  for (i = 0; i < FF_ARRAY_ELEMS(frame->buf); i++)
541  if (frame->buf[i])
542  ret &= !!av_buffer_is_writable(frame->buf[i]);
543  for (i = 0; i < frame->nb_extended_buf; i++)
544  ret &= !!av_buffer_is_writable(frame->extended_buf[i]);
545 
546  return ret;
547 }
548 
549 int av_frame_make_writable(AVFrame *frame)
550 {
551  AVFrame tmp;
552  int ret;
553 
554  if (av_frame_is_writable(frame))
555  return 0;
556 
557  memset(&tmp, 0, sizeof(tmp));
558  tmp.format = frame->format;
559  tmp.width = frame->width;
560  tmp.height = frame->height;
561 #if FF_API_OLD_CHANNEL_LAYOUT
562 FF_DISABLE_DEPRECATION_WARNINGS
563  tmp.channels = frame->channels;
564  tmp.channel_layout = frame->channel_layout;
565 FF_ENABLE_DEPRECATION_WARNINGS
566 #endif
567  tmp.nb_samples = frame->nb_samples;
568  ret = av_channel_layout_copy(&tmp.ch_layout, &frame->ch_layout);
569  if (ret < 0) {
570  av_frame_unref(&tmp);
571  return ret;
572  }
573 
574  if (frame->hw_frames_ctx)
575  ret = av_hwframe_get_buffer(frame->hw_frames_ctx, &tmp, 0);
576  else
577  ret = av_frame_get_buffer(&tmp, 0);
578  if (ret < 0)
579  return ret;
580 
581  ret = av_frame_copy(&tmp, frame);
582  if (ret < 0) {
583  av_frame_unref(&tmp);
584  return ret;
585  }
586 
587  ret = av_frame_copy_props(&tmp, frame);
588  if (ret < 0) {
589  av_frame_unref(&tmp);
590  return ret;
591  }
592 
593  av_frame_unref(frame);
594 
595  *frame = tmp;
596  if (tmp.data == tmp.extended_data)
597  frame->extended_data = frame->data;
598 
599  return 0;
600 }
601 
602 int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
603 {
604  return frame_copy_props(dst, src, 1);
605 }
606 
607 AVBufferRef *av_frame_get_plane_buffer(AVFrame *frame, int plane)
608 {
609  uint8_t *data;
610  int planes, i;
611 
612  if (frame->nb_samples) {
613  int channels = frame->ch_layout.nb_channels;
614 
615 #if FF_API_OLD_CHANNEL_LAYOUT
616 FF_DISABLE_DEPRECATION_WARNINGS
617  if (!channels) {
618  channels = frame->channels;
619  CHECK_CHANNELS_CONSISTENCY(frame);
620  }
621 FF_ENABLE_DEPRECATION_WARNINGS
622 #endif
623  if (!channels)
624  return NULL;
625  planes = av_sample_fmt_is_planar(frame->format) ? channels : 1;
626  } else
627  planes = 4;
628 
629  if (plane < 0 || plane >= planes || !frame->extended_data[plane])
630  return NULL;
631  data = frame->extended_data[plane];
632 
633  for (i = 0; i < FF_ARRAY_ELEMS(frame->buf) && frame->buf[i]; i++) {
634  AVBufferRef *buf = frame->buf[i];
635  if (data >= buf->data && data < buf->data + buf->size)
636  return buf;
637  }
638  for (i = 0; i < frame->nb_extended_buf; i++) {
639  AVBufferRef *buf = frame->extended_buf[i];
640  if (data >= buf->data && data < buf->data + buf->size)
641  return buf;
642  }
643  return NULL;
644 }
645 
646 AVFrameSideData *av_frame_new_side_data_from_buf(AVFrame *frame,
647  enum AVFrameSideDataType type,
648  AVBufferRef *buf)
649 {
650  AVFrameSideData *ret, **tmp;
651 
652  if (!buf)
653  return NULL;
654 
655  if (frame->nb_side_data > INT_MAX / sizeof(*frame->side_data) - 1)
656  return NULL;
657 
658  tmp = av_realloc(frame->side_data,
659  (frame->nb_side_data + 1) * sizeof(*frame->side_data));
660  if (!tmp)
661  return NULL;
662  frame->side_data = tmp;
663 
664  ret = av_mallocz(sizeof(*ret));
665  if (!ret)
666  return NULL;
667 
668  ret->buf = buf;
669  ret->data = ret->buf->data;
670  ret->size = buf->size;
671  ret->type = type;
672 
673  frame->side_data[frame->nb_side_data++] = ret;
674 
675  return ret;
676 }
677 
678 AVFrameSideData *av_frame_new_side_data(AVFrame *frame,
679  enum AVFrameSideDataType type,
680  size_t size)
681 {
682  AVFrameSideData *ret;
683  AVBufferRef *buf = av_buffer_alloc(size);
684  ret = av_frame_new_side_data_from_buf(frame, type, buf);
685  if (!ret)
686  av_buffer_unref(&buf);
687  return ret;
688 }
689 
690 AVFrameSideData *av_frame_get_side_data(const AVFrame *frame,
691  enum AVFrameSideDataType type)
692 {
693  int i;
694 
695  for (i = 0; i < frame->nb_side_data; i++) {
696  if (frame->side_data[i]->type == type)
697  return frame->side_data[i];
698  }
699  return NULL;
700 }
701 
702 static int frame_copy_video(AVFrame *dst, const AVFrame *src)
703 {
704  const uint8_t *src_data[4];
705  int i, planes;
706 
707  if (dst->width < src->width ||
708  dst->height < src->height)
709  return AVERROR(EINVAL);
710 
711  if (src->hw_frames_ctx || dst->hw_frames_ctx)
712  return av_hwframe_transfer_data(dst, src, 0);
713 
714  planes = av_pix_fmt_count_planes(dst->format);
715  for (i = 0; i < planes; i++)
716  if (!dst->data[i] || !src->data[i])
717  return AVERROR(EINVAL);
718 
719  memcpy(src_data, src->data, sizeof(src_data));
720  av_image_copy(dst->data, dst->linesize,
721  src_data, src->linesize,
722  dst->format, src->width, src->height);
723 
724  return 0;
725 }
726 
727 static int frame_copy_audio(AVFrame *dst, const AVFrame *src)
728 {
729  int planar = av_sample_fmt_is_planar(dst->format);
730  int channels = dst->ch_layout.nb_channels;
731  int planes = planar ? channels : 1;
732  int i;
733 
734 #if FF_API_OLD_CHANNEL_LAYOUT
735 FF_DISABLE_DEPRECATION_WARNINGS
736  if (!channels || !src->ch_layout.nb_channels) {
737  if (dst->channels != src->channels ||
738  dst->channel_layout != src->channel_layout)
739  return AVERROR(EINVAL);
740  CHECK_CHANNELS_CONSISTENCY(src);
741  }
742  if (!channels) {
743  channels = dst->channels;
744  planes = planar ? channels : 1;
745  }
746 FF_ENABLE_DEPRECATION_WARNINGS
747 #endif
748 
749  if (dst->nb_samples != src->nb_samples ||
750 #if FF_API_OLD_CHANNEL_LAYOUT
751  (av_channel_layout_check(&dst->ch_layout) &&
752  av_channel_layout_check(&src->ch_layout) &&
753 #endif
754  av_channel_layout_compare(&dst->ch_layout, &src->ch_layout))
755 #if FF_API_OLD_CHANNEL_LAYOUT
756  )
757 #endif
758  return AVERROR(EINVAL);
759 
760  for (i = 0; i < planes; i++)
761  if (!dst->extended_data[i] || !src->extended_data[i])
762  return AVERROR(EINVAL);
763 
764  av_samples_copy(dst->extended_data, src->extended_data, 0, 0,
765  dst->nb_samples, channels, dst->format);
766 
767  return 0;
768 }
769 
770 int av_frame_copy(AVFrame *dst, const AVFrame *src)
771 {
772  if (dst->format != src->format || dst->format < 0)
773  return AVERROR(EINVAL);
774 
775 FF_DISABLE_DEPRECATION_WARNINGS
776  if (dst->width > 0 && dst->height > 0)
777  return frame_copy_video(dst, src);
778  else if (dst->nb_samples > 0 &&
779  (av_channel_layout_check(&dst->ch_layout)
780 #if FF_API_OLD_CHANNEL_LAYOUT
781  || dst->channels > 0
782 #endif
783  ))
784  return frame_copy_audio(dst, src);
785 FF_ENABLE_DEPRECATION_WARNINGS
786 
787  return AVERROR(EINVAL);
788 }
789 
790 void av_frame_remove_side_data(AVFrame *frame, enum AVFrameSideDataType type)
791 {
792  int i;
793 
794  for (i = frame->nb_side_data - 1; i >= 0; i--) {
795  AVFrameSideData *sd = frame->side_data[i];
796  if (sd->type == type) {
797  free_side_data(&frame->side_data[i]);
798  frame->side_data[i] = frame->side_data[frame->nb_side_data - 1];
799  frame->nb_side_data--;
800  }
801  }
802 }
803 
804 const char *av_frame_side_data_name(enum AVFrameSideDataType type)
805 {
806  switch(type) {
807  case AV_FRAME_DATA_PANSCAN: return "AVPanScan";
808  case AV_FRAME_DATA_A53_CC: return "ATSC A53 Part 4 Closed Captions";
809  case AV_FRAME_DATA_STEREO3D: return "Stereo 3D";
810  case AV_FRAME_DATA_MATRIXENCODING: return "AVMatrixEncoding";
811  case AV_FRAME_DATA_DOWNMIX_INFO: return "Metadata relevant to a downmix procedure";
812  case AV_FRAME_DATA_REPLAYGAIN: return "AVReplayGain";
813  case AV_FRAME_DATA_DISPLAYMATRIX: return "3x3 displaymatrix";
814  case AV_FRAME_DATA_AFD: return "Active format description";
815  case AV_FRAME_DATA_MOTION_VECTORS: return "Motion vectors";
816  case AV_FRAME_DATA_SKIP_SAMPLES: return "Skip samples";
817  case AV_FRAME_DATA_AUDIO_SERVICE_TYPE: return "Audio service type";
818  case AV_FRAME_DATA_MASTERING_DISPLAY_METADATA: return "Mastering display metadata";
819  case AV_FRAME_DATA_CONTENT_LIGHT_LEVEL: return "Content light level metadata";
820  case AV_FRAME_DATA_GOP_TIMECODE: return "GOP timecode";
821  case AV_FRAME_DATA_S12M_TIMECODE: return "SMPTE 12-1 timecode";
822  case AV_FRAME_DATA_SPHERICAL: return "Spherical Mapping";
823  case AV_FRAME_DATA_ICC_PROFILE: return "ICC profile";
824  case AV_FRAME_DATA_DYNAMIC_HDR_PLUS: return "HDR Dynamic Metadata SMPTE2094-40 (HDR10+)";
825  case AV_FRAME_DATA_DYNAMIC_HDR_VIVID: return "HDR Dynamic Metadata CUVA 005.1 2021 (Vivid)";
826  case AV_FRAME_DATA_REGIONS_OF_INTEREST: return "Regions Of Interest";
827  case AV_FRAME_DATA_VIDEO_ENC_PARAMS: return "Video encoding parameters";
828  case AV_FRAME_DATA_SEI_UNREGISTERED: return "H.26[45] User Data Unregistered SEI message";
829  case AV_FRAME_DATA_FILM_GRAIN_PARAMS: return "Film grain parameters";
830  case AV_FRAME_DATA_DETECTION_BBOXES: return "Bounding boxes for object detection and classification";
831  case AV_FRAME_DATA_DOVI_RPU_BUFFER: return "Dolby Vision RPU Data";
832  case AV_FRAME_DATA_DOVI_METADATA: return "Dolby Vision Metadata";
833  case AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT: return "Ambient viewing environment";
834  }
835  return NULL;
836 }
837 
838 static int calc_cropping_offsets(size_t offsets[4], const AVFrame *frame,
839  const AVPixFmtDescriptor *desc)
840 {
841  int i, j;
842 
843  for (i = 0; frame->data[i]; i++) {
844  const AVComponentDescriptor *comp = NULL;
845  int shift_x = (i == 1 || i == 2) ? desc->log2_chroma_w : 0;
846  int shift_y = (i == 1 || i == 2) ? desc->log2_chroma_h : 0;
847 
848  if (desc->flags & AV_PIX_FMT_FLAG_PAL && i == 1) {
849  offsets[i] = 0;
850  break;
851  }
852 
853  /* find any component descriptor for this plane */
854  for (j = 0; j < desc->nb_components; j++) {
855  if (desc->comp[j].plane == i) {
856  comp = &desc->comp[j];
857  break;
858  }
859  }
860  if (!comp)
861  return AVERROR_BUG;
862 
863  offsets[i] = (frame->crop_top >> shift_y) * frame->linesize[i] +
864  (frame->crop_left >> shift_x) * comp->step;
865  }
866 
867  return 0;
868 }
869 
870 int av_frame_apply_cropping(AVFrame *frame, int flags)
871 {
872  const AVPixFmtDescriptor *desc;
873  size_t offsets[4];
874  int i;
875 
876  if (!(frame->width > 0 && frame->height > 0))
877  return AVERROR(EINVAL);
878 
879  if (frame->crop_left >= INT_MAX - frame->crop_right ||
880  frame->crop_top >= INT_MAX - frame->crop_bottom ||
881  (frame->crop_left + frame->crop_right) >= frame->width ||
882  (frame->crop_top + frame->crop_bottom) >= frame->height)
883  return AVERROR(ERANGE);
884 
885  desc = av_pix_fmt_desc_get(frame->format);
886  if (!desc)
887  return AVERROR_BUG;
888 
889  /* Apply just the right/bottom cropping for hwaccel formats. Bitstream
890  * formats cannot be easily handled here either (and corresponding decoders
891  * should not export any cropping anyway), so do the same for those as well.
892  * */
893  if (desc->flags & (AV_PIX_FMT_FLAG_BITSTREAM | AV_PIX_FMT_FLAG_HWACCEL)) {
894  frame->width -= frame->crop_right;
895  frame->height -= frame->crop_bottom;
896  frame->crop_right = 0;
897  frame->crop_bottom = 0;
898  return 0;
899  }
900 
901  /* calculate the offsets for each plane */
902  calc_cropping_offsets(offsets, frame, desc);
903 
904  /* adjust the offsets to avoid breaking alignment */
905  if (!(flags & AV_FRAME_CROP_UNALIGNED)) {
906  int log2_crop_align = frame->crop_left ? ff_ctz(frame->crop_left) : INT_MAX;
907  int min_log2_align = INT_MAX;
908 
909  for (i = 0; frame->data[i]; i++) {
910  int log2_align = offsets[i] ? ff_ctz(offsets[i]) : INT_MAX;
911  min_log2_align = FFMIN(log2_align, min_log2_align);
912  }
913 
914  /* we assume, and it should always be true, that the data alignment is
915  * related to the cropping alignment by a constant power-of-2 factor */
916  if (log2_crop_align < min_log2_align)
917  return AVERROR_BUG;
918 
919  if (min_log2_align < 5) {
920  frame->crop_left &= ~((1 << (5 + log2_crop_align - min_log2_align)) - 1);
921  calc_cropping_offsets(offsets, frame, desc);
922  }
923  }
924 
925  for (i = 0; frame->data[i]; i++)
926  frame->data[i] += offsets[i];
927 
928  frame->width -= (frame->crop_left + frame->crop_right);
929  frame->height -= (frame->crop_top + frame->crop_bottom);
930  frame->crop_left = 0;
931  frame->crop_right = 0;
932  frame->crop_top = 0;
933  frame->crop_bottom = 0;
934 
935  return 0;
936 }
AVFrame::extended_buf
AVBufferRef ** extended_buf
For planar audio which requires more than AV_NUM_DATA_POINTERS AVBufferRef pointers,...
Definition: frame.h:564
AVFrame::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: frame.h:607
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:82
free_side_data
static void free_side_data(AVFrameSideData **ptr_sd)
Definition: frame.c:70
AVFrame::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: frame.h:603
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
get_video_buffer
static int get_video_buffer(AVFrame *frame, int align)
Definition: frame.c:112
av_frame_get_buffer
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
Definition: frame.c:246
ff_ctz
#define ff_ctz
Definition: intmath.h:107
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:690
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:80
av_frame_new_side_data
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, size_t size)
Add a new side data to a frame.
Definition: frame.c:678
AVFrame::duration
int64_t duration
Duration of the frame, in the same units as pts.
Definition: frame.h:754
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2888
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
AV_FRAME_DATA_A53_CC
@ AV_FRAME_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:59
AV_FRAME_DATA_DOVI_METADATA
@ AV_FRAME_DATA_DOVI_METADATA
Parsed Dolby Vision metadata, suitable for passing to a software implementation.
Definition: frame.h:204
AV_FRAME_DATA_FILM_GRAIN_PARAMS
@ AV_FRAME_DATA_FILM_GRAIN_PARAMS
Film grain parameters for a frame, described by AVFilmGrainParams.
Definition: frame.h:184
AVFrame::color_primaries
enum AVColorPrimaries color_primaries
Definition: frame.h:605
AV_FRAME_DATA_S12M_TIMECODE
@ AV_FRAME_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1.
Definition: frame.h:152
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:103
AVFrame::opaque
void * opaque
Frame owner's private data.
Definition: frame.h:486
AVFrame::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:614
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:330
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
av_frame_make_writable
int av_frame_make_writable(AVFrame *frame)
Ensure that the frame data is writable, avoiding data copy if possible.
Definition: frame.c:549
AVFrameSideData::buf
AVBufferRef * buf
Definition: frame.h:241
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:437
AVFrame::width
int width
Definition: frame.h:402
AVFrame::top_field_first
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:502
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:561
data
const char data[16]
Definition: mxf.c:146
AV_FRAME_DATA_DOVI_RPU_BUFFER
@ AV_FRAME_DATA_DOVI_RPU_BUFFER
Dolby Vision RPU raw data, suitable for passing to x265 or other libraries.
Definition: frame.h:197
frame_copy_props
static int frame_copy_props(AVFrame *dst, const AVFrame *src, int force_copy)
Definition: frame.c:266
AV_FRAME_DATA_DISPLAYMATRIX
@ AV_FRAME_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: frame.h:85
get_audio_buffer
static int get_audio_buffer(AVFrame *frame, int align)
Definition: frame.c:181
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:596
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:306
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:311
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:550
frame_copy_video
static int frame_copy_video(AVFrame *dst, const AVFrame *src)
Definition: frame.c:702
av_frame_apply_cropping
int av_frame_apply_cropping(AVFrame *frame, int flags)
Crop the given video AVFrame according to its crop_left/crop_top/crop_right/ crop_bottom fields.
Definition: frame.c:870
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:351
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
AVFrame::opaque_ref
AVBufferRef * opaque_ref
Frame owner's private data.
Definition: frame.h:715
AVFrame::chroma_location
enum AVChromaLocation chroma_location
Definition: frame.h:616
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2928
AV_FRAME_DATA_MATRIXENCODING
@ AV_FRAME_DATA_MATRIXENCODING
The data is the AVMatrixEncoding enum defined in libavutil/channel_layout.h.
Definition: frame.h:68
fail
#define fail()
Definition: checkasm.h:134
AV_PIX_FMT_FLAG_HWACCEL
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:128
samplefmt.h
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:422
wipe_side_data
static void wipe_side_data(AVFrame *frame)
Definition: frame.c:79
AVFrame::ch_layout
AVChannelLayout ch_layout
Channel layout of the audio data.
Definition: frame.h:749
type
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
Definition: writing_filters.txt:86
av_image_fill_pointers
int av_image_fill_pointers(uint8_t *data[4], enum AVPixelFormat pix_fmt, int height, uint8_t *ptr, const int linesizes[4])
Fill plane data pointers for an image with pixel format pix_fmt and height height.
Definition: imgutils.c:145
AVFrame::channels
attribute_deprecated int channels
number of audio channels, only used for audio.
Definition: frame.h:678
planar
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi - 0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1<< 16)) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63))) #define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={ FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64), };static void cpy1(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, len);} static void cpy2(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 2 *len);} static void cpy4(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 4 *len);} static void cpy8(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 8 *len);} AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags) { AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){ in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);} ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map) { switch(av_get_bytes_per_sample(in_fmt)){ case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;} } return ctx;} void swri_audio_convert_free(AudioConvert **ctx) { av_freep(ctx);} int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len) { int ch;int off=0;const int os=(out->planar ? 1 :out->ch_count) *out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask) { int planes=in->planar ? in->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;} if(ctx->out_simd_align_mask) { int planes=out->planar ? out->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;} if(ctx->simd_f &&!ctx->ch_map &&!misaligned){ off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){ if(out->planar==in->planar){ int planes=out->planar ? out->ch_count :1;for(ch=0;ch< planes;ch++){ ctx->simd_f(out->ch+ch,(const uint8_t **) in->ch+ch, off *(out-> planar
Definition: audioconvert.c:56
AVFrameSideDataType
AVFrameSideDataType
Definition: frame.h:49
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:91
get_frame_defaults
static void get_frame_defaults(AVFrame *frame)
Definition: frame.c:38
avassert.h
AVFrameSideData::size
size_t size
Definition: frame.h:239
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
AVFrame::channel_layout
attribute_deprecated uint64_t channel_layout
Channel layout of the audio data.
Definition: frame.h:535
AVFrame::reordered_opaque
attribute_deprecated int64_t reordered_opaque
reordered opaque 64 bits (generally an integer or a double precision float PTS but can be anything).
Definition: frame.h:521
av_image_fill_linesizes
int av_image_fill_linesizes(int linesizes[4], enum AVPixelFormat pix_fmt, int width)
Fill plane linesizes for an image with pixel format pix_fmt and width width.
Definition: imgutils.c:89
offsets
static const int offsets[]
Definition: hevc_pel.c:34
AV_CHANNEL_ORDER_UNSPEC
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
Definition: channel_layout.h:112
av_channel_layout_from_mask
FF_ENABLE_DEPRECATION_WARNINGS int av_channel_layout_from_mask(AVChannelLayout *channel_layout, uint64_t mask)
Initialize a native channel layout from a bitmask indicating which channels are present.
Definition: channel_layout.c:391
AV_FRAME_DATA_AUDIO_SERVICE_TYPE
@ AV_FRAME_DATA_AUDIO_SERVICE_TYPE
This side data must be associated with an audio frame and corresponds to enum AVAudioServiceType defi...
Definition: frame.h:114
av_sample_fmt_is_planar
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
Definition: samplefmt.c:114
channels
channels
Definition: aptx.h:31
av_frame_clone
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:473
AVFrame::pkt_size
attribute_deprecated int pkt_size
size of the corresponding packet containing the compressed frame.
Definition: frame.h:692
AVFrame::crop_right
size_t crop_right
Definition: frame.h:728
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:536
AV_FRAME_DATA_DYNAMIC_HDR_VIVID
@ AV_FRAME_DATA_DYNAMIC_HDR_VIVID
HDR Vivid dynamic metadata associated with a video frame.
Definition: frame.h:211
frame_copy_audio
static int frame_copy_audio(AVFrame *dst, const AVFrame *src)
Definition: frame.c:727
AV_FRAME_DATA_SPHERICAL
@ AV_FRAME_DATA_SPHERICAL
The data represents the AVSphericalMapping structure defined in libavutil/spherical....
Definition: frame.h:131
NULL
#define NULL
Definition: coverity.c:32
sizes
static const int sizes[][2]
Definition: img2dec.c:57
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:602
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
AVComponentDescriptor
Definition: pixdesc.h:30
av_image_fill_plane_sizes
int av_image_fill_plane_sizes(size_t sizes[4], enum AVPixelFormat pix_fmt, int height, const ptrdiff_t linesizes[4])
Fill plane sizes for an image with pixel format pix_fmt and height height.
Definition: imgutils.c:111
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVFrame::coded_picture_number
attribute_deprecated int coded_picture_number
picture number in bitstream order
Definition: frame.h:459
AV_FRAME_DATA_ICC_PROFILE
@ AV_FRAME_DATA_ICC_PROFILE
The data contains an ICC profile as an opaque octet buffer following the format described by ISO 1507...
Definition: frame.h:144
AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
@ AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata associated with a video frame.
Definition: frame.h:120
av_frame_new_side_data_from_buf
AVFrameSideData * av_frame_new_side_data_from_buf(AVFrame *frame, enum AVFrameSideDataType type, AVBufferRef *buf)
Add a new side data to a frame from an existing AVBufferRef.
Definition: frame.c:646
AVFrame::pkt_dts
int64_t pkt_dts
DTS copied from the AVPacket that triggered returning this frame.
Definition: frame.h:444
AV_FRAME_DATA_AFD
@ AV_FRAME_DATA_AFD
Active Format Description data consisting of a single byte as specified in ETSI TS 101 154 using AVAc...
Definition: frame.h:90
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:627
AV_FRAME_DATA_SEI_UNREGISTERED
@ AV_FRAME_DATA_SEI_UNREGISTERED
User data unregistered metadata associated with a video frame.
Definition: frame.h:178
AVFrame::crop_bottom
size_t crop_bottom
Definition: frame.h:726
AVFrame::best_effort_timestamp
int64_t best_effort_timestamp
frame timestamp estimated using various heuristics, in stream time base
Definition: frame.h:623
AVFrame::crop_left
size_t crop_left
Definition: frame.h:727
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:427
AV_FRAME_DATA_REPLAYGAIN
@ AV_FRAME_DATA_REPLAYGAIN
ReplayGain information in the form of the AVReplayGain struct.
Definition: frame.h:77
AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT
@ AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT
Ambient viewing environment metadata, as defined by H.274.
Definition: frame.h:216
AV_FRAME_DATA_PANSCAN
@ AV_FRAME_DATA_PANSCAN
The data is the AVPanScan struct defined in libavcodec.
Definition: frame.h:53
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:352
av_frame_copy
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:770
cpu.h
AVFrame::quality
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:470
AVFrame::display_picture_number
attribute_deprecated int display_picture_number
picture number in display order
Definition: frame.h:464
AVFrame::sample_rate
int sample_rate
Sample rate of the audio data.
Definition: frame.h:527
FF_API_OLD_CHANNEL_LAYOUT
#define FF_API_OLD_CHANNEL_LAYOUT
Definition: version.h:111
size
int size
Definition: twinvq_data.h:10344
AV_NUM_DATA_POINTERS
#define AV_NUM_DATA_POINTERS
Definition: frame.h:331
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AVFrame::time_base
AVRational time_base
Time base for the timestamps in this frame.
Definition: frame.h:452
AV_PIX_FMT_FLAG_BITSTREAM
#define AV_PIX_FMT_FLAG_BITSTREAM
All values of a component are bit-wise packed end to end.
Definition: pixdesc.h:124
AVFrameSideData::data
uint8_t * data
Definition: frame.h:238
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:532
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:681
AVFrame::pkt_pos
attribute_deprecated int64_t pkt_pos
reordered pos from the last AVPacket that has been input into the decoder
Definition: frame.h:634
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:417
frame.h
buffer.h
align
static const uint8_t *BS_FUNC() align(BSCTX *bc)
Skip bits to a byte boundary.
Definition: bitstream_template.h:411
av_frame_remove_side_data
void av_frame_remove_side_data(AVFrame *frame, enum AVFrameSideDataType type)
Remove and free all side data instances of the given type.
Definition: frame.c:790
AV_CHANNEL_ORDER_NATIVE
@ AV_CHANNEL_ORDER_NATIVE
The native channel order, i.e.
Definition: channel_layout.h:118
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:223
av_buffer_alloc
AVBufferRef * av_buffer_alloc(size_t size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:77
av_channel_layout_compare
int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1)
Check whether two channel layouts are semantically the same, i.e.
Definition: channel_layout.c:932
AVBufferRef::size
size_t size
Size of data in bytes.
Definition: buffer.h:94
AVFrame::private_ref
AVBufferRef * private_ref
AVBufferRef for internal use by a single libav* library.
Definition: frame.h:744
AV_FRAME_DATA_SKIP_SAMPLES
@ AV_FRAME_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: frame.h:109
AVFrame::interlaced_frame
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:497
av_samples_copy
int av_samples_copy(uint8_t **dst, uint8_t *const *src, int dst_offset, int src_offset, int nb_samples, int nb_channels, enum AVSampleFormat sample_fmt)
Copy samples from src to dst.
Definition: samplefmt.c:222
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:410
AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
@ AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: frame.h:137
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:391
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
common.h
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
AV_FRAME_DATA_STEREO3D
@ AV_FRAME_DATA_STEREO3D
Stereoscopic 3d metadata.
Definition: frame.h:64
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_frame_move_ref
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
Definition: frame.c:515
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:486
AVFrame::pkt_duration
attribute_deprecated int64_t pkt_duration
duration of the corresponding packet, expressed in AVStream->time_base units, 0 if unknown.
Definition: frame.h:647
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:254
av_buffer_replace
int av_buffer_replace(AVBufferRef **pdst, const AVBufferRef *src)
Ensure dst refers to the same data as src.
Definition: buffer.c:233
av_samples_get_buffer_size
int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
Get the required buffer size for the given audio parameters.
Definition: samplefmt.c:121
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:590
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:262
av_buffer_is_writable
int av_buffer_is_writable(const AVBufferRef *buf)
Definition: buffer.c:147
AVFrame::decode_error_flags
int decode_error_flags
decode error flags of the frame, set to a combination of FF_DECODE_ERROR_xxx flags if the decoder pro...
Definition: frame.h:664
ret
ret
Definition: filter_design.txt:187
AV_FRAME_DATA_GOP_TIMECODE
@ AV_FRAME_DATA_GOP_TIMECODE
The GOP timecode in 25 bit timecode format.
Definition: frame.h:125
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
av_channel_layout_check
int av_channel_layout_check(const AVChannelLayout *channel_layout)
Check whether a channel layout is valid, i.e.
Definition: channel_layout.c:906
dict.h
AVFrame::sample_aspect_ratio
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:432
av_hwframe_transfer_data
int av_hwframe_transfer_data(AVFrame *dst, const AVFrame *src, int flags)
Copy data to or from a hw surface.
Definition: hwcontext.c:448
AVFrame::hw_frames_ctx
AVBufferRef * hw_frames_ctx
For hwaccel-format frames, this should be a reference to the AVHWFramesContext describing the frame.
Definition: frame.h:699
AV_FRAME_DATA_DYNAMIC_HDR_PLUS
@ AV_FRAME_DATA_DYNAMIC_HDR_PLUS
HDR dynamic metadata associated with a video frame.
Definition: frame.h:159
AVFrame::height
int height
Definition: frame.h:402
planes
static const struct @347 planes[]
av_image_copy
void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4], const uint8_t *src_data[4], const int src_linesizes[4], enum AVPixelFormat pix_fmt, int width, int height)
Copy image in src_data to dst_data.
Definition: imgutils.c:422
channel_layout.h
AVFrame::palette_has_changed
int palette_has_changed
Tell user application that palette has changed from previous frame.
Definition: frame.h:507
AV_FRAME_DATA_VIDEO_ENC_PARAMS
@ AV_FRAME_DATA_VIDEO_ENC_PARAMS
Encoding parameters for a video frame, as described by AVVideoEncParams.
Definition: frame.h:170
AVFrame::metadata
AVDictionary * metadata
metadata.
Definition: frame.h:655
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition: channel_layout.c:632
AVFrameSideData::type
enum AVFrameSideDataType type
Definition: frame.h:237
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
av_channel_layout_copy
int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src)
Make a copy of a channel layout.
Definition: channel_layout.c:639
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:81
desc
const char * desc
Definition: libsvtav1.c:83
mem.h
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:236
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AV_FRAME_CROP_UNALIGNED
@ AV_FRAME_CROP_UNALIGNED
Apply the maximum possible cropping, even if it requires setting the AVFrame.data[] entries to unalig...
Definition: frame.h:960
calc_cropping_offsets
static int calc_cropping_offsets(size_t offsets[4], const AVFrame *frame, const AVPixFmtDescriptor *desc)
Definition: frame.c:838
AVFrame::crop_top
size_t crop_top
Definition: frame.h:725
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
av_dict_copy
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:237
av_frame_side_data_name
const char * av_frame_side_data_name(enum AVFrameSideDataType type)
Definition: frame.c:804
AV_FRAME_DATA_REGIONS_OF_INTEREST
@ AV_FRAME_DATA_REGIONS_OF_INTEREST
Regions Of Interest, the data is an array of AVRegionOfInterest type, the number of array element is ...
Definition: frame.h:165
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
hwcontext.h
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:375
AVFrameSideData::metadata
AVDictionary * metadata
Definition: frame.h:240
AV_FRAME_DATA_MOTION_VECTORS
@ AV_FRAME_DATA_MOTION_VECTORS
Motion vectors exported by some codecs (on demand through the export_mvs flag set in the libavcodec A...
Definition: frame.h:97
av_frame_get_plane_buffer
AVBufferRef * av_frame_get_plane_buffer(AVFrame *frame, int plane)
Get the buffer reference a given data plane is stored in.
Definition: frame.c:607
av_image_check_size
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...
Definition: imgutils.c:318
CHECK_CHANNELS_CONSISTENCY
#define CHECK_CHANNELS_CONSISTENCY(frame)
Definition: frame.c:32
AV_PIX_FMT_FLAG_PAL
#define AV_PIX_FMT_FLAG_PAL
Pixel format has a palette in data[1], values are indexes in this palette.
Definition: pixdesc.h:120
av_hwframe_get_buffer
int av_hwframe_get_buffer(AVBufferRef *hwframe_ref, AVFrame *frame, int flags)
Allocate a new frame attached to the given AVHWFramesContext.
Definition: hwcontext.c:507
AV_FRAME_DATA_DOWNMIX_INFO
@ AV_FRAME_DATA_DOWNMIX_INFO
Metadata relevant to a downmix procedure.
Definition: frame.h:73
AVFrame::repeat_pict
int repeat_pict
When decoding, this signals how much the picture must be delayed.
Definition: frame.h:492
AV_FRAME_DATA_DETECTION_BBOXES
@ AV_FRAME_DATA_DETECTION_BBOXES
Bounding boxes for object detection and classification, as described by AVDetectionBBoxHeader.
Definition: frame.h:190
AVFrame::nb_extended_buf
int nb_extended_buf
Number of elements in extended_buf.
Definition: frame.h:568
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:153
Generated on Tue Mar 21 2023 19:21:55 for FFmpeg by   doxygen 1.8.17