1 /*****************************************************************************
2 * ac3_bit_allocate.c: ac3 allocation tables
3 *****************************************************************************
4 * Copyright (C) 2000 VideoLAN
5 * $Id: ac3_bit_allocate.c,v 1.22 2001/05/15 16:19: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 *****************************************************************************/
31 #include <string.h> /* memcpy() */
38 #include "stream_control.h"
39 #include "input_ext-dec.h"
41 #include "ac3_imdct.h"
42 #include "ac3_downmix.h"
43 #include "ac3_decoder.h"
45 #include "ac3_internal.h" /* DELTA_BIT_REUSE */
48 static void ba_compute_psd (bit_allocate_t * p_bit, s16 start, s16 end, s16 exps[]);
50 static void ba_compute_excitation (bit_allocate_t * p_bit, s16 start, s16 end, s16 fgain,
51 s16 fastleak, s16 slowleak, s16 is_lfe);
52 static void ba_compute_mask (bit_allocate_t * p_bit, s16 start, s16 end, u16 fscod,
53 u16 deltbae, u16 deltnseg, u16 deltoffst[],
54 u16 deltba[], u16 deltlen[]);
55 static void ba_compute_bap (bit_allocate_t * p_bit, s16 start, s16 end,
56 s16 snroffset, s16 bap[]);
58 /* Misc LUTs for bit allocation process */
60 static const s16 slowdec[] = { 0x0f, 0x11, 0x13, 0x15 };
61 static const s16 fastdec[] = { 0x3f, 0x53, 0x67, 0x7b };
62 static const s16 slowgain[] = { 0x540, 0x4d8, 0x478, 0x410 };
63 static const s16 dbpbtab[] = { 0x000, 0x700, 0x900, 0xb00 };
65 static const u16 floortab[] = { 0x2f0, 0x2b0, 0x270, 0x230, 0x1f0, 0x170, 0x0f0, 0xf800 };
66 static const s16 fastgain[] = { 0x080, 0x100, 0x180, 0x200, 0x280, 0x300, 0x380, 0x400 };
68 static const s16 bndtab[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
69 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
70 20, 21, 22, 23, 24, 25, 26, 27, 28, 31,
71 34, 37, 40, 43, 46, 49, 55, 61, 67, 73,
72 79, 85, 97, 109, 121, 133, 157, 181, 205, 229 };
74 static const s16 bndsz[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
75 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
76 1, 1, 1, 1, 1, 1, 1, 1, 3, 3,
77 3, 3, 3, 3, 3, 6, 6, 6, 6, 6,
78 6, 12, 12, 12, 12, 24, 24, 24, 24, 24 };
80 static const s16 masktab[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
81 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 28, 28, 29,
82 29, 29, 30, 30, 30, 31, 31, 31, 32, 32, 32, 33, 33, 33, 34, 34,
83 34, 35, 35, 35, 35, 35, 35, 36, 36, 36, 36, 36, 36, 37, 37, 37,
84 37, 37, 37, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 40,
85 40, 40, 40, 40, 40, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
86 41, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 43, 43, 43,
87 43, 43, 43, 43, 43, 43, 43, 43, 43, 44, 44, 44, 44, 44, 44, 44,
88 44, 44, 44, 44, 44, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
89 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 46, 46, 46,
90 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
91 46, 46, 46, 46, 46, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
92 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 48, 48, 48,
93 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
94 48, 48, 48, 48, 48, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
95 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 0, 0, 0 };
98 static const s16 latab[] = { 0x0040, 0x003f, 0x003e, 0x003d, 0x003c, 0x003b, 0x003a, 0x0039,
99 0x0038, 0x0037, 0x0036, 0x0035, 0x0034, 0x0034, 0x0033, 0x0032,
100 0x0031, 0x0030, 0x002f, 0x002f, 0x002e, 0x002d, 0x002c, 0x002c,
101 0x002b, 0x002a, 0x0029, 0x0029, 0x0028, 0x0027, 0x0026, 0x0026,
102 0x0025, 0x0024, 0x0024, 0x0023, 0x0023, 0x0022, 0x0021, 0x0021,
103 0x0020, 0x0020, 0x001f, 0x001e, 0x001e, 0x001d, 0x001d, 0x001c,
104 0x001c, 0x001b, 0x001b, 0x001a, 0x001a, 0x0019, 0x0019, 0x0018,
105 0x0018, 0x0017, 0x0017, 0x0016, 0x0016, 0x0015, 0x0015, 0x0015,
106 0x0014, 0x0014, 0x0013, 0x0013, 0x0013, 0x0012, 0x0012, 0x0012,
107 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x000f, 0x000f,
108 0x000f, 0x000e, 0x000e, 0x000e, 0x000d, 0x000d, 0x000d, 0x000d,
109 0x000c, 0x000c, 0x000c, 0x000c, 0x000b, 0x000b, 0x000b, 0x000b,
110 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x0009, 0x0009, 0x0009,
111 0x0009, 0x0009, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008,
112 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0006, 0x0006,
113 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0005, 0x0005,
114 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0004, 0x0004,
115 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
116 0x0004, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003,
117 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0002,
118 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
119 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
120 0x0002, 0x0002, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
121 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
122 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
123 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
124 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
125 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
126 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
127 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
128 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
129 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
130 0x0000, 0x0000, 0x0000, 0x0000};
132 static const s16 hth[][50] = {{ 0x04d0, 0x04d0, 0x0440, 0x0400, 0x03e0, 0x03c0, 0x03b0, 0x03b0,
133 0x03a0, 0x03a0, 0x03a0, 0x03a0, 0x03a0, 0x0390, 0x0390, 0x0390,
134 0x0380, 0x0380, 0x0370, 0x0370, 0x0360, 0x0360, 0x0350, 0x0350,
135 0x0340, 0x0340, 0x0330, 0x0320, 0x0310, 0x0300, 0x02f0, 0x02f0,
136 0x02f0, 0x02f0, 0x0300, 0x0310, 0x0340, 0x0390, 0x03e0, 0x0420,
137 0x0460, 0x0490, 0x04a0, 0x0460, 0x0440, 0x0440, 0x0520, 0x0800,
140 { 0x04f0, 0x04f0, 0x0460, 0x0410, 0x03e0, 0x03d0, 0x03c0, 0x03b0,
141 0x03b0, 0x03a0, 0x03a0, 0x03a0, 0x03a0, 0x03a0, 0x0390, 0x0390,
142 0x0390, 0x0380, 0x0380, 0x0380, 0x0370, 0x0370, 0x0360, 0x0360,
143 0x0350, 0x0350, 0x0340, 0x0340, 0x0320, 0x0310, 0x0300, 0x02f0,
144 0x02f0, 0x02f0, 0x02f0, 0x0300, 0x0320, 0x0350, 0x0390, 0x03e0,
145 0x0420, 0x0450, 0x04a0, 0x0490, 0x0460, 0x0440, 0x0480, 0x0630,
148 { 0x0580, 0x0580, 0x04b0, 0x0450, 0x0420, 0x03f0, 0x03e0, 0x03d0,
149 0x03c0, 0x03b0, 0x03b0, 0x03b0, 0x03a0, 0x03a0, 0x03a0, 0x03a0,
150 0x03a0, 0x03a0, 0x03a0, 0x03a0, 0x0390, 0x0390, 0x0390, 0x0390,
151 0x0380, 0x0380, 0x0380, 0x0370, 0x0360, 0x0350, 0x0340, 0x0330,
152 0x0320, 0x0310, 0x0300, 0x02f0, 0x02f0, 0x02f0, 0x0300, 0x0310,
153 0x0330, 0x0350, 0x03c0, 0x0410, 0x0470, 0x04a0, 0x0460, 0x0440,
157 static const s16 baptab[] = { 0, 1, 1, 1, 1, 1, 2, 2, 3, 3, 3, 4, 4, 5, 5, 6,
158 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 10,
159 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13, 13, 13, 14,
160 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15 };
162 static __inline__ u16 max_value (s16 a, s16 b)
164 return (a > b ? a : b);
167 static __inline__ u16 min_value (s16 a, s16 b)
169 return (a < b ? a : b);
172 static __inline__ s16 logadd (s16 a, s16 b)
176 if ((c = a - b) >= 0) {
177 return (a + latab[min_value(((c) >> 1), 255)]);
179 return (b + latab[min_value(((-c) >> 1), 255)]);
183 static __inline__ s16 calc_lowcomp (s16 a, s16 b0, s16 b1, s16 bin)
186 if ((b0 + 256) == b1)
189 a = max_value(0, a - 64);
190 } else if (bin < 20) {
191 if ((b0 + 256) == b1)
194 a = max_value(0, a - 64) ;
196 a = max_value(0, a - 128);
201 void bit_allocate (ac3dec_t * p_ac3dec)
211 /* Only perform bit_allocation if the exponents have changed or we
212 * have new sideband information */
213 if (p_ac3dec->audblk.chexpstr[0] == 0 && p_ac3dec->audblk.chexpstr[1] == 0 &&
214 p_ac3dec->audblk.chexpstr[2] == 0 && p_ac3dec->audblk.chexpstr[3] == 0 &&
215 p_ac3dec->audblk.chexpstr[4] == 0 && p_ac3dec->audblk.cplexpstr == 0 &&
216 p_ac3dec->audblk.lfeexpstr == 0 && p_ac3dec->audblk.baie == 0 &&
217 p_ac3dec->audblk.snroffste == 0 && p_ac3dec->audblk.deltbaie == 0)
220 /* Do some setup before we do the bit alloc */
221 p_ac3dec->bit_allocate.sdecay = slowdec[p_ac3dec->audblk.sdcycod];
222 p_ac3dec->bit_allocate.fdecay = fastdec[p_ac3dec->audblk.fdcycod];
223 p_ac3dec->bit_allocate.sgain = slowgain[p_ac3dec->audblk.sgaincod];
224 p_ac3dec->bit_allocate.dbknee = dbpbtab[p_ac3dec->audblk.dbpbcod];
225 p_ac3dec->bit_allocate.floor = floortab[p_ac3dec->audblk.floorcod];
227 /* if all the SNR offset constants are zero then the whole block is zero */
228 if (!p_ac3dec->audblk.csnroffst && !p_ac3dec->audblk.fsnroffst[0] &&
229 !p_ac3dec->audblk.fsnroffst[1] && !p_ac3dec->audblk.fsnroffst[2] &&
230 !p_ac3dec->audblk.fsnroffst[3] && !p_ac3dec->audblk.fsnroffst[4] &&
231 !p_ac3dec->audblk.cplfsnroffst && !p_ac3dec->audblk.lfefsnroffst) {
232 memset(p_ac3dec->audblk.fbw_bap,0,sizeof(u16) * 256 * 5);
233 memset(p_ac3dec->audblk.cpl_bap,0,sizeof(u16) * 256);
234 memset(p_ac3dec->audblk.lfe_bap,0,sizeof(u16) * 7);
238 for (i = 0; i < p_ac3dec->bsi.nfchans; i++) {
240 end = p_ac3dec->audblk.endmant[i] ;
241 fgain = fastgain[p_ac3dec->audblk.fgaincod[i]];
242 snroffset = (((p_ac3dec->audblk.csnroffst - 15) << 4) + p_ac3dec->audblk.fsnroffst[i]) << 2;
246 ba_compute_psd (&p_ac3dec->bit_allocate, start, end, p_ac3dec->audblk.fbw_exp[i]);
248 ba_compute_excitation (&p_ac3dec->bit_allocate, start, end , fgain, fastleak, slowleak, 0);
250 ba_compute_mask (&p_ac3dec->bit_allocate, start, end, p_ac3dec->syncinfo.fscod,
251 p_ac3dec->audblk.deltbae[i],
252 p_ac3dec->audblk.deltnseg[i],
253 p_ac3dec->audblk.deltoffst[i],
254 p_ac3dec->audblk.deltba[i],
255 p_ac3dec->audblk.deltlen[i]);
257 ba_compute_bap (&p_ac3dec->bit_allocate, start, end, snroffset, p_ac3dec->audblk.fbw_bap[i]);
260 if (p_ac3dec->audblk.cplinu) {
261 start = p_ac3dec->audblk.cplstrtmant;
262 end = p_ac3dec->audblk.cplendmant;
263 fgain = fastgain[p_ac3dec->audblk.cplfgaincod];
264 snroffset = (((p_ac3dec->audblk.csnroffst - 15) << 4) + p_ac3dec->audblk.cplfsnroffst) << 2 ;
265 fastleak = (p_ac3dec->audblk.cplfleak << 8) + 768;
266 slowleak = (p_ac3dec->audblk.cplsleak << 8) + 768;
268 ba_compute_psd (&p_ac3dec->bit_allocate, start, end, p_ac3dec->audblk.cpl_exp);
270 ba_compute_excitation (&p_ac3dec->bit_allocate, start, end , fgain, fastleak, slowleak, 0);
272 ba_compute_mask (&p_ac3dec->bit_allocate, start, end, p_ac3dec->syncinfo.fscod,
273 p_ac3dec->audblk.cpldeltbae,
274 p_ac3dec->audblk.cpldeltnseg,
275 p_ac3dec->audblk.cpldeltoffst,
276 p_ac3dec->audblk.cpldeltba,
277 p_ac3dec->audblk.cpldeltlen);
279 ba_compute_bap (&p_ac3dec->bit_allocate, start, end, snroffset, p_ac3dec->audblk.cpl_bap);
282 if (p_ac3dec->bsi.lfeon) {
285 fgain = fastgain[p_ac3dec->audblk.lfefgaincod];
286 snroffset = (((p_ac3dec->audblk.csnroffst - 15) << 4) + p_ac3dec->audblk.lfefsnroffst) << 2 ;
290 ba_compute_psd (&p_ac3dec->bit_allocate, start, end, p_ac3dec->audblk.lfe_exp);
292 ba_compute_excitation (&p_ac3dec->bit_allocate, start, end , fgain, fastleak, slowleak, 1);
294 ba_compute_mask (&p_ac3dec->bit_allocate, start, end, p_ac3dec->syncinfo.fscod, 2, 0, 0, 0, 0);
296 ba_compute_bap (&p_ac3dec->bit_allocate, start, end, snroffset, p_ac3dec->audblk.lfe_bap);
301 static void ba_compute_psd (bit_allocate_t * p_bit, s16 start, s16 end, s16 exps[])
306 /* Map the exponents into dBs */
307 for (bin=start; bin<end; bin++) {
308 p_bit->psd[bin] = (3072 - (exps[bin] << 7));
311 /* Integrate the psd function over each bit allocation band */
316 lastbin = min_value(bndtab[k] + bndsz[k], end);
317 p_bit->bndpsd[k] = p_bit->psd[j];
320 for (; j < lastbin; j++) {
321 p_bit->bndpsd[k] = logadd(p_bit->bndpsd[k],p_bit->psd[j]);
325 } while (end > lastbin);
328 static void ba_compute_excitation (bit_allocate_t * p_bit, s16 start, s16 end,
329 s16 fgain, s16 fastleak, s16 slowleak, s16 is_lfe)
337 /* Compute excitation function */
338 bndstrt = masktab[start];
339 bndend = masktab[end - 1] + 1;
341 if (bndstrt == 0) { /* For fbw and lfe channels */
342 lowcomp = calc_lowcomp(lowcomp, p_bit->bndpsd[0], p_bit->bndpsd[1], 0);
343 p_bit->excite[0] = p_bit->bndpsd[0] - fgain - lowcomp;
344 lowcomp = calc_lowcomp(lowcomp, p_bit->bndpsd[1], p_bit->bndpsd[2], 1);
345 p_bit->excite[1] = p_bit->bndpsd[1] - fgain - lowcomp;
348 /* Note: Do not call calc_lowcomp() for the last band of the lfe channel, (bin = 6) */
349 for (bin = 2; bin < 7; bin++) {
350 if (!(is_lfe && (bin == 6)))
351 lowcomp = calc_lowcomp (lowcomp, p_bit->bndpsd[bin], p_bit->bndpsd[bin+1], bin);
352 fastleak = p_bit->bndpsd[bin] - fgain;
353 slowleak = p_bit->bndpsd[bin] - p_bit->sgain;
354 p_bit->excite[bin] = fastleak - lowcomp;
356 if (!(is_lfe && (bin == 6))) {
357 if (p_bit->bndpsd[bin] <=
358 p_bit->bndpsd[bin+1])
366 for (bin = begin; bin < min_value(bndend, 22); bin++) {
367 if (!(is_lfe && (bin == 6)))
368 lowcomp = calc_lowcomp (lowcomp, p_bit->bndpsd[bin],
369 p_bit->bndpsd[bin+1], bin);
370 fastleak -= p_bit->fdecay ;
371 fastleak = max_value(fastleak, p_bit->bndpsd[bin] - fgain);
372 slowleak -= p_bit->sdecay ;
373 slowleak = max_value(slowleak, p_bit->bndpsd[bin] - p_bit->sgain);
374 p_bit->excite[bin] = max_value(fastleak - lowcomp, slowleak);
377 } else { /* For coupling channel */
381 for (bin = begin; bin < bndend; bin++) {
382 fastleak -= p_bit->fdecay;
383 fastleak = max_value(fastleak, p_bit->bndpsd[bin] - fgain);
384 slowleak -= p_bit->sdecay;
385 slowleak = max_value(slowleak, p_bit->bndpsd[bin] - p_bit->sgain);
386 p_bit->excite[bin] = max_value(fastleak, slowleak) ;
390 static void ba_compute_mask (bit_allocate_t * p_bit, s16 start, s16 end, u16 fscod,
391 u16 deltbae, u16 deltnseg, u16 deltoffst[],
392 u16 deltba[], u16 deltlen[])
399 bndstrt = masktab[start];
400 bndend = masktab[end - 1] + 1;
402 /* Compute the masking curve */
403 for (bin = bndstrt; bin < bndend; bin++) {
404 if (p_bit->bndpsd[bin] < p_bit->dbknee) {
405 p_bit->excite[bin] += ((p_bit->dbknee - p_bit->bndpsd[bin]) >> 2);
407 p_bit->mask[bin] = max_value(p_bit->excite[bin], hth[fscod][bin]);
410 /* Perform delta bit modulation if necessary */
411 if ((deltbae == DELTA_BIT_REUSE) || (deltbae == DELTA_BIT_NEW)) {
415 for (seg = 0; seg < deltnseg+1; seg++) {
416 band += deltoffst[seg];
417 if (deltba[seg] >= 4) {
418 delta = (deltba[seg] - 3) << 7;
420 delta = (deltba[seg] - 4) << 7;
422 for (k = 0; k < deltlen[seg]; k++) {
423 p_bit->mask[band] += delta;
430 static void ba_compute_bap (bit_allocate_t * p_bit, s16 start, s16 end, s16 snroffset,
437 /* Compute the bit allocation pointer for each bin */
442 lastbin = min_value(bndtab[j] + bndsz[j], end);
443 p_bit->mask[j] -= snroffset;
444 p_bit->mask[j] -= p_bit->floor;
446 if (p_bit->mask[j] < 0)
449 p_bit->mask[j] &= 0x1fe0;
450 p_bit->mask[j] += p_bit->floor;
451 for (k = i; k < lastbin; k++) {
452 address = (p_bit->psd[i] - p_bit->mask[j]) >> 5;
453 address = min_value(63, max_value(0, address));
454 bap[i] = baptab[address];
458 } while (end > lastbin);