path: root/audio_codec/libmad/layer3.c (plain)
blob: fc4b0fbdd6f8ac21d7073030a8276ba8386aa6f8

1	/*
2	* libmad - MPEG audio decoder library
3	* Copyright (C) 2000-2004 Underbit Technologies, Inc.
4	*
5	* This program is free software; you can redistribute it and/or modify
6	* it under the terms of the GNU General Public License as published by
7	* the Free Software Foundation; either version 2 of the License, or
8	* (at your option) any later version.
9	*
10	* This program is distributed in the hope that it will be useful,
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	* GNU General Public License for more details.
14	*
15	* You should have received a copy of the GNU General Public License
16	* along with this program; if not, write to the Free Software
17	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18	*
19	* $Id: layer3.c,v 1.43 2004/01/23 09:41:32 rob Exp $
20	*/
21
22	# ifdef HAVE_CONFIG_H
23	# include "config.h"
24	# endif
25
26	# include "global.h"
27
28	# include <stdlib.h>
29	# include <string.h>
30
31	# ifdef HAVE_ASSERT_H
32	# include <assert.h>
33	# endif
34
35	# ifdef HAVE_LIMITS_H
36	# include <limits.h>
37	# else
38	# define CHAR_BIT 8
39	# endif
40
41	# include "fixed.h"
42	# include "bit.h"
43	# include "stream.h"
44	# include "frame.h"
45	# include "huffman.h"
46	# include "layer3.h"
47
48	/* --- Layer III ----------------------------------------------------------- */
49
50	enum {
51	count1table_select = 0x01,
52	scalefac_scale = 0x02,
53	preflag = 0x04,
54	mixed_block_flag = 0x08
55	};
56
57	enum {
58	I_STEREO = 0x1,
59	MS_STEREO = 0x2
60	};
61
62	struct sideinfo {
63	unsigned int main_data_begin;
64	unsigned int private_bits;
65
66	unsigned char scfsi[2];
67
68	struct granule {
69	struct channel {
70	/* from side info */
71	unsigned short part2_3_length;
72	unsigned short big_values;
73	unsigned short global_gain;
74	unsigned short scalefac_compress;
75
76	unsigned char flags;
77	unsigned char block_type;
78	unsigned char table_select[3];
79	unsigned char subblock_gain[3];
80	unsigned char region0_count;
81	unsigned char region1_count;
82
83	/* from main_data */
84	unsigned char scalefac[39]; /* scalefac_l and/or scalefac_s */
85	} ch[2];
86	} gr[2];
87	};
88
89	/*
90	* scalefactor bit lengths
91	* derived from section 2.4.2.7 of ISO/IEC 11172-3
92	*/
93	static
94	struct {
95	unsigned char slen1;
96	unsigned char slen2;
97	} const sflen_table[16] = {
98	{ 0, 0 }, { 0, 1 }, { 0, 2 }, { 0, 3 },
99	{ 3, 0 }, { 1, 1 }, { 1, 2 }, { 1, 3 },
100	{ 2, 1 }, { 2, 2 }, { 2, 3 }, { 3, 1 },
101	{ 3, 2 }, { 3, 3 }, { 4, 2 }, { 4, 3 }
102	};
103
104	/*
105	* number of LSF scalefactor band values
106	* derived from section 2.4.3.2 of ISO/IEC 13818-3
107	*/
108	static
109	unsigned char const nsfb_table[6][3][4] = {
110	{ { 6, 5, 5, 5 },
111	{ 9, 9, 9, 9 },
112	{ 6, 9, 9, 9 }
113	},
114
115	{ { 6, 5, 7, 3 },
116	{ 9, 9, 12, 6 },
117	{ 6, 9, 12, 6 }
118	},
119
120	{ { 11, 10, 0, 0 },
121	{ 18, 18, 0, 0 },
122	{ 15, 18, 0, 0 }
123	},
124
125	{ { 7, 7, 7, 0 },
126	{ 12, 12, 12, 0 },
127	{ 6, 15, 12, 0 }
128	},
129
130	{ { 6, 6, 6, 3 },
131	{ 12, 9, 9, 6 },
132	{ 6, 12, 9, 6 }
133	},
134
135	{ { 8, 8, 5, 0 },
136	{ 15, 12, 9, 0 },
137	{ 6, 18, 9, 0 }
138	}
139	};
140
141	/*
142	* MPEG-1 scalefactor band widths
143	* derived from Table B.8 of ISO/IEC 11172-3
144	*/
145	static
146	unsigned char const sfb_48000_long[] = {
147	4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 10,
148	12, 16, 18, 22, 28, 34, 40, 46, 54, 54, 192
149	};
150
151	static
152	unsigned char const sfb_44100_long[] = {
153	4, 4, 4, 4, 4, 4, 6, 6, 8, 8, 10,
154	12, 16, 20, 24, 28, 34, 42, 50, 54, 76, 158
155	};
156
157	static
158	unsigned char const sfb_32000_long[] = {
159	4, 4, 4, 4, 4, 4, 6, 6, 8, 10, 12,
160	16, 20, 24, 30, 38, 46, 56, 68, 84, 102, 26
161	};
162
163	static
164	unsigned char const sfb_48000_short[] = {
165	4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6,
166	6, 6, 6, 6, 6, 10, 10, 10, 12, 12, 12, 14, 14,
167	14, 16, 16, 16, 20, 20, 20, 26, 26, 26, 66, 66, 66
168	};
169
170	static
171	unsigned char const sfb_44100_short[] = {
172	4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6,
173	6, 6, 8, 8, 8, 10, 10, 10, 12, 12, 12, 14, 14,
174	14, 18, 18, 18, 22, 22, 22, 30, 30, 30, 56, 56, 56
175	};
176
177	static
178	unsigned char const sfb_32000_short[] = {
179	4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6,
180	6, 6, 8, 8, 8, 12, 12, 12, 16, 16, 16, 20, 20,
181	20, 26, 26, 26, 34, 34, 34, 42, 42, 42, 12, 12, 12
182	};
183
184	static
185	unsigned char const sfb_48000_mixed[] = {
186	/* long */ 4, 4, 4, 4, 4, 4, 6, 6,
187	/* short */ 4, 4, 4, 6, 6, 6, 6, 6, 6, 10,
188	10, 10, 12, 12, 12, 14, 14, 14, 16, 16,
189	16, 20, 20, 20, 26, 26, 26, 66, 66, 66
190	};
191
192	static
193	unsigned char const sfb_44100_mixed[] = {
194	/* long */ 4, 4, 4, 4, 4, 4, 6, 6,
195	/* short */ 4, 4, 4, 6, 6, 6, 8, 8, 8, 10,
196	10, 10, 12, 12, 12, 14, 14, 14, 18, 18,
197	18, 22, 22, 22, 30, 30, 30, 56, 56, 56
198	};
199
200	static
201	unsigned char const sfb_32000_mixed[] = {
202	/* long */ 4, 4, 4, 4, 4, 4, 6, 6,
203	/* short */ 4, 4, 4, 6, 6, 6, 8, 8, 8, 12,
204	12, 12, 16, 16, 16, 20, 20, 20, 26, 26,
205	26, 34, 34, 34, 42, 42, 42, 12, 12, 12
206	};
207
208	/*
209	* MPEG-2 scalefactor band widths
210	* derived from Table B.2 of ISO/IEC 13818-3
211	*/
212	static
213	unsigned char const sfb_24000_long[] = {
214	6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16,
215	18, 22, 26, 32, 38, 46, 54, 62, 70, 76, 36
216	};
217
218	static
219	unsigned char const sfb_22050_long[] = {
220	6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16,
221	20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54
222	};
223
224	# define sfb_16000_long sfb_22050_long
225
226	static
227	unsigned char const sfb_24000_short[] = {
228	4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 8,
229	8, 8, 10, 10, 10, 12, 12, 12, 14, 14, 14, 18, 18,
230	18, 24, 24, 24, 32, 32, 32, 44, 44, 44, 12, 12, 12
231	};
232
233	static
234	unsigned char const sfb_22050_short[] = {
235	4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 6,
236	6, 6, 8, 8, 8, 10, 10, 10, 14, 14, 14, 18, 18,
237	18, 26, 26, 26, 32, 32, 32, 42, 42, 42, 18, 18, 18
238	};
239
240	static
241	unsigned char const sfb_16000_short[] = {
242	4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 8,
243	8, 8, 10, 10, 10, 12, 12, 12, 14, 14, 14, 18, 18,
244	18, 24, 24, 24, 30, 30, 30, 40, 40, 40, 18, 18, 18
245	};
246
247	static
248	unsigned char const sfb_24000_mixed[] = {
249	/* long */ 6, 6, 6, 6, 6, 6,
250	/* short */ 6, 6, 6, 8, 8, 8, 10, 10, 10, 12,
251	12, 12, 14, 14, 14, 18, 18, 18, 24, 24,
252	24, 32, 32, 32, 44, 44, 44, 12, 12, 12
253	};
254
255	static
256	unsigned char const sfb_22050_mixed[] = {
257	/* long */ 6, 6, 6, 6, 6, 6,
258	/* short */ 6, 6, 6, 6, 6, 6, 8, 8, 8, 10,
259	10, 10, 14, 14, 14, 18, 18, 18, 26, 26,
260	26, 32, 32, 32, 42, 42, 42, 18, 18, 18
261	};
262
263	static
264	unsigned char const sfb_16000_mixed[] = {
265	/* long */ 6, 6, 6, 6, 6, 6,
266	/* short */ 6, 6, 6, 8, 8, 8, 10, 10, 10, 12,
267	12, 12, 14, 14, 14, 18, 18, 18, 24, 24,
268	24, 30, 30, 30, 40, 40, 40, 18, 18, 18
269	};
270
271	/*
272	* MPEG 2.5 scalefactor band widths
273	* derived from public sources
274	*/
275	# define sfb_12000_long sfb_16000_long
276	# define sfb_11025_long sfb_12000_long
277
278	static
279	unsigned char const sfb_8000_long[] = {
280	12, 12, 12, 12, 12, 12, 16, 20, 24, 28, 32,
281	40, 48, 56, 64, 76, 90, 2, 2, 2, 2, 2
282	};
283
284	# define sfb_12000_short sfb_16000_short
285	# define sfb_11025_short sfb_12000_short
286
287	static
288	unsigned char const sfb_8000_short[] = {
289	8, 8, 8, 8, 8, 8, 8, 8, 8, 12, 12, 12, 16,
290	16, 16, 20, 20, 20, 24, 24, 24, 28, 28, 28, 36, 36,
291	36, 2, 2, 2, 2, 2, 2, 2, 2, 2, 26, 26, 26
292	};
293
294	# define sfb_12000_mixed sfb_16000_mixed
295	# define sfb_11025_mixed sfb_12000_mixed
296
297	/* the 8000 Hz short block scalefactor bands do not break after
298	the first 36 frequency lines, so this is probably wrong */
299	static
300	unsigned char const sfb_8000_mixed[] = {
301	/* long */ 12, 12, 12,
302	/* short */ 4, 4, 4, 8, 8, 8, 12, 12, 12, 16, 16, 16,
303	20, 20, 20, 24, 24, 24, 28, 28, 28, 36, 36, 36,
304	2, 2, 2, 2, 2, 2, 2, 2, 2, 26, 26, 26
305	};
306
307	static
308	struct {
309	unsigned char const *l;
310	unsigned char const *s;
311	unsigned char const *m;
312	} const sfbwidth_table[9] = {
313	{ sfb_48000_long, sfb_48000_short, sfb_48000_mixed },
314	{ sfb_44100_long, sfb_44100_short, sfb_44100_mixed },
315	{ sfb_32000_long, sfb_32000_short, sfb_32000_mixed },
316	{ sfb_24000_long, sfb_24000_short, sfb_24000_mixed },
317	{ sfb_22050_long, sfb_22050_short, sfb_22050_mixed },
318	{ sfb_16000_long, sfb_16000_short, sfb_16000_mixed },
319	{ sfb_12000_long, sfb_12000_short, sfb_12000_mixed },
320	{ sfb_11025_long, sfb_11025_short, sfb_11025_mixed },
321	{ sfb_8000_long, sfb_8000_short, sfb_8000_mixed }
322	};
323
324	/*
325	* scalefactor band preemphasis (used only when preflag is set)
326	* derived from Table B.6 of ISO/IEC 11172-3
327	*/
328	static
329	unsigned char const pretab[22] = {
330	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 2, 0
331	};
332
333	/*
334	* table for requantization
335	*
336	* rq_table[x].mantissa * 2^(rq_table[x].exponent) = x^(4/3)
337	*/
338	static
339	struct fixedfloat {
340	unsigned long mantissa : 27;
341	unsigned short exponent : 5;
342	} const rq_table[8207] = {
343	# include "rq_table.dat"
344	};
345
346	/*
347	* fractional powers of two
348	* used for requantization and joint stereo decoding
349	*
350	* root_table[3 + x] = 2^(x/4)
351	*/
352	static
353	mad_fixed_t const root_table[7] = {
354	MAD_F(0x09837f05) /* 2^(-3/4) == 0.59460355750136 */,
355	MAD_F(0x0b504f33) /* 2^(-2/4) == 0.70710678118655 */,
356	MAD_F(0x0d744fcd) /* 2^(-1/4) == 0.84089641525371 */,
357	MAD_F(0x10000000) /* 2^( 0/4) == 1.00000000000000 */,
358	MAD_F(0x1306fe0a) /* 2^(+1/4) == 1.18920711500272 */,
359	MAD_F(0x16a09e66) /* 2^(+2/4) == 1.41421356237310 */,
360	MAD_F(0x1ae89f99) /* 2^(+3/4) == 1.68179283050743 */
361	};
362
363	/*
364	* coefficients for aliasing reduction
365	* derived from Table B.9 of ISO/IEC 11172-3
366	*
367	* c[] = { -0.6, -0.535, -0.33, -0.185, -0.095, -0.041, -0.0142, -0.0037 }
368	* cs[i] = 1 / sqrt(1 + c[i]^2)
369	* ca[i] = c[i] / sqrt(1 + c[i]^2)
370	*/
371	static
372	mad_fixed_t const cs[8] = {
373	+MAD_F(0x0db84a81) /* +0.857492926 */, +MAD_F(0x0e1b9d7f) /* +0.881741997 */,
374	+MAD_F(0x0f31adcf) /* +0.949628649 */, +MAD_F(0x0fbba815) /* +0.983314592 */,
375	+MAD_F(0x0feda417) /* +0.995517816 */, +MAD_F(0x0ffc8fc8) /* +0.999160558 */,
376	+MAD_F(0x0fff964c) /* +0.999899195 */, +MAD_F(0x0ffff8d3) /* +0.999993155 */
377	};
378
379	static
380	mad_fixed_t const ca[8] = {
381	-MAD_F(0x083b5fe7) /* -0.514495755 */, -MAD_F(0x078c36d2) /* -0.471731969 */,
382	-MAD_F(0x05039814) /* -0.313377454 */, -MAD_F(0x02e91dd1) /* -0.181913200 */,
383	-MAD_F(0x0183603a) /* -0.094574193 */, -MAD_F(0x00a7cb87) /* -0.040965583 */,
384	-MAD_F(0x003a2847) /* -0.014198569 */, -MAD_F(0x000f27b4) /* -0.003699975 */
385	};
386
387	/*
388	* IMDCT coefficients for short blocks
389	* derived from section 2.4.3.4.10.2 of ISO/IEC 11172-3
390	*
391	* imdct_s[i/even][k] = cos((PI / 24) * (2 * (i / 2) + 7) * (2 * k + 1))
392	* imdct_s[i /odd][k] = cos((PI / 24) * (2 * (6 + (i-1)/2) + 7) * (2 * k + 1))
393	*/
394	static
395	mad_fixed_t const imdct_s[6][6] = {
396	# include "imdct_s.dat"
397	};
398
399	# if !defined(ASO_IMDCT)
400	/*
401	* windowing coefficients for long blocks
402	* derived from section 2.4.3.4.10.3 of ISO/IEC 11172-3
403	*
404	* window_l[i] = sin((PI / 36) * (i + 1/2))
405	*/
406	static
407	mad_fixed_t const window_l[36] = {
408	MAD_F(0x00b2aa3e) /* 0.043619387 */, MAD_F(0x0216a2a2) /* 0.130526192 */,
409	MAD_F(0x03768962) /* 0.216439614 */, MAD_F(0x04cfb0e2) /* 0.300705800 */,
410	MAD_F(0x061f78aa) /* 0.382683432 */, MAD_F(0x07635284) /* 0.461748613 */,
411	MAD_F(0x0898c779) /* 0.537299608 */, MAD_F(0x09bd7ca0) /* 0.608761429 */,
412	MAD_F(0x0acf37ad) /* 0.675590208 */, MAD_F(0x0bcbe352) /* 0.737277337 */,
413	MAD_F(0x0cb19346) /* 0.793353340 */, MAD_F(0x0d7e8807) /* 0.843391446 */,
414
415	MAD_F(0x0e313245) /* 0.887010833 */, MAD_F(0x0ec835e8) /* 0.923879533 */,
416	MAD_F(0x0f426cb5) /* 0.953716951 */, MAD_F(0x0f9ee890) /* 0.976296007 */,
417	MAD_F(0x0fdcf549) /* 0.991444861 */, MAD_F(0x0ffc19fd) /* 0.999048222 */,
418	MAD_F(0x0ffc19fd) /* 0.999048222 */, MAD_F(0x0fdcf549) /* 0.991444861 */,
419	MAD_F(0x0f9ee890) /* 0.976296007 */, MAD_F(0x0f426cb5) /* 0.953716951 */,
420	MAD_F(0x0ec835e8) /* 0.923879533 */, MAD_F(0x0e313245) /* 0.887010833 */,
421
422	MAD_F(0x0d7e8807) /* 0.843391446 */, MAD_F(0x0cb19346) /* 0.793353340 */,
423	MAD_F(0x0bcbe352) /* 0.737277337 */, MAD_F(0x0acf37ad) /* 0.675590208 */,
424	MAD_F(0x09bd7ca0) /* 0.608761429 */, MAD_F(0x0898c779) /* 0.537299608 */,
425	MAD_F(0x07635284) /* 0.461748613 */, MAD_F(0x061f78aa) /* 0.382683432 */,
426	MAD_F(0x04cfb0e2) /* 0.300705800 */, MAD_F(0x03768962) /* 0.216439614 */,
427	MAD_F(0x0216a2a2) /* 0.130526192 */, MAD_F(0x00b2aa3e) /* 0.043619387 */,
428	};
429	# endif /* ASO_IMDCT */
430
431	/*
432	* windowing coefficients for short blocks
433	* derived from section 2.4.3.4.10.3 of ISO/IEC 11172-3
434	*
435	* window_s[i] = sin((PI / 12) * (i + 1/2))
436	*/
437	static
438	mad_fixed_t const window_s[12] = {
439	MAD_F(0x0216a2a2) /* 0.130526192 */, MAD_F(0x061f78aa) /* 0.382683432 */,
440	MAD_F(0x09bd7ca0) /* 0.608761429 */, MAD_F(0x0cb19346) /* 0.793353340 */,
441	MAD_F(0x0ec835e8) /* 0.923879533 */, MAD_F(0x0fdcf549) /* 0.991444861 */,
442	MAD_F(0x0fdcf549) /* 0.991444861 */, MAD_F(0x0ec835e8) /* 0.923879533 */,
443	MAD_F(0x0cb19346) /* 0.793353340 */, MAD_F(0x09bd7ca0) /* 0.608761429 */,
444	MAD_F(0x061f78aa) /* 0.382683432 */, MAD_F(0x0216a2a2) /* 0.130526192 */,
445	};
446
447	/*
448	* coefficients for intensity stereo processing
449	* derived from section 2.4.3.4.9.3 of ISO/IEC 11172-3
450	*
451	* is_ratio[i] = tan(i * (PI / 12))
452	* is_table[i] = is_ratio[i] / (1 + is_ratio[i])
453	*/
454	static
455	mad_fixed_t const is_table[7] = {
456	MAD_F(0x00000000) /* 0.000000000 */,
457	MAD_F(0x0361962f) /* 0.211324865 */,
458	MAD_F(0x05db3d74) /* 0.366025404 */,
459	MAD_F(0x08000000) /* 0.500000000 */,
460	MAD_F(0x0a24c28c) /* 0.633974596 */,
461	MAD_F(0x0c9e69d1) /* 0.788675135 */,
462	MAD_F(0x10000000) /* 1.000000000 */
463	};
464
465	/*
466	* coefficients for LSF intensity stereo processing
467	* derived from section 2.4.3.2 of ISO/IEC 13818-3
468	*
469	* is_lsf_table[0][i] = (1 / sqrt(sqrt(2)))^(i + 1)
470	* is_lsf_table[1][i] = (1 / sqrt(2)) ^(i + 1)
471	*/
472	static
473	mad_fixed_t const is_lsf_table[2][15] = {
474	{
475	MAD_F(0x0d744fcd) /* 0.840896415 */,
476	MAD_F(0x0b504f33) /* 0.707106781 */,
477	MAD_F(0x09837f05) /* 0.594603558 */,
478	MAD_F(0x08000000) /* 0.500000000 */,
479	MAD_F(0x06ba27e6) /* 0.420448208 */,
480	MAD_F(0x05a8279a) /* 0.353553391 */,
481	MAD_F(0x04c1bf83) /* 0.297301779 */,
482	MAD_F(0x04000000) /* 0.250000000 */,
483	MAD_F(0x035d13f3) /* 0.210224104 */,
484	MAD_F(0x02d413cd) /* 0.176776695 */,
485	MAD_F(0x0260dfc1) /* 0.148650889 */,
486	MAD_F(0x02000000) /* 0.125000000 */,
487	MAD_F(0x01ae89fa) /* 0.105112052 */,
488	MAD_F(0x016a09e6) /* 0.088388348 */,
489	MAD_F(0x01306fe1) /* 0.074325445 */
490	}, {
491	MAD_F(0x0b504f33) /* 0.707106781 */,
492	MAD_F(0x08000000) /* 0.500000000 */,
493	MAD_F(0x05a8279a) /* 0.353553391 */,
494	MAD_F(0x04000000) /* 0.250000000 */,
495	MAD_F(0x02d413cd) /* 0.176776695 */,
496	MAD_F(0x02000000) /* 0.125000000 */,
497	MAD_F(0x016a09e6) /* 0.088388348 */,
498	MAD_F(0x01000000) /* 0.062500000 */,
499	MAD_F(0x00b504f3) /* 0.044194174 */,
500	MAD_F(0x00800000) /* 0.031250000 */,
501	MAD_F(0x005a827a) /* 0.022097087 */,
502	MAD_F(0x00400000) /* 0.015625000 */,
503	MAD_F(0x002d413d) /* 0.011048543 */,
504	MAD_F(0x00200000) /* 0.007812500 */,
505	MAD_F(0x0016a09e) /* 0.005524272 */
506	}
507	};
508
509	/*
510	* NAME: III_sideinfo()
511	* DESCRIPTION: decode frame side information from a bitstream
512	*/
513	static
514	enum mad_error III_sideinfo(struct mad_bitptr *ptr, unsigned int nch,
515	int lsf, struct sideinfo *si,
516	unsigned int *data_bitlen,
517	unsigned int *priv_bitlen)
518	{
519	unsigned int ngr, gr, ch, i;
520	enum mad_error result = MAD_ERROR_NONE;
521
522	*data_bitlen = 0;
523	*priv_bitlen = lsf ? ((nch == 1) ? 1 : 2) : ((nch == 1) ? 5 : 3);
524
525	si->main_data_begin = mad_bit_read(ptr, lsf ? 8 : 9);
526	si->private_bits = mad_bit_read(ptr, *priv_bitlen);
527
528	ngr = 1;
529	if (!lsf) {
530	ngr = 2;
531
532	for (ch = 0; ch < nch; ++ch) {
533	si->scfsi[ch] = mad_bit_read(ptr, 4);
534	}
535	}
536
537	for (gr = 0; gr < ngr; ++gr) {
538	struct granule *granule = &si->gr[gr];
539
540	for (ch = 0; ch < nch; ++ch) {
541	struct channel *channel = &granule->ch[ch];
542
543	channel->part2_3_length = mad_bit_read(ptr, 12);
544	channel->big_values = mad_bit_read(ptr, 9);
545	channel->global_gain = mad_bit_read(ptr, 8);
546	channel->scalefac_compress = mad_bit_read(ptr, lsf ? 9 : 4);
547
548	*data_bitlen += channel->part2_3_length;
549
550	if (channel->big_values > 288 && result == 0) {
551	result = MAD_ERROR_BADBIGVALUES;
552	}
553
554	channel->flags = 0;
555
556	/* window_switching_flag */
557	if (mad_bit_read(ptr, 1)) {
558	channel->block_type = mad_bit_read(ptr, 2);
559
560	if (channel->block_type == 0 && result == 0) {
561	result = MAD_ERROR_BADBLOCKTYPE;
562	}
563
564	if (!lsf && channel->block_type == 2 && si->scfsi[ch] && result == 0) {
565	result = MAD_ERROR_BADSCFSI;
566	}
567
568	channel->region0_count = 7;
569	channel->region1_count = 36;
570
571	if (mad_bit_read(ptr, 1)) {
572	channel->flags |= mixed_block_flag;
573	} else if (channel->block_type == 2) {
574	channel->region0_count = 8;
575	}
576
577	for (i = 0; i < 2; ++i) {
578	channel->table_select[i] = mad_bit_read(ptr, 5);
579	}
580
581	# if defined(DEBUG)
582	channel->table_select[2] = 4; /* not used */
583	# endif
584
585	for (i = 0; i < 3; ++i) {
586	channel->subblock_gain[i] = mad_bit_read(ptr, 3);
587	}
588	} else {
589	channel->block_type = 0;
590
591	for (i = 0; i < 3; ++i) {
592	channel->table_select[i] = mad_bit_read(ptr, 5);
593	}
594
595	channel->region0_count = mad_bit_read(ptr, 4);
596	channel->region1_count = mad_bit_read(ptr, 3);
597	}
598
599	/* [preflag,] scalefac_scale, count1table_select */
600	channel->flags |= mad_bit_read(ptr, lsf ? 2 : 3);
601	}
602	}
603
604	return result;
605	}
606
607	/*
608	* NAME: III_scalefactors_lsf()
609	* DESCRIPTION: decode channel scalefactors for LSF from a bitstream
610	*/
611	static
612	unsigned int III_scalefactors_lsf(struct mad_bitptr *ptr,
613	struct channel *channel,
614	struct channel *gr1ch, int mode_extension)
615	{
616	struct mad_bitptr start;
617	unsigned int scalefac_compress, index, slen[4], part, n, i;
618	unsigned char const *nsfb;
619
620	start = *ptr;
621
622	scalefac_compress = channel->scalefac_compress;
623	index = (channel->block_type == 2) ?
624	((channel->flags & mixed_block_flag) ? 2 : 1) : 0;
625
626	if (!((mode_extension & I_STEREO) && gr1ch)) {
627	if (scalefac_compress < 400) {
628	slen[0] = (scalefac_compress >> 4) / 5;
629	slen[1] = (scalefac_compress >> 4) % 5;
630	slen[2] = (scalefac_compress % 16) >> 2;
631	slen[3] = scalefac_compress % 4;
632
633	nsfb = nsfb_table[0][index];
634	} else if (scalefac_compress < 500) {
635	scalefac_compress -= 400;
636
637	slen[0] = (scalefac_compress >> 2) / 5;
638	slen[1] = (scalefac_compress >> 2) % 5;
639	slen[2] = scalefac_compress % 4;
640	slen[3] = 0;
641
642	nsfb = nsfb_table[1][index];
643	} else {
644	scalefac_compress -= 500;
645
646	slen[0] = scalefac_compress / 3;
647	slen[1] = scalefac_compress % 3;
648	slen[2] = 0;
649	slen[3] = 0;
650
651	channel->flags |= preflag;
652
653	nsfb = nsfb_table[2][index];
654	}
655
656	n = 0;
657	for (part = 0; part < 4; ++part) {
658	for (i = 0; i < nsfb[part]; ++i) {
659	channel->scalefac[n++] = mad_bit_read(ptr, slen[part]);
660	}
661	}
662
663	while (n < 39) {
664	channel->scalefac[n++] = 0;
665	}
666	} else { /* (mode_extension & I_STEREO) && gr1ch (i.e. ch == 1) */
667	scalefac_compress >>= 1;
668
669	if (scalefac_compress < 180) {
670	slen[0] = scalefac_compress / 36;
671	slen[1] = (scalefac_compress % 36) / 6;
672	slen[2] = (scalefac_compress % 36) % 6;
673	slen[3] = 0;
674
675	nsfb = nsfb_table[3][index];
676	} else if (scalefac_compress < 244) {
677	scalefac_compress -= 180;
678
679	slen[0] = (scalefac_compress % 64) >> 4;
680	slen[1] = (scalefac_compress % 16) >> 2;
681	slen[2] = scalefac_compress % 4;
682	slen[3] = 0;
683
684	nsfb = nsfb_table[4][index];
685	} else {
686	scalefac_compress -= 244;
687
688	slen[0] = scalefac_compress / 3;
689	slen[1] = scalefac_compress % 3;
690	slen[2] = 0;
691	slen[3] = 0;
692
693	nsfb = nsfb_table[5][index];
694	}
695
696	n = 0;
697	for (part = 0; part < 4; ++part) {
698	unsigned int max, is_pos;
699
700	max = (1 << slen[part]) - 1;
701
702	for (i = 0; i < nsfb[part]; ++i) {
703	is_pos = mad_bit_read(ptr, slen[part]);
704
705	channel->scalefac[n] = is_pos;
706	gr1ch->scalefac[n++] = (is_pos == max);
707	}
708	}
709
710	while (n < 39) {
711	channel->scalefac[n] = 0;
712	gr1ch->scalefac[n++] = 0; /* apparently not illegal */
713	}
714	}
715
716	return mad_bit_length(&start, ptr);
717	}
718
719	/*
720	* NAME: III_scalefactors()
721	* DESCRIPTION: decode channel scalefactors of one granule from a bitstream
722	*/
723	static
724	unsigned int III_scalefactors(struct mad_bitptr *ptr, struct channel *channel,
725	struct channel const *gr0ch, unsigned int scfsi)
726	{
727	struct mad_bitptr start;
728	unsigned int slen1, slen2, sfbi;
729
730	start = *ptr;
731
732	slen1 = sflen_table[channel->scalefac_compress].slen1;
733	slen2 = sflen_table[channel->scalefac_compress].slen2;
734
735	if (channel->block_type == 2) {
736	unsigned int nsfb;
737
738	sfbi = 0;
739
740	nsfb = (channel->flags & mixed_block_flag) ? 8 + 3 * 3 : 6 * 3;
741	while (nsfb--) {
742	channel->scalefac[sfbi++] = mad_bit_read(ptr, slen1);
743	}
744
745	nsfb = 6 * 3;
746	while (nsfb--) {
747	channel->scalefac[sfbi++] = mad_bit_read(ptr, slen2);
748	}
749
750	nsfb = 1 * 3;
751	while (nsfb--) {
752	channel->scalefac[sfbi++] = 0;
753	}
754	} else { /* channel->block_type != 2 */
755	if (scfsi & 0x8) {
756	for (sfbi = 0; sfbi < 6; ++sfbi) {
757	channel->scalefac[sfbi] = gr0ch->scalefac[sfbi];
758	}
759	} else {
760	for (sfbi = 0; sfbi < 6; ++sfbi) {
761	channel->scalefac[sfbi] = mad_bit_read(ptr, slen1);
762	}
763	}
764
765	if (scfsi & 0x4) {
766	for (sfbi = 6; sfbi < 11; ++sfbi) {
767	channel->scalefac[sfbi] = gr0ch->scalefac[sfbi];
768	}
769	} else {
770	for (sfbi = 6; sfbi < 11; ++sfbi) {
771	channel->scalefac[sfbi] = mad_bit_read(ptr, slen1);
772	}
773	}
774
775	if (scfsi & 0x2) {
776	for (sfbi = 11; sfbi < 16; ++sfbi) {
777	channel->scalefac[sfbi] = gr0ch->scalefac[sfbi];
778	}
779	} else {
780	for (sfbi = 11; sfbi < 16; ++sfbi) {
781	channel->scalefac[sfbi] = mad_bit_read(ptr, slen2);
782	}
783	}
784
785	if (scfsi & 0x1) {
786	for (sfbi = 16; sfbi < 21; ++sfbi) {
787	channel->scalefac[sfbi] = gr0ch->scalefac[sfbi];
788	}
789	} else {
790	for (sfbi = 16; sfbi < 21; ++sfbi) {
791	channel->scalefac[sfbi] = mad_bit_read(ptr, slen2);
792	}
793	}
794
795	channel->scalefac[21] = 0;
796	}
797
798	return mad_bit_length(&start, ptr);
799	}
800
801	/*
802	* The Layer III formula for requantization and scaling is defined by
803	* section 2.4.3.4.7.1 of ISO/IEC 11172-3, as follows:
804	*
805	* long blocks:
806	* xr[i] = sign(is[i]) * abs(is[i])^(4/3) *
807	* 2^((1/4) * (global_gain - 210)) *
808	* 2^-(scalefac_multiplier *
809	* (scalefac_l[sfb] + preflag * pretab[sfb]))
810	*
811	* short blocks:
812	* xr[i] = sign(is[i]) * abs(is[i])^(4/3) *
813	* 2^((1/4) * (global_gain - 210 - 8 * subblock_gain[w])) *
814	* 2^-(scalefac_multiplier * scalefac_s[sfb][w])
815	*
816	* where:
817	* scalefac_multiplier = (scalefac_scale + 1) / 2
818	*
819	* The routines III_exponents() and III_requantize() facilitate this
820	* calculation.
821	*/
822
823	/*
824	* NAME: III_exponents()
825	* DESCRIPTION: calculate scalefactor exponents
826	*/
827	static
828	void III_exponents(struct channel const *channel,
829	unsigned char const *sfbwidth, signed int exponents[39])
830	{
831	signed int gain;
832	unsigned int scalefac_multiplier, sfbi;
833
834	gain = (signed int) channel->global_gain - 210;
835	scalefac_multiplier = (channel->flags & scalefac_scale) ? 2 : 1;
836
837	if (channel->block_type == 2) {
838	unsigned int l;
839	signed int gain0, gain1, gain2;
840
841	sfbi = l = 0;
842
843	if (channel->flags & mixed_block_flag) {
844	unsigned int premask;
845
846	premask = (channel->flags & preflag) ? ~0 : 0;
847
848	/* long block subbands 0-1 */
849
850	while (l < 36) {
851	exponents[sfbi] = gain -
852	(signed int)((channel->scalefac[sfbi] + (pretab[sfbi] & premask)) <<
853	scalefac_multiplier);
854
855	l += sfbwidth[sfbi++];
856	}
857	}
858
859	/* this is probably wrong for 8000 Hz short/mixed blocks */
860
861	gain0 = gain - 8 * (signed int) channel->subblock_gain[0];
862	gain1 = gain - 8 * (signed int) channel->subblock_gain[1];
863	gain2 = gain - 8 * (signed int) channel->subblock_gain[2];
864
865	while (l < 576) {
866	exponents[sfbi + 0] = gain0 -
867	(signed int)(channel->scalefac[sfbi + 0] << scalefac_multiplier);
868	exponents[sfbi + 1] = gain1 -
869	(signed int)(channel->scalefac[sfbi + 1] << scalefac_multiplier);
870	exponents[sfbi + 2] = gain2 -
871	(signed int)(channel->scalefac[sfbi + 2] << scalefac_multiplier);
872
873	l += 3 * sfbwidth[sfbi];
874	sfbi += 3;
875	}
876	} else { /* channel->block_type != 2 */
877	if (channel->flags & preflag) {
878	for (sfbi = 0; sfbi < 22; ++sfbi) {
879	exponents[sfbi] = gain -
880	(signed int)((channel->scalefac[sfbi] + pretab[sfbi]) <<
881	scalefac_multiplier);
882	}
883	} else {
884	for (sfbi = 0; sfbi < 22; ++sfbi) {
885	exponents[sfbi] = gain -
886	(signed int)(channel->scalefac[sfbi] << scalefac_multiplier);
887	}
888	}
889	}
890	}
891
892	/*
893	* NAME: III_requantize()
894	* DESCRIPTION: requantize one (positive) value
895	*/
896	static
897	mad_fixed_t III_requantize(unsigned int value, signed int exp)
898	{
899	mad_fixed_t requantized;
900	signed int frac;
901	struct fixedfloat const *power;
902
903	frac = exp % 4; /* assumes sign(frac) == sign(exp) */
904	exp /= 4;
905
906	power = &rq_table[value];
907	requantized = power->mantissa;
908	exp += power->exponent;
909
910	if (exp < 0) {
911	if (-exp >= sizeof(mad_fixed_t) * CHAR_BIT) {
912	/* underflow */
913	requantized = 0;
914	} else {
915	requantized += 1L << (-exp - 1);
916	requantized >>= -exp;
917	}
918	} else {
919	if (exp >= 5) {
920	/* overflow */
921	# if defined(DEBUG)
922	fprintf(stderr, "requantize overflow (%f * 2^%d)\n",
923	mad_f_todouble(requantized), exp);
924	# endif
925	requantized = MAD_F_MAX;
926	} else {
927	requantized <<= exp;
928	}
929	}
930
931	return frac ? mad_f_mul(requantized, root_table[3 + frac]) : requantized;
932	}
933
934	/* we must take care that sz >= bits and sz < sizeof(long) lest bits == 0 */
935	# define MASK(cache, sz, bits) \
936	(((cache) >> ((sz) - (bits))) & ((1 << (bits)) - 1))
937	# define MASK1BIT(cache, sz) \
938	((cache) & (1 << ((sz) - 1)))
939
940	/*
941	* NAME: III_huffdecode()
942	* DESCRIPTION: decode Huffman code words of one channel of one granule
943	*/
944	static
945	enum mad_error III_huffdecode(struct mad_bitptr *ptr, mad_fixed_t xr[576],
946	struct channel *channel,
947	unsigned char const *sfbwidth,
948	unsigned int part2_length)
949	{
950	signed int exponents[39], exp;
951	signed int const *expptr;
952	struct mad_bitptr peek;
953	signed int bits_left, cachesz;
954	register mad_fixed_t *xrptr;
955	mad_fixed_t const *sfbound;
956	register unsigned long bitcache;
957
958	bits_left = (signed) channel->part2_3_length - (signed) part2_length;
959	if (bits_left < 0) {
960	return MAD_ERROR_BADPART3LEN;
961	}
962
963	III_exponents(channel, sfbwidth, exponents);
964
965	peek = *ptr;
966	mad_bit_skip(ptr, bits_left);
967
968	/* align bit reads to byte boundaries */
969	cachesz = mad_bit_bitsleft(&peek);
970	cachesz += ((32 - 1 - 24) + (24 - cachesz)) & ~7;
971
972	bitcache = mad_bit_read(&peek, cachesz);
973	bits_left -= cachesz;
974
975	xrptr = &xr[0];
976
977	/* big_values */
978	{
979	unsigned int region, rcount;
980	struct hufftable const *entry;
981	union huffpair const *table;
982	unsigned int linbits, startbits, big_values, reqhits;
983	mad_fixed_t reqcache[16];
984
985	sfbound = xrptr + *sfbwidth++;
986	rcount = channel->region0_count + 1;
987
988	entry = &mad_huff_pair_table[channel->table_select[region = 0]];
989	table = entry->table;
990	linbits = entry->linbits;
991	startbits = entry->startbits;
992
993	if (table == 0) {
994	return MAD_ERROR_BADHUFFTABLE;
995	}
996
997	expptr = &exponents[0];
998	exp = *expptr++;
999	reqhits = 0;
1000
1001	big_values = channel->big_values;
1002
1003	while (big_values-- && cachesz + bits_left > 0) {
1004	union huffpair const *pair;
1005	unsigned int clumpsz, value;
1006	register mad_fixed_t requantized;
1007
1008	if (xrptr == sfbound) {
1009	sfbound += *sfbwidth++;
1010
1011	/* change table if region boundary */
1012
1013	if (--rcount == 0) {
1014	if (region == 0) {
1015	rcount = channel->region1_count + 1;
1016	} else {
1017	rcount = 0; /* all remaining */
1018	}
1019
1020	entry = &mad_huff_pair_table[channel->table_select[++region]];
1021	table = entry->table;
1022	linbits = entry->linbits;
1023	startbits = entry->startbits;
1024
1025	if (table == 0) {
1026	return MAD_ERROR_BADHUFFTABLE;
1027	}
1028	}
1029
1030	if (exp != *expptr) {
1031	exp = *expptr;
1032	reqhits = 0;
1033	}
1034
1035	++expptr;
1036	}
1037
1038	if (cachesz < 21) {
1039	unsigned int bits;
1040
1041	bits = ((32 - 1 - 21) + (21 - cachesz)) & ~7;
1042	bitcache = (bitcache << bits) | mad_bit_read(&peek, bits);
1043	cachesz += bits;
1044	bits_left -= bits;
1045	}
1046
1047	/* hcod (0..19) */
1048
1049	clumpsz = startbits;
1050	pair = &table[MASK(bitcache, cachesz, clumpsz)];
1051
1052	while (!pair->final) {
1053	cachesz -= clumpsz;
1054
1055	clumpsz = pair->ptr.bits;
1056	pair = &table[pair->ptr.offset + MASK(bitcache, cachesz, clumpsz)];
1057	}
1058
1059	cachesz -= pair->value.hlen;
1060
1061	if (linbits) {
1062	/* x (0..14) */
1063
1064	value = pair->value.x;
1065
1066	switch (value) {
1067	case 0:
1068	xrptr[0] = 0;
1069	break;
1070
1071	case 15:
1072	if (cachesz < linbits + 2) {
1073	bitcache = (bitcache << 16) | mad_bit_read(&peek, 16);
1074	cachesz += 16;
1075	bits_left -= 16;
1076	}
1077
1078	value += MASK(bitcache, cachesz, linbits);
1079	cachesz -= linbits;
1080
1081	requantized = III_requantize(value, exp);
1082	goto x_final;
1083
1084	default:
1085	if (reqhits & (1 << value)) {
1086	requantized = reqcache[value];
1087	} else {
1088	reqhits |= (1 << value);
1089	requantized = reqcache[value] = III_requantize(value, exp);
1090	}
1091
1092	x_final:
1093	xrptr[0] = MASK1BIT(bitcache, cachesz--) ?
1094	-requantized : requantized;
1095	}
1096
1097	/* y (0..14) */
1098
1099	value = pair->value.y;
1100
1101	switch (value) {
1102	case 0:
1103	xrptr[1] = 0;
1104	break;
1105
1106	case 15:
1107	if (cachesz < linbits + 1) {
1108	bitcache = (bitcache << 16) | mad_bit_read(&peek, 16);
1109	cachesz += 16;
1110	bits_left -= 16;
1111	}
1112
1113	value += MASK(bitcache, cachesz, linbits);
1114	cachesz -= linbits;
1115
1116	requantized = III_requantize(value, exp);
1117	goto y_final;
1118
1119	default:
1120	if (reqhits & (1 << value)) {
1121	requantized = reqcache[value];
1122	} else {
1123	reqhits |= (1 << value);
1124	requantized = reqcache[value] = III_requantize(value, exp);
1125	}
1126
1127	y_final:
1128	xrptr[1] = MASK1BIT(bitcache, cachesz--) ?
1129	-requantized : requantized;
1130	}
1131	} else {
1132	/* x (0..1) */
1133
1134	value = pair->value.x;
1135
1136	if (value == 0) {
1137	xrptr[0] = 0;
1138	} else {
1139	if (reqhits & (1 << value)) {
1140	requantized = reqcache[value];
1141	} else {
1142	reqhits |= (1 << value);
1143	requantized = reqcache[value] = III_requantize(value, exp);
1144	}
1145
1146	xrptr[0] = MASK1BIT(bitcache, cachesz--) ?
1147	-requantized : requantized;
1148	}
1149
1150	/* y (0..1) */
1151
1152	value = pair->value.y;
1153
1154	if (value == 0) {
1155	xrptr[1] = 0;
1156	} else {
1157	if (reqhits & (1 << value)) {
1158	requantized = reqcache[value];
1159	} else {
1160	reqhits |= (1 << value);
1161	requantized = reqcache[value] = III_requantize(value, exp);
1162	}
1163
1164	xrptr[1] = MASK1BIT(bitcache, cachesz--) ?
1165	-requantized : requantized;
1166	}
1167	}
1168
1169	xrptr += 2;
1170	}
1171	}
1172
1173	if (cachesz + bits_left < 0) {
1174	return MAD_ERROR_BADHUFFDATA; /* big_values overrun */
1175	}
1176
1177	/* count1 */
1178	{
1179	union huffquad const *table;
1180	register mad_fixed_t requantized;
1181
1182	table = mad_huff_quad_table[channel->flags & count1table_select];
1183
1184	requantized = III_requantize(1, exp);
1185
1186	while (cachesz + bits_left > 0 && xrptr <= &xr[572]) {
1187	union huffquad const *quad;
1188
1189	/* hcod (1..6) */
1190
1191	if (cachesz < 10) {
1192	bitcache = (bitcache << 16) | mad_bit_read(&peek, 16);
1193	cachesz += 16;
1194	bits_left -= 16;
1195	}
1196
1197	quad = &table[MASK(bitcache, cachesz, 4)];
1198
1199	/* quad tables guaranteed to have at most one extra lookup */
1200	if (!quad->final) {
1201	cachesz -= 4;
1202
1203	quad = &table[quad->ptr.offset +
1204	MASK(bitcache, cachesz, quad->ptr.bits)];
1205	}
1206
1207	cachesz -= quad->value.hlen;
1208
1209	if (xrptr == sfbound) {
1210	sfbound += *sfbwidth++;
1211
1212	if (exp != *expptr) {
1213	exp = *expptr;
1214	requantized = III_requantize(1, exp);
1215	}
1216
1217	++expptr;
1218	}
1219
1220	/* v (0..1) */
1221
1222	xrptr[0] = quad->value.v ?
1223	(MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0;
1224
1225	/* w (0..1) */
1226
1227	xrptr[1] = quad->value.w ?
1228	(MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0;
1229
1230	xrptr += 2;
1231
1232	if (xrptr == sfbound) {
1233	sfbound += *sfbwidth++;
1234
1235	if (exp != *expptr) {
1236	exp = *expptr;
1237	requantized = III_requantize(1, exp);
1238	}
1239
1240	++expptr;
1241	}
1242
1243	/* x (0..1) */
1244
1245	xrptr[0] = quad->value.x ?
1246	(MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0;
1247
1248	/* y (0..1) */
1249
1250	xrptr[1] = quad->value.y ?
1251	(MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0;
1252
1253	xrptr += 2;
1254	}
1255
1256	if (cachesz + bits_left < 0) {
1257	# if 0 && defined(DEBUG)
1258	fprintf(stderr, "huffman count1 overrun (%d bits)\n",
1259	-(cachesz + bits_left));
1260	# endif
1261
1262	/* technically the bitstream is misformatted, but apparently
1263	some encoders are just a bit sloppy with stuffing bits */
1264
1265	xrptr -= 4;
1266	}
1267	}
1268
1269	assert(-bits_left <= MAD_BUFFER_GUARD * CHAR_BIT);
1270
1271	# if 0 && defined(DEBUG)
1272	if (bits_left < 0) {
1273	fprintf(stderr, "read %d bits too many\n", -bits_left);
1274	} else if (cachesz + bits_left > 0) {
1275	fprintf(stderr, "%d stuffing bits\n", cachesz + bits_left);
1276	}
1277	# endif
1278
1279	/* rzero */
1280	while (xrptr < &xr[576]) {
1281	xrptr[0] = 0;
1282	xrptr[1] = 0;
1283
1284	xrptr += 2;
1285	}
1286
1287	return MAD_ERROR_NONE;
1288	}
1289
1290	# undef MASK
1291	# undef MASK1BIT
1292
1293	/*
1294	* NAME: III_reorder()
1295	* DESCRIPTION: reorder frequency lines of a short block into subband order
1296	*/
1297	static
1298	void III_reorder(mad_fixed_t xr[576], struct channel const *channel,
1299	unsigned char const sfbwidth[39])
1300	{
1301	mad_fixed_t tmp[32][3][6];
1302	unsigned int sb, l, f, w, sbw[3], sw[3];
1303
1304	/* this is probably wrong for 8000 Hz mixed blocks */
1305
1306	sb = 0;
1307	if (channel->flags & mixed_block_flag) {
1308	sb = 2;
1309
1310	l = 0;
1311	while (l < 36) {
1312	l += *sfbwidth++;
1313	}
1314	}
1315
1316	for (w = 0; w < 3; ++w) {
1317	sbw[w] = sb;
1318	sw[w] = 0;
1319	}
1320
1321	f = *sfbwidth++;
1322	w = 0;
1323
1324	for (l = 18 * sb; l < 576; ++l) {
1325	if (f-- == 0) {
1326	f = *sfbwidth++ - 1;
1327	w = (w + 1) % 3;
1328	}
1329
1330	tmp[sbw[w]][w][sw[w]++] = xr[l];
1331
1332	if (sw[w] == 6) {
1333	sw[w] = 0;
1334	++sbw[w];
1335	}
1336	}
1337
1338	memcpy(&xr[18 * sb], &tmp[sb], (576 - 18 * sb) * sizeof(mad_fixed_t));
1339	}
1340
1341	/*
1342	* NAME: III_stereo()
1343	* DESCRIPTION: perform joint stereo processing on a granule
1344	*/
1345	static
1346	enum mad_error III_stereo(mad_fixed_t xr[2][576],
1347	struct granule const *granule,
1348	struct mad_header *header,
1349	unsigned char const *sfbwidth)
1350	{
1351	short modes[39];
1352	unsigned int sfbi, l, n, i;
1353
1354	if (granule->ch[0].block_type !=
1355	granule->ch[1].block_type ||
1356	(granule->ch[0].flags & mixed_block_flag) !=
1357	(granule->ch[1].flags & mixed_block_flag)) {
1358	return MAD_ERROR_BADSTEREO;
1359	}
1360
1361	for (i = 0; i < 39; ++i) {
1362	modes[i] = header->mode_extension;
1363	}
1364
1365	/* intensity stereo */
1366
1367	if (header->mode_extension & I_STEREO) {
1368	struct channel const *right_ch = &granule->ch[1];
1369	mad_fixed_t const *right_xr = xr[1];
1370	unsigned int is_pos;
1371
1372	header->flags |= MAD_FLAG_I_STEREO;
1373
1374	/* first determine which scalefactor bands are to be processed */
1375
1376	if (right_ch->block_type == 2) {
1377	unsigned int lower, start, max, bound[3], w;
1378
1379	lower = start = max = bound[0] = bound[1] = bound[2] = 0;
1380
1381	sfbi = l = 0;
1382
1383	if (right_ch->flags & mixed_block_flag) {
1384	while (l < 36) {
1385	n = sfbwidth[sfbi++];
1386
1387	for (i = 0; i < n; ++i) {
1388	if (right_xr[i]) {
1389	lower = sfbi;
1390	break;
1391	}
1392	}
1393
1394	right_xr += n;
1395	l += n;
1396	}
1397
1398	start = sfbi;
1399	}
1400
1401	w = 0;
1402	while (l < 576) {
1403	n = sfbwidth[sfbi++];
1404
1405	for (i = 0; i < n; ++i) {
1406	if (right_xr[i]) {
1407	max = bound[w] = sfbi;
1408	break;
1409	}
1410	}
1411
1412	right_xr += n;
1413	l += n;
1414	w = (w + 1) % 3;
1415	}
1416
1417	if (max) {
1418	lower = start;
1419	}
1420
1421	/* long blocks */
1422
1423	for (i = 0; i < lower; ++i) {
1424	modes[i] = header->mode_extension & ~I_STEREO;
1425	}
1426
1427	/* short blocks */
1428
1429	w = 0;
1430	for (i = start; i < max; ++i) {
1431	if (i < bound[w]) {
1432	modes[i] = header->mode_extension & ~I_STEREO;
1433	}
1434
1435	w = (w + 1) % 3;
1436	}
1437	} else { /* right_ch->block_type != 2 */
1438	unsigned int bound;
1439
1440	bound = 0;
1441	for (sfbi = l = 0; l < 576; l += n) {
1442	n = sfbwidth[sfbi++];
1443
1444	for (i = 0; i < n; ++i) {
1445	if (right_xr[i]) {
1446	bound = sfbi;
1447	break;
1448	}
1449	}
1450
1451	right_xr += n;
1452	}
1453
1454	for (i = 0; i < bound; ++i) {
1455	modes[i] = header->mode_extension & ~I_STEREO;
1456	}
1457	}
1458
1459	/* now do the actual processing */
1460
1461	if (header->flags & MAD_FLAG_LSF_EXT) {
1462	unsigned char const *illegal_pos = granule[1].ch[1].scalefac;
1463	mad_fixed_t const *lsf_scale;
1464
1465	/* intensity_scale */
1466	lsf_scale = is_lsf_table[right_ch->scalefac_compress & 0x1];
1467
1468	for (sfbi = l = 0; l < 576; ++sfbi, l += n) {
1469	n = sfbwidth[sfbi];
1470
1471	if (!(modes[sfbi] & I_STEREO)) {
1472	continue;
1473	}
1474
1475	if (illegal_pos[sfbi]) {
1476	modes[sfbi] &= ~I_STEREO;
1477	continue;
1478	}
1479
1480	is_pos = right_ch->scalefac[sfbi];
1481
1482	for (i = 0; i < n; ++i) {
1483	register mad_fixed_t left;
1484
1485	left = xr[0][l + i];
1486
1487	if (is_pos == 0) {
1488	xr[1][l + i] = left;
1489	} else {
1490	register mad_fixed_t opposite;
1491
1492	opposite = mad_f_mul(left, lsf_scale[(is_pos - 1) / 2]);
1493
1494	if (is_pos & 1) {
1495	xr[0][l + i] = opposite;
1496	xr[1][l + i] = left;
1497	} else {
1498	xr[1][l + i] = opposite;
1499	}
1500	}
1501	}
1502	}
1503	} else { /* !(header->flags & MAD_FLAG_LSF_EXT) */
1504	for (sfbi = l = 0; l < 576; ++sfbi, l += n) {
1505	n = sfbwidth[sfbi];
1506
1507	if (!(modes[sfbi] & I_STEREO)) {
1508	continue;
1509	}
1510
1511	is_pos = right_ch->scalefac[sfbi];
1512
1513	if (is_pos >= 7) { /* illegal intensity position */
1514	modes[sfbi] &= ~I_STEREO;
1515	continue;
1516	}
1517
1518	for (i = 0; i < n; ++i) {
1519	register mad_fixed_t left;
1520
1521	left = xr[0][l + i];
1522
1523	xr[0][l + i] = mad_f_mul(left, is_table[ is_pos]);
1524	xr[1][l + i] = mad_f_mul(left, is_table[6 - is_pos]);
1525	}
1526	}
1527	}
1528	}
1529
1530	/* middle/side stereo */
1531
1532	if (header->mode_extension & MS_STEREO) {
1533	register mad_fixed_t invsqrt2;
1534
1535	header->flags |= MAD_FLAG_MS_STEREO;
1536
1537	invsqrt2 = root_table[3 + -2];
1538
1539	for (sfbi = l = 0; l < 576; ++sfbi, l += n) {
1540	n = sfbwidth[sfbi];
1541
1542	if (modes[sfbi] != MS_STEREO) {
1543	continue;
1544	}
1545
1546	for (i = 0; i < n; ++i) {
1547	register mad_fixed_t m, s;
1548
1549	m = xr[0][l + i];
1550	s = xr[1][l + i];
1551
1552	xr[0][l + i] = mad_f_mul(m + s, invsqrt2); /* l = (m + s) / sqrt(2) */
1553	xr[1][l + i] = mad_f_mul(m - s, invsqrt2); /* r = (m - s) / sqrt(2) */
1554	}
1555	}
1556	}
1557
1558	return MAD_ERROR_NONE;
1559	}
1560
1561	/*
1562	* NAME: III_aliasreduce()
1563	* DESCRIPTION: perform frequency line alias reduction
1564	*/
1565	static
1566	void III_aliasreduce(mad_fixed_t xr[576], int lines)
1567	{
1568	mad_fixed_t const *bound;
1569	int i;
1570
1571	bound = &xr[lines];
1572	for (xr += 18; xr < bound; xr += 18) {
1573	for (i = 0; i < 8; ++i) {
1574	register mad_fixed_t a, b;
1575	register mad_fixed64hi_t hi;
1576	register mad_fixed64lo_t lo;
1577
1578	a = xr[-1 - i];
1579	b = xr[ i];
1580
1581	# if defined(ASO_ZEROCHECK)
1582	if (a | b) {
1583	# endif
1584	MAD_F_ML0(hi, lo, a, cs[i]);
1585	MAD_F_MLA(hi, lo, -b, ca[i]);
1586
1587	xr[-1 - i] = MAD_F_MLZ(hi, lo);
1588
1589	MAD_F_ML0(hi, lo, b, cs[i]);
1590	MAD_F_MLA(hi, lo, a, ca[i]);
1591
1592	xr[ i] = MAD_F_MLZ(hi, lo);
1593	# if defined(ASO_ZEROCHECK)
1594	}
1595	# endif
1596	}
1597	}
1598	}
1599
1600	# if defined(ASO_IMDCT)
1601	void III_imdct_l(mad_fixed_t const [18], mad_fixed_t [36], unsigned int);
1602	# else
1603	# if 1
1604	static
1605	void fastsdct(mad_fixed_t const x[9], mad_fixed_t y[18])
1606	{
1607	mad_fixed_t a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12;
1608	mad_fixed_t a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25;
1609	mad_fixed_t m0, m1, m2, m3, m4, m5, m6, m7;
1610
1611	enum {
1612	c0 = MAD_F(0x1f838b8d), /* 2 * cos( 1 * PI / 18) */
1613	c1 = MAD_F(0x1bb67ae8), /* 2 * cos( 3 * PI / 18) */
1614	c2 = MAD_F(0x18836fa3), /* 2 * cos( 4 * PI / 18) */
1615	c3 = MAD_F(0x1491b752), /* 2 * cos( 5 * PI / 18) */
1616	c4 = MAD_F(0x0af1d43a), /* 2 * cos( 7 * PI / 18) */
1617	c5 = MAD_F(0x058e86a0), /* 2 * cos( 8 * PI / 18) */
1618	c6 = -MAD_F(0x1e11f642) /* 2 * cos(16 * PI / 18) */
1619	};
1620
1621	a0 = x[3] + x[5];
1622	a1 = x[3] - x[5];
1623	a2 = x[6] + x[2];
1624	a3 = x[6] - x[2];
1625	a4 = x[1] + x[7];
1626	a5 = x[1] - x[7];
1627	a6 = x[8] + x[0];
1628	a7 = x[8] - x[0];
1629
1630	a8 = a0 + a2;
1631	a9 = a0 - a2;
1632	a10 = a0 - a6;
1633	a11 = a2 - a6;
1634	a12 = a8 + a6;
1635	a13 = a1 - a3;
1636	a14 = a13 + a7;
1637	a15 = a3 + a7;
1638	a16 = a1 - a7;
1639	a17 = a1 + a3;
1640
1641	m0 = mad_f_mul(a17, -c3);
1642	m1 = mad_f_mul(a16, -c0);
1643	m2 = mad_f_mul(a15, -c4);
1644	m3 = mad_f_mul(a14, -c1);
1645	m4 = mad_f_mul(a5, -c1);
1646	m5 = mad_f_mul(a11, -c6);
1647	m6 = mad_f_mul(a10, -c5);
1648	m7 = mad_f_mul(a9, -c2);
1649
1650	a18 = x[4] + a4;
1651	a19 = 2 * x[4] - a4;
1652	a20 = a19 + m5;
1653	a21 = a19 - m5;
1654	a22 = a19 + m6;
1655	a23 = m4 + m2;
1656	a24 = m4 - m2;
1657	a25 = m4 + m1;
1658
1659	/* output to every other slot for convenience */
1660
1661	y[ 0] = a18 + a12;
1662	y[ 2] = m0 - a25;
1663	y[ 4] = m7 - a20;
1664	y[ 6] = m3;
1665	y[ 8] = a21 - m6;
1666	y[10] = a24 - m1;
1667	y[12] = a12 - 2 * a18;
1668	y[14] = a23 + m0;
1669	y[16] = a22 + m7;
1670	}
1671
1672	static inline
1673	void sdctII(mad_fixed_t const x[18], mad_fixed_t X[18])
1674	{
1675	mad_fixed_t tmp[9];
1676	int i;
1677
1678	/* scale[i] = 2 * cos(PI * (2 * i + 1) / (2 * 18)) */
1679	static mad_fixed_t const scale[9] = {
1680	MAD_F(0x1fe0d3b4), MAD_F(0x1ee8dd47), MAD_F(0x1d007930),
1681	MAD_F(0x1a367e59), MAD_F(0x16a09e66), MAD_F(0x125abcf8),
1682	MAD_F(0x0d8616bc), MAD_F(0x08483ee1), MAD_F(0x02c9fad7)
1683	};
1684
1685	/* divide the 18-point SDCT-II into two 9-point SDCT-IIs */
1686
1687	/* even input butterfly */
1688
1689	for (i = 0; i < 9; i += 3) {
1690	tmp[i + 0] = x[i + 0] + x[18 - (i + 0) - 1];
1691	tmp[i + 1] = x[i + 1] + x[18 - (i + 1) - 1];
1692	tmp[i + 2] = x[i + 2] + x[18 - (i + 2) - 1];
1693	}
1694
1695	fastsdct(tmp, &X[0]);
1696
1697	/* odd input butterfly and scaling */
1698
1699	for (i = 0; i < 9; i += 3) {
1700	tmp[i + 0] = mad_f_mul(x[i + 0] - x[18 - (i + 0) - 1], scale[i + 0]);
1701	tmp[i + 1] = mad_f_mul(x[i + 1] - x[18 - (i + 1) - 1], scale[i + 1]);
1702	tmp[i + 2] = mad_f_mul(x[i + 2] - x[18 - (i + 2) - 1], scale[i + 2]);
1703	}
1704
1705	fastsdct(tmp, &X[1]);
1706
1707	/* output accumulation */
1708
1709	for (i = 3; i < 18; i += 8) {
1710	X[i + 0] -= X[(i + 0) - 2];
1711	X[i + 2] -= X[(i + 2) - 2];
1712	X[i + 4] -= X[(i + 4) - 2];
1713	X[i + 6] -= X[(i + 6) - 2];
1714	}
1715	}
1716
1717	static inline
1718	void dctIV(mad_fixed_t const y[18], mad_fixed_t X[18])
1719	{
1720	mad_fixed_t tmp[18];
1721	int i;
1722
1723	/* scale[i] = 2 * cos(PI * (2 * i + 1) / (4 * 18)) */
1724	static mad_fixed_t const scale[18] = {
1725	MAD_F(0x1ff833fa), MAD_F(0x1fb9ea93), MAD_F(0x1f3dd120),
1726	MAD_F(0x1e84d969), MAD_F(0x1d906bcf), MAD_F(0x1c62648b),
1727	MAD_F(0x1afd100f), MAD_F(0x1963268b), MAD_F(0x1797c6a4),
1728	MAD_F(0x159e6f5b), MAD_F(0x137af940), MAD_F(0x11318ef3),
1729	MAD_F(0x0ec6a507), MAD_F(0x0c3ef153), MAD_F(0x099f61c5),
1730	MAD_F(0x06ed12c5), MAD_F(0x042d4544), MAD_F(0x0165547c)
1731	};
1732
1733	/* scaling */
1734
1735	for (i = 0; i < 18; i += 3) {
1736	tmp[i + 0] = mad_f_mul(y[i + 0], scale[i + 0]);
1737	tmp[i + 1] = mad_f_mul(y[i + 1], scale[i + 1]);
1738	tmp[i + 2] = mad_f_mul(y[i + 2], scale[i + 2]);
1739	}
1740
1741	/* SDCT-II */
1742
1743	sdctII(tmp, X);
1744
1745	/* scale reduction and output accumulation */
1746
1747	X[0] /= 2;
1748	for (i = 1; i < 17; i += 4) {
1749	X[i + 0] = X[i + 0] / 2 - X[(i + 0) - 1];
1750	X[i + 1] = X[i + 1] / 2 - X[(i + 1) - 1];
1751	X[i + 2] = X[i + 2] / 2 - X[(i + 2) - 1];
1752	X[i + 3] = X[i + 3] / 2 - X[(i + 3) - 1];
1753	}
1754	X[17] = X[17] / 2 - X[16];
1755	}
1756
1757	/*
1758	* NAME: imdct36
1759	* DESCRIPTION: perform X[18]->x[36] IMDCT using Szu-Wei Lee's fast algorithm
1760	*/
1761	static inline
1762	void imdct36(mad_fixed_t const x[18], mad_fixed_t y[36])
1763	{
1764	mad_fixed_t tmp[18];
1765	int i;
1766
1767	/* DCT-IV */
1768
1769	dctIV(x, tmp);
1770
1771	/* convert 18-point DCT-IV to 36-point IMDCT */
1772
1773	for (i = 0; i < 9; i += 3) {
1774	y[i + 0] = tmp[9 + (i + 0)];
1775	y[i + 1] = tmp[9 + (i + 1)];
1776	y[i + 2] = tmp[9 + (i + 2)];
1777	}
1778	for (i = 9; i < 27; i += 3) {
1779	y[i + 0] = -tmp[36 - (9 + (i + 0)) - 1];
1780	y[i + 1] = -tmp[36 - (9 + (i + 1)) - 1];
1781	y[i + 2] = -tmp[36 - (9 + (i + 2)) - 1];
1782	}
1783	for (i = 27; i < 36; i += 3) {
1784	y[i + 0] = -tmp[(i + 0) - 27];
1785	y[i + 1] = -tmp[(i + 1) - 27];
1786	y[i + 2] = -tmp[(i + 2) - 27];
1787	}
1788	}
1789	# else
1790	/*
1791	* NAME: imdct36
1792	* DESCRIPTION: perform X[18]->x[36] IMDCT
1793	*/
1794	static inline
1795	void imdct36(mad_fixed_t const X[18], mad_fixed_t x[36])
1796	{
1797	mad_fixed_t t0, t1, t2, t3, t4, t5, t6, t7;
1798	mad_fixed_t t8, t9, t10, t11, t12, t13, t14, t15;
1799	register mad_fixed64hi_t hi;
1800	register mad_fixed64lo_t lo;
1801
1802	MAD_F_ML0(hi, lo, X[4], MAD_F(0x0ec835e8));
1803	MAD_F_MLA(hi, lo, X[13], MAD_F(0x061f78aa));
1804
1805	t6 = MAD_F_MLZ(hi, lo);
1806
1807	MAD_F_MLA(hi, lo, (t14 = X[1] - X[10]), -MAD_F(0x061f78aa));
1808	MAD_F_MLA(hi, lo, (t15 = X[7] + X[16]), -MAD_F(0x0ec835e8));
1809
1810	t0 = MAD_F_MLZ(hi, lo);
1811
1812	MAD_F_MLA(hi, lo, (t8 = X[0] - X[11] - X[12]), MAD_F(0x0216a2a2));
1813	MAD_F_MLA(hi, lo, (t9 = X[2] - X[9] - X[14]), MAD_F(0x09bd7ca0));
1814	MAD_F_MLA(hi, lo, (t10 = X[3] - X[8] - X[15]), -MAD_F(0x0cb19346));
1815	MAD_F_MLA(hi, lo, (t11 = X[5] - X[6] - X[17]), -MAD_F(0x0fdcf549));
1816
1817	x[7] = MAD_F_MLZ(hi, lo);
1818	x[10] = -x[7];
1819
1820	MAD_F_ML0(hi, lo, t8, -MAD_F(0x0cb19346));
1821	MAD_F_MLA(hi, lo, t9, MAD_F(0x0fdcf549));
1822	MAD_F_MLA(hi, lo, t10, MAD_F(0x0216a2a2));
1823	MAD_F_MLA(hi, lo, t11, -MAD_F(0x09bd7ca0));
1824
1825	x[19] = x[34] = MAD_F_MLZ(hi, lo) - t0;
1826
1827	t12 = X[0] - X[3] + X[8] - X[11] - X[12] + X[15];
1828	t13 = X[2] + X[5] - X[6] - X[9] - X[14] - X[17];
1829
1830	MAD_F_ML0(hi, lo, t12, -MAD_F(0x0ec835e8));
1831	MAD_F_MLA(hi, lo, t13, MAD_F(0x061f78aa));
1832
1833	x[22] = x[31] = MAD_F_MLZ(hi, lo) + t0;
1834
1835	MAD_F_ML0(hi, lo, X[1], -MAD_F(0x09bd7ca0));
1836	MAD_F_MLA(hi, lo, X[7], MAD_F(0x0216a2a2));
1837	MAD_F_MLA(hi, lo, X[10], -MAD_F(0x0fdcf549));
1838	MAD_F_MLA(hi, lo, X[16], MAD_F(0x0cb19346));
1839
1840	t1 = MAD_F_MLZ(hi, lo) + t6;
1841
1842	MAD_F_ML0(hi, lo, X[0], MAD_F(0x03768962));
1843	MAD_F_MLA(hi, lo, X[2], MAD_F(0x0e313245));
1844	MAD_F_MLA(hi, lo, X[3], -MAD_F(0x0ffc19fd));
1845	MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0acf37ad));
1846	MAD_F_MLA(hi, lo, X[6], MAD_F(0x04cfb0e2));
1847	MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0898c779));
1848	MAD_F_MLA(hi, lo, X[9], MAD_F(0x0d7e8807));
1849	MAD_F_MLA(hi, lo, X[11], MAD_F(0x0f426cb5));
1850	MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0bcbe352));
1851	MAD_F_MLA(hi, lo, X[14], MAD_F(0x00b2aa3e));
1852	MAD_F_MLA(hi, lo, X[15], -MAD_F(0x07635284));
1853	MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0f9ee890));
1854
1855	x[6] = MAD_F_MLZ(hi, lo) + t1;
1856	x[11] = -x[6];
1857
1858	MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0f426cb5));
1859	MAD_F_MLA(hi, lo, X[2], -MAD_F(0x00b2aa3e));
1860	MAD_F_MLA(hi, lo, X[3], MAD_F(0x0898c779));
1861	MAD_F_MLA(hi, lo, X[5], MAD_F(0x0f9ee890));
1862	MAD_F_MLA(hi, lo, X[6], MAD_F(0x0acf37ad));
1863	MAD_F_MLA(hi, lo, X[8], -MAD_F(0x07635284));
1864	MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0e313245));
1865	MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0bcbe352));
1866	MAD_F_MLA(hi, lo, X[12], -MAD_F(0x03768962));
1867	MAD_F_MLA(hi, lo, X[14], MAD_F(0x0d7e8807));
1868	MAD_F_MLA(hi, lo, X[15], MAD_F(0x0ffc19fd));
1869	MAD_F_MLA(hi, lo, X[17], MAD_F(0x04cfb0e2));
1870
1871	x[23] = x[30] = MAD_F_MLZ(hi, lo) + t1;
1872
1873	MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0bcbe352));
1874	MAD_F_MLA(hi, lo, X[2], MAD_F(0x0d7e8807));
1875	MAD_F_MLA(hi, lo, X[3], -MAD_F(0x07635284));
1876	MAD_F_MLA(hi, lo, X[5], MAD_F(0x04cfb0e2));
1877	MAD_F_MLA(hi, lo, X[6], MAD_F(0x0f9ee890));
1878	MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0ffc19fd));
1879	MAD_F_MLA(hi, lo, X[9], -MAD_F(0x00b2aa3e));
1880	MAD_F_MLA(hi, lo, X[11], MAD_F(0x03768962));
1881	MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0f426cb5));
1882	MAD_F_MLA(hi, lo, X[14], MAD_F(0x0e313245));
1883	MAD_F_MLA(hi, lo, X[15], MAD_F(0x0898c779));
1884	MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0acf37ad));
1885
1886	x[18] = x[35] = MAD_F_MLZ(hi, lo) - t1;
1887
1888	MAD_F_ML0(hi, lo, X[4], MAD_F(0x061f78aa));
1889	MAD_F_MLA(hi, lo, X[13], -MAD_F(0x0ec835e8));
1890
1891	t7 = MAD_F_MLZ(hi, lo);
1892
1893	MAD_F_MLA(hi, lo, X[1], -MAD_F(0x0cb19346));
1894	MAD_F_MLA(hi, lo, X[7], MAD_F(0x0fdcf549));
1895	MAD_F_MLA(hi, lo, X[10], MAD_F(0x0216a2a2));
1896	MAD_F_MLA(hi, lo, X[16], -MAD_F(0x09bd7ca0));
1897
1898	t2 = MAD_F_MLZ(hi, lo);
1899
1900	MAD_F_MLA(hi, lo, X[0], MAD_F(0x04cfb0e2));
1901	MAD_F_MLA(hi, lo, X[2], MAD_F(0x0ffc19fd));
1902	MAD_F_MLA(hi, lo, X[3], -MAD_F(0x0d7e8807));
1903	MAD_F_MLA(hi, lo, X[5], MAD_F(0x03768962));
1904	MAD_F_MLA(hi, lo, X[6], -MAD_F(0x0bcbe352));
1905	MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0e313245));
1906	MAD_F_MLA(hi, lo, X[9], MAD_F(0x07635284));
1907	MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0acf37ad));
1908	MAD_F_MLA(hi, lo, X[12], MAD_F(0x0f9ee890));
1909	MAD_F_MLA(hi, lo, X[14], MAD_F(0x0898c779));
1910	MAD_F_MLA(hi, lo, X[15], MAD_F(0x00b2aa3e));
1911	MAD_F_MLA(hi, lo, X[17], MAD_F(0x0f426cb5));
1912
1913	x[5] = MAD_F_MLZ(hi, lo);
1914	x[12] = -x[5];
1915
1916	MAD_F_ML0(hi, lo, X[0], MAD_F(0x0acf37ad));
1917	MAD_F_MLA(hi, lo, X[2], -MAD_F(0x0898c779));
1918	MAD_F_MLA(hi, lo, X[3], MAD_F(0x0e313245));
1919	MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0f426cb5));
1920	MAD_F_MLA(hi, lo, X[6], -MAD_F(0x03768962));
1921	MAD_F_MLA(hi, lo, X[8], MAD_F(0x00b2aa3e));
1922	MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0ffc19fd));
1923	MAD_F_MLA(hi, lo, X[11], MAD_F(0x0f9ee890));
1924	MAD_F_MLA(hi, lo, X[12], -MAD_F(0x04cfb0e2));
1925	MAD_F_MLA(hi, lo, X[14], MAD_F(0x07635284));
1926	MAD_F_MLA(hi, lo, X[15], MAD_F(0x0d7e8807));
1927	MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0bcbe352));
1928
1929	x[0] = MAD_F_MLZ(hi, lo) + t2;
1930	x[17] = -x[0];
1931
1932	MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0f9ee890));
1933	MAD_F_MLA(hi, lo, X[2], -MAD_F(0x07635284));
1934	MAD_F_MLA(hi, lo, X[3], -MAD_F(0x00b2aa3e));
1935	MAD_F_MLA(hi, lo, X[5], MAD_F(0x0bcbe352));
1936	MAD_F_MLA(hi, lo, X[6], MAD_F(0x0f426cb5));
1937	MAD_F_MLA(hi, lo, X[8], MAD_F(0x0d7e8807));
1938	MAD_F_MLA(hi, lo, X[9], MAD_F(0x0898c779));
1939	MAD_F_MLA(hi, lo, X[11], -MAD_F(0x04cfb0e2));
1940	MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0acf37ad));
1941	MAD_F_MLA(hi, lo, X[14], -MAD_F(0x0ffc19fd));
1942	MAD_F_MLA(hi, lo, X[15], -MAD_F(0x0e313245));
1943	MAD_F_MLA(hi, lo, X[17], -MAD_F(0x03768962));
1944
1945	x[24] = x[29] = MAD_F_MLZ(hi, lo) + t2;
1946
1947	MAD_F_ML0(hi, lo, X[1], -MAD_F(0x0216a2a2));
1948	MAD_F_MLA(hi, lo, X[7], -MAD_F(0x09bd7ca0));
1949	MAD_F_MLA(hi, lo, X[10], MAD_F(0x0cb19346));
1950	MAD_F_MLA(hi, lo, X[16], MAD_F(0x0fdcf549));
1951
1952	t3 = MAD_F_MLZ(hi, lo) + t7;
1953
1954	MAD_F_ML0(hi, lo, X[0], MAD_F(0x00b2aa3e));
1955	MAD_F_MLA(hi, lo, X[2], MAD_F(0x03768962));
1956	MAD_F_MLA(hi, lo, X[3], -MAD_F(0x04cfb0e2));
1957	MAD_F_MLA(hi, lo, X[5], -MAD_F(0x07635284));
1958	MAD_F_MLA(hi, lo, X[6], MAD_F(0x0898c779));
1959	MAD_F_MLA(hi, lo, X[8], MAD_F(0x0acf37ad));
1960	MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0bcbe352));
1961	MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0d7e8807));
1962	MAD_F_MLA(hi, lo, X[12], MAD_F(0x0e313245));
1963	MAD_F_MLA(hi, lo, X[14], MAD_F(0x0f426cb5));
1964	MAD_F_MLA(hi, lo, X[15], -MAD_F(0x0f9ee890));
1965	MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0ffc19fd));
1966
1967	x[8] = MAD_F_MLZ(hi, lo) + t3;
1968	x[9] = -x[8];
1969
1970	MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0e313245));
1971	MAD_F_MLA(hi, lo, X[2], MAD_F(0x0bcbe352));
1972	MAD_F_MLA(hi, lo, X[3], MAD_F(0x0f9ee890));
1973	MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0898c779));
1974	MAD_F_MLA(hi, lo, X[6], -MAD_F(0x0ffc19fd));
1975	MAD_F_MLA(hi, lo, X[8], MAD_F(0x04cfb0e2));
1976	MAD_F_MLA(hi, lo, X[9], MAD_F(0x0f426cb5));
1977	MAD_F_MLA(hi, lo, X[11], -MAD_F(0x00b2aa3e));
1978	MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0d7e8807));
1979	MAD_F_MLA(hi, lo, X[14], -MAD_F(0x03768962));
1980	MAD_F_MLA(hi, lo, X[15], MAD_F(0x0acf37ad));
1981	MAD_F_MLA(hi, lo, X[17], MAD_F(0x07635284));
1982
1983	x[21] = x[32] = MAD_F_MLZ(hi, lo) + t3;
1984
1985	MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0d7e8807));
1986	MAD_F_MLA(hi, lo, X[2], MAD_F(0x0f426cb5));
1987	MAD_F_MLA(hi, lo, X[3], MAD_F(0x0acf37ad));
1988	MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0ffc19fd));
1989	MAD_F_MLA(hi, lo, X[6], -MAD_F(0x07635284));
1990	MAD_F_MLA(hi, lo, X[8], MAD_F(0x0f9ee890));
1991	MAD_F_MLA(hi, lo, X[9], MAD_F(0x03768962));
1992	MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0e313245));
1993	MAD_F_MLA(hi, lo, X[12], MAD_F(0x00b2aa3e));
1994	MAD_F_MLA(hi, lo, X[14], MAD_F(0x0bcbe352));
1995	MAD_F_MLA(hi, lo, X[15], -MAD_F(0x04cfb0e2));
1996	MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0898c779));
1997
1998	x[20] = x[33] = MAD_F_MLZ(hi, lo) - t3;
1999
2000	MAD_F_ML0(hi, lo, t14, -MAD_F(0x0ec835e8));
2001	MAD_F_MLA(hi, lo, t15, MAD_F(0x061f78aa));
2002
2003	t4 = MAD_F_MLZ(hi, lo) - t7;
2004
2005	MAD_F_ML0(hi, lo, t12, MAD_F(0x061f78aa));
2006	MAD_F_MLA(hi, lo, t13, MAD_F(0x0ec835e8));
2007
2008	x[4] = MAD_F_MLZ(hi, lo) + t4;
2009	x[13] = -x[4];
2010
2011	MAD_F_ML0(hi, lo, t8, MAD_F(0x09bd7ca0));
2012	MAD_F_MLA(hi, lo, t9, -MAD_F(0x0216a2a2));
2013	MAD_F_MLA(hi, lo, t10, MAD_F(0x0fdcf549));
2014	MAD_F_MLA(hi, lo, t11, -MAD_F(0x0cb19346));
2015
2016	x[1] = MAD_F_MLZ(hi, lo) + t4;
2017	x[16] = -x[1];
2018
2019	MAD_F_ML0(hi, lo, t8, -MAD_F(0x0fdcf549));
2020	MAD_F_MLA(hi, lo, t9, -MAD_F(0x0cb19346));
2021	MAD_F_MLA(hi, lo, t10, -MAD_F(0x09bd7ca0));
2022	MAD_F_MLA(hi, lo, t11, -MAD_F(0x0216a2a2));
2023
2024	x[25] = x[28] = MAD_F_MLZ(hi, lo) + t4;
2025
2026	MAD_F_ML0(hi, lo, X[1], -MAD_F(0x0fdcf549));
2027	MAD_F_MLA(hi, lo, X[7], -MAD_F(0x0cb19346));
2028	MAD_F_MLA(hi, lo, X[10], -MAD_F(0x09bd7ca0));
2029	MAD_F_MLA(hi, lo, X[16], -MAD_F(0x0216a2a2));
2030
2031	t5 = MAD_F_MLZ(hi, lo) - t6;
2032
2033	MAD_F_ML0(hi, lo, X[0], MAD_F(0x0898c779));
2034	MAD_F_MLA(hi, lo, X[2], MAD_F(0x04cfb0e2));
2035	MAD_F_MLA(hi, lo, X[3], MAD_F(0x0bcbe352));
2036	MAD_F_MLA(hi, lo, X[5], MAD_F(0x00b2aa3e));
2037	MAD_F_MLA(hi, lo, X[6], MAD_F(0x0e313245));
2038	MAD_F_MLA(hi, lo, X[8], -MAD_F(0x03768962));
2039	MAD_F_MLA(hi, lo, X[9], MAD_F(0x0f9ee890));
2040	MAD_F_MLA(hi, lo, X[11], -MAD_F(0x07635284));
2041	MAD_F_MLA(hi, lo, X[12], MAD_F(0x0ffc19fd));
2042	MAD_F_MLA(hi, lo, X[14], -MAD_F(0x0acf37ad));
2043	MAD_F_MLA(hi, lo, X[15], MAD_F(0x0f426cb5));
2044	MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0d7e8807));
2045
2046	x[2] = MAD_F_MLZ(hi, lo) + t5;
2047	x[15] = -x[2];
2048
2049	MAD_F_ML0(hi, lo, X[0], MAD_F(0x07635284));
2050	MAD_F_MLA(hi, lo, X[2], MAD_F(0x0acf37ad));
2051	MAD_F_MLA(hi, lo, X[3], MAD_F(0x03768962));
2052	MAD_F_MLA(hi, lo, X[5], MAD_F(0x0d7e8807));
2053	MAD_F_MLA(hi, lo, X[6], -MAD_F(0x00b2aa3e));
2054	MAD_F_MLA(hi, lo, X[8], MAD_F(0x0f426cb5));
2055	MAD_F_MLA(hi, lo, X[9], -MAD_F(0x04cfb0e2));
2056	MAD_F_MLA(hi, lo, X[11], MAD_F(0x0ffc19fd));
2057	MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0898c779));
2058	MAD_F_MLA(hi, lo, X[14], MAD_F(0x0f9ee890));
2059	MAD_F_MLA(hi, lo, X[15], -MAD_F(0x0bcbe352));
2060	MAD_F_MLA(hi, lo, X[17], MAD_F(0x0e313245));
2061
2062	x[3] = MAD_F_MLZ(hi, lo) + t5;
2063	x[14] = -x[3];
2064
2065	MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0ffc19fd));
2066	MAD_F_MLA(hi, lo, X[2], -MAD_F(0x0f9ee890));
2067	MAD_F_MLA(hi, lo, X[3], -MAD_F(0x0f426cb5));
2068	MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0e313245));
2069	MAD_F_MLA(hi, lo, X[6], -MAD_F(0x0d7e8807));
2070	MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0bcbe352));
2071	MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0acf37ad));
2072	MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0898c779));
2073	MAD_F_MLA(hi, lo, X[12], -MAD_F(0x07635284));
2074	MAD_F_MLA(hi, lo, X[14], -MAD_F(0x04cfb0e2));
2075	MAD_F_MLA(hi, lo, X[15], -MAD_F(0x03768962));
2076	MAD_F_MLA(hi, lo, X[17], -MAD_F(0x00b2aa3e));
2077
2078	x[26] = x[27] = MAD_F_MLZ(hi, lo) + t5;
2079	}
2080	# endif
2081
2082	/*
2083	* NAME: III_imdct_l()
2084	* DESCRIPTION: perform IMDCT and windowing for long blocks
2085	*/
2086	static
2087	void III_imdct_l(mad_fixed_t const X[18], mad_fixed_t z[36],
2088	unsigned int block_type)
2089	{
2090	unsigned int i;
2091
2092	/* IMDCT */
2093
2094	imdct36(X, z);
2095
2096	/* windowing */
2097
2098	switch (block_type) {
2099	case 0: /* normal window */
2100	# if defined(ASO_INTERLEAVE1)
2101	{
2102	register mad_fixed_t tmp1, tmp2;
2103
2104	tmp1 = window_l[0];
2105	tmp2 = window_l[1];
2106
2107	for (i = 0; i < 34; i += 2) {
2108	z[i + 0] = mad_f_mul(z[i + 0], tmp1);
2109	tmp1 = window_l[i + 2];
2110	z[i + 1] = mad_f_mul(z[i + 1], tmp2);
2111	tmp2 = window_l[i + 3];
2112	}
2113
2114	z[34] = mad_f_mul(z[34], tmp1);
2115	z[35] = mad_f_mul(z[35], tmp2);
2116	}
2117	# elif defined(ASO_INTERLEAVE2)
2118	{
2119	register mad_fixed_t tmp1, tmp2;
2120
2121	tmp1 = z[0];
2122	tmp2 = window_l[0];
2123
2124	for (i = 0; i < 35; ++i) {
2125	z[i] = mad_f_mul(tmp1, tmp2);
2126	tmp1 = z[i + 1];
2127	tmp2 = window_l[i + 1];
2128	}
2129
2130	z[35] = mad_f_mul(tmp1, tmp2);
2131	}
2132	# elif 1
2133	for (i = 0; i < 36; i += 4) {
2134	z[i + 0] = mad_f_mul(z[i + 0], window_l[i + 0]);
2135	z[i + 1] = mad_f_mul(z[i + 1], window_l[i + 1]);
2136	z[i + 2] = mad_f_mul(z[i + 2], window_l[i + 2]);
2137	z[i + 3] = mad_f_mul(z[i + 3], window_l[i + 3]);
2138	}
2139	# else
2140	for (i = 0; i < 36; ++i) {
2141	z[i] = mad_f_mul(z[i], window_l[i]);
2142	}
2143	# endif
2144	break;
2145
2146	case 1: /* start block */
2147	for (i = 0; i < 18; i += 3) {
2148	z[i + 0] = mad_f_mul(z[i + 0], window_l[i + 0]);
2149	z[i + 1] = mad_f_mul(z[i + 1], window_l[i + 1]);
2150	z[i + 2] = mad_f_mul(z[i + 2], window_l[i + 2]);
2151	}
2152	/* (i = 18; i < 24; ++i) z[i] unchanged */
2153	for (i = 24; i < 30; ++i) {
2154	z[i] = mad_f_mul(z[i], window_s[i - 18]);
2155	}
2156	for (i = 30; i < 36; ++i) {
2157	z[i] = 0;
2158	}
2159	break;
2160
2161	case 3: /* stop block */
2162	for (i = 0; i < 6; ++i) {
2163	z[i] = 0;
2164	}
2165	for (i = 6; i < 12; ++i) {
2166	z[i] = mad_f_mul(z[i], window_s[i - 6]);
2167	}
2168	/* (i = 12; i < 18; ++i) z[i] unchanged */
2169	for (i = 18; i < 36; i += 3) {
2170	z[i + 0] = mad_f_mul(z[i + 0], window_l[i + 0]);
2171	z[i + 1] = mad_f_mul(z[i + 1], window_l[i + 1]);
2172	z[i + 2] = mad_f_mul(z[i + 2], window_l[i + 2]);
2173	}
2174	break;
2175	}
2176	}
2177	# endif /* ASO_IMDCT */
2178
2179	/*
2180	* NAME: III_imdct_s()
2181	* DESCRIPTION: perform IMDCT and windowing for short blocks
2182	*/
2183	static
2184	void III_imdct_s(mad_fixed_t const X[18], mad_fixed_t z[36])
2185	{
2186	mad_fixed_t y[36], *yptr;
2187	mad_fixed_t const *wptr;
2188	int w, i;
2189	register mad_fixed64hi_t hi;
2190	register mad_fixed64lo_t lo;
2191
2192	/* IMDCT */
2193
2194	yptr = &y[0];
2195
2196	for (w = 0; w < 3; ++w) {
2197	register mad_fixed_t const(*s)[6];
2198
2199	s = imdct_s;
2200
2201	for (i = 0; i < 3; ++i) {
2202	MAD_F_ML0(hi, lo, X[0], (*s)[0]);
2203	MAD_F_MLA(hi, lo, X[1], (*s)[1]);
2204	MAD_F_MLA(hi, lo, X[2], (*s)[2]);
2205	MAD_F_MLA(hi, lo, X[3], (*s)[3]);
2206	MAD_F_MLA(hi, lo, X[4], (*s)[4]);
2207	MAD_F_MLA(hi, lo, X[5], (*s)[5]);
2208
2209	yptr[i + 0] = MAD_F_MLZ(hi, lo);
2210	yptr[5 - i] = -yptr[i + 0];
2211
2212	++s;
2213
2214	MAD_F_ML0(hi, lo, X[0], (*s)[0]);
2215	MAD_F_MLA(hi, lo, X[1], (*s)[1]);
2216	MAD_F_MLA(hi, lo, X[2], (*s)[2]);
2217	MAD_F_MLA(hi, lo, X[3], (*s)[3]);
2218	MAD_F_MLA(hi, lo, X[4], (*s)[4]);
2219	MAD_F_MLA(hi, lo, X[5], (*s)[5]);
2220
2221	yptr[ i + 6] = MAD_F_MLZ(hi, lo);
2222	yptr[11 - i] = yptr[i + 6];
2223
2224	++s;
2225	}
2226
2227	yptr += 12;
2228	X += 6;
2229	}
2230
2231	/* windowing, overlapping and concatenation */
2232
2233	yptr = &y[0];
2234	wptr = &window_s[0];
2235
2236	for (i = 0; i < 6; ++i) {
2237	z[i + 0] = 0;
2238	z[i + 6] = mad_f_mul(yptr[ 0 + 0], wptr[0]);
2239
2240	MAD_F_ML0(hi, lo, yptr[ 0 + 6], wptr[6]);
2241	MAD_F_MLA(hi, lo, yptr[12 + 0], wptr[0]);
2242
2243	z[i + 12] = MAD_F_MLZ(hi, lo);
2244
2245	MAD_F_ML0(hi, lo, yptr[12 + 6], wptr[6]);
2246	MAD_F_MLA(hi, lo, yptr[24 + 0], wptr[0]);
2247
2248	z[i + 18] = MAD_F_MLZ(hi, lo);
2249
2250	z[i + 24] = mad_f_mul(yptr[24 + 6], wptr[6]);
2251	z[i + 30] = 0;
2252
2253	++yptr;
2254	++wptr;
2255	}
2256	}
2257
2258	/*
2259	* NAME: III_overlap()
2260	* DESCRIPTION: perform overlap-add of windowed IMDCT outputs
2261	*/
2262	static
2263	void III_overlap(mad_fixed_t const output[36], mad_fixed_t overlap[18],
2264	mad_fixed_t sample[18][32], unsigned int sb)
2265	{
2266	unsigned int i;
2267
2268	# if defined(ASO_INTERLEAVE2)
2269	{
2270	register mad_fixed_t tmp1, tmp2;
2271
2272	tmp1 = overlap[0];
2273	tmp2 = overlap[1];
2274
2275	for (i = 0; i < 16; i += 2) {
2276	sample[i + 0][sb] = output[i + 0 + 0] + tmp1;
2277	overlap[i + 0] = output[i + 0 + 18];
2278	tmp1 = overlap[i + 2];
2279
2280	sample[i + 1][sb] = output[i + 1 + 0] + tmp2;
2281	overlap[i + 1] = output[i + 1 + 18];
2282	tmp2 = overlap[i + 3];
2283	}
2284
2285	sample[16][sb] = output[16 + 0] + tmp1;
2286	overlap[16] = output[16 + 18];
2287	sample[17][sb] = output[17 + 0] + tmp2;
2288	overlap[17] = output[17 + 18];
2289	}
2290	# elif 0
2291	for (i = 0; i < 18; i += 2) {
2292	sample[i + 0][sb] = output[i + 0 + 0] + overlap[i + 0];
2293	overlap[i + 0] = output[i + 0 + 18];
2294
2295	sample[i + 1][sb] = output[i + 1 + 0] + overlap[i + 1];
2296	overlap[i + 1] = output[i + 1 + 18];
2297	}
2298	# else
2299	for (i = 0; i < 18; ++i) {
2300	sample[i][sb] = output[i + 0] + overlap[i];
2301	overlap[i] = output[i + 18];
2302	}
2303	# endif
2304	}
2305
2306	/*
2307	* NAME: III_overlap_z()
2308	* DESCRIPTION: perform "overlap-add" of zero IMDCT outputs
2309	*/
2310	static inline
2311	void III_overlap_z(mad_fixed_t overlap[18],
2312	mad_fixed_t sample[18][32], unsigned int sb)
2313	{
2314	unsigned int i;
2315
2316	# if defined(ASO_INTERLEAVE2)
2317	{
2318	register mad_fixed_t tmp1, tmp2;
2319
2320	tmp1 = overlap[0];
2321	tmp2 = overlap[1];
2322
2323	for (i = 0; i < 16; i += 2) {
2324	sample[i + 0][sb] = tmp1;
2325	overlap[i + 0] = 0;
2326	tmp1 = overlap[i + 2];
2327
2328	sample[i + 1][sb] = tmp2;
2329	overlap[i + 1] = 0;
2330	tmp2 = overlap[i + 3];
2331	}
2332
2333	sample[16][sb] = tmp1;
2334	overlap[16] = 0;
2335	sample[17][sb] = tmp2;
2336	overlap[17] = 0;
2337	}
2338	# else
2339	for (i = 0; i < 18; ++i) {
2340	sample[i][sb] = overlap[i];
2341	overlap[i] = 0;
2342	}
2343	# endif
2344	}
2345
2346	/*
2347	* NAME: III_freqinver()
2348	* DESCRIPTION: perform subband frequency inversion for odd sample lines
2349	*/
2350	static
2351	void III_freqinver(mad_fixed_t sample[18][32], unsigned int sb)
2352	{
2353	unsigned int i;
2354
2355	# if 1 || defined(ASO_INTERLEAVE1) || defined(ASO_INTERLEAVE2)
2356	{
2357	register mad_fixed_t tmp1, tmp2;
2358
2359	tmp1 = sample[1][sb];
2360	tmp2 = sample[3][sb];
2361
2362	for (i = 1; i < 13; i += 4) {
2363	sample[i + 0][sb] = -tmp1;
2364	tmp1 = sample[i + 4][sb];
2365	sample[i + 2][sb] = -tmp2;
2366	tmp2 = sample[i + 6][sb];
2367	}
2368
2369	sample[13][sb] = -tmp1;
2370	tmp1 = sample[17][sb];
2371	sample[15][sb] = -tmp2;
2372	sample[17][sb] = -tmp1;
2373	}
2374	# else
2375	for (i = 1; i < 18; i += 2) {
2376	sample[i][sb] = -sample[i][sb];
2377	}
2378	# endif
2379	}
2380
2381	/*
2382	* NAME: III_decode()
2383	* DESCRIPTION: decode frame main_data
2384	*/
2385	static
2386	enum mad_error III_decode(struct mad_bitptr *ptr, struct mad_frame *frame,
2387	struct sideinfo *si, unsigned int nch)
2388	{
2389	struct mad_header *header = &frame->header;
2390	unsigned int sfreqi, ngr, gr;
2391
2392	{
2393	unsigned int sfreq;
2394
2395	sfreq = header->samplerate;
2396	if (header->flags & MAD_FLAG_MPEG_2_5_EXT) {
2397	sfreq *= 2;
2398	}
2399
2400	/* 48000 => 0, 44100 => 1, 32000 => 2,
2401	24000 => 3, 22050 => 4, 16000 => 5 */
2402	sfreqi = ((sfreq >> 7) & 0x000f) +
2403	((sfreq >> 15) & 0x0001) - 8;
2404
2405	if (header->flags & MAD_FLAG_MPEG_2_5_EXT) {
2406	sfreqi += 3;
2407	}
2408	}
2409
2410	/* scalefactors, Huffman decoding, requantization */
2411
2412	ngr = (header->flags & MAD_FLAG_LSF_EXT) ? 1 : 2;
2413
2414	for (gr = 0; gr < ngr; ++gr) {
2415	struct granule *granule = &si->gr[gr];
2416	unsigned char const *sfbwidth[2];
2417	mad_fixed_t xr[2][576];
2418	unsigned int ch;
2419	enum mad_error error;
2420
2421	for (ch = 0; ch < nch; ++ch) {
2422	struct channel *channel = &granule->ch[ch];
2423	unsigned int part2_length;
2424
2425	sfbwidth[ch] = sfbwidth_table[sfreqi].l;
2426	if (channel->block_type == 2) {
2427	sfbwidth[ch] = (channel->flags & mixed_block_flag) ?
2428	sfbwidth_table[sfreqi].m : sfbwidth_table[sfreqi].s;
2429	}
2430
2431	if (header->flags & MAD_FLAG_LSF_EXT) {
2432	part2_length = III_scalefactors_lsf(ptr, channel,
2433	ch == 0 ? 0 : &si->gr[1].ch[1],
2434	header->mode_extension);
2435	} else {
2436	part2_length = III_scalefactors(ptr, channel, &si->gr[0].ch[ch],
2437	gr == 0 ? 0 : si->scfsi[ch]);
2438	}
2439
2440	error = III_huffdecode(ptr, xr[ch], channel, sfbwidth[ch], part2_length);
2441	if (error) {
2442	return error;
2443	}
2444	}
2445
2446	/* joint stereo processing */
2447
2448	if (header->mode == MAD_MODE_JOINT_STEREO && header->mode_extension) {
2449	error = III_stereo(xr, granule, header, sfbwidth[0]);
2450	if (error) {
2451	return error;
2452	}
2453	}
2454
2455	/* reordering, alias reduction, IMDCT, overlap-add, frequency inversion */
2456
2457	for (ch = 0; ch < nch; ++ch) {
2458	struct channel const *channel = &granule->ch[ch];
2459	mad_fixed_t (*sample)[32] = &frame->sbsample[ch][18 * gr];
2460	unsigned int sb, l, i, sblimit;
2461	mad_fixed_t output[36];
2462
2463	if (channel->block_type == 2) {
2464	III_reorder(xr[ch], channel, sfbwidth[ch]);
2465
2466	# if !defined(OPT_STRICT)
2467	/*
2468	* According to ISO/IEC 11172-3, "Alias reduction is not applied for
2469	* granules with block_type == 2 (short block)." However, other
2470	* sources suggest alias reduction should indeed be performed on the
2471	* lower two subbands of mixed blocks. Most other implementations do
2472	* this, so by default we will too.
2473	*/
2474	if (channel->flags & mixed_block_flag) {
2475	III_aliasreduce(xr[ch], 36);
2476	}
2477	# endif
2478	} else {
2479	III_aliasreduce(xr[ch], 576);
2480	}
2481
2482	l = 0;
2483
2484	/* subbands 0-1 */
2485
2486	if (channel->block_type != 2 || (channel->flags & mixed_block_flag)) {
2487	unsigned int block_type;
2488
2489	block_type = channel->block_type;
2490	if (channel->flags & mixed_block_flag) {
2491	block_type = 0;
2492	}
2493
2494	/* long blocks */
2495	for (sb = 0; sb < 2; ++sb, l += 18) {
2496	III_imdct_l(&xr[ch][l], output, block_type);
2497	III_overlap(output, (*frame->overlap)[ch][sb], sample, sb);
2498	}
2499	} else {
2500	/* short blocks */
2501	for (sb = 0; sb < 2; ++sb, l += 18) {
2502	III_imdct_s(&xr[ch][l], output);
2503	III_overlap(output, (*frame->overlap)[ch][sb], sample, sb);
2504	}
2505	}
2506
2507	III_freqinver(sample, 1);
2508
2509	/* (nonzero) subbands 2-31 */
2510
2511	i = 576;
2512	while (i > 36 && xr[ch][i - 1] == 0) {
2513	--i;
2514	}
2515
2516	sblimit = 32 - (576 - i) / 18;
2517
2518	if (channel->block_type != 2) {
2519	/* long blocks */
2520	for (sb = 2; sb < sblimit; ++sb, l += 18) {
2521	III_imdct_l(&xr[ch][l], output, channel->block_type);
2522	III_overlap(output, (*frame->overlap)[ch][sb], sample, sb);
2523
2524	if (sb & 1) {
2525	III_freqinver(sample, sb);
2526	}
2527	}
2528	} else {
2529	/* short blocks */
2530	for (sb = 2; sb < sblimit; ++sb, l += 18) {
2531	III_imdct_s(&xr[ch][l], output);
2532	III_overlap(output, (*frame->overlap)[ch][sb], sample, sb);
2533
2534	if (sb & 1) {
2535	III_freqinver(sample, sb);
2536	}
2537	}
2538	}
2539
2540	/* remaining (zero) subbands */
2541
2542	for (sb = sblimit; sb < 32; ++sb) {
2543	III_overlap_z((*frame->overlap)[ch][sb], sample, sb);
2544
2545	if (sb & 1) {
2546	III_freqinver(sample, sb);
2547	}
2548	}
2549	}
2550	}
2551
2552	return MAD_ERROR_NONE;
2553	}
2554
2555	/*
2556	* NAME: layer->III()
2557	* DESCRIPTION: decode a single Layer III frame
2558	*/
2559
2560	int mad_layer_III(struct mad_stream *stream, struct mad_frame *frame)
2561	{
2562	struct mad_header *header = &frame->header;
2563	unsigned int nch, priv_bitlen, next_md_begin = 0;
2564	unsigned int si_len, data_bitlen, md_len;
2565	unsigned int frame_space, frame_used, frame_free;
2566	struct mad_bitptr ptr;
2567	struct sideinfo si;
2568	enum mad_error error;
2569	int result = 0;
2570
2571	/* allocate Layer III dynamic structures */
2572
2573	if (stream->main_data == 0) {
2574	stream->main_data = malloc(MAD_BUFFER_MDLEN);
2575	if (stream->main_data == 0) {
2576	stream->error = MAD_ERROR_NOMEM;
2577	return -1;
2578	}
2579	}
2580
2581	if (frame->overlap == 0) {
2582	frame->overlap = calloc(2 * 32 * 18, sizeof(mad_fixed_t));
2583	if (frame->overlap == 0) {
2584	stream->error = MAD_ERROR_NOMEM;
2585	return -1;
2586	}
2587	}
2588
2589	nch = MAD_NCHANNELS(header);
2590	si_len = (header->flags & MAD_FLAG_LSF_EXT) ?
2591	(nch == 1 ? 9 : 17) : (nch == 1 ? 17 : 32);
2592
2593	/* check frame sanity */
2594
2595	if (stream->next_frame - mad_bit_nextbyte(&stream->ptr) <
2596	(signed int) si_len) {
2597	stream->error = MAD_ERROR_BADFRAMELEN;
2598	stream->md_len = 0;
2599	return -1;
2600	}
2601
2602	/* check CRC word */
2603
2604	if (header->flags & MAD_FLAG_PROTECTION) {
2605	header->crc_check =
2606	mad_bit_crc(stream->ptr, si_len * CHAR_BIT, header->crc_check);
2607
2608	if (header->crc_check != header->crc_target &&
2609	!(frame->options & MAD_OPTION_IGNORECRC)) {
2610	stream->error = MAD_ERROR_BADCRC;
2611	result = -1;
2612	}
2613	}
2614
2615	/* decode frame side information */
2616
2617	error = III_sideinfo(&stream->ptr, nch, header->flags & MAD_FLAG_LSF_EXT,
2618	&si, &data_bitlen, &priv_bitlen);
2619	if (error && result == 0) {
2620	stream->error = error;
2621	result = -1;
2622	}
2623
2624	header->flags |= priv_bitlen;
2625	header->private_bits |= si.private_bits;
2626
2627	/* find main_data of next frame */
2628
2629	{
2630	struct mad_bitptr peek;
2631	unsigned long header;
2632
2633	mad_bit_init(&peek, stream->next_frame);
2634
2635	header = mad_bit_read(&peek, 32);
2636	if ((header & 0xffe60000L) /* syncword | layer */ == 0xffe20000L) {
2637	if (!(header & 0x00010000L)) { /* protection_bit */
2638	mad_bit_skip(&peek, 16); /* crc_check */
2639	}
2640
2641	next_md_begin =
2642	mad_bit_read(&peek, (header & 0x00080000L) /* ID */ ? 9 : 8);
2643	}
2644
2645	mad_bit_finish(&peek);
2646	}
2647
2648	/* find main_data of this frame */
2649
2650	frame_space = stream->next_frame - mad_bit_nextbyte(&stream->ptr);
2651
2652	if (next_md_begin > si.main_data_begin + frame_space) {
2653	next_md_begin = 0;
2654	}
2655
2656	md_len = si.main_data_begin + frame_space - next_md_begin;
2657
2658	frame_used = 0;
2659
2660	if (si.main_data_begin == 0) {
2661	ptr = stream->ptr;
2662	stream->md_len = 0;
2663
2664	frame_used = md_len;
2665	} else {
2666	if (si.main_data_begin > stream->md_len) {
2667	if (result == 0) {
2668	stream->error = MAD_ERROR_BADDATAPTR;
2669	result = -1;
2670	}
2671	} else {
2672	mad_bit_init(&ptr,
2673	*stream->main_data + stream->md_len - si.main_data_begin);
2674
2675	if (md_len > si.main_data_begin) {
2676	assert(stream->md_len + md_len -
2677	si.main_data_begin <= MAD_BUFFER_MDLEN);
2678
2679	memcpy(*stream->main_data + stream->md_len,
2680	mad_bit_nextbyte(&stream->ptr),
2681	frame_used = md_len - si.main_data_begin);
2682	stream->md_len += frame_used;
2683	}
2684	}
2685	}
2686
2687	frame_free = frame_space - frame_used;
2688
2689	/* decode main_data */
2690
2691	if (result == 0) {
2692	error = III_decode(&ptr, frame, &si, nch);
2693	if (error) {
2694	stream->error = error;
2695	result = -1;
2696	}
2697
2698	/* designate ancillary bits */
2699
2700	stream->anc_ptr = ptr;
2701	stream->anc_bitlen = md_len * CHAR_BIT - data_bitlen;
2702	}
2703
2704	# if 0 && defined(DEBUG)
2705	fprintf(stderr,
2706	"main_data_begin:%u, md_len:%u, frame_free:%u, "
2707	"data_bitlen:%u, anc_bitlen: %u\n",
2708	si.main_data_begin, md_len, frame_free,
2709	data_bitlen, stream->anc_bitlen);
2710	# endif
2711
2712	/* preload main_data buffer with up to 511 bytes for next frame(s) */
2713
2714	if (frame_free >= next_md_begin) {
2715	memcpy(*stream->main_data,
2716	stream->next_frame - next_md_begin, next_md_begin);
2717	stream->md_len = next_md_begin;
2718	} else {
2719	if (md_len < si.main_data_begin) {
2720	unsigned int extra;
2721
2722	extra = si.main_data_begin - md_len;
2723	if (extra + frame_free > next_md_begin) {
2724	extra = next_md_begin - frame_free;
2725	}
2726
2727	if (extra < stream->md_len) {
2728	memmove(*stream->main_data,
2729	*stream->main_data + stream->md_len - extra, extra);
2730	stream->md_len = extra;
2731	}
2732	} else {
2733	stream->md_len = 0;
2734	}
2735
2736	memcpy(*stream->main_data + stream->md_len,
2737	stream->next_frame - frame_free, frame_free);
2738	stream->md_len += frame_free;
2739	}
2740
2741	return result;
2742	}
2743