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;
136 [VP8E_SET_CPUUSED] =
"VP8E_SET_CPUUSED",
137 [VP8E_SET_ENABLEAUTOALTREF] =
"VP8E_SET_ENABLEAUTOALTREF",
138 [VP8E_SET_NOISE_SENSITIVITY] =
"VP8E_SET_NOISE_SENSITIVITY",
139 [VP8E_SET_STATIC_THRESHOLD] =
"VP8E_SET_STATIC_THRESHOLD",
140 [VP8E_SET_TOKEN_PARTITIONS] =
"VP8E_SET_TOKEN_PARTITIONS",
141 [VP8E_SET_ARNR_MAXFRAMES] =
"VP8E_SET_ARNR_MAXFRAMES",
142 [VP8E_SET_ARNR_STRENGTH] =
"VP8E_SET_ARNR_STRENGTH",
143 [VP8E_SET_ARNR_TYPE] =
"VP8E_SET_ARNR_TYPE",
144 [VP8E_SET_TUNING] =
"VP8E_SET_TUNING",
145 [VP8E_SET_CQ_LEVEL] =
"VP8E_SET_CQ_LEVEL",
146 [VP8E_SET_MAX_INTRA_BITRATE_PCT] =
"VP8E_SET_MAX_INTRA_BITRATE_PCT",
147 [VP8E_SET_SHARPNESS] =
"VP8E_SET_SHARPNESS",
148 [VP8E_SET_TEMPORAL_LAYER_ID] =
"VP8E_SET_TEMPORAL_LAYER_ID",
149 #if CONFIG_LIBVPX_VP9_ENCODER 150 [VP9E_SET_LOSSLESS] =
"VP9E_SET_LOSSLESS",
151 [VP9E_SET_TILE_COLUMNS] =
"VP9E_SET_TILE_COLUMNS",
152 [VP9E_SET_TILE_ROWS] =
"VP9E_SET_TILE_ROWS",
153 [VP9E_SET_FRAME_PARALLEL_DECODING] =
"VP9E_SET_FRAME_PARALLEL_DECODING",
154 [VP9E_SET_AQ_MODE] =
"VP9E_SET_AQ_MODE",
155 [VP9E_SET_COLOR_SPACE] =
"VP9E_SET_COLOR_SPACE",
156 [VP9E_SET_SVC_LAYER_ID] =
"VP9E_SET_SVC_LAYER_ID",
157 #if VPX_ENCODER_ABI_VERSION >= 12 158 [VP9E_SET_SVC_PARAMETERS] =
"VP9E_SET_SVC_PARAMETERS",
159 [VP9E_SET_SVC_REF_FRAME_CONFIG] =
"VP9E_SET_SVC_REF_FRAME_CONFIG",
161 [VP9E_SET_SVC] =
"VP9E_SET_SVC",
162 #if VPX_ENCODER_ABI_VERSION >= 11 163 [VP9E_SET_COLOR_RANGE] =
"VP9E_SET_COLOR_RANGE",
165 #if VPX_ENCODER_ABI_VERSION >= 12 166 [VP9E_SET_TARGET_LEVEL] =
"VP9E_SET_TARGET_LEVEL",
167 [VP9E_GET_LEVEL] =
"VP9E_GET_LEVEL",
169 #ifdef VPX_CTRL_VP9E_SET_ROW_MT 170 [VP9E_SET_ROW_MT] =
"VP9E_SET_ROW_MT",
172 #ifdef VPX_CTRL_VP9E_SET_TUNE_CONTENT 173 [VP9E_SET_TUNE_CONTENT] =
"VP9E_SET_TUNE_CONTENT",
175 #ifdef VPX_CTRL_VP9E_SET_TPL 176 [VP9E_SET_TPL] =
"VP9E_SET_TPL",
185 const char *detail = vpx_codec_error_detail(&ctx->
encoder);
193 const struct vpx_codec_enc_cfg *cfg)
199 av_log(avctx, level,
"vpx_codec_enc_cfg\n");
200 av_log(avctx, level,
"generic settings\n" 201 " %*s%u\n %*s%u\n %*s%u\n %*s%u\n %*s%u\n" 202 #
if CONFIG_LIBVPX_VP9_ENCODER
205 " %*s{%u/%u}\n %*s%u\n %*s%d\n %*s%u\n",
206 width,
"g_usage:", cfg->g_usage,
207 width,
"g_threads:", cfg->g_threads,
208 width,
"g_profile:", cfg->g_profile,
209 width,
"g_w:", cfg->g_w,
210 width,
"g_h:", cfg->g_h,
211 #
if CONFIG_LIBVPX_VP9_ENCODER
212 width,
"g_bit_depth:", cfg->g_bit_depth,
213 width,
"g_input_bit_depth:", cfg->g_input_bit_depth,
215 width,
"g_timebase:", cfg->g_timebase.num, cfg->g_timebase.den,
216 width,
"g_error_resilient:", cfg->g_error_resilient,
217 width,
"g_pass:", cfg->g_pass,
218 width,
"g_lag_in_frames:", cfg->g_lag_in_frames);
219 av_log(avctx, level,
"rate control settings\n" 220 " %*s%u\n %*s%u\n %*s%u\n %*s%u\n" 222 width,
"rc_dropframe_thresh:", cfg->rc_dropframe_thresh,
223 width,
"rc_resize_allowed:", cfg->rc_resize_allowed,
224 width,
"rc_resize_up_thresh:", cfg->rc_resize_up_thresh,
225 width,
"rc_resize_down_thresh:", cfg->rc_resize_down_thresh,
226 width,
"rc_end_usage:", cfg->rc_end_usage,
227 width,
"rc_twopass_stats_in:", cfg->rc_twopass_stats_in.buf, cfg->rc_twopass_stats_in.sz,
228 width,
"rc_target_bitrate:", cfg->rc_target_bitrate);
229 av_log(avctx, level,
"quantizer settings\n" 231 width,
"rc_min_quantizer:", cfg->rc_min_quantizer,
232 width,
"rc_max_quantizer:", cfg->rc_max_quantizer);
233 av_log(avctx, level,
"bitrate tolerance\n" 235 width,
"rc_undershoot_pct:", cfg->rc_undershoot_pct,
236 width,
"rc_overshoot_pct:", cfg->rc_overshoot_pct);
237 av_log(avctx, level,
"temporal layering settings\n" 238 " %*s%u\n", width,
"ts_number_layers:", cfg->ts_number_layers);
241 "\n %*s", width,
"ts_target_bitrate:");
242 for (i = 0; i < VPX_TS_MAX_LAYERS; i++)
244 "%u ", cfg->ts_target_bitrate[i]);
246 #if (VPX_ENCODER_ABI_VERSION >= 12) && CONFIG_LIBVPX_VP9_ENCODER 249 "\n %*s", width,
"layer_target_bitrate:");
250 for (i = 0; i < VPX_TS_MAX_LAYERS; i++)
252 "%u ", cfg->layer_target_bitrate[i]);
255 av_log(avctx, level,
"\n");
257 "\n %*s", width,
"ts_rate_decimator:");
258 for (i = 0; i < VPX_TS_MAX_LAYERS; i++)
259 av_log(avctx, level,
"%u ", cfg->ts_rate_decimator[i]);
260 av_log(avctx, level,
"\n");
262 "\n %*s%u\n", width,
"ts_periodicity:", cfg->ts_periodicity);
264 "\n %*s", width,
"ts_layer_id:");
265 for (i = 0; i < VPX_TS_MAX_PERIODICITY; i++)
266 av_log(avctx, level,
"%u ", cfg->ts_layer_id[i]);
267 av_log(avctx, level,
"\n");
268 av_log(avctx, level,
"decoder buffer model\n" 269 " %*s%u\n %*s%u\n %*s%u\n",
270 width,
"rc_buf_sz:", cfg->rc_buf_sz,
271 width,
"rc_buf_initial_sz:", cfg->rc_buf_initial_sz,
272 width,
"rc_buf_optimal_sz:", cfg->rc_buf_optimal_sz);
273 av_log(avctx, level,
"2 pass rate control settings\n" 274 " %*s%u\n %*s%u\n %*s%u\n",
275 width,
"rc_2pass_vbr_bias_pct:", cfg->rc_2pass_vbr_bias_pct,
276 width,
"rc_2pass_vbr_minsection_pct:", cfg->rc_2pass_vbr_minsection_pct,
277 width,
"rc_2pass_vbr_maxsection_pct:", cfg->rc_2pass_vbr_maxsection_pct);
278 #if VPX_ENCODER_ABI_VERSION >= 14 279 av_log(avctx, level,
" %*s%u\n",
280 width,
"rc_2pass_vbr_corpus_complexity:", cfg->rc_2pass_vbr_corpus_complexity);
282 av_log(avctx, level,
"keyframing settings\n" 283 " %*s%d\n %*s%u\n %*s%u\n",
284 width,
"kf_mode:", cfg->kf_mode,
285 width,
"kf_min_dist:", cfg->kf_min_dist,
286 width,
"kf_max_dist:", cfg->kf_max_dist);
287 av_log(avctx, level,
"\n");
320 enum vp8e_enc_control_id
id,
int val)
330 res = vpx_codec_control(&ctx->
encoder,
id, val);
331 if (res != VPX_CODEC_OK) {
332 snprintf(buf,
sizeof(buf),
"Failed to set %s codec control",
337 return res == VPX_CODEC_OK ? 0 :
AVERROR(EINVAL);
340 #if VPX_ENCODER_ABI_VERSION >= 12 342 enum vp8e_enc_control_id
id,
int *
val)
352 res = vpx_codec_control(&ctx->
encoder,
id, val);
353 if (res != VPX_CODEC_OK) {
354 snprintf(buf,
sizeof(buf),
"Failed to set %s codec control",
359 return res == VPX_CODEC_OK ? 0 :
AVERROR(EINVAL);
367 #if VPX_ENCODER_ABI_VERSION >= 12 371 if (!codecctl_intp(avctx, VP9E_GET_LEVEL, &level_out))
378 vpx_codec_destroy(&ctx->
encoder);
393 char *saveptr =
NULL;
394 char *token =
av_strtok(value,
",", &saveptr);
396 while (token && dest_idx < max_entries) {
397 dest[dest_idx++] = strtoul(token,
NULL, 10);
402 #if CONFIG_LIBVPX_VP9_ENCODER && defined(VPX_CTRL_VP9E_SET_MAX_INTER_BITRATE_PCT) 403 static void vp8_ts_parse_int64_array(int64_t *dest,
char *
value,
size_t value_len,
int max_entries)
406 char *saveptr =
NULL;
409 while (token && dest_idx < max_entries) {
410 dest[dest_idx++] = strtoull(token,
NULL, 10);
417 int *layer_flags,
int *flag_periodicity)
419 switch (layering_mode) {
424 static const int ids[2] = { 0, 1 };
425 cfg->ts_periodicity = 2;
426 *flag_periodicity = 2;
427 cfg->ts_number_layers = 2;
428 cfg->ts_rate_decimator[0] = 2;
429 cfg->ts_rate_decimator[1] = 1;
430 memcpy(cfg->ts_layer_id, ids,
sizeof(ids));
433 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
434 VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
436 VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_GF |
437 VP8_EFLAG_NO_UPD_LAST |
438 VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_REF_GF;
448 static const int ids[4] = { 0, 2, 1, 2 };
449 cfg->ts_periodicity = 4;
450 *flag_periodicity = 4;
451 cfg->ts_number_layers = 3;
452 cfg->ts_rate_decimator[0] = 4;
453 cfg->ts_rate_decimator[1] = 2;
454 cfg->ts_rate_decimator[2] = 1;
455 memcpy(cfg->ts_layer_id, ids,
sizeof(ids));
462 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
463 VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
465 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
466 VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
467 VP8_EFLAG_NO_UPD_ARF;
469 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
470 VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
472 VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_REF_ARF |
473 VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
474 VP8_EFLAG_NO_UPD_ARF;
483 static const int ids[4] = { 0, 2, 1, 2 };
484 cfg->ts_periodicity = 4;
485 *flag_periodicity = 4;
486 cfg->ts_number_layers = 3;
487 cfg->ts_rate_decimator[0] = 4;
488 cfg->ts_rate_decimator[1] = 2;
489 cfg->ts_rate_decimator[2] = 1;
490 memcpy(cfg->ts_layer_id, ids,
sizeof(ids));
496 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
497 VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
499 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
500 VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF;
502 VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
503 VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
505 VP8_EFLAG_NO_REF_LAST |
506 VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
507 VP8_EFLAG_NO_UPD_ARF;
523 size_t value_len = strlen(value);
524 int ts_layering_mode = 0;
529 if (!strcmp(key,
"ts_number_layers"))
530 enccfg->ts_number_layers = strtoul(value, &value, 10);
531 else if (!strcmp(key,
"ts_target_bitrate")) {
534 #if (VPX_ENCODER_ABI_VERSION >= 12) && CONFIG_LIBVPX_VP9_ENCODER 538 }
else if (!strcmp(key,
"ts_rate_decimator")) {
540 }
else if (!strcmp(key,
"ts_periodicity")) {
541 enccfg->ts_periodicity = strtoul(value, &value, 10);
542 }
else if (!strcmp(key,
"ts_layer_id")) {
544 }
else if (!strcmp(key,
"ts_layering_mode")) {
546 ts_layering_mode = strtoul(value, &value, 4);
549 #if (VPX_ENCODER_ABI_VERSION >= 12) && CONFIG_LIBVPX_VP9_ENCODER 550 enccfg->temporal_layering_mode = VP9E_TEMPORAL_LAYERING_MODE_BYPASS;
551 enccfg->ss_number_layers = 1;
553 if (ts_layering_mode) {
563 #if CONFIG_LIBVPX_VP9_ENCODER && defined(VPX_CTRL_VP9E_SET_MAX_INTER_BITRATE_PCT) 564 static int vpx_ref_frame_config_parse(
VPxContext *
ctx,
const struct vpx_codec_enc_cfg *enccfg,
567 size_t value_len = strlen(
value);
568 int ss_number_layers = enccfg->ss_number_layers;
569 vpx_svc_ref_frame_config_t *ref_frame_config = &ctx->ref_frame_config;
577 if (!strcmp(
key,
"rfc_update_buffer_slot")) {
579 }
else if (!strcmp(
key,
"rfc_update_last")) {
581 }
else if (!strcmp(
key,
"rfc_update_golden")) {
583 }
else if (!strcmp(
key,
"rfc_update_alt_ref")) {
585 }
else if (!strcmp(
key,
"rfc_lst_fb_idx")) {
587 }
else if (!strcmp(
key,
"rfc_gld_fb_idx")) {
589 }
else if (!strcmp(
key,
"rfc_alt_fb_idx")) {
591 }
else if (!strcmp(
key,
"rfc_reference_last")) {
593 }
else if (!strcmp(
key,
"rfc_reference_golden")) {
595 }
else if (!strcmp(
key,
"rfc_reference_alt_ref")) {
597 }
else if (!strcmp(
key,
"rfc_reference_duration")) {
598 vp8_ts_parse_int64_array(ref_frame_config->duration,
value, value_len, ss_number_layers);
605 #if CONFIG_LIBVPX_VP9_ENCODER 607 struct vpx_codec_enc_cfg *enccfg, vpx_codec_flags_t *
flags,
608 vpx_img_fmt_t *img_fmt)
612 enccfg->g_bit_depth = enccfg->g_input_bit_depth = desc->
comp[0].
depth;
616 enccfg->g_profile = 0;
617 *img_fmt = VPX_IMG_FMT_I420;
620 enccfg->g_profile = 1;
621 *img_fmt = VPX_IMG_FMT_I422;
624 enccfg->g_profile = 1;
625 *img_fmt = VPX_IMG_FMT_I440;
628 ctx->vpx_cs = VPX_CS_SRGB;
630 enccfg->g_profile = 1;
631 *img_fmt = VPX_IMG_FMT_I444;
635 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {
636 enccfg->g_profile = 2;
637 *img_fmt = VPX_IMG_FMT_I42016;
638 *
flags |= VPX_CODEC_USE_HIGHBITDEPTH;
644 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {
645 enccfg->g_profile = 3;
646 *img_fmt = VPX_IMG_FMT_I42216;
647 *
flags |= VPX_CODEC_USE_HIGHBITDEPTH;
653 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {
654 enccfg->g_profile = 3;
655 *img_fmt = VPX_IMG_FMT_I44016;
656 *
flags |= VPX_CODEC_USE_HIGHBITDEPTH;
662 ctx->vpx_cs = VPX_CS_SRGB;
665 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {
666 enccfg->g_profile = 3;
667 *img_fmt = VPX_IMG_FMT_I44416;
668 *
flags |= VPX_CODEC_USE_HIGHBITDEPTH;
681 enum vpx_color_space vpx_cs;
705 #if VPX_ENCODER_ABI_VERSION >= 11 708 enum vpx_color_range vpx_cr;
728 struct vpx_codec_enc_cfg *enccfg)
732 avctx->
bit_rate = enccfg->rc_target_bitrate * 1000;
733 if (enccfg->rc_end_usage == VPX_CQ) {
735 "Bitrate not specified for constrained quality mode, using default of %dkbit/sec\n",
736 enccfg->rc_target_bitrate);
738 enccfg->rc_end_usage = VPX_CQ;
741 "Neither bitrate nor constrained quality specified, using default CRF of %d and bitrate of %dkbit/sec\n",
742 ctx->
crf, enccfg->rc_target_bitrate);
747 #if CONFIG_LIBVPX_VP9_ENCODER 753 struct vpx_codec_enc_cfg *enccfg)
757 if (enccfg->rc_end_usage != VPX_Q && ctx->
lossless < 0) {
758 enccfg->rc_end_usage = VPX_Q;
761 "Neither bitrate nor constrained quality specified, using default CRF of %d\n",
772 struct vpx_codec_enc_cfg *enccfg)
775 #if CONFIG_LIBVPX_VP9_ENCODER 777 set_vp9_defaults(avctx, enccfg);
785 const struct vpx_codec_iface *iface)
788 struct vpx_codec_enc_cfg enccfg = { 0 };
789 struct vpx_codec_enc_cfg enccfg_alpha;
793 vpx_img_fmt_t img_fmt = VPX_IMG_FMT_I420;
794 #if CONFIG_LIBVPX_VP9_ENCODER 795 vpx_codec_caps_t codec_caps = vpx_codec_get_caps(iface);
796 vpx_svc_extra_cfg_t svc_params;
806 if ((res = vpx_codec_enc_config_default(iface, &enccfg, 0)) != VPX_CODEC_OK) {
808 vpx_codec_err_to_string(res));
812 #if CONFIG_LIBVPX_VP9_ENCODER 814 if (
set_pix_fmt(avctx, codec_caps, &enccfg, &flags, &img_fmt))
827 enccfg.g_w = avctx->
width;
828 enccfg.g_h = avctx->
height;
836 enccfg.g_pass = VPX_RC_FIRST_PASS;
838 enccfg.g_pass = VPX_RC_LAST_PASS;
840 enccfg.g_pass = VPX_RC_ONE_PASS;
844 enccfg.rc_end_usage = VPX_CBR;
845 }
else if (ctx->
crf >= 0) {
846 enccfg.rc_end_usage = VPX_CQ;
847 #if CONFIG_LIBVPX_VP9_ENCODER 849 enccfg.rc_end_usage = VPX_Q;
856 #if CONFIG_LIBVPX_VP9_ENCODER 857 enccfg.ss_target_bitrate[0] = enccfg.rc_target_bitrate;
865 enccfg.rc_min_quantizer =
866 enccfg.rc_max_quantizer = 0;
868 if (avctx->
qmin >= 0)
869 enccfg.rc_min_quantizer = avctx->
qmin;
870 if (avctx->
qmax >= 0)
871 enccfg.rc_max_quantizer = avctx->
qmax;
874 if (enccfg.rc_end_usage == VPX_CQ
875 #
if CONFIG_LIBVPX_VP9_ENCODER
876 || enccfg.rc_end_usage == VPX_Q
879 if (ctx->
crf < enccfg.rc_min_quantizer || ctx->
crf > enccfg.rc_max_quantizer) {
881 "CQ level %d must be between minimum and maximum quantizer value (%d-%d)\n",
882 ctx->
crf, enccfg.rc_min_quantizer, enccfg.rc_max_quantizer);
887 #if FF_API_PRIVATE_OPT 898 enccfg.rc_2pass_vbr_minsection_pct =
901 enccfg.rc_2pass_vbr_maxsection_pct =
903 #if CONFIG_LIBVPX_VP9_ENCODER 905 #if VPX_ENCODER_ABI_VERSION >= 14 916 enccfg.rc_buf_initial_sz =
918 enccfg.rc_buf_optimal_sz = enccfg.rc_buf_sz * 5 / 6;
928 enccfg.kf_max_dist = avctx->
gop_size;
930 if (enccfg.g_pass == VPX_RC_FIRST_PASS)
931 enccfg.g_lag_in_frames = 0;
932 else if (enccfg.g_pass == VPX_RC_LAST_PASS) {
933 int decode_size,
ret;
951 if (decode_size < 0) {
964 enccfg.g_profile = avctx->
profile;
971 "Error parsing option '%s = %s'.\n",
977 res = vpx_codec_enc_init(&ctx->
encoder, iface, &enccfg, flags);
978 if (res != VPX_CODEC_OK) {
982 #if CONFIG_LIBVPX_VP9_ENCODER 984 memset(&svc_params, 0,
sizeof(svc_params));
985 for (
int i = 0;
i < enccfg.ts_number_layers; ++
i) {
986 svc_params.max_quantizers[
i] = enccfg.rc_max_quantizer;
987 svc_params.min_quantizers[
i] = enccfg.rc_min_quantizer;
989 svc_params.scaling_factor_num[0] = enccfg.g_h;
990 svc_params.scaling_factor_den[0] = enccfg.g_h;
991 #if VPX_ENCODER_ABI_VERSION >= 12 993 codecctl_intp(avctx, VP9E_SET_SVC_PARAMETERS, (
int *)&svc_params);
998 enccfg_alpha = enccfg;
999 res = vpx_codec_enc_init(&ctx->
encoder_alpha, iface, &enccfg_alpha, flags);
1000 if (res != VPX_CODEC_OK) {
1024 av_log(avctx,
AV_LOG_ERROR,
"Transparency encoding with auto_alt_ref does not work\n");
1032 #if FF_API_PRIVATE_OPT 1047 #if CONFIG_LIBVPX_VP9_ENCODER 1059 set_colorspace(avctx);
1060 #if VPX_ENCODER_ABI_VERSION >= 11 1063 #if VPX_ENCODER_ABI_VERSION >= 12 1066 #ifdef VPX_CTRL_VP9E_SET_ROW_MT 1070 #ifdef VPX_CTRL_VP9E_SET_TUNE_CONTENT 1074 #ifdef VPX_CTRL_VP9E_SET_TPL 1086 #if CONFIG_LIBVPX_VP9_ENCODER 1088 ctx->
rawimg.bit_depth = enccfg.g_bit_depth;
1095 if (enccfg.rc_end_usage == VPX_CBR ||
1096 enccfg.g_pass != VPX_RC_ONE_PASS) {
1107 const struct vpx_codec_cx_pkt *
src,
1108 const struct vpx_codec_cx_pkt *src_alpha,
1111 dst->
pts = src->data.frame.pts;
1112 dst->
duration = src->data.frame.duration;
1113 dst->
flags = src->data.frame.flags;
1114 dst->
sz = src->data.frame.sz;
1115 dst->
buf = src->data.frame.buf;
1118 if (!(dst->
flags & VPX_FRAME_IS_INVISIBLE)) {
1126 memcpy(dst->
sse, ctx->
sse,
sizeof(dst->
sse));
1133 dst->
buf_alpha = src_alpha->data.frame.buf;
1134 dst->
sz_alpha = src_alpha->data.frame.sz;
1157 #if FF_API_CODED_FRAME 1164 if (!!(cx_frame->
flags & VPX_FRAME_IS_KEY)) {
1166 #if FF_API_CODED_FRAME 1174 #if FF_API_CODED_FRAME 1182 cx_frame->
have_sse ? 3 : 0, pict_type);
1187 #if FF_API_CODED_FRAME && FF_API_ERROR_FRAME 1195 for (i = 0; i < 3; ++
i) {
1196 avctx->
error[
i] += cx_frame->
sse[i + 1];
1228 const struct vpx_codec_cx_pkt *
pkt;
1229 const struct vpx_codec_cx_pkt *pkt_alpha =
NULL;
1230 const void *iter =
NULL;
1231 const void *iter_alpha =
NULL;
1246 while ((pkt = vpx_codec_get_cx_data(&ctx->
encoder, &iter)) &&
1248 (pkt_alpha = vpx_codec_get_cx_data(&ctx->
encoder_alpha, &iter_alpha)))) {
1249 switch (pkt->kind) {
1250 case VPX_CODEC_CX_FRAME_PKT:
1257 cx_pktcpy(&cx_frame, pkt, pkt_alpha, ctx);
1258 size =
storeframe(avctx, &cx_frame, pkt_out);
1266 "Frame queue element alloc failed\n");
1269 cx_pktcpy(cx_frame, pkt, pkt_alpha, ctx);
1272 if (!cx_frame->
buf) {
1279 memcpy(cx_frame->
buf, pkt->data.frame.buf, pkt->data.frame.sz);
1289 memcpy(cx_frame->
buf_alpha, pkt_alpha->data.frame.buf, pkt_alpha->data.frame.sz);
1294 case VPX_CODEC_STATS_PKT: {
1299 pkt->data.twopass_stats.sz)) < 0) {
1304 memcpy((
uint8_t*)stats->buf + stats->sz,
1305 pkt->data.twopass_stats.buf, pkt->data.twopass_stats.sz);
1306 stats->sz += pkt->data.twopass_stats.sz;
1309 case VPX_CODEC_PSNR_PKT:
1311 ctx->
sse[0] = pkt->data.psnr.sse[0];
1312 ctx->
sse[1] = pkt->data.psnr.sse[1];
1313 ctx->
sse[2] = pkt->data.psnr.sse[2];
1314 ctx->
sse[3] = pkt->data.psnr.sse[3];
1317 case VPX_CODEC_CUSTOM_PKT:
1327 vpx_roi_map_t *roi_map,
int block_size,
int segment_cnt)
1332 #define MAX_DELTA_Q 63 1347 memset(roi_map, 0,
sizeof(*roi_map));
1358 if (!self_size || sd->
size % self_size) {
1362 nb_rois = sd->
size / self_size;
1368 for (
int i = 0;
i < nb_rois;
i++) {
1382 if (!segment_mapping[mapping_index]) {
1383 if (segment_id == segment_cnt) {
1385 "ROI only supports %d segments (and segment 0 is reserved for non-ROIs), skipping the left ones.\n",
1390 segment_mapping[mapping_index] = segment_id + 1;
1391 roi_map->delta_q[segment_id] =
delta_q;
1396 roi_map->rows = (frame_height + block_size - 1) / block_size;
1397 roi_map->cols = (frame_width + block_size - 1) / block_size;
1398 roi_map->roi_map =
av_mallocz_array(roi_map->rows * roi_map->cols,
sizeof(*roi_map->roi_map));
1399 if (!roi_map->roi_map) {
1407 for (
int i = nb_rois - 1;
i >= 0;
i--) {
1410 int starty, endy, startx, endx;
1414 starty = av_clip(roi->
top / block_size, 0, roi_map->rows);
1415 endy = av_clip((roi->
bottom + block_size - 1) / block_size, 0, roi_map->rows);
1416 startx = av_clip(roi->
left / block_size, 0, roi_map->cols);
1417 endx = av_clip((roi->
right + block_size - 1) / block_size, 0, roi_map->cols);
1422 mapping_value = segment_mapping[delta_q +
MAX_DELTA_Q];
1423 if (mapping_value) {
1424 for (
int y = starty; y < endy; y++)
1425 for (
int x = startx; x < endx; x++)
1426 roi_map->roi_map[x + y * roi_map->cols] = mapping_value - 1;
1437 #ifdef VPX_CTRL_VP9E_SET_ROI_MAP 1438 int version = vpx_codec_version();
1439 int major = VPX_VERSION_MAJOR(version);
1440 int minor = VPX_VERSION_MINOR(version);
1441 int patch = VPX_VERSION_PATCH(version);
1443 if (major > 1 || (major == 1 && minor > 8) || (major == 1 && minor == 8 && patch >= 1)) {
1444 vpx_roi_map_t roi_map;
1445 const int segment_cnt = 8;
1446 const int block_size = 8;
1453 "and deadline is REALTIME, so skipping ROI.\n");
1458 ret =
set_roi_map(avctx, sd, frame_width, frame_height, &roi_map, block_size, segment_cnt);
1464 memset(roi_map.ref_frame, -1,
sizeof(roi_map.ref_frame));
1466 if (vpx_codec_control(&ctx->
encoder, VP9E_SET_ROI_MAP, &roi_map)) {
1477 av_log(avctx,
AV_LOG_WARNING,
"ROI is not supported, please upgrade libvpx to version >= 1.8.1. " 1478 "You may need to rebuild ffmpeg.\n");
1485 vpx_roi_map_t roi_map;
1486 const int segment_cnt = 4;
1487 const int block_size = 16;
1490 int ret =
set_roi_map(avctx, sd, frame_width, frame_height, &roi_map, block_size, segment_cnt);
1496 if (vpx_codec_control(&ctx->
encoder, VP8E_SET_ROI_MAP, &roi_map)) {
1509 unsigned char **
planes = rawimg_alpha->planes;
1510 int *
stride = rawimg_alpha->stride;
1512 if (!planes[VPX_PLANE_U] ||
1513 !planes[VPX_PLANE_V] ||
1514 width != (
int)rawimg_alpha->d_w ||
1515 height != (
int)rawimg_alpha->d_h) {
1519 vpx_img_wrap(rawimg_alpha, VPX_IMG_FMT_I420, width, height, 1,
1523 if (!planes[VPX_PLANE_U] || !planes[VPX_PLANE_V])
1526 memset(planes[VPX_PLANE_U], 0x80, stride[VPX_PLANE_U] * height);
1527 memset(planes[VPX_PLANE_V], 0x80, stride[VPX_PLANE_V] * height);
1537 struct vpx_image *rawimg =
NULL;
1538 struct vpx_image *rawimg_alpha =
NULL;
1539 int64_t timestamp = 0;
1540 int res, coded_size;
1541 vpx_enc_frame_flags_t
flags = 0;
1542 const struct vpx_codec_enc_cfg *enccfg = ctx->
encoder.config.enc;
1543 vpx_svc_layer_id_t layer_id;
1544 int layer_id_valid = 0;
1549 rawimg->planes[VPX_PLANE_Y] = frame->
data[0];
1550 rawimg->planes[VPX_PLANE_U] = frame->
data[1];
1551 rawimg->planes[VPX_PLANE_V] = frame->
data[2];
1552 rawimg->stride[VPX_PLANE_Y] = frame->
linesize[0];
1553 rawimg->stride[VPX_PLANE_U] = frame->
linesize[1];
1554 rawimg->stride[VPX_PLANE_V] = frame->
linesize[2];
1560 rawimg_alpha->planes[VPX_PLANE_Y] = frame->
data[3];
1561 rawimg_alpha->stride[VPX_PLANE_Y] = frame->
linesize[3];
1563 timestamp = frame->
pts;
1564 #if VPX_IMAGE_ABI_VERSION >= 4 1567 rawimg->range = VPX_CR_STUDIO_RANGE;
1570 rawimg->range = VPX_CR_FULL_RANGE;
1575 flags |= VPX_EFLAG_FORCE_KF;
1582 memset(&layer_id, 0,
sizeof(layer_id));
1586 layer_id.temporal_layer_id = strtoul(en->
value,
NULL, 10);
1587 #ifdef VPX_CTRL_VP9E_SET_MAX_INTER_BITRATE_PCT 1588 layer_id.temporal_layer_id_per_spatial[0] = layer_id.temporal_layer_id;
1592 #if CONFIG_LIBVPX_VP9_ENCODER && defined(VPX_CTRL_VP9E_SET_MAX_INTER_BITRATE_PCT) 1601 if (vpx_ref_frame_config_parse(ctx, enccfg, en2->
key, en2->
value, avctx->
codec_id) < 0)
1603 "Error parsing option '%s = %s'.\n",
1607 codecctl_intp(avctx, VP9E_SET_SVC_REF_FRAME_CONFIG, (
int *)&ctx->ref_frame_config);
1610 "Error using option ref-frame-config for a non-VP9 codec\n");
1628 if (flags & VPX_EFLAG_FORCE_KF) {
1631 flags = VPX_EFLAG_FORCE_KF;
1639 memset(&layer_id, 0,
sizeof(layer_id));
1640 #if VPX_ENCODER_ABI_VERSION >= 12 1641 layer_id.spatial_layer_id = 0;
1644 #ifdef VPX_CTRL_VP9E_SET_MAX_INTER_BITRATE_PCT 1645 layer_id.temporal_layer_id_per_spatial[0] = layer_id.temporal_layer_id;
1650 if (layer_id_valid) {
1652 codecctl_int(avctx, VP8E_SET_TEMPORAL_LAYER_ID, layer_id.temporal_layer_id);
1654 #if CONFIG_LIBVPX_VP9_ENCODER && VPX_ENCODER_ABI_VERSION >= 12 1656 codecctl_intp(avctx, VP9E_SET_SVC_LAYER_ID, (
int *)&layer_id);
1661 res = vpx_codec_encode(&ctx->
encoder, rawimg, timestamp,
1663 if (res != VPX_CODEC_OK) {
1669 res = vpx_codec_encode(&ctx->
encoder_alpha, rawimg_alpha, timestamp,
1671 if (res != VPX_CODEC_OK) {
1690 }
else if (enccfg->ts_number_layers > 1 && ctx->
ts_layer_flags) {
1694 *got_packet = !!coded_size;
1698 #define OFFSET(x) offsetof(VPxContext, x) 1699 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM 1701 #define COMMON_OPTIONS \ 1702 { "lag-in-frames", "Number of frames to look ahead for " \ 1703 "alternate reference frame selection", OFFSET(lag_in_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \ 1704 { "arnr-maxframes", "altref noise reduction max frame count", OFFSET(arnr_max_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \ 1705 { "arnr-strength", "altref noise reduction filter strength", OFFSET(arnr_strength), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \ 1706 { "arnr-type", "altref noise reduction filter type", OFFSET(arnr_type), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE, "arnr_type"}, \ 1707 { "backward", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0, VE, "arnr_type" }, \ 1708 { "forward", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0, VE, "arnr_type" }, \ 1709 { "centered", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 3}, 0, 0, VE, "arnr_type" }, \ 1710 { "tune", "Tune the encoding to a specific scenario", OFFSET(tune), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE, "tune"}, \ 1711 { "psnr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VP8_TUNE_PSNR}, 0, 0, VE, "tune"}, \ 1712 { "ssim", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VP8_TUNE_SSIM}, 0, 0, VE, "tune"}, \ 1713 { "deadline", "Time to spend encoding, in microseconds.", OFFSET(deadline), AV_OPT_TYPE_INT, {.i64 = VPX_DL_GOOD_QUALITY}, INT_MIN, INT_MAX, VE, "quality"}, \ 1714 { "best", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_BEST_QUALITY}, 0, 0, VE, "quality"}, \ 1715 { "good", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_GOOD_QUALITY}, 0, 0, VE, "quality"}, \ 1716 { "realtime", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_REALTIME}, 0, 0, VE, "quality"}, \ 1717 { "error-resilient", "Error resilience configuration", OFFSET(error_resilient), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, VE, "er"}, \ 1718 { "max-intra-rate", "Maximum I-frame bitrate (pct) 0=unlimited", OFFSET(max_intra_rate), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \ 1719 { "default", "Improve resiliency against losses of whole frames", 0, AV_OPT_TYPE_CONST, {.i64 = VPX_ERROR_RESILIENT_DEFAULT}, 0, 0, VE, "er"}, \ 1720 { "partitions", "The frame partitions are independently decodable " \ 1721 "by the bool decoder, meaning that partitions can be decoded even " \ 1722 "though earlier partitions have been lost. Note that intra prediction" \ 1723 " is still done over the partition boundary.", 0, AV_OPT_TYPE_CONST, {.i64 = VPX_ERROR_RESILIENT_PARTITIONS}, 0, 0, VE, "er"}, \ 1724 { "crf", "Select the quality for constant quality mode", offsetof(VPxContext, crf), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 63, VE }, \ 1725 { "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 }, \ 1726 { "drop-threshold", "Frame drop threshold", offsetof(VPxContext, drop_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, VE }, \ 1727 { "noise-sensitivity", "Noise sensitivity", OFFSET(noise_sensitivity), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 4, VE}, \ 1728 { "undershoot-pct", "Datarate undershoot (min) target (%)", OFFSET(rc_undershoot_pct), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 100, VE }, \ 1729 { "overshoot-pct", "Datarate overshoot (max) target (%)", OFFSET(rc_overshoot_pct), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1000, VE }, \ 1730 { "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}, \ 1732 #define LEGACY_OPTIONS \ 1733 {"speed", "", offsetof(VPxContext, cpu_used), AV_OPT_TYPE_INT, {.i64 = 1}, -16, 16, VE}, \ 1734 {"quality", "", offsetof(VPxContext, deadline), AV_OPT_TYPE_INT, {.i64 = VPX_DL_GOOD_QUALITY}, INT_MIN, INT_MAX, VE, "quality"}, \ 1735 {"vp8flags", "", offsetof(VPxContext, flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, 0, UINT_MAX, VE, "flags"}, \ 1736 {"error_resilient", "enable error resilience", 0, AV_OPT_TYPE_CONST, {.i64 = VP8F_ERROR_RESILIENT}, INT_MIN, INT_MAX, VE, "flags"}, \ 1737 {"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"}, \ 1738 {"arnr_max_frames", "altref noise reduction max frame count", offsetof(VPxContext, arnr_max_frames), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 15, VE}, \ 1739 {"arnr_strength", "altref noise reduction filter strength", offsetof(VPxContext, arnr_strength), AV_OPT_TYPE_INT, {.i64 = 3}, 0, 6, VE}, \ 1740 {"arnr_type", "altref noise reduction filter type", offsetof(VPxContext, arnr_type), AV_OPT_TYPE_INT, {.i64 = 3}, 1, 3, VE}, \ 1741 {"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}, \ 1742 {"sharpness", "Increase sharpness at the expense of lower PSNR", offsetof(VPxContext, sharpness), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 7, VE}, 1744 #if CONFIG_LIBVPX_VP8_ENCODER 1745 static const AVOption vp8_options[] = {
1747 {
"auto-alt-ref",
"Enable use of alternate reference " 1755 #if CONFIG_LIBVPX_VP9_ENCODER 1756 static const AVOption vp9_options[] = {
1758 {
"auto-alt-ref",
"Enable use of alternate reference " 1762 {
"tile-columns",
"Number of tile columns to use, log2",
OFFSET(tile_columns),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6,
VE},
1764 {
"frame-parallel",
"Enable frame parallel decodability features",
OFFSET(frame_parallel),
AV_OPT_TYPE_BOOL,{.i64 = -1}, -1, 1,
VE},
1765 #if VPX_ENCODER_ABI_VERSION >= 12 1766 {
"aq-mode",
"adaptive quantization mode",
OFFSET(aq_mode),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 4,
VE,
"aq_mode"},
1768 {
"aq-mode",
"adaptive quantization mode",
OFFSET(aq_mode),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 3,
VE,
"aq_mode"},
1771 {
"variance",
"Variance based Aq", 0,
AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0,
VE,
"aq_mode" },
1772 {
"complexity",
"Complexity based Aq", 0,
AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0,
VE,
"aq_mode" },
1774 #if VPX_ENCODER_ABI_VERSION >= 12 1778 #ifdef VPX_CTRL_VP9E_SET_ROW_MT 1781 #ifdef VPX_CTRL_VP9E_SET_TUNE_CONTENT 1782 #if VPX_ENCODER_ABI_VERSION >= 14 1783 {
"tune-content",
"Tune content type",
OFFSET(tune_content),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 2,
VE,
"tune_content" },
1785 {
"tune-content",
"Tune content type",
OFFSET(tune_content),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1,
VE,
"tune_content" },
1787 {
"default",
"Regular video content", 0,
AV_OPT_TYPE_CONST, {.i64 = 0}, 0, 0,
VE,
"tune_content" },
1788 {
"screen",
"Screen capture content", 0,
AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0,
VE,
"tune_content" },
1789 #if VPX_ENCODER_ABI_VERSION >= 14 1790 {
"film",
"Film content; improves grain retention", 0,
AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0,
VE,
"tune_content" },
1793 #if VPX_ENCODER_ABI_VERSION >= 14 1794 {
"corpus-complexity",
"corpus vbr complexity midpoint",
OFFSET(corpus_complexity),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 10000,
VE },
1796 #ifdef VPX_CTRL_VP9E_SET_TPL 1804 #undef COMMON_OPTIONS 1805 #undef LEGACY_OPTIONS 1812 {
"keyint_min",
"-1" },
1816 #if CONFIG_LIBVPX_VP8_ENCODER 1819 return vpx_init(avctx, vpx_codec_vp8_cx());
1822 static const AVClass class_vp8 = {
1825 .option = vp8_options,
1840 .priv_class = &class_vp8,
1842 .wrapper_name =
"libvpx",
1846 #if CONFIG_LIBVPX_VP9_ENCODER 1849 return vpx_init(avctx, vpx_codec_vp9_cx());
1852 static const AVClass class_vp9 = {
1855 .option = vp9_options,
1860 .
name =
"libvpx-vp9",
1870 .priv_class = &class_vp9,
1873 .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
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
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
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
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)
GLsizei GLboolean const GLfloat * value
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 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)
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().
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_*.
Round to nearest and halfway cases away from zero.
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)
static const struct @321 planes[]
int64_t rc_min_rate
minimum bitrate
common internal API header
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)
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
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)
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() ...
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)
int av_dict_parse_string(AVDictionary **pm, const char *str, const char *key_val_sep, const char *pairs_sep, int flags)
Parse the key/value pairs list and add the parsed entries to a dictionary.
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)
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
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.
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining list
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)
Narrow or limited range content.
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)
GLint GLenum GLboolean GLsizei stride
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[]
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
int depth
Number of bits in the component.
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)
int keyint_min
minimum GOP size