FFmpeg  4.3.6
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
int size
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
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: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)
#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: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:88
AVOptions.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:393
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:627
static AVFrame * frame
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:192
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 i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define AVERROR(e)
Definition: error.h:43
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:188
#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:606
#define FF_PROFILE_H264_HIGH
Definition: avcodec.h:1902
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
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:383
#define VE
static const AVOption options[]
int width
picture width / height.
Definition: avcodec.h:699
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1860
#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:331
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:314
#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:2043
#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
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
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1404