cinelerra-5.1/libzmpeg3/a52dec-0.7.3/liba52/parse.c

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