26 #include "config_components.h"
28 #define VPX_DISABLE_CTRL_TYPECHECKS 1
29 #define VPX_CODEC_DISABLE_COMPAT 1
30 #include <vpx/vpx_encoder.h>
31 #include <vpx/vp8cx.h>
97 #define VP8F_ERROR_RESILIENT 0x00000001
98 #define VP8F_AUTO_ALT_REF 0x00000002
140 #if CONFIG_LIBVPX_VP9_ENCODER && defined(VPX_CTRL_VP9E_SET_MAX_INTER_BITRATE_PCT)
141 vpx_svc_ref_frame_config_t ref_frame_config;
147 [VP8E_SET_CPUUSED] =
"VP8E_SET_CPUUSED",
148 [VP8E_SET_ENABLEAUTOALTREF] =
"VP8E_SET_ENABLEAUTOALTREF",
149 [VP8E_SET_NOISE_SENSITIVITY] =
"VP8E_SET_NOISE_SENSITIVITY",
150 [VP8E_SET_STATIC_THRESHOLD] =
"VP8E_SET_STATIC_THRESHOLD",
151 [VP8E_SET_TOKEN_PARTITIONS] =
"VP8E_SET_TOKEN_PARTITIONS",
152 [VP8E_SET_ARNR_MAXFRAMES] =
"VP8E_SET_ARNR_MAXFRAMES",
153 [VP8E_SET_ARNR_STRENGTH] =
"VP8E_SET_ARNR_STRENGTH",
154 [VP8E_SET_ARNR_TYPE] =
"VP8E_SET_ARNR_TYPE",
155 [VP8E_SET_TUNING] =
"VP8E_SET_TUNING",
156 [VP8E_SET_CQ_LEVEL] =
"VP8E_SET_CQ_LEVEL",
157 [VP8E_SET_MAX_INTRA_BITRATE_PCT] =
"VP8E_SET_MAX_INTRA_BITRATE_PCT",
158 [VP8E_SET_SHARPNESS] =
"VP8E_SET_SHARPNESS",
159 [VP8E_SET_TEMPORAL_LAYER_ID] =
"VP8E_SET_TEMPORAL_LAYER_ID",
160 #if CONFIG_LIBVPX_VP9_ENCODER
161 [VP9E_SET_LOSSLESS] =
"VP9E_SET_LOSSLESS",
162 [VP9E_SET_TILE_COLUMNS] =
"VP9E_SET_TILE_COLUMNS",
163 [VP9E_SET_TILE_ROWS] =
"VP9E_SET_TILE_ROWS",
164 [VP9E_SET_FRAME_PARALLEL_DECODING] =
"VP9E_SET_FRAME_PARALLEL_DECODING",
165 [VP9E_SET_AQ_MODE] =
"VP9E_SET_AQ_MODE",
166 [VP9E_SET_COLOR_SPACE] =
"VP9E_SET_COLOR_SPACE",
167 [VP9E_SET_SVC_LAYER_ID] =
"VP9E_SET_SVC_LAYER_ID",
168 #if VPX_ENCODER_ABI_VERSION >= 12
169 [VP9E_SET_SVC_PARAMETERS] =
"VP9E_SET_SVC_PARAMETERS",
170 [VP9E_SET_SVC_REF_FRAME_CONFIG] =
"VP9E_SET_SVC_REF_FRAME_CONFIG",
172 [VP9E_SET_SVC] =
"VP9E_SET_SVC",
173 #if VPX_ENCODER_ABI_VERSION >= 11
174 [VP9E_SET_COLOR_RANGE] =
"VP9E_SET_COLOR_RANGE",
176 #if VPX_ENCODER_ABI_VERSION >= 12
177 [VP9E_SET_TARGET_LEVEL] =
"VP9E_SET_TARGET_LEVEL",
178 [VP9E_GET_LEVEL] =
"VP9E_GET_LEVEL",
180 #ifdef VPX_CTRL_VP9E_SET_ROW_MT
181 [VP9E_SET_ROW_MT] =
"VP9E_SET_ROW_MT",
183 #ifdef VPX_CTRL_VP9E_SET_TUNE_CONTENT
184 [VP9E_SET_TUNE_CONTENT] =
"VP9E_SET_TUNE_CONTENT",
186 #ifdef VPX_CTRL_VP9E_SET_TPL
187 [VP9E_SET_TPL] =
"VP9E_SET_TPL",
195 const char *
error = vpx_codec_error(&
ctx->encoder);
196 const char *detail = vpx_codec_error_detail(&
ctx->encoder);
204 const struct vpx_codec_enc_cfg *cfg,
212 " %*s%u\n %*s%u\n %*s%u\n %*s%u\n %*s%u\n"
213 #
if CONFIG_LIBVPX_VP9_ENCODER
216 " %*s{%u/%u}\n %*s%u\n %*s%d\n %*s%u\n",
217 width,
"g_usage:", cfg->g_usage,
218 width,
"g_threads:", cfg->g_threads,
219 width,
"g_profile:", cfg->g_profile,
220 width,
"g_w:", cfg->g_w,
221 width,
"g_h:", cfg->g_h,
222 #
if CONFIG_LIBVPX_VP9_ENCODER
223 width,
"g_bit_depth:", cfg->g_bit_depth,
224 width,
"g_input_bit_depth:", cfg->g_input_bit_depth,
226 width,
"g_timebase:", cfg->g_timebase.num, cfg->g_timebase.den,
227 width,
"g_error_resilient:", cfg->g_error_resilient,
228 width,
"g_pass:", cfg->g_pass,
229 width,
"g_lag_in_frames:", cfg->g_lag_in_frames);
231 " %*s%u\n %*s%u\n %*s%u\n %*s%u\n"
233 width,
"rc_dropframe_thresh:", cfg->rc_dropframe_thresh,
234 width,
"rc_resize_allowed:", cfg->rc_resize_allowed,
235 width,
"rc_resize_up_thresh:", cfg->rc_resize_up_thresh,
236 width,
"rc_resize_down_thresh:", cfg->rc_resize_down_thresh,
237 width,
"rc_end_usage:", cfg->rc_end_usage,
238 width,
"rc_twopass_stats_in:", cfg->rc_twopass_stats_in.buf, cfg->rc_twopass_stats_in.sz,
239 width,
"rc_target_bitrate:", cfg->rc_target_bitrate);
242 width,
"rc_min_quantizer:", cfg->rc_min_quantizer,
243 width,
"rc_max_quantizer:", cfg->rc_max_quantizer);
246 width,
"rc_undershoot_pct:", cfg->rc_undershoot_pct,
247 width,
"rc_overshoot_pct:", cfg->rc_overshoot_pct);
248 av_log(avctx,
level,
"temporal layering settings\n"
249 " %*s%u\n",
width,
"ts_number_layers:", cfg->ts_number_layers);
252 "\n %*s",
width,
"ts_target_bitrate:");
253 for (
i = 0;
i < VPX_TS_MAX_LAYERS;
i++)
255 "%u ", cfg->ts_target_bitrate[
i]);
257 #if (VPX_ENCODER_ABI_VERSION >= 12) && CONFIG_LIBVPX_VP9_ENCODER
260 "\n %*s",
width,
"layer_target_bitrate:");
261 for (
i = 0;
i < VPX_TS_MAX_LAYERS;
i++)
263 "%u ", cfg->layer_target_bitrate[
i]);
268 "\n %*s",
width,
"ts_rate_decimator:");
269 for (
i = 0;
i < VPX_TS_MAX_LAYERS;
i++)
273 "\n %*s%u\n",
width,
"ts_periodicity:", cfg->ts_periodicity);
275 "\n %*s",
width,
"ts_layer_id:");
276 for (
i = 0;
i < VPX_TS_MAX_PERIODICITY;
i++)
280 " %*s%u\n %*s%u\n %*s%u\n",
281 width,
"rc_buf_sz:", cfg->rc_buf_sz,
282 width,
"rc_buf_initial_sz:", cfg->rc_buf_initial_sz,
283 width,
"rc_buf_optimal_sz:", cfg->rc_buf_optimal_sz);
284 av_log(avctx,
level,
"2 pass rate control settings\n"
285 " %*s%u\n %*s%u\n %*s%u\n",
286 width,
"rc_2pass_vbr_bias_pct:", cfg->rc_2pass_vbr_bias_pct,
287 width,
"rc_2pass_vbr_minsection_pct:", cfg->rc_2pass_vbr_minsection_pct,
288 width,
"rc_2pass_vbr_maxsection_pct:", cfg->rc_2pass_vbr_maxsection_pct);
289 #if VPX_ENCODER_ABI_VERSION >= 14
291 width,
"rc_2pass_vbr_corpus_complexity:", cfg->rc_2pass_vbr_corpus_complexity);
294 " %*s%d\n %*s%u\n %*s%u\n",
295 width,
"kf_mode:", cfg->kf_mode,
296 width,
"kf_min_dist:", cfg->kf_min_dist,
297 width,
"kf_max_dist:", cfg->kf_max_dist);
360 enum vp8e_enc_control_id
id,
int val)
370 res = vpx_codec_control(&
ctx->encoder,
id,
val);
371 if (res != VPX_CODEC_OK) {
379 int res_alpha = vpx_codec_control(&
ctx->encoder_alpha,
id,
val);
380 if (res_alpha != VPX_CODEC_OK) {
381 snprintf(
buf,
sizeof(
buf),
"Failed to set %s alpha codec control",
391 #if VPX_ENCODER_ABI_VERSION >= 12
393 enum vp8e_enc_control_id
id,
int *
val)
403 res = vpx_codec_control(&
ctx->encoder,
id,
val);
404 if (res != VPX_CODEC_OK) {
412 int res_alpha = vpx_codec_control(&
ctx->encoder_alpha,
id,
val);
413 if (res_alpha != VPX_CODEC_OK) {
414 snprintf(
buf,
sizeof(
buf),
"Failed to set %s alpha codec control",
429 #if VPX_ENCODER_ABI_VERSION >= 12
433 if (!codecctl_intp(avctx, VP9E_GET_LEVEL, &level_out))
440 vpx_codec_destroy(&
ctx->encoder);
442 vpx_codec_destroy(&
ctx->encoder_alpha);
449 if (
ctx->hdr10_plus_fifo)
457 char *saveptr =
NULL;
460 while (token && dest_idx < max_entries) {
461 dest[dest_idx++] = strtoul(token,
NULL, 10);
466 #if CONFIG_LIBVPX_VP9_ENCODER && defined(VPX_CTRL_VP9E_SET_MAX_INTER_BITRATE_PCT)
467 static void vp8_ts_parse_int64_array(int64_t *dest,
char *
value,
size_t value_len,
int max_entries)
470 char *saveptr =
NULL;
473 while (token && dest_idx < max_entries) {
474 dest[dest_idx++] = strtoull(token,
NULL, 10);
481 int *layer_flags,
int *flag_periodicity)
483 switch (layering_mode) {
488 static const int ids[2] = { 0, 1 };
489 cfg->ts_periodicity = 2;
490 *flag_periodicity = 2;
491 cfg->ts_number_layers = 2;
492 cfg->ts_rate_decimator[0] = 2;
493 cfg->ts_rate_decimator[1] = 1;
494 memcpy(cfg->ts_layer_id, ids,
sizeof(ids));
497 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
498 VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
500 VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_GF |
501 VP8_EFLAG_NO_UPD_LAST |
502 VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_REF_GF;
512 static const int ids[4] = { 0, 2, 1, 2 };
513 cfg->ts_periodicity = 4;
514 *flag_periodicity = 4;
515 cfg->ts_number_layers = 3;
516 cfg->ts_rate_decimator[0] = 4;
517 cfg->ts_rate_decimator[1] = 2;
518 cfg->ts_rate_decimator[2] = 1;
519 memcpy(cfg->ts_layer_id, ids,
sizeof(ids));
526 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
527 VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
529 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
530 VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
531 VP8_EFLAG_NO_UPD_ARF;
533 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
534 VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
536 VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_REF_ARF |
537 VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
538 VP8_EFLAG_NO_UPD_ARF;
547 static const int ids[4] = { 0, 2, 1, 2 };
548 cfg->ts_periodicity = 4;
549 *flag_periodicity = 4;
550 cfg->ts_number_layers = 3;
551 cfg->ts_rate_decimator[0] = 4;
552 cfg->ts_rate_decimator[1] = 2;
553 cfg->ts_rate_decimator[2] = 1;
554 memcpy(cfg->ts_layer_id, ids,
sizeof(ids));
560 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
561 VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
563 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
564 VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF;
566 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
567 VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
569 VP8_EFLAG_NO_REF_LAST |
570 VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
571 VP8_EFLAG_NO_UPD_ARF;
587 size_t value_len = strlen(
value);
588 int ts_layering_mode = 0;
593 if (!strcmp(
key,
"ts_number_layers"))
594 enccfg->ts_number_layers = strtoul(
value, &
value, 10);
595 else if (!strcmp(
key,
"ts_target_bitrate")) {
598 #if (VPX_ENCODER_ABI_VERSION >= 12) && CONFIG_LIBVPX_VP9_ENCODER
602 }
else if (!strcmp(
key,
"ts_rate_decimator")) {
604 }
else if (!strcmp(
key,
"ts_periodicity")) {
605 enccfg->ts_periodicity = strtoul(
value, &
value, 10);
606 }
else if (!strcmp(
key,
"ts_layer_id")) {
608 }
else if (!strcmp(
key,
"ts_layering_mode")) {
613 #if (VPX_ENCODER_ABI_VERSION >= 12) && CONFIG_LIBVPX_VP9_ENCODER
614 enccfg->temporal_layering_mode = VP9E_TEMPORAL_LAYERING_MODE_BYPASS;
615 enccfg->ss_number_layers = 1;
617 if (ts_layering_mode) {
627 #if CONFIG_LIBVPX_VP9_ENCODER && defined(VPX_CTRL_VP9E_SET_MAX_INTER_BITRATE_PCT)
628 static int vpx_ref_frame_config_set_value(vpx_svc_ref_frame_config_t *ref_frame_config,
629 int ss_number_layers,
char *
key,
char *
value)
631 size_t value_len = strlen(
value);
636 if (!strcmp(
key,
"rfc_update_buffer_slot")) {
638 }
else if (!strcmp(
key,
"rfc_update_last")) {
640 }
else if (!strcmp(
key,
"rfc_update_golden")) {
642 }
else if (!strcmp(
key,
"rfc_update_alt_ref")) {
644 }
else if (!strcmp(
key,
"rfc_lst_fb_idx")) {
646 }
else if (!strcmp(
key,
"rfc_gld_fb_idx")) {
648 }
else if (!strcmp(
key,
"rfc_alt_fb_idx")) {
650 }
else if (!strcmp(
key,
"rfc_reference_last")) {
652 }
else if (!strcmp(
key,
"rfc_reference_golden")) {
654 }
else if (!strcmp(
key,
"rfc_reference_alt_ref")) {
656 }
else if (!strcmp(
key,
"rfc_reference_duration")) {
657 vp8_ts_parse_int64_array(ref_frame_config->duration,
value, value_len, ss_number_layers);
663 static int vpx_parse_ref_frame_config_element(vpx_svc_ref_frame_config_t *ref_frame_config,
664 int ss_number_layers,
const char **
buf)
666 const char key_val_sep[] =
"=";
667 const char pairs_sep[] =
":";
672 if (
key && *
key && strspn(*
buf, key_val_sep)) {
678 ret = vpx_ref_frame_config_set_value(ref_frame_config, ss_number_layers,
key,
val);
688 static int vpx_parse_ref_frame_config(vpx_svc_ref_frame_config_t *ref_frame_config,
689 int ss_number_layers,
const char *
str)
695 vpx_parse_ref_frame_config_element(ref_frame_config, ss_number_layers, &
str);
707 #if CONFIG_LIBVPX_VP9_ENCODER
709 struct vpx_codec_enc_cfg *enccfg, vpx_codec_flags_t *
flags,
710 vpx_img_fmt_t *img_fmt)
714 enccfg->g_bit_depth = enccfg->g_input_bit_depth =
desc->comp[0].depth;
718 enccfg->g_profile = 0;
719 *img_fmt = VPX_IMG_FMT_I420;
722 enccfg->g_profile = 1;
723 *img_fmt = VPX_IMG_FMT_I422;
726 enccfg->g_profile = 1;
727 *img_fmt = VPX_IMG_FMT_I440;
730 ctx->vpx_cs = VPX_CS_SRGB;
732 enccfg->g_profile = 1;
733 *img_fmt = VPX_IMG_FMT_I444;
737 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {
738 enccfg->g_profile = 2;
739 *img_fmt = VPX_IMG_FMT_I42016;
740 *
flags |= VPX_CODEC_USE_HIGHBITDEPTH;
746 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {
747 enccfg->g_profile = 3;
748 *img_fmt = VPX_IMG_FMT_I42216;
749 *
flags |= VPX_CODEC_USE_HIGHBITDEPTH;
755 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {
756 enccfg->g_profile = 3;
757 *img_fmt = VPX_IMG_FMT_I44016;
758 *
flags |= VPX_CODEC_USE_HIGHBITDEPTH;
764 ctx->vpx_cs = VPX_CS_SRGB;
767 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {
768 enccfg->g_profile = 3;
769 *img_fmt = VPX_IMG_FMT_I44416;
770 *
flags |= VPX_CODEC_USE_HIGHBITDEPTH;
783 enum vpx_color_space vpx_cs;
787 vpx_cs =
ctx->vpx_cs;
807 #if VPX_ENCODER_ABI_VERSION >= 11
810 enum vpx_color_range vpx_cr;
830 struct vpx_codec_enc_cfg *enccfg)
834 avctx->
bit_rate = enccfg->rc_target_bitrate * 1000;
835 if (enccfg->rc_end_usage == VPX_CQ) {
837 "Bitrate not specified for constrained quality mode, using default of %dkbit/sec\n",
838 enccfg->rc_target_bitrate);
840 enccfg->rc_end_usage = VPX_CQ;
843 "Neither bitrate nor constrained quality specified, using default CRF of %d and bitrate of %dkbit/sec\n",
844 ctx->crf, enccfg->rc_target_bitrate);
849 #if CONFIG_LIBVPX_VP9_ENCODER
855 struct vpx_codec_enc_cfg *enccfg)
859 if (enccfg->rc_end_usage != VPX_Q &&
ctx->lossless < 0) {
860 enccfg->rc_end_usage = VPX_Q;
863 "Neither bitrate nor constrained quality specified, using default CRF of %d\n",
874 struct vpx_codec_enc_cfg *enccfg)
877 #if CONFIG_LIBVPX_VP9_ENCODER
879 set_vp9_defaults(avctx, enccfg);
887 const struct vpx_codec_iface *iface)
890 struct vpx_codec_enc_cfg enccfg = { 0 };
891 struct vpx_codec_enc_cfg enccfg_alpha;
895 vpx_img_fmt_t img_fmt = VPX_IMG_FMT_I420;
896 #if CONFIG_LIBVPX_VP9_ENCODER
897 vpx_codec_caps_t codec_caps = vpx_codec_get_caps(iface);
898 vpx_svc_extra_cfg_t svc_params;
908 if ((res = vpx_codec_enc_config_default(iface, &enccfg, 0)) != VPX_CODEC_OK) {
910 vpx_codec_err_to_string(res));
914 #if CONFIG_LIBVPX_VP9_ENCODER
923 if (!
ctx->hdr10_plus_fifo)
937 enccfg.g_w = avctx->
width;
938 enccfg.g_h = avctx->
height;
943 enccfg.g_lag_in_frames=
ctx->lag_in_frames;
946 enccfg.g_pass = VPX_RC_FIRST_PASS;
948 enccfg.g_pass = VPX_RC_LAST_PASS;
950 enccfg.g_pass = VPX_RC_ONE_PASS;
954 enccfg.rc_end_usage = VPX_CBR;
955 }
else if (
ctx->crf >= 0) {
956 enccfg.rc_end_usage = VPX_CQ;
957 #if CONFIG_LIBVPX_VP9_ENCODER
959 enccfg.rc_end_usage = VPX_Q;
966 #if CONFIG_LIBVPX_VP9_ENCODER
967 enccfg.ss_target_bitrate[0] = enccfg.rc_target_bitrate;
975 enccfg.rc_min_quantizer =
976 enccfg.rc_max_quantizer = 0;
978 if (avctx->
qmin >= 0)
979 enccfg.rc_min_quantizer = avctx->
qmin;
980 if (avctx->
qmax >= 0)
981 enccfg.rc_max_quantizer = avctx->
qmax;
984 if (enccfg.rc_end_usage == VPX_CQ
985 #
if CONFIG_LIBVPX_VP9_ENCODER
986 || enccfg.rc_end_usage == VPX_Q
989 if (
ctx->crf < enccfg.rc_min_quantizer ||
ctx->crf > enccfg.rc_max_quantizer) {
991 "CQ level %d must be between minimum and maximum quantizer value (%d-%d)\n",
992 ctx->crf, enccfg.rc_min_quantizer, enccfg.rc_max_quantizer);
997 enccfg.rc_dropframe_thresh =
ctx->drop_threshold;
1002 enccfg.rc_2pass_vbr_minsection_pct =
1005 enccfg.rc_2pass_vbr_maxsection_pct =
1007 #if CONFIG_LIBVPX_VP9_ENCODER
1009 #if VPX_ENCODER_ABI_VERSION >= 14
1010 if (
ctx->corpus_complexity >= 0)
1011 enccfg.rc_2pass_vbr_corpus_complexity =
ctx->corpus_complexity;
1020 enccfg.rc_buf_initial_sz =
1022 enccfg.rc_buf_optimal_sz = enccfg.rc_buf_sz * 5 / 6;
1023 if (
ctx->rc_undershoot_pct >= 0)
1024 enccfg.rc_undershoot_pct =
ctx->rc_undershoot_pct;
1025 if (
ctx->rc_overshoot_pct >= 0)
1026 enccfg.rc_overshoot_pct =
ctx->rc_overshoot_pct;
1032 enccfg.kf_max_dist = avctx->
gop_size;
1034 if (enccfg.g_pass == VPX_RC_FIRST_PASS)
1035 enccfg.g_lag_in_frames = 0;
1036 else if (enccfg.g_pass == VPX_RC_LAST_PASS) {
1037 int decode_size,
ret;
1044 ctx->twopass_stats.sz = strlen(avctx->
stats_in) * 3 / 4;
1049 ctx->twopass_stats.sz);
1050 ctx->twopass_stats.sz = 0;
1054 ctx->twopass_stats.sz);
1055 if (decode_size < 0) {
1060 ctx->twopass_stats.sz = decode_size;
1061 enccfg.rc_twopass_stats_in =
ctx->twopass_stats;
1068 enccfg.g_profile = avctx->
profile;
1075 "Error parsing option '%s = %s'.\n",
1080 res = vpx_codec_enc_init(&
ctx->encoder, iface, &enccfg,
flags);
1081 if (res != VPX_CODEC_OK) {
1088 #if CONFIG_LIBVPX_VP9_ENCODER
1090 memset(&svc_params, 0,
sizeof(svc_params));
1091 for (
int i = 0;
i < enccfg.ts_number_layers; ++
i) {
1092 svc_params.max_quantizers[
i] = enccfg.rc_max_quantizer;
1093 svc_params.min_quantizers[
i] = enccfg.rc_min_quantizer;
1095 svc_params.scaling_factor_num[0] = enccfg.g_h;
1096 svc_params.scaling_factor_den[0] = enccfg.g_h;
1097 #if VPX_ENCODER_ABI_VERSION >= 12
1099 codecctl_intp(avctx, VP9E_SET_SVC_PARAMETERS, (
int *)&svc_params);
1103 if (
ctx->is_alpha) {
1104 enccfg_alpha = enccfg;
1105 res = vpx_codec_enc_init(&
ctx->encoder_alpha, iface, &enccfg_alpha,
flags);
1106 if (res != VPX_CODEC_OK) {
1116 ctx->auto_alt_ref = 1;
1117 if (
ctx->auto_alt_ref >= 0)
1120 if (
ctx->arnr_max_frames >= 0)
1122 if (
ctx->arnr_strength >= 0)
1124 if (
ctx->arnr_type >= 0)
1130 av_log(avctx,
AV_LOG_ERROR,
"Transparency encoding with auto_alt_ref does not work\n");
1134 if (
ctx->sharpness >= 0)
1138 codecctl_int(avctx, VP8E_SET_NOISE_SENSITIVITY,
ctx->noise_sensitivity);
1144 if (
ctx->max_intra_rate >= 0)
1145 codecctl_int(avctx, VP8E_SET_MAX_INTRA_BITRATE_PCT,
ctx->max_intra_rate);
1147 #if CONFIG_LIBVPX_VP9_ENCODER
1149 if (
ctx->lossless >= 0)
1151 if (
ctx->tile_columns >= 0)
1153 if (
ctx->tile_rows >= 0)
1155 if (
ctx->frame_parallel >= 0)
1156 codecctl_int(avctx, VP9E_SET_FRAME_PARALLEL_DECODING,
ctx->frame_parallel);
1157 if (
ctx->aq_mode >= 0)
1159 set_colorspace(avctx);
1160 #if VPX_ENCODER_ABI_VERSION >= 11
1163 #if VPX_ENCODER_ABI_VERSION >= 12
1166 #ifdef VPX_CTRL_VP9E_SET_ROW_MT
1167 if (
ctx->row_mt >= 0)
1170 #ifdef VPX_CTRL_VP9E_SET_TUNE_CONTENT
1171 if (
ctx->tune_content >= 0)
1174 #ifdef VPX_CTRL_VP9E_SET_TPL
1175 if (
ctx->tpl_model >= 0)
1184 vpx_img_wrap(&
ctx->rawimg, img_fmt, avctx->
width, avctx->
height, 1,
1186 #if CONFIG_LIBVPX_VP9_ENCODER
1188 ctx->rawimg.bit_depth = enccfg.g_bit_depth;
1195 if (enccfg.rc_end_usage == VPX_CBR ||
1196 enccfg.g_pass != VPX_RC_ONE_PASS) {
1207 const struct vpx_codec_cx_pkt *
src,
1208 const struct vpx_codec_cx_pkt *src_alpha,
1211 dst->
pts =
src->data.frame.pts;
1213 dst->
flags =
src->data.frame.flags;
1214 dst->
sz =
src->data.frame.sz;
1215 dst->
buf =
src->data.frame.buf;
1218 if (!(dst->
flags & VPX_FRAME_IS_INVISIBLE)) {
1221 if (
ctx->have_sse) {
1226 memcpy(dst->
sse,
ctx->sse,
sizeof(dst->
sse));
1233 dst->
buf_alpha = src_alpha->data.frame.buf;
1234 dst->
sz_alpha = src_alpha->data.frame.sz;
1263 if (!!(cx_frame->
flags & VPX_FRAME_IS_KEY)) {
1270 ret = vpx_codec_control(&
ctx->encoder, VP8E_GET_LAST_QUANTIZER_64, &
quality);
1271 if (
ret != VPX_CODEC_OK)
1274 cx_frame->
have_sse ? 3 : 0, pict_type);
1278 for (
int i = 0;
i < 3; ++
i)
1294 if (
ctx->hdr10_plus_fifo) {
1315 const struct vpx_codec_cx_pkt *
pkt;
1316 const struct vpx_codec_cx_pkt *pkt_alpha =
NULL;
1317 const void *iter =
NULL;
1318 const void *iter_alpha =
NULL;
1321 if (
ctx->coded_frame_list) {
1327 ctx->coded_frame_list = cx_frame->
next;
1333 while ((
pkt = vpx_codec_get_cx_data(&
ctx->encoder, &iter)) &&
1335 (pkt_alpha = vpx_codec_get_cx_data(&
ctx->encoder_alpha, &iter_alpha)))) {
1336 switch (
pkt->kind) {
1337 case VPX_CODEC_CX_FRAME_PKT:
1353 "Frame queue element alloc failed\n");
1359 if (!cx_frame->
buf) {
1367 if (
ctx->is_alpha) {
1376 memcpy(cx_frame->
buf_alpha, pkt_alpha->data.frame.buf, pkt_alpha->data.frame.sz);
1381 case VPX_CODEC_STATS_PKT: {
1382 struct vpx_fixed_buf *
stats = &
ctx->twopass_stats;
1386 pkt->
data.twopass_stats.sz)) < 0) {
1396 case VPX_CODEC_PSNR_PKT:
1404 case VPX_CODEC_CUSTOM_PKT:
1414 vpx_roi_map_t *roi_map,
int block_size,
int segment_cnt)
1419 #define MAX_DELTA_Q 63
1434 memset(roi_map, 0,
sizeof(*roi_map));
1445 if (!self_size || sd->
size % self_size) {
1449 nb_rois = sd->
size / self_size;
1455 for (
int i = 0;
i < nb_rois;
i++) {
1469 if (!segment_mapping[mapping_index]) {
1470 if (segment_id == segment_cnt) {
1472 "ROI only supports %d segments (and segment 0 is reserved for non-ROIs), skipping the left ones.\n",
1477 segment_mapping[mapping_index] = segment_id + 1;
1478 roi_map->delta_q[segment_id] =
delta_q;
1483 roi_map->rows = (frame_height + block_size - 1) / block_size;
1484 roi_map->cols = (frame_width + block_size - 1) / block_size;
1485 roi_map->roi_map =
av_calloc(roi_map->rows * roi_map->cols,
sizeof(*roi_map->roi_map));
1486 if (!roi_map->roi_map) {
1494 for (
int i = nb_rois - 1;
i >= 0;
i--) {
1497 int starty, endy, startx, endx;
1501 starty =
av_clip(roi->
top / block_size, 0, roi_map->rows);
1502 endy =
av_clip((roi->
bottom + block_size - 1) / block_size, 0, roi_map->rows);
1503 startx =
av_clip(roi->
left / block_size, 0, roi_map->cols);
1504 endx =
av_clip((roi->
right + block_size - 1) / block_size, 0, roi_map->cols);
1510 if (mapping_value) {
1511 for (
int y = starty; y < endy; y++)
1512 for (
int x = startx; x < endx; x++)
1513 roi_map->roi_map[x + y * roi_map->cols] = mapping_value - 1;
1524 #ifdef VPX_CTRL_VP9E_SET_ROI_MAP
1525 int version = vpx_codec_version();
1528 int patch = VPX_VERSION_PATCH(
version);
1531 vpx_roi_map_t roi_map;
1532 const int segment_cnt = 8;
1533 const int block_size = 8;
1536 if (
ctx->aq_mode > 0 ||
ctx->cpu_used < 5 ||
ctx->deadline != VPX_DL_REALTIME) {
1537 if (!
ctx->roi_warned) {
1538 ctx->roi_warned = 1;
1540 "and deadline is REALTIME, so skipping ROI.\n");
1545 ret =
set_roi_map(avctx, sd, frame_width, frame_height, &roi_map, block_size, segment_cnt);
1551 memset(roi_map.ref_frame, -1,
sizeof(roi_map.ref_frame));
1553 if (vpx_codec_control(&
ctx->encoder, VP9E_SET_ROI_MAP, &roi_map)) {
1562 if (!
ctx->roi_warned) {
1563 ctx->roi_warned = 1;
1564 av_log(avctx,
AV_LOG_WARNING,
"ROI is not supported, please upgrade libvpx to version >= 1.8.1. "
1565 "You may need to rebuild ffmpeg.\n");
1572 vpx_roi_map_t roi_map;
1573 const int segment_cnt = 4;
1574 const int block_size = 16;
1577 int ret =
set_roi_map(avctx, sd, frame_width, frame_height, &roi_map, block_size, segment_cnt);
1583 if (vpx_codec_control(&
ctx->encoder, VP8E_SET_ROI_MAP, &roi_map)) {
1595 struct vpx_image *rawimg_alpha = &
ctx->rawimg_alpha;
1596 unsigned char **
planes = rawimg_alpha->planes;
1597 int *
stride = rawimg_alpha->stride;
1599 if (!
planes[VPX_PLANE_U] ||
1601 width != (
int)rawimg_alpha->d_w ||
1602 height != (
int)rawimg_alpha->d_h) {
1606 vpx_img_wrap(rawimg_alpha, VPX_IMG_FMT_I420,
width,
height, 1,
1624 struct vpx_image *rawimg =
NULL;
1625 struct vpx_image *rawimg_alpha =
NULL;
1626 int64_t timestamp = 0;
1627 int res, coded_size;
1628 vpx_enc_frame_flags_t
flags = 0;
1629 const struct vpx_codec_enc_cfg *enccfg =
ctx->encoder.config.enc;
1630 vpx_svc_layer_id_t layer_id;
1631 int layer_id_valid = 0;
1633 if (avctx->
qmax >= 0 && enccfg->rc_max_quantizer != avctx->
qmax) {
1634 struct vpx_codec_enc_cfg cfg = *enccfg;
1635 cfg.rc_max_quantizer = avctx->
qmax;
1636 res = vpx_codec_enc_config_set(&
ctx->encoder, &cfg);
1637 if (res != VPX_CODEC_OK) {
1645 rawimg = &
ctx->rawimg;
1646 rawimg->planes[VPX_PLANE_Y] =
frame->data[0];
1647 rawimg->planes[VPX_PLANE_U] =
frame->data[1];
1648 rawimg->planes[VPX_PLANE_V] =
frame->data[2];
1649 rawimg->stride[VPX_PLANE_Y] =
frame->linesize[0];
1650 rawimg->stride[VPX_PLANE_U] =
frame->linesize[1];
1651 rawimg->stride[VPX_PLANE_V] =
frame->linesize[2];
1652 if (
ctx->is_alpha) {
1653 rawimg_alpha = &
ctx->rawimg_alpha;
1657 rawimg_alpha->planes[VPX_PLANE_Y] =
frame->data[3];
1658 rawimg_alpha->stride[VPX_PLANE_Y] =
frame->linesize[3];
1660 timestamp =
frame->pts;
1661 #if VPX_IMAGE_ABI_VERSION >= 4
1662 switch (
frame->color_range) {
1664 rawimg->range = VPX_CR_STUDIO_RANGE;
1667 rawimg->range = VPX_CR_FULL_RANGE;
1672 flags |= VPX_EFLAG_FORCE_KF;
1673 if (
frame->metadata) {
1679 memset(&layer_id, 0,
sizeof(layer_id));
1683 layer_id.temporal_layer_id = strtoul(en->
value,
NULL, 10);
1684 #ifdef VPX_CTRL_VP9E_SET_MAX_INTER_BITRATE_PCT
1685 layer_id.temporal_layer_id_per_spatial[0] = layer_id.temporal_layer_id;
1689 #if CONFIG_LIBVPX_VP9_ENCODER && defined(VPX_CTRL_VP9E_SET_MAX_INTER_BITRATE_PCT)
1694 int ret = vpx_parse_ref_frame_config(&
ctx->ref_frame_config,
1695 enccfg->ss_number_layers, en->
value);
1698 "Error parsing ref_frame_config option %s.\n", en->
value);
1702 codecctl_intp(avctx, VP9E_SET_SVC_REF_FRAME_CONFIG, (
int *)&
ctx->ref_frame_config);
1705 "Ignoring ref-frame-config for a non-VP9 codec\n");
1719 if (
ctx->hdr10_plus_fifo) {
1723 if (hdr10_plus_metadata) {
1728 if (!
data.hdr10_plus)
1741 if (enccfg->ts_number_layers > 1 &&
ctx->ts_layer_flags) {
1742 if (
flags & VPX_EFLAG_FORCE_KF) {
1744 ctx->current_temporal_idx = 0;
1745 flags = VPX_EFLAG_FORCE_KF;
1751 flags |=
ctx->ts_layer_flags[
ctx->current_temporal_idx];
1753 memset(&layer_id, 0,
sizeof(layer_id));
1754 #if VPX_ENCODER_ABI_VERSION >= 12
1755 layer_id.spatial_layer_id = 0;
1757 layer_id.temporal_layer_id = enccfg->ts_layer_id[
ctx->current_temporal_idx];
1758 #ifdef VPX_CTRL_VP9E_SET_MAX_INTER_BITRATE_PCT
1759 layer_id.temporal_layer_id_per_spatial[0] = layer_id.temporal_layer_id;
1764 if (layer_id_valid) {
1766 codecctl_int(avctx, VP8E_SET_TEMPORAL_LAYER_ID, layer_id.temporal_layer_id);
1768 #if CONFIG_LIBVPX_VP9_ENCODER && VPX_ENCODER_ABI_VERSION >= 12
1770 codecctl_intp(avctx, VP9E_SET_SVC_LAYER_ID, (
int *)&layer_id);
1775 res = vpx_codec_encode(&
ctx->encoder, rawimg, timestamp,
1777 if (res != VPX_CODEC_OK) {
1782 if (
ctx->is_alpha) {
1783 res = vpx_codec_encode(&
ctx->encoder_alpha, rawimg_alpha, timestamp,
1785 if (res != VPX_CODEC_OK) {
1803 ctx->twopass_stats.sz);
1804 }
else if (enccfg->ts_number_layers > 1 &&
ctx->ts_layer_flags) {
1805 ctx->current_temporal_idx = (
ctx->current_temporal_idx + 1) % enccfg->ts_periodicity;
1808 *got_packet = !!coded_size;
1812 #define OFFSET(x) offsetof(VPxContext, x)
1813 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1815 #define COMMON_OPTIONS \
1816 { "lag-in-frames", "Number of frames to look ahead for " \
1817 "alternate reference frame selection", OFFSET(lag_in_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \
1818 { "arnr-maxframes", "altref noise reduction max frame count", OFFSET(arnr_max_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \
1819 { "arnr-strength", "altref noise reduction filter strength", OFFSET(arnr_strength), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \
1820 { "arnr-type", "altref noise reduction filter type", OFFSET(arnr_type), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE, "arnr_type"}, \
1821 { "backward", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0, VE, "arnr_type" }, \
1822 { "forward", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0, VE, "arnr_type" }, \
1823 { "centered", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 3}, 0, 0, VE, "arnr_type" }, \
1824 { "tune", "Tune the encoding to a specific scenario", OFFSET(tune), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE, "tune"}, \
1825 { "psnr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VP8_TUNE_PSNR}, 0, 0, VE, "tune"}, \
1826 { "ssim", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VP8_TUNE_SSIM}, 0, 0, VE, "tune"}, \
1827 { "deadline", "Time to spend encoding, in microseconds.", OFFSET(deadline), AV_OPT_TYPE_INT, {.i64 = VPX_DL_GOOD_QUALITY}, INT_MIN, INT_MAX, VE, "quality"}, \
1828 { "best", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_BEST_QUALITY}, 0, 0, VE, "quality"}, \
1829 { "good", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_GOOD_QUALITY}, 0, 0, VE, "quality"}, \
1830 { "realtime", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_REALTIME}, 0, 0, VE, "quality"}, \
1831 { "error-resilient", "Error resilience configuration", OFFSET(error_resilient), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, VE, "er"}, \
1832 { "max-intra-rate", "Maximum I-frame bitrate (pct) 0=unlimited", OFFSET(max_intra_rate), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \
1833 { "default", "Improve resiliency against losses of whole frames", 0, AV_OPT_TYPE_CONST, {.i64 = VPX_ERROR_RESILIENT_DEFAULT}, 0, 0, VE, "er"}, \
1834 { "partitions", "The frame partitions are independently decodable " \
1835 "by the bool decoder, meaning that partitions can be decoded even " \
1836 "though earlier partitions have been lost. Note that intra prediction" \
1837 " is still done over the partition boundary.", 0, AV_OPT_TYPE_CONST, {.i64 = VPX_ERROR_RESILIENT_PARTITIONS}, 0, 0, VE, "er"}, \
1838 { "crf", "Select the quality for constant quality mode", offsetof(VPxContext, crf), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 63, VE }, \
1839 { "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 }, \
1840 { "drop-threshold", "Frame drop threshold", offsetof(VPxContext, drop_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, VE }, \
1841 { "noise-sensitivity", "Noise sensitivity", OFFSET(noise_sensitivity), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 4, VE}, \
1842 { "undershoot-pct", "Datarate undershoot (min) target (%)", OFFSET(rc_undershoot_pct), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 100, VE }, \
1843 { "overshoot-pct", "Datarate overshoot (max) target (%)", OFFSET(rc_overshoot_pct), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1000, VE }, \
1844 { "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}, \
1846 #define LEGACY_OPTIONS \
1847 {"speed", "", offsetof(VPxContext, cpu_used), AV_OPT_TYPE_INT, {.i64 = 1}, -16, 16, VE}, \
1848 {"quality", "", offsetof(VPxContext, deadline), AV_OPT_TYPE_INT, {.i64 = VPX_DL_GOOD_QUALITY}, INT_MIN, INT_MAX, VE, "quality"}, \
1849 {"vp8flags", "", offsetof(VPxContext, flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, 0, UINT_MAX, VE, "flags"}, \
1850 {"error_resilient", "enable error resilience", 0, AV_OPT_TYPE_CONST, {.i64 = VP8F_ERROR_RESILIENT}, INT_MIN, INT_MAX, VE, "flags"}, \
1851 {"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"}, \
1852 {"arnr_max_frames", "altref noise reduction max frame count", offsetof(VPxContext, arnr_max_frames), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 15, VE}, \
1853 {"arnr_strength", "altref noise reduction filter strength", offsetof(VPxContext, arnr_strength), AV_OPT_TYPE_INT, {.i64 = 3}, 0, 6, VE}, \
1854 {"arnr_type", "altref noise reduction filter type", offsetof(VPxContext, arnr_type), AV_OPT_TYPE_INT, {.i64 = 3}, 1, 3, VE}, \
1855 {"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}, \
1856 {"sharpness", "Increase sharpness at the expense of lower PSNR", offsetof(VPxContext, sharpness), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 7, VE},
1858 #if CONFIG_LIBVPX_VP8_ENCODER
1859 static const AVOption vp8_options[] = {
1861 {
"auto-alt-ref",
"Enable use of alternate reference "
1869 #if CONFIG_LIBVPX_VP9_ENCODER
1870 static const AVOption vp9_options[] = {
1872 {
"auto-alt-ref",
"Enable use of alternate reference "
1876 {
"tile-columns",
"Number of tile columns to use, log2",
OFFSET(tile_columns),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6,
VE},
1878 {
"frame-parallel",
"Enable frame parallel decodability features",
OFFSET(frame_parallel),
AV_OPT_TYPE_BOOL,{.i64 = -1}, -1, 1,
VE},
1879 #if VPX_ENCODER_ABI_VERSION >= 12
1880 {
"aq-mode",
"adaptive quantization mode",
OFFSET(aq_mode),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 4,
VE,
"aq_mode"},
1882 {
"aq-mode",
"adaptive quantization mode",
OFFSET(aq_mode),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 3,
VE,
"aq_mode"},
1885 {
"variance",
"Variance based Aq", 0,
AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0,
VE,
"aq_mode" },
1886 {
"complexity",
"Complexity based Aq", 0,
AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0,
VE,
"aq_mode" },
1888 #if VPX_ENCODER_ABI_VERSION >= 12
1892 #ifdef VPX_CTRL_VP9E_SET_ROW_MT
1895 #ifdef VPX_CTRL_VP9E_SET_TUNE_CONTENT
1896 #if VPX_ENCODER_ABI_VERSION >= 14
1897 {
"tune-content",
"Tune content type",
OFFSET(tune_content),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 2,
VE,
"tune_content" },
1899 {
"tune-content",
"Tune content type",
OFFSET(tune_content),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1,
VE,
"tune_content" },
1901 {
"default",
"Regular video content", 0,
AV_OPT_TYPE_CONST, {.i64 = 0}, 0, 0,
VE,
"tune_content" },
1902 {
"screen",
"Screen capture content", 0,
AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0,
VE,
"tune_content" },
1903 #if VPX_ENCODER_ABI_VERSION >= 14
1904 {
"film",
"Film content; improves grain retention", 0,
AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0,
VE,
"tune_content" },
1907 #if VPX_ENCODER_ABI_VERSION >= 14
1908 {
"corpus-complexity",
"corpus vbr complexity midpoint",
OFFSET(corpus_complexity),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 10000,
VE },
1910 #ifdef VPX_CTRL_VP9E_SET_TPL
1918 #undef COMMON_OPTIONS
1919 #undef LEGACY_OPTIONS
1926 {
"keyint_min",
"-1" },
1930 #if CONFIG_LIBVPX_VP8_ENCODER
1933 return vpx_init(avctx, vpx_codec_vp8_cx());
1936 static const AVClass class_vp8 = {
1939 .option = vp8_options,
1950 .priv_data_size =
sizeof(VPxContext),
1956 .p.priv_class = &class_vp8,
1958 .p.wrapper_name =
"libvpx",
1962 #if CONFIG_LIBVPX_VP9_ENCODER
1965 return vpx_init(avctx, vpx_codec_vp9_cx());
1968 static const AVClass class_vp9 = {
1971 .option = vp9_options,
1976 .
p.
name =
"libvpx-vp9",
1983 .p.priv_class = &class_vp9,
1984 .p.wrapper_name =
"libvpx",
1985 .priv_data_size =
sizeof(VPxContext),