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.
86512 Commits
32 Branches
824MB
Tree: a23a56e77c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a23a56e77c'
${ noResults }
FFmpeg/libavfilter/af_surround.c

1229 lines
41KB
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. 

  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. };