avfilter/vf_ssim: fix temp size calculation
[ffmpeg.git] / libavfilter / af_surround.c
1 /*
2  * Copyright (c) 2017 Paul B Mahol
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/audio_fifo.h"
22 #include "libavutil/channel_layout.h"
23 #include "libavutil/opt.h"
24 #include "libavcodec/avfft.h"
25 #include "avfilter.h"
26 #include "audio.h"
27 #include "formats.h"
28
29 typedef struct AudioSurroundContext {
30     const AVClass *class;
31
32     char *out_channel_layout_str;
33     char *in_channel_layout_str;
34     float level_in;
35     float level_out;
36     int output_lfe;
37     int lowcutf;
38     int highcutf;
39
40     float lowcut;
41     float highcut;
42
43     uint64_t out_channel_layout;
44     uint64_t in_channel_layout;
45     int nb_in_channels;
46     int nb_out_channels;
47
48     AVFrame *input;
49     AVFrame *output;
50     AVFrame *overlap_buffer;
51
52     int buf_size;
53     int hop_size;
54     AVAudioFifo *fifo;
55     RDFTContext **rdft, **irdft;
56     float *window_func_lut;
57
58     int64_t pts;
59
60     void (*filter)(AVFilterContext *ctx);
61     void (*upmix_stereo)(AVFilterContext *ctx,
62                          float l_phase,
63                          float r_phase,
64                          float c_phase,
65                          float mag_total,
66                          float x, float y,
67                          int n);
68     void (*upmix_2_1)(AVFilterContext *ctx,
69                       float l_phase,
70                       float r_phase,
71                       float c_phase,
72                       float mag_total,
73                       float lfe_im,
74                       float lfe_re,
75                       float x, float y,
76                       int n);
77     void (*upmix_3_0)(AVFilterContext *ctx,
78                       float l_phase,
79                       float r_phase,
80                       float c_mag,
81                       float c_phase,
82                       float mag_total,
83                       float x, float y,
84                       int n);
85     void (*upmix_5_1)(AVFilterContext *ctx,
86                       float c_re, float c_im,
87                       float lfe_re, float lfe_im,
88                       float mag_totall, float mag_totalr,
89                       float fl_phase, float fr_phase,
90                       float bl_phase, float br_phase,
91                       float sl_phase, float sr_phase,
92                       float xl, float yl,
93                       float xr, float yr,
94                       int n);
95 } AudioSurroundContext;
96
97 static int query_formats(AVFilterContext *ctx)
98 {
99     AudioSurroundContext *s = ctx->priv;
100     AVFilterFormats *formats = NULL;
101     AVFilterChannelLayouts *layouts = NULL;
102     int ret;
103
104     ret = ff_add_format(&formats, AV_SAMPLE_FMT_FLTP);
105     if (ret)
106         return ret;
107     ret = ff_set_common_formats(ctx, formats);
108     if (ret)
109         return ret;
110
111     layouts = NULL;
112     ret = ff_add_channel_layout(&layouts, s->out_channel_layout);
113     if (ret)
114         return ret;
115
116     ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts);
117     if (ret)
118         return ret;
119
120     layouts = NULL;
121     ret = ff_add_channel_layout(&layouts, s->in_channel_layout);
122     if (ret)
123         return ret;
124
125     ret = ff_channel_layouts_ref(layouts, &ctx->inputs[0]->out_channel_layouts);
126     if (ret)
127         return ret;
128
129     formats = ff_all_samplerates();
130     if (!formats)
131         return AVERROR(ENOMEM);
132     return ff_set_common_samplerates(ctx, formats);
133 }
134
135 static int config_input(AVFilterLink *inlink)
136 {
137     AVFilterContext *ctx = inlink->dst;
138     AudioSurroundContext *s = ctx->priv;
139     int ch;
140
141     s->rdft = av_calloc(inlink->channels, sizeof(*s->rdft));
142     if (!s->rdft)
143         return AVERROR(ENOMEM);
144
145     for (ch = 0; ch < inlink->channels; ch++) {
146         s->rdft[ch]  = av_rdft_init(ff_log2(s->buf_size), DFT_R2C);
147         if (!s->rdft[ch])
148             return AVERROR(ENOMEM);
149     }
150     s->nb_in_channels = inlink->channels;
151
152     s->input = ff_get_audio_buffer(inlink, s->buf_size * 2);
153     if (!s->input)
154         return AVERROR(ENOMEM);
155
156     s->fifo = av_audio_fifo_alloc(inlink->format, inlink->channels, s->buf_size);
157     if (!s->fifo)
158         return AVERROR(ENOMEM);
159
160     s->lowcut = 1.f * s->lowcutf / (inlink->sample_rate * 0.5) * (s->buf_size / 2);
161     s->highcut = 1.f * s->highcutf / (inlink->sample_rate * 0.5) * (s->buf_size / 2);
162
163     return 0;
164 }
165
166 static int config_output(AVFilterLink *outlink)
167 {
168     AVFilterContext *ctx = outlink->src;
169     AudioSurroundContext *s = ctx->priv;
170     int ch;
171
172     s->irdft = av_calloc(outlink->channels, sizeof(*s->irdft));
173     if (!s->irdft)
174         return AVERROR(ENOMEM);
175
176     for (ch = 0; ch < outlink->channels; ch++) {
177         s->irdft[ch] = av_rdft_init(ff_log2(s->buf_size), IDFT_C2R);
178         if (!s->irdft[ch])
179             return AVERROR(ENOMEM);
180     }
181     s->nb_out_channels = outlink->channels;
182
183     s->output = ff_get_audio_buffer(outlink, s->buf_size * 2);
184     s->overlap_buffer = ff_get_audio_buffer(outlink, s->buf_size * 2);
185     if (!s->overlap_buffer || !s->output)
186         return AVERROR(ENOMEM);
187
188     return 0;
189 }
190
191 static void stereo_position(float a, float p, float *x, float *y)
192 {
193       *x = av_clipf(a+FFMAX(0, sinf(p-M_PI_2))*FFDIFFSIGN(a,0), -1, 1);
194       *y = av_clipf(cosf(a*M_PI_2+M_PI)*cosf(M_PI_2-p/M_PI)*M_LN10+1, -1, 1);
195 }
196
197 static inline void get_lfe(int output_lfe, int n, float lowcut, float highcut,
198                            float *lfe_mag, float *mag_total)
199 {
200     if (output_lfe && n < highcut) {
201         *lfe_mag    = n < lowcut ? 1.f : .5f*(1.f+cosf(M_PI*(lowcut-n)/(lowcut-highcut)));
202         *lfe_mag   *= *mag_total;
203         *mag_total -= *lfe_mag;
204     } else {
205         *lfe_mag = 0.f;
206     }
207 }
208
209 static void upmix_1_0(AVFilterContext *ctx,
210                       float l_phase,
211                       float r_phase,
212                       float c_phase,
213                       float mag_total,
214                       float x, float y,
215                       int n)
216 {
217     AudioSurroundContext *s = ctx->priv;
218     float mag, *dst;
219
220     dst = (float *)s->output->extended_data[0];
221
222     mag = sqrtf(1.f - fabsf(x)) * ((y + 1.f) * .5f) * mag_total;
223
224     dst[2 * n    ] = mag * cosf(c_phase);
225     dst[2 * n + 1] = mag * sinf(c_phase);
226 }
227
228 static void upmix_stereo(AVFilterContext *ctx,
229                          float l_phase,
230                          float r_phase,
231                          float c_phase,
232                          float mag_total,
233                          float x, float y,
234                          int n)
235 {
236     AudioSurroundContext *s = ctx->priv;
237     float l_mag, r_mag, *dstl, *dstr;
238
239     dstl = (float *)s->output->extended_data[0];
240     dstr = (float *)s->output->extended_data[1];
241
242     l_mag = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
243     r_mag = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
244
245     dstl[2 * n    ] = l_mag * cosf(l_phase);
246     dstl[2 * n + 1] = l_mag * sinf(l_phase);
247
248     dstr[2 * n    ] = r_mag * cosf(r_phase);
249     dstr[2 * n + 1] = r_mag * sinf(r_phase);
250 }
251
252 static void upmix_2_1(AVFilterContext *ctx,
253                       float l_phase,
254                       float r_phase,
255                       float c_phase,
256                       float mag_total,
257                       float x, float y,
258                       int n)
259 {
260     AudioSurroundContext *s = ctx->priv;
261     float lfe_mag, l_mag, r_mag, *dstl, *dstr, *dstlfe;
262
263     dstl = (float *)s->output->extended_data[0];
264     dstr = (float *)s->output->extended_data[1];
265     dstlfe = (float *)s->output->extended_data[2];
266
267     get_lfe(s->output_lfe, n, s->lowcut, s->highcut, &lfe_mag, &mag_total);
268
269     l_mag = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
270     r_mag = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
271
272     dstl[2 * n    ] = l_mag * cosf(l_phase);
273     dstl[2 * n + 1] = l_mag * sinf(l_phase);
274
275     dstr[2 * n    ] = r_mag * cosf(r_phase);
276     dstr[2 * n + 1] = r_mag * sinf(r_phase);
277
278     dstlfe[2 * n    ] = lfe_mag * cosf(c_phase);
279     dstlfe[2 * n + 1] = lfe_mag * sinf(c_phase);
280 }
281
282 static void upmix_3_0(AVFilterContext *ctx,
283                       float l_phase,
284                       float r_phase,
285                       float c_phase,
286                       float mag_total,
287                       float x, float y,
288                       int n)
289 {
290     AudioSurroundContext *s = ctx->priv;
291     float l_mag, r_mag, c_mag, *dstc, *dstl, *dstr;
292
293     dstl = (float *)s->output->extended_data[0];
294     dstr = (float *)s->output->extended_data[1];
295     dstc = (float *)s->output->extended_data[2];
296
297     c_mag = sqrtf(1.f - fabsf(x))   * ((y + 1.f) * .5f) * mag_total;
298     l_mag = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
299     r_mag = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
300
301     dstl[2 * n    ] = l_mag * cosf(l_phase);
302     dstl[2 * n + 1] = l_mag * sinf(l_phase);
303
304     dstr[2 * n    ] = r_mag * cosf(r_phase);
305     dstr[2 * n + 1] = r_mag * sinf(r_phase);
306
307     dstc[2 * n    ] = c_mag * cosf(c_phase);
308     dstc[2 * n + 1] = c_mag * sinf(c_phase);
309 }
310
311 static void upmix_3_1(AVFilterContext *ctx,
312                       float l_phase,
313                       float r_phase,
314                       float c_phase,
315                       float mag_total,
316                       float x, float y,
317                       int n)
318 {
319     AudioSurroundContext *s = ctx->priv;
320     float lfe_mag, l_mag, r_mag, c_mag, *dstc, *dstl, *dstr, *dstlfe;
321
322     dstl = (float *)s->output->extended_data[0];
323     dstr = (float *)s->output->extended_data[1];
324     dstc = (float *)s->output->extended_data[2];
325     dstlfe = (float *)s->output->extended_data[3];
326
327     get_lfe(s->output_lfe, n, s->lowcut, s->highcut, &lfe_mag, &mag_total);
328
329     c_mag = sqrtf(1.f - fabsf(x))   * ((y + 1.f) * .5f) * mag_total;
330     l_mag = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
331     r_mag = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
332
333     dstl[2 * n    ] = l_mag * cosf(l_phase);
334     dstl[2 * n + 1] = l_mag * sinf(l_phase);
335
336     dstr[2 * n    ] = r_mag * cosf(r_phase);
337     dstr[2 * n + 1] = r_mag * sinf(r_phase);
338
339     dstc[2 * n    ] = c_mag * cosf(c_phase);
340     dstc[2 * n + 1] = c_mag * sinf(c_phase);
341
342     dstlfe[2 * n    ] = lfe_mag * cosf(c_phase);
343     dstlfe[2 * n + 1] = lfe_mag * sinf(c_phase);
344 }
345
346 static void upmix_3_1_surround(AVFilterContext *ctx,
347                                float l_phase,
348                                float r_phase,
349                                float c_phase,
350                                float c_mag,
351                                float mag_total,
352                                float x, float y,
353                                int n)
354 {
355     AudioSurroundContext *s = ctx->priv;
356     float lfe_mag, l_mag, r_mag, *dstc, *dstl, *dstr, *dstlfe;
357
358     dstl = (float *)s->output->extended_data[0];
359     dstr = (float *)s->output->extended_data[1];
360     dstc = (float *)s->output->extended_data[2];
361     dstlfe = (float *)s->output->extended_data[3];
362
363     get_lfe(s->output_lfe, n, s->lowcut, s->highcut, &lfe_mag, &c_mag);
364
365     l_mag = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
366     r_mag = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
367
368     dstl[2 * n    ] = l_mag * cosf(l_phase);
369     dstl[2 * n + 1] = l_mag * sinf(l_phase);
370
371     dstr[2 * n    ] = r_mag * cosf(r_phase);
372     dstr[2 * n + 1] = r_mag * sinf(r_phase);
373
374     dstc[2 * n    ] = c_mag * cosf(c_phase);
375     dstc[2 * n + 1] = c_mag * sinf(c_phase);
376
377     dstlfe[2 * n    ] = lfe_mag * cosf(c_phase);
378     dstlfe[2 * n + 1] = lfe_mag * sinf(c_phase);
379 }
380
381 static void upmix_4_0(AVFilterContext *ctx,
382                       float l_phase,
383                       float r_phase,
384                       float c_phase,
385                       float mag_total,
386                       float x, float y,
387                       int n)
388 {
389     float b_mag, l_mag, r_mag, c_mag, *dstc, *dstl, *dstr, *dstb;
390     AudioSurroundContext *s = ctx->priv;
391
392     dstl = (float *)s->output->extended_data[0];
393     dstr = (float *)s->output->extended_data[1];
394     dstc = (float *)s->output->extended_data[2];
395     dstb = (float *)s->output->extended_data[3];
396
397     c_mag = sqrtf(1.f - fabsf(x))   * ((y + 1.f) * .5f) * mag_total;
398     b_mag = sqrtf(1.f - fabsf(x))   * ((1.f - y) * .5f) * mag_total;
399     l_mag = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
400     r_mag = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
401
402     dstl[2 * n    ] = l_mag * cosf(l_phase);
403     dstl[2 * n + 1] = l_mag * sinf(l_phase);
404
405     dstr[2 * n    ] = r_mag * cosf(r_phase);
406     dstr[2 * n + 1] = r_mag * sinf(r_phase);
407
408     dstc[2 * n    ] = c_mag * cosf(c_phase);
409     dstc[2 * n + 1] = c_mag * sinf(c_phase);
410
411     dstb[2 * n    ] = b_mag * cosf(c_phase);
412     dstb[2 * n + 1] = b_mag * sinf(c_phase);
413 }
414
415 static void upmix_4_1(AVFilterContext *ctx,
416                       float l_phase,
417                       float r_phase,
418                       float c_phase,
419                       float mag_total,
420                       float x, float y,
421                       int n)
422 {
423     float lfe_mag, b_mag, l_mag, r_mag, c_mag, *dstc, *dstl, *dstr, *dstb, *dstlfe;
424     AudioSurroundContext *s = ctx->priv;
425
426     dstl = (float *)s->output->extended_data[0];
427     dstr = (float *)s->output->extended_data[1];
428     dstc = (float *)s->output->extended_data[2];
429     dstlfe = (float *)s->output->extended_data[3];
430     dstb = (float *)s->output->extended_data[4];
431
432     get_lfe(s->output_lfe, n, s->lowcut, s->highcut, &lfe_mag, &mag_total);
433
434     dstlfe[2 * n    ] = lfe_mag * cosf(c_phase);
435     dstlfe[2 * n + 1] = lfe_mag * sinf(c_phase);
436
437     c_mag = sqrtf(1.f - fabsf(x))   * ((y + 1.f) * .5f) * mag_total;
438     b_mag = sqrtf(1.f - fabsf(x))   * ((1.f - y) * .5f) * mag_total;
439     l_mag = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
440     r_mag = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
441
442     dstl[2 * n    ] = l_mag * cosf(l_phase);
443     dstl[2 * n + 1] = l_mag * sinf(l_phase);
444
445     dstr[2 * n    ] = r_mag * cosf(r_phase);
446     dstr[2 * n + 1] = r_mag * sinf(r_phase);
447
448     dstc[2 * n    ] = c_mag * cosf(c_phase);
449     dstc[2 * n + 1] = c_mag * sinf(c_phase);
450
451     dstb[2 * n    ] = b_mag * cosf(c_phase);
452     dstb[2 * n + 1] = b_mag * sinf(c_phase);
453 }
454
455 static void upmix_5_0_back(AVFilterContext *ctx,
456                            float l_phase,
457                            float r_phase,
458                            float c_phase,
459                            float mag_total,
460                            float x, float y,
461                            int n)
462 {
463     float l_mag, r_mag, ls_mag, rs_mag, c_mag, *dstc, *dstl, *dstr, *dstls, *dstrs;
464     AudioSurroundContext *s = ctx->priv;
465
466     dstl  = (float *)s->output->extended_data[0];
467     dstr  = (float *)s->output->extended_data[1];
468     dstc  = (float *)s->output->extended_data[2];
469     dstls = (float *)s->output->extended_data[3];
470     dstrs = (float *)s->output->extended_data[4];
471
472     c_mag  = sqrtf(1.f - fabsf(x))   * ((y + 1.f) * .5f) * mag_total;
473     l_mag  = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
474     r_mag  = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
475     ls_mag = sqrtf(.5f * ( x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;
476     rs_mag = sqrtf(.5f * (-x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;
477
478     dstl[2 * n    ] = l_mag * cosf(l_phase);
479     dstl[2 * n + 1] = l_mag * sinf(l_phase);
480
481     dstr[2 * n    ] = r_mag * cosf(r_phase);
482     dstr[2 * n + 1] = r_mag * sinf(r_phase);
483
484     dstc[2 * n    ] = c_mag * cosf(c_phase);
485     dstc[2 * n + 1] = c_mag * sinf(c_phase);
486
487     dstls[2 * n    ] = ls_mag * cosf(l_phase);
488     dstls[2 * n + 1] = ls_mag * sinf(l_phase);
489
490     dstrs[2 * n    ] = rs_mag * cosf(r_phase);
491     dstrs[2 * n + 1] = rs_mag * sinf(r_phase);
492 }
493
494 static void upmix_5_1_back(AVFilterContext *ctx,
495                            float l_phase,
496                            float r_phase,
497                            float c_phase,
498                            float mag_total,
499                            float x, float y,
500                            int n)
501 {
502     float lfe_mag, l_mag, r_mag, ls_mag, rs_mag, c_mag, *dstc, *dstl, *dstr, *dstls, *dstrs, *dstlfe;
503     AudioSurroundContext *s = ctx->priv;
504
505     dstl  = (float *)s->output->extended_data[0];
506     dstr  = (float *)s->output->extended_data[1];
507     dstc  = (float *)s->output->extended_data[2];
508     dstlfe = (float *)s->output->extended_data[3];
509     dstls = (float *)s->output->extended_data[4];
510     dstrs = (float *)s->output->extended_data[5];
511
512     get_lfe(s->output_lfe, n, s->lowcut, s->highcut, &lfe_mag, &mag_total);
513
514     c_mag  = sqrtf(1.f - fabsf(x))   * ((y + 1.f) * .5f) * mag_total;
515     l_mag  = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
516     r_mag  = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
517     ls_mag = sqrtf(.5f * ( x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;
518     rs_mag = sqrtf(.5f * (-x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;
519
520     dstl[2 * n    ] = l_mag * cosf(l_phase);
521     dstl[2 * n + 1] = l_mag * sinf(l_phase);
522
523     dstr[2 * n    ] = r_mag * cosf(r_phase);
524     dstr[2 * n + 1] = r_mag * sinf(r_phase);
525
526     dstc[2 * n    ] = c_mag * cosf(c_phase);
527     dstc[2 * n + 1] = c_mag * sinf(c_phase);
528
529     dstlfe[2 * n    ] = lfe_mag * cosf(c_phase);
530     dstlfe[2 * n + 1] = lfe_mag * sinf(c_phase);
531
532     dstls[2 * n    ] = ls_mag * cosf(l_phase);
533     dstls[2 * n + 1] = ls_mag * sinf(l_phase);
534
535     dstrs[2 * n    ] = rs_mag * cosf(r_phase);
536     dstrs[2 * n + 1] = rs_mag * sinf(r_phase);
537 }
538
539 static void upmix_5_1_back_surround(AVFilterContext *ctx,
540                                     float l_phase,
541                                     float r_phase,
542                                     float c_phase,
543                                     float c_mag,
544                                     float mag_total,
545                                     float x, float y,
546                                     int n)
547 {
548     AudioSurroundContext *s = ctx->priv;
549     float lfe_mag, l_mag, r_mag, *dstc, *dstl, *dstr, *dstlfe;
550     float ls_mag, rs_mag, *dstls, *dstrs;
551
552     dstl = (float *)s->output->extended_data[0];
553     dstr = (float *)s->output->extended_data[1];
554     dstc = (float *)s->output->extended_data[2];
555     dstlfe = (float *)s->output->extended_data[3];
556     dstls = (float *)s->output->extended_data[4];
557     dstrs = (float *)s->output->extended_data[5];
558
559     get_lfe(s->output_lfe, n, s->lowcut, s->highcut, &lfe_mag, &c_mag);
560
561     l_mag = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
562     r_mag = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
563     ls_mag = sqrtf(.5f * ( x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;
564     rs_mag = sqrtf(.5f * (-x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;
565
566     dstl[2 * n    ] = l_mag * cosf(l_phase);
567     dstl[2 * n + 1] = l_mag * sinf(l_phase);
568
569     dstr[2 * n    ] = r_mag * cosf(r_phase);
570     dstr[2 * n + 1] = r_mag * sinf(r_phase);
571
572     dstc[2 * n    ] = c_mag * cosf(c_phase);
573     dstc[2 * n + 1] = c_mag * sinf(c_phase);
574
575     dstlfe[2 * n    ] = lfe_mag * cosf(c_phase);
576     dstlfe[2 * n + 1] = lfe_mag * sinf(c_phase);
577
578     dstls[2 * n    ] = ls_mag * cosf(l_phase);
579     dstls[2 * n + 1] = ls_mag * sinf(l_phase);
580
581     dstrs[2 * n    ] = rs_mag * cosf(r_phase);
582     dstrs[2 * n + 1] = rs_mag * sinf(r_phase);
583 }
584
585 static void upmix_5_1_back_2_1(AVFilterContext *ctx,
586                                float l_phase,
587                                float r_phase,
588                                float c_phase,
589                                float mag_total,
590                                float lfe_re,
591                                float lfe_im,
592                                float x, float y,
593                                int n)
594 {
595     AudioSurroundContext *s = ctx->priv;
596     float c_mag, l_mag, r_mag, *dstc, *dstl, *dstr, *dstlfe;
597     float ls_mag, rs_mag, *dstls, *dstrs;
598
599     dstl = (float *)s->output->extended_data[0];
600     dstr = (float *)s->output->extended_data[1];
601     dstc = (float *)s->output->extended_data[2];
602     dstlfe = (float *)s->output->extended_data[3];
603     dstls = (float *)s->output->extended_data[4];
604     dstrs = (float *)s->output->extended_data[5];
605
606     c_mag  = sqrtf(1.f - fabsf(x))   * ((y + 1.f) * .5f) * mag_total;
607     l_mag  = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
608     r_mag  = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
609     ls_mag = sqrtf(.5f * ( x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;
610     rs_mag = sqrtf(.5f * (-x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;
611
612     dstl[2 * n    ] = l_mag * cosf(l_phase);
613     dstl[2 * n + 1] = l_mag * sinf(l_phase);
614
615     dstr[2 * n    ] = r_mag * cosf(r_phase);
616     dstr[2 * n + 1] = r_mag * sinf(r_phase);
617
618     dstc[2 * n    ] = c_mag * cosf(c_phase);
619     dstc[2 * n + 1] = c_mag * sinf(c_phase);
620
621     dstlfe[2 * n    ] = lfe_re;
622     dstlfe[2 * n + 1] = lfe_im;
623
624     dstls[2 * n    ] = ls_mag * cosf(l_phase);
625     dstls[2 * n + 1] = ls_mag * sinf(l_phase);
626
627     dstrs[2 * n    ] = rs_mag * cosf(r_phase);
628     dstrs[2 * n + 1] = rs_mag * sinf(r_phase);
629 }
630
631 static void upmix_7_0(AVFilterContext *ctx,
632                       float l_phase,
633                       float r_phase,
634                       float c_phase,
635                       float mag_total,
636                       float x, float y,
637                       int n)
638 {
639     float l_mag, r_mag, ls_mag, rs_mag, c_mag, lb_mag, rb_mag;
640     float *dstc, *dstl, *dstr, *dstls, *dstrs, *dstlb, *dstrb;
641     AudioSurroundContext *s = ctx->priv;
642
643     dstl  = (float *)s->output->extended_data[0];
644     dstr  = (float *)s->output->extended_data[1];
645     dstc  = (float *)s->output->extended_data[2];
646     dstlb = (float *)s->output->extended_data[3];
647     dstrb = (float *)s->output->extended_data[4];
648     dstls = (float *)s->output->extended_data[5];
649     dstrs = (float *)s->output->extended_data[6];
650
651     c_mag  = sqrtf(1.f - fabsf(x))   * ((y + 1.f) * .5f) * mag_total;
652     l_mag  = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
653     r_mag  = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
654     lb_mag = sqrtf(.5f * ( x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;
655     rb_mag = sqrtf(.5f * (-x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;
656     ls_mag = sqrtf(.5f * ( x + 1.f)) * (1.f - fabsf(y)) * mag_total;
657     rs_mag = sqrtf(.5f * (-x + 1.f)) * (1.f - fabsf(y)) * mag_total;
658
659     dstl[2 * n    ] = l_mag * cosf(l_phase);
660     dstl[2 * n + 1] = l_mag * sinf(l_phase);
661
662     dstr[2 * n    ] = r_mag * cosf(r_phase);
663     dstr[2 * n + 1] = r_mag * sinf(r_phase);
664
665     dstc[2 * n    ] = c_mag * cosf(c_phase);
666     dstc[2 * n + 1] = c_mag * sinf(c_phase);
667
668     dstlb[2 * n    ] = lb_mag * cosf(l_phase);
669     dstlb[2 * n + 1] = lb_mag * sinf(l_phase);
670
671     dstrb[2 * n    ] = rb_mag * cosf(r_phase);
672     dstrb[2 * n + 1] = rb_mag * sinf(r_phase);
673
674     dstls[2 * n    ] = ls_mag * cosf(l_phase);
675     dstls[2 * n + 1] = ls_mag * sinf(l_phase);
676
677     dstrs[2 * n    ] = rs_mag * cosf(r_phase);
678     dstrs[2 * n + 1] = rs_mag * sinf(r_phase);
679 }
680
681 static void upmix_7_1(AVFilterContext *ctx,
682                       float l_phase,
683                       float r_phase,
684                       float c_phase,
685                       float mag_total,
686                       float x, float y,
687                       int n)
688 {
689     float lfe_mag, l_mag, r_mag, ls_mag, rs_mag, c_mag, lb_mag, rb_mag;
690     float *dstc, *dstl, *dstr, *dstls, *dstrs, *dstlb, *dstrb, *dstlfe;
691     AudioSurroundContext *s = ctx->priv;
692
693     dstl  = (float *)s->output->extended_data[0];
694     dstr  = (float *)s->output->extended_data[1];
695     dstc  = (float *)s->output->extended_data[2];
696     dstlfe = (float *)s->output->extended_data[3];
697     dstlb = (float *)s->output->extended_data[4];
698     dstrb = (float *)s->output->extended_data[5];
699     dstls = (float *)s->output->extended_data[6];
700     dstrs = (float *)s->output->extended_data[7];
701
702     get_lfe(s->output_lfe, n, s->lowcut, s->highcut, &lfe_mag, &mag_total);
703
704     c_mag  = sqrtf(1.f - fabsf(x))   * ((y + 1.f) * .5f) * mag_total;
705     l_mag  = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
706     r_mag  = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
707     lb_mag = sqrtf(.5f * ( x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;
708     rb_mag = sqrtf(.5f * (-x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;
709     ls_mag = sqrtf(.5f * ( x + 1.f)) * (1.f - fabsf(y)) * mag_total;
710     rs_mag = sqrtf(.5f * (-x + 1.f)) * (1.f - fabsf(y)) * mag_total;
711
712     dstl[2 * n    ] = l_mag * cosf(l_phase);
713     dstl[2 * n + 1] = l_mag * sinf(l_phase);
714
715     dstr[2 * n    ] = r_mag * cosf(r_phase);
716     dstr[2 * n + 1] = r_mag * sinf(r_phase);
717
718     dstc[2 * n    ] = c_mag * cosf(c_phase);
719     dstc[2 * n + 1] = c_mag * sinf(c_phase);
720
721     dstlfe[2 * n    ] = lfe_mag * cosf(c_phase);
722     dstlfe[2 * n + 1] = lfe_mag * sinf(c_phase);
723
724     dstlb[2 * n    ] = lb_mag * cosf(l_phase);
725     dstlb[2 * n + 1] = lb_mag * sinf(l_phase);
726
727     dstrb[2 * n    ] = rb_mag * cosf(r_phase);
728     dstrb[2 * n + 1] = rb_mag * sinf(r_phase);
729
730     dstls[2 * n    ] = ls_mag * cosf(l_phase);
731     dstls[2 * n + 1] = ls_mag * sinf(l_phase);
732
733     dstrs[2 * n    ] = rs_mag * cosf(r_phase);
734     dstrs[2 * n + 1] = rs_mag * sinf(r_phase);
735 }
736
737 static void upmix_7_1_5_1(AVFilterContext *ctx,
738                           float c_re, float c_im,
739                           float lfe_re, float lfe_im,
740                           float mag_totall, float mag_totalr,
741                           float fl_phase, float fr_phase,
742                           float bl_phase, float br_phase,
743                           float sl_phase, float sr_phase,
744                           float xl, float yl,
745                           float xr, float yr,
746                           int n)
747 {
748     float fl_mag, fr_mag, ls_mag, rs_mag, lb_mag, rb_mag;
749     float *dstc, *dstl, *dstr, *dstls, *dstrs, *dstlb, *dstrb, *dstlfe;
750     AudioSurroundContext *s = ctx->priv;
751
752     dstl  = (float *)s->output->extended_data[0];
753     dstr  = (float *)s->output->extended_data[1];
754     dstc  = (float *)s->output->extended_data[2];
755     dstlfe = (float *)s->output->extended_data[3];
756     dstlb = (float *)s->output->extended_data[4];
757     dstrb = (float *)s->output->extended_data[5];
758     dstls = (float *)s->output->extended_data[6];
759     dstrs = (float *)s->output->extended_data[7];
760
761     fl_mag = sqrtf(.5f * (xl + 1.f)) * ((yl + 1.f) * .5f) * mag_totall;
762     fr_mag = sqrtf(.5f * (xr + 1.f)) * ((yr + 1.f) * .5f) * mag_totalr;
763     lb_mag = sqrtf(.5f * (-xl + 1.f)) * ((yl + 1.f) * .5f) * mag_totall;
764     rb_mag = sqrtf(.5f * (-xr + 1.f)) * ((yr + 1.f) * .5f) * mag_totalr;
765     ls_mag = sqrtf(1.f - fabsf(xl)) * ((yl + 1.f) * .5f) * mag_totall;
766     rs_mag = sqrtf(1.f - fabsf(xr)) * ((yr + 1.f) * .5f) * mag_totalr;
767
768     dstl[2 * n    ] = fl_mag * cosf(fl_phase);
769     dstl[2 * n + 1] = fl_mag * sinf(fl_phase);
770
771     dstr[2 * n    ] = fr_mag * cosf(fr_phase);
772     dstr[2 * n + 1] = fr_mag * sinf(fr_phase);
773
774     dstc[2 * n    ] = c_re;
775     dstc[2 * n + 1] = c_im;
776
777     dstlfe[2 * n    ] = lfe_re;
778     dstlfe[2 * n + 1] = lfe_im;
779
780     dstlb[2 * n    ] = lb_mag * cosf(bl_phase);
781     dstlb[2 * n + 1] = lb_mag * sinf(bl_phase);
782
783     dstrb[2 * n    ] = rb_mag * cosf(br_phase);
784     dstrb[2 * n + 1] = rb_mag * sinf(br_phase);
785
786     dstls[2 * n    ] = ls_mag * cosf(sl_phase);
787     dstls[2 * n + 1] = ls_mag * sinf(sl_phase);
788
789     dstrs[2 * n    ] = rs_mag * cosf(sr_phase);
790     dstrs[2 * n + 1] = rs_mag * sinf(sr_phase);
791 }
792
793 static void filter_stereo(AVFilterContext *ctx)
794 {
795     AudioSurroundContext *s = ctx->priv;
796     float *srcl, *srcr;
797     int n;
798
799     srcl = (float *)s->input->extended_data[0];
800     srcr = (float *)s->input->extended_data[1];
801
802     for (n = 0; n < s->buf_size; n++) {
803         float l_re = srcl[2 * n], r_re = srcr[2 * n];
804         float l_im = srcl[2 * n + 1], r_im = srcr[2 * n + 1];
805         float c_phase = atan2f(l_im + r_im, l_re + r_re);
806         float l_mag = hypotf(l_re, l_im);
807         float r_mag = hypotf(r_re, r_im);
808         float l_phase = atan2f(l_im, l_re);
809         float r_phase = atan2f(r_im, r_re);
810         float phase_dif = fabsf(l_phase - r_phase);
811         float mag_dif = (l_mag - r_mag) / (l_mag + r_mag);
812         float mag_total = hypotf(l_mag, r_mag);
813         float x, y;
814
815         if (phase_dif > M_PI)
816             phase_dif = 2 * M_PI - phase_dif;
817
818         stereo_position(mag_dif, phase_dif, &x, &y);
819
820         s->upmix_stereo(ctx, l_phase, r_phase, c_phase, mag_total, x, y, n);
821     }
822 }
823
824 static void filter_surround(AVFilterContext *ctx)
825 {
826     AudioSurroundContext *s = ctx->priv;
827     float *srcl, *srcr, *srcc;
828     int n;
829
830     srcl = (float *)s->input->extended_data[0];
831     srcr = (float *)s->input->extended_data[1];
832     srcc = (float *)s->input->extended_data[2];
833
834     for (n = 0; n < s->buf_size; n++) {
835         float l_re = srcl[2 * n], r_re = srcr[2 * n];
836         float l_im = srcl[2 * n + 1], r_im = srcr[2 * n + 1];
837         float c_re = srcc[2 * n], c_im = srcc[2 * n + 1];
838         float c_mag = hypotf(c_re, c_im);
839         float c_phase = atan2f(c_im, c_re);
840         float l_mag = hypotf(l_re, l_im);
841         float r_mag = hypotf(r_re, r_im);
842         float l_phase = atan2f(l_im, l_re);
843         float r_phase = atan2f(r_im, r_re);
844         float phase_dif = fabsf(l_phase - r_phase);
845         float mag_dif = (l_mag - r_mag) / (l_mag + r_mag);
846         float mag_total = hypotf(l_mag, r_mag);
847         float x, y;
848
849         if (phase_dif > M_PI)
850             phase_dif = 2 * M_PI - phase_dif;
851
852         stereo_position(mag_dif, phase_dif, &x, &y);
853
854         s->upmix_3_0(ctx, l_phase, r_phase, c_phase, c_mag, mag_total, x, y, n);
855     }
856 }
857
858 static void filter_2_1(AVFilterContext *ctx)
859 {
860     AudioSurroundContext *s = ctx->priv;
861     float *srcl, *srcr, *srclfe;
862     int n;
863
864     srcl = (float *)s->input->extended_data[0];
865     srcr = (float *)s->input->extended_data[1];
866     srclfe = (float *)s->input->extended_data[2];
867
868     for (n = 0; n < s->buf_size; n++) {
869         float l_re = srcl[2 * n], r_re = srcr[2 * n];
870         float l_im = srcl[2 * n + 1], r_im = srcr[2 * n + 1];
871         float lfe_re = srclfe[2 * n], lfe_im = srclfe[2 * n + 1];
872         float c_phase = atan2f(l_im + r_im, l_re + r_re);
873         float l_mag = hypotf(l_re, l_im);
874         float r_mag = hypotf(r_re, r_im);
875         float l_phase = atan2f(l_im, l_re);
876         float r_phase = atan2f(r_im, r_re);
877         float phase_dif = fabsf(l_phase - r_phase);
878         float mag_dif = (l_mag - r_mag) / (l_mag + r_mag);
879         float mag_total = hypotf(l_mag, r_mag);
880         float x, y;
881
882         if (phase_dif > M_PI)
883             phase_dif = 2 * M_PI - phase_dif;
884
885         stereo_position(mag_dif, phase_dif, &x, &y);
886
887         s->upmix_2_1(ctx, l_phase, r_phase, c_phase, mag_total, lfe_re, lfe_im, x, y, n);
888     }
889 }
890
891 static void filter_5_1_back(AVFilterContext *ctx)
892 {
893     AudioSurroundContext *s = ctx->priv;
894     float *srcl, *srcr, *srcc, *srclfe, *srcbl, *srcbr;
895     int n;
896
897     srcl = (float *)s->input->extended_data[0];
898     srcr = (float *)s->input->extended_data[1];
899     srcc = (float *)s->input->extended_data[2];
900     srclfe = (float *)s->input->extended_data[3];
901     srcbl = (float *)s->input->extended_data[4];
902     srcbr = (float *)s->input->extended_data[5];
903
904     for (n = 0; n < s->buf_size; n++) {
905         float fl_re = srcl[2 * n], fr_re = srcr[2 * n];
906         float fl_im = srcl[2 * n + 1], fr_im = srcr[2 * n + 1];
907         float c_re = srcc[2 * n], c_im = srcc[2 * n + 1];
908         float lfe_re = srclfe[2 * n], lfe_im = srclfe[2 * n + 1];
909         float bl_re = srcbl[2 * n], bl_im = srcbl[2 * n + 1];
910         float br_re = srcbr[2 * n], br_im = srcbr[2 * n + 1];
911         float fl_mag = hypotf(fl_re, fl_im);
912         float fr_mag = hypotf(fr_re, fr_im);
913         float fl_phase = atan2f(fl_im, fl_re);
914         float fr_phase = atan2f(fr_im, fr_re);
915         float bl_mag = hypotf(bl_re, bl_im);
916         float br_mag = hypotf(br_re, br_im);
917         float bl_phase = atan2f(bl_im, bl_re);
918         float br_phase = atan2f(br_im, br_re);
919         float phase_difl = fabsf(fl_phase - bl_phase);
920         float phase_difr = fabsf(fr_phase - br_phase);
921         float mag_difl = (fl_mag - bl_mag) / (fl_mag + bl_mag);
922         float mag_difr = (fr_mag - br_mag) / (fr_mag + br_mag);
923         float mag_totall = hypotf(fl_mag, bl_mag);
924         float mag_totalr = hypotf(fr_mag, br_mag);
925         float sl_phase = atan2f(fl_im + bl_im, fl_re + bl_re);
926         float sr_phase = atan2f(fr_im + br_im, fr_re + br_re);
927         float xl, yl;
928         float xr, yr;
929
930         if (phase_difl > M_PI)
931             phase_difl = 2 * M_PI - phase_difl;
932
933         if (phase_difr > M_PI)
934             phase_difr = 2 * M_PI - phase_difr;
935
936         stereo_position(mag_difl, phase_difl, &xl, &yl);
937         stereo_position(mag_difr, phase_difr, &xr, &yr);
938
939         s->upmix_5_1(ctx, c_re, c_im, lfe_re, lfe_im,
940                      mag_totall, mag_totalr,
941                      fl_phase, fr_phase,
942                      bl_phase, br_phase,
943                      sl_phase, sr_phase,
944                      xl, yl, xr, yr, n);
945     }
946 }
947
948 static int init(AVFilterContext *ctx)
949 {
950     AudioSurroundContext *s = ctx->priv;
951     float overlap;
952     int i;
953
954     if (!(s->out_channel_layout = av_get_channel_layout(s->out_channel_layout_str))) {
955         av_log(ctx, AV_LOG_ERROR, "Error parsing output channel layout '%s'.\n",
956                s->out_channel_layout_str);
957         return AVERROR(EINVAL);
958     }
959
960     if (!(s->in_channel_layout = av_get_channel_layout(s->in_channel_layout_str))) {
961         av_log(ctx, AV_LOG_ERROR, "Error parsing input channel layout '%s'.\n",
962                s->in_channel_layout_str);
963         return AVERROR(EINVAL);
964     }
965
966     if (s->lowcutf >= s->highcutf) {
967         av_log(ctx, AV_LOG_ERROR, "Low cut-off '%d' should be less than high cut-off '%d'.\n",
968                s->lowcutf, s->highcutf);
969         return AVERROR(EINVAL);
970     }
971
972     switch (s->in_channel_layout) {
973     case AV_CH_LAYOUT_STEREO:
974         s->filter = filter_stereo;
975         switch (s->out_channel_layout) {
976         case AV_CH_LAYOUT_MONO:
977             s->upmix_stereo = upmix_1_0;
978             break;
979         case AV_CH_LAYOUT_STEREO:
980             s->upmix_stereo = upmix_stereo;
981             break;
982         case AV_CH_LAYOUT_2POINT1:
983             s->upmix_stereo = upmix_2_1;
984             break;
985         case AV_CH_LAYOUT_SURROUND:
986             s->upmix_stereo = upmix_3_0;
987             break;
988         case AV_CH_LAYOUT_3POINT1:
989             s->upmix_stereo = upmix_3_1;
990             break;
991         case AV_CH_LAYOUT_4POINT0:
992             s->upmix_stereo = upmix_4_0;
993             break;
994         case AV_CH_LAYOUT_4POINT1:
995             s->upmix_stereo = upmix_4_1;
996             break;
997         case AV_CH_LAYOUT_5POINT0_BACK:
998             s->upmix_stereo = upmix_5_0_back;
999             break;
1000         case AV_CH_LAYOUT_5POINT1_BACK:
1001             s->upmix_stereo = upmix_5_1_back;
1002             break;
1003         case AV_CH_LAYOUT_7POINT0:
1004             s->upmix_stereo = upmix_7_0;
1005             break;
1006         case AV_CH_LAYOUT_7POINT1:
1007             s->upmix_stereo = upmix_7_1;
1008             break;
1009         default:
1010             goto fail;
1011         }
1012         break;
1013     case AV_CH_LAYOUT_2POINT1:
1014         s->filter = filter_2_1;
1015         switch (s->out_channel_layout) {
1016         case AV_CH_LAYOUT_5POINT1_BACK:
1017             s->upmix_2_1 = upmix_5_1_back_2_1;
1018             break;
1019         default:
1020             goto fail;
1021         }
1022         break;
1023     case AV_CH_LAYOUT_SURROUND:
1024         s->filter = filter_surround;
1025         switch (s->out_channel_layout) {
1026         case AV_CH_LAYOUT_3POINT1:
1027             s->upmix_3_0 = upmix_3_1_surround;
1028             break;
1029         case AV_CH_LAYOUT_5POINT1_BACK:
1030             s->upmix_3_0 = upmix_5_1_back_surround;
1031             break;
1032         default:
1033             goto fail;
1034         }
1035         break;
1036     case AV_CH_LAYOUT_5POINT1_BACK:
1037         s->filter = filter_5_1_back;
1038         switch (s->out_channel_layout) {
1039         case AV_CH_LAYOUT_7POINT1:
1040             s->upmix_5_1 = upmix_7_1_5_1;
1041             break;
1042         default:
1043             goto fail;
1044         }
1045         break;
1046     default:
1047 fail:
1048         av_log(ctx, AV_LOG_ERROR, "Unsupported upmix: '%s' -> '%s'.\n",
1049                s->in_channel_layout_str, s->out_channel_layout_str);
1050         return AVERROR(EINVAL);
1051     }
1052
1053     s->buf_size = 4096;
1054     s->pts = AV_NOPTS_VALUE;
1055
1056     s->window_func_lut = av_calloc(s->buf_size, sizeof(*s->window_func_lut));
1057     if (!s->window_func_lut)
1058         return AVERROR(ENOMEM);
1059
1060     for (i = 0; i < s->buf_size; i++)
1061         s->window_func_lut[i] = sqrtf(0.5 * (1 - cosf(2 * M_PI * i / s->buf_size)) / s->buf_size);
1062     overlap = .5;
1063     s->hop_size = s->buf_size * (1. - overlap);
1064
1065     return 0;
1066 }
1067
1068 static int fft_channel(AVFilterContext *ctx, void *arg, int ch, int nb_jobs)
1069 {
1070     AudioSurroundContext *s = ctx->priv;
1071     const float level_in = s->level_in;
1072     float *dst;
1073     int n;
1074
1075     memset(s->input->extended_data[ch] + s->buf_size * sizeof(float), 0, s->buf_size * sizeof(float));
1076
1077     dst = (float *)s->input->extended_data[ch];
1078     for (n = 0; n < s->buf_size; n++) {
1079         dst[n] *= s->window_func_lut[n] * level_in;
1080     }
1081
1082     av_rdft_calc(s->rdft[ch], (float *)s->input->extended_data[ch]);
1083
1084     return 0;
1085 }
1086
1087 static int ifft_channel(AVFilterContext *ctx, void *arg, int ch, int nb_jobs)
1088 {
1089     AudioSurroundContext *s = ctx->priv;
1090     const float level_out = s->level_out;
1091     AVFrame *out = arg;
1092     float *dst, *ptr;
1093     int n;
1094
1095     av_rdft_calc(s->irdft[ch], (float *)s->output->extended_data[ch]);
1096
1097     dst = (float *)s->output->extended_data[ch];
1098     ptr = (float *)s->overlap_buffer->extended_data[ch];
1099
1100     memmove(s->overlap_buffer->extended_data[ch],
1101             s->overlap_buffer->extended_data[ch] + s->hop_size * sizeof(float),
1102             s->buf_size * sizeof(float));
1103     memset(s->overlap_buffer->extended_data[ch] + s->buf_size * sizeof(float),
1104            0, s->hop_size * sizeof(float));
1105
1106     for (n = 0; n < s->buf_size; n++) {
1107         ptr[n] += dst[n] * s->window_func_lut[n] * level_out;
1108     }
1109
1110     ptr = (float *)s->overlap_buffer->extended_data[ch];
1111     dst = (float *)out->extended_data[ch];
1112     memcpy(dst, ptr, s->hop_size * sizeof(float));
1113
1114     return 0;
1115 }
1116
1117 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
1118 {
1119     AVFilterContext *ctx = inlink->dst;
1120     AVFilterLink *outlink = ctx->outputs[0];
1121     AudioSurroundContext *s = ctx->priv;
1122
1123     av_audio_fifo_write(s->fifo, (void **)in->extended_data,
1124                         in->nb_samples);
1125
1126     if (s->pts == AV_NOPTS_VALUE)
1127         s->pts = in->pts;
1128
1129     av_frame_free(&in);
1130
1131     while (av_audio_fifo_size(s->fifo) >= s->buf_size) {
1132         AVFrame *out;
1133         int ret;
1134
1135         ret = av_audio_fifo_peek(s->fifo, (void **)s->input->extended_data, s->buf_size);
1136         if (ret < 0)
1137             return ret;
1138
1139         ctx->internal->execute(ctx, fft_channel, NULL, NULL, inlink->channels);
1140
1141         s->filter(ctx);
1142
1143         out = ff_get_audio_buffer(outlink, s->hop_size);
1144         if (!out)
1145             return AVERROR(ENOMEM);
1146
1147         ctx->internal->execute(ctx, ifft_channel, out, NULL, outlink->channels);
1148
1149         out->pts = s->pts;
1150         if (s->pts != AV_NOPTS_VALUE)
1151             s->pts += av_rescale_q(out->nb_samples, (AVRational){1, outlink->sample_rate}, outlink->time_base);
1152         av_audio_fifo_drain(s->fifo, s->hop_size);
1153         ret = ff_filter_frame(outlink, out);
1154         if (ret < 0)
1155             return ret;
1156     }
1157
1158     return 0;
1159 }
1160
1161 static av_cold void uninit(AVFilterContext *ctx)
1162 {
1163     AudioSurroundContext *s = ctx->priv;
1164     int ch;
1165
1166     av_frame_free(&s->input);
1167     av_frame_free(&s->output);
1168     av_frame_free(&s->overlap_buffer);
1169
1170     for (ch = 0; ch < s->nb_in_channels; ch++) {
1171         av_rdft_end(s->rdft[ch]);
1172     }
1173     for (ch = 0; ch < s->nb_out_channels; ch++) {
1174         av_rdft_end(s->irdft[ch]);
1175     }
1176     av_freep(&s->rdft);
1177     av_freep(&s->irdft);
1178     av_audio_fifo_free(s->fifo);
1179     av_freep(&s->window_func_lut);
1180 }
1181
1182 #define OFFSET(x) offsetof(AudioSurroundContext, x)
1183 #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
1184
1185 static const AVOption surround_options[] = {
1186     { "chl_out",   "set output channel layout", OFFSET(out_channel_layout_str), AV_OPT_TYPE_STRING, {.str="5.1"}, 0,   0, FLAGS },
1187     { "chl_in",    "set input channel layout",  OFFSET(in_channel_layout_str),  AV_OPT_TYPE_STRING, {.str="stereo"},0, 0, FLAGS },
1188     { "level_in",  "set input level",           OFFSET(level_in),               AV_OPT_TYPE_FLOAT,  {.dbl=1},     0,  10, FLAGS },
1189     { "level_out", "set output level",          OFFSET(level_out),              AV_OPT_TYPE_FLOAT,  {.dbl=1},     0,  10, FLAGS },
1190     { "lfe",       "output LFE",                OFFSET(output_lfe),             AV_OPT_TYPE_BOOL,   {.i64=1},     0,   1, FLAGS },
1191     { "lfe_low",   "LFE low cut off",           OFFSET(lowcutf),                AV_OPT_TYPE_INT,    {.i64=128},   0, 256, FLAGS },
1192     { "lfe_high",  "LFE high cut off",          OFFSET(highcutf),               AV_OPT_TYPE_INT,    {.i64=256},   0, 512, FLAGS },
1193     { NULL }
1194 };
1195
1196 AVFILTER_DEFINE_CLASS(surround);
1197
1198 static const AVFilterPad inputs[] = {
1199     {
1200         .name         = "default",
1201         .type         = AVMEDIA_TYPE_AUDIO,
1202         .filter_frame = filter_frame,
1203         .config_props = config_input,
1204     },
1205     { NULL }
1206 };
1207
1208 static const AVFilterPad outputs[] = {
1209     {
1210         .name         = "default",
1211         .type         = AVMEDIA_TYPE_AUDIO,
1212         .config_props = config_output,
1213     },
1214     { NULL }
1215 };
1216
1217 AVFilter ff_af_surround = {
1218     .name           = "surround",
1219     .description    = NULL_IF_CONFIG_SMALL("Apply audio surround upmix filter."),
1220     .query_formats  = query_formats,
1221     .priv_size      = sizeof(AudioSurroundContext),
1222     .priv_class     = &surround_class,
1223     .init           = init,
1224     .uninit         = uninit,
1225     .inputs         = inputs,
1226     .outputs        = outputs,
1227     .flags          = AVFILTER_FLAG_SLICE_THREADS,
1228 };