FFmpeg: libavcodec/libopenh264enc.c Source File

FFmpeg

[フレーム]

libavcodec

libopenh264enc.c

Go to the documentation of this file.

1 /*

2 * OpenH264 video encoder

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 */

22 #include <wels/codec_api.h>

23 #include <wels/codec_ver.h>

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"

33 #include "avcodec.h"

34 #include "codec_internal.h"

35 #include "encode.h"

36 #include "libopenh264.h"

38 #if !OPENH264_VER_AT_LEAST(1, 6)

39 #define SM_SIZELIMITED_SLICE SM_DYN_SLICE

40 #endif

42 #define TARGET_BITRATE_DEFAULT 2*1000*1000

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;

55 // rate control mode

56 int rc_mode;

57 } SVCContext;

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" },

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

88 { NULL }

89 };

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 };

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 param.fMaxFrameRate = 1.0 / av_q2d(avctx->time_base);

139 }

140 param.iPicWidth = avctx->width;

141 param.iPicHeight = avctx->height;

142 param.iTargetBitrate = avctx->bit_rate > 0 ? avctx->bit_rate : TARGET_BITRATE_DEFAULT;

143 param.iMaxBitrate = FFMAX(avctx->rc_max_rate, avctx->bit_rate);

144 param.iRCMode = s->rc_mode;

145 if (avctx->qmax >= 0)

146 param.iMaxQp = av_clip(avctx->qmax, 1, 51);

147 if (avctx->qmin >= 0)

148 param.iMinQp = av_clip(avctx->qmin, 1, param.iMaxQp);

149 param.iTemporalLayerNum = 1;

150 param.iSpatialLayerNum = 1;

151 param.bEnableDenoise = 0;

152 param.bEnableBackgroundDetection = 1;

153 param.bEnableAdaptiveQuant = 1;

154 param.bEnableFrameSkip = s->skip_frames;

155 param.bEnableLongTermReference = 0;

156 param.iLtrMarkPeriod = 30;

157 if (avctx->gop_size >= 0)

158 param.uiIntraPeriod = avctx->gop_size;

159 #if OPENH264_VER_AT_LEAST(1, 4)

160 param.eSpsPpsIdStrategy = CONSTANT_ID;

161 #else

162 param.bEnableSpsPpsIdAddition = 0;

163 #endif

164 param.bPrefixNalAddingCtrl = 0;

165 param.iLoopFilterDisableIdc = !s->loopfilter;

166 param.iEntropyCodingModeFlag = s->coder >= 0 ? s->coder : 1;

167 param.iMultipleThreadIdc = avctx->thread_count;

168

169 /* Allow specifying the libopenh264 profile through AVCodecContext. */

170 if (AV_PROFILE_UNKNOWN == s->profile &&

171 AV_PROFILE_UNKNOWN != avctx->profile)

172 switch (avctx->profile) {

173 case AV_PROFILE_H264_HIGH:

174 case AV_PROFILE_H264_MAIN:

175 case AV_PROFILE_H264_CONSTRAINED_BASELINE:

176 s->profile = avctx->profile;

177 break;

178 default:

179 av_log(avctx, AV_LOG_WARNING,

180 "Unsupported avctx->profile: %d.\n", avctx->profile);

181 break;

182 }

183

184 if (s->profile == AV_PROFILE_UNKNOWN && s->coder >= 0)

185 s->profile = s->coder == 0 ? AV_PROFILE_H264_CONSTRAINED_BASELINE :

186 #if OPENH264_VER_AT_LEAST(1, 8)

187 AV_PROFILE_H264_HIGH;

188 #else

189 AV_PROFILE_H264_MAIN;

190 #endif

191

192 switch (s->profile) {

193 case AV_PROFILE_H264_HIGH:

194 av_log(avctx, AV_LOG_VERBOSE, "Using %s, "

195 "select EProfileIdc PRO_HIGH in libopenh264.\n",

196 param.iEntropyCodingModeFlag ? "CABAC" : "CAVLC");

197 break;

198 case AV_PROFILE_H264_MAIN:

199 av_log(avctx, AV_LOG_VERBOSE, "Using %s, "

200 "select EProfileIdc PRO_MAIN in libopenh264.\n",

201 param.iEntropyCodingModeFlag ? "CABAC" : "CAVLC");

202 break;

203 case AV_PROFILE_H264_CONSTRAINED_BASELINE:

204 case AV_PROFILE_UNKNOWN:

205 s->profile = AV_PROFILE_H264_CONSTRAINED_BASELINE;

206 param.iEntropyCodingModeFlag = 0;

207 av_log(avctx, AV_LOG_VERBOSE, "Using CAVLC, "

208 "select EProfileIdc PRO_BASELINE in libopenh264.\n");

209 break;

210 default:

211 s->profile = AV_PROFILE_H264_CONSTRAINED_BASELINE;

212 param.iEntropyCodingModeFlag = 0;

213 av_log(avctx, AV_LOG_WARNING, "Unsupported profile, "

214 "select EProfileIdc PRO_BASELINE in libopenh264.\n");

215 break;

216 }

217

218 param.sSpatialLayers[0].iVideoWidth = param.iPicWidth;

219 param.sSpatialLayers[0].iVideoHeight = param.iPicHeight;

220 param.sSpatialLayers[0].fFrameRate = param.fMaxFrameRate;

221 param.sSpatialLayers[0].iSpatialBitrate = param.iTargetBitrate;

222 param.sSpatialLayers[0].iMaxSpatialBitrate = param.iMaxBitrate;

223 param.sSpatialLayers[0].uiProfileIdc = s->profile;

224

225 #if OPENH264_VER_AT_LEAST(1, 7)

226 if (avctx->sample_aspect_ratio.num && avctx->sample_aspect_ratio.den) {

227 // Table E-1.

228 static const AVRational sar_idc[] = {

229 { 0, 0 }, // Unspecified (never written here).

230 { 1, 1 }, { 12, 11 }, { 10, 11 }, { 16, 11 },

231 { 40, 33 }, { 24, 11 }, { 20, 11 }, { 32, 11 },

232 { 80, 33 }, { 18, 11 }, { 15, 11 }, { 64, 33 },

233 { 160, 99 }, // Last 3 are unknown to openh264: { 4, 3 }, { 3, 2 }, { 2, 1 },

234 };

235 static const ESampleAspectRatio asp_idc[] = {

236 ASP_UNSPECIFIED,

237 ASP_1x1, ASP_12x11, ASP_10x11, ASP_16x11,

238 ASP_40x33, ASP_24x11, ASP_20x11, ASP_32x11,

239 ASP_80x33, ASP_18x11, ASP_15x11, ASP_64x33,

240 ASP_160x99,

241 };

242 int num, den, i;

243

244 av_reduce(&num, &den, avctx->sample_aspect_ratio.num,

245 avctx->sample_aspect_ratio.den, 65535);

246

247 for (i = 1; i < FF_ARRAY_ELEMS(sar_idc); i++) {

248 if (num == sar_idc[i].num &&

249 den == sar_idc[i].den)

250 break;

251 }

252 if (i == FF_ARRAY_ELEMS(sar_idc)) {

253 param.sSpatialLayers[0].eAspectRatio = ASP_EXT_SAR;

254 param.sSpatialLayers[0].sAspectRatioExtWidth = num;

255 param.sSpatialLayers[0].sAspectRatioExtHeight = den;

256 } else {

257 param.sSpatialLayers[0].eAspectRatio = asp_idc[i];

258 }

259 param.sSpatialLayers[0].bAspectRatioPresent = true;

260 } else {

261 param.sSpatialLayers[0].bAspectRatioPresent = false;

262 }

263 #endif

264

265 if ((avctx->slices > 1) && (s->max_nal_size)) {

266 av_log(avctx, AV_LOG_ERROR,

267 "Invalid combination -slices %d and -max_nal_size %d.\n",

268 avctx->slices, s->max_nal_size);

269 return AVERROR(EINVAL);

270 }

271

272 if (avctx->slices > 1)

273 s->slice_mode = SM_FIXEDSLCNUM_SLICE;

274

275 if (s->max_nal_size)

276 s->slice_mode = SM_SIZELIMITED_SLICE;

277

278 #if OPENH264_VER_AT_LEAST(1, 6)

279 param.sSpatialLayers[0].sSliceArgument.uiSliceMode = s->slice_mode;

280 param.sSpatialLayers[0].sSliceArgument.uiSliceNum = avctx->slices;

281 #else

282 param.sSpatialLayers[0].sSliceCfg.uiSliceMode = s->slice_mode;

283 param.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = avctx->slices;

284 #endif

285 if (avctx->slices == 0 && s->slice_mode == SM_FIXEDSLCNUM_SLICE)

286 av_log(avctx, AV_LOG_WARNING, "Slice count will be set automatically\n");

287

288 if (s->slice_mode == SM_SIZELIMITED_SLICE) {

289 if (s->max_nal_size) {

290 param.uiMaxNalSize = s->max_nal_size;

291 #if OPENH264_VER_AT_LEAST(1, 6)

292 param.sSpatialLayers[0].sSliceArgument.uiSliceSizeConstraint = s->max_nal_size;

293 #else

294 param.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceSizeConstraint = s->max_nal_size;

295 #endif

296 } else {

297 av_log(avctx, AV_LOG_ERROR, "Invalid -max_nal_size, "

298 "specify a valid max_nal_size to use -slice_mode dyn\n");

299 return AVERROR(EINVAL);

300 }

301 }

302

303 #if OPENH264_VER_AT_LEAST(1, 6)

304 param.sSpatialLayers[0].uiVideoFormat = VF_UNDEF;

305

306 if (avctx->color_range != AVCOL_RANGE_UNSPECIFIED) {

307 param.sSpatialLayers[0].bFullRange = (avctx->color_range == AVCOL_RANGE_JPEG);

308 } else if (avctx->pix_fmt == AV_PIX_FMT_YUVJ420P)

309 param.sSpatialLayers[0].bFullRange = 1;

310

311 if (avctx->colorspace != AVCOL_SPC_UNSPECIFIED ||

312 avctx->color_primaries != AVCOL_PRI_UNSPECIFIED ||

313 avctx->color_trc != AVCOL_TRC_UNSPECIFIED) {

314 param.sSpatialLayers[0].bColorDescriptionPresent = true;

315 }

316

317 if (avctx->colorspace != AVCOL_SPC_UNSPECIFIED)

318 param.sSpatialLayers[0].uiColorMatrix = avctx->colorspace;

319 if (avctx->color_primaries != AVCOL_PRI_UNSPECIFIED)

320 param.sSpatialLayers[0].uiColorPrimaries = avctx->color_primaries;

321 if (avctx->color_trc != AVCOL_TRC_UNSPECIFIED)

322 param.sSpatialLayers[0].uiTransferCharacteristics = avctx->color_trc;

323

324 param.sSpatialLayers[0].bVideoSignalTypePresent =

325 (param.sSpatialLayers[0].bFullRange || param.sSpatialLayers[0].bColorDescriptionPresent);

326 #endif

327

328 if ((*s->encoder)->InitializeExt(s->encoder, &param) != cmResultSuccess) {

329 av_log(avctx, AV_LOG_ERROR, "Initialize failed\n");

330 return AVERROR_UNKNOWN;

331 }

332

333 if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {

334 SFrameBSInfo fbi = { 0 };

335 int i, size = 0;

336 (*s->encoder)->EncodeParameterSets(s->encoder, &fbi);

337 for (i = 0; i < fbi.sLayerInfo[0].iNalCount; i++)

338 size += fbi.sLayerInfo[0].pNalLengthInByte[i];

339 avctx->extradata = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);

340 if (!avctx->extradata)

341 return AVERROR(ENOMEM);

342 avctx->extradata_size = size;

343 memcpy(avctx->extradata, fbi.sLayerInfo[0].pBsBuf, size);

344 }

345

346 props = ff_encode_add_cpb_side_data(avctx);

347 if (!props)

348 return AVERROR(ENOMEM);

349 props->max_bitrate = param.iMaxBitrate;

350 props->avg_bitrate = param.iTargetBitrate;

351

352 return 0;

353 }

354

355 static int svc_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,

356 const AVFrame *frame, int *got_packet)

357 {

358 SVCContext *s = avctx->priv_data;

359 SFrameBSInfo fbi = { 0 };

360 int i, ret;

361 int encoded;

362 SSourcePicture sp = { 0 };

363 int size = 0, layer, first_layer = 0;

364 int layer_size[MAX_LAYER_NUM_OF_FRAME] = { 0 };

365

366 sp.iColorFormat = videoFormatI420;

367 for (i = 0; i < 3; i++) {

368 sp.iStride[i] = frame->linesize[i];

369 sp.pData[i] = frame->data[i];

370 }

371 sp.iPicWidth = avctx->width;

372 sp.iPicHeight = avctx->height;

373

374 if (frame->pict_type == AV_PICTURE_TYPE_I) {

375 (*s->encoder)->ForceIntraFrame(s->encoder, true);

376 }

377

378 encoded = (*s->encoder)->EncodeFrame(s->encoder, &sp, &fbi);

379 if (encoded != cmResultSuccess) {

380 av_log(avctx, AV_LOG_ERROR, "EncodeFrame failed\n");

381 return AVERROR_UNKNOWN;

382 }

383 if (fbi.eFrameType == videoFrameTypeSkip) {

384 s->skipped++;

385 av_log(avctx, AV_LOG_DEBUG, "frame skipped\n");

386 return 0;

387 }

388 first_layer = 0;

389 // Normal frames are returned with one single layer, while IDR

390 // frames have two layers, where the first layer contains the SPS/PPS.

391 // If using global headers, don't include the SPS/PPS in the returned

392 // packet - thus, only return one layer.

393 if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER)

394 first_layer = fbi.iLayerNum - 1;

395

396 for (layer = first_layer; layer < fbi.iLayerNum; layer++) {

397 for (i = 0; i < fbi.sLayerInfo[layer].iNalCount; i++)

398 layer_size[layer] += fbi.sLayerInfo[layer].pNalLengthInByte[i];

399 size += layer_size[layer];

400 }

401 av_log(avctx, AV_LOG_DEBUG, "%d slices\n", fbi.sLayerInfo[fbi.iLayerNum - 1].iNalCount);

402

403 if ((ret = ff_get_encode_buffer(avctx, avpkt, size, 0)))

404 return ret;

405

406 size = 0;

407 for (layer = first_layer; layer < fbi.iLayerNum; layer++) {

408 memcpy(avpkt->data + size, fbi.sLayerInfo[layer].pBsBuf, layer_size[layer]);

409 size += layer_size[layer];

410 }

411 avpkt->pts = frame->pts;

412 if (fbi.eFrameType == videoFrameTypeIDR)

413 avpkt->flags |= AV_PKT_FLAG_KEY;

414 *got_packet = 1;

415 return 0;

416 }

417

418 static const FFCodecDefault svc_enc_defaults[] = {

419 { "b", "0" },

420 { "g", "-1" },

421 { "qmin", "-1" },

422 { "qmax", "-1" },

423 { NULL },

424 };

425

426 const FFCodec ff_libopenh264_encoder = {

427 .p.name = "libopenh264",

428 CODEC_LONG_NAME("OpenH264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),

429 .p.type = AVMEDIA_TYPE_VIDEO,

430 .p.id = AV_CODEC_ID_H264,

431 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_OTHER_THREADS |

432 AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,

433 .priv_data_size = sizeof(SVCContext),

434 .init = svc_encode_init,

435 FF_CODEC_ENCODE_CB(svc_encode_frame),

436 .close = svc_encode_close,

437 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP |

438 FF_CODEC_CAP_AUTO_THREADS,

439 CODEC_PIXFMTS(AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVJ420P),

440 .color_ranges = AVCOL_RANGE_MPEG | AVCOL_RANGE_JPEG,

441 .defaults = svc_enc_defaults,

442 .p.priv_class = &class,

443 .p.wrapper_name = "libopenh264",

444 };

CODEC_PIXFMTS

#define CODEC_PIXFMTS(...)

Definition: codec_internal.h:391

SVCContext

Definition: libopenh264dec.c:37

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:216

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:42

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:659

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:427

AVCodecContext::color_trc

enum AVColorTransferCharacteristic color_trc

Color Transfer Characteristic.

Definition: avcodec.h:652

AVCOL_RANGE_JPEG

@ AVCOL_RANGE_JPEG

Full range content.

Definition: pixfmt.h:767

AVPacket::data

uint8_t * data

Definition: packet.h:558

AVOption

AVOption.

Definition: opt.h:429

encode.h

AVCOL_TRC_UNSPECIFIED

@ AVCOL_TRC_UNSPECIFIED

Definition: pixfmt.h:664

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:226

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:1241

AV_PKT_FLAG_KEY

#define AV_PKT_FLAG_KEY

The packet contains a keyframe.

Definition: packet.h:613

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:318

AVCodecContext::framerate

AVRational framerate

Definition: avcodec.h:551

SVCContext::max_nal_size

int max_nal_size

Definition: libopenh264enc.c:50

FFCodecDefault

Definition: codec_internal.h:96

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:1561

AVCodecContext::flags

int flags

AV_CODEC_FLAG_*.

Definition: avcodec.h:488

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:358

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:645

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

av_cold

#define av_cold

Definition: attributes.h:106

AV_PROFILE_UNKNOWN

#define AV_PROFILE_UNKNOWN

Definition: defs.h:65

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:515

intreadwrite.h

#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:109

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:144

svc_encode_frame

static int svc_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet)

Definition: libopenh264enc.c:355

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:231

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:1270

AVCOL_PRI_UNSPECIFIED

@ AVCOL_PRI_UNSPECIFIED

Definition: pixfmt.h:639

AVCPBProperties

This structure describes the bitrate properties of an encoded bitstream.

Definition: defs.h:282

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:331

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:76

NULL

#define NULL

Definition: coverity.c:32

AVCodecContext::color_range

enum AVColorRange color_range

MPEG vs JPEG YUV range.

Definition: avcodec.h:669

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:481

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:241

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:278

options

Definition: swscale.c:43

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:733

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:535

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:1005

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:426

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:564

AVCPBProperties::avg_bitrate

int64_t avg_bitrate

Average bitrate of the stream, in bits per second.

Definition: defs.h:297

#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:551

AVCodecContext::extradata

uint8_t * extradata

Out-of-band global headers that may be used by some codecs.

Definition: avcodec.h:514

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:287

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:179

profile

int profile

Definition: mxfenc.c:2278

AVCOL_SPC_UNSPECIFIED

@ AVCOL_SPC_UNSPECIFIED

Definition: pixfmt.h:693

AVCodecContext::height

int height

Definition: avcodec.h:592

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:631

AVCOL_RANGE_MPEG

@ AVCOL_RANGE_MPEG

Narrow or limited range content.

Definition: pixfmt.h:750

avcodec.h

svc_encode_init

static av_cold int svc_encode_init(AVCodecContext *avctx)

Definition: libopenh264enc.c:109

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:81

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:265

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:431

AV_PROFILE_H264_HIGH

#define AV_PROFILE_H264_HIGH