Add player.destroy(); see #130, #128

src/ajax-progressive.js

 	this.isLoading = false;
 	this.loadStartTime = 0;
 	this.throttled = options.throttled !== false;
+	this.aborted = false;
 };
 
 AjaxProgressiveSource.prototype.connect = function(destination) {
 	}
 };
 
-AjaxProgressiveSource.prototype.abort = function() {
+AjaxProgressiveSource.prototype.destroy = function() {
 	this.request.abort();
+	this.aborted = true;
 };
 
 AjaxProgressiveSource.prototype.loadNextChunk = function() {
 	var start = this.loadedSize,
 		end = Math.min(this.loadedSize + this.chunkSize-1, this.fileSize-1);
 	
-	if (start >= this.fileSize) {
+	if (start >= this.fileSize || this.aborted) {
 		this.completed = true;
 		return;
 	}

src/ajax.js

 	// Nothing to do here
 };
 
-AjaxSource.prototype.abort = function() {
+AjaxSource.prototype.destroy = function() {
 	this.request.abort();
 };
 

src/canvas2d.js

 	this.context = this.canvas.getContext('2d');
 };
 
+CanvasRenderer.prototype.destroy = function() {
+	// Nothing to do here
+};
+
 CanvasRenderer.prototype.resize = function(width, height) {
 	this.width = width|0;
 	this.height = height|0;

src/player.js

 	}
 };
 
+Player.prototype.destroy = function() {
+	this.pause();
+	this.source.destroy();
+	this.renderer.destroy();
+	this.audioOut.destroy();
+};
+
 Player.prototype.seek = function(time) {
 	var startOffset = this.audio && this.audio.canPlay
 		? this.audio.startTime

src/webaudio.js

 		new (window.AudioContext || window.webkitAudioContext)();
 
 	this.gain = this.context.createGain();
-	this.gain.connect(this.context.destination);
 	this.destination = this.gain;
 
+	// Keep track of the number of connections to this AudioContext, so we
+	// can safely close() it when we're the only one connected to it.
+	this.gain.connect(this.context.destination);
+	this.context._connections = (this.context._connections || 0) + 1;
+	
 	this.startTime = 0;
 	this.buffer = null;
 	this.wallclockStartTime = 0;
 	Object.defineProperty(this, 'enqueuedTime', {get: this.getEnqueuedTime});
 };
 
+WebAudioOut.prototype.destroy = function() {
+	this.gain.disconnect();
+	this.context._connections--;
+
+	if (this.context._connections === 0) {
+		this.context.close();
+		WebAudioOut.CachedContext = null;
+	}
+};
+
 WebAudioOut.prototype.play = function(sampleRate, left, right) {
 	if (!this.enabled) {
 		return;

src/webgl.js

 	var vertexAttr = null;
 
 	// Init buffers
-	var vertexBuffer = gl.createBuffer();
+	this.vertexBuffer = gl.createBuffer();
 	var vertexCoords = new Float32Array([0, 0, 0, 1, 1, 0, 1, 1]);
-	gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer);
+	gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexBuffer);
 	gl.bufferData(gl.ARRAY_BUFFER, vertexCoords, gl.STATIC_DRAW);
 
 	// Setup the main YCrCbToRGBA shader
 	this.shouldCreateUnclampedViews = !this.allowsClampedTextureData();
 };
 
+WebGLRenderer.prototype.destroy = function() {
+	var gl = this.gl;
+	
+	gl.deleteTexture(this.textureY);
+	gl.deleteTexture(this.textureCb);
+	gl.deleteTexture(this.textureCr);
+
+	gl.deleteProgram(this.program);
+	gl.deleteProgram(this.loadingProgram);
+
+	gl.deleteBuffer(this.vertexBuffer);
+};
+
 WebGLRenderer.prototype.resize = function(width, height) {
 	this.width = width|0;
 	this.height = height|0;
 
 WebGLRenderer.prototype.renderProgress = function(progress) {
 	var gl = this.gl;
+
+	gl.useProgram(this.loadingProgram);
+
 	var loc = gl.getUniformLocation(this.loadingProgram, 'progress');
 	gl.uniform1f(loc, progress);
+	
 	gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
 };
 
 		y = new Uint8Array(y.buffer),
 		cb = new Uint8Array(cb.buffer),
 		cr = new Uint8Array(cr.buffer);	
-	}	
+	}
+
+	gl.useProgram(this.program);
 
 	this.updateTexture(gl.TEXTURE0, this.textureY, w, h, y);
 	this.updateTexture(gl.TEXTURE1, this.textureCb, w2, h2, cb);

src/websocket.js

 	this.destination = destination;
 };
 
-WSSource.prototype.abort = function() {
+WSSource.prototype.destroy = function() {
+	clearTimeout(this.reconnectTimeoutId);
 	this.shouldAttemptReconnect = false;
 	this.socket.close();
 };