Statistics
| Branch: | Revision:

ffmpeg / libavcodec / liba52 / parse.c @ 1c2a8c7f

History | View | Annotate | Download (21.2 KB)

1 976f969b Zdenek Kabelac
/*
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
}