GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/aacsbr_fixed.c Lines: 272 292 93.2 %
Date: 2021-04-20 04:37:23 Branches: 163 174 93.7 %

Line Branch Exec Source
1
/*
2
 * Copyright (c) 2013
3
 *      MIPS Technologies, Inc., California.
4
 *
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
7
 * are met:
8
 * 1. Redistributions of source code must retain the above copyright
9
 *    notice, this list of conditions and the following disclaimer.
10
 * 2. Redistributions in binary form must reproduce the above copyright
11
 *    notice, this list of conditions and the following disclaimer in the
12
 *    documentation and/or other materials provided with the distribution.
13
 * 3. Neither the name of the MIPS Technologies, Inc., nor the names of its
14
 *    contributors may be used to endorse or promote products derived from
15
 *    this software without specific prior written permission.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE MIPS TECHNOLOGIES, INC. ``AS IS'' AND
18
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE MIPS TECHNOLOGIES, INC. BE LIABLE
21
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27
 * SUCH DAMAGE.
28
 *
29
 * AAC Spectral Band Replication decoding functions (fixed-point)
30
 * Copyright (c) 2008-2009 Robert Swain ( rob opendot cl )
31
 * Copyright (c) 2009-2010 Alex Converse <alex.converse@gmail.com>
32
 *
33
 * This file is part of FFmpeg.
34
 *
35
 * FFmpeg is free software; you can redistribute it and/or
36
 * modify it under the terms of the GNU Lesser General Public
37
 * License as published by the Free Software Foundation; either
38
 * version 2.1 of the License, or (at your option) any later version.
39
 *
40
 * FFmpeg is distributed in the hope that it will be useful,
41
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
42
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
43
 * Lesser General Public License for more details.
44
 *
45
 * You should have received a copy of the GNU Lesser General Public
46
 * License along with FFmpeg; if not, write to the Free Software
47
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
48
 */
49
50
/**
51
 * @file
52
 * AAC Spectral Band Replication decoding functions (fixed-point)
53
 * Note: Rounding-to-nearest used unless otherwise stated
54
 * @author Robert Swain ( rob opendot cl )
55
 * @author Stanislav Ocovaj ( stanislav.ocovaj imgtec com )
56
 */
57
#define USE_FIXED 1
58
59
#include "aac.h"
60
#include "sbr.h"
61
#include "aacsbr.h"
62
#include "aacsbrdata.h"
63
#include "fft.h"
64
#include "aacps.h"
65
#include "sbrdsp.h"
66
#include "libavutil/internal.h"
67
#include "libavutil/libm.h"
68
#include "libavutil/avassert.h"
69
70
#include <stdint.h>
71
#include <float.h>
72
#include <math.h>
73
74
static VLC vlc_sbr[10];
75
static void aacsbr_func_ptr_init(AACSBRContext *c);
76
static const int CONST_LN2       = Q31(0.6931471806/256);  // ln(2)/256
77
static const int CONST_RECIP_LN2 = Q31(0.7213475204);      // 0.5/ln(2)
78
static const int CONST_076923    = Q31(0.76923076923076923077f);
79
80
static const int fixed_log_table[10] =
81
{
82
    Q31(1.0/2), Q31(1.0/3), Q31(1.0/4), Q31(1.0/5), Q31(1.0/6),
83
    Q31(1.0/7), Q31(1.0/8), Q31(1.0/9), Q31(1.0/10), Q31(1.0/11)
84
};
85
86
24
static int fixed_log(int x)
87
{
88
    int i, ret, xpow, tmp;
89
90
24
    ret = x;
91
24
    xpow = x;
92
144
    for (i=0; i<10; i+=2){
93
120
        xpow = (int)(((int64_t)xpow * x + 0x40000000) >> 31);
94
120
        tmp = (int)(((int64_t)xpow * fixed_log_table[i] + 0x40000000) >> 31);
95
120
        ret -= tmp;
96
97
120
        xpow = (int)(((int64_t)xpow * x + 0x40000000) >> 31);
98
120
        tmp = (int)(((int64_t)xpow * fixed_log_table[i+1] + 0x40000000) >> 31);
99
120
        ret += tmp;
100
    }
101
102
24
    return ret;
103
}
104
105
static const int fixed_exp_table[7] =
106
{
107
    Q31(1.0/2), Q31(1.0/6), Q31(1.0/24), Q31(1.0/120),
108
    Q31(1.0/720), Q31(1.0/5040), Q31(1.0/40320)
109
};
110
111
12
static int fixed_exp(int x)
112
{
113
    int i, ret, xpow, tmp;
114
115
12
    ret = 0x800000 + x;
116
12
    xpow = x;
117
96
    for (i=0; i<7; i++){
118
84
        xpow = (int)(((int64_t)xpow * x + 0x400000) >> 23);
119
84
        tmp = (int)(((int64_t)xpow * fixed_exp_table[i] + 0x40000000) >> 31);
120
84
        ret += tmp;
121
    }
122
123
12
    return ret;
124
}
125
126
12
static void make_bands(int16_t* bands, int start, int stop, int num_bands)
127
{
128
    int k, previous, present;
129
12
    int base, prod, nz = 0;
130
131
12
    base = (stop << 23) / start;
132
85
    while (base < 0x40000000){
133
73
        base <<= 1;
134
73
        nz++;
135
    }
136
12
    base = fixed_log(base - 0x80000000);
137
12
    base = (((base + 0x80) >> 8) + (8-nz)*CONST_LN2) / num_bands;
138
12
    base = fixed_exp(base);
139
140
12
    previous = start;
141
12
    prod = start << 23;
142
143
123
    for (k = 0; k < num_bands-1; k++) {
144
111
        prod = (int)(((int64_t)prod * base + 0x400000) >> 23);
145
111
        present = (prod + 0x400000) >> 23;
146
111
        bands[k] = present - previous;
147
111
        previous = present;
148
    }
149
12
    bands[num_bands-1] = stop - previous;
150
12
}
151
152
/// Dequantization and stereo decoding (14496-3 sp04 p203)
153
2082
static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
154
{
155
    int k, e;
156
    int ch;
157
158

3362
    if (id_aac == TYPE_CPE && sbr->bs_coupling) {
159
1280
        int alpha      = sbr->data[0].bs_amp_res ?  2 :  1;
160
1280
        int pan_offset = sbr->data[0].bs_amp_res ? 12 : 24;
161
2922
        for (e = 1; e <= sbr->data[0].bs_num_env; e++) {
162
19065
            for (k = 0; k < sbr->n[sbr->data[0].bs_freq_res[e]]; k++) {
163
                SoftFloat temp1, temp2, fac;
164
165
17423
                temp1.exp = sbr->data[0].env_facs_q[e][k] * alpha + 14;
166
17423
                if (temp1.exp & 1)
167
4733
                  temp1.mant = 759250125;
168
                else
169
12690
                  temp1.mant = 0x20000000;
170
17423
                temp1.exp = (temp1.exp >> 1) + 1;
171
17423
                if (temp1.exp > 66) { // temp1 > 1E20
172
                    av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n");
173
                    temp1 = FLOAT_1;
174
                }
175
176
17423
                temp2.exp = (pan_offset - sbr->data[1].env_facs_q[e][k]) * alpha;
177
17423
                if (temp2.exp & 1)
178
                  temp2.mant = 759250125;
179
                else
180
17423
                  temp2.mant = 0x20000000;
181
17423
                temp2.exp = (temp2.exp >> 1) + 1;
182
17423
                fac   = av_div_sf(temp1, av_add_sf(FLOAT_1, temp2));
183
17423
                sbr->data[0].env_facs[e][k] = fac;
184
17423
                sbr->data[1].env_facs[e][k] = av_mul_sf(fac, temp2);
185
            }
186
        }
187
2837
        for (e = 1; e <= sbr->data[0].bs_num_noise; e++) {
188
5699
            for (k = 0; k < sbr->n_q; k++) {
189
                SoftFloat temp1, temp2, fac;
190
191
4142
                temp1.exp = NOISE_FLOOR_OFFSET - \
192
4142
                    sbr->data[0].noise_facs_q[e][k] + 2;
193
4142
                temp1.mant = 0x20000000;
194
4142
                av_assert0(temp1.exp <= 66);
195
4142
                temp2.exp = 12 - sbr->data[1].noise_facs_q[e][k] + 1;
196
4142
                temp2.mant = 0x20000000;
197
4142
                fac   = av_div_sf(temp1, av_add_sf(FLOAT_1, temp2));
198
4142
                sbr->data[0].noise_facs[e][k] = fac;
199
4142
                sbr->data[1].noise_facs[e][k] = av_mul_sf(fac, temp2);
200
            }
201
        }
202
    } else { // SCE or one non-coupled CPE
203

2029
        for (ch = 0; ch < (id_aac == TYPE_CPE) + 1; ch++) {
204
1227
            int alpha = sbr->data[ch].bs_amp_res ? 2 : 1;
205
3531
            for (e = 1; e <= sbr->data[ch].bs_num_env; e++)
206
26435
                for (k = 0; k < sbr->n[sbr->data[ch].bs_freq_res[e]]; k++){
207
                    SoftFloat temp1;
208
209
24131
                    temp1.exp = alpha * sbr->data[ch].env_facs_q[e][k] + 12;
210
24131
                    if (temp1.exp & 1)
211
2958
                        temp1.mant = 759250125;
212
                    else
213
21173
                        temp1.mant = 0x20000000;
214
24131
                    temp1.exp = (temp1.exp >> 1) + 1;
215
24131
                    if (temp1.exp > 66) { // temp1 > 1E20
216
                        av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n");
217
                        temp1 = FLOAT_1;
218
                    }
219
24131
                    sbr->data[ch].env_facs[e][k] = temp1;
220
                }
221
3181
            for (e = 1; e <= sbr->data[ch].bs_num_noise; e++)
222
7656
                for (k = 0; k < sbr->n_q; k++){
223
5702
                    sbr->data[ch].noise_facs[e][k].exp = NOISE_FLOOR_OFFSET - \
224
5702
                        sbr->data[ch].noise_facs_q[e][k] + 1;
225
5702
                    sbr->data[ch].noise_facs[e][k].mant = 0x20000000;
226
                }
227
        }
228
    }
229
2082
}
230
231
/** High Frequency Generation (14496-3 sp04 p214+) and Inverse Filtering
232
 * (14496-3 sp04 p214)
233
 * Warning: This routine does not seem numerically stable.
234
 */
235
3787
static void sbr_hf_inverse_filter(SBRDSPContext *dsp,
236
                                  int (*alpha0)[2], int (*alpha1)[2],
237
                                  const int X_low[32][40][2], int k0)
238
{
239
    int k;
240
    int shift, round;
241
242
71885
    for (k = 0; k < k0; k++) {
243
        SoftFloat phi[3][2][2];
244
        SoftFloat a00, a01, a10, a11;
245
        SoftFloat dk;
246
247
68098
        dsp->autocorrelate(X_low[k], phi);
248
249
68098
        dk = av_sub_sf(av_mul_sf(phi[2][1][0], phi[1][0][0]),
250
             av_mul_sf(av_add_sf(av_mul_sf(phi[1][1][0], phi[1][1][0]),
251
             av_mul_sf(phi[1][1][1], phi[1][1][1])), FLOAT_0999999));
252
253
68098
        if (!dk.mant) {
254
1708
            a10 = FLOAT_0;
255
1708
            a11 = FLOAT_0;
256
        } else {
257
            SoftFloat temp_real, temp_im;
258
66390
            temp_real = av_sub_sf(av_sub_sf(av_mul_sf(phi[0][0][0], phi[1][1][0]),
259
                                            av_mul_sf(phi[0][0][1], phi[1][1][1])),
260
                                  av_mul_sf(phi[0][1][0], phi[1][0][0]));
261
66390
            temp_im   = av_sub_sf(av_add_sf(av_mul_sf(phi[0][0][0], phi[1][1][1]),
262
                                            av_mul_sf(phi[0][0][1], phi[1][1][0])),
263
                                  av_mul_sf(phi[0][1][1], phi[1][0][0]));
264
265
66390
            a10 = av_div_sf(temp_real, dk);
266
66390
            a11 = av_div_sf(temp_im,   dk);
267
        }
268
269
68098
        if (!phi[1][0][0].mant) {
270
1708
            a00 = FLOAT_0;
271
1708
            a01 = FLOAT_0;
272
        } else {
273
            SoftFloat temp_real, temp_im;
274
66390
            temp_real = av_add_sf(phi[0][0][0],
275
                                  av_add_sf(av_mul_sf(a10, phi[1][1][0]),
276
                                            av_mul_sf(a11, phi[1][1][1])));
277
66390
            temp_im   = av_add_sf(phi[0][0][1],
278
                                  av_sub_sf(av_mul_sf(a11, phi[1][1][0]),
279
                                            av_mul_sf(a10, phi[1][1][1])));
280
281
66390
            temp_real.mant = -temp_real.mant;
282
66390
            temp_im.mant   = -temp_im.mant;
283
66390
            a00 = av_div_sf(temp_real, phi[1][0][0]);
284
66390
            a01 = av_div_sf(temp_im,   phi[1][0][0]);
285
        }
286
287
68098
        shift = a00.exp;
288
68098
        if (shift >= 3)
289
2
            alpha0[k][0] = 0x7fffffff;
290
68096
        else if (shift <= -30)
291
2123
            alpha0[k][0] = 0;
292
        else {
293
65973
            shift = 1-shift;
294
65973
            if (shift <= 0)
295
1838
                alpha0[k][0] = a00.mant * (1<<-shift);
296
            else {
297
64135
                round = 1 << (shift-1);
298
64135
                alpha0[k][0] = (a00.mant + round) >> shift;
299
            }
300
        }
301
302
68098
        shift = a01.exp;
303
68098
        if (shift >= 3)
304
3
            alpha0[k][1] = 0x7fffffff;
305
68095
        else if (shift <= -30)
306
2078
            alpha0[k][1] = 0;
307
        else {
308
66017
            shift = 1-shift;
309
66017
            if (shift <= 0)
310
14382
                alpha0[k][1] = a01.mant * (1<<-shift);
311
            else {
312
51635
                round = 1 << (shift-1);
313
51635
                alpha0[k][1] = (a01.mant + round) >> shift;
314
            }
315
        }
316
68098
        shift = a10.exp;
317
68098
        if (shift >= 3)
318
5
            alpha1[k][0] = 0x7fffffff;
319
68093
        else if (shift <= -30)
320
2024
            alpha1[k][0] = 0;
321
        else {
322
66069
            shift = 1-shift;
323
66069
            if (shift <= 0)
324
76
                alpha1[k][0] = a10.mant * (1<<-shift);
325
            else {
326
65993
                round = 1 << (shift-1);
327
65993
                alpha1[k][0] = (a10.mant + round) >> shift;
328
            }
329
        }
330
331
68098
        shift = a11.exp;
332
68098
        if (shift >= 3)
333
            alpha1[k][1] = 0x7fffffff;
334
68098
        else if (shift <= -30)
335
2114
            alpha1[k][1] = 0;
336
        else {
337
65984
            shift = 1-shift;
338
65984
            if (shift <= 0)
339
84
                alpha1[k][1] = a11.mant * (1<<-shift);
340
            else {
341
65900
                round = 1 << (shift-1);
342
65900
                alpha1[k][1] = (a11.mant + round) >> shift;
343
            }
344
        }
345
346
68098
        shift = (int)(((int64_t)(alpha1[k][0]>>1) * (alpha1[k][0]>>1) + \
347
68098
                       (int64_t)(alpha1[k][1]>>1) * (alpha1[k][1]>>1) + \
348
68098
                       0x40000000) >> 31);
349
68098
        if (shift >= 0x20000000){
350
            alpha1[k][0] = 0;
351
            alpha1[k][1] = 0;
352
            alpha0[k][0] = 0;
353
            alpha0[k][1] = 0;
354
        }
355
356
68098
        shift = (int)(((int64_t)(alpha0[k][0]>>1) * (alpha0[k][0]>>1) + \
357
68098
                       (int64_t)(alpha0[k][1]>>1) * (alpha0[k][1]>>1) + \
358
68098
                       0x40000000) >> 31);
359
68098
        if (shift >= 0x20000000){
360
            alpha1[k][0] = 0;
361
            alpha1[k][1] = 0;
362
            alpha0[k][0] = 0;
363
            alpha0[k][1] = 0;
364
        }
365
    }
366
3787
}
367
368
/// Chirp Factors (14496-3 sp04 p214)
369
3787
static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
370
{
371
    int i;
372
    int new_bw;
373
    static const int bw_tab[] = { 0, 1610612736, 1932735283, 2104533975 };
374
    int64_t accu;
375
376
14000
    for (i = 0; i < sbr->n_q; i++) {
377
10213
        if (ch_data->bs_invf_mode[0][i] + ch_data->bs_invf_mode[1][i] == 1)
378
799
            new_bw = 1288490189;
379
        else
380
9414
            new_bw = bw_tab[ch_data->bs_invf_mode[0][i]];
381
382
10213
        if (new_bw < ch_data->bw_array[i]){
383
2080
            accu  = (int64_t)new_bw * 1610612736;
384
2080
            accu += (int64_t)ch_data->bw_array[i] * 0x20000000;
385
2080
            new_bw = (int)((accu + 0x40000000) >> 31);
386
        } else {
387
8133
            accu  = (int64_t)new_bw * 1946157056;
388
8133
            accu += (int64_t)ch_data->bw_array[i] * 201326592;
389
8133
            new_bw = (int)((accu + 0x40000000) >> 31);
390
        }
391
10213
        ch_data->bw_array[i] = new_bw < 0x2000000 ? 0 : new_bw;
392
    }
393
3787
}
394
395
/**
396
 * Calculation of levels of additional HF signal components (14496-3 sp04 p219)
397
 * and Calculation of gain (14496-3 sp04 p219)
398
 */
399
3787
static void sbr_gain_calc(AACContext *ac, SpectralBandReplication *sbr,
400
                          SBRData *ch_data, const int e_a[2])
401
{
402
    int e, k, m;
403
    // max gain limits : -3dB, 0dB, 3dB, inf dB (limiter off)
404
    static const SoftFloat limgain[4] = { { 760155524,  0 }, { 0x20000000,  1 },
405
                                            { 758351638,  1 }, { 625000000, 34 } };
406
407
9375
    for (e = 0; e < ch_data->bs_num_env; e++) {
408

5588
        int delta = !((e == e_a[1]) || (e == e_a[0]));
409
23292
        for (k = 0; k < sbr->n_lim; k++) {
410
            SoftFloat gain_boost, gain_max;
411
            SoftFloat sum[2];
412
17704
            sum[0] = sum[1] = FLOAT_0;
413
145541
            for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
414
127837
                const SoftFloat temp = av_div_sf(sbr->e_origmapped[e][m],
415
                                            av_add_sf(FLOAT_1, sbr->q_mapped[e][m]));
416
127837
                sbr->q_m[e][m] = av_sqrt_sf(av_mul_sf(temp, sbr->q_mapped[e][m]));
417
127837
                sbr->s_m[e][m] = av_sqrt_sf(av_mul_sf(temp, av_int2sf(ch_data->s_indexmapped[e + 1][m], 0)));
418
127837
                if (!sbr->s_mapped[e][m]) {
419
123205
                    if (delta) {
420
115357
                      sbr->gain[e][m] = av_sqrt_sf(av_div_sf(sbr->e_origmapped[e][m],
421
                                            av_mul_sf(av_add_sf(FLOAT_1, sbr->e_curr[e][m]),
422
                                            av_add_sf(FLOAT_1, sbr->q_mapped[e][m]))));
423
                    } else {
424
7848
                      sbr->gain[e][m] = av_sqrt_sf(av_div_sf(sbr->e_origmapped[e][m],
425
                                            av_add_sf(FLOAT_1, sbr->e_curr[e][m])));
426
                    }
427
                } else {
428
4632
                    sbr->gain[e][m] = av_sqrt_sf(
429
                                        av_div_sf(
430
                                            av_mul_sf(sbr->e_origmapped[e][m], sbr->q_mapped[e][m]),
431
                                            av_mul_sf(
432
                                                av_add_sf(FLOAT_1, sbr->e_curr[e][m]),
433
                                                av_add_sf(FLOAT_1, sbr->q_mapped[e][m]))));
434
                }
435
127837
                sbr->gain[e][m] = av_add_sf(sbr->gain[e][m], FLOAT_MIN);
436
            }
437
145541
            for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
438
127837
                sum[0] = av_add_sf(sum[0], sbr->e_origmapped[e][m]);
439
127837
                sum[1] = av_add_sf(sum[1], sbr->e_curr[e][m]);
440
            }
441
17704
            gain_max = av_mul_sf(limgain[sbr->bs_limiter_gains],
442
                            av_sqrt_sf(
443
                                av_div_sf(
444
                                    av_add_sf(FLOAT_EPSILON, sum[0]),
445
                                    av_add_sf(FLOAT_EPSILON, sum[1]))));
446
17704
            if (av_gt_sf(gain_max, FLOAT_100000))
447
3741
              gain_max = FLOAT_100000;
448
145541
            for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
449
127837
                SoftFloat q_m_max = av_div_sf(
450
                                        av_mul_sf(sbr->q_m[e][m], gain_max),
451
                                        sbr->gain[e][m]);
452
127837
                if (av_gt_sf(sbr->q_m[e][m], q_m_max))
453
33577
                  sbr->q_m[e][m] = q_m_max;
454
127837
                if (av_gt_sf(sbr->gain[e][m], gain_max))
455
33577
                  sbr->gain[e][m] = gain_max;
456
            }
457
17704
            sum[0] = sum[1] = FLOAT_0;
458
145541
            for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
459
127837
                sum[0] = av_add_sf(sum[0], sbr->e_origmapped[e][m]);
460
127837
                sum[1] = av_add_sf(sum[1],
461
                            av_mul_sf(
462
                                av_mul_sf(sbr->e_curr[e][m],
463
                                          sbr->gain[e][m]),
464
                                sbr->gain[e][m]));
465
127837
                sum[1] = av_add_sf(sum[1],
466
                            av_mul_sf(sbr->s_m[e][m], sbr->s_m[e][m]));
467

127837
                if (delta && !sbr->s_m[e][m].mant)
468
117689
                  sum[1] = av_add_sf(sum[1],
469
                                av_mul_sf(sbr->q_m[e][m], sbr->q_m[e][m]));
470
            }
471
17704
            gain_boost = av_sqrt_sf(
472
                            av_div_sf(
473
                                av_add_sf(FLOAT_EPSILON, sum[0]),
474
                                av_add_sf(FLOAT_EPSILON, sum[1])));
475
17704
            if (av_gt_sf(gain_boost, FLOAT_1584893192))
476
1483
              gain_boost = FLOAT_1584893192;
477
478
145541
            for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
479
127837
                sbr->gain[e][m] = av_mul_sf(sbr->gain[e][m], gain_boost);
480
127837
                sbr->q_m[e][m]  = av_mul_sf(sbr->q_m[e][m], gain_boost);
481
127837
                sbr->s_m[e][m]  = av_mul_sf(sbr->s_m[e][m], gain_boost);
482
            }
483
        }
484
    }
485
3787
}
486
487
/// Assembling HF Signals (14496-3 sp04 p220)
488
3787
static void sbr_hf_assemble(int Y1[38][64][2],
489
                            const int X_high[64][40][2],
490
                            SpectralBandReplication *sbr, SBRData *ch_data,
491
                            const int e_a[2])
492
{
493
    int e, i, j, m;
494
3787
    const int h_SL = 4 * !sbr->bs_smoothing_mode;
495
3787
    const int kx = sbr->kx[1];
496
3787
    const int m_max = sbr->m[1];
497
    static const SoftFloat h_smooth[5] = {
498
      { 715827883, -1 },
499
      { 647472402, -1 },
500
      { 937030863, -2 },
501
      { 989249804, -3 },
502
      { 546843842, -4 },
503
    };
504
3787
    SoftFloat (*g_temp)[48] = ch_data->g_temp, (*q_temp)[48] = ch_data->q_temp;
505
3787
    int indexnoise = ch_data->f_indexnoise;
506
3787
    int indexsine  = ch_data->f_indexsine;
507
508
3787
    if (sbr->reset) {
509
17
        for (i = 0; i < h_SL; i++) {
510
8
            memcpy(g_temp[i + 2*ch_data->t_env[0]], sbr->gain[0], m_max * sizeof(sbr->gain[0][0]));
511
8
            memcpy(q_temp[i + 2*ch_data->t_env[0]], sbr->q_m[0],  m_max * sizeof(sbr->q_m[0][0]));
512
        }
513
3778
    } else if (h_SL) {
514
5730
        for (i = 0; i < 4; i++) {
515
4584
            memcpy(g_temp[i + 2 * ch_data->t_env[0]],
516
4584
                   g_temp[i + 2 * ch_data->t_env_num_env_old],
517
                   sizeof(g_temp[0]));
518
4584
            memcpy(q_temp[i + 2 * ch_data->t_env[0]],
519
4584
                   q_temp[i + 2 * ch_data->t_env_num_env_old],
520
                   sizeof(q_temp[0]));
521
        }
522
    }
523
524
9375
    for (e = 0; e < ch_data->bs_num_env; e++) {
525
126772
        for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
526
121184
            memcpy(g_temp[h_SL + i], sbr->gain[e], m_max * sizeof(sbr->gain[0][0]));
527
121184
            memcpy(q_temp[h_SL + i], sbr->q_m[e],  m_max * sizeof(sbr->q_m[0][0]));
528
        }
529
    }
530
531
9375
    for (e = 0; e < ch_data->bs_num_env; e++) {
532
126772
        for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
533
            SoftFloat g_filt_tab[48];
534
            SoftFloat q_filt_tab[48];
535
            SoftFloat *g_filt, *q_filt;
536
537

121184
            if (h_SL && e != e_a[0] && e != e_a[1]) {
538
36634
                g_filt = g_filt_tab;
539
36634
                q_filt = q_filt_tab;
540
659412
                for (m = 0; m < m_max; m++) {
541
622778
                    const int idx1 = i + h_SL;
542
622778
                    g_filt[m].mant = g_filt[m].exp = 0;
543
622778
                    q_filt[m].mant = q_filt[m].exp = 0;
544
3736668
                    for (j = 0; j <= h_SL; j++) {
545
3113890
                        g_filt[m] = av_add_sf(g_filt[m],
546
3113890
                                        av_mul_sf(g_temp[idx1 - j][m],
547
                                            h_smooth[j]));
548
3113890
                        q_filt[m] = av_add_sf(q_filt[m],
549
3113890
                                        av_mul_sf(q_temp[idx1 - j][m],
550
                                            h_smooth[j]));
551
                    }
552
                }
553
            } else {
554
84550
                g_filt = g_temp[i + h_SL];
555
84550
                q_filt = q_temp[i];
556
            }
557
558
121184
            sbr->dsp.hf_g_filt(Y1[i] + kx, X_high + kx, g_filt, m_max,
559
121184
                               i + ENVELOPE_ADJUSTMENT_OFFSET);
560
561

121184
            if (e != e_a[0] && e != e_a[1]) {
562
119686
                sbr->dsp.hf_apply_noise[indexsine](Y1[i] + kx, sbr->s_m[e],
563
                                                   q_filt, indexnoise,
564
                                                   kx, m_max);
565
            } else {
566
1498
                int idx = indexsine&1;
567
1498
                int A = (1-((indexsine+(kx & 1))&2));
568
1498
                int B = (A^(-idx)) + idx;
569
1498
                unsigned *out = &Y1[i][kx][idx];
570
                int shift;
571
                unsigned round;
572
573
1498
                SoftFloat *in  = sbr->s_m[e];
574
18898
                for (m = 0; m+1 < m_max; m+=2) {
575
                    int shift2;
576
17400
                    shift = 22 - in[m  ].exp;
577
17400
                    shift2= 22 - in[m+1].exp;
578

17400
                    if (shift < 1 || shift2 < 1) {
579
                        av_log(NULL, AV_LOG_ERROR, "Overflow in sbr_hf_assemble, shift=%d,%d\n", shift, shift2);
580
                        return;
581
                    }
582
17400
                    if (shift < 32) {
583
600
                        round = 1 << (shift-1);
584
600
                        out[2*m  ] += (int)(in[m  ].mant * A + round) >> shift;
585
                    }
586
587
17400
                    if (shift2 < 32) {
588
152
                        round = 1 << (shift2-1);
589
152
                        out[2*m+2] += (int)(in[m+1].mant * B + round) >> shift2;
590
                    }
591
                }
592
1498
                if(m_max&1)
593
                {
594
1004
                    shift = 22 - in[m  ].exp;
595
1004
                    if (shift < 1) {
596
                        av_log(NULL, AV_LOG_ERROR, "Overflow in sbr_hf_assemble, shift=%d\n", shift);
597
                        return;
598
1004
                    } else if (shift < 32) {
599
                        round = 1 << (shift-1);
600
                        out[2*m  ] += (int)(in[m  ].mant * A + round) >> shift;
601
                    }
602
                }
603
            }
604
121184
            indexnoise = (indexnoise + m_max) & 0x1ff;
605
121184
            indexsine = (indexsine + 1) & 3;
606
        }
607
    }
608
3787
    ch_data->f_indexnoise = indexnoise;
609
3787
    ch_data->f_indexsine  = indexsine;
610
}
611
612
#include "aacsbr_template.c"