The OpenD Programming Language

1 /*
2     https://github.com/lieff/minimp3
3     To the extent possible under law, the author(s) have dedicated all copyright and related and neighboring rights to this software to the public domain worldwide.
4     This software is distributed without any warranty.
5     See <http://creativecommons.org/publicdomain/zero/1.0/>.
6 */
7 /**
8   Translated to D by Guillaume Piolat.
9   Stripped down a bit for the needs of audio-formats.
10 */
11 module audioformats.minimp3;
12 
13 import core.stdc.stdlib;
14 import core.stdc.string;
15 
16 nothrow:
17 @nogc:
18 
19 alias uint8_t = ubyte;
20 alias uint16_t = ushort;
21 alias uint32_t = uint;
22 alias uint64_t = ulong;
23 alias int16_t = short;
24 alias int32_t = int;
25 
26 enum MINIMP3_MAX_SAMPLES_PER_FRAME = (1152*2);
27 
28 struct mp3dec_frame_info_t
29 {
30     int frame_bytes;
31     int frame_offset;
32     int channels;
33     int hz;
34     int layer;
35     int bitrate_kbps;
36 }
37 
38 struct mp3dec_t
39 {
40     float[9*32][2] mdct_overlap;
41     float[15*2*32] qmf_state;
42     int reserv;
43     int free_format_bytes;
44     ubyte[4] header;
45     ubyte[511] reserv_buf;
46 }
47 
48 version = MINIMP3_FLOAT_OUTPUT;
49 
50 
51 alias mp3d_sample_t = float;
52 
53 enum MAX_FREE_FORMAT_FRAME_SIZE = 2304;    /* more than ISO spec's */
54 enum MAX_FRAME_SYNC_MATCHES = 10;
55 
56 enum MAX_L3_FRAME_PAYLOAD_BYTES = MAX_FREE_FORMAT_FRAME_SIZE; /* MUST be >= 320000/8/32000*1152 = 1440 */
57 
58 enum MAX_BITRESERVOIR_BYTES      = 511;
59 enum SHORT_BLOCK_TYPE            = 2;
60 enum STOP_BLOCK_TYPE             = 3;
61 enum MODE_MONO                   = 3;
62 enum MODE_JOINT_STEREO           = 1;
63 enum HDR_SIZE                    = 4;
64 
65 bool HDR_IS_MONO(const(ubyte)* h)
66 {
67     return (((h[3]) & 0xC0) == 0xC0);
68 }
69 
70 bool HDR_IS_MS_STEREO(const(ubyte)* h)
71 {
72     return  (((h[3]) & 0xE0) == 0x60);
73 }
74 
75 bool HDR_IS_FREE_FORMAT(const(ubyte)* h)
76 {
77     return (((h[2]) & 0xF0) == 0);
78 } 
79 
80 bool HDR_IS_CRC(const(ubyte)* h)
81 {
82     return (!((h[1]) & 1));
83 } 
84 
85 int HDR_TEST_PADDING(const(ubyte)* h)
86 {
87     return ((h[2]) & 0x2);
88 }
89 
90 int HDR_TEST_MPEG1(const(ubyte)* h)
91 {
92     return ((h[1]) & 0x8);
93 }
94 
95 int HDR_TEST_NOT_MPEG25(const(ubyte)* h)
96 {
97     return ((h[1]) & 0x10);
98 }
99 
100 int HDR_TEST_I_STEREO(const(ubyte)* h)
101 {
102     return ((h[3]) & 0x10);
103 }
104 
105 int HDR_TEST_MS_STEREO(const(ubyte)* h)
106 {
107     return ((h[3]) & 0x20);
108 }
109 
110 int HDR_GET_STEREO_MODE(const(ubyte)* h)
111 {
112     return (((h[3]) >> 6) & 3);
113 }
114 
115 int HDR_GET_STEREO_MODE_EXT(const(ubyte)* h)
116 {
117     return (((h[3]) >> 4) & 3);
118 }
119 
120 int HDR_GET_LAYER(const(ubyte)* h)
121 {
122     return (((h[1]) >> 1) & 3);
123 }
124 
125 int HDR_GET_BITRATE(const(ubyte)* h)
126 {
127     return ((h[2]) >> 4);
128 }
129 
130 int HDR_GET_SAMPLE_RATE(const(ubyte)* h)
131 {
132     return (((h[2]) >> 2) & 3);
133 }
134 
135 int HDR_GET_MY_SAMPLE_RATE(const(ubyte)* h)
136 {
137     return (HDR_GET_SAMPLE_RATE(h) + (((h[1] >> 3) & 1) + ((h[1] >> 4) & 1))*3);
138 }
139 
140 bool HDR_IS_FRAME_576(const(ubyte)* h)
141 {
142     return ((h[1] & 14) == 2);
143 }
144 
145 bool HDR_IS_LAYER_1(const(ubyte)* h)
146 {
147     return ((h[1] & 6) == 6);
148 }
149 
150 enum BITS_DEQUANTIZER_OUT        = -1;
151 enum MAX_SCF                     = 255 + BITS_DEQUANTIZER_OUT*4 - 210;
152 enum MAX_SCFI                    = (MAX_SCF + 3) & ~3;
153 
154 int MINIMP3_MIN(int a, int b)
155 {
156     return (a > b) ? b : a;
157 }
158 
159 ulong MINIMP3_MIN(ulong a, ulong b)
160 {
161     return (a > b) ? b : a;
162 }
163 
164 int MINIMP3_MAX(int a, int b)
165 {
166     return (a < b) ? b : a;
167 }
168       
169 struct bs_t
170 {
171     const(uint8_t)* buf;
172     int pos, limit;
173 }
174 
175 struct L12_scale_info
176 {
177     float[3*64] scf;
178     uint8_t total_bands;
179     uint8_t stereo_bands;
180     ubyte[64] bitalloc;
181     ubyte[64] scfcod;
182 }
183 
184 struct L12_subband_alloc_t
185 {
186     uint8_t tab_offset, code_tab_width, band_count;
187 }
188 
189 struct L3_gr_info_t
190 {
191     const(uint8_t)* sfbtab;
192     uint16_t part_23_length, big_values, scalefac_compress;
193     uint8_t global_gain, block_type, mixed_block_flag, n_long_sfb, n_short_sfb;
194     uint8_t[3] table_select, region_count, subblock_gain;
195     uint8_t preflag, scalefac_scale, count1_table, scfsi;
196 }
197 
198 struct mp3dec_scratch_t
199 {
200     bs_t bs;
201     uint8_t[MAX_BITRESERVOIR_BYTES + MAX_L3_FRAME_PAYLOAD_BYTES] maindata;
202     L3_gr_info_t[4] gr_info;
203     float[576][2] grbuf;
204     float[40] scf;
205     float[2*32][18 + 15] syn;    
206     uint8_t[39][2] ist_pos;
207 }
208 
209 void bs_init(bs_t *bs, const(uint8_t)*data, int bytes)
210 {
211     bs.buf   = data;
212     bs.pos   = 0;
213     bs.limit = bytes*8;
214 }
215 
216 uint32_t get_bits(bs_t *bs, int n)
217 {
218     uint32_t next, cache = 0, s = bs.pos & 7;
219     int shl = n + s;
220     const(uint8_t)*p = bs.buf + (bs.pos >> 3);
221     if ((bs.pos += n) > bs.limit)
222         return 0;
223     next = *p++ & (255 >> s);
224     while ((shl -= 8) > 0)
225     {
226         cache |= next << shl;
227         next = *p++;
228     }
229     return cache | (next >> -shl);
230 }
231 
232 int hdr_valid(const uint8_t *h)
233 {
234     return h[0] == 0xff &&
235         ((h[1] & 0xF0) == 0xf0 || (h[1] & 0xFE) == 0xe2) &&
236         (HDR_GET_LAYER(h) != 0) &&
237         (HDR_GET_BITRATE(h) != 15) &&
238         (HDR_GET_SAMPLE_RATE(h) != 3);
239 }
240 
241 int hdr_compare(const uint8_t *h1, const uint8_t *h2)
242 {
243     return hdr_valid(h2) &&
244         ((h1[1] ^ h2[1]) & 0xFE) == 0 &&
245         ((h1[2] ^ h2[2]) & 0x0C) == 0 &&
246         !(HDR_IS_FREE_FORMAT(h1) ^ HDR_IS_FREE_FORMAT(h2));
247 }
248 
249 uint hdr_bitrate_kbps(const uint8_t *h)
250 {
251     static immutable uint8_t[15][3][2] halfrate =
252     [
253         [ [ 0,4,8,12,16,20,24,28,32,40,48,56,64,72,80 ], [ 0,4,8,12,16,20,24,28,32,40,48,56,64,72,80 ], [ 0,16,24,28,32,40,48,56,64,72,80,88,96,112,128 ] ],
254         [ [ 0,16,20,24,28,32,40,48,56,64,80,96,112,128,160 ], [ 0,16,24,28,32,40,48,56,64,80,96,112,128,160,192 ], [ 0,16,32,48,64,80,96,112,128,144,160,176,192,208,224 ] ],
255     ];
256     return 2*halfrate[!!HDR_TEST_MPEG1(h)][HDR_GET_LAYER(h) - 1][HDR_GET_BITRATE(h)];
257 }
258 
259 uint hdr_sample_rate_hz(const uint8_t *h)
260 {
261     static immutable uint[3] g_hz = [ 44100, 48000, 32000 ];
262     return g_hz[HDR_GET_SAMPLE_RATE(h)] >> cast(int)!HDR_TEST_MPEG1(h) >> cast(int)!HDR_TEST_NOT_MPEG25(h);
263 }
264 
265 uint hdr_frame_samples(const uint8_t *h)
266 {
267     return HDR_IS_LAYER_1(h) ? 384 : (1152 >> cast(int)HDR_IS_FRAME_576(h));
268 }
269 
270 int hdr_frame_bytes(const uint8_t *h, int free_format_size)
271 {
272     int frame_bytes = hdr_frame_samples(h)*hdr_bitrate_kbps(h)*125/hdr_sample_rate_hz(h);
273     if (HDR_IS_LAYER_1(h))
274     {
275         frame_bytes &= ~3; /* slot align */
276     }
277     return frame_bytes ? frame_bytes : free_format_size;
278 }
279 
280 static int hdr_padding(const uint8_t *h)
281 {
282     return HDR_TEST_PADDING(h) ? (HDR_IS_LAYER_1(h) ? 4 : 1) : 0;
283 }
284 
285 
286 const(L12_subband_alloc_t)* L12_subband_alloc_table(const uint8_t *hdr, L12_scale_info *sci)
287 {
288     const(L12_subband_alloc_t) *alloc;
289     int mode = HDR_GET_STEREO_MODE(hdr);
290     int nbands, stereo_bands = (mode == MODE_MONO) ? 0 : (mode == MODE_JOINT_STEREO) ? (HDR_GET_STEREO_MODE_EXT(hdr) << 2) + 4 : 32;
291 
292     if (HDR_IS_LAYER_1(hdr))
293     {
294         static immutable L12_subband_alloc_t[] g_alloc_L1 = 
295         [ 
296             L12_subband_alloc_t(76, 4, 32) 
297         ];
298         alloc = g_alloc_L1.ptr;
299         nbands = 32;
300     } 
301     else if (!HDR_TEST_MPEG1(hdr))
302     {
303         static immutable L12_subband_alloc_t[] g_alloc_L2M2 = 
304         [ 
305             L12_subband_alloc_t(60, 4, 4),
306             L12_subband_alloc_t(44, 3, 7 ),
307             L12_subband_alloc_t(44, 2, 19),
308         ];
309         alloc = g_alloc_L2M2.ptr;
310         nbands = 30;
311     } 
312     else
313     {
314         static immutable L12_subband_alloc_t[] g_alloc_L2M1 = 
315         [
316             L12_subband_alloc_t(0, 4, 3),
317             L12_subband_alloc_t(16, 4, 8),
318             L12_subband_alloc_t(32, 3, 12),
319             L12_subband_alloc_t(40, 2, 7)
320         ];
321         
322         int sample_rate_idx = HDR_GET_SAMPLE_RATE(hdr);
323         uint kbps = hdr_bitrate_kbps(hdr) >> cast(int)(mode != MODE_MONO);
324         if (!kbps) /* free-format */
325         {
326             kbps = 192;
327         }
328 
329         alloc = g_alloc_L2M1.ptr;
330         nbands = 27;
331         if (kbps < 56)
332         {
333             static immutable L12_subband_alloc_t[] g_alloc_L2M1_lowrate = 
334             [
335         
336                L12_subband_alloc_t(44, 4, 2), 
337                L12_subband_alloc_t(44, 3, 10)
338             ];            
339             alloc = g_alloc_L2M1_lowrate.ptr;
340             nbands = sample_rate_idx == 2 ? 12 : 8;
341         } 
342         else if (kbps >= 96 && sample_rate_idx != 1)
343         {
344             nbands = 30;
345         }
346     }
347 
348     sci.total_bands = cast(uint8_t)nbands;
349     sci.stereo_bands = cast(uint8_t)MINIMP3_MIN(stereo_bands, nbands);
350 
351     return alloc;
352 }
353 
354 void L12_read_scalefactors(bs_t *bs, uint8_t *pba, uint8_t *scfcod, int bands, float *scf)
355 {
356     static immutable float[18*3] g_deq_L12 =
357     [
358         3.17891e-07, 2.52311e-07, 2.00259e-07, 1.36239e-07, 1.08133e-07, 8.58253e-08, 
359         6.35783e-08, 5.04621e-08, 4.00518e-08, 3.07637e-08, 2.44172e-08, 1.93799e-08, 
360         1.51377e-08, 1.20148e-08, 9.53615e-09, 7.50925e-09, 5.96009e-09, 4.73053e-09, 
361         3.7399e-09, 2.96836e-09, 2.35599e-09, 1.86629e-09, 1.48128e-09, 1.17569e-09, 
362         9.32233e-10, 7.39914e-10, 5.8727e-10, 4.65889e-10, 3.69776e-10, 2.93492e-10, 
363         2.32888e-10, 1.84843e-10, 1.4671e-10, 1.1643e-10, 9.24102e-11, 7.3346e-11, 
364         5.82112e-11, 4.62023e-11, 3.66708e-11, 2.91047e-11, 2.31004e-11, 1.83348e-11, 
365         1.45521e-11, 1.155e-11, 9.16727e-12, 3.17891e-07, 2.52311e-07, 2.00259e-07, 
366         1.90735e-07, 1.51386e-07, 1.20155e-07, 1.05964e-07, 8.41035e-08, 6.6753e-08
367     ];
368 
369     int i, m;
370     for (i = 0; i < bands; i++)
371     {
372         float s = 0;
373         int ba = *pba++;
374         int mask = ba ? 4 + ((19 >> scfcod[i]) & 3) : 0;
375         for (m = 4; m; m >>= 1)
376         {
377             if (mask & m)
378             {
379                 int b = get_bits(bs, 6);
380                 s = g_deq_L12[ba*3 - 6 + b % 3]*(1 << 21 >> b/3);
381             }
382             *scf++ = s;
383         }
384     }
385 }
386 
387 void L12_read_scale_info(const uint8_t *hdr, bs_t *bs, L12_scale_info *sci)
388 {
389     static immutable uint8_t[] g_bitalloc_code_tab = 
390     [
391         0,17, 3, 4, 5,6,7, 8,9,10,11,12,13,14,15,16,
392         0,17,18, 3,19,4,5, 6,7, 8, 9,10,11,12,13,16,
393         0,17,18, 3,19,4,5,16,
394         0,17,18,16,
395         0,17,18,19, 4,5,6, 7,8, 9,10,11,12,13,14,15,
396         0,17,18, 3,19,4,5, 6,7, 8, 9,10,11,12,13,14,
397         0, 2, 3, 4, 5,6,7, 8,9,10,11,12,13,14,15,16
398     ];
399     const(L12_subband_alloc_t)* subband_alloc = L12_subband_alloc_table(hdr, sci);
400 
401     int i, k = 0, ba_bits = 0;
402     const(uint8_t)*ba_code_tab = g_bitalloc_code_tab.ptr;
403 
404     for (i = 0; i < sci.total_bands; i++)
405     {
406         uint8_t ba;
407         if (i == k)
408         {
409             k += subband_alloc.band_count;
410             ba_bits = subband_alloc.code_tab_width;
411             ba_code_tab = g_bitalloc_code_tab.ptr + subband_alloc.tab_offset;
412             subband_alloc++;
413         }
414         ba = ba_code_tab[get_bits(bs, ba_bits)];
415         sci.bitalloc[2*i] = ba;
416         if (i < sci.stereo_bands)
417         {
418             ba = ba_code_tab[get_bits(bs, ba_bits)];
419         }
420         sci.bitalloc[2*i + 1] = sci.stereo_bands ? ba : 0;
421     }
422 
423     for (i = 0; i < 2*sci.total_bands; i++)
424     {
425         ubyte temp = ( HDR_IS_LAYER_1(hdr) ? 2 : cast(ubyte) get_bits(bs, 2) );
426         sci.scfcod[i] = sci.bitalloc[i] ? temp : 6;
427     }
428 
429     L12_read_scalefactors(bs, sci.bitalloc.ptr, sci.scfcod.ptr, sci.total_bands*2, sci.scf.ptr);
430 
431     for (i = sci.stereo_bands; i < sci.total_bands; i++)
432     {
433         sci.bitalloc[2*i + 1] = 0;
434     }
435 }
436 
437 int L12_dequantize_granule(float *grbuf, bs_t *bs, L12_scale_info *sci, int group_size)
438 {
439     int i, j, k, choff = 576;
440     for (j = 0; j < 4; j++)
441     {
442         float *dst = grbuf + group_size*j;
443         for (i = 0; i < 2*sci.total_bands; i++)
444         {
445             int ba = sci.bitalloc[i];
446             if (ba != 0)
447             {
448                 if (ba < 17)
449                 {
450                     int half = (1 << (ba - 1)) - 1;
451                     for (k = 0; k < group_size; k++)
452                     {
453                         dst[k] = cast(float)(cast(int)get_bits(bs, ba) - half);
454                     }
455                 } else
456                 {
457                     uint mod = (2 << (ba - 17)) + 1;    /* 3, 5, 9 */
458                     uint code = get_bits(bs, mod + 2 - (mod >> 3));  /* 5, 7, 10 */
459                     for (k = 0; k < group_size; k++, code /= mod)
460                     {
461                         dst[k] = cast(float)(cast(int)(code % mod - mod/2));
462                     }
463                 }
464             }
465             dst += choff;
466             choff = 18 - choff;
467         }
468     }
469     return group_size*4;
470 }
471 
472 void L12_apply_scf_384(L12_scale_info *sci, const(float)*scf, float *dst)
473 {
474     int i, k;
475     memcpy(dst + 576 + sci.stereo_bands*18, dst + sci.stereo_bands*18, (sci.total_bands - sci.stereo_bands)*18*float.sizeof);
476     for (i = 0; i < sci.total_bands; i++, dst += 18, scf += 6)
477     {
478         for (k = 0; k < 12; k++)
479         {
480             dst[k + 0]   *= scf[0];
481             dst[k + 576] *= scf[3];
482         }
483     }
484 }
485 
486 
487 int L3_read_side_info(bs_t *bs, L3_gr_info_t *gr, const uint8_t *hdr)
488 {
489     static immutable uint8_t[23][8] g_scf_long = 
490     [
491         [ 6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54,0 ],
492         [ 12,12,12,12,12,12,16,20,24,28,32,40,48,56,64,76,90,2,2,2,2,2,0 ],
493         [ 6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54,0 ],
494         [ 6,6,6,6,6,6,8,10,12,14,16,18,22,26,32,38,46,54,62,70,76,36,0 ],
495         [ 6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54,0 ],
496         [ 4,4,4,4,4,4,6,6,8,8,10,12,16,20,24,28,34,42,50,54,76,158,0 ],
497         [ 4,4,4,4,4,4,6,6,6,8,10,12,16,18,22,28,34,40,46,54,54,192,0 ],
498         [ 4,4,4,4,4,4,6,6,8,10,12,16,20,24,30,38,46,56,68,84,102,26,0 ]
499     ];
500     static immutable uint8_t[40][8] g_scf_short = [
501         [ 4,4,4,4,4,4,4,4,4,6,6,6,8,8,8,10,10,10,12,12,12,14,14,14,18,18,18,24,24,24,30,30,30,40,40,40,18,18,18,0 ],
502         [ 8,8,8,8,8,8,8,8,8,12,12,12,16,16,16,20,20,20,24,24,24,28,28,28,36,36,36,2,2,2,2,2,2,2,2,2,26,26,26,0 ],
503         [ 4,4,4,4,4,4,4,4,4,6,6,6,6,6,6,8,8,8,10,10,10,14,14,14,18,18,18,26,26,26,32,32,32,42,42,42,18,18,18,0 ],
504         [ 4,4,4,4,4,4,4,4,4,6,6,6,8,8,8,10,10,10,12,12,12,14,14,14,18,18,18,24,24,24,32,32,32,44,44,44,12,12,12,0 ],
505         [ 4,4,4,4,4,4,4,4,4,6,6,6,8,8,8,10,10,10,12,12,12,14,14,14,18,18,18,24,24,24,30,30,30,40,40,40,18,18,18,0 ],
506         [ 4,4,4,4,4,4,4,4,4,4,4,4,6,6,6,8,8,8,10,10,10,12,12,12,14,14,14,18,18,18,22,22,22,30,30,30,56,56,56,0 ],
507         [ 4,4,4,4,4,4,4,4,4,4,4,4,6,6,6,6,6,6,10,10,10,12,12,12,14,14,14,16,16,16,20,20,20,26,26,26,66,66,66,0 ],
508         [ 4,4,4,4,4,4,4,4,4,4,4,4,6,6,6,8,8,8,12,12,12,16,16,16,20,20,20,26,26,26,34,34,34,42,42,42,12,12,12,0 ]
509     ];
510     static immutable uint8_t[40][8] g_scf_mixed = [
511         [ 6,6,6,6,6,6,6,6,6,8,8,8,10,10,10,12,12,12,14,14,14,18,18,18,24,24,24,30,30,30,40,40,40,18,18,18,0 ],
512         [ 12,12,12,4,4,4,8,8,8,12,12,12,16,16,16,20,20,20,24,24,24,28,28,28,36,36,36,2,2,2,2,2,2,2,2,2,26,26,26,0 ],
513         [ 6,6,6,6,6,6,6,6,6,6,6,6,8,8,8,10,10,10,14,14,14,18,18,18,26,26,26,32,32,32,42,42,42,18,18,18,0 ],
514         [ 6,6,6,6,6,6,6,6,6,8,8,8,10,10,10,12,12,12,14,14,14,18,18,18,24,24,24,32,32,32,44,44,44,12,12,12,0 ],
515         [ 6,6,6,6,6,6,6,6,6,8,8,8,10,10,10,12,12,12,14,14,14,18,18,18,24,24,24,30,30,30,40,40,40,18,18,18,0 ],
516         [ 4,4,4,4,4,4,6,6,4,4,4,6,6,6,8,8,8,10,10,10,12,12,12,14,14,14,18,18,18,22,22,22,30,30,30,56,56,56,0 ],
517         [ 4,4,4,4,4,4,6,6,4,4,4,6,6,6,6,6,6,10,10,10,12,12,12,14,14,14,16,16,16,20,20,20,26,26,26,66,66,66,0 ],
518         [ 4,4,4,4,4,4,6,6,4,4,4,6,6,6,8,8,8,12,12,12,16,16,16,20,20,20,26,26,26,34,34,34,42,42,42,12,12,12,0 ]
519     ];
520 
521     uint tables, scfsi = 0;
522     int main_data_begin, part_23_sum = 0;
523     int sr_idx = HDR_GET_MY_SAMPLE_RATE(hdr); sr_idx -= (sr_idx != 0);
524     int gr_count = HDR_IS_MONO(hdr) ? 1 : 2;
525 
526     if (HDR_TEST_MPEG1(hdr))
527     {
528         gr_count *= 2;
529         main_data_begin = get_bits(bs, 9);
530         scfsi = get_bits(bs, 7 + gr_count);
531     } else
532     {
533         main_data_begin = get_bits(bs, 8 + gr_count) >> gr_count;
534     }
535 
536     do
537     {
538         if (HDR_IS_MONO(hdr))
539         {
540             scfsi <<= 4;
541         }
542         gr.part_23_length = cast(uint16_t)get_bits(bs, 12);
543         part_23_sum += gr.part_23_length;
544         gr.big_values = cast(uint16_t)get_bits(bs,  9);
545         if (gr.big_values > 288)
546         {
547             return -1;
548         }
549         gr.global_gain = cast(uint8_t)get_bits(bs, 8);
550         gr.scalefac_compress = cast(uint16_t)get_bits(bs, HDR_TEST_MPEG1(hdr) ? 4 : 9);
551         gr.sfbtab = g_scf_long[sr_idx].ptr;
552         gr.n_long_sfb  = 22;
553         gr.n_short_sfb = 0;
554         if (get_bits(bs, 1))
555         {
556             gr.block_type = cast(uint8_t)get_bits(bs, 2);
557             if (!gr.block_type)
558             {
559                 return -1;
560             }
561             gr.mixed_block_flag = cast(uint8_t)get_bits(bs, 1);
562             gr.region_count[0] = 7;
563             gr.region_count[1] = 255;
564             if (gr.block_type == SHORT_BLOCK_TYPE)
565             {
566                 scfsi &= 0x0F0F;
567                 if (!gr.mixed_block_flag)
568                 {
569                     gr.region_count[0] = 8;
570                     gr.sfbtab = g_scf_short[sr_idx].ptr;
571                     gr.n_long_sfb = 0;
572                     gr.n_short_sfb = 39;
573                 } else
574                 {
575                     gr.sfbtab = g_scf_mixed[sr_idx].ptr;
576                     gr.n_long_sfb = HDR_TEST_MPEG1(hdr) ? 8 : 6;
577                     gr.n_short_sfb = 30;
578                 }
579             }
580             tables = get_bits(bs, 10);
581             tables <<= 5;
582             gr.subblock_gain[0] = cast(uint8_t)get_bits(bs, 3);
583             gr.subblock_gain[1] = cast(uint8_t)get_bits(bs, 3);
584             gr.subblock_gain[2] = cast(uint8_t)get_bits(bs, 3);
585         } else
586         {
587             gr.block_type = 0;
588             gr.mixed_block_flag = 0;
589             tables = get_bits(bs, 15);
590             gr.region_count[0] = cast(uint8_t)get_bits(bs, 4);
591             gr.region_count[1] = cast(uint8_t)get_bits(bs, 3);
592             gr.region_count[2] = 255;
593         }
594         gr.table_select[0] = cast(uint8_t)(tables >> 10);
595         gr.table_select[1] = cast(uint8_t)((tables >> 5) & 31);
596         gr.table_select[2] = cast(uint8_t)((tables) & 31);
597         gr.preflag = HDR_TEST_MPEG1(hdr) ? (cast(ubyte) get_bits(bs, 1)) : (gr.scalefac_compress >= 500);
598         gr.scalefac_scale = cast(uint8_t)get_bits(bs, 1);
599         gr.count1_table = cast(uint8_t)get_bits(bs, 1);
600         gr.scfsi = cast(uint8_t)((scfsi >> 12) & 15);
601         scfsi <<= 4;
602         gr++;
603     } while(--gr_count);
604 
605     if (part_23_sum + bs.pos > bs.limit + main_data_begin*8)
606     {
607         return -1;
608     }
609 
610     return main_data_begin;
611 }
612 
613 void L3_read_scalefactors(uint8_t *scf, uint8_t *ist_pos, const uint8_t *scf_size, const uint8_t *scf_count, bs_t *bitbuf, int scfsi)
614 {
615     int i, k;
616     for (i = 0; i < 4 && scf_count[i]; i++, scfsi *= 2)
617     {
618         int cnt = scf_count[i];
619         if (scfsi & 8)
620         {
621             memcpy(scf, ist_pos, cnt);
622         } else
623         {
624             int bits = scf_size[i];
625             if (!bits)
626             {
627                 memset(scf, 0, cnt);
628                 memset(ist_pos, 0, cnt);
629             } else
630             {
631                 int max_scf = (scfsi < 0) ? (1 << bits) - 1 : -1;
632                 for (k = 0; k < cnt; k++)
633                 {
634                     int s = get_bits(bitbuf, bits);
635                     ist_pos[k] = cast(ubyte)(s == max_scf ? -1 : s);
636                     scf[k] = cast(ubyte)s;
637                 }
638             }
639         }
640         ist_pos += cnt;
641         scf += cnt;
642     }
643     scf[0] = scf[1] = scf[2] = 0;
644 }
645 
646 float L3_ldexp_q2(float y, int exp_q2)
647 {
648     static immutable float[4] g_expfrac = 
649     [ 9.31322575e-10f,7.83145814e-10f,6.58544508e-10f,5.53767716e-10f ];
650     int e;
651     do
652     {
653         e = MINIMP3_MIN(30*4, exp_q2);
654         y *= g_expfrac[e & 3]*(1 << 30 >> (e >> 2));
655     } while ((exp_q2 -= e) > 0);
656     return y;
657 }
658 
659 void L3_decode_scalefactors(const uint8_t *hdr, uint8_t *ist_pos, bs_t *bs, const L3_gr_info_t *gr, float *scf, int ch)
660 {
661     static immutable uint8_t[28][3] g_scf_partitions = [
662         [ 6,5,5, 5,6,5,5,5,6,5, 7,3,11,10,0,0, 7, 7, 7,0, 6, 6,6,3, 8, 8,5,0 ],
663         [ 8,9,6,12,6,9,9,9,6,9,12,6,15,18,0,0, 6,15,12,0, 6,12,9,6, 6,18,9,0 ],
664         [ 9,9,6,12,9,9,9,9,9,9,12,6,18,18,0,0,12,12,12,0,12, 9,9,6,15,12,9,0 ]
665     ];
666     const(uint8_t)* scf_partition = g_scf_partitions[!!gr.n_short_sfb + !gr.n_long_sfb].ptr;
667     uint8_t[4] scf_size; 
668     uint8_t[40] iscf;
669     int i, scf_shift = gr.scalefac_scale + 1, gain_exp, scfsi = gr.scfsi;
670     float gain;
671 
672     if (HDR_TEST_MPEG1(hdr))
673     {
674         static immutable uint8_t[16] g_scfc_decode = [ 0,1,2,3, 12,5,6,7, 9,10,11,13, 14,15,18,19 ];
675         int part = g_scfc_decode[gr.scalefac_compress];
676         scf_size[1] = scf_size[0] = cast(uint8_t)(part >> 2);
677         scf_size[3] = scf_size[2] = cast(uint8_t)(part & 3);
678     } else
679     {
680         static immutable uint8_t[6*4] g_mod = [ 5,5,4,4,5,5,4,1,4,3,1,1,5,6,6,1,4,4,4,1,4,3,1,1 ];
681         int k, modprod, sfc, ist = HDR_TEST_I_STEREO(hdr) && ch;
682         sfc = gr.scalefac_compress >> ist;
683         for (k = ist*3*4; sfc >= 0; sfc -= modprod, k += 4)
684         {
685             for (modprod = 1, i = 3; i >= 0; i--)
686             {
687                 scf_size[i] = cast(uint8_t)(sfc / modprod % g_mod[k + i]);
688                 modprod *= g_mod[k + i];
689             }
690         }
691         scf_partition += k;
692         scfsi = -16;
693     }
694     L3_read_scalefactors(iscf.ptr, ist_pos, scf_size.ptr, scf_partition, bs, scfsi);
695 
696     if (gr.n_short_sfb)
697     {
698         int sh = 3 - scf_shift;
699         for (i = 0; i < gr.n_short_sfb; i += 3)
700         {
701             iscf[gr.n_long_sfb + i + 0] += gr.subblock_gain[0] << sh;
702             iscf[gr.n_long_sfb + i + 1] += gr.subblock_gain[1] << sh;
703             iscf[gr.n_long_sfb + i + 2] += gr.subblock_gain[2] << sh;
704         }
705     } else if (gr.preflag)
706     {
707         static immutable uint8_t[10] g_preamp = [ 1,1,1,1,2,2,3,3,3,2 ];
708         for (i = 0; i < 10; i++)
709         {
710             iscf[11 + i] += g_preamp[i];
711         }
712     }
713 
714     gain_exp = gr.global_gain + BITS_DEQUANTIZER_OUT*4 - 210 - (HDR_IS_MS_STEREO(hdr) ? 2 : 0);
715     gain = L3_ldexp_q2(1 << (MAX_SCFI/4),  MAX_SCFI - gain_exp);
716     for (i = 0; i < cast(int)(gr.n_long_sfb + gr.n_short_sfb); i++)
717     {
718         scf[i] = L3_ldexp_q2(gain, iscf[i] << scf_shift);
719     }
720 }
721 
722 static immutable float[129 + 16] g_pow43 = [
723     0,-1,-2.519842f,-4.326749f,-6.349604f,-8.549880f,-10.902724f,-13.390518f,-16.000000f,-18.720754f,-21.544347f,-24.463781f,-27.473142f,-30.567351f,-33.741992f,-36.993181f,
724     0,1,2.519842f,4.326749f,6.349604f,8.549880f,10.902724f,13.390518f,16.000000f,18.720754f,21.544347f,24.463781f,27.473142f,30.567351f,33.741992f,36.993181f,40.317474f,43.711787f,47.173345f,50.699631f,54.288352f,57.937408f,61.644865f,65.408941f,69.227979f,73.100443f,77.024898f,81.000000f,85.024491f,89.097188f,93.216975f,97.382800f,101.593667f,105.848633f,110.146801f,114.487321f,118.869381f,123.292209f,127.755065f,132.257246f,136.798076f,141.376907f,145.993119f,150.646117f,155.335327f,160.060199f,164.820202f,169.614826f,174.443577f,179.305980f,184.201575f,189.129918f,194.090580f,199.083145f,204.107210f,209.162385f,214.248292f,219.364564f,224.510845f,229.686789f,234.892058f,240.126328f,245.389280f,250.680604f,256.000000f,261.347174f,266.721841f,272.123723f,277.552547f,283.008049f,288.489971f,293.998060f,299.532071f,305.091761f,310.676898f,316.287249f,321.922592f,327.582707f,333.267377f,338.976394f,344.709550f,350.466646f,356.247482f,362.051866f,367.879608f,373.730522f,379.604427f,385.501143f,391.420496f,397.362314f,403.326427f,409.312672f,415.320884f,421.350905f,427.402579f,433.475750f,439.570269f,445.685987f,451.822757f,457.980436f,464.158883f,470.357960f,476.577530f,482.817459f,489.077615f,495.357868f,501.658090f,507.978156f,514.317941f,520.677324f,527.056184f,533.454404f,539.871867f,546.308458f,552.764065f,559.238575f,565.731879f,572.243870f,578.774440f,585.323483f,591.890898f,598.476581f,605.080431f,611.702349f,618.342238f,625.000000f,631.675540f,638.368763f,645.079578f
725 ];
726 
727 float L3_pow_43(int x)
728 {
729     float frac;
730     int sign, mult = 256;
731 
732     if (x < 129)
733     {
734         return g_pow43[16 + x];
735     }
736 
737     if (x < 1024)
738     {
739         mult = 16;
740         x <<= 3;
741     }
742 
743     sign = 2*x & 64;
744     frac = cast(float)((x & 63) - sign) / ((x & ~63) + sign);
745     return g_pow43[16 + ((x + sign) >> 6)]*(1.0f + frac*((4.0f/3) + frac*(2.0f/9)))*mult;
746 }
747 
748 void L3_huffman(float *dst, bs_t *bs, const L3_gr_info_t *gr_info, const(float)*scf, int layer3gr_limit)
749 {
750     static immutable int16_t[] tabs = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
751         785,785,785,785,784,784,784,784,513,513,513,513,513,513,513,513,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,
752         -255,1313,1298,1282,785,785,785,785,784,784,784,784,769,769,769,769,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,290,288,
753         -255,1313,1298,1282,769,769,769,769,529,529,529,529,529,529,529,529,528,528,528,528,528,528,528,528,512,512,512,512,512,512,512,512,290,288,
754         -253,-318,-351,-367,785,785,785,785,784,784,784,784,769,769,769,769,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,819,818,547,547,275,275,275,275,561,560,515,546,289,274,288,258,
755         -254,-287,1329,1299,1314,1312,1057,1057,1042,1042,1026,1026,784,784,784,784,529,529,529,529,529,529,529,529,769,769,769,769,768,768,768,768,563,560,306,306,291,259,
756         -252,-413,-477,-542,1298,-575,1041,1041,784,784,784,784,769,769,769,769,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,-383,-399,1107,1092,1106,1061,849,849,789,789,1104,1091,773,773,1076,1075,341,340,325,309,834,804,577,577,532,532,516,516,832,818,803,816,561,561,531,531,515,546,289,289,288,258,
757         -252,-429,-493,-559,1057,1057,1042,1042,529,529,529,529,529,529,529,529,784,784,784,784,769,769,769,769,512,512,512,512,512,512,512,512,-382,1077,-415,1106,1061,1104,849,849,789,789,1091,1076,1029,1075,834,834,597,581,340,340,339,324,804,833,532,532,832,772,818,803,817,787,816,771,290,290,290,290,288,258,
758         -253,-349,-414,-447,-463,1329,1299,-479,1314,1312,1057,1057,1042,1042,1026,1026,785,785,785,785,784,784,784,784,769,769,769,769,768,768,768,768,-319,851,821,-335,836,850,805,849,341,340,325,336,533,533,579,579,564,564,773,832,578,548,563,516,321,276,306,291,304,259,
759         -251,-572,-733,-830,-863,-879,1041,1041,784,784,784,784,769,769,769,769,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,-511,-527,-543,1396,1351,1381,1366,1395,1335,1380,-559,1334,1138,1138,1063,1063,1350,1392,1031,1031,1062,1062,1364,1363,1120,1120,1333,1348,881,881,881,881,375,374,359,373,343,358,341,325,791,791,1123,1122,-703,1105,1045,-719,865,865,790,790,774,774,1104,1029,338,293,323,308,-799,-815,833,788,772,818,803,816,322,292,307,320,561,531,515,546,289,274,288,258,
760         -251,-525,-605,-685,-765,-831,-846,1298,1057,1057,1312,1282,785,785,785,785,784,784,784,784,769,769,769,769,512,512,512,512,512,512,512,512,1399,1398,1383,1367,1382,1396,1351,-511,1381,1366,1139,1139,1079,1079,1124,1124,1364,1349,1363,1333,882,882,882,882,807,807,807,807,1094,1094,1136,1136,373,341,535,535,881,775,867,822,774,-591,324,338,-671,849,550,550,866,864,609,609,293,336,534,534,789,835,773,-751,834,804,308,307,833,788,832,772,562,562,547,547,305,275,560,515,290,290,
761         -252,-397,-477,-557,-622,-653,-719,-735,-750,1329,1299,1314,1057,1057,1042,1042,1312,1282,1024,1024,785,785,785,785,784,784,784,784,769,769,769,769,-383,1127,1141,1111,1126,1140,1095,1110,869,869,883,883,1079,1109,882,882,375,374,807,868,838,881,791,-463,867,822,368,263,852,837,836,-543,610,610,550,550,352,336,534,534,865,774,851,821,850,805,593,533,579,564,773,832,578,578,548,548,577,577,307,276,306,291,516,560,259,259,
762         -250,-2107,-2507,-2764,-2909,-2974,-3007,-3023,1041,1041,1040,1040,769,769,769,769,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,-767,-1052,-1213,-1277,-1358,-1405,-1469,-1535,-1550,-1582,-1614,-1647,-1662,-1694,-1726,-1759,-1774,-1807,-1822,-1854,-1886,1565,-1919,-1935,-1951,-1967,1731,1730,1580,1717,-1983,1729,1564,-1999,1548,-2015,-2031,1715,1595,-2047,1714,-2063,1610,-2079,1609,-2095,1323,1323,1457,1457,1307,1307,1712,1547,1641,1700,1699,1594,1685,1625,1442,1442,1322,1322,-780,-973,-910,1279,1278,1277,1262,1276,1261,1275,1215,1260,1229,-959,974,974,989,989,-943,735,478,478,495,463,506,414,-1039,1003,958,1017,927,942,987,957,431,476,1272,1167,1228,-1183,1256,-1199,895,895,941,941,1242,1227,1212,1135,1014,1014,490,489,503,487,910,1013,985,925,863,894,970,955,1012,847,-1343,831,755,755,984,909,428,366,754,559,-1391,752,486,457,924,997,698,698,983,893,740,740,908,877,739,739,667,667,953,938,497,287,271,271,683,606,590,712,726,574,302,302,738,736,481,286,526,725,605,711,636,724,696,651,589,681,666,710,364,467,573,695,466,466,301,465,379,379,709,604,665,679,316,316,634,633,436,436,464,269,424,394,452,332,438,363,347,408,393,448,331,422,362,407,392,421,346,406,391,376,375,359,1441,1306,-2367,1290,-2383,1337,-2399,-2415,1426,1321,-2431,1411,1336,-2447,-2463,-2479,1169,1169,1049,1049,1424,1289,1412,1352,1319,-2495,1154,1154,1064,1064,1153,1153,416,390,360,404,403,389,344,374,373,343,358,372,327,357,342,311,356,326,1395,1394,1137,1137,1047,1047,1365,1392,1287,1379,1334,1364,1349,1378,1318,1363,792,792,792,792,1152,1152,1032,1032,1121,1121,1046,1046,1120,1120,1030,1030,-2895,1106,1061,1104,849,849,789,789,1091,1076,1029,1090,1060,1075,833,833,309,324,532,532,832,772,818,803,561,561,531,560,515,546,289,274,288,258,
763         -250,-1179,-1579,-1836,-1996,-2124,-2253,-2333,-2413,-2477,-2542,-2574,-2607,-2622,-2655,1314,1313,1298,1312,1282,785,785,785,785,1040,1040,1025,1025,768,768,768,768,-766,-798,-830,-862,-895,-911,-927,-943,-959,-975,-991,-1007,-1023,-1039,-1055,-1070,1724,1647,-1103,-1119,1631,1767,1662,1738,1708,1723,-1135,1780,1615,1779,1599,1677,1646,1778,1583,-1151,1777,1567,1737,1692,1765,1722,1707,1630,1751,1661,1764,1614,1736,1676,1763,1750,1645,1598,1721,1691,1762,1706,1582,1761,1566,-1167,1749,1629,767,766,751,765,494,494,735,764,719,749,734,763,447,447,748,718,477,506,431,491,446,476,461,505,415,430,475,445,504,399,460,489,414,503,383,474,429,459,502,502,746,752,488,398,501,473,413,472,486,271,480,270,-1439,-1455,1357,-1471,-1487,-1503,1341,1325,-1519,1489,1463,1403,1309,-1535,1372,1448,1418,1476,1356,1462,1387,-1551,1475,1340,1447,1402,1386,-1567,1068,1068,1474,1461,455,380,468,440,395,425,410,454,364,467,466,464,453,269,409,448,268,432,1371,1473,1432,1417,1308,1460,1355,1446,1459,1431,1083,1083,1401,1416,1458,1445,1067,1067,1370,1457,1051,1051,1291,1430,1385,1444,1354,1415,1400,1443,1082,1082,1173,1113,1186,1066,1185,1050,-1967,1158,1128,1172,1097,1171,1081,-1983,1157,1112,416,266,375,400,1170,1142,1127,1065,793,793,1169,1033,1156,1096,1141,1111,1155,1080,1126,1140,898,898,808,808,897,897,792,792,1095,1152,1032,1125,1110,1139,1079,1124,882,807,838,881,853,791,-2319,867,368,263,822,852,837,866,806,865,-2399,851,352,262,534,534,821,836,594,594,549,549,593,593,533,533,848,773,579,579,564,578,548,563,276,276,577,576,306,291,516,560,305,305,275,259,
764         -251,-892,-2058,-2620,-2828,-2957,-3023,-3039,1041,1041,1040,1040,769,769,769,769,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,-511,-527,-543,-559,1530,-575,-591,1528,1527,1407,1526,1391,1023,1023,1023,1023,1525,1375,1268,1268,1103,1103,1087,1087,1039,1039,1523,-604,815,815,815,815,510,495,509,479,508,463,507,447,431,505,415,399,-734,-782,1262,-815,1259,1244,-831,1258,1228,-847,-863,1196,-879,1253,987,987,748,-767,493,493,462,477,414,414,686,669,478,446,461,445,474,429,487,458,412,471,1266,1264,1009,1009,799,799,-1019,-1276,-1452,-1581,-1677,-1757,-1821,-1886,-1933,-1997,1257,1257,1483,1468,1512,1422,1497,1406,1467,1496,1421,1510,1134,1134,1225,1225,1466,1451,1374,1405,1252,1252,1358,1480,1164,1164,1251,1251,1238,1238,1389,1465,-1407,1054,1101,-1423,1207,-1439,830,830,1248,1038,1237,1117,1223,1148,1236,1208,411,426,395,410,379,269,1193,1222,1132,1235,1221,1116,976,976,1192,1162,1177,1220,1131,1191,963,963,-1647,961,780,-1663,558,558,994,993,437,408,393,407,829,978,813,797,947,-1743,721,721,377,392,844,950,828,890,706,706,812,859,796,960,948,843,934,874,571,571,-1919,690,555,689,421,346,539,539,944,779,918,873,932,842,903,888,570,570,931,917,674,674,-2575,1562,-2591,1609,-2607,1654,1322,1322,1441,1441,1696,1546,1683,1593,1669,1624,1426,1426,1321,1321,1639,1680,1425,1425,1305,1305,1545,1668,1608,1623,1667,1592,1638,1666,1320,1320,1652,1607,1409,1409,1304,1304,1288,1288,1664,1637,1395,1395,1335,1335,1622,1636,1394,1394,1319,1319,1606,1621,1392,1392,1137,1137,1137,1137,345,390,360,375,404,373,1047,-2751,-2767,-2783,1062,1121,1046,-2799,1077,-2815,1106,1061,789,789,1105,1104,263,355,310,340,325,354,352,262,339,324,1091,1076,1029,1090,1060,1075,833,833,788,788,1088,1028,818,818,803,803,561,561,531,531,816,771,546,546,289,274,288,258,
765         -253,-317,-381,-446,-478,-509,1279,1279,-811,-1179,-1451,-1756,-1900,-2028,-2189,-2253,-2333,-2414,-2445,-2511,-2526,1313,1298,-2559,1041,1041,1040,1040,1025,1025,1024,1024,1022,1007,1021,991,1020,975,1019,959,687,687,1018,1017,671,671,655,655,1016,1015,639,639,758,758,623,623,757,607,756,591,755,575,754,559,543,543,1009,783,-575,-621,-685,-749,496,-590,750,749,734,748,974,989,1003,958,988,973,1002,942,987,957,972,1001,926,986,941,971,956,1000,910,985,925,999,894,970,-1071,-1087,-1102,1390,-1135,1436,1509,1451,1374,-1151,1405,1358,1480,1420,-1167,1507,1494,1389,1342,1465,1435,1450,1326,1505,1310,1493,1373,1479,1404,1492,1464,1419,428,443,472,397,736,526,464,464,486,457,442,471,484,482,1357,1449,1434,1478,1388,1491,1341,1490,1325,1489,1463,1403,1309,1477,1372,1448,1418,1433,1476,1356,1462,1387,-1439,1475,1340,1447,1402,1474,1324,1461,1371,1473,269,448,1432,1417,1308,1460,-1711,1459,-1727,1441,1099,1099,1446,1386,1431,1401,-1743,1289,1083,1083,1160,1160,1458,1445,1067,1067,1370,1457,1307,1430,1129,1129,1098,1098,268,432,267,416,266,400,-1887,1144,1187,1082,1173,1113,1186,1066,1050,1158,1128,1143,1172,1097,1171,1081,420,391,1157,1112,1170,1142,1127,1065,1169,1049,1156,1096,1141,1111,1155,1080,1126,1154,1064,1153,1140,1095,1048,-2159,1125,1110,1137,-2175,823,823,1139,1138,807,807,384,264,368,263,868,838,853,791,867,822,852,837,866,806,865,790,-2319,851,821,836,352,262,850,805,849,-2399,533,533,835,820,336,261,578,548,563,577,532,532,832,772,562,562,547,547,305,275,560,515,290,290,288,258 ];
766     static immutable uint8_t[] tab32 = [ 130,162,193,209,44,28,76,140,9,9,9,9,9,9,9,9,190,254,222,238,126,94,157,157,109,61,173,205 ];
767     static immutable uint8_t[] tab33 = [ 252,236,220,204,188,172,156,140,124,108,92,76,60,44,28,12 ];
768     static immutable int16_t[2*16] tabindex = [ 0,32,64,98,0,132,180,218,292,364,426,538,648,746,0,1126,1460,1460,1460,1460,1460,1460,1460,1460,1842,1842,1842,1842,1842,1842,1842,1842 ];
769     static immutable uint8_t[] g_linbits =  [ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,3,4,6,8,10,13,4,5,6,7,8,9,11,13 ];
770 
771 
772     float one = 0.0f;
773     int ireg = 0, big_val_cnt = gr_info.big_values;
774     const(uint8_t)* sfb = gr_info.sfbtab;
775     const(uint8_t)* bs_next_ptr = bs.buf + bs.pos/8;
776     uint32_t bs_cache = (((bs_next_ptr[0]*256u + bs_next_ptr[1])*256u + bs_next_ptr[2])*256u + bs_next_ptr[3]) << (bs.pos & 7);
777     int pairs_to_decode, np, bs_sh = (bs.pos & 7) - 8;
778     bs_next_ptr += 4;
779 
780     while (big_val_cnt > 0)
781     {
782         int tab_num = gr_info.table_select[ireg];
783         int sfb_cnt = gr_info.region_count[ireg++];
784         const int16_t *codebook = tabs.ptr + tabindex[tab_num];
785         int linbits = g_linbits[tab_num];
786         if (linbits)
787         {
788             do
789             {
790                 np = *sfb++ / 2;
791                 pairs_to_decode = MINIMP3_MIN(big_val_cnt, np);
792                 one = *scf++;
793                 do
794                 {
795                     int j, w = 5;
796                     int leaf = codebook[(bs_cache >> (32 - w))];
797                     while (leaf < 0)
798                     {
799                         { bs_cache <<= (w); bs_sh += (w); }
800                         w = leaf & 7;
801                         leaf = codebook[(bs_cache >> (32 - w)) - (leaf >> 3)];
802                     }
803                     { bs_cache <<= (leaf >> 8); bs_sh += (leaf >> 8); }
804 
805                     for (j = 0; j < 2; j++, dst++, leaf >>= 4)
806                     {
807                         int lsb = leaf & 0x0F;
808                         if (lsb == 15)
809                         {
810                             lsb += (bs_cache >> (32 - linbits));
811                             { bs_cache <<= (linbits); bs_sh += (linbits); }
812                             while (bs_sh >= 0) { bs_cache |= cast(uint32_t)*bs_next_ptr++ << bs_sh; bs_sh -= 8; }
813                             *dst = one*L3_pow_43(lsb)*(cast(int32_t)bs_cache < 0 ? -1: 1);
814                         } else
815                         {
816                             *dst = g_pow43[16 + lsb - 16*(bs_cache >> 31)]*one;
817                         }
818 
819                         { bs_cache <<= (lsb ? 1 : 0); bs_sh += (lsb ? 1 : 0); }
820                     }
821                     while (bs_sh >= 0) { bs_cache |= cast(uint32_t)*bs_next_ptr++ << bs_sh; bs_sh -= 8; }
822                 } while (--pairs_to_decode);
823             } while ((big_val_cnt -= np) > 0 && --sfb_cnt >= 0);
824         } else
825         {
826             do
827             {
828                 np = *sfb++ / 2;
829                 pairs_to_decode = MINIMP3_MIN(big_val_cnt, np);
830                 one = *scf++;
831                 do
832                 {
833                     int j, w = 5;
834                     int leaf = codebook[(bs_cache >> (32 - w))];
835                     while (leaf < 0)
836                     {
837                         { bs_cache <<= (w); bs_sh += (w); }
838                         w = leaf & 7;
839                         leaf = codebook[(bs_cache >> (32 - w)) - (leaf >> 3)];
840                     }
841                     { bs_cache <<= (leaf >> 8); bs_sh += (leaf >> 8); }
842 
843                     for (j = 0; j < 2; j++, dst++, leaf >>= 4)
844                     {
845                         int lsb = leaf & 0x0F;
846                         *dst = g_pow43[16 + lsb - 16*(bs_cache >> 31)]*one;
847                         { bs_cache <<= (lsb ? 1 : 0); bs_sh += (lsb ? 1 : 0); }
848                     }
849                     while (bs_sh >= 0) { bs_cache |= cast(uint32_t)*bs_next_ptr++ << bs_sh; bs_sh -= 8; }
850                 } while (--pairs_to_decode);
851             } while ((big_val_cnt -= np) > 0 && --sfb_cnt >= 0);
852         }
853     }
854 
855     for (np = 1 - big_val_cnt;; dst += 4)
856     {
857         const uint8_t *codebook_count1 = (gr_info.count1_table) ? tab33.ptr : tab32.ptr;
858         int leaf = codebook_count1[(bs_cache >> (32 - 4))];
859         if (!(leaf & 8))
860         {
861             leaf = codebook_count1[(leaf >> 3) + (bs_cache << 4 >> (32 - (leaf & 3)))];
862         }
863 
864         { bs_cache <<= (leaf & 7); bs_sh += (leaf & 7); }
865 
866         if (((bs_next_ptr - bs.buf)*8 - 24 + bs_sh) > layer3gr_limit)
867         {
868             break;
869         }
870 //#define RELOAD_SCALEFACTOR  if (!--np) { np = *sfb++/2; if (!np) break; one = *scf++; }
871 //#define DEQ_COUNT1(s) if (leaf & (128 >> s)) { dst[s] = ((int32_t)bs_cache < 0) ? -one : one; FLUSH_BITS(1) }
872 
873         if (!--np) { np = *sfb++/2; if (!np) break; one = *scf++; }
874         /*DEQ_COUNT1(0);*/ if (leaf & (128 >> 0)) { dst[0] = (cast(int32_t)bs_cache < 0) ? -one : one; { bs_cache <<= (1); bs_sh += (1); } }
875         /*DEQ_COUNT1(1);*/ if (leaf & (128 >> 1)) { dst[1] = (cast(int32_t)bs_cache < 0) ? -one : one; { bs_cache <<= (1); bs_sh += (1); } }
876         if (!--np) { np = *sfb++/2; if (!np) break; one = *scf++; }
877         /* DEQ_COUNT1(2); */ if (leaf & (128 >> 2)) { dst[2] = (cast(int32_t)bs_cache < 0) ? -one : one; { bs_cache <<= (1); bs_sh += (1); } }
878         /* DEQ_COUNT1(3); */ if (leaf & (128 >> 3)) { dst[3] = (cast(int32_t)bs_cache < 0) ? -one : one; { bs_cache <<= (1); bs_sh += (1); } }
879         while (bs_sh >= 0) { bs_cache |= cast(uint32_t)*bs_next_ptr++ << bs_sh; bs_sh -= 8; }
880     }
881 
882     bs.pos = layer3gr_limit;
883 }
884 
885 void L3_midside_stereo(float *left, int n)
886 {
887     int i = 0;
888     float *right = left + 576;
889     for (; i < n; i++)
890     {
891         float a = left[i];
892         float b = right[i];
893         left[i] = a + b;
894         right[i] = a - b;
895     }
896 }
897 
898 void L3_intensity_stereo_band(float *left, int n, float kl, float kr)
899 {
900     int i;
901     for (i = 0; i < n; i++)
902     {
903         left[i + 576] = left[i]*kr;
904         left[i] = left[i]*kl;
905     }
906 }
907 
908 void L3_stereo_top_band(const(float)*right, const uint8_t *sfb, int nbands, int* max_band)
909 {
910     int i, k;
911 
912     max_band[0] = max_band[1] = max_band[2] = -1;
913 
914     for (i = 0; i < nbands; i++)
915     {
916         for (k = 0; k < sfb[i]; k += 2)
917         {
918             if (right[k] != 0 || right[k + 1] != 0)
919             {
920                 max_band[i % 3] = i;
921                 break;
922             }
923         }
924         right += sfb[i];
925     }
926 }
927 
928 void L3_stereo_process(float *left, const uint8_t *ist_pos, const uint8_t *sfb, const uint8_t *hdr, int* max_band, int mpeg2_sh)
929 {
930     static immutable float[7*2] g_pan = [ 0,1,0.21132487f,0.78867513f,0.36602540f,0.63397460f,0.5f,0.5f,0.63397460f,0.36602540f,0.78867513f,0.21132487f,1,0 ];
931     uint i;
932     uint max_pos = HDR_TEST_MPEG1(hdr) ? 7 : 64;
933 
934     for (i = 0; sfb[i]; i++)
935     {
936         uint ipos = ist_pos[i];
937         if (cast(int)i > max_band[i % 3] && ipos < max_pos)
938         {
939             float kl, kr, s = HDR_TEST_MS_STEREO(hdr) ? 1.41421356f : 1;
940             if (HDR_TEST_MPEG1(hdr))
941             {
942                 kl = g_pan[2*ipos];
943                 kr = g_pan[2*ipos + 1];
944             } else
945             {
946                 kl = 1;
947                 kr = L3_ldexp_q2(1, (ipos + 1) >> 1 << mpeg2_sh);
948                 if (ipos & 1)
949                 {
950                     kl = kr;
951                     kr = 1;
952                 }
953             }
954             L3_intensity_stereo_band(left, sfb[i], kl*s, kr*s);
955         } else if (HDR_TEST_MS_STEREO(hdr))
956         {
957             L3_midside_stereo(left, sfb[i]);
958         }
959         left += sfb[i];
960     }
961 }
962 
963 void L3_intensity_stereo(float *left, uint8_t *ist_pos, const L3_gr_info_t *gr, const uint8_t *hdr)
964 {
965     int[3] max_band;
966     int n_sfb = gr.n_long_sfb + gr.n_short_sfb;
967     int i, max_blocks = gr.n_short_sfb ? 3 : 1;
968 
969     L3_stereo_top_band(left + 576, gr.sfbtab, n_sfb, max_band.ptr);
970     if (gr.n_long_sfb)
971     {
972         max_band[0] = max_band[1] = max_band[2] = MINIMP3_MAX(MINIMP3_MAX(max_band[0], max_band[1]), max_band[2]);
973     }
974     for (i = 0; i < max_blocks; i++)
975     {
976         int default_pos = HDR_TEST_MPEG1(hdr) ? 3 : 0;
977         int itop = n_sfb - max_blocks + i;
978         int prev = itop - max_blocks;
979         ist_pos[itop] = cast(ubyte)( max_band[i] >= prev ? default_pos : ist_pos[prev] );
980     }
981     L3_stereo_process(left, ist_pos, gr.sfbtab, hdr, max_band.ptr, gr[1].scalefac_compress & 1);
982 }
983 
984 void L3_reorder(float *grbuf, float *scratch, const(uint8_t) *sfb)
985 {
986     int i, len;
987     float *src = grbuf;
988     float *dst = scratch;
989 
990     for (;0 != (len = *sfb); sfb += 3, src += 2*len)
991     {
992         for (i = 0; i < len; i++, src++)
993         {
994             *dst++ = src[0*len];
995             *dst++ = src[1*len];
996             *dst++ = src[2*len];
997         }
998     }
999     memcpy(grbuf, scratch, (dst - scratch)*float.sizeof);
1000 }
1001 
1002 void L3_antialias(float *grbuf, int nbands)
1003 {
1004     static immutable float[8][2] g_aa = [
1005         [0.85749293f,0.88174200f,0.94962865f,0.98331459f,0.99551782f,0.99916056f,0.99989920f,0.99999316f],
1006         [0.51449576f,0.47173197f,0.31337745f,0.18191320f,0.09457419f,0.04096558f,0.01419856f,0.00369997f]
1007     ];
1008 
1009     for (; nbands > 0; nbands--, grbuf += 18)
1010     {
1011         int i = 0;
1012         for(; i < 8; i++)
1013         {
1014             float u = grbuf[18 + i];
1015             float d = grbuf[17 - i];
1016             grbuf[18 + i] = u*g_aa[0][i] - d*g_aa[1][i];
1017             grbuf[17 - i] = u*g_aa[1][i] + d*g_aa[0][i];
1018         }
1019     }
1020 }
1021 
1022 void L3_dct3_9(float *y)
1023 {
1024     float s0, s1, s2, s3, s4, s5, s6, s7, s8, t0, t2, t4;
1025 
1026     s0 = y[0]; s2 = y[2]; s4 = y[4]; s6 = y[6]; s8 = y[8];
1027     t0 = s0 + s6*0.5f;
1028     s0 -= s6;
1029     t4 = (s4 + s2)*0.93969262f;
1030     t2 = (s8 + s2)*0.76604444f;
1031     s6 = (s4 - s8)*0.17364818f;
1032     s4 += s8 - s2;
1033 
1034     s2 = s0 - s4*0.5f;
1035     y[4] = s4 + s0;
1036     s8 = t0 - t2 + s6;
1037     s0 = t0 - t4 + t2;
1038     s4 = t0 + t4 - s6;
1039 
1040     s1 = y[1]; s3 = y[3]; s5 = y[5]; s7 = y[7];
1041 
1042     s3 *= 0.86602540f;
1043     t0 = (s5 + s1)*0.98480775f;
1044     t4 = (s5 - s7)*0.34202014f;
1045     t2 = (s1 + s7)*0.64278761f;
1046     s1 = (s1 - s5 - s7)*0.86602540f;
1047 
1048     s5 = t0 - s3 - t2;
1049     s7 = t4 - s3 - t0;
1050     s3 = t4 + s3 - t2;
1051 
1052     y[0] = s4 - s7;
1053     y[1] = s2 + s1;
1054     y[2] = s0 - s3;
1055     y[3] = s8 + s5;
1056     y[5] = s8 - s5;
1057     y[6] = s0 + s3;
1058     y[7] = s2 - s1;
1059     y[8] = s4 + s7;
1060 }
1061 
1062 void L3_imdct36(float *grbuf, float *overlap, const float *window, int nbands)
1063 {
1064     int i, j;
1065     static immutable float[18] g_twid9 = [
1066         0.73727734f,0.79335334f,0.84339145f,0.88701083f,0.92387953f,0.95371695f,0.97629601f,0.99144486f,0.99904822f,0.67559021f,0.60876143f,0.53729961f,0.46174861f,0.38268343f,0.30070580f,0.21643961f,0.13052619f,0.04361938f
1067     ];
1068 
1069     for (j = 0; j < nbands; j++, grbuf += 18, overlap += 9)
1070     {
1071         float[9] co, si;
1072         co[0] = -grbuf[0];
1073         si[0] = grbuf[17];
1074         for (i = 0; i < 4; i++)
1075         {
1076             si[8 - 2*i] =   grbuf[4*i + 1] - grbuf[4*i + 2];
1077             co[1 + 2*i] =   grbuf[4*i + 1] + grbuf[4*i + 2];
1078             si[7 - 2*i] =   grbuf[4*i + 4] - grbuf[4*i + 3];
1079             co[2 + 2*i] = -(grbuf[4*i + 3] + grbuf[4*i + 4]);
1080         }
1081         L3_dct3_9(co.ptr);
1082         L3_dct3_9(si.ptr);
1083 
1084         si[1] = -si[1];
1085         si[3] = -si[3];
1086         si[5] = -si[5];
1087         si[7] = -si[7];
1088 
1089         i = 0;
1090 
1091         for (; i < 9; i++)
1092         {
1093             float ovl  = overlap[i];
1094             float sum  = co[i]*g_twid9[9 + i] + si[i]*g_twid9[0 + i];
1095             overlap[i] = co[i]*g_twid9[0 + i] - si[i]*g_twid9[9 + i];
1096             grbuf[i]      = ovl*window[0 + i] - sum*window[9 + i];
1097             grbuf[17 - i] = ovl*window[9 + i] + sum*window[0 + i];
1098         }
1099     }
1100 }
1101 
1102 void L3_idct3(float x0, float x1, float x2, float *dst)
1103 {
1104     float m1 = x1*0.86602540f;
1105     float a1 = x0 - x2*0.5f;
1106     dst[1] = x0 + x2;
1107     dst[0] = a1 + m1;
1108     dst[2] = a1 - m1;
1109 }
1110 
1111 void L3_imdct12(float *x, float *dst, float *overlap)
1112 {
1113     static immutable float[6] g_twid3 = [ 0.79335334f,0.92387953f,0.99144486f, 0.60876143f,0.38268343f,0.13052619f ];
1114     float[3] co, si;
1115     int i;
1116 
1117     L3_idct3(-x[0], x[6] + x[3], x[12] + x[9], co.ptr);
1118     L3_idct3(x[15], x[12] - x[9], x[6] - x[3], si.ptr);
1119     si[1] = -si[1];
1120 
1121     for (i = 0; i < 3; i++)
1122     {
1123         float ovl  = overlap[i];
1124         float sum  = co[i]*g_twid3[3 + i] + si[i]*g_twid3[0 + i];
1125         overlap[i] = co[i]*g_twid3[0 + i] - si[i]*g_twid3[3 + i];
1126         dst[i]     = ovl*g_twid3[2 - i] - sum*g_twid3[5 - i];
1127         dst[5 - i] = ovl*g_twid3[5 - i] + sum*g_twid3[2 - i];
1128     }
1129 }
1130 
1131 void L3_imdct_short(float *grbuf, float *overlap, int nbands)
1132 {
1133     for (;nbands > 0; nbands--, overlap += 9, grbuf += 18)
1134     {
1135         float[18] tmp;
1136         memcpy(tmp.ptr, grbuf, tmp.sizeof);
1137         memcpy(grbuf, overlap, 6*float.sizeof);
1138         L3_imdct12(tmp.ptr, grbuf + 6, overlap + 6);
1139         L3_imdct12(tmp.ptr + 1, grbuf + 12, overlap + 6);
1140         L3_imdct12(tmp.ptr + 2, overlap, overlap + 6);
1141     }
1142 }
1143 
1144 void L3_change_sign(float *grbuf)
1145 {
1146     int b, i;
1147     for (b = 0, grbuf += 18; b < 32; b += 2, grbuf += 36)
1148         for (i = 1; i < 18; i += 2)
1149             grbuf[i] = -grbuf[i];
1150 }
1151 
1152 void L3_imdct_gr(float *grbuf, float *overlap, uint block_type, uint n_long_bands)
1153 {
1154     static immutable float[18][2] g_mdct_window = [
1155         [ 0.99904822f,0.99144486f,0.97629601f,0.95371695f,0.92387953f,0.88701083f,0.84339145f,0.79335334f,0.73727734f,0.04361938f,0.13052619f,0.21643961f,0.30070580f,0.38268343f,0.46174861f,0.53729961f,0.60876143f,0.67559021f ],
1156         [ 1,1,1,1,1,1,0.99144486f,0.92387953f,0.79335334f,0,0,0,0,0,0,0.13052619f,0.38268343f,0.60876143f ]
1157     ];
1158     if (n_long_bands)
1159     {
1160         L3_imdct36(grbuf, overlap, g_mdct_window[0].ptr, n_long_bands);
1161         grbuf += 18*n_long_bands;
1162         overlap += 9*n_long_bands;
1163     }
1164     if (block_type == SHORT_BLOCK_TYPE)
1165         L3_imdct_short(grbuf, overlap, 32 - n_long_bands);
1166     else
1167         L3_imdct36(grbuf, overlap, g_mdct_window[block_type == STOP_BLOCK_TYPE].ptr, 32 - n_long_bands);
1168 }
1169 
1170 void L3_save_reservoir(mp3dec_t *h, mp3dec_scratch_t *s)
1171 {
1172     int pos = (s.bs.pos + 7)/8u;
1173     int remains = s.bs.limit/8u - pos;
1174     if (remains > MAX_BITRESERVOIR_BYTES)
1175     {
1176         pos += remains - MAX_BITRESERVOIR_BYTES;
1177         remains = MAX_BITRESERVOIR_BYTES;
1178     }
1179     if (remains > 0)
1180     {
1181         memmove(h.reserv_buf.ptr, s.maindata.ptr + pos, remains);
1182     }
1183     h.reserv = remains;
1184 }
1185 
1186 static int L3_restore_reservoir(mp3dec_t *h, bs_t *bs, mp3dec_scratch_t *s, int main_data_begin)
1187 {
1188     int frame_bytes = (bs.limit - bs.pos)/8;
1189     int bytes_have = MINIMP3_MIN(h.reserv, main_data_begin);
1190     memcpy(s.maindata.ptr, h.reserv_buf.ptr + MINIMP3_MAX(0, h.reserv - main_data_begin), MINIMP3_MIN(h.reserv, main_data_begin));
1191     memcpy(s.maindata.ptr + bytes_have, bs.buf + bs.pos/8, frame_bytes);
1192     bs_init(&s.bs, s.maindata.ptr, bytes_have + frame_bytes);
1193     return h.reserv >= main_data_begin;
1194 }
1195 
1196 void L3_decode(mp3dec_t *h, mp3dec_scratch_t *s, L3_gr_info_t *gr_info, int nch)
1197 {
1198     int ch;
1199 
1200     for (ch = 0; ch < nch; ch++)
1201     {
1202         int layer3gr_limit = s.bs.pos + gr_info[ch].part_23_length;
1203         L3_decode_scalefactors(h.header.ptr, s.ist_pos[ch].ptr, &s.bs, gr_info + ch, s.scf.ptr, ch);
1204         L3_huffman(s.grbuf[ch].ptr, &s.bs, gr_info + ch, s.scf.ptr, layer3gr_limit);
1205     }
1206 
1207     if (HDR_TEST_I_STEREO(h.header.ptr))
1208     {
1209         L3_intensity_stereo(s.grbuf[0].ptr, s.ist_pos[1].ptr, gr_info, h.header.ptr);
1210     } else if (HDR_IS_MS_STEREO(h.header.ptr))
1211     {
1212         L3_midside_stereo(s.grbuf[0].ptr, 576);
1213     }
1214 
1215     for (ch = 0; ch < nch; ch++, gr_info++)
1216     {
1217         int aa_bands = 31;
1218         int n_long_bands = (gr_info.mixed_block_flag ? 2 : 0) << cast(int)(HDR_GET_MY_SAMPLE_RATE(h.header.ptr) == 2);
1219 
1220         if (gr_info.n_short_sfb)
1221         {
1222             aa_bands = n_long_bands - 1;
1223             L3_reorder(s.grbuf[ch].ptr + n_long_bands*18, s.syn[0].ptr, gr_info.sfbtab + gr_info.n_long_sfb);
1224         }
1225 
1226         L3_antialias(s.grbuf[ch].ptr, aa_bands);
1227         L3_imdct_gr(s.grbuf[ch].ptr, h.mdct_overlap[ch].ptr, gr_info.block_type, n_long_bands);
1228         L3_change_sign(s.grbuf[ch].ptr);
1229     }
1230 }
1231 
1232 void mp3d_DCT_II(float *grbuf, int n)
1233 {
1234     static immutable float[24] g_sec = [
1235         10.19000816f,0.50060302f,0.50241929f,3.40760851f,0.50547093f,0.52249861f,2.05778098f,0.51544732f,0.56694406f,1.48416460f,0.53104258f,0.64682180f,1.16943991f,0.55310392f,0.78815460f,0.97256821f,0.58293498f,1.06067765f,0.83934963f,0.62250412f,1.72244716f,0.74453628f,0.67480832f,5.10114861f
1236     ];
1237     int i, k = 0;
1238 
1239     for (; k < n; k++)
1240     {
1241         float[8][4] t;
1242         float* x, y = grbuf + k;
1243 
1244         for (x = t[0].ptr, i = 0; i < 8; i++, x++)
1245         {
1246             float x0 = y[i*18];
1247             float x1 = y[(15 - i)*18];
1248             float x2 = y[(16 + i)*18];
1249             float x3 = y[(31 - i)*18];
1250             float t0 = x0 + x3;
1251             float t1 = x1 + x2;
1252             float t2 = (x1 - x2)*g_sec[3*i + 0];
1253             float t3 = (x0 - x3)*g_sec[3*i + 1];
1254             x[0] = t0 + t1;
1255             x[8] = (t0 - t1)*g_sec[3*i + 2];
1256             x[16] = t3 + t2;
1257             x[24] = (t3 - t2)*g_sec[3*i + 2];
1258         }
1259         for (x = t[0].ptr, i = 0; i < 4; i++, x += 8)
1260         {
1261             float x0 = x[0], x1 = x[1], x2 = x[2], x3 = x[3], x4 = x[4], x5 = x[5], x6 = x[6], x7 = x[7], xt;
1262             xt = x0 - x7; x0 += x7;
1263             x7 = x1 - x6; x1 += x6;
1264             x6 = x2 - x5; x2 += x5;
1265             x5 = x3 - x4; x3 += x4;
1266             x4 = x0 - x3; x0 += x3;
1267             x3 = x1 - x2; x1 += x2;
1268             x[0] = x0 + x1;
1269             x[4] = (x0 - x1)*0.70710677f;
1270             x5 =  x5 + x6;
1271             x6 = (x6 + x7)*0.70710677f;
1272             x7 =  x7 + xt;
1273             x3 = (x3 + x4)*0.70710677f;
1274             x5 -= x7*0.198912367f;  /* rotate by PI/8 */
1275             x7 += x5*0.382683432f;
1276             x5 -= x7*0.198912367f;
1277             x0 = xt - x6; xt += x6;
1278             x[1] = (xt + x7)*0.50979561f;
1279             x[2] = (x4 + x3)*0.54119611f;
1280             x[3] = (x0 - x5)*0.60134488f;
1281             x[5] = (x0 + x5)*0.89997619f;
1282             x[6] = (x4 - x3)*1.30656302f;
1283             x[7] = (xt - x7)*2.56291556f;
1284 
1285         }
1286         for (i = 0; i < 7; i++, y += 4*18)
1287         {
1288             y[0*18] = t[0][i];
1289             y[1*18] = t[2][i] + t[3][i] + t[3][i + 1];
1290             y[2*18] = t[1][i] + t[1][i + 1];
1291             y[3*18] = t[2][i + 1] + t[3][i] + t[3][i + 1];
1292         }
1293         y[0*18] = t[0][7];
1294         y[1*18] = t[2][7] + t[3][7];
1295         y[2*18] = t[1][7];
1296         y[3*18] = t[3][7];
1297     }
1298 }
1299 
1300 float mp3d_scale_pcm(float sample)
1301 {
1302     return sample*(1.0f/32768.0f);
1303 }
1304 
1305 void mp3d_synth_pair(mp3d_sample_t *pcm, int nch, const(float)*z)
1306 {
1307     float a;
1308     a  = (z[14*64] - z[    0]) * 29;
1309     a += (z[ 1*64] + z[13*64]) * 213;
1310     a += (z[12*64] - z[ 2*64]) * 459;
1311     a += (z[ 3*64] + z[11*64]) * 2037;
1312     a += (z[10*64] - z[ 4*64]) * 5153;
1313     a += (z[ 5*64] + z[ 9*64]) * 6574;
1314     a += (z[ 8*64] - z[ 6*64]) * 37489;
1315     a +=  z[ 7*64]             * 75038;
1316     pcm[0] = mp3d_scale_pcm(a);
1317 
1318     z += 2;
1319     a  = z[14*64] * 104;
1320     a += z[12*64] * 1567;
1321     a += z[10*64] * 9727;
1322     a += z[ 8*64] * 64019;
1323     a += z[ 6*64] * -9975;
1324     a += z[ 4*64] * -45;
1325     a += z[ 2*64] * 146;
1326     a += z[ 0*64] * -5;
1327     pcm[16*nch] = mp3d_scale_pcm(a);
1328 }
1329 
1330 void mp3d_synth(float *xl, mp3d_sample_t *dstl, int nch, float *lins)
1331 {
1332     int i;
1333     float *xr = xl + 576*(nch - 1);
1334     mp3d_sample_t *dstr = dstl + (nch - 1);
1335 
1336     static immutable float[] g_win = [
1337         -1,26,-31,208,218,401,-519,2063,2000,4788,-5517,7134,5959,35640,-39336,74992,
1338         -1,24,-35,202,222,347,-581,2080,1952,4425,-5879,7640,5288,33791,-41176,74856,
1339         -1,21,-38,196,225,294,-645,2087,1893,4063,-6237,8092,4561,31947,-43006,74630,
1340         -1,19,-41,190,227,244,-711,2085,1822,3705,-6589,8492,3776,30112,-44821,74313,
1341         -1,17,-45,183,228,197,-779,2075,1739,3351,-6935,8840,2935,28289,-46617,73908,
1342         -1,16,-49,176,228,153,-848,2057,1644,3004,-7271,9139,2037,26482,-48390,73415,
1343         -2,14,-53,169,227,111,-919,2032,1535,2663,-7597,9389,1082,24694,-50137,72835,
1344         -2,13,-58,161,224,72,-991,2001,1414,2330,-7910,9592,70,22929,-51853,72169,
1345         -2,11,-63,154,221,36,-1064,1962,1280,2006,-8209,9750,-998,21189,-53534,71420,
1346         -2,10,-68,147,215,2,-1137,1919,1131,1692,-8491,9863,-2122,19478,-55178,70590,
1347         -3,9,-73,139,208,-29,-1210,1870,970,1388,-8755,9935,-3300,17799,-56778,69679,
1348         -3,8,-79,132,200,-57,-1283,1817,794,1095,-8998,9966,-4533,16155,-58333,68692,
1349         -4,7,-85,125,189,-83,-1356,1759,605,814,-9219,9959,-5818,14548,-59838,67629,
1350         -4,7,-91,117,177,-106,-1428,1698,402,545,-9416,9916,-7154,12980,-61289,66494,
1351         -5,6,-97,111,163,-127,-1498,1634,185,288,-9585,9838,-8540,11455,-62684,65290
1352     ];
1353     float *zlin = lins + 15*64;
1354     const(float) *w = g_win.ptr;
1355 
1356     zlin[4*15]     = xl[18*16];
1357     zlin[4*15 + 1] = xr[18*16];
1358     zlin[4*15 + 2] = xl[0];
1359     zlin[4*15 + 3] = xr[0];
1360 
1361     zlin[4*31]     = xl[1 + 18*16];
1362     zlin[4*31 + 1] = xr[1 + 18*16];
1363     zlin[4*31 + 2] = xl[1];
1364     zlin[4*31 + 3] = xr[1];
1365 
1366     mp3d_synth_pair(dstr, nch, lins + 4*15 + 1);
1367     mp3d_synth_pair(dstr + 32*nch, nch, lins + 4*15 + 64 + 1);
1368     mp3d_synth_pair(dstl, nch, lins + 4*15);
1369     mp3d_synth_pair(dstl + 32*nch, nch, lins + 4*15 + 64);
1370 
1371     for (i = 14; i >= 0; i--)
1372     {
1373 //#define LOAD(k) float w0 = *w++; float w1 = *w++; float *vz = &zlin[4*i - k*64]; float *vy = &zlin[4*i - (15 - k)*64];
1374 //#define S0(k) { int j; LOAD(k); for (j = 0; j < 4; j++) b[j]  = vz[j]*w1 + vy[j]*w0, a[j]  = vz[j]*w0 - vy[j]*w1; }
1375 //#define S1(k) { int j; LOAD(k); for (j = 0; j < 4; j++) b[j] += vz[j]*w1 + vy[j]*w0, a[j] += vz[j]*w0 - vy[j]*w1; }
1376 //#define S2(k) { int j; LOAD(k); for (j = 0; j < 4; j++) b[j] += vz[j]*w1 + vy[j]*w0, a[j] += vy[j]*w1 - vz[j]*w0; }
1377         float[4] a, b;
1378 
1379         zlin[4*i]     = xl[18*(31 - i)];
1380         zlin[4*i + 1] = xr[18*(31 - i)];
1381         zlin[4*i + 2] = xl[1 + 18*(31 - i)];
1382         zlin[4*i + 3] = xr[1 + 18*(31 - i)];
1383         zlin[4*(i + 16)]   = xl[1 + 18*(1 + i)];
1384         zlin[4*(i + 16) + 1] = xr[1 + 18*(1 + i)];
1385         zlin[4*(i - 16) + 2] = xl[18*(1 + i)];
1386         zlin[4*(i - 16) + 3] = xr[18*(1 + i)];
1387 
1388         /* S0(0) */ { int j; float w0 = *w++; float w1 = *w++; float *vz = &zlin[4*i - 0*64]; float *vy = &zlin[4*i - (15 - 0)*64]; /* LOAD(0); */ for (j = 0; j < 4; j++) b[j]  = vz[j]*w1 + vy[j]*w0, a[j]  = vz[j]*w0 - vy[j]*w1; }
1389         /* S2(1) */ { int j; float w0 = *w++; float w1 = *w++; float *vz = &zlin[4*i - 1*64]; float *vy = &zlin[4*i - (15 - 1)*64]; /* LOAD(1); */ for (j = 0; j < 4; j++) b[j] += vz[j]*w1 + vy[j]*w0, a[j] += vy[j]*w1 - vz[j]*w0; } 
1390         /* S1(2) */ { int j; float w0 = *w++; float w1 = *w++; float *vz = &zlin[4*i - 2*64]; float *vy = &zlin[4*i - (15 - 2)*64]; /* LOAD(2); */ for (j = 0; j < 4; j++) b[j] += vz[j]*w1 + vy[j]*w0, a[j] += vz[j]*w0 - vy[j]*w1; }
1391         /* S2(3) */ { int j; float w0 = *w++; float w1 = *w++; float *vz = &zlin[4*i - 3*64]; float *vy = &zlin[4*i - (15 - 3)*64]; /* LOAD(3); */ for (j = 0; j < 4; j++) b[j] += vz[j]*w1 + vy[j]*w0, a[j] += vy[j]*w1 - vz[j]*w0; } 
1392         /* S1(4) */ { int j; float w0 = *w++; float w1 = *w++; float *vz = &zlin[4*i - 4*64]; float *vy = &zlin[4*i - (15 - 4)*64]; /* LOAD(4); */ for (j = 0; j < 4; j++) b[j] += vz[j]*w1 + vy[j]*w0, a[j] += vz[j]*w0 - vy[j]*w1; }
1393         /* S2(5) */ { int j; float w0 = *w++; float w1 = *w++; float *vz = &zlin[4*i - 5*64]; float *vy = &zlin[4*i - (15 - 5)*64]; /* LOAD(5); */ for (j = 0; j < 4; j++) b[j] += vz[j]*w1 + vy[j]*w0, a[j] += vy[j]*w1 - vz[j]*w0; } 
1394         /* S1(6) */ { int j; float w0 = *w++; float w1 = *w++; float *vz = &zlin[4*i - 6*64]; float *vy = &zlin[4*i - (15 - 6)*64]; /* LOAD(6); */ for (j = 0; j < 4; j++) b[j] += vz[j]*w1 + vy[j]*w0, a[j] += vz[j]*w0 - vy[j]*w1; }
1395         /* S2(7) */ { int j; float w0 = *w++; float w1 = *w++; float *vz = &zlin[4*i - 7*64]; float *vy = &zlin[4*i - (15 - 7)*64]; /* LOAD(7); */ for (j = 0; j < 4; j++) b[j] += vz[j]*w1 + vy[j]*w0, a[j] += vy[j]*w1 - vz[j]*w0; } 
1396 
1397         dstr[(15 - i)*nch] = mp3d_scale_pcm(a[1]);
1398         dstr[(17 + i)*nch] = mp3d_scale_pcm(b[1]);
1399         dstl[(15 - i)*nch] = mp3d_scale_pcm(a[0]);
1400         dstl[(17 + i)*nch] = mp3d_scale_pcm(b[0]);
1401         dstr[(47 - i)*nch] = mp3d_scale_pcm(a[3]);
1402         dstr[(49 + i)*nch] = mp3d_scale_pcm(b[3]);
1403         dstl[(47 - i)*nch] = mp3d_scale_pcm(a[2]);
1404         dstl[(49 + i)*nch] = mp3d_scale_pcm(b[2]);
1405     }
1406 }
1407 
1408 void mp3d_synth_granule(float *qmf_state, float *grbuf, int nbands, int nch, mp3d_sample_t *pcm, float *lins)
1409 {
1410     int i;
1411     for (i = 0; i < nch; i++)
1412     {
1413         mp3d_DCT_II(grbuf + 576*i, nbands);
1414     }
1415 
1416     memcpy(lins, qmf_state, float.sizeof*15*64);
1417 
1418     for (i = 0; i < nbands; i += 2)
1419     {
1420         mp3d_synth(grbuf + i, pcm + 32*nch*i, nch, lins + i*64);
1421     }
1422 
1423     if (nch == 1)
1424     {
1425         for (i = 0; i < 15*64; i += 2)
1426         {
1427             qmf_state[i] = lins[nbands*64 + i];
1428         }
1429     } else
1430 
1431     {
1432         memcpy(qmf_state, lins + nbands*64, float.sizeof*15*64);
1433     }
1434 }
1435 
1436 static int mp3d_match_frame(const uint8_t *hdr, int mp3_bytes, int frame_bytes)
1437 {
1438     int i, nmatch;
1439     for (i = 0, nmatch = 0; nmatch < MAX_FRAME_SYNC_MATCHES; nmatch++)
1440     {
1441         i += hdr_frame_bytes(hdr + i, frame_bytes) + hdr_padding(hdr + i);
1442         if (i + HDR_SIZE > mp3_bytes)
1443             return nmatch > 0;
1444         if (!hdr_compare(hdr, hdr + i))
1445             return 0;
1446     }
1447     return 1;
1448 }
1449 
1450 static int mp3d_find_frame(const(uint8_t) *mp3, int mp3_bytes, int *free_format_bytes, int *ptr_frame_bytes)
1451 {
1452     int i, k;
1453     for (i = 0; i < mp3_bytes - HDR_SIZE; i++, mp3++)
1454     {
1455         if (hdr_valid(mp3))
1456         {
1457             int frame_bytes = hdr_frame_bytes(mp3, *free_format_bytes);
1458             int frame_and_padding = frame_bytes + hdr_padding(mp3);
1459 
1460             for (k = HDR_SIZE; !frame_bytes && k < MAX_FREE_FORMAT_FRAME_SIZE && i + 2*k < mp3_bytes - HDR_SIZE; k++)
1461             {
1462                 if (hdr_compare(mp3, mp3 + k))
1463                 {
1464                     int fb = k - hdr_padding(mp3);
1465                     int nextfb = fb + hdr_padding(mp3 + k);
1466                     if (i + k + nextfb + HDR_SIZE > mp3_bytes || !hdr_compare(mp3, mp3 + k + nextfb))
1467                         continue;
1468                     frame_and_padding = k;
1469                     frame_bytes = fb;
1470                     *free_format_bytes = fb;
1471                 }
1472             }
1473             if ((frame_bytes && i + frame_and_padding <= mp3_bytes &&
1474                 mp3d_match_frame(mp3, mp3_bytes - i, frame_bytes)) ||
1475                 (!i && frame_and_padding == mp3_bytes))
1476             {
1477                 *ptr_frame_bytes = frame_and_padding;
1478                 return i;
1479             }
1480             *free_format_bytes = 0;
1481         }
1482     }
1483     *ptr_frame_bytes = 0;
1484     return mp3_bytes;
1485 }
1486 
1487 void mp3dec_init(mp3dec_t *dec)
1488 {
1489     dec.header[0] = 0;
1490 }
1491 
1492 int mp3dec_decode_frame(mp3dec_t *dec, const uint8_t *mp3, int mp3_bytes, mp3d_sample_t *pcm, mp3dec_frame_info_t *info)
1493 {
1494     int i = 0, igr, frame_size = 0, success = 1;
1495     const(uint8_t) *hdr;
1496     bs_t[1] bs_frame;
1497     mp3dec_scratch_t scratch;
1498 
1499     if (mp3_bytes > 4 && dec.header[0] == 0xff && hdr_compare(dec.header.ptr, mp3))
1500     {
1501         frame_size = hdr_frame_bytes(mp3, dec.free_format_bytes) + hdr_padding(mp3);
1502         if (frame_size != mp3_bytes && (frame_size + HDR_SIZE > mp3_bytes || !hdr_compare(mp3, mp3 + frame_size)))
1503         {
1504             frame_size = 0;
1505         }
1506     }
1507     if (!frame_size)
1508     {
1509         memset(dec, 0, mp3dec_t.sizeof);
1510         i = mp3d_find_frame(mp3, mp3_bytes, &dec.free_format_bytes, &frame_size);
1511         if (!frame_size || i + frame_size > mp3_bytes)
1512         {
1513             info.frame_bytes = i;
1514             return 0;
1515         }
1516     }
1517 
1518     hdr = mp3 + i;
1519     memcpy(dec.header.ptr, hdr, HDR_SIZE);
1520     info.frame_bytes = i + frame_size;
1521     info.frame_offset = i;
1522     info.channels = HDR_IS_MONO(hdr) ? 1 : 2;
1523     info.hz = hdr_sample_rate_hz(hdr);
1524     info.layer = 4 - HDR_GET_LAYER(hdr);
1525     info.bitrate_kbps = hdr_bitrate_kbps(hdr);
1526 
1527     if (!pcm)
1528     {
1529         return hdr_frame_samples(hdr);
1530     }
1531 
1532     bs_init(bs_frame.ptr, hdr + HDR_SIZE, frame_size - HDR_SIZE);
1533     if (HDR_IS_CRC(hdr))
1534     {
1535         get_bits(bs_frame.ptr, 16);
1536     }
1537 
1538     if (info.layer == 3)
1539     {
1540         int main_data_begin = L3_read_side_info(bs_frame.ptr, scratch.gr_info.ptr, hdr);
1541         if (main_data_begin < 0 || bs_frame[0].pos > bs_frame[0].limit)
1542         {
1543             mp3dec_init(dec);
1544             return 0;
1545         }
1546         success = L3_restore_reservoir(dec, bs_frame.ptr, &scratch, main_data_begin);
1547         if (success)
1548         {
1549             for (igr = 0; igr < (HDR_TEST_MPEG1(hdr) ? 2 : 1); igr++, pcm += 576*info.channels)
1550             {
1551                 memset(scratch.grbuf[0].ptr, 0, 576*2*float.sizeof);
1552                 L3_decode(dec, &scratch, scratch.gr_info.ptr + igr*info.channels, info.channels);
1553                 mp3d_synth_granule(dec.qmf_state.ptr, scratch.grbuf[0].ptr, 18, info.channels, pcm, scratch.syn[0].ptr);
1554             }
1555         }
1556         L3_save_reservoir(dec, &scratch);
1557     } else
1558     {
1559         L12_scale_info[1] sci;
1560         L12_read_scale_info(hdr, bs_frame.ptr, sci.ptr);
1561 
1562         memset(scratch.grbuf[0].ptr, 0, 576*2*float.sizeof);
1563         for (i = 0, igr = 0; igr < 3; igr++)
1564         {
1565             if (12 == (i += L12_dequantize_granule(scratch.grbuf[0].ptr + i, bs_frame.ptr, sci.ptr, info.layer | 1)))
1566             {
1567                 i = 0;
1568                 L12_apply_scf_384(sci.ptr, sci[0].scf.ptr + igr, scratch.grbuf[0].ptr);
1569                 mp3d_synth_granule(dec.qmf_state.ptr, scratch.grbuf[0].ptr, 12, info.channels, pcm, scratch.syn[0].ptr);
1570                 memset(scratch.grbuf[0].ptr, 0, 576*2*float.sizeof);
1571                 pcm += 384*info.channels;
1572             }
1573             if (bs_frame[0].pos > bs_frame[0].limit)
1574             {
1575                 mp3dec_init(dec);
1576                 return 0;
1577             }
1578         }
1579     }
1580     return success*hdr_frame_samples(dec.header.ptr);
1581 }