mykola/freebsd-ports
1
0
Fork 0
forked from Lainports/freebsd-ports
Code Pull requests Activity
freebsd-ports/multimedia/ffmpeg/files/patch-aom
Jan Beich 5161397623 multimedia/ffmpeg: backport AOM warning fix 
[libaom-av1 encoder @ 0x807b0d1c0] Value -1.000000 for parameter 'enable-intrabc' out of range [0 - 1]
2019-05-09 00:52:20 +00:00

350 lines
16 KiB
Text
Raw Blame History

https://git.ffmpeg.org/gitweb/ffmpeg.git/commitdiff/b2ea757f68
https://git.ffmpeg.org/gitweb/ffmpeg.git/commitdiff/d12d4d4515
https://git.ffmpeg.org/gitweb/ffmpeg.git/commitdiff/b87063c06d
https://git.ffmpeg.org/gitweb/ffmpeg.git/commitdiff/2ddaaaf595
https://git.ffmpeg.org/gitweb/ffmpeg.git/commitdiff/e3991a5a45
https://git.ffmpeg.org/gitweb/ffmpeg.git/commitdiff/995889abbf
https://git.ffmpeg.org/gitweb/ffmpeg.git/commitdiff/0856c5da07
https://git.ffmpeg.org/gitweb/ffmpeg.git/commitdiff/0e1ea034d8
https://git.ffmpeg.org/gitweb/ffmpeg.git/commitdiff/1e8475b507
--- doc/encoders.texi.orig 2018-11-05 23:22:25 UTC
+++ doc/encoders.texi
@@ -1370,6 +1370,118 @@ makes it possible to store non-rgb pix_fmts.
@end table
+@section libaom-av1
+
+libaom AV1 encoder wrapper.
+
+Requires the presence of the libaom headers and library during
+configuration. You need to explicitly configure the build with
+@code{--enable-libaom}.
+
+@subsection Options
+
+The wrapper supports the following standard libavcodec options:
+
+@table @option
+
+@item b
+Set bitrate target in bits/second. By default this will use
+variable-bitrate mode. If @option{maxrate} and @option{minrate} are
+also set to the same value then it will use constant-bitrate mode,
+otherwise if @option{crf} is set as well then it will use
+constrained-quality mode.
+
+@item g keyint_min
+Set key frame placement. The GOP size sets the maximum distance between
+key frames; if zero the output stream will be intra-only. The minimum
+distance is ignored unless it is the same as the GOP size, in which case
+key frames will always appear at a fixed interval. Not set by default,
+so without this option the library has completely free choice about
+where to place key frames.
+
+@item qmin qmax
+Set minimum/maximum quantisation values. Valid range is from 0 to 63
+(warning: this does not match the quantiser values actually used by AV1
+- divide by four to map real quantiser values to this range). Defaults
+to min/max (no constraint).
+
+@item minrate maxrate bufsize rc_init_occupancy
+Set rate control buffering parameters. Not used if not set - defaults
+to unconstrained variable bitrate.
+
+@item threads
+Set the number of threads to use while encoding. This may require the
+@option{tiles} or @option{row-mt} options to also be set to actually
+use the specified number of threads fully. Defaults to the number of
+hardware threads supported by the host machine.
+
+@item profile
+Set the encoding profile. Defaults to using the profile which matches
+the bit depth and chroma subsampling of the input.
+
+@end table
+
+The wrapper also has some specific options:
+
+@table @option
+
+@item cpu-used
+Set the quality/encoding speed tradeoff. Valid range is from 0 to 8,
+higher numbers indicating greater speed and lower quality. The default
+value is 1, which will be slow and high quality.
+
+@item auto-alt-ref
+Enable use of alternate reference frames. Defaults to the internal
+default of the library.
+
+@item lag-in-frames
+Set the maximum number of frames which the encoder may keep in flight
+at any one time for lookahead purposes. Defaults to the internal
+default of the library.
+
+@item error-resilience
+Enable error resilience features:
+@table @option
+@item default
+Improve resilience against losses of whole frames.
+@end table
+Not enabled by default.
+
+@item crf
+Set the quality/size tradeoff for constant-quality (no bitrate target)
+and constrained-quality (with maximum bitrate target) modes. Valid
+range is 0 to 63, higher numbers indicating lower quality and smaller
+output size. Only used if set; by default only the bitrate target is
+used.
+
+@item static-thresh
+Set a change threshold on blocks below which they will be skipped by
+the encoder. Defined in arbitrary units as a nonnegative integer,
+defaulting to zero (no blocks are skipped).
+
+@item drop-threshold
+Set a threshold for dropping frames when close to rate control bounds.
+Defined as a percentage of the target buffer - when the rate control
+buffer falls below this percentage, frames will be dropped until it
+has refilled above the threshold. Defaults to zero (no frames are
+dropped).
+
+@item tiles
+Set the number of tiles to encode the input video with, as colums x
+rows. Larger numbers allow greater parallelism in both encoding and
+decoding, but may decrease coding efficiency. Defaults to the minimum
+number of tiles required by the size of the input video (this is 1x1
+(that is, a single tile) for sizes up to and including 4K).
+
+@item tile-columns tile-rows
+Set the number of tiles as log2 of the number of tile rows and columns.
+Provided for compatibility with libvpx/VP9.
+
+@item row-mt (Requires libaom >= 1.0.0-759-g90a15f4f2)
+Enable row based multi-threading. Disabled by default.
+
+@end table
+
@section libkvazaar
Kvazaar H.265/HEVC encoder.
--- libavcodec/libaomenc.c.orig 2018-11-05 23:22:26 UTC
+++ libavcodec/libaomenc.c
@@ -66,33 +66,69 @@ typedef struct AOMEncoderContext {
struct FrameListData *coded_frame_list;
int cpu_used;
int auto_alt_ref;
+ int arnr_max_frames;
+ int arnr_strength;
+ int aq_mode;
int lag_in_frames;
int error_resilient;
int crf;
int static_thresh;
int drop_threshold;
- int noise_sensitivity;
+ int denoise_noise_level;
+ int denoise_block_size;
uint64_t sse[4];
int have_sse; /**< true if we have pending sse[] */
uint64_t frame_number;
+ int rc_undershoot_pct;
+ int rc_overshoot_pct;
+ int minsection_pct;
+ int maxsection_pct;
+ int frame_parallel;
int tile_cols, tile_rows;
int tile_cols_log2, tile_rows_log2;
aom_superblock_size_t superblock_size;
int uniform_tiles;
+ int row_mt;
+ int enable_cdef;
+ int enable_global_motion;
+ int enable_intrabc;
} AOMContext;
static const char *const ctlidstr[] = {
[AOME_SET_CPUUSED] = "AOME_SET_CPUUSED",
[AOME_SET_CQ_LEVEL] = "AOME_SET_CQ_LEVEL",
[AOME_SET_ENABLEAUTOALTREF] = "AOME_SET_ENABLEAUTOALTREF",
+ [AOME_SET_ARNR_MAXFRAMES] = "AOME_SET_ARNR_MAXFRAMES",
+ [AOME_SET_ARNR_STRENGTH] = "AOME_SET_ARNR_STRENGTH",
[AOME_SET_STATIC_THRESHOLD] = "AOME_SET_STATIC_THRESHOLD",
[AV1E_SET_COLOR_RANGE] = "AV1E_SET_COLOR_RANGE",
[AV1E_SET_COLOR_PRIMARIES] = "AV1E_SET_COLOR_PRIMARIES",
[AV1E_SET_MATRIX_COEFFICIENTS] = "AV1E_SET_MATRIX_COEFFICIENTS",
[AV1E_SET_TRANSFER_CHARACTERISTICS] = "AV1E_SET_TRANSFER_CHARACTERISTICS",
+ [AV1E_SET_AQ_MODE] = "AV1E_SET_AQ_MODE",
+ [AV1E_SET_FRAME_PARALLEL_DECODING] = "AV1E_SET_FRAME_PARALLEL_DECODING",
[AV1E_SET_SUPERBLOCK_SIZE] = "AV1E_SET_SUPERBLOCK_SIZE",
[AV1E_SET_TILE_COLUMNS] = "AV1E_SET_TILE_COLUMNS",
[AV1E_SET_TILE_ROWS] = "AV1E_SET_TILE_ROWS",
+#ifdef AOM_CTRL_AV1E_SET_ROW_MT
+ [AV1E_SET_ROW_MT] = "AV1E_SET_ROW_MT",
+#endif
+#ifdef AOM_CTRL_AV1E_SET_DENOISE_NOISE_LEVEL
+ [AV1E_SET_DENOISE_NOISE_LEVEL] = "AV1E_SET_DENOISE_NOISE_LEVEL",
+#endif
+#ifdef AOM_CTRL_AV1E_SET_DENOISE_BLOCK_SIZE
+ [AV1E_SET_DENOISE_BLOCK_SIZE] = "AV1E_SET_DENOISE_BLOCK_SIZE",
+#endif
+#ifdef AOM_CTRL_AV1E_SET_MAX_REFERENCE_FRAMES
+ [AV1E_SET_MAX_REFERENCE_FRAMES] = "AV1E_SET_MAX_REFERENCE_FRAMES",
+#endif
+#ifdef AOM_CTRL_AV1E_SET_ENABLE_GLOBAL_MOTION
+ [AV1E_SET_ENABLE_GLOBAL_MOTION] = "AV1E_SET_ENABLE_GLOBAL_MOTION",
+#endif
+#ifdef AOM_CTRL_AV1E_SET_ENABLE_INTRABC
+ [AV1E_SET_ENABLE_INTRABC] = "AV1E_SET_ENABLE_INTRABC",
+#endif
+ [AV1E_SET_ENABLE_CDEF] = "AV1E_SET_ENABLE_CDEF",
};
static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)
@@ -505,7 +541,8 @@ static av_cold int aom_init(AVCodecContext *avctx,
enccfg.g_h = avctx->height;
enccfg.g_timebase.num = avctx->time_base.num;
enccfg.g_timebase.den = avctx->time_base.den;
- enccfg.g_threads = avctx->thread_count ? avctx->thread_count : av_cpu_count();
+ enccfg.g_threads =
+ FFMIN(avctx->thread_count ? avctx->thread_count : av_cpu_count(), 64);
if (ctx->lag_in_frames >= 0)
enccfg.g_lag_in_frames = ctx->lag_in_frames;
@@ -558,10 +595,14 @@ static av_cold int aom_init(AVCodecContext *avctx,
// 0-100 (0 => CBR, 100 => VBR)
enccfg.rc_2pass_vbr_bias_pct = round(avctx->qcompress * 100);
- if (avctx->bit_rate)
+ if (ctx->minsection_pct >= 0)
+ enccfg.rc_2pass_vbr_minsection_pct = ctx->minsection_pct;
+ else if (avctx->bit_rate)
enccfg.rc_2pass_vbr_minsection_pct =
avctx->rc_min_rate * 100LL / avctx->bit_rate;
- if (avctx->rc_max_rate)
+ if (ctx->maxsection_pct >= 0)
+ enccfg.rc_2pass_vbr_maxsection_pct = ctx->maxsection_pct;
+ else if (avctx->rc_max_rate)
enccfg.rc_2pass_vbr_maxsection_pct =
avctx->rc_max_rate * 100LL / avctx->bit_rate;
@@ -573,6 +614,11 @@ static av_cold int aom_init(AVCodecContext *avctx,
avctx->rc_initial_buffer_occupancy * 1000LL / avctx->bit_rate;
enccfg.rc_buf_optimal_sz = enccfg.rc_buf_sz * 5 / 6;
+ if (ctx->rc_undershoot_pct >= 0)
+ enccfg.rc_undershoot_pct = ctx->rc_undershoot_pct;
+ if (ctx->rc_overshoot_pct >= 0)
+ enccfg.rc_overshoot_pct = ctx->rc_overshoot_pct;
+
// _enc_init() will balk if kf_min_dist differs from max w/AOM_KF_AUTO
if (avctx->keyint_min >= 0 && avctx->keyint_min == avctx->gop_size)
enccfg.kf_min_dist = avctx->keyint_min;
@@ -634,7 +680,12 @@ static av_cold int aom_init(AVCodecContext *avctx,
codecctl_int(avctx, AOME_SET_CPUUSED, ctx->cpu_used);
if (ctx->auto_alt_ref >= 0)
codecctl_int(avctx, AOME_SET_ENABLEAUTOALTREF, ctx->auto_alt_ref);
-
+ if (ctx->arnr_max_frames >= 0)
+ codecctl_int(avctx, AOME_SET_ARNR_MAXFRAMES, ctx->arnr_max_frames);
+ if (ctx->arnr_strength >= 0)
+ codecctl_int(avctx, AOME_SET_ARNR_STRENGTH, ctx->arnr_strength);
+ if (ctx->enable_cdef >= 0)
+ codecctl_int(avctx, AV1E_SET_ENABLE_CDEF, ctx->enable_cdef);
codecctl_int(avctx, AOME_SET_STATIC_THRESHOLD, ctx->static_thresh);
if (ctx->crf >= 0)
codecctl_int(avctx, AOME_SET_CQ_LEVEL, ctx->crf);
@@ -642,6 +693,10 @@ static av_cold int aom_init(AVCodecContext *avctx,
codecctl_int(avctx, AV1E_SET_COLOR_PRIMARIES, avctx->color_primaries);
codecctl_int(avctx, AV1E_SET_MATRIX_COEFFICIENTS, avctx->colorspace);
codecctl_int(avctx, AV1E_SET_TRANSFER_CHARACTERISTICS, avctx->color_trc);
+ if (ctx->aq_mode >= 0)
+ codecctl_int(avctx, AV1E_SET_AQ_MODE, ctx->aq_mode);
+ if (ctx->frame_parallel >= 0)
+ codecctl_int(avctx, AV1E_SET_FRAME_PARALLEL_DECODING, ctx->frame_parallel);
set_color_range(avctx);
codecctl_int(avctx, AV1E_SET_SUPERBLOCK_SIZE, ctx->superblock_size);
@@ -650,6 +705,32 @@ static av_cold int aom_init(AVCodecContext *avctx,
codecctl_int(avctx, AV1E_SET_TILE_ROWS, ctx->tile_rows_log2);
}
+#ifdef AOM_CTRL_AV1E_SET_DENOISE_NOISE_LEVEL
+ if (ctx->denoise_noise_level >= 0)
+ codecctl_int(avctx, AV1E_SET_DENOISE_NOISE_LEVEL, ctx->denoise_noise_level);
+#endif
+#ifdef AOM_CTRL_AV1E_SET_DENOISE_BLOCK_SIZE
+ if (ctx->denoise_block_size >= 0)
+ codecctl_int(avctx, AV1E_SET_DENOISE_BLOCK_SIZE, ctx->denoise_block_size);
+#endif
+#ifdef AOM_CTRL_AV1E_SET_ENABLE_GLOBAL_MOTION
+ if (ctx->enable_global_motion >= 0)
+ codecctl_int(avctx, AV1E_SET_ENABLE_GLOBAL_MOTION, ctx->enable_global_motion);
+#endif
+#ifdef AOM_CTRL_AV1E_SET_MAX_REFERENCE_FRAMES
+ if (avctx->refs >= 3) {
+ codecctl_int(avctx, AV1E_SET_MAX_REFERENCE_FRAMES, avctx->refs);
+ }
+#endif
+#ifdef AOM_CTRL_AV1E_SET_ROW_MT
+ if (ctx->row_mt >= 0)
+ codecctl_int(avctx, AV1E_SET_ROW_MT, ctx->row_mt);
+#endif
+#ifdef AOM_CTRL_AV1E_SET_ENABLE_INTRABC
+ if (ctx->enable_intrabc >= 0)
+ codecctl_int(avctx, AV1E_SET_ENABLE_INTRABC, ctx->enable_intrabc);
+#endif
+
// provide dummy value to initialize wrapper, values will be updated each _encode()
aom_img_wrap(&ctx->rawimg, img_fmt, avctx->width, avctx->height, 1,
(unsigned char*)1);
@@ -727,7 +808,7 @@ static int storeframe(AVCodecContext *avctx, struct FrameListData *cx_frame,
AVPacket *pkt)
{
AOMContext *ctx = avctx->priv_data;
- int pict_type;
+ int av_unused pict_type;
int ret = ff_alloc_packet2(avctx, pkt, cx_frame->sz, 0);
if (ret < 0) {
av_log(avctx, AV_LOG_ERROR,
@@ -975,19 +1056,37 @@ static const AVOption options[] = {
"frames (2-pass only)", OFFSET(auto_alt_ref), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 2, VE},
{ "lag-in-frames", "Number of frames to look ahead at for "
"alternate reference frame selection", OFFSET(lag_in_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
+ { "arnr-max-frames", "altref noise reduction max frame count", OFFSET(arnr_max_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
+ { "arnr-strength", "altref noise reduction filter strength", OFFSET(arnr_strength), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6, VE},
+ { "aq-mode", "adaptive quantization mode", OFFSET(aq_mode), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 4, VE, "aq_mode"},
+ { "none", "Aq not used", 0, AV_OPT_TYPE_CONST, {.i64 = 0}, 0, 0, VE, "aq_mode"},
+ { "variance", "Variance based Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0, VE, "aq_mode"},
+ { "complexity", "Complexity based Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0, VE, "aq_mode"},
+ { "cyclic", "Cyclic Refresh Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 3}, 0, 0, VE, "aq_mode"},
{ "error-resilience", "Error resilience configuration", OFFSET(error_resilient), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, VE, "er"},
{ "default", "Improve resiliency against losses of whole frames", 0, AV_OPT_TYPE_CONST, {.i64 = AOM_ERROR_RESILIENT_DEFAULT}, 0, 0, VE, "er"},
{ "crf", "Select the quality for constant quality mode", offsetof(AOMContext, crf), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 63, VE },
{ "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 },
{ "drop-threshold", "Frame drop threshold", offsetof(AOMContext, drop_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, VE },
- { "noise-sensitivity", "Noise sensitivity", OFFSET(noise_sensitivity), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 4, VE},
+ { "denoise-noise-level", "Amount of noise to be removed", OFFSET(denoise_noise_level), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
+ { "denoise-block-size", "Denoise block size ", OFFSET(denoise_block_size), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
+ { "undershoot-pct", "Datarate undershoot (min) target (%)", OFFSET(rc_undershoot_pct), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 100, VE},
+ { "overshoot-pct", "Datarate overshoot (max) target (%)", OFFSET(rc_overshoot_pct), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1000, VE},
+ { "minsection-pct", "GOP min bitrate (% of target)", OFFSET(minsection_pct), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 100, VE},
+ { "maxsection-pct", "GOP max bitrate (% of target)", OFFSET(maxsection_pct), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 5000, VE},
+ { "frame-parallel", "Enable frame parallel decodability features", OFFSET(frame_parallel), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
{ "tiles", "Tile columns x rows", OFFSET(tile_cols), AV_OPT_TYPE_IMAGE_SIZE, { .str = NULL }, 0, 0, VE },
{ "tile-columns", "Log2 of number of tile columns to use", OFFSET(tile_cols_log2), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6, VE},
{ "tile-rows", "Log2 of number of tile rows to use", OFFSET(tile_rows_log2), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6, VE},
- { NULL }
+ { "row-mt", "Enable row based multi-threading", OFFSET(row_mt), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
+ { "enable-cdef", "Enable CDEF filtering", OFFSET(enable_cdef), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
+ { "enable-global-motion", "Enable global motion", OFFSET(enable_global_motion), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
+ { "enable-intrabc", "Enable intra block copy prediction mode", OFFSET(enable_intrabc), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
+ { NULL },
};
static const AVCodecDefault defaults[] = {
+ { "b", "256*1000" },
{ "qmin", "-1" },
{ "qmax", "-1" },
{ "g", "-1" },
View git blame Copy permalink