falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
93629 Commits
32 Branches
755MB
Tree: dafcdeb258
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'dafcdeb258'
${ noResults }
FFmpeg/libavfilter/af_surround.c

1520 lines
54KB
Raw Blame History 

  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. #include "window_func.h"

  29. 

  30. typedef struct AudioSurroundContext {

  31.     const AVClass *class;

  32. 

  33.     char *out_channel_layout_str;

  34.     char *in_channel_layout_str;

  35. 

  36.     float level_in;

  37.     float level_out;

  38.     float fc_in;

  39.     float fc_out;

  40.     float lfe_in;

  41.     float lfe_out;

  42.     int   win_func;

  43.     float overlap;

  44. 

  45.     float *input_levels;

  46.     float *output_levels;

  47.     int output_lfe;

  48.     int lowcutf;

  49.     int highcutf;

  50. 

  51.     float lowcut;

  52.     float highcut;

  53. 

  54.     uint64_t out_channel_layout;

  55.     uint64_t in_channel_layout;

  56.     int nb_in_channels;

  57.     int nb_out_channels;

  58. 

  59.     AVFrame *input;

  60.     AVFrame *output;

  61.     AVFrame *overlap_buffer;

  62. 

  63.     int buf_size;

  64.     int hop_size;

  65.     AVAudioFifo *fifo;

  66.     RDFTContext **rdft, **irdft;

  67.     float *window_func_lut;

  68. 

  69.     int64_t pts;

  70. 

  71.     void (*filter)(AVFilterContext *ctx);

  72.     void (*upmix_stereo)(AVFilterContext *ctx,

  73.                          float l_phase,

  74.                          float r_phase,

  75.                          float c_phase,

  76.                          float mag_total,

  77.                          float x, float y,

  78.                          int n);

  79.     void (*upmix_2_1)(AVFilterContext *ctx,

  80.                       float l_phase,

  81.                       float r_phase,

  82.                       float c_phase,

  83.                       float mag_total,

  84.                       float lfe_im,

  85.                       float lfe_re,

  86.                       float x, float y,

  87.                       int n);

  88.     void (*upmix_3_0)(AVFilterContext *ctx,

  89.                       float l_phase,

  90.                       float r_phase,

  91.                       float c_mag,

  92.                       float c_phase,

  93.                       float mag_total,

  94.                       float x, float y,

  95.                       int n);

  96.     void (*upmix_5_0)(AVFilterContext *ctx,

  97.                       float c_re, float c_im,

  98.                       float mag_totall, float mag_totalr,

  99.                       float fl_phase, float fr_phase,

  100.                       float bl_phase, float br_phase,

  101.                       float sl_phase, float sr_phase,

  102.                       float xl, float yl,

  103.                       float xr, float yr,

  104.                       int n);

  105.     void (*upmix_5_1)(AVFilterContext *ctx,

  106.                       float c_re, float c_im,

  107.                       float lfe_re, float lfe_im,

  108.                       float mag_totall, float mag_totalr,

  109.                       float fl_phase, float fr_phase,

  110.                       float bl_phase, float br_phase,

  111.                       float sl_phase, float sr_phase,

  112.                       float xl, float yl,

  113.                       float xr, float yr,

  114.                       int n);

  115. } AudioSurroundContext;

  116. 

  117. static int query_formats(AVFilterContext *ctx)

  118. {

  119.     AudioSurroundContext *s = ctx->priv;

  120.     AVFilterFormats *formats = NULL;

  121.     AVFilterChannelLayouts *layouts = NULL;

  122.     int ret;

  123. 

  124.     ret = ff_add_format(&formats, AV_SAMPLE_FMT_FLTP);

  125.     if (ret)

  126.         return ret;

  127.     ret = ff_set_common_formats(ctx, formats);

  128.     if (ret)

  129.         return ret;

  130. 

  131.     layouts = NULL;

  132.     ret = ff_add_channel_layout(&layouts, s->out_channel_layout);

  133.     if (ret)

  134.         return ret;

  135. 

  136.     ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts);

  137.     if (ret)

  138.         return ret;

  139. 

  140.     layouts = NULL;

  141.     ret = ff_add_channel_layout(&layouts, s->in_channel_layout);

  142.     if (ret)

  143.         return ret;

  144. 

  145.     ret = ff_channel_layouts_ref(layouts, &ctx->inputs[0]->out_channel_layouts);

  146.     if (ret)

  147.         return ret;

  148. 

  149.     formats = ff_all_samplerates();

  150.     if (!formats)

  151.         return AVERROR(ENOMEM);

  152.     return ff_set_common_samplerates(ctx, formats);

  153. }

  154. 

  155. static int config_input(AVFilterLink *inlink)

  156. {

  157.     AVFilterContext *ctx = inlink->dst;

  158.     AudioSurroundContext *s = ctx->priv;

  159.     int ch;

  160. 

  161.     s->rdft = av_calloc(inlink->channels, sizeof(*s->rdft));

  162.     if (!s->rdft)

  163.         return AVERROR(ENOMEM);

  164. 

  165.     for (ch = 0; ch < inlink->channels; ch++) {

  166.         s->rdft[ch]  = av_rdft_init(ff_log2(s->buf_size), DFT_R2C);

  167.         if (!s->rdft[ch])

  168.             return AVERROR(ENOMEM);

  169.     }

  170.     s->nb_in_channels = inlink->channels;

  171.     s->input_levels = av_malloc_array(s->nb_in_channels, sizeof(*s->input_levels));

  172.     if (!s->input_levels)

  173.         return AVERROR(ENOMEM);

  174.     for (ch = 0;  ch < s->nb_in_channels; ch++)

  175.         s->input_levels[ch] = s->level_in;

  176.     ch = av_get_channel_layout_channel_index(inlink->channel_layout, AV_CH_FRONT_CENTER);

  177.     if (ch >= 0)

  178.         s->input_levels[ch] *= s->fc_in;

  179.     ch = av_get_channel_layout_channel_index(inlink->channel_layout, AV_CH_LOW_FREQUENCY);

  180.     if (ch >= 0)

  181.         s->input_levels[ch] *= s->lfe_in;

  182. 

  183.     s->input = ff_get_audio_buffer(inlink, s->buf_size * 2);

  184.     if (!s->input)

  185.         return AVERROR(ENOMEM);

  186. 

  187.     s->fifo = av_audio_fifo_alloc(inlink->format, inlink->channels, s->buf_size);

  188.     if (!s->fifo)

  189.         return AVERROR(ENOMEM);

  190. 

  191.     s->lowcut = 1.f * s->lowcutf / (inlink->sample_rate * 0.5) * (s->buf_size / 2);

  192.     s->highcut = 1.f * s->highcutf / (inlink->sample_rate * 0.5) * (s->buf_size / 2);

  193. 

  194.     return 0;

  195. }

  196. 

  197. static int config_output(AVFilterLink *outlink)

  198. {

  199.     AVFilterContext *ctx = outlink->src;

  200.     AudioSurroundContext *s = ctx->priv;

  201.     int ch;

  202. 

  203.     s->irdft = av_calloc(outlink->channels, sizeof(*s->irdft));

  204.     if (!s->irdft)

  205.         return AVERROR(ENOMEM);

  206. 

  207.     for (ch = 0; ch < outlink->channels; ch++) {

  208.         s->irdft[ch] = av_rdft_init(ff_log2(s->buf_size), IDFT_C2R);

  209.         if (!s->irdft[ch])

  210.             return AVERROR(ENOMEM);

  211.     }

  212.     s->nb_out_channels = outlink->channels;

  213.     s->output_levels = av_malloc_array(s->nb_out_channels, sizeof(*s->output_levels));

  214.     if (!s->output_levels)

  215.         return AVERROR(ENOMEM);

  216.     for (ch = 0;  ch < s->nb_out_channels; ch++)

  217.         s->output_levels[ch] = s->level_out;

  218.     ch = av_get_channel_layout_channel_index(outlink->channel_layout, AV_CH_FRONT_CENTER);

  219.     if (ch >= 0)

  220.         s->output_levels[ch] *= s->fc_out;

  221.     ch = av_get_channel_layout_channel_index(outlink->channel_layout, AV_CH_LOW_FREQUENCY);

  222.     if (ch >= 0)

  223.         s->output_levels[ch] *= s->lfe_out;

  224. 

  225.     s->output = ff_get_audio_buffer(outlink, s->buf_size * 2);

  226.     s->overlap_buffer = ff_get_audio_buffer(outlink, s->buf_size * 2);

  227.     if (!s->overlap_buffer || !s->output)

  228.         return AVERROR(ENOMEM);

  229. 

  230.     return 0;

  231. }

  232. 

  233. static void stereo_position(float a, float p, float *x, float *y)

  234. {

  235.     *x = av_clipf(a+FFMAX(0, sinf(p-M_PI_2))*FFDIFFSIGN(a,0), -1, 1);

  236.     *y = av_clipf(cosf(a*M_PI_2+M_PI)*cosf(M_PI_2-p/M_PI)*M_LN10+1, -1, 1);

  237. }

  238. 

  239. static inline void get_lfe(int output_lfe, int n, float lowcut, float highcut,

  240.                            float *lfe_mag, float *mag_total)

  241. {

  242.     if (output_lfe && n < highcut) {

  243.         *lfe_mag    = n < lowcut ? 1.f : .5f*(1.f+cosf(M_PI*(lowcut-n)/(lowcut-highcut)));

  244.         *lfe_mag   *= *mag_total;

  245.         *mag_total -= *lfe_mag;

  246.     } else {

  247.         *lfe_mag = 0.f;

  248.     }

  249. }

  250. 

  251. static void upmix_1_0(AVFilterContext *ctx,

  252.                       float l_phase,

  253.                       float r_phase,

  254.                       float c_phase,

  255.                       float mag_total,

  256.                       float x, float y,

  257.                       int n)

  258. {

  259.     AudioSurroundContext *s = ctx->priv;

  260.     float mag, *dst;

  261. 

  262.     dst = (float *)s->output->extended_data[0];

  263. 

  264.     mag = sqrtf(1.f - fabsf(x)) * ((y + 1.f) * .5f) * mag_total;

  265. 

  266.     dst[2 * n    ] = mag * cosf(c_phase);

  267.     dst[2 * n + 1] = mag * sinf(c_phase);

  268. }

  269. 

  270. static void upmix_stereo(AVFilterContext *ctx,

  271.                          float l_phase,

  272.                          float r_phase,

  273.                          float c_phase,

  274.                          float mag_total,

  275.                          float x, float y,

  276.                          int n)

  277. {

  278.     AudioSurroundContext *s = ctx->priv;

  279.     float l_mag, r_mag, *dstl, *dstr;

  280. 

  281.     dstl = (float *)s->output->extended_data[0];

  282.     dstr = (float *)s->output->extended_data[1];

  283. 

  284.     l_mag = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;

  285.     r_mag = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;

  286. 

  287.     dstl[2 * n    ] = l_mag * cosf(l_phase);

  288.     dstl[2 * n + 1] = l_mag * sinf(l_phase);

  289. 

  290.     dstr[2 * n    ] = r_mag * cosf(r_phase);

  291.     dstr[2 * n + 1] = r_mag * sinf(r_phase);

  292. }

  293. 

  294. static void upmix_2_1(AVFilterContext *ctx,

  295.                       float l_phase,

  296.                       float r_phase,

  297.                       float c_phase,

  298.                       float mag_total,

  299.                       float x, float y,

  300.                       int n)

  301. {

  302.     AudioSurroundContext *s = ctx->priv;

  303.     float lfe_mag, l_mag, r_mag, *dstl, *dstr, *dstlfe;

  304. 

  305.     dstl = (float *)s->output->extended_data[0];

  306.     dstr = (float *)s->output->extended_data[1];

  307.     dstlfe = (float *)s->output->extended_data[2];

  308. 

  309.     get_lfe(s->output_lfe, n, s->lowcut, s->highcut, &lfe_mag, &mag_total);

  310. 

  311.     l_mag = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;

  312.     r_mag = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;

  313. 

  314.     dstl[2 * n    ] = l_mag * cosf(l_phase);

  315.     dstl[2 * n + 1] = l_mag * sinf(l_phase);

  316. 

  317.     dstr[2 * n    ] = r_mag * cosf(r_phase);

  318.     dstr[2 * n + 1] = r_mag * sinf(r_phase);

  319. 

  320.     dstlfe[2 * n    ] = lfe_mag * cosf(c_phase);

  321.     dstlfe[2 * n + 1] = lfe_mag * sinf(c_phase);

  322. }

  323. 

  324. static void upmix_3_0(AVFilterContext *ctx,

  325.                       float l_phase,

  326.                       float r_phase,

  327.                       float c_phase,

  328.                       float mag_total,

  329.                       float x, float y,

  330.                       int n)

  331. {

  332.     AudioSurroundContext *s = ctx->priv;

  333.     float l_mag, r_mag, c_mag, *dstc, *dstl, *dstr;

  334. 

  335.     dstl = (float *)s->output->extended_data[0];

  336.     dstr = (float *)s->output->extended_data[1];

  337.     dstc = (float *)s->output->extended_data[2];

  338. 

  339.     c_mag = sqrtf(1.f - fabsf(x))   * ((y + 1.f) * .5f) * mag_total;

  340.     l_mag = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;

  341.     r_mag = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;

  342. 

  343.     dstl[2 * n    ] = l_mag * cosf(l_phase);

  344.     dstl[2 * n + 1] = l_mag * sinf(l_phase);

  345. 

  346.     dstr[2 * n    ] = r_mag * cosf(r_phase);

  347.     dstr[2 * n + 1] = r_mag * sinf(r_phase);

  348. 

  349.     dstc[2 * n    ] = c_mag * cosf(c_phase);

  350.     dstc[2 * n + 1] = c_mag * sinf(c_phase);

  351. }

  352. 

  353. static void upmix_3_1(AVFilterContext *ctx,

  354.                       float l_phase,

  355.                       float r_phase,

  356.                       float c_phase,

  357.                       float mag_total,

  358.                       float x, float y,

  359.                       int n)

  360. {

  361.     AudioSurroundContext *s = ctx->priv;

  362.     float lfe_mag, l_mag, r_mag, c_mag, *dstc, *dstl, *dstr, *dstlfe;

  363. 

  364.     dstl = (float *)s->output->extended_data[0];

  365.     dstr = (float *)s->output->extended_data[1];

  366.     dstc = (float *)s->output->extended_data[2];

  367.     dstlfe = (float *)s->output->extended_data[3];

  368. 

  369.     get_lfe(s->output_lfe, n, s->lowcut, s->highcut, &lfe_mag, &mag_total);

  370. 

  371.     c_mag = sqrtf(1.f - fabsf(x))   * ((y + 1.f) * .5f) * mag_total;

  372.     l_mag = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;

  373.     r_mag = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;

  374. 

  375.     dstl[2 * n    ] = l_mag * cosf(l_phase);

  376.     dstl[2 * n + 1] = l_mag * sinf(l_phase);

  377. 

  378.     dstr[2 * n    ] = r_mag * cosf(r_phase);

  379.     dstr[2 * n + 1] = r_mag * sinf(r_phase);

  380. 

  381.     dstc[2 * n    ] = c_mag * cosf(c_phase);

  382.     dstc[2 * n + 1] = c_mag * sinf(c_phase);

  383. 

  384.     dstlfe[2 * n    ] = lfe_mag * cosf(c_phase);

  385.     dstlfe[2 * n + 1] = lfe_mag * sinf(c_phase);

  386. }

  387. 

  388. static void upmix_3_1_surround(AVFilterContext *ctx,

  389.                                float l_phase,

  390.                                float r_phase,

  391.                                float c_phase,

  392.                                float c_mag,

  393.                                float mag_total,

  394.                                float x, float y,

  395.                                int n)

  396. {

  397.     AudioSurroundContext *s = ctx->priv;

  398.     float lfe_mag, l_mag, r_mag, *dstc, *dstl, *dstr, *dstlfe;

  399. 

  400.     dstl = (float *)s->output->extended_data[0];

  401.     dstr = (float *)s->output->extended_data[1];

  402.     dstc = (float *)s->output->extended_data[2];

  403.     dstlfe = (float *)s->output->extended_data[3];

  404. 

  405.     get_lfe(s->output_lfe, n, s->lowcut, s->highcut, &lfe_mag, &c_mag);

  406. 

  407.     l_mag = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;

  408.     r_mag = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;

  409. 

  410.     dstl[2 * n    ] = l_mag * cosf(l_phase);

  411.     dstl[2 * n + 1] = l_mag * sinf(l_phase);

  412. 

  413.     dstr[2 * n    ] = r_mag * cosf(r_phase);

  414.     dstr[2 * n + 1] = r_mag * sinf(r_phase);

  415. 

  416.     dstc[2 * n    ] = c_mag * cosf(c_phase);

  417.     dstc[2 * n + 1] = c_mag * sinf(c_phase);

  418. 

  419.     dstlfe[2 * n    ] = lfe_mag * cosf(c_phase);

  420.     dstlfe[2 * n + 1] = lfe_mag * sinf(c_phase);

  421. }

  422. 

  423. static void upmix_4_0(AVFilterContext *ctx,

  424.                       float l_phase,

  425.                       float r_phase,

  426.                       float c_phase,

  427.                       float mag_total,

  428.                       float x, float y,

  429.                       int n)

  430. {

  431.     float b_mag, l_mag, r_mag, c_mag, *dstc, *dstl, *dstr, *dstb;

  432.     AudioSurroundContext *s = ctx->priv;

  433. 

  434.     dstl = (float *)s->output->extended_data[0];

  435.     dstr = (float *)s->output->extended_data[1];

  436.     dstc = (float *)s->output->extended_data[2];

  437.     dstb = (float *)s->output->extended_data[3];

  438. 

  439.     c_mag = sqrtf(1.f - fabsf(x))   * ((y + 1.f) * .5f) * mag_total;

  440.     b_mag = sqrtf(1.f - fabsf(x))   * ((1.f - y) * .5f) * mag_total;

  441.     l_mag = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;

  442.     r_mag = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;

  443. 

  444.     dstl[2 * n    ] = l_mag * cosf(l_phase);

  445.     dstl[2 * n + 1] = l_mag * sinf(l_phase);

  446. 

  447.     dstr[2 * n    ] = r_mag * cosf(r_phase);

  448.     dstr[2 * n + 1] = r_mag * sinf(r_phase);

  449. 

  450.     dstc[2 * n    ] = c_mag * cosf(c_phase);

  451.     dstc[2 * n + 1] = c_mag * sinf(c_phase);

  452. 

  453.     dstb[2 * n    ] = b_mag * cosf(c_phase);

  454.     dstb[2 * n + 1] = b_mag * sinf(c_phase);

  455. }

  456. 

  457. static void upmix_4_1(AVFilterContext *ctx,

  458.                       float l_phase,

  459.                       float r_phase,

  460.                       float c_phase,

  461.                       float mag_total,

  462.                       float x, float y,

  463.                       int n)

  464. {

  465.     float lfe_mag, b_mag, l_mag, r_mag, c_mag, *dstc, *dstl, *dstr, *dstb, *dstlfe;

  466.     AudioSurroundContext *s = ctx->priv;

  467. 

  468.     dstl = (float *)s->output->extended_data[0];

  469.     dstr = (float *)s->output->extended_data[1];

  470.     dstc = (float *)s->output->extended_data[2];

  471.     dstlfe = (float *)s->output->extended_data[3];

  472.     dstb = (float *)s->output->extended_data[4];

  473. 

  474.     get_lfe(s->output_lfe, n, s->lowcut, s->highcut, &lfe_mag, &mag_total);

  475. 

  476.     dstlfe[2 * n    ] = lfe_mag * cosf(c_phase);

  477.     dstlfe[2 * n + 1] = lfe_mag * sinf(c_phase);

  478. 

  479.     c_mag = sqrtf(1.f - fabsf(x))   * ((y + 1.f) * .5f) * mag_total;

  480.     b_mag = sqrtf(1.f - fabsf(x))   * ((1.f - y) * .5f) * mag_total;

  481.     l_mag = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;

  482.     r_mag = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;

  483. 

  484.     dstl[2 * n    ] = l_mag * cosf(l_phase);

  485.     dstl[2 * n + 1] = l_mag * sinf(l_phase);

  486. 

  487.     dstr[2 * n    ] = r_mag * cosf(r_phase);

  488.     dstr[2 * n + 1] = r_mag * sinf(r_phase);

  489. 

  490.     dstc[2 * n    ] = c_mag * cosf(c_phase);

  491.     dstc[2 * n + 1] = c_mag * sinf(c_phase);

  492. 

  493.     dstb[2 * n    ] = b_mag * cosf(c_phase);

  494.     dstb[2 * n + 1] = b_mag * sinf(c_phase);

  495. }

  496. 

  497. static void upmix_5_0_back(AVFilterContext *ctx,

  498.                            float l_phase,

  499.                            float r_phase,

  500.                            float c_phase,

  501.                            float mag_total,

  502.                            float x, float y,

  503.                            int n)

  504. {

  505.     float l_mag, r_mag, ls_mag, rs_mag, c_mag, *dstc, *dstl, *dstr, *dstls, *dstrs;

  506.     AudioSurroundContext *s = ctx->priv;

  507. 

  508.     dstl  = (float *)s->output->extended_data[0];

  509.     dstr  = (float *)s->output->extended_data[1];

  510.     dstc  = (float *)s->output->extended_data[2];

  511.     dstls = (float *)s->output->extended_data[3];

  512.     dstrs = (float *)s->output->extended_data[4];

  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.     dstls[2 * n    ] = ls_mag * cosf(l_phase);

  530.     dstls[2 * n + 1] = ls_mag * sinf(l_phase);

  531. 

  532.     dstrs[2 * n    ] = rs_mag * cosf(r_phase);

  533.     dstrs[2 * n + 1] = rs_mag * sinf(r_phase);

  534. }

  535. 

  536. static void upmix_5_1_back(AVFilterContext *ctx,

  537.                            float l_phase,

  538.                            float r_phase,

  539.                            float c_phase,

  540.                            float mag_total,

  541.                            float x, float y,

  542.                            int n)

  543. {

  544.     float lfe_mag, l_mag, r_mag, ls_mag, rs_mag, c_mag, *dstc, *dstl, *dstr, *dstls, *dstrs, *dstlfe;

  545.     AudioSurroundContext *s = ctx->priv;

  546. 

  547.     dstl  = (float *)s->output->extended_data[0];

  548.     dstr  = (float *)s->output->extended_data[1];

  549.     dstc  = (float *)s->output->extended_data[2];

  550.     dstlfe = (float *)s->output->extended_data[3];

  551.     dstls = (float *)s->output->extended_data[4];

  552.     dstrs = (float *)s->output->extended_data[5];

  553. 

  554.     get_lfe(s->output_lfe, n, s->lowcut, s->highcut, &lfe_mag, &mag_total);

  555. 

  556.     c_mag  = sqrtf(1.f - fabsf(x))   * ((y + 1.f) * .5f) * mag_total;

  557.     l_mag  = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;

  558.     r_mag  = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;

  559.     ls_mag = sqrtf(.5f * ( x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;

  560.     rs_mag = sqrtf(.5f * (-x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;

  561. 

  562.     dstl[2 * n    ] = l_mag * cosf(l_phase);

  563.     dstl[2 * n + 1] = l_mag * sinf(l_phase);

  564. 

  565.     dstr[2 * n    ] = r_mag * cosf(r_phase);

  566.     dstr[2 * n + 1] = r_mag * sinf(r_phase);

  567. 

  568.     dstc[2 * n    ] = c_mag * cosf(c_phase);

  569.     dstc[2 * n + 1] = c_mag * sinf(c_phase);

  570. 

  571.     dstlfe[2 * n    ] = lfe_mag * cosf(c_phase);

  572.     dstlfe[2 * n + 1] = lfe_mag * sinf(c_phase);

  573. 

  574.     dstls[2 * n    ] = ls_mag * cosf(l_phase);

  575.     dstls[2 * n + 1] = ls_mag * sinf(l_phase);

  576. 

  577.     dstrs[2 * n    ] = rs_mag * cosf(r_phase);

  578.     dstrs[2 * n + 1] = rs_mag * sinf(r_phase);

  579. }

  580. 

  581. static void upmix_5_1_back_surround(AVFilterContext *ctx,

  582.                                     float l_phase,

  583.                                     float r_phase,

  584.                                     float c_phase,

  585.                                     float c_mag,

  586.                                     float mag_total,

  587.                                     float x, float y,

  588.                                     int n)

  589. {

  590.     AudioSurroundContext *s = ctx->priv;

  591.     float lfe_mag, l_mag, r_mag, *dstc, *dstl, *dstr, *dstlfe;

  592.     float ls_mag, rs_mag, *dstls, *dstrs;

  593. 

  594.     dstl = (float *)s->output->extended_data[0];

  595.     dstr = (float *)s->output->extended_data[1];

  596.     dstc = (float *)s->output->extended_data[2];

  597.     dstlfe = (float *)s->output->extended_data[3];

  598.     dstls = (float *)s->output->extended_data[4];

  599.     dstrs = (float *)s->output->extended_data[5];

  600. 

  601.     get_lfe(s->output_lfe, n, s->lowcut, s->highcut, &lfe_mag, &c_mag);

  602. 

  603.     l_mag = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;

  604.     r_mag = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;

  605.     ls_mag = sqrtf(.5f * ( x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;

  606.     rs_mag = sqrtf(.5f * (-x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;

  607. 

  608.     dstl[2 * n    ] = l_mag * cosf(l_phase);

  609.     dstl[2 * n + 1] = l_mag * sinf(l_phase);

  610. 

  611.     dstr[2 * n    ] = r_mag * cosf(r_phase);

  612.     dstr[2 * n + 1] = r_mag * sinf(r_phase);

  613. 

  614.     dstc[2 * n    ] = c_mag * cosf(c_phase);

  615.     dstc[2 * n + 1] = c_mag * sinf(c_phase);

  616. 

  617.     dstlfe[2 * n    ] = lfe_mag * cosf(c_phase);

  618.     dstlfe[2 * n + 1] = lfe_mag * sinf(c_phase);

  619. 

  620.     dstls[2 * n    ] = ls_mag * cosf(l_phase);

  621.     dstls[2 * n + 1] = ls_mag * sinf(l_phase);

  622. 

  623.     dstrs[2 * n    ] = rs_mag * cosf(r_phase);

  624.     dstrs[2 * n + 1] = rs_mag * sinf(r_phase);

  625. }

  626. 

  627. static void upmix_5_1_back_2_1(AVFilterContext *ctx,

  628.                                float l_phase,

  629.                                float r_phase,

  630.                                float c_phase,

  631.                                float mag_total,

  632.                                float lfe_re,

  633.                                float lfe_im,

  634.                                float x, float y,

  635.                                int n)

  636. {

  637.     AudioSurroundContext *s = ctx->priv;

  638.     float c_mag, l_mag, r_mag, *dstc, *dstl, *dstr, *dstlfe;

  639.     float ls_mag, rs_mag, *dstls, *dstrs;

  640. 

  641.     dstl = (float *)s->output->extended_data[0];

  642.     dstr = (float *)s->output->extended_data[1];

  643.     dstc = (float *)s->output->extended_data[2];

  644.     dstlfe = (float *)s->output->extended_data[3];

  645.     dstls = (float *)s->output->extended_data[4];

  646.     dstrs = (float *)s->output->extended_data[5];

  647. 

  648.     c_mag  = sqrtf(1.f - fabsf(x))   * ((y + 1.f) * .5f) * mag_total;

  649.     l_mag  = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;

  650.     r_mag  = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;

  651.     ls_mag = sqrtf(.5f * ( x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;

  652.     rs_mag = sqrtf(.5f * (-x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;

  653. 

  654.     dstl[2 * n    ] = l_mag * cosf(l_phase);

  655.     dstl[2 * n + 1] = l_mag * sinf(l_phase);

  656. 

  657.     dstr[2 * n    ] = r_mag * cosf(r_phase);

  658.     dstr[2 * n + 1] = r_mag * sinf(r_phase);

  659. 

  660.     dstc[2 * n    ] = c_mag * cosf(c_phase);

  661.     dstc[2 * n + 1] = c_mag * sinf(c_phase);

  662. 

  663.     dstlfe[2 * n    ] = lfe_re;

  664.     dstlfe[2 * n + 1] = lfe_im;

  665. 

  666.     dstls[2 * n    ] = ls_mag * cosf(l_phase);

  667.     dstls[2 * n + 1] = ls_mag * sinf(l_phase);

  668. 

  669.     dstrs[2 * n    ] = rs_mag * cosf(r_phase);

  670.     dstrs[2 * n + 1] = rs_mag * sinf(r_phase);

  671. }

  672. 

  673. static void upmix_7_0(AVFilterContext *ctx,

  674.                       float l_phase,

  675.                       float r_phase,

  676.                       float c_phase,

  677.                       float mag_total,

  678.                       float x, float y,

  679.                       int n)

  680. {

  681.     float l_mag, r_mag, ls_mag, rs_mag, c_mag, lb_mag, rb_mag;

  682.     float *dstc, *dstl, *dstr, *dstls, *dstrs, *dstlb, *dstrb;

  683.     AudioSurroundContext *s = ctx->priv;

  684. 

  685.     dstl  = (float *)s->output->extended_data[0];

  686.     dstr  = (float *)s->output->extended_data[1];

  687.     dstc  = (float *)s->output->extended_data[2];

  688.     dstlb = (float *)s->output->extended_data[3];

  689.     dstrb = (float *)s->output->extended_data[4];

  690.     dstls = (float *)s->output->extended_data[5];

  691.     dstrs = (float *)s->output->extended_data[6];

  692. 

  693.     c_mag  = sqrtf(1.f - fabsf(x))   * ((y + 1.f) * .5f) * mag_total;

  694.     l_mag  = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;

  695.     r_mag  = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;

  696.     lb_mag = sqrtf(.5f * ( x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;

  697.     rb_mag = sqrtf(.5f * (-x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;

  698.     ls_mag = sqrtf(.5f * ( x + 1.f)) * (1.f - fabsf(y)) * mag_total;

  699.     rs_mag = sqrtf(.5f * (-x + 1.f)) * (1.f - fabsf(y)) * mag_total;

  700. 

  701.     dstl[2 * n    ] = l_mag * cosf(l_phase);

  702.     dstl[2 * n + 1] = l_mag * sinf(l_phase);

  703. 

  704.     dstr[2 * n    ] = r_mag * cosf(r_phase);

  705.     dstr[2 * n + 1] = r_mag * sinf(r_phase);

  706. 

  707.     dstc[2 * n    ] = c_mag * cosf(c_phase);

  708.     dstc[2 * n + 1] = c_mag * sinf(c_phase);

  709. 

  710.     dstlb[2 * n    ] = lb_mag * cosf(l_phase);

  711.     dstlb[2 * n + 1] = lb_mag * sinf(l_phase);

  712. 

  713.     dstrb[2 * n    ] = rb_mag * cosf(r_phase);

  714.     dstrb[2 * n + 1] = rb_mag * sinf(r_phase);

  715. 

  716.     dstls[2 * n    ] = ls_mag * cosf(l_phase);

  717.     dstls[2 * n + 1] = ls_mag * sinf(l_phase);

  718. 

  719.     dstrs[2 * n    ] = rs_mag * cosf(r_phase);

  720.     dstrs[2 * n + 1] = rs_mag * sinf(r_phase);

  721. }

  722. 

  723. static void upmix_7_1(AVFilterContext *ctx,

  724.                       float l_phase,

  725.                       float r_phase,

  726.                       float c_phase,

  727.                       float mag_total,

  728.                       float x, float y,

  729.                       int n)

  730. {

  731.     float lfe_mag, l_mag, r_mag, ls_mag, rs_mag, c_mag, lb_mag, rb_mag;

  732.     float *dstc, *dstl, *dstr, *dstls, *dstrs, *dstlb, *dstrb, *dstlfe;

  733.     AudioSurroundContext *s = ctx->priv;

  734. 

  735.     dstl  = (float *)s->output->extended_data[0];

  736.     dstr  = (float *)s->output->extended_data[1];

  737.     dstc  = (float *)s->output->extended_data[2];

  738.     dstlfe = (float *)s->output->extended_data[3];

  739.     dstlb = (float *)s->output->extended_data[4];

  740.     dstrb = (float *)s->output->extended_data[5];

  741.     dstls = (float *)s->output->extended_data[6];

  742.     dstrs = (float *)s->output->extended_data[7];

  743. 

  744.     get_lfe(s->output_lfe, n, s->lowcut, s->highcut, &lfe_mag, &mag_total);

  745. 

  746.     c_mag  = sqrtf(1.f - fabsf(x))   * ((y + 1.f) * .5f) * mag_total;

  747.     l_mag  = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;

  748.     r_mag  = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;

  749.     lb_mag = sqrtf(.5f * ( x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;

  750.     rb_mag = sqrtf(.5f * (-x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;

  751.     ls_mag = sqrtf(.5f * ( x + 1.f)) * (1.f - fabsf(y)) * mag_total;

  752.     rs_mag = sqrtf(.5f * (-x + 1.f)) * (1.f - fabsf(y)) * mag_total;

  753. 

  754.     dstl[2 * n    ] = l_mag * cosf(l_phase);

  755.     dstl[2 * n + 1] = l_mag * sinf(l_phase);

  756. 

  757.     dstr[2 * n    ] = r_mag * cosf(r_phase);

  758.     dstr[2 * n + 1] = r_mag * sinf(r_phase);

  759. 

  760.     dstc[2 * n    ] = c_mag * cosf(c_phase);

  761.     dstc[2 * n + 1] = c_mag * sinf(c_phase);

  762. 

  763.     dstlfe[2 * n    ] = lfe_mag * cosf(c_phase);

  764.     dstlfe[2 * n + 1] = lfe_mag * sinf(c_phase);

  765. 

  766.     dstlb[2 * n    ] = lb_mag * cosf(l_phase);

  767.     dstlb[2 * n + 1] = lb_mag * sinf(l_phase);

  768. 

  769.     dstrb[2 * n    ] = rb_mag * cosf(r_phase);

  770.     dstrb[2 * n + 1] = rb_mag * sinf(r_phase);

  771. 

  772.     dstls[2 * n    ] = ls_mag * cosf(l_phase);

  773.     dstls[2 * n + 1] = ls_mag * sinf(l_phase);

  774. 

  775.     dstrs[2 * n    ] = rs_mag * cosf(r_phase);

  776.     dstrs[2 * n + 1] = rs_mag * sinf(r_phase);

  777. }

  778. 

  779. static void upmix_7_1_5_0_side(AVFilterContext *ctx,

  780.                                float c_re, float c_im,

  781.                                float mag_totall, float mag_totalr,

  782.                                float fl_phase, float fr_phase,

  783.                                float bl_phase, float br_phase,

  784.                                float sl_phase, float sr_phase,

  785.                                float xl, float yl,

  786.                                float xr, float yr,

  787.                                int n)

  788. {

  789.     float fl_mag, fr_mag, ls_mag, rs_mag, lb_mag, rb_mag;

  790.     float *dstc, *dstl, *dstr, *dstls, *dstrs, *dstlb, *dstrb, *dstlfe;

  791.     float lfe_mag, c_phase, mag_total = (mag_totall + mag_totalr) * 0.5;

  792.     AudioSurroundContext *s = ctx->priv;

  793. 

  794.     dstl  = (float *)s->output->extended_data[0];

  795.     dstr  = (float *)s->output->extended_data[1];

  796.     dstc  = (float *)s->output->extended_data[2];

  797.     dstlfe = (float *)s->output->extended_data[3];

  798.     dstlb = (float *)s->output->extended_data[4];

  799.     dstrb = (float *)s->output->extended_data[5];

  800.     dstls = (float *)s->output->extended_data[6];

  801.     dstrs = (float *)s->output->extended_data[7];

  802. 

  803.     c_phase = atan2f(c_im, c_re);

  804. 

  805.     get_lfe(s->output_lfe, n, s->lowcut, s->highcut, &lfe_mag, &mag_total);

  806. 

  807.     fl_mag = sqrtf(.5f * (xl + 1.f)) * ((yl + 1.f) * .5f) * mag_totall;

  808.     fr_mag = sqrtf(.5f * (xr + 1.f)) * ((yr + 1.f) * .5f) * mag_totalr;

  809.     lb_mag = sqrtf(.5f * (-xl + 1.f)) * ((yl + 1.f) * .5f) * mag_totall;

  810.     rb_mag = sqrtf(.5f * (-xr + 1.f)) * ((yr + 1.f) * .5f) * mag_totalr;

  811.     ls_mag = sqrtf(1.f - fabsf(xl)) * ((yl + 1.f) * .5f) * mag_totall;

  812.     rs_mag = sqrtf(1.f - fabsf(xr)) * ((yr + 1.f) * .5f) * mag_totalr;

  813. 

  814.     dstl[2 * n    ] = fl_mag * cosf(fl_phase);

  815.     dstl[2 * n + 1] = fl_mag * sinf(fl_phase);

  816. 

  817.     dstr[2 * n    ] = fr_mag * cosf(fr_phase);

  818.     dstr[2 * n + 1] = fr_mag * sinf(fr_phase);

  819. 

  820.     dstc[2 * n    ] = c_re;

  821.     dstc[2 * n + 1] = c_im;

  822. 

  823.     dstlfe[2 * n    ] = lfe_mag * cosf(c_phase);

  824.     dstlfe[2 * n + 1] = lfe_mag * sinf(c_phase);

  825. 

  826.     dstlb[2 * n    ] = lb_mag * cosf(bl_phase);

  827.     dstlb[2 * n + 1] = lb_mag * sinf(bl_phase);

  828. 

  829.     dstrb[2 * n    ] = rb_mag * cosf(br_phase);

  830.     dstrb[2 * n + 1] = rb_mag * sinf(br_phase);

  831. 

  832.     dstls[2 * n    ] = ls_mag * cosf(sl_phase);

  833.     dstls[2 * n + 1] = ls_mag * sinf(sl_phase);

  834. 

  835.     dstrs[2 * n    ] = rs_mag * cosf(sr_phase);

  836.     dstrs[2 * n + 1] = rs_mag * sinf(sr_phase);

  837. }

  838. 

  839. static void upmix_7_1_5_1(AVFilterContext *ctx,

  840.                           float c_re, float c_im,

  841.                           float lfe_re, float lfe_im,

  842.                           float mag_totall, float mag_totalr,

  843.                           float fl_phase, float fr_phase,

  844.                           float bl_phase, float br_phase,

  845.                           float sl_phase, float sr_phase,

  846.                           float xl, float yl,

  847.                           float xr, float yr,

  848.                           int n)

  849. {

  850.     float fl_mag, fr_mag, ls_mag, rs_mag, lb_mag, rb_mag;

  851.     float *dstc, *dstl, *dstr, *dstls, *dstrs, *dstlb, *dstrb, *dstlfe;

  852.     AudioSurroundContext *s = ctx->priv;

  853. 

  854.     dstl  = (float *)s->output->extended_data[0];

  855.     dstr  = (float *)s->output->extended_data[1];

  856.     dstc  = (float *)s->output->extended_data[2];

  857.     dstlfe = (float *)s->output->extended_data[3];

  858.     dstlb = (float *)s->output->extended_data[4];

  859.     dstrb = (float *)s->output->extended_data[5];

  860.     dstls = (float *)s->output->extended_data[6];

  861.     dstrs = (float *)s->output->extended_data[7];

  862. 

  863.     fl_mag = sqrtf(.5f * (xl + 1.f)) * ((yl + 1.f) * .5f) * mag_totall;

  864.     fr_mag = sqrtf(.5f * (xr + 1.f)) * ((yr + 1.f) * .5f) * mag_totalr;

  865.     lb_mag = sqrtf(.5f * (-xl + 1.f)) * ((yl + 1.f) * .5f) * mag_totall;

  866.     rb_mag = sqrtf(.5f * (-xr + 1.f)) * ((yr + 1.f) * .5f) * mag_totalr;

  867.     ls_mag = sqrtf(1.f - fabsf(xl)) * ((yl + 1.f) * .5f) * mag_totall;

  868.     rs_mag = sqrtf(1.f - fabsf(xr)) * ((yr + 1.f) * .5f) * mag_totalr;

  869. 

  870.     dstl[2 * n    ] = fl_mag * cosf(fl_phase);

  871.     dstl[2 * n + 1] = fl_mag * sinf(fl_phase);

  872. 

  873.     dstr[2 * n    ] = fr_mag * cosf(fr_phase);

  874.     dstr[2 * n + 1] = fr_mag * sinf(fr_phase);

  875. 

  876.     dstc[2 * n    ] = c_re;

  877.     dstc[2 * n + 1] = c_im;

  878. 

  879.     dstlfe[2 * n    ] = lfe_re;

  880.     dstlfe[2 * n + 1] = lfe_im;

  881. 

  882.     dstlb[2 * n    ] = lb_mag * cosf(bl_phase);

  883.     dstlb[2 * n + 1] = lb_mag * sinf(bl_phase);

  884. 

  885.     dstrb[2 * n    ] = rb_mag * cosf(br_phase);

  886.     dstrb[2 * n + 1] = rb_mag * sinf(br_phase);

  887. 

  888.     dstls[2 * n    ] = ls_mag * cosf(sl_phase);

  889.     dstls[2 * n + 1] = ls_mag * sinf(sl_phase);

  890. 

  891.     dstrs[2 * n    ] = rs_mag * cosf(sr_phase);

  892.     dstrs[2 * n + 1] = rs_mag * sinf(sr_phase);

  893. }

  894. 

  895. static void filter_stereo(AVFilterContext *ctx)

  896. {

  897.     AudioSurroundContext *s = ctx->priv;

  898.     float *srcl, *srcr;

  899.     int n;

  900. 

  901.     srcl = (float *)s->input->extended_data[0];

  902.     srcr = (float *)s->input->extended_data[1];

  903. 

  904.     for (n = 0; n < s->buf_size; n++) {

  905.         float l_re = srcl[2 * n], r_re = srcr[2 * n];

  906.         float l_im = srcl[2 * n + 1], r_im = srcr[2 * n + 1];

  907.         float c_phase = atan2f(l_im + r_im, l_re + r_re);

  908.         float l_mag = hypotf(l_re, l_im);

  909.         float r_mag = hypotf(r_re, r_im);

  910.         float l_phase = atan2f(l_im, l_re);

  911.         float r_phase = atan2f(r_im, r_re);

  912.         float phase_dif = fabsf(l_phase - r_phase);

  913.         float mag_dif = (l_mag - r_mag) / (l_mag + r_mag);

  914.         float mag_total = hypotf(l_mag, r_mag);

  915.         float x, y;

  916. 

  917.         if (phase_dif > M_PI)

  918.             phase_dif = 2 * M_PI - phase_dif;

  919. 

  920.         stereo_position(mag_dif, phase_dif, &x, &y);

  921. 

  922.         s->upmix_stereo(ctx, l_phase, r_phase, c_phase, mag_total, x, y, n);

  923.     }

  924. }

  925. 

  926. static void filter_surround(AVFilterContext *ctx)

  927. {

  928.     AudioSurroundContext *s = ctx->priv;

  929.     float *srcl, *srcr, *srcc;

  930.     int n;

  931. 

  932.     srcl = (float *)s->input->extended_data[0];

  933.     srcr = (float *)s->input->extended_data[1];

  934.     srcc = (float *)s->input->extended_data[2];

  935. 

  936.     for (n = 0; n < s->buf_size; n++) {

  937.         float l_re = srcl[2 * n], r_re = srcr[2 * n];

  938.         float l_im = srcl[2 * n + 1], r_im = srcr[2 * n + 1];

  939.         float c_re = srcc[2 * n], c_im = srcc[2 * n + 1];

  940.         float c_mag = hypotf(c_re, c_im);

  941.         float c_phase = atan2f(c_im, c_re);

  942.         float l_mag = hypotf(l_re, l_im);

  943.         float r_mag = hypotf(r_re, r_im);

  944.         float l_phase = atan2f(l_im, l_re);

  945.         float r_phase = atan2f(r_im, r_re);

  946.         float phase_dif = fabsf(l_phase - r_phase);

  947.         float mag_dif = (l_mag - r_mag) / (l_mag + r_mag);

  948.         float mag_total = hypotf(l_mag, r_mag);

  949.         float x, y;

  950. 

  951.         if (phase_dif > M_PI)

  952.             phase_dif = 2 * M_PI - phase_dif;

  953. 

  954.         stereo_position(mag_dif, phase_dif, &x, &y);

  955. 

  956.         s->upmix_3_0(ctx, l_phase, r_phase, c_phase, c_mag, mag_total, x, y, n);

  957.     }

  958. }

  959. 

  960. static void filter_2_1(AVFilterContext *ctx)

  961. {

  962.     AudioSurroundContext *s = ctx->priv;

  963.     float *srcl, *srcr, *srclfe;

  964.     int n;

  965. 

  966.     srcl = (float *)s->input->extended_data[0];

  967.     srcr = (float *)s->input->extended_data[1];

  968.     srclfe = (float *)s->input->extended_data[2];

  969. 

  970.     for (n = 0; n < s->buf_size; n++) {

  971.         float l_re = srcl[2 * n], r_re = srcr[2 * n];

  972.         float l_im = srcl[2 * n + 1], r_im = srcr[2 * n + 1];

  973.         float lfe_re = srclfe[2 * n], lfe_im = srclfe[2 * n + 1];

  974.         float c_phase = atan2f(l_im + r_im, l_re + r_re);

  975.         float l_mag = hypotf(l_re, l_im);

  976.         float r_mag = hypotf(r_re, r_im);

  977.         float l_phase = atan2f(l_im, l_re);

  978.         float r_phase = atan2f(r_im, r_re);

  979.         float phase_dif = fabsf(l_phase - r_phase);

  980.         float mag_dif = (l_mag - r_mag) / (l_mag + r_mag);

  981.         float mag_total = hypotf(l_mag, r_mag);

  982.         float x, y;

  983. 

  984.         if (phase_dif > M_PI)

  985.             phase_dif = 2 * M_PI - phase_dif;

  986. 

  987.         stereo_position(mag_dif, phase_dif, &x, &y);

  988. 

  989.         s->upmix_2_1(ctx, l_phase, r_phase, c_phase, mag_total, lfe_re, lfe_im, x, y, n);

  990.     }

  991. }

  992. 

  993. static void filter_5_0_side(AVFilterContext *ctx)

  994. {

  995.     AudioSurroundContext *s = ctx->priv;

  996.     float *srcl, *srcr, *srcc, *srcsl, *srcsr;

  997.     int n;

  998. 

  999.     srcl = (float *)s->input->extended_data[0];

  1000.     srcr = (float *)s->input->extended_data[1];

  1001.     srcc = (float *)s->input->extended_data[2];

  1002.     srcsl = (float *)s->input->extended_data[3];

  1003.     srcsr = (float *)s->input->extended_data[4];

  1004. 

  1005.     for (n = 0; n < s->buf_size; n++) {

  1006.         float fl_re = srcl[2 * n], fr_re = srcr[2 * n];

  1007.         float fl_im = srcl[2 * n + 1], fr_im = srcr[2 * n + 1];

  1008.         float c_re = srcc[2 * n], c_im = srcc[2 * n + 1];

  1009.         float sl_re = srcsl[2 * n], sl_im = srcsl[2 * n + 1];

  1010.         float sr_re = srcsr[2 * n], sr_im = srcsr[2 * n + 1];

  1011.         float fl_mag = hypotf(fl_re, fl_im);

  1012.         float fr_mag = hypotf(fr_re, fr_im);

  1013.         float fl_phase = atan2f(fl_im, fl_re);

  1014.         float fr_phase = atan2f(fr_im, fr_re);

  1015.         float sl_mag = hypotf(sl_re, sl_im);

  1016.         float sr_mag = hypotf(sr_re, sr_im);

  1017.         float sl_phase = atan2f(sl_im, sl_re);

  1018.         float sr_phase = atan2f(sr_im, sr_re);

  1019.         float phase_difl = fabsf(fl_phase - sl_phase);

  1020.         float phase_difr = fabsf(fr_phase - sr_phase);

  1021.         float mag_difl = (fl_mag - sl_mag) / (fl_mag + sl_mag);

  1022.         float mag_difr = (fr_mag - sr_mag) / (fr_mag + sr_mag);

  1023.         float mag_totall = hypotf(fl_mag, sl_mag);

  1024.         float mag_totalr = hypotf(fr_mag, sr_mag);

  1025.         float bl_phase = atan2f(fl_im + sl_im, fl_re + sl_re);

  1026.         float br_phase = atan2f(fr_im + sr_im, fr_re + sr_re);

  1027.         float xl, yl;

  1028.         float xr, yr;

  1029. 

  1030.         if (phase_difl > M_PI)

  1031.             phase_difl = 2 * M_PI - phase_difl;

  1032. 

  1033.         if (phase_difr > M_PI)

  1034.             phase_difr = 2 * M_PI - phase_difr;

  1035. 

  1036.         stereo_position(mag_difl, phase_difl, &xl, &yl);

  1037.         stereo_position(mag_difr, phase_difr, &xr, &yr);

  1038. 

  1039.         s->upmix_5_0(ctx, c_re, c_im,

  1040.                      mag_totall, mag_totalr,

  1041.                      fl_phase, fr_phase,

  1042.                      bl_phase, br_phase,

  1043.                      sl_phase, sr_phase,

  1044.                      xl, yl, xr, yr, n);

  1045.     }

  1046. }

  1047. 

  1048. static void filter_5_1_side(AVFilterContext *ctx)

  1049. {

  1050.     AudioSurroundContext *s = ctx->priv;

  1051.     float *srcl, *srcr, *srcc, *srclfe, *srcsl, *srcsr;

  1052.     int n;

  1053. 

  1054.     srcl = (float *)s->input->extended_data[0];

  1055.     srcr = (float *)s->input->extended_data[1];

  1056.     srcc = (float *)s->input->extended_data[2];

  1057.     srclfe = (float *)s->input->extended_data[3];

  1058.     srcsl = (float *)s->input->extended_data[4];

  1059.     srcsr = (float *)s->input->extended_data[5];

  1060. 

  1061.     for (n = 0; n < s->buf_size; n++) {

  1062.         float fl_re = srcl[2 * n], fr_re = srcr[2 * n];

  1063.         float fl_im = srcl[2 * n + 1], fr_im = srcr[2 * n + 1];

  1064.         float c_re = srcc[2 * n], c_im = srcc[2 * n + 1];

  1065.         float lfe_re = srclfe[2 * n], lfe_im = srclfe[2 * n + 1];

  1066.         float sl_re = srcsl[2 * n], sl_im = srcsl[2 * n + 1];

  1067.         float sr_re = srcsr[2 * n], sr_im = srcsr[2 * n + 1];

  1068.         float fl_mag = hypotf(fl_re, fl_im);

  1069.         float fr_mag = hypotf(fr_re, fr_im);

  1070.         float fl_phase = atan2f(fl_im, fl_re);

  1071.         float fr_phase = atan2f(fr_im, fr_re);

  1072.         float sl_mag = hypotf(sl_re, sl_im);

  1073.         float sr_mag = hypotf(sr_re, sr_im);

  1074.         float sl_phase = atan2f(sl_im, sl_re);

  1075.         float sr_phase = atan2f(sr_im, sr_re);

  1076.         float phase_difl = fabsf(fl_phase - sl_phase);

  1077.         float phase_difr = fabsf(fr_phase - sr_phase);

  1078.         float mag_difl = (fl_mag - sl_mag) / (fl_mag + sl_mag);

  1079.         float mag_difr = (fr_mag - sr_mag) / (fr_mag + sr_mag);

  1080.         float mag_totall = hypotf(fl_mag, sl_mag);

  1081.         float mag_totalr = hypotf(fr_mag, sr_mag);

  1082.         float bl_phase = atan2f(fl_im + sl_im, fl_re + sl_re);

  1083.         float br_phase = atan2f(fr_im + sr_im, fr_re + sr_re);

  1084.         float xl, yl;

  1085.         float xr, yr;

  1086. 

  1087.         if (phase_difl > M_PI)

  1088.             phase_difl = 2 * M_PI - phase_difl;

  1089. 

  1090.         if (phase_difr > M_PI)

  1091.             phase_difr = 2 * M_PI - phase_difr;

  1092. 

  1093.         stereo_position(mag_difl, phase_difl, &xl, &yl);

  1094.         stereo_position(mag_difr, phase_difr, &xr, &yr);

  1095. 

  1096.         s->upmix_5_1(ctx, c_re, c_im, lfe_re, lfe_im,

  1097.                      mag_totall, mag_totalr,

  1098.                      fl_phase, fr_phase,

  1099.                      bl_phase, br_phase,

  1100.                      sl_phase, sr_phase,

  1101.                      xl, yl, xr, yr, n);

  1102.     }

  1103. }

  1104. 

  1105. static void filter_5_1_back(AVFilterContext *ctx)

  1106. {

  1107.     AudioSurroundContext *s = ctx->priv;

  1108.     float *srcl, *srcr, *srcc, *srclfe, *srcbl, *srcbr;

  1109.     int n;

  1110. 

  1111.     srcl = (float *)s->input->extended_data[0];

  1112.     srcr = (float *)s->input->extended_data[1];

  1113.     srcc = (float *)s->input->extended_data[2];

  1114.     srclfe = (float *)s->input->extended_data[3];

  1115.     srcbl = (float *)s->input->extended_data[4];

  1116.     srcbr = (float *)s->input->extended_data[5];

  1117. 

  1118.     for (n = 0; n < s->buf_size; n++) {

  1119.         float fl_re = srcl[2 * n], fr_re = srcr[2 * n];

  1120.         float fl_im = srcl[2 * n + 1], fr_im = srcr[2 * n + 1];

  1121.         float c_re = srcc[2 * n], c_im = srcc[2 * n + 1];

  1122.         float lfe_re = srclfe[2 * n], lfe_im = srclfe[2 * n + 1];

  1123.         float bl_re = srcbl[2 * n], bl_im = srcbl[2 * n + 1];

  1124.         float br_re = srcbr[2 * n], br_im = srcbr[2 * n + 1];

  1125.         float fl_mag = hypotf(fl_re, fl_im);

  1126.         float fr_mag = hypotf(fr_re, fr_im);

  1127.         float fl_phase = atan2f(fl_im, fl_re);

  1128.         float fr_phase = atan2f(fr_im, fr_re);

  1129.         float bl_mag = hypotf(bl_re, bl_im);

  1130.         float br_mag = hypotf(br_re, br_im);

  1131.         float bl_phase = atan2f(bl_im, bl_re);

  1132.         float br_phase = atan2f(br_im, br_re);

  1133.         float phase_difl = fabsf(fl_phase - bl_phase);

  1134.         float phase_difr = fabsf(fr_phase - br_phase);

  1135.         float mag_difl = (fl_mag - bl_mag) / (fl_mag + bl_mag);

  1136.         float mag_difr = (fr_mag - br_mag) / (fr_mag + br_mag);

  1137.         float mag_totall = hypotf(fl_mag, bl_mag);

  1138.         float mag_totalr = hypotf(fr_mag, br_mag);

  1139.         float sl_phase = atan2f(fl_im + bl_im, fl_re + bl_re);

  1140.         float sr_phase = atan2f(fr_im + br_im, fr_re + br_re);

  1141.         float xl, yl;

  1142.         float xr, yr;

  1143. 

  1144.         if (phase_difl > M_PI)

  1145.             phase_difl = 2 * M_PI - phase_difl;

  1146. 

  1147.         if (phase_difr > M_PI)

  1148.             phase_difr = 2 * M_PI - phase_difr;

  1149. 

  1150.         stereo_position(mag_difl, phase_difl, &xl, &yl);

  1151.         stereo_position(mag_difr, phase_difr, &xr, &yr);

  1152. 

  1153.         s->upmix_5_1(ctx, c_re, c_im, lfe_re, lfe_im,

  1154.                      mag_totall, mag_totalr,

  1155.                      fl_phase, fr_phase,

  1156.                      bl_phase, br_phase,

  1157.                      sl_phase, sr_phase,

  1158.                      xl, yl, xr, yr, n);

  1159.     }

  1160. }

  1161. 

  1162. static int init(AVFilterContext *ctx)

  1163. {

  1164.     AudioSurroundContext *s = ctx->priv;

  1165.     float overlap;

  1166.     int i;

  1167. 

  1168.     if (!(s->out_channel_layout = av_get_channel_layout(s->out_channel_layout_str))) {

  1169.         av_log(ctx, AV_LOG_ERROR, "Error parsing output channel layout '%s'.\n",

  1170.                s->out_channel_layout_str);

  1171.         return AVERROR(EINVAL);

  1172.     }

  1173. 

  1174.     if (!(s->in_channel_layout = av_get_channel_layout(s->in_channel_layout_str))) {

  1175.         av_log(ctx, AV_LOG_ERROR, "Error parsing input channel layout '%s'.\n",

  1176.                s->in_channel_layout_str);

  1177.         return AVERROR(EINVAL);

  1178.     }

  1179. 

  1180.     if (s->lowcutf >= s->highcutf) {

  1181.         av_log(ctx, AV_LOG_ERROR, "Low cut-off '%d' should be less than high cut-off '%d'.\n",

  1182.                s->lowcutf, s->highcutf);

  1183.         return AVERROR(EINVAL);

  1184.     }

  1185. 

  1186.     switch (s->in_channel_layout) {

  1187.     case AV_CH_LAYOUT_STEREO:

  1188.         s->filter = filter_stereo;

  1189.         switch (s->out_channel_layout) {

  1190.         case AV_CH_LAYOUT_MONO:

  1191.             s->upmix_stereo = upmix_1_0;

  1192.             break;

  1193.         case AV_CH_LAYOUT_STEREO:

  1194.             s->upmix_stereo = upmix_stereo;

  1195.             break;

  1196.         case AV_CH_LAYOUT_2POINT1:

  1197.             s->upmix_stereo = upmix_2_1;

  1198.             break;

  1199.         case AV_CH_LAYOUT_SURROUND:

  1200.             s->upmix_stereo = upmix_3_0;

  1201.             break;

  1202.         case AV_CH_LAYOUT_3POINT1:

  1203.             s->upmix_stereo = upmix_3_1;

  1204.             break;

  1205.         case AV_CH_LAYOUT_4POINT0:

  1206.             s->upmix_stereo = upmix_4_0;

  1207.             break;

  1208.         case AV_CH_LAYOUT_4POINT1:

  1209.             s->upmix_stereo = upmix_4_1;

  1210.             break;

  1211.         case AV_CH_LAYOUT_5POINT0_BACK:

  1212.             s->upmix_stereo = upmix_5_0_back;

  1213.             break;

  1214.         case AV_CH_LAYOUT_5POINT1_BACK:

  1215.             s->upmix_stereo = upmix_5_1_back;

  1216.             break;

  1217.         case AV_CH_LAYOUT_7POINT0:

  1218.             s->upmix_stereo = upmix_7_0;

  1219.             break;

  1220.         case AV_CH_LAYOUT_7POINT1:

  1221.             s->upmix_stereo = upmix_7_1;

  1222.             break;

  1223.         default:

  1224.             goto fail;

  1225.         }

  1226.         break;

  1227.     case AV_CH_LAYOUT_2POINT1:

  1228.         s->filter = filter_2_1;

  1229.         switch (s->out_channel_layout) {

  1230.         case AV_CH_LAYOUT_5POINT1_BACK:

  1231.             s->upmix_2_1 = upmix_5_1_back_2_1;

  1232.             break;

  1233.         default:

  1234.             goto fail;

  1235.         }

  1236.         break;

  1237.     case AV_CH_LAYOUT_SURROUND:

  1238.         s->filter = filter_surround;

  1239.         switch (s->out_channel_layout) {

  1240.         case AV_CH_LAYOUT_3POINT1:

  1241.             s->upmix_3_0 = upmix_3_1_surround;

  1242.             break;

  1243.         case AV_CH_LAYOUT_5POINT1_BACK:

  1244.             s->upmix_3_0 = upmix_5_1_back_surround;

  1245.             break;

  1246.         default:

  1247.             goto fail;

  1248.         }

  1249.         break;

  1250.     case AV_CH_LAYOUT_5POINT0:

  1251.         s->filter = filter_5_0_side;

  1252.         switch (s->out_channel_layout) {

  1253.         case AV_CH_LAYOUT_7POINT1:

  1254.             s->upmix_5_0 = upmix_7_1_5_0_side;

  1255.             break;

  1256.         default:

  1257.             goto fail;

  1258.         }

  1259.         break;

  1260.     case AV_CH_LAYOUT_5POINT1:

  1261.         s->filter = filter_5_1_side;

  1262.         switch (s->out_channel_layout) {

  1263.         case AV_CH_LAYOUT_7POINT1:

  1264.             s->upmix_5_1 = upmix_7_1_5_1;

  1265.             break;

  1266.         default:

  1267.             goto fail;

  1268.         }

  1269.         break;

  1270.     case AV_CH_LAYOUT_5POINT1_BACK:

  1271.         s->filter = filter_5_1_back;

  1272.         switch (s->out_channel_layout) {

  1273.         case AV_CH_LAYOUT_7POINT1:

  1274.             s->upmix_5_1 = upmix_7_1_5_1;

  1275.             break;

  1276.         default:

  1277.             goto fail;

  1278.         }

  1279.         break;

  1280.     default:

  1281. fail:

  1282.         av_log(ctx, AV_LOG_ERROR, "Unsupported upmix: '%s' -> '%s'.\n",

  1283.                s->in_channel_layout_str, s->out_channel_layout_str);

  1284.         return AVERROR(EINVAL);

  1285.     }

  1286. 

  1287.     s->buf_size = 4096;

  1288.     s->pts = AV_NOPTS_VALUE;

  1289. 

  1290.     s->window_func_lut = av_calloc(s->buf_size, sizeof(*s->window_func_lut));

  1291.     if (!s->window_func_lut)

  1292.         return AVERROR(ENOMEM);

  1293. 

  1294.     generate_window_func(s->window_func_lut, s->buf_size, s->win_func, &overlap);

  1295.     if (s->overlap == 1)

  1296.         s->overlap = overlap;

  1297. 

  1298.     for (i = 0; i < s->buf_size; i++)

  1299.         s->window_func_lut[i] = sqrtf(s->window_func_lut[i] / s->buf_size);

  1300.     s->hop_size = s->buf_size * (1. - s->overlap);

  1301.     if (s->hop_size <= 0)

  1302.         return AVERROR(EINVAL);

  1303. 

  1304.     return 0;

  1305. }

  1306. 

  1307. static int fft_channel(AVFilterContext *ctx, void *arg, int ch, int nb_jobs)

  1308. {

  1309.     AudioSurroundContext *s = ctx->priv;

  1310.     const float level_in = s->input_levels[ch];

  1311.     float *dst;

  1312.     int n;

  1313. 

  1314.     memset(s->input->extended_data[ch] + s->buf_size * sizeof(float), 0, s->buf_size * sizeof(float));

  1315. 

  1316.     dst = (float *)s->input->extended_data[ch];

  1317.     for (n = 0; n < s->buf_size; n++) {

  1318.         dst[n] *= s->window_func_lut[n] * level_in;

  1319.     }

  1320. 

  1321.     av_rdft_calc(s->rdft[ch], (float *)s->input->extended_data[ch]);

  1322. 

  1323.     return 0;

  1324. }

  1325. 

  1326. static int ifft_channel(AVFilterContext *ctx, void *arg, int ch, int nb_jobs)

  1327. {

  1328.     AudioSurroundContext *s = ctx->priv;

  1329.     const float level_out = s->output_levels[ch];

  1330.     AVFrame *out = arg;

  1331.     float *dst, *ptr;

  1332.     int n;

  1333. 

  1334.     av_rdft_calc(s->irdft[ch], (float *)s->output->extended_data[ch]);

  1335. 

  1336.     dst = (float *)s->output->extended_data[ch];

  1337.     ptr = (float *)s->overlap_buffer->extended_data[ch];

  1338. 

  1339.     memmove(s->overlap_buffer->extended_data[ch],

  1340.             s->overlap_buffer->extended_data[ch] + s->hop_size * sizeof(float),

  1341.             s->buf_size * sizeof(float));

  1342.     memset(s->overlap_buffer->extended_data[ch] + s->buf_size * sizeof(float),

  1343.            0, s->hop_size * sizeof(float));

  1344. 

  1345.     for (n = 0; n < s->buf_size; n++) {

  1346.         ptr[n] += dst[n] * s->window_func_lut[n] * level_out;

  1347.     }

  1348. 

  1349.     ptr = (float *)s->overlap_buffer->extended_data[ch];

  1350.     dst = (float *)out->extended_data[ch];

  1351.     memcpy(dst, ptr, s->hop_size * sizeof(float));

  1352. 

  1353.     return 0;

  1354. }

  1355. 

  1356. static int filter_frame(AVFilterLink *inlink, AVFrame *in)

  1357. {

  1358.     AVFilterContext *ctx = inlink->dst;

  1359.     AVFilterLink *outlink = ctx->outputs[0];

  1360.     AudioSurroundContext *s = ctx->priv;

  1361.     int ret;

  1362. 

  1363.     ret = av_audio_fifo_write(s->fifo, (void **)in->extended_data,

  1364.                               in->nb_samples);

  1365.     if (ret >= 0 && s->pts == AV_NOPTS_VALUE)

  1366.         s->pts = in->pts;

  1367. 

  1368.     av_frame_free(&in);

  1369.     if (ret < 0)

  1370.         return ret;

  1371. 

  1372.     while (av_audio_fifo_size(s->fifo) >= s->buf_size) {

  1373.         AVFrame *out;

  1374. 

  1375.         ret = av_audio_fifo_peek(s->fifo, (void **)s->input->extended_data, s->buf_size);

  1376.         if (ret < 0)

  1377.             return ret;

  1378. 

  1379.         ctx->internal->execute(ctx, fft_channel, NULL, NULL, inlink->channels);

  1380. 

  1381.         s->filter(ctx);

  1382. 

  1383.         out = ff_get_audio_buffer(outlink, s->hop_size);

  1384.         if (!out)

  1385.             return AVERROR(ENOMEM);

  1386. 

  1387.         ctx->internal->execute(ctx, ifft_channel, out, NULL, outlink->channels);

  1388. 

  1389.         out->pts = s->pts;

  1390.         if (s->pts != AV_NOPTS_VALUE)

  1391.             s->pts += av_rescale_q(out->nb_samples, (AVRational){1, outlink->sample_rate}, outlink->time_base);

  1392.         av_audio_fifo_drain(s->fifo, s->hop_size);

  1393.         ret = ff_filter_frame(outlink, out);

  1394.         if (ret < 0)

  1395.             return ret;

  1396.     }

  1397. 

  1398.     return 0;

  1399. }

  1400. 

  1401. static int request_frame(AVFilterLink *outlink)

  1402. {

  1403.     AVFilterContext *ctx = outlink->src;

  1404.     AudioSurroundContext *s = ctx->priv;

  1405.     int ret = 0;

  1406. 

  1407.     ret = ff_request_frame(ctx->inputs[0]);

  1408. 

  1409.     if (ret == AVERROR_EOF && av_audio_fifo_size(s->fifo) > 0 && av_audio_fifo_size(s->fifo) < s->buf_size) {

  1410.         AVFrame *in;

  1411. 

  1412.         in = ff_get_audio_buffer(outlink, s->buf_size - av_audio_fifo_size(s->fifo));

  1413.         if (!in)

  1414.             return AVERROR(ENOMEM);

  1415.         ret = filter_frame(ctx->inputs[0], in);

  1416.         av_audio_fifo_drain(s->fifo, s->buf_size);

  1417.     }

  1418. 

  1419.     return ret;

  1420. }

  1421. 

  1422. static av_cold void uninit(AVFilterContext *ctx)

  1423. {

  1424.     AudioSurroundContext *s = ctx->priv;

  1425.     int ch;

  1426. 

  1427.     av_frame_free(&s->input);

  1428.     av_frame_free(&s->output);

  1429.     av_frame_free(&s->overlap_buffer);

  1430. 

  1431.     for (ch = 0; ch < s->nb_in_channels; ch++) {

  1432.         av_rdft_end(s->rdft[ch]);

  1433.     }

  1434.     for (ch = 0; ch < s->nb_out_channels; ch++) {

  1435.         av_rdft_end(s->irdft[ch]);

  1436.     }

  1437.     av_freep(&s->input_levels);

  1438.     av_freep(&s->output_levels);

  1439.     av_freep(&s->rdft);

  1440.     av_freep(&s->irdft);

  1441.     av_audio_fifo_free(s->fifo);

  1442.     av_freep(&s->window_func_lut);

  1443. }

  1444. 

  1445. #define OFFSET(x) offsetof(AudioSurroundContext, x)

  1446. #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM

  1447. 

  1448. static const AVOption surround_options[] = {

  1449.     { "chl_out",   "set output channel layout", OFFSET(out_channel_layout_str), AV_OPT_TYPE_STRING, {.str="5.1"}, 0,   0, FLAGS },

  1450.     { "chl_in",    "set input channel layout",  OFFSET(in_channel_layout_str),  AV_OPT_TYPE_STRING, {.str="stereo"},0, 0, FLAGS },

  1451.     { "level_in",  "set input level",           OFFSET(level_in),               AV_OPT_TYPE_FLOAT,  {.dbl=1},     0,  10, FLAGS },

  1452.     { "level_out", "set output level",          OFFSET(level_out),              AV_OPT_TYPE_FLOAT,  {.dbl=1},     0,  10, FLAGS },

  1453.     { "lfe",       "output LFE",                OFFSET(output_lfe),             AV_OPT_TYPE_BOOL,   {.i64=1},     0,   1, FLAGS },

  1454.     { "lfe_low",   "LFE low cut off",           OFFSET(lowcutf),                AV_OPT_TYPE_INT,    {.i64=128},   0, 256, FLAGS },

  1455.     { "lfe_high",  "LFE high cut off",          OFFSET(highcutf),               AV_OPT_TYPE_INT,    {.i64=256},   0, 512, FLAGS },

  1456.     { "fc_in",     "set front center channel input level",  OFFSET(fc_in),      AV_OPT_TYPE_FLOAT,  {.dbl=1},     0,  10, FLAGS },

  1457.     { "fc_out",    "set front center channel output level", OFFSET(fc_out),     AV_OPT_TYPE_FLOAT,  {.dbl=1},     0,  10, FLAGS },

  1458.     { "lfe_in",    "set lfe channel input level",  OFFSET(lfe_in),              AV_OPT_TYPE_FLOAT,  {.dbl=1},     0,  10, FLAGS },

  1459.     { "lfe_out",   "set lfe channel output level", OFFSET(lfe_out),             AV_OPT_TYPE_FLOAT,  {.dbl=1},     0,  10, FLAGS },

  1460.     { "win_func", "set window function", OFFSET(win_func), AV_OPT_TYPE_INT, {.i64 = WFUNC_HANNING}, 0, NB_WFUNC-1, FLAGS, "win_func" },

  1461.         { "rect",     "Rectangular",      0, AV_OPT_TYPE_CONST, {.i64=WFUNC_RECT},     0, 0, FLAGS, "win_func" },

  1462.         { "bartlett", "Bartlett",         0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BARTLETT}, 0, 0, FLAGS, "win_func" },

  1463.         { "hann",     "Hann",             0, AV_OPT_TYPE_CONST, {.i64=WFUNC_HANNING},  0, 0, FLAGS, "win_func" },

  1464.         { "hanning",  "Hanning",          0, AV_OPT_TYPE_CONST, {.i64=WFUNC_HANNING},  0, 0, FLAGS, "win_func" },

  1465.         { "hamming",  "Hamming",          0, AV_OPT_TYPE_CONST, {.i64=WFUNC_HAMMING},  0, 0, FLAGS, "win_func" },

  1466.         { "blackman", "Blackman",         0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BLACKMAN}, 0, 0, FLAGS, "win_func" },

  1467.         { "welch",    "Welch",            0, AV_OPT_TYPE_CONST, {.i64=WFUNC_WELCH},    0, 0, FLAGS, "win_func" },

  1468.         { "flattop",  "Flat-top",         0, AV_OPT_TYPE_CONST, {.i64=WFUNC_FLATTOP},  0, 0, FLAGS, "win_func" },

  1469.         { "bharris",  "Blackman-Harris",  0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BHARRIS},  0, 0, FLAGS, "win_func" },

  1470.         { "bnuttall", "Blackman-Nuttall", 0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BNUTTALL}, 0, 0, FLAGS, "win_func" },

  1471.         { "bhann",    "Bartlett-Hann",    0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BHANN},    0, 0, FLAGS, "win_func" },

  1472.         { "sine",     "Sine",             0, AV_OPT_TYPE_CONST, {.i64=WFUNC_SINE},     0, 0, FLAGS, "win_func" },

  1473.         { "nuttall",  "Nuttall",          0, AV_OPT_TYPE_CONST, {.i64=WFUNC_NUTTALL},  0, 0, FLAGS, "win_func" },

  1474.         { "lanczos",  "Lanczos",          0, AV_OPT_TYPE_CONST, {.i64=WFUNC_LANCZOS},  0, 0, FLAGS, "win_func" },

  1475.         { "gauss",    "Gauss",            0, AV_OPT_TYPE_CONST, {.i64=WFUNC_GAUSS},    0, 0, FLAGS, "win_func" },

  1476.         { "tukey",    "Tukey",            0, AV_OPT_TYPE_CONST, {.i64=WFUNC_TUKEY},    0, 0, FLAGS, "win_func" },

  1477.         { "dolph",    "Dolph-Chebyshev",  0, AV_OPT_TYPE_CONST, {.i64=WFUNC_DOLPH},    0, 0, FLAGS, "win_func" },

  1478.         { "cauchy",   "Cauchy",           0, AV_OPT_TYPE_CONST, {.i64=WFUNC_CAUCHY},   0, 0, FLAGS, "win_func" },

  1479.         { "parzen",   "Parzen",           0, AV_OPT_TYPE_CONST, {.i64=WFUNC_PARZEN},   0, 0, FLAGS, "win_func" },

  1480.         { "poisson",  "Poisson",          0, AV_OPT_TYPE_CONST, {.i64=WFUNC_POISSON},  0, 0, FLAGS, "win_func" },

  1481.         { "bohman",   "Bohman",           0, AV_OPT_TYPE_CONST, {.i64=WFUNC_BOHMAN},   0, 0, FLAGS, "win_func" },

  1482.     { "overlap", "set window overlap", OFFSET(overlap), AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0, 1, FLAGS },

  1483.     { NULL }

  1484. };

  1485. 

  1486. AVFILTER_DEFINE_CLASS(surround);

  1487. 

  1488. static const AVFilterPad inputs[] = {

  1489.     {

  1490.         .name         = "default",

  1491.         .type         = AVMEDIA_TYPE_AUDIO,

  1492.         .filter_frame = filter_frame,

  1493.         .config_props = config_input,

  1494.     },

  1495.     { NULL }

  1496. };

  1497. 

  1498. static const AVFilterPad outputs[] = {

  1499.     {

  1500.         .name          = "default",

  1501.         .type          = AVMEDIA_TYPE_AUDIO,

  1502.         .request_frame = request_frame,

  1503.         .config_props  = config_output,

  1504.     },

  1505.     { NULL }

  1506. };

  1507. 

  1508. AVFilter ff_af_surround = {

  1509.     .name           = "surround",

  1510.     .description    = NULL_IF_CONFIG_SMALL("Apply audio surround upmix filter."),

  1511.     .query_formats  = query_formats,

  1512.     .priv_size      = sizeof(AudioSurroundContext),

  1513.     .priv_class     = &surround_class,

  1514.     .init           = init,

  1515.     .uninit         = uninit,

  1516.     .inputs         = inputs,

  1517.     .outputs        = outputs,

  1518.     .flags          = AVFILTER_FLAG_SLICE_THREADS,

  1519. };