FFmpeg
libopenh264enc.c
Go to the documentation of this file.
1 /*
2  * OpenH264 video encoder
3  * Copyright (C) 2014 Martin Storsjo
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include <wels/codec_api.h>
23 #include <wels/codec_ver.h>
24 
25 #include "libavutil/attributes.h"
26 #include "libavutil/common.h"
27 #include "libavutil/opt.h"
28 #include "libavutil/internal.h"
29 #include "libavutil/intreadwrite.h"
30 #include "libavutil/mathematics.h"
31 
32 #include "avcodec.h"
33 #include "internal.h"
34 #include "libopenh264.h"
35 
36 #if !OPENH264_VER_AT_LEAST(1, 6)
37 #define SM_SIZELIMITED_SLICE SM_DYN_SLICE
38 #endif
39 
40 typedef struct SVCContext {
41  const AVClass *av_class;
42  ISVCEncoder *encoder;
45  char *profile;
48  int skipped;
49  int cabac;
50 } SVCContext;
51 
52 #define OFFSET(x) offsetof(SVCContext, x)
53 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
54 static const AVOption options[] = {
55 #if OPENH264_VER_AT_LEAST(1, 6)
56  { "slice_mode", "set slice mode", OFFSET(slice_mode), AV_OPT_TYPE_INT, { .i64 = SM_FIXEDSLCNUM_SLICE }, SM_SINGLE_SLICE, SM_RESERVED, VE, "slice_mode" },
57 #else
58  { "slice_mode", "set slice mode", OFFSET(slice_mode), AV_OPT_TYPE_INT, { .i64 = SM_AUTO_SLICE }, SM_SINGLE_SLICE, SM_RESERVED, VE, "slice_mode" },
59 #endif
60  { "fixed", "a fixed number of slices", 0, AV_OPT_TYPE_CONST, { .i64 = SM_FIXEDSLCNUM_SLICE }, 0, 0, VE, "slice_mode" },
61 #if OPENH264_VER_AT_LEAST(1, 6)
62  { "dyn", "Size limited (compatibility name)", 0, AV_OPT_TYPE_CONST, { .i64 = SM_SIZELIMITED_SLICE }, 0, 0, VE, "slice_mode" },
63  { "sizelimited", "Size limited", 0, AV_OPT_TYPE_CONST, { .i64 = SM_SIZELIMITED_SLICE }, 0, 0, VE, "slice_mode" },
64 #else
65  { "rowmb", "one slice per row of macroblocks", 0, AV_OPT_TYPE_CONST, { .i64 = SM_ROWMB_SLICE }, 0, 0, VE, "slice_mode" },
66  { "auto", "automatic number of slices according to number of threads", 0, AV_OPT_TYPE_CONST, { .i64 = SM_AUTO_SLICE }, 0, 0, VE, "slice_mode" },
67  { "dyn", "Dynamic slicing", 0, AV_OPT_TYPE_CONST, { .i64 = SM_DYN_SLICE }, 0, 0, VE, "slice_mode" },
68 #endif
69  { "loopfilter", "enable loop filter", OFFSET(loopfilter), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, VE },
70  { "profile", "set profile restrictions", OFFSET(profile), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VE },
71  { "max_nal_size", "set maximum NAL size in bytes", OFFSET(max_nal_size), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VE },
72  { "allow_skip_frames", "allow skipping frames to hit the target bitrate", OFFSET(skip_frames), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
73  { "cabac", "Enable cabac", OFFSET(cabac), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
74  { NULL }
75 };
76 
77 static const AVClass class = {
78  .class_name = "libopenh264enc",
79  .item_name = av_default_item_name,
80  .option = options,
82 };
83 
85 {
86  SVCContext *s = avctx->priv_data;
87 
88  if (s->encoder)
89  WelsDestroySVCEncoder(s->encoder);
90  if (s->skipped > 0)
91  av_log(avctx, AV_LOG_WARNING, "%d frames skipped\n", s->skipped);
92  return 0;
93 }
94 
96 {
97  SVCContext *s = avctx->priv_data;
98  SEncParamExt param = { 0 };
99  int err;
100  int log_level;
101  WelsTraceCallback callback_function;
102  AVCPBProperties *props;
103 
104  if ((err = ff_libopenh264_check_version(avctx)) < 0)
105  return err;
106 
107  if (WelsCreateSVCEncoder(&s->encoder)) {
108  av_log(avctx, AV_LOG_ERROR, "Unable to create encoder\n");
109  return AVERROR_UNKNOWN;
110  }
111 
112  // Pass all libopenh264 messages to our callback, to allow ourselves to filter them.
113  log_level = WELS_LOG_DETAIL;
114  (*s->encoder)->SetOption(s->encoder, ENCODER_OPTION_TRACE_LEVEL, &log_level);
115 
116  // Set the logging callback function to one that uses av_log() (see implementation above).
117  callback_function = (WelsTraceCallback) ff_libopenh264_trace_callback;
118  (*s->encoder)->SetOption(s->encoder, ENCODER_OPTION_TRACE_CALLBACK, &callback_function);
119 
120  // Set the AVCodecContext as the libopenh264 callback context so that it can be passed to av_log().
121  (*s->encoder)->SetOption(s->encoder, ENCODER_OPTION_TRACE_CALLBACK_CONTEXT, &avctx);
122 
123  (*s->encoder)->GetDefaultParams(s->encoder, &param);
124 
125 #if FF_API_CODER_TYPE
127  if (!s->cabac)
128  s->cabac = avctx->coder_type == FF_CODER_TYPE_AC;
130 #endif
131 
132  param.fMaxFrameRate = 1/av_q2d(avctx->time_base);
133  param.iPicWidth = avctx->width;
134  param.iPicHeight = avctx->height;
135  param.iTargetBitrate = avctx->bit_rate;
136  param.iMaxBitrate = FFMAX(avctx->rc_max_rate, avctx->bit_rate);
137  param.iRCMode = RC_QUALITY_MODE;
138  param.iTemporalLayerNum = 1;
139  param.iSpatialLayerNum = 1;
140  param.bEnableDenoise = 0;
141  param.bEnableBackgroundDetection = 1;
142  param.bEnableAdaptiveQuant = 1;
143  param.bEnableFrameSkip = s->skip_frames;
144  param.bEnableLongTermReference = 0;
145  param.iLtrMarkPeriod = 30;
146  param.uiIntraPeriod = avctx->gop_size;
147 #if OPENH264_VER_AT_LEAST(1, 4)
148  param.eSpsPpsIdStrategy = CONSTANT_ID;
149 #else
150  param.bEnableSpsPpsIdAddition = 0;
151 #endif
152  param.bPrefixNalAddingCtrl = 0;
153  param.iLoopFilterDisableIdc = !s->loopfilter;
154  param.iEntropyCodingModeFlag = 0;
155  param.iMultipleThreadIdc = avctx->thread_count;
156  if (s->profile && !strcmp(s->profile, "main"))
157  param.iEntropyCodingModeFlag = 1;
158  else if (!s->profile && s->cabac)
159  param.iEntropyCodingModeFlag = 1;
160 
161  param.sSpatialLayers[0].iVideoWidth = param.iPicWidth;
162  param.sSpatialLayers[0].iVideoHeight = param.iPicHeight;
163  param.sSpatialLayers[0].fFrameRate = param.fMaxFrameRate;
164  param.sSpatialLayers[0].iSpatialBitrate = param.iTargetBitrate;
165  param.sSpatialLayers[0].iMaxSpatialBitrate = param.iMaxBitrate;
166 
167 #if OPENH264_VER_AT_LEAST(1, 7)
168  if (avctx->sample_aspect_ratio.num && avctx->sample_aspect_ratio.den) {
169  // Table E-1.
170  static const AVRational sar_idc[] = {
171  { 0, 0 }, // Unspecified (never written here).
172  { 1, 1 }, { 12, 11 }, { 10, 11 }, { 16, 11 },
173  { 40, 33 }, { 24, 11 }, { 20, 11 }, { 32, 11 },
174  { 80, 33 }, { 18, 11 }, { 15, 11 }, { 64, 33 },
175  { 160, 99 }, // Last 3 are unknown to openh264: { 4, 3 }, { 3, 2 }, { 2, 1 },
176  };
177  static const ESampleAspectRatio asp_idc[] = {
178  ASP_UNSPECIFIED,
179  ASP_1x1, ASP_12x11, ASP_10x11, ASP_16x11,
180  ASP_40x33, ASP_24x11, ASP_20x11, ASP_32x11,
181  ASP_80x33, ASP_18x11, ASP_15x11, ASP_64x33,
182  ASP_160x99,
183  };
184  int num, den, i;
185 
186  av_reduce(&num, &den, avctx->sample_aspect_ratio.num,
187  avctx->sample_aspect_ratio.den, 65535);
188 
189  for (i = 1; i < FF_ARRAY_ELEMS(sar_idc); i++) {
190  if (num == sar_idc[i].num &&
191  den == sar_idc[i].den)
192  break;
193  }
194  if (i == FF_ARRAY_ELEMS(sar_idc)) {
195  param.sSpatialLayers[0].eAspectRatio = ASP_EXT_SAR;
196  param.sSpatialLayers[0].sAspectRatioExtWidth = num;
197  param.sSpatialLayers[0].sAspectRatioExtHeight = den;
198  } else {
199  param.sSpatialLayers[0].eAspectRatio = asp_idc[i];
200  }
201  param.sSpatialLayers[0].bAspectRatioPresent = true;
202  }
203  else {
204  param.sSpatialLayers[0].bAspectRatioPresent = false;
205  }
206 #endif
207 
208  if ((avctx->slices > 1) && (s->max_nal_size)) {
209  av_log(avctx, AV_LOG_ERROR,
210  "Invalid combination -slices %d and -max_nal_size %d.\n",
211  avctx->slices, s->max_nal_size);
212  return AVERROR(EINVAL);
213  }
214 
215  if (avctx->slices > 1)
216  s->slice_mode = SM_FIXEDSLCNUM_SLICE;
217 
218  if (s->max_nal_size)
220 
221 #if OPENH264_VER_AT_LEAST(1, 6)
222  param.sSpatialLayers[0].sSliceArgument.uiSliceMode = s->slice_mode;
223  param.sSpatialLayers[0].sSliceArgument.uiSliceNum = avctx->slices;
224 #else
225  param.sSpatialLayers[0].sSliceCfg.uiSliceMode = s->slice_mode;
226  param.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = avctx->slices;
227 #endif
228 
229  if (s->slice_mode == SM_SIZELIMITED_SLICE) {
230  if (s->max_nal_size){
231  param.uiMaxNalSize = s->max_nal_size;
232 #if OPENH264_VER_AT_LEAST(1, 6)
233  param.sSpatialLayers[0].sSliceArgument.uiSliceSizeConstraint = s->max_nal_size;
234 #else
235  param.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceSizeConstraint = s->max_nal_size;
236 #endif
237  } else {
238  av_log(avctx, AV_LOG_ERROR, "Invalid -max_nal_size, "
239  "specify a valid max_nal_size to use -slice_mode dyn\n");
240  return AVERROR(EINVAL);
241  }
242  }
243 
244  if ((*s->encoder)->InitializeExt(s->encoder, &param) != cmResultSuccess) {
245  av_log(avctx, AV_LOG_ERROR, "Initialize failed\n");
246  return AVERROR_UNKNOWN;
247  }
248 
249  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
250  SFrameBSInfo fbi = { 0 };
251  int i, size = 0;
252  (*s->encoder)->EncodeParameterSets(s->encoder, &fbi);
253  for (i = 0; i < fbi.sLayerInfo[0].iNalCount; i++)
254  size += fbi.sLayerInfo[0].pNalLengthInByte[i];
256  if (!avctx->extradata)
257  return AVERROR(ENOMEM);
258  avctx->extradata_size = size;
259  memcpy(avctx->extradata, fbi.sLayerInfo[0].pBsBuf, size);
260  }
261 
262  props = ff_add_cpb_side_data(avctx);
263  if (!props)
264  return AVERROR(ENOMEM);
265  props->max_bitrate = param.iMaxBitrate;
266  props->avg_bitrate = param.iTargetBitrate;
267 
268  return 0;
269 }
270 
271 static int svc_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
272  const AVFrame *frame, int *got_packet)
273 {
274  SVCContext *s = avctx->priv_data;
275  SFrameBSInfo fbi = { 0 };
276  int i, ret;
277  int encoded;
278  SSourcePicture sp = { 0 };
279  int size = 0, layer, first_layer = 0;
280  int layer_size[MAX_LAYER_NUM_OF_FRAME] = { 0 };
281 
282  sp.iColorFormat = videoFormatI420;
283  for (i = 0; i < 3; i++) {
284  sp.iStride[i] = frame->linesize[i];
285  sp.pData[i] = frame->data[i];
286  }
287  sp.iPicWidth = avctx->width;
288  sp.iPicHeight = avctx->height;
289 
290  if (frame->pict_type == AV_PICTURE_TYPE_I) {
291  (*s->encoder)->ForceIntraFrame(s->encoder, true);
292  }
293 
294  encoded = (*s->encoder)->EncodeFrame(s->encoder, &sp, &fbi);
295  if (encoded != cmResultSuccess) {
296  av_log(avctx, AV_LOG_ERROR, "EncodeFrame failed\n");
297  return AVERROR_UNKNOWN;
298  }
299  if (fbi.eFrameType == videoFrameTypeSkip) {
300  s->skipped++;
301  av_log(avctx, AV_LOG_DEBUG, "frame skipped\n");
302  return 0;
303  }
304  first_layer = 0;
305  // Normal frames are returned with one single layer, while IDR
306  // frames have two layers, where the first layer contains the SPS/PPS.
307  // If using global headers, don't include the SPS/PPS in the returned
308  // packet - thus, only return one layer.
309  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER)
310  first_layer = fbi.iLayerNum - 1;
311 
312  for (layer = first_layer; layer < fbi.iLayerNum; layer++) {
313  for (i = 0; i < fbi.sLayerInfo[layer].iNalCount; i++)
314  layer_size[layer] += fbi.sLayerInfo[layer].pNalLengthInByte[i];
315  size += layer_size[layer];
316  }
317  av_log(avctx, AV_LOG_DEBUG, "%d slices\n", fbi.sLayerInfo[fbi.iLayerNum - 1].iNalCount);
318 
319  if ((ret = ff_alloc_packet2(avctx, avpkt, size, size))) {
320  av_log(avctx, AV_LOG_ERROR, "Error getting output packet\n");
321  return ret;
322  }
323  size = 0;
324  for (layer = first_layer; layer < fbi.iLayerNum; layer++) {
325  memcpy(avpkt->data + size, fbi.sLayerInfo[layer].pBsBuf, layer_size[layer]);
326  size += layer_size[layer];
327  }
328  avpkt->pts = frame->pts;
329  if (fbi.eFrameType == videoFrameTypeIDR)
330  avpkt->flags |= AV_PKT_FLAG_KEY;
331  *got_packet = 1;
332  return 0;
333 }
334 
336  .name = "libopenh264",
337  .long_name = NULL_IF_CONFIG_SMALL("OpenH264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
338  .type = AVMEDIA_TYPE_VIDEO,
339  .id = AV_CODEC_ID_H264,
340  .priv_data_size = sizeof(SVCContext),
342  .encode2 = svc_encode_frame,
343  .close = svc_encode_close,
344  .capabilities = AV_CODEC_CAP_AUTO_THREADS,
346  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P,
347  AV_PIX_FMT_NONE },
348  .priv_class = &class,
349  .wrapper_name = "libopenh264",
350 };
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
void ff_libopenh264_trace_callback(void *ctx, int level, const char *msg)
Definition: libopenh264.c:41
#define NULL
Definition: coverity.c:32
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
AVOption.
Definition: opt.h:246
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1618
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: avcodec.h:1137
int num
Numerator.
Definition: rational.h:59
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:1947
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
#define AV_CODEC_CAP_AUTO_THREADS
Codec supports avctx->thread_count == 0 (auto).
Definition: avcodec.h:1052
AVCodec.
Definition: avcodec.h:3492
Macro definitions for various function/variable attributes.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1691
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:32
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:40
#define av_cold
Definition: attributes.h:82
AVOptions.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:388
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1669
uint8_t * data
Definition: avcodec.h:1480
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
#define OFFSET(x)
#define sp
Definition: regdef.h:63
ptrdiff_t size
Definition: opengl_enc.c:100
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
ISVCEncoder * encoder
#define av_log(a,...)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1512
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
const AVClass * av_class
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1648
const char * name
Name of the codec implementation.
Definition: avcodec.h:3499
static av_cold int svc_encode_close(AVCodecContext *avctx)
#define FFMAX(a, b)
Definition: common.h:94
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1486
static av_cold int svc_encode_init(AVCodecContext *avctx)
common internal API header
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
#define VE
static const AVOption options[]
int width
picture width / height.
Definition: avcodec.h:1741
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
#define s(width, name)
Definition: cbs_vp9.c:257
attribute_deprecated int coder_type
Definition: avcodec.h:2485
#define FF_ARRAY_ELEMS(a)
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:2827
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:1131
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
main external API structure.
Definition: avcodec.h:1568
#define FF_CODER_TYPE_AC
Definition: avcodec.h:2478
char * profile
int extradata_size
Definition: avcodec.h:1670
Describe the class of an AVClass context structure.
Definition: log.h:67
Rational number (pair of numerator and denominator).
Definition: rational.h:58
static int svc_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet)
#define SM_SIZELIMITED_SLICE
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:907
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1763
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
common internal api header.
common internal and external API header
int den
Denominator.
Definition: rational.h:60
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:1968
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:793
int slices
Number of slices.
Definition: avcodec.h:2219
void * priv_data
Definition: avcodec.h:1595
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
int avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: avcodec.h:1155
int ff_libopenh264_check_version(void *logctx)
Definition: libopenh264.c:49
AVCodec ff_libopenh264_encoder
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
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1457
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1473
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:2446