GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/sbrdsp.c Lines: 99 99 100.0 %
Date: 2020-09-25 23:16:12 Branches: 20 20 100.0 %

Line Branch Exec Source
1
/*
2
 * AAC Spectral Band Replication decoding functions
3
 * Copyright (c) 2008-2009 Robert Swain ( rob opendot cl )
4
 * Copyright (c) 2009-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
#define USE_FIXED 0
24
25
#include "aac.h"
26
#include "config.h"
27
#include "libavutil/attributes.h"
28
#include "libavutil/intfloat.h"
29
#include "sbrdsp.h"
30
31
251188
static float sbr_sum_square_c(float (*x)[2], int n)
32
{
33
251188
    float sum0 = 0.0f, sum1 = 0.0f;
34
    int i;
35
36
3003652
    for (i = 0; i < n; i += 2)
37
    {
38
2752464
        sum0 += x[i + 0][0] * x[i + 0][0];
39
2752464
        sum1 += x[i + 0][1] * x[i + 0][1];
40
2752464
        sum0 += x[i + 1][0] * x[i + 1][0];
41
2752464
        sum1 += x[i + 1][1] * x[i + 1][1];
42
    }
43
44
251188
    return sum0 + sum1;
45
}
46
47
355459
static void sbr_neg_odd_64_c(float *x)
48
{
49
355459
    union av_intfloat32 *xi = (union av_intfloat32*) x;
50
    int i;
51
6042803
    for (i = 1; i < 64; i += 4) {
52
5687344
        xi[i + 0].i ^= 1U << 31;
53
5687344
        xi[i + 2].i ^= 1U << 31;
54
    }
55
355459
}
56
57
365091
static void sbr_qmf_pre_shuffle_c(float *z)
58
{
59
365091
    union av_intfloat32 *zi = (union av_intfloat32*) z;
60
    int k;
61
365091
    zi[64].i = zi[0].i;
62
365091
    zi[65].i = zi[1].i;
63
5841456
    for (k = 1; k < 31; k += 2) {
64
5476365
        zi[64 + 2 * k + 0].i = zi[64 - k].i ^ (1U << 31);
65
5476365
        zi[64 + 2 * k + 1].i = zi[ k + 1].i;
66
5476365
        zi[64 + 2 * k + 2].i = zi[63 - k].i ^ (1U << 31);
67
5476365
        zi[64 + 2 * k + 3].i = zi[ k + 2].i;
68
    }
69
70
365091
    zi[64 + 2 * 31 + 0].i = zi[64 - 31].i ^ (1U << 31);
71
365091
    zi[64 + 2 * 31 + 1].i = zi[31 +  1].i;
72
365091
}
73
74
365091
static void sbr_qmf_post_shuffle_c(float W[32][2], const float *z)
75
{
76
365091
    const union av_intfloat32 *zi = (const union av_intfloat32*) z;
77
365091
    union av_intfloat32 *Wi       = (union av_intfloat32*) W;
78
    int k;
79
6206547
    for (k = 0; k < 32; k += 2) {
80
5841456
        Wi[2 * k + 0].i = zi[63 - k].i ^ (1U << 31);
81
5841456
        Wi[2 * k + 1].i = zi[ k + 0].i;
82
5841456
        Wi[2 * k + 2].i = zi[62 - k].i ^ (1U << 31);
83
5841456
        Wi[2 * k + 3].i = zi[ k + 1].i;
84
    }
85
365091
}
86
87
73603
static void sbr_qmf_deint_neg_c(float *v, const float *src)
88
{
89
73603
    const union av_intfloat32 *si = (const union av_intfloat32*)src;
90
73603
    union av_intfloat32 *vi = (union av_intfloat32*)v;
91
    int i;
92
2428899
    for (i = 0; i < 32; i++) {
93
2355296
        vi[     i].i = si[63 - 2 * i    ].i;
94
2355296
        vi[63 - i].i = si[63 - 2 * i - 1].i ^ (1U << 31);
95
    }
96
73603
}
97
98
#if 0
99
    /* This code is slower because it multiplies memory accesses.
100
     * It is left for educational purposes and because it may offer
101
     * a better reference for writing arch-specific DSP functions. */
102
static av_always_inline void autocorrelate(const float x[40][2],
103
                                           float phi[3][2][2], int lag)
104
{
105
    int i;
106
    float real_sum = 0.0f;
107
    float imag_sum = 0.0f;
108
    if (lag) {
109
        for (i = 1; i < 38; i++) {
110
            real_sum += x[i][0] * x[i+lag][0] + x[i][1] * x[i+lag][1];
111
            imag_sum += x[i][0] * x[i+lag][1] - x[i][1] * x[i+lag][0];
112
        }
113
        phi[2-lag][1][0] = real_sum + x[ 0][0] * x[lag][0] + x[ 0][1] * x[lag][1];
114
        phi[2-lag][1][1] = imag_sum + x[ 0][0] * x[lag][1] - x[ 0][1] * x[lag][0];
115
        if (lag == 1) {
116
            phi[0][0][0] = real_sum + x[38][0] * x[39][0] + x[38][1] * x[39][1];
117
            phi[0][0][1] = imag_sum + x[38][0] * x[39][1] - x[38][1] * x[39][0];
118
        }
119
    } else {
120
        for (i = 1; i < 38; i++) {
121
            real_sum += x[i][0] * x[i][0] + x[i][1] * x[i][1];
122
        }
123
        phi[2][1][0] = real_sum + x[ 0][0] * x[ 0][0] + x[ 0][1] * x[ 0][1];
124
        phi[1][0][0] = real_sum + x[38][0] * x[38][0] + x[38][1] * x[38][1];
125
    }
126
}
127
128
static void sbr_autocorrelate_c(const float x[40][2], float phi[3][2][2])
129
{
130
    autocorrelate(x, phi, 0);
131
    autocorrelate(x, phi, 1);
132
    autocorrelate(x, phi, 2);
133
}
134
#else
135
124327
static void sbr_autocorrelate_c(const float x[40][2], float phi[3][2][2])
136
{
137
124327
    float real_sum2 = x[0][0] * x[2][0] + x[0][1] * x[2][1];
138
124327
    float imag_sum2 = x[0][0] * x[2][1] - x[0][1] * x[2][0];
139
124327
    float real_sum1 = 0.0f, imag_sum1 = 0.0f, real_sum0 = 0.0f;
140
    int   i;
141
4724426
    for (i = 1; i < 38; i++) {
142
4600099
        real_sum0 += x[i][0] * x[i    ][0] + x[i][1] * x[i    ][1];
143
4600099
        real_sum1 += x[i][0] * x[i + 1][0] + x[i][1] * x[i + 1][1];
144
4600099
        imag_sum1 += x[i][0] * x[i + 1][1] - x[i][1] * x[i + 1][0];
145
4600099
        real_sum2 += x[i][0] * x[i + 2][0] + x[i][1] * x[i + 2][1];
146
4600099
        imag_sum2 += x[i][0] * x[i + 2][1] - x[i][1] * x[i + 2][0];
147
    }
148
124327
    phi[2 - 2][1][0] = real_sum2;
149
124327
    phi[2 - 2][1][1] = imag_sum2;
150
124327
    phi[2    ][1][0] = real_sum0 + x[ 0][0] * x[ 0][0] + x[ 0][1] * x[ 0][1];
151
124327
    phi[1    ][0][0] = real_sum0 + x[38][0] * x[38][0] + x[38][1] * x[38][1];
152
124327
    phi[2 - 1][1][0] = real_sum1 + x[ 0][0] * x[ 1][0] + x[ 0][1] * x[ 1][1];
153
124327
    phi[2 - 1][1][1] = imag_sum1 + x[ 0][0] * x[ 1][1] - x[ 0][1] * x[ 1][0];
154
124327
    phi[0    ][0][0] = real_sum1 + x[38][0] * x[39][0] + x[38][1] * x[39][1];
155
124327
    phi[0    ][0][1] = imag_sum1 + x[38][0] * x[39][1] - x[38][1] * x[39][0];
156
124327
}
157
#endif
158
159
172098
static void sbr_hf_gen_c(float (*X_high)[2], const float (*X_low)[2],
160
                         const float alpha0[2], const float alpha1[2],
161
                         float bw, int start, int end)
162
{
163
    float alpha[4];
164
    int i;
165
166
172098
    alpha[0] = alpha1[0] * bw * bw;
167
172098
    alpha[1] = alpha1[1] * bw * bw;
168
172098
    alpha[2] = alpha0[0] * bw;
169
172098
    alpha[3] = alpha0[1] * bw;
170
171
5685186
    for (i = start; i < end; i++) {
172
5513088
        X_high[i][0] =
173
5513088
            X_low[i - 2][0] * alpha[0] -
174
5513088
            X_low[i - 2][1] * alpha[1] +
175
5513088
            X_low[i - 1][0] * alpha[2] -
176
5513088
            X_low[i - 1][1] * alpha[3] +
177
5513088
            X_low[i][0];
178
5513088
        X_high[i][1] =
179
5513088
            X_low[i - 2][1] * alpha[0] +
180
5513088
            X_low[i - 2][0] * alpha[1] +
181
5513088
            X_low[i - 1][1] * alpha[2] +
182
5513088
            X_low[i - 1][0] * alpha[3] +
183
5513088
            X_low[i][1];
184
    }
185
172098
}
186
187
212195
static void sbr_hf_g_filt_c(float (*Y)[2], const float (*X_high)[40][2],
188
                            const float *g_filt, int m_max, intptr_t ixh)
189
{
190
    int m;
191
192
5716739
    for (m = 0; m < m_max; m++) {
193
5504544
        Y[m][0] = X_high[m][ixh][0] * g_filt[m];
194
5504544
        Y[m][1] = X_high[m][ixh][1] * g_filt[m];
195
    }
196
212195
}
197
198
209994
static av_always_inline void sbr_hf_apply_noise(float (*Y)[2],
199
                                                const float *s_m,
200
                                                const float *q_filt,
201
                                                int noise,
202
                                                float phi_sign0,
203
                                                float phi_sign1,
204
                                                int m_max)
205
{
206
    int m;
207
208
5659882
    for (m = 0; m < m_max; m++) {
209
5449888
        float y0 = Y[m][0];
210
5449888
        float y1 = Y[m][1];
211
5449888
        noise = (noise + 1) & 0x1ff;
212
5449888
        if (s_m[m]) {
213
39374
            y0 += s_m[m] * phi_sign0;
214
39374
            y1 += s_m[m] * phi_sign1;
215
        } else {
216
5410514
            y0 += q_filt[m] * ff_sbr_noise_table[noise][0];
217
5410514
            y1 += q_filt[m] * ff_sbr_noise_table[noise][1];
218
        }
219
5449888
        Y[m][0] = y0;
220
5449888
        Y[m][1] = y1;
221
5449888
        phi_sign1 = -phi_sign1;
222
    }
223
209994
}
224
225
#include "sbrdsp_template.c"