26 #define AOM_DISABLE_CTRL_TYPECHECKS 1 27 #include <aom/aom_encoder.h> 28 #include <aom/aomcx.h> 61 typedef struct AOMEncoderContext {
64 struct aom_codec_ctx encoder;
65 struct aom_image rawimg;
66 struct aom_fixed_buf twopass_stats;
102 [AOME_SET_CPUUSED] =
"AOME_SET_CPUUSED",
103 [AOME_SET_CQ_LEVEL] =
"AOME_SET_CQ_LEVEL",
104 [AOME_SET_ENABLEAUTOALTREF] =
"AOME_SET_ENABLEAUTOALTREF",
105 [AOME_SET_ARNR_MAXFRAMES] =
"AOME_SET_ARNR_MAXFRAMES",
106 [AOME_SET_ARNR_STRENGTH] =
"AOME_SET_ARNR_STRENGTH",
107 [AOME_SET_STATIC_THRESHOLD] =
"AOME_SET_STATIC_THRESHOLD",
108 [AV1E_SET_COLOR_RANGE] =
"AV1E_SET_COLOR_RANGE",
109 [AV1E_SET_COLOR_PRIMARIES] =
"AV1E_SET_COLOR_PRIMARIES",
110 [AV1E_SET_MATRIX_COEFFICIENTS] =
"AV1E_SET_MATRIX_COEFFICIENTS",
111 [AV1E_SET_TRANSFER_CHARACTERISTICS] =
"AV1E_SET_TRANSFER_CHARACTERISTICS",
112 [AV1E_SET_AQ_MODE] =
"AV1E_SET_AQ_MODE",
113 [AV1E_SET_FRAME_PARALLEL_DECODING] =
"AV1E_SET_FRAME_PARALLEL_DECODING",
114 [AV1E_SET_SUPERBLOCK_SIZE] =
"AV1E_SET_SUPERBLOCK_SIZE",
115 [AV1E_SET_TILE_COLUMNS] =
"AV1E_SET_TILE_COLUMNS",
116 [AV1E_SET_TILE_ROWS] =
"AV1E_SET_TILE_ROWS",
117 [AV1E_SET_ENABLE_RESTORATION] =
"AV1E_SET_ENABLE_RESTORATION",
118 #ifdef AOM_CTRL_AV1E_SET_ROW_MT 119 [AV1E_SET_ROW_MT] =
"AV1E_SET_ROW_MT",
121 #ifdef AOM_CTRL_AV1E_SET_DENOISE_NOISE_LEVEL 122 [AV1E_SET_DENOISE_NOISE_LEVEL] =
"AV1E_SET_DENOISE_NOISE_LEVEL",
124 #ifdef AOM_CTRL_AV1E_SET_DENOISE_BLOCK_SIZE 125 [AV1E_SET_DENOISE_BLOCK_SIZE] =
"AV1E_SET_DENOISE_BLOCK_SIZE",
127 #ifdef AOM_CTRL_AV1E_SET_MAX_REFERENCE_FRAMES 128 [AV1E_SET_MAX_REFERENCE_FRAMES] =
"AV1E_SET_MAX_REFERENCE_FRAMES",
130 #ifdef AOM_CTRL_AV1E_SET_ENABLE_GLOBAL_MOTION 131 [AV1E_SET_ENABLE_GLOBAL_MOTION] =
"AV1E_SET_ENABLE_GLOBAL_MOTION",
133 #ifdef AOM_CTRL_AV1E_SET_ENABLE_INTRABC 134 [AV1E_SET_ENABLE_INTRABC] =
"AV1E_SET_ENABLE_INTRABC",
136 [AV1E_SET_ENABLE_CDEF] =
"AV1E_SET_ENABLE_CDEF",
137 [AOME_SET_TUNING] =
"AOME_SET_TUNING",
144 const char *detail = aom_codec_error_detail(&ctx->
encoder);
152 const struct aom_codec_enc_cfg *cfg)
157 av_log(avctx, level,
"aom_codec_enc_cfg\n");
158 av_log(avctx, level,
"generic settings\n" 159 " %*s%u\n %*s%u\n %*s%u\n %*s%u\n %*s%u\n" 161 " %*s{%u/%u}\n %*s%u\n %*s%d\n %*s%u\n",
162 width,
"g_usage:", cfg->g_usage,
163 width,
"g_threads:", cfg->g_threads,
164 width,
"g_profile:", cfg->g_profile,
165 width,
"g_w:", cfg->g_w,
166 width,
"g_h:", cfg->g_h,
167 width,
"g_bit_depth:", cfg->g_bit_depth,
168 width,
"g_input_bit_depth:", cfg->g_input_bit_depth,
169 width,
"g_timebase:", cfg->g_timebase.num, cfg->g_timebase.den,
170 width,
"g_error_resilient:", cfg->g_error_resilient,
171 width,
"g_pass:", cfg->g_pass,
172 width,
"g_lag_in_frames:", cfg->g_lag_in_frames);
173 av_log(avctx, level,
"rate control settings\n" 175 width,
"rc_dropframe_thresh:", cfg->rc_dropframe_thresh,
176 width,
"rc_end_usage:", cfg->rc_end_usage,
177 width,
"rc_twopass_stats_in:", cfg->rc_twopass_stats_in.buf, cfg->rc_twopass_stats_in.sz,
178 width,
"rc_target_bitrate:", cfg->rc_target_bitrate);
179 av_log(avctx, level,
"quantizer settings\n" 181 width,
"rc_min_quantizer:", cfg->rc_min_quantizer,
182 width,
"rc_max_quantizer:", cfg->rc_max_quantizer);
183 av_log(avctx, level,
"bitrate tolerance\n" 185 width,
"rc_undershoot_pct:", cfg->rc_undershoot_pct,
186 width,
"rc_overshoot_pct:", cfg->rc_overshoot_pct);
187 av_log(avctx, level,
"decoder buffer model\n" 188 " %*s%u\n %*s%u\n %*s%u\n",
189 width,
"rc_buf_sz:", cfg->rc_buf_sz,
190 width,
"rc_buf_initial_sz:", cfg->rc_buf_initial_sz,
191 width,
"rc_buf_optimal_sz:", cfg->rc_buf_optimal_sz);
192 av_log(avctx, level,
"2 pass rate control settings\n" 193 " %*s%u\n %*s%u\n %*s%u\n",
194 width,
"rc_2pass_vbr_bias_pct:", cfg->rc_2pass_vbr_bias_pct,
195 width,
"rc_2pass_vbr_minsection_pct:", cfg->rc_2pass_vbr_minsection_pct,
196 width,
"rc_2pass_vbr_maxsection_pct:", cfg->rc_2pass_vbr_maxsection_pct);
197 av_log(avctx, level,
"keyframing settings\n" 198 " %*s%d\n %*s%u\n %*s%u\n",
199 width,
"kf_mode:", cfg->kf_mode,
200 width,
"kf_min_dist:", cfg->kf_min_dist,
201 width,
"kf_max_dist:", cfg->kf_max_dist);
202 av_log(avctx, level,
"tile settings\n" 204 width,
"tile_width_count:", cfg->tile_width_count,
205 width,
"tile_height_count:", cfg->tile_height_count);
206 av_log(avctx, level,
"\n");
238 aome_enc_control_id
id,
240 enum aome_enc_control_id
id,
252 res = aom_codec_control(&ctx->
encoder,
id, val);
253 if (res != AOM_CODEC_OK) {
254 snprintf(buf,
sizeof(buf),
"Failed to set %s codec control",
267 aom_codec_destroy(&ctx->
encoder);
276 struct aom_codec_enc_cfg *enccfg, aom_codec_flags_t *
flags,
277 aom_img_fmt_t *img_fmt)
280 enccfg->g_bit_depth = enccfg->g_input_bit_depth = 8;
284 *img_fmt = AOM_IMG_FMT_I420;
288 *img_fmt = AOM_IMG_FMT_I422;
292 *img_fmt = AOM_IMG_FMT_I444;
296 if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
297 enccfg->g_bit_depth = enccfg->g_input_bit_depth =
301 *img_fmt = AOM_IMG_FMT_I42016;
302 *flags |= AOM_CODEC_USE_HIGHBITDEPTH;
308 if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
309 enccfg->g_bit_depth = enccfg->g_input_bit_depth =
312 *img_fmt = AOM_IMG_FMT_I42216;
313 *flags |= AOM_CODEC_USE_HIGHBITDEPTH;
319 if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
320 enccfg->g_bit_depth = enccfg->g_input_bit_depth =
324 *img_fmt = AOM_IMG_FMT_I44416;
325 *flags |= AOM_CODEC_USE_HIGHBITDEPTH;
338 aom_color_range_t aom_cr;
354 int sb_dim = (dim + sb_size - 1) / sb_size;
355 int tile_dim = (sb_dim + (1 << tiles_log2) - 1) >> tiles_log2;
357 return (sb_dim + tile_dim - 1) / tile_dim;
361 struct aom_codec_enc_cfg *enccfg)
364 int sb_128x128_possible, sb_size, sb_width, sb_height;
365 int uniform_rows, uniform_cols;
366 int uniform_64x64_possible, uniform_128x128_possible;
367 int tile_size, rounding,
i;
379 "columns to fill width.\n", ctx->
tile_cols);
400 "large enough to fit specified tile arrangement.\n");
406 "not allow more than %dx%d tiles.\n",
412 "not allow tiles of width greater than %d.\n",
424 sb_128x128_possible =
438 "-> %dx%d tiles.\n", uniform_cols, uniform_rows);
439 uniform_64x64_possible = uniform_cols == ctx->
tile_cols &&
442 if (sb_128x128_possible) {
448 "-> %dx%d tiles.\n", uniform_cols, uniform_rows);
449 uniform_128x128_possible = uniform_cols == ctx->
tile_cols &&
453 uniform_128x128_possible = 0;
457 if (uniform_64x64_possible && uniform_128x128_possible) {
459 "superblocks (tile_cols_log2 = %d, tile_rows_log2 = %d).\n",
463 if (uniform_64x64_possible && !sb_128x128_possible) {
465 "superblocks (tile_cols_log2 = %d, tile_rows_log2 = %d).\n",
470 if (uniform_128x128_possible) {
472 "superblocks (tile_cols_log2 = %d, tile_rows_log2 = %d).\n",
479 if (sb_128x128_possible) {
487 "superblocks (tile_cols = %d, tile_rows = %d).\n",
490 enccfg->tile_width_count = ctx->
tile_cols;
491 enccfg->tile_height_count = ctx->
tile_rows;
493 sb_width = (avctx->
width + sb_size - 1) / sb_size;
494 sb_height = (avctx->
height + sb_size - 1) / sb_size;
499 enccfg->tile_widths[
i] = tile_size +
501 i > ctx->
tile_cols - 1 - (rounding + 1) / 2);
507 enccfg->tile_heights[
i] = tile_size +
509 i > ctx->
tile_rows - 1 - (rounding + 1) / 2);
516 const struct aom_codec_iface *iface)
519 struct aom_codec_enc_cfg enccfg = { 0 };
520 #ifdef AOM_FRAME_IS_INTRAONLY 521 aom_codec_flags_t
flags =
524 aom_codec_flags_t flags = 0;
528 aom_img_fmt_t img_fmt;
529 aom_codec_caps_t codec_caps = aom_codec_get_caps(iface);
534 if ((res = aom_codec_enc_config_default(iface, &enccfg, 0)) != AOM_CODEC_OK) {
536 aom_codec_err_to_string(res));
540 if (
set_pix_fmt(avctx, codec_caps, &enccfg, &flags, &img_fmt))
551 enccfg.g_w = avctx->
width;
552 enccfg.g_h = avctx->
height;
558 enccfg.g_usage = ctx->
usage;
564 enccfg.g_pass = AOM_RC_FIRST_PASS;
566 enccfg.g_pass = AOM_RC_LAST_PASS;
568 enccfg.g_pass = AOM_RC_ONE_PASS;
572 enccfg.rc_end_usage = AOM_CBR;
573 }
else if (ctx->
crf >= 0) {
574 enccfg.rc_end_usage = AOM_CQ;
576 enccfg.rc_end_usage = AOM_Q;
582 }
else if (enccfg.rc_end_usage != AOM_Q) {
583 enccfg.rc_end_usage = AOM_Q;
586 "Neither bitrate nor constrained quality specified, using default CRF of %d\n",
590 if (avctx->
qmin >= 0)
591 enccfg.rc_min_quantizer = avctx->
qmin;
592 if (avctx->
qmax >= 0)
593 enccfg.rc_max_quantizer = avctx->
qmax;
595 if (enccfg.rc_end_usage == AOM_CQ || enccfg.rc_end_usage == AOM_Q) {
596 if (ctx->
crf < enccfg.rc_min_quantizer || ctx->
crf > enccfg.rc_max_quantizer) {
598 "CQ level %d must be between minimum and maximum quantizer value (%d-%d)\n",
599 ctx->
crf, enccfg.rc_min_quantizer, enccfg.rc_max_quantizer);
611 enccfg.rc_2pass_vbr_minsection_pct =
616 enccfg.rc_2pass_vbr_maxsection_pct =
623 enccfg.rc_buf_initial_sz =
625 enccfg.rc_buf_optimal_sz = enccfg.rc_buf_sz * 5 / 6;
636 enccfg.kf_max_dist = avctx->
gop_size;
638 if (enccfg.g_pass == AOM_RC_FIRST_PASS)
639 enccfg.g_lag_in_frames = 0;
640 else if (enccfg.g_pass == AOM_RC_LAST_PASS) {
641 int decode_size, ret;
659 if (decode_size < 0) {
672 enccfg.g_profile = avctx->
profile;
682 res = aom_codec_enc_init(&ctx->
encoder, iface, &enccfg, flags);
683 if (res != AOM_CODEC_OK) {
723 #ifdef AOM_CTRL_AV1E_SET_DENOISE_NOISE_LEVEL 727 #ifdef AOM_CTRL_AV1E_SET_DENOISE_BLOCK_SIZE 731 #ifdef AOM_CTRL_AV1E_SET_ENABLE_GLOBAL_MOTION 735 #ifdef AOM_CTRL_AV1E_SET_MAX_REFERENCE_FRAMES 736 if (avctx->
refs >= 3) {
740 #ifdef AOM_CTRL_AV1E_SET_ROW_MT 744 #ifdef AOM_CTRL_AV1E_SET_ENABLE_INTRABC 753 if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH)
754 ctx->
rawimg.bit_depth = enccfg.g_bit_depth;
766 "not found. This is a bug, please report it.\n");
782 if (enccfg.rc_end_usage == AOM_CBR ||
783 enccfg.g_pass != AOM_RC_ONE_PASS) {
795 const struct aom_codec_cx_pkt *
src)
797 dst->
pts = src->data.frame.pts;
798 dst->
duration = src->data.frame.duration;
799 dst->
flags = src->data.frame.flags;
800 dst->
sz = src->data.frame.sz;
801 dst->
buf = src->data.frame.buf;
802 #ifdef AOM_FRAME_IS_INTRAONLY 809 memcpy(dst->
sse, ctx->
sse,
sizeof(dst->
sse));
836 if (!!(cx_frame->
flags & AOM_FRAME_IS_KEY)) {
838 #ifdef AOM_FRAME_IS_INTRAONLY 840 }
else if (cx_frame->
flags & AOM_FRAME_IS_INTRAONLY) {
847 cx_frame->
have_sse ? 3 : 0, pict_type);
851 for (i = 0; i < 3; ++
i) {
862 "failed to send input packet\n");
869 "failed to receive output packet\n");
887 const struct aom_codec_cx_pkt *
pkt;
888 const void *iter =
NULL;
903 while ((pkt = aom_codec_get_cx_data(&ctx->
encoder, &iter))) {
905 case AOM_CODEC_CX_FRAME_PKT:
922 "Frame queue element alloc failed\n");
928 if (!cx_frame->
buf) {
935 memcpy(cx_frame->
buf, pkt->data.frame.buf, pkt->data.frame.sz);
939 case AOM_CODEC_STATS_PKT:
945 pkt->data.twopass_stats.sz)) < 0) {
950 memcpy((
uint8_t *)stats->buf + stats->sz,
951 pkt->data.twopass_stats.buf, pkt->data.twopass_stats.sz);
952 stats->sz += pkt->data.twopass_stats.sz;
955 #ifdef AOM_FRAME_IS_INTRAONLY 956 case AOM_CODEC_PSNR_PKT:
959 ctx->
sse[0] = pkt->data.psnr.sse[0];
960 ctx->
sse[1] = pkt->data.psnr.sse[1];
961 ctx->
sse[2] = pkt->data.psnr.sse[2];
962 ctx->
sse[3] = pkt->data.psnr.sse[3];
967 case AOM_CODEC_CUSTOM_PKT:
980 struct aom_image *rawimg =
NULL;
981 int64_t timestamp = 0;
983 aom_enc_frame_flags_t
flags = 0;
987 rawimg->planes[AOM_PLANE_Y] = frame->
data[0];
988 rawimg->planes[AOM_PLANE_U] = frame->
data[1];
989 rawimg->planes[AOM_PLANE_V] = frame->
data[2];
990 rawimg->stride[AOM_PLANE_Y] = frame->
linesize[0];
991 rawimg->stride[AOM_PLANE_U] = frame->
linesize[1];
992 rawimg->stride[AOM_PLANE_V] = frame->
linesize[2];
993 timestamp = frame->
pts;
996 rawimg->range = AOM_CR_STUDIO_RANGE;
999 rawimg->range = AOM_CR_FULL_RANGE;
1004 flags |= AOM_EFLAG_FORCE_KF;
1007 res = aom_codec_encode(&ctx->
encoder, rawimg, timestamp,
1009 if (res != AOM_CODEC_OK) {
1028 *got_packet = !!coded_size;
1054 aom_codec_caps_t codec_caps = aom_codec_get_caps(aom_codec_av1_cx());
1055 if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH)
1060 if (aom_codec_version_major() < 2)
1066 return aom_init(avctx, aom_codec_av1_cx());
1069 #define OFFSET(x) offsetof(AOMContext, x) 1070 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM 1073 {
"auto-alt-ref",
"Enable use of alternate reference " 1075 {
"lag-in-frames",
"Number of frames to look ahead at for " 1077 {
"arnr-max-frames",
"altref noise reduction max frame count",
OFFSET(arnr_max_frames),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
1078 {
"arnr-strength",
"altref noise reduction filter strength",
OFFSET(arnr_strength),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6, VE},
1079 {
"aq-mode",
"adaptive quantization mode",
OFFSET(aq_mode),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 4,
VE,
"aq_mode"},
1081 {
"variance",
"Variance based Aq", 0,
AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0,
VE,
"aq_mode"},
1082 {
"complexity",
"Complexity based Aq", 0,
AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0,
VE,
"aq_mode"},
1084 {
"error-resilience",
"Error resilience configuration",
OFFSET(error_resilient),
AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX,
VE,
"er"},
1085 {
"default",
"Improve resiliency against losses of whole frames", 0,
AV_OPT_TYPE_CONST, {.i64 = AOM_ERROR_RESILIENT_DEFAULT}, 0, 0,
VE,
"er"},
1086 {
"crf",
"Select the quality for constant quality mode", offsetof(
AOMContext, crf),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 63, VE },
1087 {
"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 },
1088 {
"drop-threshold",
"Frame drop threshold", offsetof(
AOMContext, drop_threshold),
AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, VE },
1089 {
"denoise-noise-level",
"Amount of noise to be removed",
OFFSET(denoise_noise_level),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
1090 {
"denoise-block-size",
"Denoise block size ",
OFFSET(denoise_block_size),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
1091 {
"undershoot-pct",
"Datarate undershoot (min) target (%)",
OFFSET(rc_undershoot_pct),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 100, VE},
1092 {
"overshoot-pct",
"Datarate overshoot (max) target (%)",
OFFSET(rc_overshoot_pct),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1000, VE},
1093 {
"minsection-pct",
"GOP min bitrate (% of target)",
OFFSET(minsection_pct),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 100, VE},
1094 {
"maxsection-pct",
"GOP max bitrate (% of target)",
OFFSET(maxsection_pct),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 5000, VE},
1095 {
"frame-parallel",
"Enable frame parallel decodability features",
OFFSET(frame_parallel),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1097 {
"tile-columns",
"Log2 of number of tile columns to use",
OFFSET(tile_cols_log2),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6, VE},
1098 {
"tile-rows",
"Log2 of number of tile rows to use",
OFFSET(tile_rows_log2),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6, VE},
1099 {
"row-mt",
"Enable row based multi-threading",
OFFSET(row_mt),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1100 {
"enable-cdef",
"Enable CDEF filtering",
OFFSET(enable_cdef),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1101 {
"enable-global-motion",
"Enable global motion",
OFFSET(enable_global_motion),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1102 {
"enable-intrabc",
"Enable intra block copy prediction mode",
OFFSET(enable_intrabc),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1103 {
"enable-restoration",
"Enable Loop Restoration filtering",
OFFSET(enable_restoration),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1104 {
"usage",
"Quality and compression efficiency vs speed trade-off",
OFFSET(
usage),
AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX,
VE,
"usage"},
1107 {
"tune",
"The metric that the encoder tunes for. Automatically chosen by the encoder by default",
OFFSET(tune),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, AOM_TUNE_SSIM,
VE,
"tune"},
1118 {
"keyint_min",
"-1" },
1130 .
name =
"libaom-av1",
1143 .wrapper_name =
"libaom",
const AVBitStreamFilter * av_bsf_get_by_name(const char *name)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
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)
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)
int max_bitrate
Maximum bitrate of the stream, in bits per second.
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
static av_cold int aom_init(AVCodecContext *avctx, const struct aom_codec_iface *iface)
enum AVColorRange color_range
MPEG vs JPEG YUV range.
The bitstream filter state.
void * buf
compressed data buffer
const char * av_default_item_name(void *ptr)
Return the context name.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
size_t sz
length of compressed data
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
#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 const AVOption options[]
static void error(const char *err)
#define AV_CODEC_CAP_AUTO_THREADS
Codec supports avctx->thread_count == 0 (auto).
int min_bitrate
Minimum bitrate of the stream, in bits per second.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
static int choose_tiling(AVCodecContext *avctx, struct aom_codec_enc_cfg *enccfg)
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.
static av_cold void free_frame_list(struct FrameListData *list)
static void filter(int16_t *output, ptrdiff_t out_stride, int16_t *low, ptrdiff_t low_stride, int16_t *high, ptrdiff_t high_stride, int len, int clip)
struct FrameListData * next
struct aom_fixed_buf twopass_stats
int64_t pts
time stamp to show frame (in timebase units)
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
#define AV_LOG_VERBOSE
Detailed information.
static av_cold int codecctl_int(AVCodecContext *avctx, enum aome_enc_control_id id, int val)
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
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
static void cx_pktcpy(AOMContext *ctx, struct FrameListData *dst, const struct aom_codec_cx_pkt *src)
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **pctx)
Allocate a context for a given bitstream filter.
#define i(width, name, range_min, range_max)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static av_cold void av1_init_static(AVCodec *codec)
int qmax
maximum quantizer
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
int capabilities
Codec capabilities.
enum AVColorRange color_range
MPEG vs JPEG YUV range.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
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.
static av_always_inline av_const double round(double x)
#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 int storeframe(AVCodecContext *avctx, struct FrameListData *cx_frame, AVPacket *pkt)
Store coded frame information in format suitable for return from encode2().
static void set_color_range(AVCodecContext *avctx)
int flags
A combination of AV_PKT_FLAG values.
int av_bsf_init(AVBSFContext *ctx)
Prepare the filter for use, after all the parameters and options have been set.
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
int rc_buffer_size
decoder bitstream buffer size
static const AVClass class_aom
int64_t rc_min_rate
minimum bitrate
AVCodec ff_libaom_av1_encoder
int refs
number of reference frames
struct FrameListData * coded_frame_list
static enum AVPixelFormat av1_pix_fmts_highbd[]
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
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.
static int queue_frames(AVCodecContext *avctx, AVPacket *pkt_out)
Queue multiple output frames from the encoder, returning the front-most.
int width
picture width / height.
#define FF_PROFILE_UNKNOWN
static av_cold void free_coded_frame(struct FrameListData *cx_frame)
#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.
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
static int count_uniform_tiling(int dim, int sb_size, int tiles_log2)
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 const char *const ctlidstr[]
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() ...
the normal 2^n-1 "JPEG" YUV ranges
int have_sse
true if we have pending sse[]
static int set_pix_fmt(AVCodecContext *avctx, aom_codec_caps_t codec_caps, struct aom_codec_enc_cfg *enccfg, aom_codec_flags_t *flags, aom_img_fmt_t *img_fmt)
This structure describes the bitrate properties of an encoded bitstream.
struct aom_codec_ctx encoder
#define AV_LOG_INFO
Standard information.
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
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.
aom_superblock_size_t superblock_size
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
const AVProfile ff_av1_profiles[]
main external API structure.
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
static enum AVPixelFormat av1_pix_fmts[]
int qmin
minimum quantizer
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
static av_cold int av1_init(AVCodecContext *avctx)
#define AV_PIX_FMT_YUV420P10
static void coded_frame_add(void *list, struct FrameListData *cx_frame)
Describe the class of an AVClass context structure.
static const AVProfile profiles[]
#define FF_PROFILE_AV1_PROFESSIONAL
enum AVColorSpace colorspace
YUV colorspace type.
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
int avcodec_parameters_from_context(AVCodecParameters *par, const AVCodecContext *codec)
Fill the parameters struct based on the values from the supplied codec context.
#define FF_PROFILE_AV1_MAIN
uint32_t flags
flags for this frame
offset must point to two consecutive integers
static av_cold void dump_enc_cfg(AVCodecContext *avctx, const struct aom_codec_enc_cfg *cfg)
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
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.
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
the normal 219*2^(n-8) "MPEG" YUV ranges
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
common internal api header.
static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)
common internal and external API header
static int aom_encode(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
static void usage(const char *program_name)
Portion of struct vpx_codec_cx_pkt from vpx_encoder.h.
int avg_bitrate
Average bitrate of the stream, in bits per second.
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...
static const AVCodecDefault defaults[]
void av_bsf_free(AVBSFContext **pctx)
Free a bitstream filter context and everything associated with it; write NULL into the supplied point...
AVPixelFormat
Pixel format.
static double val(void *priv, double ch)
This structure stores compressed data.
AVCodecParameters * par_in
Parameters of the input stream.
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
static av_cold int aom_free(AVCodecContext *avctx)
#define FF_PROFILE_AV1_HIGH
int64_t rc_max_rate
maximum bitrate
int keyint_min
minimum GOP size