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 #define TARGET_BITRATE_DEFAULT 2*1000*1000
41 
42 typedef struct SVCContext {
43  const AVClass *av_class;
44  ISVCEncoder *encoder;
47  int profile;
50  int skipped;
51 #if FF_API_OPENH264_CABAC
52  int cabac; // deprecated
53 #endif
54  int coder;
55 
56  // rate control mode
57  int rc_mode;
58 } SVCContext;
59 
60 #define OFFSET(x) offsetof(SVCContext, x)
61 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
62 #define DEPRECATED AV_OPT_FLAG_DEPRECATED
63 static const AVOption options[] = {
64 #if FF_API_OPENH264_SLICE_MODE
65 #if OPENH264_VER_AT_LEAST(1, 6)
66  { "slice_mode", "set slice mode, use slices/max_nal_size", OFFSET(slice_mode), AV_OPT_TYPE_INT, { .i64 = SM_FIXEDSLCNUM_SLICE }, SM_SINGLE_SLICE, SM_RESERVED, VE|DEPRECATED, "slice_mode" },
67 #else
68  { "slice_mode", "set slice mode, use slices/max_nal_size", OFFSET(slice_mode), AV_OPT_TYPE_INT, { .i64 = SM_AUTO_SLICE }, SM_SINGLE_SLICE, SM_RESERVED, VE|DEPRECATED, "slice_mode" },
69 #endif
70  { "fixed", "a fixed number of slices", 0, AV_OPT_TYPE_CONST, { .i64 = SM_FIXEDSLCNUM_SLICE }, 0, 0, VE, "slice_mode" },
71 #if OPENH264_VER_AT_LEAST(1, 6)
72  { "dyn", "Size limited (compatibility name)", 0, AV_OPT_TYPE_CONST, { .i64 = SM_SIZELIMITED_SLICE }, 0, 0, VE, "slice_mode" },
73  { "sizelimited", "Size limited", 0, AV_OPT_TYPE_CONST, { .i64 = SM_SIZELIMITED_SLICE }, 0, 0, VE, "slice_mode" },
74 #else
75  { "rowmb", "one slice per row of macroblocks", 0, AV_OPT_TYPE_CONST, { .i64 = SM_ROWMB_SLICE }, 0, 0, VE, "slice_mode" },
76  { "auto", "automatic number of slices according to number of threads", 0, AV_OPT_TYPE_CONST, { .i64 = SM_AUTO_SLICE }, 0, 0, VE, "slice_mode" },
77  { "dyn", "Dynamic slicing", 0, AV_OPT_TYPE_CONST, { .i64 = SM_DYN_SLICE }, 0, 0, VE, "slice_mode" },
78 #endif
79 #endif
80  { "loopfilter", "enable loop filter", OFFSET(loopfilter), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, VE },
81  { "profile", "set profile restrictions", OFFSET(profile), AV_OPT_TYPE_INT, { .i64 = FF_PROFILE_UNKNOWN }, FF_PROFILE_UNKNOWN, 0xffff, VE, "profile" },
82 #define PROFILE(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, { .i64 = value }, 0, 0, VE, "profile"
83  { PROFILE("constrained_baseline", FF_PROFILE_H264_CONSTRAINED_BASELINE) },
84  { PROFILE("main", FF_PROFILE_H264_MAIN) },
85  { PROFILE("high", FF_PROFILE_H264_HIGH) },
86 #undef PROFILE
87  { "max_nal_size", "set maximum NAL size in bytes", OFFSET(max_nal_size), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VE },
88  { "allow_skip_frames", "allow skipping frames to hit the target bitrate", OFFSET(skip_frames), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
89 #if FF_API_OPENH264_CABAC
90  { "cabac", "Enable cabac(deprecated, use coder)", OFFSET(cabac), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE|DEPRECATED },
91 #endif
92  { "coder", "Coder type", OFFSET(coder), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE, "coder" },
93  { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 }, INT_MIN, INT_MAX, VE, "coder" },
94  { "cavlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "coder" },
95  { "cabac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
96  { "vlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "coder" },
97  { "ac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "coder" },
98 
99  { "rc_mode", "Select rate control mode", OFFSET(rc_mode), AV_OPT_TYPE_INT, { .i64 = RC_QUALITY_MODE }, RC_OFF_MODE, RC_TIMESTAMP_MODE, VE, "rc_mode" },
100  { "off", "bit rate control off", 0, AV_OPT_TYPE_CONST, { .i64 = RC_OFF_MODE }, 0, 0, VE, "rc_mode" },
101  { "quality", "quality mode", 0, AV_OPT_TYPE_CONST, { .i64 = RC_QUALITY_MODE }, 0, 0, VE, "rc_mode" },
102  { "bitrate", "bitrate mode", 0, AV_OPT_TYPE_CONST, { .i64 = RC_BITRATE_MODE }, 0, 0, VE, "rc_mode" },
103  { "buffer", "using buffer status to adjust the video quality (no bitrate control)", 0, AV_OPT_TYPE_CONST, { .i64 = RC_BUFFERBASED_MODE }, 0, 0, VE, "rc_mode" },
104 #if OPENH264_VER_AT_LEAST(1, 4)
105  { "timestamp", "bit rate control based on timestamp", 0, AV_OPT_TYPE_CONST, { .i64 = RC_TIMESTAMP_MODE }, 0, 0, VE, "rc_mode" },
106 #endif
107 
108  { NULL }
109 };
110 
111 static const AVClass class = {
112  .class_name = "libopenh264enc",
113  .item_name = av_default_item_name,
114  .option = options,
116 };
117 
119 {
120  SVCContext *s = avctx->priv_data;
121 
122  if (s->encoder)
123  WelsDestroySVCEncoder(s->encoder);
124  if (s->skipped > 0)
125  av_log(avctx, AV_LOG_WARNING, "%d frames skipped\n", s->skipped);
126  return 0;
127 }
128 
130 {
131  SVCContext *s = avctx->priv_data;
132  SEncParamExt param = { 0 };
133  int err;
134  int log_level;
135  WelsTraceCallback callback_function;
136  AVCPBProperties *props;
137 
138  if ((err = ff_libopenh264_check_version(avctx)) < 0)
139  return err;
140 
141  if (WelsCreateSVCEncoder(&s->encoder)) {
142  av_log(avctx, AV_LOG_ERROR, "Unable to create encoder\n");
143  return AVERROR_UNKNOWN;
144  }
145 
146  // Pass all libopenh264 messages to our callback, to allow ourselves to filter them.
147  log_level = WELS_LOG_DETAIL;
148  (*s->encoder)->SetOption(s->encoder, ENCODER_OPTION_TRACE_LEVEL, &log_level);
149 
150  // Set the logging callback function to one that uses av_log() (see implementation above).
151  callback_function = (WelsTraceCallback) ff_libopenh264_trace_callback;
152  (*s->encoder)->SetOption(s->encoder, ENCODER_OPTION_TRACE_CALLBACK, &callback_function);
153 
154  // Set the AVCodecContext as the libopenh264 callback context so that it can be passed to av_log().
155  (*s->encoder)->SetOption(s->encoder, ENCODER_OPTION_TRACE_CALLBACK_CONTEXT, &avctx);
156 
157  (*s->encoder)->GetDefaultParams(s->encoder, &param);
158 
159  if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
160  param.fMaxFrameRate = av_q2d(avctx->framerate);
161  } else {
162  if (avctx->ticks_per_frame > INT_MAX / avctx->time_base.num) {
163  av_log(avctx, AV_LOG_ERROR,
164  "Could not set framerate for libopenh264enc: integer overflow\n");
165  return AVERROR(EINVAL);
166  }
167  param.fMaxFrameRate = 1.0 / av_q2d(avctx->time_base) / FFMAX(avctx->ticks_per_frame, 1);
168  }
169  param.iPicWidth = avctx->width;
170  param.iPicHeight = avctx->height;
171  param.iTargetBitrate = avctx->bit_rate > 0 ? avctx->bit_rate : TARGET_BITRATE_DEFAULT;
172  param.iMaxBitrate = FFMAX(avctx->rc_max_rate, avctx->bit_rate);
173  param.iRCMode = s->rc_mode;
174  if (avctx->qmax >= 0)
175  param.iMaxQp = av_clip(avctx->qmax, 1, 51);
176  if (avctx->qmin >= 0)
177  param.iMinQp = av_clip(avctx->qmin, 1, param.iMaxQp);
178  param.iTemporalLayerNum = 1;
179  param.iSpatialLayerNum = 1;
180  param.bEnableDenoise = 0;
181  param.bEnableBackgroundDetection = 1;
182  param.bEnableAdaptiveQuant = 1;
183  param.bEnableFrameSkip = s->skip_frames;
184  param.bEnableLongTermReference = 0;
185  param.iLtrMarkPeriod = 30;
186  if (avctx->gop_size >= 0)
187  param.uiIntraPeriod = avctx->gop_size;
188 #if OPENH264_VER_AT_LEAST(1, 4)
189  param.eSpsPpsIdStrategy = CONSTANT_ID;
190 #else
191  param.bEnableSpsPpsIdAddition = 0;
192 #endif
193  param.bPrefixNalAddingCtrl = 0;
194  param.iLoopFilterDisableIdc = !s->loopfilter;
195  param.iEntropyCodingModeFlag = 0;
196  param.iMultipleThreadIdc = avctx->thread_count;
197 
198  /* Allow specifying the libopenh264 profile through AVCodecContext. */
199  if (FF_PROFILE_UNKNOWN == s->profile &&
200  FF_PROFILE_UNKNOWN != avctx->profile)
201  switch (avctx->profile) {
205  s->profile = avctx->profile;
206  break;
207  default:
208  av_log(avctx, AV_LOG_WARNING,
209  "Unsupported avctx->profile: %d.\n", avctx->profile);
210  break;
211  }
212 
213 #if FF_API_CODER_TYPE && FF_API_OPENH264_CABAC
215  if (s->coder < 0 && avctx->coder_type == FF_CODER_TYPE_AC)
216  s->coder = 1;
217 
218  if (s->coder < 0)
219  s->coder = s->cabac;
221 #endif
222 
223  if (s->profile == FF_PROFILE_UNKNOWN && s->coder >= 0)
224  s->profile = s->coder == 0 ? FF_PROFILE_H264_CONSTRAINED_BASELINE :
225 #if OPENH264_VER_AT_LEAST(1, 8)
227 #else
229 #endif
230 
231  switch (s->profile) {
232 #if OPENH264_VER_AT_LEAST(1, 8)
234  param.iEntropyCodingModeFlag = 1;
235  av_log(avctx, AV_LOG_VERBOSE, "Using CABAC, "
236  "select EProfileIdc PRO_HIGH in libopenh264.\n");
237  break;
238 #else
240  param.iEntropyCodingModeFlag = 1;
241  av_log(avctx, AV_LOG_VERBOSE, "Using CABAC, "
242  "select EProfileIdc PRO_MAIN in libopenh264.\n");
243  break;
244 #endif
246  case FF_PROFILE_UNKNOWN:
247  param.iEntropyCodingModeFlag = 0;
248  av_log(avctx, AV_LOG_VERBOSE, "Using CAVLC, "
249  "select EProfileIdc PRO_BASELINE in libopenh264.\n");
250  break;
251  default:
252  param.iEntropyCodingModeFlag = 0;
253  av_log(avctx, AV_LOG_WARNING, "Unsupported profile, "
254  "select EProfileIdc PRO_BASELINE in libopenh264.\n");
255  break;
256  }
257 
258  param.sSpatialLayers[0].iVideoWidth = param.iPicWidth;
259  param.sSpatialLayers[0].iVideoHeight = param.iPicHeight;
260  param.sSpatialLayers[0].fFrameRate = param.fMaxFrameRate;
261  param.sSpatialLayers[0].iSpatialBitrate = param.iTargetBitrate;
262  param.sSpatialLayers[0].iMaxSpatialBitrate = param.iMaxBitrate;
263 
264 #if OPENH264_VER_AT_LEAST(1, 7)
265  if (avctx->sample_aspect_ratio.num && avctx->sample_aspect_ratio.den) {
266  // Table E-1.
267  static const AVRational sar_idc[] = {
268  { 0, 0 }, // Unspecified (never written here).
269  { 1, 1 }, { 12, 11 }, { 10, 11 }, { 16, 11 },
270  { 40, 33 }, { 24, 11 }, { 20, 11 }, { 32, 11 },
271  { 80, 33 }, { 18, 11 }, { 15, 11 }, { 64, 33 },
272  { 160, 99 }, // Last 3 are unknown to openh264: { 4, 3 }, { 3, 2 }, { 2, 1 },
273  };
274  static const ESampleAspectRatio asp_idc[] = {
275  ASP_UNSPECIFIED,
276  ASP_1x1, ASP_12x11, ASP_10x11, ASP_16x11,
277  ASP_40x33, ASP_24x11, ASP_20x11, ASP_32x11,
278  ASP_80x33, ASP_18x11, ASP_15x11, ASP_64x33,
279  ASP_160x99,
280  };
281  int num, den, i;
282 
283  av_reduce(&num, &den, avctx->sample_aspect_ratio.num,
284  avctx->sample_aspect_ratio.den, 65535);
285 
286  for (i = 1; i < FF_ARRAY_ELEMS(sar_idc); i++) {
287  if (num == sar_idc[i].num &&
288  den == sar_idc[i].den)
289  break;
290  }
291  if (i == FF_ARRAY_ELEMS(sar_idc)) {
292  param.sSpatialLayers[0].eAspectRatio = ASP_EXT_SAR;
293  param.sSpatialLayers[0].sAspectRatioExtWidth = num;
294  param.sSpatialLayers[0].sAspectRatioExtHeight = den;
295  } else {
296  param.sSpatialLayers[0].eAspectRatio = asp_idc[i];
297  }
298  param.sSpatialLayers[0].bAspectRatioPresent = true;
299  } else {
300  param.sSpatialLayers[0].bAspectRatioPresent = false;
301  }
302 #endif
303 
304  if ((avctx->slices > 1) && (s->max_nal_size)) {
305  av_log(avctx, AV_LOG_ERROR,
306  "Invalid combination -slices %d and -max_nal_size %d.\n",
307  avctx->slices, s->max_nal_size);
308  return AVERROR(EINVAL);
309  }
310 
311  if (avctx->slices > 1)
312  s->slice_mode = SM_FIXEDSLCNUM_SLICE;
313 
314  if (s->max_nal_size)
315  s->slice_mode = SM_SIZELIMITED_SLICE;
316 
317 #if OPENH264_VER_AT_LEAST(1, 6)
318  param.sSpatialLayers[0].sSliceArgument.uiSliceMode = s->slice_mode;
319  param.sSpatialLayers[0].sSliceArgument.uiSliceNum = avctx->slices;
320 #else
321  param.sSpatialLayers[0].sSliceCfg.uiSliceMode = s->slice_mode;
322  param.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = avctx->slices;
323 #endif
324  if (avctx->slices == 0 && s->slice_mode == SM_FIXEDSLCNUM_SLICE)
325  av_log(avctx, AV_LOG_WARNING, "Slice count will be set automatically\n");
326 
327  if (s->slice_mode == SM_SIZELIMITED_SLICE) {
328  if (s->max_nal_size) {
329  param.uiMaxNalSize = s->max_nal_size;
330 #if OPENH264_VER_AT_LEAST(1, 6)
331  param.sSpatialLayers[0].sSliceArgument.uiSliceSizeConstraint = s->max_nal_size;
332 #else
333  param.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceSizeConstraint = s->max_nal_size;
334 #endif
335  } else {
336  av_log(avctx, AV_LOG_ERROR, "Invalid -max_nal_size, "
337  "specify a valid max_nal_size to use -slice_mode dyn\n");
338  return AVERROR(EINVAL);
339  }
340  }
341 
342  if ((*s->encoder)->InitializeExt(s->encoder, &param) != cmResultSuccess) {
343  av_log(avctx, AV_LOG_ERROR, "Initialize failed\n");
344  return AVERROR_UNKNOWN;
345  }
346 
347  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
348  SFrameBSInfo fbi = { 0 };
349  int i, size = 0;
350  (*s->encoder)->EncodeParameterSets(s->encoder, &fbi);
351  for (i = 0; i < fbi.sLayerInfo[0].iNalCount; i++)
352  size += fbi.sLayerInfo[0].pNalLengthInByte[i];
354  if (!avctx->extradata)
355  return AVERROR(ENOMEM);
356  avctx->extradata_size = size;
357  memcpy(avctx->extradata, fbi.sLayerInfo[0].pBsBuf, size);
358  }
359 
360  props = ff_add_cpb_side_data(avctx);
361  if (!props)
362  return AVERROR(ENOMEM);
363  props->max_bitrate = param.iMaxBitrate;
364  props->avg_bitrate = param.iTargetBitrate;
365 
366  return 0;
367 }
368 
369 static int svc_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
370  const AVFrame *frame, int *got_packet)
371 {
372  SVCContext *s = avctx->priv_data;
373  SFrameBSInfo fbi = { 0 };
374  int i, ret;
375  int encoded;
376  SSourcePicture sp = { 0 };
377  int size = 0, layer, first_layer = 0;
378  int layer_size[MAX_LAYER_NUM_OF_FRAME] = { 0 };
379 
380  sp.iColorFormat = videoFormatI420;
381  for (i = 0; i < 3; i++) {
382  sp.iStride[i] = frame->linesize[i];
383  sp.pData[i] = frame->data[i];
384  }
385  sp.iPicWidth = avctx->width;
386  sp.iPicHeight = avctx->height;
387 
388  if (frame->pict_type == AV_PICTURE_TYPE_I) {
389  (*s->encoder)->ForceIntraFrame(s->encoder, true);
390  }
391 
392  encoded = (*s->encoder)->EncodeFrame(s->encoder, &sp, &fbi);
393  if (encoded != cmResultSuccess) {
394  av_log(avctx, AV_LOG_ERROR, "EncodeFrame failed\n");
395  return AVERROR_UNKNOWN;
396  }
397  if (fbi.eFrameType == videoFrameTypeSkip) {
398  s->skipped++;
399  av_log(avctx, AV_LOG_DEBUG, "frame skipped\n");
400  return 0;
401  }
402  first_layer = 0;
403  // Normal frames are returned with one single layer, while IDR
404  // frames have two layers, where the first layer contains the SPS/PPS.
405  // If using global headers, don't include the SPS/PPS in the returned
406  // packet - thus, only return one layer.
407  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER)
408  first_layer = fbi.iLayerNum - 1;
409 
410  for (layer = first_layer; layer < fbi.iLayerNum; layer++) {
411  for (i = 0; i < fbi.sLayerInfo[layer].iNalCount; i++)
412  layer_size[layer] += fbi.sLayerInfo[layer].pNalLengthInByte[i];
413  size += layer_size[layer];
414  }
415  av_log(avctx, AV_LOG_DEBUG, "%d slices\n", fbi.sLayerInfo[fbi.iLayerNum - 1].iNalCount);
416 
417  if ((ret = ff_alloc_packet2(avctx, avpkt, size, size))) {
418  av_log(avctx, AV_LOG_ERROR, "Error getting output packet\n");
419  return ret;
420  }
421  size = 0;
422  for (layer = first_layer; layer < fbi.iLayerNum; layer++) {
423  memcpy(avpkt->data + size, fbi.sLayerInfo[layer].pBsBuf, layer_size[layer]);
424  size += layer_size[layer];
425  }
426  avpkt->pts = frame->pts;
427  if (fbi.eFrameType == videoFrameTypeIDR)
428  avpkt->flags |= AV_PKT_FLAG_KEY;
429  *got_packet = 1;
430  return 0;
431 }
432 
434  { "b", "0" },
435  { "g", "-1" },
436  { "qmin", "-1" },
437  { "qmax", "-1" },
438  { NULL },
439 };
440 
442  .name = "libopenh264",
443  .long_name = NULL_IF_CONFIG_SMALL("OpenH264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
444  .type = AVMEDIA_TYPE_VIDEO,
445  .id = AV_CODEC_ID_H264,
446  .priv_data_size = sizeof(SVCContext),
448  .encode2 = svc_encode_frame,
449  .close = svc_encode_close,
450  .capabilities = AV_CODEC_CAP_OTHER_THREADS,
453  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P,
454  AV_PIX_FMT_NONE },
455  .defaults = svc_enc_defaults,
456  .priv_class = &class,
457  .wrapper_name = "libopenh264",
458 };
ff_libopenh264_check_version
int ff_libopenh264_check_version(void *logctx)
Definition: libopenh264.c:49
SVCContext
Definition: libopenh264dec.c:36
AVCodec
AVCodec.
Definition: codec.h:197
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
FF_CODEC_CAP_INIT_THREADSAFE
#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:41
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
av_clip
#define av_clip
Definition: common.h:122
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
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
opt.h
FF_PROFILE_H264_CONSTRAINED_BASELINE
#define FF_PROFILE_H264_CONSTRAINED_BASELINE
Definition: avcodec.h:1898
profile
mfxU16 profile
Definition: qsvenc.c:45
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:369
AVOption
AVOption.
Definition: opt.h:248
SVCContext::skipped
int skipped
Definition: libopenh264enc.c:50
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
mathematics.h
ff_libopenh264_encoder
AVCodec ff_libopenh264_encoder
Definition: libopenh264enc.c:441
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
ff_add_cpb_side_data
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:1058
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1387
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:410
libopenh264.h
AV_CODEC_FLAG_GLOBAL_HEADER
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:329
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:2071
SVCContext::max_nal_size
int max_nal_size
Definition: libopenh264enc.c:48
options
static const AVOption options[]
Definition: libopenh264enc.c:63
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1773
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:616
FF_PROFILE_H264_HIGH
#define FF_PROFILE_H264_HIGH
Definition: avcodec.h:1901
SVCContext::coder
int coder
Definition: libopenh264enc.c:54
SVCContext::rc_mode
int rc_mode
Definition: libopenh264enc.c:57
av_reduce
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
AVRational::num
int num
Numerator.
Definition: rational.h:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:638
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
AVCodecContext::ticks_per_frame
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:668
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
AV_CODEC_CAP_OTHER_THREADS
#define AV_CODEC_CAP_OTHER_THREADS
Codec supports multithreading through a method other than slice- or frame-level multithreading.
Definition: codec.h:122
svc_encode_frame
static int svc_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet)
Definition: libopenh264enc.c:369
FF_PROFILE_UNKNOWN
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1859
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:309
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
SVCContext::av_class
const AVClass * av_class
Definition: libopenh264enc.c:43
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1416
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:453
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:76
AVCodecDefault
Definition: internal.h:222
AVCPBProperties::avg_bitrate
int avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: avcodec.h:477
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
NULL
#define NULL
Definition: coverity.c:32
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:586
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
SVCContext::loopfilter
int loopfilter
Definition: libopenh264enc.c:46
SM_SIZELIMITED_SLICE
#define SM_SIZELIMITED_SLICE
Definition: libopenh264enc.c:37
AVCodecContext::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avcodec.h:659
FF_CODEC_CAP_AUTO_THREADS
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
Definition: internal.h:80
SVCContext::encoder
ISVCEncoder * encoder
Definition: libopenh264enc.c:44
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:731
TARGET_BITRATE_DEFAULT
#define TARGET_BITRATE_DEFAULT
Definition: libopenh264enc.c:40
sp
#define sp
Definition: regdef.h:63
FFMAX
#define FFMAX(a, b)
Definition: common.h:103
size
int size
Definition: twinvq_data.h:10344
DEPRECATED
#define DEPRECATED
Definition: libopenh264enc.c:62
PROFILE
#define PROFILE(name, value)
AVCodecContext::coder_type
attribute_deprecated int coder_type
Definition: avcodec.h:1455
AVCPBProperties::max_bitrate
int max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: avcodec.h:459
attributes.h
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:375
i
int i
Definition: input.c:407
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:637
SVCContext::cabac
int cabac
Definition: libopenh264enc.c:52
FF_CODEC_CAP_INIT_CLEANUP
#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:49
internal.h
SVCContext::skip_frames
int skip_frames
Definition: libopenh264enc.c:49
common.h
OFFSET
#define OFFSET(x)
Definition: libopenh264enc.c:60
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:237
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
AVCodecContext::height
int height
Definition: avcodec.h:709
avcodec.h
svc_encode_init
static av_cold int svc_encode_init(AVCodecContext *avctx)
Definition: libopenh264enc.c:129
ret
ret
Definition: filter_design.txt:187
AVClass::class_name
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
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
SVCContext::profile
int profile
Definition: libopenh264enc.c:47
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: avcodec.h:215
AVCodecContext
main external API structure.
Definition: avcodec.h:536
SVCContext::slice_mode
int slice_mode
Definition: libopenh264enc.c:45
svc_encode_close
static av_cold int svc_encode_close(AVCodecContext *avctx)
Definition: libopenh264enc.c:118
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1380
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1858
VE
#define VE
Definition: libopenh264enc.c:61
FF_CODER_TYPE_AC
#define FF_CODER_TYPE_AC
Definition: avcodec.h:1448
ff_libopenh264_trace_callback
void ff_libopenh264_trace_callback(void *ctx, int level, const char *msg)
Definition: libopenh264.c:41
FF_PROFILE_H264_MAIN
#define FF_PROFILE_H264_MAIN
Definition: avcodec.h:1899
svc_enc_defaults
static const AVCodecDefault svc_enc_defaults[]
Definition: libopenh264enc.c:433
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVCodecContext::slices
int slices
Number of slices.
Definition: avcodec.h:1187
AVPacket
This structure stores compressed data.
Definition: packet.h:346
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:563
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:242
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:709
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
rc_mode
mfxU16 rc_mode
Definition: qsvenc.c:84
ff_alloc_packet2
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:33
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
AVCodecContext::sample_aspect_ratio
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:915