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 static const AVSideDataDescriptor sd_props[] = {
32  [AV_FRAME_DATA_PANSCAN] = { "AVPanScan" },
33  [AV_FRAME_DATA_A53_CC] = { "ATSC A53 Part 4 Closed Captions" },
34  [AV_FRAME_DATA_MATRIXENCODING] = { "AVMatrixEncoding" },
35  [AV_FRAME_DATA_DOWNMIX_INFO] = { "Metadata relevant to a downmix procedure" },
36  [AV_FRAME_DATA_AFD] = { "Active format description" },
37  [AV_FRAME_DATA_MOTION_VECTORS] = { "Motion vectors" },
38  [AV_FRAME_DATA_SKIP_SAMPLES] = { "Skip samples" },
39  [AV_FRAME_DATA_GOP_TIMECODE] = { "GOP timecode" },
40  [AV_FRAME_DATA_S12M_TIMECODE] = { "SMPTE 12-1 timecode" },
41  [AV_FRAME_DATA_DYNAMIC_HDR_PLUS] = { "HDR Dynamic Metadata SMPTE2094-40 (HDR10+)" },
42  [AV_FRAME_DATA_DYNAMIC_HDR_VIVID] = { "HDR Dynamic Metadata CUVA 005.1 2021 (Vivid)" },
43  [AV_FRAME_DATA_REGIONS_OF_INTEREST] = { "Regions Of Interest" },
44  [AV_FRAME_DATA_VIDEO_ENC_PARAMS] = { "Video encoding parameters" },
45  [AV_FRAME_DATA_FILM_GRAIN_PARAMS] = { "Film grain parameters" },
46  [AV_FRAME_DATA_DETECTION_BBOXES] = { "Bounding boxes for object detection and classification" },
47  [AV_FRAME_DATA_DOVI_RPU_BUFFER] = { "Dolby Vision RPU Data" },
48  [AV_FRAME_DATA_DOVI_METADATA] = { "Dolby Vision Metadata" },
50  [AV_FRAME_DATA_REPLAYGAIN] = { "AVReplayGain", AV_SIDE_DATA_PROP_GLOBAL },
51  [AV_FRAME_DATA_DISPLAYMATRIX] = { "3x3 displaymatrix", AV_SIDE_DATA_PROP_GLOBAL },
52  [AV_FRAME_DATA_AUDIO_SERVICE_TYPE] = { "Audio service type", AV_SIDE_DATA_PROP_GLOBAL },
53  [AV_FRAME_DATA_MASTERING_DISPLAY_METADATA] = { "Mastering display metadata", AV_SIDE_DATA_PROP_GLOBAL },
54  [AV_FRAME_DATA_CONTENT_LIGHT_LEVEL] = { "Content light level metadata", AV_SIDE_DATA_PROP_GLOBAL },
55  [AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT] = { "Ambient viewing environment", AV_SIDE_DATA_PROP_GLOBAL },
56  [AV_FRAME_DATA_SPHERICAL] = { "Spherical Mapping", AV_SIDE_DATA_PROP_GLOBAL },
58  [AV_FRAME_DATA_SEI_UNREGISTERED] = { "H.26[45] User Data Unregistered SEI message", AV_SIDE_DATA_PROP_MULTI },
59 };
60 
62 {
63  memset(frame, 0, sizeof(*frame));
64 
65  frame->pts =
66  frame->pkt_dts = AV_NOPTS_VALUE;
67  frame->best_effort_timestamp = AV_NOPTS_VALUE;
68  frame->duration = 0;
69 #if FF_API_FRAME_PKT
71  frame->pkt_pos = -1;
72  frame->pkt_size = -1;
74 #endif
75  frame->time_base = (AVRational){ 0, 1 };
76  frame->sample_aspect_ratio = (AVRational){ 0, 1 };
77  frame->format = -1; /* unknown */
78  frame->extended_data = frame->data;
79  frame->color_primaries = AVCOL_PRI_UNSPECIFIED;
80  frame->color_trc = AVCOL_TRC_UNSPECIFIED;
81  frame->colorspace = AVCOL_SPC_UNSPECIFIED;
82  frame->color_range = AVCOL_RANGE_UNSPECIFIED;
83  frame->chroma_location = AVCHROMA_LOC_UNSPECIFIED;
84  frame->flags = 0;
85 }
86 
87 static void free_side_data(AVFrameSideData **ptr_sd)
88 {
89  AVFrameSideData *sd = *ptr_sd;
90 
91  av_buffer_unref(&sd->buf);
92  av_dict_free(&sd->metadata);
93  av_freep(ptr_sd);
94 }
95 
96 static void wipe_side_data(AVFrameSideData ***sd, int *nb_side_data)
97 {
98  for (int i = 0; i < *nb_side_data; i++) {
99  free_side_data(&((*sd)[i]));
100  }
101  *nb_side_data = 0;
102 
103  av_freep(sd);
104 }
105 
107 {
108  wipe_side_data(&frame->side_data, &frame->nb_side_data);
109 }
110 
112 {
113  wipe_side_data(sd, nb_sd);
114 }
115 
116 static void remove_side_data(AVFrameSideData ***sd, int *nb_side_data,
117  const enum AVFrameSideDataType type)
118 {
119  for (int i = *nb_side_data - 1; i >= 0; i--) {
120  AVFrameSideData *entry = ((*sd)[i]);
121  if (entry->type != type)
122  continue;
123 
125 
126  ((*sd)[i]) = ((*sd)[*nb_side_data - 1]);
127  (*nb_side_data)--;
128  }
129 }
130 
131 static void remove_side_data_by_entry(AVFrameSideData ***sd, int *nb_sd,
132  const AVFrameSideData *target)
133 {
134  for (int i = *nb_sd - 1; i >= 0; i--) {
135  AVFrameSideData *entry = ((*sd)[i]);
136  if (entry != target)
137  continue;
138 
140 
141  ((*sd)[i]) = ((*sd)[*nb_sd - 1]);
142  (*nb_sd)--;
143 
144  return;
145  }
146 }
147 
149 {
150  AVFrame *frame = av_malloc(sizeof(*frame));
151 
152  if (!frame)
153  return NULL;
154 
156 
157  return frame;
158 }
159 
161 {
162  if (!frame || !*frame)
163  return;
164 
166  av_freep(frame);
167 }
168 
170 {
172  int ret, padded_height, total_size;
173  int plane_padding = FFMAX(16 + 16/*STRIDE_ALIGN*/, align);
174  ptrdiff_t linesizes[4];
175  size_t sizes[4];
176 
177  if (!desc)
178  return AVERROR(EINVAL);
179 
180  if ((ret = av_image_check_size(frame->width, frame->height, 0, NULL)) < 0)
181  return ret;
182 
183  if (!frame->linesize[0]) {
184  if (align <= 0)
185  align = 32; /* STRIDE_ALIGN. Should be av_cpu_max_align() */
186 
187  for (int i = 1; i <= align; i += i) {
188  ret = av_image_fill_linesizes(frame->linesize, frame->format,
189  FFALIGN(frame->width, i));
190  if (ret < 0)
191  return ret;
192  if (!(frame->linesize[0] & (align-1)))
193  break;
194  }
195 
196  for (int i = 0; i < 4 && frame->linesize[i]; i++)
197  frame->linesize[i] = FFALIGN(frame->linesize[i], align);
198  }
199 
200  for (int i = 0; i < 4; i++)
201  linesizes[i] = frame->linesize[i];
202 
203  padded_height = FFALIGN(frame->height, 32);
204  if ((ret = av_image_fill_plane_sizes(sizes, frame->format,
205  padded_height, linesizes)) < 0)
206  return ret;
207 
208  total_size = 4*plane_padding;
209  for (int i = 0; i < 4; i++) {
210  if (sizes[i] > INT_MAX - total_size)
211  return AVERROR(EINVAL);
212  total_size += sizes[i];
213  }
214 
215  frame->buf[0] = av_buffer_alloc(total_size);
216  if (!frame->buf[0]) {
217  ret = AVERROR(ENOMEM);
218  goto fail;
219  }
220 
221  if ((ret = av_image_fill_pointers(frame->data, frame->format, padded_height,
222  frame->buf[0]->data, frame->linesize)) < 0)
223  goto fail;
224 
225  for (int i = 1; i < 4; i++) {
226  if (frame->data[i])
227  frame->data[i] += i * plane_padding;
228  }
229 
230  frame->extended_data = frame->data;
231 
232  return 0;
233 fail:
235  return ret;
236 }
237 
239 {
240  int planar = av_sample_fmt_is_planar(frame->format);
241  int channels, planes;
242  int ret;
243 
244  channels = frame->ch_layout.nb_channels;
245  planes = planar ? channels : 1;
246  if (!frame->linesize[0]) {
247  ret = av_samples_get_buffer_size(&frame->linesize[0], channels,
248  frame->nb_samples, frame->format,
249  align);
250  if (ret < 0)
251  return ret;
252  }
253 
255  frame->extended_data = av_calloc(planes,
256  sizeof(*frame->extended_data));
257  frame->extended_buf = av_calloc(planes - AV_NUM_DATA_POINTERS,
258  sizeof(*frame->extended_buf));
259  if (!frame->extended_data || !frame->extended_buf) {
260  av_freep(&frame->extended_data);
261  av_freep(&frame->extended_buf);
262  return AVERROR(ENOMEM);
263  }
264  frame->nb_extended_buf = planes - AV_NUM_DATA_POINTERS;
265  } else
266  frame->extended_data = frame->data;
267 
268  for (int i = 0; i < FFMIN(planes, AV_NUM_DATA_POINTERS); i++) {
269  frame->buf[i] = av_buffer_alloc(frame->linesize[0]);
270  if (!frame->buf[i]) {
272  return AVERROR(ENOMEM);
273  }
274  frame->extended_data[i] = frame->data[i] = frame->buf[i]->data;
275  }
276  for (int i = 0; i < planes - AV_NUM_DATA_POINTERS; i++) {
277  frame->extended_buf[i] = av_buffer_alloc(frame->linesize[0]);
278  if (!frame->extended_buf[i]) {
280  return AVERROR(ENOMEM);
281  }
282  frame->extended_data[i + AV_NUM_DATA_POINTERS] = frame->extended_buf[i]->data;
283  }
284  return 0;
285 
286 }
287 
289 {
290  if (frame->format < 0)
291  return AVERROR(EINVAL);
292 
293  if (frame->width > 0 && frame->height > 0)
294  return get_video_buffer(frame, align);
295  else if (frame->nb_samples > 0 &&
296  (av_channel_layout_check(&frame->ch_layout)))
297  return get_audio_buffer(frame, align);
298 
299  return AVERROR(EINVAL);
300 }
301 
302 static int frame_copy_props(AVFrame *dst, const AVFrame *src, int force_copy)
303 {
304  int ret;
305 
306 #if FF_API_FRAME_KEY
308  dst->key_frame = src->key_frame;
310 #endif
311  dst->pict_type = src->pict_type;
312  dst->sample_aspect_ratio = src->sample_aspect_ratio;
313  dst->crop_top = src->crop_top;
314  dst->crop_bottom = src->crop_bottom;
315  dst->crop_left = src->crop_left;
316  dst->crop_right = src->crop_right;
317  dst->pts = src->pts;
318  dst->duration = src->duration;
319  dst->repeat_pict = src->repeat_pict;
320 #if FF_API_INTERLACED_FRAME
322  dst->interlaced_frame = src->interlaced_frame;
323  dst->top_field_first = src->top_field_first;
325 #endif
326 #if FF_API_PALETTE_HAS_CHANGED
328  dst->palette_has_changed = src->palette_has_changed;
330 #endif
331  dst->sample_rate = src->sample_rate;
332  dst->opaque = src->opaque;
333  dst->pkt_dts = src->pkt_dts;
334 #if FF_API_FRAME_PKT
336  dst->pkt_pos = src->pkt_pos;
337  dst->pkt_size = src->pkt_size;
339 #endif
340  dst->time_base = src->time_base;
341  dst->quality = src->quality;
342  dst->best_effort_timestamp = src->best_effort_timestamp;
343  dst->flags = src->flags;
344  dst->decode_error_flags = src->decode_error_flags;
345  dst->color_primaries = src->color_primaries;
346  dst->color_trc = src->color_trc;
347  dst->colorspace = src->colorspace;
348  dst->color_range = src->color_range;
349  dst->chroma_location = src->chroma_location;
350 
351  av_dict_copy(&dst->metadata, src->metadata, 0);
352 
353  for (int i = 0; i < src->nb_side_data; i++) {
354  const AVFrameSideData *sd_src = src->side_data[i];
355  AVFrameSideData *sd_dst;
356  if ( sd_src->type == AV_FRAME_DATA_PANSCAN
357  && (src->width != dst->width || src->height != dst->height))
358  continue;
359  if (force_copy) {
360  sd_dst = av_frame_new_side_data(dst, sd_src->type,
361  sd_src->size);
362  if (!sd_dst) {
364  return AVERROR(ENOMEM);
365  }
366  memcpy(sd_dst->data, sd_src->data, sd_src->size);
367  } else {
368  AVBufferRef *ref = av_buffer_ref(sd_src->buf);
369  sd_dst = av_frame_new_side_data_from_buf(dst, sd_src->type, ref);
370  if (!sd_dst) {
373  return AVERROR(ENOMEM);
374  }
375  }
376  av_dict_copy(&sd_dst->metadata, sd_src->metadata, 0);
377  }
378 
379  ret = av_buffer_replace(&dst->opaque_ref, src->opaque_ref);
380  ret |= av_buffer_replace(&dst->private_ref, src->private_ref);
381  return ret;
382 }
383 
384 int av_frame_ref(AVFrame *dst, const AVFrame *src)
385 {
386  int ret = 0;
387 
388  av_assert1(dst->width == 0 && dst->height == 0);
389  av_assert1(dst->ch_layout.nb_channels == 0 &&
391 
392  dst->format = src->format;
393  dst->width = src->width;
394  dst->height = src->height;
395  dst->nb_samples = src->nb_samples;
396 
397  ret = frame_copy_props(dst, src, 0);
398  if (ret < 0)
399  goto fail;
400 
401  ret = av_channel_layout_copy(&dst->ch_layout, &src->ch_layout);
402  if (ret < 0)
403  goto fail;
404 
405  /* duplicate the frame data if it's not refcounted */
406  if (!src->buf[0]) {
407  ret = av_frame_get_buffer(dst, 0);
408  if (ret < 0)
409  goto fail;
410 
411  ret = av_frame_copy(dst, src);
412  if (ret < 0)
413  goto fail;
414 
415  return 0;
416  }
417 
418  /* ref the buffers */
419  for (int i = 0; i < FF_ARRAY_ELEMS(src->buf); i++) {
420  if (!src->buf[i])
421  continue;
422  dst->buf[i] = av_buffer_ref(src->buf[i]);
423  if (!dst->buf[i]) {
424  ret = AVERROR(ENOMEM);
425  goto fail;
426  }
427  }
428 
429  if (src->extended_buf) {
430  dst->extended_buf = av_calloc(src->nb_extended_buf,
431  sizeof(*dst->extended_buf));
432  if (!dst->extended_buf) {
433  ret = AVERROR(ENOMEM);
434  goto fail;
435  }
436  dst->nb_extended_buf = src->nb_extended_buf;
437 
438  for (int i = 0; i < src->nb_extended_buf; i++) {
439  dst->extended_buf[i] = av_buffer_ref(src->extended_buf[i]);
440  if (!dst->extended_buf[i]) {
441  ret = AVERROR(ENOMEM);
442  goto fail;
443  }
444  }
445  }
446 
447  if (src->hw_frames_ctx) {
448  dst->hw_frames_ctx = av_buffer_ref(src->hw_frames_ctx);
449  if (!dst->hw_frames_ctx) {
450  ret = AVERROR(ENOMEM);
451  goto fail;
452  }
453  }
454 
455  /* duplicate extended data */
456  if (src->extended_data != src->data) {
457  int ch = dst->ch_layout.nb_channels;
458 
459  if (!ch) {
460  ret = AVERROR(EINVAL);
461  goto fail;
462  }
463 
464  dst->extended_data = av_malloc_array(sizeof(*dst->extended_data), ch);
465  if (!dst->extended_data) {
466  ret = AVERROR(ENOMEM);
467  goto fail;
468  }
469  memcpy(dst->extended_data, src->extended_data, sizeof(*src->extended_data) * ch);
470  } else
471  dst->extended_data = dst->data;
472 
473  memcpy(dst->data, src->data, sizeof(src->data));
474  memcpy(dst->linesize, src->linesize, sizeof(src->linesize));
475 
476  return 0;
477 
478 fail:
479  av_frame_unref(dst);
480  return ret;
481 }
482 
484 {
485  int ret = 0;
486 
487  if (dst == src)
488  return AVERROR(EINVAL);
489 
490  if (!src->buf[0]) {
491  av_frame_unref(dst);
492 
493  /* duplicate the frame data if it's not refcounted */
494  if ( src->data[0] || src->data[1]
495  || src->data[2] || src->data[3])
496  return av_frame_ref(dst, src);
497 
498  ret = frame_copy_props(dst, src, 0);
499  if (ret < 0)
500  goto fail;
501  }
502 
503  dst->format = src->format;
504  dst->width = src->width;
505  dst->height = src->height;
506  dst->nb_samples = src->nb_samples;
507 
508  ret = av_channel_layout_copy(&dst->ch_layout, &src->ch_layout);
509  if (ret < 0)
510  goto fail;
511 
513  av_dict_free(&dst->metadata);
514  ret = frame_copy_props(dst, src, 0);
515  if (ret < 0)
516  goto fail;
517 
518  /* replace the buffers */
519  for (int i = 0; i < FF_ARRAY_ELEMS(src->buf); i++) {
520  ret = av_buffer_replace(&dst->buf[i], src->buf[i]);
521  if (ret < 0)
522  goto fail;
523  }
524 
525  if (src->extended_buf) {
526  if (dst->nb_extended_buf != src->nb_extended_buf) {
527  int nb_extended_buf = FFMIN(dst->nb_extended_buf, src->nb_extended_buf);
528  void *tmp;
529 
530  for (int i = nb_extended_buf; i < dst->nb_extended_buf; i++)
532 
533  tmp = av_realloc_array(dst->extended_buf, sizeof(*dst->extended_buf),
534  src->nb_extended_buf);
535  if (!tmp) {
536  ret = AVERROR(ENOMEM);
537  goto fail;
538  }
539  dst->extended_buf = tmp;
540  dst->nb_extended_buf = src->nb_extended_buf;
541 
542  memset(&dst->extended_buf[nb_extended_buf], 0,
543  (src->nb_extended_buf - nb_extended_buf) * sizeof(*dst->extended_buf));
544  }
545 
546  for (int i = 0; i < src->nb_extended_buf; i++) {
547  ret = av_buffer_replace(&dst->extended_buf[i], src->extended_buf[i]);
548  if (ret < 0)
549  goto fail;
550  }
551  } else if (dst->extended_buf) {
552  for (int i = 0; i < dst->nb_extended_buf; i++)
554  av_freep(&dst->extended_buf);
555  }
556 
557  ret = av_buffer_replace(&dst->hw_frames_ctx, src->hw_frames_ctx);
558  if (ret < 0)
559  goto fail;
560 
561  if (dst->extended_data != dst->data)
562  av_freep(&dst->extended_data);
563 
564  if (src->extended_data != src->data) {
565  int ch = dst->ch_layout.nb_channels;
566 
567  if (!ch) {
568  ret = AVERROR(EINVAL);
569  goto fail;
570  }
571 
572  if (ch > SIZE_MAX / sizeof(*dst->extended_data))
573  goto fail;
574 
575  dst->extended_data = av_memdup(src->extended_data, sizeof(*dst->extended_data) * ch);
576  if (!dst->extended_data) {
577  ret = AVERROR(ENOMEM);
578  goto fail;
579  }
580  } else
581  dst->extended_data = dst->data;
582 
583  memcpy(dst->data, src->data, sizeof(src->data));
584  memcpy(dst->linesize, src->linesize, sizeof(src->linesize));
585 
586  return 0;
587 
588 fail:
589  av_frame_unref(dst);
590  return ret;
591 }
592 
594 {
596 
597  if (!ret)
598  return NULL;
599 
600  if (av_frame_ref(ret, src) < 0)
601  av_frame_free(&ret);
602 
603  return ret;
604 }
605 
607 {
608  if (!frame)
609  return;
610 
612 
613  for (int i = 0; i < FF_ARRAY_ELEMS(frame->buf); i++)
614  av_buffer_unref(&frame->buf[i]);
615  for (int i = 0; i < frame->nb_extended_buf; i++)
616  av_buffer_unref(&frame->extended_buf[i]);
617  av_freep(&frame->extended_buf);
618  av_dict_free(&frame->metadata);
619 
620  av_buffer_unref(&frame->hw_frames_ctx);
621 
622  av_buffer_unref(&frame->opaque_ref);
623  av_buffer_unref(&frame->private_ref);
624 
625  if (frame->extended_data != frame->data)
626  av_freep(&frame->extended_data);
627 
628  av_channel_layout_uninit(&frame->ch_layout);
629 
631 }
632 
634 {
635  av_assert1(dst->width == 0 && dst->height == 0);
636  av_assert1(dst->ch_layout.nb_channels == 0 &&
638 
639  *dst = *src;
640  if (src->extended_data == src->data)
641  dst->extended_data = dst->data;
643 }
644 
646 {
647  int ret = 1;
648 
649  /* assume non-refcounted frames are not writable */
650  if (!frame->buf[0])
651  return 0;
652 
653  for (int i = 0; i < FF_ARRAY_ELEMS(frame->buf); i++)
654  if (frame->buf[i])
655  ret &= !!av_buffer_is_writable(frame->buf[i]);
656  for (int i = 0; i < frame->nb_extended_buf; i++)
657  ret &= !!av_buffer_is_writable(frame->extended_buf[i]);
658 
659  return ret;
660 }
661 
663 {
664  AVFrame tmp;
665  int ret;
666 
668  return 0;
669 
670  memset(&tmp, 0, sizeof(tmp));
671  tmp.format = frame->format;
672  tmp.width = frame->width;
673  tmp.height = frame->height;
674  tmp.nb_samples = frame->nb_samples;
675  ret = av_channel_layout_copy(&tmp.ch_layout, &frame->ch_layout);
676  if (ret < 0) {
678  return ret;
679  }
680 
681  if (frame->hw_frames_ctx)
682  ret = av_hwframe_get_buffer(frame->hw_frames_ctx, &tmp, 0);
683  else
684  ret = av_frame_get_buffer(&tmp, 0);
685  if (ret < 0)
686  return ret;
687 
688  ret = av_frame_copy(&tmp, frame);
689  if (ret < 0) {
691  return ret;
692  }
693 
695  if (ret < 0) {
697  return ret;
698  }
699 
701 
702  *frame = tmp;
703  if (tmp.data == tmp.extended_data)
704  frame->extended_data = frame->data;
705 
706  return 0;
707 }
708 
710 {
711  return frame_copy_props(dst, src, 1);
712 }
713 
715 {
716  uint8_t *data;
717  int planes;
718 
719  if (frame->nb_samples) {
720  int channels = frame->ch_layout.nb_channels;
721  if (!channels)
722  return NULL;
723  planes = av_sample_fmt_is_planar(frame->format) ? channels : 1;
724  } else
725  planes = 4;
726 
727  if (plane < 0 || plane >= planes || !frame->extended_data[plane])
728  return NULL;
729  data = frame->extended_data[plane];
730 
731  for (int i = 0; i < FF_ARRAY_ELEMS(frame->buf) && frame->buf[i]; i++) {
732  AVBufferRef *buf = frame->buf[i];
733  if (data >= buf->data && data < buf->data + buf->size)
734  return buf;
735  }
736  for (int i = 0; i < frame->nb_extended_buf; i++) {
737  AVBufferRef *buf = frame->extended_buf[i];
738  if (data >= buf->data && data < buf->data + buf->size)
739  return buf;
740  }
741  return NULL;
742 }
743 
745  int *nb_sd,
747  AVBufferRef *buf, uint8_t *data,
748  size_t size)
749 {
750  AVFrameSideData *ret, **tmp;
751 
752  // *nb_sd + 1 needs to fit into an int and a size_t.
753  if ((unsigned)*nb_sd >= FFMIN(INT_MAX, SIZE_MAX))
754  return NULL;
755 
756  tmp = av_realloc_array(*sd, sizeof(**sd), *nb_sd + 1);
757  if (!tmp)
758  return NULL;
759  *sd = tmp;
760 
761  ret = av_mallocz(sizeof(*ret));
762  if (!ret)
763  return NULL;
764 
765  ret->buf = buf;
766  ret->data = data;
767  ret->size = size;
768  ret->type = type;
769 
770  (*sd)[(*nb_sd)++] = ret;
771 
772  return ret;
773 }
774 
776  int *nb_sd,
778  AVBufferRef *buf)
779 {
780  if (!buf)
781  return NULL;
782 
783  return add_side_data_from_buf_ext(sd, nb_sd, type, buf, buf->data, buf->size);
784 }
785 
788  AVBufferRef *buf)
789 {
790  return
792  &frame->side_data, &frame->nb_side_data, type, buf);
793 }
794 
797  size_t size)
798 {
802  if (!ret)
803  av_buffer_unref(&buf);
804  return ret;
805 }
806 
808  AVBufferRef *buf, int flags)
809 {
811  return NULL;
812 
813  av_dict_free(&dst->metadata);
814  av_buffer_unref(&dst->buf);
815  dst->buf = buf;
816  dst->data = buf->data;
817  dst->size = buf->size;
818  return dst;
819 }
820 
823  size_t size, unsigned int flags)
824 {
828 
830  remove_side_data(sd, nb_sd, type);
831  if ((!desc || !(desc->props & AV_SIDE_DATA_PROP_MULTI)) &&
832  (ret = (AVFrameSideData *)av_frame_side_data_get(*sd, *nb_sd, type))) {
834  if (!ret)
835  av_buffer_unref(&buf);
836  return ret;
837  }
838 
839  ret = add_side_data_from_buf(sd, nb_sd, type, buf);
840  if (!ret)
841  av_buffer_unref(&buf);
842 
843  return ret;
844 }
845 
848  AVBufferRef **pbuf, unsigned int flags)
849 {
851  AVFrameSideData *sd_dst = NULL;
852  AVBufferRef *buf = *pbuf;
853 
855  remove_side_data(sd, nb_sd, type);
856  if ((!desc || !(desc->props & AV_SIDE_DATA_PROP_MULTI)) &&
857  (sd_dst = (AVFrameSideData *)av_frame_side_data_get(*sd, *nb_sd, type))) {
858  sd_dst = replace_side_data_from_buf(sd_dst, buf, flags);
859  if (sd_dst)
860  *pbuf = NULL;
861  return sd_dst;
862  }
863 
864  sd_dst = add_side_data_from_buf(sd, nb_sd, type, buf);
865  if (!sd_dst)
866  return NULL;
867 
868  *pbuf = NULL;
869  return sd_dst;
870 }
871 
873  const AVFrameSideData *src, unsigned int flags)
874 {
875  const AVSideDataDescriptor *desc;
876  AVBufferRef *buf = NULL;
877  AVFrameSideData *sd_dst = NULL;
878  int ret = AVERROR_BUG;
879 
880  if (!sd || !src || !nb_sd || (*nb_sd && !*sd))
881  return AVERROR(EINVAL);
882 
885  remove_side_data(sd, nb_sd, src->type);
886  if ((!desc || !(desc->props & AV_SIDE_DATA_PROP_MULTI)) &&
887  (sd_dst = (AVFrameSideData *)av_frame_side_data_get(*sd, *nb_sd, src->type))) {
888  AVDictionary *dict = NULL;
889 
891  return AVERROR(EEXIST);
892 
893  ret = av_dict_copy(&dict, src->metadata, 0);
894  if (ret < 0)
895  return ret;
896 
897  ret = av_buffer_replace(&sd_dst->buf, src->buf);
898  if (ret < 0) {
899  av_dict_free(&dict);
900  return ret;
901  }
902 
903  av_dict_free(&sd_dst->metadata);
904  sd_dst->metadata = dict;
905  sd_dst->data = src->data;
906  sd_dst->size = src->size;
907  return 0;
908  }
909 
910  buf = av_buffer_ref(src->buf);
911  if (!buf)
912  return AVERROR(ENOMEM);
913 
914  sd_dst = add_side_data_from_buf_ext(sd, nb_sd, src->type, buf,
915  src->data, src->size);
916  if (!sd_dst) {
917  av_buffer_unref(&buf);
918  return AVERROR(ENOMEM);
919  }
920 
921  ret = av_dict_copy(&sd_dst->metadata, src->metadata, 0);
922  if (ret < 0) {
923  remove_side_data_by_entry(sd, nb_sd, sd_dst);
924  return ret;
925  }
926 
927  return 0;
928 }
929 
931  const int nb_sd,
933 {
934  for (int i = 0; i < nb_sd; i++) {
935  if (sd[i]->type == type)
936  return sd[i];
937  }
938  return NULL;
939 }
940 
943 {
944  remove_side_data(sd, nb_sd, type);
945 }
946 
949 {
951  frame->side_data, frame->nb_side_data,
952  type
953  );
954 }
955 
956 static int frame_copy_video(AVFrame *dst, const AVFrame *src)
957 {
958  int planes;
959 
960  if (dst->width < src->width ||
961  dst->height < src->height)
962  return AVERROR(EINVAL);
963 
964  if (src->hw_frames_ctx || dst->hw_frames_ctx)
965  return av_hwframe_transfer_data(dst, src, 0);
966 
968  for (int i = 0; i < planes; i++)
969  if (!dst->data[i] || !src->data[i])
970  return AVERROR(EINVAL);
971 
972  av_image_copy2(dst->data, dst->linesize,
973  src->data, src->linesize,
974  dst->format, src->width, src->height);
975 
976  return 0;
977 }
978 
979 static int frame_copy_audio(AVFrame *dst, const AVFrame *src)
980 {
982  int channels = dst->ch_layout.nb_channels;
983  int planes = planar ? channels : 1;
984 
985  if (dst->nb_samples != src->nb_samples ||
986  av_channel_layout_compare(&dst->ch_layout, &src->ch_layout))
987  return AVERROR(EINVAL);
988 
989  for (int i = 0; i < planes; i++)
990  if (!dst->extended_data[i] || !src->extended_data[i])
991  return AVERROR(EINVAL);
992 
993  av_samples_copy(dst->extended_data, src->extended_data, 0, 0,
994  dst->nb_samples, channels, dst->format);
995 
996  return 0;
997 }
998 
999 int av_frame_copy(AVFrame *dst, const AVFrame *src)
1000 {
1001  if (dst->format != src->format || dst->format < 0)
1002  return AVERROR(EINVAL);
1003 
1004  if (dst->width > 0 && dst->height > 0)
1005  return frame_copy_video(dst, src);
1006  else if (dst->nb_samples > 0 &&
1008  return frame_copy_audio(dst, src);
1009 
1010  return AVERROR(EINVAL);
1011 }
1012 
1014 {
1015  remove_side_data(&frame->side_data, &frame->nb_side_data, type);
1016 }
1017 
1019 {
1020  unsigned t = type;
1021  if (t < FF_ARRAY_ELEMS(sd_props) && sd_props[t].name)
1022  return &sd_props[t];
1023  return NULL;
1024 }
1025 
1027 {
1029  return desc ? desc->name : NULL;
1030 }
1031 
1032 static int calc_cropping_offsets(size_t offsets[4], const AVFrame *frame,
1033  const AVPixFmtDescriptor *desc)
1034 {
1035  for (int i = 0; frame->data[i]; i++) {
1036  const AVComponentDescriptor *comp = NULL;
1037  int shift_x = (i == 1 || i == 2) ? desc->log2_chroma_w : 0;
1038  int shift_y = (i == 1 || i == 2) ? desc->log2_chroma_h : 0;
1039 
1040  if (desc->flags & AV_PIX_FMT_FLAG_PAL && i == 1) {
1041  offsets[i] = 0;
1042  break;
1043  }
1044 
1045  /* find any component descriptor for this plane */
1046  for (int j = 0; j < desc->nb_components; j++) {
1047  if (desc->comp[j].plane == i) {
1048  comp = &desc->comp[j];
1049  break;
1050  }
1051  }
1052  if (!comp)
1053  return AVERROR_BUG;
1054 
1055  offsets[i] = (frame->crop_top >> shift_y) * frame->linesize[i] +
1056  (frame->crop_left >> shift_x) * comp->step;
1057  }
1058 
1059  return 0;
1060 }
1061 
1063 {
1064  const AVPixFmtDescriptor *desc;
1065  size_t offsets[4];
1066 
1067  if (!(frame->width > 0 && frame->height > 0))
1068  return AVERROR(EINVAL);
1069 
1070  if (frame->crop_left >= INT_MAX - frame->crop_right ||
1071  frame->crop_top >= INT_MAX - frame->crop_bottom ||
1072  (frame->crop_left + frame->crop_right) >= frame->width ||
1073  (frame->crop_top + frame->crop_bottom) >= frame->height)
1074  return AVERROR(ERANGE);
1075 
1076  desc = av_pix_fmt_desc_get(frame->format);
1077  if (!desc)
1078  return AVERROR_BUG;
1079 
1080  /* Apply just the right/bottom cropping for hwaccel formats. Bitstream
1081  * formats cannot be easily handled here either (and corresponding decoders
1082  * should not export any cropping anyway), so do the same for those as well.
1083  * */
1085  frame->width -= frame->crop_right;
1086  frame->height -= frame->crop_bottom;
1087  frame->crop_right = 0;
1088  frame->crop_bottom = 0;
1089  return 0;
1090  }
1091 
1092  /* calculate the offsets for each plane */
1094 
1095  /* adjust the offsets to avoid breaking alignment */
1096  if (!(flags & AV_FRAME_CROP_UNALIGNED)) {
1097  int log2_crop_align = frame->crop_left ? ff_ctz(frame->crop_left) : INT_MAX;
1098  int min_log2_align = INT_MAX;
1099 
1100  for (int i = 0; frame->data[i]; i++) {
1101  int log2_align = offsets[i] ? ff_ctz(offsets[i]) : INT_MAX;
1102  min_log2_align = FFMIN(log2_align, min_log2_align);
1103  }
1104 
1105  /* we assume, and it should always be true, that the data alignment is
1106  * related to the cropping alignment by a constant power-of-2 factor */
1107  if (log2_crop_align < min_log2_align)
1108  return AVERROR_BUG;
1109 
1110  if (min_log2_align < 5) {
1111  frame->crop_left &= ~((1 << (5 + log2_crop_align - min_log2_align)) - 1);
1113  }
1114  }
1115 
1116  for (int i = 0; frame->data[i]; i++)
1117  frame->data[i] += offsets[i];
1118 
1119  frame->width -= (frame->crop_left + frame->crop_right);
1120  frame->height -= (frame->crop_top + frame->crop_bottom);
1121  frame->crop_left = 0;
1122  frame->crop_right = 0;
1123  frame->crop_top = 0;
1124  frame->crop_bottom = 0;
1125 
1126  return 0;
1127 }
AVFrame::extended_buf
AVBufferRef ** extended_buf
For planar audio which requires more than AV_NUM_DATA_POINTERS AVBufferRef pointers,...
Definition: frame.h:601
AVFrame::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: frame.h:657
av_samples_copy
int av_samples_copy(uint8_t *const *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
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
free_side_data
static void free_side_data(AVFrameSideData **ptr_sd)
Definition: frame.c:87
AVFrame::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: frame.h:653
name
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
Definition: writing_filters.txt:88
entry
#define entry
Definition: aom_film_grain_template.c:66
AVFrame::palette_has_changed
attribute_deprecated int palette_has_changed
Tell user application that palette has changed from previous frame.
Definition: frame.h:567
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:169
sd_props
static const AVSideDataDescriptor sd_props[]
Definition: frame.c:31
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:288
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:947
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:81
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:795
AVFrame::duration
int64_t duration
Duration of the frame, in the same units as pts.
Definition: frame.h:780
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2965
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
add_side_data_from_buf_ext
static AVFrameSideData * add_side_data_from_buf_ext(AVFrameSideData ***sd, int *nb_sd, enum AVFrameSideDataType type, AVBufferRef *buf, uint8_t *data, size_t size)
Definition: frame.c:744
AV_FRAME_DATA_DOVI_METADATA
@ AV_FRAME_DATA_DOVI_METADATA
Parsed Dolby Vision metadata, suitable for passing to a software implementation.
Definition: frame.h:208
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:999
AV_FRAME_DATA_FILM_GRAIN_PARAMS
@ AV_FRAME_DATA_FILM_GRAIN_PARAMS
Film grain parameters for a frame, described by AVFilmGrainParams.
Definition: frame.h:188
AVFrame::color_primaries
enum AVColorPrimaries color_primaries
Definition: frame.h:655
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:160
AVFrame::opaque
void * opaque
Frame owner's private data.
Definition: frame.h:522
AVFrame::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:664
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
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:662
AVFrameSideData::buf
AVBufferRef * buf
Definition: frame.h:255
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:486
AVFrame::width
int width
Definition: frame.h:446
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:583
data
const char data[16]
Definition: mxf.c:148
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:201
frame_copy_props
static int frame_copy_props(AVFrame *dst, const AVFrame *src, int force_copy)
Definition: frame.c:302
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:238
AVDictionary
Definition: dict.c:34
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:646
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:308
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
av_frame_side_data_clone
int av_frame_side_data_clone(AVFrameSideData ***sd, int *nb_sd, const AVFrameSideData *src, unsigned int flags)
Add a new side data entry to an array based on existing side data, taking a reference towards the con...
Definition: frame.c:872
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:313
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:587
frame_copy_video
static int frame_copy_video(AVFrame *dst, const AVFrame *src)
Definition: frame.c:956
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:1062
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:395
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:304
AVFrame::opaque_ref
AVBufferRef * opaque_ref
Frame owner's private data.
Definition: frame.h:741
AVFrame::chroma_location
enum AVChromaLocation chroma_location
Definition: frame.h:666
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3005
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:182
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::ch_layout
AVChannelLayout ch_layout
Channel layout of the audio data.
Definition: frame.h:775
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
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:148
get_frame_defaults
static void get_frame_defaults(AVFrame *frame)
Definition: frame.c:61
AVFrame::interlaced_frame
attribute_deprecated int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:551
avassert.h
AV_FRAME_SIDE_DATA_FLAG_UNIQUE
#define AV_FRAME_SIDE_DATA_FLAG_UNIQUE
Remove existing entries before adding new ones.
Definition: frame.h:1045
AVFrameSideData::size
size_t size
Definition: frame.h:253
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
planes
static const struct @417 planes[]
remove_side_data_by_entry
static void remove_side_data_by_entry(AVFrameSideData ***sd, int *nb_sd, const AVFrameSideData *target)
Definition: frame.c:131
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_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:217
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_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
replace_side_data_from_buf
static AVFrameSideData * replace_side_data_from_buf(AVFrameSideData *dst, AVBufferRef *buf, int flags)
Definition: frame.c:807
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
wipe_side_data
static void wipe_side_data(AVFrameSideData ***sd, int *nb_side_data)
Definition: frame.c:96
channels
channels
Definition: aptx.h:31
AV_SIDE_DATA_PROP_MULTI
@ AV_SIDE_DATA_PROP_MULTI
Multiple instances of this side data type can be meaningfully present in a single side data array.
Definition: frame.h:270
av_frame_clone
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:593
AVFrame::pkt_size
attribute_deprecated int pkt_size
size of the corresponding packet containing the compressed frame.
Definition: frame.h:718
AVFrame::crop_right
size_t crop_right
Definition: frame.h:754
AV_SIDE_DATA_PROP_GLOBAL
@ AV_SIDE_DATA_PROP_GLOBAL
The side data type can be used in stream-global structures.
Definition: frame.h:264
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:558
AVFrame::key_frame
attribute_deprecated int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:470
AV_FRAME_DATA_DYNAMIC_HDR_VIVID
@ AV_FRAME_DATA_DYNAMIC_HDR_VIVID
HDR Vivid dynamic metadata associated with a video frame.
Definition: frame.h:215
frame_copy_audio
static int frame_copy_audio(AVFrame *dst, const AVFrame *src)
Definition: frame.c:979
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:59
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:709
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
av_frame_side_data_remove
void av_frame_side_data_remove(AVFrameSideData ***sd, int *nb_sd, enum AVFrameSideDataType type)
Remove and free all side data instances of the given type from an array.
Definition: frame.c:941
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:786
AVFrame::pkt_dts
int64_t pkt_dts
DTS copied from the AVPacket that triggered returning this frame.
Definition: frame.h:493
AV_FRAME_SIDE_DATA_FLAG_REPLACE
#define AV_FRAME_SIDE_DATA_FLAG_REPLACE
Don't add a new entry if another of the same type exists.
Definition: frame.h:1050
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
av_frame_get_plane_buffer
AVBufferRef * av_frame_get_plane_buffer(const AVFrame *frame, int plane)
Get the buffer reference a given data plane is stored in.
Definition: frame.c:714
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:652
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:752
AVFrame::best_effort_timestamp
int64_t best_effort_timestamp
frame timestamp estimated using various heuristics, in stream time base
Definition: frame.h:673
AVFrame::crop_left
size_t crop_left
Definition: frame.h:753
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:476
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:220
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:384
av_frame_copy
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:999
cpu.h
AVFrame::quality
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:506
AVFrame::sample_rate
int sample_rate
Sample rate of the audio data.
Definition: frame.h:573
size
int size
Definition: twinvq_data.h:10344
AV_NUM_DATA_POINTERS
#define AV_NUM_DATA_POINTERS
Definition: frame.h:375
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:501
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:252
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:645
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:706
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:684
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:461
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:1013
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:801
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:770
AV_FRAME_DATA_SKIP_SAMPLES
@ AV_FRAME_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: frame.h:109
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:454
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:256
av_frame_side_data_free
void av_frame_side_data_free(AVFrameSideData ***sd, int *nb_sd)
Free all side data entries and their contents, then zeroes out the values which the pointers are poin...
Definition: frame.c:111
AVFrame::top_field_first
attribute_deprecated int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:559
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:435
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:56
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:633
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:606
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:256
remove_side_data
static void remove_side_data(AVFrameSideData ***sd, int *nb_side_data, const enum AVFrameSideDataType type)
Definition: frame.c:116
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:612
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
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:701
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:775
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:481
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:433
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:725
av_frame_replace
int av_frame_replace(AVFrame *dst, const AVFrame *src)
Ensure the destination frame refers to the same data described by the source frame,...
Definition: frame.c:483
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:446
channel_layout.h
av_frame_side_data_new
AVFrameSideData * av_frame_side_data_new(AVFrameSideData ***sd, int *nb_sd, enum AVFrameSideDataType type, size_t size, unsigned int flags)
Add new side data entry to an array.
Definition: frame.c:821
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
av_image_copy2
static void av_image_copy2(uint8_t *const dst_data[4], const int dst_linesizes[4], uint8_t *const src_data[4], const int src_linesizes[4], enum AVPixelFormat pix_fmt, int width, int height)
Wrapper around av_image_copy() to workaround the limitation that the conversion from uint8_t * const ...
Definition: imgutils.h:184
AVFrame::metadata
AVDictionary * metadata
metadata.
Definition: frame.h:692
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:433
AVFrameSideData::type
enum AVFrameSideDataType type
Definition: frame.h:251
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
AVSideDataDescriptor
This struct describes the properties of a side data type.
Definition: frame.h:277
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:440
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
desc
const char * desc
Definition: libsvtav1.c:79
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:250
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_side_data_desc
const AVSideDataDescriptor * av_frame_side_data_desc(enum AVFrameSideDataType type)
Definition: frame.c:1018
calc_cropping_offsets
static int calc_cropping_offsets(size_t offsets[4], const AVFrame *frame, const AVPixFmtDescriptor *desc)
Definition: frame.c:1032
AVFrame::crop_top
size_t crop_top
Definition: frame.h:751
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
add_side_data_from_buf
static AVFrameSideData * add_side_data_from_buf(AVFrameSideData ***sd, int *nb_sd, enum AVFrameSideDataType type, AVBufferRef *buf)
Definition: frame.c:775
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:1026
av_frame_side_data_get
static const AVFrameSideData * av_frame_side_data_get(AVFrameSideData *const *sd, const int nb_sd, enum AVFrameSideDataType type)
Wrapper around av_frame_side_data_get_c() to workaround the limitation that for any type T the conver...
Definition: frame.h:1143
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:474
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:419
AVFrameSideData::metadata
AVDictionary * metadata
Definition: frame.h:254
av_frame_side_data_get_c
const AVFrameSideData * av_frame_side_data_get_c(const AVFrameSideData *const *sd, const int nb_sd, enum AVFrameSideDataType type)
Get a side data entry of a specific type from an array.
Definition: frame.c:930
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_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
frame_side_data_wipe
static void frame_side_data_wipe(AVFrame *frame)
Definition: frame.c:106
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:491
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
Number of fields in this frame which should be repeated, i.e.
Definition: frame.h:542
av_frame_side_data_add
AVFrameSideData * av_frame_side_data_add(AVFrameSideData ***sd, int *nb_sd, enum AVFrameSideDataType type, AVBufferRef **pbuf, unsigned int flags)
Add a new side data entry to an array from an existing AVBufferRef.
Definition: frame.c:846
AV_FRAME_DATA_DETECTION_BBOXES
@ AV_FRAME_DATA_DETECTION_BBOXES
Bounding boxes for object detection and classification, as described by AVDetectionBBoxHeader.
Definition: frame.h:194
AVFrame::nb_extended_buf
int nb_extended_buf
Number of elements in extended_buf.
Definition: frame.h:605