FFmpeg: libavcodec/libopenh264enc.c Source File

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/mem.h"
28 #include "libavutil/opt.h"
29 #include "libavutil/internal.h"
30 #include "libavutil/intreadwrite.h"
31 #include "libavutil/mathematics.h"
32 
33 #include "avcodec.h"
34 #include "codec_internal.h"
35 #include "encode.h"
36 #include "libopenh264.h"
37 
38 #if !OPENH264_VER_AT_LEAST(1, 6)
39  #define SM_SIZELIMITED_SLICE SM_DYN_SLICE
40 #endif
41 
42  #define TARGET_BITRATE_DEFAULT 2*1000*1000
43 
44 typedef struct SVCContext {
45   const AVClass *av_class;
46   ISVCEncoder *encoder;
47   int slice_mode;
48   int loopfilter;
49   int profile;
50   int max_nal_size;
51   int skip_frames;
52   int skipped;
53   int coder;
54 
55  // rate control mode
56   int rc_mode;
57 } SVCContext;
58 
59  #define OFFSET(x) offsetof(SVCContext, x)
60  #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
61  #define DEPRECATED AV_OPT_FLAG_DEPRECATED
62  static const AVOption options[] = {
63  { "loopfilter", "enable loop filter", OFFSET(loopfilter), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, VE },
64  { "profile", "set profile restrictions", OFFSET(profile), AV_OPT_TYPE_INT, { .i64 = AV_PROFILE_UNKNOWN }, AV_PROFILE_UNKNOWN, 0xffff, VE, .unit = "profile" },
65 #define PROFILE(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, { .i64 = value }, 0, 0, VE, .unit = "profile"
66  { PROFILE("constrained_baseline", AV_PROFILE_H264_CONSTRAINED_BASELINE) },
67  { PROFILE("main", AV_PROFILE_H264_MAIN) },
68  { PROFILE("high", AV_PROFILE_H264_HIGH) },
69 #undef PROFILE
70  { "max_nal_size", "set maximum NAL size in bytes", OFFSET(max_nal_size), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VE },
71  { "allow_skip_frames", "allow skipping frames to hit the target bitrate", OFFSET(skip_frames), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
72  { "coder", "Coder type", OFFSET(coder), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE, .unit = "coder" },
73  { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 }, INT_MIN, INT_MAX, VE, .unit = "coder" },
74  { "cavlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, .unit = "coder" },
75  { "cabac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, .unit = "coder" },
76  { "vlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, .unit = "coder" },
77  { "ac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, .unit = "coder" },
78 
79  { "rc_mode", "Select rate control mode", OFFSET(rc_mode), AV_OPT_TYPE_INT, { .i64 = RC_QUALITY_MODE }, RC_OFF_MODE, RC_TIMESTAMP_MODE, VE, .unit = "rc_mode" },
80  { "off", "bit rate control off", 0, AV_OPT_TYPE_CONST, { .i64 = RC_OFF_MODE }, 0, 0, VE, .unit = "rc_mode" },
81  { "quality", "quality mode", 0, AV_OPT_TYPE_CONST, { .i64 = RC_QUALITY_MODE }, 0, 0, VE, .unit = "rc_mode" },
82  { "bitrate", "bitrate mode", 0, AV_OPT_TYPE_CONST, { .i64 = RC_BITRATE_MODE }, 0, 0, VE, .unit = "rc_mode" },
83  { "buffer", "using buffer status to adjust the video quality (no bitrate control)", 0, AV_OPT_TYPE_CONST, { .i64 = RC_BUFFERBASED_MODE }, 0, 0, VE, .unit = "rc_mode" },
84 #if OPENH264_VER_AT_LEAST(1, 4)
85  { "timestamp", "bit rate control based on timestamp", 0, AV_OPT_TYPE_CONST, { .i64 = RC_TIMESTAMP_MODE }, 0, 0, VE, .unit = "rc_mode" },
86 #endif
87 
88  { NULL }
89 };
90 
91 static const AVClass class = {
92   .class_name = "libopenh264enc",
93   .item_name = av_default_item_name,
94   .option = options,
95   .version = LIBAVUTIL_VERSION_INT,
96 };
97 
98  static av_cold int svc_encode_close(AVCodecContext *avctx)
99 {
100  SVCContext *s = avctx->priv_data;
101 
102  if (s->encoder)
103  WelsDestroySVCEncoder(s->encoder);
104  if (s->skipped > 0)
105  av_log(avctx, AV_LOG_WARNING, "%d frames skipped\n", s->skipped);
106  return 0;
107 }
108 
109  static av_cold int svc_encode_init(AVCodecContext *avctx)
110 {
111  SVCContext *s = avctx->priv_data;
112  SEncParamExt param = { 0 };
113  int log_level;
114  WelsTraceCallback callback_function;
115  AVCPBProperties *props;
116 
117  if (WelsCreateSVCEncoder(&s->encoder)) {
118  av_log(avctx, AV_LOG_ERROR, "Unable to create encoder\n");
119  return AVERROR_UNKNOWN;
120  }
121 
122  // Pass all libopenh264 messages to our callback, to allow ourselves to filter them.
123  log_level = WELS_LOG_DETAIL;
124  (*s->encoder)->SetOption(s->encoder, ENCODER_OPTION_TRACE_LEVEL, &log_level);
125 
126  // Set the logging callback function to one that uses av_log() (see implementation above).
127  callback_function = (WelsTraceCallback) ff_libopenh264_trace_callback;
128  (*s->encoder)->SetOption(s->encoder, ENCODER_OPTION_TRACE_CALLBACK, &callback_function);
129 
130  // Set the AVCodecContext as the libopenh264 callback context so that it can be passed to av_log().
131  (*s->encoder)->SetOption(s->encoder, ENCODER_OPTION_TRACE_CALLBACK_CONTEXT, &avctx);
132 
133  (*s->encoder)->GetDefaultParams(s->encoder, &param);
134 
135  if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
136  param.fMaxFrameRate = av_q2d(avctx->framerate);
137  } else {
138 FF_DISABLE_DEPRECATION_WARNINGS
139  param.fMaxFrameRate = 1.0 / av_q2d(avctx->time_base)
140 #if FF_API_TICKS_PER_FRAME
141  / FFMAX(avctx->ticks_per_frame, 1)
142 #endif
143  ;
144 FF_ENABLE_DEPRECATION_WARNINGS
145  }
146  param.iPicWidth = avctx->width;
147  param.iPicHeight = avctx->height;
148  param.iTargetBitrate = avctx->bit_rate > 0 ? avctx->bit_rate : TARGET_BITRATE_DEFAULT;
149  param.iMaxBitrate = FFMAX(avctx->rc_max_rate, avctx->bit_rate);
150  param.iRCMode = s->rc_mode;
151  if (avctx->qmax >= 0)
152  param.iMaxQp = av_clip(avctx->qmax, 1, 51);
153  if (avctx->qmin >= 0)
154  param.iMinQp = av_clip(avctx->qmin, 1, param.iMaxQp);
155  param.iTemporalLayerNum = 1;
156  param.iSpatialLayerNum = 1;
157  param.bEnableDenoise = 0;
158  param.bEnableBackgroundDetection = 1;
159  param.bEnableAdaptiveQuant = 1;
160  param.bEnableFrameSkip = s->skip_frames;
161  param.bEnableLongTermReference = 0;
162  param.iLtrMarkPeriod = 30;
163  if (avctx->gop_size >= 0)
164  param.uiIntraPeriod = avctx->gop_size;
165 #if OPENH264_VER_AT_LEAST(1, 4)
166  param.eSpsPpsIdStrategy = CONSTANT_ID;
167 #else
168  param.bEnableSpsPpsIdAddition = 0;
169 #endif
170  param.bPrefixNalAddingCtrl = 0;
171  param.iLoopFilterDisableIdc = !s->loopfilter;
172  param.iEntropyCodingModeFlag = s->coder >= 0 ? s->coder : 1;
173  param.iMultipleThreadIdc = avctx->thread_count;
174 
175  /* Allow specifying the libopenh264 profile through AVCodecContext. */
176  if (AV_PROFILE_UNKNOWN == s->profile &&
177  AV_PROFILE_UNKNOWN != avctx->profile)
178  switch (avctx->profile) {
179  case AV_PROFILE_H264_HIGH:
180  case AV_PROFILE_H264_MAIN:
181  case AV_PROFILE_H264_CONSTRAINED_BASELINE:
182  s->profile = avctx->profile;
183  break;
184  default:
185  av_log(avctx, AV_LOG_WARNING,
186  "Unsupported avctx->profile: %d.\n", avctx->profile);
187  break;
188  }
189 
190  if (s->profile == AV_PROFILE_UNKNOWN && s->coder >= 0)
191  s->profile = s->coder == 0 ? AV_PROFILE_H264_CONSTRAINED_BASELINE :
192 #if OPENH264_VER_AT_LEAST(1, 8)
193  AV_PROFILE_H264_HIGH;
194 #else
195  AV_PROFILE_H264_MAIN;
196 #endif
197 
198  switch (s->profile) {
199  case AV_PROFILE_H264_HIGH:
200  av_log(avctx, AV_LOG_VERBOSE, "Using %s, "
201  "select EProfileIdc PRO_HIGH in libopenh264.\n",
202  param.iEntropyCodingModeFlag ? "CABAC" : "CAVLC");
203  break;
204  case AV_PROFILE_H264_MAIN:
205  av_log(avctx, AV_LOG_VERBOSE, "Using %s, "
206  "select EProfileIdc PRO_MAIN in libopenh264.\n",
207  param.iEntropyCodingModeFlag ? "CABAC" : "CAVLC");
208  break;
209  case AV_PROFILE_H264_CONSTRAINED_BASELINE:
210  case AV_PROFILE_UNKNOWN:
211  s->profile = AV_PROFILE_H264_CONSTRAINED_BASELINE;
212  param.iEntropyCodingModeFlag = 0;
213  av_log(avctx, AV_LOG_VERBOSE, "Using CAVLC, "
214  "select EProfileIdc PRO_BASELINE in libopenh264.\n");
215  break;
216  default:
217  s->profile = AV_PROFILE_H264_CONSTRAINED_BASELINE;
218  param.iEntropyCodingModeFlag = 0;
219  av_log(avctx, AV_LOG_WARNING, "Unsupported profile, "
220  "select EProfileIdc PRO_BASELINE in libopenh264.\n");
221  break;
222  }
223 
224  param.sSpatialLayers[0].iVideoWidth = param.iPicWidth;
225  param.sSpatialLayers[0].iVideoHeight = param.iPicHeight;
226  param.sSpatialLayers[0].fFrameRate = param.fMaxFrameRate;
227  param.sSpatialLayers[0].iSpatialBitrate = param.iTargetBitrate;
228  param.sSpatialLayers[0].iMaxSpatialBitrate = param.iMaxBitrate;
229  param.sSpatialLayers[0].uiProfileIdc = s->profile;
230 
231 #if OPENH264_VER_AT_LEAST(1, 7)
232  if (avctx->sample_aspect_ratio.num && avctx->sample_aspect_ratio.den) {
233  // Table E-1.
234  static const AVRational sar_idc[] = {
235  { 0, 0 }, // Unspecified (never written here).
236  { 1, 1 }, { 12, 11 }, { 10, 11 }, { 16, 11 },
237  { 40, 33 }, { 24, 11 }, { 20, 11 }, { 32, 11 },
238  { 80, 33 }, { 18, 11 }, { 15, 11 }, { 64, 33 },
239  { 160, 99 }, // Last 3 are unknown to openh264: { 4, 3 }, { 3, 2 }, { 2, 1 },
240  };
241  static const ESampleAspectRatio asp_idc[] = {
242  ASP_UNSPECIFIED,
243  ASP_1x1, ASP_12x11, ASP_10x11, ASP_16x11,
244  ASP_40x33, ASP_24x11, ASP_20x11, ASP_32x11,
245  ASP_80x33, ASP_18x11, ASP_15x11, ASP_64x33,
246  ASP_160x99,
247  };
248  int num, den, i;
249 
250  av_reduce(&num, &den, avctx->sample_aspect_ratio.num,
251  avctx->sample_aspect_ratio.den, 65535);
252 
253  for (i = 1; i < FF_ARRAY_ELEMS(sar_idc); i++) {
254  if (num == sar_idc[i].num &&
255  den == sar_idc[i].den)
256  break;
257  }
258  if (i == FF_ARRAY_ELEMS(sar_idc)) {
259  param.sSpatialLayers[0].eAspectRatio = ASP_EXT_SAR;
260  param.sSpatialLayers[0].sAspectRatioExtWidth = num;
261  param.sSpatialLayers[0].sAspectRatioExtHeight = den;
262  } else {
263  param.sSpatialLayers[0].eAspectRatio = asp_idc[i];
264  }
265  param.sSpatialLayers[0].bAspectRatioPresent = true;
266  } else {
267  param.sSpatialLayers[0].bAspectRatioPresent = false;
268  }
269 #endif
270 
271  if ((avctx->slices > 1) && (s->max_nal_size)) {
272  av_log(avctx, AV_LOG_ERROR,
273  "Invalid combination -slices %d and -max_nal_size %d.\n",
274  avctx->slices, s->max_nal_size);
275  return AVERROR(EINVAL);
276  }
277 
278  if (avctx->slices > 1)
279  s->slice_mode = SM_FIXEDSLCNUM_SLICE;
280 
281  if (s->max_nal_size)
282  s->slice_mode = SM_SIZELIMITED_SLICE;
283 
284 #if OPENH264_VER_AT_LEAST(1, 6)
285  param.sSpatialLayers[0].sSliceArgument.uiSliceMode = s->slice_mode;
286  param.sSpatialLayers[0].sSliceArgument.uiSliceNum = avctx->slices;
287 #else
288  param.sSpatialLayers[0].sSliceCfg.uiSliceMode = s->slice_mode;
289  param.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = avctx->slices;
290 #endif
291  if (avctx->slices == 0 && s->slice_mode == SM_FIXEDSLCNUM_SLICE)
292  av_log(avctx, AV_LOG_WARNING, "Slice count will be set automatically\n");
293 
294  if (s->slice_mode == SM_SIZELIMITED_SLICE) {
295  if (s->max_nal_size) {
296  param.uiMaxNalSize = s->max_nal_size;
297 #if OPENH264_VER_AT_LEAST(1, 6)
298  param.sSpatialLayers[0].sSliceArgument.uiSliceSizeConstraint = s->max_nal_size;
299 #else
300  param.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceSizeConstraint = s->max_nal_size;
301 #endif
302  } else {
303  av_log(avctx, AV_LOG_ERROR, "Invalid -max_nal_size, "
304  "specify a valid max_nal_size to use -slice_mode dyn\n");
305  return AVERROR(EINVAL);
306  }
307  }
308 
309 #if OPENH264_VER_AT_LEAST(1, 6)
310  param.sSpatialLayers[0].uiVideoFormat = VF_UNDEF;
311 
312  if (avctx->color_range != AVCOL_RANGE_UNSPECIFIED) {
313  param.sSpatialLayers[0].bFullRange = (avctx->color_range == AVCOL_RANGE_JPEG);
314  } else if (avctx->pix_fmt == AV_PIX_FMT_YUVJ420P)
315  param.sSpatialLayers[0].bFullRange = 1;
316 
317  if (avctx->colorspace != AVCOL_SPC_UNSPECIFIED ||
318  avctx->color_primaries != AVCOL_PRI_UNSPECIFIED ||
319  avctx->color_trc != AVCOL_TRC_UNSPECIFIED) {
320  param.sSpatialLayers[0].bColorDescriptionPresent = true;
321  }
322 
323  if (avctx->colorspace != AVCOL_SPC_UNSPECIFIED)
324  param.sSpatialLayers[0].uiColorMatrix = avctx->colorspace;
325  if (avctx->color_primaries != AVCOL_PRI_UNSPECIFIED)
326  param.sSpatialLayers[0].uiColorPrimaries = avctx->color_primaries;
327  if (avctx->color_trc != AVCOL_TRC_UNSPECIFIED)
328  param.sSpatialLayers[0].uiTransferCharacteristics = avctx->color_trc;
329 
330  param.sSpatialLayers[0].bVideoSignalTypePresent =
331  (param.sSpatialLayers[0].bFullRange || param.sSpatialLayers[0].bColorDescriptionPresent);
332 #endif
333 
334  if ((*s->encoder)->InitializeExt(s->encoder, &param) != cmResultSuccess) {
335  av_log(avctx, AV_LOG_ERROR, "Initialize failed\n");
336  return AVERROR_UNKNOWN;
337  }
338 
339  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
340  SFrameBSInfo fbi = { 0 };
341  int i, size = 0;
342  (*s->encoder)->EncodeParameterSets(s->encoder, &fbi);
343  for (i = 0; i < fbi.sLayerInfo[0].iNalCount; i++)
344  size += fbi.sLayerInfo[0].pNalLengthInByte[i];
345  avctx->extradata = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
346  if (!avctx->extradata)
347  return AVERROR(ENOMEM);
348  avctx->extradata_size = size;
349  memcpy(avctx->extradata, fbi.sLayerInfo[0].pBsBuf, size);
350  }
351 
352  props = ff_encode_add_cpb_side_data(avctx);
353  if (!props)
354  return AVERROR(ENOMEM);
355  props->max_bitrate = param.iMaxBitrate;
356  props->avg_bitrate = param.iTargetBitrate;
357 
358  return 0;
359 }
360 
361  static int svc_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
362  const AVFrame *frame, int *got_packet)
363 {
364  SVCContext *s = avctx->priv_data;
365  SFrameBSInfo fbi = { 0 };
366  int i, ret;
367  int encoded;
368  SSourcePicture sp = { 0 };
369  int size = 0, layer, first_layer = 0;
370  int layer_size[MAX_LAYER_NUM_OF_FRAME] = { 0 };
371 
372  sp.iColorFormat = videoFormatI420;
373  for (i = 0; i < 3; i++) {
374  sp.iStride[i] = frame->linesize[i];
375  sp.pData[i] = frame->data[i];
376  }
377  sp.iPicWidth = avctx->width;
378  sp.iPicHeight = avctx->height;
379 
380  if (frame->pict_type == AV_PICTURE_TYPE_I) {
381  (*s->encoder)->ForceIntraFrame(s->encoder, true);
382  }
383 
384  encoded = (*s->encoder)->EncodeFrame(s->encoder, &sp, &fbi);
385  if (encoded != cmResultSuccess) {
386  av_log(avctx, AV_LOG_ERROR, "EncodeFrame failed\n");
387  return AVERROR_UNKNOWN;
388  }
389  if (fbi.eFrameType == videoFrameTypeSkip) {
390  s->skipped++;
391  av_log(avctx, AV_LOG_DEBUG, "frame skipped\n");
392  return 0;
393  }
394  first_layer = 0;
395  // Normal frames are returned with one single layer, while IDR
396  // frames have two layers, where the first layer contains the SPS/PPS.
397  // If using global headers, don't include the SPS/PPS in the returned
398  // packet - thus, only return one layer.
399  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER)
400  first_layer = fbi.iLayerNum - 1;
401 
402  for (layer = first_layer; layer < fbi.iLayerNum; layer++) {
403  for (i = 0; i < fbi.sLayerInfo[layer].iNalCount; i++)
404  layer_size[layer] += fbi.sLayerInfo[layer].pNalLengthInByte[i];
405  size += layer_size[layer];
406  }
407  av_log(avctx, AV_LOG_DEBUG, "%d slices\n", fbi.sLayerInfo[fbi.iLayerNum - 1].iNalCount);
408 
409  if ((ret = ff_get_encode_buffer(avctx, avpkt, size, 0)))
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 
424  static const FFCodecDefault svc_enc_defaults[] = {
425  { "b", "0" },
426  { "g", "-1" },
427  { "qmin", "-1" },
428  { "qmax", "-1" },
429  { NULL },
430 };
431 
432  const FFCodec ff_libopenh264_encoder = {
433  .p.name = "libopenh264",
434  CODEC_LONG_NAME("OpenH264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
435  .p.type = AVMEDIA_TYPE_VIDEO,
436  .p.id = AV_CODEC_ID_H264,
437  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_OTHER_THREADS |
438  AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
439  .priv_data_size = sizeof(SVCContext),
440  .init = svc_encode_init,
441  FF_CODEC_ENCODE_CB(svc_encode_frame),
442  .close = svc_encode_close,
443  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP |
444  FF_CODEC_CAP_AUTO_THREADS,
445  .p.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P,
446  AV_PIX_FMT_YUVJ420P,
447  AV_PIX_FMT_NONE },
448  .color_ranges = AVCOL_RANGE_MPEG | AVCOL_RANGE_JPEG,
449  .defaults = svc_enc_defaults,
450  .p.priv_class = &class,
451  .p.wrapper_name = "libopenh264",
452 };
SVCContext
Definition: libopenh264dec.c:37
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
av_clip
#define av_clip
Definition: common.h:100
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: codec_internal.h:43
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
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:691
AV_PROFILE_H264_MAIN
#define AV_PROFILE_H264_MAIN
Definition: defs.h:112
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:684
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:686
AVPacket::data
uint8_t * data
Definition: packet.h:539
AVOption
AVOption.
Definition: opt.h:429
encode.h
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:583
SVCContext::skipped
int skipped
Definition: libopenh264enc.c:52
FFCodec
Definition: codec_internal.h:127
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
mathematics.h
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1273
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:594
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:338
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:566
SVCContext::max_nal_size
int max_nal_size
Definition: libopenh264enc.c:50
FFCodecDefault
Definition: codec_internal.h:97
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
options
static const AVOption options[]
Definition: libopenh264enc.c:62
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1593
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:508
SVCContext::coder
int coder
Definition: libopenh264enc.c:53
SVCContext::rc_mode
int rc_mode
Definition: libopenh264enc.c:56
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:320
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
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:677
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
AV_PROFILE_UNKNOWN
#define AV_PROFILE_UNKNOWN
Definition: defs.h:65
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:530
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
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:124
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
Definition: codec.h:159
svc_encode_frame
static int svc_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet)
Definition: libopenh264enc.c:361
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
SVCContext::av_class
const AVClass * av_class
Definition: libopenh264enc.c:45
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:73
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1302
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:558
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:271
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:296
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:701
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AV_PIX_FMT_YUVJ420P
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:85
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:501
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
SVCContext::loopfilter
int loopfilter
Definition: libopenh264enc.c:48
SM_SIZELIMITED_SLICE
#define SM_SIZELIMITED_SLICE
Definition: libopenh264enc.c:39
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:652
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:550
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
SVCContext::encoder
ISVCEncoder * encoder
Definition: libopenh264enc.c:46
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1037
codec_internal.h
TARGET_BITRATE_DEFAULT
#define TARGET_BITRATE_DEFAULT
Definition: libopenh264enc.c:42
ff_libopenh264_encoder
const FFCodec ff_libopenh264_encoder
Definition: libopenh264enc.c:432
size
int size
Definition: twinvq_data.h:10344
PROFILE
#define PROFILE(name, value)
attributes.h
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:545
AVCPBProperties::avg_bitrate
int64_t avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: defs.h:286
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:532
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:529
internal.h
SVCContext::skip_frames
int skip_frames
Definition: libopenh264enc.c:51
common.h
AVCPBProperties::max_bitrate
int64_t max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: defs.h:276
OFFSET
#define OFFSET(x)
Definition: libopenh264enc.c:59
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:256
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
profile
int profile
Definition: mxfenc.c:2228
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:612
AVCodecContext::height
int height
Definition: avcodec.h:624
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:663
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:669
avcodec.h
svc_encode_init
static av_cold int svc_encode_init(AVCodecContext *avctx)
Definition: libopenh264enc.c:109
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:71
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:49
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
AVCodecContext
main external API structure.
Definition: avcodec.h:451
AV_PROFILE_H264_HIGH
#define AV_PROFILE_H264_HIGH
Definition: defs.h:114
SVCContext::slice_mode
int slice_mode
Definition: libopenh264enc.c:47
ff_get_encode_buffer
int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)
Get a buffer for a packet.
Definition: encode.c:106
svc_encode_close
static av_cold int svc_encode_close(AVCodecContext *avctx)
Definition: libopenh264enc.c:98
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1266
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1650
VE
#define VE
Definition: libopenh264enc.c:60
AVCodecContext::ticks_per_frame
attribute_deprecated int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:582
ff_libopenh264_trace_callback
void ff_libopenh264_trace_callback(void *ctx, int level, const char *msg)
Definition: libopenh264.c:42
AV_PROFILE_H264_CONSTRAINED_BASELINE
#define AV_PROFILE_H264_CONSTRAINED_BASELINE
Definition: defs.h:111
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
FF_CODEC_CAP_AUTO_THREADS
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
Definition: codec_internal.h:73
AVCodecContext::slices
int slices
Number of slices.
Definition: avcodec.h:1053
AVPacket
This structure stores compressed data.
Definition: packet.h:516
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:624
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ff_encode_add_cpb_side_data
AVCPBProperties * ff_encode_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: encode.c:909
rc_mode
mfxU16 rc_mode
Definition: qsvenc.c:143
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
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:648
svc_enc_defaults
static const FFCodecDefault svc_enc_defaults[]
Definition: libopenh264enc.c:424
Generated on Fri Aug 22 2025 13:58:28 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /