[FFmpeg-devel] [PATCH] avfilter/alimiter: Add "flush_buffer" option to flush the remaining valid data to the output

[Wang Cao]

The change in the commit will add some samples to the end of the audio
stream. The intention is to add a "zero_delay" option eventually to not
have the delay in the begining the output from alimiter due to
lookahead.

Signed-off-by: Wang Cao <wangcao at google.com>
---
 doc/filters.texi          |  5 ++++
 libavfilter/af_alimiter.c | 57 ++++++++++++++++++++++++++++++++-------
 2 files changed, 53 insertions(+), 9 deletions(-)

If the intention is clear to you, do you prefer us add the "zero_delay"
option to the same patch or it needs to go in a separate patch? Thanks!

diff --git a/doc/filters.texi b/doc/filters.texi
index d70ac3e237..bb8f7c1a0b 100644
--- a/doc/filters.texi
+++ b/doc/filters.texi
@@ -1978,6 +1978,11 @@ in release time while 1 produces higher release times.
 @item level
 Auto level output signal. Default is enabled.
 This normalizes audio back to 0dB if enabled.
+
+ at item flush_buffer
+Flushes the internal buffer so that all the input audio samples to the limiter 
+will appear to the output. Currently due to lookahead buffer, the total number 
+of output samples will be larger than the input.
 @end table
 
 Depending on picked setting it is recommended to upsample input 2x or 4x times
diff --git a/libavfilter/af_alimiter.c b/libavfilter/af_alimiter.c
index 133f98f165..ba0a1361ac 100644
--- a/libavfilter/af_alimiter.c
+++ b/libavfilter/af_alimiter.c
@@ -55,6 +55,9 @@ typedef struct AudioLimiterContext {
     int *nextpos;
     double *nextdelta;
 
+    int flush_buffer;
+    int total_samples_to_flush;
+
     double delta;
     int nextiter;
     int nextlen;
@@ -65,14 +68,15 @@ typedef struct AudioLimiterContext {
 #define AF AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_RUNTIME_PARAM
 
 static const AVOption alimiter_options[] = {
-    { "level_in",  "set input level",  OFFSET(level_in),     AV_OPT_TYPE_DOUBLE, {.dbl=1},.015625,   64, AF },
-    { "level_out", "set output level", OFFSET(level_out),    AV_OPT_TYPE_DOUBLE, {.dbl=1},.015625,   64, AF },
-    { "limit",     "set limit",        OFFSET(limit),        AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0.0625,    1, AF },
-    { "attack",    "set attack",       OFFSET(attack),       AV_OPT_TYPE_DOUBLE, {.dbl=5},    0.1,   80, AF },
-    { "release",   "set release",      OFFSET(release),      AV_OPT_TYPE_DOUBLE, {.dbl=50},     1, 8000, AF },
-    { "asc",       "enable asc",       OFFSET(auto_release), AV_OPT_TYPE_BOOL,   {.i64=0},      0,    1, AF },
-    { "asc_level", "set asc level",    OFFSET(asc_coeff),    AV_OPT_TYPE_DOUBLE, {.dbl=0.5},    0,    1, AF },
-    { "level",     "auto level",       OFFSET(auto_level),   AV_OPT_TYPE_BOOL,   {.i64=1},      0,    1, AF },
+    { "level_in",  "set input level",                              OFFSET(level_in),     AV_OPT_TYPE_DOUBLE, {.dbl=1},.015625,   64, AF },
+    { "level_out", "set output level",                             OFFSET(level_out),    AV_OPT_TYPE_DOUBLE, {.dbl=1},.015625,   64, AF },
+    { "limit",     "set limit",                                    OFFSET(limit),        AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0.0625,    1, AF },
+    { "attack",    "set attack",                                   OFFSET(attack),       AV_OPT_TYPE_DOUBLE, {.dbl=5},    0.1,   80, AF },
+    { "release",   "set release",                                  OFFSET(release),      AV_OPT_TYPE_DOUBLE, {.dbl=50},     1, 8000, AF },
+    { "asc",       "enable asc",                                   OFFSET(auto_release), AV_OPT_TYPE_BOOL,   {.i64=0},      0,    1, AF },
+    { "asc_level", "set asc level",                                OFFSET(asc_coeff),    AV_OPT_TYPE_DOUBLE, {.dbl=0.5},    0,    1, AF },
+    { "level",     "auto level",                                   OFFSET(auto_level),   AV_OPT_TYPE_BOOL,   {.i64=1},      0,    1, AF },
+    { "flush_buffer","flush the samples in the lookahead buffer",  OFFSET(flush_buffer),   AV_OPT_TYPE_BOOL, {.i64=0},      0,    1, AF },
     { NULL }
 };
 
@@ -275,6 +279,39 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
     return ff_filter_frame(outlink, out);
 }
 
+
+static int request_frame(AVFilterLink* outlink) {
+  AVFilterContext* ctx = outlink->src;
+  AudioLimiterContext* s = (AudioLimiterContext*)ctx->priv;
+  int ret;
+  AVFilterLink *inlink;
+  AVFrame *silence_frame;
+
+  ret = ff_request_frame(ctx->inputs[0]);
+
+  if (!s->flush_buffer) {
+      return 0;
+  }
+
+  if (ret != AVERROR_EOF || s->total_samples_to_flush) {
+    // Not necessarily an error, just not EOF.s
+    return ret;
+  }
+
+  // We reach here when input filters have finished producing data (i.e. EOF),
+  // but because of the attac param, s->buffer still has meaningful
+  // audio content that needs flushing. The amount of remaining audio to flush
+  // is the same as the amount of lookahead that was trimmed from the beginning.
+  inlink = ctx->inputs[0];
+  // Pushes silence frame to flush valid audio in the s->buffer
+  silence_frame = ff_get_audio_buffer(inlink, s->total_samples_to_flush);
+  ret = filter_frame(inlink, silence_frame);
+  if (ret < 0) {
+    return ret;
+  }
+  return AVERROR_EOF;
+}
+
 static int config_input(AVFilterLink *inlink)
 {
     AVFilterContext *ctx = inlink->dst;
@@ -292,7 +329,8 @@ static int config_input(AVFilterLink *inlink)
         return AVERROR(ENOMEM);
 
     memset(s->nextpos, -1, obuffer_size * sizeof(*s->nextpos));
-    s->buffer_size = inlink->sample_rate * s->attack * inlink->ch_layout.nb_channels;
+    s->total_samples_to_flush = inlink->sample_rate * s->attack;
+    s->buffer_size = s->total_samples_to_flush * inlink->ch_layout.nb_channels;
     s->buffer_size -= s->buffer_size % inlink->ch_layout.nb_channels;
 
     if (s->buffer_size <= 0) {
@@ -325,6 +363,7 @@ static const AVFilterPad alimiter_outputs[] = {
     {
         .name = "default",
         .type = AVMEDIA_TYPE_AUDIO,
+        .request_frame = request_frame,
     },
 };
 
-- 
2.35.1.1021.g381101b075-goog