avfilter/f_loop: make sure duration of frame is never zero
[ffmpeg.git] / libavfilter / af_adelay.c
index ca141ce..98c7ca5 100644 (file)
@@ -23,6 +23,7 @@
 #include "libavutil/samplefmt.h"
 #include "avfilter.h"
 #include "audio.h"
+#include "filters.h"
 #include "internal.h"
 
 typedef struct ChanDelay {
@@ -38,8 +39,10 @@ typedef struct AudioDelayContext {
     ChanDelay *chandelay;
     int nb_delays;
     int block_align;
-    unsigned max_delay;
+    int64_t padding;
+    int64_t max_delay;
     int64_t next_pts;
+    int eof;
 
     void (*delay_channel)(ChanDelay *d, int nb_samples,
                           const uint8_t *src, uint8_t *dst);
@@ -66,7 +69,7 @@ static int query_formats(AVFilterContext *ctx)
     };
     int ret;
 
-    layouts = ff_all_channel_layouts();
+    layouts = ff_all_channel_counts();
     if (!layouts)
         return AVERROR(ENOMEM);
     ret = ff_set_common_channel_layouts(ctx, layouts);
@@ -138,20 +141,41 @@ static int config_input(AVFilterLink *inlink)
     for (i = 0; i < s->nb_delays; i++) {
         ChanDelay *d = &s->chandelay[i];
         float delay;
+        char type = 0;
+        int ret;
 
         if (!(arg = av_strtok(p, "|", &saveptr)))
             break;
 
         p = NULL;
-        sscanf(arg, "%f", &delay);
 
-        d->delay = delay * inlink->sample_rate / 1000.0;
+        ret = sscanf(arg, "%d%c", &d->delay, &type);
+        if (ret != 2 || type != 'S') {
+            sscanf(arg, "%f", &delay);
+            d->delay = delay * inlink->sample_rate / 1000.0;
+        }
+
         if (d->delay < 0) {
             av_log(ctx, AV_LOG_ERROR, "Delay must be non negative number.\n");
             return AVERROR(EINVAL);
         }
     }
 
+    s->padding = s->chandelay[0].delay;
+    for (i = 1; i < s->nb_delays; i++) {
+        ChanDelay *d = &s->chandelay[i];
+
+        s->padding = FFMIN(s->padding, d->delay);
+    }
+
+    if (s->padding) {
+        for (i = 0; i < s->nb_delays; i++) {
+            ChanDelay *d = &s->chandelay[i];
+
+            d->delay -= s->padding;
+        }
+    }
+
     for (i = 0; i < s->nb_delays; i++) {
         ChanDelay *d = &s->chandelay[i];
 
@@ -165,11 +189,6 @@ static int config_input(AVFilterLink *inlink)
         s->max_delay = FFMAX(s->max_delay, d->delay);
     }
 
-    if (!s->max_delay) {
-        av_log(ctx, AV_LOG_ERROR, "At least one delay >0 must be specified.\n");
-        return AVERROR(EINVAL);
-    }
-
     switch (inlink->format) {
     case AV_SAMPLE_FMT_U8P : s->delay_channel = delay_channel_u8p ; break;
     case AV_SAMPLE_FMT_S16P: s->delay_channel = delay_channel_s16p; break;
@@ -191,9 +210,11 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
     if (ctx->is_disabled || !s->delays)
         return ff_filter_frame(ctx->outputs[0], frame);
 
-    out_frame = ff_get_audio_buffer(inlink, frame->nb_samples);
-    if (!out_frame)
+    out_frame = ff_get_audio_buffer(ctx->outputs[0], frame->nb_samples);
+    if (!out_frame) {
+        av_frame_free(&frame);
         return AVERROR(ENOMEM);
+    }
     av_frame_copy_props(out_frame, frame);
 
     for (i = 0; i < s->nb_delays; i++) {
@@ -207,26 +228,30 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
             s->delay_channel(d, frame->nb_samples, src, dst);
     }
 
-    s->next_pts = frame->pts + av_rescale_q(frame->nb_samples, (AVRational){1, inlink->sample_rate}, inlink->time_base);
+    out_frame->pts = s->next_pts;
+    s->next_pts += av_rescale_q(frame->nb_samples, (AVRational){1, inlink->sample_rate}, inlink->time_base);
     av_frame_free(&frame);
     return ff_filter_frame(ctx->outputs[0], out_frame);
 }
 
-static int request_frame(AVFilterLink *outlink)
+static int activate(AVFilterContext *ctx)
 {
-    AVFilterContext *ctx = outlink->src;
+    AVFilterLink *inlink = ctx->inputs[0];
+    AVFilterLink *outlink = ctx->outputs[0];
     AudioDelayContext *s = ctx->priv;
-    int ret;
+    AVFrame *frame = NULL;
+    int ret, status;
+    int64_t pts;
 
-    ret = ff_request_frame(ctx->inputs[0]);
-    if (ret == AVERROR_EOF && !ctx->is_disabled && s->max_delay) {
-        int nb_samples = FFMIN(s->max_delay, 2048);
-        AVFrame *frame;
+    FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink);
+
+    if (s->padding) {
+        int nb_samples = FFMIN(s->padding, 2048);
 
         frame = ff_get_audio_buffer(outlink, nb_samples);
         if (!frame)
             return AVERROR(ENOMEM);
-        s->max_delay -= nb_samples;
+        s->padding -= nb_samples;
 
         av_samples_set_silence(frame->extended_data, 0,
                                frame->nb_samples,
@@ -237,19 +262,57 @@ static int request_frame(AVFilterLink *outlink)
         if (s->next_pts != AV_NOPTS_VALUE)
             s->next_pts += av_rescale_q(nb_samples, (AVRational){1, outlink->sample_rate}, outlink->time_base);
 
-        ret = filter_frame(ctx->inputs[0], frame);
+        return ff_filter_frame(outlink, frame);
     }
 
-    return ret;
+    ret = ff_inlink_consume_frame(inlink, &frame);
+    if (ret < 0)
+        return ret;
+
+    if (ret > 0)
+        return filter_frame(inlink, frame);
+
+    if (ff_inlink_acknowledge_status(inlink, &status, &pts)) {
+        if (status == AVERROR_EOF)
+            s->eof = 1;
+    }
+
+    if (s->eof && s->max_delay) {
+        int nb_samples = FFMIN(s->max_delay, 2048);
+
+        frame = ff_get_audio_buffer(outlink, nb_samples);
+        if (!frame)
+            return AVERROR(ENOMEM);
+        s->max_delay -= nb_samples;
+
+        av_samples_set_silence(frame->extended_data, 0,
+                               frame->nb_samples,
+                               outlink->channels,
+                               frame->format);
+
+        frame->pts = s->next_pts;
+        return filter_frame(inlink, frame);
+    }
+
+    if (s->eof && s->max_delay == 0) {
+        ff_outlink_set_status(outlink, AVERROR_EOF, s->next_pts);
+        return 0;
+    }
+
+    if (!s->eof)
+        FF_FILTER_FORWARD_WANTED(outlink, inlink);
+
+    return FFERROR_NOT_READY;
 }
 
 static av_cold void uninit(AVFilterContext *ctx)
 {
     AudioDelayContext *s = ctx->priv;
-    int i;
 
-    for (i = 0; i < s->nb_delays; i++)
-        av_freep(&s->chandelay[i].samples);
+    if (s->chandelay) {
+        for (int i = 0; i < s->nb_delays; i++)
+            av_freep(&s->chandelay[i].samples);
+    }
     av_freep(&s->chandelay);
 }
 
@@ -258,16 +321,14 @@ static const AVFilterPad adelay_inputs[] = {
         .name         = "default",
         .type         = AVMEDIA_TYPE_AUDIO,
         .config_props = config_input,
-        .filter_frame = filter_frame,
     },
     { NULL }
 };
 
 static const AVFilterPad adelay_outputs[] = {
     {
-        .name          = "default",
-        .request_frame = request_frame,
-        .type          = AVMEDIA_TYPE_AUDIO,
+        .name = "default",
+        .type = AVMEDIA_TYPE_AUDIO,
     },
     { NULL }
 };
@@ -278,6 +339,7 @@ AVFilter ff_af_adelay = {
     .query_formats = query_formats,
     .priv_size     = sizeof(AudioDelayContext),
     .priv_class    = &adelay_class,
+    .activate      = activate,
     .uninit        = uninit,
     .inputs        = adelay_inputs,
     .outputs       = adelay_outputs,