The OpenD Programming Language

1 /++
2 	Port of the C library [https://github.com/lieff/minimp3|minimp3] to D, with an added high-level API
3 	in the form of [MP3Decoder].
4 
5 	You can use it through [arsd.simpleaudio]'s playMp3 function for a very easy high-level api to just play
6 	the sound. If all you want is the mp3 sound to come out your computer's speakers, use that api. If you want
7 	to inspect a mp3 file's innards, play it through a different api, convert it to different formats, etc., this
8 	module may help you.
9 
10 	Authors:
11 		Original C source: https://github.com/lieff/minimp3
12 
13 		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.  This software is distributed without any warranty.  See <http://creativecommons.org/publicdomain/zero/1.0/>.
14 
15 		Translated to D by Guillaume Piolat. He stripped it down a bit for the needs of audio-formats.
16 
17 		Lightly modified by Adam for arsd inclusion and maintaining compatibility with the published interface of the old implementation.
18 		I added the [MP3Decoder] back from the old implementation and removed `@nogc nothrow` for being annoying. Of course, most things
19 		here don't do GC or throws at runtime anyway, with the exception of first call setups.
20 	History:
21 		This module used to be based on a different minimp3, written in 2008 and based on ffmpeg code. On November 20, 2020, I replaced it with the newer implementation (which is the designated successor of the original minimp3). Since the implementation was all private previously, this meant little outside breakage, but some attribute qualifiers changed.
22 
23 		The new minimp3 implementation is public, but not part of the official `arsd.mp3` API, so I reserve the right to change it again without notice. Only the [MP3Decoder] has stability guarantees. (Though I am unlikely to change what works.)
24 +/
25 module arsd.mp3;
26 
27 /++
28 	The high-level D api for mp3 decoding. You construct it with a read and seek function,
29 	then inspect the members for info about the mp3, then call [decodeNextFrame] and
30 	[frameSamplesFloat] in a loop to get the data until frameSamplesFloat returns an empty
31 	array, indicating you've hit the end of file.
32 +/
33 class MP3Decoder {
34 
35 	// https://github.com/lieff/minimp3#high-level-api
36 
37 	private mp3dec_ex_t dec;
38 	private bool isOpen;
39 
40 	private static size_t read_cb_static(void* buf, size_t size, void* user_data) {
41 		//import std.stdio; writeln("request ", size);
42 		auto d = cast(MP3Decoder) user_data;
43 		return d.reader(cast(ubyte[]) buf[0 .. size]);
44 	}
45 
46 	private static int seek_cb_static(uint64_t position, void* user_data) {
47 		auto d = cast(MP3Decoder) user_data;
48 		return d.seeker(position);
49 	}
50 
51 	// read bytes into the buffer, return number of bytes read or 0 for EOF, -1 on error
52 	// will never be called with empty buffer, or buffer more than 128KB
53 	alias ReadBufFn = int delegate (void[] buf);
54 
55 	private int delegate (ubyte[] buf) reader;
56 	private int delegate(ulong where) seeker;
57 
58 	private mp3dec_io_t io;
59 
60 	/++
61 		Creates a mp3 decoder out of two functions: a reader and a seeker. Both must work together
62 		for things to work.
63 
64 		A reader works like `fread` - it gives you a buffer and you fill it as much as you can,
65 		and return the number of bytes filled. A seeker works like `fseek`, it tells you a position
66 		in the file to go to and you do it, then return 0. If you return non-zero, the library will
67 		treat that as an I/O error. You can forward directly to those C functions if you like. Or, you
68 		can refer to a memory buffer, or even a network stream. It is all up to you.
69 
70 		Please note that you are responsible for closing the file when you are done with it. This means
71 		*after* the mp3 decoder is no longer used. The api will not help you determine this.
72 
73 		Also note that the delegates are NOT scope - they are held on to by this class. It is your
74 		responsibility to get lifetimes right; the delegates need to remain valid throughout the use
75 		of the decoder object. As a particular warning, a [std.stdio.File] has a RAII destructor that
76 		will trigger when it goes out of scope - $(I not) at the end of its referenced lifetime. Meaning
77 		the object will be copied for your delegates, but the file will be closed when the function
78 		returns, making it useless! I recommend you encapsulate all this in an additional object.
79 
80 		[arsd.simpleaudio]'s playMp3 function does this encapsulation for you.
81 
82 		History:
83 			It used to take the `reader` as scope, but that changed on November 20, 2022. It also
84 			used to not take the `seeker` argument, but this is now required.
85 
86 			The `reader` used to take `void[] buf`, but now takes `ubyte[] buf`. This is a simple
87 			change in your signature, otherwise they work the same. ubyte is more appropriate since
88 			it is looking for file bytes, not random untyped data.
89 
90 			I realize these are all breaking changes, but the fix is easy and the new functionality,
91 			the [seek] function among others, is worth it. To me anyway, and I hope for you too.
92 	+/
93 	this (int delegate (ubyte[] buf) reader, int delegate(ulong where) seeker) @system {
94 		if (reader is null)
95 			throw new Exception("reader is null");
96 		if (seeker is null)
97 			throw new Exception("seeker is null");
98 
99 		this.reader = reader;
100 		this.seeker = seeker;
101 
102 		io.read = &read_cb_static;
103 		io.read_data = cast(void*) this;
104 		io.seek = &seek_cb_static;
105 		io.seek_data = cast(void*) this;
106 
107 		auto ret = mp3dec_ex_open_cb(&dec, &io, MP3D_SEEK_TO_SAMPLE);
108 		if(ret != 0) {
109 			// import std.stdio; writeln(ret);
110 			throw new Exception("open");
111 		}
112 		isOpen = true;
113 	}
114 
115 	~this () { close(); }
116 
117 	/++
118 		Seeks the decoder to the given sample number, so the next call to [decodeNextFrame] will move to that part of the file.
119 
120 		To go from a time in seconds to a sampleNumber, multiply by [sampleRate] and by [channels]: `mp3.seek(timeInSeconds * mp3.sampleRate * mp3.channels)`.
121 
122 		Returns: `true` if the seek was successful. Among the reasons it can be false is giving an invalid sample number, an i/o error, or the decoder already being closed.
123 
124 		History:
125 			Added November 20, 2022
126 	+/
127 	bool seek(uint sampleNumber) {
128 		if(!isOpen)
129 			return false;
130 
131 		auto ret = mp3dec_ex_seek(&dec, sampleNumber);
132 		// import std.stdio; writeln("seek ", ret);
133 
134 		return true;
135 	}
136 
137 	/++
138 		Closes the decoder, freeing memory associated with it. Remember, this does NOT close any file you referred to in your reader and seeker delegates, it just frees internal memory.
139 	+/
140 	void close () {
141 		if(isOpen) {
142 			mp3dec_ex_close(&dec);
143 			isOpen = false;
144 		}
145 	}
146 
147 	private float[] decodedFramesFloat;
148 	private short[] decodedFramesShort;
149 	private size_t decodedFramesUsed;
150 	private bool shortDecoded;
151 
152 	// Deprecated - it ignores the reader and calls the other overload.
153 	// Only provided for API compatibility with old versions.
154 
155 	// FIXME: when it reaches eof, what do we want to do?
156 	/++
157 		Decodes the next frame of data and stores it in [frameSamplesFloat] (also accessible
158 		through [frameSamples] as `short[]`).
159 
160 		Returns:
161 			`true` if a new frame was decoded, `false` if it wasn't. Possible reasons for failure are trying to decode an invalid mp3 (see [valid]) and reaching end-of-file.
162 
163 		Params:
164 			reader = ignored. Overload only provided for API compatibility with older versions of `arsd.mp3`.
165 
166 		See_Also:
167 			[channels], [sampleRate]
168 	+/
169 	bool decodeNextFrame () {
170 		if(!isOpen)
171 			return false;
172 
173 		if(decodedFramesFloat is null)
174 			decodedFramesFloat = new float[](MINIMP3_MAX_SAMPLES_PER_FRAME);
175 
176 		auto ret = mp3dec_ex_read(&dec, decodedFramesFloat.ptr, decodedFramesFloat.length);
177 		// import std.stdio; writeln("ret ", ret);
178 		decodedFramesUsed = ret;
179 		shortDecoded = false;
180 
181 		if(ret <= 0) {
182 			close();
183 		}
184 
185 		return ret > 0;
186 	}
187 
188 	/// ditto
189 	deprecated bool decodeNextFrame (scope ReadBufFn reader) {
190 		return decodeNextFrame();
191 	}
192 
193 	/++
194 		Returns `true` if the object is in a valid state. May be
195 		false if the stream was corrupted or reached end-of-file.
196 	+/
197 	@property bool valid () const pure nothrow @trusted @nogc {
198 		return isOpen;
199 	}
200 	/++
201 		Returns the sample rate, in hz, of the audio stream. Note that
202 		this is per channel, so if this returns 44,100 hz and [channels]
203 		returns 2, you'd have a total of 88,200 samples per second between
204 		the two channels.
205 
206 		See_Also:
207 			[channels]
208 	+/
209 	@property uint sampleRate () const pure nothrow @trusted @nogc {
210 		return valid ? dec.info.hz : 0;
211 	}
212 	/++
213 		Returns the number of channels in the file. Note the channel
214 		data is interlaced, meaning the first sample is left channel,
215 		second sample right channel, then back and forth (assuming two
216 		channels, of course).
217 
218 		See_Also:
219 			[sampleRate]
220 	+/
221 	@property ubyte channels () const pure nothrow @trusted @nogc {
222 		return (valid ? cast(ubyte) dec.info.channels : 0);
223 	}
224 	/++
225 		Returns the bitrate of the first frame, in kbps.
226 
227 		Note that different frames of the file may vary bitrate, so this
228 		is only an approximation of the whole file.
229 
230 		History:
231 			Added November 21, 2022 (dub v10.10)
232 	+/
233 	@property int bitrate() const pure nothrow @trusted @nogc {
234 		return (valid ? dec.info.bitrate_kbps : 0);
235 	}
236 
237 	/++
238 		Returns the duration of the mp3, in seconds, if available, or `float.nan` if it is unknown
239 		(unknown may happen because it is an unseekable stream without metadata).
240 
241 		History:
242 			Added November 26, 2022 (dub v10.10)
243 	+/
244 	@property float duration() const pure nothrow @trusted @nogc {
245 		return (valid ? (cast(float) dec.samples / sampleRate / channels) : float.nan);
246 	}
247 
248 	/++
249 		Returns the number of samples in the current frame, as prepared by [decodeNextFrame].
250 
251 		You probably never need to actually call this, as it is just `frameSamplesFloat.length / channels`.
252 
253 		See_Also:
254 			[frameSamplesFloat], [frameSamples], [decodeNextFrame], [channels]
255 	+/
256 	@property int samplesInFrame () const pure nothrow @trusted @nogc {
257 		if(valid)
258 			return cast(int) (decodedFramesUsed / channels);
259 		else
260 			return 0;
261 	}
262 	/++
263 		Returns the current frame, as prepared by [decodeNextFrame], in signed 16 bit (`short[]`) format.
264 
265 		This will allocate the buffer on first use, then continue reusing it for the duration of the `MP3Decoder`
266 		instance's lifetime, meaning it will not allocate again in the loop, but you should not keep a reference
267 		to the array because its contents will be overwritten as you continue calling `decodeNextFrame`.
268 
269 		Is you want something that never allocates, see [frameSamplesFloat].
270 
271 		Please note that you MUST call [decodeNextFrame] first.
272 
273 		See_Also:
274 			[frameSamplesFloat], [decodeNextFrame]
275 
276 		History:
277 			This was `@nogc` until November 20, 2022. It now lazily allocates the buffer
278 			if needed. If you want something nogc, use [frameSamplesFloat] and convert it yourself.
279 	+/
280 	@property short[] frameSamples () nothrow {
281 		if(decodedFramesShort is null)
282 			decodedFramesShort = new short[](MINIMP3_MAX_SAMPLES_PER_FRAME);
283 		if(!shortDecoded) {
284 			foreach(i, frame; frameSamplesFloat)
285 				decodedFramesShort[i] = cast(short)(frame * short.max);
286 			shortDecoded = true;
287 		}
288 		return decodedFramesShort[0 .. decodedFramesUsed];
289 	}
290 	/++
291 		Returns the current frame, as prepared by [decodeNextFrame], in floating point (`float[]`) format.
292 
293 		You should not keep a reference to the array because its contents will be overwritten as you continue
294 		calling `decodeNextFrame`.
295 
296 		See_Also:
297 			[frameSamples], [decodeNextFrame]
298 
299 		History:
300 			Added November 20, 2022 (dub v10.10)
301 
302 	+/
303 	@property float[] frameSamplesFloat () nothrow @nogc {
304 		return decodedFramesFloat[0 .. decodedFramesUsed];
305 	}
306 
307 	/++
308 		Calls `seek(0)`. This function is provided for compatibility with older versions of the MP3Decoder api and has no other use.
309 
310 		Params:
311 			reader = ignored, provided just for legacy compatibility
312 	+/
313 	deprecated void restart (scope ReadBufFn reader) { seek(0); }
314 
315 	/++
316 		Does nothing. Only provided for compatibility with older versions of the MP3Decoder api.
317 
318 		Previously would resync to a frame after a file seek, but this is no longer necessary. Call [seek] instead.
319 	+/
320 	deprecated void sync (scope ReadBufFn reader) { }
321 }
322 
323 
324 
325 
326 @system:
327 
328 import core.stdc.stdlib;
329 import core.stdc.string;
330 
331 // nothrow:
332 // @nogc:
333 
334 alias uint8_t = ubyte;
335 alias uint16_t = ushort;
336 alias uint32_t = uint;
337 alias uint64_t = ulong;
338 alias int16_t = short;
339 alias int32_t = int;
340 
341 @safe enum MINIMP3_MAX_SAMPLES_PER_FRAME = (1152*2);
342 
343 struct mp3dec_frame_info_t
344 {
345     int frame_bytes;
346     int frame_offset;
347     int channels;
348     int hz;
349     int layer;
350     int bitrate_kbps;
351 }
352 
353 struct mp3dec_t
354 {
355     float[9*32][2] mdct_overlap;
356     float[15*2*32] qmf_state;
357     int reserv;
358     int free_format_bytes;
359     ubyte[4] header;
360     ubyte[511] reserv_buf;
361 }
362 
363 version = MINIMP3_FLOAT_OUTPUT;
364 
365 
366 alias mp3d_sample_t = float;
367 
368 enum MAX_FREE_FORMAT_FRAME_SIZE = 2304;    /* more than ISO spec's */
369 enum MAX_FRAME_SYNC_MATCHES = 10;
370 
371 enum MAX_L3_FRAME_PAYLOAD_BYTES = MAX_FREE_FORMAT_FRAME_SIZE; /* MUST be >= 320000/8/32000*1152 = 1440 */
372 
373 enum MAX_BITRESERVOIR_BYTES      = 511;
374 enum SHORT_BLOCK_TYPE            = 2;
375 enum STOP_BLOCK_TYPE             = 3;
376 enum MODE_MONO                   = 3;
377 enum MODE_JOINT_STEREO           = 1;
378 enum HDR_SIZE                    = 4;
379 
380 bool HDR_IS_MONO(const(ubyte)* h)
381 {
382     return (((h[3]) & 0xC0) == 0xC0);
383 }
384 
385 bool HDR_IS_MS_STEREO(const(ubyte)* h)
386 {
387     return  (((h[3]) & 0xE0) == 0x60);
388 }
389 
390 bool HDR_IS_FREE_FORMAT(const(ubyte)* h)
391 {
392     return (((h[2]) & 0xF0) == 0);
393 }
394 
395 bool HDR_IS_CRC(const(ubyte)* h)
396 {
397     return (!((h[1]) & 1));
398 }
399 
400 int HDR_TEST_PADDING(const(ubyte)* h)
401 {
402     return ((h[2]) & 0x2);
403 }
404 
405 int HDR_TEST_MPEG1(const(ubyte)* h)
406 {
407     return ((h[1]) & 0x8);
408 }
409 
410 int HDR_TEST_NOT_MPEG25(const(ubyte)* h)
411 {
412     return ((h[1]) & 0x10);
413 }
414 
415 int HDR_TEST_I_STEREO(const(ubyte)* h)
416 {
417     return ((h[3]) & 0x10);
418 }
419 
420 int HDR_TEST_MS_STEREO(const(ubyte)* h)
421 {
422     return ((h[3]) & 0x20);
423 }
424 
425 int HDR_GET_STEREO_MODE(const(ubyte)* h)
426 {
427     return (((h[3]) >> 6) & 3);
428 }
429 
430 int HDR_GET_STEREO_MODE_EXT(const(ubyte)* h)
431 {
432     return (((h[3]) >> 4) & 3);
433 }
434 
435 int HDR_GET_LAYER(const(ubyte)* h)
436 {
437     return (((h[1]) >> 1) & 3);
438 }
439 
440 int HDR_GET_BITRATE(const(ubyte)* h)
441 {
442     return ((h[2]) >> 4);
443 }
444 
445 int HDR_GET_SAMPLE_RATE(const(ubyte)* h)
446 {
447     return (((h[2]) >> 2) & 3);
448 }
449 
450 int HDR_GET_MY_SAMPLE_RATE(const(ubyte)* h)
451 {
452     return (HDR_GET_SAMPLE_RATE(h) + (((h[1] >> 3) & 1) + ((h[1] >> 4) & 1))*3);
453 }
454 
455 bool HDR_IS_FRAME_576(const(ubyte)* h)
456 {
457     return ((h[1] & 14) == 2);
458 }
459 
460 bool HDR_IS_LAYER_1(const(ubyte)* h)
461 {
462     return ((h[1] & 6) == 6);
463 }
464 
465 enum BITS_DEQUANTIZER_OUT        = -1;
466 enum MAX_SCF                     = 255 + BITS_DEQUANTIZER_OUT*4 - 210;
467 enum MAX_SCFI                    = (MAX_SCF + 3) & ~3;
468 
469 int MINIMP3_MIN(int a, int b)
470 {
471     return (a > b) ? b : a;
472 }
473 
474 ulong MINIMP3_MIN(ulong a, ulong b)
475 {
476     return (a > b) ? b : a;
477 }
478 
479 int MINIMP3_MAX(int a, int b)
480 {
481     return (a < b) ? b : a;
482 }
483 
484 struct bs_t
485 {
486     const(uint8_t)* buf;
487     int pos, limit;
488 }
489 
490 struct L12_scale_info
491 {
492     float[3*64] scf;
493     uint8_t total_bands;
494     uint8_t stereo_bands;
495     ubyte[64] bitalloc;
496     ubyte[64] scfcod;
497 }
498 
499 struct L12_subband_alloc_t
500 {
501     uint8_t tab_offset, code_tab_width, band_count;
502 }
503 
504 struct L3_gr_info_t
505 {
506     const(uint8_t)* sfbtab;
507     uint16_t part_23_length, big_values, scalefac_compress;
508     uint8_t global_gain, block_type, mixed_block_flag, n_long_sfb, n_short_sfb;
509     uint8_t[3] table_select, region_count, subblock_gain;
510     uint8_t preflag, scalefac_scale, count1_table, scfsi;
511 }
512 
513 struct mp3dec_scratch_t
514 {
515     bs_t bs;
516     uint8_t[MAX_BITRESERVOIR_BYTES + MAX_L3_FRAME_PAYLOAD_BYTES] maindata;
517     L3_gr_info_t[4] gr_info;
518     float[576][2] grbuf;
519     float[40] scf;
520     float[2*32][18 + 15] syn;
521     uint8_t[39][2] ist_pos;
522 }
523 
524 void bs_init(bs_t *bs, const(uint8_t)*data, int bytes)
525 {
526     bs.buf   = data;
527     bs.pos   = 0;
528     bs.limit = bytes*8;
529 }
530 
531 uint32_t get_bits(bs_t *bs, int n)
532 {
533     uint32_t next, cache = 0, s = bs.pos & 7;
534     int shl = n + s;
535     const(uint8_t)*p = bs.buf + (bs.pos >> 3);
536     if ((bs.pos += n) > bs.limit)
537         return 0;
538     next = *p++ & (255 >> s);
539     while ((shl -= 8) > 0)
540     {
541         cache |= next << shl;
542         next = *p++;
543     }
544     return cache | (next >> -shl);
545 }
546 
547 int hdr_valid(const uint8_t *h)
548 {
549     return h[0] == 0xff &&
550         ((h[1] & 0xF0) == 0xf0 || (h[1] & 0xFE) == 0xe2) &&
551         (HDR_GET_LAYER(h) != 0) &&
552         (HDR_GET_BITRATE(h) != 15) &&
553         (HDR_GET_SAMPLE_RATE(h) != 3);
554 }
555 
556 int hdr_compare(const uint8_t *h1, const uint8_t *h2)
557 {
558     return hdr_valid(h2) &&
559         ((h1[1] ^ h2[1]) & 0xFE) == 0 &&
560         ((h1[2] ^ h2[2]) & 0x0C) == 0 &&
561         !(HDR_IS_FREE_FORMAT(h1) ^ HDR_IS_FREE_FORMAT(h2));
562 }
563 
564 uint hdr_bitrate_kbps(const uint8_t *h)
565 {
566     static immutable uint8_t[15][3][2] halfrate =
567     [
568         [ [ 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 ] ],
569         [ [ 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 ] ],
570     ];
571     return 2*halfrate[!!HDR_TEST_MPEG1(h)][HDR_GET_LAYER(h) - 1][HDR_GET_BITRATE(h)];
572 }
573 
574 uint hdr_sample_rate_hz(const uint8_t *h)
575 {
576     static immutable uint[3] g_hz = [ 44100, 48000, 32000 ];
577     return g_hz[HDR_GET_SAMPLE_RATE(h)] >> cast(int)!HDR_TEST_MPEG1(h) >> cast(int)!HDR_TEST_NOT_MPEG25(h);
578 }
579 
580 uint hdr_frame_samples(const uint8_t *h)
581 {
582     return HDR_IS_LAYER_1(h) ? 384 : (1152 >> cast(int)HDR_IS_FRAME_576(h));
583 }
584 
585 int hdr_frame_bytes(const uint8_t *h, int free_format_size)
586 {
587     int frame_bytes = hdr_frame_samples(h)*hdr_bitrate_kbps(h)*125/hdr_sample_rate_hz(h);
588     if (HDR_IS_LAYER_1(h))
589     {
590         frame_bytes &= ~3; /* slot align */
591     }
592     return frame_bytes ? frame_bytes : free_format_size;
593 }
594 
595 static int hdr_padding(const uint8_t *h)
596 {
597     return HDR_TEST_PADDING(h) ? (HDR_IS_LAYER_1(h) ? 4 : 1) : 0;
598 }
599 
600 
601 const(L12_subband_alloc_t)* L12_subband_alloc_table(const uint8_t *hdr, L12_scale_info *sci)
602 {
603     const(L12_subband_alloc_t) *alloc;
604     int mode = HDR_GET_STEREO_MODE(hdr);
605     int nbands, stereo_bands = (mode == MODE_MONO) ? 0 : (mode == MODE_JOINT_STEREO) ? (HDR_GET_STEREO_MODE_EXT(hdr) << 2) + 4 : 32;
606 
607     if (HDR_IS_LAYER_1(hdr))
608     {
609         static immutable L12_subband_alloc_t[] g_alloc_L1 =
610         [
611             L12_subband_alloc_t(76, 4, 32)
612         ];
613         alloc = g_alloc_L1.ptr;
614         nbands = 32;
615     }
616     else if (!HDR_TEST_MPEG1(hdr))
617     {
618         static immutable L12_subband_alloc_t[] g_alloc_L2M2 =
619         [
620             L12_subband_alloc_t(60, 4, 4),
621             L12_subband_alloc_t(44, 3, 7 ),
622             L12_subband_alloc_t(44, 2, 19),
623         ];
624         alloc = g_alloc_L2M2.ptr;
625         nbands = 30;
626     }
627     else
628     {
629         static immutable L12_subband_alloc_t[] g_alloc_L2M1 =
630         [
631             L12_subband_alloc_t(0, 4, 3),
632             L12_subband_alloc_t(16, 4, 8),
633             L12_subband_alloc_t(32, 3, 12),
634             L12_subband_alloc_t(40, 2, 7)
635         ];
636 
637         int sample_rate_idx = HDR_GET_SAMPLE_RATE(hdr);
638         uint kbps = hdr_bitrate_kbps(hdr) >> cast(int)(mode != MODE_MONO);
639         if (!kbps) /* free-format */
640         {
641             kbps = 192;
642         }
643 
644         alloc = g_alloc_L2M1.ptr;
645         nbands = 27;
646         if (kbps < 56)
647         {
648             static immutable L12_subband_alloc_t[] g_alloc_L2M1_lowrate =
649             [
650 
651                L12_subband_alloc_t(44, 4, 2),
652                L12_subband_alloc_t(44, 3, 10)
653             ];
654             alloc = g_alloc_L2M1_lowrate.ptr;
655             nbands = sample_rate_idx == 2 ? 12 : 8;
656         }
657         else if (kbps >= 96 && sample_rate_idx != 1)
658         {
659             nbands = 30;
660         }
661     }
662 
663     sci.total_bands = cast(uint8_t)nbands;
664     sci.stereo_bands = cast(uint8_t)MINIMP3_MIN(stereo_bands, nbands);
665 
666     return alloc;
667 }
668 
669 void L12_read_scalefactors(bs_t *bs, uint8_t *pba, uint8_t *scfcod, int bands, float *scf)
670 {
671     static immutable float[18*3] g_deq_L12 =
672     [
673         3.17891e-07, 2.52311e-07, 2.00259e-07, 1.36239e-07, 1.08133e-07, 8.58253e-08,
674         6.35783e-08, 5.04621e-08, 4.00518e-08, 3.07637e-08, 2.44172e-08, 1.93799e-08,
675         1.51377e-08, 1.20148e-08, 9.53615e-09, 7.50925e-09, 5.96009e-09, 4.73053e-09,
676         3.7399e-09, 2.96836e-09, 2.35599e-09, 1.86629e-09, 1.48128e-09, 1.17569e-09,
677         9.32233e-10, 7.39914e-10, 5.8727e-10, 4.65889e-10, 3.69776e-10, 2.93492e-10,
678         2.32888e-10, 1.84843e-10, 1.4671e-10, 1.1643e-10, 9.24102e-11, 7.3346e-11,
679         5.82112e-11, 4.62023e-11, 3.66708e-11, 2.91047e-11, 2.31004e-11, 1.83348e-11,
680         1.45521e-11, 1.155e-11, 9.16727e-12, 3.17891e-07, 2.52311e-07, 2.00259e-07,
681         1.90735e-07, 1.51386e-07, 1.20155e-07, 1.05964e-07, 8.41035e-08, 6.6753e-08
682     ];
683 
684     int i, m;
685     for (i = 0; i < bands; i++)
686     {
687         float s = 0;
688         int ba = *pba++;
689         int mask = ba ? 4 + ((19 >> scfcod[i]) & 3) : 0;
690         for (m = 4; m; m >>= 1)
691         {
692             if (mask & m)
693             {
694                 int b = get_bits(bs, 6);
695                 s = g_deq_L12[ba*3 - 6 + b % 3]*(1 << 21 >> b/3);
696             }
697             *scf++ = s;
698         }
699     }
700 }
701 
702 void L12_read_scale_info(const uint8_t *hdr, bs_t *bs, L12_scale_info *sci)
703 {
704     static immutable uint8_t[] g_bitalloc_code_tab =
705     [
706         0,17, 3, 4, 5,6,7, 8,9,10,11,12,13,14,15,16,
707         0,17,18, 3,19,4,5, 6,7, 8, 9,10,11,12,13,16,
708         0,17,18, 3,19,4,5,16,
709         0,17,18,16,
710         0,17,18,19, 4,5,6, 7,8, 9,10,11,12,13,14,15,
711         0,17,18, 3,19,4,5, 6,7, 8, 9,10,11,12,13,14,
712         0, 2, 3, 4, 5,6,7, 8,9,10,11,12,13,14,15,16
713     ];
714     const(L12_subband_alloc_t)* subband_alloc = L12_subband_alloc_table(hdr, sci);
715 
716     int i, k = 0, ba_bits = 0;
717     const(uint8_t)*ba_code_tab = g_bitalloc_code_tab.ptr;
718 
719     for (i = 0; i < sci.total_bands; i++)
720     {
721         uint8_t ba;
722         if (i == k)
723         {
724             k += subband_alloc.band_count;
725             ba_bits = subband_alloc.code_tab_width;
726             ba_code_tab = g_bitalloc_code_tab.ptr + subband_alloc.tab_offset;
727             subband_alloc++;
728         }
729         ba = ba_code_tab[get_bits(bs, ba_bits)];
730         sci.bitalloc[2*i] = ba;
731         if (i < sci.stereo_bands)
732         {
733             ba = ba_code_tab[get_bits(bs, ba_bits)];
734         }
735         sci.bitalloc[2*i + 1] = sci.stereo_bands ? ba : 0;
736     }
737 
738     for (i = 0; i < 2*sci.total_bands; i++)
739     {
740         ubyte temp = ( HDR_IS_LAYER_1(hdr) ? 2 : cast(ubyte) get_bits(bs, 2) );
741         sci.scfcod[i] = sci.bitalloc[i] ? temp : 6;
742     }
743 
744     L12_read_scalefactors(bs, sci.bitalloc.ptr, sci.scfcod.ptr, sci.total_bands*2, sci.scf.ptr);
745 
746     for (i = sci.stereo_bands; i < sci.total_bands; i++)
747     {
748         sci.bitalloc[2*i + 1] = 0;
749     }
750 }
751 
752 int L12_dequantize_granule(float *grbuf, bs_t *bs, L12_scale_info *sci, int group_size)
753 {
754     int i, j, k, choff = 576;
755     for (j = 0; j < 4; j++)
756     {
757         float *dst = grbuf + group_size*j;
758         for (i = 0; i < 2*sci.total_bands; i++)
759         {
760             int ba = sci.bitalloc[i];
761             if (ba != 0)
762             {
763                 if (ba < 17)
764                 {
765                     int half = (1 << (ba - 1)) - 1;
766                     for (k = 0; k < group_size; k++)
767                     {
768                         dst[k] = cast(float)(cast(int)get_bits(bs, ba) - half);
769                     }
770                 } else
771                 {
772                     uint mod = (2 << (ba - 17)) + 1;    /* 3, 5, 9 */
773                     uint code = get_bits(bs, mod + 2 - (mod >> 3));  /* 5, 7, 10 */
774                     for (k = 0; k < group_size; k++, code /= mod)
775                     {
776                         dst[k] = cast(float)(cast(int)(code % mod - mod/2));
777                     }
778                 }
779             }
780             dst += choff;
781             choff = 18 - choff;
782         }
783     }
784     return group_size*4;
785 }
786 
787 void L12_apply_scf_384(L12_scale_info *sci, const(float)*scf, float *dst)
788 {
789     int i, k;
790     memcpy(dst + 576 + sci.stereo_bands*18, dst + sci.stereo_bands*18, (sci.total_bands - sci.stereo_bands)*18*float.sizeof);
791     for (i = 0; i < sci.total_bands; i++, dst += 18, scf += 6)
792     {
793         for (k = 0; k < 12; k++)
794         {
795             dst[k + 0]   *= scf[0];
796             dst[k + 576] *= scf[3];
797         }
798     }
799 }
800 
801 
802 int L3_read_side_info(bs_t *bs, L3_gr_info_t *gr, const uint8_t *hdr)
803 {
804     static immutable uint8_t[23][8] g_scf_long =
805     [
806         [ 6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54,0 ],
807         [ 12,12,12,12,12,12,16,20,24,28,32,40,48,56,64,76,90,2,2,2,2,2,0 ],
808         [ 6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54,0 ],
809         [ 6,6,6,6,6,6,8,10,12,14,16,18,22,26,32,38,46,54,62,70,76,36,0 ],
810         [ 6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54,0 ],
811         [ 4,4,4,4,4,4,6,6,8,8,10,12,16,20,24,28,34,42,50,54,76,158,0 ],
812         [ 4,4,4,4,4,4,6,6,6,8,10,12,16,18,22,28,34,40,46,54,54,192,0 ],
813         [ 4,4,4,4,4,4,6,6,8,10,12,16,20,24,30,38,46,56,68,84,102,26,0 ]
814     ];
815     static immutable uint8_t[40][8] g_scf_short = [
816         [ 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 ],
817         [ 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 ],
818         [ 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 ],
819         [ 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 ],
820         [ 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 ],
821         [ 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 ],
822         [ 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 ],
823         [ 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 ]
824     ];
825     static immutable uint8_t[40][8] g_scf_mixed = [
826         [ 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 ],
827         [ 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 ],
828         [ 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 ],
829         [ 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 ],
830         [ 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 ],
831         [ 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 ],
832         [ 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 ],
833         [ 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 ]
834     ];
835 
836     uint tables, scfsi = 0;
837     int main_data_begin, part_23_sum = 0;
838     int sr_idx = HDR_GET_MY_SAMPLE_RATE(hdr); sr_idx -= (sr_idx != 0);
839     int gr_count = HDR_IS_MONO(hdr) ? 1 : 2;
840 
841     if (HDR_TEST_MPEG1(hdr))
842     {
843         gr_count *= 2;
844         main_data_begin = get_bits(bs, 9);
845         scfsi = get_bits(bs, 7 + gr_count);
846     } else
847     {
848         main_data_begin = get_bits(bs, 8 + gr_count) >> gr_count;
849     }
850 
851     do
852     {
853         if (HDR_IS_MONO(hdr))
854         {
855             scfsi <<= 4;
856         }
857         gr.part_23_length = cast(uint16_t)get_bits(bs, 12);
858         part_23_sum += gr.part_23_length;
859         gr.big_values = cast(uint16_t)get_bits(bs,  9);
860         if (gr.big_values > 288)
861         {
862             return -1;
863         }
864         gr.global_gain = cast(uint8_t)get_bits(bs, 8);
865         gr.scalefac_compress = cast(uint16_t)get_bits(bs, HDR_TEST_MPEG1(hdr) ? 4 : 9);
866         gr.sfbtab = g_scf_long[sr_idx].ptr;
867         gr.n_long_sfb  = 22;
868         gr.n_short_sfb = 0;
869         if (get_bits(bs, 1))
870         {
871             gr.block_type = cast(uint8_t)get_bits(bs, 2);
872             if (!gr.block_type)
873             {
874                 return -1;
875             }
876             gr.mixed_block_flag = cast(uint8_t)get_bits(bs, 1);
877             gr.region_count[0] = 7;
878             gr.region_count[1] = 255;
879             if (gr.block_type == SHORT_BLOCK_TYPE)
880             {
881                 scfsi &= 0x0F0F;
882                 if (!gr.mixed_block_flag)
883                 {
884                     gr.region_count[0] = 8;
885                     gr.sfbtab = g_scf_short[sr_idx].ptr;
886                     gr.n_long_sfb = 0;
887                     gr.n_short_sfb = 39;
888                 } else
889                 {
890                     gr.sfbtab = g_scf_mixed[sr_idx].ptr;
891                     gr.n_long_sfb = HDR_TEST_MPEG1(hdr) ? 8 : 6;
892                     gr.n_short_sfb = 30;
893                 }
894             }
895             tables = get_bits(bs, 10);
896             tables <<= 5;
897             gr.subblock_gain[0] = cast(uint8_t)get_bits(bs, 3);
898             gr.subblock_gain[1] = cast(uint8_t)get_bits(bs, 3);
899             gr.subblock_gain[2] = cast(uint8_t)get_bits(bs, 3);
900         } else
901         {
902             gr.block_type = 0;
903             gr.mixed_block_flag = 0;
904             tables = get_bits(bs, 15);
905             gr.region_count[0] = cast(uint8_t)get_bits(bs, 4);
906             gr.region_count[1] = cast(uint8_t)get_bits(bs, 3);
907             gr.region_count[2] = 255;
908         }
909         gr.table_select[0] = cast(uint8_t)(tables >> 10);
910         gr.table_select[1] = cast(uint8_t)((tables >> 5) & 31);
911         gr.table_select[2] = cast(uint8_t)((tables) & 31);
912         gr.preflag = HDR_TEST_MPEG1(hdr) ? (cast(ubyte) get_bits(bs, 1)) : (gr.scalefac_compress >= 500);
913         gr.scalefac_scale = cast(uint8_t)get_bits(bs, 1);
914         gr.count1_table = cast(uint8_t)get_bits(bs, 1);
915         gr.scfsi = cast(uint8_t)((scfsi >> 12) & 15);
916         scfsi <<= 4;
917         gr++;
918     } while(--gr_count);
919 
920     if (part_23_sum + bs.pos > bs.limit + main_data_begin*8)
921     {
922         return -1;
923     }
924 
925     return main_data_begin;
926 }
927 
928 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)
929 {
930     int i, k;
931     for (i = 0; i < 4 && scf_count[i]; i++, scfsi *= 2)
932     {
933         int cnt = scf_count[i];
934         if (scfsi & 8)
935         {
936             memcpy(scf, ist_pos, cnt);
937         } else
938         {
939             int bits = scf_size[i];
940             if (!bits)
941             {
942                 memset(scf, 0, cnt);
943                 memset(ist_pos, 0, cnt);
944             } else
945             {
946                 int max_scf = (scfsi < 0) ? (1 << bits) - 1 : -1;
947                 for (k = 0; k < cnt; k++)
948                 {
949                     int s = get_bits(bitbuf, bits);
950                     ist_pos[k] = cast(ubyte)(s == max_scf ? -1 : s);
951                     scf[k] = cast(ubyte)s;
952                 }
953             }
954         }
955         ist_pos += cnt;
956         scf += cnt;
957     }
958     scf[0] = scf[1] = scf[2] = 0;
959 }
960 
961 float L3_ldexp_q2(float y, int exp_q2)
962 {
963     static immutable float[4] g_expfrac =
964     [ 9.31322575e-10f,7.83145814e-10f,6.58544508e-10f,5.53767716e-10f ];
965     int e;
966     do
967     {
968         e = MINIMP3_MIN(30*4, exp_q2);
969         y *= g_expfrac[e & 3]*(1 << 30 >> (e >> 2));
970     } while ((exp_q2 -= e) > 0);
971     return y;
972 }
973 
974 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)
975 {
976     static immutable uint8_t[28][3] g_scf_partitions = [
977         [ 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 ],
978         [ 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 ],
979         [ 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 ]
980     ];
981     const(uint8_t)* scf_partition = g_scf_partitions[!!gr.n_short_sfb + !gr.n_long_sfb].ptr;
982     uint8_t[4] scf_size;
983     uint8_t[40] iscf;
984     int i, scf_shift = gr.scalefac_scale + 1, gain_exp, scfsi = gr.scfsi;
985     float gain;
986 
987     if (HDR_TEST_MPEG1(hdr))
988     {
989         static immutable uint8_t[16] g_scfc_decode = [ 0,1,2,3, 12,5,6,7, 9,10,11,13, 14,15,18,19 ];
990         int part = g_scfc_decode[gr.scalefac_compress];
991         scf_size[1] = scf_size[0] = cast(uint8_t)(part >> 2);
992         scf_size[3] = scf_size[2] = cast(uint8_t)(part & 3);
993     } else
994     {
995         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 ];
996         int k, modprod, sfc, ist = HDR_TEST_I_STEREO(hdr) && ch;
997         sfc = gr.scalefac_compress >> ist;
998         for (k = ist*3*4; sfc >= 0; sfc -= modprod, k += 4)
999         {
1000             for (modprod = 1, i = 3; i >= 0; i--)
1001             {
1002                 scf_size[i] = cast(uint8_t)(sfc / modprod % g_mod[k + i]);
1003                 modprod *= g_mod[k + i];
1004             }
1005         }
1006         scf_partition += k;
1007         scfsi = -16;
1008     }
1009     L3_read_scalefactors(iscf.ptr, ist_pos, scf_size.ptr, scf_partition, bs, scfsi);
1010 
1011     if (gr.n_short_sfb)
1012     {
1013         int sh = 3 - scf_shift;
1014         for (i = 0; i < gr.n_short_sfb; i += 3)
1015         {
1016             iscf[gr.n_long_sfb + i + 0] += gr.subblock_gain[0] << sh;
1017             iscf[gr.n_long_sfb + i + 1] += gr.subblock_gain[1] << sh;
1018             iscf[gr.n_long_sfb + i + 2] += gr.subblock_gain[2] << sh;
1019         }
1020     } else if (gr.preflag)
1021     {
1022         static immutable uint8_t[10] g_preamp = [ 1,1,1,1,2,2,3,3,3,2 ];
1023         for (i = 0; i < 10; i++)
1024         {
1025             iscf[11 + i] += g_preamp[i];
1026         }
1027     }
1028 
1029     gain_exp = gr.global_gain + BITS_DEQUANTIZER_OUT*4 - 210 - (HDR_IS_MS_STEREO(hdr) ? 2 : 0);
1030     gain = L3_ldexp_q2(1 << (MAX_SCFI/4),  MAX_SCFI - gain_exp);
1031     for (i = 0; i < cast(int)(gr.n_long_sfb + gr.n_short_sfb); i++)
1032     {
1033         scf[i] = L3_ldexp_q2(gain, iscf[i] << scf_shift);
1034     }
1035 }
1036 
1037 static immutable float[129 + 16] g_pow43 = [
1038     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,
1039     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
1040 ];
1041 
1042 float L3_pow_43(int x)
1043 {
1044     float frac;
1045     int sign, mult = 256;
1046 
1047     if (x < 129)
1048     {
1049         return g_pow43[16 + x];
1050     }
1051 
1052     if (x < 1024)
1053     {
1054         mult = 16;
1055         x <<= 3;
1056     }
1057 
1058     sign = 2*x & 64;
1059     frac = cast(float)((x & 63) - sign) / ((x & ~63) + sign);
1060     return g_pow43[16 + ((x + sign) >> 6)]*(1.0f + frac*((4.0f/3) + frac*(2.0f/9)))*mult;
1061 }
1062 
1063 void L3_huffman(float *dst, bs_t *bs, const L3_gr_info_t *gr_info, const(float)*scf, int layer3gr_limit)
1064 {
1065     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,
1066         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,
1067         -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,
1068         -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,
1069         -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,
1070         -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,
1071         -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,
1072         -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,
1073         -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,
1074         -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,
1075         -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,
1076         -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,
1077         -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,
1078         -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,
1079         -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,
1080         -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 ];
1081     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 ];
1082     static immutable uint8_t[] tab33 = [ 252,236,220,204,188,172,156,140,124,108,92,76,60,44,28,12 ];
1083     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 ];
1084     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 ];
1085 
1086 
1087     float one = 0.0f;
1088     int ireg = 0, big_val_cnt = gr_info.big_values;
1089     const(uint8_t)* sfb = gr_info.sfbtab;
1090     const(uint8_t)* bs_next_ptr = bs.buf + bs.pos/8;
1091     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);
1092     int pairs_to_decode, np, bs_sh = (bs.pos & 7) - 8;
1093     bs_next_ptr += 4;
1094 
1095     while (big_val_cnt > 0)
1096     {
1097         int tab_num = gr_info.table_select[ireg];
1098         int sfb_cnt = gr_info.region_count[ireg++];
1099         const int16_t *codebook = tabs.ptr + tabindex[tab_num];
1100         int linbits = g_linbits[tab_num];
1101         if (linbits)
1102         {
1103             do
1104             {
1105                 np = *sfb++ / 2;
1106                 pairs_to_decode = MINIMP3_MIN(big_val_cnt, np);
1107                 one = *scf++;
1108                 do
1109                 {
1110                     int j, w = 5;
1111                     int leaf = codebook[(bs_cache >> (32 - w))];
1112                     while (leaf < 0)
1113                     {
1114                         { bs_cache <<= (w); bs_sh += (w); }
1115                         w = leaf & 7;
1116                         leaf = codebook[(bs_cache >> (32 - w)) - (leaf >> 3)];
1117                     }
1118                     { bs_cache <<= (leaf >> 8); bs_sh += (leaf >> 8); }
1119 
1120                     for (j = 0; j < 2; j++, dst++, leaf >>= 4)
1121                     {
1122                         int lsb = leaf & 0x0F;
1123                         if (lsb == 15)
1124                         {
1125                             lsb += (bs_cache >> (32 - linbits));
1126                             { bs_cache <<= (linbits); bs_sh += (linbits); }
1127                             while (bs_sh >= 0) { bs_cache |= cast(uint32_t)*bs_next_ptr++ << bs_sh; bs_sh -= 8; }
1128                             *dst = one*L3_pow_43(lsb)*(cast(int32_t)bs_cache < 0 ? -1: 1);
1129                         } else
1130                         {
1131                             *dst = g_pow43[16 + lsb - 16*(bs_cache >> 31)]*one;
1132                         }
1133 
1134                         { bs_cache <<= (lsb ? 1 : 0); bs_sh += (lsb ? 1 : 0); }
1135                     }
1136                     while (bs_sh >= 0) { bs_cache |= cast(uint32_t)*bs_next_ptr++ << bs_sh; bs_sh -= 8; }
1137                 } while (--pairs_to_decode);
1138             } while ((big_val_cnt -= np) > 0 && --sfb_cnt >= 0);
1139         } else
1140         {
1141             do
1142             {
1143                 np = *sfb++ / 2;
1144                 pairs_to_decode = MINIMP3_MIN(big_val_cnt, np);
1145                 one = *scf++;
1146                 do
1147                 {
1148                     int j, w = 5;
1149                     int leaf = codebook[(bs_cache >> (32 - w))];
1150                     while (leaf < 0)
1151                     {
1152                         { bs_cache <<= (w); bs_sh += (w); }
1153                         w = leaf & 7;
1154                         leaf = codebook[(bs_cache >> (32 - w)) - (leaf >> 3)];
1155                     }
1156                     { bs_cache <<= (leaf >> 8); bs_sh += (leaf >> 8); }
1157 
1158                     for (j = 0; j < 2; j++, dst++, leaf >>= 4)
1159                     {
1160                         int lsb = leaf & 0x0F;
1161                         *dst = g_pow43[16 + lsb - 16*(bs_cache >> 31)]*one;
1162                         { bs_cache <<= (lsb ? 1 : 0); bs_sh += (lsb ? 1 : 0); }
1163                     }
1164                     while (bs_sh >= 0) { bs_cache |= cast(uint32_t)*bs_next_ptr++ << bs_sh; bs_sh -= 8; }
1165                 } while (--pairs_to_decode);
1166             } while ((big_val_cnt -= np) > 0 && --sfb_cnt >= 0);
1167         }
1168     }
1169 
1170     for (np = 1 - big_val_cnt;; dst += 4)
1171     {
1172         const uint8_t *codebook_count1 = (gr_info.count1_table) ? tab33.ptr : tab32.ptr;
1173         int leaf = codebook_count1[(bs_cache >> (32 - 4))];
1174         if (!(leaf & 8))
1175         {
1176             leaf = codebook_count1[(leaf >> 3) + (bs_cache << 4 >> (32 - (leaf & 3)))];
1177         }
1178 
1179         { bs_cache <<= (leaf & 7); bs_sh += (leaf & 7); }
1180 
1181         if (((bs_next_ptr - bs.buf)*8 - 24 + bs_sh) > layer3gr_limit)
1182         {
1183             break;
1184         }
1185 //#define RELOAD_SCALEFACTOR  if (!--np) { np = *sfb++/2; if (!np) break; one = *scf++; }
1186 //#define DEQ_COUNT1(s) if (leaf & (128 >> s)) { dst[s] = ((int32_t)bs_cache < 0) ? -one : one; FLUSH_BITS(1) }
1187 
1188         if (!--np) { np = *sfb++/2; if (!np) break; one = *scf++; }
1189         /*DEQ_COUNT1(0);*/ if (leaf & (128 >> 0)) { dst[0] = (cast(int32_t)bs_cache < 0) ? -one : one; { bs_cache <<= (1); bs_sh += (1); } }
1190         /*DEQ_COUNT1(1);*/ if (leaf & (128 >> 1)) { dst[1] = (cast(int32_t)bs_cache < 0) ? -one : one; { bs_cache <<= (1); bs_sh += (1); } }
1191         if (!--np) { np = *sfb++/2; if (!np) break; one = *scf++; }
1192         /* DEQ_COUNT1(2); */ if (leaf & (128 >> 2)) { dst[2] = (cast(int32_t)bs_cache < 0) ? -one : one; { bs_cache <<= (1); bs_sh += (1); } }
1193         /* DEQ_COUNT1(3); */ if (leaf & (128 >> 3)) { dst[3] = (cast(int32_t)bs_cache < 0) ? -one : one; { bs_cache <<= (1); bs_sh += (1); } }
1194         while (bs_sh >= 0) { bs_cache |= cast(uint32_t)*bs_next_ptr++ << bs_sh; bs_sh -= 8; }
1195     }
1196 
1197     bs.pos = layer3gr_limit;
1198 }
1199 
1200 void L3_midside_stereo(float *left, int n)
1201 {
1202     int i = 0;
1203     float *right = left + 576;
1204     for (; i < n; i++)
1205     {
1206         float a = left[i];
1207         float b = right[i];
1208         left[i] = a + b;
1209         right[i] = a - b;
1210     }
1211 }
1212 
1213 void L3_intensity_stereo_band(float *left, int n, float kl, float kr)
1214 {
1215     int i;
1216     for (i = 0; i < n; i++)
1217     {
1218         left[i + 576] = left[i]*kr;
1219         left[i] = left[i]*kl;
1220     }
1221 }
1222 
1223 void L3_stereo_top_band(const(float)*right, const uint8_t *sfb, int nbands, int* max_band)
1224 {
1225     int i, k;
1226 
1227     max_band[0] = max_band[1] = max_band[2] = -1;
1228 
1229     for (i = 0; i < nbands; i++)
1230     {
1231         for (k = 0; k < sfb[i]; k += 2)
1232         {
1233             if (right[k] != 0 || right[k + 1] != 0)
1234             {
1235                 max_band[i % 3] = i;
1236                 break;
1237             }
1238         }
1239         right += sfb[i];
1240     }
1241 }
1242 
1243 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)
1244 {
1245     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 ];
1246     uint i;
1247     uint max_pos = HDR_TEST_MPEG1(hdr) ? 7 : 64;
1248 
1249     for (i = 0; sfb[i]; i++)
1250     {
1251         uint ipos = ist_pos[i];
1252         if (cast(int)i > max_band[i % 3] && ipos < max_pos)
1253         {
1254             float kl, kr, s = HDR_TEST_MS_STEREO(hdr) ? 1.41421356f : 1;
1255             if (HDR_TEST_MPEG1(hdr))
1256             {
1257                 kl = g_pan[2*ipos];
1258                 kr = g_pan[2*ipos + 1];
1259             } else
1260             {
1261                 kl = 1;
1262                 kr = L3_ldexp_q2(1, (ipos + 1) >> 1 << mpeg2_sh);
1263                 if (ipos & 1)
1264                 {
1265                     kl = kr;
1266                     kr = 1;
1267                 }
1268             }
1269             L3_intensity_stereo_band(left, sfb[i], kl*s, kr*s);
1270         } else if (HDR_TEST_MS_STEREO(hdr))
1271         {
1272             L3_midside_stereo(left, sfb[i]);
1273         }
1274         left += sfb[i];
1275     }
1276 }
1277 
1278 void L3_intensity_stereo(float *left, uint8_t *ist_pos, const L3_gr_info_t *gr, const uint8_t *hdr)
1279 {
1280     int[3] max_band;
1281     int n_sfb = gr.n_long_sfb + gr.n_short_sfb;
1282     int i, max_blocks = gr.n_short_sfb ? 3 : 1;
1283 
1284     L3_stereo_top_band(left + 576, gr.sfbtab, n_sfb, max_band.ptr);
1285     if (gr.n_long_sfb)
1286     {
1287         max_band[0] = max_band[1] = max_band[2] = MINIMP3_MAX(MINIMP3_MAX(max_band[0], max_band[1]), max_band[2]);
1288     }
1289     for (i = 0; i < max_blocks; i++)
1290     {
1291         int default_pos = HDR_TEST_MPEG1(hdr) ? 3 : 0;
1292         int itop = n_sfb - max_blocks + i;
1293         int prev = itop - max_blocks;
1294         ist_pos[itop] = cast(ubyte)( max_band[i] >= prev ? default_pos : ist_pos[prev] );
1295     }
1296     L3_stereo_process(left, ist_pos, gr.sfbtab, hdr, max_band.ptr, gr[1].scalefac_compress & 1);
1297 }
1298 
1299 void L3_reorder(float *grbuf, float *scratch, const(uint8_t) *sfb)
1300 {
1301     int i, len;
1302     float *src = grbuf;
1303     float *dst = scratch;
1304 
1305     for (;0 != (len = *sfb); sfb += 3, src += 2*len)
1306     {
1307         for (i = 0; i < len; i++, src++)
1308         {
1309             *dst++ = src[0*len];
1310             *dst++ = src[1*len];
1311             *dst++ = src[2*len];
1312         }
1313     }
1314     memcpy(grbuf, scratch, (dst - scratch)*float.sizeof);
1315 }
1316 
1317 void L3_antialias(float *grbuf, int nbands)
1318 {
1319     static immutable float[8][2] g_aa = [
1320         [0.85749293f,0.88174200f,0.94962865f,0.98331459f,0.99551782f,0.99916056f,0.99989920f,0.99999316f],
1321         [0.51449576f,0.47173197f,0.31337745f,0.18191320f,0.09457419f,0.04096558f,0.01419856f,0.00369997f]
1322     ];
1323 
1324     for (; nbands > 0; nbands--, grbuf += 18)
1325     {
1326         int i = 0;
1327         for(; i < 8; i++)
1328         {
1329             float u = grbuf[18 + i];
1330             float d = grbuf[17 - i];
1331             grbuf[18 + i] = u*g_aa[0][i] - d*g_aa[1][i];
1332             grbuf[17 - i] = u*g_aa[1][i] + d*g_aa[0][i];
1333         }
1334     }
1335 }
1336 
1337 void L3_dct3_9(float *y)
1338 {
1339     float s0, s1, s2, s3, s4, s5, s6, s7, s8, t0, t2, t4;
1340 
1341     s0 = y[0]; s2 = y[2]; s4 = y[4]; s6 = y[6]; s8 = y[8];
1342     t0 = s0 + s6*0.5f;
1343     s0 -= s6;
1344     t4 = (s4 + s2)*0.93969262f;
1345     t2 = (s8 + s2)*0.76604444f;
1346     s6 = (s4 - s8)*0.17364818f;
1347     s4 += s8 - s2;
1348 
1349     s2 = s0 - s4*0.5f;
1350     y[4] = s4 + s0;
1351     s8 = t0 - t2 + s6;
1352     s0 = t0 - t4 + t2;
1353     s4 = t0 + t4 - s6;
1354 
1355     s1 = y[1]; s3 = y[3]; s5 = y[5]; s7 = y[7];
1356 
1357     s3 *= 0.86602540f;
1358     t0 = (s5 + s1)*0.98480775f;
1359     t4 = (s5 - s7)*0.34202014f;
1360     t2 = (s1 + s7)*0.64278761f;
1361     s1 = (s1 - s5 - s7)*0.86602540f;
1362 
1363     s5 = t0 - s3 - t2;
1364     s7 = t4 - s3 - t0;
1365     s3 = t4 + s3 - t2;
1366 
1367     y[0] = s4 - s7;
1368     y[1] = s2 + s1;
1369     y[2] = s0 - s3;
1370     y[3] = s8 + s5;
1371     y[5] = s8 - s5;
1372     y[6] = s0 + s3;
1373     y[7] = s2 - s1;
1374     y[8] = s4 + s7;
1375 }
1376 
1377 void L3_imdct36(float *grbuf, float *overlap, const float *window, int nbands)
1378 {
1379     int i, j;
1380     static immutable float[18] g_twid9 = [
1381         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
1382     ];
1383 
1384     for (j = 0; j < nbands; j++, grbuf += 18, overlap += 9)
1385     {
1386         float[9] co, si;
1387         co[0] = -grbuf[0];
1388         si[0] = grbuf[17];
1389         for (i = 0; i < 4; i++)
1390         {
1391             si[8 - 2*i] =   grbuf[4*i + 1] - grbuf[4*i + 2];
1392             co[1 + 2*i] =   grbuf[4*i + 1] + grbuf[4*i + 2];
1393             si[7 - 2*i] =   grbuf[4*i + 4] - grbuf[4*i + 3];
1394             co[2 + 2*i] = -(grbuf[4*i + 3] + grbuf[4*i + 4]);
1395         }
1396         L3_dct3_9(co.ptr);
1397         L3_dct3_9(si.ptr);
1398 
1399         si[1] = -si[1];
1400         si[3] = -si[3];
1401         si[5] = -si[5];
1402         si[7] = -si[7];
1403 
1404         i = 0;
1405 
1406         for (; i < 9; i++)
1407         {
1408             float ovl  = overlap[i];
1409             float sum  = co[i]*g_twid9[9 + i] + si[i]*g_twid9[0 + i];
1410             overlap[i] = co[i]*g_twid9[0 + i] - si[i]*g_twid9[9 + i];
1411             grbuf[i]      = ovl*window[0 + i] - sum*window[9 + i];
1412             grbuf[17 - i] = ovl*window[9 + i] + sum*window[0 + i];
1413         }
1414     }
1415 }
1416 
1417 void L3_idct3(float x0, float x1, float x2, float *dst)
1418 {
1419     float m1 = x1*0.86602540f;
1420     float a1 = x0 - x2*0.5f;
1421     dst[1] = x0 + x2;
1422     dst[0] = a1 + m1;
1423     dst[2] = a1 - m1;
1424 }
1425 
1426 void L3_imdct12(float *x, float *dst, float *overlap)
1427 {
1428     static immutable float[6] g_twid3 = [ 0.79335334f,0.92387953f,0.99144486f, 0.60876143f,0.38268343f,0.13052619f ];
1429     float[3] co, si;
1430     int i;
1431 
1432     L3_idct3(-x[0], x[6] + x[3], x[12] + x[9], co.ptr);
1433     L3_idct3(x[15], x[12] - x[9], x[6] - x[3], si.ptr);
1434     si[1] = -si[1];
1435 
1436     for (i = 0; i < 3; i++)
1437     {
1438         float ovl  = overlap[i];
1439         float sum  = co[i]*g_twid3[3 + i] + si[i]*g_twid3[0 + i];
1440         overlap[i] = co[i]*g_twid3[0 + i] - si[i]*g_twid3[3 + i];
1441         dst[i]     = ovl*g_twid3[2 - i] - sum*g_twid3[5 - i];
1442         dst[5 - i] = ovl*g_twid3[5 - i] + sum*g_twid3[2 - i];
1443     }
1444 }
1445 
1446 void L3_imdct_short(float *grbuf, float *overlap, int nbands)
1447 {
1448     for (;nbands > 0; nbands--, overlap += 9, grbuf += 18)
1449     {
1450         float[18] tmp;
1451         memcpy(tmp.ptr, grbuf, tmp.sizeof);
1452         memcpy(grbuf, overlap, 6*float.sizeof);
1453         L3_imdct12(tmp.ptr, grbuf + 6, overlap + 6);
1454         L3_imdct12(tmp.ptr + 1, grbuf + 12, overlap + 6);
1455         L3_imdct12(tmp.ptr + 2, overlap, overlap + 6);
1456     }
1457 }
1458 
1459 void L3_change_sign(float *grbuf)
1460 {
1461     int b, i;
1462     for (b = 0, grbuf += 18; b < 32; b += 2, grbuf += 36)
1463         for (i = 1; i < 18; i += 2)
1464             grbuf[i] = -grbuf[i];
1465 }
1466 
1467 void L3_imdct_gr(float *grbuf, float *overlap, uint block_type, uint n_long_bands)
1468 {
1469     static immutable float[18][2] g_mdct_window = [
1470         [ 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 ],
1471         [ 1,1,1,1,1,1,0.99144486f,0.92387953f,0.79335334f,0,0,0,0,0,0,0.13052619f,0.38268343f,0.60876143f ]
1472     ];
1473     if (n_long_bands)
1474     {
1475         L3_imdct36(grbuf, overlap, g_mdct_window[0].ptr, n_long_bands);
1476         grbuf += 18*n_long_bands;
1477         overlap += 9*n_long_bands;
1478     }
1479     if (block_type == SHORT_BLOCK_TYPE)
1480         L3_imdct_short(grbuf, overlap, 32 - n_long_bands);
1481     else
1482         L3_imdct36(grbuf, overlap, g_mdct_window[block_type == STOP_BLOCK_TYPE].ptr, 32 - n_long_bands);
1483 }
1484 
1485 void L3_save_reservoir(mp3dec_t *h, mp3dec_scratch_t *s)
1486 {
1487     int pos = (s.bs.pos + 7)/8u;
1488     int remains = s.bs.limit/8u - pos;
1489     if (remains > MAX_BITRESERVOIR_BYTES)
1490     {
1491         pos += remains - MAX_BITRESERVOIR_BYTES;
1492         remains = MAX_BITRESERVOIR_BYTES;
1493     }
1494     if (remains > 0)
1495     {
1496         memmove(h.reserv_buf.ptr, s.maindata.ptr + pos, remains);
1497     }
1498     h.reserv = remains;
1499 }
1500 
1501 static int L3_restore_reservoir(mp3dec_t *h, bs_t *bs, mp3dec_scratch_t *s, int main_data_begin)
1502 {
1503     int frame_bytes = (bs.limit - bs.pos)/8;
1504     int bytes_have = MINIMP3_MIN(h.reserv, main_data_begin);
1505     memcpy(s.maindata.ptr, h.reserv_buf.ptr + MINIMP3_MAX(0, h.reserv - main_data_begin), MINIMP3_MIN(h.reserv, main_data_begin));
1506     memcpy(s.maindata.ptr + bytes_have, bs.buf + bs.pos/8, frame_bytes);
1507     bs_init(&s.bs, s.maindata.ptr, bytes_have + frame_bytes);
1508     return h.reserv >= main_data_begin;
1509 }
1510 
1511 void L3_decode(mp3dec_t *h, mp3dec_scratch_t *s, L3_gr_info_t *gr_info, int nch)
1512 {
1513     int ch;
1514 
1515     for (ch = 0; ch < nch; ch++)
1516     {
1517         int layer3gr_limit = s.bs.pos + gr_info[ch].part_23_length;
1518         L3_decode_scalefactors(h.header.ptr, s.ist_pos[ch].ptr, &s.bs, gr_info + ch, s.scf.ptr, ch);
1519         L3_huffman(s.grbuf[ch].ptr, &s.bs, gr_info + ch, s.scf.ptr, layer3gr_limit);
1520     }
1521 
1522     if (HDR_TEST_I_STEREO(h.header.ptr))
1523     {
1524         L3_intensity_stereo(s.grbuf[0].ptr, s.ist_pos[1].ptr, gr_info, h.header.ptr);
1525     } else if (HDR_IS_MS_STEREO(h.header.ptr))
1526     {
1527         L3_midside_stereo(s.grbuf[0].ptr, 576);
1528     }
1529 
1530     for (ch = 0; ch < nch; ch++, gr_info++)
1531     {
1532         int aa_bands = 31;
1533         int n_long_bands = (gr_info.mixed_block_flag ? 2 : 0) << cast(int)(HDR_GET_MY_SAMPLE_RATE(h.header.ptr) == 2);
1534 
1535         if (gr_info.n_short_sfb)
1536         {
1537             aa_bands = n_long_bands - 1;
1538             L3_reorder(s.grbuf[ch].ptr + n_long_bands*18, s.syn[0].ptr, gr_info.sfbtab + gr_info.n_long_sfb);
1539         }
1540 
1541         L3_antialias(s.grbuf[ch].ptr, aa_bands);
1542         L3_imdct_gr(s.grbuf[ch].ptr, h.mdct_overlap[ch].ptr, gr_info.block_type, n_long_bands);
1543         L3_change_sign(s.grbuf[ch].ptr);
1544     }
1545 }
1546 
1547 void mp3d_DCT_II(float *grbuf, int n)
1548 {
1549     static immutable float[24] g_sec = [
1550         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
1551     ];
1552     int i, k = 0;
1553 
1554     for (; k < n; k++)
1555     {
1556         float[8][4] t;
1557         float* x, y = grbuf + k;
1558 
1559         for (x = t[0].ptr, i = 0; i < 8; i++, x++)
1560         {
1561             float x0 = y[i*18];
1562             float x1 = y[(15 - i)*18];
1563             float x2 = y[(16 + i)*18];
1564             float x3 = y[(31 - i)*18];
1565             float t0 = x0 + x3;
1566             float t1 = x1 + x2;
1567             float t2 = (x1 - x2)*g_sec[3*i + 0];
1568             float t3 = (x0 - x3)*g_sec[3*i + 1];
1569             x[0] = t0 + t1;
1570             x[8] = (t0 - t1)*g_sec[3*i + 2];
1571             x[16] = t3 + t2;
1572             x[24] = (t3 - t2)*g_sec[3*i + 2];
1573         }
1574         for (x = t[0].ptr, i = 0; i < 4; i++, x += 8)
1575         {
1576             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;
1577             xt = x0 - x7; x0 += x7;
1578             x7 = x1 - x6; x1 += x6;
1579             x6 = x2 - x5; x2 += x5;
1580             x5 = x3 - x4; x3 += x4;
1581             x4 = x0 - x3; x0 += x3;
1582             x3 = x1 - x2; x1 += x2;
1583             x[0] = x0 + x1;
1584             x[4] = (x0 - x1)*0.70710677f;
1585             x5 =  x5 + x6;
1586             x6 = (x6 + x7)*0.70710677f;
1587             x7 =  x7 + xt;
1588             x3 = (x3 + x4)*0.70710677f;
1589             x5 -= x7*0.198912367f;  /* rotate by PI/8 */
1590             x7 += x5*0.382683432f;
1591             x5 -= x7*0.198912367f;
1592             x0 = xt - x6; xt += x6;
1593             x[1] = (xt + x7)*0.50979561f;
1594             x[2] = (x4 + x3)*0.54119611f;
1595             x[3] = (x0 - x5)*0.60134488f;
1596             x[5] = (x0 + x5)*0.89997619f;
1597             x[6] = (x4 - x3)*1.30656302f;
1598             x[7] = (xt - x7)*2.56291556f;
1599 
1600         }
1601         for (i = 0; i < 7; i++, y += 4*18)
1602         {
1603             y[0*18] = t[0][i];
1604             y[1*18] = t[2][i] + t[3][i] + t[3][i + 1];
1605             y[2*18] = t[1][i] + t[1][i + 1];
1606             y[3*18] = t[2][i + 1] + t[3][i] + t[3][i + 1];
1607         }
1608         y[0*18] = t[0][7];
1609         y[1*18] = t[2][7] + t[3][7];
1610         y[2*18] = t[1][7];
1611         y[3*18] = t[3][7];
1612     }
1613 }
1614 
1615 float mp3d_scale_pcm(float sample)
1616 {
1617     return sample*(1.0f/32768.0f);
1618 }
1619 
1620 void mp3d_synth_pair(mp3d_sample_t *pcm, int nch, const(float)*z)
1621 {
1622     float a;
1623     a  = (z[14*64] - z[    0]) * 29;
1624     a += (z[ 1*64] + z[13*64]) * 213;
1625     a += (z[12*64] - z[ 2*64]) * 459;
1626     a += (z[ 3*64] + z[11*64]) * 2037;
1627     a += (z[10*64] - z[ 4*64]) * 5153;
1628     a += (z[ 5*64] + z[ 9*64]) * 6574;
1629     a += (z[ 8*64] - z[ 6*64]) * 37489;
1630     a +=  z[ 7*64]             * 75038;
1631     pcm[0] = mp3d_scale_pcm(a);
1632 
1633     z += 2;
1634     a  = z[14*64] * 104;
1635     a += z[12*64] * 1567;
1636     a += z[10*64] * 9727;
1637     a += z[ 8*64] * 64019;
1638     a += z[ 6*64] * -9975;
1639     a += z[ 4*64] * -45;
1640     a += z[ 2*64] * 146;
1641     a += z[ 0*64] * -5;
1642     pcm[16*nch] = mp3d_scale_pcm(a);
1643 }
1644 
1645 void mp3d_synth(float *xl, mp3d_sample_t *dstl, int nch, float *lins)
1646 {
1647     int i;
1648     float *xr = xl + 576*(nch - 1);
1649     mp3d_sample_t *dstr = dstl + (nch - 1);
1650 
1651     static immutable float[] g_win = [
1652         -1,26,-31,208,218,401,-519,2063,2000,4788,-5517,7134,5959,35640,-39336,74992,
1653         -1,24,-35,202,222,347,-581,2080,1952,4425,-5879,7640,5288,33791,-41176,74856,
1654         -1,21,-38,196,225,294,-645,2087,1893,4063,-6237,8092,4561,31947,-43006,74630,
1655         -1,19,-41,190,227,244,-711,2085,1822,3705,-6589,8492,3776,30112,-44821,74313,
1656         -1,17,-45,183,228,197,-779,2075,1739,3351,-6935,8840,2935,28289,-46617,73908,
1657         -1,16,-49,176,228,153,-848,2057,1644,3004,-7271,9139,2037,26482,-48390,73415,
1658         -2,14,-53,169,227,111,-919,2032,1535,2663,-7597,9389,1082,24694,-50137,72835,
1659         -2,13,-58,161,224,72,-991,2001,1414,2330,-7910,9592,70,22929,-51853,72169,
1660         -2,11,-63,154,221,36,-1064,1962,1280,2006,-8209,9750,-998,21189,-53534,71420,
1661         -2,10,-68,147,215,2,-1137,1919,1131,1692,-8491,9863,-2122,19478,-55178,70590,
1662         -3,9,-73,139,208,-29,-1210,1870,970,1388,-8755,9935,-3300,17799,-56778,69679,
1663         -3,8,-79,132,200,-57,-1283,1817,794,1095,-8998,9966,-4533,16155,-58333,68692,
1664         -4,7,-85,125,189,-83,-1356,1759,605,814,-9219,9959,-5818,14548,-59838,67629,
1665         -4,7,-91,117,177,-106,-1428,1698,402,545,-9416,9916,-7154,12980,-61289,66494,
1666         -5,6,-97,111,163,-127,-1498,1634,185,288,-9585,9838,-8540,11455,-62684,65290
1667     ];
1668     float *zlin = lins + 15*64;
1669     const(float) *w = g_win.ptr;
1670 
1671     zlin[4*15]     = xl[18*16];
1672     zlin[4*15 + 1] = xr[18*16];
1673     zlin[4*15 + 2] = xl[0];
1674     zlin[4*15 + 3] = xr[0];
1675 
1676     zlin[4*31]     = xl[1 + 18*16];
1677     zlin[4*31 + 1] = xr[1 + 18*16];
1678     zlin[4*31 + 2] = xl[1];
1679     zlin[4*31 + 3] = xr[1];
1680 
1681     mp3d_synth_pair(dstr, nch, lins + 4*15 + 1);
1682     mp3d_synth_pair(dstr + 32*nch, nch, lins + 4*15 + 64 + 1);
1683     mp3d_synth_pair(dstl, nch, lins + 4*15);
1684     mp3d_synth_pair(dstl + 32*nch, nch, lins + 4*15 + 64);
1685 
1686     for (i = 14; i >= 0; i--)
1687     {
1688 //#define LOAD(k) float w0 = *w++; float w1 = *w++; float *vz = &zlin[4*i - k*64]; float *vy = &zlin[4*i - (15 - k)*64];
1689 //#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; }
1690 //#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; }
1691 //#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; }
1692         float[4] a, b;
1693 
1694         zlin[4*i]     = xl[18*(31 - i)];
1695         zlin[4*i + 1] = xr[18*(31 - i)];
1696         zlin[4*i + 2] = xl[1 + 18*(31 - i)];
1697         zlin[4*i + 3] = xr[1 + 18*(31 - i)];
1698         zlin[4*(i + 16)]   = xl[1 + 18*(1 + i)];
1699         zlin[4*(i + 16) + 1] = xr[1 + 18*(1 + i)];
1700         zlin[4*(i - 16) + 2] = xl[18*(1 + i)];
1701         zlin[4*(i - 16) + 3] = xr[18*(1 + i)];
1702 
1703         /* 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; }
1704         /* 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; }
1705         /* 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; }
1706         /* 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; }
1707         /* 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; }
1708         /* 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; }
1709         /* 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; }
1710         /* 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; }
1711 
1712         dstr[(15 - i)*nch] = mp3d_scale_pcm(a[1]);
1713         dstr[(17 + i)*nch] = mp3d_scale_pcm(b[1]);
1714         dstl[(15 - i)*nch] = mp3d_scale_pcm(a[0]);
1715         dstl[(17 + i)*nch] = mp3d_scale_pcm(b[0]);
1716         dstr[(47 - i)*nch] = mp3d_scale_pcm(a[3]);
1717         dstr[(49 + i)*nch] = mp3d_scale_pcm(b[3]);
1718         dstl[(47 - i)*nch] = mp3d_scale_pcm(a[2]);
1719         dstl[(49 + i)*nch] = mp3d_scale_pcm(b[2]);
1720     }
1721 }
1722 
1723 void mp3d_synth_granule(float *qmf_state, float *grbuf, int nbands, int nch, mp3d_sample_t *pcm, float *lins)
1724 {
1725     int i;
1726     for (i = 0; i < nch; i++)
1727     {
1728         mp3d_DCT_II(grbuf + 576*i, nbands);
1729     }
1730 
1731     memcpy(lins, qmf_state, float.sizeof*15*64);
1732 
1733     for (i = 0; i < nbands; i += 2)
1734     {
1735         mp3d_synth(grbuf + i, pcm + 32*nch*i, nch, lins + i*64);
1736     }
1737 
1738     if (nch == 1)
1739     {
1740         for (i = 0; i < 15*64; i += 2)
1741         {
1742             qmf_state[i] = lins[nbands*64 + i];
1743         }
1744     } else
1745 
1746     {
1747         memcpy(qmf_state, lins + nbands*64, float.sizeof*15*64);
1748     }
1749 }
1750 
1751 static int mp3d_match_frame(const uint8_t *hdr, int mp3_bytes, int frame_bytes)
1752 {
1753     int i, nmatch;
1754     for (i = 0, nmatch = 0; nmatch < MAX_FRAME_SYNC_MATCHES; nmatch++)
1755     {
1756         i += hdr_frame_bytes(hdr + i, frame_bytes) + hdr_padding(hdr + i);
1757         if (i + HDR_SIZE > mp3_bytes)
1758             return nmatch > 0;
1759         if (!hdr_compare(hdr, hdr + i))
1760             return 0;
1761     }
1762     return 1;
1763 }
1764 
1765 static int mp3d_find_frame(const(uint8_t) *mp3, int mp3_bytes, int *free_format_bytes, int *ptr_frame_bytes)
1766 {
1767     int i, k;
1768     for (i = 0; i < mp3_bytes - HDR_SIZE; i++, mp3++)
1769     {
1770         if (hdr_valid(mp3))
1771         {
1772             int frame_bytes = hdr_frame_bytes(mp3, *free_format_bytes);
1773             int frame_and_padding = frame_bytes + hdr_padding(mp3);
1774 
1775             for (k = HDR_SIZE; !frame_bytes && k < MAX_FREE_FORMAT_FRAME_SIZE && i + 2*k < mp3_bytes - HDR_SIZE; k++)
1776             {
1777                 if (hdr_compare(mp3, mp3 + k))
1778                 {
1779                     int fb = k - hdr_padding(mp3);
1780                     int nextfb = fb + hdr_padding(mp3 + k);
1781                     if (i + k + nextfb + HDR_SIZE > mp3_bytes || !hdr_compare(mp3, mp3 + k + nextfb))
1782                         continue;
1783                     frame_and_padding = k;
1784                     frame_bytes = fb;
1785                     *free_format_bytes = fb;
1786                 }
1787             }
1788             if ((frame_bytes && i + frame_and_padding <= mp3_bytes &&
1789                 mp3d_match_frame(mp3, mp3_bytes - i, frame_bytes)) ||
1790                 (!i && frame_and_padding == mp3_bytes))
1791             {
1792                 *ptr_frame_bytes = frame_and_padding;
1793                 return i;
1794             }
1795             *free_format_bytes = 0;
1796         }
1797     }
1798     *ptr_frame_bytes = 0;
1799     return mp3_bytes;
1800 }
1801 
1802 void mp3dec_init(mp3dec_t *dec)
1803 {
1804     dec.header[0] = 0;
1805 }
1806 
1807 int mp3dec_decode_frame(mp3dec_t *dec, const uint8_t *mp3, int mp3_bytes, mp3d_sample_t *pcm, mp3dec_frame_info_t *info)
1808 {
1809     int i = 0, igr, frame_size = 0, success = 1;
1810     const(uint8_t) *hdr;
1811     bs_t[1] bs_frame;
1812     mp3dec_scratch_t scratch;
1813 
1814     if (mp3_bytes > 4 && dec.header[0] == 0xff && hdr_compare(dec.header.ptr, mp3))
1815     {
1816         frame_size = hdr_frame_bytes(mp3, dec.free_format_bytes) + hdr_padding(mp3);
1817         if (frame_size != mp3_bytes && (frame_size + HDR_SIZE > mp3_bytes || !hdr_compare(mp3, mp3 + frame_size)))
1818         {
1819             frame_size = 0;
1820         }
1821     }
1822     if (!frame_size)
1823     {
1824         memset(dec, 0, mp3dec_t.sizeof);
1825         i = mp3d_find_frame(mp3, mp3_bytes, &dec.free_format_bytes, &frame_size);
1826         if (!frame_size || i + frame_size > mp3_bytes)
1827         {
1828             info.frame_bytes = i;
1829             return 0;
1830         }
1831     }
1832 
1833     hdr = mp3 + i;
1834     memcpy(dec.header.ptr, hdr, HDR_SIZE);
1835     info.frame_bytes = i + frame_size;
1836     info.frame_offset = i;
1837     info.channels = HDR_IS_MONO(hdr) ? 1 : 2;
1838     info.hz = hdr_sample_rate_hz(hdr);
1839     info.layer = 4 - HDR_GET_LAYER(hdr);
1840     info.bitrate_kbps = hdr_bitrate_kbps(hdr);
1841 
1842     if (!pcm)
1843     {
1844         return hdr_frame_samples(hdr);
1845     }
1846 
1847     bs_init(bs_frame.ptr, hdr + HDR_SIZE, frame_size - HDR_SIZE);
1848     if (HDR_IS_CRC(hdr))
1849     {
1850         get_bits(bs_frame.ptr, 16);
1851     }
1852 
1853     if (info.layer == 3)
1854     {
1855         int main_data_begin = L3_read_side_info(bs_frame.ptr, scratch.gr_info.ptr, hdr);
1856         if (main_data_begin < 0 || bs_frame[0].pos > bs_frame[0].limit)
1857         {
1858             mp3dec_init(dec);
1859             return 0;
1860         }
1861         success = L3_restore_reservoir(dec, bs_frame.ptr, &scratch, main_data_begin);
1862         if (success)
1863         {
1864             for (igr = 0; igr < (HDR_TEST_MPEG1(hdr) ? 2 : 1); igr++, pcm += 576*info.channels)
1865             {
1866                 memset(scratch.grbuf[0].ptr, 0, 576*2*float.sizeof);
1867                 L3_decode(dec, &scratch, scratch.gr_info.ptr + igr*info.channels, info.channels);
1868                 mp3d_synth_granule(dec.qmf_state.ptr, scratch.grbuf[0].ptr, 18, info.channels, pcm, scratch.syn[0].ptr);
1869             }
1870         }
1871         L3_save_reservoir(dec, &scratch);
1872     } else
1873     {
1874         L12_scale_info[1] sci;
1875         L12_read_scale_info(hdr, bs_frame.ptr, sci.ptr);
1876 
1877         memset(scratch.grbuf[0].ptr, 0, 576*2*float.sizeof);
1878         for (i = 0, igr = 0; igr < 3; igr++)
1879         {
1880             if (12 == (i += L12_dequantize_granule(scratch.grbuf[0].ptr + i, bs_frame.ptr, sci.ptr, info.layer | 1)))
1881             {
1882                 i = 0;
1883                 L12_apply_scf_384(sci.ptr, sci[0].scf.ptr + igr, scratch.grbuf[0].ptr);
1884                 mp3d_synth_granule(dec.qmf_state.ptr, scratch.grbuf[0].ptr, 12, info.channels, pcm, scratch.syn[0].ptr);
1885                 memset(scratch.grbuf[0].ptr, 0, 576*2*float.sizeof);
1886                 pcm += 384*info.channels;
1887             }
1888             if (bs_frame[0].pos > bs_frame[0].limit)
1889             {
1890                 mp3dec_init(dec);
1891                 return 0;
1892             }
1893         }
1894     }
1895     return success*hdr_frame_samples(dec.header.ptr);
1896 }
1897 
1898 /*
1899     https://github.com/lieff/minimp3
1900     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.
1901     This software is distributed without any warranty.
1902     See <http://creativecommons.org/publicdomain/zero/1.0/>.
1903 */
1904 /*
1905   Translated to D by Guillaume Piolat.
1906   Stripped down a bit for the needs of audio-formats.
1907 */
1908 
1909 import core.stdc.stdlib;
1910 import core.stdc.string;
1911 
1912 enum MP3D_SEEK_TO_BYTE =   0;
1913 enum MP3D_SEEK_TO_SAMPLE = 1;
1914 
1915 enum MINIMP3_PREDECODE_FRAMES = 2; /* frames to pre-decode and skip after seek (to fill internal structures) */
1916 /*#define MINIMP3_SEEK_IDX_LINEAR_SEARCH*/ /* define to use linear index search instead of binary search on seek */
1917 enum MINIMP3_IO_SIZE = (128*1024); /* io buffer size for streaming functions, must be greater than MINIMP3_BUF_SIZE */
1918 enum MINIMP3_BUF_SIZE = (16*1024); /* buffer which can hold minimum 10 consecutive mp3 frames (~16KB) worst case */
1919 enum MINIMP3_ENABLE_RING = 0;      /* enable hardware magic ring buffer if available, to make less input buffer memmove(s) in callback IO mode */
1920 
1921 enum MP3D_E_PARAM     =  -1;
1922 enum MP3D_E_MEMORY    =  -2;
1923 enum MP3D_E_IOERROR   =  -3;
1924 enum MP3D_E_USER      =  -4;  /* can be used to stop processing from callbacks without indicating specific error */
1925 enum MP3D_E_DECODE    =  -5;  /* decode error which can't be safely skipped, such as sample rate, layer and channels change */
1926 
1927 struct mp3dec_file_info_t
1928 {
1929     mp3d_sample_t *buffer;
1930     size_t samples; /* channels included, byte size = samples*sizeof(mp3d_sample_t) */
1931     int channels, hz, layer, avg_bitrate_kbps;
1932 }
1933 
1934 struct mp3dec_map_info_t
1935 {
1936     const(uint8_t) *buffer;
1937     size_t size;
1938 }
1939 
1940 struct mp3dec_frame_t
1941 {
1942     uint64_t sample;
1943     uint64_t offset;
1944 }
1945 
1946 struct mp3dec_index_t
1947 {
1948     mp3dec_frame_t *frames;
1949     size_t num_frames, capacity;
1950 }
1951 
1952 alias MP3D_READ_CB = size_t function(void *buf, size_t size, void *user_data);
1953 alias MP3D_SEEK_CB = int function(uint64_t position, void *user_data);
1954 
1955 
1956 struct mp3dec_io_t
1957 {
1958     MP3D_READ_CB read;
1959     void *read_data;
1960     MP3D_SEEK_CB seek;
1961     void *seek_data;
1962 }
1963 
1964 struct mp3dec_ex_t
1965 {
1966     mp3dec_t mp3d;
1967     mp3dec_map_info_t file;
1968     mp3dec_io_t *io;
1969     mp3dec_index_t index;
1970     uint64_t offset, samples, detected_samples, cur_sample, start_offset, end_offset;
1971     mp3dec_frame_info_t info;
1972     mp3d_sample_t[MINIMP3_MAX_SAMPLES_PER_FRAME] buffer;
1973     size_t input_consumed, input_filled;
1974     int is_file, seek_method, vbr_tag_found;
1975     int free_format_bytes;
1976     int buffer_samples, buffer_consumed, to_skip, start_delay;
1977     int last_error;
1978 }
1979 
1980 alias MP3D_ITERATE_CB = int function(void *user_data, const uint8_t *frame, int frame_size, int free_format_bytes, size_t buf_size, uint64_t offset, mp3dec_frame_info_t *info);
1981 alias MP3D_PROGRESS_CB = int function(void *user_data, size_t file_size, uint64_t offset, mp3dec_frame_info_t *info);
1982 
1983 
1984 void mp3dec_skip_id3v1(const uint8_t *buf, size_t *pbuf_size)
1985 {
1986     size_t buf_size = *pbuf_size;
1987     if (buf_size >= 128 && !memcmp(buf + buf_size - 128, "TAG".ptr, 3))
1988     {
1989         buf_size -= 128;
1990         if (buf_size >= 227 && !memcmp(buf + buf_size - 227, "TAG+".ptr, 4))
1991             buf_size -= 227;
1992     }
1993     if (buf_size > 32 && !memcmp(buf + buf_size - 32, "APETAGEX".ptr, 8))
1994     {
1995         buf_size -= 32;
1996         const uint8_t *tag = buf + buf_size + 8 + 4;
1997         uint32_t tag_size = cast(uint32_t)(tag[3] << 24) | (tag[2] << 16) | (tag[1] << 8) | tag[0];
1998         if (buf_size >= tag_size)
1999             buf_size -= tag_size;
2000     }
2001     *pbuf_size = buf_size;
2002 }
2003 
2004 enum MINIMP3_ID3_DETECT_SIZE = 10;
2005 
2006 size_t mp3dec_skip_id3v2(const uint8_t *buf, size_t buf_size)
2007 {
2008     if (buf_size >= MINIMP3_ID3_DETECT_SIZE && !memcmp(buf, "ID3".ptr, 3) && !((buf[5] & 15) || (buf[6] & 0x80) || (buf[7] & 0x80) || (buf[8] & 0x80) || (buf[9] & 0x80)))
2009     {
2010         size_t id3v2size = (((buf[6] & 0x7f) << 21) | ((buf[7] & 0x7f) << 14) | ((buf[8] & 0x7f) << 7) | (buf[9] & 0x7f)) + 10;
2011         if ((buf[5] & 16))
2012             id3v2size += 10; /* footer */
2013         return id3v2size;
2014     }enum MINIMP3_ID3_DETECT_SIZE = 10;
2015     return 0;
2016 }
2017 
2018 void mp3dec_skip_id3(const(uint8_t)**pbuf, size_t *pbuf_size)
2019 {
2020     uint8_t *buf = cast(uint8_t *)(*pbuf);
2021     size_t buf_size = *pbuf_size;
2022     size_t id3v2size = mp3dec_skip_id3v2(buf, buf_size);
2023     if (id3v2size)
2024     {
2025         if (id3v2size >= buf_size)
2026             id3v2size = buf_size;
2027         buf      += id3v2size;
2028         buf_size -= id3v2size;
2029     }
2030     mp3dec_skip_id3v1(buf, &buf_size);
2031     *pbuf = cast(const uint8_t *)buf;
2032     *pbuf_size = buf_size;
2033 }
2034 
2035 static int mp3dec_check_vbrtag(const uint8_t *frame, int frame_size, uint32_t *frames, int *delay, int *padding)
2036 {
2037     static immutable char[4] g_xing_tag = "Xing";
2038     static immutable char[4] g_info_tag = "Info";
2039 
2040 enum FRAMES_FLAG =    1;
2041 enum BYTES_FLAG     = 2;
2042 enum TOC_FLAG       = 4;
2043 enum VBR_SCALE_FLAG = 8;
2044     /* Side info offsets after header:
2045     /                Mono  Stereo
2046     /  MPEG1          17     32
2047     /  MPEG2 & 2.5     9     17*/
2048     bs_t[1] bs;
2049     L3_gr_info_t[4] gr_info;
2050     bs_init(bs.ptr, frame + HDR_SIZE, frame_size - HDR_SIZE);
2051     if (HDR_IS_CRC(frame))
2052         get_bits(bs.ptr, 16);
2053     if (L3_read_side_info(bs.ptr, gr_info.ptr, frame) < 0)
2054         return 0; /* side info corrupted */
2055 
2056     const(uint8_t)*tag = frame + HDR_SIZE + bs[0].pos/8;
2057     if (memcmp(g_xing_tag.ptr, tag, 4) && memcmp(g_info_tag.ptr, tag, 4))
2058         return 0;
2059     int flags = tag[7];
2060     if (!((flags & FRAMES_FLAG)))
2061         return -1;
2062     tag += 8;
2063     *frames = cast(uint32_t)(tag[0] << 24) | (tag[1] << 16) | (tag[2] << 8) | tag[3];
2064     tag += 4;
2065     if (flags & BYTES_FLAG)
2066         tag += 4;
2067     if (flags & TOC_FLAG)
2068         tag += 100;
2069     if (flags & VBR_SCALE_FLAG)
2070         tag += 4;
2071     *delay = *padding = 0;
2072     if (*tag)
2073     {   /* extension, LAME, Lavc, etc. Should be the same structure. */
2074         tag += 21;
2075         if (tag - frame + 14 >= frame_size)
2076             return 0;
2077         *delay   = ((tag[0] << 4) | (tag[1] >> 4)) + (528 + 1);
2078         *padding = (((tag[1] & 0xF) << 8) | tag[2]) - (528 + 1);
2079     }
2080     return 1;
2081 }
2082 
2083 int mp3dec_detect_buf(const uint8_t *buf, size_t buf_size)
2084 {
2085     return mp3dec_detect_cb(null, cast(uint8_t *)buf, buf_size);
2086 }
2087 
2088 int mp3dec_detect_cb(mp3dec_io_t *io, uint8_t *buf, size_t buf_size)
2089 {
2090     if (!buf || cast(size_t)-1 == buf_size || (io && buf_size < MINIMP3_BUF_SIZE))
2091         return MP3D_E_PARAM;
2092     size_t filled = buf_size;
2093     if (io)
2094     {
2095         if (io.seek(0, io.seek_data))
2096             return MP3D_E_IOERROR;
2097         filled = io.read(buf, MINIMP3_ID3_DETECT_SIZE, io.read_data);
2098         if (filled > MINIMP3_ID3_DETECT_SIZE)
2099             return MP3D_E_IOERROR;
2100     }
2101     if (filled < MINIMP3_ID3_DETECT_SIZE)
2102         return MP3D_E_USER; /* too small, can't be mp3/mpa */
2103     if (mp3dec_skip_id3v2(buf, filled))
2104         return 0; /* id3v2 tag is enough evidence */
2105     if (io)
2106     {
2107         size_t readed = io.read(buf + MINIMP3_ID3_DETECT_SIZE, buf_size - MINIMP3_ID3_DETECT_SIZE, io.read_data);
2108         if (readed > (buf_size - MINIMP3_ID3_DETECT_SIZE))
2109             return MP3D_E_IOERROR;
2110         filled += readed;
2111         if (filled < MINIMP3_BUF_SIZE)
2112             mp3dec_skip_id3v1(buf, &filled);
2113     } else
2114     {
2115         mp3dec_skip_id3v1(buf, &filled);
2116         if (filled > MINIMP3_BUF_SIZE)
2117             filled = MINIMP3_BUF_SIZE;
2118     }
2119     int free_format_bytes, frame_size;
2120     mp3d_find_frame(buf, cast(int)filled, &free_format_bytes, &frame_size);
2121     if (frame_size)
2122         return 0; /* MAX_FRAME_SYNC_MATCHES consecutive frames found */
2123     return MP3D_E_USER;
2124 }
2125 
2126 int mp3dec_load_buf(mp3dec_t *dec, const uint8_t *buf, size_t buf_size, mp3dec_file_info_t *info, MP3D_PROGRESS_CB progress_cb, void *user_data)
2127 {
2128     return mp3dec_load_cb(dec, null, cast(uint8_t *)buf, buf_size, info, progress_cb, user_data);
2129 }
2130 
2131 int mp3dec_load_cb(mp3dec_t *dec, mp3dec_io_t *io, uint8_t *buf, size_t buf_size, mp3dec_file_info_t *info, MP3D_PROGRESS_CB progress_cb, void *user_data)
2132 {
2133     if (!dec || !buf || !info || cast(size_t)-1 == buf_size || (io && buf_size < MINIMP3_BUF_SIZE))
2134         return MP3D_E_PARAM;
2135     uint64_t detected_samples = 0;
2136     size_t orig_buf_size = buf_size;
2137     int to_skip = 0;
2138     mp3dec_frame_info_t frame_info;
2139     memset(info, 0, (*info).sizeof);
2140     memset(&frame_info, 0, (frame_info).sizeof);
2141 
2142     /* skip id3 */
2143     size_t filled = 0, consumed = 0;
2144     int eof = 0, ret2 = 0;
2145     if (io)
2146     {
2147         if (io.seek(0, io.seek_data))
2148             return MP3D_E_IOERROR;
2149         filled = io.read(buf, MINIMP3_ID3_DETECT_SIZE, io.read_data);
2150         if (filled > MINIMP3_ID3_DETECT_SIZE)
2151             return MP3D_E_IOERROR;
2152         if (MINIMP3_ID3_DETECT_SIZE != filled)
2153             return 0;
2154         size_t id3v2size = mp3dec_skip_id3v2(buf, filled);
2155         if (id3v2size)
2156         {
2157             if (io.seek(id3v2size, io.seek_data))
2158                 return MP3D_E_IOERROR;
2159             filled = io.read(buf, buf_size, io.read_data);
2160             if (filled > buf_size)
2161                 return MP3D_E_IOERROR;
2162         } else
2163         {
2164             size_t readed = io.read(buf + MINIMP3_ID3_DETECT_SIZE, buf_size - MINIMP3_ID3_DETECT_SIZE, io.read_data);
2165             if (readed > (buf_size - MINIMP3_ID3_DETECT_SIZE))
2166                 return MP3D_E_IOERROR;
2167             filled += readed;
2168         }
2169         if (filled < MINIMP3_BUF_SIZE)
2170             mp3dec_skip_id3v1(buf, &filled);
2171     } else
2172     {
2173         mp3dec_skip_id3(cast(const(uint8_t)**)&buf, &buf_size);
2174         if (!buf_size)
2175             return 0;
2176     }
2177     /* try to make allocation size assumption by first frame or vbr tag */
2178     mp3dec_init(dec);
2179     int samples;
2180     do
2181     {
2182         uint32_t frames;
2183         int i, delay, padding, free_format_bytes = 0, frame_size = 0;
2184         const(uint8_t) *hdr;
2185         if (io)
2186         {
2187             if (!eof && filled - consumed < MINIMP3_BUF_SIZE)
2188             {   /* keep minimum 10 consecutive mp3 frames (~16KB) worst case */
2189                 memmove(buf, buf + consumed, filled - consumed);
2190                 filled -= consumed;
2191                 consumed = 0;
2192                 size_t readed = io.read(buf + filled, buf_size - filled, io.read_data);
2193                 if (readed > (buf_size - filled))
2194                     return MP3D_E_IOERROR;
2195                 if (readed != (buf_size - filled))
2196                     eof = 1;
2197                 filled += readed;
2198                 if (eof)
2199                     mp3dec_skip_id3v1(buf, &filled);
2200             }
2201             i = mp3d_find_frame(buf + consumed, cast(int)(filled - consumed), &free_format_bytes, &frame_size);
2202             consumed += i;
2203             hdr = buf + consumed;
2204         } else
2205         {
2206             i = mp3d_find_frame(buf, cast(int)buf_size, &free_format_bytes, &frame_size);
2207             buf      += i;
2208             buf_size -= i;
2209             hdr = buf;
2210         }
2211         if (i && !frame_size)
2212             continue;
2213         if (!frame_size)
2214             return 0;
2215         frame_info.channels = HDR_IS_MONO(hdr) ? 1 : 2;
2216         frame_info.hz = hdr_sample_rate_hz(hdr);
2217         frame_info.layer = 4 - HDR_GET_LAYER(hdr);
2218         frame_info.bitrate_kbps = hdr_bitrate_kbps(hdr);
2219         frame_info.frame_bytes = frame_size;
2220         samples = hdr_frame_samples(hdr)*frame_info.channels;
2221         if (3 != frame_info.layer)
2222             break;
2223         int ret = mp3dec_check_vbrtag(hdr, frame_size, &frames, &delay, &padding);
2224         if (ret > 0)
2225         {
2226             padding *= frame_info.channels;
2227             to_skip = delay*frame_info.channels;
2228             detected_samples = samples*cast(uint64_t)frames;
2229             if (detected_samples >= cast(uint64_t)to_skip)
2230                 detected_samples -= to_skip;
2231             if (padding > 0 && detected_samples >= cast(uint64_t)padding)
2232                 detected_samples -= padding;
2233             if (!detected_samples)
2234                 return 0;
2235         }
2236         if (ret)
2237         {
2238             if (io)
2239             {
2240                 consumed += frame_size;
2241             } else
2242             {
2243                 buf      += frame_size;
2244                 buf_size -= frame_size;
2245             }
2246         }
2247         break;
2248     } while(1);
2249     size_t allocated = MINIMP3_MAX_SAMPLES_PER_FRAME*(mp3d_sample_t.sizeof);
2250     if (detected_samples)
2251         allocated += detected_samples*(mp3d_sample_t.sizeof);
2252     else
2253         allocated += (buf_size/frame_info.frame_bytes)*samples*(mp3d_sample_t.sizeof);
2254     info.buffer = cast(mp3d_sample_t*) malloc(allocated);
2255     if (!info.buffer)
2256         return MP3D_E_MEMORY;
2257     /* save info */
2258     info.channels = frame_info.channels;
2259     info.hz       = frame_info.hz;
2260     info.layer    = frame_info.layer;
2261     /* decode all frames */
2262     size_t avg_bitrate_kbps = 0, frames = 0;
2263     do
2264     {
2265         if ((allocated - info.samples*(mp3d_sample_t.sizeof)) < MINIMP3_MAX_SAMPLES_PER_FRAME*(mp3d_sample_t.sizeof))
2266         {
2267             allocated *= 2;
2268             mp3d_sample_t *alloc_buf = cast(mp3d_sample_t*)realloc(info.buffer, allocated);
2269             if (!alloc_buf)
2270                 return MP3D_E_MEMORY;
2271             info.buffer = alloc_buf;
2272         }
2273         if (io)
2274         {
2275             if (!eof && filled - consumed < MINIMP3_BUF_SIZE)
2276             {   /* keep minimum 10 consecutive mp3 frames (~16KB) worst case */
2277                 memmove(buf, buf + consumed, filled - consumed);
2278                 filled -= consumed;
2279                 consumed = 0;
2280                 size_t readed = io.read(buf + filled, buf_size - filled, io.read_data);
2281                 if (readed != (buf_size - filled))
2282                     eof = 1;
2283                 filled += readed;
2284                 if (eof)
2285                     mp3dec_skip_id3v1(buf, &filled);
2286             }
2287             samples = mp3dec_decode_frame(dec, buf + consumed, cast(int)(filled - consumed), info.buffer + info.samples, &frame_info);
2288             consumed += frame_info.frame_bytes;
2289         } else
2290         {
2291             samples = mp3dec_decode_frame(dec, buf, cast(int)MINIMP3_MIN(buf_size, cast(size_t)int.max), info.buffer + info.samples, &frame_info);
2292             buf      += frame_info.frame_bytes;
2293             buf_size -= frame_info.frame_bytes;
2294         }
2295         if (samples)
2296         {
2297             if (info.hz != frame_info.hz || info.layer != frame_info.layer)
2298             {
2299                 ret2 = MP3D_E_DECODE;
2300                 break;
2301             }
2302             if (info.channels && info.channels != frame_info.channels)
2303             {
2304                 ret2 = MP3D_E_DECODE;
2305                 break;
2306             }
2307             samples *= frame_info.channels;
2308             if (to_skip)
2309             {
2310                 size_t skip = MINIMP3_MIN(samples, to_skip);
2311                 to_skip -= skip;
2312                 samples -= skip;
2313                 memmove(info.buffer, info.buffer + skip, samples);
2314             }
2315             info.samples += samples;
2316             avg_bitrate_kbps += frame_info.bitrate_kbps;
2317             frames++;
2318             if (progress_cb)
2319             {
2320                 ret2 = progress_cb(user_data, orig_buf_size, (orig_buf_size - buf_size), &frame_info);
2321                 if (ret2)
2322                     break;
2323             }
2324         }
2325     } while (frame_info.frame_bytes);
2326     if (detected_samples && info.samples > detected_samples)
2327         info.samples = cast(size_t) detected_samples; /* cut padding */
2328     /* reallocate to normal buffer size */
2329     if (allocated != info.samples*(mp3d_sample_t.sizeof))
2330     {
2331         mp3d_sample_t *alloc_buf = cast(mp3d_sample_t*)realloc(info.buffer, info.samples*(mp3d_sample_t.sizeof));
2332         if (!alloc_buf && info.samples)
2333             return MP3D_E_MEMORY;
2334         info.buffer = alloc_buf;
2335     }
2336     if (frames)
2337         info.avg_bitrate_kbps = cast(int)(avg_bitrate_kbps/frames);
2338     return ret2;
2339 }
2340 
2341 int mp3dec_iterate_buf(const(uint8_t)*buf, size_t buf_size, MP3D_ITERATE_CB callback, void *user_data)
2342 {
2343     const uint8_t *orig_buf = buf;
2344     if (!buf || cast(size_t)-1 == buf_size || !callback)
2345         return MP3D_E_PARAM;
2346     /* skip id3 */
2347     mp3dec_skip_id3(&buf, &buf_size);
2348     if (!buf_size)
2349         return 0;
2350     mp3dec_frame_info_t frame_info;
2351     memset(&frame_info, 0, (frame_info.sizeof));
2352     do
2353     {
2354         int free_format_bytes = 0, frame_size = 0, ret;
2355         int i = mp3d_find_frame(buf, cast(int)buf_size, &free_format_bytes, &frame_size);
2356         buf      += i;
2357         buf_size -= i;
2358         if (i && !frame_size)
2359             continue;
2360         if (!frame_size)
2361             break;
2362         const uint8_t *hdr = buf;
2363         frame_info.channels = HDR_IS_MONO(hdr) ? 1 : 2;
2364         frame_info.hz = hdr_sample_rate_hz(hdr);
2365         frame_info.layer = 4 - HDR_GET_LAYER(hdr);
2366         frame_info.bitrate_kbps = hdr_bitrate_kbps(hdr);
2367         frame_info.frame_bytes = frame_size;
2368 
2369         if (callback)
2370         {
2371             ret = callback(user_data, hdr, frame_size, free_format_bytes, buf_size, (hdr - orig_buf), &frame_info);
2372             if (ret)
2373                 return ret;
2374         }
2375         buf      += frame_size;
2376         buf_size -= frame_size;
2377     } while (1);
2378     return 0;
2379 }
2380 
2381 int mp3dec_iterate_cb(mp3dec_io_t *io, uint8_t *buf, size_t buf_size, MP3D_ITERATE_CB callback, void *user_data)
2382 {
2383     if (!io || !buf || cast(size_t)-1 == buf_size || buf_size < MINIMP3_BUF_SIZE || !callback)
2384         return MP3D_E_PARAM;
2385     size_t filled = io.read(buf, MINIMP3_ID3_DETECT_SIZE, io.read_data), consumed = 0;
2386     uint64_t readed2 = 0;
2387     mp3dec_frame_info_t frame_info;
2388     int eof = 0;
2389     memset(&frame_info, 0, (frame_info.sizeof));
2390     if (filled > MINIMP3_ID3_DETECT_SIZE)
2391         return MP3D_E_IOERROR;
2392     if (MINIMP3_ID3_DETECT_SIZE != filled)
2393         return 0;
2394     size_t id3v2size = mp3dec_skip_id3v2(buf, filled);
2395     if (id3v2size)
2396     {
2397         if (io.seek(id3v2size, io.seek_data))
2398             return MP3D_E_IOERROR;
2399         filled = io.read(buf, buf_size, io.read_data);
2400         if (filled > buf_size)
2401             return MP3D_E_IOERROR;
2402         readed2 += id3v2size;
2403     } else
2404     {
2405         size_t readed = io.read(buf + MINIMP3_ID3_DETECT_SIZE, buf_size - MINIMP3_ID3_DETECT_SIZE, io.read_data);
2406         if (readed > (buf_size - MINIMP3_ID3_DETECT_SIZE))
2407             return MP3D_E_IOERROR;
2408         filled += readed;
2409     }
2410     if (filled < MINIMP3_BUF_SIZE)
2411         mp3dec_skip_id3v1(buf, &filled);
2412     do
2413     {
2414         int free_format_bytes = 0, frame_size = 0, ret;
2415         int i = mp3d_find_frame(buf + consumed, cast(int)(filled - consumed), &free_format_bytes, &frame_size);
2416         if (i && !frame_size)
2417         {
2418             consumed += i;
2419             continue;
2420         }
2421         if (!frame_size)
2422             break;
2423         const uint8_t *hdr = buf + consumed + i;
2424         frame_info.channels = HDR_IS_MONO(hdr) ? 1 : 2;
2425         frame_info.hz = hdr_sample_rate_hz(hdr);
2426         frame_info.layer = 4 - HDR_GET_LAYER(hdr);
2427         frame_info.bitrate_kbps = hdr_bitrate_kbps(hdr);
2428         frame_info.frame_bytes = frame_size;
2429 
2430         readed2 += i;
2431         if (callback)
2432         {
2433             ret = callback(user_data, hdr, frame_size, free_format_bytes, filled - consumed, readed2, &frame_info);
2434             if (ret)
2435                 return ret;
2436         }
2437         readed2 += frame_size;
2438         consumed += i + frame_size;
2439         if (!eof && filled - consumed < MINIMP3_BUF_SIZE)
2440         {   /* keep minimum 10 consecutive mp3 frames (~16KB) worst case */
2441             memmove(buf, buf + consumed, filled - consumed);
2442             filled -= consumed;
2443             consumed = 0;
2444             size_t readed = io.read(buf + filled, buf_size - filled, io.read_data);
2445             if (readed > (buf_size - filled))
2446                 return MP3D_E_IOERROR;
2447             if (readed != (buf_size - filled))
2448                 eof = 1;
2449             filled += readed;
2450             if (eof)
2451                 mp3dec_skip_id3v1(buf, &filled);
2452         }
2453     } while (1);
2454     return 0;
2455 }
2456 
2457 static int mp3dec_load_index(void *user_data, const uint8_t *frame, int frame_size, int free_format_bytes, size_t buf_size, uint64_t offset, mp3dec_frame_info_t *info)
2458 {
2459     mp3dec_frame_t *idx_frame;
2460     mp3dec_ex_t *dec = cast(mp3dec_ex_t *)user_data;
2461     if (!dec.index.frames && !dec.start_offset)
2462     {   /* detect VBR tag and try to avoid full scan */
2463         uint32_t frames;
2464         int delay, padding;
2465         dec.info = *info;
2466         dec.start_offset = dec.offset = offset;
2467         dec.end_offset   = (offset + buf_size);
2468         dec.free_format_bytes = free_format_bytes; /* should not change */
2469         if (3 == dec.info.layer)
2470         {
2471             int ret = mp3dec_check_vbrtag(frame, frame_size, &frames, &delay, &padding);
2472             if (ret)
2473                 dec.start_offset = dec.offset = offset + frame_size;
2474             if (ret > 0)
2475             {
2476                 padding *= info.channels;
2477                 dec.start_delay = dec.to_skip = delay*info.channels;
2478                 dec.samples = hdr_frame_samples(frame)*info.channels*cast(uint64_t)frames;
2479                 if (dec.samples >= cast(uint64_t)dec.start_delay)
2480                     dec.samples -= dec.start_delay;
2481                 if (padding > 0 && dec.samples >= cast(uint64_t)padding)
2482                     dec.samples -= padding;
2483                 dec.detected_samples = dec.samples;
2484                 dec.vbr_tag_found = 1;
2485                 return MP3D_E_USER;
2486             } else if (ret < 0)
2487                 return 0;
2488         }
2489     }
2490     if (dec.index.num_frames + 1 > dec.index.capacity)
2491     {
2492         if (!dec.index.capacity)
2493             dec.index.capacity = 4096;
2494         else
2495             dec.index.capacity *= 2;
2496         mp3dec_frame_t *alloc_buf = cast(mp3dec_frame_t *)realloc(cast(void*)dec.index.frames, (mp3dec_frame_t.sizeof)*dec.index.capacity);
2497         if (!alloc_buf)
2498             return MP3D_E_MEMORY;
2499         dec.index.frames = alloc_buf;
2500     }
2501     idx_frame = &dec.index.frames[dec.index.num_frames++];
2502     idx_frame.offset = offset;
2503     idx_frame.sample = dec.samples;
2504     if (!dec.buffer_samples && dec.index.num_frames < 256)
2505     {   /* for some cutted mp3 frames, bit-reservoir not filled and decoding can't be started from first frames */
2506         /* try to decode up to 255 first frames till samples starts to decode */
2507         dec.buffer_samples = mp3dec_decode_frame(&dec.mp3d, frame, cast(int)MINIMP3_MIN(buf_size, cast(size_t)int.max), dec.buffer.ptr, info);
2508         dec.samples += dec.buffer_samples*info.channels;
2509     } else
2510         dec.samples += hdr_frame_samples(frame)*info.channels;
2511     return 0;
2512 }
2513 
2514 int mp3dec_ex_open_buf(mp3dec_ex_t *dec, const uint8_t *buf, size_t buf_size, int seek_method)
2515 {
2516     if (!dec || !buf || cast(size_t)-1 == buf_size || !(MP3D_SEEK_TO_BYTE == seek_method || MP3D_SEEK_TO_SAMPLE == seek_method))
2517         return MP3D_E_PARAM;
2518     memset(dec, 0, (*dec).sizeof);
2519     dec.file.buffer = buf;
2520     dec.file.size   = buf_size;
2521     dec.seek_method = seek_method;
2522     mp3dec_init(&dec.mp3d);
2523     int ret = mp3dec_iterate_buf(dec.file.buffer, dec.file.size, &mp3dec_load_index, dec);
2524     if (ret && MP3D_E_USER != ret)
2525         return ret;
2526     mp3dec_init(&dec.mp3d);
2527     dec.buffer_samples = 0;
2528     return 0;
2529 }
2530 
2531 size_t mp3dec_idx_binary_search(mp3dec_index_t *idx, uint64_t position)
2532 {
2533     size_t end = idx.num_frames, start = 0, index = 0;
2534     while (start <= end)
2535     {
2536         size_t mid = (start + end) / 2;
2537         if (idx.frames[mid].sample >= position)
2538         {   /* move left side. */
2539             if (idx.frames[mid].sample == position)
2540                 return mid;
2541             end = mid - 1;
2542         }  else
2543         {   /* move to right side */
2544             index = mid;
2545             start = mid + 1;
2546             if (start == idx.num_frames)
2547                 break;
2548         }
2549     }
2550     return index;
2551 }
2552 
2553 int mp3dec_ex_seek(mp3dec_ex_t *dec, uint64_t position)
2554 {
2555     size_t i;
2556     if (!dec)
2557         return MP3D_E_PARAM;
2558     if (MP3D_SEEK_TO_BYTE == dec.seek_method)
2559     {
2560         if (dec.io)
2561         {
2562             dec.offset = position;
2563         } else
2564         {
2565             dec.offset = MINIMP3_MIN(position, dec.file.size);
2566         }
2567         dec.cur_sample = 0;
2568         goto do_exit;
2569     }
2570     dec.cur_sample = position;
2571     position += dec.start_delay;
2572     if (0 == position)
2573     {   /* optimize seek to zero, no index needed */
2574 seek_zero:
2575         dec.offset  = dec.start_offset;
2576         dec.to_skip = 0;
2577         goto do_exit;
2578     }
2579     if (!dec.index.frames && dec.vbr_tag_found)
2580     {   /* no index created yet (vbr tag used to calculate track length) */
2581         dec.samples = 0;
2582         dec.buffer_samples = 0;
2583         if (dec.io)
2584         {
2585             if (dec.io.seek(dec.start_offset, dec.io.seek_data))
2586                 return MP3D_E_IOERROR;
2587             int ret = mp3dec_iterate_cb(dec.io, cast(uint8_t *)dec.file.buffer, dec.file.size, &mp3dec_load_index, dec);
2588             if (ret && MP3D_E_USER != ret)
2589                 return ret;
2590         } else
2591         {
2592             int ret = mp3dec_iterate_buf(dec.file.buffer + dec.start_offset, cast(size_t)(dec.file.size - dec.start_offset), &mp3dec_load_index, dec);
2593             if (ret && MP3D_E_USER != ret)
2594                 return ret;
2595         }
2596         for (i = 0; i < dec.index.num_frames; i++)
2597             dec.index.frames[i].offset += dec.start_offset;
2598         dec.samples = dec.detected_samples;
2599     }
2600     if (!dec.index.frames)
2601         goto seek_zero; /* no frames in file - seek to zero */
2602     i = mp3dec_idx_binary_search(&dec.index, position);
2603     if (i)
2604     {
2605         int to_fill_bytes = 511;
2606         int skip_frames = MINIMP3_PREDECODE_FRAMES;
2607         i -= MINIMP3_MIN(i, cast(size_t)skip_frames);
2608         if (3 == dec.info.layer)
2609         {
2610             while (i && to_fill_bytes)
2611             {   /* make sure bit-reservoir is filled when we start decoding */
2612                 bs_t[1] bs;
2613                 L3_gr_info_t[4] gr_info;
2614                 int frame_bytes, frame_size;
2615                 const(uint8_t) *hdr;
2616                 if (dec.io)
2617                 {
2618                     hdr = dec.file.buffer;
2619                     if (dec.io.seek(dec.index.frames[i - 1].offset, dec.io.seek_data))
2620                         return MP3D_E_IOERROR;
2621                     size_t readed = dec.io.read(cast(uint8_t *)hdr, HDR_SIZE, dec.io.read_data);
2622                     if (readed != HDR_SIZE)
2623                         return MP3D_E_IOERROR;
2624                     frame_size = hdr_frame_bytes(hdr, dec.free_format_bytes) + hdr_padding(hdr);
2625                     readed = dec.io.read(cast(uint8_t *)hdr + HDR_SIZE, frame_size - HDR_SIZE, dec.io.read_data);
2626                     if (readed != cast(size_t)(frame_size - HDR_SIZE))
2627                         return MP3D_E_IOERROR;
2628                     bs_init(bs.ptr, hdr + HDR_SIZE, frame_size - HDR_SIZE);
2629                 } else
2630                 {
2631                     hdr = dec.file.buffer + dec.index.frames[i - 1].offset;
2632                     frame_size = hdr_frame_bytes(hdr, dec.free_format_bytes) + hdr_padding(hdr);
2633                     bs_init(bs.ptr, hdr + HDR_SIZE, frame_size - HDR_SIZE);
2634                 }
2635                 if (HDR_IS_CRC(hdr))
2636                     get_bits(bs.ptr, 16);
2637                 i--;
2638                 if (L3_read_side_info(bs.ptr, gr_info.ptr, hdr) < 0)
2639                     break; /* frame not decodable, we can start from here */
2640                 frame_bytes = (bs[0].limit - bs[0].pos)/8;
2641                 to_fill_bytes -= MINIMP3_MIN(to_fill_bytes, frame_bytes);
2642             }
2643         }
2644     }
2645     dec.offset = dec.index.frames[i].offset;
2646     dec.to_skip = cast(int)(position - dec.index.frames[i].sample);
2647     while ((i + 1) < dec.index.num_frames && !dec.index.frames[i].sample && !dec.index.frames[i + 1].sample)
2648     {   /* skip not decodable first frames */
2649         const(uint8_t) *hdr;
2650         if (dec.io)
2651         {
2652             hdr = dec.file.buffer;
2653             if (dec.io.seek(dec.index.frames[i].offset, dec.io.seek_data))
2654                 return MP3D_E_IOERROR;
2655             size_t readed = dec.io.read(cast(uint8_t *)hdr, HDR_SIZE, dec.io.read_data);
2656             if (readed != HDR_SIZE)
2657                 return MP3D_E_IOERROR;
2658         } else
2659             hdr = dec.file.buffer + dec.index.frames[i].offset;
2660         dec.to_skip += hdr_frame_samples(hdr)*dec.info.channels;
2661         i++;
2662     }
2663 do_exit:
2664     if (dec.io)
2665     {
2666         if (dec.io.seek(dec.offset, dec.io.seek_data))
2667             return MP3D_E_IOERROR;
2668     }
2669     dec.buffer_samples  = 0;
2670     dec.buffer_consumed = 0;
2671     dec.input_consumed  = 0;
2672     dec.input_filled    = 0;
2673     dec.last_error      = 0;
2674     mp3dec_init(&dec.mp3d);
2675     return 0;
2676 }
2677 
2678 size_t mp3dec_ex_read(mp3dec_ex_t *dec, mp3d_sample_t *buf, size_t samples)
2679 {
2680     if (!dec || !buf)
2681         return MP3D_E_PARAM;
2682     uint64_t end_offset = dec.end_offset ? dec.end_offset : dec.file.size;
2683     size_t samples_requested = samples;
2684     int eof = 0;
2685     mp3dec_frame_info_t frame_info;
2686     memset(&frame_info, 0, (frame_info.sizeof));
2687     if (dec.detected_samples && dec.cur_sample >= dec.detected_samples)
2688         return 0; /* at end of stream */
2689     if (dec.last_error)
2690         return 0; /* error eof state, seek can reset it */
2691     if (dec.buffer_consumed < dec.buffer_samples)
2692     {
2693         size_t to_copy = MINIMP3_MIN(cast(size_t)(dec.buffer_samples - dec.buffer_consumed), samples);
2694         if (dec.detected_samples)
2695         {   /* count decoded samples to properly cut padding */
2696             if (dec.cur_sample + to_copy >= dec.detected_samples)
2697                 to_copy = cast(size_t)(dec.detected_samples - dec.cur_sample);
2698         }
2699         dec.cur_sample += to_copy;
2700         memcpy(buf, dec.buffer.ptr + dec.buffer_consumed, to_copy*(mp3d_sample_t.sizeof));
2701         buf += to_copy;
2702         dec.buffer_consumed += to_copy;
2703         samples -= to_copy;
2704     }
2705     while (samples)
2706     {
2707         if (dec.detected_samples && dec.cur_sample >= dec.detected_samples)
2708             break;
2709         const(uint8_t) *dec_buf;
2710         if (dec.io)
2711         {
2712             if (!eof && (dec.input_filled - dec.input_consumed) < MINIMP3_BUF_SIZE)
2713             {   /* keep minimum 10 consecutive mp3 frames (~16KB) worst case */
2714                 memmove(cast(uint8_t*)dec.file.buffer, cast(uint8_t*)dec.file.buffer + dec.input_consumed, dec.input_filled - dec.input_consumed);
2715                 dec.input_filled -= dec.input_consumed;
2716                 dec.input_consumed = 0;
2717                 size_t readed = dec.io.read(cast(uint8_t*)dec.file.buffer + dec.input_filled, dec.file.size - dec.input_filled, dec.io.read_data);
2718                 if (readed > (dec.file.size - dec.input_filled))
2719                 {
2720                     dec.last_error = MP3D_E_IOERROR;
2721                     readed = 0;
2722                 }
2723                 if (readed != (dec.file.size - dec.input_filled))
2724                     eof = 1;
2725                 dec.input_filled += readed;
2726                 if (eof)
2727                     mp3dec_skip_id3v1(cast(uint8_t*)dec.file.buffer, &dec.input_filled);
2728             }
2729             dec_buf = dec.file.buffer + dec.input_consumed;
2730             if (!(dec.input_filled - dec.input_consumed))
2731                 break;
2732             dec.buffer_samples = mp3dec_decode_frame(&dec.mp3d, dec_buf, cast(int)(dec.input_filled - dec.input_consumed), dec.buffer.ptr, &frame_info);
2733             dec.input_consumed += frame_info.frame_bytes;
2734         } else
2735         {
2736             dec_buf = dec.file.buffer + dec.offset;
2737             uint64_t buf_size = end_offset - dec.offset;
2738             if (!buf_size)
2739                 break;
2740             dec.buffer_samples = mp3dec_decode_frame(&dec.mp3d, dec_buf, cast(int) MINIMP3_MIN(buf_size, cast(uint64_t)int.max), dec.buffer.ptr, &frame_info);
2741         }
2742         dec.buffer_consumed = 0;
2743         if (dec.info.hz != frame_info.hz || dec.info.layer != frame_info.layer
2744             || dec.info.channels != frame_info.channels
2745             )
2746         {
2747             dec.last_error = MP3D_E_DECODE;
2748             break;
2749         }
2750         if (dec.buffer_samples)
2751         {
2752             dec.buffer_samples *= frame_info.channels;
2753             if (dec.to_skip)
2754             {
2755                 size_t skip = MINIMP3_MIN(dec.buffer_samples, dec.to_skip);
2756                 dec.buffer_consumed += skip;
2757                 dec.to_skip -= skip;
2758             }
2759             size_t to_copy = MINIMP3_MIN(cast(size_t)(dec.buffer_samples - dec.buffer_consumed), samples);
2760             if (dec.detected_samples)
2761             {   /* ^ handle padding */
2762                 if (dec.cur_sample + to_copy >= dec.detected_samples)
2763                     to_copy = cast(size_t)(dec.detected_samples - dec.cur_sample);
2764             }
2765             dec.cur_sample += to_copy;
2766             memcpy(buf, dec.buffer.ptr + dec.buffer_consumed, to_copy*(mp3d_sample_t.sizeof));
2767             buf += to_copy;
2768             dec.buffer_consumed += to_copy;
2769             samples -= to_copy;
2770         } else if (dec.to_skip)
2771         {   /* In mp3 decoding not always can start decode from any frame because of bit reservoir,
2772                count skip samples for such frames */
2773             int frame_samples = hdr_frame_samples(dec_buf)*frame_info.channels;
2774             dec.to_skip -= MINIMP3_MIN(frame_samples, dec.to_skip);
2775         }
2776         dec.offset += frame_info.frame_bytes;
2777     }
2778     return samples_requested - samples;
2779 }
2780 
2781 
2782 void mp3dec_close_file(mp3dec_map_info_t *map_info)
2783 {
2784     if (map_info.buffer)
2785         free(cast(void *)map_info.buffer);
2786     map_info.buffer = null;
2787     map_info.size = 0;
2788 }
2789 
2790 int mp3dec_detect_mapinfo(mp3dec_map_info_t *map_info)
2791 {
2792     int ret = mp3dec_detect_buf(map_info.buffer, map_info.size);
2793     mp3dec_close_file(map_info);
2794     return ret;
2795 }
2796 
2797 int mp3dec_load_mapinfo(mp3dec_t *dec, mp3dec_map_info_t *map_info, mp3dec_file_info_t *info, MP3D_PROGRESS_CB progress_cb, void *user_data)
2798 {
2799     int ret = mp3dec_load_buf(dec, map_info.buffer, map_info.size, info, progress_cb, user_data);
2800     mp3dec_close_file(map_info);
2801     return ret;
2802 }
2803 
2804 int mp3dec_iterate_mapinfo(mp3dec_map_info_t *map_info, MP3D_ITERATE_CB callback, void *user_data)
2805 {
2806     int ret = mp3dec_iterate_buf(map_info.buffer, map_info.size, callback, user_data);
2807     mp3dec_close_file(map_info);
2808     return ret;
2809 }
2810 
2811 static int mp3dec_ex_open_mapinfo(mp3dec_ex_t *dec, int seek_method)
2812 {
2813     int ret = mp3dec_ex_open_buf(dec, dec.file.buffer, dec.file.size, seek_method);
2814     dec.is_file = 1;
2815     if (ret)
2816         mp3dec_ex_close(dec);
2817     return ret;
2818 }
2819 
2820 int mp3dec_ex_open_cb(mp3dec_ex_t *dec, mp3dec_io_t *io, int seek_method)
2821 {
2822     if (!dec || !io || !(MP3D_SEEK_TO_BYTE == seek_method || MP3D_SEEK_TO_SAMPLE == seek_method))
2823         return MP3D_E_PARAM;
2824     memset(dec, 0, (*dec).sizeof);
2825     dec.file.size = MINIMP3_IO_SIZE;
2826     dec.file.buffer = cast(const uint8_t*)malloc(dec.file.size);
2827     if (!dec.file.buffer)
2828         return MP3D_E_MEMORY;
2829     dec.seek_method = seek_method;
2830     dec.io = io;
2831     mp3dec_init(&dec.mp3d);
2832     if (io.seek(0, io.seek_data))
2833         return MP3D_E_IOERROR;
2834     int ret = mp3dec_iterate_cb(io, cast(uint8_t *)dec.file.buffer, dec.file.size, &mp3dec_load_index, dec);
2835     if (ret && MP3D_E_USER != ret)
2836         return ret;
2837     if (dec.io.seek(dec.start_offset, dec.io.seek_data))
2838         return MP3D_E_IOERROR;
2839     mp3dec_init(&dec.mp3d);
2840     dec.buffer_samples = 0;
2841     return 0;
2842 }
2843 
2844 void mp3dec_ex_close(mp3dec_ex_t *dec)
2845 {
2846     if (dec.index.frames)
2847         free(dec.index.frames);
2848     memset(dec, 0, (*dec).sizeof);
2849 }
2850 
2851