← Back to branch summary

~ubuntu-branches/debian/wheezy/vlc/wheezy

« back to all changes in this revision

Viewing changes to plugins/ac3_adec/ac3_mantissa.h

Tags: upstream-0.7.2.final
Import upstream version 0.7.2.final

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins/ac3_adec/ac3_mantissa.h
1
 
/*****************************************************************************
2
 
 * ac3_mantissa.h: ac3 mantissa computation
3
 
 *****************************************************************************
4
 
 * Copyright (C) 1999, 2000, 2001 VideoLAN
5
 
 * $Id: ac3_mantissa.h,v 1.1 2001/11/13 12:09:17 henri Exp $
6
 
 *
7
 
 * Authors: Michel Kaempf <maxx@via.ecp.fr>
8
 
 *          Aaron Holtzman <aholtzma@engr.uvic.ca>
9
 
 *          Renaud Dartus <reno@videolan.org>
10
 
 *
11
 
 * This program is free software; you can redistribute it and/or modify
12
 
 * it under the terms of the GNU General Public License as published by
13
 
 * the Free Software Foundation; either version 2 of the License, or
14
 
 * (at your option) any later version.
15
 
 * 
16
 
 * This program is distributed in the hope that it will be useful,
17
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19
 
 * GNU General Public License for more details.
20
 
 *
21
 
 * You should have received a copy of the GNU General Public License
22
 
 * along with this program; if not, write to the Free Software
23
 
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
24
 
 *****************************************************************************/
25
 
 
26
 
#define Q0 ((-2 << 15) / 3.0)
27
 
#define Q1 (0)
28
 
#define Q2 ((2 << 15) / 3.0)
29
 
static const float q_1_0[ 32 ] =
30
 
{
31
 
    Q0, Q0, Q0, Q0, Q0, Q0, Q0, Q0, Q0,
32
 
    Q1, Q1, Q1, Q1, Q1, Q1, Q1, Q1, Q1,
33
 
    Q2, Q2, Q2, Q2, Q2, Q2, Q2, Q2, Q2,
34
 
    0, 0, 0, 0, 0
35
 
};
36
 
static const float q_1_1[ 32 ] =
37
 
{
38
 
    Q0, Q0, Q0, Q1, Q1, Q1, Q2, Q2, Q2,
39
 
    Q0, Q0, Q0, Q1, Q1, Q1, Q2, Q2, Q2,
40
 
    Q0, Q0, Q0, Q1, Q1, Q1, Q2, Q2, Q2,
41
 
    0, 0, 0, 0, 0
42
 
};
43
 
static const float q_1_2[ 32 ] =
44
 
{
45
 
    Q0, Q1, Q2, Q0, Q1, Q2, Q0, Q1, Q2,
46
 
    Q0, Q1, Q2, Q0, Q1, Q2, Q0, Q1, Q2,
47
 
    Q0, Q1, Q2, Q0, Q1, Q2, Q0, Q1, Q2,
48
 
    0, 0, 0, 0, 0
49
 
};
50
 
#undef Q0
51
 
#undef Q1
52
 
#undef Q2
53
 
 
54
 
#define Q0 ((-4 << 15) / 5.0)
55
 
#define Q1 ((-2 << 15) / 5.0)
56
 
#define Q2 (0)
57
 
#define Q3 ((2 << 15) / 5.0)
58
 
#define Q4 ((4 << 15) / 5.0)
59
 
static const float q_2_0[ 128 ] =
60
 
{
61
 
    Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,Q0,
62
 
    Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,Q1,
63
 
    Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,Q2,
64
 
    Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,Q3,
65
 
    Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,Q4,
66
 
    0, 0, 0
67
 
};
68
 
static const float q_2_1[ 128 ] =
69
 
{
70
 
    Q0,Q0,Q0,Q0,Q0,Q1,Q1,Q1,Q1,Q1,Q2,Q2,Q2,Q2,Q2,Q3,Q3,Q3,Q3,Q3,Q4,Q4,Q4,Q4,Q4,
71
 
    Q0,Q0,Q0,Q0,Q0,Q1,Q1,Q1,Q1,Q1,Q2,Q2,Q2,Q2,Q2,Q3,Q3,Q3,Q3,Q3,Q4,Q4,Q4,Q4,Q4,
72
 
    Q0,Q0,Q0,Q0,Q0,Q1,Q1,Q1,Q1,Q1,Q2,Q2,Q2,Q2,Q2,Q3,Q3,Q3,Q3,Q3,Q4,Q4,Q4,Q4,Q4,
73
 
    Q0,Q0,Q0,Q0,Q0,Q1,Q1,Q1,Q1,Q1,Q2,Q2,Q2,Q2,Q2,Q3,Q3,Q3,Q3,Q3,Q4,Q4,Q4,Q4,Q4,
74
 
    Q0,Q0,Q0,Q0,Q0,Q1,Q1,Q1,Q1,Q1,Q2,Q2,Q2,Q2,Q2,Q3,Q3,Q3,Q3,Q3,Q4,Q4,Q4,Q4,Q4,
75
 
    0, 0, 0
76
 
};
77
 
static const float q_2_2[ 128 ] =
78
 
{
79
 
    Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,
80
 
    Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,
81
 
    Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,
82
 
    Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,
83
 
    Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,Q0,Q1,Q2,Q3,Q4,
84
 
    0, 0, 0
85
 
};
86
 
#undef Q0
87
 
#undef Q1
88
 
#undef Q2
89
 
#undef Q3
90
 
#undef Q4
91
 
 
92
 
#define Q0 ((-10 << 15) / 11.0)
93
 
#define Q1 ((-8 << 15) / 11.0)
94
 
#define Q2 ((-6 << 15) / 11.0)
95
 
#define Q3 ((-4 << 15) / 11.0)
96
 
#define Q4 ((-2 << 15) / 11.0)
97
 
#define Q5 (0)
98
 
#define Q6 ((2 << 15) / 11.0)
99
 
#define Q7 ((4 << 15) / 11.0)
100
 
#define Q8 ((6 << 15) / 11.0)
101
 
#define Q9 ((8 << 15) / 11.0)
102
 
#define QA ((10 << 15) / 11.0)
103
 
static const float q_4_0[ 128 ] =
104
 
{
105
 
    Q0, Q0, Q0, Q0, Q0, Q0, Q0, Q0, Q0, Q0, Q0,
106
 
    Q1, Q1, Q1, Q1, Q1, Q1, Q1, Q1, Q1, Q1, Q1,
107
 
    Q2, Q2, Q2, Q2, Q2, Q2, Q2, Q2, Q2, Q2, Q2,
108
 
    Q3, Q3, Q3, Q3, Q3, Q3, Q3, Q3, Q3, Q3, Q3,
109
 
    Q4, Q4, Q4, Q4, Q4, Q4, Q4, Q4, Q4, Q4, Q4,
110
 
    Q5, Q5, Q5, Q5, Q5, Q5, Q5, Q5, Q5, Q5, Q5,
111
 
    Q6, Q6, Q6, Q6, Q6, Q6, Q6, Q6, Q6, Q6, Q6,
112
 
    Q7, Q7, Q7, Q7, Q7, Q7, Q7, Q7, Q7, Q7, Q7,
113
 
    Q8, Q8, Q8, Q8, Q8, Q8, Q8, Q8, Q8, Q8, Q8,
114
 
    Q9, Q9, Q9, Q9, Q9, Q9, Q9, Q9, Q9, Q9, Q9,
115
 
    QA, QA, QA, QA, QA, QA, QA, QA, QA, QA, QA,
116
 
    0,  0,  0,  0,  0,  0,  0
117
 
};
118
 
static const float q_4_1[ 128 ] =
119
 
{
120
 
    Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, QA,
121
 
    Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, QA,
122
 
    Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, QA,
123
 
    Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, QA,
124
 
    Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, QA,
125
 
    Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, QA,
126
 
    Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, QA,
127
 
    Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, QA,
128
 
    Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, QA,
129
 
    Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, QA,
130
 
    Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, QA,
131
 
    0,  0,  0,  0,  0,  0,  0
132
 
};
133
 
#undef Q0
134
 
#undef Q1
135
 
#undef Q2
136
 
#undef Q3
137
 
#undef Q4
138
 
#undef Q5
139
 
#undef Q6
140
 
#undef Q7
141
 
#undef Q8
142
 
#undef Q9
143
 
#undef QA
144
 
 
145
 
/* Lookup tables of 0.16 two's complement quantization values */
146
 
 
147
 
static const float q_3[8] =
148
 
{
149
 
    (-6 << 15)/7.0, (-4 << 15)/7.0, (-2 << 15)/7.0,
150
 
    0           , (2 << 15)/7.0, (4 << 15)/7.0,
151
 
    (6 << 15)/7.0, 0
152
 
};
153
 
 
154
 
static const float q_5[16] =
155
 
{
156
 
    (-14 << 15)/15.0, (-12 << 15)/15.0, (-10 << 15)/15.0,
157
 
    (-8 << 15)/15.0,  (-6 << 15)/15.0,  (-4 << 15)/15.0,
158
 
    (-2 << 15)/15.0,  0            ,    (2 << 15)/15.0,
159
 
    (4 << 15)/15.0,   (6 << 15)/15.0,   (8 << 15)/15.0,
160
 
    (10 << 15)/15.0,  (12 << 15)/15.0,  (14 << 15)/15.0,
161
 
    0
162
 
};
163
 
 
164
 
/* Conversion from bap to number of bits in the mantissas
165
 
 * zeros account for cases 0,1,2,4 which are special cased */
166
 
static const u16 qnttztab[16] =
167
 
{
168
 
    0, 0, 0, 3, 0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 16
169
 
};
170
 
 
171
 
static const float scale_factor[25] =
172
 
{
173
 
    6.10351562500000000000000000e-05,
174
 
    3.05175781250000000000000000e-05,
175
 
    1.52587890625000000000000000e-05,
176
 
    7.62939453125000000000000000e-06,
177
 
    3.81469726562500000000000000e-06,
178
 
    1.90734863281250000000000000e-06,
179
 
    9.53674316406250000000000000e-07,
180
 
    4.76837158203125000000000000e-07,
181
 
    2.38418579101562500000000000e-07,
182
 
    1.19209289550781250000000000e-07,
183
 
    5.96046447753906250000000000e-08,
184
 
    2.98023223876953125000000000e-08,
185
 
    1.49011611938476562500000000e-08,
186
 
    7.45058059692382812500000000e-09,
187
 
    3.72529029846191406250000000e-09,
188
 
    1.86264514923095703125000000e-09,
189
 
    9.31322574615478515625000000e-10,
190
 
    4.65661287307739257812500000e-10,
191
 
    2.32830643653869628906250000e-10,
192
 
    1.16415321826934814453125000e-10,
193
 
    5.82076609134674072265625000e-11,
194
 
    2.91038304567337036132812500e-11,
195
 
    1.45519152283668518066406250e-11,
196
 
    7.27595761418342590332031250e-12,
197
 
    3.63797880709171295166015625e-12,
198
 
};
199
 
 
200
 
static const u16 dither_lut[256] =
201
 
{
202
 
 0x0000, 0xa011, 0xe033, 0x4022, 0x6077, 0xc066, 0x8044, 0x2055,
203
 
 0xc0ee, 0x60ff, 0x20dd, 0x80cc, 0xa099, 0x0088, 0x40aa, 0xe0bb,
204
 
 0x21cd, 0x81dc, 0xc1fe, 0x61ef, 0x41ba, 0xe1ab, 0xa189, 0x0198,
205
 
 0xe123, 0x4132, 0x0110, 0xa101, 0x8154, 0x2145, 0x6167, 0xc176,
206
 
 0x439a, 0xe38b, 0xa3a9, 0x03b8, 0x23ed, 0x83fc, 0xc3de, 0x63cf,
207
 
 0x8374, 0x2365, 0x6347, 0xc356, 0xe303, 0x4312, 0x0330, 0xa321,
208
 
 0x6257, 0xc246, 0x8264, 0x2275, 0x0220, 0xa231, 0xe213, 0x4202,
209
 
 0xa2b9, 0x02a8, 0x428a, 0xe29b, 0xc2ce, 0x62df, 0x22fd, 0x82ec,
210
 
 0x8734, 0x2725, 0x6707, 0xc716, 0xe743, 0x4752, 0x0770, 0xa761,
211
 
 0x47da, 0xe7cb, 0xa7e9, 0x07f8, 0x27ad, 0x87bc, 0xc79e, 0x678f,
212
 
 0xa6f9, 0x06e8, 0x46ca, 0xe6db, 0xc68e, 0x669f, 0x26bd, 0x86ac,
213
 
 0x6617, 0xc606, 0x8624, 0x2635, 0x0660, 0xa671, 0xe653, 0x4642,
214
 
 0xc4ae, 0x64bf, 0x249d, 0x848c, 0xa4d9, 0x04c8, 0x44ea, 0xe4fb,
215
 
 0x0440, 0xa451, 0xe473, 0x4462, 0x6437, 0xc426, 0x8404, 0x2415,
216
 
 0xe563, 0x4572, 0x0550, 0xa541, 0x8514, 0x2505, 0x6527, 0xc536,
217
 
 0x258d, 0x859c, 0xc5be, 0x65af, 0x45fa, 0xe5eb, 0xa5c9, 0x05d8,
218
 
 0xae79, 0x0e68, 0x4e4a, 0xee5b, 0xce0e, 0x6e1f, 0x2e3d, 0x8e2c,
219
 
 0x6e97, 0xce86, 0x8ea4, 0x2eb5, 0x0ee0, 0xaef1, 0xeed3, 0x4ec2,
220
 
 0x8fb4, 0x2fa5, 0x6f87, 0xcf96, 0xefc3, 0x4fd2, 0x0ff0, 0xafe1,
221
 
 0x4f5a, 0xef4b, 0xaf69, 0x0f78, 0x2f2d, 0x8f3c, 0xcf1e, 0x6f0f,
222
 
 0xede3, 0x4df2, 0x0dd0, 0xadc1, 0x8d94, 0x2d85, 0x6da7, 0xcdb6,
223
 
 0x2d0d, 0x8d1c, 0xcd3e, 0x6d2f, 0x4d7a, 0xed6b, 0xad49, 0x0d58,
224
 
 0xcc2e, 0x6c3f, 0x2c1d, 0x8c0c, 0xac59, 0x0c48, 0x4c6a, 0xec7b,
225
 
 0x0cc0, 0xacd1, 0xecf3, 0x4ce2, 0x6cb7, 0xcca6, 0x8c84, 0x2c95,
226
 
 0x294d, 0x895c, 0xc97e, 0x696f, 0x493a, 0xe92b, 0xa909, 0x0918,
227
 
 0xe9a3, 0x49b2, 0x0990, 0xa981, 0x89d4, 0x29c5, 0x69e7, 0xc9f6,
228
 
 0x0880, 0xa891, 0xe8b3, 0x48a2, 0x68f7, 0xc8e6, 0x88c4, 0x28d5,
229
 
 0xc86e, 0x687f, 0x285d, 0x884c, 0xa819, 0x0808, 0x482a, 0xe83b,
230
 
 0x6ad7, 0xcac6, 0x8ae4, 0x2af5, 0x0aa0, 0xaab1, 0xea93, 0x4a82,
231
 
 0xaa39, 0x0a28, 0x4a0a, 0xea1b, 0xca4e, 0x6a5f, 0x2a7d, 0x8a6c,
232
 
 0x4b1a, 0xeb0b, 0xab29, 0x0b38, 0x2b6d, 0x8b7c, 0xcb5e, 0x6b4f,
233
 
 0x8bf4, 0x2be5, 0x6bc7, 0xcbd6, 0xeb83, 0x4b92, 0x0bb0, 0xaba1
234
 
};
235
 
 
236
 
static __inline__ u16 dither_gen (mantissa_t * p_mantissa)
237
 
{
238
 
        s16 state;
239
 
 
240
 
        state = dither_lut[p_mantissa->lfsr_state >> 8] ^ 
241
 
                    (p_mantissa->lfsr_state << 8);
242
 
        p_mantissa->lfsr_state = (u16) state;
243
 
        return ( (state * (s32) (0.707106 * 256.0)) >> 8 );
244
 
}
245
 
 
246
 
 
247
 
/* Fetch an unpacked, left justified, and properly biased/dithered mantissa value */
248
 
static __inline__ float coeff_get_float (ac3dec_t * p_ac3dec, u16 bap, u16 dithflag,
249
 
                                   u16 exp)
250
 
{
251
 
    u16 group_code = 0;
252
 
 
253
 
    /* If the bap is 0-5 then we have special cases to take care of */
254
 
    switch (bap)
255
 
    {
256
 
        case 0:
257
 
            if (dithflag)
258
 
            {
259
 
                return ( dither_gen(&p_ac3dec->mantissa) * scale_factor[exp] );
260
 
            }    
261
 
            return (0);
262
 
 
263
 
        case 1:
264
 
            if (p_ac3dec->mantissa.q_1_pointer >= 0)
265
 
            {
266
 
                return (p_ac3dec->mantissa.q_1[p_ac3dec->mantissa.q_1_pointer--] *
267
 
                        scale_factor[exp]);
268
 
            }
269
 
 
270
 
            p_ac3dec->total_bits_read += 5;
271
 
            if ((group_code = GetBits (&p_ac3dec->bit_stream,5)) > 26)
272
 
            {
273
 
                intf_WarnMsg ( 3, "ac3dec warn: invalid mantissa (1)" );
274
 
                return 0;
275
 
            }
276
 
    
277
 
            p_ac3dec->mantissa.q_1[ 1 ] = q_1_1[ group_code ];
278
 
            p_ac3dec->mantissa.q_1[ 0 ] = q_1_2[ group_code ];
279
 
    
280
 
            p_ac3dec->mantissa.q_1_pointer = 1;
281
 
    
282
 
            return (q_1_0[group_code] * scale_factor[exp]);
283
 
    
284
 
        case 2:
285
 
            if (p_ac3dec->mantissa.q_2_pointer >= 0)
286
 
            {
287
 
                return (p_ac3dec->mantissa.q_2[p_ac3dec->mantissa.q_2_pointer--] *
288
 
                        scale_factor[exp]);
289
 
            }
290
 
            
291
 
            p_ac3dec->total_bits_read += 7;
292
 
            if ((group_code = GetBits (&p_ac3dec->bit_stream,7)) > 124)
293
 
            {
294
 
                intf_WarnMsg ( 3, "ac3dec warn: invalid mantissa (2)" );
295
 
                return 0;
296
 
            }
297
 
 
298
 
            p_ac3dec->mantissa.q_2[ 1 ] = q_2_1[ group_code ];
299
 
            p_ac3dec->mantissa.q_2[ 0 ] = q_2_2[ group_code ];
300
 
 
301
 
            p_ac3dec->mantissa.q_2_pointer = 1;
302
 
 
303
 
            return (q_2_0[group_code] * scale_factor[exp]);
304
 
 
305
 
        case 3:
306
 
            p_ac3dec->total_bits_read += 3;
307
 
            if ((group_code = GetBits (&p_ac3dec->bit_stream,3)) > 6)
308
 
            {
309
 
                intf_WarnMsg ( 3, "ac3dec warn: invalid mantissa (3)" );
310
 
                return 0;
311
 
            }
312
 
 
313
 
            return (q_3[group_code] * scale_factor[exp]);
314
 
 
315
 
        case 4:
316
 
            if (p_ac3dec->mantissa.q_4_pointer >= 0)
317
 
            {
318
 
                return (p_ac3dec->mantissa.q_4[p_ac3dec->mantissa.q_4_pointer--] *
319
 
                        scale_factor[exp]);
320
 
            }
321
 
 
322
 
            p_ac3dec->total_bits_read += 7;
323
 
            if ((group_code = GetBits (&p_ac3dec->bit_stream,7)) > 120)
324
 
            {
325
 
                intf_WarnMsg ( 3, "ac3dec warn: invalid mantissa (4)" );
326
 
                return 0;
327
 
            }
328
 
 
329
 
            p_ac3dec->mantissa.q_4[ 0 ] = q_4_1[group_code];
330
 
 
331
 
            p_ac3dec->mantissa.q_4_pointer = 0;
332
 
 
333
 
            return (q_4_0[group_code] * scale_factor[exp]);
334
 
 
335
 
        case 5:
336
 
            p_ac3dec->total_bits_read += 4;
337
 
            if ((group_code = GetBits (&p_ac3dec->bit_stream,4)) > 14)
338
 
            {
339
 
                intf_WarnMsg ( 3, "ac3dec warn: invalid mantissa (5)" );
340
 
                return 0;
341
 
            }
342
 
 
343
 
            return (q_5[group_code] * scale_factor[exp]);
344
 
 
345
 
        default:
346
 
            group_code = GetBits (&p_ac3dec->bit_stream,qnttztab[bap]);
347
 
            group_code <<= 16 - qnttztab[bap];
348
 
            p_ac3dec->total_bits_read += qnttztab[bap];
349
 
 
350
 
            return ((s16)(group_code) * scale_factor[exp]);
351
 
    }
352
 
}
353
 
 
354
 
/* Uncouple the coupling channel into a fbw channel */
355
 
static __inline__ void uncouple_channel (ac3dec_t * p_ac3dec, u32 ch)
356
 
{
357
 
    u32 bnd = 0;
358
 
    u32 sub_bnd = 0;
359
 
    u32 i,j;
360
 
    float cpl_coord = 1.0;
361
 
    u32 cpl_exp_tmp;
362
 
    u32 cpl_mant_tmp;
363
 
 
364
 
    for (i = p_ac3dec->audblk.cplstrtmant; i < p_ac3dec->audblk.cplendmant;)
365
 
    {
366
 
        if (!p_ac3dec->audblk.cplbndstrc[sub_bnd++])
367
 
        {
368
 
            cpl_exp_tmp = p_ac3dec->audblk.cplcoexp[ch][bnd] +
369
 
                3 * p_ac3dec->audblk.mstrcplco[ch];
370
 
            if (p_ac3dec->audblk.cplcoexp[ch][bnd] == 15)
371
 
            {
372
 
                cpl_mant_tmp = (p_ac3dec->audblk.cplcomant[ch][bnd]) << 11;
373
 
            }
374
 
            else
375
 
            {
376
 
                cpl_mant_tmp = ((0x10) | p_ac3dec->audblk.cplcomant[ch][bnd]) << 10;
377
 
            }
378
 
            cpl_coord = (cpl_mant_tmp) * scale_factor[cpl_exp_tmp] * 8.0f;
379
 
 
380
 
            /* Invert the phase for the right channel if necessary */
381
 
            if (p_ac3dec->bsi.acmod == 0x02 && p_ac3dec->audblk.phsflginu &&
382
 
                    ch == 1 && p_ac3dec->audblk.phsflg[bnd])
383
 
            {
384
 
                cpl_coord *= -1;
385
 
            }
386
 
            bnd++;
387
 
        }
388
 
 
389
 
        for (j=0;j < 12; j++)
390
 
        {
391
 
            /* Get new dither values for each channel if necessary,
392
 
             * so the channels are uncorrelated */
393
 
            if (p_ac3dec->audblk.dithflag[ch] && !p_ac3dec->audblk.cpl_bap[i])
394
 
            {
395
 
                *(p_ac3dec->samples+ch*256+i) = cpl_coord * dither_gen(&p_ac3dec->mantissa) *
396
 
                    scale_factor[p_ac3dec->audblk.cpl_exp[i]];
397
 
            } else {
398
 
                *(p_ac3dec->samples+ch*256+i) = cpl_coord * p_ac3dec->audblk.cpl_flt[i];
399
 
            }
400
 
            i++;
401
 
        }
402
 
    }
403
 
}
404