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>
61 typedef struct VP8EncoderContext {
63 struct vpx_codec_ctx encoder;
64 struct vpx_image rawimg;
65 struct vpx_codec_ctx encoder_alpha;
66 struct vpx_image rawimg_alpha;
68 struct vpx_fixed_buf twopass_stats;
80 #define VP8F_ERROR_RESILIENT 0x00000001
81 #define VP8F_AUTO_ALT_REF 0x00000002
107 [VP8E_SET_CPUUSED] =
"VP8E_SET_CPUUSED",
108 [VP8E_SET_ENABLEAUTOALTREF] =
"VP8E_SET_ENABLEAUTOALTREF",
109 [VP8E_SET_NOISE_SENSITIVITY] =
"VP8E_SET_NOISE_SENSITIVITY",
110 [VP8E_SET_STATIC_THRESHOLD] =
"VP8E_SET_STATIC_THRESHOLD",
111 [VP8E_SET_TOKEN_PARTITIONS] =
"VP8E_SET_TOKEN_PARTITIONS",
112 [VP8E_SET_ARNR_MAXFRAMES] =
"VP8E_SET_ARNR_MAXFRAMES",
113 [VP8E_SET_ARNR_STRENGTH] =
"VP8E_SET_ARNR_STRENGTH",
114 [VP8E_SET_ARNR_TYPE] =
"VP8E_SET_ARNR_TYPE",
115 [VP8E_SET_CQ_LEVEL] =
"VP8E_SET_CQ_LEVEL",
116 [VP8E_SET_MAX_INTRA_BITRATE_PCT] =
"VP8E_SET_MAX_INTRA_BITRATE_PCT",
117 #if CONFIG_LIBVPX_VP9_ENCODER
118 [VP9E_SET_LOSSLESS] =
"VP9E_SET_LOSSLESS",
119 [VP9E_SET_TILE_COLUMNS] =
"VP9E_SET_TILE_COLUMNS",
120 [VP9E_SET_TILE_ROWS] =
"VP9E_SET_TILE_ROWS",
121 [VP9E_SET_FRAME_PARALLEL_DECODING] =
"VP9E_SET_FRAME_PARALLEL_DECODING",
122 [VP9E_SET_AQ_MODE] =
"VP9E_SET_AQ_MODE",
123 #if VPX_ENCODER_ABI_VERSION > 8
124 [VP9E_SET_COLOR_SPACE] =
"VP9E_SET_COLOR_SPACE",
132 const char *error = vpx_codec_error(&ctx->
encoder);
133 const char *detail = vpx_codec_error_detail(&ctx->
encoder);
141 const struct vpx_codec_enc_cfg *cfg)
146 av_log(avctx, level,
"vpx_codec_enc_cfg\n");
147 av_log(avctx, level,
"generic settings\n"
148 " %*s%u\n %*s%u\n %*s%u\n %*s%u\n %*s%u\n"
152 " %*s{%u/%u}\n %*s%u\n %*s%d\n %*s%u\n",
153 width,
"g_usage:", cfg->g_usage,
154 width,
"g_threads:", cfg->g_threads,
155 width,
"g_profile:", cfg->g_profile,
156 width,
"g_w:", cfg->g_w,
157 width,
"g_h:", cfg->g_h,
159 width,
"g_bit_depth:", cfg->g_bit_depth,
160 width,
"g_input_bit_depth:", cfg->g_input_bit_depth,
162 width,
"g_timebase:", cfg->g_timebase.num, cfg->g_timebase.den,
163 width,
"g_error_resilient:", cfg->g_error_resilient,
164 width,
"g_pass:", cfg->g_pass,
165 width,
"g_lag_in_frames:", cfg->g_lag_in_frames);
166 av_log(avctx, level,
"rate control settings\n"
167 " %*s%u\n %*s%u\n %*s%u\n %*s%u\n"
169 width,
"rc_dropframe_thresh:", cfg->rc_dropframe_thresh,
170 width,
"rc_resize_allowed:", cfg->rc_resize_allowed,
171 width,
"rc_resize_up_thresh:", cfg->rc_resize_up_thresh,
172 width,
"rc_resize_down_thresh:", cfg->rc_resize_down_thresh,
173 width,
"rc_end_usage:", cfg->rc_end_usage,
174 width,
"rc_twopass_stats_in:", cfg->rc_twopass_stats_in.buf, cfg->rc_twopass_stats_in.sz,
175 width,
"rc_target_bitrate:", cfg->rc_target_bitrate);
176 av_log(avctx, level,
"quantizer settings\n"
178 width,
"rc_min_quantizer:", cfg->rc_min_quantizer,
179 width,
"rc_max_quantizer:", cfg->rc_max_quantizer);
180 av_log(avctx, level,
"bitrate tolerance\n"
182 width,
"rc_undershoot_pct:", cfg->rc_undershoot_pct,
183 width,
"rc_overshoot_pct:", cfg->rc_overshoot_pct);
184 av_log(avctx, level,
"decoder buffer model\n"
185 " %*s%u\n %*s%u\n %*s%u\n",
186 width,
"rc_buf_sz:", cfg->rc_buf_sz,
187 width,
"rc_buf_initial_sz:", cfg->rc_buf_initial_sz,
188 width,
"rc_buf_optimal_sz:", cfg->rc_buf_optimal_sz);
189 av_log(avctx, level,
"2 pass rate control settings\n"
190 " %*s%u\n %*s%u\n %*s%u\n",
191 width,
"rc_2pass_vbr_bias_pct:", cfg->rc_2pass_vbr_bias_pct,
192 width,
"rc_2pass_vbr_minsection_pct:", cfg->rc_2pass_vbr_minsection_pct,
193 width,
"rc_2pass_vbr_maxsection_pct:", cfg->rc_2pass_vbr_maxsection_pct);
194 av_log(avctx, level,
"keyframing settings\n"
195 " %*s%d\n %*s%u\n %*s%u\n",
196 width,
"kf_mode:", cfg->kf_mode,
197 width,
"kf_min_dist:", cfg->kf_min_dist,
198 width,
"kf_max_dist:", cfg->kf_max_dist);
199 av_log(avctx, level,
"\n");
232 enum vp8e_enc_control_id
id,
int val)
242 res = vpx_codec_control(&ctx->
encoder,
id, val);
243 if (res != VPX_CODEC_OK) {
244 snprintf(buf,
sizeof(buf),
"Failed to set %s codec control",
249 return res == VPX_CODEC_OK ? 0 :
AVERROR(EINVAL);
256 vpx_codec_destroy(&ctx->
encoder);
265 #if CONFIG_LIBVPX_VP9_ENCODER
267 struct vpx_codec_enc_cfg *enccfg, vpx_codec_flags_t *
flags,
268 vpx_img_fmt_t *img_fmt)
270 #ifdef VPX_IMG_FMT_HIGHBITDEPTH
271 enccfg->g_bit_depth = enccfg->g_input_bit_depth = 8;
275 enccfg->g_profile = 0;
276 *img_fmt = VPX_IMG_FMT_I420;
279 enccfg->g_profile = 1;
280 *img_fmt = VPX_IMG_FMT_I422;
282 #if VPX_IMAGE_ABI_VERSION >= 3
284 enccfg->g_profile = 1;
285 *img_fmt = VPX_IMG_FMT_I440;
289 enccfg->g_profile = 1;
290 *img_fmt = VPX_IMG_FMT_I444;
292 #ifdef VPX_IMG_FMT_HIGHBITDEPTH
295 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {
296 enccfg->g_bit_depth = enccfg->g_input_bit_depth =
298 enccfg->g_profile = 2;
299 *img_fmt = VPX_IMG_FMT_I42016;
300 *flags |= VPX_CODEC_USE_HIGHBITDEPTH;
306 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {
307 enccfg->g_bit_depth = enccfg->g_input_bit_depth =
309 enccfg->g_profile = 3;
310 *img_fmt = VPX_IMG_FMT_I42216;
311 *flags |= VPX_CODEC_USE_HIGHBITDEPTH;
315 #if VPX_IMAGE_ABI_VERSION >= 3
318 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {
319 enccfg->g_bit_depth = enccfg->g_input_bit_depth =
321 enccfg->g_profile = 3;
322 *img_fmt = VPX_IMG_FMT_I44016;
323 *flags |= VPX_CODEC_USE_HIGHBITDEPTH;
330 if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {
331 enccfg->g_bit_depth = enccfg->g_input_bit_depth =
333 enccfg->g_profile = 3;
334 *img_fmt = VPX_IMG_FMT_I44416;
335 *flags |= VPX_CODEC_USE_HIGHBITDEPTH;
347 #if VPX_ENCODER_ABI_VERSION > 8
350 enum vpx_color_space vpx_cs;
372 const struct vpx_codec_iface *iface)
375 struct vpx_codec_enc_cfg enccfg = { 0 };
376 struct vpx_codec_enc_cfg enccfg_alpha;
379 vpx_img_fmt_t img_fmt = VPX_IMG_FMT_I420;
380 #if CONFIG_LIBVPX_VP9_ENCODER
381 vpx_codec_caps_t codec_caps = vpx_codec_get_caps(iface);
390 if ((res = vpx_codec_enc_config_default(iface, &enccfg, 0)) != VPX_CODEC_OK) {
392 vpx_codec_err_to_string(res));
396 #if CONFIG_LIBVPX_VP9_ENCODER
398 if (
set_pix_fmt(avctx, codec_caps, &enccfg, &flags, &img_fmt))
411 enccfg.g_w = avctx->
width;
412 enccfg.g_h = avctx->
height;
419 enccfg.g_pass = VPX_RC_FIRST_PASS;
421 enccfg.g_pass = VPX_RC_LAST_PASS;
423 enccfg.g_pass = VPX_RC_ONE_PASS;
427 enccfg.rc_end_usage = VPX_CBR;
428 }
else if (ctx->
crf >= 0) {
429 enccfg.rc_end_usage = VPX_CQ;
430 #if CONFIG_LIBVPX_VP9_ENCODER
432 enccfg.rc_end_usage = VPX_Q;
439 #if CONFIG_LIBVPX_VP9_ENCODER
440 }
else if (enccfg.rc_end_usage == VPX_Q) {
443 if (enccfg.rc_end_usage == VPX_CQ) {
444 enccfg.rc_target_bitrate = 1000000;
446 avctx->
bit_rate = enccfg.rc_target_bitrate * 1000;
448 "Neither bitrate nor constrained quality specified, using default bitrate of %dkbit/sec\n",
449 enccfg.rc_target_bitrate);
454 enccfg.rc_min_quantizer =
455 enccfg.rc_max_quantizer = 0;
457 if (avctx->
qmin >= 0)
458 enccfg.rc_min_quantizer = avctx->
qmin;
459 if (avctx->
qmax >= 0)
460 enccfg.rc_max_quantizer = avctx->
qmax;
463 if (enccfg.rc_end_usage == VPX_CQ
465 || enccfg.rc_end_usage == VPX_Q
468 if (ctx->
crf < enccfg.rc_min_quantizer || ctx->
crf > enccfg.rc_max_quantizer) {
470 "CQ level %d must be between minimum and maximum quantizer value (%d-%d)\n",
471 ctx->
crf, enccfg.rc_min_quantizer, enccfg.rc_max_quantizer);
481 enccfg.rc_2pass_vbr_minsection_pct =
484 enccfg.rc_2pass_vbr_maxsection_pct =
491 enccfg.rc_buf_initial_sz =
493 enccfg.rc_buf_optimal_sz = enccfg.rc_buf_sz * 5 / 6;
498 "deprecated, use the undershoot-pct private option instead.\n");
512 enccfg.kf_max_dist = avctx->
gop_size;
514 if (enccfg.g_pass == VPX_RC_FIRST_PASS)
515 enccfg.g_lag_in_frames = 0;
516 else if (enccfg.g_pass == VPX_RC_LAST_PASS) {
517 int decode_size, ret;
535 if (decode_size < 0) {
548 enccfg.g_profile = avctx->
profile;
554 res = vpx_codec_enc_init(&ctx->
encoder, iface, &enccfg, flags);
555 if (res != VPX_CODEC_OK) {
561 enccfg_alpha = enccfg;
562 res = vpx_codec_enc_init(&ctx->
encoder_alpha, iface, &enccfg_alpha, flags);
563 if (res != VPX_CODEC_OK) {
591 "use the static-thresh private option instead.\n");
602 #if CONFIG_LIBVPX_VP9_ENCODER
614 #if VPX_ENCODER_ABI_VERSION > 8
615 set_colorspace(avctx);
625 #if CONFIG_LIBVPX_VP9_ENCODER && defined(VPX_IMG_FMT_HIGHBITDEPTH)
627 ctx->
rawimg.bit_depth = enccfg.g_bit_depth;
638 const struct vpx_codec_cx_pkt *
src,
639 const struct vpx_codec_cx_pkt *src_alpha,
642 dst->
pts = src->data.frame.pts;
643 dst->
duration = src->data.frame.duration;
644 dst->
flags = src->data.frame.flags;
645 dst->
sz = src->data.frame.sz;
646 dst->
buf = src->data.frame.buf;
649 if (!(dst->
flags & VPX_FRAME_IS_INVISIBLE)) {
657 memcpy(dst->
sse, ctx->
sse,
sizeof(dst->
sse));
664 dst->
buf_alpha = src_alpha->data.frame.buf;
665 dst->
sz_alpha = src_alpha->data.frame.sz;
688 #if FF_API_CODED_FRAME
695 if (!!(cx_frame->
flags & VPX_FRAME_IS_KEY)) {
697 #if FF_API_CODED_FRAME
705 #if FF_API_CODED_FRAME
713 cx_frame->
have_sse ? 3 : 0, pict_type);
718 #if FF_API_CODED_FRAME
726 for (i = 0; i < 3; ++i) {
727 avctx->
error[i] += cx_frame->
sse[i + 1];
759 const struct vpx_codec_cx_pkt *
pkt;
760 const struct vpx_codec_cx_pkt *pkt_alpha =
NULL;
761 const void *iter =
NULL;
762 const void *iter_alpha =
NULL;
777 while ((pkt = vpx_codec_get_cx_data(&ctx->
encoder, &iter)) &&
781 case VPX_CODEC_CX_FRAME_PKT:
788 cx_pktcpy(&cx_frame, pkt, pkt_alpha, ctx);
798 "Frame queue element alloc failed\n");
801 cx_pktcpy(cx_frame, pkt, pkt_alpha, ctx);
804 if (!cx_frame->
buf) {
811 memcpy(cx_frame->
buf, pkt->data.frame.buf, pkt->data.frame.sz);
821 memcpy(cx_frame->
buf_alpha, pkt_alpha->data.frame.buf, pkt_alpha->data.frame.sz);
826 case VPX_CODEC_STATS_PKT: {
831 pkt->data.twopass_stats.sz)) < 0) {
836 memcpy((
uint8_t*)stats->buf + stats->sz,
837 pkt->data.twopass_stats.buf, pkt->data.twopass_stats.sz);
838 stats->sz += pkt->data.twopass_stats.sz;
841 case VPX_CODEC_PSNR_PKT:
843 ctx->
sse[0] = pkt->data.psnr.sse[0];
844 ctx->
sse[1] = pkt->data.psnr.sse[1];
845 ctx->
sse[2] = pkt->data.psnr.sse[2];
846 ctx->
sse[3] = pkt->data.psnr.sse[3];
849 case VPX_CODEC_CUSTOM_PKT:
862 struct vpx_image *rawimg =
NULL;
863 struct vpx_image *rawimg_alpha =
NULL;
864 int64_t timestamp = 0;
866 vpx_enc_frame_flags_t flags = 0;
870 rawimg->planes[VPX_PLANE_Y] = frame->
data[0];
871 rawimg->planes[VPX_PLANE_U] = frame->
data[1];
872 rawimg->planes[VPX_PLANE_V] = frame->
data[2];
873 rawimg->stride[VPX_PLANE_Y] = frame->
linesize[0];
874 rawimg->stride[VPX_PLANE_U] = frame->
linesize[1];
875 rawimg->stride[VPX_PLANE_V] = frame->
linesize[2];
879 rawimg_alpha->planes[VPX_PLANE_Y] = frame->
data[3];
882 if (!u_plane || !v_plane) {
888 rawimg_alpha->planes[VPX_PLANE_U] = u_plane;
890 rawimg_alpha->planes[VPX_PLANE_V] = v_plane;
891 rawimg_alpha->stride[VPX_PLANE_Y] = frame->
linesize[0];
892 rawimg_alpha->stride[VPX_PLANE_U] = frame->
linesize[1];
893 rawimg_alpha->stride[VPX_PLANE_V] = frame->
linesize[2];
895 timestamp = frame->
pts;
897 flags |= VPX_EFLAG_FORCE_KF;
900 res = vpx_codec_encode(&ctx->
encoder, rawimg, timestamp,
902 if (res != VPX_CODEC_OK) {
908 res = vpx_codec_encode(&ctx->
encoder_alpha, rawimg_alpha, timestamp,
910 if (res != VPX_CODEC_OK) {
932 av_freep(&rawimg_alpha->planes[VPX_PLANE_U]);
933 av_freep(&rawimg_alpha->planes[VPX_PLANE_V]);
936 *got_packet = !!coded_size;
940 #define OFFSET(x) offsetof(VP8Context, x)
941 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
943 #ifndef VPX_ERROR_RESILIENT_DEFAULT
944 #define VPX_ERROR_RESILIENT_DEFAULT 1
945 #define VPX_ERROR_RESILIENT_PARTITIONS 2
948 #define COMMON_OPTIONS \
949 { "cpu-used", "Quality/Speed ratio modifier", OFFSET(cpu_used), AV_OPT_TYPE_INT, {.i64 = 1}, -16, 16, VE}, \
950 { "auto-alt-ref", "Enable use of alternate reference " \
951 "frames (2-pass only)", OFFSET(auto_alt_ref), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1, VE}, \
952 { "lag-in-frames", "Number of frames to look ahead for " \
953 "alternate reference frame selection", OFFSET(lag_in_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \
954 { "arnr-maxframes", "altref noise reduction max frame count", OFFSET(arnr_max_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \
955 { "arnr-strength", "altref noise reduction filter strength", OFFSET(arnr_strength), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \
956 { "arnr-type", "altref noise reduction filter type", OFFSET(arnr_type), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE, "arnr_type"}, \
957 { "backward", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0, VE, "arnr_type" }, \
958 { "forward", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0, VE, "arnr_type" }, \
959 { "centered", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 3}, 0, 0, VE, "arnr_type" }, \
960 { "deadline", "Time to spend encoding, in microseconds.", OFFSET(deadline), AV_OPT_TYPE_INT, {.i64 = VPX_DL_GOOD_QUALITY}, INT_MIN, INT_MAX, VE, "quality"}, \
961 { "best", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_BEST_QUALITY}, 0, 0, VE, "quality"}, \
962 { "good", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_GOOD_QUALITY}, 0, 0, VE, "quality"}, \
963 { "realtime", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_REALTIME}, 0, 0, VE, "quality"}, \
964 { "error-resilient", "Error resilience configuration", OFFSET(error_resilient), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, VE, "er"}, \
965 { "max-intra-rate", "Maximum I-frame bitrate (pct) 0=unlimited", OFFSET(max_intra_rate), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \
966 { "default", "Improve resiliency against losses of whole frames", 0, AV_OPT_TYPE_CONST, {.i64 = VPX_ERROR_RESILIENT_DEFAULT}, 0, 0, VE, "er"}, \
967 { "partitions", "The frame partitions are independently decodable " \
968 "by the bool decoder, meaning that partitions can be decoded even " \
969 "though earlier partitions have been lost. Note that intra predicition" \
970 " is still done over the partition boundary.", 0, AV_OPT_TYPE_CONST, {.i64 = VPX_ERROR_RESILIENT_PARTITIONS}, 0, 0, VE, "er"}, \
971 { "crf", "Select the quality for constant quality mode", offsetof(VP8Context, crf), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 63, VE }, \
972 { "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 }, \
973 { "undershoot-pct", "Datarate undershoot (min) target (%)", OFFSET(rc_undershoot_pct), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 100, VE }, \
974 { "overshoot-pct", "Datarate overshoot (max) target (%)", OFFSET(rc_overshoot_pct), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1000, VE }, \
976 #define LEGACY_OPTIONS \
977 {"speed", "", offsetof(VP8Context, cpu_used), AV_OPT_TYPE_INT, {.i64 = 1}, -16, 16, VE}, \
978 {"quality", "", offsetof(VP8Context, deadline), AV_OPT_TYPE_INT, {.i64 = VPX_DL_GOOD_QUALITY}, INT_MIN, INT_MAX, VE, "quality"}, \
979 {"vp8flags", "", offsetof(VP8Context, flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, 0, UINT_MAX, VE, "flags"}, \
980 {"error_resilient", "enable error resilience", 0, AV_OPT_TYPE_CONST, {.i64 = VP8F_ERROR_RESILIENT}, INT_MIN, INT_MAX, VE, "flags"}, \
981 {"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"}, \
982 {"arnr_max_frames", "altref noise reduction max frame count", offsetof(VP8Context, arnr_max_frames), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 15, VE}, \
983 {"arnr_strength", "altref noise reduction filter strength", offsetof(VP8Context, arnr_strength), AV_OPT_TYPE_INT, {.i64 = 3}, 0, 6, VE}, \
984 {"arnr_type", "altref noise reduction filter type", offsetof(VP8Context, arnr_type), AV_OPT_TYPE_INT, {.i64 = 3}, 1, 3, VE}, \
985 {"rc_lookahead", "Number of frames to look ahead for alternate reference frame selection", offsetof(VP8Context, lag_in_frames), AV_OPT_TYPE_INT, {.i64 = 25}, 0, 25, VE}, \
987 #if CONFIG_LIBVPX_VP8_ENCODER
988 static const AVOption vp8_options[] = {
995 #if CONFIG_LIBVPX_VP9_ENCODER
996 static const AVOption vp9_options[] = {
999 {
"tile-columns",
"Number of tile columns to use, log2",
OFFSET(tile_columns),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6,
VE},
1000 {
"tile-rows",
"Number of tile rows to use, log2",
OFFSET(tile_rows),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 2,
VE},
1001 {
"frame-parallel",
"Enable frame parallel decodability features",
OFFSET(frame_parallel),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1,
VE},
1002 {
"aq-mode",
"adaptive quantization mode",
OFFSET(aq_mode),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 3,
VE,
"aq_mode"},
1004 {
"variance",
"Variance based Aq", 0,
AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0,
VE,
"aq_mode" },
1005 {
"complexity",
"Complexity based Aq", 0,
AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0,
VE,
"aq_mode" },
1012 #undef COMMON_OPTIONS
1013 #undef LEGACY_OPTIONS
1019 {
"keyint_min",
"-1" },
1023 #if CONFIG_LIBVPX_VP8_ENCODER
1026 return vpx_init(avctx, vpx_codec_vp8_cx());
1029 static const AVClass class_vp8 = {
1032 .option = vp8_options,
1036 AVCodec ff_libvpx_vp8_encoder = {
1047 .priv_class = &class_vp8,
1052 #if CONFIG_LIBVPX_VP9_ENCODER
1055 return vpx_init(avctx, vpx_codec_vp9_cx());
1058 static const AVClass class_vp9 = {
1061 .option = vp9_options,
1073 AVCodec ff_libvpx_vp9_encoder = {
1074 .
name =
"libvpx-vp9",
1084 .priv_class = &class_vp9,
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
struct vpx_image rawimg_alpha
const char const char void * val
planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
void av_free_packet(AVPacket *pkt)
Free a packet.
This structure describes decoded (raw) audio or video data.
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
struct vpx_codec_ctx encoder
uint64_t error[AV_NUM_DATA_POINTERS]
error
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.
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
#define AV_LOG_WARNING
Something somehow does not look correct.
#define LIBAVUTIL_VERSION_INT
static av_cold int init(AVCodecContext *avctx)
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.
also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above ...
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
size_t sz
length of compressed data
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride)
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
#define AV_CODEC_CAP_AUTO_THREADS
Codec supports avctx->thread_count == 0 (auto).
struct vpx_codec_ctx encoder_alpha
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
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.
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
attribute_deprecated float rc_buffer_aggressivity
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)
static void coded_frame_add(void *list, struct FrameListData *cx_frame)
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
#define FF_PROFILE_UNKNOWN
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
int av_reallocp(void *ptr, size_t size)
Allocate or reallocate a block of memory.
#define CONFIG_LIBVPX_VP9_ENCODER
#define AV_LOG_VERBOSE
Detailed information.
char * stats_out
pass1 encoding statistics output buffer
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
#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 frame_skip_threshold
frame skip threshold
#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. ...
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
int flags
AV_CODEC_FLAG_*.
Round to nearest and halfway cases away from zero.
int rc_max_rate
maximum bitrate
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
static av_always_inline av_const double round(double x)
char * av_base64_encode(char *out, int out_size, const uint8_t *in, int in_size)
Encode data to base64 and null-terminate.
Libavcodec external API header.
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 void cx_pktcpy(struct FrameListData *dst, const struct vpx_codec_cx_pkt *src, const struct vpx_codec_cx_pkt *src_alpha, VP8Context *ctx)
static av_cold void dump_enc_cfg(AVCodecContext *avctx, const struct vpx_codec_enc_cfg *cfg)
int bit_rate
the average bitrate
enum AVPictureType pict_type
Picture type of the frame.
#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.
ITU-R BT2020 non-constant luminance system.
#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 av_cold int vp8_free(AVCodecContext *avctx)
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)
attribute_deprecated int mb_threshold
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
struct FrameListData * next
#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 flags
VP8 specific flags, see VP8F_* below.
static const AVCodecDefault defaults[]
#define AV_LOG_INFO
Standard information.
uint64_t error[AV_NUM_DATA_POINTERS]
error
static const AVProfile profiles[]
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.
int qmin
minimum quantizer
planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
Data found in BlockAdditional element of matroska container.
Describe the class of an AVClass context structure.
enum AVColorSpace colorspace
YUV colorspace type.
uint32_t flags
flags for this frame
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
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 int set_pix_fmt(AVCodecContext *avctx, struct vpx_image *img)
static int vp8_encode(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
static enum AVPixelFormat pix_fmts[]
void * buf
compressed data buffer
int have_sse
true if we have pending sse[]
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int noise_reduction
noise reduction strength
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_fixed_buf twopass_stats
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)
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
#define FF_DISABLE_DEPRECATION_WARNINGS
common internal api header.
common internal and external API header
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
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 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.
int have_sse
true if we have pending sse[]
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
int rc_min_rate
minimum bitrate
AVPixelFormat
Pixel format.
This structure stores compressed data.
struct FrameListData * coded_frame_list
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
int keyint_min
minimum GOP size