FFmpeg
frame.h
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 /**
20  * @file
21  * @ingroup lavu_frame
22  * reference-counted frame API
23  */
24 
25 #ifndef AVUTIL_FRAME_H
26 #define AVUTIL_FRAME_H
27 
28 #include <stddef.h>
29 #include <stdint.h>
30 
31 #include "avutil.h"
32 #include "buffer.h"
33 #include "channel_layout.h"
34 #include "dict.h"
35 #include "rational.h"
36 #include "samplefmt.h"
37 #include "pixfmt.h"
38 #include "version.h"
39 
40 
41 /**
42  * @defgroup lavu_frame AVFrame
43  * @ingroup lavu_data
44  *
45  * @{
46  * AVFrame is an abstraction for reference-counted raw multimedia data.
47  */
48 
50  /**
51  * The data is the AVPanScan struct defined in libavcodec.
52  */
54  /**
55  * ATSC A53 Part 4 Closed Captions.
56  * A53 CC bitstream is stored as uint8_t in AVFrameSideData.data.
57  * The number of bytes of CC data is AVFrameSideData.size.
58  */
60  /**
61  * Stereoscopic 3d metadata.
62  * The data is the AVStereo3D struct defined in libavutil/stereo3d.h.
63  */
65  /**
66  * The data is the AVMatrixEncoding enum defined in libavutil/channel_layout.h.
67  */
69  /**
70  * Metadata relevant to a downmix procedure.
71  * The data is the AVDownmixInfo struct defined in libavutil/downmix_info.h.
72  */
74  /**
75  * ReplayGain information in the form of the AVReplayGain struct.
76  */
78  /**
79  * This side data contains a 3x3 transformation matrix describing an affine
80  * transformation that needs to be applied to the frame for correct
81  * presentation.
82  *
83  * See libavutil/display.h for a detailed description of the data.
84  */
86  /**
87  * Active Format Description data consisting of a single byte as specified
88  * in ETSI TS 101 154 using AVActiveFormatDescription enum.
89  */
91  /**
92  * Motion vectors exported by some codecs (on demand through the export_mvs
93  * flag set in the libavcodec AVCodecContext flags2 option).
94  * The data is the AVMotionVector struct defined in
95  * libavutil/motion_vector.h.
96  */
98  /**
99  * Recommmends skipping the specified number of samples. This is exported
100  * only if the "skip_manual" AVOption is set in libavcodec.
101  * This has the same format as AV_PKT_DATA_SKIP_SAMPLES.
102  * @code
103  * u32le number of samples to skip from start of this packet
104  * u32le number of samples to skip from end of this packet
105  * u8 reason for start skip
106  * u8 reason for end skip (0=padding silence, 1=convergence)
107  * @endcode
108  */
110  /**
111  * This side data must be associated with an audio frame and corresponds to
112  * enum AVAudioServiceType defined in avcodec.h.
113  */
115  /**
116  * Mastering display metadata associated with a video frame. The payload is
117  * an AVMasteringDisplayMetadata type and contains information about the
118  * mastering display color volume.
119  */
121  /**
122  * The GOP timecode in 25 bit timecode format. Data format is 64-bit integer.
123  * This is set on the first frame of a GOP that has a temporal reference of 0.
124  */
126 
127  /**
128  * The data represents the AVSphericalMapping structure defined in
129  * libavutil/spherical.h.
130  */
132 
133  /**
134  * Content light level (based on CTA-861.3). This payload contains data in
135  * the form of the AVContentLightMetadata struct.
136  */
138 
139  /**
140  * The data contains an ICC profile as an opaque octet buffer following the
141  * format described by ISO 15076-1 with an optional name defined in the
142  * metadata key entry "name".
143  */
145 
146  /**
147  * Timecode which conforms to SMPTE ST 12-1. The data is an array of 4 uint32_t
148  * where the first uint32_t describes how many (1-3) of the other timecodes are used.
149  * The timecode format is described in the documentation of av_timecode_get_smpte_from_framenum()
150  * function in libavutil/timecode.h.
151  */
153 
154  /**
155  * HDR dynamic metadata associated with a video frame. The payload is
156  * an AVDynamicHDRPlus type and contains information for color
157  * volume transform - application 4 of SMPTE 2094-40:2016 standard.
158  */
160 
161  /**
162  * Regions Of Interest, the data is an array of AVRegionOfInterest type, the number of
163  * array element is implied by AVFrameSideData.size / AVRegionOfInterest.self_size.
164  */
166 
167  /**
168  * Encoding parameters for a video frame, as described by AVVideoEncParams.
169  */
171 
172  /**
173  * User data unregistered metadata associated with a video frame.
174  * This is the H.26[45] UDU SEI message, and shouldn't be used for any other purpose
175  * The data is stored as uint8_t in AVFrameSideData.data which is 16 bytes of
176  * uuid_iso_iec_11578 followed by AVFrameSideData.size - 16 bytes of user_data_payload_byte.
177  */
179 
180  /**
181  * Film grain parameters for a frame, described by AVFilmGrainParams.
182  * Must be present for every frame which should have film grain applied.
183  *
184  * May be present multiple times, for example when there are multiple
185  * alternative parameter sets for different video signal characteristics.
186  * The user should select the most appropriate set for the application.
187  */
189 
190  /**
191  * Bounding boxes for object detection and classification,
192  * as described by AVDetectionBBoxHeader.
193  */
195 
196  /**
197  * Dolby Vision RPU raw data, suitable for passing to x265
198  * or other libraries. Array of uint8_t, with NAL emulation
199  * bytes intact.
200  */
202 
203  /**
204  * Parsed Dolby Vision metadata, suitable for passing to a software
205  * implementation. The payload is the AVDOVIMetadata struct defined in
206  * libavutil/dovi_meta.h.
207  */
209 
210  /**
211  * HDR Vivid dynamic metadata associated with a video frame. The payload is
212  * an AVDynamicHDRVivid type and contains information for color
213  * volume transform - CUVA 005.1-2021.
214  */
216 
217  /**
218  * Ambient viewing environment metadata, as defined by H.274.
219  */
221 
222  /**
223  * Provide encoder-specific hinting information about changed/unchanged
224  * portions of a frame. It can be used to pass information about which
225  * macroblocks can be skipped because they didn't change from the
226  * corresponding ones in the previous frame. This could be useful for
227  * applications which know this information in advance to speed up
228  * encoding.
229  */
231 
232  /**
233  * Raw LCEVC payload data, as a uint8_t array, with NAL emulation
234  * bytes intact.
235  */
237 
238  /**
239  * This side data must be associated with a video frame.
240  * The presence of this side data indicates that the video stream is
241  * composed of multiple views (e.g. stereoscopic 3D content,
242  * cf. H.264 Annex H or H.265 Annex G).
243  * The data is an int storing the view ID.
244  */
246 
247  /**
248  * This side data contains information about the reference display width(s)
249  * and reference viewing distance(s) as well as information about the
250  * corresponding reference stereo pair(s), i.e., the pair(s) of views to be
251  * displayed for the viewer's left and right eyes on the reference display
252  * at the reference viewing distance.
253  * The payload is the AV3DReferenceDisplaysInfo struct defined in
254  * libavutil/tdrdi.h.
255  */
257 };
258 
267 };
268 
269 
270 /**
271  * Structure to hold side data for an AVFrame.
272  *
273  * sizeof(AVFrameSideData) is not a part of the public ABI, so new fields may be added
274  * to the end with a minor bump.
275  */
276 typedef struct AVFrameSideData {
278  uint8_t *data;
279  size_t size;
283 
285  /**
286  * The side data type can be used in stream-global structures.
287  * Side data types without this property are only meaningful on per-frame
288  * basis.
289  */
291 
292  /**
293  * Multiple instances of this side data type can be meaningfully present in
294  * a single side data array.
295  */
297 
298  /**
299  * Side data depends on the video dimensions. Side data with this property
300  * loses its meaning when rescaling or cropping the image, unless
301  * either recomputed or adjusted to the new resolution.
302  */
304 
305  /**
306  * Side data depends on the video color space. Side data with this property
307  * loses its meaning when changing the video color encoding, e.g. by
308  * adapting to a different set of primaries or transfer characteristics.
309  */
311 
312  /**
313  * Side data depends on the channel layout. Side data with this property
314  * loses its meaning when downmixing or upmixing, unless either recomputed
315  * or adjusted to the new layout.
316  */
318 };
319 
320 /**
321  * This struct describes the properties of a side data type. Its instance
322  * corresponding to a given type can be obtained from av_frame_side_data_desc().
323  */
324 typedef struct AVSideDataDescriptor {
325  /**
326  * Human-readable side data description.
327  */
328  const char *name;
329 
330  /**
331  * Side data property flags, a combination of AVSideDataProps values.
332  */
333  unsigned props;
335 
336 /**
337  * Structure describing a single Region Of Interest.
338  *
339  * When multiple regions are defined in a single side-data block, they
340  * should be ordered from most to least important - some encoders are only
341  * capable of supporting a limited number of distinct regions, so will have
342  * to truncate the list.
343  *
344  * When overlapping regions are defined, the first region containing a given
345  * area of the frame applies.
346  */
347 typedef struct AVRegionOfInterest {
348  /**
349  * Must be set to the size of this data structure (that is,
350  * sizeof(AVRegionOfInterest)).
351  */
352  uint32_t self_size;
353  /**
354  * Distance in pixels from the top edge of the frame to the top and
355  * bottom edges and from the left edge of the frame to the left and
356  * right edges of the rectangle defining this region of interest.
357  *
358  * The constraints on a region are encoder dependent, so the region
359  * actually affected may be slightly larger for alignment or other
360  * reasons.
361  */
362  int top;
363  int bottom;
364  int left;
365  int right;
366  /**
367  * Quantisation offset.
368  *
369  * Must be in the range -1 to +1. A value of zero indicates no quality
370  * change. A negative value asks for better quality (less quantisation),
371  * while a positive value asks for worse quality (greater quantisation).
372  *
373  * The range is calibrated so that the extreme values indicate the
374  * largest possible offset - if the rest of the frame is encoded with the
375  * worst possible quality, an offset of -1 indicates that this region
376  * should be encoded with the best possible quality anyway. Intermediate
377  * values are then interpolated in some codec-dependent way.
378  *
379  * For example, in 10-bit H.264 the quantisation parameter varies between
380  * -12 and 51. A typical qoffset value of -1/10 therefore indicates that
381  * this region should be encoded with a QP around one-tenth of the full
382  * range better than the rest of the frame. So, if most of the frame
383  * were to be encoded with a QP of around 30, this region would get a QP
384  * of around 24 (an offset of approximately -1/10 * (51 - -12) = -6.3).
385  * An extreme value of -1 would indicate that this region should be
386  * encoded with the best possible quality regardless of the treatment of
387  * the rest of the frame - that is, should be encoded at a QP of -12.
388  */
391 
392 /**
393  * This structure describes decoded (raw) audio or video data.
394  *
395  * AVFrame must be allocated using av_frame_alloc(). Note that this only
396  * allocates the AVFrame itself, the buffers for the data must be managed
397  * through other means (see below).
398  * AVFrame must be freed with av_frame_free().
399  *
400  * AVFrame is typically allocated once and then reused multiple times to hold
401  * different data (e.g. a single AVFrame to hold frames received from a
402  * decoder). In such a case, av_frame_unref() will free any references held by
403  * the frame and reset it to its original clean state before it
404  * is reused again.
405  *
406  * The data described by an AVFrame is usually reference counted through the
407  * AVBuffer API. The underlying buffer references are stored in AVFrame.buf /
408  * AVFrame.extended_buf. An AVFrame is considered to be reference counted if at
409  * least one reference is set, i.e. if AVFrame.buf[0] != NULL. In such a case,
410  * every single data plane must be contained in one of the buffers in
411  * AVFrame.buf or AVFrame.extended_buf.
412  * There may be a single buffer for all the data, or one separate buffer for
413  * each plane, or anything in between.
414  *
415  * sizeof(AVFrame) is not a part of the public ABI, so new fields may be added
416  * to the end with a minor bump.
417  *
418  * Fields can be accessed through AVOptions, the name string used, matches the
419  * C structure field name for fields accessible through AVOptions.
420  */
421 typedef struct AVFrame {
422 #define AV_NUM_DATA_POINTERS 8
423  /**
424  * pointer to the picture/channel planes.
425  * This might be different from the first allocated byte. For video,
426  * it could even point to the end of the image data.
427  *
428  * All pointers in data and extended_data must point into one of the
429  * AVBufferRef in buf or extended_buf.
430  *
431  * Some decoders access areas outside 0,0 - width,height, please
432  * see avcodec_align_dimensions2(). Some filters and swscale can read
433  * up to 16 bytes beyond the planes, if these filters are to be used,
434  * then 16 extra bytes must be allocated.
435  *
436  * NOTE: Pointers not needed by the format MUST be set to NULL.
437  *
438  * @attention In case of video, the data[] pointers can point to the
439  * end of image data in order to reverse line order, when used in
440  * combination with negative values in the linesize[] array.
441  */
443 
444  /**
445  * For video, a positive or negative value, which is typically indicating
446  * the size in bytes of each picture line, but it can also be:
447  * - the negative byte size of lines for vertical flipping
448  * (with data[n] pointing to the end of the data
449  * - a positive or negative multiple of the byte size as for accessing
450  * even and odd fields of a frame (possibly flipped)
451  *
452  * For audio, only linesize[0] may be set. For planar audio, each channel
453  * plane must be the same size.
454  *
455  * For video the linesizes should be multiples of the CPUs alignment
456  * preference, this is 16 or 32 for modern desktop CPUs.
457  * Some code requires such alignment other code can be slower without
458  * correct alignment, for yet other it makes no difference.
459  *
460  * @note The linesize may be larger than the size of usable data -- there
461  * may be extra padding present for performance reasons.
462  *
463  * @attention In case of video, line size values can be negative to achieve
464  * a vertically inverted iteration over image lines.
465  */
467 
468  /**
469  * pointers to the data planes/channels.
470  *
471  * For video, this should simply point to data[].
472  *
473  * For planar audio, each channel has a separate data pointer, and
474  * linesize[0] contains the size of each channel buffer.
475  * For packed audio, there is just one data pointer, and linesize[0]
476  * contains the total size of the buffer for all channels.
477  *
478  * Note: Both data and extended_data should always be set in a valid frame,
479  * but for planar audio with more channels that can fit in data,
480  * extended_data must be used in order to access all channels.
481  */
482  uint8_t **extended_data;
483 
484  /**
485  * @name Video dimensions
486  * Video frames only. The coded dimensions (in pixels) of the video frame,
487  * i.e. the size of the rectangle that contains some well-defined values.
488  *
489  * @note The part of the frame intended for display/presentation is further
490  * restricted by the @ref cropping "Cropping rectangle".
491  * @{
492  */
493  int width, height;
494  /**
495  * @}
496  */
497 
498  /**
499  * number of audio samples (per channel) described by this frame
500  */
502 
503  /**
504  * format of the frame, -1 if unknown or unset
505  * Values correspond to enum AVPixelFormat for video frames,
506  * enum AVSampleFormat for audio)
507  */
508  int format;
509 
510  /**
511  * Picture type of the frame.
512  */
514 
515  /**
516  * Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
517  */
519 
520  /**
521  * Presentation timestamp in time_base units (time when frame should be shown to user).
522  */
524 
525  /**
526  * DTS copied from the AVPacket that triggered returning this frame. (if frame threading isn't used)
527  * This is also the Presentation time of this AVFrame calculated from
528  * only AVPacket.dts values without pts values.
529  */
531 
532  /**
533  * Time base for the timestamps in this frame.
534  * In the future, this field may be set on frames output by decoders or
535  * filters, but its value will be by default ignored on input to encoders
536  * or filters.
537  */
539 
540  /**
541  * quality (between 1 (good) and FF_LAMBDA_MAX (bad))
542  */
543  int quality;
544 
545  /**
546  * Frame owner's private data.
547  *
548  * This field may be set by the code that allocates/owns the frame data.
549  * It is then not touched by any library functions, except:
550  * - it is copied to other references by av_frame_copy_props() (and hence by
551  * av_frame_ref());
552  * - it is set to NULL when the frame is cleared by av_frame_unref()
553  * - on the caller's explicit request. E.g. libavcodec encoders/decoders
554  * will copy this field to/from @ref AVPacket "AVPackets" if the caller sets
555  * @ref AV_CODEC_FLAG_COPY_OPAQUE.
556  *
557  * @see opaque_ref the reference-counted analogue
558  */
559  void *opaque;
560 
561  /**
562  * Number of fields in this frame which should be repeated, i.e. the total
563  * duration of this frame should be repeat_pict + 2 normal field durations.
564  *
565  * For interlaced frames this field may be set to 1, which signals that this
566  * frame should be presented as 3 fields: beginning with the first field (as
567  * determined by AV_FRAME_FLAG_TOP_FIELD_FIRST being set or not), followed
568  * by the second field, and then the first field again.
569  *
570  * For progressive frames this field may be set to a multiple of 2, which
571  * signals that this frame's duration should be (repeat_pict + 2) / 2
572  * normal frame durations.
573  *
574  * @note This field is computed from MPEG2 repeat_first_field flag and its
575  * associated flags, H.264 pic_struct from picture timing SEI, and
576  * their analogues in other codecs. Typically it should only be used when
577  * higher-layer timing information is not available.
578  */
580 
581  /**
582  * Sample rate of the audio data.
583  */
585 
586  /**
587  * AVBuffer references backing the data for this frame. All the pointers in
588  * data and extended_data must point inside one of the buffers in buf or
589  * extended_buf. This array must be filled contiguously -- if buf[i] is
590  * non-NULL then buf[j] must also be non-NULL for all j < i.
591  *
592  * There may be at most one AVBuffer per data plane, so for video this array
593  * always contains all the references. For planar audio with more than
594  * AV_NUM_DATA_POINTERS channels, there may be more buffers than can fit in
595  * this array. Then the extra AVBufferRef pointers are stored in the
596  * extended_buf array.
597  */
599 
600  /**
601  * For planar audio which requires more than AV_NUM_DATA_POINTERS
602  * AVBufferRef pointers, this array will hold all the references which
603  * cannot fit into AVFrame.buf.
604  *
605  * Note that this is different from AVFrame.extended_data, which always
606  * contains all the pointers. This array only contains the extra pointers,
607  * which cannot fit into AVFrame.buf.
608  *
609  * This array is always allocated using av_malloc() by whoever constructs
610  * the frame. It is freed in av_frame_unref().
611  */
613  /**
614  * Number of elements in extended_buf.
615  */
617 
620 
621 /**
622  * @defgroup lavu_frame_flags AV_FRAME_FLAGS
623  * @ingroup lavu_frame
624  * Flags describing additional frame properties.
625  *
626  * @{
627  */
628 
629 /**
630  * The frame data may be corrupted, e.g. due to decoding errors.
631  */
632 #define AV_FRAME_FLAG_CORRUPT (1 << 0)
633 /**
634  * A flag to mark frames that are keyframes.
635  */
636 #define AV_FRAME_FLAG_KEY (1 << 1)
637 /**
638  * A flag to mark the frames which need to be decoded, but shouldn't be output.
639  */
640 #define AV_FRAME_FLAG_DISCARD (1 << 2)
641 /**
642  * A flag to mark frames whose content is interlaced.
643  */
644 #define AV_FRAME_FLAG_INTERLACED (1 << 3)
645 /**
646  * A flag to mark frames where the top field is displayed first if the content
647  * is interlaced.
648  */
649 #define AV_FRAME_FLAG_TOP_FIELD_FIRST (1 << 4)
650 /**
651  * A decoder can use this flag to mark frames which were originally encoded losslessly.
652  *
653  * For coding bitstream formats which support both lossless and lossy
654  * encoding, it is sometimes possible for a decoder to determine which method
655  * was used when the bitsream was encoded.
656  */
657 #define AV_FRAME_FLAG_LOSSLESS (1 << 5)
658 /**
659  * @}
660  */
661 
662  /**
663  * Frame flags, a combination of @ref lavu_frame_flags
664  */
665  int flags;
666 
667  /**
668  * MPEG vs JPEG YUV range.
669  * - encoding: Set by user
670  * - decoding: Set by libavcodec
671  */
673 
675 
677 
678  /**
679  * YUV colorspace type.
680  * - encoding: Set by user
681  * - decoding: Set by libavcodec
682  */
684 
686 
687  /**
688  * frame timestamp estimated using various heuristics, in stream time base
689  * - encoding: unused
690  * - decoding: set by libavcodec, read by user.
691  */
693 
694  /**
695  * metadata.
696  * - encoding: Set by user.
697  * - decoding: Set by libavcodec.
698  */
700 
701  /**
702  * decode error flags of the frame, set to a combination of
703  * FF_DECODE_ERROR_xxx flags if the decoder produced a frame, but there
704  * were errors during the decoding.
705  * - encoding: unused
706  * - decoding: set by libavcodec, read by user.
707  */
709 #define FF_DECODE_ERROR_INVALID_BITSTREAM 1
710 #define FF_DECODE_ERROR_MISSING_REFERENCE 2
711 #define FF_DECODE_ERROR_CONCEALMENT_ACTIVE 4
712 #define FF_DECODE_ERROR_DECODE_SLICES 8
713 
714  /**
715  * For hwaccel-format frames, this should be a reference to the
716  * AVHWFramesContext describing the frame.
717  */
719 
720  /**
721  * Frame owner's private data.
722  *
723  * This field may be set by the code that allocates/owns the frame data.
724  * It is then not touched by any library functions, except:
725  * - a new reference to the underlying buffer is propagated by
726  * av_frame_copy_props() (and hence by av_frame_ref());
727  * - it is unreferenced in av_frame_unref();
728  * - on the caller's explicit request. E.g. libavcodec encoders/decoders
729  * will propagate a new reference to/from @ref AVPacket "AVPackets" if the
730  * caller sets @ref AV_CODEC_FLAG_COPY_OPAQUE.
731  *
732  * @see opaque the plain pointer analogue
733  */
735 
736  /**
737  * @anchor cropping
738  * @name Cropping
739  * Video frames only. The number of pixels to discard from the the
740  * top/bottom/left/right border of the frame to obtain the sub-rectangle of
741  * the frame intended for presentation.
742  * @{
743  */
744  size_t crop_top;
745  size_t crop_bottom;
746  size_t crop_left;
747  size_t crop_right;
748  /**
749  * @}
750  */
751 
752  /**
753  * RefStruct reference for internal use by a single libav* library.
754  * Must not be used to transfer data between libraries.
755  * Has to be NULL when ownership of the frame leaves the respective library.
756  *
757  * Code outside the FFmpeg libs must never check or change private_ref.
758  */
759  void *private_ref;
760 
761  /**
762  * Channel layout of the audio data.
763  */
765 
766  /**
767  * Duration of the frame, in the same units as pts. 0 if unknown.
768  */
770 } AVFrame;
771 
772 
773 /**
774  * Allocate an AVFrame and set its fields to default values. The resulting
775  * struct must be freed using av_frame_free().
776  *
777  * @return An AVFrame filled with default values or NULL on failure.
778  *
779  * @note this only allocates the AVFrame itself, not the data buffers. Those
780  * must be allocated through other means, e.g. with av_frame_get_buffer() or
781  * manually.
782  */
783 AVFrame *av_frame_alloc(void);
784 
785 /**
786  * Free the frame and any dynamically allocated objects in it,
787  * e.g. extended_data. If the frame is reference counted, it will be
788  * unreferenced first.
789  *
790  * @param frame frame to be freed. The pointer will be set to NULL.
791  */
792 void av_frame_free(AVFrame **frame);
793 
794 /**
795  * Set up a new reference to the data described by the source frame.
796  *
797  * Copy frame properties from src to dst and create a new reference for each
798  * AVBufferRef from src.
799  *
800  * If src is not reference counted, new buffers are allocated and the data is
801  * copied.
802  *
803  * @warning: dst MUST have been either unreferenced with av_frame_unref(dst),
804  * or newly allocated with av_frame_alloc() before calling this
805  * function, or undefined behavior will occur.
806  *
807  * @return 0 on success, a negative AVERROR on error
808  */
809 int av_frame_ref(AVFrame *dst, const AVFrame *src);
810 
811 /**
812  * Ensure the destination frame refers to the same data described by the source
813  * frame, either by creating a new reference for each AVBufferRef from src if
814  * they differ from those in dst, by allocating new buffers and copying data if
815  * src is not reference counted, or by unrefencing it if src is empty.
816  *
817  * Frame properties on dst will be replaced by those from src.
818  *
819  * @return 0 on success, a negative AVERROR on error. On error, dst is
820  * unreferenced.
821  */
822 int av_frame_replace(AVFrame *dst, const AVFrame *src);
823 
824 /**
825  * Create a new frame that references the same data as src.
826  *
827  * This is a shortcut for av_frame_alloc()+av_frame_ref().
828  *
829  * @return newly created AVFrame on success, NULL on error.
830  */
832 
833 /**
834  * Unreference all the buffers referenced by frame and reset the frame fields.
835  */
837 
838 /**
839  * Move everything contained in src to dst and reset src.
840  *
841  * @warning: dst is not unreferenced, but directly overwritten without reading
842  * or deallocating its contents. Call av_frame_unref(dst) manually
843  * before calling this function to ensure that no memory is leaked.
844  */
846 
847 /**
848  * Allocate new buffer(s) for audio or video data.
849  *
850  * The following fields must be set on frame before calling this function:
851  * - format (pixel format for video, sample format for audio)
852  * - width and height for video
853  * - nb_samples and ch_layout for audio
854  *
855  * This function will fill AVFrame.data and AVFrame.buf arrays and, if
856  * necessary, allocate and fill AVFrame.extended_data and AVFrame.extended_buf.
857  * For planar formats, one buffer will be allocated for each plane.
858  *
859  * @warning: if frame already has been allocated, calling this function will
860  * leak memory. In addition, undefined behavior can occur in certain
861  * cases.
862  *
863  * @param frame frame in which to store the new buffers.
864  * @param align Required buffer size and data pointer alignment. If equal to 0,
865  * alignment will be chosen automatically for the current CPU.
866  * It is highly recommended to pass 0 here unless you know what
867  * you are doing.
868  *
869  * @return 0 on success, a negative AVERROR on error.
870  */
872 
873 /**
874  * Check if the frame data is writable.
875  *
876  * @return A positive value if the frame data is writable (which is true if and
877  * only if each of the underlying buffers has only one reference, namely the one
878  * stored in this frame). Return 0 otherwise.
879  *
880  * If 1 is returned the answer is valid until av_buffer_ref() is called on any
881  * of the underlying AVBufferRefs (e.g. through av_frame_ref() or directly).
882  *
883  * @see av_frame_make_writable(), av_buffer_is_writable()
884  */
886 
887 /**
888  * Ensure that the frame data is writable, avoiding data copy if possible.
889  *
890  * Do nothing if the frame is writable, allocate new buffers and copy the data
891  * if it is not. Non-refcounted frames behave as non-writable, i.e. a copy
892  * is always made.
893  *
894  * @return 0 on success, a negative AVERROR on error.
895  *
896  * @see av_frame_is_writable(), av_buffer_is_writable(),
897  * av_buffer_make_writable()
898  */
900 
901 /**
902  * Copy the frame data from src to dst.
903  *
904  * This function does not allocate anything, dst must be already initialized and
905  * allocated with the same parameters as src.
906  *
907  * This function only copies the frame data (i.e. the contents of the data /
908  * extended data arrays), not any other properties.
909  *
910  * @return >= 0 on success, a negative AVERROR on error.
911  */
912 int av_frame_copy(AVFrame *dst, const AVFrame *src);
913 
914 /**
915  * Copy only "metadata" fields from src to dst.
916  *
917  * Metadata for the purpose of this function are those fields that do not affect
918  * the data layout in the buffers. E.g. pts, sample rate (for audio) or sample
919  * aspect ratio (for video), but not width/height or channel layout.
920  * Side data is also copied.
921  */
923 
924 /**
925  * Get the buffer reference a given data plane is stored in.
926  *
927  * @param frame the frame to get the plane's buffer from
928  * @param plane index of the data plane of interest in frame->extended_data.
929  *
930  * @return the buffer reference that contains the plane or NULL if the input
931  * frame is not valid.
932  */
934 
935 /**
936  * Add a new side data to a frame.
937  *
938  * @param frame a frame to which the side data should be added
939  * @param type type of the added side data
940  * @param size size of the side data
941  *
942  * @return newly added side data on success, NULL on error
943  */
946  size_t size);
947 
948 /**
949  * Add a new side data to a frame from an existing AVBufferRef
950  *
951  * @param frame a frame to which the side data should be added
952  * @param type the type of the added side data
953  * @param buf an AVBufferRef to add as side data. The ownership of
954  * the reference is transferred to the frame.
955  *
956  * @return newly added side data on success, NULL on error. On failure
957  * the frame is unchanged and the AVBufferRef remains owned by
958  * the caller.
959  */
962  AVBufferRef *buf);
963 
964 /**
965  * @return a pointer to the side data of a given type on success, NULL if there
966  * is no side data with such type in this frame.
967  */
970 
971 /**
972  * Remove and free all side data instances of the given type.
973  */
975 
976 
977 /**
978  * Flags for frame cropping.
979  */
980 enum {
981  /**
982  * Apply the maximum possible cropping, even if it requires setting the
983  * AVFrame.data[] entries to unaligned pointers. Passing unaligned data
984  * to FFmpeg API is generally not allowed, and causes undefined behavior
985  * (such as crashes). You can pass unaligned data only to FFmpeg APIs that
986  * are explicitly documented to accept it. Use this flag only if you
987  * absolutely know what you are doing.
988  */
990 };
991 
992 /**
993  * Crop the given video AVFrame according to its crop_left/crop_top/crop_right/
994  * crop_bottom fields. If cropping is successful, the function will adjust the
995  * data pointers and the width/height fields, and set the crop fields to 0.
996  *
997  * In all cases, the cropping boundaries will be rounded to the inherent
998  * alignment of the pixel format. In some cases, such as for opaque hwaccel
999  * formats, the left/top cropping is ignored. The crop fields are set to 0 even
1000  * if the cropping was rounded or ignored.
1001  *
1002  * @param frame the frame which should be cropped
1003  * @param flags Some combination of AV_FRAME_CROP_* flags, or 0.
1004  *
1005  * @return >= 0 on success, a negative AVERROR on error. If the cropping fields
1006  * were invalid, AVERROR(ERANGE) is returned, and nothing is changed.
1007  */
1009 
1010 /**
1011  * @return a string identifying the side data type
1012  */
1014 
1015 /**
1016  * @return side data descriptor corresponding to a given side data type, NULL
1017  * when not available.
1018  */
1020 
1021 /**
1022  * Free all side data entries and their contents, then zeroes out the
1023  * values which the pointers are pointing to.
1024  *
1025  * @param sd pointer to array of side data to free. Will be set to NULL
1026  * upon return.
1027  * @param nb_sd pointer to an integer containing the number of entries in
1028  * the array. Will be set to 0 upon return.
1029  */
1030 void av_frame_side_data_free(AVFrameSideData ***sd, int *nb_sd);
1031 
1032 /**
1033  * Remove existing entries before adding new ones.
1034  */
1035 #define AV_FRAME_SIDE_DATA_FLAG_UNIQUE (1 << 0)
1036 /**
1037  * Don't add a new entry if another of the same type exists.
1038  * Applies only for side data types without the AV_SIDE_DATA_PROP_MULTI prop.
1039  */
1040 #define AV_FRAME_SIDE_DATA_FLAG_REPLACE (1 << 1)
1041 /**
1042  * Create a new reference to the passed in buffer instead of taking ownership
1043  * of it.
1044  */
1045 #define AV_FRAME_SIDE_DATA_FLAG_NEW_REF (1 << 2)
1046 
1047 /**
1048  * Add new side data entry to an array.
1049  *
1050  * @param sd pointer to array of side data to which to add another entry,
1051  * or to NULL in order to start a new array.
1052  * @param nb_sd pointer to an integer containing the number of entries in
1053  * the array.
1054  * @param type type of the added side data
1055  * @param size size of the side data
1056  * @param flags Some combination of AV_FRAME_SIDE_DATA_FLAG_* flags, or 0.
1057  *
1058  * @return newly added side data on success, NULL on error.
1059  * @note In case of AV_FRAME_SIDE_DATA_FLAG_UNIQUE being set, entries of
1060  * matching AVFrameSideDataType will be removed before the addition
1061  * is attempted.
1062  * @note In case of AV_FRAME_SIDE_DATA_FLAG_REPLACE being set, if an
1063  * entry of the same type already exists, it will be replaced instead.
1064  */
1067  size_t size, unsigned int flags);
1068 
1069 /**
1070  * Add a new side data entry to an array from an existing AVBufferRef.
1071  *
1072  * @param sd pointer to array of side data to which to add another entry,
1073  * or to NULL in order to start a new array.
1074  * @param nb_sd pointer to an integer containing the number of entries in
1075  * the array.
1076  * @param type type of the added side data
1077  * @param buf Pointer to AVBufferRef to add to the array. On success,
1078  * the function takes ownership of the AVBufferRef and *buf is
1079  * set to NULL, unless AV_FRAME_SIDE_DATA_FLAG_NEW_REF is set
1080  * in which case the ownership will remain with the caller.
1081  * @param flags Some combination of AV_FRAME_SIDE_DATA_FLAG_* flags, or 0.
1082  *
1083  * @return newly added side data on success, NULL on error.
1084  * @note In case of AV_FRAME_SIDE_DATA_FLAG_UNIQUE being set, entries of
1085  * matching AVFrameSideDataType will be removed before the addition
1086  * is attempted.
1087  * @note In case of AV_FRAME_SIDE_DATA_FLAG_REPLACE being set, if an
1088  * entry of the same type already exists, it will be replaced instead.
1089  *
1090  */
1093  AVBufferRef **buf, unsigned int flags);
1094 
1095 /**
1096  * Add a new side data entry to an array based on existing side data, taking
1097  * a reference towards the contained AVBufferRef.
1098  *
1099  * @param sd pointer to array of side data to which to add another entry,
1100  * or to NULL in order to start a new array.
1101  * @param nb_sd pointer to an integer containing the number of entries in
1102  * the array.
1103  * @param src side data to be cloned, with a new reference utilized
1104  * for the buffer.
1105  * @param flags Some combination of AV_FRAME_SIDE_DATA_FLAG_* flags, or 0.
1106  *
1107  * @return negative error code on failure, >=0 on success.
1108  * @note In case of AV_FRAME_SIDE_DATA_FLAG_UNIQUE being set, entries of
1109  * matching AVFrameSideDataType will be removed before the addition
1110  * is attempted.
1111  * @note In case of AV_FRAME_SIDE_DATA_FLAG_REPLACE being set, if an
1112  * entry of the same type already exists, it will be replaced instead.
1113  */
1114 int av_frame_side_data_clone(AVFrameSideData ***sd, int *nb_sd,
1115  const AVFrameSideData *src, unsigned int flags);
1116 
1117 /**
1118  * Get a side data entry of a specific type from an array.
1119  *
1120  * @param sd array of side data.
1121  * @param nb_sd integer containing the number of entries in the array.
1122  * @param type type of side data to be queried
1123  *
1124  * @return a pointer to the side data of a given type on success, NULL if there
1125  * is no side data with such type in this set.
1126  */
1128  const int nb_sd,
1129  enum AVFrameSideDataType type);
1130 
1131 /**
1132  * Wrapper around av_frame_side_data_get_c() to workaround the limitation
1133  * that for any type T the conversion from T * const * to const T * const *
1134  * is not performed automatically in C.
1135  * @see av_frame_side_data_get_c()
1136  */
1137 static inline
1139  const int nb_sd,
1141 {
1142  return av_frame_side_data_get_c((const AVFrameSideData * const *)sd,
1143  nb_sd, type);
1144 }
1145 
1146 /**
1147  * Remove and free all side data instances of the given type from an array.
1148  */
1149 void av_frame_side_data_remove(AVFrameSideData ***sd, int *nb_sd,
1150  enum AVFrameSideDataType type);
1151 
1152 /**
1153  * Remove and free all side data instances that match any of the given
1154  * side data properties. (See enum AVSideDataProps)
1155  */
1157  int props);
1158 
1159 /**
1160  * @}
1161  */
1162 
1163 #endif /* AVUTIL_FRAME_H */
AVFrame::extended_buf
AVBufferRef ** extended_buf
For planar audio which requires more than AV_NUM_DATA_POINTERS AVBufferRef pointers,...
Definition: frame.h:612
flags
const SwsFlags flags[]
Definition: swscale.c:61
AVFrame::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: frame.h:676
AV_AFD_14_9
@ AV_AFD_14_9
Definition: frame.h:263
AVFrame::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: frame.h:672
AVColorTransferCharacteristic
AVColorTransferCharacteristic
Color Transfer Characteristic.
Definition: pixfmt.h:659
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:205
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:657
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:645
AVFrame::duration
int64_t duration
Duration of the frame, in the same units as pts.
Definition: frame.h:769
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:619
AVPictureType
AVPictureType
Definition: avutil.h:276
rational.h
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
int64_t
long long int64_t
Definition: coverity.c:34
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:674
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:63
AVFrame::opaque
void * opaque
Frame owner's private data.
Definition: frame.h:559
AVFrame::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:683
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:421
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:550
AVFrameSideData::buf
AVBufferRef * buf
Definition: frame.h:281
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:523
AVFrame::width
int width
Definition: frame.h:493
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
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
AV_AFD_16_9
@ AV_AFD_16_9
Definition: frame.h:262
AVDictionary
Definition: dict.c:32
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:665
AVColorPrimaries
AVColorPrimaries
Chromaticity coordinates of the source primaries.
Definition: pixfmt.h:634
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: side_data.c:247
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:598
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:758
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:442
AVFrame::opaque_ref
AVBufferRef * opaque_ref
Frame owner's private data.
Definition: frame.h:734
AVFrame::chroma_location
enum AVChromaLocation chroma_location
Definition: frame.h:685
AV_AFD_SAME
@ AV_AFD_SAME
Definition: frame.h:260
AV_FRAME_DATA_MATRIXENCODING
@ AV_FRAME_DATA_MATRIXENCODING
The data is the AVMatrixEncoding enum defined in libavutil/channel_layout.h.
Definition: frame.h:68
samplefmt.h
AVFrame::ch_layout
AVChannelLayout ch_layout
Channel layout of the audio data.
Definition: frame.h:764
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_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:989
AVFrameSideDataType
AVFrameSideDataType
Definition: frame.h:49
AV_SIDE_DATA_PROP_SIZE_DEPENDENT
@ AV_SIDE_DATA_PROP_SIZE_DEPENDENT
Side data depends on the video dimensions.
Definition: frame.h:303
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:51
AVFrameSideData::size
size_t size
Definition: frame.h:279
AVRegionOfInterest
Structure describing a single Region Of Interest.
Definition: frame.h:347
AVRegionOfInterest::bottom
int bottom
Definition: frame.h:363
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_AFD_SP_4_3
@ AV_AFD_SP_4_3
Definition: frame.h:266
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:296
av_frame_clone
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:481
AV_FRAME_DATA_3D_REFERENCE_DISPLAYS
@ AV_FRAME_DATA_3D_REFERENCE_DISPLAYS
This side data contains information about the reference display width(s) and reference viewing distan...
Definition: frame.h:256
AVFrame::crop_right
size_t crop_right
Definition: frame.h:747
AV_SIDE_DATA_PROP_GLOBAL
@ AV_SIDE_DATA_PROP_GLOBAL
The side data type can be used in stream-global structures.
Definition: frame.h:290
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
AV_FRAME_DATA_SPHERICAL
@ AV_FRAME_DATA_SPHERICAL
The data represents the AVSphericalMapping structure defined in libavutil/spherical....
Definition: frame.h:131
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:597
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: side_data.c:101
AVRegionOfInterest::self_size
uint32_t self_size
Must be set to the size of this data structure (that is, sizeof(AVRegionOfInterest)).
Definition: frame.h:352
AVActiveFormatDescription
AVActiveFormatDescription
Definition: frame.h:259
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:636
AVFrame::pkt_dts
int64_t pkt_dts
DTS copied from the AVPacket that triggered returning this frame.
Definition: frame.h:530
AVSideDataDescriptor::props
unsigned props
Side data property flags, a combination of AVSideDataProps values.
Definition: frame.h:333
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_AFD_4_3_SP_14_9
@ AV_AFD_4_3_SP_14_9
Definition: frame.h:264
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:602
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:745
AVFrame::best_effort_timestamp
int64_t best_effort_timestamp
frame timestamp estimated using various heuristics, in stream time base
Definition: frame.h:692
AVFrame::crop_left
size_t crop_left
Definition: frame.h:746
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:513
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:276
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:319
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
av_frame_copy
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:709
AVFrame::quality
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:543
AVFrame::sample_rate
int sample_rate
Sample rate of the audio data.
Definition: frame.h:584
AV_FRAME_DATA_LCEVC
@ AV_FRAME_DATA_LCEVC
Raw LCEVC payload data, as a uint8_t array, with NAL emulation bytes intact.
Definition: frame.h:236
size
int size
Definition: twinvq_data.h:10344
AV_NUM_DATA_POINTERS
#define AV_NUM_DATA_POINTERS
Definition: frame.h:422
AVFrame::time_base
AVRational time_base
Time base for the timestamps in this frame.
Definition: frame.h:538
AVFrameSideData::data
uint8_t * data
Definition: frame.h:278
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:533
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:508
buffer.h
align
static const uint8_t *BS_FUNC() align(BSCTX *bc)
Skip bits to a byte boundary.
Definition: bitstream_template.h:419
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:723
AVSideDataDescriptor::name
const char * name
Human-readable side data description.
Definition: frame.h:328
AVRegionOfInterest::right
int right
Definition: frame.h:365
av_frame_side_data_remove_by_props
void av_frame_side_data_remove_by_props(AVFrameSideData ***sd, int *nb_sd, int props)
Remove and free all side data instances that match any of the given side data properties.
Definition: side_data.c:116
AV_FRAME_DATA_VIEW_ID
@ AV_FRAME_DATA_VIEW_ID
This side data must be associated with a video frame.
Definition: frame.h:245
AV_FRAME_DATA_SKIP_SAMPLES
@ AV_FRAME_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: frame.h:109
AVChromaLocation
AVChromaLocation
Location of chroma samples.
Definition: pixfmt.h:784
AVFrame::private_ref
void * private_ref
RefStruct reference for internal use by a single libav* library.
Definition: frame.h:759
AVRegionOfInterest::left
int left
Definition: frame.h:364
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:501
AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
@ AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: frame.h:137
AVSideDataProps
AVSideDataProps
Definition: frame.h:284
AV_SIDE_DATA_PROP_CHANNEL_DEPENDENT
@ AV_SIDE_DATA_PROP_CHANNEL_DEPENDENT
Side data depends on the channel layout.
Definition: frame.h:317
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: side_data.c:132
AVRegionOfInterest::top
int top
Distance in pixels from the top edge of the frame to the top and bottom edges and from the left edge ...
Definition: frame.h:362
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:482
AVColorSpace
AVColorSpace
YUV colorspace type.
Definition: pixfmt.h:688
AV_FRAME_DATA_STEREO3D
@ AV_FRAME_DATA_STEREO3D
Stereoscopic 3d metadata.
Definition: frame.h:64
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:521
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:494
AVFrame::side_data
AVFrameSideData ** side_data
Definition: frame.h:618
AV_SIDE_DATA_PROP_COLOR_DEPENDENT
@ AV_SIDE_DATA_PROP_COLOR_DEPENDENT
Side data depends on the video color space.
Definition: frame.h:310
version.h
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:708
AV_FRAME_DATA_GOP_TIMECODE
@ AV_FRAME_DATA_GOP_TIMECODE
The GOP timecode in 25 bit timecode format.
Definition: frame.h:125
pixfmt.h
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:265
AV_FRAME_DATA_VIDEO_HINT
@ AV_FRAME_DATA_VIDEO_HINT
Provide encoder-specific hinting information about changed/unchanged portions of a frame.
Definition: frame.h:230
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:518
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:718
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:374
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:493
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: side_data.c:197
AV_FRAME_DATA_VIDEO_ENC_PARAMS
@ AV_FRAME_DATA_VIDEO_ENC_PARAMS
Encoding parameters for a video frame, as described by AVVideoEncParams.
Definition: frame.h:170
AVFrame::metadata
AVDictionary * metadata
metadata.
Definition: frame.h:699
AVFrameSideData::type
enum AVFrameSideDataType type
Definition: frame.h:277
AVSideDataDescriptor
This struct describes the properties of a side data type.
Definition: frame.h:324
avutil.h
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:276
av_frame_side_data_desc
const AVSideDataDescriptor * av_frame_side_data_desc(enum AVFrameSideDataType type)
Definition: side_data.c:61
AVFrame::crop_top
size_t crop_top
Definition: frame.h:744
av_frame_side_data_name
const char * av_frame_side_data_name(enum AVFrameSideDataType type)
Definition: side_data.c:69
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:1138
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
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:466
AVFrameSideData::metadata
AVDictionary * metadata
Definition: frame.h:280
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: side_data.c:305
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_AFD_4_3
@ AV_AFD_4_3
Definition: frame.h:261
AVColorRange
AVColorRange
Visual content value range.
Definition: pixfmt.h:730
AVRegionOfInterest::qoffset
AVRational qoffset
Quantisation offset.
Definition: frame.h:389
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:579
av_frame_side_data_add
AVFrameSideData * av_frame_side_data_add(AVFrameSideData ***sd, int *nb_sd, enum AVFrameSideDataType type, AVBufferRef **buf, unsigned int flags)
Add a new side data entry to an array from an existing AVBufferRef.
Definition: side_data.c:222
src
#define src
Definition: vp8dsp.c:248
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:616
AV_AFD_16_9_SP_14_9
@ AV_AFD_16_9_SP_14_9
Definition: frame.h:265