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;
131 [AOME_SET_CPUUSED] =
"AOME_SET_CPUUSED",
132 [AOME_SET_CQ_LEVEL] =
"AOME_SET_CQ_LEVEL",
133 [AOME_SET_ENABLEAUTOALTREF] =
"AOME_SET_ENABLEAUTOALTREF",
134 [AOME_SET_ARNR_MAXFRAMES] =
"AOME_SET_ARNR_MAXFRAMES",
135 [AOME_SET_ARNR_STRENGTH] =
"AOME_SET_ARNR_STRENGTH",
136 [AOME_SET_STATIC_THRESHOLD] =
"AOME_SET_STATIC_THRESHOLD",
137 [AV1E_SET_COLOR_RANGE] =
"AV1E_SET_COLOR_RANGE",
138 [AV1E_SET_COLOR_PRIMARIES] =
"AV1E_SET_COLOR_PRIMARIES",
139 [AV1E_SET_MATRIX_COEFFICIENTS] =
"AV1E_SET_MATRIX_COEFFICIENTS",
140 [AV1E_SET_TRANSFER_CHARACTERISTICS] =
"AV1E_SET_TRANSFER_CHARACTERISTICS",
141 [AV1E_SET_AQ_MODE] =
"AV1E_SET_AQ_MODE",
142 [AV1E_SET_FRAME_PARALLEL_DECODING] =
"AV1E_SET_FRAME_PARALLEL_DECODING",
143 [AV1E_SET_SUPERBLOCK_SIZE] =
"AV1E_SET_SUPERBLOCK_SIZE",
144 [AV1E_SET_TILE_COLUMNS] =
"AV1E_SET_TILE_COLUMNS",
145 [AV1E_SET_TILE_ROWS] =
"AV1E_SET_TILE_ROWS",
146 [AV1E_SET_ENABLE_RESTORATION] =
"AV1E_SET_ENABLE_RESTORATION",
147 #ifdef AOM_CTRL_AV1E_SET_ROW_MT
148 [AV1E_SET_ROW_MT] =
"AV1E_SET_ROW_MT",
150 #ifdef AOM_CTRL_AV1E_SET_DENOISE_NOISE_LEVEL
151 [AV1E_SET_DENOISE_NOISE_LEVEL] =
"AV1E_SET_DENOISE_NOISE_LEVEL",
153 #ifdef AOM_CTRL_AV1E_SET_DENOISE_BLOCK_SIZE
154 [AV1E_SET_DENOISE_BLOCK_SIZE] =
"AV1E_SET_DENOISE_BLOCK_SIZE",
156 #ifdef AOM_CTRL_AV1E_SET_MAX_REFERENCE_FRAMES
157 [AV1E_SET_MAX_REFERENCE_FRAMES] =
"AV1E_SET_MAX_REFERENCE_FRAMES",
159 #ifdef AOM_CTRL_AV1E_SET_ENABLE_GLOBAL_MOTION
160 [AV1E_SET_ENABLE_GLOBAL_MOTION] =
"AV1E_SET_ENABLE_GLOBAL_MOTION",
162 #ifdef AOM_CTRL_AV1E_SET_ENABLE_INTRABC
163 [AV1E_SET_ENABLE_INTRABC] =
"AV1E_SET_ENABLE_INTRABC",
165 [AV1E_SET_ENABLE_CDEF] =
"AV1E_SET_ENABLE_CDEF",
166 [AOME_SET_TUNING] =
"AOME_SET_TUNING",
167 #if AOM_ENCODER_ABI_VERSION >= 22
168 [AV1E_SET_ENABLE_1TO4_PARTITIONS] =
"AV1E_SET_ENABLE_1TO4_PARTITIONS",
169 [AV1E_SET_ENABLE_AB_PARTITIONS] =
"AV1E_SET_ENABLE_AB_PARTITIONS",
170 [AV1E_SET_ENABLE_RECT_PARTITIONS] =
"AV1E_SET_ENABLE_RECT_PARTITIONS",
171 [AV1E_SET_ENABLE_ANGLE_DELTA] =
"AV1E_SET_ENABLE_ANGLE_DELTA",
172 [AV1E_SET_ENABLE_CFL_INTRA] =
"AV1E_SET_ENABLE_CFL_INTRA",
173 [AV1E_SET_ENABLE_FILTER_INTRA] =
"AV1E_SET_ENABLE_FILTER_INTRA",
174 [AV1E_SET_ENABLE_INTRA_EDGE_FILTER] =
"AV1E_SET_ENABLE_INTRA_EDGE_FILTER",
175 [AV1E_SET_ENABLE_PAETH_INTRA] =
"AV1E_SET_ENABLE_PAETH_INTRA",
176 [AV1E_SET_ENABLE_SMOOTH_INTRA] =
"AV1E_SET_ENABLE_SMOOTH_INTRA",
177 [AV1E_SET_ENABLE_PALETTE] =
"AV1E_SET_ENABLE_PALETTE",
178 [AV1E_SET_ENABLE_FLIP_IDTX] =
"AV1E_SET_ENABLE_FLIP_IDTX",
179 [AV1E_SET_ENABLE_TX64] =
"AV1E_SET_ENABLE_TX64",
180 [AV1E_SET_INTRA_DCT_ONLY] =
"AV1E_SET_INTRA_DCT_ONLY",
181 [AV1E_SET_INTER_DCT_ONLY] =
"AV1E_SET_INTER_DCT_ONLY",
182 [AV1E_SET_INTRA_DEFAULT_TX_ONLY] =
"AV1E_SET_INTRA_DEFAULT_TX_ONLY",
183 [AV1E_SET_REDUCED_TX_TYPE_SET] =
"AV1E_SET_REDUCED_TX_TYPE_SET",
184 [AV1E_SET_ENABLE_DIFF_WTD_COMP] =
"AV1E_SET_ENABLE_DIFF_WTD_COMP",
185 [AV1E_SET_ENABLE_DIST_WTD_COMP] =
"AV1E_SET_ENABLE_DIST_WTD_COMP",
186 [AV1E_SET_ENABLE_DUAL_FILTER] =
"AV1E_SET_ENABLE_DUAL_FILTER",
187 [AV1E_SET_ENABLE_INTERINTER_WEDGE] =
"AV1E_SET_ENABLE_INTERINTER_WEDGE",
188 [AV1E_SET_ENABLE_INTERINTRA_WEDGE] =
"AV1E_SET_ENABLE_INTERINTRA_WEDGE",
189 [AV1E_SET_ENABLE_MASKED_COMP] =
"AV1E_SET_ENABLE_MASKED_COMP",
190 [AV1E_SET_ENABLE_INTERINTRA_COMP] =
"AV1E_SET_ENABLE_INTERINTRA_COMP",
191 [AV1E_SET_ENABLE_OBMC] =
"AV1E_SET_ENABLE_OBMC",
192 [AV1E_SET_ENABLE_ONESIDED_COMP] =
"AV1E_SET_ENABLE_ONESIDED_COMP",
193 [AV1E_SET_REDUCED_REFERENCE_SET] =
"AV1E_SET_REDUCED_REFERENCE_SET",
194 [AV1E_SET_ENABLE_SMOOTH_INTERINTRA] =
"AV1E_SET_ENABLE_SMOOTH_INTERINTRA",
195 [AV1E_SET_ENABLE_REF_FRAME_MVS] =
"AV1E_SET_ENABLE_REF_FRAME_MVS",
202 const char *
error = aom_codec_error(&
ctx->encoder);
203 const char *detail = aom_codec_error_detail(&
ctx->encoder);
211 const struct aom_codec_enc_cfg *cfg)
218 " %*s%u\n %*s%u\n %*s%u\n %*s%u\n %*s%u\n"
220 " %*s{%u/%u}\n %*s%u\n %*s%d\n %*s%u\n",
221 width,
"g_usage:", cfg->g_usage,
222 width,
"g_threads:", cfg->g_threads,
223 width,
"g_profile:", cfg->g_profile,
224 width,
"g_w:", cfg->g_w,
225 width,
"g_h:", cfg->g_h,
226 width,
"g_bit_depth:", cfg->g_bit_depth,
227 width,
"g_input_bit_depth:", cfg->g_input_bit_depth,
228 width,
"g_timebase:", cfg->g_timebase.num, cfg->g_timebase.den,
229 width,
"g_error_resilient:", cfg->g_error_resilient,
230 width,
"g_pass:", cfg->g_pass,
231 width,
"g_lag_in_frames:", cfg->g_lag_in_frames);
234 width,
"rc_dropframe_thresh:", cfg->rc_dropframe_thresh,
235 width,
"rc_end_usage:", cfg->rc_end_usage,
236 width,
"rc_twopass_stats_in:", cfg->rc_twopass_stats_in.buf, cfg->rc_twopass_stats_in.sz,
237 width,
"rc_target_bitrate:", cfg->rc_target_bitrate);
240 width,
"rc_min_quantizer:", cfg->rc_min_quantizer,
241 width,
"rc_max_quantizer:", cfg->rc_max_quantizer);
244 width,
"rc_undershoot_pct:", cfg->rc_undershoot_pct,
245 width,
"rc_overshoot_pct:", cfg->rc_overshoot_pct);
247 " %*s%u\n %*s%u\n %*s%u\n",
248 width,
"rc_buf_sz:", cfg->rc_buf_sz,
249 width,
"rc_buf_initial_sz:", cfg->rc_buf_initial_sz,
250 width,
"rc_buf_optimal_sz:", cfg->rc_buf_optimal_sz);
251 av_log(avctx,
level,
"2 pass rate control settings\n"
252 " %*s%u\n %*s%u\n %*s%u\n",
253 width,
"rc_2pass_vbr_bias_pct:", cfg->rc_2pass_vbr_bias_pct,
254 width,
"rc_2pass_vbr_minsection_pct:", cfg->rc_2pass_vbr_minsection_pct,
255 width,
"rc_2pass_vbr_maxsection_pct:", cfg->rc_2pass_vbr_maxsection_pct);
257 " %*s%d\n %*s%u\n %*s%u\n",
258 width,
"kf_mode:", cfg->kf_mode,
259 width,
"kf_min_dist:", cfg->kf_min_dist,
260 width,
"kf_max_dist:", cfg->kf_max_dist);
263 width,
"tile_width_count:", cfg->tile_width_count,
264 width,
"tile_height_count:", cfg->tile_height_count);
297 aome_enc_control_id
id,
299 enum aome_enc_control_id
id,
311 res = aom_codec_control(&
ctx->encoder,
id,
val);
312 if (res != AOM_CODEC_OK) {
326 aom_codec_destroy(&
ctx->encoder);
335 struct aom_codec_enc_cfg *enccfg, aom_codec_flags_t *
flags,
336 aom_img_fmt_t *img_fmt)
340 enccfg->g_bit_depth = enccfg->g_input_bit_depth =
desc->comp[0].depth;
343 enccfg->monochrome = 1;
347 *img_fmt = AOM_IMG_FMT_I420;
351 *img_fmt = AOM_IMG_FMT_I422;
356 *img_fmt = AOM_IMG_FMT_I444;
360 enccfg->monochrome = 1;
364 if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
367 *img_fmt = AOM_IMG_FMT_I42016;
368 *
flags |= AOM_CODEC_USE_HIGHBITDEPTH;
374 if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
376 *img_fmt = AOM_IMG_FMT_I42216;
377 *
flags |= AOM_CODEC_USE_HIGHBITDEPTH;
385 if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
388 *img_fmt = AOM_IMG_FMT_I44416;
389 *
flags |= AOM_CODEC_USE_HIGHBITDEPTH;
402 aom_color_range_t aom_cr;
418 int sb_dim = (
dim + sb_size - 1) / sb_size;
419 int tile_dim = (sb_dim + (1 << tiles_log2) - 1) >> tiles_log2;
421 return (sb_dim + tile_dim - 1) / tile_dim;
425 struct aom_codec_enc_cfg *enccfg)
428 int sb_128x128_possible, sb_size, sb_width, sb_height;
429 int uniform_rows, uniform_cols;
430 int uniform_64x64_possible, uniform_128x128_possible;
431 int tile_size, rounding,
i;
433 if (
ctx->tile_cols_log2 >= 0)
434 ctx->tile_cols = 1 <<
ctx->tile_cols_log2;
435 if (
ctx->tile_rows_log2 >= 0)
436 ctx->tile_rows = 1 <<
ctx->tile_rows_log2;
438 if (
ctx->tile_cols == 0) {
441 if (
ctx->tile_cols > 1) {
443 "columns to fill width.\n",
ctx->tile_cols);
447 if (
ctx->tile_rows == 0) {
450 ctx->tile_cols - 1) /
ctx->tile_cols, 128);
454 if (
ctx->tile_rows > 1) {
456 "rows to fill area.\n",
ctx->tile_rows);
461 if ((avctx->
width + 63) / 64 <
ctx->tile_cols ||
462 (avctx->
height + 63) / 64 <
ctx->tile_rows) {
464 "large enough to fit specified tile arrangement.\n");
470 "not allow more than %dx%d tiles.\n",
476 "not allow tiles of width greater than %d.\n",
481 ctx->superblock_size = AOM_SUPERBLOCK_SIZE_DYNAMIC;
483 if (
ctx->tile_cols == 1 &&
ctx->tile_rows == 1) {
488 sb_128x128_possible =
489 (avctx->
width + 127) / 128 >=
ctx->tile_cols &&
490 (avctx->
height + 127) / 128 >=
ctx->tile_rows;
492 ctx->tile_cols_log2 =
ctx->tile_cols == 1 ? 0 :
494 ctx->tile_rows_log2 =
ctx->tile_rows == 1 ? 0 :
498 64,
ctx->tile_cols_log2);
500 64,
ctx->tile_rows_log2);
502 "-> %dx%d tiles.\n", uniform_cols, uniform_rows);
503 uniform_64x64_possible = uniform_cols ==
ctx->tile_cols &&
504 uniform_rows ==
ctx->tile_rows;
506 if (sb_128x128_possible) {
508 128,
ctx->tile_cols_log2);
510 128,
ctx->tile_rows_log2);
512 "-> %dx%d tiles.\n", uniform_cols, uniform_rows);
513 uniform_128x128_possible = uniform_cols ==
ctx->tile_cols &&
514 uniform_rows ==
ctx->tile_rows;
517 uniform_128x128_possible = 0;
520 ctx->uniform_tiles = 1;
521 if (uniform_64x64_possible && uniform_128x128_possible) {
523 "superblocks (tile_cols_log2 = %d, tile_rows_log2 = %d).\n",
524 ctx->tile_cols_log2,
ctx->tile_rows_log2);
527 if (uniform_64x64_possible && !sb_128x128_possible) {
529 "superblocks (tile_cols_log2 = %d, tile_rows_log2 = %d).\n",
530 ctx->tile_cols_log2,
ctx->tile_rows_log2);
531 ctx->superblock_size = AOM_SUPERBLOCK_SIZE_64X64;
534 if (uniform_128x128_possible) {
536 "superblocks (tile_cols_log2 = %d, tile_rows_log2 = %d).\n",
537 ctx->tile_cols_log2,
ctx->tile_rows_log2);
538 ctx->superblock_size = AOM_SUPERBLOCK_SIZE_128X128;
541 ctx->uniform_tiles = 0;
543 if (sb_128x128_possible) {
545 ctx->superblock_size = AOM_SUPERBLOCK_SIZE_128X128;
548 ctx->superblock_size = AOM_SUPERBLOCK_SIZE_64X64;
551 "superblocks (tile_cols = %d, tile_rows = %d).\n",
552 sb_size, sb_size,
ctx->tile_cols,
ctx->tile_rows);
554 enccfg->tile_width_count =
ctx->tile_cols;
555 enccfg->tile_height_count =
ctx->tile_rows;
557 sb_width = (avctx->
width + sb_size - 1) / sb_size;
558 sb_height = (avctx->
height + sb_size - 1) / sb_size;
560 tile_size = sb_width /
ctx->tile_cols;
561 rounding = sb_width %
ctx->tile_cols;
562 for (
i = 0;
i <
ctx->tile_cols;
i++) {
563 enccfg->tile_widths[
i] = tile_size +
565 i >
ctx->tile_cols - 1 - (rounding + 1) / 2);
568 tile_size = sb_height /
ctx->tile_rows;
569 rounding = sb_height %
ctx->tile_rows;
570 for (
i = 0;
i <
ctx->tile_rows;
i++) {
571 enccfg->tile_heights[
i] = tile_size +
573 i >
ctx->tile_rows - 1 - (rounding + 1) / 2);
580 const struct aom_codec_iface *iface)
584 struct aom_codec_enc_cfg enccfg = { 0 };
585 #ifdef AOM_FRAME_IS_INTRAONLY
586 aom_codec_flags_t
flags =
589 aom_codec_flags_t
flags = 0;
593 aom_img_fmt_t img_fmt;
594 aom_codec_caps_t codec_caps = aom_codec_get_caps(iface);
599 if ((res = aom_codec_enc_config_default(iface, &enccfg, 0)) != AOM_CODEC_OK) {
601 aom_codec_err_to_string(res));
616 enccfg.g_w = avctx->
width;
617 enccfg.g_h = avctx->
height;
623 enccfg.g_usage =
ctx->usage;
625 if (
ctx->lag_in_frames >= 0)
626 enccfg.g_lag_in_frames =
ctx->lag_in_frames;
629 enccfg.g_pass = AOM_RC_FIRST_PASS;
631 enccfg.g_pass = AOM_RC_LAST_PASS;
633 enccfg.g_pass = AOM_RC_ONE_PASS;
637 enccfg.rc_end_usage = AOM_CBR;
638 }
else if (
ctx->crf >= 0) {
639 enccfg.rc_end_usage = AOM_CQ;
641 enccfg.rc_end_usage = AOM_Q;
647 }
else if (enccfg.rc_end_usage != AOM_Q) {
648 enccfg.rc_end_usage = AOM_Q;
651 "Neither bitrate nor constrained quality specified, using default CRF of %d\n",
655 if (avctx->
qmin >= 0)
656 enccfg.rc_min_quantizer = avctx->
qmin;
657 if (avctx->
qmax >= 0)
658 enccfg.rc_max_quantizer = avctx->
qmax;
660 if (enccfg.rc_end_usage == AOM_CQ || enccfg.rc_end_usage == AOM_Q) {
661 if (
ctx->crf < enccfg.rc_min_quantizer ||
ctx->crf > enccfg.rc_max_quantizer) {
663 "CQ level %d must be between minimum and maximum quantizer value (%d-%d)\n",
664 ctx->crf, enccfg.rc_min_quantizer, enccfg.rc_max_quantizer);
669 enccfg.rc_dropframe_thresh =
ctx->drop_threshold;
673 if (
ctx->minsection_pct >= 0)
674 enccfg.rc_2pass_vbr_minsection_pct =
ctx->minsection_pct;
676 enccfg.rc_2pass_vbr_minsection_pct =
678 if (
ctx->maxsection_pct >= 0)
679 enccfg.rc_2pass_vbr_maxsection_pct =
ctx->maxsection_pct;
681 enccfg.rc_2pass_vbr_maxsection_pct =
688 enccfg.rc_buf_initial_sz =
690 enccfg.rc_buf_optimal_sz = enccfg.rc_buf_sz * 5 / 6;
692 if (
ctx->rc_undershoot_pct >= 0)
693 enccfg.rc_undershoot_pct =
ctx->rc_undershoot_pct;
694 if (
ctx->rc_overshoot_pct >= 0)
695 enccfg.rc_overshoot_pct =
ctx->rc_overshoot_pct;
701 enccfg.kf_max_dist = avctx->
gop_size;
703 if (enccfg.g_pass == AOM_RC_FIRST_PASS)
704 enccfg.g_lag_in_frames = 0;
705 else if (enccfg.g_pass == AOM_RC_LAST_PASS) {
706 int decode_size, ret;
713 ctx->twopass_stats.sz = strlen(avctx->
stats_in) * 3 / 4;
718 ctx->twopass_stats.sz);
719 ctx->twopass_stats.sz = 0;
723 ctx->twopass_stats.sz);
724 if (decode_size < 0) {
729 ctx->twopass_stats.sz = decode_size;
730 enccfg.rc_twopass_stats_in =
ctx->twopass_stats;
737 enccfg.g_profile = avctx->
profile;
739 enccfg.g_error_resilient =
ctx->error_resilient;
747 res = aom_codec_enc_init(&
ctx->encoder, iface, &enccfg,
flags);
748 if (res != AOM_CODEC_OK) {
756 if (
ctx->auto_alt_ref >= 0)
758 if (
ctx->arnr_max_frames >= 0)
760 if (
ctx->arnr_strength >= 0)
762 if (
ctx->enable_cdef >= 0)
764 if (
ctx->enable_restoration >= 0)
765 codecctl_int(avctx, AV1E_SET_ENABLE_RESTORATION,
ctx->enable_restoration);
766 #if AOM_ENCODER_ABI_VERSION >= 22
767 if (
ctx->enable_rect_partitions >= 0)
768 codecctl_int(avctx, AV1E_SET_ENABLE_RECT_PARTITIONS,
ctx->enable_rect_partitions);
769 if (
ctx->enable_1to4_partitions >= 0)
770 codecctl_int(avctx, AV1E_SET_ENABLE_1TO4_PARTITIONS,
ctx->enable_1to4_partitions);
771 if (
ctx->enable_ab_partitions >= 0)
772 codecctl_int(avctx, AV1E_SET_ENABLE_AB_PARTITIONS,
ctx->enable_ab_partitions);
773 if (
ctx->enable_angle_delta >= 0)
774 codecctl_int(avctx, AV1E_SET_ENABLE_ANGLE_DELTA,
ctx->enable_angle_delta);
775 if (
ctx->enable_cfl_intra >= 0)
777 if (
ctx->enable_filter_intra >= 0)
778 codecctl_int(avctx, AV1E_SET_ENABLE_FILTER_INTRA,
ctx->enable_filter_intra);
779 if (
ctx->enable_intra_edge_filter >= 0)
780 codecctl_int(avctx, AV1E_SET_ENABLE_INTRA_EDGE_FILTER,
ctx->enable_intra_edge_filter);
781 if (
ctx->enable_paeth_intra >= 0)
782 codecctl_int(avctx, AV1E_SET_ENABLE_PAETH_INTRA,
ctx->enable_paeth_intra);
783 if (
ctx->enable_smooth_intra >= 0)
784 codecctl_int(avctx, AV1E_SET_ENABLE_SMOOTH_INTRA,
ctx->enable_smooth_intra);
785 if (
ctx->enable_palette >= 0)
787 if (
ctx->enable_tx64 >= 0)
789 if (
ctx->enable_flip_idtx >= 0)
791 if (
ctx->use_intra_dct_only >= 0)
793 if (
ctx->use_inter_dct_only >= 0)
795 if (
ctx->use_intra_default_tx_only >= 0)
796 codecctl_int(avctx, AV1E_SET_INTRA_DEFAULT_TX_ONLY,
ctx->use_intra_default_tx_only);
797 if (
ctx->reduced_tx_type_set >= 0)
798 codecctl_int(avctx, AV1E_SET_REDUCED_TX_TYPE_SET,
ctx->reduced_tx_type_set);
799 if (
ctx->enable_ref_frame_mvs >= 0)
800 codecctl_int(avctx, AV1E_SET_ENABLE_REF_FRAME_MVS,
ctx->enable_ref_frame_mvs);
801 if (
ctx->enable_reduced_reference_set >= 0)
802 codecctl_int(avctx, AV1E_SET_REDUCED_REFERENCE_SET,
ctx->enable_reduced_reference_set);
803 if (
ctx->enable_diff_wtd_comp >= 0)
804 codecctl_int(avctx, AV1E_SET_ENABLE_DIFF_WTD_COMP,
ctx->enable_diff_wtd_comp);
805 if (
ctx->enable_dist_wtd_comp >= 0)
806 codecctl_int(avctx, AV1E_SET_ENABLE_DIST_WTD_COMP,
ctx->enable_dist_wtd_comp);
807 if (
ctx->enable_dual_filter >= 0)
808 codecctl_int(avctx, AV1E_SET_ENABLE_DUAL_FILTER,
ctx->enable_dual_filter);
809 if (
ctx->enable_interinter_wedge >= 0)
810 codecctl_int(avctx, AV1E_SET_ENABLE_INTERINTER_WEDGE,
ctx->enable_interinter_wedge);
811 if (
ctx->enable_masked_comp >= 0)
812 codecctl_int(avctx, AV1E_SET_ENABLE_MASKED_COMP,
ctx->enable_masked_comp);
813 if (
ctx->enable_interintra_comp >= 0)
814 codecctl_int(avctx, AV1E_SET_ENABLE_INTERINTRA_COMP,
ctx->enable_interintra_comp);
815 if (
ctx->enable_interintra_wedge >= 0)
816 codecctl_int(avctx, AV1E_SET_ENABLE_INTERINTRA_WEDGE,
ctx->enable_interintra_wedge);
817 if (
ctx->enable_obmc >= 0)
819 if (
ctx->enable_onesided_comp >= 0)
820 codecctl_int(avctx, AV1E_SET_ENABLE_ONESIDED_COMP,
ctx->enable_onesided_comp);
821 if (
ctx->enable_smooth_interintra >= 0)
822 codecctl_int(avctx, AV1E_SET_ENABLE_SMOOTH_INTERINTRA,
ctx->enable_smooth_interintra);
840 if (
ctx->aq_mode >= 0)
842 if (
ctx->frame_parallel >= 0)
843 codecctl_int(avctx, AV1E_SET_FRAME_PARALLEL_DECODING,
ctx->frame_parallel);
847 if (
ctx->uniform_tiles) {
852 #ifdef AOM_CTRL_AV1E_SET_DENOISE_NOISE_LEVEL
853 if (
ctx->denoise_noise_level >= 0)
854 codecctl_int(avctx, AV1E_SET_DENOISE_NOISE_LEVEL,
ctx->denoise_noise_level);
856 #ifdef AOM_CTRL_AV1E_SET_DENOISE_BLOCK_SIZE
857 if (
ctx->denoise_block_size >= 0)
858 codecctl_int(avctx, AV1E_SET_DENOISE_BLOCK_SIZE,
ctx->denoise_block_size);
860 #ifdef AOM_CTRL_AV1E_SET_ENABLE_GLOBAL_MOTION
861 if (
ctx->enable_global_motion >= 0)
862 codecctl_int(avctx, AV1E_SET_ENABLE_GLOBAL_MOTION,
ctx->enable_global_motion);
864 #ifdef AOM_CTRL_AV1E_SET_MAX_REFERENCE_FRAMES
865 if (avctx->
refs >= 3) {
869 #ifdef AOM_CTRL_AV1E_SET_ROW_MT
870 if (
ctx->row_mt >= 0)
873 #ifdef AOM_CTRL_AV1E_SET_ENABLE_INTRABC
874 if (
ctx->enable_intrabc >= 0)
878 #if AOM_ENCODER_ABI_VERSION >= 23
883 int ret = aom_codec_set_option(&
ctx->encoder, en->
key, en->
value);
884 if (ret != AOM_CODEC_OK) {
893 aom_img_wrap(&
ctx->rawimg, img_fmt, avctx->
width, avctx->
height, 1,
896 if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH)
897 ctx->rawimg.bit_depth = enccfg.g_bit_depth;
909 "not found. This is a bug, please report it.\n");
925 if (enccfg.rc_end_usage == AOM_CBR ||
926 enccfg.g_pass != AOM_RC_ONE_PASS) {
938 const struct aom_codec_cx_pkt *
src)
940 dst->
pts =
src->data.frame.pts;
943 dst->
sz =
src->data.frame.sz;
944 dst->
buf =
src->data.frame.buf;
945 #ifdef AOM_FRAME_IS_INTRAONLY
952 memcpy(dst->
sse,
ctx->sse,
sizeof(dst->
sse));
979 if (!!(cx_frame->
flags & AOM_FRAME_IS_KEY)) {
981 #ifdef AOM_FRAME_IS_INTRAONLY
983 }
else if (cx_frame->
flags & AOM_FRAME_IS_INTRAONLY) {
990 cx_frame->
have_sse ? 3 : 0, pict_type);
994 for (
i = 0;
i < 3; ++
i) {
1005 "failed to send input packet\n");
1012 "failed to receive output packet\n");
1030 const struct aom_codec_cx_pkt *
pkt;
1031 const void *iter =
NULL;
1034 if (
ctx->coded_frame_list) {
1040 ctx->coded_frame_list = cx_frame->
next;
1046 while ((
pkt = aom_codec_get_cx_data(&
ctx->encoder, &iter))) {
1047 switch (
pkt->kind) {
1048 case AOM_CODEC_CX_FRAME_PKT:
1065 "Frame queue element alloc failed\n");
1071 if (!cx_frame->
buf) {
1082 case AOM_CODEC_STATS_PKT:
1084 struct aom_fixed_buf *
stats = &
ctx->twopass_stats;
1088 pkt->
data.twopass_stats.sz)) < 0) {
1098 #ifdef AOM_FRAME_IS_INTRAONLY
1099 case AOM_CODEC_PSNR_PKT:
1110 case AOM_CODEC_CUSTOM_PKT:
1123 struct aom_image *rawimg =
NULL;
1125 int res, coded_size;
1126 aom_enc_frame_flags_t
flags = 0;
1129 rawimg = &
ctx->rawimg;
1130 rawimg->planes[AOM_PLANE_Y] =
frame->
data[0];
1131 rawimg->planes[AOM_PLANE_U] =
frame->
data[1];
1132 rawimg->planes[AOM_PLANE_V] =
frame->
data[2];
1139 rawimg->range = AOM_CR_STUDIO_RANGE;
1142 rawimg->range = AOM_CR_FULL_RANGE;
1147 flags |= AOM_EFLAG_FORCE_KF;
1150 res = aom_codec_encode(&
ctx->encoder, rawimg, timestamp,
1152 if (res != AOM_CODEC_OK) {
1168 ctx->twopass_stats.sz);
1171 *got_packet = !!coded_size;
1229 int supports_monochrome = aom_codec_version() >= 20001;
1230 aom_codec_caps_t codec_caps = aom_codec_get_caps(aom_codec_av1_cx());
1231 if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH)
1238 if (aom_codec_version_major() < 2)
1244 return aom_init(avctx, aom_codec_av1_cx());
1247 #define OFFSET(x) offsetof(AOMContext, x)
1248 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1251 {
"auto-alt-ref",
"Enable use of alternate reference "
1253 {
"lag-in-frames",
"Number of frames to look ahead at for "
1255 {
"arnr-max-frames",
"altref noise reduction max frame count",
OFFSET(arnr_max_frames),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX,
VE},
1256 {
"arnr-strength",
"altref noise reduction filter strength",
OFFSET(arnr_strength),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6,
VE},
1257 {
"aq-mode",
"adaptive quantization mode",
OFFSET(aq_mode),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 4,
VE,
"aq_mode"},
1259 {
"variance",
"Variance based Aq", 0,
AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0,
VE,
"aq_mode"},
1260 {
"complexity",
"Complexity based Aq", 0,
AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0,
VE,
"aq_mode"},
1262 {
"error-resilience",
"Error resilience configuration",
OFFSET(error_resilient),
AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX,
VE,
"er"},
1263 {
"default",
"Improve resiliency against losses of whole frames", 0,
AV_OPT_TYPE_CONST, {.i64 = AOM_ERROR_RESILIENT_DEFAULT}, 0, 0,
VE,
"er"},
1265 {
"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 },
1266 {
"drop-threshold",
"Frame drop threshold", offsetof(
AOMContext, drop_threshold),
AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX,
VE },
1267 {
"denoise-noise-level",
"Amount of noise to be removed",
OFFSET(denoise_noise_level),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX,
VE},
1268 {
"denoise-block-size",
"Denoise block size ",
OFFSET(denoise_block_size),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX,
VE},
1269 {
"undershoot-pct",
"Datarate undershoot (min) target (%)",
OFFSET(rc_undershoot_pct),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 100,
VE},
1270 {
"overshoot-pct",
"Datarate overshoot (max) target (%)",
OFFSET(rc_overshoot_pct),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1000,
VE},
1271 {
"minsection-pct",
"GOP min bitrate (% of target)",
OFFSET(minsection_pct),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 100,
VE},
1272 {
"maxsection-pct",
"GOP max bitrate (% of target)",
OFFSET(maxsection_pct),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 5000,
VE},
1273 {
"frame-parallel",
"Enable frame parallel decodability features",
OFFSET(frame_parallel),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1275 {
"tile-columns",
"Log2 of number of tile columns to use",
OFFSET(tile_cols_log2),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6,
VE},
1276 {
"tile-rows",
"Log2 of number of tile rows to use",
OFFSET(tile_rows_log2),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6,
VE},
1279 {
"enable-global-motion",
"Enable global motion",
OFFSET(enable_global_motion),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1280 {
"enable-intrabc",
"Enable intra block copy prediction mode",
OFFSET(enable_intrabc),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1281 {
"enable-restoration",
"Enable Loop Restoration filtering",
OFFSET(enable_restoration),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1282 {
"usage",
"Quality and compression efficiency vs speed trade-off",
OFFSET(
usage),
AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX,
VE,
"usage"},
1285 {
"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"},
1289 {
"enable-rect-partitions",
"Enable rectangular partitions",
OFFSET(enable_rect_partitions),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1290 {
"enable-1to4-partitions",
"Enable 1:4/4:1 partitions",
OFFSET(enable_1to4_partitions),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1291 {
"enable-ab-partitions",
"Enable ab shape partitions",
OFFSET(enable_ab_partitions),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1292 {
"enable-angle-delta",
"Enable angle delta intra prediction",
OFFSET(enable_angle_delta),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1293 {
"enable-cfl-intra",
"Enable chroma predicted from luma intra prediction",
OFFSET(enable_cfl_intra),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1294 {
"enable-filter-intra",
"Enable filter intra predictor",
OFFSET(enable_filter_intra),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1295 {
"enable-intra-edge-filter",
"Enable intra edge filter",
OFFSET(enable_intra_edge_filter),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1296 {
"enable-smooth-intra",
"Enable smooth intra prediction mode",
OFFSET(enable_smooth_intra),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1297 {
"enable-paeth-intra",
"Enable paeth predictor in intra prediction",
OFFSET(enable_paeth_intra),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1298 {
"enable-palette",
"Enable palette prediction mode",
OFFSET(enable_palette),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1299 {
"enable-flip-idtx",
"Enable extended transform type",
OFFSET(enable_flip_idtx),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1301 {
"reduced-tx-type-set",
"Use reduced set of transform types",
OFFSET(reduced_tx_type_set),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1302 {
"use-intra-dct-only",
"Use DCT only for INTRA modes",
OFFSET(use_intra_dct_only),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1303 {
"use-inter-dct-only",
"Use DCT only for INTER modes",
OFFSET(use_inter_dct_only),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1304 {
"use-intra-default-tx-only",
"Use default-transform only for INTRA modes",
OFFSET(use_intra_default_tx_only),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1305 {
"enable-ref-frame-mvs",
"Enable temporal mv prediction",
OFFSET(enable_ref_frame_mvs),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1306 {
"enable-reduced-reference-set",
"Use reduced set of single and compound references",
OFFSET(enable_reduced_reference_set),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1308 {
"enable-dual-filter",
"Enable dual filter",
OFFSET(enable_dual_filter),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1309 {
"enable-diff-wtd-comp",
"Enable difference-weighted compound",
OFFSET(enable_diff_wtd_comp),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1310 {
"enable-dist-wtd-comp",
"Enable distance-weighted compound",
OFFSET(enable_dist_wtd_comp),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1311 {
"enable-onesided-comp",
"Enable one sided compound",
OFFSET(enable_onesided_comp),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1312 {
"enable-interinter-wedge",
"Enable interinter wedge compound",
OFFSET(enable_interinter_wedge),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1313 {
"enable-interintra-wedge",
"Enable interintra wedge compound",
OFFSET(enable_interintra_wedge),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1314 {
"enable-masked-comp",
"Enable masked compound",
OFFSET(enable_masked_comp),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1315 {
"enable-interintra-comp",
"Enable interintra compound",
OFFSET(enable_interintra_comp),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1316 {
"enable-smooth-interintra",
"Enable smooth interintra mode",
OFFSET(enable_smooth_interintra),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1,
VE},
1317 #if AOM_ENCODER_ABI_VERSION >= 23
1318 {
"aom-params",
"Set libaom options using a :-separated list of key=value pairs",
OFFSET(aom_params),
AV_OPT_TYPE_DICT, { 0 }, 0, 0,
VE },
1328 {
"keyint_min",
"-1" },
1340 .
name =
"libaom-av1",
1354 .wrapper_name =
"libaom",
static double val(void *priv, double ch)
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Libavcodec external API header.
#define FF_PROFILE_UNKNOWN
#define FF_PROFILE_AV1_HIGH
#define FF_PROFILE_AV1_MAIN
#define FF_PROFILE_AV1_PROFESSIONAL
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
static av_cold int init(AVCodecContext *avctx)
#define flags(name, subs,...)
static av_always_inline void filter(int16_t *output, ptrdiff_t out_stride, const int16_t *low, ptrdiff_t low_stride, const int16_t *high, ptrdiff_t high_stride, int len, int clip)
common internal and external API header
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
@ AV_OPT_TYPE_IMAGE_SIZE
offset must point to two consecutive integers
void av_bsf_free(AVBSFContext **pctx)
Free a bitstream filter context and everything associated with it; write NULL into the supplied point...
int avcodec_parameters_from_context(AVCodecParameters *par, const AVCodecContext *codec)
Fill the parameters struct based on the values from the supplied codec context.
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
int av_bsf_init(AVBSFContext *ctx)
Prepare the filter for use, after all the parameters and options have been set.
#define AV_CODEC_CAP_OTHER_THREADS
Codec supports multithreading through a method other than slice- or frame-level multithreading.
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **pctx)
Allocate a context for a given bitstream filter.
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
const AVBitStreamFilter * av_bsf_get_by_name(const char *name)
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
char * av_base64_encode(char *out, int out_size, const uint8_t *in, int in_size)
Encode data to base64 and null-terminate.
#define AV_BASE64_SIZE(x)
Calculate the output size needed to base64-encode x bytes to a null-terminated string.
int av_base64_decode(uint8_t *out, const char *in_str, int out_size)
Decode a base64-encoded string.
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
#define AVERROR_EXTERNAL
Generic error in an external library.
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define AV_LOG_VERBOSE
Detailed information.
#define AV_LOG_INFO
Standard information.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
const char * av_default_item_name(void *ptr)
Return the context name.
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)
Rescale a 64-bit integer with specified rounding.
@ AV_ROUND_NEAR_INF
Round to nearest and halfway cases away from zero.
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
@ AV_PICTURE_TYPE_I
Intra.
@ AV_PICTURE_TYPE_P
Predicted.
#define LIBAVUTIL_VERSION_INT
static const AVCodecDefault defaults[]
static const char *const ctlidstr[]
static enum AVPixelFormat av1_pix_fmts_highbd_with_gray[]
static enum AVPixelFormat av1_pix_fmts_highbd[]
static int queue_frames(AVCodecContext *avctx, AVPacket *pkt_out)
Queue multiple output frames from the encoder, returning the front-most.
static void cx_pktcpy(AOMContext *ctx, struct FrameListData *dst, const struct aom_codec_cx_pkt *src)
static enum AVPixelFormat av1_pix_fmts_with_gray[]
static const AVOption options[]
static void set_color_range(AVCodecContext *avctx)
static av_cold int av1_init(AVCodecContext *avctx)
static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)
static av_cold void av1_init_static(AVCodec *codec)
static int count_uniform_tiling(int dim, int sb_size, int tiles_log2)
static av_cold void free_coded_frame(struct FrameListData *cx_frame)
AVCodec ff_libaom_av1_encoder
static av_cold int aom_free(AVCodecContext *avctx)
static int aom_encode(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
static av_cold int aom_init(AVCodecContext *avctx, const struct aom_codec_iface *iface)
static int storeframe(AVCodecContext *avctx, struct FrameListData *cx_frame, AVPacket *pkt)
Store coded frame information in format suitable for return from encode2().
static enum AVPixelFormat av1_pix_fmts[]
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)
static void coded_frame_add(void *list, struct FrameListData *cx_frame)
static av_cold int codecctl_int(AVCodecContext *avctx, enum aome_enc_control_id id, int val)
static av_cold void free_frame_list(struct FrameListData *list)
static const AVClass class_aom
static av_cold void dump_enc_cfg(AVCodecContext *avctx, const struct aom_codec_enc_cfg *cfg)
static int choose_tiling(AVCodecContext *avctx, struct aom_codec_enc_cfg *enccfg)
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
static const AVProfile profiles[]
static av_always_inline av_const double round(double x)
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride)
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
#define AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV420P10
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
@ AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_JPEG
Full range content.
#define AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GBRP12
AVPixelFormat
Pixel format.
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
#define AV_PIX_FMT_GRAY10
@ AVCOL_PRI_BT709
also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
@ AVCOL_TRC_IEC61966_2_1
IEC 61966-2-1 (sRGB or sYCC)
#define AV_PIX_FMT_YUV444P10
@ AVCOL_SPC_RGB
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
const AVProfile ff_av1_profiles[]
#define FF_AV1_PROFILE_OPTS
int use_intra_default_tx_only
AVDictionary * aom_params
int enable_interintra_wedge
int enable_smooth_interintra
int enable_reduced_reference_set
int enable_1to4_partitions
int enable_rect_partitions
aom_superblock_size_t superblock_size
int have_sse
true if we have pending sse[]
struct FrameListData * coded_frame_list
int enable_interintra_comp
int enable_interinter_wedge
int enable_intra_edge_filter
The bitstream filter state.
This structure describes the bitrate properties of an encoded bitstream.
int avg_bitrate
Average bitrate of the stream, in bits per second.
int min_bitrate
Minimum bitrate of the stream, in bits per second.
int buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
int max_bitrate
Maximum bitrate of the stream, in bits per second.
Describe the class of an AVClass context structure.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
main external API structure.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
int width
picture width / height.
char * stats_out
pass1 encoding statistics output buffer
int rc_buffer_size
decoder bitstream buffer size
enum AVColorRange color_range
MPEG vs JPEG YUV range.
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
int qmin
minimum quantizer
int keyint_min
minimum GOP size
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
int64_t bit_rate
the average bitrate
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
enum AVColorSpace colorspace
YUV colorspace type.
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
int refs
number of reference frames
int64_t rc_max_rate
maximum bitrate
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
int qmax
maximum quantizer
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
int flags
AV_CODEC_FLAG_*.
int64_t rc_min_rate
minimum bitrate
uint64_t error[AV_NUM_DATA_POINTERS]
error
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
const char * name
Name of the codec implementation.
int capabilities
Codec capabilities.
This structure describes decoded (raw) audio or video data.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
enum AVColorRange color_range
MPEG vs JPEG YUV range.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
enum AVPictureType pict_type
Picture type of the frame.
This structure stores compressed data.
int flags
A combination of AV_PKT_FLAG values.
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Portion of struct vpx_codec_cx_pkt from vpx_encoder.h.
int64_t pts
time stamp to show frame (in timebase units)
struct FrameListData * next
size_t sz
length of compressed data
void * buf
compressed data buffer
unsigned long duration
duration to show frame (in timebase units)
int have_sse
true if we have pending sse[]
uint32_t flags
flags for this frame
static void error(const char *err)
static void stats(AVPacket *const *in, int n_in, unsigned *_max, unsigned *_sum)