git.sesse.net Git - ffmpeg/blob - libavcodec/aacps_tablegen.h

   1 /*
   2  * Header file for hardcoded Parametric Stereo tables
   3  *
   4  * Copyright (c) 2010 Alex Converse <alex.converse@gmail.com>
   5  *
   6  * This file is part of Libav.
   7  *
   8  * Libav is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * Libav is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with Libav; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 #ifndef AACPS_TABLEGEN_H
  24 #define AACPS_TABLEGEN_H
  25
  26 #include <stdint.h>
  27
  28 #if CONFIG_HARDCODED_TABLES
  29 #define ps_tableinit()
  30 #include "libavcodec/aacps_tables.h"
  31 #else
  32 #include "libavutil/common.h"
  33 #include "libavutil/mathematics.h"
  34 #include "libavutil/mem.h"
  35 #define NR_ALLPASS_BANDS20 30
  36 #define NR_ALLPASS_BANDS34 50
  37 #define PS_AP_LINKS 3
  38 static float pd_re_smooth[8*8*8];
  39 static float pd_im_smooth[8*8*8];
  40 static float HA[46][8][4];
  41 static float HB[46][8][4];
  42 static DECLARE_ALIGNED(16, float, f20_0_8) [ 8][8][2];
  43 static DECLARE_ALIGNED(16, float, f34_0_12)[12][8][2];
  44 static DECLARE_ALIGNED(16, float, f34_1_8) [ 8][8][2];
  45 static DECLARE_ALIGNED(16, float, f34_2_4) [ 4][8][2];
  46 static DECLARE_ALIGNED(16, float, Q_fract_allpass)[2][50][3][2];
  47 static DECLARE_ALIGNED(16, float, phi_fract)[2][50][2];
  48
  49 static const float g0_Q8[] = {
  50     0.00746082949812f, 0.02270420949825f, 0.04546865930473f, 0.07266113929591f,
  51     0.09885108575264f, 0.11793710567217f, 0.125f
  52 };
  53
  54 static const float g0_Q12[] = {
  55     0.04081179924692f, 0.03812810994926f, 0.05144908135699f, 0.06399831151592f,
  56     0.07428313801106f, 0.08100347892914f, 0.08333333333333f
  57 };
  58
  59 static const float g1_Q8[] = {
  60     0.01565675600122f, 0.03752716391991f, 0.05417891378782f, 0.08417044116767f,
  61     0.10307344158036f, 0.12222452249753f, 0.125f
  62 };
  63
  64 static const float g2_Q4[] = {
  65     -0.05908211155639f, -0.04871498374946f, 0.0f,   0.07778723915851f,
  66      0.16486303567403f,  0.23279856662996f, 0.25f
  67 };
  68
  69 static void make_filters_from_proto(float (*filter)[8][2], const float *proto, int bands)
  70 {
  71     int q, n;
  72     for (q = 0; q < bands; q++) {
  73         for (n = 0; n < 7; n++) {
  74             double theta = 2 * M_PI * (q + 0.5) * (n - 6) / bands;
  75             filter[q][n][0] = proto[n] *  cos(theta);
  76             filter[q][n][1] = proto[n] * -sin(theta);
  77         }
  78     }
  79 }
  80
  81 static void ps_tableinit(void)
  82 {
  83     static const float ipdopd_sin[] = { 0, M_SQRT1_2, 1,  M_SQRT1_2,  0, -M_SQRT1_2, -1, -M_SQRT1_2 };
  84     static const float ipdopd_cos[] = { 1, M_SQRT1_2, 0, -M_SQRT1_2, -1, -M_SQRT1_2,  0,  M_SQRT1_2 };
  85     int pd0, pd1, pd2;
  86
  87     static const float iid_par_dequant[] = {
  88         //iid_par_dequant_default
  89         0.05623413251903, 0.12589254117942, 0.19952623149689, 0.31622776601684,
  90         0.44668359215096, 0.63095734448019, 0.79432823472428, 1,
  91         1.25892541179417, 1.58489319246111, 2.23872113856834, 3.16227766016838,
  92         5.01187233627272, 7.94328234724282, 17.7827941003892,
  93         //iid_par_dequant_fine
  94         0.00316227766017, 0.00562341325190, 0.01,             0.01778279410039,
  95         0.03162277660168, 0.05623413251903, 0.07943282347243, 0.11220184543020,
  96         0.15848931924611, 0.22387211385683, 0.31622776601684, 0.39810717055350,
  97         0.50118723362727, 0.63095734448019, 0.79432823472428, 1,
  98         1.25892541179417, 1.58489319246111, 1.99526231496888, 2.51188643150958,
  99         3.16227766016838, 4.46683592150963, 6.30957344480193, 8.91250938133745,
 100         12.5892541179417, 17.7827941003892, 31.6227766016838, 56.2341325190349,
 101         100,              177.827941003892, 316.227766016837,
 102     };
 103     static const float icc_invq[] = {
 104         1, 0.937,      0.84118,    0.60092,    0.36764,   0,      -0.589,    -1
 105     };
 106     static const float acos_icc_invq[] = {
 107         0, 0.35685527, 0.57133466, 0.92614472, 1.1943263, M_PI/2, 2.2006171, M_PI
 108     };
 109     int iid, icc;
 110
 111     int k, m;
 112     static const int8_t f_center_20[] = {
 113         -3, -1, 1, 3, 5, 7, 10, 14, 18, 22,
 114     };
 115     static const int8_t f_center_34[] = {
 116          2,  6, 10, 14, 18, 22, 26, 30,
 117         34,-10, -6, -2, 51, 57, 15, 21,
 118         27, 33, 39, 45, 54, 66, 78, 42,
 119        102, 66, 78, 90,102,114,126, 90,
 120     };
 121     static const float fractional_delay_links[] = { 0.43f, 0.75f, 0.347f };
 122     const float fractional_delay_gain = 0.39f;
 123
 124     for (pd0 = 0; pd0 < 8; pd0++) {
 125         float pd0_re = ipdopd_cos[pd0];
 126         float pd0_im = ipdopd_sin[pd0];
 127         for (pd1 = 0; pd1 < 8; pd1++) {
 128             float pd1_re = ipdopd_cos[pd1];
 129             float pd1_im = ipdopd_sin[pd1];
 130             for (pd2 = 0; pd2 < 8; pd2++) {
 131                 float pd2_re = ipdopd_cos[pd2];
 132                 float pd2_im = ipdopd_sin[pd2];
 133                 float re_smooth = 0.25f * pd0_re + 0.5f * pd1_re + pd2_re;
 134                 float im_smooth = 0.25f * pd0_im + 0.5f * pd1_im + pd2_im;
 135                 float pd_mag = 1 / sqrt(im_smooth * im_smooth + re_smooth * re_smooth);
 136                 pd_re_smooth[pd0*64+pd1*8+pd2] = re_smooth * pd_mag;
 137                 pd_im_smooth[pd0*64+pd1*8+pd2] = im_smooth * pd_mag;
 138             }
 139         }
 140     }
 141
 142     for (iid = 0; iid < 46; iid++) {
 143         float c = iid_par_dequant[iid]; ///< Linear Inter-channel Intensity Difference
 144         float c1 = (float)M_SQRT2 / sqrtf(1.0f + c*c);
 145         float c2 = c * c1;
 146         for (icc = 0; icc < 8; icc++) {
 147             /*if (PS_BASELINE || ps->icc_mode < 3)*/ {
 148                 float alpha = 0.5f * acos_icc_invq[icc];
 149                 float beta  = alpha * (c1 - c2) * (float)M_SQRT1_2;
 150                 HA[iid][icc][0] = c2 * cosf(beta + alpha);
 151                 HA[iid][icc][1] = c1 * cosf(beta - alpha);
 152                 HA[iid][icc][2] = c2 * sinf(beta + alpha);
 153                 HA[iid][icc][3] = c1 * sinf(beta - alpha);
 154             } /* else */ {
 155                 float alpha, gamma, mu, rho;
 156                 float alpha_c, alpha_s, gamma_c, gamma_s;
 157                 rho = FFMAX(icc_invq[icc], 0.05f);
 158                 alpha = 0.5f * atan2f(2.0f * c * rho, c*c - 1.0f);
 159                 mu = c + 1.0f / c;
 160                 mu = sqrtf(1 + (4 * rho * rho - 4)/(mu * mu));
 161                 gamma = atanf(sqrtf((1.0f - mu)/(1.0f + mu)));
 162                 if (alpha < 0) alpha += M_PI/2;
 163                 alpha_c = cosf(alpha);
 164                 alpha_s = sinf(alpha);
 165                 gamma_c = cosf(gamma);
 166                 gamma_s = sinf(gamma);
 167                 HB[iid][icc][0] =  M_SQRT2 * alpha_c * gamma_c;
 168                 HB[iid][icc][1] =  M_SQRT2 * alpha_s * gamma_c;
 169                 HB[iid][icc][2] = -M_SQRT2 * alpha_s * gamma_s;
 170                 HB[iid][icc][3] =  M_SQRT2 * alpha_c * gamma_s;
 171             }
 172         }
 173     }
 174
 175     for (k = 0; k < NR_ALLPASS_BANDS20; k++) {
 176         double f_center, theta;
 177         if (k < FF_ARRAY_ELEMS(f_center_20))
 178             f_center = f_center_20[k] * 0.125;
 179         else
 180             f_center = k - 6.5f;
 181         for (m = 0; m < PS_AP_LINKS; m++) {
 182             theta = -M_PI * fractional_delay_links[m] * f_center;
 183             Q_fract_allpass[0][k][m][0] = cos(theta);
 184             Q_fract_allpass[0][k][m][1] = sin(theta);
 185         }
 186         theta = -M_PI*fractional_delay_gain*f_center;
 187         phi_fract[0][k][0] = cos(theta);
 188         phi_fract[0][k][1] = sin(theta);
 189     }
 190     for (k = 0; k < NR_ALLPASS_BANDS34; k++) {
 191         double f_center, theta;
 192         if (k < FF_ARRAY_ELEMS(f_center_34))
 193             f_center = f_center_34[k] / 24.;
 194         else
 195             f_center = k - 26.5f;
 196         for (m = 0; m < PS_AP_LINKS; m++) {
 197             theta = -M_PI * fractional_delay_links[m] * f_center;
 198             Q_fract_allpass[1][k][m][0] = cos(theta);
 199             Q_fract_allpass[1][k][m][1] = sin(theta);
 200         }
 201         theta = -M_PI*fractional_delay_gain*f_center;
 202         phi_fract[1][k][0] = cos(theta);
 203         phi_fract[1][k][1] = sin(theta);
 204     }
 205
 206     make_filters_from_proto(f20_0_8,  g0_Q8,   8);
 207     make_filters_from_proto(f34_0_12, g0_Q12, 12);
 208     make_filters_from_proto(f34_1_8,  g1_Q8,   8);
 209     make_filters_from_proto(f34_2_4,  g2_Q4,   4);
 210 }
 211 #endif /* CONFIG_HARDCODED_TABLES */
 212
 213 #endif /* AACPS_TABLEGEN_H */