FFmpeg: libavcodec/libvpxenc.c Source File

FFmpeg

[フレーム]

libavcodec

libvpxenc.c

Go to the documentation of this file.

1 /*

3 *

4 * This file is part of FFmpeg.

5 *

6 * FFmpeg is free software; you can redistribute it and/or

7 * modify it under the terms of the GNU Lesser General Public

8 * License as published by the Free Software Foundation; either

9 * version 2.1 of the License, or (at your option) any later version.

10 *

11 * FFmpeg is distributed in the hope that it will be useful,

12 * but WITHOUT ANY WARRANTY; without even the implied warranty of

13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

14 * Lesser General Public License for more details.

15 *

16 * You should have received a copy of the GNU Lesser General Public

17 * License along with FFmpeg; if not, write to the Free Software

18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

19 */

21 /**

22 * @file

23 * VP8 encoder support via libvpx

24 */

26 #define VPX_DISABLE_CTRL_TYPECHECKS 1

27 #define VPX_CODEC_DISABLE_COMPAT 1

28 #include <vpx/vpx_encoder.h>

29 #include <vpx/vp8cx.h>

31 #include "avcodec.h"

32 #include "internal.h"

33 #include "libavutil/avassert.h"

34 #include "libvpx.h"

35 #include "profiles.h"

36 #include "libavutil/base64.h"

37 #include "libavutil/common.h"

38 #include "libavutil/internal.h"

39 #include "libavutil/intreadwrite.h"

40 #include "libavutil/mathematics.h"

41 #include "libavutil/opt.h"

43 /**

44 * Portion of struct vpx_codec_cx_pkt from vpx_encoder.h.

45 * One encoded frame returned from the library.

46 */

47 struct FrameListData {

48 void *buf; /**< compressed data buffer */

49 size_t sz; /**< length of compressed data */

50 void *buf_alpha;

51 size_t sz_alpha;

52 int64_t pts; /**< time stamp to show frame

53 (in timebase units) */

54 unsigned long duration; /**< duration to show frame

55 (in timebase units) */

56 uint32_t flags; /**< flags for this frame */

57 uint64_t sse[4];

58 int have_sse; /**< true if we have pending sse[] */

59 uint64_t frame_number;

60 struct FrameListData *next;

61 };

63 typedef struct VP8EncoderContext {

64 AVClass *class;

65 struct vpx_codec_ctx encoder;

66 struct vpx_image rawimg;

67 struct vpx_codec_ctx encoder_alpha;

68 struct vpx_image rawimg_alpha;

69 uint8_t is_alpha;

70 struct vpx_fixed_buf twopass_stats;

71 int deadline; //i.e., RT/GOOD/BEST

72 uint64_t sse[4];

73 int have_sse; /**< true if we have pending sse[] */

74 uint64_t frame_number;

75 struct FrameListData *coded_frame_list;

77 int cpu_used;

78 /**

79 * VP8 specific flags, see VP8F_* below.

80 */

81 int flags;

82 #define VP8F_ERROR_RESILIENT 0x00000001 ///< Enable measures appropriate for streaming over lossy links

83 #define VP8F_AUTO_ALT_REF 0x00000002 ///< Enable automatic alternate reference frame generation

85 int auto_alt_ref;

87 int arnr_max_frames;

88 int arnr_strength;

89 int arnr_type;

91 int tune;

93 int lag_in_frames;

94 int error_resilient;

95 int crf;

96 int static_thresh;

97 int max_intra_rate;

98 int rc_undershoot_pct;

99 int rc_overshoot_pct;

100

101 // VP9-only

102 int lossless;

103 int tile_columns;

104 int tile_rows;

105 int frame_parallel;

106 int aq_mode;

107 int drop_threshold;

108 int noise_sensitivity;

109 } VP8Context;

110

111 /** String mappings for enum vp8e_enc_control_id */

112 static const char *const ctlidstr[] = {

113 [VP8E_SET_CPUUSED] = "VP8E_SET_CPUUSED",

114 [VP8E_SET_ENABLEAUTOALTREF] = "VP8E_SET_ENABLEAUTOALTREF",

115 [VP8E_SET_NOISE_SENSITIVITY] = "VP8E_SET_NOISE_SENSITIVITY",

116 [VP8E_SET_STATIC_THRESHOLD] = "VP8E_SET_STATIC_THRESHOLD",

117 [VP8E_SET_TOKEN_PARTITIONS] = "VP8E_SET_TOKEN_PARTITIONS",

118 [VP8E_SET_ARNR_MAXFRAMES] = "VP8E_SET_ARNR_MAXFRAMES",

119 [VP8E_SET_ARNR_STRENGTH] = "VP8E_SET_ARNR_STRENGTH",

120 [VP8E_SET_ARNR_TYPE] = "VP8E_SET_ARNR_TYPE",

121 [VP8E_SET_TUNING] = "VP8E_SET_TUNING",

122 [VP8E_SET_CQ_LEVEL] = "VP8E_SET_CQ_LEVEL",

123 [VP8E_SET_MAX_INTRA_BITRATE_PCT] = "VP8E_SET_MAX_INTRA_BITRATE_PCT",

124 #if CONFIG_LIBVPX_VP9_ENCODER

125 [VP9E_SET_LOSSLESS] = "VP9E_SET_LOSSLESS",

126 [VP9E_SET_TILE_COLUMNS] = "VP9E_SET_TILE_COLUMNS",

127 [VP9E_SET_TILE_ROWS] = "VP9E_SET_TILE_ROWS",

128 [VP9E_SET_FRAME_PARALLEL_DECODING] = "VP9E_SET_FRAME_PARALLEL_DECODING",

129 [VP9E_SET_AQ_MODE] = "VP9E_SET_AQ_MODE",

130 #if VPX_ENCODER_ABI_VERSION > 8

131 [VP9E_SET_COLOR_SPACE] = "VP9E_SET_COLOR_SPACE",

132 #endif

133 #if VPX_ENCODER_ABI_VERSION >= 11

134 [VP9E_SET_COLOR_RANGE] = "VP9E_SET_COLOR_RANGE",

135 #endif

136 #endif

137 };

138

139 static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)

140 {

141 VP8Context *ctx = avctx->priv_data;

142 const char *error = vpx_codec_error(&ctx->encoder);

143 const char *detail = vpx_codec_error_detail(&ctx->encoder);

144

145 av_log(avctx, AV_LOG_ERROR, "%s: %s\n", desc, error);

146 if (detail)

147 av_log(avctx, AV_LOG_ERROR, " Additional information: %s\n", detail);

148 }

149

150 static av_cold void dump_enc_cfg(AVCodecContext *avctx,

151 const struct vpx_codec_enc_cfg *cfg)

152 {

153 int width = -30;

154 int level = AV_LOG_DEBUG;

155

156 av_log(avctx, level, "vpx_codec_enc_cfg\n");

157 av_log(avctx, level, "generic settings\n"

158 " %*s%u\n %*s%u\n %*s%u\n %*s%u\n %*s%u\n"

159 #if CONFIG_LIBVPX_VP9_ENCODER && defined(VPX_IMG_FMT_HIGHBITDEPTH)

160 " %*s%u\n %*s%u\n"

161 #endif

162 " %*s{%u/%u}\n %*s%u\n %*s%d\n %*s%u\n",

163 width, "g_usage:", cfg->g_usage,

164 width, "g_threads:", cfg->g_threads,

165 width, "g_profile:", cfg->g_profile,

166 width, "g_w:", cfg->g_w,

167 width, "g_h:", cfg->g_h,

168 #if CONFIG_LIBVPX_VP9_ENCODER && defined(VPX_IMG_FMT_HIGHBITDEPTH)

169 width, "g_bit_depth:", cfg->g_bit_depth,

170 width, "g_input_bit_depth:", cfg->g_input_bit_depth,

171 #endif

172 width, "g_timebase:", cfg->g_timebase.num, cfg->g_timebase.den,

173 width, "g_error_resilient:", cfg->g_error_resilient,

174 width, "g_pass:", cfg->g_pass,

175 width, "g_lag_in_frames:", cfg->g_lag_in_frames);

176 av_log(avctx, level, "rate control settings\n"

177 " %*s%u\n %*s%u\n %*s%u\n %*s%u\n"

178 " %*s%d\n %*s%p(%"SIZE_SPECIFIER ")\n %*s%u\n",

179 width, "rc_dropframe_thresh:", cfg->rc_dropframe_thresh,

180 width, "rc_resize_allowed:", cfg->rc_resize_allowed,

181 width, "rc_resize_up_thresh:", cfg->rc_resize_up_thresh,

182 width, "rc_resize_down_thresh:", cfg->rc_resize_down_thresh,

183 width, "rc_end_usage:", cfg->rc_end_usage,

184 width, "rc_twopass_stats_in:", cfg->rc_twopass_stats_in.buf, cfg->rc_twopass_stats_in.sz,

185 width, "rc_target_bitrate:", cfg->rc_target_bitrate);

186 av_log(avctx, level, "quantizer settings\n"

187 " %*s%u\n %*s%u\n",

188 width, "rc_min_quantizer:", cfg->rc_min_quantizer,

189 width, "rc_max_quantizer:", cfg->rc_max_quantizer);

190 av_log(avctx, level, "bitrate tolerance\n"

191 " %*s%u\n %*s%u\n",

192 width, "rc_undershoot_pct:", cfg->rc_undershoot_pct,

193 width, "rc_overshoot_pct:", cfg->rc_overshoot_pct);

194 av_log(avctx, level, "decoder buffer model\n"

195 " %*s%u\n %*s%u\n %*s%u\n",

196 width, "rc_buf_sz:", cfg->rc_buf_sz,

197 width, "rc_buf_initial_sz:", cfg->rc_buf_initial_sz,

198 width, "rc_buf_optimal_sz:", cfg->rc_buf_optimal_sz);

199 av_log(avctx, level, "2 pass rate control settings\n"

200 " %*s%u\n %*s%u\n %*s%u\n",

201 width, "rc_2pass_vbr_bias_pct:", cfg->rc_2pass_vbr_bias_pct,

202 width, "rc_2pass_vbr_minsection_pct:", cfg->rc_2pass_vbr_minsection_pct,

203 width, "rc_2pass_vbr_maxsection_pct:", cfg->rc_2pass_vbr_maxsection_pct);

204 av_log(avctx, level, "keyframing settings\n"

205 " %*s%d\n %*s%u\n %*s%u\n",

206 width, "kf_mode:", cfg->kf_mode,

207 width, "kf_min_dist:", cfg->kf_min_dist,

208 width, "kf_max_dist:", cfg->kf_max_dist);

209 av_log(avctx, level, "\n");

210 }

211

212 static void coded_frame_add(void *list, struct FrameListData *cx_frame)

213 {

214 struct FrameListData **p = list;

215

216 while (*p)

217 p = &(*p)->next;

218 *p = cx_frame;

219 cx_frame->next = NULL;

220 }

221

222 static av_cold void free_coded_frame(struct FrameListData *cx_frame)

223 {

224 av_freep(&cx_frame->buf);

225 if (cx_frame->buf_alpha)

226 av_freep(&cx_frame->buf_alpha);

227 av_freep(&cx_frame);

228 }

229

230 static av_cold void free_frame_list(struct FrameListData *list)

231 {

232 struct FrameListData *p = list;

233

234 while (p) {

235 list = list->next;

236 free_coded_frame(p);

237 p = list;

238 }

239 }

240

241 static av_cold int codecctl_int(AVCodecContext *avctx,

242 enum vp8e_enc_control_id id, int val)

243 {

244 VP8Context *ctx = avctx->priv_data;

245 char buf[80];

246 int width = -30;

247 int res;

248

249 snprintf(buf, sizeof(buf), "%s:", ctlidstr[id]);

250 av_log(avctx, AV_LOG_DEBUG, " %*s%d\n", width, buf, val);

251

252 res = vpx_codec_control(&ctx->encoder, id, val);

253 if (res != VPX_CODEC_OK) {

254 snprintf(buf, sizeof(buf), "Failed to set %s codec control",

255 ctlidstr[id]);

256 log_encoder_error(avctx, buf);

257 }

258

259 return res == VPX_CODEC_OK ? 0 : AVERROR(EINVAL);

260 }

261

262 static av_cold int vp8_free(AVCodecContext *avctx)

263 {

264 VP8Context *ctx = avctx->priv_data;

265

266 vpx_codec_destroy(&ctx->encoder);

267 if (ctx->is_alpha)

268 vpx_codec_destroy(&ctx->encoder_alpha);

269 av_freep(&ctx->twopass_stats.buf);

270 av_freep(&avctx->stats_out);

271 free_frame_list(ctx->coded_frame_list);

272 return 0;

273 }

274

275 #if CONFIG_LIBVPX_VP9_ENCODER

276 static int set_pix_fmt(AVCodecContext *avctx, vpx_codec_caps_t codec_caps,

277 struct vpx_codec_enc_cfg *enccfg, vpx_codec_flags_t *flags,

278 vpx_img_fmt_t *img_fmt)

279 {

280 #ifdef VPX_IMG_FMT_HIGHBITDEPTH

281 enccfg->g_bit_depth = enccfg->g_input_bit_depth = 8;

282 #endif

283 switch (avctx->pix_fmt) {

284 case AV_PIX_FMT_YUV420P:

285 enccfg->g_profile = 0;

286 *img_fmt = VPX_IMG_FMT_I420;

287 return 0;

288 case AV_PIX_FMT_YUV422P:

289 enccfg->g_profile = 1;

290 *img_fmt = VPX_IMG_FMT_I422;

291 return 0;

292 #if VPX_IMAGE_ABI_VERSION >= 3

293 case AV_PIX_FMT_YUV440P:

294 enccfg->g_profile = 1;

295 *img_fmt = VPX_IMG_FMT_I440;

296 return 0;

297 #endif

298 case AV_PIX_FMT_YUV444P:

299 enccfg->g_profile = 1;

300 *img_fmt = VPX_IMG_FMT_I444;

301 return 0;

302 #ifdef VPX_IMG_FMT_HIGHBITDEPTH

303 case AV_PIX_FMT_YUV420P10LE:

304 case AV_PIX_FMT_YUV420P12LE:

305 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {

306 enccfg->g_bit_depth = enccfg->g_input_bit_depth =

307 avctx->pix_fmt == AV_PIX_FMT_YUV420P10LE ? 10 : 12;

308 enccfg->g_profile = 2;

309 *img_fmt = VPX_IMG_FMT_I42016;

310 *flags |= VPX_CODEC_USE_HIGHBITDEPTH;

311 return 0;

312 }

313 break;

314 case AV_PIX_FMT_YUV422P10LE:

315 case AV_PIX_FMT_YUV422P12LE:

316 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {

317 enccfg->g_bit_depth = enccfg->g_input_bit_depth =

318 avctx->pix_fmt == AV_PIX_FMT_YUV422P10LE ? 10 : 12;

319 enccfg->g_profile = 3;

320 *img_fmt = VPX_IMG_FMT_I42216;

321 *flags |= VPX_CODEC_USE_HIGHBITDEPTH;

322 return 0;

323 }

324 break;

325 #if VPX_IMAGE_ABI_VERSION >= 3

326 case AV_PIX_FMT_YUV440P10LE:

327 case AV_PIX_FMT_YUV440P12LE:

328 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {

329 enccfg->g_bit_depth = enccfg->g_input_bit_depth =

330 avctx->pix_fmt == AV_PIX_FMT_YUV440P10LE ? 10 : 12;

331 enccfg->g_profile = 3;

332 *img_fmt = VPX_IMG_FMT_I44016;

333 *flags |= VPX_CODEC_USE_HIGHBITDEPTH;

334 return 0;

335 }

336 break;

337 #endif

338 case AV_PIX_FMT_YUV444P10LE:

339 case AV_PIX_FMT_YUV444P12LE:

340 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {

341 enccfg->g_bit_depth = enccfg->g_input_bit_depth =

342 avctx->pix_fmt == AV_PIX_FMT_YUV444P10LE ? 10 : 12;

343 enccfg->g_profile = 3;

344 *img_fmt = VPX_IMG_FMT_I44416;

345 *flags |= VPX_CODEC_USE_HIGHBITDEPTH;

346 return 0;

347 }

348 break;

349 #endif

350 default:

351 break;

352 }

353 av_log(avctx, AV_LOG_ERROR, "Unsupported pixel format.\n");

354 return AVERROR_INVALIDDATA;

355 }

356

357 #if VPX_ENCODER_ABI_VERSION > 8

358 static void set_colorspace(AVCodecContext *avctx)

359 {

360 enum vpx_color_space vpx_cs;

361

362 switch (avctx->colorspace) {

363 case AVCOL_SPC_RGB: vpx_cs = VPX_CS_SRGB; break;

364 case AVCOL_SPC_BT709: vpx_cs = VPX_CS_BT_709; break;

365 case AVCOL_SPC_UNSPECIFIED: vpx_cs = VPX_CS_UNKNOWN; break;

366 case AVCOL_SPC_RESERVED: vpx_cs = VPX_CS_RESERVED; break;

367 case AVCOL_SPC_BT470BG: vpx_cs = VPX_CS_BT_601; break;

368 case AVCOL_SPC_SMPTE170M: vpx_cs = VPX_CS_SMPTE_170; break;

369 case AVCOL_SPC_SMPTE240M: vpx_cs = VPX_CS_SMPTE_240; break;

370 case AVCOL_SPC_BT2020_NCL: vpx_cs = VPX_CS_BT_2020; break;

371 default:

372 av_log(avctx, AV_LOG_WARNING, "Unsupported colorspace (%d)\n",

373 avctx->colorspace);

374 return;

375 }

376 codecctl_int(avctx, VP9E_SET_COLOR_SPACE, vpx_cs);

377 }

378 #endif

379

380 #if VPX_ENCODER_ABI_VERSION >= 11

381 static void set_color_range(AVCodecContext *avctx)

382 {

383 enum vpx_color_range vpx_cr;

384 switch (avctx->color_range) {

385 case AVCOL_RANGE_UNSPECIFIED:

386 case AVCOL_RANGE_MPEG: vpx_cr = VPX_CR_STUDIO_RANGE; break;

387 case AVCOL_RANGE_JPEG: vpx_cr = VPX_CR_FULL_RANGE; break;

388 default:

389 av_log(avctx, AV_LOG_WARNING, "Unsupported color range (%d)\n",

390 avctx->color_range);

391 return;

392 }

393

394 codecctl_int(avctx, VP9E_SET_COLOR_RANGE, vpx_cr);

395 }

396 #endif

397 #endif

398

399 static av_cold int vpx_init(AVCodecContext *avctx,

400 const struct vpx_codec_iface *iface)

401 {

402 VP8Context *ctx = avctx->priv_data;

403 struct vpx_codec_enc_cfg enccfg = { 0 };

404 struct vpx_codec_enc_cfg enccfg_alpha;

405 vpx_codec_flags_t flags = (avctx->flags & AV_CODEC_FLAG_PSNR) ? VPX_CODEC_USE_PSNR : 0;

406 AVCPBProperties *cpb_props;

407 int res;

408 vpx_img_fmt_t img_fmt = VPX_IMG_FMT_I420;

409 #if CONFIG_LIBVPX_VP9_ENCODER

410 vpx_codec_caps_t codec_caps = vpx_codec_get_caps(iface);

411 #endif

412

413 av_log(avctx, AV_LOG_INFO, "%s\n", vpx_codec_version_str());

414 av_log(avctx, AV_LOG_VERBOSE, "%s\n", vpx_codec_build_config());

415

416 if (avctx->pix_fmt == AV_PIX_FMT_YUVA420P)

417 ctx->is_alpha = 1;

418

419 if ((res = vpx_codec_enc_config_default(iface, &enccfg, 0)) != VPX_CODEC_OK) {

420 av_log(avctx, AV_LOG_ERROR, "Failed to get config: %s\n",

421 vpx_codec_err_to_string(res));

422 return AVERROR(EINVAL);

423 }

424

425 #if CONFIG_LIBVPX_VP9_ENCODER

426 if (avctx->codec_id == AV_CODEC_ID_VP9) {

427 if (set_pix_fmt(avctx, codec_caps, &enccfg, &flags, &img_fmt))

428 return AVERROR(EINVAL);

429 }

430 #endif

431

432 if(!avctx->bit_rate)

433 if(avctx->rc_max_rate || avctx->rc_buffer_size || avctx->rc_initial_buffer_occupancy) {

434 av_log( avctx, AV_LOG_ERROR, "Rate control parameters set without a bitrate\n");

435 return AVERROR(EINVAL);

436 }

437

438 dump_enc_cfg(avctx, &enccfg);

439

440 enccfg.g_w = avctx->width;

441 enccfg.g_h = avctx->height;

442 enccfg.g_timebase.num = avctx->time_base.num;

443 enccfg.g_timebase.den = avctx->time_base.den;

444 enccfg.g_threads = avctx->thread_count;

445 enccfg.g_lag_in_frames= ctx->lag_in_frames;

446

447 if (avctx->flags & AV_CODEC_FLAG_PASS1)

448 enccfg.g_pass = VPX_RC_FIRST_PASS;

449 else if (avctx->flags & AV_CODEC_FLAG_PASS2)

450 enccfg.g_pass = VPX_RC_LAST_PASS;

451 else

452 enccfg.g_pass = VPX_RC_ONE_PASS;

453

454 if (avctx->rc_min_rate == avctx->rc_max_rate &&

455 avctx->rc_min_rate == avctx->bit_rate && avctx->bit_rate) {

456 enccfg.rc_end_usage = VPX_CBR;

457 } else if (ctx->crf >= 0) {

458 enccfg.rc_end_usage = VPX_CQ;

459 #if CONFIG_LIBVPX_VP9_ENCODER

460 if (!avctx->bit_rate && avctx->codec_id == AV_CODEC_ID_VP9)

461 enccfg.rc_end_usage = VPX_Q;

462 #endif

463 }

464

465 if (avctx->bit_rate) {

466 enccfg.rc_target_bitrate = av_rescale_rnd(avctx->bit_rate, 1, 1000,

467 AV_ROUND_NEAR_INF);

468 #if CONFIG_LIBVPX_VP9_ENCODER

469 } else if (enccfg.rc_end_usage == VPX_Q) {

470 #endif

471 } else {

472 if (enccfg.rc_end_usage == VPX_CQ) {

473 enccfg.rc_target_bitrate = 1000000;

474 } else {

475 avctx->bit_rate = enccfg.rc_target_bitrate * 1000;

476 av_log(avctx, AV_LOG_WARNING,

477 "Neither bitrate nor constrained quality specified, using default bitrate of %dkbit/sec\n",

478 enccfg.rc_target_bitrate);

479 }

480 }

481

482 if (avctx->codec_id == AV_CODEC_ID_VP9 && ctx->lossless == 1) {

483 enccfg.rc_min_quantizer =

484 enccfg.rc_max_quantizer = 0;

485 } else {

486 if (avctx->qmin >= 0)

487 enccfg.rc_min_quantizer = avctx->qmin;

488 if (avctx->qmax >= 0)

489 enccfg.rc_max_quantizer = avctx->qmax;

490 }

491

492 if (enccfg.rc_end_usage == VPX_CQ

493 #if CONFIG_LIBVPX_VP9_ENCODER

494 || enccfg.rc_end_usage == VPX_Q

495 #endif

496 ) {

497 if (ctx->crf < enccfg.rc_min_quantizer || ctx->crf > enccfg.rc_max_quantizer) {

498 av_log(avctx, AV_LOG_ERROR,

499 "CQ level %d must be between minimum and maximum quantizer value (%d-%d)\n",

500 ctx->crf, enccfg.rc_min_quantizer, enccfg.rc_max_quantizer);

501 return AVERROR(EINVAL);

502 }

503 }

504

505 #if FF_API_PRIVATE_OPT

506 FF_DISABLE_DEPRECATION_WARNINGS

507 if (avctx->frame_skip_threshold)

508 ctx->drop_threshold = avctx->frame_skip_threshold;

509 FF_ENABLE_DEPRECATION_WARNINGS

510 #endif

511 enccfg.rc_dropframe_thresh = ctx->drop_threshold;

512

513 //0-100 (0 => CBR, 100 => VBR)

514 enccfg.rc_2pass_vbr_bias_pct = lrint(avctx->qcompress * 100);

515 if (avctx->bit_rate)

516 enccfg.rc_2pass_vbr_minsection_pct =

517 avctx->rc_min_rate * 100LL / avctx->bit_rate;

518 if (avctx->rc_max_rate)

519 enccfg.rc_2pass_vbr_maxsection_pct =

520 avctx->rc_max_rate * 100LL / avctx->bit_rate;

521

522 if (avctx->rc_buffer_size)

523 enccfg.rc_buf_sz =

524 avctx->rc_buffer_size * 1000LL / avctx->bit_rate;

525 if (avctx->rc_initial_buffer_occupancy)

526 enccfg.rc_buf_initial_sz =

527 avctx->rc_initial_buffer_occupancy * 1000LL / avctx->bit_rate;

528 enccfg.rc_buf_optimal_sz = enccfg.rc_buf_sz * 5 / 6;

529 #if FF_API_MPV_OPT

530 FF_DISABLE_DEPRECATION_WARNINGS

531 if (avctx->rc_buffer_aggressivity != 1.0) {

532 av_log(avctx, AV_LOG_WARNING, "The rc_buffer_aggressivity option is "

533 "deprecated, use the undershoot-pct private option instead.\n");

534 enccfg.rc_undershoot_pct = lrint(avctx->rc_buffer_aggressivity * 100);

535 }

536 FF_ENABLE_DEPRECATION_WARNINGS

537 #endif

538 if (ctx->rc_undershoot_pct >= 0)

539 enccfg.rc_undershoot_pct = ctx->rc_undershoot_pct;

540 if (ctx->rc_overshoot_pct >= 0)

541 enccfg.rc_overshoot_pct = ctx->rc_overshoot_pct;

542

543 //_enc_init() will balk if kf_min_dist differs from max w/VPX_KF_AUTO

544 if (avctx->keyint_min >= 0 && avctx->keyint_min == avctx->gop_size)

545 enccfg.kf_min_dist = avctx->keyint_min;

546 if (avctx->gop_size >= 0)

547 enccfg.kf_max_dist = avctx->gop_size;

548

549 if (enccfg.g_pass == VPX_RC_FIRST_PASS)

550 enccfg.g_lag_in_frames = 0;

551 else if (enccfg.g_pass == VPX_RC_LAST_PASS) {

552 int decode_size, ret;

553

554 if (!avctx->stats_in) {

555 av_log(avctx, AV_LOG_ERROR, "No stats file for second pass\n");

556 return AVERROR_INVALIDDATA;

557 }

558

559 ctx->twopass_stats.sz = strlen(avctx->stats_in) * 3 / 4;

560 ret = av_reallocp(&ctx->twopass_stats.buf, ctx->twopass_stats.sz);

561 if (ret < 0) {

562 av_log(avctx, AV_LOG_ERROR,

563 "Stat buffer alloc (%"SIZE_SPECIFIER " bytes) failed\n",

564 ctx->twopass_stats.sz);

565 ctx->twopass_stats.sz = 0;

566 return ret;

567 }

568 decode_size = av_base64_decode(ctx->twopass_stats.buf, avctx->stats_in,

569 ctx->twopass_stats.sz);

570 if (decode_size < 0) {

571 av_log(avctx, AV_LOG_ERROR, "Stat buffer decode failed\n");

572 return AVERROR_INVALIDDATA;

573 }

574

575 ctx->twopass_stats.sz = decode_size;

576 enccfg.rc_twopass_stats_in = ctx->twopass_stats;

577 }

578

579 /* 0-3: For non-zero values the encoder increasingly optimizes for reduced

580 complexity playback on low powered devices at the expense of encode

581 quality. */

582 if (avctx->profile != FF_PROFILE_UNKNOWN)

583 enccfg.g_profile = avctx->profile;

584

585 enccfg.g_error_resilient = ctx->error_resilient || ctx->flags & VP8F_ERROR_RESILIENT;

586

587 dump_enc_cfg(avctx, &enccfg);

588 /* Construct Encoder Context */

589 res = vpx_codec_enc_init(&ctx->encoder, iface, &enccfg, flags);

590 if (res != VPX_CODEC_OK) {

591 log_encoder_error(avctx, "Failed to initialize encoder");

592 return AVERROR(EINVAL);

593 }

594

595 if (ctx->is_alpha) {

596 enccfg_alpha = enccfg;

597 res = vpx_codec_enc_init(&ctx->encoder_alpha, iface, &enccfg_alpha, flags);

598 if (res != VPX_CODEC_OK) {

599 log_encoder_error(avctx, "Failed to initialize alpha encoder");

600 return AVERROR(EINVAL);

601 }

602 }

603

604 //codec control failures are currently treated only as warnings

605 av_log(avctx, AV_LOG_DEBUG, "vpx_codec_control\n");

606 codecctl_int(avctx, VP8E_SET_CPUUSED, ctx->cpu_used);

607 if (ctx->flags & VP8F_AUTO_ALT_REF)

608 ctx->auto_alt_ref = 1;

609 if (ctx->auto_alt_ref >= 0)

610 codecctl_int(avctx, VP8E_SET_ENABLEAUTOALTREF, ctx->auto_alt_ref);

611 if (ctx->arnr_max_frames >= 0)

612 codecctl_int(avctx, VP8E_SET_ARNR_MAXFRAMES, ctx->arnr_max_frames);

613 if (ctx->arnr_strength >= 0)

614 codecctl_int(avctx, VP8E_SET_ARNR_STRENGTH, ctx->arnr_strength);

615 if (ctx->arnr_type >= 0)

616 codecctl_int(avctx, VP8E_SET_ARNR_TYPE, ctx->arnr_type);

617 if (ctx->tune >= 0)

618 codecctl_int(avctx, VP8E_SET_TUNING, ctx->tune);

619

620 if (CONFIG_LIBVPX_VP8_ENCODER && avctx->codec_id == AV_CODEC_ID_VP8) {

621 #if FF_API_PRIVATE_OPT

622 FF_DISABLE_DEPRECATION_WARNINGS

623 if (avctx->noise_reduction)

624 ctx->noise_sensitivity = avctx->noise_reduction;

625 FF_ENABLE_DEPRECATION_WARNINGS

626 #endif

627 codecctl_int(avctx, VP8E_SET_NOISE_SENSITIVITY, ctx->noise_sensitivity);

628 codecctl_int(avctx, VP8E_SET_TOKEN_PARTITIONS, av_log2(avctx->slices));

629 }

630 #if FF_API_MPV_OPT

631 FF_DISABLE_DEPRECATION_WARNINGS

632 if (avctx->mb_threshold) {

633 av_log(avctx, AV_LOG_WARNING, "The mb_threshold option is deprecated, "

634 "use the static-thresh private option instead.\n");

635 ctx->static_thresh = avctx->mb_threshold;

636 }

637 FF_ENABLE_DEPRECATION_WARNINGS

638 #endif

639 codecctl_int(avctx, VP8E_SET_STATIC_THRESHOLD, ctx->static_thresh);

640 if (ctx->crf >= 0)

641 codecctl_int(avctx, VP8E_SET_CQ_LEVEL, ctx->crf);

642 if (ctx->max_intra_rate >= 0)

643 codecctl_int(avctx, VP8E_SET_MAX_INTRA_BITRATE_PCT, ctx->max_intra_rate);

644

645 #if CONFIG_LIBVPX_VP9_ENCODER

646 if (avctx->codec_id == AV_CODEC_ID_VP9) {

647 if (ctx->lossless >= 0)

648 codecctl_int(avctx, VP9E_SET_LOSSLESS, ctx->lossless);

649 if (ctx->tile_columns >= 0)

650 codecctl_int(avctx, VP9E_SET_TILE_COLUMNS, ctx->tile_columns);

651 if (ctx->tile_rows >= 0)

652 codecctl_int(avctx, VP9E_SET_TILE_ROWS, ctx->tile_rows);

653 if (ctx->frame_parallel >= 0)

654 codecctl_int(avctx, VP9E_SET_FRAME_PARALLEL_DECODING, ctx->frame_parallel);

655 if (ctx->aq_mode >= 0)

656 codecctl_int(avctx, VP9E_SET_AQ_MODE, ctx->aq_mode);

657 #if VPX_ENCODER_ABI_VERSION > 8

658 set_colorspace(avctx);

659 #endif

660 #if VPX_ENCODER_ABI_VERSION >= 11

661 set_color_range(avctx);

662 #endif

663 }

664 #endif

665

666 av_log(avctx, AV_LOG_DEBUG, "Using deadline: %d\n", ctx->deadline);

667

668 //provide dummy value to initialize wrapper, values will be updated each _encode()

669 vpx_img_wrap(&ctx->rawimg, img_fmt, avctx->width, avctx->height, 1,

670 (unsigned char*)1);

671 #if CONFIG_LIBVPX_VP9_ENCODER && defined(VPX_IMG_FMT_HIGHBITDEPTH)

672 if (avctx->codec_id == AV_CODEC_ID_VP9 && (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH))

673 ctx->rawimg.bit_depth = enccfg.g_bit_depth;

674 #endif

675

676 if (ctx->is_alpha)

677 vpx_img_wrap(&ctx->rawimg_alpha, VPX_IMG_FMT_I420, avctx->width, avctx->height, 1,

678 (unsigned char*)1);

679

680 cpb_props = ff_add_cpb_side_data(avctx);

681 if (!cpb_props)

682 return AVERROR(ENOMEM);

683

684 if (enccfg.rc_end_usage == VPX_CBR ||

685 enccfg.g_pass != VPX_RC_ONE_PASS) {

686 cpb_props->max_bitrate = avctx->rc_max_rate;

687 cpb_props->min_bitrate = avctx->rc_min_rate;

688 cpb_props->avg_bitrate = avctx->bit_rate;

689 }

690 cpb_props->buffer_size = avctx->rc_buffer_size;

691

692 return 0;

693 }

694

695 static inline void cx_pktcpy(struct FrameListData *dst,

696 const struct vpx_codec_cx_pkt *src,

697 const struct vpx_codec_cx_pkt *src_alpha,

698 VP8Context *ctx)

699 {

700 dst->pts = src->data.frame.pts;

701 dst->duration = src->data.frame.duration;

702 dst->flags = src->data.frame.flags;

703 dst->sz = src->data.frame.sz;

704 dst->buf = src->data.frame.buf;

705 dst->have_sse = 0;

706 /* For alt-ref frame, don't store PSNR or increment frame_number */

707 if (!(dst->flags & VPX_FRAME_IS_INVISIBLE)) {

708 dst->frame_number = ++ctx->frame_number;

709 dst->have_sse = ctx->have_sse;

710 if (ctx->have_sse) {

711 /* associate last-seen SSE to the frame. */

712 /* Transfers ownership from ctx to dst. */

713 /* WARNING! This makes the assumption that PSNR_PKT comes

714 just before the frame it refers to! */

715 memcpy(dst->sse, ctx->sse, sizeof(dst->sse));

716 ctx->have_sse = 0;

717 }

718 } else {

719 dst->frame_number = -1; /* sanity marker */

720 }

721 if (src_alpha) {

722 dst->buf_alpha = src_alpha->data.frame.buf;

723 dst->sz_alpha = src_alpha->data.frame.sz;

724 } else {

725 dst->buf_alpha = NULL;

726 dst->sz_alpha = 0;

727 }

728 }

729

730 /**

731 * Store coded frame information in format suitable for return from encode2().

732 *

733 * Write information from @a cx_frame to @a pkt

734 * @return packet data size on success

735 * @return a negative AVERROR on error

736 */

737 static int storeframe(AVCodecContext *avctx, struct FrameListData *cx_frame,

738 AVPacket *pkt)

739 {

740 int ret = ff_alloc_packet2(avctx, pkt, cx_frame->sz, 0);

741 uint8_t *side_data;

742 if (ret >= 0) {

743 int pict_type;

744 memcpy(pkt->data, cx_frame->buf, pkt->size);

745 pkt->pts = pkt->dts = cx_frame->pts;

746 #if FF_API_CODED_FRAME

747 FF_DISABLE_DEPRECATION_WARNINGS

748 avctx->coded_frame->pts = cx_frame->pts;

749 avctx->coded_frame->key_frame = !!(cx_frame->flags & VPX_FRAME_IS_KEY);

750 FF_ENABLE_DEPRECATION_WARNINGS

751 #endif

752

753 if (!!(cx_frame->flags & VPX_FRAME_IS_KEY)) {

754 pict_type = AV_PICTURE_TYPE_I;

755 #if FF_API_CODED_FRAME

756 FF_DISABLE_DEPRECATION_WARNINGS

757 avctx->coded_frame->pict_type = pict_type;

758 FF_ENABLE_DEPRECATION_WARNINGS

759 #endif

760 pkt->flags |= AV_PKT_FLAG_KEY;

761 } else {

762 pict_type = AV_PICTURE_TYPE_P;

763 #if FF_API_CODED_FRAME

764 FF_DISABLE_DEPRECATION_WARNINGS

765 avctx->coded_frame->pict_type = pict_type;

766 FF_ENABLE_DEPRECATION_WARNINGS

767 #endif

768 }

769

770 ff_side_data_set_encoder_stats(pkt, 0, cx_frame->sse + 1,

771 cx_frame->have_sse ? 3 : 0, pict_type);

772

773 if (cx_frame->have_sse) {

774 int i;

775 /* Beware of the Y/U/V/all order! */

776 #if FF_API_CODED_FRAME

777 FF_DISABLE_DEPRECATION_WARNINGS

778 avctx->coded_frame->error[0] = cx_frame->sse[1];

779 avctx->coded_frame->error[1] = cx_frame->sse[2];

780 avctx->coded_frame->error[2] = cx_frame->sse[3];

781 avctx->coded_frame->error[3] = 0; // alpha

782 FF_ENABLE_DEPRECATION_WARNINGS

783 #endif

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

785 avctx->error[i] += cx_frame->sse[i + 1];

786 }

787 cx_frame->have_sse = 0;

788 }

789 if (cx_frame->sz_alpha > 0) {

790 side_data = av_packet_new_side_data(pkt,

791 AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL,

792 cx_frame->sz_alpha + 8);

793 if(!side_data) {

794 av_packet_unref(pkt);

795 av_free(pkt);

796 return AVERROR(ENOMEM);

797 }

798 AV_WB64(side_data, 1);

799 memcpy(side_data + 8, cx_frame->buf_alpha, cx_frame->sz_alpha);

800 }

801 } else {

802 return ret;

803 }

804 return pkt->size;

805 }

806

807 /**

808 * Queue multiple output frames from the encoder, returning the front-most.

809 * In cases where vpx_codec_get_cx_data() returns more than 1 frame append

810 * the frame queue. Return the head frame if available.

811 * @return Stored frame size

812 * @return AVERROR(EINVAL) on output size error

813 * @return AVERROR(ENOMEM) on coded frame queue data allocation error

814 */

815 static int queue_frames(AVCodecContext *avctx, AVPacket *pkt_out)

816 {

817 VP8Context *ctx = avctx->priv_data;

818 const struct vpx_codec_cx_pkt *pkt;

819 const struct vpx_codec_cx_pkt *pkt_alpha = NULL;

820 const void *iter = NULL;

821 const void *iter_alpha = NULL;

822 int size = 0;

823

824 if (ctx->coded_frame_list) {

825 struct FrameListData *cx_frame = ctx->coded_frame_list;

826 /* return the leading frame if we've already begun queueing */

827 size = storeframe(avctx, cx_frame, pkt_out);

828 if (size < 0)

829 return size;

830 ctx->coded_frame_list = cx_frame->next;

831 free_coded_frame(cx_frame);

832 }

833

834 /* consume all available output from the encoder before returning. buffers

835 are only good through the next vpx_codec call */

836 while ((pkt = vpx_codec_get_cx_data(&ctx->encoder, &iter)) &&

837 (!ctx->is_alpha ||

838 (ctx->is_alpha && (pkt_alpha = vpx_codec_get_cx_data(&ctx->encoder_alpha, &iter_alpha))))) {

839 switch (pkt->kind) {

840 case VPX_CODEC_CX_FRAME_PKT:

841 if (!size) {

842 struct FrameListData cx_frame;

843

844 /* avoid storing the frame when the list is empty and we haven't yet

845 provided a frame for output */

846 av_assert0(!ctx->coded_frame_list);

847 cx_pktcpy(&cx_frame, pkt, pkt_alpha, ctx);

848 size = storeframe(avctx, &cx_frame, pkt_out);

849 if (size < 0)

850 return size;

851 } else {

852 struct FrameListData *cx_frame =

853 av_malloc(sizeof(struct FrameListData));

854

855 if (!cx_frame) {

856 av_log(avctx, AV_LOG_ERROR,

857 "Frame queue element alloc failed\n");

858 return AVERROR(ENOMEM);

859 }

860 cx_pktcpy(cx_frame, pkt, pkt_alpha, ctx);

861 cx_frame->buf = av_malloc(cx_frame->sz);

862

863 if (!cx_frame->buf) {

864 av_log(avctx, AV_LOG_ERROR,

865 "Data buffer alloc (%"SIZE_SPECIFIER " bytes) failed\n",

866 cx_frame->sz);

867 av_freep(&cx_frame);

868 return AVERROR(ENOMEM);

869 }

870 memcpy(cx_frame->buf, pkt->data.frame.buf, pkt->data.frame.sz);

871 if (ctx->is_alpha) {

872 cx_frame->buf_alpha = av_malloc(cx_frame->sz_alpha);

873 if (!cx_frame->buf_alpha) {

874 av_log(avctx, AV_LOG_ERROR,

875 "Data buffer alloc (%"SIZE_SPECIFIER " bytes) failed\n",

876 cx_frame->sz_alpha);

877 av_free(cx_frame);

878 return AVERROR(ENOMEM);

879 }

880 memcpy(cx_frame->buf_alpha, pkt_alpha->data.frame.buf, pkt_alpha->data.frame.sz);

881 }

882 coded_frame_add(&ctx->coded_frame_list, cx_frame);

883 }

884 break;

885 case VPX_CODEC_STATS_PKT: {

886 struct vpx_fixed_buf *stats = &ctx->twopass_stats;

887 int err;

888 if ((err = av_reallocp(&stats->buf,

889 stats->sz +

890 pkt->data.twopass_stats.sz)) < 0) {

891 stats->sz = 0;

892 av_log(avctx, AV_LOG_ERROR, "Stat buffer realloc failed\n");

893 return err;

894 }

895 memcpy((uint8_t*)stats->buf + stats->sz,

896 pkt->data.twopass_stats.buf, pkt->data.twopass_stats.sz);

897 stats->sz += pkt->data.twopass_stats.sz;

898 break;

899 }

900 case VPX_CODEC_PSNR_PKT:

901 av_assert0(!ctx->have_sse);

902 ctx->sse[0] = pkt->data.psnr.sse[0];

903 ctx->sse[1] = pkt->data.psnr.sse[1];

904 ctx->sse[2] = pkt->data.psnr.sse[2];

905 ctx->sse[3] = pkt->data.psnr.sse[3];

906 ctx->have_sse = 1;

907 break;

908 case VPX_CODEC_CUSTOM_PKT:

909 //ignore unsupported/unrecognized packet types

910 break;

911 }

912 }

913

914 return size;

915 }

916

917 static int vp8_encode(AVCodecContext *avctx, AVPacket *pkt,

918 const AVFrame *frame, int *got_packet)

919 {

920 VP8Context *ctx = avctx->priv_data;

921 struct vpx_image *rawimg = NULL;

922 struct vpx_image *rawimg_alpha = NULL;

923 int64_t timestamp = 0;

924 int res, coded_size;

925 vpx_enc_frame_flags_t flags = 0;

926

927 if (frame) {

928 rawimg = &ctx->rawimg;

929 rawimg->planes[VPX_PLANE_Y] = frame->data[0];

930 rawimg->planes[VPX_PLANE_U] = frame->data[1];

931 rawimg->planes[VPX_PLANE_V] = frame->data[2];

932 rawimg->stride[VPX_PLANE_Y] = frame->linesize[0];

933 rawimg->stride[VPX_PLANE_U] = frame->linesize[1];

934 rawimg->stride[VPX_PLANE_V] = frame->linesize[2];

935 if (ctx->is_alpha) {

936 uint8_t *u_plane, *v_plane;

937 rawimg_alpha = &ctx->rawimg_alpha;

938 rawimg_alpha->planes[VPX_PLANE_Y] = frame->data[3];

939 u_plane = av_malloc(frame->linesize[1] * frame->height);

940 v_plane = av_malloc(frame->linesize[2] * frame->height);

941 if (!u_plane || !v_plane) {

942 av_free(u_plane);

943 av_free(v_plane);

944 return AVERROR(ENOMEM);

945 }

946 memset(u_plane, 0x80, frame->linesize[1] * frame->height);

947 rawimg_alpha->planes[VPX_PLANE_U] = u_plane;

948 memset(v_plane, 0x80, frame->linesize[2] * frame->height);

949 rawimg_alpha->planes[VPX_PLANE_V] = v_plane;

950 rawimg_alpha->stride[VPX_PLANE_Y] = frame->linesize[0];

951 rawimg_alpha->stride[VPX_PLANE_U] = frame->linesize[1];

952 rawimg_alpha->stride[VPX_PLANE_V] = frame->linesize[2];

953 }

954 timestamp = frame->pts;

955 if (frame->pict_type == AV_PICTURE_TYPE_I)

956 flags |= VPX_EFLAG_FORCE_KF;

957 }

958

959 res = vpx_codec_encode(&ctx->encoder, rawimg, timestamp,

960 avctx->ticks_per_frame, flags, ctx->deadline);

961 if (res != VPX_CODEC_OK) {

962 log_encoder_error(avctx, "Error encoding frame");

963 return AVERROR_INVALIDDATA;

964 }

965

966 if (ctx->is_alpha) {

967 res = vpx_codec_encode(&ctx->encoder_alpha, rawimg_alpha, timestamp,

968 avctx->ticks_per_frame, flags, ctx->deadline);

969 if (res != VPX_CODEC_OK) {

970 log_encoder_error(avctx, "Error encoding alpha frame");

971 return AVERROR_INVALIDDATA;

972 }

973 }

974

975 coded_size = queue_frames(avctx, pkt);

976

977 if (!frame && avctx->flags & AV_CODEC_FLAG_PASS1) {

978 unsigned int b64_size = AV_BASE64_SIZE(ctx->twopass_stats.sz);

979

980 avctx->stats_out = av_malloc(b64_size);

981 if (!avctx->stats_out) {

982 av_log(avctx, AV_LOG_ERROR, "Stat buffer alloc (%d bytes) failed\n",

983 b64_size);

984 return AVERROR(ENOMEM);

985 }

986 av_base64_encode(avctx->stats_out, b64_size, ctx->twopass_stats.buf,

987 ctx->twopass_stats.sz);

988 }

989

990 if (rawimg_alpha) {

991 av_freep(&rawimg_alpha->planes[VPX_PLANE_U]);

992 av_freep(&rawimg_alpha->planes[VPX_PLANE_V]);

993 }

994

995 *got_packet = !!coded_size;

996 return 0;

997 }

998

999 #define OFFSET(x) offsetof(VP8Context, x)

1000 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM

1001

1002 #ifndef VPX_ERROR_RESILIENT_DEFAULT

1003 #define VPX_ERROR_RESILIENT_DEFAULT 1

1004 #define VPX_ERROR_RESILIENT_PARTITIONS 2

1005 #endif

1006

1007 #define COMMON_OPTIONS \

1008 { "auto-alt-ref", "Enable use of alternate reference " \

1009 "frames (2-pass only)", OFFSET(auto_alt_ref), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE}, \

1010 { "lag-in-frames", "Number of frames to look ahead for " \

1011 "alternate reference frame selection", OFFSET(lag_in_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \

1012 { "arnr-maxframes", "altref noise reduction max frame count", OFFSET(arnr_max_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \

1013 { "arnr-strength", "altref noise reduction filter strength", OFFSET(arnr_strength), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \

1014 { "arnr-type", "altref noise reduction filter type", OFFSET(arnr_type), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE, "arnr_type"}, \

1015 { "backward", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0, VE, "arnr_type" }, \

1016 { "forward", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0, VE, "arnr_type" }, \

1017 { "centered", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 3}, 0, 0, VE, "arnr_type" }, \

1018 { "tune", "Tune the encoding to a specific scenario", OFFSET(tune), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE, "tune"}, \

1019 { "psnr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VP8_TUNE_PSNR}, 0, 0, VE, "tune"}, \

1020 { "ssim", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VP8_TUNE_SSIM}, 0, 0, VE, "tune"}, \

1021 { "deadline", "Time to spend encoding, in microseconds.", OFFSET(deadline), AV_OPT_TYPE_INT, {.i64 = VPX_DL_GOOD_QUALITY}, INT_MIN, INT_MAX, VE, "quality"}, \

1022 { "best", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_BEST_QUALITY}, 0, 0, VE, "quality"}, \

1023 { "good", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_GOOD_QUALITY}, 0, 0, VE, "quality"}, \

1024 { "realtime", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_REALTIME}, 0, 0, VE, "quality"}, \

1025 { "error-resilient", "Error resilience configuration", OFFSET(error_resilient), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, VE, "er"}, \

1026 { "max-intra-rate", "Maximum I-frame bitrate (pct) 0=unlimited", OFFSET(max_intra_rate), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \

1027 { "default", "Improve resiliency against losses of whole frames", 0, AV_OPT_TYPE_CONST, {.i64 = VPX_ERROR_RESILIENT_DEFAULT}, 0, 0, VE, "er"}, \

1028 { "partitions", "The frame partitions are independently decodable " \

1029 "by the bool decoder, meaning that partitions can be decoded even " \

1030 "though earlier partitions have been lost. Note that intra predicition" \

1031 " is still done over the partition boundary.", 0, AV_OPT_TYPE_CONST, {.i64 = VPX_ERROR_RESILIENT_PARTITIONS}, 0, 0, VE, "er"}, \

1032 { "crf", "Select the quality for constant quality mode", offsetof(VP8Context, crf), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 63, VE }, \

1033 { "static-thresh", "A change threshold on blocks below which they will be skipped by the encoder", OFFSET(static_thresh), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VE }, \

1034 { "drop-threshold", "Frame drop threshold", offsetof(VP8Context, drop_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, VE }, \

1035 { "noise-sensitivity", "Noise sensitivity", OFFSET(noise_sensitivity), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 4, VE}, \

1036 { "undershoot-pct", "Datarate undershoot (min) target (%)", OFFSET(rc_undershoot_pct), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 100, VE }, \

1037 { "overshoot-pct", "Datarate overshoot (max) target (%)", OFFSET(rc_overshoot_pct), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1000, VE }, \

1038

1039 #define LEGACY_OPTIONS \

1040 {"speed", "", offsetof(VP8Context, cpu_used), AV_OPT_TYPE_INT, {.i64 = 1}, -16, 16, VE}, \

1041 {"quality", "", offsetof(VP8Context, deadline), AV_OPT_TYPE_INT, {.i64 = VPX_DL_GOOD_QUALITY}, INT_MIN, INT_MAX, VE, "quality"}, \

1042 {"vp8flags", "", offsetof(VP8Context, flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, 0, UINT_MAX, VE, "flags"}, \

1043 {"error_resilient", "enable error resilience", 0, AV_OPT_TYPE_CONST, {.i64 = VP8F_ERROR_RESILIENT}, INT_MIN, INT_MAX, VE, "flags"}, \

1044 {"altref", "enable use of alternate reference frames (VP8/2-pass only)", 0, AV_OPT_TYPE_CONST, {.i64 = VP8F_AUTO_ALT_REF}, INT_MIN, INT_MAX, VE, "flags"}, \

1045 {"arnr_max_frames", "altref noise reduction max frame count", offsetof(VP8Context, arnr_max_frames), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 15, VE}, \

1046 {"arnr_strength", "altref noise reduction filter strength", offsetof(VP8Context, arnr_strength), AV_OPT_TYPE_INT, {.i64 = 3}, 0, 6, VE}, \

1047 {"arnr_type", "altref noise reduction filter type", offsetof(VP8Context, arnr_type), AV_OPT_TYPE_INT, {.i64 = 3}, 1, 3, VE}, \

1048 {"rc_lookahead", "Number of frames to look ahead for alternate reference frame selection", offsetof(VP8Context, lag_in_frames), AV_OPT_TYPE_INT, {.i64 = 25}, 0, 25, VE}, \

1049

1050 #if CONFIG_LIBVPX_VP8_ENCODER

1051 static const AVOption vp8_options[] = {

1052 COMMON_OPTIONS

1053 { "cpu-used", "Quality/Speed ratio modifier", OFFSET(cpu_used), AV_OPT_TYPE_INT, {.i64 = 1}, -16, 16, VE},

1054 LEGACY_OPTIONS

1055 { NULL }

1056 };

1057 #endif

1058

1059 #if CONFIG_LIBVPX_VP9_ENCODER

1060 static const AVOption vp9_options[] = {

1061 COMMON_OPTIONS

1062 { "cpu-used", "Quality/Speed ratio modifier", OFFSET(cpu_used), AV_OPT_TYPE_INT, {.i64 = 1}, -8, 8, VE},

1063 { "lossless", "Lossless mode", OFFSET(lossless), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1, VE},

1064 { "tile-columns", "Number of tile columns to use, log2", OFFSET(tile_columns), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6, VE},

1065 { "tile-rows", "Number of tile rows to use, log2", OFFSET(tile_rows), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 2, VE},

1066 { "frame-parallel", "Enable frame parallel decodability features", OFFSET(frame_parallel), AV_OPT_TYPE_BOOL,{.i64 = -1}, -1, 1, VE},

1067 { "aq-mode", "adaptive quantization mode", OFFSET(aq_mode), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 3, VE, "aq_mode"},

1068 { "none", "Aq not used", 0, AV_OPT_TYPE_CONST, {.i64 = 0}, 0, 0, VE, "aq_mode" },

1069 { "variance", "Variance based Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0, VE, "aq_mode" },

1070 { "complexity", "Complexity based Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0, VE, "aq_mode" },

1071 { "cyclic", "Cyclic Refresh Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 3}, 0, 0, VE, "aq_mode" },

1072 LEGACY_OPTIONS

1073 { NULL }

1074 };

1075 #endif

1076

1077 #undef COMMON_OPTIONS

1078 #undef LEGACY_OPTIONS

1079

1080 static const AVCodecDefault defaults[] = {

1081 { "qmin", "-1" },

1082 { "qmax", "-1" },

1083 { "g", "-1" },

1084 { "keyint_min", "-1" },

1085 { NULL },

1086 };

1087

1088 #if CONFIG_LIBVPX_VP8_ENCODER

1089 static av_cold int vp8_init(AVCodecContext *avctx)

1090 {

1091 return vpx_init(avctx, vpx_codec_vp8_cx());

1092 }

1093

1094 static const AVClass class_vp8 = {

1095 .class_name = "libvpx-vp8 encoder",

1096 .item_name = av_default_item_name,

1097 .option = vp8_options,

1098 .version = LIBAVUTIL_VERSION_INT,

1099 };

1100

1101 AVCodec ff_libvpx_vp8_encoder = {

1102 .name = "libvpx",

1103 .long_name = NULL_IF_CONFIG_SMALL("libvpx VP8"),

1104 .type = AVMEDIA_TYPE_VIDEO,

1105 .id = AV_CODEC_ID_VP8,

1106 .priv_data_size = sizeof(VP8Context),

1107 .init = vp8_init,

1108 .encode2 = vp8_encode,

1109 .close = vp8_free,

1110 .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS,

1111 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_NONE },

1112 .priv_class = &class_vp8,

1113 .defaults = defaults,

1114 };

1115 #endif /* CONFIG_LIBVPX_VP8_ENCODER */

1116

1117 #if CONFIG_LIBVPX_VP9_ENCODER

1118 static av_cold int vp9_init(AVCodecContext *avctx)

1119 {

1120 return vpx_init(avctx, vpx_codec_vp9_cx());

1121 }

1122

1123 static const AVClass class_vp9 = {

1124 .class_name = "libvpx-vp9 encoder",

1125 .item_name = av_default_item_name,

1126 .option = vp9_options,

1127 .version = LIBAVUTIL_VERSION_INT,

1128 };

1129

1130 AVCodec ff_libvpx_vp9_encoder = {

1131 .name = "libvpx-vp9",

1132 .long_name = NULL_IF_CONFIG_SMALL("libvpx VP9"),

1133 .type = AVMEDIA_TYPE_VIDEO,

1134 .id = AV_CODEC_ID_VP9,

1135 .priv_data_size = sizeof(VP8Context),

1136 .init = vp9_init,

1137 .encode2 = vp8_encode,

1138 .close = vp8_free,

1139 .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS,

1140 .profiles = NULL_IF_CONFIG_SMALL(ff_vp9_profiles),

1141 .priv_class = &class_vp9,

1142 .defaults = defaults,

1143 .init_static_data = ff_vp9_init_static,

1144 };

1145 #endif /* CONFIG_LIBVPX_VP9_ENCODER */

FrameListData::sse

uint64_t sse[4]

Definition: libvpxenc.c:57

AVCOL_SPC_BT709

also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B

Definition: pixfmt.h:422

VP8Context::cpu_used

int cpu_used

Definition: libvpxenc.c:77

VP8Context::rawimg_alpha

struct vpx_image rawimg_alpha

Definition: libvpxenc.c:68

NULL

#define NULL

Definition: coverity.c:32

AV_CODEC_ID_VP9

Definition: avcodec.h:275

val

const char const char void * val

Definition: avisynth_c.h:634

AV_PIX_FMT_YUV440P10LE

planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian

Definition: pixfmt.h:283

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:59

VP8Context::lag_in_frames

int lag_in_frames

Definition: libvpxenc.c:93

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:181

AV_PIX_FMT_NONE

Definition: pixfmt.h:62

AVOption

AVOption.

Definition: opt.h:245

ff_side_data_set_encoder_stats

int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)

Definition: avpacket.c:618

AV_PIX_FMT_YUV420P10LE

planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian

Definition: pixfmt.h:171

AVCOL_SPC_UNSPECIFIED

Definition: pixfmt.h:423

VP8Context::encoder

struct vpx_codec_ctx encoder

Definition: libvpxenc.c:65

AVCodecContext::error

uint64_t error[AV_NUM_DATA_POINTERS]

error

Definition: avcodec.h:2862

ctx

AVFormatContext * ctx

Definition: movenc-test.c:48

av_rescale_rnd

int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)

Rescale a 64-bit integer with specified rounding.

Definition: mathematics.c:58

OFFSET

#define OFFSET(x)

Definition: libvpxenc.c:999

AV_PIX_FMT_YUV444P

planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)

Definition: pixfmt.h:68

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:182

AVCodecContext::bit_rate

int64_t bit_rate

the average bitrate

Definition: avcodec.h:1597

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:70

init

static av_cold int init(AVCodecContext *avctx)

Definition: avrndec.c:35

AV_OPT_TYPE_INT

Definition: opt.h:223

AVCPBProperties::max_bitrate

int max_bitrate

Maximum bitrate of the stream, in bits per second.

Definition: avcodec.h:1203

AVCOL_SPC_BT470BG

also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601 ...

Definition: pixfmt.h:426

AVCodecContext::rc_initial_buffer_occupancy

int rc_initial_buffer_occupancy

Number of bits which should be loaded into the rc buffer before decoding starts.

Definition: avcodec.h:2562

VP8Context::tile_columns

int tile_columns

Definition: libvpxenc.c:103

VP8Context::crf

int crf

Definition: libvpxenc.c:95

AVCodecContext::color_range

enum AVColorRange color_range

MPEG vs JPEG YUV range.

Definition: avcodec.h:2262

AVRational::num

int num

numerator

Definition: rational.h:44

AVPacket::size

int size

Definition: avcodec.h:1468

av_log2

int av_log2(unsigned v)

Definition: intmath.c:26

AVCOL_SPC_SMPTE170M

also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above ...

Definition: pixfmt.h:427

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:1752

FrameListData::sz

size_t sz

length of compressed data

Definition: libvpxenc.c:49

sse

static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride)

Definition: mpegvideo_enc.c:2723

AVCodecContext::stats_in

char * stats_in

pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...

Definition: avcodec.h:2700

VP8Context::arnr_max_frames

int arnr_max_frames

Definition: libvpxenc.c:87

pkt

static AVPacket pkt

Definition: demuxing_decoding.c:54

AV_CODEC_CAP_AUTO_THREADS

#define AV_CODEC_CAP_AUTO_THREADS

Codec supports avctx->thread_count == 0 (auto).

Definition: avcodec.h:931

VP8Context::encoder_alpha

struct vpx_codec_ctx encoder_alpha

Definition: libvpxenc.c:67

AVCodecContext::profile

int profile

profile

Definition: avcodec.h:3028

VP8Context::max_intra_rate

int max_intra_rate

Definition: libvpxenc.c:97

AVCodec

AVCodec.

Definition: avcodec.h:3392

AVCOL_SPC_RGB

order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)

Definition: pixfmt.h:421

AVCPBProperties::min_bitrate

int min_bitrate

Minimum bitrate of the stream, in bits per second.

Definition: avcodec.h:1208

AVCOL_SPC_SMPTE240M

Definition: pixfmt.h:428

libvpx.h

VP8Context::error_resilient

int error_resilient

Definition: libvpxenc.c:94

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

VP8F_AUTO_ALT_REF

#define VP8F_AUTO_ALT_REF

Enable automatic alternate reference frame generation.

Definition: libvpxenc.c:83

mathematics.h

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

AV_WB64

#define AV_WB64(p, v)

Definition: intreadwrite.h:433

AV_CODEC_CAP_DELAY

#define AV_CODEC_CAP_DELAY

Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...

Definition: avcodec.h:881

VP8Context::auto_alt_ref

int auto_alt_ref

Definition: libvpxenc.c:85

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

AV_OPT_TYPE_CONST

Definition: opt.h:231

AV_PIX_FMT_YUVA420P

planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)

Definition: pixfmt.h:103

AVCodecContext::rc_buffer_aggressivity

attribute_deprecated float rc_buffer_aggressivity

Definition: avcodec.h:2537

uint8_t

Definition: audio_convert.c:194

av_cold

#define av_cold

Definition: attributes.h:82

codecctl_int

static av_cold int codecctl_int(AVCodecContext *avctx, enum vp8e_enc_control_id id, int val)

Definition: libvpxenc.c:241

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

VP8Context::lossless

int lossless

Definition: libvpxenc.c:102

FrameListData::pts

int64_t pts

time stamp to show frame (in timebase units)

Definition: libvpxenc.c:52

opt.h

AVOptions.

AVCOL_SPC_RESERVED

Definition: pixfmt.h:424

coded_frame_add

static void coded_frame_add(void *list, struct FrameListData *cx_frame)

Definition: libvpxenc.c:212

AV_PIX_FMT_YUV444P12LE

planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian

Definition: pixfmt.h:259

AVFrame::pts

int64_t pts

Presentation timestamp in time_base units (time when frame should be shown to user).

Definition: frame.h:262

frame

static AVFrame * frame

Definition: demuxing_decoding.c:53

AVPacket::data

uint8_t * data

Definition: avcodec.h:1467

VP8Context::frame_parallel

int frame_parallel

Definition: libvpxenc.c:105

AV_LOG_VERBOSE

#define AV_LOG_VERBOSE

Detailed information.

Definition: log.h:192

AVCPBProperties::buffer_size

int buffer_size

The size of the buffer to which the ratecontrol is applied, in bits.

Definition: avcodec.h:1219

size

ptrdiff_t size

Definition: opengl_enc.c:101

AVCodecContext::stats_out

char * stats_out

pass1 encoding statistics output buffer

Definition: avcodec.h:2692

AVFrame::error

attribute_deprecated uint64_t error[AV_NUM_DATA_POINTERS]

Definition: frame.h:300

AVCodecContext::frame_skip_threshold

attribute_deprecated int frame_skip_threshold

Definition: avcodec.h:2602

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

LEGACY_OPTIONS

#define LEGACY_OPTIONS

Definition: libvpxenc.c:1039

AV_PKT_FLAG_KEY

#define AV_PKT_FLAG_KEY

The packet contains a keyframe.

Definition: avcodec.h:1499

VP8Context::tune

int tune

Definition: libvpxenc.c:91

AV_PIX_FMT_YUV444P10LE

planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian

Definition: pixfmt.h:177

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

VP8Context::rawimg

struct vpx_image rawimg

Definition: libvpxenc.c:66

storeframe

static int storeframe(AVCodecContext *avctx, struct FrameListData *cx_frame, AVPacket *pkt)

Store coded frame information in format suitable for return from encode2().

Definition: libvpxenc.c:737

av_default_item_name

Definition: libopenh264enc.c:68

AVERROR

#define AVERROR(e)

Definition: error.h:43

AVCodecDefault

Definition: internal.h:165

COMMON_OPTIONS

#define COMMON_OPTIONS

Definition: libvpxenc.c:1007

AVCodecContext::qmax

int qmax

maximum quantizer

Definition: avcodec.h:2473

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...

Definition: internal.h:176

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:197

AV_PIX_FMT_YUV422P10LE

planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian

Definition: pixfmt.h:173

AVCodecContext::flags

int flags

AV_CODEC_FLAG_*.

Definition: avcodec.h:1627

AV_ROUND_NEAR_INF

Round to nearest and halfway cases away from zero.

Definition: mathematics.h:75

avassert.h

simple assert() macros that are a bit more flexible than ISO C assert().

AVCodec::name

const char * name

Name of the codec implementation.

Definition: avcodec.h:3399

av_base64_encode

char * av_base64_encode(char *out, int out_size, const uint8_t *in, int in_size)

Encode data to base64 and null-terminate.

Definition: base64.c:138

AVPacket::flags

int flags

A combination of AV_PKT_FLAG values.

Definition: avcodec.h:1473

AV_PIX_FMT_YUV422P

planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)

Definition: pixfmt.h:67

AVCodecContext::rc_buffer_size

int rc_buffer_size

decoder bitstream buffer size

Definition: avcodec.h:2500

AVCodecContext::rc_min_rate

int64_t rc_min_rate

minimum bitrate

Definition: avcodec.h:2530

internal.h

common internal API header

cx_pktcpy

static void cx_pktcpy(struct FrameListData *dst, const struct vpx_codec_cx_pkt *src, const struct vpx_codec_cx_pkt *src_alpha, VP8Context *ctx)

Definition: libvpxenc.c:695

dump_enc_cfg

static av_cold void dump_enc_cfg(AVCodecContext *avctx, const struct vpx_codec_enc_cfg *cfg)

Definition: libvpxenc.c:150

AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:266

AVFrame::pict_type

enum AVPictureType pict_type

Picture type of the frame.

Definition: frame.h:252

profiles.h

AV_BASE64_SIZE

#define AV_BASE64_SIZE(x)

Calculate the output size needed to base64-encode x bytes to a null-terminated string.

Definition: base64.h:61

intreadwrite.h

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:1711

FF_PROFILE_UNKNOWN

#define FF_PROFILE_UNKNOWN

Definition: avcodec.h:3029

AVCOL_SPC_BT2020_NCL

ITU-R BT2020 non-constant luminance system.

Definition: pixfmt.h:430

AVCodecContext::noise_reduction

attribute_deprecated int noise_reduction

Definition: avcodec.h:2112

VP8Context::static_thresh

int static_thresh

Definition: libvpxenc.c:96

AV_CODEC_FLAG_PSNR

#define AV_CODEC_FLAG_PSNR

error[?] variables will be set during encoding.

Definition: avcodec.h:766

AV_OPT_TYPE_BOOL

Definition: opt.h:239

AV_CODEC_FLAG_PASS1

#define AV_CODEC_FLAG_PASS1

Use internal 2pass ratecontrol in first pass mode.

Definition: avcodec.h:750

VP8Context::sse

uint64_t sse[4]

Definition: libvpxenc.c:72

vp8_free

static av_cold int vp8_free(AVCodecContext *avctx)

Definition: libvpxenc.c:262

AVCodecContext::ticks_per_frame

int ticks_per_frame

For some codecs, the time base is closer to the field rate than the frame rate.

Definition: avcodec.h:1670

AV_PIX_FMT_YUV420P12LE

planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian

Definition: pixfmt.h:251

log_encoder_error

static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)

Definition: libvpxenc.c:139

AVCodecContext::mb_threshold

attribute_deprecated int mb_threshold

Definition: avcodec.h:2126

AV_CODEC_ID_VP8

Definition: avcodec.h:247

VP8Context::arnr_strength

int arnr_strength

Definition: libvpxenc.c:88

src

#define src

Definition: vp9dsp.c:530

AVCodecContext::height

int height

Definition: avcodec.h:1711

AVCodecContext::thread_count

int thread_count

thread count is used to decide how many independent tasks should be passed to execute() ...

Definition: avcodec.h:2954

FrameListData::next

struct FrameListData * next

Definition: libvpxenc.c:60

AVCOL_RANGE_JPEG

the normal 2^n-1 "JPEG" YUV ranges

Definition: pixfmt.h:443

VP8F_ERROR_RESILIENT

#define VP8F_ERROR_RESILIENT

Enable measures appropriate for streaming over lossy links.

Definition: libvpxenc.c:82

vpx_init

static av_cold int vpx_init(AVCodecContext *avctx, const struct vpx_codec_iface *iface)

Definition: libvpxenc.c:399

VP8Context::flags

int flags

VP8 specific flags, see VP8F_* below.

Definition: libvpxenc.c:81

AVCPBProperties

This structure describes the bitrate properties of an encoded bitstream.

Definition: avcodec.h:1198

defaults

static const AVCodecDefault defaults[]

Definition: libvpxenc.c:1080

AV_LOG_INFO

#define AV_LOG_INFO

Standard information.

Definition: log.h:187

#define VE

Definition: libvpxenc.c:1000

avcodec.h

Libavcodec external API header.

AVCodecContext::codec_id

enum AVCodecID codec_id

Definition: avcodec.h:1549

ff_vp9_init_static

av_cold void ff_vp9_init_static(AVCodec *codec)

Definition: libvpx.c:61

AVFrame::linesize

int linesize[AV_NUM_DATA_POINTERS]

For video, size in bytes of each picture line.

Definition: frame.h:209

vp9_init

static av_cold int vp9_init(AVFormatContext *ctx, int st_index, PayloadContext *data)

Definition: rtpdec_vp9.c:34

AVCodecContext

main external API structure.

Definition: avcodec.h:1532

queue_frames

static int queue_frames(AVCodecContext *avctx, AVPacket *pkt_out)

Queue multiple output frames from the encoder, returning the front-most.

Definition: libvpxenc.c:815

av_packet_unref

void av_packet_unref(AVPacket *pkt)

Wipe the packet.

Definition: avpacket.c:545

AVCodecContext::qmin

int qmin

minimum quantizer

Definition: avcodec.h:2466

AV_PIX_FMT_YUV440P12LE

planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian

Definition: pixfmt.h:285

buf

void * buf

Definition: avisynth_c.h:553

AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL

Data found in BlockAdditional element of matroska container.

Definition: avcodec.h:1387

VP8Context::deadline

int deadline

Definition: libvpxenc.c:71

base64.h

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:67

AVCodecContext::colorspace

enum AVColorSpace colorspace

YUV colorspace type.

Definition: avcodec.h:2255

VP8Context::arnr_type

int arnr_type

Definition: libvpxenc.c:89

FrameListData::flags

uint32_t flags

flags for this frame

Definition: libvpxenc.c:56

snprintf

#define snprintf

Definition: snprintf.h:34

ff_alloc_packet2

int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)

Check AVPacket size and/or allocate data.

Definition: utils.c:1621

free_coded_frame

static av_cold void free_coded_frame(struct FrameListData *cx_frame)

Definition: libvpxenc.c:222

FrameListData::frame_number

uint64_t frame_number

Definition: libvpxenc.c:59

AVCodecContext::qcompress

float qcompress

amount of qscale change between easy & hard scenes (0.0-1.0)

Definition: avcodec.h:2458

set_pix_fmt

static int set_pix_fmt(AVCodecContext *avctx, struct vpx_image *img)

Definition: libvpxdec.c:64

vp8_encode

static int vp8_encode(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)

Definition: libvpxenc.c:917

pix_fmts

static enum AVPixelFormat pix_fmts[]

Definition: libkvazaar.c:262

FrameListData::buf

void * buf

compressed data buffer

Definition: libvpxenc.c:48

VP8Context::rc_undershoot_pct

int rc_undershoot_pct

Definition: libvpxenc.c:98

FrameListData::sz_alpha

size_t sz_alpha

Definition: libvpxenc.c:51

FrameListData::have_sse

int have_sse

true if we have pending sse[]

Definition: libvpxenc.c:58

SIZE_SPECIFIER

#define SIZE_SPECIFIER

Definition: internal.h:251

flags

static int flags

Definition: cpu.c:47

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:192

level

uint8_t level

Definition: svq3.c:150

VP8Context::is_alpha

uint8_t is_alpha

Definition: libvpxenc.c:69

AVCOL_RANGE_MPEG

the normal 219*2^(n-8) "MPEG" YUV ranges

Definition: pixfmt.h:442

AVCodecContext::gop_size

int gop_size

the number of pictures in a group of pictures, or 0 for intra_only

Definition: avcodec.h:1737

ctlidstr

static const char *const ctlidstr[]

String mappings for enum vp8e_enc_control_id.

Definition: libvpxenc.c:112

VP8Context::twopass_stats

struct vpx_fixed_buf twopass_stats

Definition: libvpxenc.c:70

vp8_init

static av_cold int vp8_init(AVFormatContext *s, int st_index, PayloadContext *vp8)

Definition: rtpdec_vp8.c:263

profiles

static const AVProfile profiles[]

Definition: libfaac.c:216

AV_PIX_FMT_YUV420P

planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)

Definition: pixfmt.h:63

AV_PIX_FMT_YUV422P12LE

planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian

Definition: pixfmt.h:255

FF_DISABLE_DEPRECATION_WARNINGS

#define FF_DISABLE_DEPRECATION_WARNINGS

Definition: internal.h:80

internal.h

common internal api header.

VP8Context::noise_sensitivity

int noise_sensitivity

Definition: libvpxenc.c:108

VP8Context::rc_overshoot_pct

int rc_overshoot_pct

Definition: libvpxenc.c:99

common.h

common internal and external API header

av_reallocp

int av_reallocp(void *ptr, size_t size)

Allocate or reallocate a block of memory.

Definition: mem.c:187

AVCodecContext::coded_frame

attribute_deprecated AVFrame * coded_frame

the picture in the bitstream

Definition: avcodec.h:2945

AVRational::den

int den

denominator

Definition: rational.h:45

ff_add_cpb_side_data

AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)

Add a CPB properties side data to an encoding context.

Definition: utils.c:3533

free_frame_list

static av_cold void free_frame_list(struct FrameListData *list)

Definition: libvpxenc.c:230

AV_CODEC_FLAG_PASS2

#define AV_CODEC_FLAG_PASS2

Use internal 2pass ratecontrol in second pass mode.

Definition: avcodec.h:754

FrameListData::buf_alpha

void * buf_alpha

Definition: libvpxenc.c:50

AVCodecContext::slices

int slices

Number of slices.

Definition: avcodec.h:2278

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:1574

av_free

#define av_free(p)

Definition: tableprint_vlc.h:34

VP8Context::drop_threshold

int drop_threshold

Definition: libvpxenc.c:107

FF_ENABLE_DEPRECATION_WARNINGS

#define FF_ENABLE_DEPRECATION_WARNINGS

Definition: internal.h:81

FrameListData

Portion of struct vpx_codec_cx_pkt from vpx_encoder.h.

Definition: libvpxenc.c:47

AVCPBProperties::avg_bitrate

int avg_bitrate

Average bitrate of the stream, in bits per second.

Definition: avcodec.h:1213

VP8Context::tile_rows

int tile_rows

Definition: libvpxenc.c:104

AVFrame::key_frame

int key_frame

1 -> keyframe, 0-> not

Definition: frame.h:247

FrameListData::duration

unsigned long duration

duration to show frame (in timebase units)

Definition: libvpxenc.c:54

av_base64_decode

int av_base64_decode(uint8_t *out, const char *in_str, int out_size)

Decode a base64-encoded string.

Definition: base64.c:79

lrint

#define lrint

Definition: tablegen.h:53

VP8Context

Definition: libvpxdec.c:37

VP8Context::have_sse

int have_sse

true if we have pending sse[]

Definition: libvpxenc.c:73

AVPacket::dts

int64_t dts

Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...

Definition: avcodec.h:1466

AVFrame::height

int height

Definition: frame.h:230

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

AV_PIX_FMT_YUV440P

planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)

Definition: pixfmt.h:101

AVMEDIA_TYPE_VIDEO

Definition: avutil.h:193

av_packet_new_side_data

uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)

Allocate new information of a packet.

Definition: avpacket.c:299

ff_vp9_profiles

const AVProfile ff_vp9_profiles[]

Definition: profiles.c:124

AVPixelFormat

Pixel format.

Definition: pixfmt.h:61

AVPacket

This structure stores compressed data.

Definition: avcodec.h:1444

VP8Context::coded_frame_list

struct FrameListData * coded_frame_list

Definition: libvpxenc.c:75

VP8Context::aq_mode

int aq_mode

Definition: libvpxenc.c:106

VP8Context::frame_number

uint64_t frame_number

Definition: libvpxenc.c:74

AVPacket::pts

int64_t pts

Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...

Definition: avcodec.h:1460

AV_PICTURE_TYPE_P

Predicted.

Definition: avutil.h:267

AVCodecContext::rc_max_rate

int64_t rc_max_rate

maximum bitrate

Definition: avcodec.h:2523

AVCodecContext::keyint_min

int keyint_min

minimum GOP size

Definition: avcodec.h:2198

AVCOL_RANGE_UNSPECIFIED

Definition: pixfmt.h:441

width

static int width

Definition: demuxing_decoding.c:39

Generated on Mon Feb 15 2016 15:20:39 for FFmpeg by doxygen 1.8.6