1 /*****************************************************************************
2 * bit_allocate.c: A52 allocation tables
3 *****************************************************************************
4 * Copyright (C) 2000-2001 VideoLAN
5 * $Id: bit_allocate.c,v 1.1 2002/08/04 17:23:42 sam Exp $
7 * Authors: Michel Kaempf <maxx@via.ecp.fr>
8 * Aaron Holtzman <aholtzma@engr.uvic.ca>
9 * Renaud Dartus <reno@videolan.org>
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
24 *****************************************************************************/
26 /*****************************************************************************
28 *****************************************************************************/
29 #include <string.h> /* memcpy() */
32 #include <vlc/decoder.h>
38 #include "internal.h" /* DELTA_BIT_REUSE */
41 static void ba_compute_psd (bit_allocate_t * p_bit, s16 start, s16 end, s16 exps[]);
43 static void ba_compute_excitation (bit_allocate_t * p_bit, s16 start, s16 end, s16 fgain,
44 s16 fastleak, s16 slowleak, s16 is_lfe);
45 static void ba_compute_mask (bit_allocate_t * p_bit, s16 start, s16 end, u16 fscod,
46 u16 deltbae, u16 deltnseg, u16 deltoffst[],
47 u16 deltba[], u16 deltlen[]);
48 static void ba_compute_bap (bit_allocate_t * p_bit, s16 start, s16 end,
49 s16 snroffset, s16 bap[]);
51 /* Misc LUTs for bit allocation process */
53 static const s16 slowdec[] = { 0x0f, 0x11, 0x13, 0x15 };
54 static const s16 fastdec[] = { 0x3f, 0x53, 0x67, 0x7b };
55 static const s16 slowgain[] = { 0x540, 0x4d8, 0x478, 0x410 };
56 static const s16 dbpbtab[] = { 0x000, 0x700, 0x900, 0xb00 };
58 static const u16 floortab[] = { 0x2f0, 0x2b0, 0x270, 0x230, 0x1f0, 0x170, 0x0f0, 0xf800 };
59 static const s16 fastgain[] = { 0x080, 0x100, 0x180, 0x200, 0x280, 0x300, 0x380, 0x400 };
61 static const s16 bndtab[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
62 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
63 20, 21, 22, 23, 24, 25, 26, 27, 28, 31,
64 34, 37, 40, 43, 46, 49, 55, 61, 67, 73,
65 79, 85, 97, 109, 121, 133, 157, 181, 205, 229 };
67 static const s16 bndsz[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
68 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
69 1, 1, 1, 1, 1, 1, 1, 1, 3, 3,
70 3, 3, 3, 3, 3, 6, 6, 6, 6, 6,
71 6, 12, 12, 12, 12, 24, 24, 24, 24, 24 };
73 static const s16 masktab[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
74 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 28, 28, 29,
75 29, 29, 30, 30, 30, 31, 31, 31, 32, 32, 32, 33, 33, 33, 34, 34,
76 34, 35, 35, 35, 35, 35, 35, 36, 36, 36, 36, 36, 36, 37, 37, 37,
77 37, 37, 37, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 40,
78 40, 40, 40, 40, 40, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
79 41, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 43, 43, 43,
80 43, 43, 43, 43, 43, 43, 43, 43, 43, 44, 44, 44, 44, 44, 44, 44,
81 44, 44, 44, 44, 44, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
82 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 46, 46, 46,
83 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
84 46, 46, 46, 46, 46, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
85 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 48, 48, 48,
86 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
87 48, 48, 48, 48, 48, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
88 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 0, 0, 0 };
91 static const s16 latab[] = { 0x0040, 0x003f, 0x003e, 0x003d, 0x003c, 0x003b, 0x003a, 0x0039,
92 0x0038, 0x0037, 0x0036, 0x0035, 0x0034, 0x0034, 0x0033, 0x0032,
93 0x0031, 0x0030, 0x002f, 0x002f, 0x002e, 0x002d, 0x002c, 0x002c,
94 0x002b, 0x002a, 0x0029, 0x0029, 0x0028, 0x0027, 0x0026, 0x0026,
95 0x0025, 0x0024, 0x0024, 0x0023, 0x0023, 0x0022, 0x0021, 0x0021,
96 0x0020, 0x0020, 0x001f, 0x001e, 0x001e, 0x001d, 0x001d, 0x001c,
97 0x001c, 0x001b, 0x001b, 0x001a, 0x001a, 0x0019, 0x0019, 0x0018,
98 0x0018, 0x0017, 0x0017, 0x0016, 0x0016, 0x0015, 0x0015, 0x0015,
99 0x0014, 0x0014, 0x0013, 0x0013, 0x0013, 0x0012, 0x0012, 0x0012,
100 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x000f, 0x000f,
101 0x000f, 0x000e, 0x000e, 0x000e, 0x000d, 0x000d, 0x000d, 0x000d,
102 0x000c, 0x000c, 0x000c, 0x000c, 0x000b, 0x000b, 0x000b, 0x000b,
103 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x0009, 0x0009, 0x0009,
104 0x0009, 0x0009, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008,
105 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0006, 0x0006,
106 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0005, 0x0005,
107 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0004, 0x0004,
108 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
109 0x0004, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003,
110 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0002,
111 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
112 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
113 0x0002, 0x0002, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
114 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
115 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
116 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
117 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
118 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
119 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
120 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
121 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
122 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
123 0x0000, 0x0000, 0x0000, 0x0000};
125 static const s16 hth[][50] = {{ 0x04d0, 0x04d0, 0x0440, 0x0400, 0x03e0, 0x03c0, 0x03b0, 0x03b0,
126 0x03a0, 0x03a0, 0x03a0, 0x03a0, 0x03a0, 0x0390, 0x0390, 0x0390,
127 0x0380, 0x0380, 0x0370, 0x0370, 0x0360, 0x0360, 0x0350, 0x0350,
128 0x0340, 0x0340, 0x0330, 0x0320, 0x0310, 0x0300, 0x02f0, 0x02f0,
129 0x02f0, 0x02f0, 0x0300, 0x0310, 0x0340, 0x0390, 0x03e0, 0x0420,
130 0x0460, 0x0490, 0x04a0, 0x0460, 0x0440, 0x0440, 0x0520, 0x0800,
133 { 0x04f0, 0x04f0, 0x0460, 0x0410, 0x03e0, 0x03d0, 0x03c0, 0x03b0,
134 0x03b0, 0x03a0, 0x03a0, 0x03a0, 0x03a0, 0x03a0, 0x0390, 0x0390,
135 0x0390, 0x0380, 0x0380, 0x0380, 0x0370, 0x0370, 0x0360, 0x0360,
136 0x0350, 0x0350, 0x0340, 0x0340, 0x0320, 0x0310, 0x0300, 0x02f0,
137 0x02f0, 0x02f0, 0x02f0, 0x0300, 0x0320, 0x0350, 0x0390, 0x03e0,
138 0x0420, 0x0450, 0x04a0, 0x0490, 0x0460, 0x0440, 0x0480, 0x0630,
141 { 0x0580, 0x0580, 0x04b0, 0x0450, 0x0420, 0x03f0, 0x03e0, 0x03d0,
142 0x03c0, 0x03b0, 0x03b0, 0x03b0, 0x03a0, 0x03a0, 0x03a0, 0x03a0,
143 0x03a0, 0x03a0, 0x03a0, 0x03a0, 0x0390, 0x0390, 0x0390, 0x0390,
144 0x0380, 0x0380, 0x0380, 0x0370, 0x0360, 0x0350, 0x0340, 0x0330,
145 0x0320, 0x0310, 0x0300, 0x02f0, 0x02f0, 0x02f0, 0x0300, 0x0310,
146 0x0330, 0x0350, 0x03c0, 0x0410, 0x0470, 0x04a0, 0x0460, 0x0440,
150 static const s16 baptab[] = { 0, 1, 1, 1, 1, 1, 2, 2, 3, 3, 3, 4, 4, 5, 5, 6,
151 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 10,
152 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13, 13, 13, 14,
153 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15 };
155 static inline u16 max_value (s16 a, s16 b)
157 return (a > b ? a : b);
160 static inline u16 min_value (s16 a, s16 b)
162 return (a < b ? a : b);
165 static inline s16 logadd (s16 a, s16 b)
169 if ((c = a - b) >= 0) {
170 return (a + latab[min_value(((c) >> 1), 255)]);
172 return (b + latab[min_value(((-c) >> 1), 255)]);
176 static inline s16 calc_lowcomp (s16 a, s16 b0, s16 b1, s16 bin)
179 if ((b0 + 256) == b1)
182 a = max_value(0, a - 64);
183 } else if (bin < 20) {
184 if ((b0 + 256) == b1)
187 a = max_value(0, a - 64) ;
189 a = max_value(0, a - 128);
194 void bit_allocate (a52dec_t * p_a52dec)
204 /* Only perform bit_allocation if the exponents have changed or we
205 * have new sideband information */
206 if (p_a52dec->audblk.chexpstr[0] == 0 && p_a52dec->audblk.chexpstr[1] == 0 &&
207 p_a52dec->audblk.chexpstr[2] == 0 && p_a52dec->audblk.chexpstr[3] == 0 &&
208 p_a52dec->audblk.chexpstr[4] == 0 && p_a52dec->audblk.cplexpstr == 0 &&
209 p_a52dec->audblk.lfeexpstr == 0 && p_a52dec->audblk.baie == 0 &&
210 p_a52dec->audblk.snroffste == 0 && p_a52dec->audblk.deltbaie == 0)
213 /* Do some setup before we do the bit alloc */
214 p_a52dec->bit_allocate.sdecay = slowdec[p_a52dec->audblk.sdcycod];
215 p_a52dec->bit_allocate.fdecay = fastdec[p_a52dec->audblk.fdcycod];
216 p_a52dec->bit_allocate.sgain = slowgain[p_a52dec->audblk.sgaincod];
217 p_a52dec->bit_allocate.dbknee = dbpbtab[p_a52dec->audblk.dbpbcod];
218 p_a52dec->bit_allocate.floor = floortab[p_a52dec->audblk.floorcod];
220 /* if all the SNR offset constants are zero then the whole block is zero */
221 if (!p_a52dec->audblk.csnroffst && !p_a52dec->audblk.fsnroffst[0] &&
222 !p_a52dec->audblk.fsnroffst[1] && !p_a52dec->audblk.fsnroffst[2] &&
223 !p_a52dec->audblk.fsnroffst[3] && !p_a52dec->audblk.fsnroffst[4] &&
224 !p_a52dec->audblk.cplfsnroffst && !p_a52dec->audblk.lfefsnroffst) {
225 memset(p_a52dec->audblk.fbw_bap,0,sizeof(u16) * 256 * 5);
226 memset(p_a52dec->audblk.cpl_bap,0,sizeof(u16) * 256);
227 memset(p_a52dec->audblk.lfe_bap,0,sizeof(u16) * 7);
231 for (i = 0; i < p_a52dec->bsi.nfchans; i++) {
233 end = p_a52dec->audblk.endmant[i] ;
234 fgain = fastgain[p_a52dec->audblk.fgaincod[i]];
235 snroffset = (((p_a52dec->audblk.csnroffst - 15) << 4) + p_a52dec->audblk.fsnroffst[i]) << 2;
239 ba_compute_psd (&p_a52dec->bit_allocate, start, end, p_a52dec->audblk.fbw_exp[i]);
241 ba_compute_excitation (&p_a52dec->bit_allocate, start, end , fgain, fastleak, slowleak, 0);
243 ba_compute_mask (&p_a52dec->bit_allocate, start, end, p_a52dec->syncinfo.fscod,
244 p_a52dec->audblk.deltbae[i],
245 p_a52dec->audblk.deltnseg[i],
246 p_a52dec->audblk.deltoffst[i],
247 p_a52dec->audblk.deltba[i],
248 p_a52dec->audblk.deltlen[i]);
250 ba_compute_bap (&p_a52dec->bit_allocate, start, end, snroffset, p_a52dec->audblk.fbw_bap[i]);
253 if (p_a52dec->audblk.cplinu) {
254 start = p_a52dec->audblk.cplstrtmant;
255 end = p_a52dec->audblk.cplendmant;
256 fgain = fastgain[p_a52dec->audblk.cplfgaincod];
257 snroffset = (((p_a52dec->audblk.csnroffst - 15) << 4) + p_a52dec->audblk.cplfsnroffst) << 2 ;
258 fastleak = (p_a52dec->audblk.cplfleak << 8) + 768;
259 slowleak = (p_a52dec->audblk.cplsleak << 8) + 768;
261 ba_compute_psd (&p_a52dec->bit_allocate, start, end, p_a52dec->audblk.cpl_exp);
263 ba_compute_excitation (&p_a52dec->bit_allocate, start, end , fgain, fastleak, slowleak, 0);
265 ba_compute_mask (&p_a52dec->bit_allocate, start, end, p_a52dec->syncinfo.fscod,
266 p_a52dec->audblk.cpldeltbae,
267 p_a52dec->audblk.cpldeltnseg,
268 p_a52dec->audblk.cpldeltoffst,
269 p_a52dec->audblk.cpldeltba,
270 p_a52dec->audblk.cpldeltlen);
272 ba_compute_bap (&p_a52dec->bit_allocate, start, end, snroffset, p_a52dec->audblk.cpl_bap);
275 if (p_a52dec->bsi.lfeon) {
278 fgain = fastgain[p_a52dec->audblk.lfefgaincod];
279 snroffset = (((p_a52dec->audblk.csnroffst - 15) << 4) + p_a52dec->audblk.lfefsnroffst) << 2 ;
283 ba_compute_psd (&p_a52dec->bit_allocate, start, end, p_a52dec->audblk.lfe_exp);
285 ba_compute_excitation (&p_a52dec->bit_allocate, start, end , fgain, fastleak, slowleak, 1);
287 ba_compute_mask (&p_a52dec->bit_allocate, start, end, p_a52dec->syncinfo.fscod, 2, 0, 0, 0, 0);
289 ba_compute_bap (&p_a52dec->bit_allocate, start, end, snroffset, p_a52dec->audblk.lfe_bap);
294 static void ba_compute_psd (bit_allocate_t * p_bit, s16 start, s16 end, s16 exps[])
299 /* Map the exponents into dBs */
300 for (bin=start; bin<end; bin++) {
301 p_bit->psd[bin] = (3072 - (exps[bin] << 7));
304 /* Integrate the psd function over each bit allocation band */
309 lastbin = min_value(bndtab[k] + bndsz[k], end);
310 p_bit->bndpsd[k] = p_bit->psd[j];
313 for (; j < lastbin; j++) {
314 p_bit->bndpsd[k] = logadd(p_bit->bndpsd[k],p_bit->psd[j]);
318 } while (end > lastbin);
321 static void ba_compute_excitation (bit_allocate_t * p_bit, s16 start, s16 end,
322 s16 fgain, s16 fastleak, s16 slowleak, s16 is_lfe)
330 /* Compute excitation function */
331 bndstrt = masktab[start];
332 bndend = masktab[end - 1] + 1;
334 if (bndstrt == 0) { /* For fbw and lfe channels */
335 lowcomp = calc_lowcomp(lowcomp, p_bit->bndpsd[0], p_bit->bndpsd[1], 0);
336 p_bit->excite[0] = p_bit->bndpsd[0] - fgain - lowcomp;
337 lowcomp = calc_lowcomp(lowcomp, p_bit->bndpsd[1], p_bit->bndpsd[2], 1);
338 p_bit->excite[1] = p_bit->bndpsd[1] - fgain - lowcomp;
341 /* Note: Do not call calc_lowcomp() for the last band of the lfe channel, (bin = 6) */
342 for (bin = 2; bin < 7; bin++) {
343 if (!(is_lfe && (bin == 6)))
344 lowcomp = calc_lowcomp (lowcomp, p_bit->bndpsd[bin], p_bit->bndpsd[bin+1], bin);
345 fastleak = p_bit->bndpsd[bin] - fgain;
346 slowleak = p_bit->bndpsd[bin] - p_bit->sgain;
347 p_bit->excite[bin] = fastleak - lowcomp;
349 if (!(is_lfe && (bin == 6))) {
350 if (p_bit->bndpsd[bin] <=
351 p_bit->bndpsd[bin+1])
359 for (bin = begin; bin < min_value(bndend, 22); bin++) {
360 if (!(is_lfe && (bin == 6)))
361 lowcomp = calc_lowcomp (lowcomp, p_bit->bndpsd[bin],
362 p_bit->bndpsd[bin+1], bin);
363 fastleak -= p_bit->fdecay ;
364 fastleak = max_value(fastleak, p_bit->bndpsd[bin] - fgain);
365 slowleak -= p_bit->sdecay ;
366 slowleak = max_value(slowleak, p_bit->bndpsd[bin] - p_bit->sgain);
367 p_bit->excite[bin] = max_value(fastleak - lowcomp, slowleak);
370 } else { /* For coupling channel */
374 for (bin = begin; bin < bndend; bin++) {
375 fastleak -= p_bit->fdecay;
376 fastleak = max_value(fastleak, p_bit->bndpsd[bin] - fgain);
377 slowleak -= p_bit->sdecay;
378 slowleak = max_value(slowleak, p_bit->bndpsd[bin] - p_bit->sgain);
379 p_bit->excite[bin] = max_value(fastleak, slowleak) ;
383 static void ba_compute_mask (bit_allocate_t * p_bit, s16 start, s16 end, u16 fscod,
384 u16 deltbae, u16 deltnseg, u16 deltoffst[],
385 u16 deltba[], u16 deltlen[])
392 bndstrt = masktab[start];
393 bndend = masktab[end - 1] + 1;
395 /* Compute the masking curve */
396 for (bin = bndstrt; bin < bndend; bin++) {
397 if (p_bit->bndpsd[bin] < p_bit->dbknee) {
398 p_bit->excite[bin] += ((p_bit->dbknee - p_bit->bndpsd[bin]) >> 2);
400 p_bit->mask[bin] = max_value(p_bit->excite[bin], hth[fscod][bin]);
403 /* Perform delta bit modulation if necessary */
404 if ((deltbae == DELTA_BIT_REUSE) || (deltbae == DELTA_BIT_NEW)) {
408 for (seg = 0; seg < deltnseg+1; seg++) {
409 band += deltoffst[seg];
410 if (deltba[seg] >= 4) {
411 delta = (deltba[seg] - 3) << 7;
413 delta = (deltba[seg] - 4) << 7;
415 for (k = 0; k < deltlen[seg]; k++) {
416 p_bit->mask[band] += delta;
423 static void ba_compute_bap (bit_allocate_t * p_bit, s16 start, s16 end, s16 snroffset,
430 /* Compute the bit allocation pointer for each bin */
435 lastbin = min_value(bndtab[j] + bndsz[j], end);
436 p_bit->mask[j] -= snroffset;
437 p_bit->mask[j] -= p_bit->floor;
439 if (p_bit->mask[j] < 0)
442 p_bit->mask[j] &= 0x1fe0;
443 p_bit->mask[j] += p_bit->floor;
444 for (k = i; k < lastbin; k++) {
445 address = (p_bit->psd[i] - p_bit->mask[j]) >> 5;
446 address = min_value(63, max_value(0, address));
447 bap[i] = baptab[address];
451 } while (end > lastbin);