summaryrefslogtreecommitdiff
path: root/audio_codec/libfaad/sbr_fbt.c (plain)
blob: 6bf5d135e04a32a64fbe73ca623f605cf39cf03f
1/*
2** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
3** Copyright (C) 2003-2005 M. Bakker, Nero AG, http://www.nero.com
4**
5** This program is free software; you can redistribute it and/or modify
6** it under the terms of the GNU General Public License as published by
7** the Free Software Foundation; either version 2 of the License, or
8** (at your option) any later version.
9**
10** This program is distributed in the hope that it will be useful,
11** but WITHOUT ANY WARRANTY; without even the implied warranty of
12** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13** GNU General Public License for more details.
14**
15** You should have received a copy of the GNU General Public License
16** along with this program; if not, write to the Free Software
17** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18**
19** Any non-GPL usage of this software or parts of this software is strictly
20** forbidden.
21**
22** The "appropriate copyright message" mentioned in section 2c of the GPLv2
23** must read: "Code from FAAD2 is copyright (c) Nero AG, www.nero.com"
24**
25** Commercial non-GPL licensing of this software is possible.
26** For more info contact Nero AG through Mpeg4AAClicense@nero.com.
27**
28** $Id: sbr_fbt.c,v 1.21 2007/11/01 12:33:35 menno Exp $
29**/
30
31/* Calculate frequency band tables */
32#include <stdlib.h>
33#include "common.h"
34#include "structs.h"
35
36#ifdef SBR_DEC
37
38#include "sbr_syntax.h"
39#include "sbr_fbt.h"
40
41/* static function declarations */
42static int32_t find_bands(uint8_t warp, uint8_t bands, uint8_t a0, uint8_t a1);
43
44
45/* calculate the start QMF channel for the master frequency band table */
46/* parameter is also called k0 */
47uint8_t qmf_start_channel(uint8_t bs_start_freq, uint8_t bs_samplerate_mode,
48 uint32_t sample_rate)
49{
50 static const uint8_t startMinTable[12] = { 7, 7, 10, 11, 12, 16, 16,
51 17, 24, 32, 35, 48
52 };
53 static const uint8_t offsetIndexTable[12] = { 5, 5, 4, 4, 4, 3, 2, 1, 0,
54 6, 6, 6
55 };
56 static const int8_t offset[7][16] = {
57 { -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7 },
58 { -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 13 },
59 { -5, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 13, 16 },
60 { -6, -4, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 13, 16 },
61 { -4, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 13, 16, 20 },
62 { -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 13, 16, 20, 24 },
63 { 0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 13, 16, 20, 24, 28, 33 }
64 };
65 uint8_t startMin = startMinTable[get_sr_index(sample_rate)];
66 uint8_t offsetIndex = offsetIndexTable[get_sr_index(sample_rate)];
67
68#if 0 /* replaced with table (startMinTable) */
69 if (sample_rate >= 64000) {
70 startMin = (uint8_t)((5000.*128.) / (float)sample_rate + 0.5);
71 } else if (sample_rate < 32000) {
72 startMin = (uint8_t)((3000.*128.) / (float)sample_rate + 0.5);
73 } else {
74 startMin = (uint8_t)((4000.*128.) / (float)sample_rate + 0.5);
75 }
76#endif
77
78 if (bs_samplerate_mode) {
79 return startMin + offset[offsetIndex][bs_start_freq];
80
81#if 0 /* replaced by offsetIndexTable */
82 switch (sample_rate) {
83 case 16000:
84 return startMin + offset[0][bs_start_freq];
85 case 22050:
86 return startMin + offset[1][bs_start_freq];
87 case 24000:
88 return startMin + offset[2][bs_start_freq];
89 case 32000:
90 return startMin + offset[3][bs_start_freq];
91 default:
92 if (sample_rate > 64000) {
93 return startMin + offset[5][bs_start_freq];
94 } else { /* 44100 <= sample_rate <= 64000 */
95 return startMin + offset[4][bs_start_freq];
96 }
97 }
98#endif
99 } else {
100 return startMin + offset[6][bs_start_freq];
101 }
102}
103
104static int longcmp(const void *a, const void *b)
105{
106 return ((int)(*(int32_t*)a - * (int32_t*)b));
107}
108
109/* calculate the stop QMF channel for the master frequency band table */
110/* parameter is also called k2 */
111uint8_t qmf_stop_channel(uint8_t bs_stop_freq, uint32_t sample_rate,
112 uint8_t k0)
113{
114 if (bs_stop_freq == 15) {
115 return min(64, k0 * 3);
116 } else if (bs_stop_freq == 14) {
117 return min(64, k0 * 2);
118 } else {
119 static const uint8_t stopMinTable[12] = { 13, 15, 20, 21, 23,
120 32, 32, 35, 48, 64, 70, 96
121 };
122 static const int8_t offset[12][14] = {
123 { 0, 2, 4, 6, 8, 11, 14, 18, 22, 26, 31, 37, 44, 51 },
124 { 0, 2, 4, 6, 8, 11, 14, 18, 22, 26, 31, 36, 42, 49 },
125 { 0, 2, 4, 6, 8, 11, 14, 17, 21, 25, 29, 34, 39, 44 },
126 { 0, 2, 4, 6, 8, 11, 14, 17, 20, 24, 28, 33, 38, 43 },
127 { 0, 2, 4, 6, 8, 11, 14, 17, 20, 24, 28, 32, 36, 41 },
128 { 0, 2, 4, 6, 8, 10, 12, 14, 17, 20, 23, 26, 29, 32 },
129 { 0, 2, 4, 6, 8, 10, 12, 14, 17, 20, 23, 26, 29, 32 },
130 { 0, 1, 3, 5, 7, 9, 11, 13, 15, 17, 20, 23, 26, 29 },
131 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16 },
132 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
133 { 0, -1, -2, -3, -4, -5, -6, -6, -6, -6, -6, -6, -6, -6 },
134 { 0, -3, -6, -9, -12, -15, -18, -20, -22, -24, -26, -28, -30, -32 }
135 };
136#if 0
137 uint8_t i;
138 int32_t stopDk[13], stopDk_t[14], k2;
139#endif
140 uint8_t stopMin = stopMinTable[get_sr_index(sample_rate)];
141
142#if 0 /* replaced by table lookup */
143 if (sample_rate >= 64000) {
144 stopMin = (uint8_t)((10000.*128.) / (float)sample_rate + 0.5);
145 } else if (sample_rate < 32000) {
146 stopMin = (uint8_t)((6000.*128.) / (float)sample_rate + 0.5);
147 } else {
148 stopMin = (uint8_t)((8000.*128.) / (float)sample_rate + 0.5);
149 }
150#endif
151
152#if 0 /* replaced by table lookup */
153 /* diverging power series */
154 for (i = 0; i <= 13; i++) {
155 stopDk_t[i] = (int32_t)(stopMin * pow(64.0 / stopMin, i / 13.0) + 0.5);
156 }
157 for (i = 0; i < 13; i++) {
158 stopDk[i] = stopDk_t[i + 1] - stopDk_t[i];
159 }
160
161 /* needed? */
162 qsort(stopDk, 13, sizeof(stopDk[0]), longcmp);
163
164 k2 = stopMin;
165 for (i = 0; i < bs_stop_freq; i++) {
166 k2 += stopDk[i];
167 }
168 return min(64, k2);
169#endif
170 /* bs_stop_freq <= 13 */
171 return min(64, stopMin + offset[get_sr_index(sample_rate)][min(bs_stop_freq, 13)]);
172 }
173
174 return 0;
175}
176
177/* calculate the master frequency table from k0, k2, bs_freq_scale
178 and bs_alter_scale
179
180 version for bs_freq_scale = 0
181*/
182uint8_t master_frequency_table_fs0(sbr_info *sbr, uint8_t k0, uint8_t k2,
183 uint8_t bs_alter_scale)
184{
185 int8_t incr;
186 uint8_t k;
187 uint8_t dk;
188 uint32_t nrBands, k2Achieved;
189 int32_t k2Diff, vDk[64] = {0};
190
191 /* mft only defined for k2 > k0 */
192 if (k2 <= k0) {
193 sbr->N_master = 0;
194 return 1;
195 }
196
197 dk = bs_alter_scale ? 2 : 1;
198
199#if 0 /* replaced by float-less design */
200 nrBands = 2 * (int32_t)((float)(k2 - k0) / (dk * 2) + (-1 + dk) / 2.0f);
201#else
202 if (bs_alter_scale) {
203 nrBands = (((k2 - k0 + 2) >> 2) << 1);
204 } else {
205 nrBands = (((k2 - k0) >> 1) << 1);
206 }
207#endif
208 nrBands = min(nrBands, 63);
209 if (nrBands <= 0) {
210 return 1;
211 }
212
213 k2Achieved = k0 + nrBands * dk;
214 k2Diff = k2 - k2Achieved;
215 for (k = 0; k < nrBands; k++) {
216 vDk[k] = dk;
217 }
218
219 if (k2Diff) {
220 incr = (k2Diff > 0) ? -1 : 1;
221 k = (uint8_t)((k2Diff > 0) ? (nrBands - 1) : 0);
222
223 while (k2Diff != 0) {
224 vDk[k] -= incr;
225 k += incr;
226 k2Diff += incr;
227 }
228 }
229
230 sbr->f_master[0] = k0;
231 for (k = 1; k <= nrBands; k++) {
232 sbr->f_master[k] = (uint8_t)(sbr->f_master[k - 1] + vDk[k - 1]);
233 }
234
235 sbr->N_master = (uint8_t)nrBands;
236 sbr->N_master = (min(sbr->N_master, 64));
237
238#if 0
239 printf("f_master[%d]: ", nrBands);
240 for (k = 0; k <= nrBands; k++) {
241 printf("%d ", sbr->f_master[k]);
242 }
243 printf("\n");
244#endif
245
246 return 0;
247}
248
249/*
250 This function finds the number of bands using this formula:
251 bands * log(a1/a0)/log(2.0) + 0.5
252*/
253static int32_t find_bands(uint8_t warp, uint8_t bands, uint8_t a0, uint8_t a1)
254{
255#ifdef FIXED_POINT
256 /* table with log2() values */
257 static const real_t log2Table[65] = {
258 COEF_CONST(0.0), COEF_CONST(0.0), COEF_CONST(1.0000000000), COEF_CONST(1.5849625007),
259 COEF_CONST(2.0000000000), COEF_CONST(2.3219280949), COEF_CONST(2.5849625007), COEF_CONST(2.8073549221),
260 COEF_CONST(3.0000000000), COEF_CONST(3.1699250014), COEF_CONST(3.3219280949), COEF_CONST(3.4594316186),
261 COEF_CONST(3.5849625007), COEF_CONST(3.7004397181), COEF_CONST(3.8073549221), COEF_CONST(3.9068905956),
262 COEF_CONST(4.0000000000), COEF_CONST(4.0874628413), COEF_CONST(4.1699250014), COEF_CONST(4.2479275134),
263 COEF_CONST(4.3219280949), COEF_CONST(4.3923174228), COEF_CONST(4.4594316186), COEF_CONST(4.5235619561),
264 COEF_CONST(4.5849625007), COEF_CONST(4.6438561898), COEF_CONST(4.7004397181), COEF_CONST(4.7548875022),
265 COEF_CONST(4.8073549221), COEF_CONST(4.8579809951), COEF_CONST(4.9068905956), COEF_CONST(4.9541963104),
266 COEF_CONST(5.0000000000), COEF_CONST(5.0443941194), COEF_CONST(5.0874628413), COEF_CONST(5.1292830169),
267 COEF_CONST(5.1699250014), COEF_CONST(5.2094533656), COEF_CONST(5.2479275134), COEF_CONST(5.2854022189),
268 COEF_CONST(5.3219280949), COEF_CONST(5.3575520046), COEF_CONST(5.3923174228), COEF_CONST(5.4262647547),
269 COEF_CONST(5.4594316186), COEF_CONST(5.4918530963), COEF_CONST(5.5235619561), COEF_CONST(5.5545888517),
270 COEF_CONST(5.5849625007), COEF_CONST(5.6147098441), COEF_CONST(5.6438561898), COEF_CONST(5.6724253420),
271 COEF_CONST(5.7004397181), COEF_CONST(5.7279204546), COEF_CONST(5.7548875022), COEF_CONST(5.7813597135),
272 COEF_CONST(5.8073549221), COEF_CONST(5.8328900142), COEF_CONST(5.8579809951), COEF_CONST(5.8826430494),
273 COEF_CONST(5.9068905956), COEF_CONST(5.9307373376), COEF_CONST(5.9541963104), COEF_CONST(5.9772799235),
274 COEF_CONST(6.0)
275 };
276 real_t r0 = log2Table[a0]; /* coef */
277 real_t r1 = log2Table[a1]; /* coef */
278 real_t r2 = (r1 - r0); /* coef */
279
280 if (warp) {
281 r2 = MUL_C(r2, COEF_CONST(1.0 / 1.3));
282 }
283
284 /* convert r2 to real and then multiply and round */
285 r2 = (r2 >> (COEF_BITS - REAL_BITS)) * bands + (1 << (REAL_BITS - 1));
286
287 return (r2 >> REAL_BITS);
288#else
289 real_t div = (real_t)log(2.0);
290 if (warp) {
291 div *= (real_t)1.3;
292 }
293
294 return (int32_t)(bands * log((float)a1 / (float)a0) / div + 0.5);
295#endif
296}
297
298static real_t find_initial_power(uint8_t bands, uint8_t a0, uint8_t a1)
299{
300#ifdef FIXED_POINT
301 /* table with log() values */
302 static const real_t logTable[65] = {
303 COEF_CONST(0.0), COEF_CONST(0.0), COEF_CONST(0.6931471806), COEF_CONST(1.0986122887),
304 COEF_CONST(1.3862943611), COEF_CONST(1.6094379124), COEF_CONST(1.7917594692), COEF_CONST(1.9459101491),
305 COEF_CONST(2.0794415417), COEF_CONST(2.1972245773), COEF_CONST(2.3025850930), COEF_CONST(2.3978952728),
306 COEF_CONST(2.4849066498), COEF_CONST(2.5649493575), COEF_CONST(2.6390573296), COEF_CONST(2.7080502011),
307 COEF_CONST(2.7725887222), COEF_CONST(2.8332133441), COEF_CONST(2.8903717579), COEF_CONST(2.9444389792),
308 COEF_CONST(2.9957322736), COEF_CONST(3.0445224377), COEF_CONST(3.0910424534), COEF_CONST(3.1354942159),
309 COEF_CONST(3.1780538303), COEF_CONST(3.2188758249), COEF_CONST(3.2580965380), COEF_CONST(3.2958368660),
310 COEF_CONST(3.3322045102), COEF_CONST(3.3672958300), COEF_CONST(3.4011973817), COEF_CONST(3.4339872045),
311 COEF_CONST(3.4657359028), COEF_CONST(3.4965075615), COEF_CONST(3.5263605246), COEF_CONST(3.5553480615),
312 COEF_CONST(3.5835189385), COEF_CONST(3.6109179126), COEF_CONST(3.6375861597), COEF_CONST(3.6635616461),
313 COEF_CONST(3.6888794541), COEF_CONST(3.7135720667), COEF_CONST(3.7376696183), COEF_CONST(3.7612001157),
314 COEF_CONST(3.7841896339), COEF_CONST(3.8066624898), COEF_CONST(3.8286413965), COEF_CONST(3.8501476017),
315 COEF_CONST(3.8712010109), COEF_CONST(3.8918202981), COEF_CONST(3.9120230054), COEF_CONST(3.9318256327),
316 COEF_CONST(3.9512437186), COEF_CONST(3.9702919136), COEF_CONST(3.9889840466), COEF_CONST(4.0073331852),
317 COEF_CONST(4.0253516907), COEF_CONST(4.0430512678), COEF_CONST(4.0604430105), COEF_CONST(4.0775374439),
318 COEF_CONST(4.0943445622), COEF_CONST(4.1108738642), COEF_CONST(4.1271343850), COEF_CONST(4.1431347264),
319 COEF_CONST(4.158883083)
320 };
321 /* standard Taylor polynomial coefficients for exp(x) around 0 */
322 /* a polynomial around x=1 is more precise, as most values are around 1.07,
323 but this is just fine already */
324 static const real_t c1 = COEF_CONST(1.0);
325 static const real_t c2 = COEF_CONST(1.0 / 2.0);
326 static const real_t c3 = COEF_CONST(1.0 / 6.0);
327 static const real_t c4 = COEF_CONST(1.0 / 24.0);
328
329 real_t r0 = logTable[a0]; /* coef */
330 real_t r1 = logTable[a1]; /* coef */
331 real_t r2 = (r1 - r0) / bands; /* coef */
332 real_t rexp = c1 + MUL_C((c1 + MUL_C((c2 + MUL_C((c3 + MUL_C(c4, r2)), r2)), r2)), r2);
333
334 return (rexp >> (COEF_BITS - REAL_BITS)); /* real */
335#else
336 return (real_t)pow((real_t)a1 / (real_t)a0, 1.0 / (real_t)bands);
337#endif
338}
339
340/*
341 version for bs_freq_scale > 0
342*/
343uint8_t master_frequency_table(sbr_info *sbr, uint8_t k0, uint8_t k2,
344 uint8_t bs_freq_scale, uint8_t bs_alter_scale)
345{
346 uint8_t k, bands, twoRegions;
347 uint8_t k1;
348 uint8_t nrBand0, nrBand1;
349 int32_t vDk0[64] = {0}, vDk1[64] = {0};
350 int32_t vk0[64] = {0}, vk1[64] = {0};
351 uint8_t temp1[] = { 6, 5, 4 };
352 real_t q, qk;
353 int32_t A_1;
354#ifdef FIXED_POINT
355 real_t rk2, rk0;
356#endif
357
358 /* mft only defined for k2 > k0 */
359 if (k2 <= k0) {
360 sbr->N_master = 0;
361 return 1;
362 }
363
364 bands = temp1[bs_freq_scale - 1];
365
366#ifdef FIXED_POINT
367 rk0 = (real_t)k0 << REAL_BITS;
368 rk2 = (real_t)k2 << REAL_BITS;
369 if (rk2 > MUL_C(rk0, COEF_CONST(2.2449)))
370#else
371 if ((float)k2 / (float)k0 > 2.2449)
372#endif
373 {
374 twoRegions = 1;
375 k1 = k0 << 1;
376 } else {
377 twoRegions = 0;
378 k1 = k2;
379 }
380
381 nrBand0 = (uint8_t)(2 * find_bands(0, bands, k0, k1));
382 nrBand0 = min(nrBand0, 63);
383 if (nrBand0 <= 0) {
384 return 1;
385 }
386
387 q = find_initial_power(nrBand0, k0, k1);
388#ifdef FIXED_POINT
389 qk = (real_t)k0 << REAL_BITS;
390 //A_1 = (int32_t)((qk + REAL_CONST(0.5)) >> REAL_BITS);
391 A_1 = k0;
392#else
393 qk = REAL_CONST(k0);
394 A_1 = (int32_t)(qk + .5);
395#endif
396 for (k = 0; k <= nrBand0; k++) {
397 int32_t A_0 = A_1;
398#ifdef FIXED_POINT
399 qk = MUL_R(qk, q);
400 A_1 = (int32_t)((qk + REAL_CONST(0.5)) >> REAL_BITS);
401#else
402 qk *= q;
403 A_1 = (int32_t)(qk + 0.5);
404#endif
405 vDk0[k] = A_1 - A_0;
406 }
407
408 /* needed? */
409 qsort(vDk0, nrBand0, sizeof(vDk0[0]), longcmp);
410
411 vk0[0] = k0;
412 for (k = 1; k <= nrBand0; k++) {
413 vk0[k] = vk0[k - 1] + vDk0[k - 1];
414 if (vDk0[k - 1] == 0) {
415 return 1;
416 }
417 }
418
419 if (!twoRegions) {
420 for (k = 0; k <= nrBand0; k++) {
421 sbr->f_master[k] = (uint8_t) vk0[k];
422 }
423
424 sbr->N_master = nrBand0;
425 sbr->N_master = min(sbr->N_master, 64);
426 return 0;
427 }
428
429 nrBand1 = (uint8_t)(2 * find_bands(1 /* warped */, bands, k1, k2));
430 nrBand1 = min(nrBand1, 63);
431
432 q = find_initial_power(nrBand1, k1, k2);
433#ifdef FIXED_POINT
434 qk = (real_t)k1 << REAL_BITS;
435 //A_1 = (int32_t)((qk + REAL_CONST(0.5)) >> REAL_BITS);
436 A_1 = k1;
437#else
438 qk = REAL_CONST(k1);
439 A_1 = (int32_t)(qk + .5);
440#endif
441 for (k = 0; k <= nrBand1 - 1; k++) {
442 int32_t A_0 = A_1;
443#ifdef FIXED_POINT
444 qk = MUL_R(qk, q);
445 A_1 = (int32_t)((qk + REAL_CONST(0.5)) >> REAL_BITS);
446#else
447 qk *= q;
448 A_1 = (int32_t)(qk + 0.5);
449#endif
450 vDk1[k] = A_1 - A_0;
451 }
452
453 if (vDk1[0] < vDk0[nrBand0 - 1]) {
454 int32_t change;
455
456 /* needed? */
457 qsort(vDk1, nrBand1 + 1, sizeof(vDk1[0]), longcmp);
458 change = vDk0[nrBand0 - 1] - vDk1[0];
459 vDk1[0] = vDk0[nrBand0 - 1];
460 vDk1[nrBand1 - 1] = vDk1[nrBand1 - 1] - change;
461 }
462
463 /* needed? */
464 qsort(vDk1, nrBand1, sizeof(vDk1[0]), longcmp);
465 vk1[0] = k1;
466 for (k = 1; k <= nrBand1; k++) {
467 vk1[k] = vk1[k - 1] + vDk1[k - 1];
468 if (vDk1[k - 1] == 0) {
469 return 1;
470 }
471 }
472
473 sbr->N_master = nrBand0 + nrBand1;
474 sbr->N_master = min(sbr->N_master, 64);
475 for (k = 0; k <= nrBand0; k++) {
476 sbr->f_master[k] = (uint8_t) vk0[k];
477 }
478 for (k = nrBand0 + 1; k <= sbr->N_master; k++) {
479 sbr->f_master[k] = (uint8_t) vk1[k - nrBand0];
480 }
481
482#if 0
483 printf("f_master[%d]: ", sbr->N_master);
484 for (k = 0; k <= sbr->N_master; k++) {
485 printf("%d ", sbr->f_master[k]);
486 }
487 printf("\n");
488#endif
489
490 return 0;
491}
492
493/* calculate the derived frequency border tables from f_master */
494uint8_t derived_frequency_table(sbr_info *sbr, uint8_t bs_xover_band,
495 uint8_t k2)
496{
497 uint8_t k, i;
498 uint32_t minus;
499
500 /* The following relation shall be satisfied: bs_xover_band < N_Master */
501 if (sbr->N_master <= bs_xover_band) {
502 return 1;
503 }
504
505 sbr->N_high = sbr->N_master - bs_xover_band;
506 sbr->N_low = (sbr->N_high >> 1) + (sbr->N_high - ((sbr->N_high >> 1) << 1));
507
508 sbr->n[0] = sbr->N_low;
509 sbr->n[1] = sbr->N_high;
510
511 for (k = 0; k <= sbr->N_high; k++) {
512 sbr->f_table_res[HI_RES][k] = sbr->f_master[k + bs_xover_band];
513 }
514
515 sbr->M = sbr->f_table_res[HI_RES][sbr->N_high] - sbr->f_table_res[HI_RES][0];
516 sbr->kx = sbr->f_table_res[HI_RES][0];
517 if (sbr->kx > 32) {
518 return 1;
519 }
520 if (sbr->kx + sbr->M > 64) {
521 return 1;
522 }
523
524 minus = (sbr->N_high & 1) ? 1 : 0;
525
526 for (k = 0; k <= sbr->N_low; k++) {
527 if (k == 0) {
528 i = 0;
529 } else {
530 i = (uint8_t)(2 * k - minus);
531 }
532 sbr->f_table_res[LO_RES][k] = sbr->f_table_res[HI_RES][i];
533 }
534
535#if 0
536 printf("bs_freq_scale: %d\n", sbr->bs_freq_scale);
537 printf("bs_limiter_bands: %d\n", sbr->bs_limiter_bands);
538 printf("f_table_res[HI_RES][%d]: ", sbr->N_high);
539 for (k = 0; k <= sbr->N_high; k++) {
540 printf("%d ", sbr->f_table_res[HI_RES][k]);
541 }
542 printf("\n");
543#endif
544#if 0
545 printf("f_table_res[LO_RES][%d]: ", sbr->N_low);
546 for (k = 0; k <= sbr->N_low; k++) {
547 printf("%d ", sbr->f_table_res[LO_RES][k]);
548 }
549 printf("\n");
550#endif
551
552 sbr->N_Q = 0;
553 if (sbr->bs_noise_bands == 0) {
554 sbr->N_Q = 1;
555 } else {
556#if 0
557 sbr->N_Q = max(1, (int32_t)(sbr->bs_noise_bands * (log(k2 / (float)sbr->kx) / log(2.0)) + 0.5));
558#else
559 sbr->N_Q = (uint8_t)(max(1, find_bands(0, sbr->bs_noise_bands, sbr->kx, k2)));
560#endif
561 sbr->N_Q = min(5, sbr->N_Q);
562 }
563
564 for (k = 0; k <= sbr->N_Q; k++) {
565 if (k == 0) {
566 i = 0;
567 } else {
568 /* i = i + (int32_t)((sbr->N_low - i)/(sbr->N_Q + 1 - k)); */
569 i = i + (sbr->N_low - i) / (sbr->N_Q + 1 - k);
570 }
571 sbr->f_table_noise[k] = sbr->f_table_res[LO_RES][i];
572 }
573
574 /* build table for mapping k to g in hf patching */
575 for (k = 0; k < 64; k++) {
576 uint8_t g;
577 for (g = 0; g < sbr->N_Q; g++) {
578 if ((sbr->f_table_noise[g] <= k) &&
579 (k < sbr->f_table_noise[g + 1])) {
580 sbr->table_map_k_to_g[k] = g;
581 break;
582 }
583 }
584 }
585
586#if 0
587 printf("f_table_noise[%d]: ", sbr->N_Q);
588 for (k = 0; k <= sbr->N_Q; k++) {
589 printf("%d ", sbr->f_table_noise[k] - sbr->kx);
590 }
591 printf("\n");
592#endif
593
594 return 0;
595}
596
597/* TODO: blegh, ugly */
598/* Modified to calculate for all possible bs_limiter_bands always
599 * This reduces the number calls to this functions needed (now only on
600 * header reset)
601 */
602void limiter_frequency_table(sbr_info *sbr)
603{
604#if 0
605 static const real_t limiterBandsPerOctave[] = { REAL_CONST(1.2),
606 REAL_CONST(2), REAL_CONST(3)
607 };
608#else
609 static const real_t limiterBandsCompare[] = { REAL_CONST(1.327152),
610 REAL_CONST(1.185093), REAL_CONST(1.119872)
611 };
612#endif
613 uint8_t k, s;
614 int8_t nrLim;
615#if 0
616 real_t limBands;
617#endif
618
619 sbr->f_table_lim[0][0] = sbr->f_table_res[LO_RES][0] - sbr->kx;
620 sbr->f_table_lim[0][1] = sbr->f_table_res[LO_RES][sbr->N_low] - sbr->kx;
621 sbr->N_L[0] = 1;
622
623#if 0
624 printf("f_table_lim[%d][%d]: ", 0, sbr->N_L[0]);
625 for (k = 0; k <= sbr->N_L[0]; k++) {
626 printf("%d ", sbr->f_table_lim[0][k]);
627 }
628 printf("\n");
629#endif
630
631 for (s = 1; s < 4; s++) {
632 int32_t limTable[100 /*TODO*/] = {0};
633 uint8_t patchBorders[64/*??*/] = {0};
634
635#if 0
636 limBands = limiterBandsPerOctave[s - 1];
637#endif
638
639 patchBorders[0] = sbr->kx;
640 for (k = 1; k <= sbr->noPatches; k++) {
641 patchBorders[k] = patchBorders[k - 1] + sbr->patchNoSubbands[k - 1];
642 }
643
644 for (k = 0; k <= sbr->N_low; k++) {
645 limTable[k] = sbr->f_table_res[LO_RES][k];
646 }
647 for (k = 1; k < sbr->noPatches; k++) {
648 limTable[k + sbr->N_low] = patchBorders[k];
649 }
650
651 /* needed */
652 qsort(limTable, sbr->noPatches + sbr->N_low, sizeof(limTable[0]), longcmp);
653 k = 1;
654 nrLim = sbr->noPatches + sbr->N_low - 1;
655
656 if (nrLim < 0) { // TODO: BIG FAT PROBLEM
657 return;
658 }
659
660restart:
661 if (k <= nrLim) {
662 real_t nOctaves;
663
664 if (limTable[k - 1] != 0)
665#if 0
666 nOctaves = REAL_CONST(log((float)limTable[k] / (float)limTable[k - 1]) / log(2.0));
667#else
668#ifdef FIXED_POINT
669 nOctaves = DIV_R((limTable[k] << REAL_BITS), REAL_CONST(limTable[k - 1]));
670#else
671 nOctaves = (real_t)limTable[k] / (real_t)limTable[k - 1];
672#endif
673#endif
674 else {
675 nOctaves = 0;
676 }
677
678#if 0
679 if ((MUL_R(nOctaves, limBands)) < REAL_CONST(0.49))
680#else
681 if (nOctaves < limiterBandsCompare[s - 1])
682#endif
683 {
684 uint8_t i;
685 if (limTable[k] != limTable[k - 1]) {
686 uint8_t found = 0, found2 = 0;
687 for (i = 0; i <= sbr->noPatches; i++) {
688 if (limTable[k] == patchBorders[i]) {
689 found = 1;
690 }
691 }
692 if (found) {
693 found2 = 0;
694 for (i = 0; i <= sbr->noPatches; i++) {
695 if (limTable[k - 1] == patchBorders[i]) {
696 found2 = 1;
697 }
698 }
699 if (found2) {
700 k++;
701 goto restart;
702 } else {
703 /* remove (k-1)th element */
704 limTable[k - 1] = sbr->f_table_res[LO_RES][sbr->N_low];
705 qsort(limTable, sbr->noPatches + sbr->N_low, sizeof(limTable[0]), longcmp);
706 nrLim--;
707 goto restart;
708 }
709 }
710 }
711 /* remove kth element */
712 limTable[k] = sbr->f_table_res[LO_RES][sbr->N_low];
713 qsort(limTable, nrLim, sizeof(limTable[0]), longcmp);
714 nrLim--;
715 goto restart;
716 } else {
717 k++;
718 goto restart;
719 }
720 }
721
722 sbr->N_L[s] = nrLim;
723 for (k = 0; k <= nrLim; k++) {
724 sbr->f_table_lim[s][k] = limTable[k] - sbr->kx;
725 }
726
727#if 0
728 printf("f_table_lim[%d][%d]: ", s, sbr->N_L[s]);
729 for (k = 0; k <= sbr->N_L[s]; k++) {
730 printf("%d ", sbr->f_table_lim[s][k]);
731 }
732 printf("\n");
733#endif
734 }
735}
736
737#endif
738
generated by cgit at 2024-05-18 21:28:57 (GMT)