vf_paletteuse: Add error checking to apply_palette
[ffmpeg.git] / 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 #include "formats.h"
26
27 typedef struct CrystalizerContext {
28     const AVClass *class;
29     float mult;
30     int clip;
31     AVFrame *prev;
32     void (*filter)(void **dst, void **prv, const void **src,
33                    int nb_samples, int channels, float mult, int clip);
34 } CrystalizerContext;
35
36 #define OFFSET(x) offsetof(CrystalizerContext, x)
37 #define A AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
38
39 static const AVOption crystalizer_options[] = {
40     { "i", "set intensity",    OFFSET(mult), AV_OPT_TYPE_FLOAT, {.dbl=2.0}, 0, 10, A },
41     { "c", "enable clipping",  OFFSET(clip), AV_OPT_TYPE_BOOL,  {.i64=1},   0,  1, A },
42     { NULL }
43 };
44
45 AVFILTER_DEFINE_CLASS(crystalizer);
46
47 static int query_formats(AVFilterContext *ctx)
48 {
49     AVFilterFormats *formats = NULL;
50     AVFilterChannelLayouts *layouts = NULL;
51     static const enum AVSampleFormat sample_fmts[] = {
52         AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLTP,
53         AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBLP,
54         AV_SAMPLE_FMT_NONE
55     };
56     int ret;
57
58     formats = ff_make_format_list(sample_fmts);
59     if (!formats)
60         return AVERROR(ENOMEM);
61     ret = ff_set_common_formats(ctx, formats);
62     if (ret < 0)
63         return ret;
64
65     layouts = ff_all_channel_counts();
66     if (!layouts)
67         return AVERROR(ENOMEM);
68
69     ret = ff_set_common_channel_layouts(ctx, layouts);
70     if (ret < 0)
71         return ret;
72
73     formats = ff_all_samplerates();
74     return ff_set_common_samplerates(ctx, formats);
75 }
76
77 static void filter_flt(void **d, void **p, const void **s,
78                        int nb_samples, int channels,
79                        float mult, int clip)
80 {
81     const float *src = s[0];
82     float *dst = d[0];
83     float *prv = p[0];
84     int n, c;
85
86     for (n = 0; n < nb_samples; n++) {
87         for (c = 0; c < channels; c++) {
88             float current = src[c];
89
90             dst[c] = current + (current - prv[c]) * mult;
91             prv[c] = current;
92             if (clip) {
93                 dst[c] = av_clipf(dst[c], -1, 1);
94             }
95         }
96
97         dst += c;
98         src += c;
99     }
100 }
101
102 static void filter_dbl(void **d, void **p, const void **s,
103                        int nb_samples, int channels,
104                        float mult, int clip)
105 {
106     const double *src = s[0];
107     double *dst = d[0];
108     double *prv = p[0];
109     int n, c;
110
111     for (n = 0; n < nb_samples; n++) {
112         for (c = 0; c < channels; c++) {
113             double current = src[c];
114
115             dst[c] = current + (current - prv[c]) * mult;
116             prv[c] = current;
117             if (clip) {
118                 dst[c] = av_clipd(dst[c], -1, 1);
119             }
120         }
121
122         dst += c;
123         src += c;
124     }
125 }
126
127 static void filter_fltp(void **d, void **p, const void **s,
128                         int nb_samples, int channels,
129                         float mult, int clip)
130 {
131     int n, c;
132
133     for (c = 0; c < channels; c++) {
134         const float *src = s[c];
135         float *dst = d[c];
136         float *prv = p[c];
137
138         for (n = 0; n < nb_samples; n++) {
139             float current = src[n];
140
141             dst[n] = current + (current - prv[0]) * mult;
142             prv[0] = current;
143             if (clip) {
144                 dst[n] = av_clipf(dst[n], -1, 1);
145             }
146         }
147     }
148 }
149
150 static void filter_dblp(void **d, void **p, const void **s,
151                         int nb_samples, int channels,
152                         float mult, int clip)
153 {
154     int n, c;
155
156     for (c = 0; c < channels; c++) {
157         const double *src = s[c];
158         double *dst = d[c];
159         double *prv = p[c];
160
161         for (n = 0; n < nb_samples; n++) {
162             double current = src[n];
163
164             dst[n] = current + (current - prv[0]) * mult;
165             prv[0] = current;
166             if (clip) {
167                 dst[n] = av_clipd(dst[n], -1, 1);
168             }
169         }
170     }
171 }
172
173 static int config_input(AVFilterLink *inlink)
174 {
175     AVFilterContext *ctx = inlink->dst;
176     CrystalizerContext *s = ctx->priv;
177
178     switch (inlink->format) {
179     case AV_SAMPLE_FMT_FLT:  s->filter = filter_flt;  break;
180     case AV_SAMPLE_FMT_DBL:  s->filter = filter_dbl;  break;
181     case AV_SAMPLE_FMT_FLTP: s->filter = filter_fltp; break;
182     case AV_SAMPLE_FMT_DBLP: s->filter = filter_dblp; break;
183     }
184
185     return 0;
186 }
187
188 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
189 {
190     AVFilterContext *ctx = inlink->dst;
191     AVFilterLink *outlink = ctx->outputs[0];
192     CrystalizerContext *s = ctx->priv;
193     AVFrame *out;
194
195     if (!s->prev) {
196         s->prev = ff_get_audio_buffer(inlink, 1);
197         if (!s->prev) {
198             av_frame_free(&in);
199             return AVERROR(ENOMEM);
200         }
201     }
202
203     if (av_frame_is_writable(in)) {
204         out = in;
205     } else {
206         out = ff_get_audio_buffer(outlink, in->nb_samples);
207         if (!out) {
208             av_frame_free(&in);
209             return AVERROR(ENOMEM);
210         }
211         av_frame_copy_props(out, in);
212     }
213
214     s->filter((void **)out->extended_data, (void **)s->prev->extended_data, (const void **)in->extended_data,
215               in->nb_samples, in->channels, s->mult, s->clip);
216
217     if (out != in)
218         av_frame_free(&in);
219
220     return ff_filter_frame(outlink, out);
221 }
222
223 static av_cold void uninit(AVFilterContext *ctx)
224 {
225     CrystalizerContext *s = ctx->priv;
226
227     av_frame_free(&s->prev);
228 }
229
230 static const AVFilterPad inputs[] = {
231     {
232         .name         = "default",
233         .type         = AVMEDIA_TYPE_AUDIO,
234         .filter_frame = filter_frame,
235         .config_props = config_input,
236     },
237     { NULL }
238 };
239
240 static const AVFilterPad outputs[] = {
241     {
242         .name = "default",
243         .type = AVMEDIA_TYPE_AUDIO,
244     },
245     { NULL }
246 };
247
248 AVFilter ff_af_crystalizer = {
249     .name           = "crystalizer",
250     .description    = NULL_IF_CONFIG_SMALL("Simple expand audio dynamic range filter."),
251     .query_formats  = query_formats,
252     .priv_size      = sizeof(CrystalizerContext),
253     .priv_class     = &crystalizer_class,
254     .uninit         = uninit,
255     .inputs         = inputs,
256     .outputs        = outputs,
257 };