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> 65 typedef struct VPxEncoderContext {
67 struct vpx_codec_ctx encoder;
68 struct vpx_image rawimg;
69 struct vpx_codec_ctx encoder_alpha;
70 struct vpx_image rawimg_alpha;
72 struct vpx_fixed_buf twopass_stats;
85 #define VP8F_ERROR_RESILIENT 0x00000001 86 #define VP8F_AUTO_ALT_REF 0x00000002
131 [VP8E_SET_CPUUSED] =
"VP8E_SET_CPUUSED",
132 [VP8E_SET_ENABLEAUTOALTREF] =
"VP8E_SET_ENABLEAUTOALTREF",
133 [VP8E_SET_NOISE_SENSITIVITY] =
"VP8E_SET_NOISE_SENSITIVITY",
134 [VP8E_SET_STATIC_THRESHOLD] =
"VP8E_SET_STATIC_THRESHOLD",
135 [VP8E_SET_TOKEN_PARTITIONS] =
"VP8E_SET_TOKEN_PARTITIONS",
136 [VP8E_SET_ARNR_MAXFRAMES] =
"VP8E_SET_ARNR_MAXFRAMES",
137 [VP8E_SET_ARNR_STRENGTH] =
"VP8E_SET_ARNR_STRENGTH",
138 [VP8E_SET_ARNR_TYPE] =
"VP8E_SET_ARNR_TYPE",
139 [VP8E_SET_TUNING] =
"VP8E_SET_TUNING",
140 [VP8E_SET_CQ_LEVEL] =
"VP8E_SET_CQ_LEVEL",
141 [VP8E_SET_MAX_INTRA_BITRATE_PCT] =
"VP8E_SET_MAX_INTRA_BITRATE_PCT",
142 [VP8E_SET_SHARPNESS] =
"VP8E_SET_SHARPNESS",
143 [VP8E_SET_TEMPORAL_LAYER_ID] =
"VP8E_SET_TEMPORAL_LAYER_ID",
144 #if CONFIG_LIBVPX_VP9_ENCODER 145 [VP9E_SET_LOSSLESS] =
"VP9E_SET_LOSSLESS",
146 [VP9E_SET_TILE_COLUMNS] =
"VP9E_SET_TILE_COLUMNS",
147 [VP9E_SET_TILE_ROWS] =
"VP9E_SET_TILE_ROWS",
148 [VP9E_SET_FRAME_PARALLEL_DECODING] =
"VP9E_SET_FRAME_PARALLEL_DECODING",
149 [VP9E_SET_AQ_MODE] =
"VP9E_SET_AQ_MODE",
150 [VP9E_SET_COLOR_SPACE] =
"VP9E_SET_COLOR_SPACE",
151 [VP9E_SET_SVC_LAYER_ID] =
"VP9E_SET_SVC_LAYER_ID",
152 #if VPX_ENCODER_ABI_VERSION >= 12 153 [VP9E_SET_SVC_PARAMETERS] =
"VP9E_SET_SVC_PARAMETERS",
155 [VP9E_SET_SVC] =
"VP9E_SET_SVC",
156 #if VPX_ENCODER_ABI_VERSION >= 11 157 [VP9E_SET_COLOR_RANGE] =
"VP9E_SET_COLOR_RANGE",
159 #if VPX_ENCODER_ABI_VERSION >= 12 160 [VP9E_SET_TARGET_LEVEL] =
"VP9E_SET_TARGET_LEVEL",
161 [VP9E_GET_LEVEL] =
"VP9E_GET_LEVEL",
163 #ifdef VPX_CTRL_VP9E_SET_ROW_MT 164 [VP9E_SET_ROW_MT] =
"VP9E_SET_ROW_MT",
166 #ifdef VPX_CTRL_VP9E_SET_TUNE_CONTENT 167 [VP9E_SET_TUNE_CONTENT] =
"VP9E_SET_TUNE_CONTENT",
169 #ifdef VPX_CTRL_VP9E_SET_TPL 170 [VP9E_SET_TPL] =
"VP9E_SET_TPL",
179 const char *detail = vpx_codec_error_detail(&ctx->
encoder);
187 const struct vpx_codec_enc_cfg *cfg)
193 av_log(avctx, level,
"vpx_codec_enc_cfg\n");
194 av_log(avctx, level,
"generic settings\n" 195 " %*s%u\n %*s%u\n %*s%u\n %*s%u\n %*s%u\n" 199 " %*s{%u/%u}\n %*s%u\n %*s%d\n %*s%u\n",
200 width,
"g_usage:", cfg->g_usage,
201 width,
"g_threads:", cfg->g_threads,
202 width,
"g_profile:", cfg->g_profile,
203 width,
"g_w:", cfg->g_w,
204 width,
"g_h:", cfg->g_h,
206 width,
"g_bit_depth:", cfg->g_bit_depth,
207 width,
"g_input_bit_depth:", cfg->g_input_bit_depth,
209 width,
"g_timebase:", cfg->g_timebase.num, cfg->g_timebase.den,
210 width,
"g_error_resilient:", cfg->g_error_resilient,
211 width,
"g_pass:", cfg->g_pass,
212 width,
"g_lag_in_frames:", cfg->g_lag_in_frames);
213 av_log(avctx, level,
"rate control settings\n" 214 " %*s%u\n %*s%u\n %*s%u\n %*s%u\n" 216 width,
"rc_dropframe_thresh:", cfg->rc_dropframe_thresh,
217 width,
"rc_resize_allowed:", cfg->rc_resize_allowed,
218 width,
"rc_resize_up_thresh:", cfg->rc_resize_up_thresh,
219 width,
"rc_resize_down_thresh:", cfg->rc_resize_down_thresh,
220 width,
"rc_end_usage:", cfg->rc_end_usage,
221 width,
"rc_twopass_stats_in:", cfg->rc_twopass_stats_in.buf, cfg->rc_twopass_stats_in.sz,
222 width,
"rc_target_bitrate:", cfg->rc_target_bitrate);
223 av_log(avctx, level,
"quantizer settings\n" 225 width,
"rc_min_quantizer:", cfg->rc_min_quantizer,
226 width,
"rc_max_quantizer:", cfg->rc_max_quantizer);
227 av_log(avctx, level,
"bitrate tolerance\n" 229 width,
"rc_undershoot_pct:", cfg->rc_undershoot_pct,
230 width,
"rc_overshoot_pct:", cfg->rc_overshoot_pct);
231 av_log(avctx, level,
"temporal layering settings\n" 232 " %*s%u\n", width,
"ts_number_layers:", cfg->ts_number_layers);
235 "\n %*s", width,
"ts_target_bitrate:");
236 for (i = 0; i < VPX_TS_MAX_LAYERS; i++)
238 "%u ", cfg->ts_target_bitrate[i]);
240 #if (VPX_ENCODER_ABI_VERSION >= 12) && CONFIG_LIBVPX_VP9_ENCODER 243 "\n %*s", width,
"layer_target_bitrate:");
244 for (i = 0; i < VPX_TS_MAX_LAYERS; i++)
246 "%u ", cfg->layer_target_bitrate[i]);
249 av_log(avctx, level,
"\n");
251 "\n %*s", width,
"ts_rate_decimator:");
252 for (i = 0; i < VPX_TS_MAX_LAYERS; i++)
253 av_log(avctx, level,
"%u ", cfg->ts_rate_decimator[i]);
254 av_log(avctx, level,
"\n");
256 "\n %*s%u\n", width,
"ts_periodicity:", cfg->ts_periodicity);
258 "\n %*s", width,
"ts_layer_id:");
259 for (i = 0; i < VPX_TS_MAX_PERIODICITY; i++)
260 av_log(avctx, level,
"%u ", cfg->ts_layer_id[i]);
261 av_log(avctx, level,
"\n");
262 av_log(avctx, level,
"decoder buffer model\n" 263 " %*s%u\n %*s%u\n %*s%u\n",
264 width,
"rc_buf_sz:", cfg->rc_buf_sz,
265 width,
"rc_buf_initial_sz:", cfg->rc_buf_initial_sz,
266 width,
"rc_buf_optimal_sz:", cfg->rc_buf_optimal_sz);
267 av_log(avctx, level,
"2 pass rate control settings\n" 268 " %*s%u\n %*s%u\n %*s%u\n",
269 width,
"rc_2pass_vbr_bias_pct:", cfg->rc_2pass_vbr_bias_pct,
270 width,
"rc_2pass_vbr_minsection_pct:", cfg->rc_2pass_vbr_minsection_pct,
271 width,
"rc_2pass_vbr_maxsection_pct:", cfg->rc_2pass_vbr_maxsection_pct);
272 #if VPX_ENCODER_ABI_VERSION >= 14 273 av_log(avctx, level,
" %*s%u\n",
274 width,
"rc_2pass_vbr_corpus_complexity:", cfg->rc_2pass_vbr_corpus_complexity);
276 av_log(avctx, level,
"keyframing settings\n" 277 " %*s%d\n %*s%u\n %*s%u\n",
278 width,
"kf_mode:", cfg->kf_mode,
279 width,
"kf_min_dist:", cfg->kf_min_dist,
280 width,
"kf_max_dist:", cfg->kf_max_dist);
281 av_log(avctx, level,
"\n");
314 enum vp8e_enc_control_id
id,
int val)
324 res = vpx_codec_control(&ctx->
encoder,
id, val);
325 if (res != VPX_CODEC_OK) {
326 snprintf(buf,
sizeof(buf),
"Failed to set %s codec control",
331 return res == VPX_CODEC_OK ? 0 :
AVERROR(EINVAL);
334 #if VPX_ENCODER_ABI_VERSION >= 12 336 enum vp8e_enc_control_id
id,
int *
val)
346 res = vpx_codec_control(&ctx->
encoder,
id, val);
347 if (res != VPX_CODEC_OK) {
348 snprintf(buf,
sizeof(buf),
"Failed to set %s codec control",
353 return res == VPX_CODEC_OK ? 0 :
AVERROR(EINVAL);
361 #if VPX_ENCODER_ABI_VERSION >= 12 365 if (!codecctl_intp(avctx, VP9E_GET_LEVEL, &level_out))
372 vpx_codec_destroy(&ctx->
encoder);
387 char *saveptr =
NULL;
388 char *token =
av_strtok(value,
",", &saveptr);
390 while (token && dest_idx < max_entries) {
391 dest[dest_idx++] = strtoul(token,
NULL, 10);
397 int *layer_flags,
int *flag_periodicity)
399 switch (layering_mode) {
404 static const int ids[2] = { 0, 1 };
405 cfg->ts_periodicity = 2;
406 *flag_periodicity = 2;
407 cfg->ts_number_layers = 2;
408 cfg->ts_rate_decimator[0] = 2;
409 cfg->ts_rate_decimator[1] = 1;
410 memcpy(cfg->ts_layer_id, ids,
sizeof(ids));
413 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
414 VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
416 VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_GF |
417 VP8_EFLAG_NO_UPD_LAST |
418 VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_REF_GF;
428 static const int ids[4] = { 0, 2, 1, 2 };
429 cfg->ts_periodicity = 4;
430 *flag_periodicity = 4;
431 cfg->ts_number_layers = 3;
432 cfg->ts_rate_decimator[0] = 4;
433 cfg->ts_rate_decimator[1] = 2;
434 cfg->ts_rate_decimator[2] = 1;
435 memcpy(cfg->ts_layer_id, ids,
sizeof(ids));
442 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
443 VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
445 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
446 VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
447 VP8_EFLAG_NO_UPD_ARF;
449 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
450 VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
452 VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_REF_ARF |
453 VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
454 VP8_EFLAG_NO_UPD_ARF;
463 static const int ids[4] = { 0, 2, 1, 2 };
464 cfg->ts_periodicity = 4;
465 *flag_periodicity = 4;
466 cfg->ts_number_layers = 3;
467 cfg->ts_rate_decimator[0] = 4;
468 cfg->ts_rate_decimator[1] = 2;
469 cfg->ts_rate_decimator[2] = 1;
470 memcpy(cfg->ts_layer_id, ids,
sizeof(ids));
476 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
477 VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
479 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
480 VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF;
482 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
483 VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
485 VP8_EFLAG_NO_REF_LAST |
486 VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
487 VP8_EFLAG_NO_UPD_ARF;
503 size_t value_len = strlen(value);
504 int ts_layering_mode = 0;
509 if (!strcmp(key,
"ts_number_layers"))
510 enccfg->ts_number_layers = strtoul(value, &value, 10);
511 else if (!strcmp(key,
"ts_target_bitrate")) {
514 #if (VPX_ENCODER_ABI_VERSION >= 12) && CONFIG_LIBVPX_VP9_ENCODER 518 }
else if (!strcmp(key,
"ts_rate_decimator")) {
520 }
else if (!strcmp(key,
"ts_periodicity")) {
521 enccfg->ts_periodicity = strtoul(value, &value, 10);
522 }
else if (!strcmp(key,
"ts_layer_id")) {
524 }
else if (!strcmp(key,
"ts_layering_mode")) {
526 ts_layering_mode = strtoul(value, &value, 4);
529 #if (VPX_ENCODER_ABI_VERSION >= 12) && CONFIG_LIBVPX_VP9_ENCODER 530 enccfg->temporal_layering_mode = VP9E_TEMPORAL_LAYERING_MODE_BYPASS;
531 enccfg->ss_number_layers = 1;
533 if (ts_layering_mode) {
543 #if CONFIG_LIBVPX_VP9_ENCODER 545 struct vpx_codec_enc_cfg *enccfg, vpx_codec_flags_t *
flags,
546 vpx_img_fmt_t *img_fmt)
549 enccfg->g_bit_depth = enccfg->g_input_bit_depth = 8;
553 enccfg->g_profile = 0;
554 *img_fmt = VPX_IMG_FMT_I420;
557 enccfg->g_profile = 1;
558 *img_fmt = VPX_IMG_FMT_I422;
561 enccfg->g_profile = 1;
562 *img_fmt = VPX_IMG_FMT_I440;
565 ctx->vpx_cs = VPX_CS_SRGB;
567 enccfg->g_profile = 1;
568 *img_fmt = VPX_IMG_FMT_I444;
572 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {
573 enccfg->g_bit_depth = enccfg->g_input_bit_depth =
575 enccfg->g_profile = 2;
576 *img_fmt = VPX_IMG_FMT_I42016;
577 *
flags |= VPX_CODEC_USE_HIGHBITDEPTH;
583 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {
584 enccfg->g_bit_depth = enccfg->g_input_bit_depth =
586 enccfg->g_profile = 3;
587 *img_fmt = VPX_IMG_FMT_I42216;
588 *
flags |= VPX_CODEC_USE_HIGHBITDEPTH;
594 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {
595 enccfg->g_bit_depth = enccfg->g_input_bit_depth =
597 enccfg->g_profile = 3;
598 *img_fmt = VPX_IMG_FMT_I44016;
599 *
flags |= VPX_CODEC_USE_HIGHBITDEPTH;
605 ctx->vpx_cs = VPX_CS_SRGB;
608 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {
609 enccfg->g_bit_depth = enccfg->g_input_bit_depth =
612 enccfg->g_profile = 3;
613 *img_fmt = VPX_IMG_FMT_I44416;
614 *
flags |= VPX_CODEC_USE_HIGHBITDEPTH;
627 enum vpx_color_space vpx_cs;
651 #if VPX_ENCODER_ABI_VERSION >= 11 654 enum vpx_color_range vpx_cr;
674 struct vpx_codec_enc_cfg *enccfg)
678 avctx->
bit_rate = enccfg->rc_target_bitrate * 1000;
679 if (enccfg->rc_end_usage == VPX_CQ) {
681 "Bitrate not specified for constrained quality mode, using default of %dkbit/sec\n",
682 enccfg->rc_target_bitrate);
684 enccfg->rc_end_usage = VPX_CQ;
687 "Neither bitrate nor constrained quality specified, using default CRF of %d and bitrate of %dkbit/sec\n",
688 ctx->
crf, enccfg->rc_target_bitrate);
693 #if CONFIG_LIBVPX_VP9_ENCODER 699 struct vpx_codec_enc_cfg *enccfg)
703 if (enccfg->rc_end_usage != VPX_Q && ctx->
lossless < 0) {
704 enccfg->rc_end_usage = VPX_Q;
707 "Neither bitrate nor constrained quality specified, using default CRF of %d\n",
718 struct vpx_codec_enc_cfg *enccfg)
721 #if CONFIG_LIBVPX_VP9_ENCODER 723 set_vp9_defaults(avctx, enccfg);
731 const struct vpx_codec_iface *iface)
734 struct vpx_codec_enc_cfg enccfg = { 0 };
735 struct vpx_codec_enc_cfg enccfg_alpha;
739 vpx_img_fmt_t img_fmt = VPX_IMG_FMT_I420;
740 #if CONFIG_LIBVPX_VP9_ENCODER 741 vpx_codec_caps_t codec_caps = vpx_codec_get_caps(iface);
742 vpx_svc_extra_cfg_t svc_params;
752 if ((res = vpx_codec_enc_config_default(iface, &enccfg, 0)) != VPX_CODEC_OK) {
754 vpx_codec_err_to_string(res));
758 #if CONFIG_LIBVPX_VP9_ENCODER 760 if (
set_pix_fmt(avctx, codec_caps, &enccfg, &flags, &img_fmt))
773 enccfg.g_w = avctx->
width;
774 enccfg.g_h = avctx->
height;
782 enccfg.g_pass = VPX_RC_FIRST_PASS;
784 enccfg.g_pass = VPX_RC_LAST_PASS;
786 enccfg.g_pass = VPX_RC_ONE_PASS;
790 enccfg.rc_end_usage = VPX_CBR;
791 }
else if (ctx->
crf >= 0) {
792 enccfg.rc_end_usage = VPX_CQ;
793 #if CONFIG_LIBVPX_VP9_ENCODER 795 enccfg.rc_end_usage = VPX_Q;
802 #if CONFIG_LIBVPX_VP9_ENCODER 803 enccfg.ss_target_bitrate[0] = enccfg.rc_target_bitrate;
811 enccfg.rc_min_quantizer =
812 enccfg.rc_max_quantizer = 0;
814 if (avctx->
qmin >= 0)
815 enccfg.rc_min_quantizer = avctx->
qmin;
816 if (avctx->
qmax >= 0)
817 enccfg.rc_max_quantizer = avctx->
qmax;
820 if (enccfg.rc_end_usage == VPX_CQ
822 || enccfg.rc_end_usage == VPX_Q
825 if (ctx->
crf < enccfg.rc_min_quantizer || ctx->
crf > enccfg.rc_max_quantizer) {
827 "CQ level %d must be between minimum and maximum quantizer value (%d-%d)\n",
828 ctx->
crf, enccfg.rc_min_quantizer, enccfg.rc_max_quantizer);
833 #if FF_API_PRIVATE_OPT 844 enccfg.rc_2pass_vbr_minsection_pct =
847 enccfg.rc_2pass_vbr_maxsection_pct =
849 #if CONFIG_LIBVPX_VP9_ENCODER 851 #if VPX_ENCODER_ABI_VERSION >= 14 862 enccfg.rc_buf_initial_sz =
864 enccfg.rc_buf_optimal_sz = enccfg.rc_buf_sz * 5 / 6;
874 enccfg.kf_max_dist = avctx->
gop_size;
876 if (enccfg.g_pass == VPX_RC_FIRST_PASS)
877 enccfg.g_lag_in_frames = 0;
878 else if (enccfg.g_pass == VPX_RC_LAST_PASS) {
879 int decode_size, ret;
897 if (decode_size < 0) {
910 enccfg.g_profile = avctx->
profile;
917 "Error parsing option '%s = %s'.\n",
923 res = vpx_codec_enc_init(&ctx->
encoder, iface, &enccfg, flags);
924 if (res != VPX_CODEC_OK) {
928 #if CONFIG_LIBVPX_VP9_ENCODER 930 memset(&svc_params, 0,
sizeof(svc_params));
931 for (
int i = 0;
i < enccfg.ts_number_layers; ++
i) {
932 svc_params.max_quantizers[
i] = enccfg.rc_max_quantizer;
933 svc_params.min_quantizers[
i] = enccfg.rc_min_quantizer;
935 svc_params.scaling_factor_num[0] = enccfg.g_h;
936 svc_params.scaling_factor_den[0] = enccfg.g_h;
937 #if VPX_ENCODER_ABI_VERSION >= 12 939 codecctl_intp(avctx, VP9E_SET_SVC_PARAMETERS, (
int *)&svc_params);
944 enccfg_alpha = enccfg;
945 res = vpx_codec_enc_init(&ctx->
encoder_alpha, iface, &enccfg_alpha, flags);
946 if (res != VPX_CODEC_OK) {
970 av_log(avctx,
AV_LOG_ERROR,
"Transparency encoding with auto_alt_ref does not work\n");
978 #if FF_API_PRIVATE_OPT 993 #if CONFIG_LIBVPX_VP9_ENCODER 1005 set_colorspace(avctx);
1006 #if VPX_ENCODER_ABI_VERSION >= 11 1009 #if VPX_ENCODER_ABI_VERSION >= 12 1012 #ifdef VPX_CTRL_VP9E_SET_ROW_MT 1016 #ifdef VPX_CTRL_VP9E_SET_TUNE_CONTENT 1020 #ifdef VPX_CTRL_VP9E_SET_TPL 1032 #if CONFIG_LIBVPX_VP9_ENCODER 1034 ctx->
rawimg.bit_depth = enccfg.g_bit_depth;
1041 if (enccfg.rc_end_usage == VPX_CBR ||
1042 enccfg.g_pass != VPX_RC_ONE_PASS) {
1053 const struct vpx_codec_cx_pkt *
src,
1054 const struct vpx_codec_cx_pkt *src_alpha,
1057 dst->
pts = src->data.frame.pts;
1058 dst->
duration = src->data.frame.duration;
1059 dst->
flags = src->data.frame.flags;
1060 dst->
sz = src->data.frame.sz;
1061 dst->
buf = src->data.frame.buf;
1064 if (!(dst->
flags & VPX_FRAME_IS_INVISIBLE)) {
1072 memcpy(dst->
sse, ctx->
sse,
sizeof(dst->
sse));
1079 dst->
buf_alpha = src_alpha->data.frame.buf;
1080 dst->
sz_alpha = src_alpha->data.frame.sz;
1103 #if FF_API_CODED_FRAME 1110 if (!!(cx_frame->
flags & VPX_FRAME_IS_KEY)) {
1112 #if FF_API_CODED_FRAME 1120 #if FF_API_CODED_FRAME 1128 cx_frame->
have_sse ? 3 : 0, pict_type);
1133 #if FF_API_CODED_FRAME 1141 for (i = 0; i < 3; ++
i) {
1142 avctx->
error[
i] += cx_frame->
sse[i + 1];
1174 const struct vpx_codec_cx_pkt *
pkt;
1175 const struct vpx_codec_cx_pkt *pkt_alpha =
NULL;
1176 const void *iter =
NULL;
1177 const void *iter_alpha =
NULL;
1192 while ((pkt = vpx_codec_get_cx_data(&ctx->
encoder, &iter)) &&
1194 (pkt_alpha = vpx_codec_get_cx_data(&ctx->
encoder_alpha, &iter_alpha)))) {
1195 switch (pkt->kind) {
1196 case VPX_CODEC_CX_FRAME_PKT:
1203 cx_pktcpy(&cx_frame, pkt, pkt_alpha, ctx);
1204 size =
storeframe(avctx, &cx_frame, pkt_out);
1212 "Frame queue element alloc failed\n");
1215 cx_pktcpy(cx_frame, pkt, pkt_alpha, ctx);
1218 if (!cx_frame->
buf) {
1225 memcpy(cx_frame->
buf, pkt->data.frame.buf, pkt->data.frame.sz);
1235 memcpy(cx_frame->
buf_alpha, pkt_alpha->data.frame.buf, pkt_alpha->data.frame.sz);
1240 case VPX_CODEC_STATS_PKT: {
1245 pkt->data.twopass_stats.sz)) < 0) {
1250 memcpy((
uint8_t*)stats->buf + stats->sz,
1251 pkt->data.twopass_stats.buf, pkt->data.twopass_stats.sz);
1252 stats->sz += pkt->data.twopass_stats.sz;
1255 case VPX_CODEC_PSNR_PKT:
1257 ctx->
sse[0] = pkt->data.psnr.sse[0];
1258 ctx->
sse[1] = pkt->data.psnr.sse[1];
1259 ctx->
sse[2] = pkt->data.psnr.sse[2];
1260 ctx->
sse[3] = pkt->data.psnr.sse[3];
1263 case VPX_CODEC_CUSTOM_PKT:
1273 vpx_roi_map_t *roi_map,
int block_size,
int segment_cnt)
1278 #define MAX_DELTA_Q 63 1293 memset(roi_map, 0,
sizeof(*roi_map));
1304 if (!self_size || sd->
size % self_size) {
1308 nb_rois = sd->
size / self_size;
1314 for (
int i = 0;
i < nb_rois;
i++) {
1328 if (!segment_mapping[mapping_index]) {
1329 if (segment_id == segment_cnt) {
1331 "ROI only supports %d segments (and segment 0 is reserved for non-ROIs), skipping the left ones.\n",
1336 segment_mapping[mapping_index] = segment_id + 1;
1337 roi_map->delta_q[segment_id] =
delta_q;
1342 roi_map->rows = (frame_height + block_size - 1) / block_size;
1343 roi_map->cols = (frame_width + block_size - 1) / block_size;
1344 roi_map->roi_map =
av_mallocz_array(roi_map->rows * roi_map->cols,
sizeof(*roi_map->roi_map));
1345 if (!roi_map->roi_map) {
1353 for (
int i = nb_rois - 1;
i >= 0;
i--) {
1356 int starty, endy, startx, endx;
1360 starty = av_clip(roi->
top / block_size, 0, roi_map->rows);
1361 endy = av_clip((roi->
bottom + block_size - 1) / block_size, 0, roi_map->rows);
1362 startx = av_clip(roi->
left / block_size, 0, roi_map->cols);
1363 endx = av_clip((roi->
right + block_size - 1) / block_size, 0, roi_map->cols);
1368 mapping_value = segment_mapping[delta_q +
MAX_DELTA_Q];
1369 if (mapping_value) {
1370 for (
int y = starty; y < endy; y++)
1371 for (
int x = startx; x < endx; x++)
1372 roi_map->roi_map[x + y * roi_map->cols] = mapping_value - 1;
1383 #ifdef VPX_CTRL_VP9E_SET_ROI_MAP 1384 int version = vpx_codec_version();
1385 int major = VPX_VERSION_MAJOR(version);
1386 int minor = VPX_VERSION_MINOR(version);
1387 int patch = VPX_VERSION_PATCH(version);
1389 if (major > 1 || (major == 1 && minor > 8) || (major == 1 && minor == 8 && patch >= 1)) {
1390 vpx_roi_map_t roi_map;
1391 const int segment_cnt = 8;
1392 const int block_size = 8;
1399 "and deadline is REALTIME, so skipping ROI.\n");
1404 ret =
set_roi_map(avctx, sd, frame_width, frame_height, &roi_map, block_size, segment_cnt);
1410 memset(roi_map.ref_frame, -1,
sizeof(roi_map.ref_frame));
1412 if (vpx_codec_control(&ctx->
encoder, VP9E_SET_ROI_MAP, &roi_map)) {
1423 av_log(avctx,
AV_LOG_WARNING,
"ROI is not supported, please upgrade libvpx to version >= 1.8.1. " 1424 "You may need to rebuild ffmpeg.\n");
1431 vpx_roi_map_t roi_map;
1432 const int segment_cnt = 4;
1433 const int block_size = 16;
1436 int ret =
set_roi_map(avctx, sd, frame_width, frame_height, &roi_map, block_size, segment_cnt);
1442 if (vpx_codec_control(&ctx->
encoder, VP8E_SET_ROI_MAP, &roi_map)) {
1455 unsigned char **
planes = rawimg_alpha->planes;
1456 int *
stride = rawimg_alpha->stride;
1458 if (!planes[VPX_PLANE_U] ||
1459 !planes[VPX_PLANE_V] ||
1460 width != (
int)rawimg_alpha->d_w ||
1461 height != (
int)rawimg_alpha->d_h) {
1465 vpx_img_wrap(rawimg_alpha, VPX_IMG_FMT_I420, width, height, 1,
1469 if (!planes[VPX_PLANE_U] || !planes[VPX_PLANE_V])
1472 memset(planes[VPX_PLANE_U], 0x80, stride[VPX_PLANE_U] * height);
1473 memset(planes[VPX_PLANE_V], 0x80, stride[VPX_PLANE_V] * height);
1483 struct vpx_image *rawimg =
NULL;
1484 struct vpx_image *rawimg_alpha =
NULL;
1486 int res, coded_size;
1487 vpx_enc_frame_flags_t
flags = 0;
1488 const struct vpx_codec_enc_cfg *enccfg = ctx->
encoder.config.enc;
1489 vpx_svc_layer_id_t layer_id;
1490 int layer_id_valid = 0;
1495 rawimg->planes[VPX_PLANE_Y] = frame->
data[0];
1496 rawimg->planes[VPX_PLANE_U] = frame->
data[1];
1497 rawimg->planes[VPX_PLANE_V] = frame->
data[2];
1498 rawimg->stride[VPX_PLANE_Y] = frame->
linesize[0];
1499 rawimg->stride[VPX_PLANE_U] = frame->
linesize[1];
1500 rawimg->stride[VPX_PLANE_V] = frame->
linesize[2];
1506 rawimg_alpha->planes[VPX_PLANE_Y] = frame->
data[3];
1507 rawimg_alpha->stride[VPX_PLANE_Y] = frame->
linesize[3];
1509 timestamp = frame->
pts;
1510 #if VPX_IMAGE_ABI_VERSION >= 4 1513 rawimg->range = VPX_CR_STUDIO_RANGE;
1516 rawimg->range = VPX_CR_FULL_RANGE;
1521 flags |= VPX_EFLAG_FORCE_KF;
1528 memset(&layer_id, 0,
sizeof(layer_id));
1532 layer_id.temporal_layer_id = strtoul(en->
value,
NULL, 10);
1533 #ifdef VPX_CTRL_VP9E_SET_MAX_INTER_BITRATE_PCT 1534 layer_id.temporal_layer_id_per_spatial[0] = layer_id.temporal_layer_id;
1552 if (flags & VPX_EFLAG_FORCE_KF) {
1555 flags = VPX_EFLAG_FORCE_KF;
1563 memset(&layer_id, 0,
sizeof(layer_id));
1564 #if VPX_ENCODER_ABI_VERSION >= 12 1565 layer_id.spatial_layer_id = 0;
1568 #ifdef VPX_CTRL_VP9E_SET_MAX_INTER_BITRATE_PCT 1569 layer_id.temporal_layer_id_per_spatial[0] = layer_id.temporal_layer_id;
1574 if (layer_id_valid) {
1576 codecctl_int(avctx, VP8E_SET_TEMPORAL_LAYER_ID, layer_id.temporal_layer_id);
1578 #if CONFIG_LIBVPX_VP9_ENCODER && VPX_ENCODER_ABI_VERSION >= 12 1580 codecctl_intp(avctx, VP9E_SET_SVC_LAYER_ID, (
int *)&layer_id);
1585 res = vpx_codec_encode(&ctx->
encoder, rawimg, timestamp,
1587 if (res != VPX_CODEC_OK) {
1593 res = vpx_codec_encode(&ctx->
encoder_alpha, rawimg_alpha, timestamp,
1595 if (res != VPX_CODEC_OK) {
1614 }
else if (enccfg->ts_number_layers > 1 && ctx->
ts_layer_flags) {
1618 *got_packet = !!coded_size;
1622 #define OFFSET(x) offsetof(VPxContext, x) 1623 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM 1625 #define COMMON_OPTIONS \ 1626 { "lag-in-frames", "Number of frames to look ahead for " \ 1627 "alternate reference frame selection", OFFSET(lag_in_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \ 1628 { "arnr-maxframes", "altref noise reduction max frame count", OFFSET(arnr_max_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \ 1629 { "arnr-strength", "altref noise reduction filter strength", OFFSET(arnr_strength), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \ 1630 { "arnr-type", "altref noise reduction filter type", OFFSET(arnr_type), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE, "arnr_type"}, \ 1631 { "backward", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0, VE, "arnr_type" }, \ 1632 { "forward", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0, VE, "arnr_type" }, \ 1633 { "centered", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 3}, 0, 0, VE, "arnr_type" }, \ 1634 { "tune", "Tune the encoding to a specific scenario", OFFSET(tune), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE, "tune"}, \ 1635 { "psnr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VP8_TUNE_PSNR}, 0, 0, VE, "tune"}, \ 1636 { "ssim", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VP8_TUNE_SSIM}, 0, 0, VE, "tune"}, \ 1637 { "deadline", "Time to spend encoding, in microseconds.", OFFSET(deadline), AV_OPT_TYPE_INT, {.i64 = VPX_DL_GOOD_QUALITY}, INT_MIN, INT_MAX, VE, "quality"}, \ 1638 { "best", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_BEST_QUALITY}, 0, 0, VE, "quality"}, \ 1639 { "good", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_GOOD_QUALITY}, 0, 0, VE, "quality"}, \ 1640 { "realtime", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_REALTIME}, 0, 0, VE, "quality"}, \ 1641 { "error-resilient", "Error resilience configuration", OFFSET(error_resilient), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, VE, "er"}, \ 1642 { "max-intra-rate", "Maximum I-frame bitrate (pct) 0=unlimited", OFFSET(max_intra_rate), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \ 1643 { "default", "Improve resiliency against losses of whole frames", 0, AV_OPT_TYPE_CONST, {.i64 = VPX_ERROR_RESILIENT_DEFAULT}, 0, 0, VE, "er"}, \ 1644 { "partitions", "The frame partitions are independently decodable " \ 1645 "by the bool decoder, meaning that partitions can be decoded even " \ 1646 "though earlier partitions have been lost. Note that intra prediction" \ 1647 " is still done over the partition boundary.", 0, AV_OPT_TYPE_CONST, {.i64 = VPX_ERROR_RESILIENT_PARTITIONS}, 0, 0, VE, "er"}, \ 1648 { "crf", "Select the quality for constant quality mode", offsetof(VPxContext, crf), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 63, VE }, \ 1649 { "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 }, \ 1650 { "drop-threshold", "Frame drop threshold", offsetof(VPxContext, drop_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, VE }, \ 1651 { "noise-sensitivity", "Noise sensitivity", OFFSET(noise_sensitivity), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 4, VE}, \ 1652 { "undershoot-pct", "Datarate undershoot (min) target (%)", OFFSET(rc_undershoot_pct), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 100, VE }, \ 1653 { "overshoot-pct", "Datarate overshoot (max) target (%)", OFFSET(rc_overshoot_pct), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1000, VE }, \ 1654 { "ts-parameters", "Temporal scaling configuration using a :-separated list of key=value parameters", OFFSET(vpx_ts_parameters), AV_OPT_TYPE_DICT, {.str=NULL}, 0, 0, VE}, \ 1656 #define LEGACY_OPTIONS \ 1657 {"speed", "", offsetof(VPxContext, cpu_used), AV_OPT_TYPE_INT, {.i64 = 1}, -16, 16, VE}, \ 1658 {"quality", "", offsetof(VPxContext, deadline), AV_OPT_TYPE_INT, {.i64 = VPX_DL_GOOD_QUALITY}, INT_MIN, INT_MAX, VE, "quality"}, \ 1659 {"vp8flags", "", offsetof(VPxContext, flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, 0, UINT_MAX, VE, "flags"}, \ 1660 {"error_resilient", "enable error resilience", 0, AV_OPT_TYPE_CONST, {.i64 = VP8F_ERROR_RESILIENT}, INT_MIN, INT_MAX, VE, "flags"}, \ 1661 {"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"}, \ 1662 {"arnr_max_frames", "altref noise reduction max frame count", offsetof(VPxContext, arnr_max_frames), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 15, VE}, \ 1663 {"arnr_strength", "altref noise reduction filter strength", offsetof(VPxContext, arnr_strength), AV_OPT_TYPE_INT, {.i64 = 3}, 0, 6, VE}, \ 1664 {"arnr_type", "altref noise reduction filter type", offsetof(VPxContext, arnr_type), AV_OPT_TYPE_INT, {.i64 = 3}, 1, 3, VE}, \ 1665 {"rc_lookahead", "Number of frames to look ahead for alternate reference frame selection", offsetof(VPxContext, lag_in_frames), AV_OPT_TYPE_INT, {.i64 = 25}, 0, 25, VE}, \ 1666 {"sharpness", "Increase sharpness at the expense of lower PSNR", offsetof(VPxContext, sharpness), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 7, VE}, 1668 #if CONFIG_LIBVPX_VP8_ENCODER 1669 static const AVOption vp8_options[] = {
1671 {
"auto-alt-ref",
"Enable use of alternate reference " 1679 #if CONFIG_LIBVPX_VP9_ENCODER 1680 static const AVOption vp9_options[] = {
1682 {
"auto-alt-ref",
"Enable use of alternate reference " 1686 {
"tile-columns",
"Number of tile columns to use, log2",
OFFSET(tile_columns),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6,
VE},
1688 {
"frame-parallel",
"Enable frame parallel decodability features",
OFFSET(frame_parallel),
AV_OPT_TYPE_BOOL,{.i64 = -1}, -1, 1,
VE},
1689 #if VPX_ENCODER_ABI_VERSION >= 12 1690 {
"aq-mode",
"adaptive quantization mode",
OFFSET(aq_mode),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 4,
VE,
"aq_mode"},
1692 {
"aq-mode",
"adaptive quantization mode",
OFFSET(aq_mode),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 3,
VE,
"aq_mode"},
1695 {
"variance",
"Variance based Aq", 0,
AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0,
VE,
"aq_mode" },
1696 {
"complexity",
"Complexity based Aq", 0,
AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0,
VE,
"aq_mode" },
1698 #if VPX_ENCODER_ABI_VERSION >= 12 1702 #ifdef VPX_CTRL_VP9E_SET_ROW_MT 1705 #ifdef VPX_CTRL_VP9E_SET_TUNE_CONTENT 1706 #if VPX_ENCODER_ABI_VERSION >= 14 1707 {
"tune-content",
"Tune content type",
OFFSET(tune_content),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 2,
VE,
"tune_content" },
1709 {
"tune-content",
"Tune content type",
OFFSET(tune_content),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1,
VE,
"tune_content" },
1711 {
"default",
"Regular video content", 0,
AV_OPT_TYPE_CONST, {.i64 = 0}, 0, 0,
VE,
"tune_content" },
1712 {
"screen",
"Screen capture content", 0,
AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0,
VE,
"tune_content" },
1713 #if VPX_ENCODER_ABI_VERSION >= 14 1714 {
"film",
"Film content; improves grain retention", 0,
AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0,
VE,
"tune_content" },
1717 #if VPX_ENCODER_ABI_VERSION >= 14 1718 {
"corpus-complexity",
"corpus vbr complexity midpoint",
OFFSET(corpus_complexity),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 10000,
VE },
1720 #ifdef VPX_CTRL_VP9E_SET_TPL 1728 #undef COMMON_OPTIONS 1729 #undef LEGACY_OPTIONS 1736 {
"keyint_min",
"-1" },
1740 #if CONFIG_LIBVPX_VP8_ENCODER 1743 return vpx_init(avctx, vpx_codec_vp8_cx());
1746 static const AVClass class_vp8 = {
1749 .option = vp8_options,
1764 .priv_class = &class_vp8,
1766 .wrapper_name =
"libvpx",
1770 #if CONFIG_LIBVPX_VP9_ENCODER 1773 return vpx_init(avctx, vpx_codec_vp9_cx());
1776 static const AVClass class_vp9 = {
1779 .option = vp9_options,
1784 .
name =
"libvpx-vp9",
1794 .priv_class = &class_vp9,
1797 .wrapper_name =
"libvpx",
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
static void set_vpx_defaults(AVCodecContext *avctx, struct vpx_codec_enc_cfg *enccfg)
Called when the bitrate is not set.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
int top
Distance in pixels from the top edge of the frame to the top and bottom edges and from the left edge ...
#define AV_PIX_FMT_YUV440P10
This structure describes decoded (raw) audio or video data.
static av_cold int vpx_free(AVCodecContext *avctx)
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
uint64_t error[AV_NUM_DATA_POINTERS]
error
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
#define AV_LOG_WARNING
Something somehow does not look correct.
int64_t bit_rate
the average bitrate
#define LIBAVUTIL_VERSION_INT
static av_cold int init(AVCodecContext *avctx)
struct FrameListData * coded_frame_list
int max_bitrate
Maximum bitrate of the stream, in bits per second.
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601 ...
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
enum AVColorRange color_range
MPEG vs JPEG YUV range.
void * buf
compressed data buffer
#define AV_PIX_FMT_GBRP10
const char * av_default_item_name(void *ptr)
Return the context name.
also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
size_t sz
length of compressed data
#define AV_PIX_FMT_YUV420P12
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
static void cx_pktcpy(struct FrameListData *dst, const struct vpx_codec_cx_pkt *src, const struct vpx_codec_cx_pkt *src_alpha, VPxContext *ctx)
static void error(const char *err)
#define AV_CODEC_CAP_AUTO_THREADS
Codec supports avctx->thread_count == 0 (auto).
struct vpx_fixed_buf twopass_stats
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
int min_bitrate
Minimum bitrate of the stream, in bits per second.
functionally identical to above
AVRational qoffset
Quantisation offset.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
#define VP8F_AUTO_ALT_REF
Enable automatic alternate reference frame generation.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
struct FrameListData * next
static av_cold int codecctl_int(AVCodecContext *avctx, enum vp8e_enc_control_id id, int val)
int64_t pts
time stamp to show frame (in timebase units)
AVCodec ff_libvpx_vp8_encoder
static void coded_frame_add(void *list, struct FrameListData *cx_frame)
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Structure to hold side data for an AVFrame.
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
#define CONFIG_LIBVPX_VP9_ENCODER
#define AV_LOG_VERBOSE
Detailed information.
AVDictionary * metadata
metadata.
int buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
uint32_t self_size
Must be set to the size of this data structure (that is, sizeof(AVRegionOfInterest)).
#define AV_PIX_FMT_YUV422P12
char * stats_out
pass1 encoding statistics output buffer
attribute_deprecated uint64_t error[AV_NUM_DATA_POINTERS]
attribute_deprecated int frame_skip_threshold
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
static int vpx_encode(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
#define i(width, name, range_min, range_max)
AVCodecID
Identify the syntax and semantics of the bitstream.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static int storeframe(AVCodecContext *avctx, struct FrameListData *cx_frame, AVPacket *pkt)
Store coded frame information in format suitable for return from encode2().
#define CONFIG_LIBVPX_VP8_ENCODER
int qmax
maximum quantizer
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
enum AVColorRange color_range
MPEG vs JPEG YUV range.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
int roi_warned
If the driver does not support ROI then warn the first time we encounter a frame with ROI side data...
int flags
AV_CODEC_FLAG_*.
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
#define AV_PIX_FMT_YUV444P10
char * av_base64_encode(char *out, int out_size, const uint8_t *in, int in_size)
Encode data to base64 and null-terminate.
static void set_color_range(AVCodecContext *avctx)
int flags
A combination of AV_PKT_FLAG values.
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
int rc_buffer_size
decoder bitstream buffer size
static int vp8_encode_set_roi(AVCodecContext *avctx, int frame_width, int frame_height, const AVFrameSideData *sd)
int64_t rc_min_rate
minimum bitrate
common internal API header
static const struct @315 planes[]
static av_cold void dump_enc_cfg(AVCodecContext *avctx, const struct vpx_codec_enc_cfg *cfg)
enum AVPictureType pict_type
Picture type of the frame.
struct vpx_image rawimg_alpha
#define AV_BASE64_SIZE(x)
Calculate the output size needed to base64-encode x bytes to a null-terminated string.
int width
picture width / height.
#define FF_PROFILE_UNKNOWN
ITU-R BT2020 non-constant luminance system.
attribute_deprecated int noise_reduction
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
static void vp8_ts_parse_int_array(int *dest, char *value, size_t value_len, int max_entries)
static void stats(AVPacket *const *in, int n_in, unsigned *_max, unsigned *_sum)
static int vp9_encode_set_roi(AVCodecContext *avctx, int frame_width, int frame_height, const AVFrameSideData *sd)
Structure describing a single Region Of Interest.
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)
Round to nearest and halfway cases away from zero.
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.
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
the normal 2^n-1 "JPEG" YUV ranges
AVCodec ff_libvpx_vp9_encoder
#define VP8F_ERROR_RESILIENT
Enable measures appropriate for streaming over lossy links.
static av_cold int vpx_init(AVCodecContext *avctx, const struct vpx_codec_iface *iface)
This structure describes the bitrate properties of an encoded bitstream.
static const AVCodecDefault defaults[]
#define AV_LOG_INFO
Standard information.
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
Libavcodec external API header.
av_cold void ff_vp9_init_static(AVCodec *codec)
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
static av_cold int vp9_init(AVFormatContext *ctx, int st_index, PayloadContext *data)
main external API structure.
static int queue_frames(AVCodecContext *avctx, AVPacket *pkt_out)
Queue multiple output frames from the encoder, returning the front-most.
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
AVDictionary * vpx_ts_parameters
static void set_vp8_defaults(AVCodecContext *avctx, struct vpx_codec_enc_cfg *enccfg)
Set the target bitrate to VPX library default.
int qmin
minimum quantizer
static void set_temporal_layer_pattern(int layering_mode, vpx_codec_enc_cfg_t *cfg, int *layer_flags, int *flag_periodicity)
Data found in BlockAdditional element of matroska container.
#define AV_PIX_FMT_YUV420P10
Describe the class of an AVClass context structure.
static int vpx_ts_param_parse(VPxContext *ctx, struct vpx_codec_enc_cfg *enccfg, char *key, char *value, enum AVCodecID codec_id)
static const AVProfile profiles[]
enum AVColorSpace colorspace
YUV colorspace type.
static int set_pix_fmt(AVCodecContext *avctx, struct aom_image *img)
Regions Of Interest, the data is an array of AVRegionOfInterest type, the number of array element is ...
uint32_t flags
flags for this frame
#define AV_PIX_FMT_YUV440P12
static av_cold void free_coded_frame(struct FrameListData *cx_frame)
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
static enum AVPixelFormat pix_fmts[]
#define AV_PIX_FMT_GBRP12
int have_sse
true if we have pending sse[]
#define AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV444P12
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static int set_roi_map(AVCodecContext *avctx, const AVFrameSideData *sd, int frame_width, int frame_height, vpx_roi_map_t *roi_map, int block_size, int segment_cnt)
the normal 219*2^(n-8) "MPEG" YUV ranges
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok()...
int flags
VP8 specific flags, see VP8F_* below.
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
static const char *const ctlidstr[]
String mappings for enum vp8e_enc_control_id.
struct vpx_codec_ctx encoder_alpha
static av_cold int vp8_init(AVFormatContext *s, int st_index, PayloadContext *vp8)
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
#define FF_DISABLE_DEPRECATION_WARNINGS
common internal api header.
common internal and external API header
struct vpx_codec_ctx encoder
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
static av_cold void free_frame_list(struct FrameListData *list)
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
int slices
Number of slices.
#define FF_ENABLE_DEPRECATION_WARNINGS
Portion of struct vpx_codec_cx_pkt from vpx_encoder.h.
int avg_bitrate
Average bitrate of the stream, in bits per second.
int key_frame
1 -> keyframe, 0-> not
unsigned long duration
duration to show frame (in timebase units)
int av_base64_decode(uint8_t *out, const char *in_str, int out_size)
Decode a base64-encoded string.
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
int have_sse
true if we have pending sse[]
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
static int realloc_alpha_uv(AVCodecContext *avctx, int width, int height)
#define av_malloc_array(a, b)
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
const AVProfile ff_vp9_profiles[]
AVPixelFormat
Pixel format.
static double val(void *priv, double ch)
This structure stores compressed data.
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
int64_t rc_max_rate
maximum bitrate
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
int keyint_min
minimum GOP size