libavfilter/af_crystalizer.c

   1 /*
   2  * Copyright (c) 2016 The FFmpeg Project
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include "libavutil/channel_layout.h"
  22 #include "libavutil/opt.h"
  23 #include "avfilter.h"
  24 #include "audio.h"
  25
  26 typedef struct CrystalizerContext {
  27     const AVClass *class;
  28     float mult;
  29     int clip;
  30     AVFrame *prev;
  31     int (*filter[2][2])(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
  32 } CrystalizerContext;
  33
  34 #define OFFSET(x) offsetof(CrystalizerContext, x)
  35 #define A AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
  36
  37 static const AVOption crystalizer_options[] = {
  38     { "i", "set intensity",    OFFSET(mult), AV_OPT_TYPE_FLOAT, {.dbl=2.0},-10, 10, A },
  39     { "c", "enable clipping",  OFFSET(clip), AV_OPT_TYPE_BOOL,  {.i64=1},   0,  1, A },
  40     { NULL }
  41 };
  42
  43 AVFILTER_DEFINE_CLASS(crystalizer);
  44
  45 typedef struct ThreadData {
  46     void **d;
  47     void **p;
  48     const void **s;
  49     int nb_samples;
  50     int channels;
  51     float mult;
  52 } ThreadData;
  53
  54 #define filters(fmt, type, inverse, clp, inverset, clip, one, clip_fn, packed)  \
  55 static int filter_## inverse ##_## fmt ##_## clp(AVFilterContext *ctx, \
  56                                                   void *arg, int jobnr,\
  57                                                   int nb_jobs)         \
  58 {                                                                      \
  59     ThreadData *td = arg;                                              \
  60     void **d = td->d;                                                  \
  61     void **p = td->p;                                                  \
  62     const void **s = td->s;                                            \
  63     const int nb_samples = td->nb_samples;                             \
  64     const int channels = td->channels;                                 \
  65     const type mult = td->mult;                                        \
  66     const type scale = one / (-mult + one);                            \
  67     const int start = (channels * jobnr) / nb_jobs;                    \
  68     const int end = (channels * (jobnr+1)) / nb_jobs;                  \
  69                                                                        \
  70     if (packed) {                                                      \
  71         type *prv = p[0];                                              \
  72         for (int c = start; c < end; c++) {                            \
  73             const type *src = s[0];                                    \
  74             type *dst = d[0];                                          \
  75                                                                        \
  76             for (int n = 0; n < nb_samples; n++) {                     \
  77                 type current = src[c];                                 \
  78                                                                        \
  79                 if (inverset) {                                        \
  80                     dst[c] = (current - prv[c] * mult) * scale;        \
  81                     prv[c] = dst[c];                                   \
  82                 } else {                                               \
  83                     dst[c] = current + (current - prv[c]) * mult;      \
  84                     prv[c] = current;                                  \
  85                 }                                                      \
  86                 if (clip) {                                            \
  87                     dst[c] = clip_fn(dst[c], -one, one);               \
  88                 }                                                      \
  89                                                                        \
  90                 dst += channels;                                       \
  91                 src += channels;                                       \
  92             }                                                          \
  93         }                                                              \
  94     } else {                                                           \
  95         for (int c = start; c < end; c++) {                            \
  96             const type *src = s[c];                                    \
  97             type *dst = d[c];                                          \
  98             type *prv = p[c];                                          \
  99                                                                        \
 100             for (int n = 0; n < nb_samples; n++) {                     \
 101                 type current = src[n];                                 \
 102                                                                        \
 103                 if (inverset) {                                        \
 104                     dst[n] = (current - prv[0] * mult) * scale;        \
 105                     prv[0] = dst[n];                                   \
 106                 } else {                                               \
 107                     dst[n] = current + (current - prv[0]) * mult;      \
 108                     prv[0] = current;                                  \
 109                 }                                                      \
 110                 if (clip) {                                            \
 111                     dst[n] = clip_fn(dst[n], -one, one);               \
 112                 }                                                      \
 113             }                                                          \
 114         }                                                              \
 115     }                                                                  \
 116                                                                        \
 117     return 0;                                                          \
 118 }
 119
 120 filters(flt, float, inverse, noclip, 1, 0, 1.f, av_clipf, 1)
 121 filters(flt, float, inverse, clip, 1, 1, 1.f, av_clipf, 1)
 122 filters(flt, float, noinverse, noclip, 0, 0, 1.f, av_clipf, 1)
 123 filters(flt, float, noinverse, clip, 0, 1, 1.f, av_clipf, 1)
 124
 125 filters(fltp, float, inverse, noclip, 1, 0, 1.f, av_clipf, 0)
 126 filters(fltp, float, inverse, clip, 1, 1, 1.f, av_clipf, 0)
 127 filters(fltp, float, noinverse, noclip, 0, 0, 1.f, av_clipf, 0)
 128 filters(fltp, float, noinverse, clip, 0, 1, 1.f, av_clipf, 0)
 129
 130 filters(dbl, double, inverse, noclip, 1, 0, 1.0, av_clipd, 1)
 131 filters(dbl, double, inverse, clip, 1, 1, 1.0, av_clipd, 1)
 132 filters(dbl, double, noinverse, noclip, 0, 0, 1.0, av_clipd, 1)
 133 filters(dbl, double, noinverse, clip, 0, 1, 1.0, av_clipd, 1)
 134
 135 filters(dblp, double, inverse, noclip, 1, 0, 1.0, av_clipd, 0)
 136 filters(dblp, double, inverse, clip, 1, 1, 1.0, av_clipd, 0)
 137 filters(dblp, double, noinverse, noclip, 0, 0, 1.0, av_clipd, 0)
 138 filters(dblp, double, noinverse, clip, 0, 1, 1.0, av_clipd, 0)
 139
 140 static int config_input(AVFilterLink *inlink)
 141 {
 142     AVFilterContext *ctx = inlink->dst;
 143     CrystalizerContext *s = ctx->priv;
 144
 145     switch (inlink->format) {
 146     case AV_SAMPLE_FMT_FLT:
 147         s->filter[0][0] = filter_inverse_flt_noclip;
 148         s->filter[1][0] = filter_noinverse_flt_noclip;
 149         s->filter[0][1] = filter_inverse_flt_clip;
 150         s->filter[1][1] = filter_noinverse_flt_clip;
 151         break;
 152     case AV_SAMPLE_FMT_FLTP:
 153         s->filter[0][0] = filter_inverse_fltp_noclip;
 154         s->filter[1][0] = filter_noinverse_fltp_noclip;
 155         s->filter[0][1] = filter_inverse_fltp_clip;
 156         s->filter[1][1] = filter_noinverse_fltp_clip;
 157         break;
 158     case AV_SAMPLE_FMT_DBL:
 159         s->filter[0][0] = filter_inverse_dbl_noclip;
 160         s->filter[1][0] = filter_noinverse_dbl_noclip;
 161         s->filter[0][1] = filter_inverse_dbl_clip;
 162         s->filter[1][1] = filter_noinverse_dbl_clip;
 163         break;
 164     case AV_SAMPLE_FMT_DBLP:
 165         s->filter[0][0] = filter_inverse_dblp_noclip;
 166         s->filter[1][0] = filter_noinverse_dblp_noclip;
 167         s->filter[0][1] = filter_inverse_dblp_clip;
 168         s->filter[1][1] = filter_noinverse_dblp_clip;
 169         break;
 170     default:
 171         return AVERROR_BUG;
 172     }
 173
 174     return 0;
 175 }
 176
 177 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
 178 {
 179     AVFilterContext *ctx = inlink->dst;
 180     AVFilterLink *outlink = ctx->outputs[0];
 181     CrystalizerContext *s = ctx->priv;
 182     AVFrame *out;
 183     ThreadData td;
 184
 185     if (!s->prev) {
 186         s->prev = ff_get_audio_buffer(inlink, 1);
 187         if (!s->prev) {
 188             av_frame_free(&in);
 189             return AVERROR(ENOMEM);
 190         }
 191     }
 192
 193     if (av_frame_is_writable(in)) {
 194         out = in;
 195     } else {
 196         out = ff_get_audio_buffer(outlink, in->nb_samples);
 197         if (!out) {
 198             av_frame_free(&in);
 199             return AVERROR(ENOMEM);
 200         }
 201         av_frame_copy_props(out, in);
 202     }
 203
 204     td.d = (void **)out->extended_data;
 205     td.s = (const void **)in->extended_data;
 206     td.p = (void **)s->prev->extended_data;
 207     td.nb_samples = in->nb_samples;
 208     td.channels = in->ch_layout.nb_channels;
 209     td.mult = ctx->is_disabled ? 0.f : s->mult;
 210     ff_filter_execute(ctx, s->filter[td.mult >= 0.f][s->clip], &td, NULL,
 211                       FFMIN(inlink->ch_layout.nb_channels, ff_filter_get_nb_threads(ctx)));
 212
 213     if (out != in)
 214         av_frame_free(&in);
 215
 216     return ff_filter_frame(outlink, out);
 217 }
 218
 219 static av_cold void uninit(AVFilterContext *ctx)
 220 {
 221     CrystalizerContext *s = ctx->priv;
 222
 223     av_frame_free(&s->prev);
 224 }
 225
 226 static const AVFilterPad inputs[] = {
 227     {
 228         .name         = "default",
 229         .type         = AVMEDIA_TYPE_AUDIO,
 230         .filter_frame = filter_frame,
 231         .config_props = config_input,
 232     },
 233 };
 234
 235 const AVFilter ff_af_crystalizer = {
 236     .name           = "crystalizer",
 237     .description    = NULL_IF_CONFIG_SMALL("Simple audio noise sharpening filter."),
 238     .priv_size      = sizeof(CrystalizerContext),
 239     .priv_class     = &crystalizer_class,
 240     .uninit         = uninit,
 241     FILTER_INPUTS(inputs),
 242     FILTER_OUTPUTS(ff_audio_default_filterpad),
 243     FILTER_SAMPLEFMTS(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLTP,
 244                       AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBLP),
 245     .process_command = ff_filter_process_command,
 246     .flags          = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
 247                       AVFILTER_FLAG_SLICE_THREADS,
 248 };