FFmpeg  4.4.4
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 
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 };
Macro definitions for various function/variable attributes.
#define av_cold
Definition: attributes.h:88
Libavcodec external API header.
#define FF_PROFILE_H264_HIGH
Definition: avcodec.h:1901
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1859
#define FF_PROFILE_H264_CONSTRAINED_BASELINE
Definition: avcodec.h:1898
#define FF_PROFILE_H264_MAIN
Definition: avcodec.h:1899
#define FF_CODER_TYPE_AC
Definition: avcodec.h:1448
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
#define s(width, name)
Definition: cbs_vp9.c:257
common internal and external API header
#define av_clip
Definition: common.h:122
#define FFMAX(a, b)
Definition: common.h:103
#define NULL
Definition: coverity.c:32
static AVFrame * frame
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
Definition: opt.h:234
@ AV_OPT_TYPE_INT
Definition: opt.h:225
@ AV_OPT_TYPE_BOOL
Definition: opt.h:242
#define AV_CODEC_CAP_OTHER_THREADS
Codec supports multithreading through a method other than slice- or frame-level multithreading.
Definition: codec.h:122
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:329
@ AV_CODEC_ID_H264
Definition: codec_id.h:76
#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
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:410
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
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
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
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
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
int i
Definition: input.c:407
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:1064
#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
#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
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
Definition: internal.h:80
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:309
int ff_libopenh264_check_version(void *logctx)
Definition: libopenh264.c:49
void ff_libopenh264_trace_callback(void *ctx, int level, const char *msg)
Definition: libopenh264.c:41
static av_cold int svc_encode_close(AVCodecContext *avctx)
static const AVOption options[]
#define VE
AVCodec ff_libopenh264_encoder
static av_cold int svc_encode_init(AVCodecContext *avctx)
#define SM_SIZELIMITED_SLICE
#define DEPRECATED
#define PROFILE(name, value)
static int svc_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet)
#define TARGET_BITRATE_DEFAULT
#define OFFSET(x)
static const AVCodecDefault svc_enc_defaults[]
AVOptions.
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
mfxU16 rc_mode
Definition: qsvenc.c:84
mfxU16 profile
Definition: qsvenc.c:45
#define sp
Definition: regdef.h:63
#define FF_ARRAY_ELEMS(a)
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:453
int avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: avcodec.h:477
int max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: avcodec.h:459
Describe the class of an AVClass context structure.
Definition: log.h:67
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
main external API structure.
Definition: avcodec.h:536
int width
picture width / height.
Definition: avcodec.h:709
attribute_deprecated int coder_type
Definition: avcodec.h:1455
int qmin
minimum quantizer
Definition: avcodec.h:1380
AVRational framerate
Definition: avcodec.h:2071
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
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:668
int64_t bit_rate
the average bitrate
Definition: avcodec.h:586
int profile
profile
Definition: avcodec.h:1858
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:731
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1416
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1773
int qmax
maximum quantizer
Definition: avcodec.h:1387
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avcodec.h:659
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:616
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:637
int extradata_size
Definition: avcodec.h:638
void * priv_data
Definition: avcodec.h:563
int slices
Number of slices.
Definition: avcodec.h:1187
AVCodec.
Definition: codec.h:197
const char * name
Name of the codec implementation.
Definition: codec.h:204
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:411
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:401
AVOption.
Definition: opt.h:248
This structure stores compressed data.
Definition: packet.h:346
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:375
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
uint8_t * data
Definition: packet.h:369
Rational number (pair of numerator and denominator).
Definition: rational.h:58
int num
Numerator.
Definition: rational.h:59
int den
Denominator.
Definition: rational.h:60
const AVClass * av_class
ISVCEncoder * encoder
#define av_log(a,...)
int size