3 * Copyright (C) 2000-2002 Michel Lespinasse <walken@zoy.org>
4 * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
6 * This file is part of a52dec, a free ATSC A-52 stream decoder.
7 * See http://liba52.sourceforge.net/ for updates.
9 * Modified for use with MPlayer, changes contained in liba52_changes.diff.
10 * detailed changelog at http://svn.mplayerhq.hu/mplayer/trunk/
13 * a52dec is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
18 * a52dec is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
36 #include "a52_internal.h"
37 #include "bitstream.h"
40 #include "libavutil/avutil.h"
43 /* some systems have memalign() but no declaration for it */
44 void * memalign (size_t align
, size_t size
);
56 static uint8_t halfrate
[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3};
58 a52_state_t
* a52_init (uint32_t mm_accel
)
63 state
= malloc (sizeof (a52_state_t
));
67 #if defined(__MINGW32__) && defined(HAVE_SSE)
68 state
->samples
= av_malloc(256 * 12 * sizeof (sample_t
));
70 state
->samples
= memalign (16, 256 * 12 * sizeof (sample_t
));
72 if(((int)state
->samples
%16) && (mm_accel
&MM_ACCEL_X86_SSE
)){
73 mm_accel
&=~MM_ACCEL_X86_SSE
;
74 fprintf(stderr
, "liba52: unable to get 16 byte aligned memory disabling usage of SSE instructions\n");
77 if (state
->samples
== NULL
) {
82 for (i
= 0; i
< 256 * 12; i
++)
83 state
->samples
[i
] = 0;
87 state
->lfsr_state
= 1;
89 a52_imdct_init (mm_accel
);
90 downmix_accel_init(mm_accel
);
95 sample_t
* a52_samples (a52_state_t
* state
)
97 return state
->samples
;
100 int a52_syncinfo (uint8_t * buf
, int * flags
,
101 int * sample_rate
, int * bit_rate
)
103 static int rate
[] = { 32, 40, 48, 56, 64, 80, 96, 112,
104 128, 160, 192, 224, 256, 320, 384, 448,
106 static uint8_t lfeon
[8] = {0x10, 0x10, 0x04, 0x04, 0x04, 0x01, 0x04, 0x01};
112 if ((buf
[0] != 0x0b) || (buf
[1] != 0x77)) /* syncword */
115 if (buf
[5] >= 0x60) /* bsid >= 12 */
117 half
= halfrate
[buf
[5] >> 3];
119 /* acmod, dsurmod and lfeon */
121 *flags
= ((((buf
[6] & 0xf8) == 0x50) ? A52_DOLBY
: acmod
) |
122 ((buf
[6] & lfeon
[acmod
]) ? A52_LFE
: 0));
124 frmsizecod
= buf
[4] & 63;
125 if (frmsizecod
>= 38)
127 bitrate
= rate
[frmsizecod
>> 1];
128 *bit_rate
= (bitrate
* 1000) >> half
;
130 switch (buf
[4] & 0xc0) {
132 *sample_rate
= 48000 >> half
;
135 *sample_rate
= 44100 >> half
;
136 return 2 * (320 * bitrate
/ 147 + (frmsizecod
& 1));
138 *sample_rate
= 32000 >> half
;
145 int a52_frame (a52_state_t
* state
, uint8_t * buf
, int * flags
,
146 sample_t
* level
, sample_t bias
)
148 static sample_t clev
[4] = {LEVEL_3DB
, LEVEL_45DB
, LEVEL_6DB
, LEVEL_45DB
};
149 static sample_t slev
[4] = {LEVEL_3DB
, LEVEL_6DB
, 0, LEVEL_6DB
};
153 state
->fscod
= buf
[4] >> 6;
154 state
->halfrate
= halfrate
[buf
[5] >> 3];
155 state
->acmod
= acmod
= buf
[6] >> 5;
157 a52_bitstream_set_ptr (state
, buf
+ 6);
158 bitstream_skip (state
, 3); /* skip acmod we already parsed */
160 if ((acmod
== 2) && (bitstream_get (state
, 2) == 2)) /* dsurmod */
163 if ((acmod
& 1) && (acmod
!= 1))
164 state
->clev
= clev
[bitstream_get (state
, 2)]; /* cmixlev */
167 state
->slev
= slev
[bitstream_get (state
, 2)]; /* surmixlev */
169 state
->lfeon
= bitstream_get (state
, 1);
171 state
->output
= a52_downmix_init (acmod
, *flags
, level
,
172 state
->clev
, state
->slev
);
173 if (state
->output
< 0)
175 if (state
->lfeon
&& (*flags
& A52_LFE
))
176 state
->output
|= A52_LFE
;
177 *flags
= state
->output
;
178 /* the 2* compensates for differences in imdct */
179 state
->dynrng
= state
->level
= 2 * *level
;
182 state
->dynrngcall
= NULL
;
183 state
->cplba
.deltbae
= DELTA_BIT_NONE
;
184 state
->ba
[0].deltbae
= state
->ba
[1].deltbae
= state
->ba
[2].deltbae
=
185 state
->ba
[3].deltbae
= state
->ba
[4].deltbae
= DELTA_BIT_NONE
;
189 bitstream_skip (state
, 5); /* dialnorm */
190 if (bitstream_get (state
, 1)) /* compre */
191 bitstream_skip (state
, 8); /* compr */
192 if (bitstream_get (state
, 1)) /* langcode */
193 bitstream_skip (state
, 8); /* langcod */
194 if (bitstream_get (state
, 1)) /* audprodie */
195 bitstream_skip (state
, 7); /* mixlevel + roomtyp */
196 } while (chaninfo
--);
198 bitstream_skip (state
, 2); /* copyrightb + origbs */
200 if (bitstream_get (state
, 1)) /* timecod1e */
201 bitstream_skip (state
, 14); /* timecod1 */
202 if (bitstream_get (state
, 1)) /* timecod2e */
203 bitstream_skip (state
, 14); /* timecod2 */
205 if (bitstream_get (state
, 1)) { /* addbsie */
208 addbsil
= bitstream_get (state
, 6);
210 bitstream_skip (state
, 8); /* addbsi */
217 void a52_dynrng (a52_state_t
* state
,
218 sample_t (* call
) (sample_t
, void *), void * data
)
223 state
->dynrngcall
= call
;
224 state
->dynrngdata
= data
;
228 static int parse_exponents (a52_state_t
* state
, int expstr
, int ngrps
,
229 uint8_t exponent
, uint8_t * dest
)
234 exps
= bitstream_get (state
, 7);
236 exponent
+= exp_1
[exps
];
242 *(dest
++) = exponent
;
243 *(dest
++) = exponent
;
245 *(dest
++) = exponent
;
247 *(dest
++) = exponent
;
250 exponent
+= exp_2
[exps
];
256 *(dest
++) = exponent
;
257 *(dest
++) = exponent
;
259 *(dest
++) = exponent
;
261 *(dest
++) = exponent
;
264 exponent
+= exp_3
[exps
];
270 *(dest
++) = exponent
;
271 *(dest
++) = exponent
;
273 *(dest
++) = exponent
;
275 *(dest
++) = exponent
;
282 static int parse_deltba (a52_state_t
* state
, int8_t * deltba
)
284 int deltnseg
, deltlen
, delta
, j
;
286 memset (deltba
, 0, 50);
288 deltnseg
= bitstream_get (state
, 3);
291 j
+= bitstream_get (state
, 5);
292 deltlen
= bitstream_get (state
, 4);
293 delta
= bitstream_get (state
, 3);
294 delta
-= (delta
>= 4) ? 3 : 4;
297 if (j
+ deltlen
>= 50)
301 } while (deltnseg
--);
306 static inline int zero_snr_offsets (int nfchans
, a52_state_t
* state
)
310 if ((state
->csnroffst
) ||
311 (state
->chincpl
&& state
->cplba
.bai
>> 3) || /* cplinu, fsnroffst */
312 (state
->lfeon
&& state
->lfeba
.bai
>> 3)) /* fsnroffst */
314 for (i
= 0; i
< nfchans
; i
++)
315 if (state
->ba
[i
].bai
>> 3) /* fsnroffst */
320 static inline int16_t dither_gen (a52_state_t
* state
)
324 nstate
= dither_lut
[state
->lfsr_state
>> 8] ^ (state
->lfsr_state
<< 8);
326 state
->lfsr_state
= (uint16_t) nstate
;
331 static void coeff_get (a52_state_t
* state
, sample_t
* coeff
,
332 expbap_t
* expbap
, quantizer_t
* quantizer
,
333 sample_t level
, int dither
, int end
)
340 for (i
= 0; i
<= 24; i
++)
341 factor
[i
] = scale_factor
[i
] * level
;
346 for (i
= 0; i
< end
; i
++) {
353 coeff
[i
] = dither_gen (state
) * LEVEL_3DB
* factor
[exp
[i
]];
361 if (quantizer
->q1_ptr
>= 0) {
362 coeff
[i
] = quantizer
->q1
[quantizer
->q1_ptr
--] * factor
[exp
[i
]];
367 code
= bitstream_get (state
, 5);
369 quantizer
->q1_ptr
= 1;
370 quantizer
->q1
[0] = q_1_2
[code
];
371 quantizer
->q1
[1] = q_1_1
[code
];
372 coeff
[i
] = q_1_0
[code
] * factor
[exp
[i
]];
377 if (quantizer
->q2_ptr
>= 0) {
378 coeff
[i
] = quantizer
->q2
[quantizer
->q2_ptr
--] * factor
[exp
[i
]];
383 code
= bitstream_get (state
, 7);
385 quantizer
->q2_ptr
= 1;
386 quantizer
->q2
[0] = q_2_2
[code
];
387 quantizer
->q2
[1] = q_2_1
[code
];
388 coeff
[i
] = q_2_0
[code
] * factor
[exp
[i
]];
393 coeff
[i
] = q_3
[bitstream_get (state
, 3)] * factor
[exp
[i
]];
397 if (quantizer
->q4_ptr
== 0) {
398 quantizer
->q4_ptr
= -1;
399 coeff
[i
] = quantizer
->q4
* factor
[exp
[i
]];
404 code
= bitstream_get (state
, 7);
406 quantizer
->q4_ptr
= 0;
407 quantizer
->q4
= q_4_1
[code
];
408 coeff
[i
] = q_4_0
[code
] * factor
[exp
[i
]];
413 coeff
[i
] = q_5
[bitstream_get (state
, 4)] * factor
[exp
[i
]];
417 coeff
[i
] = ((bitstream_get_2 (state
, bapi
) << (16 - bapi
)) *
423 static void coeff_get_coupling (a52_state_t
* state
, int nfchans
,
424 sample_t
* coeff
, sample_t (* samples
)[256],
425 quantizer_t
* quantizer
, uint8_t dithflag
[5])
427 int cplbndstrc
, bnd
, i
, i_end
, ch
;
432 exp
= state
->cpl_expbap
.exp
;
433 bap
= state
->cpl_expbap
.bap
;
435 cplbndstrc
= state
->cplbndstrc
;
436 i
= state
->cplstrtmant
;
437 while (i
< state
->cplendmant
) {
439 while (cplbndstrc
& 1) {
444 for (ch
= 0; ch
< nfchans
; ch
++)
445 cplco
[ch
] = state
->cplco
[ch
][bnd
] * coeff
[ch
];
455 cplcoeff
= LEVEL_3DB
* scale_factor
[exp
[i
]];
456 for (ch
= 0; ch
< nfchans
; ch
++)
457 if ((state
->chincpl
>> ch
) & 1) {
459 samples
[ch
][i
] = (cplcoeff
* cplco
[ch
] *
468 if (quantizer
->q1_ptr
>= 0) {
469 cplcoeff
= quantizer
->q1
[quantizer
->q1_ptr
--];
474 code
= bitstream_get (state
, 5);
476 quantizer
->q1_ptr
= 1;
477 quantizer
->q1
[0] = q_1_2
[code
];
478 quantizer
->q1
[1] = q_1_1
[code
];
479 cplcoeff
= q_1_0
[code
];
484 if (quantizer
->q2_ptr
>= 0) {
485 cplcoeff
= quantizer
->q2
[quantizer
->q2_ptr
--];
490 code
= bitstream_get (state
, 7);
492 quantizer
->q2_ptr
= 1;
493 quantizer
->q2
[0] = q_2_2
[code
];
494 quantizer
->q2
[1] = q_2_1
[code
];
495 cplcoeff
= q_2_0
[code
];
500 cplcoeff
= q_3
[bitstream_get (state
, 3)];
504 if (quantizer
->q4_ptr
== 0) {
505 quantizer
->q4_ptr
= -1;
506 cplcoeff
= quantizer
->q4
;
511 code
= bitstream_get (state
, 7);
513 quantizer
->q4_ptr
= 0;
514 quantizer
->q4
= q_4_1
[code
];
515 cplcoeff
= q_4_0
[code
];
520 cplcoeff
= q_5
[bitstream_get (state
, 4)];
524 cplcoeff
= bitstream_get_2 (state
, bapi
) << (16 - bapi
);
527 cplcoeff
*= scale_factor
[exp
[i
]];
528 for (ch
= 0; ch
< nfchans
; ch
++)
529 if ((state
->chincpl
>> ch
) & 1)
530 samples
[ch
][i
] = cplcoeff
* cplco
[ch
];
536 int a52_block (a52_state_t
* state
)
538 static const uint8_t nfchans_tbl
[] = {2, 1, 2, 3, 3, 4, 4, 5, 1, 1, 2};
539 static int rematrix_band
[4] = {25, 37, 61, 253};
540 int i
, nfchans
, chaninfo
;
541 uint8_t cplexpstr
, chexpstr
[5], lfeexpstr
, do_bit_alloc
, done_cpl
;
542 uint8_t blksw
[5], dithflag
[5];
545 quantizer_t quantizer
;
548 nfchans
= nfchans_tbl
[state
->acmod
];
550 for (i
= 0; i
< nfchans
; i
++)
551 blksw
[i
] = bitstream_get (state
, 1);
553 for (i
= 0; i
< nfchans
; i
++)
554 dithflag
[i
] = bitstream_get (state
, 1);
556 chaninfo
= !state
->acmod
;
558 if (bitstream_get (state
, 1)) { /* dynrnge */
561 dynrng
= bitstream_get_2 (state
, 8);
562 if (state
->dynrnge
) {
565 range
= ((((dynrng
& 0x1f) | 0x20) << 13) *
566 scale_factor
[3 - (dynrng
>> 5)]);
567 if (state
->dynrngcall
)
568 range
= state
->dynrngcall (range
, state
->dynrngdata
);
569 state
->dynrng
= state
->level
* range
;
572 } while (chaninfo
--);
574 if (bitstream_get (state
, 1)) { /* cplstre */
576 if (bitstream_get (state
, 1)) { /* cplinu */
577 static uint8_t bndtab
[16] = {31, 35, 37, 39, 41, 42, 43, 44,
578 45, 45, 46, 46, 47, 47, 48, 48};
583 for (i
= 0; i
< nfchans
; i
++)
584 state
->chincpl
|= bitstream_get (state
, 1) << i
;
585 switch (state
->acmod
) {
589 state
->phsflginu
= bitstream_get (state
, 1);
591 cplbegf
= bitstream_get (state
, 4);
592 cplendf
= bitstream_get (state
, 4);
594 if (cplendf
+ 3 - cplbegf
< 0)
596 state
->ncplbnd
= ncplsubnd
= cplendf
+ 3 - cplbegf
;
597 state
->cplstrtbnd
= bndtab
[cplbegf
];
598 state
->cplstrtmant
= cplbegf
* 12 + 37;
599 state
->cplendmant
= cplendf
* 12 + 73;
601 state
->cplbndstrc
= 0;
602 for (i
= 0; i
< ncplsubnd
- 1; i
++)
603 if (bitstream_get (state
, 1)) {
604 state
->cplbndstrc
|= 1 << i
;
610 if (state
->chincpl
) { /* cplinu */
614 for (i
= 0; i
< nfchans
; i
++)
615 if ((state
->chincpl
) >> i
& 1)
616 if (bitstream_get (state
, 1)) { /* cplcoe */
617 int mstrcplco
, cplcoexp
, cplcomant
;
620 mstrcplco
= 3 * bitstream_get (state
, 2);
621 for (j
= 0; j
< state
->ncplbnd
; j
++) {
622 cplcoexp
= bitstream_get (state
, 4);
623 cplcomant
= bitstream_get (state
, 4);
627 cplcomant
= (cplcomant
| 0x10) << 13;
629 cplcomant
* scale_factor
[cplcoexp
+ mstrcplco
];
632 if ((state
->acmod
== 2) && state
->phsflginu
&& cplcoe
)
633 for (j
= 0; j
< state
->ncplbnd
; j
++)
634 if (bitstream_get (state
, 1)) /* phsflg */
635 state
->cplco
[1][j
] = -state
->cplco
[1][j
];
638 if ((state
->acmod
== 2) && (bitstream_get (state
, 1))) { /* rematstr */
642 end
= (state
->chincpl
) ? state
->cplstrtmant
: 253; /* cplinu */
645 state
->rematflg
|= bitstream_get (state
, 1) << i
;
646 while (rematrix_band
[i
++] < end
);
649 cplexpstr
= EXP_REUSE
;
650 lfeexpstr
= EXP_REUSE
;
651 if (state
->chincpl
) /* cplinu */
652 cplexpstr
= bitstream_get (state
, 2);
653 for (i
= 0; i
< nfchans
; i
++)
654 chexpstr
[i
] = bitstream_get (state
, 2);
656 lfeexpstr
= bitstream_get (state
, 1);
658 for (i
= 0; i
< nfchans
; i
++)
659 if (chexpstr
[i
] != EXP_REUSE
) {
660 if ((state
->chincpl
>> i
) & 1)
661 state
->endmant
[i
] = state
->cplstrtmant
;
665 chbwcod
= bitstream_get (state
, 6);
668 state
->endmant
[i
] = chbwcod
* 3 + 73;
674 if (cplexpstr
!= EXP_REUSE
) {
675 int cplabsexp
, ncplgrps
;
678 ncplgrps
= ((state
->cplendmant
- state
->cplstrtmant
) /
679 (3 << (cplexpstr
- 1)));
680 cplabsexp
= bitstream_get (state
, 4) << 1;
681 if (parse_exponents (state
, cplexpstr
, ncplgrps
, cplabsexp
,
682 state
->cpl_expbap
.exp
+ state
->cplstrtmant
))
685 for (i
= 0; i
< nfchans
; i
++)
686 if (chexpstr
[i
] != EXP_REUSE
) {
687 int grp_size
, nchgrps
;
689 do_bit_alloc
|= 1 << i
;
690 grp_size
= 3 << (chexpstr
[i
] - 1);
691 nchgrps
= (state
->endmant
[i
] + grp_size
- 4) / grp_size
;
692 state
->fbw_expbap
[i
].exp
[0] = bitstream_get (state
, 4);
693 if (parse_exponents (state
, chexpstr
[i
], nchgrps
,
694 state
->fbw_expbap
[i
].exp
[0],
695 state
->fbw_expbap
[i
].exp
+ 1))
697 bitstream_skip (state
, 2); /* gainrng */
699 if (lfeexpstr
!= EXP_REUSE
) {
701 state
->lfe_expbap
.exp
[0] = bitstream_get (state
, 4);
702 if (parse_exponents (state
, lfeexpstr
, 2, state
->lfe_expbap
.exp
[0],
703 state
->lfe_expbap
.exp
+ 1))
707 if (bitstream_get (state
, 1)) { /* baie */
709 state
->bai
= bitstream_get (state
, 11);
711 if (bitstream_get (state
, 1)) { /* snroffste */
713 state
->csnroffst
= bitstream_get (state
, 6);
714 if (state
->chincpl
) /* cplinu */
715 state
->cplba
.bai
= bitstream_get (state
, 7);
716 for (i
= 0; i
< nfchans
; i
++)
717 state
->ba
[i
].bai
= bitstream_get (state
, 7);
719 state
->lfeba
.bai
= bitstream_get (state
, 7);
721 if ((state
->chincpl
) && (bitstream_get (state
, 1))) { /* cplleake */
723 state
->cplfleak
= 9 - bitstream_get (state
, 3);
724 state
->cplsleak
= 9 - bitstream_get (state
, 3);
727 if (bitstream_get (state
, 1)) { /* deltbaie */
729 if (state
->chincpl
) /* cplinu */
730 state
->cplba
.deltbae
= bitstream_get (state
, 2);
731 for (i
= 0; i
< nfchans
; i
++)
732 state
->ba
[i
].deltbae
= bitstream_get (state
, 2);
733 if (state
->chincpl
&& /* cplinu */
734 (state
->cplba
.deltbae
== DELTA_BIT_NEW
) &&
735 parse_deltba (state
, state
->cplba
.deltba
))
737 for (i
= 0; i
< nfchans
; i
++)
738 if ((state
->ba
[i
].deltbae
== DELTA_BIT_NEW
) &&
739 parse_deltba (state
, state
->ba
[i
].deltba
))
744 if (zero_snr_offsets (nfchans
, state
)) {
745 memset (state
->cpl_expbap
.bap
, 0, sizeof (state
->cpl_expbap
.bap
));
746 for (i
= 0; i
< nfchans
; i
++)
747 memset (state
->fbw_expbap
[i
].bap
, 0,
748 sizeof (state
->fbw_expbap
[i
].bap
));
749 memset (state
->lfe_expbap
.bap
, 0, sizeof (state
->lfe_expbap
.bap
));
751 if (state
->chincpl
&& (do_bit_alloc
& 64)) /* cplinu */
752 a52_bit_allocate (state
, &state
->cplba
, state
->cplstrtbnd
,
753 state
->cplstrtmant
, state
->cplendmant
,
754 state
->cplfleak
<< 8, state
->cplsleak
<< 8,
756 for (i
= 0; i
< nfchans
; i
++)
757 if (do_bit_alloc
& (1 << i
))
758 a52_bit_allocate (state
, state
->ba
+ i
, 0, 0,
759 state
->endmant
[i
], 0, 0,
760 state
->fbw_expbap
+i
);
761 if (state
->lfeon
&& (do_bit_alloc
& 32)) {
762 state
->lfeba
.deltbae
= DELTA_BIT_NONE
;
763 a52_bit_allocate (state
, &state
->lfeba
, 0, 0, 7, 0, 0,
769 if (bitstream_get (state
, 1)) { /* skiple */
770 i
= bitstream_get (state
, 9); /* skipl */
772 bitstream_skip (state
, 8);
775 samples
= state
->samples
;
776 if (state
->output
& A52_LFE
)
777 samples
+= 256; /* shift for LFE channel */
779 chanbias
= a52_downmix_coeff (coeff
, state
->acmod
, state
->output
,
780 state
->dynrng
, state
->clev
, state
->slev
);
782 quantizer
.q1_ptr
= quantizer
.q2_ptr
= quantizer
.q4_ptr
= -1;
785 for (i
= 0; i
< nfchans
; i
++) {
788 coeff_get (state
, samples
+ 256 * i
, state
->fbw_expbap
+i
, &quantizer
,
789 coeff
[i
], dithflag
[i
], state
->endmant
[i
]);
791 if ((state
->chincpl
>> i
) & 1) {
794 coeff_get_coupling (state
, nfchans
, coeff
,
795 (sample_t (*)[256])samples
, &quantizer
,
798 j
= state
->cplendmant
;
800 j
= state
->endmant
[i
];
802 (samples
+ 256 * i
)[j
] = 0;
806 if (state
->acmod
== 2) {
807 int j
, end
, band
, rematflg
;
809 end
= ((state
->endmant
[0] < state
->endmant
[1]) ?
810 state
->endmant
[0] : state
->endmant
[1]);
814 rematflg
= state
->rematflg
;
816 if (! (rematflg
& 1)) {
818 j
= rematrix_band
[i
++];
822 band
= rematrix_band
[i
++];
829 tmp1
= (samples
+256)[j
];
830 samples
[j
] = tmp0
+ tmp1
;
831 (samples
+256)[j
] = tmp0
- tmp1
;
832 } while (++j
< band
);
837 if (state
->output
& A52_LFE
) {
838 coeff_get (state
, samples
- 256, &state
->lfe_expbap
, &quantizer
,
839 state
->dynrng
, 0, 7);
840 for (i
= 7; i
< 256; i
++)
841 (samples
-256)[i
] = 0;
842 a52_imdct_512 (samples
- 256, samples
+ 1536 - 256, state
->bias
);
844 /* just skip the LFE coefficients */
845 coeff_get (state
, samples
+ 1280, &state
->lfe_expbap
, &quantizer
,
851 if (nfchans_tbl
[state
->output
& A52_CHANNEL_MASK
] < nfchans
)
852 for (i
= 1; i
< nfchans
; i
++)
853 if (blksw
[i
] != blksw
[0])
857 if (state
->downmixed
) {
858 state
->downmixed
= 0;
859 a52_upmix (samples
+ 1536, state
->acmod
, state
->output
);
862 for (i
= 0; i
< nfchans
; i
++) {
866 if (!(chanbias
& (1 << i
)))
871 a52_imdct_256 (samples
+ 256 * i
, samples
+ 1536 + 256 * i
,
874 a52_imdct_512 (samples
+ 256 * i
, samples
+ 1536 + 256 * i
,
879 for (j
= 0; j
< 256; j
++)
880 (samples
+ 256 * i
)[j
] = bias
;
884 a52_downmix (samples
, state
->acmod
, state
->output
, state
->bias
,
885 state
->clev
, state
->slev
);
887 nfchans
= nfchans_tbl
[state
->output
& A52_CHANNEL_MASK
];
889 a52_downmix (samples
, state
->acmod
, state
->output
, 0,
890 state
->clev
, state
->slev
);
892 if (!state
->downmixed
) {
893 state
->downmixed
= 1;
894 a52_downmix (samples
+ 1536, state
->acmod
, state
->output
, 0,
895 state
->clev
, state
->slev
);
899 for (i
= 0; i
< nfchans
; i
++)
900 a52_imdct_256 (samples
+ 256 * i
, samples
+ 1536 + 256 * i
,
903 for (i
= 0; i
< nfchans
; i
++)
904 a52_imdct_512 (samples
+ 256 * i
, samples
+ 1536 + 256 * i
,
911 void a52_free (a52_state_t
* state
)
913 #if defined(__MINGW32__) && defined(HAVE_SSE)
914 av_free (state
->samples
);
916 free (state
->samples
);