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 
32 {
33  memset(frame, 0, sizeof(*frame));
34 
35  frame->pts =
38  frame->duration = 0;
39 #if FF_API_FRAME_PKT
41  frame->pkt_pos = -1;
42  frame->pkt_size = -1;
44 #endif
45  frame->time_base = (AVRational){ 0, 1 };
47  frame->format = -1; /* unknown */
54  frame->flags = 0;
55 }
56 
57 static void free_side_data(AVFrameSideData **ptr_sd)
58 {
59  AVFrameSideData *sd = *ptr_sd;
60 
61  av_buffer_unref(&sd->buf);
62  av_dict_free(&sd->metadata);
63  av_freep(ptr_sd);
64 }
65 
67 {
68  for (int i = 0; i < frame->nb_side_data; i++) {
70  }
71  frame->nb_side_data = 0;
72 
74 }
75 
77 {
78  AVFrame *frame = av_malloc(sizeof(*frame));
79 
80  if (!frame)
81  return NULL;
82 
84 
85  return frame;
86 }
87 
89 {
90  if (!frame || !*frame)
91  return;
92 
94  av_freep(frame);
95 }
96 
98 {
100  int ret, padded_height, total_size;
101  int plane_padding = FFMAX(16 + 16/*STRIDE_ALIGN*/, align);
102  ptrdiff_t linesizes[4];
103  size_t sizes[4];
104 
105  if (!desc)
106  return AVERROR(EINVAL);
107 
108  if ((ret = av_image_check_size(frame->width, frame->height, 0, NULL)) < 0)
109  return ret;
110 
111  if (!frame->linesize[0]) {
112  if (align <= 0)
113  align = 32; /* STRIDE_ALIGN. Should be av_cpu_max_align() */
114 
115  for (int i = 1; i <= align; i += i) {
117  FFALIGN(frame->width, i));
118  if (ret < 0)
119  return ret;
120  if (!(frame->linesize[0] & (align-1)))
121  break;
122  }
123 
124  for (int i = 0; i < 4 && frame->linesize[i]; i++)
126  }
127 
128  for (int i = 0; i < 4; i++)
129  linesizes[i] = frame->linesize[i];
130 
131  padded_height = FFALIGN(frame->height, 32);
133  padded_height, linesizes)) < 0)
134  return ret;
135 
136  total_size = 4*plane_padding;
137  for (int i = 0; i < 4; i++) {
138  if (sizes[i] > INT_MAX - total_size)
139  return AVERROR(EINVAL);
140  total_size += sizes[i];
141  }
142 
143  frame->buf[0] = av_buffer_alloc(total_size);
144  if (!frame->buf[0]) {
145  ret = AVERROR(ENOMEM);
146  goto fail;
147  }
148 
149  if ((ret = av_image_fill_pointers(frame->data, frame->format, padded_height,
150  frame->buf[0]->data, frame->linesize)) < 0)
151  goto fail;
152 
153  for (int i = 1; i < 4; i++) {
154  if (frame->data[i])
155  frame->data[i] += i * plane_padding;
156  }
157 
159 
160  return 0;
161 fail:
163  return ret;
164 }
165 
167 {
169  int channels, planes;
170  int ret;
171 
173  planes = planar ? channels : 1;
174  if (!frame->linesize[0]) {
177  align);
178  if (ret < 0)
179  return ret;
180  }
181 
184  sizeof(*frame->extended_data));
186  sizeof(*frame->extended_buf));
187  if (!frame->extended_data || !frame->extended_buf) {
190  return AVERROR(ENOMEM);
191  }
193  } else
195 
196  for (int i = 0; i < FFMIN(planes, AV_NUM_DATA_POINTERS); i++) {
198  if (!frame->buf[i]) {
200  return AVERROR(ENOMEM);
201  }
202  frame->extended_data[i] = frame->data[i] = frame->buf[i]->data;
203  }
204  for (int i = 0; i < planes - AV_NUM_DATA_POINTERS; i++) {
206  if (!frame->extended_buf[i]) {
208  return AVERROR(ENOMEM);
209  }
211  }
212  return 0;
213 
214 }
215 
217 {
218  if (frame->format < 0)
219  return AVERROR(EINVAL);
220 
221  if (frame->width > 0 && frame->height > 0)
222  return get_video_buffer(frame, align);
223  else if (frame->nb_samples > 0 &&
225  return get_audio_buffer(frame, align);
226 
227  return AVERROR(EINVAL);
228 }
229 
230 static int frame_copy_props(AVFrame *dst, const AVFrame *src, int force_copy)
231 {
232  int ret;
233 
234 #if FF_API_FRAME_KEY
236  dst->key_frame = src->key_frame;
238 #endif
239  dst->pict_type = src->pict_type;
240  dst->sample_aspect_ratio = src->sample_aspect_ratio;
241  dst->crop_top = src->crop_top;
242  dst->crop_bottom = src->crop_bottom;
243  dst->crop_left = src->crop_left;
244  dst->crop_right = src->crop_right;
245  dst->pts = src->pts;
246  dst->duration = src->duration;
247  dst->repeat_pict = src->repeat_pict;
248 #if FF_API_INTERLACED_FRAME
250  dst->interlaced_frame = src->interlaced_frame;
251  dst->top_field_first = src->top_field_first;
253 #endif
254 #if FF_API_PALETTE_HAS_CHANGED
256  dst->palette_has_changed = src->palette_has_changed;
258 #endif
259  dst->sample_rate = src->sample_rate;
260  dst->opaque = src->opaque;
261  dst->pkt_dts = src->pkt_dts;
262 #if FF_API_FRAME_PKT
264  dst->pkt_pos = src->pkt_pos;
265  dst->pkt_size = src->pkt_size;
267 #endif
268  dst->time_base = src->time_base;
269  dst->quality = src->quality;
270  dst->best_effort_timestamp = src->best_effort_timestamp;
271  dst->flags = src->flags;
272  dst->decode_error_flags = src->decode_error_flags;
273  dst->color_primaries = src->color_primaries;
274  dst->color_trc = src->color_trc;
275  dst->colorspace = src->colorspace;
276  dst->color_range = src->color_range;
277  dst->chroma_location = src->chroma_location;
278 
279  av_dict_copy(&dst->metadata, src->metadata, 0);
280 
281  for (int i = 0; i < src->nb_side_data; i++) {
282  const AVFrameSideData *sd_src = src->side_data[i];
283  AVFrameSideData *sd_dst;
284  if ( sd_src->type == AV_FRAME_DATA_PANSCAN
285  && (src->width != dst->width || src->height != dst->height))
286  continue;
287  if (force_copy) {
288  sd_dst = av_frame_new_side_data(dst, sd_src->type,
289  sd_src->size);
290  if (!sd_dst) {
291  wipe_side_data(dst);
292  return AVERROR(ENOMEM);
293  }
294  memcpy(sd_dst->data, sd_src->data, sd_src->size);
295  } else {
296  AVBufferRef *ref = av_buffer_ref(sd_src->buf);
297  sd_dst = av_frame_new_side_data_from_buf(dst, sd_src->type, ref);
298  if (!sd_dst) {
300  wipe_side_data(dst);
301  return AVERROR(ENOMEM);
302  }
303  }
304  av_dict_copy(&sd_dst->metadata, sd_src->metadata, 0);
305  }
306 
307  ret = av_buffer_replace(&dst->opaque_ref, src->opaque_ref);
308  ret |= av_buffer_replace(&dst->private_ref, src->private_ref);
309  return ret;
310 }
311 
312 int av_frame_ref(AVFrame *dst, const AVFrame *src)
313 {
314  int ret = 0;
315 
316  av_assert1(dst->width == 0 && dst->height == 0);
317  av_assert1(dst->ch_layout.nb_channels == 0 &&
319 
320  dst->format = src->format;
321  dst->width = src->width;
322  dst->height = src->height;
323  dst->nb_samples = src->nb_samples;
324 
325  ret = frame_copy_props(dst, src, 0);
326  if (ret < 0)
327  goto fail;
328 
329  ret = av_channel_layout_copy(&dst->ch_layout, &src->ch_layout);
330  if (ret < 0)
331  goto fail;
332 
333  /* duplicate the frame data if it's not refcounted */
334  if (!src->buf[0]) {
335  ret = av_frame_get_buffer(dst, 0);
336  if (ret < 0)
337  goto fail;
338 
339  ret = av_frame_copy(dst, src);
340  if (ret < 0)
341  goto fail;
342 
343  return 0;
344  }
345 
346  /* ref the buffers */
347  for (int i = 0; i < FF_ARRAY_ELEMS(src->buf); i++) {
348  if (!src->buf[i])
349  continue;
350  dst->buf[i] = av_buffer_ref(src->buf[i]);
351  if (!dst->buf[i]) {
352  ret = AVERROR(ENOMEM);
353  goto fail;
354  }
355  }
356 
357  if (src->extended_buf) {
358  dst->extended_buf = av_calloc(src->nb_extended_buf,
359  sizeof(*dst->extended_buf));
360  if (!dst->extended_buf) {
361  ret = AVERROR(ENOMEM);
362  goto fail;
363  }
364  dst->nb_extended_buf = src->nb_extended_buf;
365 
366  for (int i = 0; i < src->nb_extended_buf; i++) {
367  dst->extended_buf[i] = av_buffer_ref(src->extended_buf[i]);
368  if (!dst->extended_buf[i]) {
369  ret = AVERROR(ENOMEM);
370  goto fail;
371  }
372  }
373  }
374 
375  if (src->hw_frames_ctx) {
376  dst->hw_frames_ctx = av_buffer_ref(src->hw_frames_ctx);
377  if (!dst->hw_frames_ctx) {
378  ret = AVERROR(ENOMEM);
379  goto fail;
380  }
381  }
382 
383  /* duplicate extended data */
384  if (src->extended_data != src->data) {
385  int ch = dst->ch_layout.nb_channels;
386 
387  if (!ch) {
388  ret = AVERROR(EINVAL);
389  goto fail;
390  }
391 
392  dst->extended_data = av_malloc_array(sizeof(*dst->extended_data), ch);
393  if (!dst->extended_data) {
394  ret = AVERROR(ENOMEM);
395  goto fail;
396  }
397  memcpy(dst->extended_data, src->extended_data, sizeof(*src->extended_data) * ch);
398  } else
399  dst->extended_data = dst->data;
400 
401  memcpy(dst->data, src->data, sizeof(src->data));
402  memcpy(dst->linesize, src->linesize, sizeof(src->linesize));
403 
404  return 0;
405 
406 fail:
407  av_frame_unref(dst);
408  return ret;
409 }
410 
412 {
413  int ret = 0;
414 
415  if (dst == src)
416  return AVERROR(EINVAL);
417 
418  if (!src->buf[0]) {
419  av_frame_unref(dst);
420 
421  /* duplicate the frame data if it's not refcounted */
422  if ( src->data[0] || src->data[1]
423  || src->data[2] || src->data[3])
424  return av_frame_ref(dst, src);
425 
426  ret = frame_copy_props(dst, src, 0);
427  if (ret < 0)
428  goto fail;
429  }
430 
431  dst->format = src->format;
432  dst->width = src->width;
433  dst->height = src->height;
434  dst->nb_samples = src->nb_samples;
435 
436  ret = av_channel_layout_copy(&dst->ch_layout, &src->ch_layout);
437  if (ret < 0)
438  goto fail;
439 
440  wipe_side_data(dst);
441  av_dict_free(&dst->metadata);
442  ret = frame_copy_props(dst, src, 0);
443  if (ret < 0)
444  goto fail;
445 
446  /* replace the buffers */
447  for (int i = 0; i < FF_ARRAY_ELEMS(src->buf); i++) {
448  ret = av_buffer_replace(&dst->buf[i], src->buf[i]);
449  if (ret < 0)
450  goto fail;
451  }
452 
453  if (src->extended_buf) {
454  if (dst->nb_extended_buf != src->nb_extended_buf) {
455  int nb_extended_buf = FFMIN(dst->nb_extended_buf, src->nb_extended_buf);
456  void *tmp;
457 
458  for (int i = nb_extended_buf; i < dst->nb_extended_buf; i++)
460 
461  tmp = av_realloc_array(dst->extended_buf, sizeof(*dst->extended_buf),
462  src->nb_extended_buf);
463  if (!tmp) {
464  ret = AVERROR(ENOMEM);
465  goto fail;
466  }
467  dst->extended_buf = tmp;
468  dst->nb_extended_buf = src->nb_extended_buf;
469 
470  memset(&dst->extended_buf[nb_extended_buf], 0,
471  (src->nb_extended_buf - nb_extended_buf) * sizeof(*dst->extended_buf));
472  }
473 
474  for (int i = 0; i < src->nb_extended_buf; i++) {
475  ret = av_buffer_replace(&dst->extended_buf[i], src->extended_buf[i]);
476  if (ret < 0)
477  goto fail;
478  }
479  } else if (dst->extended_buf) {
480  for (int i = 0; i < dst->nb_extended_buf; i++)
482  av_freep(&dst->extended_buf);
483  }
484 
485  ret = av_buffer_replace(&dst->hw_frames_ctx, src->hw_frames_ctx);
486  if (ret < 0)
487  goto fail;
488 
489  if (dst->extended_data != dst->data)
490  av_freep(&dst->extended_data);
491 
492  if (src->extended_data != src->data) {
493  int ch = dst->ch_layout.nb_channels;
494 
495  if (!ch) {
496  ret = AVERROR(EINVAL);
497  goto fail;
498  }
499 
500  if (ch > SIZE_MAX / sizeof(*dst->extended_data))
501  goto fail;
502 
503  dst->extended_data = av_memdup(src->extended_data, sizeof(*dst->extended_data) * ch);
504  if (!dst->extended_data) {
505  ret = AVERROR(ENOMEM);
506  goto fail;
507  }
508  } else
509  dst->extended_data = dst->data;
510 
511  memcpy(dst->data, src->data, sizeof(src->data));
512  memcpy(dst->linesize, src->linesize, sizeof(src->linesize));
513 
514  return 0;
515 
516 fail:
517  av_frame_unref(dst);
518  return ret;
519 }
520 
522 {
524 
525  if (!ret)
526  return NULL;
527 
528  if (av_frame_ref(ret, src) < 0)
529  av_frame_free(&ret);
530 
531  return ret;
532 }
533 
535 {
536  if (!frame)
537  return;
538 
540 
541  for (int i = 0; i < FF_ARRAY_ELEMS(frame->buf); i++)
543  for (int i = 0; i < frame->nb_extended_buf; i++)
547 
549 
552 
553  if (frame->extended_data != frame->data)
555 
557 
559 }
560 
562 {
563  av_assert1(dst->width == 0 && dst->height == 0);
564  av_assert1(dst->ch_layout.nb_channels == 0 &&
566 
567  *dst = *src;
568  if (src->extended_data == src->data)
569  dst->extended_data = dst->data;
571 }
572 
574 {
575  int ret = 1;
576 
577  /* assume non-refcounted frames are not writable */
578  if (!frame->buf[0])
579  return 0;
580 
581  for (int i = 0; i < FF_ARRAY_ELEMS(frame->buf); i++)
582  if (frame->buf[i])
584  for (int i = 0; i < frame->nb_extended_buf; i++)
586 
587  return ret;
588 }
589 
591 {
592  AVFrame tmp;
593  int ret;
594 
596  return 0;
597 
598  memset(&tmp, 0, sizeof(tmp));
599  tmp.format = frame->format;
600  tmp.width = frame->width;
601  tmp.height = frame->height;
602  tmp.nb_samples = frame->nb_samples;
603  ret = av_channel_layout_copy(&tmp.ch_layout, &frame->ch_layout);
604  if (ret < 0) {
606  return ret;
607  }
608 
609  if (frame->hw_frames_ctx)
611  else
612  ret = av_frame_get_buffer(&tmp, 0);
613  if (ret < 0)
614  return ret;
615 
616  ret = av_frame_copy(&tmp, frame);
617  if (ret < 0) {
619  return ret;
620  }
621 
623  if (ret < 0) {
625  return ret;
626  }
627 
629 
630  *frame = tmp;
631  if (tmp.data == tmp.extended_data)
633 
634  return 0;
635 }
636 
638 {
639  return frame_copy_props(dst, src, 1);
640 }
641 
643 {
644  uint8_t *data;
645  int planes;
646 
647  if (frame->nb_samples) {
649  if (!channels)
650  return NULL;
652  } else
653  planes = 4;
654 
655  if (plane < 0 || plane >= planes || !frame->extended_data[plane])
656  return NULL;
657  data = frame->extended_data[plane];
658 
659  for (int i = 0; i < FF_ARRAY_ELEMS(frame->buf) && frame->buf[i]; i++) {
660  AVBufferRef *buf = frame->buf[i];
661  if (data >= buf->data && data < buf->data + buf->size)
662  return buf;
663  }
664  for (int i = 0; i < frame->nb_extended_buf; i++) {
665  AVBufferRef *buf = frame->extended_buf[i];
666  if (data >= buf->data && data < buf->data + buf->size)
667  return buf;
668  }
669  return NULL;
670 }
671 
674  AVBufferRef *buf)
675 {
676  AVFrameSideData *ret, **tmp;
677 
678  if (!buf)
679  return NULL;
680 
681  if (frame->nb_side_data > INT_MAX / sizeof(*frame->side_data) - 1)
682  return NULL;
683 
685  (frame->nb_side_data + 1) * sizeof(*frame->side_data));
686  if (!tmp)
687  return NULL;
688  frame->side_data = tmp;
689 
690  ret = av_mallocz(sizeof(*ret));
691  if (!ret)
692  return NULL;
693 
694  ret->buf = buf;
695  ret->data = ret->buf->data;
696  ret->size = buf->size;
697  ret->type = type;
698 
700 
701  return ret;
702 }
703 
706  size_t size)
707 {
711  if (!ret)
712  av_buffer_unref(&buf);
713  return ret;
714 }
715 
718 {
719  for (int i = 0; i < frame->nb_side_data; i++) {
720  if (frame->side_data[i]->type == type)
721  return frame->side_data[i];
722  }
723  return NULL;
724 }
725 
726 static int frame_copy_video(AVFrame *dst, const AVFrame *src)
727 {
728  int planes;
729 
730  if (dst->width < src->width ||
731  dst->height < src->height)
732  return AVERROR(EINVAL);
733 
734  if (src->hw_frames_ctx || dst->hw_frames_ctx)
735  return av_hwframe_transfer_data(dst, src, 0);
736 
738  for (int i = 0; i < planes; i++)
739  if (!dst->data[i] || !src->data[i])
740  return AVERROR(EINVAL);
741 
742  av_image_copy2(dst->data, dst->linesize,
743  src->data, src->linesize,
744  dst->format, src->width, src->height);
745 
746  return 0;
747 }
748 
749 static int frame_copy_audio(AVFrame *dst, const AVFrame *src)
750 {
752  int channels = dst->ch_layout.nb_channels;
753  int planes = planar ? channels : 1;
754 
755  if (dst->nb_samples != src->nb_samples ||
756  av_channel_layout_compare(&dst->ch_layout, &src->ch_layout))
757  return AVERROR(EINVAL);
758 
759  for (int i = 0; i < planes; i++)
760  if (!dst->extended_data[i] || !src->extended_data[i])
761  return AVERROR(EINVAL);
762 
763  av_samples_copy(dst->extended_data, src->extended_data, 0, 0,
764  dst->nb_samples, channels, dst->format);
765 
766  return 0;
767 }
768 
769 int av_frame_copy(AVFrame *dst, const AVFrame *src)
770 {
771  if (dst->format != src->format || dst->format < 0)
772  return AVERROR(EINVAL);
773 
774  if (dst->width > 0 && dst->height > 0)
775  return frame_copy_video(dst, src);
776  else if (dst->nb_samples > 0 &&
778  return frame_copy_audio(dst, src);
779 
780  return AVERROR(EINVAL);
781 }
782 
784 {
785  for (int i = frame->nb_side_data - 1; i >= 0; i--) {
787  if (sd->type == type) {
790  frame->nb_side_data--;
791  }
792  }
793 }
794 
796 {
797  switch(type) {
798  case AV_FRAME_DATA_PANSCAN: return "AVPanScan";
799  case AV_FRAME_DATA_A53_CC: return "ATSC A53 Part 4 Closed Captions";
800  case AV_FRAME_DATA_STEREO3D: return "Stereo 3D";
801  case AV_FRAME_DATA_MATRIXENCODING: return "AVMatrixEncoding";
802  case AV_FRAME_DATA_DOWNMIX_INFO: return "Metadata relevant to a downmix procedure";
803  case AV_FRAME_DATA_REPLAYGAIN: return "AVReplayGain";
804  case AV_FRAME_DATA_DISPLAYMATRIX: return "3x3 displaymatrix";
805  case AV_FRAME_DATA_AFD: return "Active format description";
806  case AV_FRAME_DATA_MOTION_VECTORS: return "Motion vectors";
807  case AV_FRAME_DATA_SKIP_SAMPLES: return "Skip samples";
808  case AV_FRAME_DATA_AUDIO_SERVICE_TYPE: return "Audio service type";
809  case AV_FRAME_DATA_MASTERING_DISPLAY_METADATA: return "Mastering display metadata";
810  case AV_FRAME_DATA_CONTENT_LIGHT_LEVEL: return "Content light level metadata";
811  case AV_FRAME_DATA_GOP_TIMECODE: return "GOP timecode";
812  case AV_FRAME_DATA_S12M_TIMECODE: return "SMPTE 12-1 timecode";
813  case AV_FRAME_DATA_SPHERICAL: return "Spherical Mapping";
814  case AV_FRAME_DATA_ICC_PROFILE: return "ICC profile";
815  case AV_FRAME_DATA_DYNAMIC_HDR_PLUS: return "HDR Dynamic Metadata SMPTE2094-40 (HDR10+)";
816  case AV_FRAME_DATA_DYNAMIC_HDR_VIVID: return "HDR Dynamic Metadata CUVA 005.1 2021 (Vivid)";
817  case AV_FRAME_DATA_REGIONS_OF_INTEREST: return "Regions Of Interest";
818  case AV_FRAME_DATA_VIDEO_ENC_PARAMS: return "Video encoding parameters";
819  case AV_FRAME_DATA_SEI_UNREGISTERED: return "H.26[45] User Data Unregistered SEI message";
820  case AV_FRAME_DATA_FILM_GRAIN_PARAMS: return "Film grain parameters";
821  case AV_FRAME_DATA_DETECTION_BBOXES: return "Bounding boxes for object detection and classification";
822  case AV_FRAME_DATA_DOVI_RPU_BUFFER: return "Dolby Vision RPU Data";
823  case AV_FRAME_DATA_DOVI_METADATA: return "Dolby Vision Metadata";
824  case AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT: return "Ambient viewing environment";
825  }
826  return NULL;
827 }
828 
829 static int calc_cropping_offsets(size_t offsets[4], const AVFrame *frame,
830  const AVPixFmtDescriptor *desc)
831 {
832  for (int i = 0; frame->data[i]; i++) {
834  int shift_x = (i == 1 || i == 2) ? desc->log2_chroma_w : 0;
835  int shift_y = (i == 1 || i == 2) ? desc->log2_chroma_h : 0;
836 
837  if (desc->flags & AV_PIX_FMT_FLAG_PAL && i == 1) {
838  offsets[i] = 0;
839  break;
840  }
841 
842  /* find any component descriptor for this plane */
843  for (int j = 0; j < desc->nb_components; j++) {
844  if (desc->comp[j].plane == i) {
845  comp = &desc->comp[j];
846  break;
847  }
848  }
849  if (!comp)
850  return AVERROR_BUG;
851 
852  offsets[i] = (frame->crop_top >> shift_y) * frame->linesize[i] +
853  (frame->crop_left >> shift_x) * comp->step;
854  }
855 
856  return 0;
857 }
858 
860 {
861  const AVPixFmtDescriptor *desc;
862  size_t offsets[4];
863 
864  if (!(frame->width > 0 && frame->height > 0))
865  return AVERROR(EINVAL);
866 
867  if (frame->crop_left >= INT_MAX - frame->crop_right ||
868  frame->crop_top >= INT_MAX - frame->crop_bottom ||
871  return AVERROR(ERANGE);
872 
874  if (!desc)
875  return AVERROR_BUG;
876 
877  /* Apply just the right/bottom cropping for hwaccel formats. Bitstream
878  * formats cannot be easily handled here either (and corresponding decoders
879  * should not export any cropping anyway), so do the same for those as well.
880  * */
884  frame->crop_right = 0;
885  frame->crop_bottom = 0;
886  return 0;
887  }
888 
889  /* calculate the offsets for each plane */
891 
892  /* adjust the offsets to avoid breaking alignment */
893  if (!(flags & AV_FRAME_CROP_UNALIGNED)) {
894  int log2_crop_align = frame->crop_left ? ff_ctz(frame->crop_left) : INT_MAX;
895  int min_log2_align = INT_MAX;
896 
897  for (int i = 0; frame->data[i]; i++) {
898  int log2_align = offsets[i] ? ff_ctz(offsets[i]) : INT_MAX;
899  min_log2_align = FFMIN(log2_align, min_log2_align);
900  }
901 
902  /* we assume, and it should always be true, that the data alignment is
903  * related to the cropping alignment by a constant power-of-2 factor */
904  if (log2_crop_align < min_log2_align)
905  return AVERROR_BUG;
906 
907  if (min_log2_align < 5) {
908  frame->crop_left &= ~((1 << (5 + log2_crop_align - min_log2_align)) - 1);
910  }
911  }
912 
913  for (int i = 0; frame->data[i]; i++)
914  frame->data[i] += offsets[i];
915 
918  frame->crop_left = 0;
919  frame->crop_right = 0;
920  frame->crop_top = 0;
921  frame->crop_bottom = 0;
922 
923  return 0;
924 }
AVFrame::extended_buf
AVBufferRef ** extended_buf
For planar audio which requires more than AV_NUM_DATA_POINTERS AVBufferRef pointers,...
Definition: frame.h:567
AVFrame::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: frame.h:623
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:57
AVFrame::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: frame.h:619
AVFrame::palette_has_changed
attribute_deprecated int palette_has_changed
Tell user application that palette has changed from previous frame.
Definition: frame.h:533
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:97
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:216
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:716
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:704
AVFrame::duration
int64_t duration
Duration of the frame, in the same units as pts.
Definition: frame.h:746
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2962
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
AVFrame::nb_side_data
int nb_side_data
Definition: frame.h:574
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:621
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:88
AVFrame::opaque
void * opaque
Frame owner's private data.
Definition: frame.h:488
AVFrame::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:630
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
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:590
AVFrameSideData::buf
AVBufferRef * buf
Definition: frame.h:251
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:452
AVFrame::width
int width
Definition: frame.h:412
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:197
frame_copy_props
static int frame_copy_props(AVFrame *dst, const AVFrame *src, int force_copy)
Definition: frame.c:230
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:166
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:612
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
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:553
frame_copy_video
static int frame_copy_video(AVFrame *dst, const AVFrame *src)
Definition: frame.c:726
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:859
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
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:302
AVFrame::opaque_ref
AVBufferRef * opaque_ref
Frame owner's private data.
Definition: frame.h:707
AVFrame::chroma_location
enum AVChromaLocation chroma_location
Definition: frame.h:632
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3002
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:179
AV_PIX_FMT_FLAG_HWACCEL
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:128
samplefmt.h
wipe_side_data
static void wipe_side_data(AVFrame *frame)
Definition: frame.c:66
AVFrame::ch_layout
AVChannelLayout ch_layout
Channel layout of the audio data.
Definition: frame.h:741
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:76
get_frame_defaults
static void get_frame_defaults(AVFrame *frame)
Definition: frame.c:31
AVFrame::interlaced_frame
attribute_deprecated int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:517
avassert.h
AVFrameSideData::size
size_t size
Definition: frame.h:249
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
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:215
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
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:521
AVFrame::pkt_size
attribute_deprecated int pkt_size
size of the corresponding packet containing the compressed frame.
Definition: frame.h:684
AVFrame::crop_right
size_t crop_right
Definition: frame.h:720
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:436
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
static AVFrame * frame
Definition: demux_decode.c:54
frame_copy_audio
static int frame_copy_audio(AVFrame *dst, const AVFrame *src)
Definition: frame.c:749
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:637
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_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:672
AVFrame::pkt_dts
int64_t pkt_dts
DTS copied from the AVPacket that triggered returning this frame.
Definition: frame.h:459
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:642
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:649
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:718
AVFrame::best_effort_timestamp
int64_t best_effort_timestamp
frame timestamp estimated using various heuristics, in stream time base
Definition: frame.h:639
AVFrame::crop_left
size_t crop_left
Definition: frame.h:719
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:442
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:312
av_frame_copy
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:769
cpu.h
AVFrame::quality
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:472
AVFrame::sample_rate
int sample_rate
Sample rate of the audio data.
Definition: frame.h:539
size
int size
Definition: twinvq_data.h:10344
AV_NUM_DATA_POINTERS
#define AV_NUM_DATA_POINTERS
Definition: frame.h:341
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:467
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:248
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:573
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:703
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:650
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:427
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:783
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:800
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:736
AV_FRAME_DATA_SKIP_SAMPLES
@ AV_FRAME_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: frame.h:109
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:965
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:420
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:255
AVFrame::top_field_first
attribute_deprecated int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:525
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:401
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:561
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:534
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
AVFrame::side_data
AVFrameSideData ** side_data
Definition: frame.h:573
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: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:667
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
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:774
planes
static const struct @383 planes[]
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:447
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:691
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:411
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:412
channel_layout.h
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:658
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:432
AVFrameSideData::type
enum AVFrameSideDataType type
Definition: frame.h:247
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:439
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
desc
const char * desc
Definition: libsvtav1.c:73
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:246
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
calc_cropping_offsets
static int calc_cropping_offsets(size_t offsets[4], const AVFrame *frame, const AVPixFmtDescriptor *desc)
Definition: frame.c:829
AVFrame::crop_top
size_t crop_top
Definition: frame.h:717
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:795
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:385
AVFrameSideData::metadata
AVDictionary * metadata
Definition: frame.h:250
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
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:508
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:571
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:153