git.sesse.net Git - vlc/blob - src/ac3_decoder/ac3_bit_allocate.c

   1 /*****************************************************************************
   2  * ac3_bit_allocate.c: ac3 allocation tables
   3  *****************************************************************************
   4  * Copyright (C) 2000 VideoLAN
   5  *
   6  * Authors: Michel Kaempf <maxx@via.ecp.fr>
   7  *          Aaron Holtzman <aholtzma@engr.uvic.ca>
   8  *          Renaud Dartus <reno@videolan.org>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23  *****************************************************************************/
  24 #include "defs.h"
  25
  26 #include "int_types.h"
  27 #include "ac3_decoder.h"
  28 #include "ac3_internal.h"
  29
  30
  31 static void ba_compute_psd (bit_allocate_t * p_bit, s16 start, s16 end, s16 exps[]);
  32
  33 static void ba_compute_excitation (bit_allocate_t * p_bit, s16 start, s16 end, s16 fgain,
  34                                    s16 fastleak, s16 slowleak, s16 is_lfe);
  35 static void ba_compute_mask (bit_allocate_t * p_bit, s16 start, s16 end, u16 fscod,
  36                              u16 deltbae, u16 deltnseg, u16 deltoffst[],
  37                              u16 deltba[], u16 deltlen[]);
  38 static void ba_compute_bap (bit_allocate_t * p_bit, s16 start, s16 end,
  39                             s16 snroffset, s16 bap[]);
  40
  41 /* Misc LUTs for bit allocation process */
  42
  43 static const s16 slowdec[]  = { 0x0f,  0x11,  0x13,  0x15  };
  44 static const s16 fastdec[]  = { 0x3f,  0x53,  0x67,  0x7b  };
  45 static const s16 slowgain[] = { 0x540, 0x4d8, 0x478, 0x410 };
  46 static const s16 dbpbtab[]  = { 0x000, 0x700, 0x900, 0xb00 };
  47
  48 static const u16 floortab[] = { 0x2f0, 0x2b0, 0x270, 0x230, 0x1f0, 0x170, 0x0f0, 0xf800 };
  49 static const s16 fastgain[] = { 0x080, 0x100, 0x180, 0x200, 0x280, 0x300, 0x380, 0x400  };
  50
  51 static const s16 bndtab[] = {  0,  1,  2,   3,   4,   5,   6,   7,   8,   9,
  52                         10, 11, 12,  13,  14,  15,  16,  17,  18,  19,
  53                         20, 21, 22,  23,  24,  25,  26,  27,  28,  31,
  54                         34, 37, 40,  43,  46,  49,  55,  61,  67,  73,
  55                         79, 85, 97, 109, 121, 133, 157, 181, 205, 229 };
  56
  57 static const s16 bndsz[]  = { 1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
  58                         1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
  59                         1,  1,  1,  1,  1,  1,  1,  1,  3,  3,
  60                         3,  3,  3,  3,  3,  6,  6,  6,  6,  6,
  61                         6, 12, 12, 12, 12, 24, 24, 24, 24, 24 };
  62
  63 static const s16 masktab[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
  64                      16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 28, 28, 29,
  65                      29, 29, 30, 30, 30, 31, 31, 31, 32, 32, 32, 33, 33, 33, 34, 34,
  66                      34, 35, 35, 35, 35, 35, 35, 36, 36, 36, 36, 36, 36, 37, 37, 37,
  67                      37, 37, 37, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 40,
  68                      40, 40, 40, 40, 40, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
  69                      41, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 43, 43, 43,
  70                      43, 43, 43, 43, 43, 43, 43, 43, 43, 44, 44, 44, 44, 44, 44, 44,
  71                      44, 44, 44, 44, 44, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
  72                      45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 46, 46, 46,
  73                      46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
  74                      46, 46, 46, 46, 46, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
  75                      47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 48, 48, 48,
  76                      48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
  77                      48, 48, 48, 48, 48, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
  78                      49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49,  0,  0,  0 };
  79
  80
  81 static const s16 latab[] = { 0x0040, 0x003f, 0x003e, 0x003d, 0x003c, 0x003b, 0x003a, 0x0039,
  82                     0x0038, 0x0037, 0x0036, 0x0035, 0x0034, 0x0034, 0x0033, 0x0032,
  83                     0x0031, 0x0030, 0x002f, 0x002f, 0x002e, 0x002d, 0x002c, 0x002c,
  84                     0x002b, 0x002a, 0x0029, 0x0029, 0x0028, 0x0027, 0x0026, 0x0026,
  85                     0x0025, 0x0024, 0x0024, 0x0023, 0x0023, 0x0022, 0x0021, 0x0021,
  86                     0x0020, 0x0020, 0x001f, 0x001e, 0x001e, 0x001d, 0x001d, 0x001c,
  87                     0x001c, 0x001b, 0x001b, 0x001a, 0x001a, 0x0019, 0x0019, 0x0018,
  88                     0x0018, 0x0017, 0x0017, 0x0016, 0x0016, 0x0015, 0x0015, 0x0015,
  89                     0x0014, 0x0014, 0x0013, 0x0013, 0x0013, 0x0012, 0x0012, 0x0012,
  90                     0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x000f, 0x000f,
  91                     0x000f, 0x000e, 0x000e, 0x000e, 0x000d, 0x000d, 0x000d, 0x000d,
  92                     0x000c, 0x000c, 0x000c, 0x000c, 0x000b, 0x000b, 0x000b, 0x000b,
  93                     0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x0009, 0x0009, 0x0009,
  94                     0x0009, 0x0009, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008,
  95                     0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0006, 0x0006,
  96                     0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0005, 0x0005,
  97                     0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0004, 0x0004,
  98                     0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
  99                     0x0004, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003,
 100                     0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0002,
 101                     0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
 102                     0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
 103                     0x0002, 0x0002, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
 104                     0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
 105                     0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
 106                     0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
 107                     0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 108                     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 109                     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 110                     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 111                     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 112                     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 113                     0x0000, 0x0000, 0x0000, 0x0000};
 114
 115 static const s16 hth[][50] = {{ 0x04d0, 0x04d0, 0x0440, 0x0400, 0x03e0, 0x03c0, 0x03b0, 0x03b0,
 116                       0x03a0, 0x03a0, 0x03a0, 0x03a0, 0x03a0, 0x0390, 0x0390, 0x0390,
 117                       0x0380, 0x0380, 0x0370, 0x0370, 0x0360, 0x0360, 0x0350, 0x0350,
 118                       0x0340, 0x0340, 0x0330, 0x0320, 0x0310, 0x0300, 0x02f0, 0x02f0,
 119                       0x02f0, 0x02f0, 0x0300, 0x0310, 0x0340, 0x0390, 0x03e0, 0x0420,
 120                       0x0460, 0x0490, 0x04a0, 0x0460, 0x0440, 0x0440, 0x0520, 0x0800,
 121                       0x0840, 0x0840 },
 122
 123                     { 0x04f0, 0x04f0, 0x0460, 0x0410, 0x03e0, 0x03d0, 0x03c0, 0x03b0,
 124                       0x03b0, 0x03a0, 0x03a0, 0x03a0, 0x03a0, 0x03a0, 0x0390, 0x0390,
 125                       0x0390, 0x0380, 0x0380, 0x0380, 0x0370, 0x0370, 0x0360, 0x0360,
 126                       0x0350, 0x0350, 0x0340, 0x0340, 0x0320, 0x0310, 0x0300, 0x02f0,
 127                       0x02f0, 0x02f0, 0x02f0, 0x0300, 0x0320, 0x0350, 0x0390, 0x03e0,
 128                       0x0420, 0x0450, 0x04a0, 0x0490, 0x0460, 0x0440, 0x0480, 0x0630,
 129                       0x0840, 0x0840 },
 130
 131                     { 0x0580, 0x0580, 0x04b0, 0x0450, 0x0420, 0x03f0, 0x03e0, 0x03d0,
 132                       0x03c0, 0x03b0, 0x03b0, 0x03b0, 0x03a0, 0x03a0, 0x03a0, 0x03a0,
 133                       0x03a0, 0x03a0, 0x03a0, 0x03a0, 0x0390, 0x0390, 0x0390, 0x0390,
 134                       0x0380, 0x0380, 0x0380, 0x0370, 0x0360, 0x0350, 0x0340, 0x0330,
 135                       0x0320, 0x0310, 0x0300, 0x02f0, 0x02f0, 0x02f0, 0x0300, 0x0310,
 136                       0x0330, 0x0350, 0x03c0, 0x0410, 0x0470, 0x04a0, 0x0460, 0x0440,
 137                       0x0450, 0x04e0 }};
 138
 139
 140 static const s16 baptab[] = { 0,  1,  1,  1,  1,  1,  2,  2,  3,  3,  3,  4,  4,  5,  5,  6,
 141                      6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  8,  9,  9,  9,  9, 10,
 142                      10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13, 13, 13, 14,
 143                      14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15 };
 144
 145 static __inline__ u16 max (s16 a, s16 b)
 146 {
 147     return (a > b ? a : b);
 148 }
 149
 150 static __inline__ u16 min (s16 a, s16 b)
 151 {
 152     return (a < b ? a : b);
 153 }
 154
 155 static __inline__ s16 logadd (s16 a, s16 b)
 156 {
 157     s16 c;
 158
 159     if ((c = a - b) >= 0) {
 160         return (a + latab[min(((c) >> 1), 255)]);
 161     } else {
 162         return (b + latab[min(((-c) >> 1), 255)]);
 163     }
 164 }
 165
 166 static __inline__ s16 calc_lowcomp (s16 a, s16 b0, s16 b1, s16 bin)
 167 {
 168     if (bin < 7) {
 169         if ((b0 + 256) == b1)
 170             a = 384;
 171         else if (b0 > b1)
 172             a = max(0, a - 64);
 173     } else if (bin < 20) {
 174         if ((b0 + 256) == b1)
 175             a = 320;
 176         else if (b0 > b1)
 177             a = max(0, a - 64) ;
 178     } else
 179         a = max(0, a - 128);
 180
 181     return a;
 182 }
 183
 184 void bit_allocate (ac3dec_t * p_ac3dec)
 185 {
 186     u16 i;
 187     s16 fgain;
 188     s16 snroffset;
 189     s16 start;
 190     s16 end;
 191     s16 fastleak;
 192     s16 slowleak;
 193
 194     /* Only perform bit_allocation if the exponents have changed or we
 195      * have new sideband information */
 196     if (p_ac3dec->audblk.chexpstr[0]  == 0 && p_ac3dec->audblk.chexpstr[1] == 0 &&
 197         p_ac3dec->audblk.chexpstr[2]  == 0 && p_ac3dec->audblk.chexpstr[3] == 0 &&
 198         p_ac3dec->audblk.chexpstr[4]  == 0 && p_ac3dec->audblk.cplexpstr   == 0 &&
 199         p_ac3dec->audblk.lfeexpstr    == 0 && p_ac3dec->audblk.baie        == 0 &&
 200         p_ac3dec->audblk.snroffste    == 0 && p_ac3dec->audblk.deltbaie    == 0)
 201         return;
 202
 203     /* Do some setup before we do the bit alloc */
 204     p_ac3dec->bit_allocate.sdecay = slowdec[p_ac3dec->audblk.sdcycod];
 205     p_ac3dec->bit_allocate.fdecay = fastdec[p_ac3dec->audblk.fdcycod];
 206     p_ac3dec->bit_allocate.sgain = slowgain[p_ac3dec->audblk.sgaincod];
 207     p_ac3dec->bit_allocate.dbknee = dbpbtab[p_ac3dec->audblk.dbpbcod];
 208     p_ac3dec->bit_allocate.floor = floortab[p_ac3dec->audblk.floorcod];
 209
 210     /* if all the SNR offset constants are zero then the whole block is zero */
 211     if (!p_ac3dec->audblk.csnroffst    && !p_ac3dec->audblk.fsnroffst[0] &&
 212         !p_ac3dec->audblk.fsnroffst[1] && !p_ac3dec->audblk.fsnroffst[2] &&
 213         !p_ac3dec->audblk.fsnroffst[3] && !p_ac3dec->audblk.fsnroffst[4] &&
 214         !p_ac3dec->audblk.cplfsnroffst && !p_ac3dec->audblk.lfefsnroffst) {
 215         memset(p_ac3dec->audblk.fbw_bap,0,sizeof(u16) * 256 * 5);
 216         memset(p_ac3dec->audblk.cpl_bap,0,sizeof(u16) * 256);
 217         memset(p_ac3dec->audblk.lfe_bap,0,sizeof(u16) * 7);
 218         return;
 219     }
 220
 221     for (i = 0; i < p_ac3dec->bsi.nfchans; i++) {
 222         start = 0;
 223         end = p_ac3dec->audblk.endmant[i] ;
 224         fgain = fastgain[p_ac3dec->audblk.fgaincod[i]];
 225         snroffset = (((p_ac3dec->audblk.csnroffst - 15) << 4) + p_ac3dec->audblk.fsnroffst[i]) << 2;
 226         fastleak = 0;
 227         slowleak = 0;
 228
 229         ba_compute_psd (&p_ac3dec->bit_allocate, start, end, p_ac3dec->audblk.fbw_exp[i]);
 230
 231         ba_compute_excitation (&p_ac3dec->bit_allocate, start, end , fgain, fastleak, slowleak, 0);
 232
 233         ba_compute_mask (&p_ac3dec->bit_allocate, start, end, p_ac3dec->syncinfo.fscod,
 234                          p_ac3dec->audblk.deltbae[i],
 235                          p_ac3dec->audblk.deltnseg[i],
 236                          p_ac3dec->audblk.deltoffst[i],
 237                          p_ac3dec->audblk.deltba[i],
 238                          p_ac3dec->audblk.deltlen[i]);
 239
 240         ba_compute_bap (&p_ac3dec->bit_allocate, start, end, snroffset, p_ac3dec->audblk.fbw_bap[i]);
 241     }
 242
 243     if (p_ac3dec->audblk.cplinu) {
 244         start = p_ac3dec->audblk.cplstrtmant;
 245         end = p_ac3dec->audblk.cplendmant;
 246         fgain = fastgain[p_ac3dec->audblk.cplfgaincod];
 247         snroffset = (((p_ac3dec->audblk.csnroffst - 15) << 4) + p_ac3dec->audblk.cplfsnroffst) << 2 ;
 248         fastleak = (p_ac3dec->audblk.cplfleak << 8) + 768;
 249         slowleak = (p_ac3dec->audblk.cplsleak << 8) + 768;
 250
 251         ba_compute_psd (&p_ac3dec->bit_allocate, start, end, p_ac3dec->audblk.cpl_exp);
 252
 253         ba_compute_excitation (&p_ac3dec->bit_allocate, start, end , fgain, fastleak, slowleak, 0);
 254
 255         ba_compute_mask (&p_ac3dec->bit_allocate, start, end, p_ac3dec->syncinfo.fscod,
 256                          p_ac3dec->audblk.cpldeltbae,
 257                          p_ac3dec->audblk.cpldeltnseg,
 258                          p_ac3dec->audblk.cpldeltoffst,
 259                          p_ac3dec->audblk.cpldeltba,
 260                          p_ac3dec->audblk.cpldeltlen);
 261
 262         ba_compute_bap (&p_ac3dec->bit_allocate, start, end, snroffset, p_ac3dec->audblk.cpl_bap);
 263     }
 264
 265     if (p_ac3dec->bsi.lfeon) {
 266         start = 0;
 267         end = 7;
 268         fgain = fastgain[p_ac3dec->audblk.lfefgaincod];
 269         snroffset = (((p_ac3dec->audblk.csnroffst - 15) << 4) + p_ac3dec->audblk.lfefsnroffst) << 2 ;
 270         fastleak = 0;
 271         slowleak = 0;
 272
 273         ba_compute_psd (&p_ac3dec->bit_allocate, start, end, p_ac3dec->audblk.lfe_exp);
 274
 275         ba_compute_excitation (&p_ac3dec->bit_allocate, start, end , fgain, fastleak, slowleak, 1);
 276
 277         ba_compute_mask (&p_ac3dec->bit_allocate, start, end, p_ac3dec->syncinfo.fscod, 2, 0, 0, 0, 0);
 278
 279         ba_compute_bap (&p_ac3dec->bit_allocate, start, end, snroffset, p_ac3dec->audblk.lfe_bap);
 280     }
 281 }
 282
 283
 284 static void ba_compute_psd (bit_allocate_t * p_bit, s16 start, s16 end, s16 exps[])
 285 {
 286     int bin,j,k;
 287     s16 lastbin = 0;
 288
 289     /* Map the exponents into dBs */
 290     for (bin=start; bin<end; bin++) {
 291         p_bit->psd[bin] = (3072 - (exps[bin] << 7));
 292     }
 293
 294     /* Integrate the psd function over each bit allocation band */
 295     j = start;
 296     k = masktab[start];
 297
 298     do {
 299         lastbin = min(bndtab[k] + bndsz[k], end);
 300         p_bit->bndpsd[k] = p_bit->psd[j];
 301         j++;
 302
 303         for (; j < lastbin; j++) {
 304             p_bit->bndpsd[k] = logadd(p_bit->bndpsd[k],p_bit->psd[j]);
 305         }
 306
 307         k++;
 308     } while (end > lastbin);
 309 }
 310
 311 static void ba_compute_excitation (bit_allocate_t * p_bit, s16 start, s16 end,
 312                         s16 fgain, s16 fastleak, s16 slowleak, s16 is_lfe)
 313 {
 314     int bin;
 315     s16 bndstrt;
 316     s16 bndend;
 317     s16 lowcomp = 0;
 318     s16 begin = 0;
 319
 320     /* Compute excitation function */
 321     bndstrt = masktab[start];
 322     bndend = masktab[end - 1] + 1;
 323
 324     if (bndstrt == 0) { /* For fbw and lfe channels */
 325         lowcomp = calc_lowcomp(lowcomp, p_bit->bndpsd[0], p_bit->bndpsd[1], 0);
 326         p_bit->excite[0] = p_bit->bndpsd[0] - fgain - lowcomp;
 327         lowcomp = calc_lowcomp(lowcomp, p_bit->bndpsd[1], p_bit->bndpsd[2], 1);
 328         p_bit->excite[1] = p_bit->bndpsd[1] - fgain - lowcomp;
 329         begin = 7 ;
 330
 331         /* Note: Do not call calc_lowcomp() for the last band of the lfe channel, (bin = 6) */
 332         for (bin = 2; bin < 7; bin++) {
 333             if (!(is_lfe && (bin == 6)))
 334                 lowcomp = calc_lowcomp (lowcomp, p_bit->bndpsd[bin], p_bit->bndpsd[bin+1], bin);
 335             fastleak = p_bit->bndpsd[bin] - fgain;
 336             slowleak = p_bit->bndpsd[bin] - p_bit->sgain;
 337             p_bit->excite[bin] = fastleak - lowcomp;
 338
 339             if (!(is_lfe && (bin == 6))) {
 340                 if (p_bit->bndpsd[bin] <=
 341                         p_bit->bndpsd[bin+1])
 342                 {
 343                     begin = bin + 1 ;
 344                     break;
 345                 }
 346             }
 347         }
 348
 349         for (bin = begin; bin < min(bndend, 22); bin++) {
 350             if (!(is_lfe && (bin == 6)))
 351                 lowcomp = calc_lowcomp (lowcomp, p_bit->bndpsd[bin],
 352                             p_bit->bndpsd[bin+1], bin);
 353             fastleak -= p_bit->fdecay ;
 354             fastleak = max(fastleak, p_bit->bndpsd[bin] - fgain);
 355             slowleak -= p_bit->sdecay ;
 356             slowleak = max(slowleak, p_bit->bndpsd[bin] - p_bit->sgain);
 357             p_bit->excite[bin] = max(fastleak - lowcomp, slowleak);
 358         }
 359         begin = 22;
 360     } else { /* For coupling channel */
 361         begin = bndstrt;
 362     }
 363
 364     for (bin = begin; bin < bndend; bin++) {
 365         fastleak -= p_bit->fdecay;
 366         fastleak = max(fastleak, p_bit->bndpsd[bin] - fgain);
 367         slowleak -= p_bit->sdecay;
 368         slowleak = max(slowleak, p_bit->bndpsd[bin] - p_bit->sgain);
 369         p_bit->excite[bin] = max(fastleak, slowleak) ;
 370     }
 371 }
 372
 373 static void ba_compute_mask (bit_allocate_t * p_bit, s16 start, s16 end, u16 fscod,
 374                              u16 deltbae, u16 deltnseg, u16 deltoffst[],
 375                              u16 deltba[], u16 deltlen[])
 376 {
 377     int bin,k;
 378     s16 bndstrt;
 379     s16 bndend;
 380     s16 delta;
 381
 382     bndstrt = masktab[start];
 383     bndend = masktab[end - 1] + 1;
 384
 385     /* Compute the masking curve */
 386     for (bin = bndstrt; bin < bndend; bin++) {
 387         if (p_bit->bndpsd[bin] < p_bit->dbknee) {
 388             p_bit->excite[bin] += ((p_bit->dbknee - p_bit->bndpsd[bin]) >> 2);
 389         }
 390         p_bit->mask[bin] = max(p_bit->excite[bin], hth[fscod][bin]);
 391     }
 392
 393     /* Perform delta bit modulation if necessary */
 394     if ((deltbae == DELTA_BIT_REUSE) || (deltbae == DELTA_BIT_NEW)) {
 395         s16 band = 0;
 396         s16 seg = 0;
 397
 398         for (seg = 0; seg < deltnseg+1; seg++) {
 399             band += deltoffst[seg];
 400             if (deltba[seg] >= 4) {
 401                 delta = (deltba[seg] - 3) << 7;
 402             } else {
 403                 delta = (deltba[seg] - 4) << 7;
 404             }
 405             for (k = 0; k < deltlen[seg]; k++) {
 406                 p_bit->mask[band] += delta;
 407                 band++;
 408             }
 409         }
 410     }
 411 }
 412
 413 static void ba_compute_bap (bit_allocate_t * p_bit, s16 start, s16 end, s16 snroffset,
 414                             s16 bap[])
 415 {
 416     int i,j,k;
 417     s16 lastbin = 0;
 418     s16 address = 0;
 419
 420     /* Compute the bit allocation pointer for each bin */
 421     i = start;
 422     j = masktab[start];
 423
 424     do {
 425         lastbin = min(bndtab[j] + bndsz[j], end);
 426         p_bit->mask[j] -= snroffset;
 427         p_bit->mask[j] -= p_bit->floor;
 428
 429         if (p_bit->mask[j] < 0)
 430             p_bit->mask[j] = 0;
 431
 432         p_bit->mask[j] &= 0x1fe0;
 433         p_bit->mask[j] += p_bit->floor;
 434         for (k = i; k < lastbin; k++) {
 435             address = (p_bit->psd[i] - p_bit->mask[j]) >> 5;
 436             address = min(63, max(0, address));
 437             bap[i] = baptab[address];
 438             i++;
 439         }
 440         j++;
 441     } while (end > lastbin);
 442 }