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  param.fMaxFrameRate = 1/av_q2d(avctx->time_base);
160  param.iPicWidth = avctx->width;
161  param.iPicHeight = avctx->height;
162  param.iTargetBitrate = avctx->bit_rate > 0 ? avctx->bit_rate : TARGET_BITRATE_DEFAULT;
163  param.iMaxBitrate = FFMAX(avctx->rc_max_rate, avctx->bit_rate);
164  param.iRCMode = s->rc_mode;
165  if (avctx->qmax >= 0)
166  param.iMaxQp = av_clip(avctx->qmax, 1, 51);
167  if (avctx->qmin >= 0)
168  param.iMinQp = av_clip(avctx->qmin, 1, param.iMaxQp);
169  param.iTemporalLayerNum = 1;
170  param.iSpatialLayerNum = 1;
171  param.bEnableDenoise = 0;
172  param.bEnableBackgroundDetection = 1;
173  param.bEnableAdaptiveQuant = 1;
174  param.bEnableFrameSkip = s->skip_frames;
175  param.bEnableLongTermReference = 0;
176  param.iLtrMarkPeriod = 30;
177  if (avctx->gop_size >= 0)
178  param.uiIntraPeriod = avctx->gop_size;
179 #if OPENH264_VER_AT_LEAST(1, 4)
180  param.eSpsPpsIdStrategy = CONSTANT_ID;
181 #else
182  param.bEnableSpsPpsIdAddition = 0;
183 #endif
184  param.bPrefixNalAddingCtrl = 0;
185  param.iLoopFilterDisableIdc = !s->loopfilter;
186  param.iEntropyCodingModeFlag = 0;
187  param.iMultipleThreadIdc = avctx->thread_count;
188 
189  /* Allow specifying the libopenh264 profile through AVCodecContext. */
190  if (FF_PROFILE_UNKNOWN == s->profile &&
191  FF_PROFILE_UNKNOWN != avctx->profile)
192  switch (avctx->profile) {
196  s->profile = avctx->profile;
197  break;
198  default:
199  av_log(avctx, AV_LOG_WARNING,
200  "Unsupported avctx->profile: %d.\n", avctx->profile);
201  break;
202  }
203 
204 #if FF_API_CODER_TYPE && FF_API_OPENH264_CABAC
206  if (s->coder < 0 && avctx->coder_type == FF_CODER_TYPE_AC)
207  s->coder = 1;
208 
209  if (s->coder < 0)
210  s->coder = s->cabac;
212 #endif
213 
214  if (s->profile == FF_PROFILE_UNKNOWN && s->coder >= 0)
216 #if OPENH264_VER_AT_LEAST(1, 8)
218 #else
220 #endif
221 
222  switch (s->profile) {
223 #if OPENH264_VER_AT_LEAST(1, 8)
225  param.iEntropyCodingModeFlag = 1;
226  av_log(avctx, AV_LOG_VERBOSE, "Using CABAC, "
227  "select EProfileIdc PRO_HIGH in libopenh264.\n");
228  break;
229 #else
231  param.iEntropyCodingModeFlag = 1;
232  av_log(avctx, AV_LOG_VERBOSE, "Using CABAC, "
233  "select EProfileIdc PRO_MAIN in libopenh264.\n");
234  break;
235 #endif
237  case FF_PROFILE_UNKNOWN:
238  param.iEntropyCodingModeFlag = 0;
239  av_log(avctx, AV_LOG_VERBOSE, "Using CAVLC, "
240  "select EProfileIdc PRO_BASELINE in libopenh264.\n");
241  break;
242  default:
243  param.iEntropyCodingModeFlag = 0;
244  av_log(avctx, AV_LOG_WARNING, "Unsupported profile, "
245  "select EProfileIdc PRO_BASELINE in libopenh264.\n");
246  break;
247  }
248 
249  param.sSpatialLayers[0].iVideoWidth = param.iPicWidth;
250  param.sSpatialLayers[0].iVideoHeight = param.iPicHeight;
251  param.sSpatialLayers[0].fFrameRate = param.fMaxFrameRate;
252  param.sSpatialLayers[0].iSpatialBitrate = param.iTargetBitrate;
253  param.sSpatialLayers[0].iMaxSpatialBitrate = param.iMaxBitrate;
254 
255 #if OPENH264_VER_AT_LEAST(1, 7)
256  if (avctx->sample_aspect_ratio.num && avctx->sample_aspect_ratio.den) {
257  // Table E-1.
258  static const AVRational sar_idc[] = {
259  { 0, 0 }, // Unspecified (never written here).
260  { 1, 1 }, { 12, 11 }, { 10, 11 }, { 16, 11 },
261  { 40, 33 }, { 24, 11 }, { 20, 11 }, { 32, 11 },
262  { 80, 33 }, { 18, 11 }, { 15, 11 }, { 64, 33 },
263  { 160, 99 }, // Last 3 are unknown to openh264: { 4, 3 }, { 3, 2 }, { 2, 1 },
264  };
265  static const ESampleAspectRatio asp_idc[] = {
266  ASP_UNSPECIFIED,
267  ASP_1x1, ASP_12x11, ASP_10x11, ASP_16x11,
268  ASP_40x33, ASP_24x11, ASP_20x11, ASP_32x11,
269  ASP_80x33, ASP_18x11, ASP_15x11, ASP_64x33,
270  ASP_160x99,
271  };
272  int num, den, i;
273 
274  av_reduce(&num, &den, avctx->sample_aspect_ratio.num,
275  avctx->sample_aspect_ratio.den, 65535);
276 
277  for (i = 1; i < FF_ARRAY_ELEMS(sar_idc); i++) {
278  if (num == sar_idc[i].num &&
279  den == sar_idc[i].den)
280  break;
281  }
282  if (i == FF_ARRAY_ELEMS(sar_idc)) {
283  param.sSpatialLayers[0].eAspectRatio = ASP_EXT_SAR;
284  param.sSpatialLayers[0].sAspectRatioExtWidth = num;
285  param.sSpatialLayers[0].sAspectRatioExtHeight = den;
286  } else {
287  param.sSpatialLayers[0].eAspectRatio = asp_idc[i];
288  }
289  param.sSpatialLayers[0].bAspectRatioPresent = true;
290  } else {
291  param.sSpatialLayers[0].bAspectRatioPresent = false;
292  }
293 #endif
294 
295  if ((avctx->slices > 1) && (s->max_nal_size)) {
296  av_log(avctx, AV_LOG_ERROR,
297  "Invalid combination -slices %d and -max_nal_size %d.\n",
298  avctx->slices, s->max_nal_size);
299  return AVERROR(EINVAL);
300  }
301 
302  if (avctx->slices > 1)
303  s->slice_mode = SM_FIXEDSLCNUM_SLICE;
304 
305  if (s->max_nal_size)
307 
308 #if OPENH264_VER_AT_LEAST(1, 6)
309  param.sSpatialLayers[0].sSliceArgument.uiSliceMode = s->slice_mode;
310  param.sSpatialLayers[0].sSliceArgument.uiSliceNum = avctx->slices;
311 #else
312  param.sSpatialLayers[0].sSliceCfg.uiSliceMode = s->slice_mode;
313  param.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = avctx->slices;
314 #endif
315  if (avctx->slices == 0 && s->slice_mode == SM_FIXEDSLCNUM_SLICE)
316  av_log(avctx, AV_LOG_WARNING, "Slice count will be set automatically\n");
317 
318  if (s->slice_mode == SM_SIZELIMITED_SLICE) {
319  if (s->max_nal_size) {
320  param.uiMaxNalSize = s->max_nal_size;
321 #if OPENH264_VER_AT_LEAST(1, 6)
322  param.sSpatialLayers[0].sSliceArgument.uiSliceSizeConstraint = s->max_nal_size;
323 #else
324  param.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceSizeConstraint = s->max_nal_size;
325 #endif
326  } else {
327  av_log(avctx, AV_LOG_ERROR, "Invalid -max_nal_size, "
328  "specify a valid max_nal_size to use -slice_mode dyn\n");
329  return AVERROR(EINVAL);
330  }
331  }
332 
333  if ((*s->encoder)->InitializeExt(s->encoder, &param) != cmResultSuccess) {
334  av_log(avctx, AV_LOG_ERROR, "Initialize failed\n");
335  return AVERROR_UNKNOWN;
336  }
337 
338  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
339  SFrameBSInfo fbi = { 0 };
340  int i, size = 0;
341  (*s->encoder)->EncodeParameterSets(s->encoder, &fbi);
342  for (i = 0; i < fbi.sLayerInfo[0].iNalCount; i++)
343  size += fbi.sLayerInfo[0].pNalLengthInByte[i];
345  if (!avctx->extradata)
346  return AVERROR(ENOMEM);
347  avctx->extradata_size = size;
348  memcpy(avctx->extradata, fbi.sLayerInfo[0].pBsBuf, size);
349  }
350 
351  props = ff_add_cpb_side_data(avctx);
352  if (!props)
353  return AVERROR(ENOMEM);
354  props->max_bitrate = param.iMaxBitrate;
355  props->avg_bitrate = param.iTargetBitrate;
356 
357  return 0;
358 }
359 
360 static int svc_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
361  const AVFrame *frame, int *got_packet)
362 {
363  SVCContext *s = avctx->priv_data;
364  SFrameBSInfo fbi = { 0 };
365  int i, ret;
366  int encoded;
367  SSourcePicture sp = { 0 };
368  int size = 0, layer, first_layer = 0;
369  int layer_size[MAX_LAYER_NUM_OF_FRAME] = { 0 };
370 
371  sp.iColorFormat = videoFormatI420;
372  for (i = 0; i < 3; i++) {
373  sp.iStride[i] = frame->linesize[i];
374  sp.pData[i] = frame->data[i];
375  }
376  sp.iPicWidth = avctx->width;
377  sp.iPicHeight = avctx->height;
378 
379  if (frame->pict_type == AV_PICTURE_TYPE_I) {
380  (*s->encoder)->ForceIntraFrame(s->encoder, true);
381  }
382 
383  encoded = (*s->encoder)->EncodeFrame(s->encoder, &sp, &fbi);
384  if (encoded != cmResultSuccess) {
385  av_log(avctx, AV_LOG_ERROR, "EncodeFrame failed\n");
386  return AVERROR_UNKNOWN;
387  }
388  if (fbi.eFrameType == videoFrameTypeSkip) {
389  s->skipped++;
390  av_log(avctx, AV_LOG_DEBUG, "frame skipped\n");
391  return 0;
392  }
393  first_layer = 0;
394  // Normal frames are returned with one single layer, while IDR
395  // frames have two layers, where the first layer contains the SPS/PPS.
396  // If using global headers, don't include the SPS/PPS in the returned
397  // packet - thus, only return one layer.
398  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER)
399  first_layer = fbi.iLayerNum - 1;
400 
401  for (layer = first_layer; layer < fbi.iLayerNum; layer++) {
402  for (i = 0; i < fbi.sLayerInfo[layer].iNalCount; i++)
403  layer_size[layer] += fbi.sLayerInfo[layer].pNalLengthInByte[i];
404  size += layer_size[layer];
405  }
406  av_log(avctx, AV_LOG_DEBUG, "%d slices\n", fbi.sLayerInfo[fbi.iLayerNum - 1].iNalCount);
407 
408  if ((ret = ff_alloc_packet2(avctx, avpkt, size, size))) {
409  av_log(avctx, AV_LOG_ERROR, "Error getting output packet\n");
410  return ret;
411  }
412  size = 0;
413  for (layer = first_layer; layer < fbi.iLayerNum; layer++) {
414  memcpy(avpkt->data + size, fbi.sLayerInfo[layer].pBsBuf, layer_size[layer]);
415  size += layer_size[layer];
416  }
417  avpkt->pts = frame->pts;
418  if (fbi.eFrameType == videoFrameTypeIDR)
419  avpkt->flags |= AV_PKT_FLAG_KEY;
420  *got_packet = 1;
421  return 0;
422 }
423 
425  { "b", "0" },
426  { "g", "-1" },
427  { "qmin", "-1" },
428  { "qmax", "-1" },
429  { NULL },
430 };
431 
433  .name = "libopenh264",
434  .long_name = NULL_IF_CONFIG_SMALL("OpenH264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
435  .type = AVMEDIA_TYPE_VIDEO,
436  .id = AV_CODEC_ID_H264,
437  .priv_data_size = sizeof(SVCContext),
439  .encode2 = svc_encode_frame,
440  .close = svc_encode_close,
441  .capabilities = AV_CODEC_CAP_AUTO_THREADS,
443  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P,
444  AV_PIX_FMT_NONE },
445  .defaults = svc_enc_defaults,
446  .priv_class = &class,
447  .wrapper_name = "libopenh264",
448 };
#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
#define FF_PROFILE_H264_MAIN
Definition: avcodec.h:1900
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:308
AVOption.
Definition: opt.h:248
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
int64_t bit_rate
the average bitrate
Definition: avcodec.h:576
#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:454
int num
Numerator.
Definition: rational.h:59
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
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:905
#define PROFILE(name, value)
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
#define AV_CODEC_CAP_AUTO_THREADS
Codec supports avctx->thread_count == 0 (auto).
Definition: codec.h:118
int profile
profile
Definition: avcodec.h:1859
AVCodec.
Definition: codec.h:190
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:649
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:33
#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:88
AVOptions.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:401
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:627
uint8_t * data
Definition: packet.h:355
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
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
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
#define DEPRECATED
ISVCEncoder * encoder
#define av_log(a,...)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:388
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int qmax
maximum quantizer
Definition: avcodec.h:1375
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
const AVClass * av_class
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:606
#define FF_PROFILE_H264_HIGH
Definition: avcodec.h:1902
const char * name
Name of the codec implementation.
Definition: codec.h:197
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: packet.h:361
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:391
#define VE
static const AVOption options[]
int width
picture width / height.
Definition: avcodec.h:699
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1860
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
static const AVCodecDefault svc_enc_defaults[]
attribute_deprecated int coder_type
Definition: avcodec.h:1443
#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:1785
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:448
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:339
main external API structure.
Definition: avcodec.h:526
int qmin
minimum quantizer
Definition: avcodec.h:1368
#define FF_CODER_TYPE_AC
Definition: avcodec.h:1436
int extradata_size
Definition: avcodec.h:628
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:322
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:329
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:721
#define TARGET_BITRATE_DEFAULT
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:2001
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:215
int slices
Number of slices.
Definition: avcodec.h:1177
void * priv_data
Definition: avcodec.h:553
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
int avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: avcodec.h:472
int ff_libopenh264_check_version(void *logctx)
Definition: libopenh264.c:49
AVCodec ff_libopenh264_encoder
#define FF_PROFILE_H264_CONSTRAINED_BASELINE
Definition: avcodec.h:1899
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: packet.h:332
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:348
int i
Definition: input.c:406
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1404