GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/aacps_tablegen.h Lines: 75 75 100.0 %
Date: 2021-04-20 15:25:36 Branches: 29 30 96.7 %

Line Branch Exec Source
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 FFmpeg.
7
 *
8
 * FFmpeg 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
 * FFmpeg 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 FFmpeg; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
 */
22
23
#ifndef AVCODEC_AACPS_TABLEGEN_H
24
#define AVCODEC_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
604
static av_cold void make_filters_from_proto(float (*filter)[8][2], const float *proto, int bands)
74
{
75
    int q, n;
76
5436
    for (q = 0; q < bands; q++) {
77
38656
        for (n = 0; n < 7; n++) {
78
33824
            double theta = 2 * M_PI * (q + 0.5) * (n - 6) / bands;
79
33824
            filter[q][n][0] = proto[n] *  cos(theta);
80
33824
            filter[q][n][1] = proto[n] * -sin(theta);
81
        }
82
    }
83
604
}
84
85
151
static av_cold 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
151
    const float fractional_delay_gain = 0.39f;
127
128
1359
    for (pd0 = 0; pd0 < 8; pd0++) {
129
1208
        float pd0_re = ipdopd_cos[pd0];
130
1208
        float pd0_im = ipdopd_sin[pd0];
131
10872
        for (pd1 = 0; pd1 < 8; pd1++) {
132
9664
            float pd1_re = ipdopd_cos[pd1];
133
9664
            float pd1_im = ipdopd_sin[pd1];
134
86976
            for (pd2 = 0; pd2 < 8; pd2++) {
135
77312
                float pd2_re = ipdopd_cos[pd2];
136
77312
                float pd2_im = ipdopd_sin[pd2];
137
77312
                float re_smooth = 0.25f * pd0_re + 0.5f * pd1_re + pd2_re;
138
77312
                float im_smooth = 0.25f * pd0_im + 0.5f * pd1_im + pd2_im;
139
77312
                float pd_mag = 1 / hypot(im_smooth, re_smooth);
140
77312
                pd_re_smooth[pd0*64+pd1*8+pd2] = re_smooth * pd_mag;
141
77312
                pd_im_smooth[pd0*64+pd1*8+pd2] = im_smooth * pd_mag;
142
            }
143
        }
144
    }
145
146
7097
    for (iid = 0; iid < 46; iid++) {
147
6946
        float c = iid_par_dequant[iid]; ///< Linear Inter-channel Intensity Difference
148
6946
        float c1 = (float)M_SQRT2 / sqrtf(1.0f + c*c);
149
6946
        float c2 = c * c1;
150
62514
        for (icc = 0; icc < 8; icc++) {
151
            /*if (PS_BASELINE || ps->icc_mode < 3)*/ {
152
55568
                float alpha = 0.5f * acos_icc_invq[icc];
153
55568
                float beta  = alpha * (c1 - c2) * (float)M_SQRT1_2;
154
55568
                HA[iid][icc][0] = c2 * cosf(beta + alpha);
155
55568
                HA[iid][icc][1] = c1 * cosf(beta - alpha);
156
55568
                HA[iid][icc][2] = c2 * sinf(beta + alpha);
157
55568
                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
55568
                rho = FFMAX(icc_invq[icc], 0.05f);
162
55568
                alpha = 0.5f * atan2f(2.0f * c * rho, c*c - 1.0f);
163
55568
                mu = c + 1.0f / c;
164
55568
                mu = sqrtf(1 + (4 * rho * rho - 4)/(mu * mu));
165
55568
                gamma = atanf(sqrtf((1.0f - mu)/(1.0f + mu)));
166
55568
                if (alpha < 0) alpha += M_PI/2;
167
55568
                alpha_c = cosf(alpha);
168
55568
                alpha_s = sinf(alpha);
169
55568
                gamma_c = cosf(gamma);
170
55568
                gamma_s = sinf(gamma);
171
55568
                HB[iid][icc][0] =  M_SQRT2 * alpha_c * gamma_c;
172
55568
                HB[iid][icc][1] =  M_SQRT2 * alpha_s * gamma_c;
173
55568
                HB[iid][icc][2] = -M_SQRT2 * alpha_s * gamma_s;
174
55568
                HB[iid][icc][3] =  M_SQRT2 * alpha_c * gamma_s;
175
            }
176
        }
177
    }
178
179
4681
    for (k = 0; k < NR_ALLPASS_BANDS20; k++) {
180
        double f_center, theta;
181
4530
        if (k < FF_ARRAY_ELEMS(f_center_20))
182
1510
            f_center = f_center_20[k] * 0.125;
183
        else
184
3020
            f_center = k - 6.5f;
185
18120
        for (m = 0; m < PS_AP_LINKS; m++) {
186
13590
            theta = -M_PI * fractional_delay_links[m] * f_center;
187
13590
            Q_fract_allpass[0][k][m][0] = cos(theta);
188
13590
            Q_fract_allpass[0][k][m][1] = sin(theta);
189
        }
190
4530
        theta = -M_PI*fractional_delay_gain*f_center;
191
4530
        phi_fract[0][k][0] = cos(theta);
192
4530
        phi_fract[0][k][1] = sin(theta);
193
    }
194
7701
    for (k = 0; k < NR_ALLPASS_BANDS34; k++) {
195
        double f_center, theta;
196
7550
        if (k < FF_ARRAY_ELEMS(f_center_34))
197
4832
            f_center = f_center_34[k] / 24.0;
198
        else
199
2718
            f_center = k - 26.5f;
200
30200
        for (m = 0; m < PS_AP_LINKS; m++) {
201
22650
            theta = -M_PI * fractional_delay_links[m] * f_center;
202
22650
            Q_fract_allpass[1][k][m][0] = cos(theta);
203
22650
            Q_fract_allpass[1][k][m][1] = sin(theta);
204
        }
205
7550
        theta = -M_PI*fractional_delay_gain*f_center;
206
7550
        phi_fract[1][k][0] = cos(theta);
207
7550
        phi_fract[1][k][1] = sin(theta);
208
    }
209
210
151
    make_filters_from_proto(f20_0_8,  g0_Q8,   8);
211
151
    make_filters_from_proto(f34_0_12, g0_Q12, 12);
212
151
    make_filters_from_proto(f34_1_8,  g1_Q8,   8);
213
151
    make_filters_from_proto(f34_2_4,  g2_Q4,   4);
214
151
}
215
#endif /* CONFIG_HARDCODED_TABLES */
216
217
#endif /* AVCODEC_AACPS_TABLEGEN_H */