Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Copyright (c) 1999 Chris Bagwell
  3.  * Copyright (c) 1999 Nick Bailey
  4.  * Copyright (c) 2007 Rob Sykes <robs@users.sourceforge.net>
  5.  * Copyright (c) 2013 Paul B Mahol
  6.  * Copyright (c) 2014 Andrew Kelley
  7.  *
  8.  * This file is part of FFmpeg.
  9.  *
  10.  * FFmpeg is free software; you can redistribute it and/or
  11.  * modify it under the terms of the GNU Lesser General Public
  12.  * License as published by the Free Software Foundation; either
  13.  * version 2.1 of the License, or (at your option) any later version.
  14.  *
  15.  * FFmpeg is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18.  * Lesser General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU Lesser General Public
  21.  * License along with FFmpeg; if not, write to the Free Software
  22.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  23.  */
  24.  
  25. /**
  26.  * @file
  27.  * audio compand filter
  28.  */
  29.  
  30. #include "libavutil/avassert.h"
  31. #include "libavutil/avstring.h"
  32. #include "libavutil/opt.h"
  33. #include "libavutil/samplefmt.h"
  34. #include "audio.h"
  35. #include "avfilter.h"
  36. #include "internal.h"
  37.  
  38. typedef struct ChanParam {
  39.     double attack;
  40.     double decay;
  41.     double volume;
  42. } ChanParam;
  43.  
  44. typedef struct CompandSegment {
  45.     double x, y;
  46.     double a, b;
  47. } CompandSegment;
  48.  
  49. typedef struct CompandContext {
  50.     const AVClass *class;
  51.     int nb_segments;
  52.     char *attacks, *decays, *points;
  53.     CompandSegment *segments;
  54.     ChanParam *channels;
  55.     double in_min_lin;
  56.     double out_min_lin;
  57.     double curve_dB;
  58.     double gain_dB;
  59.     double initial_volume;
  60.     double delay;
  61.     AVFrame *delay_frame;
  62.     int delay_samples;
  63.     int delay_count;
  64.     int delay_index;
  65.     int64_t pts;
  66.  
  67.     int (*compand)(AVFilterContext *ctx, AVFrame *frame);
  68. } CompandContext;
  69.  
  70. #define OFFSET(x) offsetof(CompandContext, x)
  71. #define A AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
  72.  
  73. static const AVOption compand_options[] = {
  74.     { "attacks", "set time over which increase of volume is determined", OFFSET(attacks), AV_OPT_TYPE_STRING, { .str = "0.3" }, 0, 0, A },
  75.     { "decays", "set time over which decrease of volume is determined", OFFSET(decays), AV_OPT_TYPE_STRING, { .str = "0.8" }, 0, 0, A },
  76.     { "points", "set points of transfer function", OFFSET(points), AV_OPT_TYPE_STRING, { .str = "-70/-70|-60/-20" }, 0, 0, A },
  77.     { "soft-knee", "set soft-knee", OFFSET(curve_dB), AV_OPT_TYPE_DOUBLE, { .dbl = 0.01 }, 0.01, 900, A },
  78.     { "gain", "set output gain", OFFSET(gain_dB), AV_OPT_TYPE_DOUBLE, { .dbl = 0 }, -900, 900, A },
  79.     { "volume", "set initial volume", OFFSET(initial_volume), AV_OPT_TYPE_DOUBLE, { .dbl = 0 }, -900, 0, A },
  80.     { "delay", "set delay for samples before sending them to volume adjuster", OFFSET(delay), AV_OPT_TYPE_DOUBLE, { .dbl = 0 }, 0, 20, A },
  81.     { NULL }
  82. };
  83.  
  84. AVFILTER_DEFINE_CLASS(compand);
  85.  
  86. static av_cold int init(AVFilterContext *ctx)
  87. {
  88.     CompandContext *s = ctx->priv;
  89.     s->pts            = AV_NOPTS_VALUE;
  90.     return 0;
  91. }
  92.  
  93. static av_cold void uninit(AVFilterContext *ctx)
  94. {
  95.     CompandContext *s = ctx->priv;
  96.  
  97.     av_freep(&s->channels);
  98.     av_freep(&s->segments);
  99.     av_frame_free(&s->delay_frame);
  100. }
  101.  
  102. static int query_formats(AVFilterContext *ctx)
  103. {
  104.     AVFilterChannelLayouts *layouts;
  105.     AVFilterFormats *formats;
  106.     static const enum AVSampleFormat sample_fmts[] = {
  107.         AV_SAMPLE_FMT_DBLP,
  108.         AV_SAMPLE_FMT_NONE
  109.     };
  110.     int ret;
  111.  
  112.     layouts = ff_all_channel_layouts();
  113.     if (!layouts)
  114.         return AVERROR(ENOMEM);
  115.     ret = ff_set_common_channel_layouts(ctx, layouts);
  116.     if (ret < 0)
  117.         return ret;
  118.  
  119.     formats = ff_make_format_list(sample_fmts);
  120.     if (!formats)
  121.         return AVERROR(ENOMEM);
  122.     ret = ff_set_common_formats(ctx, formats);
  123.     if (ret < 0)
  124.         return ret;
  125.  
  126.     formats = ff_all_samplerates();
  127.     if (!formats)
  128.         return AVERROR(ENOMEM);
  129.     return ff_set_common_samplerates(ctx, formats);
  130. }
  131.  
  132. static void count_items(char *item_str, int *nb_items)
  133. {
  134.     char *p;
  135.  
  136.     *nb_items = 1;
  137.     for (p = item_str; *p; p++) {
  138.         if (*p == ' ' || *p == '|')
  139.             (*nb_items)++;
  140.     }
  141. }
  142.  
  143. static void update_volume(ChanParam *cp, double in)
  144. {
  145.     double delta = in - cp->volume;
  146.  
  147.     if (delta > 0.0)
  148.         cp->volume += delta * cp->attack;
  149.     else
  150.         cp->volume += delta * cp->decay;
  151. }
  152.  
  153. static double get_volume(CompandContext *s, double in_lin)
  154. {
  155.     CompandSegment *cs;
  156.     double in_log, out_log;
  157.     int i;
  158.  
  159.     if (in_lin < s->in_min_lin)
  160.         return s->out_min_lin;
  161.  
  162.     in_log = log(in_lin);
  163.  
  164.     for (i = 1; i < s->nb_segments; i++)
  165.         if (in_log <= s->segments[i].x)
  166.             break;
  167.     cs = &s->segments[i - 1];
  168.     in_log -= cs->x;
  169.     out_log = cs->y + in_log * (cs->a * in_log + cs->b);
  170.  
  171.     return exp(out_log);
  172. }
  173.  
  174. static int compand_nodelay(AVFilterContext *ctx, AVFrame *frame)
  175. {
  176.     CompandContext *s    = ctx->priv;
  177.     AVFilterLink *inlink = ctx->inputs[0];
  178.     const int channels   = inlink->channels;
  179.     const int nb_samples = frame->nb_samples;
  180.     AVFrame *out_frame;
  181.     int chan, i;
  182.     int err;
  183.  
  184.     if (av_frame_is_writable(frame)) {
  185.         out_frame = frame;
  186.     } else {
  187.         out_frame = ff_get_audio_buffer(inlink, nb_samples);
  188.         if (!out_frame) {
  189.             av_frame_free(&frame);
  190.             return AVERROR(ENOMEM);
  191.         }
  192.         err = av_frame_copy_props(out_frame, frame);
  193.         if (err < 0) {
  194.             av_frame_free(&out_frame);
  195.             av_frame_free(&frame);
  196.             return err;
  197.         }
  198.     }
  199.  
  200.     for (chan = 0; chan < channels; chan++) {
  201.         const double *src = (double *)frame->extended_data[chan];
  202.         double *dst = (double *)out_frame->extended_data[chan];
  203.         ChanParam *cp = &s->channels[chan];
  204.  
  205.         for (i = 0; i < nb_samples; i++) {
  206.             update_volume(cp, fabs(src[i]));
  207.  
  208.             dst[i] = av_clipd(src[i] * get_volume(s, cp->volume), -1, 1);
  209.         }
  210.     }
  211.  
  212.     if (frame != out_frame)
  213.         av_frame_free(&frame);
  214.  
  215.     return ff_filter_frame(ctx->outputs[0], out_frame);
  216. }
  217.  
  218. #define MOD(a, b) (((a) >= (b)) ? (a) - (b) : (a))
  219.  
  220. static int compand_delay(AVFilterContext *ctx, AVFrame *frame)
  221. {
  222.     CompandContext *s    = ctx->priv;
  223.     AVFilterLink *inlink = ctx->inputs[0];
  224.     const int channels = inlink->channels;
  225.     const int nb_samples = frame->nb_samples;
  226.     int chan, i, av_uninit(dindex), oindex, av_uninit(count);
  227.     AVFrame *out_frame   = NULL;
  228.     int err;
  229.  
  230.     if (s->pts == AV_NOPTS_VALUE) {
  231.         s->pts = (frame->pts == AV_NOPTS_VALUE) ? 0 : frame->pts;
  232.     }
  233.  
  234.     av_assert1(channels > 0); /* would corrupt delay_count and delay_index */
  235.  
  236.     for (chan = 0; chan < channels; chan++) {
  237.         AVFrame *delay_frame = s->delay_frame;
  238.         const double *src    = (double *)frame->extended_data[chan];
  239.         double *dbuf         = (double *)delay_frame->extended_data[chan];
  240.         ChanParam *cp        = &s->channels[chan];
  241.         double *dst;
  242.  
  243.         count  = s->delay_count;
  244.         dindex = s->delay_index;
  245.         for (i = 0, oindex = 0; i < nb_samples; i++) {
  246.             const double in = src[i];
  247.             update_volume(cp, fabs(in));
  248.  
  249.             if (count >= s->delay_samples) {
  250.                 if (!out_frame) {
  251.                     out_frame = ff_get_audio_buffer(inlink, nb_samples - i);
  252.                     if (!out_frame) {
  253.                         av_frame_free(&frame);
  254.                         return AVERROR(ENOMEM);
  255.                     }
  256.                     err = av_frame_copy_props(out_frame, frame);
  257.                     if (err < 0) {
  258.                         av_frame_free(&out_frame);
  259.                         av_frame_free(&frame);
  260.                         return err;
  261.                     }
  262.                     out_frame->pts = s->pts;
  263.                     s->pts += av_rescale_q(nb_samples - i,
  264.                         (AVRational){ 1, inlink->sample_rate },
  265.                         inlink->time_base);
  266.                 }
  267.  
  268.                 dst = (double *)out_frame->extended_data[chan];
  269.                 dst[oindex++] = av_clipd(dbuf[dindex] *
  270.                         get_volume(s, cp->volume), -1, 1);
  271.             } else {
  272.                 count++;
  273.             }
  274.  
  275.             dbuf[dindex] = in;
  276.             dindex = MOD(dindex + 1, s->delay_samples);
  277.         }
  278.     }
  279.  
  280.     s->delay_count = count;
  281.     s->delay_index = dindex;
  282.  
  283.     av_frame_free(&frame);
  284.  
  285.     if (out_frame) {
  286.         err = ff_filter_frame(ctx->outputs[0], out_frame);
  287.         return err;
  288.     }
  289.  
  290.     return 0;
  291. }
  292.  
  293. static int compand_drain(AVFilterLink *outlink)
  294. {
  295.     AVFilterContext *ctx = outlink->src;
  296.     CompandContext *s    = ctx->priv;
  297.     const int channels   = outlink->channels;
  298.     AVFrame *frame       = NULL;
  299.     int chan, i, dindex;
  300.  
  301.     /* 2048 is to limit output frame size during drain */
  302.     frame = ff_get_audio_buffer(outlink, FFMIN(2048, s->delay_count));
  303.     if (!frame)
  304.         return AVERROR(ENOMEM);
  305.     frame->pts = s->pts;
  306.     s->pts += av_rescale_q(frame->nb_samples,
  307.             (AVRational){ 1, outlink->sample_rate }, outlink->time_base);
  308.  
  309.     av_assert0(channels > 0);
  310.     for (chan = 0; chan < channels; chan++) {
  311.         AVFrame *delay_frame = s->delay_frame;
  312.         double *dbuf = (double *)delay_frame->extended_data[chan];
  313.         double *dst = (double *)frame->extended_data[chan];
  314.         ChanParam *cp = &s->channels[chan];
  315.  
  316.         dindex = s->delay_index;
  317.         for (i = 0; i < frame->nb_samples; i++) {
  318.             dst[i] = av_clipd(dbuf[dindex] * get_volume(s, cp->volume),
  319.                     -1, 1);
  320.             dindex = MOD(dindex + 1, s->delay_samples);
  321.         }
  322.     }
  323.     s->delay_count -= frame->nb_samples;
  324.     s->delay_index = dindex;
  325.  
  326.     return ff_filter_frame(outlink, frame);
  327. }
  328.  
  329. static int config_output(AVFilterLink *outlink)
  330. {
  331.     AVFilterContext *ctx  = outlink->src;
  332.     CompandContext *s     = ctx->priv;
  333.     const int sample_rate = outlink->sample_rate;
  334.     double radius         = s->curve_dB * M_LN10 / 20.0;
  335.     char *p, *saveptr     = NULL;
  336.     const int channels    = outlink->channels;
  337.     int nb_attacks, nb_decays, nb_points;
  338.     int new_nb_items, num;
  339.     int i;
  340.     int err;
  341.  
  342.  
  343.     count_items(s->attacks, &nb_attacks);
  344.     count_items(s->decays, &nb_decays);
  345.     count_items(s->points, &nb_points);
  346.  
  347.     if (channels <= 0) {
  348.         av_log(ctx, AV_LOG_ERROR, "Invalid number of channels: %d\n", channels);
  349.         return AVERROR(EINVAL);
  350.     }
  351.  
  352.     if (nb_attacks > channels || nb_decays > channels) {
  353.         av_log(ctx, AV_LOG_ERROR,
  354.                 "Number of attacks/decays bigger than number of channels.\n");
  355.         return AVERROR(EINVAL);
  356.     }
  357.  
  358.     uninit(ctx);
  359.  
  360.     s->channels = av_mallocz_array(channels, sizeof(*s->channels));
  361.     s->nb_segments = (nb_points + 4) * 2;
  362.     s->segments = av_mallocz_array(s->nb_segments, sizeof(*s->segments));
  363.  
  364.     if (!s->channels || !s->segments) {
  365.         uninit(ctx);
  366.         return AVERROR(ENOMEM);
  367.     }
  368.  
  369.     p = s->attacks;
  370.     for (i = 0, new_nb_items = 0; i < nb_attacks; i++) {
  371.         char *tstr = av_strtok(p, " |", &saveptr);
  372.         p = NULL;
  373.         new_nb_items += sscanf(tstr, "%lf", &s->channels[i].attack) == 1;
  374.         if (s->channels[i].attack < 0) {
  375.             uninit(ctx);
  376.             return AVERROR(EINVAL);
  377.         }
  378.     }
  379.     nb_attacks = new_nb_items;
  380.  
  381.     p = s->decays;
  382.     for (i = 0, new_nb_items = 0; i < nb_decays; i++) {
  383.         char *tstr = av_strtok(p, " |", &saveptr);
  384.         p = NULL;
  385.         new_nb_items += sscanf(tstr, "%lf", &s->channels[i].decay) == 1;
  386.         if (s->channels[i].decay < 0) {
  387.             uninit(ctx);
  388.             return AVERROR(EINVAL);
  389.         }
  390.     }
  391.     nb_decays = new_nb_items;
  392.  
  393.     if (nb_attacks != nb_decays) {
  394.         av_log(ctx, AV_LOG_ERROR,
  395.                 "Number of attacks %d differs from number of decays %d.\n",
  396.                 nb_attacks, nb_decays);
  397.         uninit(ctx);
  398.         return AVERROR(EINVAL);
  399.     }
  400.  
  401.     for (i = nb_decays; i < channels; i++) {
  402.         s->channels[i].attack = s->channels[nb_decays - 1].attack;
  403.         s->channels[i].decay = s->channels[nb_decays - 1].decay;
  404.     }
  405.  
  406. #define S(x) s->segments[2 * ((x) + 1)]
  407.     p = s->points;
  408.     for (i = 0, new_nb_items = 0; i < nb_points; i++) {
  409.         char *tstr = av_strtok(p, " |", &saveptr);
  410.         p = NULL;
  411.         if (sscanf(tstr, "%lf/%lf", &S(i).x, &S(i).y) != 2) {
  412.             av_log(ctx, AV_LOG_ERROR,
  413.                     "Invalid and/or missing input/output value.\n");
  414.             uninit(ctx);
  415.             return AVERROR(EINVAL);
  416.         }
  417.         if (i && S(i - 1).x > S(i).x) {
  418.             av_log(ctx, AV_LOG_ERROR,
  419.                     "Transfer function input values must be increasing.\n");
  420.             uninit(ctx);
  421.             return AVERROR(EINVAL);
  422.         }
  423.         S(i).y -= S(i).x;
  424.         av_log(ctx, AV_LOG_DEBUG, "%d: x=%f y=%f\n", i, S(i).x, S(i).y);
  425.         new_nb_items++;
  426.     }
  427.     num = new_nb_items;
  428.  
  429.     /* Add 0,0 if necessary */
  430.     if (num == 0 || S(num - 1).x)
  431.         num++;
  432.  
  433. #undef S
  434. #define S(x) s->segments[2 * (x)]
  435.     /* Add a tail off segment at the start */
  436.     S(0).x = S(1).x - 2 * s->curve_dB;
  437.     S(0).y = S(1).y;
  438.     num++;
  439.  
  440.     /* Join adjacent colinear segments */
  441.     for (i = 2; i < num; i++) {
  442.         double g1 = (S(i - 1).y - S(i - 2).y) * (S(i - 0).x - S(i - 1).x);
  443.         double g2 = (S(i - 0).y - S(i - 1).y) * (S(i - 1).x - S(i - 2).x);
  444.         int j;
  445.  
  446.         if (fabs(g1 - g2))
  447.             continue;
  448.         num--;
  449.         for (j = --i; j < num; j++)
  450.             S(j) = S(j + 1);
  451.     }
  452.  
  453.     for (i = 0; !i || s->segments[i - 2].x; i += 2) {
  454.         s->segments[i].y += s->gain_dB;
  455.         s->segments[i].x *= M_LN10 / 20;
  456.         s->segments[i].y *= M_LN10 / 20;
  457.     }
  458.  
  459. #define L(x) s->segments[i - (x)]
  460.     for (i = 4; s->segments[i - 2].x; i += 2) {
  461.         double x, y, cx, cy, in1, in2, out1, out2, theta, len, r;
  462.  
  463.         L(4).a = 0;
  464.         L(4).b = (L(2).y - L(4).y) / (L(2).x - L(4).x);
  465.  
  466.         L(2).a = 0;
  467.         L(2).b = (L(0).y - L(2).y) / (L(0).x - L(2).x);
  468.  
  469.         theta = atan2(L(2).y - L(4).y, L(2).x - L(4).x);
  470.         len = sqrt(pow(L(2).x - L(4).x, 2.) + pow(L(2).y - L(4).y, 2.));
  471.         r = FFMIN(radius, len);
  472.         L(3).x = L(2).x - r * cos(theta);
  473.         L(3).y = L(2).y - r * sin(theta);
  474.  
  475.         theta = atan2(L(0).y - L(2).y, L(0).x - L(2).x);
  476.         len = sqrt(pow(L(0).x - L(2).x, 2.) + pow(L(0).y - L(2).y, 2.));
  477.         r = FFMIN(radius, len / 2);
  478.         x = L(2).x + r * cos(theta);
  479.         y = L(2).y + r * sin(theta);
  480.  
  481.         cx = (L(3).x + L(2).x + x) / 3;
  482.         cy = (L(3).y + L(2).y + y) / 3;
  483.  
  484.         L(2).x = x;
  485.         L(2).y = y;
  486.  
  487.         in1  = cx - L(3).x;
  488.         out1 = cy - L(3).y;
  489.         in2  = L(2).x - L(3).x;
  490.         out2 = L(2).y - L(3).y;
  491.         L(3).a = (out2 / in2 - out1 / in1) / (in2 - in1);
  492.         L(3).b = out1 / in1 - L(3).a * in1;
  493.     }
  494.     L(3).x = 0;
  495.     L(3).y = L(2).y;
  496.  
  497.     s->in_min_lin  = exp(s->segments[1].x);
  498.     s->out_min_lin = exp(s->segments[1].y);
  499.  
  500.     for (i = 0; i < channels; i++) {
  501.         ChanParam *cp = &s->channels[i];
  502.  
  503.         if (cp->attack > 1.0 / sample_rate)
  504.             cp->attack = 1.0 - exp(-1.0 / (sample_rate * cp->attack));
  505.         else
  506.             cp->attack = 1.0;
  507.         if (cp->decay > 1.0 / sample_rate)
  508.             cp->decay = 1.0 - exp(-1.0 / (sample_rate * cp->decay));
  509.         else
  510.             cp->decay = 1.0;
  511.         cp->volume = pow(10.0, s->initial_volume / 20);
  512.     }
  513.  
  514.     s->delay_samples = s->delay * sample_rate;
  515.     if (s->delay_samples <= 0) {
  516.         s->compand = compand_nodelay;
  517.         return 0;
  518.     }
  519.  
  520.     s->delay_frame = av_frame_alloc();
  521.     if (!s->delay_frame) {
  522.         uninit(ctx);
  523.         return AVERROR(ENOMEM);
  524.     }
  525.  
  526.     s->delay_frame->format         = outlink->format;
  527.     s->delay_frame->nb_samples     = s->delay_samples;
  528.     s->delay_frame->channel_layout = outlink->channel_layout;
  529.  
  530.     err = av_frame_get_buffer(s->delay_frame, 32);
  531.     if (err)
  532.         return err;
  533.  
  534.     outlink->flags |= FF_LINK_FLAG_REQUEST_LOOP;
  535.     s->compand = compand_delay;
  536.     return 0;
  537. }
  538.  
  539. static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
  540. {
  541.     AVFilterContext *ctx = inlink->dst;
  542.     CompandContext *s    = ctx->priv;
  543.  
  544.     return s->compand(ctx, frame);
  545. }
  546.  
  547. static int request_frame(AVFilterLink *outlink)
  548. {
  549.     AVFilterContext *ctx = outlink->src;
  550.     CompandContext *s    = ctx->priv;
  551.     int ret = 0;
  552.  
  553.     ret = ff_request_frame(ctx->inputs[0]);
  554.  
  555.     if (ret == AVERROR_EOF && !ctx->is_disabled && s->delay_count)
  556.         ret = compand_drain(outlink);
  557.  
  558.     return ret;
  559. }
  560.  
  561. static const AVFilterPad compand_inputs[] = {
  562.     {
  563.         .name         = "default",
  564.         .type         = AVMEDIA_TYPE_AUDIO,
  565.         .filter_frame = filter_frame,
  566.     },
  567.     { NULL }
  568. };
  569.  
  570. static const AVFilterPad compand_outputs[] = {
  571.     {
  572.         .name          = "default",
  573.         .request_frame = request_frame,
  574.         .config_props  = config_output,
  575.         .type          = AVMEDIA_TYPE_AUDIO,
  576.     },
  577.     { NULL }
  578. };
  579.  
  580.  
  581. AVFilter ff_af_compand = {
  582.     .name           = "compand",
  583.     .description    = NULL_IF_CONFIG_SMALL(
  584.             "Compress or expand audio dynamic range."),
  585.     .query_formats  = query_formats,
  586.     .priv_size      = sizeof(CompandContext),
  587.     .priv_class     = &compand_class,
  588.     .init           = init,
  589.     .uninit         = uninit,
  590.     .inputs         = compand_inputs,
  591.     .outputs        = compand_outputs,
  592. };
  593.