avfilter/af_silenceremove: prefer outlink instead of inlink
[ffmpeg.git] / libavfilter / af_compand.c
index db5aa35..c138f0b 100644 (file)
  * You should have received a copy of the GNU Lesser General Public
  * License along with FFmpeg; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- *
+ */
+
+/**
+ * @file
+ * audio compand filter
  */
 
 #include "libavutil/avassert.h"
 #include "libavutil/avstring.h"
+#include "libavutil/ffmath.h"
 #include "libavutil/opt.h"
 #include "libavutil/samplefmt.h"
-#include "avfilter.h"
 #include "audio.h"
+#include "avfilter.h"
 #include "internal.h"
 
 typedef struct ChanParam {
@@ -44,10 +49,10 @@ typedef struct CompandSegment {
 
 typedef struct CompandContext {
     const AVClass *class;
+    int nb_segments;
     char *attacks, *decays, *points;
     CompandSegment *segments;
     ChanParam *channels;
-    int nb_segments;
     double in_min_lin;
     double out_min_lin;
     double curve_dB;
@@ -67,9 +72,9 @@ typedef struct CompandContext {
 #define A AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
 
 static const AVOption compand_options[] = {
-    { "attacks", "set time over which increase of volume is determined", OFFSET(attacks), AV_OPT_TYPE_STRING, { .str=NULL}, 0, 0, A },
-    { "decays", "set time over which decrease of volume is determined", OFFSET(decays), AV_OPT_TYPE_STRING, { .str=NULL}, 0, 0, A },
-    { "points", "set points of transfer function", OFFSET(points), AV_OPT_TYPE_STRING, { .str=NULL}, 0, 0, A },
+    { "attacks", "set time over which increase of volume is determined", OFFSET(attacks), AV_OPT_TYPE_STRING, { .str = "0" }, 0, 0, A },
+    { "decays", "set time over which decrease of volume is determined", OFFSET(decays), AV_OPT_TYPE_STRING, { .str = "0.8" }, 0, 0, A },
+    { "points", "set points of transfer function", OFFSET(points), AV_OPT_TYPE_STRING, { .str = "-70/-70|-60/-20|1/0" }, 0, 0, A },
     { "soft-knee", "set soft-knee", OFFSET(curve_dB), AV_OPT_TYPE_DOUBLE, { .dbl = 0.01 }, 0.01, 900, A },
     { "gain", "set output gain", OFFSET(gain_dB), AV_OPT_TYPE_DOUBLE, { .dbl = 0 }, -900, 900, A },
     { "volume", "set initial volume", OFFSET(initial_volume), AV_OPT_TYPE_DOUBLE, { .dbl = 0 }, -900, 0, A },
@@ -82,12 +87,7 @@ AVFILTER_DEFINE_CLASS(compand);
 static av_cold int init(AVFilterContext *ctx)
 {
     CompandContext *s = ctx->priv;
-
-    if (!s->attacks || !s->decays || !s->points) {
-        av_log(ctx, AV_LOG_ERROR, "Missing attacks and/or decays and/or points.\n");
-        return AVERROR(EINVAL);
-    }
-
+    s->pts            = AV_NOPTS_VALUE;
     return 0;
 }
 
@@ -108,23 +108,26 @@ static int query_formats(AVFilterContext *ctx)
         AV_SAMPLE_FMT_DBLP,
         AV_SAMPLE_FMT_NONE
     };
+    int ret;
 
-    layouts = ff_all_channel_layouts();
+    layouts = ff_all_channel_counts();
     if (!layouts)
         return AVERROR(ENOMEM);
-    ff_set_common_channel_layouts(ctx, layouts);
+    ret = ff_set_common_channel_layouts(ctx, layouts);
+    if (ret < 0)
+        return ret;
 
     formats = ff_make_format_list(sample_fmts);
     if (!formats)
         return AVERROR(ENOMEM);
-    ff_set_common_formats(ctx, formats);
+    ret = ff_set_common_formats(ctx, formats);
+    if (ret < 0)
+        return ret;
 
     formats = ff_all_samplerates();
     if (!formats)
         return AVERROR(ENOMEM);
-    ff_set_common_samplerates(ctx, formats);
-
-    return 0;
+    return ff_set_common_samplerates(ctx, formats);
 }
 
 static void count_items(char *item_str, int *nb_items)
@@ -173,20 +176,26 @@ static int compand_nodelay(AVFilterContext *ctx, AVFrame *frame)
 {
     CompandContext *s    = ctx->priv;
     AVFilterLink *inlink = ctx->inputs[0];
-    const int channels = inlink->channels;
+    const int channels   = inlink->channels;
     const int nb_samples = frame->nb_samples;
     AVFrame *out_frame;
     int chan, i;
+    int err;
 
     if (av_frame_is_writable(frame)) {
         out_frame = frame;
     } else {
-        out_frame = ff_get_audio_buffer(inlink, nb_samples);
+        out_frame = ff_get_audio_buffer(ctx->outputs[0], nb_samples);
         if (!out_frame) {
             av_frame_free(&frame);
             return AVERROR(ENOMEM);
         }
-        av_frame_copy_props(out_frame, frame);
+        err = av_frame_copy_props(out_frame, frame);
+        if (err < 0) {
+            av_frame_free(&out_frame);
+            av_frame_free(&frame);
+            return err;
+        }
     }
 
     for (chan = 0; chan < channels; chan++) {
@@ -197,7 +206,7 @@ static int compand_nodelay(AVFilterContext *ctx, AVFrame *frame)
         for (i = 0; i < nb_samples; i++) {
             update_volume(cp, fabs(src[i]));
 
-            dst[i] = av_clipd(src[i] * get_volume(s, cp->volume), -1, 1);
+            dst[i] = src[i] * get_volume(s, cp->volume);
         }
     }
 
@@ -217,14 +226,19 @@ static int compand_delay(AVFilterContext *ctx, AVFrame *frame)
     const int nb_samples = frame->nb_samples;
     int chan, i, av_uninit(dindex), oindex, av_uninit(count);
     AVFrame *out_frame   = NULL;
+    int err;
+
+    if (s->pts == AV_NOPTS_VALUE) {
+        s->pts = (frame->pts == AV_NOPTS_VALUE) ? 0 : frame->pts;
+    }
 
     av_assert1(channels > 0); /* would corrupt delay_count and delay_index */
 
     for (chan = 0; chan < channels; chan++) {
         AVFrame *delay_frame = s->delay_frame;
-        const double *src = (double *)frame->extended_data[chan];
-        double *dbuf      = (double *)delay_frame->extended_data[chan];
-        ChanParam *cp = &s->channels[chan];
+        const double *src    = (double *)frame->extended_data[chan];
+        double *dbuf         = (double *)delay_frame->extended_data[chan];
+        ChanParam *cp        = &s->channels[chan];
         double *dst;
 
         count  = s->delay_count;
@@ -235,12 +249,17 @@ static int compand_delay(AVFilterContext *ctx, AVFrame *frame)
 
             if (count >= s->delay_samples) {
                 if (!out_frame) {
-                    out_frame = ff_get_audio_buffer(inlink, nb_samples - i);
+                    out_frame = ff_get_audio_buffer(ctx->outputs[0], nb_samples - i);
                     if (!out_frame) {
                         av_frame_free(&frame);
                         return AVERROR(ENOMEM);
                     }
-                    av_frame_copy_props(out_frame, frame);
+                    err = av_frame_copy_props(out_frame, frame);
+                    if (err < 0) {
+                        av_frame_free(&out_frame);
+                        av_frame_free(&frame);
+                        return err;
+                    }
                     out_frame->pts = s->pts;
                     s->pts += av_rescale_q(nb_samples - i,
                         (AVRational){ 1, inlink->sample_rate },
@@ -248,8 +267,7 @@ static int compand_delay(AVFilterContext *ctx, AVFrame *frame)
                 }
 
                 dst = (double *)out_frame->extended_data[chan];
-                dst[oindex++] = av_clipd(dbuf[dindex] *
-                        get_volume(s, cp->volume), -1, 1);
+                dst[oindex++] = dbuf[dindex] * get_volume(s, cp->volume);
             } else {
                 count++;
             }
@@ -263,17 +281,24 @@ static int compand_delay(AVFilterContext *ctx, AVFrame *frame)
     s->delay_index = dindex;
 
     av_frame_free(&frame);
-    return out_frame ? ff_filter_frame(ctx->outputs[0], out_frame) : 0;
+
+    if (out_frame) {
+        err = ff_filter_frame(ctx->outputs[0], out_frame);
+        return err;
+    }
+
+    return 0;
 }
 
 static int compand_drain(AVFilterLink *outlink)
 {
     AVFilterContext *ctx = outlink->src;
     CompandContext *s    = ctx->priv;
-    const int channels = outlink->channels;
+    const int channels   = outlink->channels;
+    AVFrame *frame       = NULL;
     int chan, i, dindex;
-    AVFrame *frame = NULL;
 
+    /* 2048 is to limit output frame size during drain */
     frame = ff_get_audio_buffer(outlink, FFMIN(2048, s->delay_count));
     if (!frame)
         return AVERROR(ENOMEM);
@@ -281,6 +306,7 @@ static int compand_drain(AVFilterLink *outlink)
     s->pts += av_rescale_q(frame->nb_samples,
             (AVRational){ 1, outlink->sample_rate }, outlink->time_base);
 
+    av_assert0(channels > 0);
     for (chan = 0; chan < channels; chan++) {
         AVFrame *delay_frame = s->delay_frame;
         double *dbuf = (double *)delay_frame->extended_data[chan];
@@ -289,7 +315,7 @@ static int compand_drain(AVFilterLink *outlink)
 
         dindex = s->delay_index;
         for (i = 0; i < frame->nb_samples; i++) {
-            dst[i] = av_clipd(dbuf[dindex] * get_volume(s, cp->volume), -1, 1);
+            dst[i] = dbuf[dindex] * get_volume(s, cp->volume);
             dindex = MOD(dindex + 1, s->delay_samples);
         }
     }
@@ -304,9 +330,10 @@ static int config_output(AVFilterLink *outlink)
     AVFilterContext *ctx  = outlink->src;
     CompandContext *s     = ctx->priv;
     const int sample_rate = outlink->sample_rate;
-    double radius         = s->curve_dB * M_LN10 / 20;
+    double radius         = s->curve_dB * M_LN10 / 20.0;
+    char *p, *saveptr     = NULL;
+    const int channels    = outlink->channels;
     int nb_attacks, nb_decays, nb_points;
-    char *p, *saveptr = NULL;
     int new_nb_items, num;
     int i;
     int err;
@@ -316,14 +343,20 @@ static int config_output(AVFilterLink *outlink)
     count_items(s->decays, &nb_decays);
     count_items(s->points, &nb_points);
 
-    if ((nb_attacks > outlink->channels) || (nb_decays > outlink->channels)) {
-        av_log(ctx, AV_LOG_ERROR, "Number of attacks/decays bigger than number of channels.\n");
+    if (channels <= 0) {
+        av_log(ctx, AV_LOG_ERROR, "Invalid number of channels: %d\n", channels);
+        return AVERROR(EINVAL);
+    }
+
+    if (nb_attacks > channels || nb_decays > channels) {
+        av_log(ctx, AV_LOG_ERROR,
+                "Number of attacks/decays bigger than number of channels.\n");
         return AVERROR(EINVAL);
     }
 
     uninit(ctx);
 
-    s->channels = av_mallocz_array(outlink->channels, sizeof(*s->channels));
+    s->channels = av_mallocz_array(channels, sizeof(*s->channels));
     s->nb_segments = (nb_points + 4) * 2;
     s->segments = av_mallocz_array(s->nb_segments, sizeof(*s->segments));
 
@@ -335,6 +368,10 @@ static int config_output(AVFilterLink *outlink)
     p = s->attacks;
     for (i = 0, new_nb_items = 0; i < nb_attacks; i++) {
         char *tstr = av_strtok(p, " |", &saveptr);
+        if (!tstr) {
+            uninit(ctx);
+            return AVERROR(EINVAL);
+        }
         p = NULL;
         new_nb_items += sscanf(tstr, "%lf", &s->channels[i].attack) == 1;
         if (s->channels[i].attack < 0) {
@@ -347,6 +384,10 @@ static int config_output(AVFilterLink *outlink)
     p = s->decays;
     for (i = 0, new_nb_items = 0; i < nb_decays; i++) {
         char *tstr = av_strtok(p, " |", &saveptr);
+        if (!tstr) {
+            uninit(ctx);
+            return AVERROR(EINVAL);
+        }
         p = NULL;
         new_nb_items += sscanf(tstr, "%lf", &s->channels[i].decay) == 1;
         if (s->channels[i].decay < 0) {
@@ -364,12 +405,17 @@ static int config_output(AVFilterLink *outlink)
         return AVERROR(EINVAL);
     }
 
+    for (i = nb_decays; i < channels; i++) {
+        s->channels[i].attack = s->channels[nb_decays - 1].attack;
+        s->channels[i].decay = s->channels[nb_decays - 1].decay;
+    }
+
 #define S(x) s->segments[2 * ((x) + 1)]
     p = s->points;
     for (i = 0, new_nb_items = 0; i < nb_points; i++) {
         char *tstr = av_strtok(p, " |", &saveptr);
         p = NULL;
-        if (sscanf(tstr, "%lf/%lf", &S(i).x, &S(i).y) != 2) {
+        if (!tstr || sscanf(tstr, "%lf/%lf", &S(i).x, &S(i).y) != 2) {
             av_log(ctx, AV_LOG_ERROR,
                     "Invalid and/or missing input/output value.\n");
             uninit(ctx);
@@ -411,14 +457,14 @@ static int config_output(AVFilterLink *outlink)
             S(j) = S(j + 1);
     }
 
-    for (i = 0; !i || s->segments[i - 2].x; i += 2) {
+    for (i = 0; i < s->nb_segments; i += 2) {
         s->segments[i].y += s->gain_dB;
         s->segments[i].x *= M_LN10 / 20;
         s->segments[i].y *= M_LN10 / 20;
     }
 
 #define L(x) s->segments[i - (x)]
-    for (i = 4; s->segments[i - 2].x; i += 2) {
+    for (i = 4; i < s->nb_segments; i += 2) {
         double x, y, cx, cy, in1, in2, out1, out2, theta, len, r;
 
         L(4).a = 0;
@@ -428,13 +474,13 @@ static int config_output(AVFilterLink *outlink)
         L(2).b = (L(0).y - L(2).y) / (L(0).x - L(2).x);
 
         theta = atan2(L(2).y - L(4).y, L(2).x - L(4).x);
-        len = sqrt(pow(L(2).x - L(4).x, 2.) + pow(L(2).y - L(4).y, 2.));
+        len = hypot(L(2).x - L(4).x, L(2).y - L(4).y);
         r = FFMIN(radius, len);
         L(3).x = L(2).x - r * cos(theta);
         L(3).y = L(2).y - r * sin(theta);
 
         theta = atan2(L(0).y - L(2).y, L(0).x - L(2).x);
-        len = sqrt(pow(L(0).x - L(2).x, 2.) + pow(L(0).y - L(2).y, 2.));
+        len = hypot(L(0).x - L(2).x, L(0).y - L(2).y);
         r = FFMIN(radius, len / 2);
         x = L(2).x + r * cos(theta);
         y = L(2).y + r * sin(theta);
@@ -458,7 +504,7 @@ static int config_output(AVFilterLink *outlink)
     s->in_min_lin  = exp(s->segments[1].x);
     s->out_min_lin = exp(s->segments[1].y);
 
-    for (i = 0; i < outlink->channels; i++) {
+    for (i = 0; i < channels; i++) {
         ChanParam *cp = &s->channels[i];
 
         if (cp->attack > 1.0 / sample_rate)
@@ -469,7 +515,7 @@ static int config_output(AVFilterLink *outlink)
             cp->decay = 1.0 - exp(-1.0 / (sample_rate * cp->decay));
         else
             cp->decay = 1.0;
-        cp->volume = pow(10.0, s->initial_volume / 20);
+        cp->volume = ff_exp10(s->initial_volume / 20);
     }
 
     s->delay_samples = s->delay * sample_rate;
@@ -492,7 +538,6 @@ static int config_output(AVFilterLink *outlink)
     if (err)
         return err;
 
-    outlink->flags |= FF_LINK_FLAG_REQUEST_LOOP;
     s->compand = compand_delay;
     return 0;
 }
@@ -509,7 +554,7 @@ static int request_frame(AVFilterLink *outlink)
 {
     AVFilterContext *ctx = outlink->src;
     CompandContext *s    = ctx->priv;
-    int ret;
+    int ret = 0;
 
     ret = ff_request_frame(ctx->inputs[0]);