liba52/parse.c

   1 /*
   2  * parse.c
   3  * Copyright (C) 2000-2001 Michel Lespinasse <walken@zoy.org>
   4  * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
   5  *
   6  * This file is part of a52dec, a free ATSC A-52 stream decoder.
   7  * See http://liba52.sourceforge.net/ for updates.
   8  *
   9  * a52dec is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * a52dec is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  */
  23
  24 #include "config.h"
  25
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <inttypes.h>
  29
  30 #include "a52.h"
  31 #include "a52_internal.h"
  32 #include "bitstream.h"
  33 #include "tables.h"
  34 #include "mm_accel.h"
  35
  36 #ifdef HAVE_MEMALIGN
  37 /* some systems have memalign() but no declaration for it */
  38 void * memalign (size_t align, size_t size);
  39 #endif
  40
  41 typedef struct {
  42     sample_t q1[2];
  43     sample_t q2[2];
  44     sample_t q4;
  45     int q1_ptr;
  46     int q2_ptr;
  47     int q4_ptr;
  48 } quantizer_t;
  49
  50 static uint8_t halfrate[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3};
  51
  52 sample_t * a52_init (uint32_t mm_accel)
  53 {
  54     sample_t * samples;
  55     int i;
  56
  57     samples = memalign (16, 256 * 12 * sizeof (sample_t));
  58 #if defined(__MINGW32__) && defined(HAVE_SSE)
  59     for(i=0;i<10;i++){
  60       if((int)samples%16){
  61         sample_t* samplestmp=malloc(256 * 12 * sizeof (sample_t));
  62         free(samples);
  63         samples = samplestmp;
  64       }
  65       else break;
  66     }
  67 #endif
  68     if(((int)samples%16) && (mm_accel&MM_ACCEL_X86_SSE)){
  69       mm_accel &=~MM_ACCEL_X86_SSE;
  70       printf("liba52: unable to get 16 byte aligned memory disabling usage of SSE instructions\n");
  71     }
  72
  73     if (samples == NULL)
  74         return NULL;
  75
  76     imdct_init (mm_accel);
  77     downmix_accel_init(mm_accel);
  78
  79     for (i = 0; i < 256 * 12; i++)
  80         samples[i] = 0;
  81
  82     return samples;
  83 }
  84
  85 int a52_syncinfo (uint8_t * buf, int * flags,
  86                   int * sample_rate, int * bit_rate)
  87 {
  88     static int rate[] = { 32,  40,  48,  56,  64,  80,  96, 112,
  89                          128, 160, 192, 224, 256, 320, 384, 448,
  90                          512, 576, 640};
  91     static uint8_t lfeon[8] = {0x10, 0x10, 0x04, 0x04, 0x04, 0x01, 0x04, 0x01};
  92     int frmsizecod;
  93     int bitrate;
  94     int half;
  95     int acmod;
  96
  97     if ((buf[0] != 0x0b) || (buf[1] != 0x77))   /* syncword */
  98         return 0;
  99
 100     if (buf[5] >= 0x60)         /* bsid >= 12 */
 101         return 0;
 102     half = halfrate[buf[5] >> 3];
 103
 104     /* acmod, dsurmod and lfeon */
 105     acmod = buf[6] >> 5;
 106     *flags = ((((buf[6] & 0xf8) == 0x50) ? A52_DOLBY : acmod) |
 107               ((buf[6] & lfeon[acmod]) ? A52_LFE : 0));
 108
 109     frmsizecod = buf[4] & 63;
 110     if (frmsizecod >= 38)
 111         return 0;
 112     bitrate = rate [frmsizecod >> 1];
 113     *bit_rate = (bitrate * 1000) >> half;
 114
 115     switch (buf[4] & 0xc0) {
 116     case 0:     /* 48 KHz */
 117         *sample_rate = 48000 >> half;
 118         return 4 * bitrate;
 119     case 0x40:
 120         *sample_rate = 44100 >> half;
 121         return 2 * (320 * bitrate / 147 + (frmsizecod & 1));
 122     case 0x80:
 123         *sample_rate = 32000 >> half;
 124         return 6 * bitrate;
 125     default:
 126         return 0;
 127     }
 128 }
 129
 130 int a52_frame (a52_state_t * state, uint8_t * buf, int * flags,
 131                sample_t * level, sample_t bias)
 132 {
 133     static sample_t clev[4] = {LEVEL_3DB, LEVEL_45DB, LEVEL_6DB, LEVEL_45DB};
 134     static sample_t slev[4] = {LEVEL_3DB, LEVEL_6DB, 0, LEVEL_6DB};
 135     int chaninfo;
 136     int acmod;
 137
 138     state->fscod = buf[4] >> 6;
 139     state->halfrate = halfrate[buf[5] >> 3];
 140     state->acmod = acmod = buf[6] >> 5;
 141
 142     bitstream_set_ptr (buf + 6);
 143     bitstream_skip (3); /* skip acmod we already parsed */
 144
 145     if ((acmod == 2) && (bitstream_get (2) == 2))       /* dsurmod */
 146         acmod = A52_DOLBY;
 147
 148     if ((acmod & 1) && (acmod != 1))
 149         state->clev = clev[bitstream_get (2)];  /* cmixlev */
 150
 151     if (acmod & 4)
 152         state->slev = slev[bitstream_get (2)];  /* surmixlev */
 153
 154     state->lfeon = bitstream_get (1);
 155
 156     state->output = downmix_init (acmod, *flags, level,
 157                                   state->clev, state->slev);
 158     if (state->output < 0)
 159         return 1;
 160     if (state->lfeon && (*flags & A52_LFE))
 161         state->output |= A52_LFE;
 162     *flags = state->output;
 163     /* the 2* compensates for differences in imdct */
 164     state->dynrng = state->level = 2 * *level;
 165     state->bias = bias;
 166     state->dynrnge = 1;
 167     state->dynrngcall = NULL;
 168
 169     chaninfo = !acmod;
 170     do {
 171         bitstream_skip (5);     /* dialnorm */
 172         if (bitstream_get (1))  /* compre */
 173             bitstream_skip (8); /* compr */
 174         if (bitstream_get (1))  /* langcode */
 175             bitstream_skip (8); /* langcod */
 176         if (bitstream_get (1))  /* audprodie */
 177             bitstream_skip (7); /* mixlevel + roomtyp */
 178     } while (chaninfo--);
 179
 180     bitstream_skip (2);         /* copyrightb + origbs */
 181
 182     if (bitstream_get (1))      /* timecod1e */
 183         bitstream_skip (14);    /* timecod1 */
 184     if (bitstream_get (1))      /* timecod2e */
 185         bitstream_skip (14);    /* timecod2 */
 186
 187     if (bitstream_get (1)) {    /* addbsie */
 188         int addbsil;
 189
 190         addbsil = bitstream_get (6);
 191         do {
 192             bitstream_skip (8); /* addbsi */
 193         } while (addbsil--);
 194     }
 195
 196     return 0;
 197 }
 198
 199 void a52_dynrng (a52_state_t * state,
 200                  sample_t (* call) (sample_t, void *), void * data)
 201 {
 202     state->dynrnge = 0;
 203     if (call) {
 204         state->dynrnge = 1;
 205         state->dynrngcall = call;
 206         state->dynrngdata = data;
 207     }
 208 }
 209
 210 static int parse_exponents (int expstr, int ngrps, uint8_t exponent,
 211                             uint8_t * dest)
 212 {
 213     int exps;
 214
 215     while (ngrps--) {
 216         exps = bitstream_get (7);
 217
 218         exponent += exp_1[exps];
 219         if (exponent > 24)
 220             return 1;
 221
 222         switch (expstr) {
 223         case EXP_D45:
 224             *(dest++) = exponent;
 225             *(dest++) = exponent;
 226         case EXP_D25:
 227             *(dest++) = exponent;
 228         case EXP_D15:
 229             *(dest++) = exponent;
 230         }
 231
 232         exponent += exp_2[exps];
 233         if (exponent > 24)
 234             return 1;
 235
 236         switch (expstr) {
 237         case EXP_D45:
 238             *(dest++) = exponent;
 239             *(dest++) = exponent;
 240         case EXP_D25:
 241             *(dest++) = exponent;
 242         case EXP_D15:
 243             *(dest++) = exponent;
 244         }
 245
 246         exponent += exp_3[exps];
 247         if (exponent > 24)
 248             return 1;
 249
 250         switch (expstr) {
 251         case EXP_D45:
 252             *(dest++) = exponent;
 253             *(dest++) = exponent;
 254         case EXP_D25:
 255             *(dest++) = exponent;
 256         case EXP_D15:
 257             *(dest++) = exponent;
 258         }
 259     }
 260
 261     return 0;
 262 }
 263
 264 static int parse_deltba (int8_t * deltba)
 265 {
 266     int deltnseg, deltlen, delta, j;
 267
 268     memset (deltba, 0, 50);
 269
 270     deltnseg = bitstream_get (3);
 271     j = 0;
 272     do {
 273         j += bitstream_get (5);
 274         deltlen = bitstream_get (4);
 275         delta = bitstream_get (3);
 276         delta -= (delta >= 4) ? 3 : 4;
 277         if (!deltlen)
 278             continue;
 279         if (j + deltlen >= 50)
 280             return 1;
 281         while (deltlen--)
 282             deltba[j++] = delta;
 283     } while (deltnseg--);
 284
 285     return 0;
 286 }
 287
 288 static inline int zero_snr_offsets (int nfchans, a52_state_t * state)
 289 {
 290     int i;
 291
 292     if ((state->csnroffst) || (state->cplinu && state->cplba.fsnroffst) ||
 293         (state->lfeon && state->lfeba.fsnroffst))
 294         return 0;
 295     for (i = 0; i < nfchans; i++)
 296         if (state->ba[i].fsnroffst)
 297             return 0;
 298     return 1;
 299 }
 300
 301 static inline int16_t dither_gen (void)
 302 {
 303     static uint16_t lfsr_state = 1;
 304     int16_t state;
 305
 306     state = dither_lut[lfsr_state >> 8] ^ (lfsr_state << 8);
 307
 308     lfsr_state = (uint16_t) state;
 309
 310     return state;
 311 }
 312
 313 static void coeff_get (sample_t * coeff, uint8_t * exp, int8_t * bap,
 314                        quantizer_t * quantizer, sample_t level,
 315                        int dither, int end)
 316 {
 317     int i;
 318     sample_t factor[25];
 319
 320     for (i = 0; i <= 24; i++)
 321         factor[i] = scale_factor[i] * level;
 322
 323     for (i = 0; i < end; i++) {
 324         int bapi;
 325
 326         bapi = bap[i];
 327         switch (bapi) {
 328         case 0:
 329             if (dither) {
 330                 coeff[i] = dither_gen() * LEVEL_3DB * factor[exp[i]];
 331                 continue;
 332             } else {
 333                 coeff[i] = 0;
 334                 continue;
 335             }
 336
 337         case -1:
 338             if (quantizer->q1_ptr >= 0) {
 339                 coeff[i] = quantizer->q1[quantizer->q1_ptr--] * factor[exp[i]];
 340                 continue;
 341             } else {
 342                 int code;
 343
 344                 code = bitstream_get (5);
 345
 346                 quantizer->q1_ptr = 1;
 347                 quantizer->q1[0] = q_1_2[code];
 348                 quantizer->q1[1] = q_1_1[code];
 349                 coeff[i] = q_1_0[code] * factor[exp[i]];
 350                 continue;
 351             }
 352
 353         case -2:
 354             if (quantizer->q2_ptr >= 0) {
 355                 coeff[i] = quantizer->q2[quantizer->q2_ptr--] * factor[exp[i]];
 356                 continue;
 357             } else {
 358                 int code;
 359
 360                 code = bitstream_get (7);
 361
 362                 quantizer->q2_ptr = 1;
 363                 quantizer->q2[0] = q_2_2[code];
 364                 quantizer->q2[1] = q_2_1[code];
 365                 coeff[i] = q_2_0[code] * factor[exp[i]];
 366                 continue;
 367             }
 368
 369         case 3:
 370             coeff[i] = q_3[bitstream_get (3)] * factor[exp[i]];
 371             continue;
 372
 373         case -3:
 374             if (quantizer->q4_ptr == 0) {
 375                 quantizer->q4_ptr = -1;
 376                 coeff[i] = quantizer->q4 * factor[exp[i]];
 377                 continue;
 378             } else {
 379                 int code;
 380
 381                 code = bitstream_get (7);
 382
 383                 quantizer->q4_ptr = 0;
 384                 quantizer->q4 = q_4_1[code];
 385                 coeff[i] = q_4_0[code] * factor[exp[i]];
 386                 continue;
 387             }
 388
 389         case 4:
 390             coeff[i] = q_5[bitstream_get (4)] * factor[exp[i]];
 391             continue;
 392
 393         default:
 394             coeff[i] = ((bitstream_get_2 (bapi) << (16 - bapi)) *
 395                           factor[exp[i]]);
 396         }
 397     }
 398 }
 399
 400 static void coeff_get_coupling (a52_state_t * state, int nfchans,
 401                                 sample_t * coeff, sample_t (* samples)[256],
 402                                 quantizer_t * quantizer, uint8_t dithflag[5])
 403 {
 404     int sub_bnd, bnd, i, i_end, ch;
 405     int8_t * bap;
 406     uint8_t * exp;
 407     sample_t cplco[5];
 408
 409     bap = state->cpl_bap;
 410     exp = state->cpl_exp;
 411     sub_bnd = bnd = 0;
 412     i = state->cplstrtmant;
 413     while (i < state->cplendmant) {
 414         i_end = i + 12;
 415         while (state->cplbndstrc[sub_bnd++])
 416             i_end += 12;
 417         for (ch = 0; ch < nfchans; ch++)
 418             cplco[ch] = state->cplco[ch][bnd] * coeff[ch];
 419         bnd++;
 420
 421         while (i < i_end) {
 422             sample_t cplcoeff;
 423             int bapi;
 424
 425             bapi = bap[i];
 426             switch (bapi) {
 427             case 0:
 428                 cplcoeff = LEVEL_3DB * scale_factor[exp[i]];
 429                 for (ch = 0; ch < nfchans; ch++)
 430                     if (state->chincpl[ch]) {
 431                         if (dithflag[ch])
 432                             samples[ch][i] = (cplcoeff * cplco[ch] *
 433                                               dither_gen ());
 434                         else
 435                             samples[ch][i] = 0;
 436                     }
 437                 i++;
 438                 continue;
 439
 440             case -1:
 441                 if (quantizer->q1_ptr >= 0) {
 442                     cplcoeff = quantizer->q1[quantizer->q1_ptr--];
 443                     break;
 444                 } else {
 445                     int code;
 446
 447                     code = bitstream_get (5);
 448
 449                     quantizer->q1_ptr = 1;
 450                     quantizer->q1[0] = q_1_2[code];
 451                     quantizer->q1[1] = q_1_1[code];
 452                     cplcoeff = q_1_0[code];
 453                     break;
 454                 }
 455
 456             case -2:
 457                 if (quantizer->q2_ptr >= 0) {
 458                     cplcoeff = quantizer->q2[quantizer->q2_ptr--];
 459                     break;
 460                 } else {
 461                     int code;
 462
 463                     code = bitstream_get (7);
 464
 465                     quantizer->q2_ptr = 1;
 466                     quantizer->q2[0] = q_2_2[code];
 467                     quantizer->q2[1] = q_2_1[code];
 468                     cplcoeff = q_2_0[code];
 469                     break;
 470                 }
 471
 472             case 3:
 473                 cplcoeff = q_3[bitstream_get (3)];
 474                 break;
 475
 476             case -3:
 477                 if (quantizer->q4_ptr == 0) {
 478                     quantizer->q4_ptr = -1;
 479                     cplcoeff = quantizer->q4;
 480                     break;
 481                 } else {
 482                     int code;
 483
 484                     code = bitstream_get (7);
 485
 486                     quantizer->q4_ptr = 0;
 487                     quantizer->q4 = q_4_1[code];
 488                     cplcoeff = q_4_0[code];
 489                     break;
 490                 }
 491
 492             case 4:
 493                 cplcoeff = q_5[bitstream_get (4)];
 494                 break;
 495
 496             default:
 497                 cplcoeff = bitstream_get_2 (bapi) << (16 - bapi);
 498             }
 499
 500             cplcoeff *= scale_factor[exp[i]];
 501             for (ch = 0; ch < nfchans; ch++)
 502                 if (state->chincpl[ch])
 503                     samples[ch][i] = cplcoeff * cplco[ch];
 504             i++;
 505         }
 506     }
 507 }
 508
 509 int a52_block (a52_state_t * state, sample_t * samples)
 510 {
 511     static const uint8_t nfchans_tbl[] = {2, 1, 2, 3, 3, 4, 4, 5, 1, 1, 2};
 512     static int rematrix_band[4] = {25, 37, 61, 253};
 513     int i, nfchans, chaninfo;
 514     uint8_t cplexpstr, chexpstr[5], lfeexpstr, do_bit_alloc, done_cpl;
 515     uint8_t blksw[5], dithflag[5];
 516     sample_t coeff[5];
 517     int chanbias;
 518     quantizer_t quantizer;
 519
 520     nfchans = nfchans_tbl[state->acmod];
 521
 522     for (i = 0; i < nfchans; i++)
 523         blksw[i] = bitstream_get (1);
 524
 525     for (i = 0; i < nfchans; i++)
 526         dithflag[i] = bitstream_get (1);
 527
 528     chaninfo = !(state->acmod);
 529     do {
 530         if (bitstream_get (1)) {        /* dynrnge */
 531             int dynrng;
 532
 533             dynrng = bitstream_get_2 (8);
 534             if (state->dynrnge) {
 535                 sample_t range;
 536
 537                 range = ((((dynrng & 0x1f) | 0x20) << 13) *
 538                          scale_factor[3 - (dynrng >> 5)]);
 539                 if (state->dynrngcall)
 540                     range = state->dynrngcall (range, state->dynrngdata);
 541                 state->dynrng = state->level * range;
 542             }
 543         }
 544     } while (chaninfo--);
 545
 546     if (bitstream_get (1)) {    /* cplstre */
 547         state->cplinu = bitstream_get (1);
 548         if (state->cplinu) {
 549             static int bndtab[16] = {31, 35, 37, 39, 41, 42, 43, 44,
 550                                      45, 45, 46, 46, 47, 47, 48, 48};
 551             int cplbegf;
 552             int cplendf;
 553             int ncplsubnd;
 554
 555             for (i = 0; i < nfchans; i++)
 556                 state->chincpl[i] = bitstream_get (1);
 557             switch (state->acmod) {
 558             case 0: case 1:
 559                 return 1;
 560             case 2:
 561                 state->phsflginu = bitstream_get (1);
 562             }
 563             cplbegf = bitstream_get (4);
 564             cplendf = bitstream_get (4);
 565
 566             if (cplendf + 3 - cplbegf < 0)
 567                 return 1;
 568             state->ncplbnd = ncplsubnd = cplendf + 3 - cplbegf;
 569             state->cplstrtbnd = bndtab[cplbegf];
 570             state->cplstrtmant = cplbegf * 12 + 37;
 571             state->cplendmant = cplendf * 12 + 73;
 572
 573             for (i = 0; i < ncplsubnd - 1; i++) {
 574                 state->cplbndstrc[i] = bitstream_get (1);
 575                 state->ncplbnd -= state->cplbndstrc[i];
 576             }
 577             state->cplbndstrc[i] = 0;   /* last value is a sentinel */
 578         }
 579     }
 580
 581     if (state->cplinu) {
 582         int j, cplcoe;
 583
 584         cplcoe = 0;
 585         for (i = 0; i < nfchans; i++)
 586             if (state->chincpl[i])
 587                 if (bitstream_get (1)) {        /* cplcoe */
 588                     int mstrcplco, cplcoexp, cplcomant;
 589
 590                     cplcoe = 1;
 591                     mstrcplco = 3 * bitstream_get (2);
 592                     for (j = 0; j < state->ncplbnd; j++) {
 593                         cplcoexp = bitstream_get (4);
 594                         cplcomant = bitstream_get (4);
 595                         if (cplcoexp == 15)
 596                             cplcomant <<= 14;
 597                         else
 598                             cplcomant = (cplcomant | 0x10) << 13;
 599                         state->cplco[i][j] =
 600                             cplcomant * scale_factor[cplcoexp + mstrcplco];
 601                     }
 602                 }
 603         if ((state->acmod == 2) && state->phsflginu && cplcoe)
 604             for (j = 0; j < state->ncplbnd; j++)
 605                 if (bitstream_get (1))  /* phsflg */
 606                     state->cplco[1][j] = -state->cplco[1][j];
 607     }
 608
 609     if ((state->acmod == 2) && (bitstream_get (1))) {   /* rematstr */
 610         int end;
 611
 612         end = (state->cplinu) ? state->cplstrtmant : 253;
 613         i = 0;
 614         do
 615             state->rematflg[i] = bitstream_get (1);
 616         while (rematrix_band[i++] < end);
 617     }
 618
 619     cplexpstr = EXP_REUSE;
 620     lfeexpstr = EXP_REUSE;
 621     if (state->cplinu)
 622         cplexpstr = bitstream_get (2);
 623     for (i = 0; i < nfchans; i++)
 624         chexpstr[i] = bitstream_get (2);
 625     if (state->lfeon)
 626         lfeexpstr = bitstream_get (1);
 627
 628     for (i = 0; i < nfchans; i++)
 629         if (chexpstr[i] != EXP_REUSE) {
 630             if (state->cplinu && state->chincpl[i])
 631                 state->endmant[i] = state->cplstrtmant;
 632             else {
 633                 int chbwcod;
 634
 635                 chbwcod = bitstream_get (6);
 636                 if (chbwcod > 60)
 637                     return 1;
 638                 state->endmant[i] = chbwcod * 3 + 73;
 639             }
 640         }
 641
 642     do_bit_alloc = 0;
 643
 644     if (cplexpstr != EXP_REUSE) {
 645         int cplabsexp, ncplgrps;
 646
 647         do_bit_alloc = 64;
 648         ncplgrps = ((state->cplendmant - state->cplstrtmant) /
 649                     (3 << (cplexpstr - 1)));
 650         cplabsexp = bitstream_get (4) << 1;
 651         if (parse_exponents (cplexpstr, ncplgrps, cplabsexp,
 652                              state->cpl_exp + state->cplstrtmant))
 653             return 1;
 654     }
 655     for (i = 0; i < nfchans; i++)
 656         if (chexpstr[i] != EXP_REUSE) {
 657             int grp_size, nchgrps;
 658
 659             do_bit_alloc |= 1 << i;
 660             grp_size = 3 << (chexpstr[i] - 1);
 661             nchgrps = (state->endmant[i] + grp_size - 4) / grp_size;
 662             state->fbw_exp[i][0] = bitstream_get (4);
 663             if (parse_exponents (chexpstr[i], nchgrps, state->fbw_exp[i][0],
 664                                  state->fbw_exp[i] + 1))
 665                 return 1;
 666             bitstream_skip (2); /* gainrng */
 667         }
 668     if (lfeexpstr != EXP_REUSE) {
 669         do_bit_alloc |= 32;
 670         state->lfe_exp[0] = bitstream_get (4);
 671         if (parse_exponents (lfeexpstr, 2, state->lfe_exp[0],
 672                              state->lfe_exp + 1))
 673             return 1;
 674     }
 675
 676     if (bitstream_get (1)) {    /* baie */
 677         do_bit_alloc = -1;
 678         state->sdcycod = bitstream_get (2);
 679         state->fdcycod = bitstream_get (2);
 680         state->sgaincod = bitstream_get (2);
 681         state->dbpbcod = bitstream_get (2);
 682         state->floorcod = bitstream_get (3);
 683     }
 684     if (bitstream_get (1)) {    /* snroffste */
 685         do_bit_alloc = -1;
 686         state->csnroffst = bitstream_get (6);
 687         if (state->cplinu) {
 688             state->cplba.fsnroffst = bitstream_get (4);
 689             state->cplba.fgaincod = bitstream_get (3);
 690         }
 691         for (i = 0; i < nfchans; i++) {
 692             state->ba[i].fsnroffst = bitstream_get (4);
 693             state->ba[i].fgaincod = bitstream_get (3);
 694         }
 695         if (state->lfeon) {
 696             state->lfeba.fsnroffst = bitstream_get (4);
 697             state->lfeba.fgaincod = bitstream_get (3);
 698         }
 699     }
 700     if ((state->cplinu) && (bitstream_get (1))) {       /* cplleake */
 701         do_bit_alloc |= 64;
 702         state->cplfleak = 2304 - (bitstream_get (3) << 8);
 703         state->cplsleak = 2304 - (bitstream_get (3) << 8);
 704     }
 705
 706     if (bitstream_get (1)) {    /* deltbaie */
 707         do_bit_alloc = -1;
 708         if (state->cplinu)
 709             state->cplba.deltbae = bitstream_get (2);
 710         for (i = 0; i < nfchans; i++)
 711             state->ba[i].deltbae = bitstream_get (2);
 712         if (state->cplinu && (state->cplba.deltbae == DELTA_BIT_NEW) &&
 713             parse_deltba (state->cplba.deltba))
 714             return 1;
 715         for (i = 0; i < nfchans; i++)
 716             if ((state->ba[i].deltbae == DELTA_BIT_NEW) &&
 717                 parse_deltba (state->ba[i].deltba))
 718                 return 1;
 719     }
 720
 721     if (do_bit_alloc) {
 722         if (zero_snr_offsets (nfchans, state)) {
 723             memset (state->cpl_bap, 0, sizeof (state->cpl_bap));
 724             memset (state->fbw_bap, 0, sizeof (state->fbw_bap));
 725             memset (state->lfe_bap, 0, sizeof (state->lfe_bap));
 726         } else {
 727             if (state->cplinu && (do_bit_alloc & 64))
 728                 bit_allocate (state, &state->cplba, state->cplstrtbnd,
 729                               state->cplstrtmant, state->cplendmant,
 730                               state->cplfleak, state->cplsleak,
 731                               state->cpl_exp, state->cpl_bap);
 732             for (i = 0; i < nfchans; i++)
 733                 if (do_bit_alloc & (1 << i))
 734                     bit_allocate (state, state->ba + i, 0, 0,
 735                                   state->endmant[i], 0, 0, state->fbw_exp[i],
 736                                   state->fbw_bap[i]);
 737             if (state->lfeon && (do_bit_alloc & 32)) {
 738                 state->lfeba.deltbae = DELTA_BIT_NONE;
 739                 bit_allocate (state, &state->lfeba, 0, 0, 7, 0, 0,
 740                               state->lfe_exp, state->lfe_bap);
 741             }
 742         }
 743     }
 744
 745     if (bitstream_get (1)) {    /* skiple */
 746         i = bitstream_get (9);  /* skipl */
 747         while (i--)
 748             bitstream_skip (8);
 749     }
 750
 751     if (state->output & A52_LFE)
 752         samples += 256; /* shift for LFE channel */
 753
 754     chanbias = downmix_coeff (coeff, state->acmod, state->output,
 755                               state->dynrng, state->clev, state->slev);
 756
 757     quantizer.q1_ptr = quantizer.q2_ptr = quantizer.q4_ptr = -1;
 758     done_cpl = 0;
 759
 760     for (i = 0; i < nfchans; i++) {
 761         int j;
 762
 763         coeff_get (samples + 256 * i, state->fbw_exp[i], state->fbw_bap[i],
 764                    &quantizer, coeff[i], dithflag[i], state->endmant[i]);
 765
 766         if (state->cplinu && state->chincpl[i]) {
 767             if (!done_cpl) {
 768                 done_cpl = 1;
 769                 coeff_get_coupling (state, nfchans, coeff,
 770                                     (sample_t (*)[256])samples, &quantizer,
 771                                     dithflag);
 772             }
 773             j = state->cplendmant;
 774         } else
 775             j = state->endmant[i];
 776         do
 777             (samples + 256 * i)[j] = 0;
 778         while (++j < 256);
 779     }
 780
 781     if (state->acmod == 2) {
 782         int j, end, band;
 783
 784         end = ((state->endmant[0] < state->endmant[1]) ?
 785                state->endmant[0] : state->endmant[1]);
 786
 787         i = 0;
 788         j = 13;
 789         do {
 790             if (!state->rematflg[i]) {
 791                 j = rematrix_band[i++];
 792                 continue;
 793             }
 794             band = rematrix_band[i++];
 795             if (band > end)
 796                 band = end;
 797             do {
 798                 sample_t tmp0, tmp1;
 799
 800                 tmp0 = samples[j];
 801                 tmp1 = (samples+256)[j];
 802                 samples[j] = tmp0 + tmp1;
 803                 (samples+256)[j] = tmp0 - tmp1;
 804             } while (++j < band);
 805         } while (j < end);
 806     }
 807
 808     if (state->lfeon) {
 809         if (state->output & A52_LFE) {
 810             coeff_get (samples - 256, state->lfe_exp, state->lfe_bap,
 811                        &quantizer, state->dynrng, 0, 7);
 812             for (i = 7; i < 256; i++)
 813                 (samples-256)[i] = 0;
 814             imdct_512 (samples - 256, samples + 1536 - 256, state->bias);
 815         } else {
 816             /* just skip the LFE coefficients */
 817             coeff_get (samples + 1280, state->lfe_exp, state->lfe_bap,
 818                        &quantizer, 0, 0, 7);
 819         }
 820     }
 821
 822     i = 0;
 823     if (nfchans_tbl[state->output & A52_CHANNEL_MASK] < nfchans)
 824         for (i = 1; i < nfchans; i++)
 825             if (blksw[i] != blksw[0])
 826                 break;
 827
 828     if (i < nfchans) {
 829         if (samples[2 * 1536 - 1] == (sample_t)0x776b6e21) {
 830             samples[2 * 1536 - 1] = 0;
 831             upmix (samples + 1536, state->acmod, state->output);
 832         }
 833
 834         for (i = 0; i < nfchans; i++) {
 835             sample_t bias;
 836
 837             bias = 0;
 838             if (!(chanbias & (1 << i)))
 839                 bias = state->bias;
 840
 841             if (coeff[i]) {
 842                 if (blksw[i])
 843                     imdct_256 (samples + 256 * i, samples + 1536 + 256 * i,
 844                                bias);
 845                 else
 846                     imdct_512 (samples + 256 * i, samples + 1536 + 256 * i,
 847                                bias);
 848             } else {
 849                 int j;
 850
 851                 for (j = 0; j < 256; j++)
 852                     (samples + 256 * i)[j] = bias;
 853             }
 854         }
 855
 856         downmix (samples, state->acmod, state->output, state->bias,
 857                  state->clev, state->slev);
 858     } else {
 859         nfchans = nfchans_tbl[state->output & A52_CHANNEL_MASK];
 860
 861         downmix (samples, state->acmod, state->output, 0,
 862                  state->clev, state->slev);
 863
 864         if (samples[2 * 1536 - 1] != (sample_t)0x776b6e21) {
 865             downmix (samples + 1536, state->acmod, state->output, 0,
 866                      state->clev, state->slev);
 867             samples[2 * 1536 - 1] = (sample_t)0x776b6e21;
 868         }
 869
 870         if (blksw[0])
 871             for (i = 0; i < nfchans; i++)
 872                 imdct_256 (samples + 256 * i, samples + 1536 + 256 * i,
 873                            state->bias);
 874         else
 875             for (i = 0; i < nfchans; i++)
 876                 imdct_512 (samples + 256 * i, samples + 1536 + 256 * i,
 877                            state->bias);
 878     }
 879
 880     return 0;
 881 }