/decoders/audio/mp3.d

Large files files are truncated, but you can click here to view the full file

/*
 * mp3.d
 *
 * This file implements the MP3 audio standard.
 *
 * Author: Dave Wilkinson
 *
 */

module decoders.audio.mp3;

import decoders.audio.decoder;
import decoders.decoder;

import core.stream;
import core.time;
import core.string;
import core.definitions;

import io.wavelet;
import io.audio;
import io.console;

import math.common;

// initialize the array to zero
typedef double zerodouble = 0.0;

template FromBigEndian(uint input) {
	version (LittleEndian) {
		const auto FromBigEndian = (input >> 24) | ((input >> 8) & 0x0000FF00) | ((input << 8) & 0x00FF0000) | ((input << 24) & 0xFF000000);
	}
	else {
		const auto FromBigEndian = input;
	}
}

template FromBigEndianBitIndex32(uint index) {
	version (LittleEndian) {
		const auto FromBigEndianBitIndex32 = ((3 - cast(uint)(index/8)) * 8) + (index % 8);
	}
	else {
		const auto FromBigEndianBitIndex32 = index;
	}
}

class MP3Decoder : AudioDecoder {

private:

	enum : uint {
		MP3_STATE_INIT,
		MP3_BUFFER_AUDIO,
		MP3_READ_HEADER,
		MP3_AMBIGUOUS_SYNC,
		MP3_READ_CRC,
		MP3_READ_AUDIO_DATA,
		MP3_READ_AUDIO_DATA_PREAMBLE,
		MP3_READ_AUDIO_DATA_SINGLE_CHANNEL,
		MP3_READ_AUDIO_DATA_SCALE_FACTORS,
		MP3_READ_AUDIO_DATA_JOINT_STEREO,
	}

	align(1) struct MP3HeaderInformation {
		uint ID;
		uint Layer;
		uint Protected;
		uint BitrateIndex;
		uint SamplingFrequency;
		uint Padding;
		uint Private;
		uint Mode;
		uint ModeExtension;
		uint Copyright;
		uint Original;
		uint Emphasis;
	}

	align(1) struct ID3HeaderInformation {
		ubyte[3] signature;
		ubyte[2] ver;
		ubyte flags;
		ubyte[4] len;
	}

	const auto MPEG_SYNC_BITS 		= FromBigEndian!(0xFFF00000);
	const auto MPEG_ID_BIT    		= FromBigEndian!(0x00080000);
	const auto MPEG_LAYER			= FromBigEndian!(0x00060000);
	const auto MPEG_LAYER_SHIFT				= FromBigEndianBitIndex32!(17);
	const auto MPEG_PROTECTION_BIT	= FromBigEndian!(0x00010000);
	const auto MPEG_BITRATE_INDEX	= FromBigEndian!(0x0000F000);
	const auto MPEG_BITRATE_INDEX_SHIFT 	= FromBigEndianBitIndex32!(12);
	const auto MPEG_SAMPLING_FREQ	= FromBigEndian!(0x00000C00);
	const auto MPEG_SAMPLING_FREQ_SHIFT 	= FromBigEndianBitIndex32!(10);
	const auto MPEG_PADDING_BIT		= FromBigEndian!(0x00000200);
	const auto MPEG_PRIVATE_BIT		= FromBigEndian!(0x00000100);
	const auto MPEG_MODE			= FromBigEndian!(0x000000C0);
	const auto MPEG_MODE_SHIFT				= FromBigEndianBitIndex32!(6);
	const auto MPEG_MODE_EXTENSION	= FromBigEndian!(0x00000030);
	const auto MPEG_MODE_EXTENSION_SHIFT 	= FromBigEndianBitIndex32!(4);
	const auto MPEG_COPYRIGHT		= FromBigEndian!(0x00000008);
	const auto MPEG_ORIGINAL		= FromBigEndian!(0x00000004);
	const auto MPEG_EMPHASIS		= FromBigEndian!(0x00000003);
	const auto MPEG_EMPHASIS_SHIFT = 0;

	// modes

	const auto MPEG_MODE_STEREO			= 0;
	const auto MPEG_MODE_JOINT_STEREO	= 1;
	const auto MPEG_MODE_DUAL_CHANNEL	= 2;
	const auto MPEG_MODE_SINGLE_CHANNEL = 3;

	const uint byteMasks[9][] = [
		[0x00, 0x00, 0x00, 0x00, 0x0, 0x0, 0x0, 0x0],		// 0 bit
		[0x80, 0x40, 0x20, 0x10, 0x8, 0x4, 0x2, 0x1],		// 1 bit
		[0xC0, 0x60, 0x30, 0x18, 0xC, 0x6, 0x3, 0x1],		// 2 bits
		[0xE0, 0x70, 0x38, 0x1C, 0xE, 0x7, 0x3, 0x1],		// 3 bits
		[0xF0, 0x78, 0x3C, 0x1E, 0xF, 0x7, 0x3, 0x1],		// 4 bits
		[0xF8, 0x7C, 0x3E, 0x1F, 0xF, 0x7, 0x3, 0x1],		// 5 bits
		[0xFC, 0x7E, 0x3F, 0x1F, 0xF, 0x7, 0x3, 0x1],		// 6 bits
		[0xFE, 0x7F, 0x3F, 0x1F, 0xF, 0x7, 0x3, 0x1],		// 7 bits
		[0xFF, 0x7F, 0x3F, 0x1F, 0xF, 0x7, 0x3, 0x1]		// 8 bits
	];

	// layer 3 bit rates (MPEG-1)
	const uint[] bitRates = [ 0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320 ]; // the first entry is the 'free' bitrate
	const double[] samplingFrequencies = [ 44.1, 48.0, 32.0, 1.0 ]; // the final entry is reserved, but set to 1.0 due to being used in division

	// Scalefactor Band Indices
	const uint[23][3] sfindex_long = [
		// 44.1
		[0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 52, 62, 74, 90, 110, 134, 162, 196, 238, 288, 342, 418, 576],
		// 48.0
		[0, 4, 8, 12, 16, 20, 24, 30, 36, 42, 50, 60, 72, 88, 106, 128, 156, 190, 230, 276, 330, 384, 576],
		// 32.0
		[0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 54, 66, 82, 102, 126, 156, 194, 240, 296, 364, 448, 550, 576]
	];

	const uint[14][3] sfindex_short = [
		// 44.1
		[0, 4, 8, 12, 16, 22, 30, 40, 52, 66, 84, 106, 136, 192],
		// 48.0
		[0, 4, 8, 12, 16, 22, 28, 38, 50, 64, 80, 100, 126, 192],
		// 32.0
		[0, 4, 8, 12, 16, 22, 30, 42, 58, 78, 104, 138, 180, 192]
	];
	
	// Synthesis Filter Working Area:
	int bufOffset[2] = [64,64];
	zerodouble BB[2][2*512];

	// Static Huffman tables

	// Imports huffmanTables[][][] and huffmanValues[][]
	// These are in an array from 0 - 16 and then table 24 being 17
	// Index as: huffmanTables[tableIndex][bitlength][value]
	//           huffmanValues[tableIndex][value]
	// Both tables correspond in their order.
	import decoders.audio.mp3Huffman;

	uint[][] curTable;
	uint[] curValues;
	uint linbits;

	// Select the table to use for decoding and reset state.
	void initializeHuffman(uint region, uint gr, uint ch) {
		uint tableIndex = table_select[region][gr][ch];
		
		switch (tableIndex) {

			case 16:
				linbits = 1;
				break;

			case 17:
				linbits = 2;
				break;

			case 18:
				linbits = 3;
				break;

			case 24:
			case 19:
				linbits = 4;
				break;
				
			case 25:
				linbits = 5;
				break;

			case 26:
			case 20:
				linbits = 6;
				break;

			case 27:
				linbits = 7;
				break;

			case 28:
			case 21:
				linbits = 8;
				break;

			case 29:
				linbits = 9;
				break;

			case 22:
				linbits = 10;
				break;

			case 30:
				linbits = 11;
				break;

			case 31:
			case 23:
				linbits = 13;
				break;

			default:
				linbits = 0;
				break;
		}

		if (tableIndex >= 24) {
			tableIndex = 17;
		}
		else if (tableIndex >= 16) {
			tableIndex = 16;
		}

		// XXX: This silliness is due to a compiler bug in DMD 1.046
		if (tableIndex == 17) {
			curTable = huffmanTable24;
		}
		else {
			curTable = huffmanTables[tableIndex];
		}
		curValues = huffmanValues[tableIndex];
	}

	int[] readCode() {
		uint code;
		uint bitlength;
		uint valoffset;

		for(;;) {
			code <<= 1;
			code |= readBits(1);
			
			if (bitlength > curTable.length) {
				break;
			}

			foreach(uint i, foo; curTable[bitlength]) {
				if (foo == code) {
					// found code

					// get value offset
					valoffset += i;
					valoffset *= 2;

     				int[] values = [curValues[valoffset], curValues[valoffset+1]];
     			//	Console.putln("b:", values[0], " ", values[1]);

					// read linbits (x)
					if (linbits > 0 && values[0] == 15) {
						values[0] += readBits(linbits);
					}

					if (values[0] > 0) {
						if (readBits(1) == 1) {
							values[0] = -values[0];
						}
					}

					if (linbits > 0 && values[1] == 15) {
						values[1] += readBits(linbits);
					}

					if (values[1] > 0) {
						if (readBits(1) == 1) {
							values[1] = -values[1];
						}
					}

     				//Console.putln("a:", values[0], " ", values[1]);
					return values;
				}
			}

			valoffset += curTable[bitlength].length;
			bitlength++;
			if (bitlength >= curTable.length) {
				return [128, 128];
			}
		}

		return [128, 128];
	}

	uint curCountTable;

	void initializeQuantizationHuffman(uint gr, uint ch) {
		curCountTable = count1table_select[gr][ch];
	}

	int[] readQuantizationCode() {
		uint code = decodeQuantization();

		int v = ((code >> 3) & 1);
		int w = ((code >> 2) & 1);
		int x = ((code >> 1) & 1);
		int y = (code & 1);

		// Get Sign Bits (for non-zero values)

		if (v > 0 && readBits(1) == 1) {
			v = -v;
		}

		if (w > 0 && readBits(1) == 1) {
			w = -w;
		}

		if (x > 0 && readBits(1) == 1) {
			x = -x;
		}

		if (y > 0 && readBits(1) == 1) {
			y = -y;
		}

	//	Console.putln("v: ", v, " w: ", w, " x: ", x , " y: ",y );

		return [v,w,x,y];
	}

	uint decodeQuantization() {
		uint code;

		if (curCountTable == 1) {
			// Quantization Huffman Table B is trivial...
			// It is simply the bitwise negation of 4 bits from the stream.
			// code = ~readBits(4);
			code = readBits(4);
			code = ~code;
		}
		else {
			// Quantization Huffman Table A is the only case,
			// so it is written here by hand:

			// state 1
			code = readBits(1);

			if (code == 0b1) {
				return 0b0000;
			}

			// state 2
			code = readBits(3);

			if (code >= 0b0100 && code <= 0b0111) {
				uint idx = code - 0b0100;
				const uint[] stage2_values = [0b0010, 0b0101, 0b0110, 0b0111];
				return stage2_values[idx];
			}

			// state 3
			code <<= 1;
			code |= readBits(1);

			if (code >= 0b00011 && code <= 0b00111) {
				uint idx = code - 0b00011;
				const uint[] stage3_values = [0b1001, 0b0110, 0b0011, 0b1010, 0b1100];
				return stage3_values[idx];
			}

			// state 4
			code <<= 1;
			code |= readBits(1);

			if (code <= 0b000101) {
				const uint[] stage4_values = [0b1011, 0b1111, 0b1101, 0b1110, 0b0111, 0b0101];
				return stage4_values[code];
			}

			// invalid code;
			code = 0;
		}

		return code;
	}

	import decoders.audio.mpegCommon;

	bool accepted = false;

	// number of blocks (of 1728 samples) to buffer
	const auto NUM_BLOCKS = 40;
	
	Wavelet tempBuffer;

public:
	string name() {
		return "MPEG Layer 3";
	}

	string extension() {
		return "mp3";
	}

	bool firstTime = true;

	StreamData decode(Stream stream, Wavelet toBuffer, ref AudioInfo wi) {
		for(;;) {
			switch (decoderState) {
				case MP3_STATE_INIT:

					decoderState = MP3_BUFFER_AUDIO;

					/* follow through */

					// attempts to find the 12-16 sync bits
					// if it is unsure of the filetype, it will
					// look for only 12 bits (b 1111 1111 1111)
					// if it knows its layer it will search for
					// the sync bits plus that part of the header
				case MP3_BUFFER_AUDIO:

					samplesLeft = 1728 * NUM_BLOCKS;

					if (toBuffer !is null) {
						samplesLeft = cast(int)(toBuffer.length() / 1728) * 1728;
						samplesLeft += 1728;
						bufferSize = samplesLeft;
					}

					bufferSize = samplesLeft;

					decoderState = MP3_READ_HEADER;

					// *** fall through *** //

				case MP3_READ_HEADER:
					//Console.putln("pos: ", new String("%x", stream.position));

					if (!stream.read(mpeg_header)) {
						return StreamData.Accepted;
					}

					decoderState = MP3_AMBIGUOUS_SYNC;


					// *** fall through *** //

					// look at the sync bits of the header
					// if they are not correct, shift the header
					// 8 bits and read another byte until the
					// sync bits match

				case MP3_AMBIGUOUS_SYNC:

     				if ((mpeg_header & FromBigEndian!(0xFFFFFF00)) == FromBigEndian!(0x49443300)) {

     					if (id3.signature[0] != 0x49) {
							if (!stream.read((cast(ubyte*)&id3) + 4, id3.sizeof - 4)) {
								return StreamData.Required;
							}

							id3.signature[0] = 0x49;

							id3.ver[0] = cast(ubyte)(mpeg_header & 0xFF);

							// skip the ID3 section
							foreach(b; id3.len) {
								id3length <<= 7;
								b &= 0x7f;
								id3length |= b;
							}

							//Console.putln("id3 length: ", new String("%x", id3length));
						}

						if (!stream.skip(id3length)) {
							return StreamData.Required;
						}

						decoderState = MP3_READ_HEADER;
						continue;
					}

					//Console.putln("mpeg_header ", new String("%x", mpeg_header)	);

					if ((mpeg_header & MPEG_SYNC_BITS) == MPEG_SYNC_BITS) {
						// sync bits found
						//writeln("sync bits found ", stream.getPosition() - 4);

						// pull apart header

						// the header looks like this:

						// SYNCWORD			12 bits
						// ID				1 bit
						// LAYER			2 bits
						// PROTECTION BIT	1 bit
						// BITRATE INDEX	4 bits
						// SAMPLING FREQ	2 bits
						// PADDING BIT		1 bit
						// PRIVATE BIT		1 bit
						// MODE				2 bits
						// MODE EXTENSION	2 bits
						// COPYRIGHT		1 bit
						// ORIGINAL/HOME	1 bit
						// EMPHASIS			2 bits

						header.ID = (mpeg_header & MPEG_ID_BIT ? 1 : 0);
						header.Layer = (mpeg_header & MPEG_LAYER) >> MPEG_LAYER_SHIFT;

						if (header.Layer != 1) {
							return StreamData.Invalid;
						}

						header.Protected = (mpeg_header & MPEG_PROTECTION_BIT ? 1 : 0);
						header.BitrateIndex = (mpeg_header & MPEG_BITRATE_INDEX) >> MPEG_BITRATE_INDEX_SHIFT;
						header.SamplingFrequency = (mpeg_header & MPEG_SAMPLING_FREQ) >> MPEG_SAMPLING_FREQ_SHIFT;
						header.Padding = (mpeg_header & MPEG_PADDING_BIT ? 1 : 0);
						header.Private = (mpeg_header & MPEG_PRIVATE_BIT ? 1 : 0);
						header.Mode = (mpeg_header & MPEG_MODE) >> MPEG_MODE_SHIFT;
						header.ModeExtension = (mpeg_header & MPEG_MODE_EXTENSION) >> MPEG_MODE_EXTENSION_SHIFT;
						header.Copyright = (mpeg_header & MPEG_COPYRIGHT ? 1 : 0);
						header.Original = (mpeg_header & MPEG_ORIGINAL ? 1 : 0);
						header.Emphasis = (mpeg_header & MPEG_EMPHASIS) >> MPEG_EMPHASIS_SHIFT;

						/*Console.putln("Header: ", mpeg_header & MPEG_SYNC_BITS, "\n",
								"ID: ", header.ID, "\n",
								"Layer: ", header.Layer, "\n",
								"Protected: ", header.Protected, "\n",
								"BitrateIndex: ", header.BitrateIndex, "\n",
								"SamplingFrequency: ", header.SamplingFrequency, "\n",
								"Padding: ", header.Padding, "\n",
								"Private: ", header.Private, "\n",
								"Mode: ", header.Mode, "\n",
								"ModeExtension: ", header.ModeExtension, "\n",
								"Copyright: ", header.Copyright, "\n",
								"Original: ", header.Original, "\n",
								"Emphasis: ", header.Emphasis); //*/

						// Calculate the length of the Audio Data

						bufferLength = cast(uint)(144 * (cast(double)bitRates[header.BitrateIndex] / cast(double)samplingFrequencies[header.SamplingFrequency]));
						if (header.Padding) {
							bufferLength++;
						}

						// subtract the size of the header
						bufferLength -= 4;

						// set the format of the wave buffer

						if (header.SamplingFrequency == 0) {
							// 44.1 kHz
							wf.samplesPerSecond = 44100;
						}
						else if (header.SamplingFrequency == 1) {
							// 48 kHz
							wf.samplesPerSecond = 48000;
						}
						else {
							// 32 kHz
							wf.samplesPerSecond = 32000;
						}

						wf.compressionType = 1;

						switch(header.Mode) {
							case MPEG_MODE_STEREO:
							case MPEG_MODE_DUAL_CHANNEL:
								wf.numChannels = 2;
								break;

							case MPEG_MODE_SINGLE_CHANNEL:
								wf.numChannels = 1;
								break;

							case MPEG_MODE_JOINT_STEREO:
								wf.numChannels = 2;
								break;

							default: // impossible!
								return StreamData.Invalid;
						}


						wf.averageBytesPerSecond = wf.samplesPerSecond * 2 * wf.numChannels;
						wf.blockAlign = 2 * wf.numChannels;
						wf.bitsPerSample = 16;

						// set the wavelet's audio format
						if (toBuffer !is null) {
							toBuffer.setAudioFormat(wf);
							bufferTime = toBuffer.time;
						}

						if (header.Protected == 0) {
							decoderState = MP3_READ_CRC;
						}
						else {
							decoderState = MP3_READ_AUDIO_DATA;
						}
						
						if (!accepted) {
							if (toBuffer !is null) {
								if (toBuffer.length() != bufferSize) {
									//Console.putln("resize ", bufferSize, " from ", toBuffer.length());
									//toBuffer.resize(bufferSize);
									//Console.putln("resize ", bufferSize, " from ", toBuffer.length());
								}
								toBuffer.rewind();
							}

							if (toBuffer is null && isSeek == false) {
								decoderState = MP3_READ_AUDIO_DATA_PREAMBLE;
								return StreamData.Accepted;
							}
						}

						accepted = true;

						continue;
					}
					else {
						Console.putln("cur test ", mpeg_header & MPEG_SYNC_BITS, " @ ", stream.position - 4);
						ubyte curByte;

						// test 15K worth
						syncAmount++;

						if (syncAmount == 1024*15) {
							return StreamData.Invalid;
						}

						if (!stream.read(curByte)) {
							return StreamData.Required;
						}

						mpeg_header <<= 8;
						mpeg_header |= (cast(uint)curByte);
					}

					continue;

				case MP3_READ_CRC:

					if (!stream.read(crc)) {
						return StreamData.Required;
					}

					decoderState = MP3_READ_AUDIO_DATA;

					continue;
				
				case MP3_READ_AUDIO_DATA_PREAMBLE:
				
					if (toBuffer !is null) {
						samplesLeft = cast(int)(toBuffer.length() / 1728) * 1728;
						samplesLeft += 1728;
						bufferSize = samplesLeft;
					}

					decoderState = MP3_READ_AUDIO_DATA;

					/* FOLLOW THROUGH */

				case MP3_READ_AUDIO_DATA:
				//	Console.putln("pos: ", new String("%x", stream.position));

					// curByte is currently at the end of the last frame (supposedly)
					// main_data_end depicts the end of the data frame

					curByte = audioData.length - bufferLength;
					curPos = 0;

					switch(header.Mode) {
						case MPEG_MODE_STEREO:
						case MPEG_MODE_DUAL_CHANNEL:
							channels = 2;
							decoderState = MP3_READ_AUDIO_DATA_SINGLE_CHANNEL;
							break;

						case MPEG_MODE_SINGLE_CHANNEL:
							channels = 1;
							decoderState = MP3_READ_AUDIO_DATA_SINGLE_CHANNEL;
							break;

						case MPEG_MODE_JOINT_STEREO:
							channels = 2;
							decoderState = MP3_READ_AUDIO_DATA_SINGLE_CHANNEL;
							break;

						default: // impossible!
							return StreamData.Invalid;
					}

					continue;

				case MP3_READ_AUDIO_DATA_SINGLE_CHANNEL:

					// Read in enough data for decoding a buffer
					audioHeaderLength = 32;

					if (channels == 1) { audioHeaderLength = 17; }

					//Console.putln("reading ", audioHeaderLength, " info header buffer");

					// read in the side info
					if (!stream.read(audioHeader.ptr, audioHeaderLength)) {
						return StreamData.Required;
					}
					
					// reset bit stream
					audioRef = audioHeader;
					audioRefLength = audioHeader.length;
					curByte = 0;
					curPos = 0;

					//Console.putln(audioRefLength, " <--- header length");

					// The reading of side info

					main_data_begin = readBits(9);	// actually main_data_end in the spec,
													// but that makes no sense in this context

					if (channels == 1) {
						readBits(5); // ignore private_bits
					}
					else {
						readBits(3); // ignore private_bits
					}

					for(uint ch = 0; ch < channels; ch++) {
						for(uint scfsi_band = 0; scfsi_band < 4; scfsi_band++) {
							scfsi[scfsi_band][ch] = readBits(1);
						}
					}

					// 18 or 16 bits read

					for(uint gr=0; gr < 2; gr++) {
						for(uint ch = 0; ch < channels; ch++) {

							part2_3_length[gr][ch] = readBits(12);
							big_values[gr][ch] = readBits(9);
							global_gain[gr][ch] = readBits(8);
							scalefac_compress[gr][ch] = readBits(4);
							blocksplit_flag[gr][ch] = readBits(1);

							slen1[gr][ch] = slen1_interpret[scalefac_compress[gr][ch]];
							slen2[gr][ch] = slen2_interpret[scalefac_compress[gr][ch]];

							if (blocksplit_flag[gr][ch]) {
								block_type[gr][ch] = readBits(2);
								switch_point[gr][ch] = readBits(1);
								for (uint region = 0; region < 2; region++) {
									table_select[region][gr][ch] = readBits(5);
								}

								// window -- Number of actual time slot in case of
								// block_type == 2, 0 = window = 2.

								for (uint window = 0; window < 3; window++) {
									subblock_gain[window][gr][ch] = readBits(3);
								}

								if (block_type[gr][ch] == 2 && switch_point[gr][ch] == 0) {
									region_address1[gr][ch] = 8;
								}
								else {
									region_address1[gr][ch] = 7;
								}

								region_address2[gr][ch] = 20 - region_address1[gr][ch];

								if (switch_point[gr][ch] == 1) {
									switch_point_l[gr][ch] = 8;
									switch_point_s[gr][ch] = 3;
								}
								else {
									switch_point_l[gr][ch] = 0;
									switch_point_s[gr][ch] = 0;
								}
							}
							else {
								block_type[gr][ch] = 0;

								for (uint region = 0; region < 3; region++) {
									table_select[region][gr][ch] = readBits(5);
								}

								region_address1[gr][ch] = readBits(4);
								region_address2[gr][ch] = readBits(3);

								switch_point[gr][ch] = 0;
								switch_point_l[gr][ch] = 0;
								switch_point_s[gr][ch] = 0;
							}

							preflag[gr][ch] = readBits(1);
							scalefac_scale[gr][ch] = readBits(1);
							count1table_select[gr][ch] = readBits(1);
						}
					}

					bufferLength -= audioHeaderLength;

					//Console.putln("Audio Data Length: ", bufferLength);

					// append the buffer
					audioData ~= new ubyte[bufferLength];

					/* followed by main data (at main_data_end... not immediately following) */

					decoderState = MP3_READ_AUDIO_DATA_SCALE_FACTORS;

				case MP3_READ_AUDIO_DATA_SCALE_FACTORS:

					//Console.putln("reading ", bufferLength, " info decode buffer");

					// read in the data
					if (!stream.read(&audioData[$ - bufferLength], bufferLength)) {
						return StreamData.Required;
					}

					// reset bit stream
					curByte = audioData.length;
					curByte -= bufferLength;
					curByte -= main_data_begin;

					main_data_begin = curByte;

					//Console.putln(curByte, " start of read");

					audioRefLength = audioData.length;
					audioRef = audioData;

					curPos = 0;

					bool output = false;

					for (uint gr = 0; gr < 2; gr++) {
						//Console.putln("gr ", gr);
						for (uint ch = 0; ch < channels; ch++) {

							part2_length = (curByte * 8) + curPos;

							// Read the scalefactors for this granule
							readScalefactors(gr, ch);

							part2_length = ((curByte * 8) + curPos) - part2_length;

							// Decode the current huffman data
							decodeHuffman(gr, ch);

							// Requantize
							requantizeSample(gr, ch);
							// ro[ch] == quantizedData[ch]
							for (uint sb = 0; sb < SBLIMIT; sb++) {
								for (uint ss = 0; ss < SSLIMIT; ss++) {
									//printf("%f\n", quantizedData[ch][sb][ss]);
								}
							}
						}

						// Account for a mode switch from intensity stereo to MS_stereo
						normalizeStereo(gr);
						for (uint ch = 0; ch < channels; ch++) {
							for (uint sb = 0; sb < SBLIMIT; sb++) {
								for (uint ss = 0; ss < SSLIMIT; ss++) {
									//if (normalizedData[ch][sb][ss] > 0.0) {
									//	printf("%f\n", normalizedData[ch][sb][ss]);
									//}
								}
							}
						}

						for (uint ch = 0; ch < channels; ch++) {
							// Reorder the short blocks
							reorder(gr, ch);
							for (uint sb = 0; sb < SBLIMIT; sb++) {
								for (uint ss = 0; ss < SSLIMIT; ss++) {
									//if (reorderedData[sb][ss] > 0.0) {
										//printf("%f\n", reorderedData[sb][ss]);
									//}
								}
							}

							// Perform anti-alias pass on subband butterflies
							antialias(gr, ch);
							for (uint sb = 0; sb < SBLIMIT; sb++) {
								for (uint ss = 0; ss < SSLIMIT; ss++) {
								//	if (hybridData[sb][ss] > 0.0) {
										//printf("%f\n", hybridData[sb][ss]);
								//	}
								}
							}

							// Perform hybrid synthesis pass
							for (uint sb; sb < SBLIMIT; sb++) {
								hybridSynthesis(gr, ch, sb);
							}

							// Multiply every second subband's every second input by -1
							// To correct for frequency inversion of the polyphase filterbank
							for (uint sb; sb < SBLIMIT; sb++) {
								for (uint ss; ss < SSLIMIT; ss++) {
									if (((ss % 2) == 1) && ((sb % 2) == 1)) {
										polysynthData[ch][sb][ss] = -polysynthData[ch][sb][ss];
									}
								}
							}

							for (uint sb = 0; sb < SBLIMIT; sb++) {
								for (uint ss = 0; ss < SSLIMIT; ss++) {
									//if (polysynthData[ch][sb][ss] > 0.0) {
									//	printf("%f\n", polysynthData[ch][sb][ss]);
									//}
								}
							}
						}

						// Polyphase Synthesis
						//Console.putln("polyphase");
						for (uint ss; ss < 18; ss++) {
							polyphaseSynthesis(gr, ss, toBuffer);
						}
						//Console.putln("polyphase!");
					}

					samplesLeft -= (3*18*32*channels);

					if (samplesLeft <= 0) {
						decoderState = MP3_BUFFER_AUDIO;
						curTime += bufferTime;
							//curTime.toString();
						return StreamData.Accepted; /*
					toBuffer.rewind();
						continue; //*/
					}

					//Console.putln(curByte, " end of read");
					//Console.putln(curByte - main_data_begin, " read");

					main_data_end = curByte+1;

					/* followed by huffman encoded data */

					decoderState = MP3_READ_HEADER;
					continue;

				case MP3_READ_AUDIO_DATA_JOINT_STEREO:
					continue;

				default:
					break;
			}
			break;
		}
		return StreamData.Invalid;
	}

protected:

	void readScalefactors(uint gr, uint ch) {
		if (blocksplit_flag[gr][ch] == 1 && block_type[gr][ch] == 2) {
			if (switch_point[gr][ch] == 0) {

				// Decoding scalefactors for a short window.

            	for (uint cb = 0; cb < 6; cb++) {
            		for (uint window = 0; window < 3; window++) {
						scalefac[gr][ch].short_window[cb][window] = readBits(slen1[gr][ch]);
            		}
            	}

            	for (uint cb = 6; cb < cb_limit_short; cb++) {
            		for (uint window = 0; window < 3; window++) {
						scalefac[gr][ch].short_window[cb][window] = readBits(slen2[gr][ch]);
            		}
            	}

            	for (uint window = 0; window < 3; window++) {
            		scalefac[gr][ch].short_window[12][window] = 0;
            	}
			}
			else {

				// Decoding scalefactors for a long window with a switch point to short.

				for (uint cb = 0; cb < 8; cb++) {
					if ((scfsi[cb][ch] == 0) || (gr == 0)) {
						scalefac[gr][ch].long_window[cb] = readBits(slen1[gr][ch]);
					}
				}

				for (uint cb = 3; cb < 6; cb++) {
					for (uint window = 0; window < 3; window++) {
						if ((scfsi[cb][ch] == 0) || (gr == 0)) {
							scalefac[gr][ch].short_window[cb][window] = readBits(slen1[gr][ch]);
						}
					}
				}

				for (uint cb = 6; cb < cb_limit_short; cb++) {
					for (uint window = 0; window < 3; window++) {
						if ((scfsi[cb][ch] == 0) || (gr == 0)) {
							scalefac[gr][ch].short_window[cb][window] = readBits(slen2[gr][ch]);
						}
					}
				}

				for (uint window = 0; window < 3; window++) {
					if ((scfsi[cb_limit_short][ch] == 0) || (gr == 0)) {
						scalefac[gr][ch].short_window[cb_limit_short][window] = 0;
					}
				}
			}
		}
		else {

			// The block_type cannot be 2 in this block (so, it must be block 0, 1, or 3).

			// Decoding the scalefactors for a long window

			if ((scfsi[0][ch] == 0) || (gr == 0)) {
        		for (uint cb = 0; cb < 6; cb++) {
					scalefac[gr][ch].long_window[cb] = readBits(slen1[gr][ch]);
        		}
			}

			if ((scfsi[1][ch] == 0) || (gr == 0)) {
        		for (uint cb = 6; cb < 11; cb++) {
					scalefac[gr][ch].long_window[cb] = readBits(slen1[gr][ch]);
        		}
			}

			if ((scfsi[2][ch] == 0) || (gr == 0)) {
        		for (uint cb = 11; cb < 16; cb++) {
					scalefac[gr][ch].long_window[cb] = readBits(slen2[gr][ch]);
        		}
			}

			if ((scfsi[3][ch] == 0) || (gr == 0)) {
        		for (uint cb = 16; cb < 21; cb++) {
					scalefac[gr][ch].long_window[cb] = readBits(slen2[gr][ch]);
        		}
			}

			// (The reference implementation does nothing with subband 21)

			// We fill it with a high negative integer:
			scalefac[gr][ch].long_window[21] = -858993460;

			scalefac[gr][ch].long_window[22] = 0;
		}
	}

	const auto SBLIMIT = 32;
	const auto SSLIMIT = 18;

	// Decoded Huffman Data -- is(i) in the spec
	int[SSLIMIT][SBLIMIT] codedData;

	// Requantizated Data -- xr(i) in the spec
	double[SSLIMIT][SBLIMIT][2] quantizedData;

	// Normalized Data -- lr(i)
	double[SSLIMIT][SBLIMIT][2] normalizedData;

	// reordered data -- re(i)
	double[SSLIMIT][SBLIMIT] reorderedData;

	// anti-aliased hybrid synthesis data -- hybridIn
	double[SSLIMIT][SBLIMIT] hybridData;

	// data for the polysynth phase -- hybridOut
	double[SSLIMIT][SBLIMIT][2] polysynthData;

	void decodeHuffman(uint gr, uint ch) {
		// part2_3_length is the length of all of the data
		// (huffman + scalefactors). part2_length is just
		// the scalefactors by themselves.

		// Note: SSLIMIT * SBLIMIT = 32 * 18 = 576

//		Console.putln("-=-=-=-");

		static const auto max_table_entry = 15;

		uint region1Start;
		uint region2Start;

		if (blocksplit_flag[gr][ch] == 1 && block_type[gr][ch] == 2) {
			// Short Blocks
			region1Start = 36;
			region2Start = 576; // There isn't a region 2 for short blocks
		}
		else {
			// Long Blocks
			region1Start = sfindex_long[header.SamplingFrequency][region_address1[gr][ch] + 1];
			region2Start = sfindex_long[header.SamplingFrequency][region_address1[gr][ch] + region_address2[gr][ch] + 2];
		}
		
		uint maxBand = big_values[gr][ch] * 2;

//		Console.putln(region1Start, " to ", region2Start);

		if (region1Start > maxBand) { region1Start = maxBand; }
		if (region2Start > maxBand) { region2Start = maxBand; }

		uint freqIndex;

		uint pos = curByte;
		uint posbit = curPos;

		// The number of bits used for the huffman data
 		uint huffmanLength = (part2_3_length[gr][ch] - part2_length);

 		// The bit position in the stream to stop.
 		uint maxBit = huffmanLength + curPos + (curByte * 8);

		// Region 0
		if (freqIndex < region1Start) {
			//Console.putln("region 0 -=-=-");
			initializeHuffman(0,gr,ch);
		}

		for (; freqIndex < region1Start; freqIndex+=2) {
			int[] code = readCode();
			codedData[freqIndex/SSLIMIT][freqIndex%SSLIMIT] = code[0];
			codedData[(freqIndex+1)/SSLIMIT][(freqIndex+1)%SSLIMIT] = code[1];
		}

		// Region 1
		if (freqIndex < region2Start) {
		//	Console.putln("region 1 -=-=-");
			initializeHuffman(1,gr,ch);
		}

		for (; freqIndex < region2Start; freqIndex+=2) {
			int[] code = readCode();
			codedData[freqIndex/SSLIMIT][freqIndex%SSLIMIT] = code[0];
			codedData[(freqIndex+1)/SSLIMIT][(freqIndex+1)%SSLIMIT] = code[1];
		}

		// Region 2
		if (freqIndex < maxBand) {
	//		Console.putln("region 2 -=-=-");
			initializeHuffman(2,gr,ch);
		}

		for (; freqIndex < maxBand; freqIndex+=2) {
			int[] code = readCode();
			codedData[freqIndex/SSLIMIT][freqIndex%SSLIMIT] = code[0];
			codedData[(freqIndex+1)/SSLIMIT][(freqIndex+1)%SSLIMIT] = code[1];
		}

//		Console.putln("big values decoded -=-=-");

		// Read in Count1 Area
		initializeQuantizationHuffman(gr,ch);

		for (; (curPos + (curByte * 8)) < maxBit && freqIndex < 574; freqIndex += 4) {
			int[4] code = readQuantizationCode();
			codedData[freqIndex/SSLIMIT][freqIndex%SSLIMIT] = code[0];
			codedData[(freqIndex+1)/SSLIMIT][(freqIndex+1)%SSLIMIT] = code[1];
			codedData[(freqIndex+2)/SSLIMIT][(freqIndex+2)%SSLIMIT] = code[2];
			codedData[(freqIndex+3)/SSLIMIT][(freqIndex+3)%SSLIMIT] = code[3];
		}

		// Zero rest
		for (; freqIndex < 576; freqIndex++) {
			codedData[freqIndex/SSLIMIT][freqIndex%SSLIMIT] = 0;
		}

		// Resync to the correct position
		// (where we started + the number of bits that would have been used)
		curByte = maxBit / 8;
		curPos = maxBit % 8;
	}
	
	void requantizeSample(uint gr, uint ch) {
		uint criticalBandBegin;
		uint criticalBandWidth;
		uint criticalBandBoundary;
		uint criticalBandIndex;

		const int[22] pretab = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 2, 0];

		// Initialize the critical boundary information
		if ((blocksplit_flag[gr][ch] == 1) && (block_type[gr][ch] == 2)) {
			if (switch_point[gr][ch] == 0) {
				// Short blocks
				criticalBandBoundary = sfindex_short[header.SamplingFrequency][1] * 3;
				criticalBandWidth = sfindex_short[header.SamplingFrequency][1];
				criticalBandBegin = 0;
			}
			else {
				// Long blocks come first for switched windows
				criticalBandBoundary = sfindex_long[header.SamplingFrequency][1];
			}
		}
		else {
			// Long windows
			criticalBandBoundary = sfindex_long[header.SamplingFrequency][1];
		}

		for (uint sb; sb < SBLIMIT; sb++) {
			for (uint ss; ss < SSLIMIT; ss++) {

				// Get the critical band boundary
				if ((sb * 18) + ss == criticalBandBoundary) {
					if (blocksplit_flag[gr][ch] == 1 && block_type[gr][ch] == 2) {
						if (switch_point[gr][ch] == 0) {
							// Requantizing the samples for a short window.
							criticalBandIndex++;
							criticalBandBoundary = sfindex_short[header.SamplingFrequency][criticalBandIndex+1]*3;
							criticalBandWidth = sfindex_short[header.SamplingFrequency][criticalBandIndex + 1] - sfindex_short[header.SamplingFrequency][criticalBandIndex];
							criticalBandBegin = sfindex_short[header.SamplingFrequency][criticalBandIndex] * 3;
						}
						else {
							// Requantizing the samples for a long window that switches to short.

							// The first two are long windows and the last two are short windows
							if (((sb * 18) + ss) == sfindex_long[header.SamplingFrequency][8]) {
								criticalBandBoundary = sfindex_short[header.SamplingFrequency][4] * 3;
								criticalBandIndex = 3;
								criticalBandWidth = sfindex_short[header.SamplingFrequency][criticalBandIndex + 1] - sfindex_short[header.SamplingFrequency][criticalBandIndex];
								criticalBandBegin = sfindex_short[header.SamplingFrequency][criticalBandIndex] * 3;
							}
							else if (((sb * 18) + ss) < sfindex_long[header.SamplingFrequency][8]) {
								criticalBandIndex++;
								criticalBandBoundary = sfindex_long[header.SamplingFrequency][criticalBandIndex+1];
							}
							else {
								criticalBandIndex++;
								criticalBandBoundary = sfindex_short[header.SamplingFrequency][criticalBandIndex + 1] * 3;
								criticalBandWidth = sfindex_short[header.SamplingFrequency][criticalBandIndex + 1] - sfindex_short[header.SamplingFrequency][criticalBandIndex];
								criticalBandBegin = sfindex_short[header.SamplingFrequency][criticalBandIndex] * 3;
							}
						}
					}
					else {
						// The block_type cannot be 2 in this block (so, it must be block 0, 1, or 3).

						// Requantizing the samples for a long window
						criticalBandIndex++;
						criticalBandBoundary = sfindex_long[header.SamplingFrequency][criticalBandIndex+1];
					}
				}

				// Global gain
				quantizedData[ch][sb][ss] = pow(2.0, (0.25 * (cast(double)global_gain[gr][ch] - 210.0)));
         //printf("g : %d %d: %f\n", sb,ss,quantizedData[ch][sb][ss]);
static bool output = false;
				// Perform the scaling that depends on the type of window
				if (blocksplit_flag[gr][ch] == 1
					&& (((block_type[gr][ch] == 2) && (switch_point[gr][ch] == 0))
					|| ((block_type[gr][ch] == 2) && (switch_point[gr][ch] == 1) && (sb >= 2)))) {

					// Short blocks (either via block_type 2 or the last 2 bands for switched windows)

					uint sbgainIndex = (((sb * 18) + ss) - criticalBandBegin) / criticalBandWidth;

					// if (output) printf("%d %d\n", sbgainIndex, criticalBandIndex);
					quantizedData[ch][sb][ss] *= pow(2.0, 0.25 * -8.0
						* subblock_gain[sbgainIndex][gr][ch]);
					quantizedData[ch][sb][ss] *= pow(2.0, 0.25 * -2.0 * (1.0 + scalefac_scale[gr][ch])
						* scalefac[gr][ch].short_window[criticalBandIndex][sbgainIndex]);
				}
				else {
					// Long blocks (either via block_type 0, 1, or 3, or the 1st 2 bands
					double powExp = -0.5 * (1.0 + cast(double)scalefac_scale[gr][ch])
						* (cast(double)scalefac[gr][ch].long_window[criticalBandIndex]
						+ (cast(double)preflag[gr][ch] * cast(double)pretab[criticalBandIndex]));
					double powResult = pow(2.0, powExp);
						//if (powResult > 0.0) {
							//printf("r : %f\nfrom : %f\n", powResult, powExp);
							//printf("with : %f %d [%d, %d, %d] %f %f\n", cast(double)scalefac_scale[gr][ch], scalefac[gr][ch].long_window[criticalBandIndex], gr, ch, criticalBandIndex,
						//	cast(double)preflag[gr][ch], cast(double)pretab[criticalBandIndex]);
						//}
					quantizedData[ch][sb][ss] *= powResult;
				}

				// Scale values

				double powResult = pow(cast(double)abs(codedData[sb][ss]), 4.0/3.0);
			//	printf("%f\n", powResult);

				quantizedData[ch][sb][ss] *= powResult;
				if (codedData[sb][ss] < 0) {
					quantizedData[ch][sb][ss] = -quantizedData[ch][sb][ss];
				}
//printf("%d %d: [%d] %.21f\n", sb,ss, codedData[sb][ss], quantizedData[ch][sb][ss]);
			}
		}
	}

	void normalizeStereo(uint gr) {

		double io;

		if ((scalefac_compress[gr][0] % 2) == 1) {
			io = 0.707106781188;
		}
		else {
			io = 0.840896415256;
		}

		short[576] decodedPos;
		double[576] decodedRatio;
		double[576][2] k;

		int i;
		int sb;
		int ss;
		int ch;
		
		int scalefactorBand;

  		// Initialize
  		decodedPos[0..$] = 7;

  		bool intensityStereo = (header.Mode == MPEG_MODE_JOINT_STEREO) && (header.ModeExtension & 0x1);
  		bool msStereo = (header.Mode == MPEG_MODE_JOINT_STEREO) && (header.ModeExtension & 0x2);
  		
  		if ((channels == 2) && intensityStereo) {
			if ((blocksplit_flag[gr][ch] == 1) && (block_type[gr][ch] == 2)) {
				if (switch_point[gr][ch] == 0) {
					for (uint j = 0; j < 3; j++) {
						int scalefactorCount = -1;

						for (scalefactorBand = 12; scalefactorBand >= 0; scalefactorBand--) {
							int lines = sfindex_short[header.SamplingFrequency][scalefactorBand + 1]
								- sfindex_short[header.SamplingFrequency][scalefactorBand];

							i = 3 * sfindex_short[header.SamplingFrequency][scalefactorBand]
								+ ((j + 1) * lines) - 1;
							
							for (; lines > 0; lines--) {
								if (quantizedData[1][i/SSLIMIT][i%SSLIMIT] != 0.0) {
									scalefactorCount = scalefactorBand;
									scalefactorBand = -10;
									lines = -10;
								}
								i--;
							}
						}

						scalefactorBand = scalefactorCount + 1;
						
						for (; scalefactorBand < 12; scalefactorBand++) {
							sb = sfindex_short[header.SamplingFrequency][scalefactorBand+1]
								- sfindex_short[header.SamplingFrequency][scalefactorBand];

							i = 3 * sfindex_short[header.SamplingFrequency][scalefactorBand] + (j * sb);

							for ( ; sb > 0; sb--) {
								decodedPos[i] = cast(short)scalefac[gr][1].short_window[scalefactorBand][j];
								if (decodedPos[i] != 7) {
									// IF (MPEG2) { ... }
									// ELSE {
										decodedRatio[i] = tan(cast(double)decodedPos[i] * (PI / 12));
									// }
								}
								i++;
							}
						}

						sb = sfindex_short[header.SamplingFrequency][12] - sfindex_short[header.SamplingFrequency][11];
						scalefactorBand = (3 * sfindex_short[header.SamplingFrequency][11]) + (j * sb);
						sb = sfindex_short[header.SamplingFrequency][13] - sfindex_short[header.SamplingFrequency][12];

						i = (3 * sfindex_short[header.SamplingFrequency][11]) + (j * sb);

						for (; sb > 0; sb--) {
							decodedPos[i] = decodedPos[scalefactorBand];
							decodedRatio[i] = decodedRatio[scalefactorBand];
							k[0][i] = k[0][scalefactorBand];
							k[1][i] = k[1][scalefactorBand];
							i++;
						}
					}
				}
				else {
					int maxScalefactorBand;

					for (uint j; j<3; j++) {
						int scalefactorCount = 2;
						for (scalefactorBand = 12; scalefactorBand >= 3; scalefactorBand--) {
							int lines = sfindex_short[header.SamplingFrequency][scalefactorBand+1]
								- sfindex_short[header.SamplingFrequency][scalefactorBand];

							i = 3 * sfindex_short[header.SamplingFrequency][scalefactorBand]
								+ ((j + 1) * lines) - 1;
							
							for (; lines > 0; lines--) {
								if (quantizedData[1][i/SSLIMIT][i%SSLIMIT] != 0.0) {
									scalefactorCount = scalefactorBand;
									scalefactorBand = -10;
									lines = -10;
								}
								i--;
							}
						}

						scalefactorBand = scalefactorCount + 1;

						if (scalefactorBand > maxScalefactorBand) {
							maxScalefactorBand = scalefactorBand;
						}
						
						for (; scalefactorBand < 12; scalefactorBand++) {
							sb = sfindex_short[header.SamplingFrequency][scalefactorBand+1]
								- sfindex_short[header.SamplingFrequency][scalefactorBand];

							i = 3 * sfindex_short[header.SamplingFrequency][scalefactorBand]
								+ (j * sb);

							for (; sb > 0; sb--) {
								decodedPos[i] = cast(short)scalefac[gr][1].short_window[scalefactorBand][j];
								if (decodedPos[i] != 7) {
									// IF (MPEG2) { ... }
									// ELSE {
									decodedRatio[i] = tan(cast(double)decodedPos[i] * (PI / 12.0));
									// }
								}
								i++;
							}
						}

						sb = sfindex_short[header.SamplingFrequency][12]
								- sfindex_short[header.SamplingFrequency][11];
						scalefactorBand = 3 * sfindex_short[header.SamplingFrequency][11]
								+ j * sb;
						sb = sfindex_short[header.SamplingFrequency][13]
								- sfindex_short[header.SamplingFrequency][12];

						i = 3 * sfindex_short[header.SamplingFrequency][11] + j * sb;
						for (; sb > 0; sb--) {
							decodedPos[i] = decodedPos[scalefactorBand];
							decodedRatio[i] = decodedRatio[scalefactorBand];
							k[0][i] = k[0][scalefactorBand];
							k[1][i] = k[1][scalefactorBand];
							i++;
						}
					}
					
					if (maxScalefactorBand <= 3) {
						i = 2;
						ss = 17;
						sb = -1;
						while (i >= 0) {
							if (quantizedData[1][i][ss] != 0.0) {
								sb = (i * 18) + ss;
								i = -1;
							}
							else {
								ss--;
								if (ss < 0) {
									i--;
									ss = 17;
								}
							}
						}

						i = 0;

						while (sfindex_long[header.SamplingFrequency][i] <= sb) {
							i++;
						}
						
						scalefactorBand = i;
						i = sfindex_long[header.SamplingFrequency][i];

						for (; scalefactorBand < 8; scalefactorBand++) {
							sb = sfindex_long[header.SamplingFrequency][scalefactorBand+1]
									- sfindex_long[header.SamplingFrequency][scalefactorBand];
							for (; sb > 0; sb--) {
								decodedPos[i] = cast(short)scalefac[gr][1].long_window[scalefactorBand];
								if (decodedPos[i] != 7) {
									// IF (MPEG2) { ... }
									// ELSE {
										decodedRatio[i] = tan(cast(double)decodedPos[i] * (PI / 12.0));
									// }
								}
								i++;
							}
						}
					}
				}
			}
			else {
				i = 31;
				ss = 17;
				sb = 0;
				
				while (i >= 0) {
					if (quantizedData[1][i][ss] != 0.0) {
						sb = (i * 18) + ss;
						i = -1;
					}
					else {
						ss--;
						if (ss < 0) {
							i--;
							ss = 17;
						}
					}
				}
				i = 0;
				
				while (sfindex_long[header.SamplingFrequency][i] <= sb) {
					i++;
				}

				scalefactorBand = i;
				i = sfindex_long[header.SamplingFrequency][i];

				for (; scalefactorBand < 21; scalefactorBand++) {
					sb = sfindex_long[header.SamplingFrequency][scalefactorBand+1]
						- sfindex_long[header.SamplingFrequency][scalefactorBand];
					
					for (; sb > 0; sb--) {
						decodedPos[i] = cast(short)scalefac[gr][1].long_window[scalefactorBand];
						if (decodedPos[i] != 7) {
							// IF (MPEG2) { ... }
							// ELSE {
							decodedRatio[i] = tan(cast(double)decodedPos[i] * (PI / 12.0));
							// }
						}
						i++;
					}
				}
				
				scalefactorBand = sfindex_long[header.SamplingFrequency][20];

				for (sb = 576 - sfindex_long[header.SamplingFrequency][21]; sb > 0; sb--) {
					decodedPos[i] = decodedPos[scalefactorBand];
					decodedRatio[i] = decodedRatio[scalefactorBand];
					k[0][i] = k[0][scalefactorBand];
					k[1][i] = k[1][scalefactorBand];
					i++;
				}
			}
  		}

		for (ch = 0; ch < 2; ch++) {
			for (sb = 0; sb < SBLIMIT; sb++) {
				for (ss = 0; ss < SSLIMIT; ss++) {
					normalizedData[ch][sb][ss] = 0;
				}
			}
		}

        if (channels == 2) {
        	for (sb = 0; sb < SBLIMIT; sb++) {
        		for (ss = 0; ss < SSLIMIT; ss++) {
        			i = (sb * 18) + ss;
        			if (decodedPos[i] == 7) {
        				if (msStereo) {
        					normalizedData[0][sb][ss] = (quantizedData[0][sb][ss] + quantizedData[1][sb][ss])
        						/ 1.41421356;
        					normalizedData[1][sb][ss] = (quantizedData[0][sb][ss] - quantizedData[1][sb][ss])
        						/ 1.41421356;
        				}
        				else {
        					normalizedData[0][sb][ss] = quantizedData[0][sb][ss];
        					normalizedData[1][sb][ss] = quantizedData[1][sb][ss];
        				}
        			}
        			else if (intensityStereo) {
        				// IF (MPEG2) {
        				// normalizedData[0][sb][ss] = quantizedData[0][sb][ss] * k[0][i];
        				// normalizedData[1][sb][ss] = quantizedData[0][sb][ss] * k[1][i];
        				// }
        				// ELSE {
        				normalizedData[0][sb][ss] = quantizedData[0][sb][ss] * (decodedRatio[i] / (1 + decodedRatio[i]));
        				normalizedData[1][sb][ss] = quantizedData[0][sb][ss] * (1 / (1 + decodedRatio[i]));
        				// }
        			}
        			else {
        				// Error ...
        			}
        		}
        	}
        }
        else { // Mono
        	for (sb = 0; sb < SBLIMIT; sb++) {
        		for (ss = 0; ss < SSLIMIT; ss++) {
        			normalizedData[0][sb][ss] = quantizedData[0][sb][ss];
        		}
        	}
        }
	}

	void reorder(uint gr, uint ch) {
		int sfreq = header.SamplingFrequency;

		for (uint sb; sb < SBLIMIT; sb++) {
			for (uint ss; ss < SSLIMIT; ss++) {
				reorderedData[sb][ss] = 0;
			}
		}

		if ((blocksplit_flag[gr][ch] == 1) && (block_type[gr][ch] == 2)) {
			if (switch_point[gr][ch] == 0) {
				// Recoder the short blocks
				uint scalefactorStart;
				uint scalefactorLines;

				for (uint scalefactorBand; scalefactorBand < 13; scalefactorBand++) {
					scalefactorStart = sfindex_short[sfreq][scalefactorBand];
					scalefactorLines = sfindex_short[sfreq][scalefactorBand + 1] - scalefactorStart;

					for (uint window; window < 3; window++) {
						for (uint freq; freq < scalefactorLines; freq++) {
							uint srcLine = (scalefactorStart * 3) + (window * scalefactorLines) + freq;
							uint destLine = (scalefactorStart * 3) + window + (freq * 3);
							reorderedData[destLine / SSLIMIT][destLine % SSLIMIT] =
								normalizedData[ch][srcLine / SSLIMIT][srcLine % SSLIMIT];
                                 //   printf("::%d %d %f\n", srcLine, destLine, reorderedData[destLine / SSLIMIT][destLine % SSLIMIT]);
						}
					}
				}
			}
			else {
				// We do not reorder the long blocks
				for (uint sb; sb < 2; sb++) {
					for (uint ss; ss < SSLIMIT; ss++) {
						reorderedData[sb][ss] = normalizedData[ch][sb][ss];
					}
				}

				// We reorder the short blocks
				uint scalefactorStart;
				uint scalefactorLines;

				for (uint scalefactorBand = 3; scalefactorBand < 13; scalefactorBand++) {
					scalefactorStart = sfindex_short[sfreq][scalefactorBand];
					scalefactorLines = sfindex_short[sfreq][scalefactorBand + 1] - scalefactorStart;

					for (uint window; window < 3; window++) {
						for (uint freq; freq < scalefactorLines; freq++) {
							uint srcLine = (scalefactorStart * 3) + (window * scalefactorLines) + freq;
							uint destLine = (scalefactorStart * 3) + window + (freq * 3);
							reorderedData[destLine / SSLIMIT][destLine % SSLIMIT] =
								normalizedData[ch][srcLine / SSLIMIT][srcLine % SSLIMIT];
						}
					}
				}
			}
		}
		else {
			// We do not reorder long blocks
			for (uint sb; sb < SBLIMIT; sb++) {
				for (uint ss; ss < SSLIMIT; ss++) {
					reorderedData[sb][ss] = normalizedData[ch][sb][ss];
				}
			}
		}
	}

	// Butterfly anti-alias
	void antialias(uint gr, uint ch) {
		uint subbandLimit = SBLIMIT - 1;
		
		// Ci[i] = [-0.6,-0.535,-0.33,-0.185,-0.095,-0.041,-0.0142,-0.0037];
		// cs[i] = 1.0 / (sqrt(1.0 + (Ci[i] * Ci[i])));
		// ca[i] = ca[i] * Ci[i];

		const double cs[8] = [
			0.85749292571254418689325777610964,
			0.88174199731770518177557399759066,
			0.94962864910273289204833276115398,
			0.98331459249179014599030200066392,
			0.99551781606758576429088040422867,
			0.99916055817814750452934664352117,
			0.99989919524444704626703489425565,
			0.99999315507028023572010150517204
		];

		const double ca[8] = [
			-0.5144957554275265121359546656654,
			-0.47173196856497227224993208871065,
			-0.31337745420390185437594981118049,
			-0.18191319961098117700820587012266,
			-0.09457419252642064760763363840166,
			-0.040965582885304047685703212384361,
			-0.014198568572471148056991895498421,
			-0.0036999746737600368721643755691364
		];

		// Init our working array with quantized data
		for (uint sb; sb < SBLIMIT; sb++) {
			for (uint ss; ss < SSLIMIT; ss++) {
				hybridData[sb][ss] = reorderedData[sb][ss];
			}
		}

		if ((blocksplit_flag[gr][ch] == 1) && (block_type[gr][ch] == 2) && (switch_point[gr][ch] == 0)) {
			return;
		}

		if ((blocksplit_flag[gr][ch] == 1) && (block_type[gr][ch] == 2) && (switch_point[gr][ch] == 1)) {
			subbandLimit = 1;
		}

		// 8 butterflies for each pair of subbands
		for (uint sb; sb < subbandLimit; sb++) {
			for (uint ss; ss < 8; ss++) {
				double bu = reorderedData[sb][17 - ss];
				double bd = reorderedData[sb + 1][ss];
				hybridData[sb][17 - ss] = (bu * cs[ss]) - (bd * ca[ss]);
				hybridData[sb + 1][ss] = (bd * cs[ss]) + (bu * ca[ss]);
			}
		}
	}
	// zerodouble initializes to 0.0 instead of nil
	zerodouble[SSLIMIT][SBLIMIT][2] previousBlock;

	void hybridSynthesis(uint gr, uint ch, uint sb) {

		int blockType = block_type[gr][ch];

		if ((blocksplit_flag[gr][ch] == 1) && (switch_point[gr][ch] == 1) && (sb < 2)) {
			blockType = 0;
		}

		double[36] output = inverseMDCT(hybridData[sb], blockType);

		// Overlapping and Adding with Previous Block:
		// The last half gets reserved for the next block, and used in this block
		for (uint ss; ss < SSLIMIT; ss++) {
			polysynthData[ch][sb][ss] = output[ss] + previousBlock[ch][sb][ss];
			previousBlock[ch][sb][ss] = cast(zerodouble)output[ss+18];
		}
	}

	double[] inverseMDCT(double[18] working, int blockType) {
		double[] ret = new double[36];

		// The Constant Parts of the Windowing equations

		const double[36][4] win = [
			// Block Type 0
			// win[i] = sin( (PI / 36) * ( i + 0.5 ) ) ; i = 0 to 35
			[
				0.043619387365336000084, 0.130526192220051573400, 0.216439613938102876070,
				0.300705799504273119100, 0.382683432365089781770, 0.461748613235033911190,
				0.537299608346823887030, 0.608761429008720655880, 0.675590207615660132130,
				0.737277336810123973260, 0.793353340291235165080, 0.843391445812885720550,
				0.887010833178221602670, 0.923879532511286738480, 0.953716950748226821580,
				0.976296007119933362260, 0.991444861373810382150, 0.999048221581857798230,
				0.999048221581857798230, 0.991444861373810382150, 0.976296007119933362260,
				0.953716950748226932610, 0.923879532511286738480, 0.887010833178221824720,
				0.843391445812885831570, 0.793353340291235165080, 0.737277336810124084280,
				0.675590207615660354170, 0.60876142900…