aic: Fix slice size computation for widths multiples of 32 macroblocks
[ffmpeg.git] / 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 <math.h>
27 #include <stdint.h>
28
29 #if CONFIG_HARDCODED_TABLES
30 #define ps_tableinit()
31 #define TABLE_CONST const
32 #include "libavcodec/aacps_tables.h"
33 #else
34 #include "libavutil/common.h"
35 #include "libavutil/libm.h"
36 #include "libavutil/mathematics.h"
37 #include "libavutil/mem.h"
38 #define NR_ALLPASS_BANDS20 30
39 #define NR_ALLPASS_BANDS34 50
40 #define PS_AP_LINKS 3
41 #define TABLE_CONST
42 static float pd_re_smooth[8*8*8];
43 static float pd_im_smooth[8*8*8];
44 static float HA[46][8][4];
45 static float HB[46][8][4];
46 static DECLARE_ALIGNED(16, float, f20_0_8) [ 8][8][2];
47 static DECLARE_ALIGNED(16, float, f34_0_12)[12][8][2];
48 static DECLARE_ALIGNED(16, float, f34_1_8) [ 8][8][2];
49 static DECLARE_ALIGNED(16, float, f34_2_4) [ 4][8][2];
50 static TABLE_CONST DECLARE_ALIGNED(16, float, Q_fract_allpass)[2][50][3][2];
51 static DECLARE_ALIGNED(16, float, phi_fract)[2][50][2];
52
53 static const float g0_Q8[] = {
54     0.00746082949812f, 0.02270420949825f, 0.04546865930473f, 0.07266113929591f,
55     0.09885108575264f, 0.11793710567217f, 0.125f
56 };
57
58 static const float g0_Q12[] = {
59     0.04081179924692f, 0.03812810994926f, 0.05144908135699f, 0.06399831151592f,
60     0.07428313801106f, 0.08100347892914f, 0.08333333333333f
61 };
62
63 static const float g1_Q8[] = {
64     0.01565675600122f, 0.03752716391991f, 0.05417891378782f, 0.08417044116767f,
65     0.10307344158036f, 0.12222452249753f, 0.125f
66 };
67
68 static const float g2_Q4[] = {
69     -0.05908211155639f, -0.04871498374946f, 0.0f,   0.07778723915851f,
70      0.16486303567403f,  0.23279856662996f, 0.25f
71 };
72
73 static void make_filters_from_proto(float (*filter)[8][2], const float *proto, int bands)
74 {
75     int q, n;
76     for (q = 0; q < bands; q++) {
77         for (n = 0; n < 7; n++) {
78             double theta = 2 * M_PI * (q + 0.5) * (n - 6) / bands;
79             filter[q][n][0] = proto[n] *  cos(theta);
80             filter[q][n][1] = proto[n] * -sin(theta);
81         }
82     }
83 }
84
85 static void ps_tableinit(void)
86 {
87     static const float ipdopd_sin[] = { 0, M_SQRT1_2, 1,  M_SQRT1_2,  0, -M_SQRT1_2, -1, -M_SQRT1_2 };
88     static const float ipdopd_cos[] = { 1, M_SQRT1_2, 0, -M_SQRT1_2, -1, -M_SQRT1_2,  0,  M_SQRT1_2 };
89     int pd0, pd1, pd2;
90
91     static const float iid_par_dequant[] = {
92         //iid_par_dequant_default
93         0.05623413251903, 0.12589254117942, 0.19952623149689, 0.31622776601684,
94         0.44668359215096, 0.63095734448019, 0.79432823472428, 1,
95         1.25892541179417, 1.58489319246111, 2.23872113856834, 3.16227766016838,
96         5.01187233627272, 7.94328234724282, 17.7827941003892,
97         //iid_par_dequant_fine
98         0.00316227766017, 0.00562341325190, 0.01,             0.01778279410039,
99         0.03162277660168, 0.05623413251903, 0.07943282347243, 0.11220184543020,
100         0.15848931924611, 0.22387211385683, 0.31622776601684, 0.39810717055350,
101         0.50118723362727, 0.63095734448019, 0.79432823472428, 1,
102         1.25892541179417, 1.58489319246111, 1.99526231496888, 2.51188643150958,
103         3.16227766016838, 4.46683592150963, 6.30957344480193, 8.91250938133745,
104         12.5892541179417, 17.7827941003892, 31.6227766016838, 56.2341325190349,
105         100,              177.827941003892, 316.227766016837,
106     };
107     static const float icc_invq[] = {
108         1, 0.937,      0.84118,    0.60092,    0.36764,   0,      -0.589,    -1
109     };
110     static const float acos_icc_invq[] = {
111         0, 0.35685527, 0.57133466, 0.92614472, 1.1943263, M_PI/2, 2.2006171, M_PI
112     };
113     int iid, icc;
114
115     int k, m;
116     static const int8_t f_center_20[] = {
117         -3, -1, 1, 3, 5, 7, 10, 14, 18, 22,
118     };
119     static const int8_t f_center_34[] = {
120          2,  6, 10, 14, 18, 22, 26, 30,
121         34,-10, -6, -2, 51, 57, 15, 21,
122         27, 33, 39, 45, 54, 66, 78, 42,
123        102, 66, 78, 90,102,114,126, 90,
124     };
125     static const float fractional_delay_links[] = { 0.43f, 0.75f, 0.347f };
126     const float fractional_delay_gain = 0.39f;
127
128     for (pd0 = 0; pd0 < 8; pd0++) {
129         float pd0_re = ipdopd_cos[pd0];
130         float pd0_im = ipdopd_sin[pd0];
131         for (pd1 = 0; pd1 < 8; pd1++) {
132             float pd1_re = ipdopd_cos[pd1];
133             float pd1_im = ipdopd_sin[pd1];
134             for (pd2 = 0; pd2 < 8; pd2++) {
135                 float pd2_re = ipdopd_cos[pd2];
136                 float pd2_im = ipdopd_sin[pd2];
137                 float re_smooth = 0.25f * pd0_re + 0.5f * pd1_re + pd2_re;
138                 float im_smooth = 0.25f * pd0_im + 0.5f * pd1_im + pd2_im;
139                 float pd_mag = 1 / sqrt(im_smooth * im_smooth + re_smooth * re_smooth);
140                 pd_re_smooth[pd0*64+pd1*8+pd2] = re_smooth * pd_mag;
141                 pd_im_smooth[pd0*64+pd1*8+pd2] = im_smooth * pd_mag;
142             }
143         }
144     }
145
146     for (iid = 0; iid < 46; iid++) {
147         float c = iid_par_dequant[iid]; ///< Linear Inter-channel Intensity Difference
148         float c1 = (float)M_SQRT2 / sqrtf(1.0f + c*c);
149         float c2 = c * c1;
150         for (icc = 0; icc < 8; icc++) {
151             /*if (PS_BASELINE || ps->icc_mode < 3)*/ {
152                 float alpha = 0.5f * acos_icc_invq[icc];
153                 float beta  = alpha * (c1 - c2) * (float)M_SQRT1_2;
154                 HA[iid][icc][0] = c2 * cosf(beta + alpha);
155                 HA[iid][icc][1] = c1 * cosf(beta - alpha);
156                 HA[iid][icc][2] = c2 * sinf(beta + alpha);
157                 HA[iid][icc][3] = c1 * sinf(beta - alpha);
158             } /* else */ {
159                 float alpha, gamma, mu, rho;
160                 float alpha_c, alpha_s, gamma_c, gamma_s;
161                 rho = FFMAX(icc_invq[icc], 0.05f);
162                 alpha = 0.5f * atan2f(2.0f * c * rho, c*c - 1.0f);
163                 mu = c + 1.0f / c;
164                 mu = sqrtf(1 + (4 * rho * rho - 4)/(mu * mu));
165                 gamma = atanf(sqrtf((1.0f - mu)/(1.0f + mu)));
166                 if (alpha < 0) alpha += M_PI/2;
167                 alpha_c = cosf(alpha);
168                 alpha_s = sinf(alpha);
169                 gamma_c = cosf(gamma);
170                 gamma_s = sinf(gamma);
171                 HB[iid][icc][0] =  M_SQRT2 * alpha_c * gamma_c;
172                 HB[iid][icc][1] =  M_SQRT2 * alpha_s * gamma_c;
173                 HB[iid][icc][2] = -M_SQRT2 * alpha_s * gamma_s;
174                 HB[iid][icc][3] =  M_SQRT2 * alpha_c * gamma_s;
175             }
176         }
177     }
178
179     for (k = 0; k < NR_ALLPASS_BANDS20; k++) {
180         double f_center, theta;
181         if (k < FF_ARRAY_ELEMS(f_center_20))
182             f_center = f_center_20[k] * 0.125;
183         else
184             f_center = k - 6.5f;
185         for (m = 0; m < PS_AP_LINKS; m++) {
186             theta = -M_PI * fractional_delay_links[m] * f_center;
187             Q_fract_allpass[0][k][m][0] = cos(theta);
188             Q_fract_allpass[0][k][m][1] = sin(theta);
189         }
190         theta = -M_PI*fractional_delay_gain*f_center;
191         phi_fract[0][k][0] = cos(theta);
192         phi_fract[0][k][1] = sin(theta);
193     }
194     for (k = 0; k < NR_ALLPASS_BANDS34; k++) {
195         double f_center, theta;
196         if (k < FF_ARRAY_ELEMS(f_center_34))
197             f_center = f_center_34[k] / 24.0;
198         else
199             f_center = k - 26.5f;
200         for (m = 0; m < PS_AP_LINKS; m++) {
201             theta = -M_PI * fractional_delay_links[m] * f_center;
202             Q_fract_allpass[1][k][m][0] = cos(theta);
203             Q_fract_allpass[1][k][m][1] = sin(theta);
204         }
205         theta = -M_PI*fractional_delay_gain*f_center;
206         phi_fract[1][k][0] = cos(theta);
207         phi_fract[1][k][1] = sin(theta);
208     }
209
210     make_filters_from_proto(f20_0_8,  g0_Q8,   8);
211     make_filters_from_proto(f34_0_12, g0_Q12, 12);
212     make_filters_from_proto(f34_1_8,  g1_Q8,   8);
213     make_filters_from_proto(f34_2_4,  g2_Q4,   4);
214 }
215 #endif /* CONFIG_HARDCODED_TABLES */
216
217 #endif /* AACPS_TABLEGEN_H */