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> 64 typedef struct VPxEncoderContext {
66 struct vpx_codec_ctx encoder;
67 struct vpx_image rawimg;
68 struct vpx_codec_ctx encoder_alpha;
69 struct vpx_image rawimg_alpha;
71 struct vpx_fixed_buf twopass_stats;
84 #define VP8F_ERROR_RESILIENT 0x00000001 85 #define VP8F_AUTO_ALT_REF 0x00000002
123 [VP8E_SET_CPUUSED] =
"VP8E_SET_CPUUSED",
124 [VP8E_SET_ENABLEAUTOALTREF] =
"VP8E_SET_ENABLEAUTOALTREF",
125 [VP8E_SET_NOISE_SENSITIVITY] =
"VP8E_SET_NOISE_SENSITIVITY",
126 [VP8E_SET_STATIC_THRESHOLD] =
"VP8E_SET_STATIC_THRESHOLD",
127 [VP8E_SET_TOKEN_PARTITIONS] =
"VP8E_SET_TOKEN_PARTITIONS",
128 [VP8E_SET_ARNR_MAXFRAMES] =
"VP8E_SET_ARNR_MAXFRAMES",
129 [VP8E_SET_ARNR_STRENGTH] =
"VP8E_SET_ARNR_STRENGTH",
130 [VP8E_SET_ARNR_TYPE] =
"VP8E_SET_ARNR_TYPE",
131 [VP8E_SET_TUNING] =
"VP8E_SET_TUNING",
132 [VP8E_SET_CQ_LEVEL] =
"VP8E_SET_CQ_LEVEL",
133 [VP8E_SET_MAX_INTRA_BITRATE_PCT] =
"VP8E_SET_MAX_INTRA_BITRATE_PCT",
134 [VP8E_SET_SHARPNESS] =
"VP8E_SET_SHARPNESS",
135 #if CONFIG_LIBVPX_VP9_ENCODER 136 [VP9E_SET_LOSSLESS] =
"VP9E_SET_LOSSLESS",
137 [VP9E_SET_TILE_COLUMNS] =
"VP9E_SET_TILE_COLUMNS",
138 [VP9E_SET_TILE_ROWS] =
"VP9E_SET_TILE_ROWS",
139 [VP9E_SET_FRAME_PARALLEL_DECODING] =
"VP9E_SET_FRAME_PARALLEL_DECODING",
140 [VP9E_SET_AQ_MODE] =
"VP9E_SET_AQ_MODE",
141 [VP9E_SET_COLOR_SPACE] =
"VP9E_SET_COLOR_SPACE",
142 #if VPX_ENCODER_ABI_VERSION >= 11 143 [VP9E_SET_COLOR_RANGE] =
"VP9E_SET_COLOR_RANGE",
145 #if VPX_ENCODER_ABI_VERSION >= 12 146 [VP9E_SET_TARGET_LEVEL] =
"VP9E_SET_TARGET_LEVEL",
147 [VP9E_GET_LEVEL] =
"VP9E_GET_LEVEL",
149 #ifdef VPX_CTRL_VP9E_SET_ROW_MT 150 [VP9E_SET_ROW_MT] =
"VP9E_SET_ROW_MT",
152 #ifdef VPX_CTRL_VP9E_SET_TUNE_CONTENT 153 [VP9E_SET_TUNE_CONTENT] =
"VP9E_SET_TUNE_CONTENT",
155 #ifdef VPX_CTRL_VP9E_SET_TPL 156 [VP9E_SET_TPL] =
"VP9E_SET_TPL",
165 const char *detail = vpx_codec_error_detail(&ctx->
encoder);
173 const struct vpx_codec_enc_cfg *cfg)
179 av_log(avctx, level,
"vpx_codec_enc_cfg\n");
180 av_log(avctx, level,
"generic settings\n" 181 " %*s%u\n %*s%u\n %*s%u\n %*s%u\n %*s%u\n" 185 " %*s{%u/%u}\n %*s%u\n %*s%d\n %*s%u\n",
186 width,
"g_usage:", cfg->g_usage,
187 width,
"g_threads:", cfg->g_threads,
188 width,
"g_profile:", cfg->g_profile,
189 width,
"g_w:", cfg->g_w,
190 width,
"g_h:", cfg->g_h,
192 width,
"g_bit_depth:", cfg->g_bit_depth,
193 width,
"g_input_bit_depth:", cfg->g_input_bit_depth,
195 width,
"g_timebase:", cfg->g_timebase.num, cfg->g_timebase.den,
196 width,
"g_error_resilient:", cfg->g_error_resilient,
197 width,
"g_pass:", cfg->g_pass,
198 width,
"g_lag_in_frames:", cfg->g_lag_in_frames);
199 av_log(avctx, level,
"rate control settings\n" 200 " %*s%u\n %*s%u\n %*s%u\n %*s%u\n" 202 width,
"rc_dropframe_thresh:", cfg->rc_dropframe_thresh,
203 width,
"rc_resize_allowed:", cfg->rc_resize_allowed,
204 width,
"rc_resize_up_thresh:", cfg->rc_resize_up_thresh,
205 width,
"rc_resize_down_thresh:", cfg->rc_resize_down_thresh,
206 width,
"rc_end_usage:", cfg->rc_end_usage,
207 width,
"rc_twopass_stats_in:", cfg->rc_twopass_stats_in.buf, cfg->rc_twopass_stats_in.sz,
208 width,
"rc_target_bitrate:", cfg->rc_target_bitrate);
209 av_log(avctx, level,
"quantizer settings\n" 211 width,
"rc_min_quantizer:", cfg->rc_min_quantizer,
212 width,
"rc_max_quantizer:", cfg->rc_max_quantizer);
213 av_log(avctx, level,
"bitrate tolerance\n" 215 width,
"rc_undershoot_pct:", cfg->rc_undershoot_pct,
216 width,
"rc_overshoot_pct:", cfg->rc_overshoot_pct);
217 av_log(avctx, level,
"temporal layering settings\n" 218 " %*s%u\n", width,
"ts_number_layers:", cfg->ts_number_layers);
220 "\n %*s", width,
"ts_target_bitrate:");
221 for (i = 0; i < VPX_TS_MAX_LAYERS; i++)
222 av_log(avctx, level,
"%u ", cfg->ts_target_bitrate[i]);
223 av_log(avctx, level,
"\n");
225 "\n %*s", width,
"ts_rate_decimator:");
226 for (i = 0; i < VPX_TS_MAX_LAYERS; i++)
227 av_log(avctx, level,
"%u ", cfg->ts_rate_decimator[i]);
228 av_log(avctx, level,
"\n");
230 "\n %*s%u\n", width,
"ts_periodicity:", cfg->ts_periodicity);
232 "\n %*s", width,
"ts_layer_id:");
233 for (i = 0; i < VPX_TS_MAX_PERIODICITY; i++)
234 av_log(avctx, level,
"%u ", cfg->ts_layer_id[i]);
235 av_log(avctx, level,
"\n");
236 av_log(avctx, level,
"decoder buffer model\n" 237 " %*s%u\n %*s%u\n %*s%u\n",
238 width,
"rc_buf_sz:", cfg->rc_buf_sz,
239 width,
"rc_buf_initial_sz:", cfg->rc_buf_initial_sz,
240 width,
"rc_buf_optimal_sz:", cfg->rc_buf_optimal_sz);
241 av_log(avctx, level,
"2 pass rate control settings\n" 242 " %*s%u\n %*s%u\n %*s%u\n",
243 width,
"rc_2pass_vbr_bias_pct:", cfg->rc_2pass_vbr_bias_pct,
244 width,
"rc_2pass_vbr_minsection_pct:", cfg->rc_2pass_vbr_minsection_pct,
245 width,
"rc_2pass_vbr_maxsection_pct:", cfg->rc_2pass_vbr_maxsection_pct);
246 #if VPX_ENCODER_ABI_VERSION >= 14 247 av_log(avctx, level,
" %*s%u\n",
248 width,
"rc_2pass_vbr_corpus_complexity:", cfg->rc_2pass_vbr_corpus_complexity);
250 av_log(avctx, level,
"keyframing settings\n" 251 " %*s%d\n %*s%u\n %*s%u\n",
252 width,
"kf_mode:", cfg->kf_mode,
253 width,
"kf_min_dist:", cfg->kf_min_dist,
254 width,
"kf_max_dist:", cfg->kf_max_dist);
255 av_log(avctx, level,
"\n");
288 enum vp8e_enc_control_id
id,
int val)
298 res = vpx_codec_control(&ctx->
encoder,
id, val);
299 if (res != VPX_CODEC_OK) {
300 snprintf(buf,
sizeof(buf),
"Failed to set %s codec control",
305 return res == VPX_CODEC_OK ? 0 :
AVERROR(EINVAL);
308 #if VPX_ENCODER_ABI_VERSION >= 12 310 enum vp8e_enc_control_id
id,
int *
val)
320 res = vpx_codec_control(&ctx->
encoder,
id, val);
321 if (res != VPX_CODEC_OK) {
322 snprintf(buf,
sizeof(buf),
"Failed to set %s codec control",
327 return res == VPX_CODEC_OK ? 0 :
AVERROR(EINVAL);
335 #if VPX_ENCODER_ABI_VERSION >= 12 339 if (!codecctl_intp(avctx, VP9E_GET_LEVEL, &level_out))
344 vpx_codec_destroy(&ctx->
encoder);
356 char *saveptr =
NULL;
357 char *token =
av_strtok(value,
",", &saveptr);
359 while (token && dest_idx < max_entries) {
360 dest[dest_idx++] = strtoul(token,
NULL, 10);
367 size_t value_len = strlen(value);
372 if (!strcmp(key,
"ts_number_layers"))
373 enccfg->ts_number_layers = strtoul(value, &value, 10);
374 else if (!strcmp(key,
"ts_target_bitrate"))
376 else if (!strcmp(key,
"ts_rate_decimator"))
378 else if (!strcmp(key,
"ts_periodicity"))
379 enccfg->ts_periodicity = strtoul(value, &value, 10);
380 else if (!strcmp(key,
"ts_layer_id"))
386 #if CONFIG_LIBVPX_VP9_ENCODER 388 struct vpx_codec_enc_cfg *enccfg, vpx_codec_flags_t *
flags,
389 vpx_img_fmt_t *img_fmt)
392 enccfg->g_bit_depth = enccfg->g_input_bit_depth = 8;
396 enccfg->g_profile = 0;
397 *img_fmt = VPX_IMG_FMT_I420;
400 enccfg->g_profile = 1;
401 *img_fmt = VPX_IMG_FMT_I422;
404 enccfg->g_profile = 1;
405 *img_fmt = VPX_IMG_FMT_I440;
408 ctx->vpx_cs = VPX_CS_SRGB;
410 enccfg->g_profile = 1;
411 *img_fmt = VPX_IMG_FMT_I444;
415 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {
416 enccfg->g_bit_depth = enccfg->g_input_bit_depth =
418 enccfg->g_profile = 2;
419 *img_fmt = VPX_IMG_FMT_I42016;
420 *
flags |= VPX_CODEC_USE_HIGHBITDEPTH;
426 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {
427 enccfg->g_bit_depth = enccfg->g_input_bit_depth =
429 enccfg->g_profile = 3;
430 *img_fmt = VPX_IMG_FMT_I42216;
431 *
flags |= VPX_CODEC_USE_HIGHBITDEPTH;
437 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {
438 enccfg->g_bit_depth = enccfg->g_input_bit_depth =
440 enccfg->g_profile = 3;
441 *img_fmt = VPX_IMG_FMT_I44016;
442 *
flags |= VPX_CODEC_USE_HIGHBITDEPTH;
448 ctx->vpx_cs = VPX_CS_SRGB;
451 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {
452 enccfg->g_bit_depth = enccfg->g_input_bit_depth =
455 enccfg->g_profile = 3;
456 *img_fmt = VPX_IMG_FMT_I44416;
457 *
flags |= VPX_CODEC_USE_HIGHBITDEPTH;
470 enum vpx_color_space vpx_cs;
494 #if VPX_ENCODER_ABI_VERSION >= 11 497 enum vpx_color_range vpx_cr;
514 const struct vpx_codec_iface *iface)
517 struct vpx_codec_enc_cfg enccfg = { 0 };
518 struct vpx_codec_enc_cfg enccfg_alpha;
522 vpx_img_fmt_t img_fmt = VPX_IMG_FMT_I420;
523 #if CONFIG_LIBVPX_VP9_ENCODER 524 vpx_codec_caps_t codec_caps = vpx_codec_get_caps(iface);
533 if ((res = vpx_codec_enc_config_default(iface, &enccfg, 0)) != VPX_CODEC_OK) {
535 vpx_codec_err_to_string(res));
539 #if CONFIG_LIBVPX_VP9_ENCODER 541 if (
set_pix_fmt(avctx, codec_caps, &enccfg, &flags, &img_fmt))
554 enccfg.g_w = avctx->
width;
555 enccfg.g_h = avctx->
height;
563 enccfg.g_pass = VPX_RC_FIRST_PASS;
565 enccfg.g_pass = VPX_RC_LAST_PASS;
567 enccfg.g_pass = VPX_RC_ONE_PASS;
571 enccfg.rc_end_usage = VPX_CBR;
572 }
else if (ctx->
crf >= 0) {
573 enccfg.rc_end_usage = VPX_CQ;
574 #if CONFIG_LIBVPX_VP9_ENCODER 576 enccfg.rc_end_usage = VPX_Q;
583 #if CONFIG_LIBVPX_VP9_ENCODER 584 }
else if (enccfg.rc_end_usage == VPX_Q) {
587 if (enccfg.rc_end_usage == VPX_CQ) {
588 enccfg.rc_target_bitrate = 1000000;
590 avctx->
bit_rate = enccfg.rc_target_bitrate * 1000;
592 "Neither bitrate nor constrained quality specified, using default bitrate of %dkbit/sec\n",
593 enccfg.rc_target_bitrate);
598 enccfg.rc_min_quantizer =
599 enccfg.rc_max_quantizer = 0;
601 if (avctx->
qmin >= 0)
602 enccfg.rc_min_quantizer = avctx->
qmin;
603 if (avctx->
qmax >= 0)
604 enccfg.rc_max_quantizer = avctx->
qmax;
607 if (enccfg.rc_end_usage == VPX_CQ
609 || enccfg.rc_end_usage == VPX_Q
612 if (ctx->
crf < enccfg.rc_min_quantizer || ctx->
crf > enccfg.rc_max_quantizer) {
614 "CQ level %d must be between minimum and maximum quantizer value (%d-%d)\n",
615 ctx->
crf, enccfg.rc_min_quantizer, enccfg.rc_max_quantizer);
620 #if FF_API_PRIVATE_OPT 631 enccfg.rc_2pass_vbr_minsection_pct =
634 enccfg.rc_2pass_vbr_maxsection_pct =
636 #if CONFIG_LIBVPX_VP9_ENCODER 638 #if VPX_ENCODER_ABI_VERSION >= 14 649 enccfg.rc_buf_initial_sz =
651 enccfg.rc_buf_optimal_sz = enccfg.rc_buf_sz * 5 / 6;
661 enccfg.kf_max_dist = avctx->
gop_size;
663 if (enccfg.g_pass == VPX_RC_FIRST_PASS)
664 enccfg.g_lag_in_frames = 0;
665 else if (enccfg.g_pass == VPX_RC_LAST_PASS) {
666 int decode_size, ret;
684 if (decode_size < 0) {
697 enccfg.g_profile = avctx->
profile;
709 "Error parsing option '%s = %s'.\n",
719 res = vpx_codec_enc_init(&ctx->
encoder, iface, &enccfg, flags);
720 if (res != VPX_CODEC_OK) {
726 enccfg_alpha = enccfg;
727 res = vpx_codec_enc_init(&ctx->
encoder_alpha, iface, &enccfg_alpha, flags);
728 if (res != VPX_CODEC_OK) {
752 av_log(avctx,
AV_LOG_ERROR,
"Transparency encoding with auto_alt_ref does not work\n");
760 #if FF_API_PRIVATE_OPT 775 #if CONFIG_LIBVPX_VP9_ENCODER 787 set_colorspace(avctx);
788 #if VPX_ENCODER_ABI_VERSION >= 11 791 #if VPX_ENCODER_ABI_VERSION >= 12 794 #ifdef VPX_CTRL_VP9E_SET_ROW_MT 798 #ifdef VPX_CTRL_VP9E_SET_TUNE_CONTENT 802 #ifdef VPX_CTRL_VP9E_SET_TPL 814 #if CONFIG_LIBVPX_VP9_ENCODER 816 ctx->
rawimg.bit_depth = enccfg.g_bit_depth;
827 if (enccfg.rc_end_usage == VPX_CBR ||
828 enccfg.g_pass != VPX_RC_ONE_PASS) {
839 const struct vpx_codec_cx_pkt *
src,
840 const struct vpx_codec_cx_pkt *src_alpha,
843 dst->
pts = src->data.frame.pts;
844 dst->
duration = src->data.frame.duration;
845 dst->
flags = src->data.frame.flags;
846 dst->
sz = src->data.frame.sz;
847 dst->
buf = src->data.frame.buf;
850 if (!(dst->
flags & VPX_FRAME_IS_INVISIBLE)) {
858 memcpy(dst->
sse, ctx->
sse,
sizeof(dst->
sse));
865 dst->
buf_alpha = src_alpha->data.frame.buf;
866 dst->
sz_alpha = src_alpha->data.frame.sz;
889 #if FF_API_CODED_FRAME 896 if (!!(cx_frame->
flags & VPX_FRAME_IS_KEY)) {
898 #if FF_API_CODED_FRAME 906 #if FF_API_CODED_FRAME 914 cx_frame->
have_sse ? 3 : 0, pict_type);
919 #if FF_API_CODED_FRAME 927 for (i = 0; i < 3; ++
i) {
961 const struct vpx_codec_cx_pkt *
pkt;
962 const struct vpx_codec_cx_pkt *pkt_alpha =
NULL;
963 const void *iter =
NULL;
964 const void *iter_alpha =
NULL;
979 while ((pkt = vpx_codec_get_cx_data(&ctx->
encoder, &iter)) &&
981 (pkt_alpha = vpx_codec_get_cx_data(&ctx->
encoder_alpha, &iter_alpha)))) {
983 case VPX_CODEC_CX_FRAME_PKT:
990 cx_pktcpy(&cx_frame, pkt, pkt_alpha, ctx);
1000 "Frame queue element alloc failed\n");
1003 cx_pktcpy(cx_frame, pkt, pkt_alpha, ctx);
1006 if (!cx_frame->
buf) {
1013 memcpy(cx_frame->
buf, pkt->data.frame.buf, pkt->data.frame.sz);
1023 memcpy(cx_frame->
buf_alpha, pkt_alpha->data.frame.buf, pkt_alpha->data.frame.sz);
1028 case VPX_CODEC_STATS_PKT: {
1033 pkt->data.twopass_stats.sz)) < 0) {
1038 memcpy((
uint8_t*)stats->buf + stats->sz,
1039 pkt->data.twopass_stats.buf, pkt->data.twopass_stats.sz);
1040 stats->sz += pkt->data.twopass_stats.sz;
1043 case VPX_CODEC_PSNR_PKT:
1045 ctx->
sse[0] = pkt->data.psnr.sse[0];
1046 ctx->
sse[1] = pkt->data.psnr.sse[1];
1047 ctx->
sse[2] = pkt->data.psnr.sse[2];
1048 ctx->
sse[3] = pkt->data.psnr.sse[3];
1051 case VPX_CODEC_CUSTOM_PKT:
1064 struct vpx_image *rawimg =
NULL;
1065 struct vpx_image *rawimg_alpha =
NULL;
1066 int64_t timestamp = 0;
1067 int res, coded_size;
1068 vpx_enc_frame_flags_t
flags = 0;
1072 rawimg->planes[VPX_PLANE_Y] = frame->
data[0];
1073 rawimg->planes[VPX_PLANE_U] = frame->
data[1];
1074 rawimg->planes[VPX_PLANE_V] = frame->
data[2];
1075 rawimg->stride[VPX_PLANE_Y] = frame->
linesize[0];
1076 rawimg->stride[VPX_PLANE_U] = frame->
linesize[1];
1077 rawimg->stride[VPX_PLANE_V] = frame->
linesize[2];
1081 rawimg_alpha->planes[VPX_PLANE_Y] = frame->
data[3];
1084 if (!u_plane || !v_plane) {
1090 rawimg_alpha->planes[VPX_PLANE_U] = u_plane;
1092 rawimg_alpha->planes[VPX_PLANE_V] = v_plane;
1093 rawimg_alpha->stride[VPX_PLANE_Y] = frame->
linesize[0];
1094 rawimg_alpha->stride[VPX_PLANE_U] = frame->
linesize[1];
1095 rawimg_alpha->stride[VPX_PLANE_V] = frame->
linesize[2];
1097 timestamp = frame->
pts;
1098 #if VPX_IMAGE_ABI_VERSION >= 4 1101 rawimg->range = VPX_CR_STUDIO_RANGE;
1104 rawimg->range = VPX_CR_FULL_RANGE;
1109 flags |= VPX_EFLAG_FORCE_KF;
1118 res = vpx_codec_encode(&ctx->
encoder, rawimg, timestamp,
1120 if (res != VPX_CODEC_OK) {
1126 res = vpx_codec_encode(&ctx->
encoder_alpha, rawimg_alpha, timestamp,
1128 if (res != VPX_CODEC_OK) {
1150 av_freep(&rawimg_alpha->planes[VPX_PLANE_U]);
1151 av_freep(&rawimg_alpha->planes[VPX_PLANE_V]);
1154 *got_packet = !!coded_size;
1158 #define OFFSET(x) offsetof(VPxContext, x) 1159 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM 1161 #define COMMON_OPTIONS \ 1162 { "lag-in-frames", "Number of frames to look ahead for " \ 1163 "alternate reference frame selection", OFFSET(lag_in_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \ 1164 { "arnr-maxframes", "altref noise reduction max frame count", OFFSET(arnr_max_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \ 1165 { "arnr-strength", "altref noise reduction filter strength", OFFSET(arnr_strength), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \ 1166 { "arnr-type", "altref noise reduction filter type", OFFSET(arnr_type), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE, "arnr_type"}, \ 1167 { "backward", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0, VE, "arnr_type" }, \ 1168 { "forward", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0, VE, "arnr_type" }, \ 1169 { "centered", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 3}, 0, 0, VE, "arnr_type" }, \ 1170 { "tune", "Tune the encoding to a specific scenario", OFFSET(tune), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE, "tune"}, \ 1171 { "psnr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VP8_TUNE_PSNR}, 0, 0, VE, "tune"}, \ 1172 { "ssim", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VP8_TUNE_SSIM}, 0, 0, VE, "tune"}, \ 1173 { "deadline", "Time to spend encoding, in microseconds.", OFFSET(deadline), AV_OPT_TYPE_INT, {.i64 = VPX_DL_GOOD_QUALITY}, INT_MIN, INT_MAX, VE, "quality"}, \ 1174 { "best", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_BEST_QUALITY}, 0, 0, VE, "quality"}, \ 1175 { "good", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_GOOD_QUALITY}, 0, 0, VE, "quality"}, \ 1176 { "realtime", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_REALTIME}, 0, 0, VE, "quality"}, \ 1177 { "error-resilient", "Error resilience configuration", OFFSET(error_resilient), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, VE, "er"}, \ 1178 { "max-intra-rate", "Maximum I-frame bitrate (pct) 0=unlimited", OFFSET(max_intra_rate), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \ 1179 { "default", "Improve resiliency against losses of whole frames", 0, AV_OPT_TYPE_CONST, {.i64 = VPX_ERROR_RESILIENT_DEFAULT}, 0, 0, VE, "er"}, \ 1180 { "partitions", "The frame partitions are independently decodable " \ 1181 "by the bool decoder, meaning that partitions can be decoded even " \ 1182 "though earlier partitions have been lost. Note that intra predicition" \ 1183 " is still done over the partition boundary.", 0, AV_OPT_TYPE_CONST, {.i64 = VPX_ERROR_RESILIENT_PARTITIONS}, 0, 0, VE, "er"}, \ 1184 { "crf", "Select the quality for constant quality mode", offsetof(VPxContext, crf), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 63, VE }, \ 1185 { "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 }, \ 1186 { "drop-threshold", "Frame drop threshold", offsetof(VPxContext, drop_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, VE }, \ 1187 { "noise-sensitivity", "Noise sensitivity", OFFSET(noise_sensitivity), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 4, VE}, \ 1188 { "undershoot-pct", "Datarate undershoot (min) target (%)", OFFSET(rc_undershoot_pct), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 100, VE }, \ 1189 { "overshoot-pct", "Datarate overshoot (max) target (%)", OFFSET(rc_overshoot_pct), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1000, VE }, \ 1191 #define LEGACY_OPTIONS \ 1192 {"speed", "", offsetof(VPxContext, cpu_used), AV_OPT_TYPE_INT, {.i64 = 1}, -16, 16, VE}, \ 1193 {"quality", "", offsetof(VPxContext, deadline), AV_OPT_TYPE_INT, {.i64 = VPX_DL_GOOD_QUALITY}, INT_MIN, INT_MAX, VE, "quality"}, \ 1194 {"vp8flags", "", offsetof(VPxContext, flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, 0, UINT_MAX, VE, "flags"}, \ 1195 {"error_resilient", "enable error resilience", 0, AV_OPT_TYPE_CONST, {.i64 = VP8F_ERROR_RESILIENT}, INT_MIN, INT_MAX, VE, "flags"}, \ 1196 {"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"}, \ 1197 {"arnr_max_frames", "altref noise reduction max frame count", offsetof(VPxContext, arnr_max_frames), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 15, VE}, \ 1198 {"arnr_strength", "altref noise reduction filter strength", offsetof(VPxContext, arnr_strength), AV_OPT_TYPE_INT, {.i64 = 3}, 0, 6, VE}, \ 1199 {"arnr_type", "altref noise reduction filter type", offsetof(VPxContext, arnr_type), AV_OPT_TYPE_INT, {.i64 = 3}, 1, 3, VE}, \ 1200 {"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}, \ 1201 {"sharpness", "Increase sharpness at the expense of lower PSNR", offsetof(VPxContext, sharpness), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 7, VE}, 1203 #if CONFIG_LIBVPX_VP8_ENCODER 1204 static const AVOption vp8_options[] = {
1206 {
"auto-alt-ref",
"Enable use of alternate reference " 1209 {
"ts-parameters",
"Temporal scaling configuration using a " 1216 #if CONFIG_LIBVPX_VP9_ENCODER 1217 static const AVOption vp9_options[] = {
1219 {
"auto-alt-ref",
"Enable use of alternate reference " 1223 {
"tile-columns",
"Number of tile columns to use, log2",
OFFSET(tile_columns),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6,
VE},
1225 {
"frame-parallel",
"Enable frame parallel decodability features",
OFFSET(frame_parallel),
AV_OPT_TYPE_BOOL,{.i64 = -1}, -1, 1,
VE},
1226 #if VPX_ENCODER_ABI_VERSION >= 12 1227 {
"aq-mode",
"adaptive quantization mode",
OFFSET(aq_mode),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 4,
VE,
"aq_mode"},
1229 {
"aq-mode",
"adaptive quantization mode",
OFFSET(aq_mode),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 3,
VE,
"aq_mode"},
1232 {
"variance",
"Variance based Aq", 0,
AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0,
VE,
"aq_mode" },
1233 {
"complexity",
"Complexity based Aq", 0,
AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0,
VE,
"aq_mode" },
1235 #if VPX_ENCODER_ABI_VERSION >= 12 1239 #ifdef VPX_CTRL_VP9E_SET_ROW_MT 1242 #ifdef VPX_CTRL_VP9E_SET_TUNE_CONTENT 1243 #if VPX_ENCODER_ABI_VERSION >= 14 1244 {
"tune-content",
"Tune content type",
OFFSET(tune_content),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 2,
VE,
"tune_content" },
1246 {
"tune-content",
"Tune content type",
OFFSET(tune_content),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1,
VE,
"tune_content" },
1248 {
"default",
"Regular video content", 0,
AV_OPT_TYPE_CONST, {.i64 = 0}, 0, 0,
VE,
"tune_content" },
1249 {
"screen",
"Screen capture content", 0,
AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0,
VE,
"tune_content" },
1250 #if VPX_ENCODER_ABI_VERSION >= 14 1251 {
"film",
"Film content; improves grain retention", 0,
AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0,
VE,
"tune_content" },
1254 #if VPX_ENCODER_ABI_VERSION >= 14 1255 {
"corpus-complexity",
"corpus vbr complexity midpoint",
OFFSET(corpus_complexity),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 10000,
VE },
1257 #ifdef VPX_CTRL_VP9E_SET_TPL 1265 #undef COMMON_OPTIONS 1266 #undef LEGACY_OPTIONS 1272 {
"keyint_min",
"-1" },
1276 #if CONFIG_LIBVPX_VP8_ENCODER 1279 return vpx_init(avctx, vpx_codec_vp8_cx());
1282 static const AVClass class_vp8 = {
1285 .option = vp8_options,
1300 .priv_class = &class_vp8,
1302 .wrapper_name =
"libvpx",
1306 #if CONFIG_LIBVPX_VP9_ENCODER 1309 return vpx_init(avctx, vpx_codec_vp9_cx());
1312 static const AVClass class_vp9 = {
1315 .option = vp9_options,
1320 .
name =
"libvpx-vp9",
1330 .priv_class = &class_vp9,
1333 .wrapper_name =
"libvpx",
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
const char const char void * val
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define AV_PIX_FMT_YUV440P10
This structure describes decoded (raw) audio or video data.
static av_cold int vpx_free(AVCodecContext *avctx)
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
uint64_t error[AV_NUM_DATA_POINTERS]
error
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
#define AV_LOG_WARNING
Something somehow does not look correct.
int64_t bit_rate
the average bitrate
#define LIBAVUTIL_VERSION_INT
static av_cold int init(AVCodecContext *avctx)
struct FrameListData * coded_frame_list
int max_bitrate
Maximum bitrate of the stream, in bits per second.
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601 ...
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
enum AVColorRange color_range
MPEG vs JPEG YUV range.
void * buf
compressed data buffer
#define AV_PIX_FMT_GBRP10
const char * av_default_item_name(void *ptr)
Return the context name.
also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
size_t sz
length of compressed data
#define AV_PIX_FMT_YUV420P12
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
static void cx_pktcpy(struct FrameListData *dst, const struct vpx_codec_cx_pkt *src, const struct vpx_codec_cx_pkt *src_alpha, VPxContext *ctx)
#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 time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
#define VP8F_AUTO_ALT_REF
Enable automatic alternate reference frame generation.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
struct FrameListData * next
static av_cold int codecctl_int(AVCodecContext *avctx, enum vp8e_enc_control_id id, int val)
int64_t pts
time stamp to show frame (in timebase units)
AVCodec ff_libvpx_vp8_encoder
static void coded_frame_add(void *list, struct FrameListData *cx_frame)
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
#define CONFIG_LIBVPX_VP9_ENCODER
#define AV_LOG_VERBOSE
Detailed information.
AVDictionary * metadata
metadata.
int buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
#define AV_PIX_FMT_YUV422P12
char * stats_out
pass1 encoding statistics output buffer
attribute_deprecated uint64_t error[AV_NUM_DATA_POINTERS]
attribute_deprecated int frame_skip_threshold
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
static int vpx_encode(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
#define i(width, name, range_min, range_max)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static int storeframe(AVCodecContext *avctx, struct FrameListData *cx_frame, AVPacket *pkt)
Store coded frame information in format suitable for return from encode2().
#define CONFIG_LIBVPX_VP8_ENCODER
int qmax
maximum quantizer
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
enum AVColorRange color_range
MPEG vs JPEG YUV range.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
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
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)
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.
static void error(const char *err)
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
the normal 2^n-1 "JPEG" YUV ranges
AVCodec ff_libvpx_vp9_encoder
#define VP8F_ERROR_RESILIENT
Enable measures appropriate for streaming over lossy links.
static av_cold int vpx_init(AVCodecContext *avctx, const struct vpx_codec_iface *iface)
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)
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.
int qmin
minimum quantizer
Data found in BlockAdditional element of matroska container.
#define AV_PIX_FMT_YUV420P10
Describe the class of an AVClass context structure.
static const AVProfile profiles[]
enum AVColorSpace colorspace
YUV colorspace type.
static int set_pix_fmt(AVCodecContext *avctx, struct aom_image *img)
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.
the normal 219*2^(n-8) "MPEG" YUV ranges
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok()...
int flags
VP8 specific flags, see VP8F_* below.
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
static const char *const ctlidstr[]
String mappings for enum vp8e_enc_control_id.
struct vpx_codec_ctx encoder_alpha
static av_cold int vp8_init(AVFormatContext *s, int st_index, PayloadContext *vp8)
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
#define FF_DISABLE_DEPRECATION_WARNINGS
common internal api header.
common internal and external API header
struct vpx_codec_ctx encoder
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
static av_cold void free_frame_list(struct FrameListData *list)
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
int slices
Number of slices.
#define FF_ENABLE_DEPRECATION_WARNINGS
Portion of struct vpx_codec_cx_pkt from vpx_encoder.h.
int avg_bitrate
Average bitrate of the stream, in bits per second.
static int vp8_ts_param_parse(struct vpx_codec_enc_cfg *enccfg, char *key, char *value)
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.
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
const AVProfile ff_vp9_profiles[]
AVPixelFormat
Pixel format.
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
int keyint_min
minimum GOP size