Mercurial > libavcodec.hg
annotate ac3dec.c @ 12454:f4355cd85faa libavcodec
Port latest x264 deblock asm (before they moved to using NV12 as internal
format), LGPL'ed with permission from Jason and Loren. This includes mmx2
code, so remove inline asm from h264dsp_mmx.c accordingly.
author | rbultje |
---|---|
date | Fri, 03 Sep 2010 16:52:46 +0000 |
parents | 0c98bdb71f48 |
children |
rev | line source |
---|---|
5328 | 1 /* |
2 * AC-3 Audio Decoder | |
7626 | 3 * This code was developed as part of Google Summer of Code 2006. |
4 * E-AC-3 support was added as part of Google Summer of Code 2007. | |
5316
a09b700fcfca
AC-3 decoder, soc revision 56, Aug 17 14:21:58 2006 UTC by cloud9
jbr
parents:
5315
diff
changeset
|
5 * |
8629
04423b2f6e0b
cosmetics: Remove pointless period after copyright statement non-sentences.
diego
parents:
8545
diff
changeset
|
6 * Copyright (c) 2006 Kartikey Mahendra BHATT (bhattkm at gmail dot com) |
7626 | 7 * Copyright (c) 2007-2008 Bartlomiej Wolowiec <bartek.wolowiec@gmail.com> |
7594
cd6217c9ce92
update my email address to one which does not depend on my service provider
jbr
parents:
7564
diff
changeset
|
8 * Copyright (c) 2007 Justin Ruggles <justin.ruggles@gmail.com> |
5316
a09b700fcfca
AC-3 decoder, soc revision 56, Aug 17 14:21:58 2006 UTC by cloud9
jbr
parents:
5315
diff
changeset
|
9 * |
5328 | 10 * This file is part of FFmpeg. |
5303
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
11 * |
5328 | 12 * FFmpeg is free software; you can redistribute it and/or |
9673
3e1a08ba8481
The AC-3 decoder is now LGPL. Exchange the license header and change references
diego
parents:
9672
diff
changeset
|
13 * modify it under the terms of the GNU Lesser General Public |
5303
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
14 * License as published by the Free Software Foundation; either |
9673
3e1a08ba8481
The AC-3 decoder is now LGPL. Exchange the license header and change references
diego
parents:
9672
diff
changeset
|
15 * version 2.1 of the License, or (at your option) any later version. |
5303
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
16 * |
5328 | 17 * FFmpeg is distributed in the hope that it will be useful, |
5303
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
9673
3e1a08ba8481
The AC-3 decoder is now LGPL. Exchange the license header and change references
diego
parents:
9672
diff
changeset
|
20 * Lesser General Public License for more details. |
5303
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
21 * |
9673
3e1a08ba8481
The AC-3 decoder is now LGPL. Exchange the license header and change references
diego
parents:
9672
diff
changeset
|
22 * You should have received a copy of the GNU Lesser General Public |
5328 | 23 * License along with FFmpeg; if not, write to the Free Software |
5303
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
24 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
25 */ |
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
26 |
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
27 #include <stdio.h> |
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
28 #include <stddef.h> |
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
29 #include <math.h> |
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
30 #include <string.h> |
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
31 |
6763 | 32 #include "libavutil/crc.h" |
8281
f93efc084e41
Make av_log_missing_feature an internal function, and change its name
stefano
parents:
8280
diff
changeset
|
33 #include "internal.h" |
8545
a5402e89a80c
Factorise enum of AC3 error types to be usable by AAC in the ADTS patch that
superdump
parents:
8281
diff
changeset
|
34 #include "aac_ac3_parser.h" |
5386
d6347c3cb329
Use shared AC-3 header parsing. Move some initializations to block parsing function.
jbr
parents:
5385
diff
changeset
|
35 #include "ac3_parser.h" |
7020
40a2db8dbaa2
move the decode context and some macro constants to a new file, ac3dec.h
jbr
parents:
7019
diff
changeset
|
36 #include "ac3dec.h" |
7033 | 37 #include "ac3dec_data.h" |
5309
0662a270aab7
AC-3 decoder, soc revision 38, Aug 7 00:03:00 2006 UTC by cloud9
jbr
parents:
5308
diff
changeset
|
38 |
7624
545305ba44a0
rename AC3_MAX_FRAME_SIZE to AC3_FRAME_BUFFER_SIZE and increase the size
jbr
parents:
7603
diff
changeset
|
39 /** Large enough for maximum possible frame size when the specification limit is ignored */ |
545305ba44a0
rename AC3_MAX_FRAME_SIZE to AC3_FRAME_BUFFER_SIZE and increase the size
jbr
parents:
7603
diff
changeset
|
40 #define AC3_FRAME_BUFFER_SIZE 32768 |
6536
8f2186d5daca
additional protection from segmentation faults and memory access errors by
jbr
parents:
6529
diff
changeset
|
41 |
7471
1788013cf23b
use the same table for ungrouping exponents and bap=2 mantissas
jbr
parents:
7470
diff
changeset
|
42 /** |
1788013cf23b
use the same table for ungrouping exponents and bap=2 mantissas
jbr
parents:
7470
diff
changeset
|
43 * table for ungrouping 3 values in 7 bits. |
1788013cf23b
use the same table for ungrouping exponents and bap=2 mantissas
jbr
parents:
7470
diff
changeset
|
44 * used for exponents and bap=2 mantissas |
1788013cf23b
use the same table for ungrouping exponents and bap=2 mantissas
jbr
parents:
7470
diff
changeset
|
45 */ |
1788013cf23b
use the same table for ungrouping exponents and bap=2 mantissas
jbr
parents:
7470
diff
changeset
|
46 static uint8_t ungroup_3_in_7_bits_tab[128][3]; |
5325
0d963101e0d7
AC-3 decoder, soc revision 402, Jul 14 13:45:14 2007 UTC by jbr
jbr
parents:
5324
diff
changeset
|
47 |
0d963101e0d7
AC-3 decoder, soc revision 402, Jul 14 13:45:14 2007 UTC by jbr
jbr
parents:
5324
diff
changeset
|
48 |
5456 | 49 /** tables for ungrouping mantissas */ |
6430
de7502093922
Use 24-bit fixed-point transform coefficients until just before MDCT. This
jbr
parents:
6142
diff
changeset
|
50 static int b1_mantissas[32][3]; |
de7502093922
Use 24-bit fixed-point transform coefficients until just before MDCT. This
jbr
parents:
6142
diff
changeset
|
51 static int b2_mantissas[128][3]; |
de7502093922
Use 24-bit fixed-point transform coefficients until just before MDCT. This
jbr
parents:
6142
diff
changeset
|
52 static int b3_mantissas[8]; |
de7502093922
Use 24-bit fixed-point transform coefficients until just before MDCT. This
jbr
parents:
6142
diff
changeset
|
53 static int b4_mantissas[128][2]; |
de7502093922
Use 24-bit fixed-point transform coefficients until just before MDCT. This
jbr
parents:
6142
diff
changeset
|
54 static int b5_mantissas[16]; |
5325
0d963101e0d7
AC-3 decoder, soc revision 402, Jul 14 13:45:14 2007 UTC by jbr
jbr
parents:
5324
diff
changeset
|
55 |
5456 | 56 /** |
57 * Quantization table: levels for symmetric. bits for asymmetric. | |
58 * reference: Table 7.18 Mapping of bap to Quantizer | |
59 */ | |
6006 | 60 static const uint8_t quantization_tab[16] = { |
5456 | 61 0, 3, 5, 7, 11, 15, |
62 5, 6, 7, 8, 9, 10, 11, 12, 14, 16 | |
63 }; | |
5325
0d963101e0d7
AC-3 decoder, soc revision 402, Jul 14 13:45:14 2007 UTC by jbr
jbr
parents:
5324
diff
changeset
|
64 |
5457
0a5849a4858b
use table for converting dynamic range codes to scale factors
jbr
parents:
5456
diff
changeset
|
65 /** dynamic range table. converts codes to scale factors. */ |
6006 | 66 static float dynamic_range_tab[256]; |
5457
0a5849a4858b
use table for converting dynamic range codes to scale factors
jbr
parents:
5456
diff
changeset
|
67 |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
68 /** Adjustments in dB gain */ |
7018
885cad616170
add more gain levels and adjust mix level tables accordingly.
jbr
parents:
7017
diff
changeset
|
69 #define LEVEL_PLUS_3DB 1.4142135623730950 |
885cad616170
add more gain levels and adjust mix level tables accordingly.
jbr
parents:
7017
diff
changeset
|
70 #define LEVEL_PLUS_1POINT5DB 1.1892071150027209 |
885cad616170
add more gain levels and adjust mix level tables accordingly.
jbr
parents:
7017
diff
changeset
|
71 #define LEVEL_MINUS_1POINT5DB 0.8408964152537145 |
5325
0d963101e0d7
AC-3 decoder, soc revision 402, Jul 14 13:45:14 2007 UTC by jbr
jbr
parents:
5324
diff
changeset
|
72 #define LEVEL_MINUS_3DB 0.7071067811865476 |
0d963101e0d7
AC-3 decoder, soc revision 402, Jul 14 13:45:14 2007 UTC by jbr
jbr
parents:
5324
diff
changeset
|
73 #define LEVEL_MINUS_4POINT5DB 0.5946035575013605 |
0d963101e0d7
AC-3 decoder, soc revision 402, Jul 14 13:45:14 2007 UTC by jbr
jbr
parents:
5324
diff
changeset
|
74 #define LEVEL_MINUS_6DB 0.5000000000000000 |
5480 | 75 #define LEVEL_MINUS_9DB 0.3535533905932738 |
5325
0d963101e0d7
AC-3 decoder, soc revision 402, Jul 14 13:45:14 2007 UTC by jbr
jbr
parents:
5324
diff
changeset
|
76 #define LEVEL_ZERO 0.0000000000000000 |
5480 | 77 #define LEVEL_ONE 1.0000000000000000 |
78 | |
7018
885cad616170
add more gain levels and adjust mix level tables accordingly.
jbr
parents:
7017
diff
changeset
|
79 static const float gain_levels[9] = { |
885cad616170
add more gain levels and adjust mix level tables accordingly.
jbr
parents:
7017
diff
changeset
|
80 LEVEL_PLUS_3DB, |
885cad616170
add more gain levels and adjust mix level tables accordingly.
jbr
parents:
7017
diff
changeset
|
81 LEVEL_PLUS_1POINT5DB, |
5480 | 82 LEVEL_ONE, |
7018
885cad616170
add more gain levels and adjust mix level tables accordingly.
jbr
parents:
7017
diff
changeset
|
83 LEVEL_MINUS_1POINT5DB, |
5480 | 84 LEVEL_MINUS_3DB, |
85 LEVEL_MINUS_4POINT5DB, | |
86 LEVEL_MINUS_6DB, | |
7018
885cad616170
add more gain levels and adjust mix level tables accordingly.
jbr
parents:
7017
diff
changeset
|
87 LEVEL_ZERO, |
5480 | 88 LEVEL_MINUS_9DB |
89 }; | |
90 | |
91 /** | |
7019
81d5c68233e5
move mix level tables from parser to decoder. have parser read bitstream value instead of using an index to a table in the decoder.
jbr
parents:
7018
diff
changeset
|
92 * Table for center mix levels |
81d5c68233e5
move mix level tables from parser to decoder. have parser read bitstream value instead of using an index to a table in the decoder.
jbr
parents:
7018
diff
changeset
|
93 * reference: Section 5.4.2.4 cmixlev |
81d5c68233e5
move mix level tables from parser to decoder. have parser read bitstream value instead of using an index to a table in the decoder.
jbr
parents:
7018
diff
changeset
|
94 */ |
81d5c68233e5
move mix level tables from parser to decoder. have parser read bitstream value instead of using an index to a table in the decoder.
jbr
parents:
7018
diff
changeset
|
95 static const uint8_t center_levels[4] = { 4, 5, 6, 5 }; |
81d5c68233e5
move mix level tables from parser to decoder. have parser read bitstream value instead of using an index to a table in the decoder.
jbr
parents:
7018
diff
changeset
|
96 |
81d5c68233e5
move mix level tables from parser to decoder. have parser read bitstream value instead of using an index to a table in the decoder.
jbr
parents:
7018
diff
changeset
|
97 /** |
81d5c68233e5
move mix level tables from parser to decoder. have parser read bitstream value instead of using an index to a table in the decoder.
jbr
parents:
7018
diff
changeset
|
98 * Table for surround mix levels |
81d5c68233e5
move mix level tables from parser to decoder. have parser read bitstream value instead of using an index to a table in the decoder.
jbr
parents:
7018
diff
changeset
|
99 * reference: Section 5.4.2.5 surmixlev |
81d5c68233e5
move mix level tables from parser to decoder. have parser read bitstream value instead of using an index to a table in the decoder.
jbr
parents:
7018
diff
changeset
|
100 */ |
81d5c68233e5
move mix level tables from parser to decoder. have parser read bitstream value instead of using an index to a table in the decoder.
jbr
parents:
7018
diff
changeset
|
101 static const uint8_t surround_levels[4] = { 4, 6, 7, 6 }; |
81d5c68233e5
move mix level tables from parser to decoder. have parser read bitstream value instead of using an index to a table in the decoder.
jbr
parents:
7018
diff
changeset
|
102 |
81d5c68233e5
move mix level tables from parser to decoder. have parser read bitstream value instead of using an index to a table in the decoder.
jbr
parents:
7018
diff
changeset
|
103 /** |
5480 | 104 * Table for default stereo downmixing coefficients |
105 * reference: Section 7.8.2 Downmixing Into Two Channels | |
106 */ | |
107 static const uint8_t ac3_default_coeffs[8][5][2] = { | |
7018
885cad616170
add more gain levels and adjust mix level tables accordingly.
jbr
parents:
7017
diff
changeset
|
108 { { 2, 7 }, { 7, 2 }, }, |
885cad616170
add more gain levels and adjust mix level tables accordingly.
jbr
parents:
7017
diff
changeset
|
109 { { 4, 4 }, }, |
885cad616170
add more gain levels and adjust mix level tables accordingly.
jbr
parents:
7017
diff
changeset
|
110 { { 2, 7 }, { 7, 2 }, }, |
885cad616170
add more gain levels and adjust mix level tables accordingly.
jbr
parents:
7017
diff
changeset
|
111 { { 2, 7 }, { 5, 5 }, { 7, 2 }, }, |
885cad616170
add more gain levels and adjust mix level tables accordingly.
jbr
parents:
7017
diff
changeset
|
112 { { 2, 7 }, { 7, 2 }, { 6, 6 }, }, |
885cad616170
add more gain levels and adjust mix level tables accordingly.
jbr
parents:
7017
diff
changeset
|
113 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 }, }, |
885cad616170
add more gain levels and adjust mix level tables accordingly.
jbr
parents:
7017
diff
changeset
|
114 { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, }, |
885cad616170
add more gain levels and adjust mix level tables accordingly.
jbr
parents:
7017
diff
changeset
|
115 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, }, |
5480 | 116 }; |
5325
0d963101e0d7
AC-3 decoder, soc revision 402, Jul 14 13:45:14 2007 UTC by jbr
jbr
parents:
5324
diff
changeset
|
117 |
5310
9aa9197034d7
AC-3 decoder, soc revision 40, Aug 9 00:10:14 2006 UTC by cloud9
jbr
parents:
5309
diff
changeset
|
118 /** |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
119 * Symmetrical Dequantization |
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
120 * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization |
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
121 * Tables 7.19 to 7.23 |
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
122 */ |
6430
de7502093922
Use 24-bit fixed-point transform coefficients until just before MDCT. This
jbr
parents:
6142
diff
changeset
|
123 static inline int |
5456 | 124 symmetric_dequant(int code, int levels) |
5309
0662a270aab7
AC-3 decoder, soc revision 38, Aug 7 00:03:00 2006 UTC by cloud9
jbr
parents:
5308
diff
changeset
|
125 { |
6430
de7502093922
Use 24-bit fixed-point transform coefficients until just before MDCT. This
jbr
parents:
6142
diff
changeset
|
126 return ((code - (levels >> 1)) << 24) / levels; |
5309
0662a270aab7
AC-3 decoder, soc revision 38, Aug 7 00:03:00 2006 UTC by cloud9
jbr
parents:
5308
diff
changeset
|
127 } |
0662a270aab7
AC-3 decoder, soc revision 38, Aug 7 00:03:00 2006 UTC by cloud9
jbr
parents:
5308
diff
changeset
|
128 |
5321
fcb2a52c88fe
AC-3 decoder, soc revision 71, Sep 4 09:47:12 2006 UTC by cloud9
jbr
parents:
5320
diff
changeset
|
129 /* |
fcb2a52c88fe
AC-3 decoder, soc revision 71, Sep 4 09:47:12 2006 UTC by cloud9
jbr
parents:
5320
diff
changeset
|
130 * Initialize tables at runtime. |
fcb2a52c88fe
AC-3 decoder, soc revision 71, Sep 4 09:47:12 2006 UTC by cloud9
jbr
parents:
5320
diff
changeset
|
131 */ |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6487
diff
changeset
|
132 static av_cold void ac3_tables_init(void) |
5305
5892b4a6380b
AC-3 decoder, soc revision 31, Jul 14 23:53:28 2006 UTC by cloud9
jbr
parents:
5304
diff
changeset
|
133 { |
5375 | 134 int i; |
5309
0662a270aab7
AC-3 decoder, soc revision 38, Aug 7 00:03:00 2006 UTC by cloud9
jbr
parents:
5308
diff
changeset
|
135 |
7471
1788013cf23b
use the same table for ungrouping exponents and bap=2 mantissas
jbr
parents:
7470
diff
changeset
|
136 /* generate table for ungrouping 3 values in 7 bits |
1788013cf23b
use the same table for ungrouping exponents and bap=2 mantissas
jbr
parents:
7470
diff
changeset
|
137 reference: Section 7.1.3 Exponent Decoding */ |
1788013cf23b
use the same table for ungrouping exponents and bap=2 mantissas
jbr
parents:
7470
diff
changeset
|
138 for(i=0; i<128; i++) { |
1788013cf23b
use the same table for ungrouping exponents and bap=2 mantissas
jbr
parents:
7470
diff
changeset
|
139 ungroup_3_in_7_bits_tab[i][0] = i / 25; |
1788013cf23b
use the same table for ungrouping exponents and bap=2 mantissas
jbr
parents:
7470
diff
changeset
|
140 ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5; |
1788013cf23b
use the same table for ungrouping exponents and bap=2 mantissas
jbr
parents:
7470
diff
changeset
|
141 ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5; |
1788013cf23b
use the same table for ungrouping exponents and bap=2 mantissas
jbr
parents:
7470
diff
changeset
|
142 } |
1788013cf23b
use the same table for ungrouping exponents and bap=2 mantissas
jbr
parents:
7470
diff
changeset
|
143 |
5456 | 144 /* generate grouped mantissa tables |
145 reference: Section 7.3.5 Ungrouping of Mantissas */ | |
146 for(i=0; i<32; i++) { | |
147 /* bap=1 mantissas */ | |
7472
83c16f531a90
Hardcode the table for ungrouping 3 values in 5 bits. It will be reused by
jbr
parents:
7471
diff
changeset
|
148 b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3); |
83c16f531a90
Hardcode the table for ungrouping 3 values in 5 bits. It will be reused by
jbr
parents:
7471
diff
changeset
|
149 b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3); |
83c16f531a90
Hardcode the table for ungrouping 3 values in 5 bits. It will be reused by
jbr
parents:
7471
diff
changeset
|
150 b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3); |
5456 | 151 } |
152 for(i=0; i<128; i++) { | |
153 /* bap=2 mantissas */ | |
7471
1788013cf23b
use the same table for ungrouping exponents and bap=2 mantissas
jbr
parents:
7470
diff
changeset
|
154 b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5); |
1788013cf23b
use the same table for ungrouping exponents and bap=2 mantissas
jbr
parents:
7470
diff
changeset
|
155 b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5); |
1788013cf23b
use the same table for ungrouping exponents and bap=2 mantissas
jbr
parents:
7470
diff
changeset
|
156 b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5); |
5309
0662a270aab7
AC-3 decoder, soc revision 38, Aug 7 00:03:00 2006 UTC by cloud9
jbr
parents:
5308
diff
changeset
|
157 |
5456 | 158 /* bap=4 mantissas */ |
159 b4_mantissas[i][0] = symmetric_dequant(i / 11, 11); | |
160 b4_mantissas[i][1] = symmetric_dequant(i % 11, 11); | |
161 } | |
162 /* generate ungrouped mantissa tables | |
163 reference: Tables 7.21 and 7.23 */ | |
164 for(i=0; i<7; i++) { | |
165 /* bap=3 mantissas */ | |
166 b3_mantissas[i] = symmetric_dequant(i, 7); | |
167 } | |
168 for(i=0; i<15; i++) { | |
169 /* bap=5 mantissas */ | |
170 b5_mantissas[i] = symmetric_dequant(i, 15); | |
171 } | |
5321
fcb2a52c88fe
AC-3 decoder, soc revision 71, Sep 4 09:47:12 2006 UTC by cloud9
jbr
parents:
5320
diff
changeset
|
172 |
5457
0a5849a4858b
use table for converting dynamic range codes to scale factors
jbr
parents:
5456
diff
changeset
|
173 /* generate dynamic range table |
0a5849a4858b
use table for converting dynamic range codes to scale factors
jbr
parents:
5456
diff
changeset
|
174 reference: Section 7.7.1 Dynamic Range Control */ |
0a5849a4858b
use table for converting dynamic range codes to scale factors
jbr
parents:
5456
diff
changeset
|
175 for(i=0; i<256; i++) { |
0a5849a4858b
use table for converting dynamic range codes to scale factors
jbr
parents:
5456
diff
changeset
|
176 int v = (i >> 5) - ((i >> 7) << 3) - 5; |
6006 | 177 dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20); |
5457
0a5849a4858b
use table for converting dynamic range codes to scale factors
jbr
parents:
5456
diff
changeset
|
178 } |
5305
5892b4a6380b
AC-3 decoder, soc revision 31, Jul 14 23:53:28 2006 UTC by cloud9
jbr
parents:
5304
diff
changeset
|
179 } |
5892b4a6380b
AC-3 decoder, soc revision 31, Jul 14 23:53:28 2006 UTC by cloud9
jbr
parents:
5304
diff
changeset
|
180 |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
181 |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
182 /** |
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
183 * AVCodec initialization |
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
184 */ |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6487
diff
changeset
|
185 static av_cold int ac3_decode_init(AVCodecContext *avctx) |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
186 { |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
187 AC3DecodeContext *s = avctx->priv_data; |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
188 s->avctx = avctx; |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
189 |
5331 | 190 ac3_common_init(); |
5309
0662a270aab7
AC-3 decoder, soc revision 38, Aug 7 00:03:00 2006 UTC by cloud9
jbr
parents:
5308
diff
changeset
|
191 ac3_tables_init(); |
9658
67a20f0eb42c
Support for getting (i)MDCT output multiplied by a constant scaling factor.
serge
parents:
9608
diff
changeset
|
192 ff_mdct_init(&s->imdct_256, 8, 1, 1.0); |
67a20f0eb42c
Support for getting (i)MDCT output multiplied by a constant scaling factor.
serge
parents:
9608
diff
changeset
|
193 ff_mdct_init(&s->imdct_512, 9, 1, 1.0); |
6142
a35b838ab955
Add variable alpha and size of half window for Kaiser-Bessel Derived window
superdump
parents:
6139
diff
changeset
|
194 ff_kbd_window_init(s->window, 5.0, 256); |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
195 dsputil_init(&s->dsp, avctx); |
7601 | 196 av_lfg_init(&s->dith_state, 0); |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
197 |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
198 /* set bias values for float to int16 conversion */ |
7550 | 199 if(s->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) { |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
200 s->add_bias = 385.0f; |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
201 s->mul_bias = 1.0f; |
5479
943c732c905d
use dsputil for float to signed 16-bit sample conversion
jbr
parents:
5477
diff
changeset
|
202 } else { |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
203 s->add_bias = 0.0f; |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
204 s->mul_bias = 32767.0f; |
5479
943c732c905d
use dsputil for float to signed 16-bit sample conversion
jbr
parents:
5477
diff
changeset
|
205 } |
943c732c905d
use dsputil for float to signed 16-bit sample conversion
jbr
parents:
5477
diff
changeset
|
206 |
6112 | 207 /* allow downmixing to stereo or mono */ |
208 if (avctx->channels > 0 && avctx->request_channels > 0 && | |
209 avctx->request_channels < avctx->channels && | |
210 avctx->request_channels <= 2) { | |
211 avctx->channels = avctx->request_channels; | |
212 } | |
6480
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
213 s->downmixed = 1; |
6112 | 214 |
6538
b8f886bce6f5
only allocate context input buffer if AVCodecContext.error_reslience is greater than 0.
jbr
parents:
6537
diff
changeset
|
215 /* allocate context input buffer */ |
7831 | 216 if (avctx->error_recognition >= FF_ER_CAREFUL) { |
7624
545305ba44a0
rename AC3_MAX_FRAME_SIZE to AC3_FRAME_BUFFER_SIZE and increase the size
jbr
parents:
7603
diff
changeset
|
217 s->input_buffer = av_mallocz(AC3_FRAME_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE); |
6538
b8f886bce6f5
only allocate context input buffer if AVCodecContext.error_reslience is greater than 0.
jbr
parents:
6537
diff
changeset
|
218 if (!s->input_buffer) |
11581
998691d7f8f5
Replace all remaining occurrences of AVERROR_NOMEM with
stefano
parents:
11560
diff
changeset
|
219 return AVERROR(ENOMEM); |
6538
b8f886bce6f5
only allocate context input buffer if AVCodecContext.error_reslience is greater than 0.
jbr
parents:
6537
diff
changeset
|
220 } |
b8f886bce6f5
only allocate context input buffer if AVCodecContext.error_reslience is greater than 0.
jbr
parents:
6537
diff
changeset
|
221 |
7451
85ab7655ad4d
Modify all codecs to report their supported input and output sample format(s).
pross
parents:
7328
diff
changeset
|
222 avctx->sample_fmt = SAMPLE_FMT_S16; |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
223 return 0; |
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
224 } |
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
225 |
5386
d6347c3cb329
Use shared AC-3 header parsing. Move some initializations to block parsing function.
jbr
parents:
5385
diff
changeset
|
226 /** |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
227 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream. |
5321
fcb2a52c88fe
AC-3 decoder, soc revision 71, Sep 4 09:47:12 2006 UTC by cloud9
jbr
parents:
5320
diff
changeset
|
228 * GetBitContext within AC3DecodeContext must point to |
7470
1a93d3bbe3ee
cosmetics: make all references to AC-3 capitalized and hyphenated
jbr
parents:
7451
diff
changeset
|
229 * the start of the synchronized AC-3 bitstream. |
5321
fcb2a52c88fe
AC-3 decoder, soc revision 71, Sep 4 09:47:12 2006 UTC by cloud9
jbr
parents:
5320
diff
changeset
|
230 */ |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
231 static int ac3_parse_header(AC3DecodeContext *s) |
5303
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
232 { |
7028 | 233 GetBitContext *gbc = &s->gbc; |
234 int i; | |
235 | |
236 /* read the rest of the bsi. read twice for dual mono mode. */ | |
237 i = !(s->channel_mode); | |
238 do { | |
239 skip_bits(gbc, 5); // skip dialog normalization | |
240 if (get_bits1(gbc)) | |
241 skip_bits(gbc, 8); //skip compression | |
242 if (get_bits1(gbc)) | |
243 skip_bits(gbc, 8); //skip language code | |
244 if (get_bits1(gbc)) | |
245 skip_bits(gbc, 7); //skip audio production information | |
246 } while (i--); | |
247 | |
248 skip_bits(gbc, 2); //skip copyright bit and original bitstream bit | |
249 | |
250 /* skip the timecodes (or extra bitstream information for Alternate Syntax) | |
251 TODO: read & use the xbsi1 downmix levels */ | |
252 if (get_bits1(gbc)) | |
253 skip_bits(gbc, 14); //skip timecode1 / xbsi1 | |
254 if (get_bits1(gbc)) | |
255 skip_bits(gbc, 14); //skip timecode2 / xbsi2 | |
256 | |
257 /* skip additional bitstream info */ | |
258 if (get_bits1(gbc)) { | |
259 i = get_bits(gbc, 6); | |
260 do { | |
261 skip_bits(gbc, 8); | |
262 } while(i--); | |
263 } | |
264 | |
265 return 0; | |
266 } | |
267 | |
268 /** | |
7470
1a93d3bbe3ee
cosmetics: make all references to AC-3 capitalized and hyphenated
jbr
parents:
7451
diff
changeset
|
269 * Common function to parse AC-3 or E-AC-3 frame header |
7028 | 270 */ |
271 static int parse_frame_header(AC3DecodeContext *s) | |
272 { | |
5386
d6347c3cb329
Use shared AC-3 header parsing. Move some initializations to block parsing function.
jbr
parents:
5385
diff
changeset
|
273 AC3HeaderInfo hdr; |
7028 | 274 int err; |
5309
0662a270aab7
AC-3 decoder, soc revision 38, Aug 7 00:03:00 2006 UTC by cloud9
jbr
parents:
5308
diff
changeset
|
275 |
7489 | 276 err = ff_ac3_parse_header(&s->gbc, &hdr); |
5386
d6347c3cb329
Use shared AC-3 header parsing. Move some initializations to block parsing function.
jbr
parents:
5385
diff
changeset
|
277 if(err) |
d6347c3cb329
Use shared AC-3 header parsing. Move some initializations to block parsing function.
jbr
parents:
5385
diff
changeset
|
278 return err; |
5305
5892b4a6380b
AC-3 decoder, soc revision 31, Jul 14 23:53:28 2006 UTC by cloud9
jbr
parents:
5304
diff
changeset
|
279 |
5386
d6347c3cb329
Use shared AC-3 header parsing. Move some initializations to block parsing function.
jbr
parents:
5385
diff
changeset
|
280 /* get decoding parameters from header info */ |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
281 s->bit_alloc_params.sr_code = hdr.sr_code; |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
282 s->channel_mode = hdr.channel_mode; |
9512
ba5d9a97ab2f
Add channel layout support to the AC-3 decoder and AC-3 parser.
jbr
parents:
9454
diff
changeset
|
283 s->channel_layout = hdr.channel_layout; |
6091 | 284 s->lfe_on = hdr.lfe_on; |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
285 s->bit_alloc_params.sr_shift = hdr.sr_shift; |
6093 | 286 s->sample_rate = hdr.sample_rate; |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
287 s->bit_rate = hdr.bit_rate; |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
288 s->channels = hdr.channels; |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
289 s->fbw_channels = s->channels - s->lfe_on; |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
290 s->lfe_ch = s->fbw_channels + 1; |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
291 s->frame_size = hdr.frame_size; |
6661
a409fbf1f42b
change ff_ac3_parse_header() to take a GetBitContext instead of const char*
bwolowiec
parents:
6540
diff
changeset
|
292 s->center_mix_level = hdr.center_mix_level; |
a409fbf1f42b
change ff_ac3_parse_header() to take a GetBitContext instead of const char*
bwolowiec
parents:
6540
diff
changeset
|
293 s->surround_mix_level = hdr.surround_mix_level; |
7011
77f607fb4e8b
get the number of blocks from the ac3 parser and use in the ac3 decoder.
jbr
parents:
6999
diff
changeset
|
294 s->num_blocks = hdr.num_blocks; |
7013 | 295 s->frame_type = hdr.frame_type; |
7012 | 296 s->substreamid = hdr.substreamid; |
5412
3f6a6dda6b2d
remove broken downmixing. will add new implementation later.
jbr
parents:
5393
diff
changeset
|
297 |
6958
1c523b5212cd
set lfe params at frame init instead of in every block
jbr
parents:
6957
diff
changeset
|
298 if(s->lfe_on) { |
1c523b5212cd
set lfe params at frame init instead of in every block
jbr
parents:
6957
diff
changeset
|
299 s->start_freq[s->lfe_ch] = 0; |
1c523b5212cd
set lfe params at frame init instead of in every block
jbr
parents:
6957
diff
changeset
|
300 s->end_freq[s->lfe_ch] = 7; |
1c523b5212cd
set lfe params at frame init instead of in every block
jbr
parents:
6957
diff
changeset
|
301 s->num_exp_groups[s->lfe_ch] = 2; |
1c523b5212cd
set lfe params at frame init instead of in every block
jbr
parents:
6957
diff
changeset
|
302 s->channel_in_cpl[s->lfe_ch] = 0; |
1c523b5212cd
set lfe params at frame init instead of in every block
jbr
parents:
6957
diff
changeset
|
303 } |
1c523b5212cd
set lfe params at frame init instead of in every block
jbr
parents:
6957
diff
changeset
|
304 |
7626 | 305 if (hdr.bitstream_id <= 10) { |
306 s->eac3 = 0; | |
307 s->snr_offset_strategy = 2; | |
308 s->block_switch_syntax = 1; | |
309 s->dither_flag_syntax = 1; | |
310 s->bit_allocation_syntax = 1; | |
311 s->fast_gain_syntax = 0; | |
312 s->first_cpl_leak = 0; | |
313 s->dba_syntax = 1; | |
314 s->skip_syntax = 1; | |
315 memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht)); | |
7627 | 316 return ac3_parse_header(s); |
9983 | 317 } else if (CONFIG_EAC3_DECODER) { |
7756
2994fe74068f
turn on E-AC-3 decoding support and update the Changelog
jbr
parents:
7749
diff
changeset
|
318 s->eac3 = 1; |
2994fe74068f
turn on E-AC-3 decoding support and update the Changelog
jbr
parents:
7749
diff
changeset
|
319 return ff_eac3_parse_header(s); |
9983 | 320 } else { |
321 av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n"); | |
322 return -1; | |
7626 | 323 } |
6126
c24cd5282108
split out init of downmix coeffs into a separate function that can be called
jbr
parents:
6125
diff
changeset
|
324 } |
c24cd5282108
split out init of downmix coeffs into a separate function that can be called
jbr
parents:
6125
diff
changeset
|
325 |
c24cd5282108
split out init of downmix coeffs into a separate function that can be called
jbr
parents:
6125
diff
changeset
|
326 /** |
c24cd5282108
split out init of downmix coeffs into a separate function that can be called
jbr
parents:
6125
diff
changeset
|
327 * Set stereo downmixing coefficients based on frame header info. |
c24cd5282108
split out init of downmix coeffs into a separate function that can be called
jbr
parents:
6125
diff
changeset
|
328 * reference: Section 7.8.2 Downmixing Into Two Channels |
c24cd5282108
split out init of downmix coeffs into a separate function that can be called
jbr
parents:
6125
diff
changeset
|
329 */ |
c24cd5282108
split out init of downmix coeffs into a separate function that can be called
jbr
parents:
6125
diff
changeset
|
330 static void set_downmix_coeffs(AC3DecodeContext *s) |
c24cd5282108
split out init of downmix coeffs into a separate function that can be called
jbr
parents:
6125
diff
changeset
|
331 { |
c24cd5282108
split out init of downmix coeffs into a separate function that can be called
jbr
parents:
6125
diff
changeset
|
332 int i; |
7019
81d5c68233e5
move mix level tables from parser to decoder. have parser read bitstream value instead of using an index to a table in the decoder.
jbr
parents:
7018
diff
changeset
|
333 float cmix = gain_levels[center_levels[s->center_mix_level]]; |
81d5c68233e5
move mix level tables from parser to decoder. have parser read bitstream value instead of using an index to a table in the decoder.
jbr
parents:
7018
diff
changeset
|
334 float smix = gain_levels[surround_levels[s->surround_mix_level]]; |
7554 | 335 float norm0, norm1; |
6126
c24cd5282108
split out init of downmix coeffs into a separate function that can be called
jbr
parents:
6125
diff
changeset
|
336 |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
337 for(i=0; i<s->fbw_channels; i++) { |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
338 s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]]; |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
339 s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]]; |
5480 | 340 } |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
341 if(s->channel_mode > 1 && s->channel_mode & 1) { |
6126
c24cd5282108
split out init of downmix coeffs into a separate function that can be called
jbr
parents:
6125
diff
changeset
|
342 s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix; |
5480 | 343 } |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
344 if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) { |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
345 int nf = s->channel_mode - 2; |
6126
c24cd5282108
split out init of downmix coeffs into a separate function that can be called
jbr
parents:
6125
diff
changeset
|
346 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB; |
5480 | 347 } |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
348 if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) { |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
349 int nf = s->channel_mode - 4; |
6126
c24cd5282108
split out init of downmix coeffs into a separate function that can be called
jbr
parents:
6125
diff
changeset
|
350 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix; |
5480 | 351 } |
6431
305c49259b59
pre-calculate downmix coefficient sums. 2% faster 5.1-to-stereo downmixing.
jbr
parents:
6430
diff
changeset
|
352 |
7554 | 353 /* renormalize */ |
354 norm0 = norm1 = 0.0; | |
355 for(i=0; i<s->fbw_channels; i++) { | |
356 norm0 += s->downmix_coeffs[i][0]; | |
357 norm1 += s->downmix_coeffs[i][1]; | |
358 } | |
359 norm0 = 1.0f / norm0; | |
360 norm1 = 1.0f / norm1; | |
6431
305c49259b59
pre-calculate downmix coefficient sums. 2% faster 5.1-to-stereo downmixing.
jbr
parents:
6430
diff
changeset
|
361 for(i=0; i<s->fbw_channels; i++) { |
7554 | 362 s->downmix_coeffs[i][0] *= norm0; |
363 s->downmix_coeffs[i][1] *= norm1; | |
6431
305c49259b59
pre-calculate downmix coefficient sums. 2% faster 5.1-to-stereo downmixing.
jbr
parents:
6430
diff
changeset
|
364 } |
7554 | 365 |
366 if(s->output_mode == AC3_CHMODE_MONO) { | |
367 for(i=0; i<s->fbw_channels; i++) | |
368 s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] + s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB; | |
369 } | |
5303
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
370 } |
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
371 |
5376 | 372 /** |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
373 * Decode the grouped exponents according to exponent strategy. |
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
374 * reference: Section 7.1.3 Exponent Decoding |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
375 */ |
8268 | 376 static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps, |
8270 | 377 uint8_t absexp, int8_t *dexps) |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
378 { |
6006 | 379 int i, j, grp, group_size; |
5375 | 380 int dexp[256]; |
381 int expacc, prevexp; | |
5305
5892b4a6380b
AC-3 decoder, soc revision 31, Jul 14 23:53:28 2006 UTC by cloud9
jbr
parents:
5304
diff
changeset
|
382 |
5375 | 383 /* unpack groups */ |
6006 | 384 group_size = exp_strategy + (exp_strategy == EXP_D45); |
5375 | 385 for(grp=0,i=0; grp<ngrps; grp++) { |
6089 | 386 expacc = get_bits(gbc, 7); |
7471
1788013cf23b
use the same table for ungrouping exponents and bap=2 mantissas
jbr
parents:
7470
diff
changeset
|
387 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0]; |
1788013cf23b
use the same table for ungrouping exponents and bap=2 mantissas
jbr
parents:
7470
diff
changeset
|
388 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1]; |
1788013cf23b
use the same table for ungrouping exponents and bap=2 mantissas
jbr
parents:
7470
diff
changeset
|
389 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2]; |
5375 | 390 } |
5303
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
391 |
5375 | 392 /* convert to absolute exps and expand groups */ |
393 prevexp = absexp; | |
8271
52af55b08c1d
ac3dec: unroll inner loop in exponent decoding. 46% faster decode_exponents().
jbr
parents:
8270
diff
changeset
|
394 for(i=0,j=0; i<ngrps*3; i++) { |
8268 | 395 prevexp += dexp[i] - 2; |
8275 | 396 if (prevexp > 24U) |
8268 | 397 return -1; |
8271
52af55b08c1d
ac3dec: unroll inner loop in exponent decoding. 46% faster decode_exponents().
jbr
parents:
8270
diff
changeset
|
398 switch (group_size) { |
52af55b08c1d
ac3dec: unroll inner loop in exponent decoding. 46% faster decode_exponents().
jbr
parents:
8270
diff
changeset
|
399 case 4: dexps[j++] = prevexp; |
52af55b08c1d
ac3dec: unroll inner loop in exponent decoding. 46% faster decode_exponents().
jbr
parents:
8270
diff
changeset
|
400 dexps[j++] = prevexp; |
52af55b08c1d
ac3dec: unroll inner loop in exponent decoding. 46% faster decode_exponents().
jbr
parents:
8270
diff
changeset
|
401 case 2: dexps[j++] = prevexp; |
52af55b08c1d
ac3dec: unroll inner loop in exponent decoding. 46% faster decode_exponents().
jbr
parents:
8270
diff
changeset
|
402 case 1: dexps[j++] = prevexp; |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
403 } |
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
404 } |
8268 | 405 return 0; |
5303
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
406 } |
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
407 |
5451
19bb5e64a57c
split out coupling coefficient reconstruction into a separate function
jbr
parents:
5435
diff
changeset
|
408 /** |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
409 * Generate transform coefficients for each coupled channel in the coupling |
5451
19bb5e64a57c
split out coupling coefficient reconstruction into a separate function
jbr
parents:
5435
diff
changeset
|
410 * range using the coupling coefficients and coupling coordinates. |
19bb5e64a57c
split out coupling coefficient reconstruction into a separate function
jbr
parents:
5435
diff
changeset
|
411 * reference: Section 7.4.3 Coupling Coordinate Format |
19bb5e64a57c
split out coupling coefficient reconstruction into a separate function
jbr
parents:
5435
diff
changeset
|
412 */ |
7491
0dbdc638270e
cosmetics: use a better function name than uncouple_channels()
jbr
parents:
7490
diff
changeset
|
413 static void calc_transform_coeffs_cpl(AC3DecodeContext *s) |
5451
19bb5e64a57c
split out coupling coefficient reconstruction into a separate function
jbr
parents:
5435
diff
changeset
|
414 { |
10295 | 415 int bin, band, ch; |
5451
19bb5e64a57c
split out coupling coefficient reconstruction into a separate function
jbr
parents:
5435
diff
changeset
|
416 |
10294 | 417 bin = s->start_freq[CPL_CH]; |
418 for (band = 0; band < s->num_cpl_bands; band++) { | |
10297
12d40dab6d80
Rearrange loop structure for approx. 35-50% faster calc_transform_coeffs_cpl()
jbr
parents:
10295
diff
changeset
|
419 int band_start = bin; |
10295 | 420 int band_end = bin + s->cpl_band_sizes[band]; |
10297
12d40dab6d80
Rearrange loop structure for approx. 35-50% faster calc_transform_coeffs_cpl()
jbr
parents:
10295
diff
changeset
|
421 for (ch = 1; ch <= s->fbw_channels; ch++) { |
12d40dab6d80
Rearrange loop structure for approx. 35-50% faster calc_transform_coeffs_cpl()
jbr
parents:
10295
diff
changeset
|
422 if (s->channel_in_cpl[ch]) { |
10865
bcdc5343a577
Use MULH instead of 64x64 multiplication, around 5% overall speedup on Intel Atom.
reimar
parents:
10529
diff
changeset
|
423 int cpl_coord = s->cpl_coords[ch][band] << 5; |
10297
12d40dab6d80
Rearrange loop structure for approx. 35-50% faster calc_transform_coeffs_cpl()
jbr
parents:
10295
diff
changeset
|
424 for (bin = band_start; bin < band_end; bin++) { |
10865
bcdc5343a577
Use MULH instead of 64x64 multiplication, around 5% overall speedup on Intel Atom.
reimar
parents:
10529
diff
changeset
|
425 s->fixed_coeffs[ch][bin] = MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord); |
10297
12d40dab6d80
Rearrange loop structure for approx. 35-50% faster calc_transform_coeffs_cpl()
jbr
parents:
10295
diff
changeset
|
426 } |
12d40dab6d80
Rearrange loop structure for approx. 35-50% faster calc_transform_coeffs_cpl()
jbr
parents:
10295
diff
changeset
|
427 if (ch == 2 && s->phase_flags[band]) { |
12d40dab6d80
Rearrange loop structure for approx. 35-50% faster calc_transform_coeffs_cpl()
jbr
parents:
10295
diff
changeset
|
428 for (bin = band_start; bin < band_end; bin++) |
12d40dab6d80
Rearrange loop structure for approx. 35-50% faster calc_transform_coeffs_cpl()
jbr
parents:
10295
diff
changeset
|
429 s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin]; |
5451
19bb5e64a57c
split out coupling coefficient reconstruction into a separate function
jbr
parents:
5435
diff
changeset
|
430 } |
10024 | 431 } |
10021
f6c433eacc5a
Use coupling band sizes instead of coupling band structure when
jbr
parents:
10016
diff
changeset
|
432 } |
10297
12d40dab6d80
Rearrange loop structure for approx. 35-50% faster calc_transform_coeffs_cpl()
jbr
parents:
10295
diff
changeset
|
433 bin = band_end; |
5451
19bb5e64a57c
split out coupling coefficient reconstruction into a separate function
jbr
parents:
5435
diff
changeset
|
434 } |
19bb5e64a57c
split out coupling coefficient reconstruction into a separate function
jbr
parents:
5435
diff
changeset
|
435 } |
19bb5e64a57c
split out coupling coefficient reconstruction into a separate function
jbr
parents:
5435
diff
changeset
|
436 |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
437 /** |
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
438 * Grouped mantissas for 3-level 5-level and 11-level quantization |
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
439 */ |
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
440 typedef struct { |
9672
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
441 int b1_mant[2]; |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
442 int b2_mant[2]; |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
443 int b4_mant; |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
444 int b1; |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
445 int b2; |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
446 int b4; |
5306
abc5c130b448
AC-3 decoder, soc revision 32, Jul 17 09:37:32 2006 UTC by cloud9
jbr
parents:
5305
diff
changeset
|
447 } mant_groups; |
abc5c130b448
AC-3 decoder, soc revision 32, Jul 17 09:37:32 2006 UTC by cloud9
jbr
parents:
5305
diff
changeset
|
448 |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
449 /** |
7719 | 450 * Decode the transform coefficients for a particular channel |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
451 * reference: Section 7.3 Quantization and Decoding of Mantissas |
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
452 */ |
7702
f91e273722c8
add more OKed parts of the E-AC-3 decoder: structural changes to support AHT mode mantissa decoding
jbr
parents:
7701
diff
changeset
|
453 static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m) |
5303
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
454 { |
9672
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
455 int start_freq = s->start_freq[ch_index]; |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
456 int end_freq = s->end_freq[ch_index]; |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
457 uint8_t *baps = s->bap[ch_index]; |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
458 int8_t *exps = s->dexps[ch_index]; |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
459 int *coeffs = s->fixed_coeffs[ch_index]; |
10025
3fccd61e69d1
ac3dec: simplify zero-bit mantissa dithering by calculating it
jbr
parents:
10024
diff
changeset
|
460 int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index]; |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
461 GetBitContext *gbc = &s->gbc; |
9672
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
462 int freq; |
5303
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
463 |
9672
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
464 for(freq = start_freq; freq < end_freq; freq++){ |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
465 int bap = baps[freq]; |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
466 int mantissa; |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
467 switch(bap){ |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
468 case 0: |
10025
3fccd61e69d1
ac3dec: simplify zero-bit mantissa dithering by calculating it
jbr
parents:
10024
diff
changeset
|
469 if (dither) |
10026 | 470 mantissa = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000; |
10025
3fccd61e69d1
ac3dec: simplify zero-bit mantissa dithering by calculating it
jbr
parents:
10024
diff
changeset
|
471 else |
3fccd61e69d1
ac3dec: simplify zero-bit mantissa dithering by calculating it
jbr
parents:
10024
diff
changeset
|
472 mantissa = 0; |
5453 | 473 break; |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
474 case 1: |
9672
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
475 if(m->b1){ |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
476 m->b1--; |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
477 mantissa = m->b1_mant[m->b1]; |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
478 } |
9672
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
479 else{ |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
480 int bits = get_bits(gbc, 5); |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
481 mantissa = b1_mantissas[bits][0]; |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
482 m->b1_mant[1] = b1_mantissas[bits][1]; |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
483 m->b1_mant[0] = b1_mantissas[bits][2]; |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
484 m->b1 = 2; |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
485 } |
5453 | 486 break; |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
487 case 2: |
9672
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
488 if(m->b2){ |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
489 m->b2--; |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
490 mantissa = m->b2_mant[m->b2]; |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
491 } |
9672
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
492 else{ |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
493 int bits = get_bits(gbc, 7); |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
494 mantissa = b2_mantissas[bits][0]; |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
495 m->b2_mant[1] = b2_mantissas[bits][1]; |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
496 m->b2_mant[0] = b2_mantissas[bits][2]; |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
497 m->b2 = 2; |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
498 } |
5453 | 499 break; |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
500 case 3: |
9672
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
501 mantissa = b3_mantissas[get_bits(gbc, 3)]; |
5453 | 502 break; |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
503 case 4: |
9672
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
504 if(m->b4){ |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
505 m->b4 = 0; |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
506 mantissa = m->b4_mant; |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
507 } |
9672
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
508 else{ |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
509 int bits = get_bits(gbc, 7); |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
510 mantissa = b4_mantissas[bits][0]; |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
511 m->b4_mant = b4_mantissas[bits][1]; |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
512 m->b4 = 1; |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
513 } |
5453 | 514 break; |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
515 case 5: |
9672
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
516 mantissa = b5_mantissas[get_bits(gbc, 4)]; |
5453 | 517 break; |
9672
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
518 default: /* 6 to 15 */ |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
519 mantissa = get_bits(gbc, quantization_tab[bap]); |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
520 /* Shift mantissa and sign-extend it. */ |
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
521 mantissa = (mantissa << (32-quantization_tab[bap]))>>8; |
5453 | 522 break; |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
523 } |
9672
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
524 coeffs[freq] = mantissa >> exps[freq]; |
5303
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
525 } |
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
526 } |
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
527 |
5454
5b497d971546
dither zero-bit mantissas by default. remove dithering only if it's explicitly turned off.
jbr
parents:
5453
diff
changeset
|
528 /** |
10025
3fccd61e69d1
ac3dec: simplify zero-bit mantissa dithering by calculating it
jbr
parents:
10024
diff
changeset
|
529 * Remove random dithering from coupling range coefficients with zero-bit |
3fccd61e69d1
ac3dec: simplify zero-bit mantissa dithering by calculating it
jbr
parents:
10024
diff
changeset
|
530 * mantissas for coupled channels which do not use dithering. |
5454
5b497d971546
dither zero-bit mantissas by default. remove dithering only if it's explicitly turned off.
jbr
parents:
5453
diff
changeset
|
531 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0) |
5b497d971546
dither zero-bit mantissas by default. remove dithering only if it's explicitly turned off.
jbr
parents:
5453
diff
changeset
|
532 */ |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
533 static void remove_dithering(AC3DecodeContext *s) { |
5454
5b497d971546
dither zero-bit mantissas by default. remove dithering only if it's explicitly turned off.
jbr
parents:
5453
diff
changeset
|
534 int ch, i; |
5b497d971546
dither zero-bit mantissas by default. remove dithering only if it's explicitly turned off.
jbr
parents:
5453
diff
changeset
|
535 |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
536 for(ch=1; ch<=s->fbw_channels; ch++) { |
10025
3fccd61e69d1
ac3dec: simplify zero-bit mantissa dithering by calculating it
jbr
parents:
10024
diff
changeset
|
537 if(!s->dither_flag[ch] && s->channel_in_cpl[ch]) { |
3fccd61e69d1
ac3dec: simplify zero-bit mantissa dithering by calculating it
jbr
parents:
10024
diff
changeset
|
538 for(i = s->start_freq[CPL_CH]; i<s->end_freq[CPL_CH]; i++) { |
3fccd61e69d1
ac3dec: simplify zero-bit mantissa dithering by calculating it
jbr
parents:
10024
diff
changeset
|
539 if(!s->bap[CPL_CH][i]) |
3fccd61e69d1
ac3dec: simplify zero-bit mantissa dithering by calculating it
jbr
parents:
10024
diff
changeset
|
540 s->fixed_coeffs[ch][i] = 0; |
5454
5b497d971546
dither zero-bit mantissas by default. remove dithering only if it's explicitly turned off.
jbr
parents:
5453
diff
changeset
|
541 } |
5b497d971546
dither zero-bit mantissas by default. remove dithering only if it's explicitly turned off.
jbr
parents:
5453
diff
changeset
|
542 } |
5b497d971546
dither zero-bit mantissas by default. remove dithering only if it's explicitly turned off.
jbr
parents:
5453
diff
changeset
|
543 } |
5b497d971546
dither zero-bit mantissas by default. remove dithering only if it's explicitly turned off.
jbr
parents:
5453
diff
changeset
|
544 } |
5b497d971546
dither zero-bit mantissas by default. remove dithering only if it's explicitly turned off.
jbr
parents:
5453
diff
changeset
|
545 |
7701
20b27ee9b40f
cosmetics: rename some functions from *get_* to *decode_*
jbr
parents:
7667
diff
changeset
|
546 static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch, |
7626 | 547 mant_groups *m) |
548 { | |
549 if (!s->channel_uses_aht[ch]) { | |
7701
20b27ee9b40f
cosmetics: rename some functions from *get_* to *decode_*
jbr
parents:
7667
diff
changeset
|
550 ac3_decode_transform_coeffs_ch(s, ch, m); |
7626 | 551 } else { |
552 /* if AHT is used, mantissas for all blocks are encoded in the first | |
553 block of the frame. */ | |
554 int bin; | |
9983 | 555 if (!blk && CONFIG_EAC3_DECODER) |
7701
20b27ee9b40f
cosmetics: rename some functions from *get_* to *decode_*
jbr
parents:
7667
diff
changeset
|
556 ff_eac3_decode_transform_coeffs_aht_ch(s, ch); |
7626 | 557 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) { |
9680
debe2623a70a
eac3dec: revert commit r18860. keep the AHT IDCT 24-bit. will make AHT GAQ
jbr
parents:
9673
diff
changeset
|
558 s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin]; |
7626 | 559 } |
560 } | |
561 } | |
562 | |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
563 /** |
7718 | 564 * Decode the transform coefficients. |
5321
fcb2a52c88fe
AC-3 decoder, soc revision 71, Sep 4 09:47:12 2006 UTC by cloud9
jbr
parents:
5320
diff
changeset
|
565 */ |
7702
f91e273722c8
add more OKed parts of the E-AC-3 decoder: structural changes to support AHT mode mantissa decoding
jbr
parents:
7701
diff
changeset
|
566 static void decode_transform_coeffs(AC3DecodeContext *s, int blk) |
5303
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
567 { |
5476
e50f0d583a36
consolidate decoding of lfe and coupling channels with decoding of full-bandwidth channels.
jbr
parents:
5475
diff
changeset
|
568 int ch, end; |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
569 int got_cplchan = 0; |
5306
abc5c130b448
AC-3 decoder, soc revision 32, Jul 17 09:37:32 2006 UTC by cloud9
jbr
parents:
5305
diff
changeset
|
570 mant_groups m; |
abc5c130b448
AC-3 decoder, soc revision 32, Jul 17 09:37:32 2006 UTC by cloud9
jbr
parents:
5305
diff
changeset
|
571 |
9672
15276eb66180
LGPL version of ac3_decode_transform_coeffs_ch, ~12.4% faster.
darkshikari
parents:
9661
diff
changeset
|
572 m.b1 = m.b2 = m.b4 = 0; |
5303
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
573 |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
574 for (ch = 1; ch <= s->channels; ch++) { |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
575 /* transform coefficients for full-bandwidth channel */ |
7702
f91e273722c8
add more OKed parts of the E-AC-3 decoder: structural changes to support AHT mode mantissa decoding
jbr
parents:
7701
diff
changeset
|
576 decode_transform_coeffs_ch(s, blk, ch, &m); |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
577 /* tranform coefficients for coupling channel come right after the |
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
578 coefficients for the first coupled channel*/ |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
579 if (s->channel_in_cpl[ch]) { |
5306
abc5c130b448
AC-3 decoder, soc revision 32, Jul 17 09:37:32 2006 UTC by cloud9
jbr
parents:
5305
diff
changeset
|
580 if (!got_cplchan) { |
7702
f91e273722c8
add more OKed parts of the E-AC-3 decoder: structural changes to support AHT mode mantissa decoding
jbr
parents:
7701
diff
changeset
|
581 decode_transform_coeffs_ch(s, blk, CPL_CH, &m); |
7491
0dbdc638270e
cosmetics: use a better function name than uncouple_channels()
jbr
parents:
7490
diff
changeset
|
582 calc_transform_coeffs_cpl(s); |
5306
abc5c130b448
AC-3 decoder, soc revision 32, Jul 17 09:37:32 2006 UTC by cloud9
jbr
parents:
5305
diff
changeset
|
583 got_cplchan = 1; |
abc5c130b448
AC-3 decoder, soc revision 32, Jul 17 09:37:32 2006 UTC by cloud9
jbr
parents:
5305
diff
changeset
|
584 } |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
585 end = s->end_freq[CPL_CH]; |
5461
c427d8950769
cosmetics: use braces when it makes the code easier to read.
jbr
parents:
5460
diff
changeset
|
586 } else { |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
587 end = s->end_freq[ch]; |
5461
c427d8950769
cosmetics: use braces when it makes the code easier to read.
jbr
parents:
5460
diff
changeset
|
588 } |
5306
abc5c130b448
AC-3 decoder, soc revision 32, Jul 17 09:37:32 2006 UTC by cloud9
jbr
parents:
5305
diff
changeset
|
589 do |
6906
86e3dce7f723
zero the upper frequencies of the correct coefficients
jbr
parents:
6889
diff
changeset
|
590 s->fixed_coeffs[ch][end] = 0; |
5306
abc5c130b448
AC-3 decoder, soc revision 32, Jul 17 09:37:32 2006 UTC by cloud9
jbr
parents:
5305
diff
changeset
|
591 while(++end < 256); |
abc5c130b448
AC-3 decoder, soc revision 32, Jul 17 09:37:32 2006 UTC by cloud9
jbr
parents:
5305
diff
changeset
|
592 } |
5303
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
593 |
7740 | 594 /* zero the dithered coefficients for appropriate channels */ |
7717 | 595 remove_dithering(s); |
5303
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
596 } |
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
597 |
5415 | 598 /** |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
599 * Stereo rematrixing. |
5415 | 600 * reference: Section 7.5.4 Rematrixing : Decoding Technique |
601 */ | |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
602 static void do_rematrixing(AC3DecodeContext *s) |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
603 { |
5415 | 604 int bnd, i; |
5310
9aa9197034d7
AC-3 decoder, soc revision 40, Aug 9 00:10:14 2006 UTC by cloud9
jbr
parents:
5309
diff
changeset
|
605 int end, bndend; |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
606 |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
607 end = FFMIN(s->end_freq[1], s->end_freq[2]); |
5310
9aa9197034d7
AC-3 decoder, soc revision 40, Aug 9 00:10:14 2006 UTC by cloud9
jbr
parents:
5309
diff
changeset
|
608 |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
609 for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) { |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
610 if(s->rematrixing_flags[bnd]) { |
7033 | 611 bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd+1]); |
10498
9bf0edb1aeb1
ac3dec: revert r20089. The change was just wrong. 10l for me.
jbr
parents:
10333
diff
changeset
|
612 for(i=ff_ac3_rematrix_band_tab[bnd]; i<bndend; i++) { |
10323
1f5c4d2ce77f
Simplify stereo rematrixing by only using one temporary variable. It is also
jbr
parents:
10322
diff
changeset
|
613 int tmp0 = s->fixed_coeffs[1][i]; |
10331 | 614 s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i]; |
10323
1f5c4d2ce77f
Simplify stereo rematrixing by only using one temporary variable. It is also
jbr
parents:
10322
diff
changeset
|
615 s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i]; |
5415 | 616 } |
617 } | |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
618 } |
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
619 } |
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
620 |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
621 /** |
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
622 * Inverse MDCT Transform. |
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
623 * Convert frequency domain coefficients to time-domain audio samples. |
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
624 * reference: Section 7.9.4 Transformation Equations |
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
625 */ |
6480
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
626 static inline void do_imdct(AC3DecodeContext *s, int channels) |
5306
abc5c130b448
AC-3 decoder, soc revision 32, Jul 17 09:37:32 2006 UTC by cloud9
jbr
parents:
5305
diff
changeset
|
627 { |
5336 | 628 int ch; |
7561
be6d31643128
oops, non-normalized downmix to mono contaminated add_bias for non-simd float-to-int.
lorenm
parents:
7554
diff
changeset
|
629 float add_bias = s->add_bias; |
be6d31643128
oops, non-normalized downmix to mono contaminated add_bias for non-simd float-to-int.
lorenm
parents:
7554
diff
changeset
|
630 if(s->out_channels==1 && channels>1) |
be6d31643128
oops, non-normalized downmix to mono contaminated add_bias for non-simd float-to-int.
lorenm
parents:
7554
diff
changeset
|
631 add_bias *= LEVEL_MINUS_3DB; // compensate for the gain in downmix |
5476
e50f0d583a36
consolidate decoding of lfe and coupling channels with decoding of full-bandwidth channels.
jbr
parents:
5475
diff
changeset
|
632 |
6006 | 633 for (ch=1; ch<=channels; ch++) { |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
634 if (s->block_switch[ch]) { |
7549 | 635 int i; |
636 float *x = s->tmp_output+128; | |
637 for(i=0; i<128; i++) | |
638 x[i] = s->transform_coeffs[ch][2*i]; | |
639 ff_imdct_half(&s->imdct_256, s->tmp_output, x); | |
7561
be6d31643128
oops, non-normalized downmix to mono contaminated add_bias for non-simd float-to-int.
lorenm
parents:
7554
diff
changeset
|
640 s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, add_bias, 128); |
7549 | 641 for(i=0; i<128; i++) |
642 x[i] = s->transform_coeffs[ch][2*i+1]; | |
643 ff_imdct_half(&s->imdct_256, s->delay[ch-1], x); | |
5461
c427d8950769
cosmetics: use braces when it makes the code easier to read.
jbr
parents:
5460
diff
changeset
|
644 } else { |
7549 | 645 ff_imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]); |
7561
be6d31643128
oops, non-normalized downmix to mono contaminated add_bias for non-simd float-to-int.
lorenm
parents:
7554
diff
changeset
|
646 s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, add_bias, 128); |
7549 | 647 memcpy(s->delay[ch-1], s->tmp_output+128, 128*sizeof(float)); |
5461
c427d8950769
cosmetics: use braces when it makes the code easier to read.
jbr
parents:
5460
diff
changeset
|
648 } |
5306
abc5c130b448
AC-3 decoder, soc revision 32, Jul 17 09:37:32 2006 UTC by cloud9
jbr
parents:
5305
diff
changeset
|
649 } |
abc5c130b448
AC-3 decoder, soc revision 32, Jul 17 09:37:32 2006 UTC by cloud9
jbr
parents:
5305
diff
changeset
|
650 } |
abc5c130b448
AC-3 decoder, soc revision 32, Jul 17 09:37:32 2006 UTC by cloud9
jbr
parents:
5305
diff
changeset
|
651 |
5480 | 652 /** |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
653 * Downmix the output to mono or stereo. |
5480 | 654 */ |
7563 | 655 void ff_ac3_downmix_c(float (*samples)[256], float (*matrix)[2], int out_ch, int in_ch, int len) |
5480 | 656 { |
657 int i, j; | |
6431
305c49259b59
pre-calculate downmix coefficient sums. 2% faster 5.1-to-stereo downmixing.
jbr
parents:
6430
diff
changeset
|
658 float v0, v1; |
7563 | 659 if(out_ch == 2) { |
660 for(i=0; i<len; i++) { | |
7554 | 661 v0 = v1 = 0.0f; |
7563 | 662 for(j=0; j<in_ch; j++) { |
663 v0 += samples[j][i] * matrix[j][0]; | |
664 v1 += samples[j][i] * matrix[j][1]; | |
7554 | 665 } |
666 samples[0][i] = v0; | |
667 samples[1][i] = v1; | |
5480 | 668 } |
7563 | 669 } else if(out_ch == 1) { |
670 for(i=0; i<len; i++) { | |
7554 | 671 v0 = 0.0f; |
7563 | 672 for(j=0; j<in_ch; j++) |
673 v0 += samples[j][i] * matrix[j][0]; | |
7554 | 674 samples[0][i] = v0; |
5480 | 675 } |
676 } | |
677 } | |
678 | |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
679 /** |
6480
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
680 * Upmix delay samples from stereo to original channel layout. |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
681 */ |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
682 static void ac3_upmix_delay(AC3DecodeContext *s) |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
683 { |
7625
da9353cd6d71
get data size based on the actual data array instead of coding-in the calculation
jbr
parents:
7624
diff
changeset
|
684 int channel_data_size = sizeof(s->delay[0]); |
6480
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
685 switch(s->channel_mode) { |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
686 case AC3_CHMODE_DUALMONO: |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
687 case AC3_CHMODE_STEREO: |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
688 /* upmix mono to stereo */ |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
689 memcpy(s->delay[1], s->delay[0], channel_data_size); |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
690 break; |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
691 case AC3_CHMODE_2F2R: |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
692 memset(s->delay[3], 0, channel_data_size); |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
693 case AC3_CHMODE_2F1R: |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
694 memset(s->delay[2], 0, channel_data_size); |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
695 break; |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
696 case AC3_CHMODE_3F2R: |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
697 memset(s->delay[4], 0, channel_data_size); |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
698 case AC3_CHMODE_3F1R: |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
699 memset(s->delay[3], 0, channel_data_size); |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
700 case AC3_CHMODE_3F: |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
701 memcpy(s->delay[2], s->delay[1], channel_data_size); |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
702 memset(s->delay[1], 0, channel_data_size); |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
703 break; |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
704 } |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
705 } |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
706 |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
707 /** |
8135
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
708 * Decode band structure for coupling, spectral extension, or enhanced coupling. |
10016
0649c00003a1
cosmetics: add more detailed information to the documentation for
jbr
parents:
9983
diff
changeset
|
709 * The band structure defines how many subbands are in each band. For each |
0649c00003a1
cosmetics: add more detailed information to the documentation for
jbr
parents:
9983
diff
changeset
|
710 * subband in the range, 1 means it is combined with the previous band, and 0 |
0649c00003a1
cosmetics: add more detailed information to the documentation for
jbr
parents:
9983
diff
changeset
|
711 * means that it starts a new band. |
0649c00003a1
cosmetics: add more detailed information to the documentation for
jbr
parents:
9983
diff
changeset
|
712 * |
8135
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
713 * @param[in] gbc bit reader context |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
714 * @param[in] blk block number |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
715 * @param[in] eac3 flag to indicate E-AC-3 |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
716 * @param[in] ecpl flag to indicate enhanced coupling |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
717 * @param[in] start_subband subband number for start of range |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
718 * @param[in] end_subband subband number for end of range |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
719 * @param[in] default_band_struct default band structure table |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
720 * @param[out] num_bands number of bands (optionally NULL) |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
721 * @param[out] band_sizes array containing the number of bins in each band (optionally NULL) |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
722 */ |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
723 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3, |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
724 int ecpl, int start_subband, int end_subband, |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
725 const uint8_t *default_band_struct, |
10023 | 726 int *num_bands, uint8_t *band_sizes) |
8135
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
727 { |
8255
1c4ec499557e
silence gcc warning: ¡Æn_bands¡Ç may be used uninitialized
jbr
parents:
8254
diff
changeset
|
728 int subbnd, bnd, n_subbands, n_bands=0; |
8254 | 729 uint8_t bnd_sz[22]; |
10022
e60ed9255bf4
Modify decode_band_structure() so that the actual band structure is only
jbr
parents:
10021
diff
changeset
|
730 uint8_t coded_band_struct[22]; |
e60ed9255bf4
Modify decode_band_structure() so that the actual band structure is only
jbr
parents:
10021
diff
changeset
|
731 const uint8_t *band_struct; |
8135
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
732 |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
733 n_subbands = end_subband - start_subband; |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
734 |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
735 /* decode band structure from bitstream or use default */ |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
736 if (!eac3 || get_bits1(gbc)) { |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
737 for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) { |
10022
e60ed9255bf4
Modify decode_band_structure() so that the actual band structure is only
jbr
parents:
10021
diff
changeset
|
738 coded_band_struct[subbnd] = get_bits1(gbc); |
8135
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
739 } |
10022
e60ed9255bf4
Modify decode_band_structure() so that the actual band structure is only
jbr
parents:
10021
diff
changeset
|
740 band_struct = coded_band_struct; |
8135
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
741 } else if (!blk) { |
10022
e60ed9255bf4
Modify decode_band_structure() so that the actual band structure is only
jbr
parents:
10021
diff
changeset
|
742 band_struct = &default_band_struct[start_subband+1]; |
e60ed9255bf4
Modify decode_band_structure() so that the actual band structure is only
jbr
parents:
10021
diff
changeset
|
743 } else { |
e60ed9255bf4
Modify decode_band_structure() so that the actual band structure is only
jbr
parents:
10021
diff
changeset
|
744 /* no change in band structure */ |
e60ed9255bf4
Modify decode_band_structure() so that the actual band structure is only
jbr
parents:
10021
diff
changeset
|
745 return; |
8135
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
746 } |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
747 |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
748 /* calculate number of bands and band sizes based on band structure. |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
749 note that the first 4 subbands in enhanced coupling span only 6 bins |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
750 instead of 12. */ |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
751 if (num_bands || band_sizes ) { |
8142
f17b1eb9ccd1
revert r15812 (E-AC-3 Spectral Extension) pending further review
jbr
parents:
8139
diff
changeset
|
752 n_bands = n_subbands; |
8135
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
753 bnd_sz[0] = ecpl ? 6 : 12; |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
754 for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) { |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
755 int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12; |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
756 if (band_struct[subbnd-1]) { |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
757 n_bands--; |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
758 bnd_sz[bnd] += subbnd_size; |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
759 } else { |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
760 bnd_sz[++bnd] = subbnd_size; |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
761 } |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
762 } |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
763 } |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
764 |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
765 /* set optional output params */ |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
766 if (num_bands) |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
767 *num_bands = n_bands; |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
768 if (band_sizes) |
8254 | 769 memcpy(band_sizes, bnd_sz, n_bands); |
8135
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
770 } |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
771 |
c82f8f5657ff
add a generic function to decode banding structure for coupling, spectral
jbr
parents:
8134
diff
changeset
|
772 /** |
7490
bddd15a1d167
cosmetics: change function name and comments to refer to block decoding
jbr
parents:
7489
diff
changeset
|
773 * Decode a single audio block from the AC-3 bitstream. |
5321
fcb2a52c88fe
AC-3 decoder, soc revision 71, Sep 4 09:47:12 2006 UTC by cloud9
jbr
parents:
5320
diff
changeset
|
774 */ |
7490
bddd15a1d167
cosmetics: change function name and comments to refer to block decoding
jbr
parents:
7489
diff
changeset
|
775 static int decode_audio_block(AC3DecodeContext *s, int blk) |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
776 { |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
777 int fbw_channels = s->fbw_channels; |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
778 int channel_mode = s->channel_mode; |
5471
37c1944ca4ee
make exponent decoding consistent (prepare for merging coupling and lfe code with normal channel code).
jbr
parents:
5461
diff
changeset
|
779 int i, bnd, seg, ch; |
6480
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
780 int different_transforms; |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
781 int downmix_output; |
7026 | 782 int cpl_in_use; |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
783 GetBitContext *gbc = &s->gbc; |
5476
e50f0d583a36
consolidate decoding of lfe and coupling channels with decoding of full-bandwidth channels.
jbr
parents:
5475
diff
changeset
|
784 uint8_t bit_alloc_stages[AC3_MAX_CHANNELS]; |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
785 |
5476
e50f0d583a36
consolidate decoding of lfe and coupling channels with decoding of full-bandwidth channels.
jbr
parents:
5475
diff
changeset
|
786 memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS); |
e50f0d583a36
consolidate decoding of lfe and coupling channels with decoding of full-bandwidth channels.
jbr
parents:
5475
diff
changeset
|
787 |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
788 /* block switch flags */ |
6480
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
789 different_transforms = 0; |
7626 | 790 if (s->block_switch_syntax) { |
7627 | 791 for (ch = 1; ch <= fbw_channels; ch++) { |
792 s->block_switch[ch] = get_bits1(gbc); | |
793 if(ch > 1 && s->block_switch[ch] != s->block_switch[1]) | |
794 different_transforms = 1; | |
795 } | |
7626 | 796 } |
5309
0662a270aab7
AC-3 decoder, soc revision 38, Aug 7 00:03:00 2006 UTC by cloud9
jbr
parents:
5308
diff
changeset
|
797 |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
798 /* dithering flags */ |
7626 | 799 if (s->dither_flag_syntax) { |
7627 | 800 for (ch = 1; ch <= fbw_channels; ch++) { |
801 s->dither_flag[ch] = get_bits1(gbc); | |
802 } | |
7626 | 803 } |
5309
0662a270aab7
AC-3 decoder, soc revision 38, Aug 7 00:03:00 2006 UTC by cloud9
jbr
parents:
5308
diff
changeset
|
804 |
5497 | 805 /* dynamic range */ |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
806 i = !(s->channel_mode); |
5497 | 807 do { |
6089 | 808 if(get_bits1(gbc)) { |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
809 s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) * |
6091 | 810 s->avctx->drc_scale)+1.0; |
5386
d6347c3cb329
Use shared AC-3 header parsing. Move some initializations to block parsing function.
jbr
parents:
5385
diff
changeset
|
811 } else if(blk == 0) { |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
812 s->dynamic_range[i] = 1.0f; |
5386
d6347c3cb329
Use shared AC-3 header parsing. Move some initializations to block parsing function.
jbr
parents:
5385
diff
changeset
|
813 } |
5497 | 814 } while(i--); |
5309
0662a270aab7
AC-3 decoder, soc revision 38, Aug 7 00:03:00 2006 UTC by cloud9
jbr
parents:
5308
diff
changeset
|
815 |
7664 | 816 /* spectral extension strategy */ |
817 if (s->eac3 && (!blk || get_bits1(gbc))) { | |
11559 | 818 s->spx_in_use = get_bits1(gbc); |
819 if (s->spx_in_use) { | |
820 int dst_start_freq, dst_end_freq, src_start_freq, | |
821 start_subband, end_subband; | |
822 | |
823 /* determine which channels use spx */ | |
824 if (s->channel_mode == AC3_CHMODE_MONO) { | |
825 s->channel_uses_spx[1] = 1; | |
826 } else { | |
827 for (ch = 1; ch <= fbw_channels; ch++) | |
828 s->channel_uses_spx[ch] = get_bits1(gbc); | |
829 } | |
830 | |
831 /* get the frequency bins of the spx copy region and the spx start | |
832 and end subbands */ | |
833 dst_start_freq = get_bits(gbc, 2); | |
834 start_subband = get_bits(gbc, 3) + 2; | |
835 if (start_subband > 7) | |
836 start_subband += start_subband - 7; | |
837 end_subband = get_bits(gbc, 3) + 5; | |
838 if (end_subband > 7) | |
839 end_subband += end_subband - 7; | |
840 dst_start_freq = dst_start_freq * 12 + 25; | |
841 src_start_freq = start_subband * 12 + 25; | |
842 dst_end_freq = end_subband * 12 + 25; | |
843 | |
844 /* check validity of spx ranges */ | |
845 if (start_subband >= end_subband) { | |
846 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension " | |
847 "range (%d >= %d)\n", start_subband, end_subband); | |
848 return -1; | |
849 } | |
850 if (dst_start_freq >= src_start_freq) { | |
851 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension " | |
852 "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq); | |
853 return -1; | |
854 } | |
855 | |
856 s->spx_dst_start_freq = dst_start_freq; | |
857 s->spx_src_start_freq = src_start_freq; | |
858 s->spx_dst_end_freq = dst_end_freq; | |
859 | |
860 decode_band_structure(gbc, blk, s->eac3, 0, | |
861 start_subband, end_subband, | |
862 ff_eac3_default_spx_band_struct, | |
863 &s->num_spx_bands, | |
864 s->spx_band_sizes); | |
865 } else { | |
866 for (ch = 1; ch <= fbw_channels; ch++) { | |
867 s->channel_uses_spx[ch] = 0; | |
868 s->first_spx_coords[ch] = 1; | |
869 } | |
7664 | 870 } |
871 } | |
872 | |
11559 | 873 /* spectral extension coordinates */ |
874 if (s->spx_in_use) { | |
875 for (ch = 1; ch <= fbw_channels; ch++) { | |
876 if (s->channel_uses_spx[ch]) { | |
877 if (s->first_spx_coords[ch] || get_bits1(gbc)) { | |
878 float spx_blend; | |
879 int bin, master_spx_coord; | |
880 | |
881 s->first_spx_coords[ch] = 0; | |
882 spx_blend = get_bits(gbc, 5) * (1.0f/32); | |
883 master_spx_coord = get_bits(gbc, 2) * 3; | |
884 | |
885 bin = s->spx_src_start_freq; | |
886 for (bnd = 0; bnd < s->num_spx_bands; bnd++) { | |
887 int bandsize; | |
888 int spx_coord_exp, spx_coord_mant; | |
889 float nratio, sblend, nblend, spx_coord; | |
890 | |
891 /* calculate blending factors */ | |
892 bandsize = s->spx_band_sizes[bnd]; | |
893 nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend; | |
894 nratio = av_clipf(nratio, 0.0f, 1.0f); | |
895 nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3) to give unity variance | |
896 sblend = sqrtf(1.0f - nratio); | |
897 bin += bandsize; | |
898 | |
899 /* decode spx coordinates */ | |
900 spx_coord_exp = get_bits(gbc, 4); | |
901 spx_coord_mant = get_bits(gbc, 2); | |
902 if (spx_coord_exp == 15) spx_coord_mant <<= 1; | |
903 else spx_coord_mant += 4; | |
904 spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord); | |
905 spx_coord = spx_coord_mant * (1.0f/(1<<23)); | |
906 | |
907 /* multiply noise and signal blending factors by spx coordinate */ | |
908 s->spx_noise_blend [ch][bnd] = nblend * spx_coord; | |
909 s->spx_signal_blend[ch][bnd] = sblend * spx_coord; | |
910 } | |
911 } | |
912 } else { | |
913 s->first_spx_coords[ch] = 1; | |
914 } | |
915 } | |
916 } | |
7664 | 917 |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
918 /* coupling strategy */ |
7746 | 919 if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) { |
5476
e50f0d583a36
consolidate decoding of lfe and coupling channels with decoding of full-bandwidth channels.
jbr
parents:
5475
diff
changeset
|
920 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS); |
7664 | 921 if (!s->eac3) |
7665 | 922 s->cpl_in_use[blk] = get_bits1(gbc); |
7328
9309e19c2b98
read 'coupling in use' parameter from bitstream into decoder context first,
jbr
parents:
7311
diff
changeset
|
923 if (s->cpl_in_use[blk]) { |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
924 /* coupling in use */ |
8132 | 925 int cpl_start_subband, cpl_end_subband; |
5414 | 926 |
6868
5387096bf92a
add check for invalid channel mode when coupling is used
jbr
parents:
6763
diff
changeset
|
927 if (channel_mode < AC3_CHMODE_STEREO) { |
5387096bf92a
add check for invalid channel mode when coupling is used
jbr
parents:
6763
diff
changeset
|
928 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n"); |
5387096bf92a
add check for invalid channel mode when coupling is used
jbr
parents:
6763
diff
changeset
|
929 return -1; |
5387096bf92a
add check for invalid channel mode when coupling is used
jbr
parents:
6763
diff
changeset
|
930 } |
5387096bf92a
add check for invalid channel mode when coupling is used
jbr
parents:
6763
diff
changeset
|
931 |
7664 | 932 /* check for enhanced coupling */ |
933 if (s->eac3 && get_bits1(gbc)) { | |
934 /* TODO: parse enhanced coupling strategy info */ | |
9891
7ad7d4094d1f
Rename ff_log_missing_feature() to av_log_missing_feature().
rbultje
parents:
9680
diff
changeset
|
935 av_log_missing_feature(s->avctx, "Enhanced coupling", 1); |
7664 | 936 return -1; |
937 } | |
938 | |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
939 /* determine which channels are coupled */ |
7664 | 940 if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) { |
941 s->channel_in_cpl[1] = 1; | |
942 s->channel_in_cpl[2] = 1; | |
943 } else { | |
7665 | 944 for (ch = 1; ch <= fbw_channels; ch++) |
945 s->channel_in_cpl[ch] = get_bits1(gbc); | |
7664 | 946 } |
5309
0662a270aab7
AC-3 decoder, soc revision 38, Aug 7 00:03:00 2006 UTC by cloud9
jbr
parents:
5308
diff
changeset
|
947 |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
948 /* phase flags in use */ |
6005 | 949 if (channel_mode == AC3_CHMODE_STEREO) |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
950 s->phase_flags_in_use = get_bits1(gbc); |
5309
0662a270aab7
AC-3 decoder, soc revision 38, Aug 7 00:03:00 2006 UTC by cloud9
jbr
parents:
5308
diff
changeset
|
951 |
7664 | 952 /* coupling frequency range */ |
8132 | 953 cpl_start_subband = get_bits(gbc, 4); |
11559 | 954 cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 : |
955 get_bits(gbc, 4) + 3; | |
9659
b4350a6fb24a
ac3dec: fix coupling range check. the start subband must be less than
jbr
parents:
9658
diff
changeset
|
956 if (cpl_start_subband >= cpl_end_subband) { |
b4350a6fb24a
ac3dec: fix coupling range check. the start subband must be less than
jbr
parents:
9658
diff
changeset
|
957 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n", |
8133 | 958 cpl_start_subband, cpl_end_subband); |
5309
0662a270aab7
AC-3 decoder, soc revision 38, Aug 7 00:03:00 2006 UTC by cloud9
jbr
parents:
5308
diff
changeset
|
959 return -1; |
0662a270aab7
AC-3 decoder, soc revision 38, Aug 7 00:03:00 2006 UTC by cloud9
jbr
parents:
5308
diff
changeset
|
960 } |
8132 | 961 s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37; |
8133 | 962 s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37; |
7664 | 963 |
9608 | 964 decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband, |
965 cpl_end_subband, | |
966 ff_eac3_default_cpl_band_struct, | |
10023 | 967 &s->num_cpl_bands, s->cpl_band_sizes); |
5388 | 968 } else { |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
969 /* coupling not in use */ |
7664 | 970 for (ch = 1; ch <= fbw_channels; ch++) { |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
971 s->channel_in_cpl[ch] = 0; |
7664 | 972 s->first_cpl_coords[ch] = 1; |
973 } | |
7667 | 974 s->first_cpl_leak = s->eac3; |
7664 | 975 s->phase_flags_in_use = 0; |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
976 } |
7664 | 977 } else if (!s->eac3) { |
978 if(!blk) { | |
7665 | 979 av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must be present in block 0\n"); |
980 return -1; | |
981 } else { | |
982 s->cpl_in_use[blk] = s->cpl_in_use[blk-1]; | |
983 } | |
7664 | 984 } |
7328
9309e19c2b98
read 'coupling in use' parameter from bitstream into decoder context first,
jbr
parents:
7311
diff
changeset
|
985 cpl_in_use = s->cpl_in_use[blk]; |
5309
0662a270aab7
AC-3 decoder, soc revision 38, Aug 7 00:03:00 2006 UTC by cloud9
jbr
parents:
5308
diff
changeset
|
986 |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
987 /* coupling coordinates */ |
7026 | 988 if (cpl_in_use) { |
6006 | 989 int cpl_coords_exist = 0; |
5309
0662a270aab7
AC-3 decoder, soc revision 38, Aug 7 00:03:00 2006 UTC by cloud9
jbr
parents:
5308
diff
changeset
|
990 |
6006 | 991 for (ch = 1; ch <= fbw_channels; ch++) { |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
992 if (s->channel_in_cpl[ch]) { |
7746 | 993 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) { |
6006 | 994 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant; |
7746 | 995 s->first_cpl_coords[ch] = 0; |
6006 | 996 cpl_coords_exist = 1; |
6089 | 997 master_cpl_coord = 3 * get_bits(gbc, 2); |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
998 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) { |
6089 | 999 cpl_coord_exp = get_bits(gbc, 4); |
1000 cpl_coord_mant = get_bits(gbc, 4); | |
6006 | 1001 if (cpl_coord_exp == 15) |
6430
de7502093922
Use 24-bit fixed-point transform coefficients until just before MDCT. This
jbr
parents:
6142
diff
changeset
|
1002 s->cpl_coords[ch][bnd] = cpl_coord_mant << 22; |
5306
abc5c130b448
AC-3 decoder, soc revision 32, Jul 17 09:37:32 2006 UTC by cloud9
jbr
parents:
5305
diff
changeset
|
1003 else |
6430
de7502093922
Use 24-bit fixed-point transform coefficients until just before MDCT. This
jbr
parents:
6142
diff
changeset
|
1004 s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21; |
de7502093922
Use 24-bit fixed-point transform coefficients until just before MDCT. This
jbr
parents:
6142
diff
changeset
|
1005 s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord); |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
1006 } |
6869 | 1007 } else if (!blk) { |
1008 av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must be present in block 0\n"); | |
1009 return -1; | |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
1010 } |
7746 | 1011 } else { |
1012 /* channel not in coupling */ | |
1013 s->first_cpl_coords[ch] = 1; | |
5461
c427d8950769
cosmetics: use braces when it makes the code easier to read.
jbr
parents:
5460
diff
changeset
|
1014 } |
c427d8950769
cosmetics: use braces when it makes the code easier to read.
jbr
parents:
5460
diff
changeset
|
1015 } |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
1016 /* phase flags */ |
6123
8d88831a2777
fix phase flag processing for the case when coupling coordinates are reused
jbr
parents:
6117
diff
changeset
|
1017 if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) { |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1018 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) { |
6123
8d88831a2777
fix phase flag processing for the case when coupling coordinates are reused
jbr
parents:
6117
diff
changeset
|
1019 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0; |
5461
c427d8950769
cosmetics: use braces when it makes the code easier to read.
jbr
parents:
5460
diff
changeset
|
1020 } |
c427d8950769
cosmetics: use braces when it makes the code easier to read.
jbr
parents:
5460
diff
changeset
|
1021 } |
5309
0662a270aab7
AC-3 decoder, soc revision 38, Aug 7 00:03:00 2006 UTC by cloud9
jbr
parents:
5308
diff
changeset
|
1022 } |
0662a270aab7
AC-3 decoder, soc revision 38, Aug 7 00:03:00 2006 UTC by cloud9
jbr
parents:
5308
diff
changeset
|
1023 |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
1024 /* stereo rematrixing strategy and band structure */ |
6005 | 1025 if (channel_mode == AC3_CHMODE_STEREO) { |
7664 | 1026 if ((s->eac3 && !blk) || get_bits1(gbc)) { |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1027 s->num_rematrixing_bands = 4; |
11559 | 1028 if (cpl_in_use && s->start_freq[CPL_CH] <= 61) { |
8142
f17b1eb9ccd1
revert r15812 (E-AC-3 Spectral Extension) pending further review
jbr
parents:
8139
diff
changeset
|
1029 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37); |
11559 | 1030 } else if (s->spx_in_use && s->spx_src_start_freq <= 61) { |
1031 s->num_rematrixing_bands--; | |
1032 } | |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1033 for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1034 s->rematrixing_flags[bnd] = get_bits1(gbc); |
6869 | 1035 } else if (!blk) { |
10333
c1c4435539e6
Change an error to a warning to support broken AC-3 files known to exist.
jbr
parents:
10331
diff
changeset
|
1036 av_log(s->avctx, AV_LOG_WARNING, "Warning: new rematrixing strategy not present in block 0\n"); |
c1c4435539e6
Change an error to a warning to support broken AC-3 files known to exist.
jbr
parents:
10331
diff
changeset
|
1037 s->num_rematrixing_bands = 0; |
5305
5892b4a6380b
AC-3 decoder, soc revision 31, Jul 14 23:53:28 2006 UTC by cloud9
jbr
parents:
5304
diff
changeset
|
1038 } |
5303
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
1039 } |
5309
0662a270aab7
AC-3 decoder, soc revision 38, Aug 7 00:03:00 2006 UTC by cloud9
jbr
parents:
5308
diff
changeset
|
1040 |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
1041 /* exponent strategies for each channel */ |
7026 | 1042 for (ch = !cpl_in_use; ch <= s->channels; ch++) { |
7709
0b11b0e7b404
do not read exponent strategies from each block for E-AC-3 since they are in the header
jbr
parents:
7703
diff
changeset
|
1043 if (!s->eac3) |
7710 | 1044 s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch)); |
7027 | 1045 if(s->exp_strategy[blk][ch] != EXP_REUSE) |
5476
e50f0d583a36
consolidate decoding of lfe and coupling channels with decoding of full-bandwidth channels.
jbr
parents:
5475
diff
changeset
|
1046 bit_alloc_stages[ch] = 3; |
e50f0d583a36
consolidate decoding of lfe and coupling channels with decoding of full-bandwidth channels.
jbr
parents:
5475
diff
changeset
|
1047 } |
5309
0662a270aab7
AC-3 decoder, soc revision 38, Aug 7 00:03:00 2006 UTC by cloud9
jbr
parents:
5308
diff
changeset
|
1048 |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
1049 /* channel bandwidth */ |
6006 | 1050 for (ch = 1; ch <= fbw_channels; ch++) { |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1051 s->start_freq[ch] = 0; |
7027 | 1052 if (s->exp_strategy[blk][ch] != EXP_REUSE) { |
6957
6eb895971766
only calculate number of exponent groups when exponents are not reused.
jbr
parents:
6956
diff
changeset
|
1053 int group_size; |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1054 int prev = s->end_freq[ch]; |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1055 if (s->channel_in_cpl[ch]) |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1056 s->end_freq[ch] = s->start_freq[CPL_CH]; |
11559 | 1057 else if (s->channel_uses_spx[ch]) |
1058 s->end_freq[ch] = s->spx_src_start_freq; | |
5305
5892b4a6380b
AC-3 decoder, soc revision 31, Jul 14 23:53:28 2006 UTC by cloud9
jbr
parents:
5304
diff
changeset
|
1059 else { |
6089 | 1060 int bandwidth_code = get_bits(gbc, 6); |
6006 | 1061 if (bandwidth_code > 60) { |
8134 | 1062 av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code); |
5305
5892b4a6380b
AC-3 decoder, soc revision 31, Jul 14 23:53:28 2006 UTC by cloud9
jbr
parents:
5304
diff
changeset
|
1063 return -1; |
5892b4a6380b
AC-3 decoder, soc revision 31, Jul 14 23:53:28 2006 UTC by cloud9
jbr
parents:
5304
diff
changeset
|
1064 } |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1065 s->end_freq[ch] = bandwidth_code * 3 + 73; |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
1066 } |
7027 | 1067 group_size = 3 << (s->exp_strategy[blk][ch] - 1); |
6957
6eb895971766
only calculate number of exponent groups when exponents are not reused.
jbr
parents:
6956
diff
changeset
|
1068 s->num_exp_groups[ch] = (s->end_freq[ch]+group_size-4) / group_size; |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1069 if(blk > 0 && s->end_freq[ch] != prev) |
5476
e50f0d583a36
consolidate decoding of lfe and coupling channels with decoding of full-bandwidth channels.
jbr
parents:
5475
diff
changeset
|
1070 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS); |
5305
5892b4a6380b
AC-3 decoder, soc revision 31, Jul 14 23:53:28 2006 UTC by cloud9
jbr
parents:
5304
diff
changeset
|
1071 } |
5461
c427d8950769
cosmetics: use braces when it makes the code easier to read.
jbr
parents:
5460
diff
changeset
|
1072 } |
7027 | 1073 if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) { |
6957
6eb895971766
only calculate number of exponent groups when exponents are not reused.
jbr
parents:
6956
diff
changeset
|
1074 s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) / |
7027 | 1075 (3 << (s->exp_strategy[blk][CPL_CH] - 1)); |
6957
6eb895971766
only calculate number of exponent groups when exponents are not reused.
jbr
parents:
6956
diff
changeset
|
1076 } |
5309
0662a270aab7
AC-3 decoder, soc revision 38, Aug 7 00:03:00 2006 UTC by cloud9
jbr
parents:
5308
diff
changeset
|
1077 |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
1078 /* decode exponents for each channel */ |
7026 | 1079 for (ch = !cpl_in_use; ch <= s->channels; ch++) { |
7027 | 1080 if (s->exp_strategy[blk][ch] != EXP_REUSE) { |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1081 s->dexps[ch][0] = get_bits(gbc, 4) << !ch; |
8268 | 1082 if (decode_exponents(gbc, s->exp_strategy[blk][ch], |
8269 | 1083 s->num_exp_groups[ch], s->dexps[ch][0], |
1084 &s->dexps[ch][s->start_freq[ch]+!!ch])) { | |
8268 | 1085 av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n"); |
1086 return -1; | |
1087 } | |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1088 if(ch != CPL_CH && ch != s->lfe_ch) |
6089 | 1089 skip_bits(gbc, 2); /* skip gainrng */ |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
1090 } |
5461
c427d8950769
cosmetics: use braces when it makes the code easier to read.
jbr
parents:
5460
diff
changeset
|
1091 } |
5309
0662a270aab7
AC-3 decoder, soc revision 38, Aug 7 00:03:00 2006 UTC by cloud9
jbr
parents:
5308
diff
changeset
|
1092 |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
1093 /* bit allocation information */ |
7626 | 1094 if (s->bit_allocation_syntax) { |
7627 | 1095 if (get_bits1(gbc)) { |
1096 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift; | |
1097 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift; | |
1098 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)]; | |
1099 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)]; | |
8142
f17b1eb9ccd1
revert r15812 (E-AC-3 Spectral Extension) pending further review
jbr
parents:
8139
diff
changeset
|
1100 s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)]; |
7627 | 1101 for(ch=!cpl_in_use; ch<=s->channels; ch++) |
1102 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2); | |
1103 } else if (!blk) { | |
1104 av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must be present in block 0\n"); | |
1105 return -1; | |
1106 } | |
7626 | 1107 } |
5309
0662a270aab7
AC-3 decoder, soc revision 38, Aug 7 00:03:00 2006 UTC by cloud9
jbr
parents:
5308
diff
changeset
|
1108 |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
1109 /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */ |
7747 | 1110 if(!s->eac3 || !blk){ |
1111 if(s->snr_offset_strategy && get_bits1(gbc)) { | |
7749 | 1112 int snr = 0; |
1113 int csnr; | |
1114 csnr = (get_bits(gbc, 6) - 15) << 4; | |
1115 for (i = ch = !cpl_in_use; ch <= s->channels; ch++) { | |
1116 /* snr offset */ | |
1117 if (ch == i || s->snr_offset_strategy == 2) | |
1118 snr = (csnr + get_bits(gbc, 4)) << 2; | |
1119 /* run at least last bit allocation stage if snr offset changes */ | |
1120 if(blk && s->snr_offset[ch] != snr) { | |
1121 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1); | |
1122 } | |
1123 s->snr_offset[ch] = snr; | |
7747 | 1124 |
1125 /* fast gain (normal AC-3 only) */ | |
1126 if (!s->eac3) { | |
1127 int prev = s->fast_gain[ch]; | |
7749 | 1128 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)]; |
7747 | 1129 /* run last 2 bit allocation stages if fast gain changes */ |
1130 if(blk && prev != s->fast_gain[ch]) | |
1131 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2); | |
1132 } | |
7749 | 1133 } |
7747 | 1134 } else if (!s->eac3 && !blk) { |
7749 | 1135 av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n"); |
1136 return -1; | |
7747 | 1137 } |
5303
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
1138 } |
5309
0662a270aab7
AC-3 decoder, soc revision 38, Aug 7 00:03:00 2006 UTC by cloud9
jbr
parents:
5308
diff
changeset
|
1139 |
7664 | 1140 /* fast gain (E-AC-3 only) */ |
1141 if (s->fast_gain_syntax && get_bits1(gbc)) { | |
1142 for (ch = !cpl_in_use; ch <= s->channels; ch++) { | |
1143 int prev = s->fast_gain[ch]; | |
1144 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)]; | |
1145 /* run last 2 bit allocation stages if fast gain changes */ | |
1146 if(blk && prev != s->fast_gain[ch]) | |
1147 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2); | |
1148 } | |
1149 } else if (s->eac3 && !blk) { | |
1150 for (ch = !cpl_in_use; ch <= s->channels; ch++) | |
1151 s->fast_gain[ch] = ff_ac3_fast_gain_tab[4]; | |
1152 } | |
1153 | |
1154 /* E-AC-3 to AC-3 converter SNR offset */ | |
1155 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) { | |
1156 skip_bits(gbc, 10); // skip converter snr offset | |
1157 } | |
1158 | |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
1159 /* coupling leak information */ |
7026 | 1160 if (cpl_in_use) { |
7747 | 1161 if (s->first_cpl_leak || get_bits1(gbc)) { |
1162 int fl = get_bits(gbc, 3); | |
1163 int sl = get_bits(gbc, 3); | |
1164 /* run last 2 bit allocation stages for coupling channel if | |
1165 coupling leak changes */ | |
1166 if(blk && (fl != s->bit_alloc_params.cpl_fast_leak || | |
1167 sl != s->bit_alloc_params.cpl_slow_leak)) { | |
7749 | 1168 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2); |
7747 | 1169 } |
1170 s->bit_alloc_params.cpl_fast_leak = fl; | |
1171 s->bit_alloc_params.cpl_slow_leak = sl; | |
1172 } else if (!s->eac3 && !blk) { | |
6872 | 1173 av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must be present in block 0\n"); |
1174 return -1; | |
1175 } | |
7747 | 1176 s->first_cpl_leak = 0; |
6871 | 1177 } |
5309
0662a270aab7
AC-3 decoder, soc revision 38, Aug 7 00:03:00 2006 UTC by cloud9
jbr
parents:
5308
diff
changeset
|
1178 |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
1179 /* delta bit allocation information */ |
7626 | 1180 if (s->dba_syntax && get_bits1(gbc)) { |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
1181 /* delta bit allocation exists (strategy) */ |
7026 | 1182 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) { |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1183 s->dba_mode[ch] = get_bits(gbc, 2); |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1184 if (s->dba_mode[ch] == DBA_RESERVED) { |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1185 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n"); |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
1186 return -1; |
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
1187 } |
5476
e50f0d583a36
consolidate decoding of lfe and coupling channels with decoding of full-bandwidth channels.
jbr
parents:
5475
diff
changeset
|
1188 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2); |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
1189 } |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
1190 /* channel delta offset, len and bit allocation */ |
7026 | 1191 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) { |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1192 if (s->dba_mode[ch] == DBA_NEW) { |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1193 s->dba_nsegs[ch] = get_bits(gbc, 3); |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1194 for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) { |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1195 s->dba_offsets[ch][seg] = get_bits(gbc, 5); |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1196 s->dba_lengths[ch][seg] = get_bits(gbc, 4); |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1197 s->dba_values[ch][seg] = get_bits(gbc, 3); |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
1198 } |
6954
57797b6c9d59
new dba values requires running last 2 bit allocation stages
jbr
parents:
6953
diff
changeset
|
1199 /* run last 2 bit allocation stages if new dba values */ |
57797b6c9d59
new dba values requires running last 2 bit allocation stages
jbr
parents:
6953
diff
changeset
|
1200 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2); |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
1201 } |
5461
c427d8950769
cosmetics: use braces when it makes the code easier to read.
jbr
parents:
5460
diff
changeset
|
1202 } |
5386
d6347c3cb329
Use shared AC-3 header parsing. Move some initializations to block parsing function.
jbr
parents:
5385
diff
changeset
|
1203 } else if(blk == 0) { |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1204 for(ch=0; ch<=s->channels; ch++) { |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1205 s->dba_mode[ch] = DBA_NONE; |
5386
d6347c3cb329
Use shared AC-3 header parsing. Move some initializations to block parsing function.
jbr
parents:
5385
diff
changeset
|
1206 } |
5303
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
1207 } |
5305
5892b4a6380b
AC-3 decoder, soc revision 31, Jul 14 23:53:28 2006 UTC by cloud9
jbr
parents:
5304
diff
changeset
|
1208 |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
1209 /* Bit allocation */ |
7026 | 1210 for(ch=!cpl_in_use; ch<=s->channels; ch++) { |
5476
e50f0d583a36
consolidate decoding of lfe and coupling channels with decoding of full-bandwidth channels.
jbr
parents:
5475
diff
changeset
|
1211 if(bit_alloc_stages[ch] > 2) { |
e50f0d583a36
consolidate decoding of lfe and coupling channels with decoding of full-bandwidth channels.
jbr
parents:
5475
diff
changeset
|
1212 /* Exponent mapping into PSD and PSD integration */ |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1213 ff_ac3_bit_alloc_calc_psd(s->dexps[ch], |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1214 s->start_freq[ch], s->end_freq[ch], |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1215 s->psd[ch], s->band_psd[ch]); |
5461
c427d8950769
cosmetics: use braces when it makes the code easier to read.
jbr
parents:
5460
diff
changeset
|
1216 } |
5476
e50f0d583a36
consolidate decoding of lfe and coupling channels with decoding of full-bandwidth channels.
jbr
parents:
5475
diff
changeset
|
1217 if(bit_alloc_stages[ch] > 1) { |
e50f0d583a36
consolidate decoding of lfe and coupling channels with decoding of full-bandwidth channels.
jbr
parents:
5475
diff
changeset
|
1218 /* Compute excitation function, Compute masking curve, and |
e50f0d583a36
consolidate decoding of lfe and coupling channels with decoding of full-bandwidth channels.
jbr
parents:
5475
diff
changeset
|
1219 Apply delta bit allocation */ |
8279
6c2dcc1410bb
ac3: detect dba errors and prevent writing past end of array
jbr
parents:
8275
diff
changeset
|
1220 if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch], |
8280 | 1221 s->start_freq[ch], s->end_freq[ch], |
1222 s->fast_gain[ch], (ch == s->lfe_ch), | |
1223 s->dba_mode[ch], s->dba_nsegs[ch], | |
1224 s->dba_offsets[ch], s->dba_lengths[ch], | |
1225 s->dba_values[ch], s->mask[ch])) { | |
8279
6c2dcc1410bb
ac3: detect dba errors and prevent writing past end of array
jbr
parents:
8275
diff
changeset
|
1226 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n"); |
6c2dcc1410bb
ac3: detect dba errors and prevent writing past end of array
jbr
parents:
8275
diff
changeset
|
1227 return -1; |
6c2dcc1410bb
ac3: detect dba errors and prevent writing past end of array
jbr
parents:
8275
diff
changeset
|
1228 } |
5461
c427d8950769
cosmetics: use braces when it makes the code easier to read.
jbr
parents:
5460
diff
changeset
|
1229 } |
5476
e50f0d583a36
consolidate decoding of lfe and coupling channels with decoding of full-bandwidth channels.
jbr
parents:
5475
diff
changeset
|
1230 if(bit_alloc_stages[ch] > 0) { |
e50f0d583a36
consolidate decoding of lfe and coupling channels with decoding of full-bandwidth channels.
jbr
parents:
5475
diff
changeset
|
1231 /* Compute bit allocation */ |
7626 | 1232 const uint8_t *bap_tab = s->channel_uses_aht[ch] ? |
1233 ff_eac3_hebap_tab : ff_ac3_bap_tab; | |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1234 ff_ac3_bit_alloc_calc_bap(s->mask[ch], s->psd[ch], |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1235 s->start_freq[ch], s->end_freq[ch], |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1236 s->snr_offset[ch], |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1237 s->bit_alloc_params.floor, |
7626 | 1238 bap_tab, s->bap[ch]); |
5461
c427d8950769
cosmetics: use braces when it makes the code easier to read.
jbr
parents:
5460
diff
changeset
|
1239 } |
5310
9aa9197034d7
AC-3 decoder, soc revision 40, Aug 9 00:10:14 2006 UTC by cloud9
jbr
parents:
5309
diff
changeset
|
1240 } |
5309
0662a270aab7
AC-3 decoder, soc revision 38, Aug 7 00:03:00 2006 UTC by cloud9
jbr
parents:
5308
diff
changeset
|
1241 |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
1242 /* unused dummy data */ |
7626 | 1243 if (s->skip_syntax && get_bits1(gbc)) { |
6089 | 1244 int skipl = get_bits(gbc, 9); |
5309
0662a270aab7
AC-3 decoder, soc revision 38, Aug 7 00:03:00 2006 UTC by cloud9
jbr
parents:
5308
diff
changeset
|
1245 while(skipl--) |
6089 | 1246 skip_bits(gbc, 8); |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
1247 } |
5499 | 1248 |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
1249 /* unpack the transform coefficients |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
1250 this also uncouples channels if coupling is in use. */ |
7702
f91e273722c8
add more OKed parts of the E-AC-3 decoder: structural changes to support AHT mode mantissa decoding
jbr
parents:
7701
diff
changeset
|
1251 decode_transform_coeffs(s, blk); |
5306
abc5c130b448
AC-3 decoder, soc revision 32, Jul 17 09:37:32 2006 UTC by cloud9
jbr
parents:
5305
diff
changeset
|
1252 |
7626 | 1253 /* TODO: generate enhanced coupling coordinates and uncouple */ |
1254 | |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
1255 /* recover coefficients if rematrixing is in use */ |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1256 if(s->channel_mode == AC3_CHMODE_STEREO) |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1257 do_rematrixing(s); |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
1258 |
6032
f74202e7e896
Skip dialog normalization. It shouldn't be used by the decoder, and there is
jbr
parents:
6031
diff
changeset
|
1259 /* apply scaling to coefficients (headroom, dynrng) */ |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1260 for(ch=1; ch<=s->channels; ch++) { |
6430
de7502093922
Use 24-bit fixed-point transform coefficients until just before MDCT. This
jbr
parents:
6142
diff
changeset
|
1261 float gain = s->mul_bias / 4194304.0f; |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1262 if(s->channel_mode == AC3_CHMODE_DUALMONO) { |
10529
f8fc0a56745e
ac3dec: apply dynamic range compression to correct channels in dual-mono mode.
jbr
parents:
10498
diff
changeset
|
1263 gain *= s->dynamic_range[2-ch]; |
5412
3f6a6dda6b2d
remove broken downmixing. will add new implementation later.
jbr
parents:
5393
diff
changeset
|
1264 } else { |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1265 gain *= s->dynamic_range[0]; |
5412
3f6a6dda6b2d
remove broken downmixing. will add new implementation later.
jbr
parents:
5393
diff
changeset
|
1266 } |
7564 | 1267 s->dsp.int32_to_float_fmul_scalar(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256); |
5412
3f6a6dda6b2d
remove broken downmixing. will add new implementation later.
jbr
parents:
5393
diff
changeset
|
1268 } |
5318
ef4ef249ca72
AC-3 decoder, soc revision 58, Aug 19 14:20:45 2006 UTC by cloud9
jbr
parents:
5317
diff
changeset
|
1269 |
11559 | 1270 /* apply spectral extension to high frequency bins */ |
11727
0c98bdb71f48
Fix compilation of AC3 decoder if E-AC3 decoder was disabled.
cehoyos
parents:
11656
diff
changeset
|
1271 if (s->spx_in_use && CONFIG_EAC3_DECODER) { |
11559 | 1272 ff_eac3_apply_spectral_extension(s); |
1273 } | |
1274 | |
6480
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
1275 /* downmix and MDCT. order depends on whether block switching is used for |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
1276 any channel in this block. this is because coefficients for the long |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
1277 and short transforms cannot be mixed. */ |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
1278 downmix_output = s->channels != s->out_channels && |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
1279 !((s->output_mode & AC3_OUTPUT_LFEON) && |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
1280 s->fbw_channels == s->out_channels); |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
1281 if(different_transforms) { |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
1282 /* the delay samples have already been downmixed, so we upmix the delay |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
1283 samples in order to reconstruct all channels before downmixing. */ |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
1284 if(s->downmixed) { |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
1285 s->downmixed = 0; |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
1286 ac3_upmix_delay(s); |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
1287 } |
5306
abc5c130b448
AC-3 decoder, soc revision 32, Jul 17 09:37:32 2006 UTC by cloud9
jbr
parents:
5305
diff
changeset
|
1288 |
6480
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
1289 do_imdct(s, s->channels); |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
1290 |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
1291 if(downmix_output) { |
7563 | 1292 s->dsp.ac3_downmix(s->output, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256); |
6480
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
1293 } |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
1294 } else { |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
1295 if(downmix_output) { |
7563 | 1296 s->dsp.ac3_downmix(s->transform_coeffs+1, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256); |
6480
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
1297 } |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
1298 |
7562
ef456ee01ea2
don't mark the delayed samples for upmixing if they haven't been downmixed
lorenm
parents:
7561
diff
changeset
|
1299 if(downmix_output && !s->downmixed) { |
6480
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
1300 s->downmixed = 1; |
7563 | 1301 s->dsp.ac3_downmix(s->delay, s->downmix_coeffs, s->out_channels, s->fbw_channels, 128); |
6480
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
1302 } |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
1303 |
6f01a499e785
downmix before imdct unless different size transforms are used. about 20%
jbr
parents:
6432
diff
changeset
|
1304 do_imdct(s, s->out_channels); |
5480 | 1305 } |
1306 | |
5479
943c732c905d
use dsputil for float to signed 16-bit sample conversion
jbr
parents:
5477
diff
changeset
|
1307 return 0; |
5306
abc5c130b448
AC-3 decoder, soc revision 32, Jul 17 09:37:32 2006 UTC by cloud9
jbr
parents:
5305
diff
changeset
|
1308 } |
abc5c130b448
AC-3 decoder, soc revision 32, Jul 17 09:37:32 2006 UTC by cloud9
jbr
parents:
5305
diff
changeset
|
1309 |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
1310 /** |
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
1311 * Decode a single AC-3 frame. |
5321
fcb2a52c88fe
AC-3 decoder, soc revision 71, Sep 4 09:47:12 2006 UTC by cloud9
jbr
parents:
5320
diff
changeset
|
1312 */ |
6487
8f1b27d73a07
make input buffer const, as it should be. fixes a warning.
jbr
parents:
6480
diff
changeset
|
1313 static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size, |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8629
diff
changeset
|
1314 AVPacket *avpkt) |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
1315 { |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8629
diff
changeset
|
1316 const uint8_t *buf = avpkt->data; |
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8629
diff
changeset
|
1317 int buf_size = avpkt->size; |
6092 | 1318 AC3DecodeContext *s = avctx->priv_data; |
5305
5892b4a6380b
AC-3 decoder, soc revision 31, Jul 14 23:53:28 2006 UTC by cloud9
jbr
parents:
5304
diff
changeset
|
1319 int16_t *out_samples = (int16_t *)data; |
7550 | 1320 int blk, ch, err; |
9454
7db61b0d21f9
ac3dec: reorder output channels to SMPTE channel order
jbr
parents:
9355
diff
changeset
|
1321 const uint8_t *channel_map; |
9605
93029f1a4c14
ac3dec: move channel remapping to outside of block loop
jbr
parents:
9512
diff
changeset
|
1322 const float *output[AC3_MAX_CHANNELS]; |
5318
ef4ef249ca72
AC-3 decoder, soc revision 58, Aug 19 14:20:45 2006 UTC by cloud9
jbr
parents:
5317
diff
changeset
|
1323 |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
1324 /* initialize the GetBitContext with the start of valid AC-3 Frame */ |
6538
b8f886bce6f5
only allocate context input buffer if AVCodecContext.error_reslience is greater than 0.
jbr
parents:
6537
diff
changeset
|
1325 if (s->input_buffer) { |
6536
8f2186d5daca
additional protection from segmentation faults and memory access errors by
jbr
parents:
6529
diff
changeset
|
1326 /* copy input buffer to decoder context to avoid reading past the end |
8f2186d5daca
additional protection from segmentation faults and memory access errors by
jbr
parents:
6529
diff
changeset
|
1327 of the buffer, which can be caused by a damaged input stream. */ |
7624
545305ba44a0
rename AC3_MAX_FRAME_SIZE to AC3_FRAME_BUFFER_SIZE and increase the size
jbr
parents:
7603
diff
changeset
|
1328 memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE)); |
6536
8f2186d5daca
additional protection from segmentation faults and memory access errors by
jbr
parents:
6529
diff
changeset
|
1329 init_get_bits(&s->gbc, s->input_buffer, buf_size * 8); |
8f2186d5daca
additional protection from segmentation faults and memory access errors by
jbr
parents:
6529
diff
changeset
|
1330 } else { |
6537 | 1331 init_get_bits(&s->gbc, buf, buf_size * 8); |
6536
8f2186d5daca
additional protection from segmentation faults and memory access errors by
jbr
parents:
6529
diff
changeset
|
1332 } |
5305
5892b4a6380b
AC-3 decoder, soc revision 31, Jul 14 23:53:28 2006 UTC by cloud9
jbr
parents:
5304
diff
changeset
|
1333 |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
1334 /* parse the syncinfo */ |
6950 | 1335 *data_size = 0; |
7028 | 1336 err = parse_frame_header(s); |
6950 | 1337 |
11049
e26ea20d293a
Simplify error handling by processing header errors separate from CRC and
jbr
parents:
11001
diff
changeset
|
1338 if (err) { |
5680 | 1339 switch(err) { |
8545
a5402e89a80c
Factorise enum of AC3 error types to be usable by AAC in the ADTS patch that
superdump
parents:
8281
diff
changeset
|
1340 case AAC_AC3_PARSE_ERROR_SYNC: |
6950 | 1341 av_log(avctx, AV_LOG_ERROR, "frame sync error\n"); |
6999 | 1342 return -1; |
8545
a5402e89a80c
Factorise enum of AC3 error types to be usable by AAC in the ADTS patch that
superdump
parents:
8281
diff
changeset
|
1343 case AAC_AC3_PARSE_ERROR_BSID: |
5680 | 1344 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n"); |
1345 break; | |
8545
a5402e89a80c
Factorise enum of AC3 error types to be usable by AAC in the ADTS patch that
superdump
parents:
8281
diff
changeset
|
1346 case AAC_AC3_PARSE_ERROR_SAMPLE_RATE: |
5680 | 1347 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n"); |
1348 break; | |
8545
a5402e89a80c
Factorise enum of AC3 error types to be usable by AAC in the ADTS patch that
superdump
parents:
8281
diff
changeset
|
1349 case AAC_AC3_PARSE_ERROR_FRAME_SIZE: |
5680 | 1350 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n"); |
1351 break; | |
8545
a5402e89a80c
Factorise enum of AC3 error types to be usable by AAC in the ADTS patch that
superdump
parents:
8281
diff
changeset
|
1352 case AAC_AC3_PARSE_ERROR_FRAME_TYPE: |
7014 | 1353 /* skip frame if CRC is ok. otherwise use error concealment. */ |
1354 /* TODO: add support for substreams and dependent frames */ | |
1355 if(s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) { | |
1356 av_log(avctx, AV_LOG_ERROR, "unsupported frame type : skipping frame\n"); | |
1357 return s->frame_size; | |
1358 } else { | |
7015 | 1359 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n"); |
7014 | 1360 } |
6529 | 1361 break; |
5680 | 1362 default: |
1363 av_log(avctx, AV_LOG_ERROR, "invalid header\n"); | |
1364 break; | |
1365 } | |
11049
e26ea20d293a
Simplify error handling by processing header errors separate from CRC and
jbr
parents:
11001
diff
changeset
|
1366 } else { |
e26ea20d293a
Simplify error handling by processing header errors separate from CRC and
jbr
parents:
11001
diff
changeset
|
1367 /* check that reported frame size fits in input buffer */ |
e26ea20d293a
Simplify error handling by processing header errors separate from CRC and
jbr
parents:
11001
diff
changeset
|
1368 if (s->frame_size > buf_size) { |
e26ea20d293a
Simplify error handling by processing header errors separate from CRC and
jbr
parents:
11001
diff
changeset
|
1369 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n"); |
e26ea20d293a
Simplify error handling by processing header errors separate from CRC and
jbr
parents:
11001
diff
changeset
|
1370 err = AAC_AC3_PARSE_ERROR_FRAME_SIZE; |
e26ea20d293a
Simplify error handling by processing header errors separate from CRC and
jbr
parents:
11001
diff
changeset
|
1371 } else if (avctx->error_recognition >= FF_ER_CAREFUL) { |
e26ea20d293a
Simplify error handling by processing header errors separate from CRC and
jbr
parents:
11001
diff
changeset
|
1372 /* check for crc mismatch */ |
e26ea20d293a
Simplify error handling by processing header errors separate from CRC and
jbr
parents:
11001
diff
changeset
|
1373 if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) { |
e26ea20d293a
Simplify error handling by processing header errors separate from CRC and
jbr
parents:
11001
diff
changeset
|
1374 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n"); |
e26ea20d293a
Simplify error handling by processing header errors separate from CRC and
jbr
parents:
11001
diff
changeset
|
1375 err = AAC_AC3_PARSE_ERROR_CRC; |
e26ea20d293a
Simplify error handling by processing header errors separate from CRC and
jbr
parents:
11001
diff
changeset
|
1376 } |
e26ea20d293a
Simplify error handling by processing header errors separate from CRC and
jbr
parents:
11001
diff
changeset
|
1377 } |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
1378 } |
5303
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
1379 |
6889 | 1380 /* if frame is ok, set audio parameters */ |
1381 if (!err) { | |
6885 | 1382 avctx->sample_rate = s->sample_rate; |
1383 avctx->bit_rate = s->bit_rate; | |
6098 | 1384 |
6885 | 1385 /* channel config */ |
1386 s->out_channels = s->channels; | |
6889 | 1387 s->output_mode = s->channel_mode; |
1388 if(s->lfe_on) | |
1389 s->output_mode |= AC3_OUTPUT_LFEON; | |
6885 | 1390 if (avctx->request_channels > 0 && avctx->request_channels <= 2 && |
1391 avctx->request_channels < s->channels) { | |
1392 s->out_channels = avctx->request_channels; | |
1393 s->output_mode = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO; | |
9512
ba5d9a97ab2f
Add channel layout support to the AC-3 decoder and AC-3 parser.
jbr
parents:
9454
diff
changeset
|
1394 s->channel_layout = ff_ac3_channel_layout_tab[s->output_mode]; |
6885 | 1395 } |
1396 avctx->channels = s->out_channels; | |
9512
ba5d9a97ab2f
Add channel layout support to the AC-3 decoder and AC-3 parser.
jbr
parents:
9454
diff
changeset
|
1397 avctx->channel_layout = s->channel_layout; |
5303
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
1398 |
6885 | 1399 /* set downmixing coefficients if needed */ |
1400 if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) && | |
1401 s->fbw_channels == s->out_channels)) { | |
1402 set_downmix_coeffs(s); | |
1403 } | |
6889 | 1404 } else if (!s->out_channels) { |
1405 s->out_channels = avctx->channels; | |
1406 if(s->out_channels < s->channels) | |
1407 s->output_mode = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO; | |
6884 | 1408 } |
6126
c24cd5282108
split out init of downmix coeffs into a separate function that can be called
jbr
parents:
6125
diff
changeset
|
1409 |
7490
bddd15a1d167
cosmetics: change function name and comments to refer to block decoding
jbr
parents:
7489
diff
changeset
|
1410 /* decode the audio blocks */ |
9454
7db61b0d21f9
ac3dec: reorder output channels to SMPTE channel order
jbr
parents:
9355
diff
changeset
|
1411 channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on]; |
9606 | 1412 for (ch = 0; ch < s->out_channels; ch++) |
1413 output[ch] = s->output[channel_map[ch]]; | |
7011
77f607fb4e8b
get the number of blocks from the ac3 parser and use in the ac3 decoder.
jbr
parents:
6999
diff
changeset
|
1414 for (blk = 0; blk < s->num_blocks; blk++) { |
7490
bddd15a1d167
cosmetics: change function name and comments to refer to block decoding
jbr
parents:
7489
diff
changeset
|
1415 if (!err && decode_audio_block(s, blk)) { |
bddd15a1d167
cosmetics: change function name and comments to refer to block decoding
jbr
parents:
7489
diff
changeset
|
1416 av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n"); |
8249
5057047bcc52
ac3dec: skip decoding and use error concealment for remaining blocks in
jbr
parents:
8142
diff
changeset
|
1417 err = 1; |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
1418 } |
7550 | 1419 s->dsp.float_to_int16_interleave(out_samples, output, 256, s->out_channels); |
1420 out_samples += 256 * s->out_channels; | |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
1421 } |
7011
77f607fb4e8b
get the number of blocks from the ac3 parser and use in the ac3 decoder.
jbr
parents:
6999
diff
changeset
|
1422 *data_size = s->num_blocks * 256 * avctx->channels * sizeof (int16_t); |
11656
e6bff5319932
ac3dec: return smaller of buf_size and frame_size instead of always returning
jbr
parents:
11581
diff
changeset
|
1423 return FFMIN(buf_size, s->frame_size); |
5303
b8821ff5c30d
AC-3 decoder, soc revision 9, Jun 14 03:52:02 2006 UTC by cloud9
jbr
parents:
diff
changeset
|
1424 } |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
1425 |
5515
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
1426 /** |
b499866a3397
comments modification: add, clean up, Doxygenize, and reword
jbr
parents:
5499
diff
changeset
|
1427 * Uninitialize the AC-3 decoder. |
5321
fcb2a52c88fe
AC-3 decoder, soc revision 71, Sep 4 09:47:12 2006 UTC by cloud9
jbr
parents:
5320
diff
changeset
|
1428 */ |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6487
diff
changeset
|
1429 static av_cold int ac3_decode_end(AVCodecContext *avctx) |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
1430 { |
6092 | 1431 AC3DecodeContext *s = avctx->priv_data; |
6090
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1432 ff_mdct_end(&s->imdct_512); |
b7b19fbc4746
cosmetics: rename all AC3DecodeContext variables from ctx to s
jbr
parents:
6089
diff
changeset
|
1433 ff_mdct_end(&s->imdct_256); |
5321
fcb2a52c88fe
AC-3 decoder, soc revision 71, Sep 4 09:47:12 2006 UTC by cloud9
jbr
parents:
5320
diff
changeset
|
1434 |
6538
b8f886bce6f5
only allocate context input buffer if AVCodecContext.error_reslience is greater than 0.
jbr
parents:
6537
diff
changeset
|
1435 av_freep(&s->input_buffer); |
b8f886bce6f5
only allocate context input buffer if AVCodecContext.error_reslience is greater than 0.
jbr
parents:
6537
diff
changeset
|
1436 |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
1437 return 0; |
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
1438 } |
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
1439 |
5334
d406baea3275
no need for the decoder to have the license as a prefix
jbr
parents:
5333
diff
changeset
|
1440 AVCodec ac3_decoder = { |
5315
31033309ebc9
AC-3 decoder, soc revision 55, Aug 17 12:25:24 2006 UTC by cloud9
jbr
parents:
5314
diff
changeset
|
1441 .name = "ac3", |
11560
8a4984c5cacc
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
11559
diff
changeset
|
1442 .type = AVMEDIA_TYPE_AUDIO, |
5315
31033309ebc9
AC-3 decoder, soc revision 55, Aug 17 12:25:24 2006 UTC by cloud9
jbr
parents:
5314
diff
changeset
|
1443 .id = CODEC_ID_AC3, |
31033309ebc9
AC-3 decoder, soc revision 55, Aug 17 12:25:24 2006 UTC by cloud9
jbr
parents:
5314
diff
changeset
|
1444 .priv_data_size = sizeof (AC3DecodeContext), |
31033309ebc9
AC-3 decoder, soc revision 55, Aug 17 12:25:24 2006 UTC by cloud9
jbr
parents:
5314
diff
changeset
|
1445 .init = ac3_decode_init, |
31033309ebc9
AC-3 decoder, soc revision 55, Aug 17 12:25:24 2006 UTC by cloud9
jbr
parents:
5314
diff
changeset
|
1446 .close = ac3_decode_end, |
31033309ebc9
AC-3 decoder, soc revision 55, Aug 17 12:25:24 2006 UTC by cloud9
jbr
parents:
5314
diff
changeset
|
1447 .decode = ac3_decode_frame, |
7769 | 1448 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"), |
5304
eff51058fe13
AC-3 decoder, soc revision 26, Jul 5 04:55:15 2006 UTC by cloud9
jbr
parents:
5303
diff
changeset
|
1449 }; |
7769 | 1450 |
9982
daa53251c64d
Make sure that eac3_decoder only gets enabled when CONFIG_EAC3_DECODER is set.
diego
parents:
9891
diff
changeset
|
1451 #if CONFIG_EAC3_DECODER |
7769 | 1452 AVCodec eac3_decoder = { |
1453 .name = "eac3", | |
11560
8a4984c5cacc
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
11559
diff
changeset
|
1454 .type = AVMEDIA_TYPE_AUDIO, |
7769 | 1455 .id = CODEC_ID_EAC3, |
1456 .priv_data_size = sizeof (AC3DecodeContext), | |
1457 .init = ac3_decode_init, | |
1458 .close = ac3_decode_end, | |
1459 .decode = ac3_decode_frame, | |
1460 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"), | |
1461 }; | |
9982
daa53251c64d
Make sure that eac3_decoder only gets enabled when CONFIG_EAC3_DECODER is set.
diego
parents:
9891
diff
changeset
|
1462 #endif |