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>
66 typedef struct VPxEncoderContext {
68 struct vpx_codec_ctx encoder;
69 struct vpx_image rawimg;
70 struct vpx_codec_ctx encoder_alpha;
71 struct vpx_image rawimg_alpha;
73 struct vpx_fixed_buf twopass_stats;
86 #define VP8F_ERROR_RESILIENT 0x00000001
87 #define VP8F_AUTO_ALT_REF 0x00000002
128 #if CONFIG_LIBVPX_VP9_ENCODER && defined(VPX_CTRL_VP9E_SET_MAX_INTER_BITRATE_PCT)
129 vpx_svc_ref_frame_config_t ref_frame_config;
135 [VP8E_SET_CPUUSED] =
"VP8E_SET_CPUUSED",
136 [VP8E_SET_ENABLEAUTOALTREF] =
"VP8E_SET_ENABLEAUTOALTREF",
137 [VP8E_SET_NOISE_SENSITIVITY] =
"VP8E_SET_NOISE_SENSITIVITY",
138 [VP8E_SET_STATIC_THRESHOLD] =
"VP8E_SET_STATIC_THRESHOLD",
139 [VP8E_SET_TOKEN_PARTITIONS] =
"VP8E_SET_TOKEN_PARTITIONS",
140 [VP8E_SET_ARNR_MAXFRAMES] =
"VP8E_SET_ARNR_MAXFRAMES",
141 [VP8E_SET_ARNR_STRENGTH] =
"VP8E_SET_ARNR_STRENGTH",
142 [VP8E_SET_ARNR_TYPE] =
"VP8E_SET_ARNR_TYPE",
143 [VP8E_SET_TUNING] =
"VP8E_SET_TUNING",
144 [VP8E_SET_CQ_LEVEL] =
"VP8E_SET_CQ_LEVEL",
145 [VP8E_SET_MAX_INTRA_BITRATE_PCT] =
"VP8E_SET_MAX_INTRA_BITRATE_PCT",
146 [VP8E_SET_SHARPNESS] =
"VP8E_SET_SHARPNESS",
147 [VP8E_SET_TEMPORAL_LAYER_ID] =
"VP8E_SET_TEMPORAL_LAYER_ID",
148 #if CONFIG_LIBVPX_VP9_ENCODER
149 [VP9E_SET_LOSSLESS] =
"VP9E_SET_LOSSLESS",
150 [VP9E_SET_TILE_COLUMNS] =
"VP9E_SET_TILE_COLUMNS",
151 [VP9E_SET_TILE_ROWS] =
"VP9E_SET_TILE_ROWS",
152 [VP9E_SET_FRAME_PARALLEL_DECODING] =
"VP9E_SET_FRAME_PARALLEL_DECODING",
153 [VP9E_SET_AQ_MODE] =
"VP9E_SET_AQ_MODE",
154 [VP9E_SET_COLOR_SPACE] =
"VP9E_SET_COLOR_SPACE",
155 [VP9E_SET_SVC_LAYER_ID] =
"VP9E_SET_SVC_LAYER_ID",
156 #if VPX_ENCODER_ABI_VERSION >= 12
157 [VP9E_SET_SVC_PARAMETERS] =
"VP9E_SET_SVC_PARAMETERS",
158 [VP9E_SET_SVC_REF_FRAME_CONFIG] =
"VP9E_SET_SVC_REF_FRAME_CONFIG",
160 [VP9E_SET_SVC] =
"VP9E_SET_SVC",
161 #if VPX_ENCODER_ABI_VERSION >= 11
162 [VP9E_SET_COLOR_RANGE] =
"VP9E_SET_COLOR_RANGE",
164 #if VPX_ENCODER_ABI_VERSION >= 12
165 [VP9E_SET_TARGET_LEVEL] =
"VP9E_SET_TARGET_LEVEL",
166 [VP9E_GET_LEVEL] =
"VP9E_GET_LEVEL",
168 #ifdef VPX_CTRL_VP9E_SET_ROW_MT
169 [VP9E_SET_ROW_MT] =
"VP9E_SET_ROW_MT",
171 #ifdef VPX_CTRL_VP9E_SET_TUNE_CONTENT
172 [VP9E_SET_TUNE_CONTENT] =
"VP9E_SET_TUNE_CONTENT",
174 #ifdef VPX_CTRL_VP9E_SET_TPL
175 [VP9E_SET_TPL] =
"VP9E_SET_TPL",
183 const char *
error = vpx_codec_error(&
ctx->encoder);
184 const char *detail = vpx_codec_error_detail(&
ctx->encoder);
192 const struct vpx_codec_enc_cfg *cfg)
200 " %*s%u\n %*s%u\n %*s%u\n %*s%u\n %*s%u\n"
204 " %*s{%u/%u}\n %*s%u\n %*s%d\n %*s%u\n",
205 width,
"g_usage:", cfg->g_usage,
206 width,
"g_threads:", cfg->g_threads,
207 width,
"g_profile:", cfg->g_profile,
208 width,
"g_w:", cfg->g_w,
209 width,
"g_h:", cfg->g_h,
211 width,
"g_bit_depth:", cfg->g_bit_depth,
212 width,
"g_input_bit_depth:", cfg->g_input_bit_depth,
214 width,
"g_timebase:", cfg->g_timebase.num, cfg->g_timebase.den,
215 width,
"g_error_resilient:", cfg->g_error_resilient,
216 width,
"g_pass:", cfg->g_pass,
217 width,
"g_lag_in_frames:", cfg->g_lag_in_frames);
219 " %*s%u\n %*s%u\n %*s%u\n %*s%u\n"
221 width,
"rc_dropframe_thresh:", cfg->rc_dropframe_thresh,
222 width,
"rc_resize_allowed:", cfg->rc_resize_allowed,
223 width,
"rc_resize_up_thresh:", cfg->rc_resize_up_thresh,
224 width,
"rc_resize_down_thresh:", cfg->rc_resize_down_thresh,
225 width,
"rc_end_usage:", cfg->rc_end_usage,
226 width,
"rc_twopass_stats_in:", cfg->rc_twopass_stats_in.buf, cfg->rc_twopass_stats_in.sz,
227 width,
"rc_target_bitrate:", cfg->rc_target_bitrate);
230 width,
"rc_min_quantizer:", cfg->rc_min_quantizer,
231 width,
"rc_max_quantizer:", cfg->rc_max_quantizer);
234 width,
"rc_undershoot_pct:", cfg->rc_undershoot_pct,
235 width,
"rc_overshoot_pct:", cfg->rc_overshoot_pct);
236 av_log(avctx,
level,
"temporal layering settings\n"
237 " %*s%u\n",
width,
"ts_number_layers:", cfg->ts_number_layers);
240 "\n %*s",
width,
"ts_target_bitrate:");
241 for (
i = 0;
i < VPX_TS_MAX_LAYERS;
i++)
243 "%u ", cfg->ts_target_bitrate[
i]);
245 #if (VPX_ENCODER_ABI_VERSION >= 12) && CONFIG_LIBVPX_VP9_ENCODER
248 "\n %*s",
width,
"layer_target_bitrate:");
249 for (
i = 0;
i < VPX_TS_MAX_LAYERS;
i++)
251 "%u ", cfg->layer_target_bitrate[
i]);
256 "\n %*s",
width,
"ts_rate_decimator:");
257 for (
i = 0;
i < VPX_TS_MAX_LAYERS;
i++)
261 "\n %*s%u\n",
width,
"ts_periodicity:", cfg->ts_periodicity);
263 "\n %*s",
width,
"ts_layer_id:");
264 for (
i = 0;
i < VPX_TS_MAX_PERIODICITY;
i++)
268 " %*s%u\n %*s%u\n %*s%u\n",
269 width,
"rc_buf_sz:", cfg->rc_buf_sz,
270 width,
"rc_buf_initial_sz:", cfg->rc_buf_initial_sz,
271 width,
"rc_buf_optimal_sz:", cfg->rc_buf_optimal_sz);
272 av_log(avctx,
level,
"2 pass rate control settings\n"
273 " %*s%u\n %*s%u\n %*s%u\n",
274 width,
"rc_2pass_vbr_bias_pct:", cfg->rc_2pass_vbr_bias_pct,
275 width,
"rc_2pass_vbr_minsection_pct:", cfg->rc_2pass_vbr_minsection_pct,
276 width,
"rc_2pass_vbr_maxsection_pct:", cfg->rc_2pass_vbr_maxsection_pct);
277 #if VPX_ENCODER_ABI_VERSION >= 14
279 width,
"rc_2pass_vbr_corpus_complexity:", cfg->rc_2pass_vbr_corpus_complexity);
282 " %*s%d\n %*s%u\n %*s%u\n",
283 width,
"kf_mode:", cfg->kf_mode,
284 width,
"kf_min_dist:", cfg->kf_min_dist,
285 width,
"kf_max_dist:", cfg->kf_max_dist);
319 enum vp8e_enc_control_id
id,
int val)
329 res = vpx_codec_control(&
ctx->encoder,
id,
val);
330 if (res != VPX_CODEC_OK) {
336 return res == VPX_CODEC_OK ? 0 :
AVERROR(EINVAL);
339 #if VPX_ENCODER_ABI_VERSION >= 12
341 enum vp8e_enc_control_id
id,
int *
val)
351 res = vpx_codec_control(&
ctx->encoder,
id,
val);
352 if (res != VPX_CODEC_OK) {
358 return res == VPX_CODEC_OK ? 0 :
AVERROR(EINVAL);
366 #if VPX_ENCODER_ABI_VERSION >= 12
370 if (!codecctl_intp(avctx, VP9E_GET_LEVEL, &level_out))
377 vpx_codec_destroy(&
ctx->encoder);
379 vpx_codec_destroy(&
ctx->encoder_alpha);
392 char *saveptr =
NULL;
395 while (token && dest_idx < max_entries) {
396 dest[dest_idx++] = strtoul(token,
NULL, 10);
401 #if CONFIG_LIBVPX_VP9_ENCODER && defined(VPX_CTRL_VP9E_SET_MAX_INTER_BITRATE_PCT)
402 static void vp8_ts_parse_int64_array(int64_t *dest,
char *
value,
size_t value_len,
int max_entries)
405 char *saveptr =
NULL;
408 while (token && dest_idx < max_entries) {
409 dest[dest_idx++] = strtoull(token,
NULL, 10);
416 int *layer_flags,
int *flag_periodicity)
418 switch (layering_mode) {
423 static const int ids[2] = { 0, 1 };
424 cfg->ts_periodicity = 2;
425 *flag_periodicity = 2;
426 cfg->ts_number_layers = 2;
427 cfg->ts_rate_decimator[0] = 2;
428 cfg->ts_rate_decimator[1] = 1;
429 memcpy(cfg->ts_layer_id, ids,
sizeof(ids));
432 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
433 VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
435 VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_GF |
436 VP8_EFLAG_NO_UPD_LAST |
437 VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_REF_GF;
447 static const int ids[4] = { 0, 2, 1, 2 };
448 cfg->ts_periodicity = 4;
449 *flag_periodicity = 4;
450 cfg->ts_number_layers = 3;
451 cfg->ts_rate_decimator[0] = 4;
452 cfg->ts_rate_decimator[1] = 2;
453 cfg->ts_rate_decimator[2] = 1;
454 memcpy(cfg->ts_layer_id, ids,
sizeof(ids));
461 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
462 VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
464 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
465 VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
466 VP8_EFLAG_NO_UPD_ARF;
468 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
469 VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
471 VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_REF_ARF |
472 VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
473 VP8_EFLAG_NO_UPD_ARF;
482 static const int ids[4] = { 0, 2, 1, 2 };
483 cfg->ts_periodicity = 4;
484 *flag_periodicity = 4;
485 cfg->ts_number_layers = 3;
486 cfg->ts_rate_decimator[0] = 4;
487 cfg->ts_rate_decimator[1] = 2;
488 cfg->ts_rate_decimator[2] = 1;
489 memcpy(cfg->ts_layer_id, ids,
sizeof(ids));
495 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
496 VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
498 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
499 VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF;
501 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
502 VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
504 VP8_EFLAG_NO_REF_LAST |
505 VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
506 VP8_EFLAG_NO_UPD_ARF;
522 size_t value_len = strlen(
value);
523 int ts_layering_mode = 0;
528 if (!strcmp(
key,
"ts_number_layers"))
529 enccfg->ts_number_layers = strtoul(
value, &
value, 10);
530 else if (!strcmp(
key,
"ts_target_bitrate")) {
533 #if (VPX_ENCODER_ABI_VERSION >= 12) && CONFIG_LIBVPX_VP9_ENCODER
537 }
else if (!strcmp(
key,
"ts_rate_decimator")) {
539 }
else if (!strcmp(
key,
"ts_periodicity")) {
540 enccfg->ts_periodicity = strtoul(
value, &
value, 10);
541 }
else if (!strcmp(
key,
"ts_layer_id")) {
543 }
else if (!strcmp(
key,
"ts_layering_mode")) {
548 #if (VPX_ENCODER_ABI_VERSION >= 12) && CONFIG_LIBVPX_VP9_ENCODER
549 enccfg->temporal_layering_mode = VP9E_TEMPORAL_LAYERING_MODE_BYPASS;
550 enccfg->ss_number_layers = 1;
552 if (ts_layering_mode) {
562 #if CONFIG_LIBVPX_VP9_ENCODER && defined(VPX_CTRL_VP9E_SET_MAX_INTER_BITRATE_PCT)
563 static int vpx_ref_frame_config_set_value(vpx_svc_ref_frame_config_t *ref_frame_config,
564 int ss_number_layers,
char *
key,
char *
value)
566 size_t value_len = strlen(
value);
571 if (!strcmp(
key,
"rfc_update_buffer_slot")) {
573 }
else if (!strcmp(
key,
"rfc_update_last")) {
575 }
else if (!strcmp(
key,
"rfc_update_golden")) {
577 }
else if (!strcmp(
key,
"rfc_update_alt_ref")) {
579 }
else if (!strcmp(
key,
"rfc_lst_fb_idx")) {
581 }
else if (!strcmp(
key,
"rfc_gld_fb_idx")) {
583 }
else if (!strcmp(
key,
"rfc_alt_fb_idx")) {
585 }
else if (!strcmp(
key,
"rfc_reference_last")) {
587 }
else if (!strcmp(
key,
"rfc_reference_golden")) {
589 }
else if (!strcmp(
key,
"rfc_reference_alt_ref")) {
591 }
else if (!strcmp(
key,
"rfc_reference_duration")) {
592 vp8_ts_parse_int64_array(ref_frame_config->duration,
value, value_len, ss_number_layers);
598 static int vpx_parse_ref_frame_config_element(vpx_svc_ref_frame_config_t *ref_frame_config,
599 int ss_number_layers,
const char **
buf)
601 const char key_val_sep[] =
"=";
602 const char pairs_sep[] =
":";
607 if (
key && *
key && strspn(*
buf, key_val_sep)) {
613 ret = vpx_ref_frame_config_set_value(ref_frame_config, ss_number_layers,
key,
val);
623 static int vpx_parse_ref_frame_config(vpx_svc_ref_frame_config_t *ref_frame_config,
624 int ss_number_layers,
const char *
str)
630 vpx_parse_ref_frame_config_element(ref_frame_config, ss_number_layers, &
str);
642 #if CONFIG_LIBVPX_VP9_ENCODER
644 struct vpx_codec_enc_cfg *enccfg, vpx_codec_flags_t *
flags,
645 vpx_img_fmt_t *img_fmt)
649 enccfg->g_bit_depth = enccfg->g_input_bit_depth =
desc->comp[0].depth;
653 enccfg->g_profile = 0;
654 *img_fmt = VPX_IMG_FMT_I420;
657 enccfg->g_profile = 1;
658 *img_fmt = VPX_IMG_FMT_I422;
661 enccfg->g_profile = 1;
662 *img_fmt = VPX_IMG_FMT_I440;
665 ctx->vpx_cs = VPX_CS_SRGB;
667 enccfg->g_profile = 1;
668 *img_fmt = VPX_IMG_FMT_I444;
672 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {
673 enccfg->g_profile = 2;
674 *img_fmt = VPX_IMG_FMT_I42016;
675 *
flags |= VPX_CODEC_USE_HIGHBITDEPTH;
681 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {
682 enccfg->g_profile = 3;
683 *img_fmt = VPX_IMG_FMT_I42216;
684 *
flags |= VPX_CODEC_USE_HIGHBITDEPTH;
690 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {
691 enccfg->g_profile = 3;
692 *img_fmt = VPX_IMG_FMT_I44016;
693 *
flags |= VPX_CODEC_USE_HIGHBITDEPTH;
699 ctx->vpx_cs = VPX_CS_SRGB;
702 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {
703 enccfg->g_profile = 3;
704 *img_fmt = VPX_IMG_FMT_I44416;
705 *
flags |= VPX_CODEC_USE_HIGHBITDEPTH;
718 enum vpx_color_space vpx_cs;
722 vpx_cs =
ctx->vpx_cs;
742 #if VPX_ENCODER_ABI_VERSION >= 11
745 enum vpx_color_range vpx_cr;
765 struct vpx_codec_enc_cfg *enccfg)
769 avctx->
bit_rate = enccfg->rc_target_bitrate * 1000;
770 if (enccfg->rc_end_usage == VPX_CQ) {
772 "Bitrate not specified for constrained quality mode, using default of %dkbit/sec\n",
773 enccfg->rc_target_bitrate);
775 enccfg->rc_end_usage = VPX_CQ;
778 "Neither bitrate nor constrained quality specified, using default CRF of %d and bitrate of %dkbit/sec\n",
779 ctx->crf, enccfg->rc_target_bitrate);
784 #if CONFIG_LIBVPX_VP9_ENCODER
790 struct vpx_codec_enc_cfg *enccfg)
794 if (enccfg->rc_end_usage != VPX_Q &&
ctx->lossless < 0) {
795 enccfg->rc_end_usage = VPX_Q;
798 "Neither bitrate nor constrained quality specified, using default CRF of %d\n",
809 struct vpx_codec_enc_cfg *enccfg)
812 #if CONFIG_LIBVPX_VP9_ENCODER
814 set_vp9_defaults(avctx, enccfg);
822 const struct vpx_codec_iface *iface)
825 struct vpx_codec_enc_cfg enccfg = { 0 };
826 struct vpx_codec_enc_cfg enccfg_alpha;
830 vpx_img_fmt_t img_fmt = VPX_IMG_FMT_I420;
831 #if CONFIG_LIBVPX_VP9_ENCODER
832 vpx_codec_caps_t codec_caps = vpx_codec_get_caps(iface);
833 vpx_svc_extra_cfg_t svc_params;
843 if ((res = vpx_codec_enc_config_default(iface, &enccfg, 0)) != VPX_CODEC_OK) {
845 vpx_codec_err_to_string(res));
849 #if CONFIG_LIBVPX_VP9_ENCODER
864 enccfg.g_w = avctx->
width;
865 enccfg.g_h = avctx->
height;
870 enccfg.g_lag_in_frames=
ctx->lag_in_frames;
873 enccfg.g_pass = VPX_RC_FIRST_PASS;
875 enccfg.g_pass = VPX_RC_LAST_PASS;
877 enccfg.g_pass = VPX_RC_ONE_PASS;
881 enccfg.rc_end_usage = VPX_CBR;
882 }
else if (
ctx->crf >= 0) {
883 enccfg.rc_end_usage = VPX_CQ;
884 #if CONFIG_LIBVPX_VP9_ENCODER
886 enccfg.rc_end_usage = VPX_Q;
893 #if CONFIG_LIBVPX_VP9_ENCODER
894 enccfg.ss_target_bitrate[0] = enccfg.rc_target_bitrate;
902 enccfg.rc_min_quantizer =
903 enccfg.rc_max_quantizer = 0;
905 if (avctx->
qmin >= 0)
906 enccfg.rc_min_quantizer = avctx->
qmin;
907 if (avctx->
qmax >= 0)
908 enccfg.rc_max_quantizer = avctx->
qmax;
911 if (enccfg.rc_end_usage == VPX_CQ
913 || enccfg.rc_end_usage == VPX_Q
916 if (
ctx->crf < enccfg.rc_min_quantizer ||
ctx->crf > enccfg.rc_max_quantizer) {
918 "CQ level %d must be between minimum and maximum quantizer value (%d-%d)\n",
919 ctx->crf, enccfg.rc_min_quantizer, enccfg.rc_max_quantizer);
924 #if FF_API_PRIVATE_OPT
930 enccfg.rc_dropframe_thresh =
ctx->drop_threshold;
935 enccfg.rc_2pass_vbr_minsection_pct =
938 enccfg.rc_2pass_vbr_maxsection_pct =
940 #if CONFIG_LIBVPX_VP9_ENCODER
942 #if VPX_ENCODER_ABI_VERSION >= 14
943 if (
ctx->corpus_complexity >= 0)
944 enccfg.rc_2pass_vbr_corpus_complexity =
ctx->corpus_complexity;
953 enccfg.rc_buf_initial_sz =
955 enccfg.rc_buf_optimal_sz = enccfg.rc_buf_sz * 5 / 6;
956 if (
ctx->rc_undershoot_pct >= 0)
957 enccfg.rc_undershoot_pct =
ctx->rc_undershoot_pct;
958 if (
ctx->rc_overshoot_pct >= 0)
959 enccfg.rc_overshoot_pct =
ctx->rc_overshoot_pct;
965 enccfg.kf_max_dist = avctx->
gop_size;
967 if (enccfg.g_pass == VPX_RC_FIRST_PASS)
968 enccfg.g_lag_in_frames = 0;
969 else if (enccfg.g_pass == VPX_RC_LAST_PASS) {
970 int decode_size, ret;
977 ctx->twopass_stats.sz = strlen(avctx->
stats_in) * 3 / 4;
982 ctx->twopass_stats.sz);
983 ctx->twopass_stats.sz = 0;
987 ctx->twopass_stats.sz);
988 if (decode_size < 0) {
993 ctx->twopass_stats.sz = decode_size;
994 enccfg.rc_twopass_stats_in =
ctx->twopass_stats;
1001 enccfg.g_profile = avctx->
profile;
1008 "Error parsing option '%s = %s'.\n",
1014 res = vpx_codec_enc_init(&
ctx->encoder, iface, &enccfg,
flags);
1015 if (res != VPX_CODEC_OK) {
1019 #if CONFIG_LIBVPX_VP9_ENCODER
1021 memset(&svc_params, 0,
sizeof(svc_params));
1022 for (
int i = 0;
i < enccfg.ts_number_layers; ++
i) {
1023 svc_params.max_quantizers[
i] = enccfg.rc_max_quantizer;
1024 svc_params.min_quantizers[
i] = enccfg.rc_min_quantizer;
1026 svc_params.scaling_factor_num[0] = enccfg.g_h;
1027 svc_params.scaling_factor_den[0] = enccfg.g_h;
1028 #if VPX_ENCODER_ABI_VERSION >= 12
1030 codecctl_intp(avctx, VP9E_SET_SVC_PARAMETERS, (
int *)&svc_params);
1034 if (
ctx->is_alpha) {
1035 enccfg_alpha = enccfg;
1036 res = vpx_codec_enc_init(&
ctx->encoder_alpha, iface, &enccfg_alpha,
flags);
1037 if (res != VPX_CODEC_OK) {
1047 ctx->auto_alt_ref = 1;
1048 if (
ctx->auto_alt_ref >= 0)
1051 if (
ctx->arnr_max_frames >= 0)
1053 if (
ctx->arnr_strength >= 0)
1055 if (
ctx->arnr_type >= 0)
1061 av_log(avctx,
AV_LOG_ERROR,
"Transparency encoding with auto_alt_ref does not work\n");
1065 if (
ctx->sharpness >= 0)
1069 #if FF_API_PRIVATE_OPT
1075 codecctl_int(avctx, VP8E_SET_NOISE_SENSITIVITY,
ctx->noise_sensitivity);
1081 if (
ctx->max_intra_rate >= 0)
1082 codecctl_int(avctx, VP8E_SET_MAX_INTRA_BITRATE_PCT,
ctx->max_intra_rate);
1084 #if CONFIG_LIBVPX_VP9_ENCODER
1086 if (
ctx->lossless >= 0)
1088 if (
ctx->tile_columns >= 0)
1090 if (
ctx->tile_rows >= 0)
1092 if (
ctx->frame_parallel >= 0)
1093 codecctl_int(avctx, VP9E_SET_FRAME_PARALLEL_DECODING,
ctx->frame_parallel);
1094 if (
ctx->aq_mode >= 0)
1096 set_colorspace(avctx);
1097 #if VPX_ENCODER_ABI_VERSION >= 11
1100 #if VPX_ENCODER_ABI_VERSION >= 12
1103 #ifdef VPX_CTRL_VP9E_SET_ROW_MT
1104 if (
ctx->row_mt >= 0)
1107 #ifdef VPX_CTRL_VP9E_SET_TUNE_CONTENT
1108 if (
ctx->tune_content >= 0)
1111 #ifdef VPX_CTRL_VP9E_SET_TPL
1112 if (
ctx->tpl_model >= 0)
1121 vpx_img_wrap(&
ctx->rawimg, img_fmt, avctx->
width, avctx->
height, 1,
1123 #if CONFIG_LIBVPX_VP9_ENCODER
1125 ctx->rawimg.bit_depth = enccfg.g_bit_depth;
1132 if (enccfg.rc_end_usage == VPX_CBR ||
1133 enccfg.g_pass != VPX_RC_ONE_PASS) {
1144 const struct vpx_codec_cx_pkt *
src,
1145 const struct vpx_codec_cx_pkt *src_alpha,
1148 dst->
pts =
src->data.frame.pts;
1150 dst->
flags =
src->data.frame.flags;
1151 dst->
sz =
src->data.frame.sz;
1152 dst->
buf =
src->data.frame.buf;
1155 if (!(dst->
flags & VPX_FRAME_IS_INVISIBLE)) {
1158 if (
ctx->have_sse) {
1163 memcpy(dst->
sse,
ctx->sse,
sizeof(dst->
sse));
1170 dst->
buf_alpha = src_alpha->data.frame.buf;
1171 dst->
sz_alpha = src_alpha->data.frame.sz;
1194 #if FF_API_CODED_FRAME
1201 if (!!(cx_frame->
flags & VPX_FRAME_IS_KEY)) {
1203 #if FF_API_CODED_FRAME
1211 #if FF_API_CODED_FRAME
1219 cx_frame->
have_sse ? 3 : 0, pict_type);
1224 #if FF_API_CODED_FRAME && FF_API_ERROR_FRAME
1232 for (
i = 0;
i < 3; ++
i) {
1265 const struct vpx_codec_cx_pkt *
pkt;
1266 const struct vpx_codec_cx_pkt *pkt_alpha =
NULL;
1267 const void *iter =
NULL;
1268 const void *iter_alpha =
NULL;
1271 if (
ctx->coded_frame_list) {
1277 ctx->coded_frame_list = cx_frame->
next;
1283 while ((
pkt = vpx_codec_get_cx_data(&
ctx->encoder, &iter)) &&
1285 (pkt_alpha = vpx_codec_get_cx_data(&
ctx->encoder_alpha, &iter_alpha)))) {
1286 switch (
pkt->kind) {
1287 case VPX_CODEC_CX_FRAME_PKT:
1303 "Frame queue element alloc failed\n");
1309 if (!cx_frame->
buf) {
1317 if (
ctx->is_alpha) {
1326 memcpy(cx_frame->
buf_alpha, pkt_alpha->data.frame.buf, pkt_alpha->data.frame.sz);
1331 case VPX_CODEC_STATS_PKT: {
1332 struct vpx_fixed_buf *
stats = &
ctx->twopass_stats;
1336 pkt->
data.twopass_stats.sz)) < 0) {
1346 case VPX_CODEC_PSNR_PKT:
1354 case VPX_CODEC_CUSTOM_PKT:
1364 vpx_roi_map_t *roi_map,
int block_size,
int segment_cnt)
1369 #define MAX_DELTA_Q 63
1384 memset(roi_map, 0,
sizeof(*roi_map));
1395 if (!self_size || sd->
size % self_size) {
1399 nb_rois = sd->
size / self_size;
1405 for (
int i = 0;
i < nb_rois;
i++) {
1419 if (!segment_mapping[mapping_index]) {
1420 if (segment_id == segment_cnt) {
1422 "ROI only supports %d segments (and segment 0 is reserved for non-ROIs), skipping the left ones.\n",
1427 segment_mapping[mapping_index] = segment_id + 1;
1428 roi_map->delta_q[segment_id] =
delta_q;
1433 roi_map->rows = (frame_height + block_size - 1) / block_size;
1434 roi_map->cols = (frame_width + block_size - 1) / block_size;
1435 roi_map->roi_map =
av_mallocz_array(roi_map->rows * roi_map->cols,
sizeof(*roi_map->roi_map));
1436 if (!roi_map->roi_map) {
1444 for (
int i = nb_rois - 1;
i >= 0;
i--) {
1447 int starty, endy, startx, endx;
1451 starty =
av_clip(roi->
top / block_size, 0, roi_map->rows);
1452 endy =
av_clip((roi->
bottom + block_size - 1) / block_size, 0, roi_map->rows);
1453 startx =
av_clip(roi->
left / block_size, 0, roi_map->cols);
1454 endx =
av_clip((roi->
right + block_size - 1) / block_size, 0, roi_map->cols);
1460 if (mapping_value) {
1461 for (
int y = starty; y < endy; y++)
1462 for (
int x = startx; x < endx; x++)
1463 roi_map->roi_map[x + y * roi_map->cols] = mapping_value - 1;
1474 #ifdef VPX_CTRL_VP9E_SET_ROI_MAP
1475 int version = vpx_codec_version();
1478 int patch = VPX_VERSION_PATCH(
version);
1481 vpx_roi_map_t roi_map;
1482 const int segment_cnt = 8;
1483 const int block_size = 8;
1486 if (
ctx->aq_mode > 0 ||
ctx->cpu_used < 5 ||
ctx->deadline != VPX_DL_REALTIME) {
1487 if (!
ctx->roi_warned) {
1488 ctx->roi_warned = 1;
1490 "and deadline is REALTIME, so skipping ROI.\n");
1495 ret =
set_roi_map(avctx, sd, frame_width, frame_height, &roi_map, block_size, segment_cnt);
1501 memset(roi_map.ref_frame, -1,
sizeof(roi_map.ref_frame));
1503 if (vpx_codec_control(&
ctx->encoder, VP9E_SET_ROI_MAP, &roi_map)) {
1512 if (!
ctx->roi_warned) {
1513 ctx->roi_warned = 1;
1514 av_log(avctx,
AV_LOG_WARNING,
"ROI is not supported, please upgrade libvpx to version >= 1.8.1. "
1515 "You may need to rebuild ffmpeg.\n");
1522 vpx_roi_map_t roi_map;
1523 const int segment_cnt = 4;
1524 const int block_size = 16;
1527 int ret =
set_roi_map(avctx, sd, frame_width, frame_height, &roi_map, block_size, segment_cnt);
1533 if (vpx_codec_control(&
ctx->encoder, VP8E_SET_ROI_MAP, &roi_map)) {
1545 struct vpx_image *rawimg_alpha = &
ctx->rawimg_alpha;
1546 unsigned char **
planes = rawimg_alpha->planes;
1547 int *
stride = rawimg_alpha->stride;
1549 if (!
planes[VPX_PLANE_U] ||
1551 width != (
int)rawimg_alpha->d_w ||
1552 height != (
int)rawimg_alpha->d_h) {
1556 vpx_img_wrap(rawimg_alpha, VPX_IMG_FMT_I420,
width,
height, 1,
1574 struct vpx_image *rawimg =
NULL;
1575 struct vpx_image *rawimg_alpha =
NULL;
1576 int64_t timestamp = 0;
1577 int res, coded_size;
1578 vpx_enc_frame_flags_t
flags = 0;
1579 const struct vpx_codec_enc_cfg *enccfg =
ctx->encoder.config.enc;
1580 vpx_svc_layer_id_t layer_id;
1581 int layer_id_valid = 0;
1585 rawimg = &
ctx->rawimg;
1586 rawimg->planes[VPX_PLANE_Y] =
frame->
data[0];
1587 rawimg->planes[VPX_PLANE_U] =
frame->
data[1];
1588 rawimg->planes[VPX_PLANE_V] =
frame->
data[2];
1592 if (
ctx->is_alpha) {
1593 rawimg_alpha = &
ctx->rawimg_alpha;
1597 rawimg_alpha->planes[VPX_PLANE_Y] =
frame->
data[3];
1601 #if VPX_IMAGE_ABI_VERSION >= 4
1604 rawimg->range = VPX_CR_STUDIO_RANGE;
1607 rawimg->range = VPX_CR_FULL_RANGE;
1612 flags |= VPX_EFLAG_FORCE_KF;
1619 memset(&layer_id, 0,
sizeof(layer_id));
1623 layer_id.temporal_layer_id = strtoul(en->
value,
NULL, 10);
1624 #ifdef VPX_CTRL_VP9E_SET_MAX_INTER_BITRATE_PCT
1625 layer_id.temporal_layer_id_per_spatial[0] = layer_id.temporal_layer_id;
1629 #if CONFIG_LIBVPX_VP9_ENCODER && defined(VPX_CTRL_VP9E_SET_MAX_INTER_BITRATE_PCT)
1634 int ret = vpx_parse_ref_frame_config(&
ctx->ref_frame_config,
1635 enccfg->ss_number_layers, en->
value);
1638 "Error parsing ref_frame_config option %s.\n", en->
value);
1642 codecctl_intp(avctx, VP9E_SET_SVC_REF_FRAME_CONFIG, (
int *)&
ctx->ref_frame_config);
1645 "Ignoring ref-frame-config for a non-VP9 codec\n");
1662 if (enccfg->ts_number_layers > 1 &&
ctx->ts_layer_flags) {
1663 if (
flags & VPX_EFLAG_FORCE_KF) {
1665 ctx->current_temporal_idx = 0;
1666 flags = VPX_EFLAG_FORCE_KF;
1672 flags |=
ctx->ts_layer_flags[
ctx->current_temporal_idx];
1674 memset(&layer_id, 0,
sizeof(layer_id));
1675 #if VPX_ENCODER_ABI_VERSION >= 12
1676 layer_id.spatial_layer_id = 0;
1678 layer_id.temporal_layer_id = enccfg->ts_layer_id[
ctx->current_temporal_idx];
1679 #ifdef VPX_CTRL_VP9E_SET_MAX_INTER_BITRATE_PCT
1680 layer_id.temporal_layer_id_per_spatial[0] = layer_id.temporal_layer_id;
1685 if (layer_id_valid) {
1687 codecctl_int(avctx, VP8E_SET_TEMPORAL_LAYER_ID, layer_id.temporal_layer_id);
1689 #if CONFIG_LIBVPX_VP9_ENCODER && VPX_ENCODER_ABI_VERSION >= 12
1691 codecctl_intp(avctx, VP9E_SET_SVC_LAYER_ID, (
int *)&layer_id);
1696 res = vpx_codec_encode(&
ctx->encoder, rawimg, timestamp,
1698 if (res != VPX_CODEC_OK) {
1703 if (
ctx->is_alpha) {
1704 res = vpx_codec_encode(&
ctx->encoder_alpha, rawimg_alpha, timestamp,
1706 if (res != VPX_CODEC_OK) {
1724 ctx->twopass_stats.sz);
1725 }
else if (enccfg->ts_number_layers > 1 &&
ctx->ts_layer_flags) {
1726 ctx->current_temporal_idx = (
ctx->current_temporal_idx + 1) % enccfg->ts_periodicity;
1729 *got_packet = !!coded_size;
1733 #define OFFSET(x) offsetof(VPxContext, x)
1734 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1736 #define COMMON_OPTIONS \
1737 { "lag-in-frames", "Number of frames to look ahead for " \
1738 "alternate reference frame selection", OFFSET(lag_in_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \
1739 { "arnr-maxframes", "altref noise reduction max frame count", OFFSET(arnr_max_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \
1740 { "arnr-strength", "altref noise reduction filter strength", OFFSET(arnr_strength), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \
1741 { "arnr-type", "altref noise reduction filter type", OFFSET(arnr_type), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE, "arnr_type"}, \
1742 { "backward", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0, VE, "arnr_type" }, \
1743 { "forward", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0, VE, "arnr_type" }, \
1744 { "centered", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 3}, 0, 0, VE, "arnr_type" }, \
1745 { "tune", "Tune the encoding to a specific scenario", OFFSET(tune), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE, "tune"}, \
1746 { "psnr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VP8_TUNE_PSNR}, 0, 0, VE, "tune"}, \
1747 { "ssim", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VP8_TUNE_SSIM}, 0, 0, VE, "tune"}, \
1748 { "deadline", "Time to spend encoding, in microseconds.", OFFSET(deadline), AV_OPT_TYPE_INT, {.i64 = VPX_DL_GOOD_QUALITY}, INT_MIN, INT_MAX, VE, "quality"}, \
1749 { "best", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_BEST_QUALITY}, 0, 0, VE, "quality"}, \
1750 { "good", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_GOOD_QUALITY}, 0, 0, VE, "quality"}, \
1751 { "realtime", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_REALTIME}, 0, 0, VE, "quality"}, \
1752 { "error-resilient", "Error resilience configuration", OFFSET(error_resilient), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, VE, "er"}, \
1753 { "max-intra-rate", "Maximum I-frame bitrate (pct) 0=unlimited", OFFSET(max_intra_rate), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \
1754 { "default", "Improve resiliency against losses of whole frames", 0, AV_OPT_TYPE_CONST, {.i64 = VPX_ERROR_RESILIENT_DEFAULT}, 0, 0, VE, "er"}, \
1755 { "partitions", "The frame partitions are independently decodable " \
1756 "by the bool decoder, meaning that partitions can be decoded even " \
1757 "though earlier partitions have been lost. Note that intra prediction" \
1758 " is still done over the partition boundary.", 0, AV_OPT_TYPE_CONST, {.i64 = VPX_ERROR_RESILIENT_PARTITIONS}, 0, 0, VE, "er"}, \
1759 { "crf", "Select the quality for constant quality mode", offsetof(VPxContext, crf), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 63, VE }, \
1760 { "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 }, \
1761 { "drop-threshold", "Frame drop threshold", offsetof(VPxContext, drop_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, VE }, \
1762 { "noise-sensitivity", "Noise sensitivity", OFFSET(noise_sensitivity), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 4, VE}, \
1763 { "undershoot-pct", "Datarate undershoot (min) target (%)", OFFSET(rc_undershoot_pct), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 100, VE }, \
1764 { "overshoot-pct", "Datarate overshoot (max) target (%)", OFFSET(rc_overshoot_pct), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1000, VE }, \
1765 { "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}, \
1767 #define LEGACY_OPTIONS \
1768 {"speed", "", offsetof(VPxContext, cpu_used), AV_OPT_TYPE_INT, {.i64 = 1}, -16, 16, VE}, \
1769 {"quality", "", offsetof(VPxContext, deadline), AV_OPT_TYPE_INT, {.i64 = VPX_DL_GOOD_QUALITY}, INT_MIN, INT_MAX, VE, "quality"}, \
1770 {"vp8flags", "", offsetof(VPxContext, flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, 0, UINT_MAX, VE, "flags"}, \
1771 {"error_resilient", "enable error resilience", 0, AV_OPT_TYPE_CONST, {.i64 = VP8F_ERROR_RESILIENT}, INT_MIN, INT_MAX, VE, "flags"}, \
1772 {"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"}, \
1773 {"arnr_max_frames", "altref noise reduction max frame count", offsetof(VPxContext, arnr_max_frames), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 15, VE}, \
1774 {"arnr_strength", "altref noise reduction filter strength", offsetof(VPxContext, arnr_strength), AV_OPT_TYPE_INT, {.i64 = 3}, 0, 6, VE}, \
1775 {"arnr_type", "altref noise reduction filter type", offsetof(VPxContext, arnr_type), AV_OPT_TYPE_INT, {.i64 = 3}, 1, 3, VE}, \
1776 {"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}, \
1777 {"sharpness", "Increase sharpness at the expense of lower PSNR", offsetof(VPxContext, sharpness), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 7, VE},
1779 #if CONFIG_LIBVPX_VP8_ENCODER
1780 static const AVOption vp8_options[] = {
1782 {
"auto-alt-ref",
"Enable use of alternate reference "
1790 #if CONFIG_LIBVPX_VP9_ENCODER
1791 static const AVOption vp9_options[] = {
1793 {
"auto-alt-ref",
"Enable use of alternate reference "
1797 {
"tile-columns",
"Number of tile columns to use, log2",
OFFSET(tile_columns),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6,
VE},
1799 {
"frame-parallel",
"Enable frame parallel decodability features",
OFFSET(frame_parallel),
AV_OPT_TYPE_BOOL,{.i64 = -1}, -1, 1,
VE},
1800 #if VPX_ENCODER_ABI_VERSION >= 12
1801 {
"aq-mode",
"adaptive quantization mode",
OFFSET(aq_mode),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 4,
VE,
"aq_mode"},
1803 {
"aq-mode",
"adaptive quantization mode",
OFFSET(aq_mode),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 3,
VE,
"aq_mode"},
1806 {
"variance",
"Variance based Aq", 0,
AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0,
VE,
"aq_mode" },
1807 {
"complexity",
"Complexity based Aq", 0,
AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0,
VE,
"aq_mode" },
1809 #if VPX_ENCODER_ABI_VERSION >= 12
1813 #ifdef VPX_CTRL_VP9E_SET_ROW_MT
1816 #ifdef VPX_CTRL_VP9E_SET_TUNE_CONTENT
1817 #if VPX_ENCODER_ABI_VERSION >= 14
1818 {
"tune-content",
"Tune content type",
OFFSET(tune_content),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 2,
VE,
"tune_content" },
1820 {
"tune-content",
"Tune content type",
OFFSET(tune_content),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1,
VE,
"tune_content" },
1822 {
"default",
"Regular video content", 0,
AV_OPT_TYPE_CONST, {.i64 = 0}, 0, 0,
VE,
"tune_content" },
1823 {
"screen",
"Screen capture content", 0,
AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0,
VE,
"tune_content" },
1824 #if VPX_ENCODER_ABI_VERSION >= 14
1825 {
"film",
"Film content; improves grain retention", 0,
AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0,
VE,
"tune_content" },
1828 #if VPX_ENCODER_ABI_VERSION >= 14
1829 {
"corpus-complexity",
"corpus vbr complexity midpoint",
OFFSET(corpus_complexity),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 10000,
VE },
1831 #ifdef VPX_CTRL_VP9E_SET_TPL
1839 #undef COMMON_OPTIONS
1840 #undef LEGACY_OPTIONS
1847 {
"keyint_min",
"-1" },
1851 #if CONFIG_LIBVPX_VP8_ENCODER
1854 return vpx_init(avctx, vpx_codec_vp8_cx());
1857 static const AVClass class_vp8 = {
1860 .option = vp8_options,
1876 .priv_class = &class_vp8,
1878 .wrapper_name =
"libvpx",
1882 #if CONFIG_LIBVPX_VP9_ENCODER
1885 return vpx_init(avctx, vpx_codec_vp9_cx());
1888 static const AVClass class_vp9 = {
1891 .option = vp9_options,
1896 .
name =
"libvpx-vp9",
1907 .priv_class = &class_vp9,
1910 .wrapper_name =
"libvpx",
static double val(void *priv, double ch)
AVCodec ff_libvpx_vp8_encoder
AVCodec ff_libvpx_vp9_encoder
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Libavcodec external API header.
#define FF_PROFILE_UNKNOWN
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, buffer_size_t size)
static av_cold int init(AVCodecContext *avctx)
#define flags(name, subs,...)
common internal and external API header
#define CONFIG_LIBVPX_VP8_ENCODER
#define CONFIG_LIBVPX_VP9_ENCODER
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
#define AV_CODEC_CAP_OTHER_THREADS
Codec supports multithreading through a method other than slice- or frame-level multithreading.
#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_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
AVCodecID
Identify the syntax and semantics of the bitstream.
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
@ AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL
Data found in BlockAdditional element of matroska container.
char * av_base64_encode(char *out, int out_size, const uint8_t *in, int in_size)
Encode data to base64 and null-terminate.
#define AV_BASE64_SIZE(x)
Calculate the output size needed to base64-encode x bytes to a null-terminated string.
int av_base64_decode(uint8_t *out, const char *in_str, int out_size)
Decode a base64-encoded string.
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
@ AV_FRAME_DATA_REGIONS_OF_INTEREST
Regions Of Interest, the data is an array of AVRegionOfInterest type, the number of array element is ...
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define AV_LOG_VERBOSE
Detailed information.
#define AV_LOG_INFO
Standard information.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
const char * av_default_item_name(void *ptr)
Return the context name.
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.
@ AV_ROUND_NEAR_INF
Round to nearest and halfway cases away from zero.
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
@ AV_PICTURE_TYPE_I
Intra.
@ AV_PICTURE_TYPE_P
Predicted.
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().
char * av_get_token(const char **buf, const char *term)
Unescape the given string until a non escaped terminating char, and return the token corresponding to...
#define LIBAVUTIL_VERSION_INT
static int set_pix_fmt(AVCodecContext *avctx, struct aom_image *img)
static void set_color_range(AVCodecContext *avctx)
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
#define FF_DISABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
static const AVProfile profiles[]
static enum AVPixelFormat pix_fmts[]
av_cold void ff_vp9_init_static(AVCodec *codec)
static const AVCodecDefault defaults[]
static const char *const ctlidstr[]
String mappings for enum vp8e_enc_control_id.
static int queue_frames(AVCodecContext *avctx, AVPacket *pkt_out)
Queue multiple output frames from the encoder, returning the front-most.
static int vpx_ts_param_parse(VPxContext *ctx, struct vpx_codec_enc_cfg *enccfg, char *key, char *value, enum AVCodecID codec_id)
#define VP8F_ERROR_RESILIENT
Enable measures appropriate for streaming over lossy links.
#define VP8F_AUTO_ALT_REF
Enable automatic alternate reference frame generation.
static av_cold int vpx_init(AVCodecContext *avctx, const struct vpx_codec_iface *iface)
static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)
static av_cold void free_coded_frame(struct FrameListData *cx_frame)
static void set_temporal_layer_pattern(int layering_mode, vpx_codec_enc_cfg_t *cfg, int *layer_flags, int *flag_periodicity)
static int vp9_encode_set_roi(AVCodecContext *avctx, int frame_width, int frame_height, const AVFrameSideData *sd)
static av_cold int vpx_free(AVCodecContext *avctx)
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 set_vpx_defaults(AVCodecContext *avctx, struct vpx_codec_enc_cfg *enccfg)
Called when the bitrate is not set.
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)
static av_cold void dump_enc_cfg(AVCodecContext *avctx, const struct vpx_codec_enc_cfg *cfg)
static int vpx_encode(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
static int storeframe(AVCodecContext *avctx, struct FrameListData *cx_frame, AVPacket *pkt)
Store coded frame information in format suitable for return from encode2().
static void set_vp8_defaults(AVCodecContext *avctx, struct vpx_codec_enc_cfg *enccfg)
Set the target bitrate to VPX library default.
static int realloc_alpha_uv(AVCodecContext *avctx, int width, int height)
static void vp8_ts_parse_int_array(int *dest, char *value, size_t value_len, int max_entries)
static int vp8_encode_set_roi(AVCodecContext *avctx, int frame_width, int frame_height, const AVFrameSideData *sd)
static void coded_frame_add(void *list, struct FrameListData *cx_frame)
static av_cold void free_frame_list(struct FrameListData *list)
static av_cold int codecctl_int(AVCodecContext *avctx, enum vp8e_enc_control_id id, int val)
static const struct @322 planes[]
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride)
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
#define AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV440P12
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
@ AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_JPEG
Full range content.
#define AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_GBRP12
AVPixelFormat
Pixel format.
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
#define AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUV444P10
@ AVCOL_SPC_BT709
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
@ AVCOL_SPC_BT470BG
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601
@ AVCOL_SPC_RGB
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
@ AVCOL_SPC_BT2020_NCL
ITU-R BT2020 non-constant luminance system.
@ AVCOL_SPC_SMPTE170M
also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
@ AVCOL_SPC_SMPTE240M
functionally identical to above
const AVProfile ff_vp9_profiles[]
static av_cold int vp8_init(AVFormatContext *s, int st_index, PayloadContext *vp8)
static av_cold int vp9_init(AVFormatContext *ctx, int st_index, PayloadContext *data)
This structure describes the bitrate properties of an encoded bitstream.
int avg_bitrate
Average bitrate of the stream, in bits per second.
int min_bitrate
Minimum bitrate of the stream, in bits per second.
int buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
int max_bitrate
Maximum bitrate of the stream, in bits per second.
Describe the class of an AVClass context structure.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
main external API structure.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
int width
picture width / height.
char * stats_out
pass1 encoding statistics output buffer
int rc_buffer_size
decoder bitstream buffer size
enum AVColorRange color_range
MPEG vs JPEG YUV range.
int qmin
minimum quantizer
int keyint_min
minimum GOP size
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
attribute_deprecated int frame_skip_threshold
int64_t bit_rate
the average bitrate
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
enum AVColorSpace colorspace
YUV colorspace type.
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
int64_t rc_max_rate
maximum bitrate
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
int qmax
maximum quantizer
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
int flags
AV_CODEC_FLAG_*.
int64_t rc_min_rate
minimum bitrate
uint64_t error[AV_NUM_DATA_POINTERS]
error
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
attribute_deprecated int noise_reduction
int slices
Number of slices.
const char * name
Name of the codec implementation.
int flags
Flags modifying the (de)muxer behaviour.
Structure to hold side data for an AVFrame.
This structure describes decoded (raw) audio or video data.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
attribute_deprecated uint64_t error[AV_NUM_DATA_POINTERS]
int key_frame
1 -> keyframe, 0-> not
AVDictionary * metadata
metadata.
enum AVColorRange color_range
MPEG vs JPEG YUV range.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
enum AVPictureType pict_type
Picture type of the frame.
This structure stores compressed data.
int flags
A combination of AV_PKT_FLAG values.
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Structure describing a single Region Of Interest.
uint32_t self_size
Must be set to the size of this data structure (that is, sizeof(AVRegionOfInterest)).
AVRational qoffset
Quantisation offset.
int top
Distance in pixels from the top edge of the frame to the top and bottom edges and from the left edge ...
Portion of struct vpx_codec_cx_pkt from vpx_encoder.h.
int64_t pts
time stamp to show frame (in timebase units)
struct FrameListData * next
size_t sz
length of compressed data
void * buf
compressed data buffer
unsigned long duration
duration to show frame (in timebase units)
int have_sse
true if we have pending sse[]
uint32_t flags
flags for this frame
int roi_warned
If the driver does not support ROI then warn the first time we encounter a frame with ROI side data.
AVDictionary * vpx_ts_parameters
int have_sse
true if we have pending sse[]
struct FrameListData * coded_frame_list
int flags
VP8 specific flags, see VP8F_* below.
#define av_malloc_array(a, b)
static void error(const char *err)
static void stats(AVPacket *const *in, int n_in, unsigned *_max, unsigned *_sum)