Add WebAssembly mpeg1 video and mp2 audio decoder

build.sh

@@ -1,5 +1,63 @@
 #!/bin/sh
-uglifyjs \
+
+
+# Build the .wasm Module first
+
+# Since we're compiling a side module here, so that we can load it without the
+# runtime cruft, we have to explicitly compile in support for malloc and
+# friends.
+# Note memcpy, memmove and memset are explicitly exported, otherwise they will
+# be eliminated by the SIDE_MODULE=2 setting - not sure why that happens.
+emcc \
+	src/wasm/mpeg1.c \
+	src/wasm/mp2.c \
+	src/wasm/buffer.c \
+	$EMSCRIPTEN/system/lib/emmalloc.cpp \
+	$EMSCRIPTEN/system/lib/libc/musl/src/string/memcpy.c \
+	$EMSCRIPTEN/system/lib/libc/musl/src/string/memmove.c \
+	$EMSCRIPTEN/system/lib/libc/musl/src/string/memset.c \
+	-s WASM=1 \
+	-s SIDE_MODULE=2 \
+	-s TOTAL_STACK=5242880\
+	-s USE_PTHREADS=0 \
+	-s LEGALIZE_JS_FFI=0\
+	-s NO_FILESYSTEM=1 \
+	-s DEFAULT_LIBRARY_FUNCS_TO_INCLUDE="[]" \
+	-s "EXPORTED_FUNCTIONS=[
+		'_memcpy',
+		'_memmove',
+		'_memset',
+		'_mpeg1_decoder_create',
+		'_mpeg1_decoder_destroy',
+		'_mpeg1_decoder_get_write_ptr',
+		'_mpeg1_decoder_get_index',
+		'_mpeg1_decoder_set_index',
+		'_mpeg1_decoder_did_write',
+		'_mpeg1_decoder_has_sequence_header',
+		'_mpeg1_decoder_get_frame_rate',
+		'_mpeg1_decoder_get_coded_size',
+		'_mpeg1_decoder_get_width',
+		'_mpeg1_decoder_get_height',
+		'_mpeg1_decoder_get_y_ptr',
+		'_mpeg1_decoder_get_cr_ptr',
+		'_mpeg1_decoder_get_cb_ptr',
+		'_mpeg1_decoder_decode',
+		'_mp2_decoder_create',
+		'_mp2_decoder_destroy',
+		'_mp2_decoder_get_write_ptr',
+		'_mp2_decoder_get_index',
+		'_mp2_decoder_set_index',
+		'_mp2_decoder_did_write',
+		'_mp2_decoder_get_left_channel_ptr',
+		'_mp2_decoder_get_right_channel_ptr',
+		'_mp2_decoder_get_sample_rate',
+		'_mp2_decoder_decode']" \
+	-O3 \
+	-o jsmpeg.wasm
+
+
+# Concat all .js sources
+cat \
 	src/jsmpeg.js \
 	src/video-element.js \
 	src/player.js \
@@ -10,8 +68,24 @@ uglifyjs \
 	src/ts.js \
 	src/decoder.js \
 	src/mpeg1.js \
+	src/mpeg1-wasm.js \
 	src/mp2.js \
+	src/mp2-wasm.js \
 	src/webgl.js \
 	src/canvas2d.js \
 	src/webaudio.js \
-	-o jsmpeg.min.js
+	src/wasm-module.js \
+	> jsmpeg.js
+
+# Append the .wasm module to the .js source as base64 string
+echo "JSMpeg.WASM_BINARY_INLINED='$(base64 -w 0 jsmpeg.wasm)';" \
+	>> jsmpeg.js
+
+
+# Minify
+uglifyjs jsmpeg.js -o jsmpeg.min.js
+
+# Cleanup
+rm jsmpeg.js
+rm jsmpeg.wasm
+

src/buffer.js

@@ -99,6 +99,8 @@ BitBuffer.prototype.write = function(buffers) {
 	else {
 		this.appendSingleBuffer(buffers);
 	}
+
+	return totalLength;
 };
 
 BitBuffer.prototype.appendSingleBuffer = function(buffer) {

src/decoder.js

@@ -5,6 +5,7 @@ var BaseDecoder = function(options) {
 	this.canPlay = false;
 
 	this.collectTimestamps = !options.streaming;
+	this.bytesWritten = 0;
 	this.timestamps = [];
 	this.timestampIndex = 0;
 
@@ -14,20 +15,34 @@ var BaseDecoder = function(options) {
 	Object.defineProperty(this, 'currentTime', {get: this.getCurrentTime});
 };
 
+BaseDecoder.prototype.destroy = function() {};
+
 BaseDecoder.prototype.connect = function(destination) {
 	this.destination = destination;
 };
 
+BaseDecoder.prototype.bufferGetIndex = function() {
+	return this.bits.index;
+};
+
+BaseDecoder.prototype.bufferSetIndex = function(index) {
+	this.bits.index = index;
+};
+
+BaseDecoder.prototype.bufferWrite = function(buffers) {
+	return this.bits.write(buffers);
+};
+
 BaseDecoder.prototype.write = function(pts, buffers) {
 	if (this.collectTimestamps) {
 		if (this.timestamps.length === 0) {
 			this.startTime = pts;
 			this.decodedTime = pts;
 		}
-		this.timestamps.push({index: this.bits.byteLength << 3, time: pts});
+		this.timestamps.push({index: this.bytesWritten << 3, time: pts});
 	}
 
-	this.bits.write(buffers);
+	this.bytesWritten += this.bufferWrite(buffers);
 	this.canPlay = true;
 };
 
@@ -46,11 +61,11 @@ BaseDecoder.prototype.seek = function(time) {
 
 	var ts = this.timestamps[this.timestampIndex];
 	if (ts) {
-		this.bits.index = ts.index;
+		this.bufferSetIndex(ts.index);
 		this.decodedTime = ts.time;
 	}
 	else {
-		this.bits.index = 0;
+		this.bufferSetIndex(0);
 		this.decodedTime = this.startTime;
 	}
 };
@@ -62,8 +77,9 @@ BaseDecoder.prototype.decode = function() {
 BaseDecoder.prototype.advanceDecodedTime = function(seconds) {
 	if (this.collectTimestamps) {
 		var newTimestampIndex = -1;
+		var currentIndex = this.bufferGetIndex();
 		for (var i = this.timestampIndex; i < this.timestamps.length; i++) {
-			if (this.timestamps[i].index > this.bits.index) {
+			if (this.timestamps[i].index > currentIndex) {
 				break;
 			}
 			newTimestampIndex = i;

src/jsmpeg.js

@@ -92,7 +92,23 @@ var JSMpeg = {
 				array[i] = value;
 			}
 		}
-	}
+	},
+
+	Base64ToArrayBuffer: function(base64) {
+		var binary =  window.atob(base64);
+		var length = binary.length;
+		var bytes = new Uint8Array(length);
+		for (var i = 0; i < length; i++)        {
+			bytes[i] = binary.charCodeAt(i);
+		}
+		return bytes.buffer;
+	},
+
+	// The build process may append `JSMpeg.WASM_BINARY_INLINED = base64data;` 
+	// to the minified source.
+	// If this property is present, jsmpeg will use the inlined binary data
+	// instead of trying to load a jsmpeg.wasm file via Ajax.
+	WASM_BINARY_INLINED: null
 };
 
 // Automatically create players for all found <div class="jsmpeg"/> elements.
@@ -103,3 +119,4 @@ else {
 	document.addEventListener('DOMContentLoaded', JSMpeg.CreateVideoElements);
 }
 
+

src/mp2-wasm.js

@@ -0,0 +1,106 @@
+JSMpeg.Decoder.MP2AudioWASM = (function(){ "use strict";
+
+// Based on kjmp2 by Martin J. Fiedler
+// http://keyj.emphy.de/kjmp2/
+
+var MP2WASM = function(options) {
+	JSMpeg.Decoder.Base.call(this, options);
+
+	this.module = options.wasmModule;
+
+	this.bufferSize = options.audioBufferSize || 128*1024;
+	this.bufferMode = options.streaming
+		? JSMpeg.BitBuffer.MODE.EVICT
+		: JSMpeg.BitBuffer.MODE.EXPAND;
+
+	this.sampleRate = 0;
+};
+
+MP2WASM.prototype = Object.create(JSMpeg.Decoder.Base.prototype);
+MP2WASM.prototype.constructor = MP2WASM;
+
+MP2WASM.prototype.initializeWasmDecoder = function() {
+	if (!this.module.instance) {
+		console.warn('JSMpeg: WASM module not compiled yet');
+		return;
+	}
+	this.instance = this.module.instance;
+	this.functions = this.module.instance.exports;
+	this.decoder = this.functions._mp2_decoder_create(this.bufferSize, this.bufferMode);
+};
+
+MP2WASM.prototype.destroy = function() {
+	this.functions._mp2_decoder_destroy(this.decoder);
+};
+
+MP2WASM.prototype.bufferGetIndex = function() {
+	return this.functions._mp2_decoder_get_index(this.decoder);
+};
+
+MP2WASM.prototype.bufferSetIndex = function(index) {
+	this.functions._mp2_decoder_set_index(this.decoder, index);
+};
+
+MP2WASM.prototype.bufferWrite = function(buffers) {
+	if (!this.decoder) {
+		this.initializeWasmDecoder();
+	}
+
+	var totalLength = 0;
+	for (var i = 0; i < buffers.length; i++) {
+		totalLength += buffers[i].length;
+	}
+
+	var ptr = this.functions._mp2_decoder_get_write_ptr(this.decoder, totalLength);
+	for (var i = 0; i < buffers.length; i++) {
+		this.instance.heapU8.set(buffers[i], ptr);
+		ptr += buffers[i].length;
+	}
+	
+	this.functions._mp2_decoder_did_write(this.decoder, totalLength);
+	return totalLength;
+};
+
+MP2WASM.prototype.decode = function() {
+	if (!this.decoder) { return; }
+	
+	var decodedBytes = this.functions._mp2_decoder_decode(this.decoder);
+
+	if (decodedBytes === 0) {
+		return false;
+	}
+
+	if (!this.sampleRate) {
+		this.sampleRate = this.functions._mp2_decoder_get_sample_rate(this.decoder);
+	}
+
+	if (this.destination) {
+		// Create a Float32 View into the modules output channel data
+		var leftPtr = this.functions._mp2_decoder_get_left_channel_ptr(this.decoder),
+			rightPtr = this.functions._mp2_decoder_get_right_channel_ptr(this.decoder);
+
+		var leftOffset = leftPtr / Float32Array.BYTES_PER_ELEMENT,
+			rightOffset = rightPtr / Float32Array.BYTES_PER_ELEMENT;
+
+		var left = this.instance.heapF32.subarray(leftOffset, leftOffset + MP2WASM.SAMPLES_PER_FRAME),
+			right = this.instance.heapF32.subarray(rightOffset, rightOffset + MP2WASM.SAMPLES_PER_FRAME);
+
+		this.destination.play(this.sampleRate, left, right);
+	}
+
+	this.advanceDecodedTime(MP2WASM.SAMPLES_PER_FRAME / this.sampleRate);
+	return true;
+};
+
+
+MP2WASM.prototype.getCurrentTime = function() {
+	var enqueuedTime = this.destination ? this.destination.enqueuedTime : 0;
+	return this.decodedTime - enqueuedTime;
+};
+
+MP2WASM.SAMPLES_PER_FRAME = 1152;
+
+return MP2WASM;
+
+})();
+

src/mpeg1-wasm.js

@@ -0,0 +1,115 @@
+JSMpeg.Decoder.MPEG1VideoWASM = (function(){ "use strict";
+
+var MPEG1WASM = function(options) {
+	JSMpeg.Decoder.Base.call(this, options);
+
+	this.module = options.wasmModule;
+
+	this.bufferSize = options.videoBufferSize || 512*1024;
+	this.bufferMode = options.streaming
+		? JSMpeg.BitBuffer.MODE.EVICT
+		: JSMpeg.BitBuffer.MODE.EXPAND;
+
+	this.decodeFirstFrame = options.decodeFirstFrame !== false;
+	this.hasSequenceHeader = false;
+};
+
+MPEG1WASM.prototype = Object.create(JSMpeg.Decoder.Base.prototype);
+MPEG1WASM.prototype.constructor = MPEG1WASM;
+
+MPEG1WASM.prototype.initializeWasmDecoder = function() {
+	if (!this.module.instance) {
+		console.warn('JSMpeg: WASM module not compiled yet');
+		return;
+	}
+	this.instance = this.module.instance;
+	this.functions = this.module.instance.exports;
+	this.decoder = this.functions._mpeg1_decoder_create(this.bufferSize, this.bufferMode);
+};
+
+MPEG1WASM.prototype.destroy = function() {
+	this.functions._mpeg1_decoder_destroy(this.decoder);
+};
+
+MPEG1WASM.prototype.bufferGetIndex = function() {
+	return this.functions._mpeg1_decoder_get_index(this.decoder);
+};
+
+MPEG1WASM.prototype.bufferSetIndex = function(index) {
+	this.functions._mpeg1_decoder_set_index(this.decoder, index);
+};
+
+MPEG1WASM.prototype.bufferWrite = function(buffers) {
+	if (!this.decoder) {
+		this.initializeWasmDecoder();
+	}
+
+	var totalLength = 0;
+	for (var i = 0; i < buffers.length; i++) {
+		totalLength += buffers[i].length;
+	}
+
+	var ptr = this.functions._mpeg1_decoder_get_write_ptr(this.decoder, totalLength);
+	for (var i = 0; i < buffers.length; i++) {
+		this.instance.heapU8.set(buffers[i], ptr);
+		ptr += buffers[i].length;
+	}
+	
+	this.functions._mpeg1_decoder_did_write(this.decoder, totalLength);
+	return totalLength;
+};
+
+MPEG1WASM.prototype.write = function(pts, buffers) {
+	JSMpeg.Decoder.Base.prototype.write.call(this, pts, buffers);
+
+	if (!this.hasSequenceHeader && this.functions._mpeg1_decoder_has_sequence_header(this.decoder)) {
+		this.loadSequnceHeader();
+	}
+};
+
+MPEG1WASM.prototype.loadSequnceHeader = function() {
+	this.hasSequenceHeader = true;
+	this.frameRate = this.functions._mpeg1_decoder_get_frame_rate(this.decoder);
+	this.codedSize = this.functions._mpeg1_decoder_get_coded_size(this.decoder);
+
+	if (this.destination) {
+		var w = this.functions._mpeg1_decoder_get_width(this.decoder);
+		var h = this.functions._mpeg1_decoder_get_height(this.decoder);
+		this.destination.resize(w, h);
+	}
+
+	if (this.decodeFirstFrame) {
+		this.decode();
+	}
+};
+
+MPEG1WASM.prototype.decode = function() {
+	if (!this.decoder) { return; }
+	
+	var didDecode = this.functions._mpeg1_decoder_decode(this.decoder);
+
+	if (!didDecode) {
+		return false;
+	}
+
+	// Invoke decode callbacks
+	if (this.destination) {
+		var ptrY = this.functions._mpeg1_decoder_get_y_ptr(this.decoder),
+			ptrCr = this.functions._mpeg1_decoder_get_cr_ptr(this.decoder),
+			ptrCb = this.functions._mpeg1_decoder_get_cb_ptr(this.decoder);
+
+		var dy = this.instance.heapU8.subarray(ptrY, ptrY + this.codedSize);
+		var dcr = this.instance.heapU8.subarray(ptrCr, ptrCr + (this.codedSize >> 2));
+		var dcb = this.instance.heapU8.subarray(ptrCb, ptrCb + (this.codedSize >> 2));
+
+		this.destination.render(dy, dcr, dcb, false);
+	}
+
+	this.advanceDecodedTime(1/this.frameRate);
+	return true;
+};
+
+return MPEG1WASM;
+
+})();
+

src/player.js

@@ -27,17 +27,28 @@ var Player = function(url, options) {
 	this.demuxer = new JSMpeg.Demuxer.TS(options);
 	this.source.connect(this.demuxer);
 
+	if (!options.disableWebAssembly && JSMpeg.WASMModule.IsSupported()) {
+		this.wasmModule = new JSMpeg.WASMModule();
+		options.wasmModule =this.wasmModule;
+	}
+
 	if (options.video !== false) {
-		this.video = new JSMpeg.Decoder.MPEG1Video(options);
+		this.video = options.wasmModule
+			? new JSMpeg.Decoder.MPEG1VideoWASM(options)
+			: new JSMpeg.Decoder.MPEG1Video(options);
+
 		this.renderer = !options.disableGl && JSMpeg.Renderer.WebGL.IsSupported()
 			? new JSMpeg.Renderer.WebGL(options)
 			: new JSMpeg.Renderer.Canvas2D(options);
+		
 		this.demuxer.connect(JSMpeg.Demuxer.TS.STREAM.VIDEO_1, this.video);
 		this.video.connect(this.renderer);
 	}
 
 	if (options.audio !== false && JSMpeg.AudioOutput.WebAudio.IsSupported()) {
-		this.audio = new JSMpeg.Decoder.MP2Audio(options);
+		this.audio = options.wasmModule
+			? new JSMpeg.Decoder.MP2AudioWASM(options)
+			: new JSMpeg.Decoder.MP2Audio(options);
 		this.audioOut = new JSMpeg.AudioOutput.WebAudio(options);
 		this.demuxer.connect(JSMpeg.Demuxer.TS.STREAM.AUDIO_1, this.audio);
 		this.audio.connect(this.audioOut);
@@ -57,8 +68,26 @@ var Player = function(url, options) {
 		document.addEventListener('visibilitychange', this.showHide.bind(this));
 	}
 
-	this.source.start();
+	// If we have WebAssembly support, wait until the module is compiled before
+	// loading the source. Otherwise the decoders won't know what to do with 
+	// the source data.
+	if (this.wasmModule) {
+		if (JSMpeg.WASM_BINARY_INLINED) {
+			var wasm = JSMpeg.Base64ToArrayBuffer(JSMpeg.WASM_BINARY_INLINED);
+			this.wasmModule.loadFromBuffer(wasm, this.startLoading.bind(this));
+		}
+		else {
+			this.wasmModule.loadFromFile('jsmpeg.wasm',  this.startLoading.bind(this));
+		}
+	}
+	else {
+		this.startLoading();
+		
+	}
+};
 
+Player.prototype.startLoading = function() {
+	this.source.start();
 	if (this.autoplay) {
 		this.play();
 	}
@@ -113,8 +142,10 @@ Player.prototype.stop = function(ev) {
 Player.prototype.destroy = function() {
 	this.pause();
 	this.source.destroy();
-	this.renderer.destroy();
-	this.audioOut.destroy();
+	this.video && this.video.destroy();
+	this.renderer && this.renderer.destroy();
+	this.audio && this.audio.destroy();
+	this.audioOut && this.audioOut.destroy();
 };
 
 Player.prototype.seek = function(time) {

src/wasm-module.js

@@ -0,0 +1,148 @@
+JSMpeg.WASMModule = (function(){ "use strict";
+
+var WASM = function() {
+	this.stackSize = 5 * 1024 * 1024; // emscripten default
+	this.pageSize = 64 * 1024; // wasm page size
+	this.onInitCallback = null;
+};
+
+WASM.prototype.write = function(buffer) {
+	this.loadFromBuffer(buffer, this.onInitCallback);
+};
+
+WASM.prototype.loadFromFile = function(url, callback) {
+	this.onInitCallback = callback;
+	var ajax = new JSMpeg.Source.Ajax(url);
+	ajax.connect(this);
+	ajax.start();
+};
+
+WASM.prototype.loadFromBuffer = function(buffer, callback) {
+	this.moduleInfo = this.readDylinkSection(buffer);
+	if (!this.moduleInfo) {
+		this.callback && this.callback(null);
+		return;
+	}
+
+	this.memory = new WebAssembly.Memory({initial: 256});
+	var env = {
+		memory: this.memory,
+		memoryBase: 0,
+		table: new WebAssembly.Table({initial: this.moduleInfo.tableSize, element: 'anyfunc'}),
+		tableBase: 0,
+		abort: this.c_abort.bind(this),
+		___assert_fail: this.c_assertFail.bind(this),
+		_sbrk: this.c_sbrk.bind(this)
+	};
+
+	this.brk = this.align(this.moduleInfo.memorySize + this.stackSize);
+	WebAssembly.instantiate(buffer, {env: env}).then(function(results){
+		this.instance = results.instance;
+		if (this.instance.exports.__post_instantiate) {
+			this.instance.exports.__post_instantiate();
+		}
+		this.createHeapViews();
+		callback && callback(this);
+	}.bind(this))
+};
+
+WASM.prototype.createHeapViews = function() {
+	this.instance.heapU8 = new Uint8Array(this.memory.buffer);
+	this.instance.heapU32 = new Uint32Array(this.memory.buffer);
+	this.instance.heapF32 = new Float32Array(this.memory.buffer);
+};
+
+WASM.prototype.align = function(addr) {
+	var a = Math.pow(2, this.moduleInfo.memoryAlignment);
+	return Math.ceil(addr / a) * a;
+};
+
+WASM.prototype.c_sbrk = function(size) {
+	var previousBrk = this.brk;
+	this.brk += size;
+
+	if (this.brk > this.memory.buffer.byteLength) {
+		var bytesNeeded = this.brk - this.memory.buffer.byteLength;
+		var pagesNeeded = Math.ceil(bytesNeeded / this.pageSize);
+		this.memory.grow(pagesNeeded);
+		this.createHeapViews();
+	}
+	return previousBrk;
+};
+
+WASM.prototype.c_abort = function(size) {
+	console.warn('JSMPeg: WASM abort', arguments);
+};
+
+WASM.prototype.c_assertFail = function(size) {
+	console.warn('JSMPeg: WASM ___assert_fail', arguments);
+};
+
+
+WASM.prototype.readDylinkSection = function(buffer) {
+	// Read the WASM header and dylink section of the .wasm binary data
+	// to get the needed table size and static data size.
+
+	// https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md
+	// https://github.com/kripken/emscripten/blob/20602efb955a7c6c20865a495932427e205651d2/src/support.js
+
+	var bytes = new Uint8Array(buffer);
+	var next = 0;
+
+	var readVarUint = function () {
+		var ret = 0;
+		var mul = 1;
+		while (1) {
+			var byte = bytes[next++];
+			ret += ((byte & 0x7f) * mul);
+			mul *= 0x80;
+			if (!(byte & 0x80)) {
+				return ret
+			}
+		}
+	}
+
+	var matchNextBytes = function(expected) {
+		for (var i = 0; i < expected.length; i++) {
+			var b = typeof(expected[i]) === 'string' 
+				? expected[i].charCodeAt(0)
+				: expected[i];
+			if (bytes[next++] !== b) {
+				return false;
+			}
+		}
+		return true;
+	};
+
+	
+
+	// Make sure we have a wasm header
+	if (!matchNextBytes([0, 'a', 's', 'm'])) {
+		console.warn('JSMpeg: WASM header not found');
+		return null;
+	}
+
+	// Make sure we have a dylink section
+	var next = 9;
+	var sectionSize = readVarUint();
+	if (!matchNextBytes([6, 'd', 'y', 'l', 'i', 'n', 'k'])) {
+		console.warn('JSMpeg: No dylink section found in WASM');
+		return null;
+	}
+
+	return {
+		memorySize: readVarUint(),
+		memoryAlignment: readVarUint(),
+		tableSize: readVarUint(),
+		tableAlignment: readVarUint()
+	};
+};
+
+WASM.IsSupported = function() {
+	return (!!window.WebAssembly);
+};
+
+return WASM;
+
+})();
+

src/wasm/buffer.c

@@ -0,0 +1,189 @@
+#include <string.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+#include "buffer.h"
+
+typedef struct bit_buffer_t {
+	uint8_t *bytes;
+	unsigned int index;
+	unsigned int byte_capacity;
+	unsigned int byte_length;
+	bit_buffer_mode_t mode;
+} bit_buffer_t;
+
+void bit_buffer_resize(bit_buffer_t *self, unsigned int byte_capacity);
+void bit_buffer_evict(bit_buffer_t *self, unsigned int bytes_needed);
+
+
+
+bit_buffer_t *bit_buffer_create(unsigned int initial_byte_capacity, bit_buffer_mode_t mode) {
+	bit_buffer_t *self = malloc(sizeof(bit_buffer_t));
+	self->mode = mode;
+	self->bytes = malloc(initial_byte_capacity);
+	self->byte_capacity = initial_byte_capacity;
+	self->byte_length = 0;
+	self->index = 0;
+	return self;
+}
+
+
+void bit_buffer_destroy(bit_buffer_t *self) {
+	free(self->bytes);
+	free(self);
+}
+
+
+int bit_buffer_get_index(bit_buffer_t *self) {
+	return self->index;
+}
+
+
+void bit_buffer_set_index(bit_buffer_t *self, unsigned int index) {
+	self->index = index; // TODO check validity!
+}
+
+
+uint8_t *bit_buffer_get_write_ptr(bit_buffer_t *self, unsigned int bytes_to_write) {
+	int bytes_available = self->byte_capacity - self->byte_length;
+
+	if (bytes_to_write > bytes_available) {
+		if (self->mode == BIT_BUFFER_MODE_EXPAND) {
+			int new_byte_capacity = self->byte_capacity * 2;
+			if (new_byte_capacity + bytes_available < bytes_to_write) {
+				new_byte_capacity = bytes_to_write - bytes_available;
+			}
+			bit_buffer_resize(self, new_byte_capacity);
+		}
+		else {
+			bit_buffer_evict(self, bytes_to_write);
+		}
+	}
+
+	return self->bytes + self->byte_length;
+};
+
+
+void bit_buffer_did_write(bit_buffer_t *self, unsigned int bytes_written) {
+	self->byte_length += bytes_written;
+}
+
+
+int bit_buffer_find_next_start_code(bit_buffer_t *self) {
+	for (int i = ((self->index + 7) >> 3); i < self->byte_length; i++) {
+		if(
+			self->bytes[i] == 0x00 &&
+			self->bytes[i+1] == 0x00 &&
+			self->bytes[i+2] == 0x01
+		) {
+			self->index = (i+4) << 3;
+			return self->bytes[i+3];
+		}
+	}
+	self->index = (self->byte_length << 3);
+	return -1;
+}
+
+
+int bit_buffer_find_start_code(bit_buffer_t *self, int code) {
+	int current = 0;
+	while (true) {
+		current = bit_buffer_find_next_start_code(self);
+		if (current == code || current == -1) {
+			return current;
+		}
+	}
+	return -1;
+}
+
+
+int bit_buffer_next_bytes_are_start_code(bit_buffer_t *self) {
+	int i = ((self->index + 7) >> 3);
+	return (
+		i >= self->byte_length || (
+			self->bytes[i] == 0x00 && 
+			self->bytes[i+1] == 0x00 &&
+			self->bytes[i+2] == 0x01
+		)
+	);
+}
+
+
+int bit_buffer_peek(bit_buffer_t *self, unsigned int count) {
+	int offset = self->index;
+	int value = 0;
+	while (count) {
+		int current_byte = self->bytes[offset >> 3];
+		int remaining = 8 - (offset & 7); // remaining bits in byte
+		int read = remaining < count ? remaining : count; // bits in self run
+		int shift = remaining - read;
+		int mask = (0xff >> (8-read));
+
+		value = (value << read) | ((current_byte & (mask << shift)) >> shift);
+
+		offset += read;
+		count -= read;
+	}
+
+	return value;
+}
+
+
+int bit_buffer_read(bit_buffer_t *self, unsigned int count) {
+	int value = bit_buffer_peek(self, count);
+	self->index += count;
+	return value;
+}
+
+
+int bit_buffer_skip(bit_buffer_t *self, unsigned int count) {
+	return (self->index += count);
+}
+
+
+void bit_buffer_rewind(bit_buffer_t *self, unsigned int count) {
+	self->index = self->index - count;
+	if (self->index < 0) {
+		self->index = 0;
+	}
+}
+
+
+int bit_buffer_has(bit_buffer_t *self, unsigned int count) {
+	return ((self->byte_length << 3) - self->index) >= count;
+}
+
+
+void bit_buffer_resize(bit_buffer_t *self, unsigned int byte_capacity) {
+	self->bytes = realloc(self->bytes, byte_capacity);
+	self->byte_capacity = byte_capacity;
+	if (self->index > self->byte_length << 3) {
+		self->index = self->byte_length << 3;
+	}
+}
+
+
+void bit_buffer_evict(bit_buffer_t *self, unsigned int bytes_needed) {
+	int byte_pos = self->index >> 3;
+	int bytes_available = self->byte_capacity - self->byte_length;
+	
+	// If the current index is the write position, we can simply reset both
+	// to 0. Also reset (and throw away yet unread data) if we won't be able
+	// to fit the new data in even after a normal eviction.
+	if (
+		byte_pos == self->byte_length ||
+		bytes_needed > bytes_available + byte_pos // emergency evac
+	) {
+		self->byte_length = 0;
+		self->index = 0;
+		return;
+	}
+	else if (byte_pos == 0) {
+		// Nothing read yet - we can't evict anything
+		return;
+	}
+
+	memmove(self->bytes, self->bytes + byte_pos, self->byte_length - byte_pos);
+	self->byte_length -= byte_pos;
+	self->index -= byte_pos << 3;
+}

src/wasm/buffer.h

@@ -0,0 +1,31 @@
+#ifndef BUFFER_H
+#define BUFFER_H
+
+#include <stdint.h>
+
+typedef struct bit_buffer_t bit_buffer_t;
+
+typedef enum {
+	BIT_BUFFER_MODE_EVICT = 1,
+	BIT_BUFFER_MODE_EXPAND = 2
+} bit_buffer_mode_t;
+
+
+bit_buffer_t *bit_buffer_create(unsigned int initial_byte_capacity, bit_buffer_mode_t mode);
+void bit_buffer_destroy(bit_buffer_t *self);
+
+int bit_buffer_get_index(bit_buffer_t *self);
+void bit_buffer_set_index(bit_buffer_t *self, unsigned int index);
+
+uint8_t *bit_buffer_get_write_ptr(bit_buffer_t *self, unsigned int bytes_to_write);
+void bit_buffer_did_write(bit_buffer_t *self, unsigned int bytes_written);
+int bit_buffer_find_next_start_code(bit_buffer_t *self);
+int bit_buffer_find_start_code(bit_buffer_t *self, int code);
+int bit_buffer_next_bytes_are_start_code(bit_buffer_t *self);
+int bit_buffer_peek(bit_buffer_t *self, unsigned int count);
+int bit_buffer_read(bit_buffer_t *self, unsigned int count);
+int bit_buffer_skip(bit_buffer_t *self, unsigned int count);
+int bit_buffer_has(bit_buffer_t *self, unsigned int count);
+void bit_buffer_rewind(bit_buffer_t *self, unsigned int count);
+
+#endif

src/wasm/mp2.c

@@ -0,0 +1,703 @@
+#include <string.h>
+#include <stdlib.h>
+#include "mp2.h"
+
+const static int FRAME_SYNC = 0x7ff;
+
+const static int VERSION_MPEG_2_5 = 0x0;
+const static int VERSION_MPEG_2 = 0x2;
+const static int VERSION_MPEG_1 = 0x3;
+
+const static int LAYER_III = 0x1;
+const static int LAYER_II = 0x2;
+const static int LAYER_I = 0x3;
+
+const static int MODE_STEREO = 0x0;
+const static int MODE_JOINT_STEREO = 0x1;
+const static int MODE_DUAL_CHANNEL = 0x2;
+const static int MODE_MONO = 0x3;
+
+const static unsigned short SAMPLE_RATE[] = {
+	44100, 48000, 32000, 0, // MPEG-1
+	22050, 24000, 16000, 0  // MPEG-2
+};
+
+const static short BIT_RATE[] = {
+	32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, // MPEG-1
+	 8, 16, 24, 32, 40, 48,  56,  64,  80,  96, 112, 128, 144, 160  // MPEG-2
+};
+
+const static int SCALEFACTOR_BASE[] = {
+	0x02000000, 0x01965FEA, 0x01428A30
+};
+
+const static float SYNTHESIS_WINDOW[] = {
+	     0.0,     -0.5,     -0.5,     -0.5,     -0.5,     -0.5,
+	    -0.5,     -1.0,     -1.0,     -1.0,     -1.0,     -1.5,
+	    -1.5,     -2.0,     -2.0,     -2.5,     -2.5,     -3.0,
+	    -3.5,     -3.5,     -4.0,     -4.5,     -5.0,     -5.5,
+	    -6.5,     -7.0,     -8.0,     -8.5,     -9.5,    -10.5,
+	   -12.0,    -13.0,    -14.5,    -15.5,    -17.5,    -19.0,
+	   -20.5,    -22.5,    -24.5,    -26.5,    -29.0,    -31.5,
+	   -34.0,    -36.5,    -39.5,    -42.5,    -45.5,    -48.5,
+	   -52.0,    -55.5,    -58.5,    -62.5,    -66.0,    -69.5,
+	   -73.5,    -77.0,    -80.5,    -84.5,    -88.0,    -91.5,
+	   -95.0,    -98.0,   -101.0,   -104.0,    106.5,    109.0,
+	   111.0,    112.5,    113.5,    114.0,    114.0,    113.5,
+	   112.0,    110.5,    107.5,    104.0,    100.0,     94.5,
+	    88.5,     81.5,     73.0,     63.5,     53.0,     41.5,
+	    28.5,     14.5,     -1.0,    -18.0,    -36.0,    -55.5,
+	   -76.5,    -98.5,   -122.0,   -147.0,   -173.5,   -200.5,
+	  -229.5,   -259.5,   -290.5,   -322.5,   -355.5,   -389.5,
+	  -424.0,   -459.5,   -495.5,   -532.0,   -568.5,   -605.0,
+	  -641.5,   -678.0,   -714.0,   -749.0,   -783.5,   -817.0,
+	  -849.0,   -879.5,   -908.5,   -935.0,   -959.5,   -981.0,
+	 -1000.5,  -1016.0,  -1028.5,  -1037.5,  -1042.5,  -1043.5,
+	 -1040.0,  -1031.5,   1018.5,   1000.0,    976.0,    946.5,
+	   911.0,    869.5,    822.0,    767.5,    707.0,    640.0,
+	   565.5,    485.0,    397.0,    302.5,    201.0,     92.5,
+	   -22.5,   -144.0,   -272.5,   -407.0,   -547.5,   -694.0,
+	  -846.0,  -1003.0,  -1165.0,  -1331.5,  -1502.0,  -1675.5,
+	 -1852.5,  -2031.5,  -2212.5,  -2394.0,  -2576.5,  -2758.5,
+	 -2939.5,  -3118.5,  -3294.5,  -3467.5,  -3635.5,  -3798.5,
+	 -3955.0,  -4104.5,  -4245.5,  -4377.5,  -4499.0,  -4609.5,
+	 -4708.0,  -4792.5,  -4863.5,  -4919.0,  -4958.0,  -4979.5,
+	 -4983.0,  -4967.5,  -4931.5,  -4875.0,  -4796.0,  -4694.5,
+	 -4569.5,  -4420.0,  -4246.0,  -4046.0,  -3820.0,  -3567.0,
+	  3287.0,   2979.5,   2644.0,   2280.5,   1888.0,   1467.5,
+	  1018.5,    541.0,     35.0,   -499.0,  -1061.0,  -1650.0,
+	 -2266.5,  -2909.0,  -3577.0,  -4270.0,  -4987.5,  -5727.5,
+	 -6490.0,  -7274.0,  -8077.5,  -8899.5,  -9739.0, -10594.5,
+	-11464.5, -12347.0, -13241.0, -14144.5, -15056.0, -15973.5,
+	-16895.5, -17820.0, -18744.5, -19668.0, -20588.0, -21503.0,
+	-22410.5, -23308.5, -24195.0, -25068.5, -25926.5, -26767.0,
+	-27589.0, -28389.0, -29166.5, -29919.0, -30644.5, -31342.0,
+	-32009.5, -32645.0, -33247.0, -33814.5, -34346.0, -34839.5,
+	-35295.0, -35710.0, -36084.5, -36417.5, -36707.5, -36954.0,
+	-37156.5, -37315.0, -37428.0, -37496.0,  37519.0,  37496.0,
+	 37428.0,  37315.0,  37156.5,  36954.0,  36707.5,  36417.5,
+	 36084.5,  35710.0,  35295.0,  34839.5,  34346.0,  33814.5,
+	 33247.0,  32645.0,  32009.5,  31342.0,  30644.5,  29919.0,
+	 29166.5,  28389.0,  27589.0,  26767.0,  25926.5,  25068.5,
+	 24195.0,  23308.5,  22410.5,  21503.0,  20588.0,  19668.0,
+	 18744.5,  17820.0,  16895.5,  15973.5,  15056.0,  14144.5,
+	 13241.0,  12347.0,  11464.5,  10594.5,   9739.0,   8899.5,
+	  8077.5,   7274.0,   6490.0,   5727.5,   4987.5,   4270.0,
+	  3577.0,   2909.0,   2266.5,   1650.0,   1061.0,    499.0,
+	   -35.0,   -541.0,  -1018.5,  -1467.5,  -1888.0,  -2280.5,
+	 -2644.0,  -2979.5,   3287.0,   3567.0,   3820.0,   4046.0,
+	  4246.0,   4420.0,   4569.5,   4694.5,   4796.0,   4875.0,
+	  4931.5,   4967.5,   4983.0,   4979.5,   4958.0,   4919.0,
+	  4863.5,   4792.5,   4708.0,   4609.5,   4499.0,   4377.5,
+	  4245.5,   4104.5,   3955.0,   3798.5,   3635.5,   3467.5,
+	  3294.5,   3118.5,   2939.5,   2758.5,   2576.5,   2394.0,
+	  2212.5,   2031.5,   1852.5,   1675.5,   1502.0,   1331.5,
+	  1165.0,   1003.0,    846.0,    694.0,    547.5,    407.0,
+	   272.5,    144.0,     22.5,    -92.5,   -201.0,   -302.5,
+	  -397.0,   -485.0,   -565.5,   -640.0,   -707.0,   -767.5,
+	  -822.0,   -869.5,   -911.0,   -946.5,   -976.0,  -1000.0,
+	  1018.5,   1031.5,   1040.0,   1043.5,   1042.5,   1037.5,
+	  1028.5,   1016.0,   1000.5,    981.0,    959.5,    935.0,
+	   908.5,    879.5,    849.0,    817.0,    783.5,    749.0,
+	   714.0,    678.0,    641.5,    605.0,    568.5,    532.0,
+	   495.5,    459.5,    424.0,    389.5,    355.5,    322.5,
+	   290.5,    259.5,    229.5,    200.5,    173.5,    147.0,
+	   122.0,     98.5,     76.5,     55.5,     36.0,     18.0,
+		1.0,    -14.5,    -28.5,    -41.5,    -53.0,    -63.5,
+	   -73.0,    -81.5,    -88.5,    -94.5,   -100.0,   -104.0,
+	  -107.5,   -110.5,   -112.0,   -113.5,   -114.0,   -114.0,
+	  -113.5,   -112.5,   -111.0,   -109.0,    106.5,    104.0,
+	   101.0,     98.0,     95.0,     91.5,     88.0,     84.5,
+	    80.5,     77.0,     73.5,     69.5,     66.0,     62.5,
+	    58.5,     55.5,     52.0,     48.5,     45.5,     42.5,
+	    39.5,     36.5,     34.0,     31.5,     29.0,     26.5,
+	    24.5,     22.5,     20.5,     19.0,     17.5,     15.5,
+	    14.5,     13.0,     12.0,     10.5,      9.5,      8.5,
+	     8.0,      7.0,      6.5,      5.5,      5.0,      4.5,
+	     4.0,      3.5,      3.5,      3.0,      2.5,      2.5,
+	     2.0,      2.0,      1.5,      1.5,      1.0,      1.0,
+	     1.0,      1.0,      0.5,      0.5,      0.5,      0.5,
+	     0.5,      0.5
+};
+
+// Quantizer lookup, step 1: bitrate classes
+const static uint8_t QUANT_LUT_STEP_1[2][16] = {
+ 	// 32, 48, 56, 64, 80, 96,112,128,160,192,224,256,320,384 <- bitrate
+	{   0,  0,  1,  1,  1,  2,  2,  2,  2,  2,  2,  2,  2,  2}, // mono
+	// 16, 24, 28, 32, 40, 48, 56, 64, 80, 96,112,128,160,192 <- bitrate / chan
+	{   0,  0,  0,  0,  0,  0,  1,  1,  1,  2,  2,  2,  2,  2} // stereo
+};
+
+// Quantizer lookup, step 2: bitrate class, sample rate -> B2 table idx, sblimit
+const static uint8_t QUANT_TAB_A = (27 | 64);   // Table 3-B.2a: high-rate, sblimit = 27
+const static uint8_t QUANT_TAB_B = (30 | 64);   // Table 3-B.2b: high-rate, sblimit = 30
+const static uint8_t QUANT_TAB_C =   8;         // Table 3-B.2c:  low-rate, sblimit =  8
+const static uint8_t QUANT_TAB_D =  12;         // Table 3-B.2d:  low-rate, sblimit = 12
+
+const static uint8_t QUANT_LUT_STEP_2[3][3] = {
+	// 44.1 kHz,    48 kHz,      32 kHz
+	{QUANT_TAB_C, QUANT_TAB_C, QUANT_TAB_D}, // 32 - 48 kbit/sec/ch
+	{QUANT_TAB_A, QUANT_TAB_A, QUANT_TAB_A}, // 56 - 80 kbit/sec/ch
+	{QUANT_TAB_B, QUANT_TAB_A, QUANT_TAB_B}  // 96+	 kbit/sec/ch
+};
+
+// Quantizer lookup, step 3: B2 table, subband -> nbal, row index
+// (upper 4 bits: nbal, lower 4 bits: row index)
+const static uint8_t QUANT_LUT_STEP_3[3][32] = {
+	// Low-rate table (3-B.2c and 3-B.2d)
+	{
+		0x44,0x44,
+	  	0x34,0x34,0x34,0x34,0x34,0x34,0x34,0x34,0x34,0x34
+	},
+	// High-rate table (3-B.2a and 3-B.2b)
+	{
+		0x43,0x43,0x43,
+		0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x42,
+		0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,
+		0x20,0x20,0x20,0x20,0x20,0x20,0x20
+	},
+	// MPEG-2 LSR table (B.2 in ISO 13818-3)
+	{
+		0x45,0x45,0x45,0x45,
+		0x34,0x34,0x34,0x34,0x34,0x34,0x34,
+		0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,
+					   0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24	
+	}
+};
+
+// Quantizer lookup, step 4: table row, allocation[] value -> quant table index
+const static uint8_t QUANT_LUT_STEP4[6][16] = {
+	{0, 1, 2, 17},
+	{0, 1, 2, 3, 4, 5, 6, 17},
+	{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17},
+	{0, 1, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17},
+	{0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17},
+	{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
+};
+
+typedef struct quantizer_spec_t {
+	unsigned short levels;
+	unsigned char group;
+	unsigned char bits;
+} quantizer_spec_t;
+
+const static quantizer_spec_t QUANT_TAB[] = {
+	{.levels =     3, .group = 1, .bits =  5},  //  1
+	{.levels =     5, .group = 1, .bits =  7},  //  2
+	{.levels =     7, .group = 0, .bits =  3},  //  3
+	{.levels =     9, .group = 1, .bits = 10},  //  4
+	{.levels =    15, .group = 0, .bits =  4},  //  5
+	{.levels =    31, .group = 0, .bits =  5},  //  6
+	{.levels =    63, .group = 0, .bits =  6},  //  7
+	{.levels =   127, .group = 0, .bits =  7},  //  8
+	{.levels =   255, .group = 0, .bits =  8},  //  9
+	{.levels =   511, .group = 0, .bits =  9},  // 10
+	{.levels =  1023, .group = 0, .bits = 10},  // 11
+	{.levels =  2047, .group = 0, .bits = 11},  // 12
+	{.levels =  4095, .group = 0, .bits = 12},  // 13
+	{.levels =  8191, .group = 0, .bits = 13},  // 14
+	{.levels = 16383, .group = 0, .bits = 14},  // 15
+	{.levels = 32767, .group = 0, .bits = 15},  // 16
+	{.levels = 65535, .group = 0, .bits = 16}   // 17
+};
+
+#define SAMPLES_PER_FRAME 1152
+
+typedef struct mp2_decoder_t {
+	int sample_rate;
+	int v_pos;
+
+	bit_buffer_t *bits;
+
+	const quantizer_spec_t *allocation[2][32];
+	uint8_t scale_factor_info[2][32];
+	int scale_factor[2][32][3];
+	int sample[2][32][3];
+
+	float channel_left[SAMPLES_PER_FRAME];
+	float channel_right[SAMPLES_PER_FRAME];
+	float D[1024];
+	float V[1024];
+	int U[32];
+} mp2_decoder_t;
+
+
+void matrix_transform(int s[32][3], int ss, float *d, int dp);
+void read_samples(mp2_decoder_t *self, int ch, int sb, int part);
+const quantizer_spec_t *read_allocation(mp2_decoder_t *self, int sb, int tab3);
+int decode_frame(mp2_decoder_t *self);
+
+
+// -----------------------------------------------------------------------------
+// Public interface
+
+mp2_decoder_t *mp2_decoder_create(unsigned int buffer_size, bit_buffer_mode_t buffer_mode) {
+	mp2_decoder_t *self = malloc(sizeof(mp2_decoder_t));
+	self->bits = bit_buffer_create(buffer_size, buffer_mode);
+
+	self->sample_rate = 44100;
+	memcpy(self->D, SYNTHESIS_WINDOW, 512 * sizeof(float));
+	memcpy(self->D + 512, SYNTHESIS_WINDOW, 512 * sizeof(float));
+
+	return self;
+}
+
+void mp2_decoder_destroy(mp2_decoder_t *self) {
+	bit_buffer_destroy(self->bits);
+	free(self);
+}
+
+void *mp2_decoder_get_write_ptr(mp2_decoder_t *self, unsigned int byte_size) {
+	return bit_buffer_get_write_ptr(self->bits, byte_size);
+}
+
+int mp2_decoder_get_index(mp2_decoder_t *self) {
+	return bit_buffer_get_index(self->bits);
+}
+
+void mp2_decoder_set_index(mp2_decoder_t *self, unsigned int index) {
+	bit_buffer_set_index(self->bits, index);
+}
+
+void mp2_decoder_did_write(mp2_decoder_t *self, unsigned int byte_size) {
+	bit_buffer_did_write(self->bits, byte_size);
+}
+
+int mp2_decoder_get_sample_rate(mp2_decoder_t *self) {
+	return self->sample_rate;
+}
+
+void *mp2_decoder_get_left_channel_ptr(mp2_decoder_t *self) {
+	return self->channel_left;
+}
+
+void *mp2_decoder_get_right_channel_ptr(mp2_decoder_t *self) {
+	return self->channel_right;
+}
+
+int mp2_decoder_decode(mp2_decoder_t *self) {
+	int byte_pos = bit_buffer_get_index(self->bits) >> 3;
+
+	if (!bit_buffer_has(self->bits, 16)) {
+		return 0;
+	}
+
+	int decoded_bytes = decode_frame(self);
+	bit_buffer_set_index(self->bits, (byte_pos + decoded_bytes) << 3);
+	return decoded_bytes;
+}
+
+
+
+
+int decode_frame(mp2_decoder_t *self) {
+	// Check for valid header: syncword OK, MPEG-Audio Layer 2
+	int sync = bit_buffer_read(self->bits, 11);
+	int version = bit_buffer_read(self->bits, 2);
+	int layer = bit_buffer_read(self->bits, 2);
+	int hasCRC = !bit_buffer_read(self->bits, 1);
+
+	if (
+		sync != FRAME_SYNC ||
+		version != VERSION_MPEG_1 ||
+		layer != LAYER_II
+	) {
+		return 0; // Invalid header or unsupported version
+	}
+
+	int bitrate_index = bit_buffer_read(self->bits, 4) - 1;
+	if (bitrate_index > 13) {
+		return 0;  // Invalid bit rate or 'free format'
+	}
+
+	int sample_rate_index = bit_buffer_read(self->bits, 2);
+	int sample_rate = SAMPLE_RATE[sample_rate_index];
+	if (sample_rate_index == 3) {
+		return 0; // Invalid sample rate
+	}
+	if (version == VERSION_MPEG_2) {
+		sample_rate_index += 4;
+		bitrate_index += 14;
+	}
+	int padding = bit_buffer_read(self->bits, 1),
+		privat = bit_buffer_read(self->bits, 1),
+		mode = bit_buffer_read(self->bits, 2);
+
+	// Parse the mode_extension, set up the stereo bound
+	int bound = 0;
+	if (mode == MODE_JOINT_STEREO) {
+		bound = (bit_buffer_read(self->bits, 2) + 1) << 2;
+	}
+	else {
+		bit_buffer_skip(self->bits, 2);
+		bound = (mode == MODE_MONO) ? 0 : 32;
+	}
+
+	// Discard the last 4 bits of the header and the CRC value, if present
+	bit_buffer_skip(self->bits, 4);
+	if (hasCRC) {
+		bit_buffer_skip(self->bits, 16);
+	}
+
+	// Compute the frame size
+	int bitrate = BIT_RATE[bitrate_index];
+	sample_rate = SAMPLE_RATE[sample_rate_index];
+	int frame_size = ((144000 * bitrate / sample_rate) + padding)|0;
+	
+
+	// Prepare the quantizer table lookups
+	int tab3 = 0;
+	int sblimit = 0;
+	if (version == VERSION_MPEG_2) {
+		// MPEG-2 (LSR)
+		tab3 = 2;
+		sblimit = 30;
+	}
+	else {
+		// MPEG-1
+		int tab1 = (mode == MODE_MONO) ? 0 : 1;
+		int tab2 = QUANT_LUT_STEP_1[tab1][bitrate_index];
+		tab3 = QUANT_LUT_STEP_2[tab2][sample_rate_index];
+		sblimit = tab3 & 63;
+		tab3 >>= 6;
+	}
+
+	if (bound > sblimit) {
+		bound = sblimit;
+	}
+
+	// Read the allocation information
+	for (int sb = 0; sb < bound; sb++) {
+		self->allocation[0][sb] = read_allocation(self, sb, tab3);
+		self->allocation[1][sb] = read_allocation(self, sb, tab3);
+	}
+
+	for (int sb = bound; sb < sblimit; sb++) {
+		self->allocation[0][sb] = 
+			self->allocation[1][sb] =
+			read_allocation(self, sb, tab3);
+	}
+
+	// Read scale factor selector information
+	int channels = (mode == MODE_MONO) ? 1 : 2;
+	for (int sb = 0;  sb < sblimit; sb++) {
+		for (int ch = 0;  ch < channels; ch++) {
+			if (self->allocation[ch][sb]) {
+				self->scale_factor_info[ch][sb] = bit_buffer_read(self->bits, 2);
+			}
+		}
+		if (mode == MODE_MONO) {
+			self->scale_factor_info[1][sb] = self->scale_factor_info[0][sb];
+		}
+	}
+
+	// Read scale factors
+	for (int sb = 0;  sb < sblimit; sb++) {
+		for (int ch = 0;  ch < channels; ch++) {
+			if (self->allocation[ch][sb]) {
+				int *sf = self->scale_factor[ch][sb];
+				switch (self->scale_factor_info[ch][sb]) {
+					case 0:
+						sf[0] = bit_buffer_read(self->bits, 6);
+						sf[1] = bit_buffer_read(self->bits, 6);
+						sf[2] = bit_buffer_read(self->bits, 6);
+						break;
+					case 1:
+						sf[0] =
+						sf[1] = bit_buffer_read(self->bits, 6);
+						sf[2] = bit_buffer_read(self->bits, 6);
+						break;
+					case 2:
+						sf[0] =
+						sf[1] =
+						sf[2] = bit_buffer_read(self->bits, 6);
+						break;
+					case 3:
+						sf[0] = bit_buffer_read(self->bits, 6);
+						sf[1] =
+						sf[2] = bit_buffer_read(self->bits, 6);
+						break;
+				}
+			}
+		}
+		if (mode == MODE_MONO) {
+			self->scale_factor[1][sb][0] = self->scale_factor[0][sb][0];
+			self->scale_factor[1][sb][1] = self->scale_factor[0][sb][1];
+			self->scale_factor[1][sb][2] = self->scale_factor[0][sb][2];
+		}
+	}
+
+	// Coefficient input and reconstruction
+	int out_pos = 0;
+	for (int part = 0; part < 3; part++) {
+		for (int granule = 0; granule < 4; granule++) {
+
+			// Read the samples
+			for (int sb = 0; sb < bound; sb++) {
+				read_samples(self, 0, sb, part);
+				read_samples(self, 1, sb, part);
+			}
+			for (int sb = bound; sb < sblimit; sb++) {
+				read_samples(self, 0, sb, part);
+				self->sample[1][sb][0] = self->sample[0][sb][0];
+				self->sample[1][sb][1] = self->sample[0][sb][1];
+				self->sample[1][sb][2] = self->sample[0][sb][2];
+			}
+			for (int sb = sblimit; sb < 32; sb++) {
+				self->sample[0][sb][0] = 0;
+				self->sample[0][sb][1] = 0;
+				self->sample[0][sb][2] = 0;
+				self->sample[1][sb][0] = 0;
+				self->sample[1][sb][1] = 0;
+				self->sample[1][sb][2] = 0;
+			}
+
+			// Synthesis loop
+			for (int p = 0; p < 3; p++) {
+				// Shifting step
+				self->v_pos = (self->v_pos - 64) & 1023;
+
+				for (int ch = 0;  ch < 2; ch++) {
+					matrix_transform(self->sample[ch], p, self->V, self->v_pos);
+
+					// Build U, windowing, calculate output
+					memset(self->U, 0, sizeof(self->U));
+
+					int d_index = 512 - (self->v_pos >> 1);
+					int v_index = (self->v_pos % 128) >> 1;
+					while (v_index < 1024) {
+						for (int i = 0; i < 32; ++i) {
+							self->U[i] += self->D[d_index++] * self->V[v_index++];
+						}
+
+						v_index += 128-32;
+						d_index += 64-32;
+					}
+
+					v_index = (128-32 + 1024) - v_index;
+					d_index -= (512 - 32);
+					while (v_index < 1024) {
+						for (int i = 0; i < 32; ++i) {
+							self->U[i] += self->D[d_index++] * self->V[v_index++];
+						}
+
+						v_index += 128-32;
+						d_index += 64-32;
+					}
+
+					// Output samples
+					float *out_channel = ch == 0 
+						? self->channel_left 
+						: self->channel_right;
+					for (int j = 0; j < 32; j++) {
+						out_channel[out_pos + j] = (float)self->U[j] / 2147418112.0;
+					}
+				} // End of synthesis channel loop
+				out_pos += 32;
+			} // End of synthesis sub-block loop
+
+		} // Decoding of the granule finished
+	}
+
+	self->sample_rate = sample_rate;
+	return frame_size;
+}
+
+const quantizer_spec_t *read_allocation(mp2_decoder_t *self, int sb, int tab3) {
+	int tab4 = QUANT_LUT_STEP_3[tab3][sb];
+	int qtab = QUANT_LUT_STEP4[tab4 & 15][bit_buffer_read(self->bits, tab4 >> 4)];
+	return qtab ? (&QUANT_TAB[qtab - 1]) : 0;
+}
+
+void read_samples(mp2_decoder_t *self, int ch, int sb, int part) {
+	const quantizer_spec_t *q = self->allocation[ch][sb];
+	int sf = self->scale_factor[ch][sb][part];
+	int *sample = self->sample[ch][sb];
+	int val = 0;
+
+	if (!q) {
+		// No bits allocated for this subband
+		sample[0] = sample[1] = sample[2] = 0;
+		return;
+	}
+
+	// Resolve scalefactor
+	if (sf == 63) {
+		sf = 0;
+	}
+	else {
+		int shift = (sf / 3)|0;
+		sf = (SCALEFACTOR_BASE[sf % 3] + ((1 << shift) >> 1)) >> shift;
+	}
+
+	// Decode samples
+	int adj = q->levels;
+	if (q->group) {
+		// Decode grouped samples
+		val = bit_buffer_read(self->bits, q->bits);
+		sample[0] = val % adj;
+		val /= adj;
+		sample[1] = val % adj;
+		sample[2] = val / adj;
+	}
+	else {
+		// Decode direct samples
+		sample[0] = bit_buffer_read(self->bits, q->bits);
+		sample[1] = bit_buffer_read(self->bits, q->bits);
+		sample[2] = bit_buffer_read(self->bits, q->bits);
+	}
+
+	// Postmultiply samples
+	int scale = 65536 / (adj + 1);
+	adj = ((adj + 1) >> 1) - 1;
+
+	val = (adj - sample[0]) * scale;
+	sample[0] = (val * (sf >> 12) + ((val * (sf & 4095) + 2048) >> 12)) >> 12;
+
+	val = (adj - sample[1]) * scale;
+	sample[1] = (val * (sf >> 12) + ((val * (sf & 4095) + 2048) >> 12)) >> 12;
+
+	val = (adj - sample[2]) * scale;
+	sample[2] = (val * (sf >> 12) + ((val * (sf & 4095) + 2048) >> 12)) >> 12;
+}
+
+void matrix_transform(int s[32][3], int ss, float *d, int dp) {
+	float t01, t02, t03, t04, t05, t06, t07, t08, t09, t10, t11, t12,
+		t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23, t24,
+		t25, t26, t27, t28, t29, t30, t31, t32, t33;
+
+	t01 = s[ 0][ss] + s[31][ss]; t02 = (float)(s[ 0][ss] - s[31][ss]) * 0.500602998235;
+	t03 = s[ 1][ss] + s[30][ss]; t04 = (float)(s[ 1][ss] - s[30][ss]) * 0.505470959898;
+	t05 = s[ 2][ss] + s[29][ss]; t06 = (float)(s[ 2][ss] - s[29][ss]) * 0.515447309923;
+	t07 = s[ 3][ss] + s[28][ss]; t08 = (float)(s[ 3][ss] - s[28][ss]) * 0.53104259109;
+	t09 = s[ 4][ss] + s[27][ss]; t10 = (float)(s[ 4][ss] - s[27][ss]) * 0.553103896034;
+	t11 = s[ 5][ss] + s[26][ss]; t12 = (float)(s[ 5][ss] - s[26][ss]) * 0.582934968206;
+	t13 = s[ 6][ss] + s[25][ss]; t14 = (float)(s[ 6][ss] - s[25][ss]) * 0.622504123036;
+	t15 = s[ 7][ss] + s[24][ss]; t16 = (float)(s[ 7][ss] - s[24][ss]) * 0.674808341455;
+	t17 = s[ 8][ss] + s[23][ss]; t18 = (float)(s[ 8][ss] - s[23][ss]) * 0.744536271002;
+	t19 = s[ 9][ss] + s[22][ss]; t20 = (float)(s[ 9][ss] - s[22][ss]) * 0.839349645416;
+	t21 = s[10][ss] + s[21][ss]; t22 = (float)(s[10][ss] - s[21][ss]) * 0.972568237862;
+	t23 = s[11][ss] + s[20][ss]; t24 = (float)(s[11][ss] - s[20][ss]) * 1.16943993343;
+	t25 = s[12][ss] + s[19][ss]; t26 = (float)(s[12][ss] - s[19][ss]) * 1.48416461631;
+	t27 = s[13][ss] + s[18][ss]; t28 = (float)(s[13][ss] - s[18][ss]) * 2.05778100995;
+	t29 = s[14][ss] + s[17][ss]; t30 = (float)(s[14][ss] - s[17][ss]) * 3.40760841847;
+	t31 = s[15][ss] + s[16][ss]; t32 = (float)(s[15][ss] - s[16][ss]) * 10.1900081235;
+
+	t33 = t01 + t31; t31 = (t01 - t31) * 0.502419286188;
+	t01 = t03 + t29; t29 = (t03 - t29) * 0.52249861494;
+	t03 = t05 + t27; t27 = (t05 - t27) * 0.566944034816;
+	t05 = t07 + t25; t25 = (t07 - t25) * 0.64682178336;
+	t07 = t09 + t23; t23 = (t09 - t23) * 0.788154623451;
+	t09 = t11 + t21; t21 = (t11 - t21) * 1.06067768599;
+	t11 = t13 + t19; t19 = (t13 - t19) * 1.72244709824;
+	t13 = t15 + t17; t17 = (t15 - t17) * 5.10114861869;
+	t15 = t33 + t13; t13 = (t33 - t13) * 0.509795579104;
+	t33 = t01 + t11; t01 = (t01 - t11) * 0.601344886935;
+	t11 = t03 + t09; t09 = (t03 - t09) * 0.899976223136;
+	t03 = t05 + t07; t07 = (t05 - t07) * 2.56291544774;
+	t05 = t15 + t03; t15 = (t15 - t03) * 0.541196100146;
+	t03 = t33 + t11; t11 = (t33 - t11) * 1.30656296488;
+	t33 = t05 + t03; t05 = (t05 - t03) * 0.707106781187;
+	t03 = t15 + t11; t15 = (t15 - t11) * 0.707106781187;
+	t03 += t15;
+	t11 = t13 + t07; t13 = (t13 - t07) * 0.541196100146;
+	t07 = t01 + t09; t09 = (t01 - t09) * 1.30656296488;
+	t01 = t11 + t07; t07 = (t11 - t07) * 0.707106781187;
+	t11 = t13 + t09; t13 = (t13 - t09) * 0.707106781187;
+	t11 += t13; t01 += t11; 
+	t11 += t07; t07 += t13;
+	t09 = t31 + t17; t31 = (t31 - t17) * 0.509795579104;
+	t17 = t29 + t19; t29 = (t29 - t19) * 0.601344886935;
+	t19 = t27 + t21; t21 = (t27 - t21) * 0.899976223136;
+	t27 = t25 + t23; t23 = (t25 - t23) * 2.56291544774;
+	t25 = t09 + t27; t09 = (t09 - t27) * 0.541196100146;
+	t27 = t17 + t19; t19 = (t17 - t19) * 1.30656296488;
+	t17 = t25 + t27; t27 = (t25 - t27) * 0.707106781187;
+	t25 = t09 + t19; t19 = (t09 - t19) * 0.707106781187;
+	t25 += t19;
+	t09 = t31 + t23; t31 = (t31 - t23) * 0.541196100146;
+	t23 = t29 + t21; t21 = (t29 - t21) * 1.30656296488;
+	t29 = t09 + t23; t23 = (t09 - t23) * 0.707106781187;
+	t09 = t31 + t21; t31 = (t31 - t21) * 0.707106781187;
+	t09 += t31;	t29 += t09;	t09 += t23;	t23 += t31;
+	t17 += t29;	t29 += t25;	t25 += t09;	t09 += t27;
+	t27 += t23;	t23 += t19; t19 += t31;	
+	t21 = t02 + t32; t02 = (t02 - t32) * 0.502419286188;
+	t32 = t04 + t30; t04 = (t04 - t30) * 0.52249861494;
+	t30 = t06 + t28; t28 = (t06 - t28) * 0.566944034816;
+	t06 = t08 + t26; t08 = (t08 - t26) * 0.64682178336;
+	t26 = t10 + t24; t10 = (t10 - t24) * 0.788154623451;
+	t24 = t12 + t22; t22 = (t12 - t22) * 1.06067768599;
+	t12 = t14 + t20; t20 = (t14 - t20) * 1.72244709824;
+	t14 = t16 + t18; t16 = (t16 - t18) * 5.10114861869;
+	t18 = t21 + t14; t14 = (t21 - t14) * 0.509795579104;
+	t21 = t32 + t12; t32 = (t32 - t12) * 0.601344886935;
+	t12 = t30 + t24; t24 = (t30 - t24) * 0.899976223136;
+	t30 = t06 + t26; t26 = (t06 - t26) * 2.56291544774;
+	t06 = t18 + t30; t18 = (t18 - t30) * 0.541196100146;
+	t30 = t21 + t12; t12 = (t21 - t12) * 1.30656296488;
+	t21 = t06 + t30; t30 = (t06 - t30) * 0.707106781187;
+	t06 = t18 + t12; t12 = (t18 - t12) * 0.707106781187;
+	t06 += t12;
+	t18 = t14 + t26; t26 = (t14 - t26) * 0.541196100146;
+	t14 = t32 + t24; t24 = (t32 - t24) * 1.30656296488;
+	t32 = t18 + t14; t14 = (t18 - t14) * 0.707106781187;
+	t18 = t26 + t24; t24 = (t26 - t24) * 0.707106781187;
+	t18 += t24; t32 += t18; 
+	t18 += t14; t26 = t14 + t24;
+	t14 = t02 + t16; t02 = (t02 - t16) * 0.509795579104;
+	t16 = t04 + t20; t04 = (t04 - t20) * 0.601344886935;
+	t20 = t28 + t22; t22 = (t28 - t22) * 0.899976223136;
+	t28 = t08 + t10; t10 = (t08 - t10) * 2.56291544774;
+	t08 = t14 + t28; t14 = (t14 - t28) * 0.541196100146;
+	t28 = t16 + t20; t20 = (t16 - t20) * 1.30656296488;
+	t16 = t08 + t28; t28 = (t08 - t28) * 0.707106781187;
+	t08 = t14 + t20; t20 = (t14 - t20) * 0.707106781187;
+	t08 += t20;
+	t14 = t02 + t10; t02 = (t02 - t10) * 0.541196100146;
+	t10 = t04 + t22; t22 = (t04 - t22) * 1.30656296488;
+	t04 = t14 + t10; t10 = (t14 - t10) * 0.707106781187;
+	t14 = t02 + t22; t02 = (t02 - t22) * 0.707106781187;
+	t14 += t02;	t04 += t14;	t14 += t10;	t10 += t02;
+	t16 += t04;	t04 += t08;	t08 += t14;	t14 += t28;
+	t28 += t10;	t10 += t20;	t20 += t02;	t21 += t16;
+	t16 += t32;	t32 += t04;	t04 += t06;	t06 += t08;
+	t08 += t18;	t18 += t14;	t14 += t30;	t30 += t28;
+	t28 += t26;	t26 += t10;	t10 += t12;	t12 += t20;
+	t20 += t24;	t24 += t02;
+
+	d[dp + 48] = -t33;
+	d[dp + 49] = d[dp + 47] = -t21;
+	d[dp + 50] = d[dp + 46] = -t17;
+	d[dp + 51] = d[dp + 45] = -t16;
+	d[dp + 52] = d[dp + 44] = -t01;
+	d[dp + 53] = d[dp + 43] = -t32;
+	d[dp + 54] = d[dp + 42] = -t29;
+	d[dp + 55] = d[dp + 41] = -t04;
+	d[dp + 56] = d[dp + 40] = -t03;
+	d[dp + 57] = d[dp + 39] = -t06;
+	d[dp + 58] = d[dp + 38] = -t25;
+	d[dp + 59] = d[dp + 37] = -t08;
+	d[dp + 60] = d[dp + 36] = -t11;
+	d[dp + 61] = d[dp + 35] = -t18;
+	d[dp + 62] = d[dp + 34] = -t09;
+	d[dp + 63] = d[dp + 33] = -t14;
+	d[dp + 32] = -t05;
+	d[dp +  0] = t05; d[dp + 31] = -t30;
+	d[dp +  1] = t30; d[dp + 30] = -t27;
+	d[dp +  2] = t27; d[dp + 29] = -t28;
+	d[dp +  3] = t28; d[dp + 28] = -t07;
+	d[dp +  4] = t07; d[dp + 27] = -t26;
+	d[dp +  5] = t26; d[dp + 26] = -t23;
+	d[dp +  6] = t23; d[dp + 25] = -t10;
+	d[dp +  7] = t10; d[dp + 24] = -t15;
+	d[dp +  8] = t15; d[dp + 23] = -t12;
+	d[dp +  9] = t12; d[dp + 22] = -t19;
+	d[dp + 10] = t19; d[dp + 21] = -t20;
+	d[dp + 11] = t20; d[dp + 20] = -t13;
+	d[dp + 12] = t13; d[dp + 19] = -t24;
+	d[dp + 13] = t24; d[dp + 18] = -t31;
+	d[dp + 14] = t31; d[dp + 17] = -t02;
+	d[dp + 15] = t02; d[dp + 16] =  0.0;
+};
+

src/wasm/mp2.h

@@ -0,0 +1,22 @@
+#ifndef MP2_H
+#define MP2_H
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "buffer.h"
+
+typedef struct mp2_decoder_t mp2_decoder_t;
+
+mp2_decoder_t *mp2_decoder_create(unsigned int buffer_size, bit_buffer_mode_t buffer_mode);
+void mp2_decoder_destroy(mp2_decoder_t *self);
+void *mp2_decoder_get_write_ptr(mp2_decoder_t *self, unsigned int byte_size);
+int mp2_decoder_get_index(mp2_decoder_t *self);
+void mp2_decoder_set_index(mp2_decoder_t *self, unsigned int index);
+void mp2_decoder_did_write(mp2_decoder_t *self, unsigned int byte_size);
+
+void *mp2_decoder_get_left_channel_ptr(mp2_decoder_t *self);
+void *mp2_decoder_get_right_channel_ptr(mp2_decoder_t *self);
+int mp2_decoder_get_sample_rate(mp2_decoder_t *self);
+int mp2_decoder_decode(mp2_decoder_t *self);
+
+#endif

src/wasm/mpeg1.h

@@ -0,0 +1,27 @@
+#ifndef MPEG1_H
+#define MPEG1_H
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "buffer.h"
+
+typedef struct mpeg1_decoder_t mpeg1_decoder_t;
+
+mpeg1_decoder_t *mpeg1_decoder_create(unsigned int buffer_size, bit_buffer_mode_t buffer_mode);
+void mpeg1_decoder_destroy(mpeg1_decoder_t *self);
+void *mpeg1_decoder_get_write_ptr(mpeg1_decoder_t *self, unsigned int byte_size);
+int mpeg1_decoder_get_index(mpeg1_decoder_t *self);
+void mpeg1_decoder_set_index(mpeg1_decoder_t *self, unsigned int index);
+void mpeg1_decoder_did_write(mpeg1_decoder_t *self, unsigned int byte_size);
+
+int mpeg1_decoder_has_sequence_header(mpeg1_decoder_t *self);
+float mpeg1_decoder_get_frame_rate(mpeg1_decoder_t *self);
+int mpeg1_decoder_get_coded_size(mpeg1_decoder_t *self);
+int mpeg1_decoder_get_width(mpeg1_decoder_t *self);
+int mpeg1_decoder_get_height(mpeg1_decoder_t *self);
+void *mpeg1_decoder_get_y_ptr(mpeg1_decoder_t *self);
+void *mpeg1_decoder_get_cr_ptr(mpeg1_decoder_t *self);
+void *mpeg1_decoder_get_cb_ptr(mpeg1_decoder_t *self);
+bool mpeg1_decoder_decode(mpeg1_decoder_t *self);
+
+#endif