11 files changed, 4199 insertions, 0 deletions

diff --git a/js/.DS_Store b/js/.DS_Store
new file mode 100644
index 0000000..5008ddf
--- /dev/null
+++ b/js/.DS_Store
diff --git a/js/client.concat.js b/js/client.concat.js
new file mode 100644
index 0000000..d896a61
--- /dev/null
+++ b/js/client.concat.js
@@ -0,0 +1,626 @@
+function shuffle(a){
+	var aa = new Array(a.length);
+	aa[0] = a[0];
+
+	for (var i = 1; i < a.length; i++) {
+		var j = Math.floor( Math.random() * i );
+		aa[i] = aa[j];
+		aa[j] = a[i];
+	}
+	return aa;
+}
+function sample(a, n) {
+	var aa = shuffle(a);
+	return aa.slice(0,n);
+}
+;var nextTick = (function(){
+  // postMessage behaves badly on IE8
+  if (window.ActiveXObject || !window.postMessage) {
+    var nextTick = function(fn) {
+      setTimeout(fn, 0);
+    }
+  } else {
+    // based on setZeroTimeout by David Baron
+    // - http://dbaron.org/log/20100309-faster-timeouts
+    var timeouts = []
+      , name = 'next-tick-zero-timeout'
+
+    window.addEventListener('message', function(e){
+      if (e.source == window && e.data == name) {
+        if (e.stopPropagation) e.stopPropagation();
+        if (timeouts.length) timeouts.shift()();
+      }
+    }, true);
+
+    var nextTick = function(fn){
+      timeouts.push(fn);
+      window.postMessage(name, '*');
+    }
+  }
+
+  return nextTick;
+})()
+
+var Uid = (function(){
+  var id = 0
+  return function(){ return id++ + "" }
+})()
+
+
+var tokenize = (function(){
+  var tokenize = function(str, splitOn){
+    return str
+             .trim()
+             .split(splitOn || tokenize.default);
+  };
+
+  tokenize.default = /\s+/g;
+
+  return tokenize;
+})()
+
+// globber("*".split(":"), "a:b:c".split(":")) => true
+// globber("*:c".split(":"), "a:b:c".split(":")) => true
+// globber("a:*".split(":"), "a:b:c".split(":")) => true
+// globber("a:*:c".split(":"), "a:b:c".split(":")) => true
+
+// based on codegolf.stackexchange.com/questions/467/implement-glob-matcher
+var globber = function(patterns, strings) {
+  // console.log("globber called with: " + patterns.join(":"), strings.join(":"))
+  var first = patterns[0],
+      rest = patterns.slice(1),
+      len = strings.length,
+      matchFound;
+
+  if(first === '*') { 
+    for(var i = 0; i <= len; ++i) {
+      // console.log("* " + i + " trying " + rest.join(":") + " with " + strings.slice(i).join(":"))
+      if(globber(rest, strings.slice(i))) return true;
+    }
+    return false;
+  } else { 
+    matchFound = (first === strings[0]);
+    // console.log ("literal matching " + first + " " + strings[0] + " " + !!matched)
+  }
+
+  return matchFound && ((!rest.length && !len) || globber(rest, strings.slice(1)));
+};
+
+var setproto = function(obj, proto){
+  if (obj.__proto__)
+    obj.__proto__ = proto;
+  else
+    for (var key in proto)
+      obj[key] = proto[key];
+};
+
+
+var Tube = (function(){
+  var globcache = {};
+  var Tube = function(opts){
+    opts = opts || {};
+    if (opts.queue){
+      var c = function(){
+        var args = arguments;
+        // queueOrNextTick (function(){ c.send.apply(c, args) });
+        nextTick (function(){ c.send.apply(c, args) });
+        return c;
+      };
+    } else {
+      var c = function(){
+        c.send.apply(c, arguments);
+        return c;
+      };
+    }
+
+    setproto(c, Tube.proto);
+    c.listeners = {};
+    c.globListeners = {};
+
+    return c;
+  };
+
+  Tube.total = {};
+  Tube.proto = {};
+
+  /*
+  adds fns as listeners to a channel
+
+  on("msg", fn, {opts})
+  on("msg", [fn, fn2], {opts})
+  on("msg msg2 msg3", fn, {opts})
+  on({"msg": fn, "msg2": fn2}, {opts})
+  */
+
+  Tube.proto.on = function(){
+    var chan = this;
+    if (typeof arguments[0] === "string") { 
+    //if (arguments.length > 1) {           // on("msg", f)
+      var msgMap = {};
+      msgMap[arguments[0]] = arguments[1];
+      var opts = arguments[2] || {};
+    } else {                              // on({"msg": f, ...})
+      var msgMap = arguments[0];
+      var opts = arguments[1] || {};
+    }
+
+    for (var string in msgMap){
+      var msgs = string.split(" ");
+      var fs = msgMap[string];
+      if (!Array.isArray(fs)) fs = [fs];
+
+      for(var i=0, f; f=fs[i]; i++){
+        if (!f.uid) f.uid = Uid();
+      }
+
+      for(var i=0, msg; msg=msgs[i]; i++){
+        var listeners = (msg.indexOf("*") === -1) ?
+                          chan.listeners :
+                          chan.globListeners;
+
+        // todo: this probably wastes a lot of memory?
+        // make a copy of the listener, add to it, and replace the listener
+        // why not just push directly?
+        // send might be iterating over it... and that will fuck up the iteration
+
+        listeners[msg] = (msg in listeners) ?
+                           listeners[msg].concat(fs) :
+                           fs.concat();
+      }
+    }
+
+    return chan;
+  };
+
+  /*
+  off()
+  off("a:b:c")
+  off(f)
+  off("a:b:c", f)
+  off("a:b:c d:e:f")
+  off([f, f2])
+  off({"a": f, "b": f2})
+  */
+
+  Tube.proto.off = function(){ var chan = this;
+
+    var listeners, i, msgs, msg;
+
+    // off() : delete all listeners. but replace, instead of delete
+    if (arguments.length === 0) { 
+      chan.listeners = {};
+      chan.globListeners = {};
+      return chan;
+    }
+
+    // off("a:b:c d:e:f")
+    // remove all matching listeners
+    if (arguments.length === 1 && typeof arguments[0] === "string"){
+      // question... will this fuck up send if we delete in the middle of it dispatching?
+      msgs = arguments[0].split(" ");
+
+      for (i=0; msg=msgs[i]; i++){
+        delete chan.listeners[msg];
+        delete chan.globListeners[msg];
+      }
+      return chan;
+    }
+
+    // off(f) or off([f, f2])
+    // remove all matching functions
+    if (typeof arguments[0] === "function" || Array.isArray(arguments[0])) {
+      var fs = (typeof arguments[0] === "function") ? 
+                 [arguments[0]] :
+                 arguments[0];
+      // TODO
+      return chan;
+    }
+
+    // off("a:b:c", f) or off({"a": f, "b": f2})
+    if (arguments.length > 1) {           // off("msg", f)
+      var msgMap = {};
+      msgMap[arguments[0]] = arguments[1];
+    } else {                              // off({"msg": f, ...})
+      var msgMap = arguments[0];
+    }
+
+    for (var string in msgMap){
+      msgs = string.split(" ");
+
+      var fs = msgMap[string];
+      if (typeof fs === "function") fs = [fs];
+
+      for(var i=0; msg=msgs[i]; i++){
+        if (msg in chan.listeners)
+          listeners = chan.listeners;
+        else if (msg in chan.globListeners)
+          listeners = chan.globListeners;
+        else
+          continue;
+
+        // gotta do this carefully in case we are still iterating through the listener in send
+        // build a new array and assign it to the property, instead of mutating it.
+
+        // console.log(" length of listeners[" + msg + "]: " + listeners[msg].length)
+        // console.log(listeners[msg].join(","));
+        // console.log(fs.join(","));
+
+        listeners[msg] = listeners[msg].filter(
+                           function(f){ return fs.indexOf(f) === -1 }
+                         );
+
+        // console.log(" length of listeners[" + msg + "]: " + listeners[msg].length)
+
+      }
+    }
+
+    return chan;
+
+  };
+
+  /*
+  c = Tube()
+  c.on("foo", fn)
+  c("foo", "bar", [])
+
+  will call fn("bar", [], "foo")
+  */
+
+  Tube.proto.send = function(msgString /*, data... */){
+    // todo: don't do this?
+    if (!Tube.total[msgString]) Tube.total[msgString] = 0
+    Tube.total[msgString]+=1;
+
+    var listener,
+        listeners = this.listeners,
+        globListeners = this.globListeners,
+        //args = Array.prototype.splice.call(arguments, 1),
+        msgs = tokenize(msgString),
+        msg, f;
+
+    if (arguments.length) {
+      var args = Array.prototype.splice.call(arguments, 1);
+      args.push(msgString);
+
+    } else {
+      var args = [];
+    }
+
+    for (var m=0; msg=msgs[m]; m++){
+
+      var fsToRun = [];
+      var uidKeyFnValue = {};
+      var uidKeyMsgStringValue = {};
+
+      // note this will die on errors
+      // todo: implement http://dean.edwards.name/weblog/2009/03/callbacks-vs-events/
+      // exact matches
+      if (listener = listeners[msg]) {
+        for (var i=0; f=listener[i]; i++){
+            // fsToRun.push([f, msg]);
+          uidKeyFnValue[f.uid] = f;
+          uidKeyMsgStringValue[f.uid] = msg;
+        }
+      }
+
+      // glob matches
+      var msgSplit = msg.split(":");
+
+      for (var pattern in globListeners){
+
+        if (pattern !== "*") { // * always matches
+          var patternSplit = globcache[pattern] || (globcache[pattern] = pattern.split(":"));
+          if (!globber(patternSplit, msgSplit)) continue;
+        }
+
+        listener = globListeners[pattern];
+
+        for (var i=0; f=listener[i]; i++){
+          //f.apply(window, args); // hm possibly pass the actual message to the func
+          // fsToRun.push([f, msg]);
+          uidKeyFnValue[f.uid] = f;
+          uidKeyMsgStringValue[f.uid] = msg;
+        }
+      }
+
+      var fns = [];
+      for (var f in uidKeyFnValue) fns.push(uidKeyFnValue[f]);
+
+      for (var i=0, f; f=fns[i]; i++)
+        f.apply(f, args);
+
+    }
+    return this;
+  };
+
+  return Tube;
+})()
+
+;// Total frames to record
+var FRAMES_PER_GIF = 36;
+
+// Frames per second to read from the video
+var FPS = 12;
+
+// Per-frame delay in milliseconds
+var DELAY = Math.floor( 1000 / FPS );
+
+// Number of WebWorkers to create
+var WORKERS = 6;
+
+// Number of frames to use to build the gif palette (takes longest)
+var FRAMES_TO_QUANTIZE = 4;
+
+// Upload these gifs when finished??
+var DO_UPLOAD = true;
+
+function GifEncoder(){
+	var base = this;
+  this.working = false;
+  var canvases = [];
+  var contexts = [];
+  var frames = [];
+  var delays = [];
+  var width = 0;
+  var height = 0;
+  var frames_done = 0;
+
+	var initted = Date.now();
+	var started = Date.now();
+	var tube = base.tube = new Tube ()
+	
+	var workers = new Factory ();
+
+  var width, height;
+  var neuquant, colortab;
+
+	workers.hire("message", receiveMessage);
+	workers.hire("quantize", receiveQuantize);
+	workers.hire("encode", receiveEncode);
+
+	var reset = this.reset = function(){
+    resetFrames()
+		neuquant = null;
+		colortab = null;
+		base.quantized = false
+	}
+	var resetFrames = this.resetFrames = function(){
+		canvases = [];
+		contexts = [];
+		frames = [];
+    delays = [];
+    width = 0;
+    height = 0;
+    frames_done = 0;
+	}
+
+	this.on = function(){
+    base.tube.on.apply(base.tube, arguments)
+  };
+
+  this.off = function(){
+    base.tube.off.apply(base.tube, arguments)
+  };
+
+  var addFrame = this.addFrame = function(canvas, delay) {
+    var ctx = canvas.getContext('2d');
+		canvases.push(canvas);
+    contexts.push(ctx);
+    delays.push(delay);
+
+    if (canvases.length == 1) {
+      width = canvas.width;
+      height = canvas.height;
+    }
+  }
+  
+  var addFrames = this.addFrames = function(canvas_array, delay){
+    for (var i = 0; i < canvas_array.length; i++) {
+      var canvas = canvas_array[i]
+      var ctx = canvas.getContext('2d');
+      canvases.push(canvas);
+      contexts.push(ctx);
+      delays.push(delay);
+    }
+
+    if (canvases.length == canvas_array.length) {
+      width = canvas_array[0].width;
+      height = canvas_array[0].height;
+    }
+  }
+
+  var copyFrame = this.copyFrame = function(canvas, delay) {
+    var newCanvas = document.createElement("canvas");
+    var ctx = newCanvas.getContext('2d');
+    
+    ctx.drawImage(canvas, 0, 0, canvas.width, canvas.height);
+    
+		canvases.push(newCanvas);
+    contexts.push(ctx);
+    delays.push(delay);
+    
+    if (canvases.length == 1) {
+      width = canvas.width;
+      height = canvas.height;
+    }
+  }
+  
+	function Factory () {
+		var base = this;
+		var w = 0; // which worker to work next
+    var ww = [];
+		base.init = function(){
+			for (var i = 0; i < WORKERS; i++) {
+				var worker = new Worker('js/vendor/gif-encode/worker.js');
+				worker.onmessage = base.receiveWork;
+				ww.push(worker);
+			}
+		}
+		var tasks = {};
+		base.hire = function(task, cb){
+			tasks[task] = cb;
+		}
+		base.work = function(job){
+			ww[++w % ww.length].postMessage(job);
+		}
+		base.receiveWork = function(e){
+			e.data.task in tasks && tasks[e.data.task](e);
+		}
+		base.fire = function(){
+		  for (var i in ww) {
+		    ww[i].postMessage("close");
+		  }
+		  ww = []
+		  base.init()	  
+		}
+		base.init();
+	}
+
+	function receiveMessage(e){
+		console.log("[WORKER]", e.data.message);
+	}
+	
+  var neuquant, colortab;
+	var quantize = this.quantize = function () {
+		initted = Date.now();
+		started = Date.now();
+		var spritedata = spriteSheet(FRAMES_TO_QUANTIZE);
+		
+		workers.work({
+			task: 'quantize',
+			imageData: spritedata
+		});
+	}
+
+	function receiveQuantize(e) {
+		console.log(Date.now() - started, "quantization done");
+		neuquant = e.data.neuquant;
+		colortab = e.data.colortab;
+		base.quantized = true
+		base.tube("quantized")
+	}
+
+	var encode = this.encode = function (nq, ct) {
+    if (! canvases.length) {
+      throw Error ("No frames to encode")
+    }
+	  nq = nq || neuquant
+	  ct = ct || colortab
+
+		started = Date.now();
+    frames_done = 0;
+
+		console.log('working .... ');
+		var i = 0;
+
+		function sendWork () {
+			if (i == canvases.length) return doneSending();
+
+			var ctx = contexts[i];
+			var imdata = ctx.getImageData(0, 0, width, height).data;
+			var delay = delays[i];
+
+			workers.work({
+				task: 'encode',
+				frame_index: i,
+				frame_length: contexts.length-1,
+				height: height,
+				width: width,
+				delay: delay,
+				imageData: imdata,
+				neuquant: neuquant,
+				colortab: colortab
+			});
+
+			i++;
+			setTimeout(sendWork, 16);
+		}
+		function doneSending(){
+		  base.tube("done_sending")
+		}
+		sendWork();
+	}
+
+	function receiveEncode(e){
+		var frame_index = e.data["frame_index"];
+		var frame_data = e.data["frame_data"];
+
+		frames[frame_index] = frame_data;
+
+    base.tube("encoded-frame", frames.length, canvases.length)
+		for (var j = 0; j < canvases.length; j++) {
+			if (frames[j] == null) {
+				return;
+			}
+		}
+		console.log("FINISHED " + canvases.length);
+		var binary_gif = frames.join('');
+		var base64_gif = window.btoa(binary_gif);
+		var data_url = 'data:image/gif;base64,'+base64_gif;
+
+		base.working = false;
+
+		// photo.setAttribute('src', data_url);
+		// ui.doneEncodingPicture();
+    base.tube("rendered", binary_gif)
+    base.tube("rendered-url", data_url)
+// 		if (DO_UPLOAD) upload( base64_gif );
+
+		console.log((Date.now() - started), "processed frames");
+		console.log((Date.now() - initted), "done");
+		
+		workers.fire()
+	}
+	
+// 	function upload (base64_gif) {
+// 	  $("#working").html("UPLOADING")
+// 	  	
+//     console.log("starting upload")
+// 		var params = {
+// 			url: base64_gif
+// 		}
+//     $.ajax({
+//       'url': "/photos.json",
+//       'type': 'post',
+//       'data': csrf(params),
+//       'success': function(data){
+// 
+// //         $("#share").data("href", "/photos/" + data.hash)
+// //         $("#share, #make-another").fadeIn(400);
+// 				console.log(data);
+// 				console.log((Date.now() - started), "uploaded");
+// //         $("#photo").attr("src", data.url);
+// //         window.location.href = "/photos/" + data.hash
+//         localStorage.setItem('hash', data.hash)
+//         window.location.href = "/"
+//         // data.hash
+//       }
+//     });
+// 		console.log("ok");
+// 	}
+
+	function spriteSheet (frameCount) {
+		var start = Date.now();
+		frameCount = Math.min(contexts.length, frameCount);
+		var sprites = document.createElement("canvas");
+		var spriteContext = sprites.getContext('2d');
+		sprites.width = width;
+		sprites.height = height * frameCount;
+		var spritedata = spriteContext.getImageData(0, 0, sprites.width, sprites.height)
+		var spritedatadata = spritedata.data
+		var j = 0;
+		var ctxz = sample(contexts, 4);
+		while (frameCount--) {
+			var ctx = ctxz[frameCount];
+			var imdata = ctx.getImageData(0, 0, width, height).data;
+			for (var n = 0; n < imdata.length; j++, n++) {
+				spritedatadata[j] = imdata[n];
+			}
+		}
+		// spriteContext.putImageData(spritedata, 0, 0, 0, 0, sprites.width, sprites.height);
+		// upload( sprites.toDataURL("image/png").split(",")[1]
+		console.log(Date.now() - start, "built spritesheet");
+		return spritedata;
+	}
+ 
+}
diff --git a/js/client/client.js b/js/client/client.js
new file mode 100644
index 0000000..a11a8c8
--- /dev/null
+++ b/js/client/client.js
@@ -0,0 +1,288 @@
+// Total frames to record
+var FRAMES_PER_GIF = 36;
+
+// Frames per second to read from the video
+var FPS = 12;
+
+// Per-frame delay in milliseconds
+var DELAY = Math.floor( 1000 / FPS );
+
+// Number of WebWorkers to create
+var WORKERS = 6;
+
+// Number of frames to use to build the gif palette (takes longest)
+var FRAMES_TO_QUANTIZE = 4;
+
+// Upload these gifs when finished??
+var DO_UPLOAD = true;
+
+function GifEncoder(){
+	var base = this;
+  this.working = false;
+  var canvases = [];
+  var contexts = [];
+  var frames = [];
+  var delays = [];
+  var width = 0;
+  var height = 0;
+  var frames_done = 0;
+
+	var initted = Date.now();
+	var started = Date.now();
+	var tube = base.tube = new Tube ()
+	
+	var workers = new Factory ();
+
+  var width, height;
+  var neuquant, colortab;
+
+	workers.hire("message", receiveMessage);
+	workers.hire("quantize", receiveQuantize);
+	workers.hire("encode", receiveEncode);
+
+	var reset = this.reset = function(){
+    resetFrames()
+		neuquant = null;
+		colortab = null;
+		base.quantized = false
+	}
+	var resetFrames = this.resetFrames = function(){
+		canvases = [];
+		contexts = [];
+		frames = [];
+    delays = [];
+    width = 0;
+    height = 0;
+    frames_done = 0;
+	}
+
+	this.on = function(){
+    base.tube.on.apply(base.tube, arguments)
+  };
+
+  this.off = function(){
+    base.tube.off.apply(base.tube, arguments)
+  };
+
+  var addFrame = this.addFrame = function(canvas, delay) {
+    var ctx = canvas.getContext('2d');
+		canvases.push(canvas);
+    contexts.push(ctx);
+    delays.push(delay);
+
+    if (canvases.length == 1) {
+      width = canvas.width;
+      height = canvas.height;
+    }
+  }
+  
+  var addFrames = this.addFrames = function(canvas_array, delay){
+    for (var i = 0; i < canvas_array.length; i++) {
+      var canvas = canvas_array[i]
+      var ctx = canvas.getContext('2d');
+      canvases.push(canvas);
+      contexts.push(ctx);
+      delays.push(delay);
+    }
+
+    if (canvases.length == canvas_array.length) {
+      width = canvas_array[0].width;
+      height = canvas_array[0].height;
+    }
+  }
+
+  var copyFrame = this.copyFrame = function(canvas, delay) {
+    var newCanvas = document.createElement("canvas");
+    var ctx = newCanvas.getContext('2d');
+    
+    ctx.drawImage(canvas, 0, 0, canvas.width, canvas.height);
+    
+		canvases.push(newCanvas);
+    contexts.push(ctx);
+    delays.push(delay);
+    
+    if (canvases.length == 1) {
+      width = canvas.width;
+      height = canvas.height;
+    }
+  }
+  
+	function Factory () {
+		var base = this;
+		var w = 0; // which worker to work next
+    var ww = [];
+		base.init = function(){
+			for (var i = 0; i < WORKERS; i++) {
+				var worker = new Worker('js/vendor/gif-encode/worker.js');
+				worker.onmessage = base.receiveWork;
+				ww.push(worker);
+			}
+		}
+		var tasks = {};
+		base.hire = function(task, cb){
+			tasks[task] = cb;
+		}
+		base.work = function(job){
+			ww[++w % ww.length].postMessage(job);
+		}
+		base.receiveWork = function(e){
+			e.data.task in tasks && tasks[e.data.task](e);
+		}
+		base.fire = function(){
+		  for (var i in ww) {
+		    ww[i].postMessage("close");
+		  }
+		  ww = []
+		  base.init()	  
+		}
+		base.init();
+	}
+
+	function receiveMessage(e){
+		console.log("[WORKER]", e.data.message);
+	}
+	
+  var neuquant, colortab;
+	var quantize = this.quantize = function () {
+		initted = Date.now();
+		started = Date.now();
+		var spritedata = spriteSheet(FRAMES_TO_QUANTIZE);
+		
+		workers.work({
+			task: 'quantize',
+			imageData: spritedata
+		});
+	}
+
+	function receiveQuantize(e) {
+		console.log(Date.now() - started, "quantization done");
+		neuquant = e.data.neuquant;
+		colortab = e.data.colortab;
+		base.quantized = true
+		base.tube("quantized")
+	}
+
+	var encode = this.encode = function (nq, ct) {
+    if (! canvases.length) {
+      throw Error ("No frames to encode")
+    }
+	  nq = nq || neuquant
+	  ct = ct || colortab
+
+		started = Date.now();
+    frames_done = 0;
+
+		console.log('working .... ');
+		var i = 0;
+
+		function sendWork () {
+			if (i == canvases.length) return doneSending();
+
+			var ctx = contexts[i];
+			var imdata = ctx.getImageData(0, 0, width, height).data;
+			var delay = delays[i];
+
+			workers.work({
+				task: 'encode',
+				frame_index: i,
+				frame_length: contexts.length-1,
+				height: height,
+				width: width,
+				delay: delay,
+				imageData: imdata,
+				neuquant: neuquant,
+				colortab: colortab
+			});
+
+			i++;
+			setTimeout(sendWork, 16);
+		}
+		function doneSending(){
+		  base.tube("done_sending")
+		}
+		sendWork();
+	}
+
+	function receiveEncode(e){
+		var frame_index = e.data["frame_index"];
+		var frame_data = e.data["frame_data"];
+
+		frames[frame_index] = frame_data;
+
+    base.tube("encoded-frame", frames.length, canvases.length)
+		for (var j = 0; j < canvases.length; j++) {
+			if (frames[j] == null) {
+				return;
+			}
+		}
+		console.log("FINISHED " + canvases.length);
+		var binary_gif = frames.join('');
+		var base64_gif = window.btoa(binary_gif);
+		var data_url = 'data:image/gif;base64,'+base64_gif;
+
+		base.working = false;
+
+		// photo.setAttribute('src', data_url);
+		// ui.doneEncodingPicture();
+    base.tube("rendered", binary_gif)
+    base.tube("rendered-url", data_url)
+// 		if (DO_UPLOAD) upload( base64_gif );
+
+		console.log((Date.now() - started), "processed frames");
+		console.log((Date.now() - initted), "done");
+		
+		workers.fire()
+	}
+	
+// 	function upload (base64_gif) {
+// 	  $("#working").html("UPLOADING")
+// 	  	
+//     console.log("starting upload")
+// 		var params = {
+// 			url: base64_gif
+// 		}
+//     $.ajax({
+//       'url': "/photos.json",
+//       'type': 'post',
+//       'data': csrf(params),
+//       'success': function(data){
+// 
+// //         $("#share").data("href", "/photos/" + data.hash)
+// //         $("#share, #make-another").fadeIn(400);
+// 				console.log(data);
+// 				console.log((Date.now() - started), "uploaded");
+// //         $("#photo").attr("src", data.url);
+// //         window.location.href = "/photos/" + data.hash
+//         localStorage.setItem('hash', data.hash)
+//         window.location.href = "/"
+//         // data.hash
+//       }
+//     });
+// 		console.log("ok");
+// 	}
+
+	function spriteSheet (frameCount) {
+		var start = Date.now();
+		frameCount = Math.min(contexts.length, frameCount);
+		var sprites = document.createElement("canvas");
+		var spriteContext = sprites.getContext('2d');
+		sprites.width = width;
+		sprites.height = height * frameCount;
+		var spritedata = spriteContext.getImageData(0, 0, sprites.width, sprites.height)
+		var spritedatadata = spritedata.data
+		var j = 0;
+		var ctxz = sample(contexts, 4);
+		while (frameCount--) {
+			var ctx = ctxz[frameCount];
+			var imdata = ctx.getImageData(0, 0, width, height).data;
+			for (var n = 0; n < imdata.length; j++, n++) {
+				spritedatadata[j] = imdata[n];
+			}
+		}
+		// spriteContext.putImageData(spritedata, 0, 0, 0, 0, sprites.width, sprites.height);
+		// upload( sprites.toDataURL("image/png").split(",")[1]
+		console.log(Date.now() - start, "built spritesheet");
+		return spritedata;
+	}
+ 
+}
diff --git a/js/client/tube.js b/js/client/tube.js
new file mode 100644
index 0000000..17d3bfd
--- /dev/null
+++ b/js/client/tube.js
@@ -0,0 +1,323 @@
+var nextTick = (function(){
+  // postMessage behaves badly on IE8
+  if (window.ActiveXObject || !window.postMessage) {
+    var nextTick = function(fn) {
+      setTimeout(fn, 0);
+    }
+  } else {
+    // based on setZeroTimeout by David Baron
+    // - http://dbaron.org/log/20100309-faster-timeouts
+    var timeouts = []
+      , name = 'next-tick-zero-timeout'
+
+    window.addEventListener('message', function(e){
+      if (e.source == window && e.data == name) {
+        if (e.stopPropagation) e.stopPropagation();
+        if (timeouts.length) timeouts.shift()();
+      }
+    }, true);
+
+    var nextTick = function(fn){
+      timeouts.push(fn);
+      window.postMessage(name, '*');
+    }
+  }
+
+  return nextTick;
+})()
+
+var Uid = (function(){
+  var id = 0
+  return function(){ return id++ + "" }
+})()
+
+
+var tokenize = (function(){
+  var tokenize = function(str, splitOn){
+    return str
+             .trim()
+             .split(splitOn || tokenize.default);
+  };
+
+  tokenize.default = /\s+/g;
+
+  return tokenize;
+})()
+
+// globber("*".split(":"), "a:b:c".split(":")) => true
+// globber("*:c".split(":"), "a:b:c".split(":")) => true
+// globber("a:*".split(":"), "a:b:c".split(":")) => true
+// globber("a:*:c".split(":"), "a:b:c".split(":")) => true
+
+// based on codegolf.stackexchange.com/questions/467/implement-glob-matcher
+var globber = function(patterns, strings) {
+  // console.log("globber called with: " + patterns.join(":"), strings.join(":"))
+  var first = patterns[0],
+      rest = patterns.slice(1),
+      len = strings.length,
+      matchFound;
+
+  if(first === '*') { 
+    for(var i = 0; i <= len; ++i) {
+      // console.log("* " + i + " trying " + rest.join(":") + " with " + strings.slice(i).join(":"))
+      if(globber(rest, strings.slice(i))) return true;
+    }
+    return false;
+  } else { 
+    matchFound = (first === strings[0]);
+    // console.log ("literal matching " + first + " " + strings[0] + " " + !!matched)
+  }
+
+  return matchFound && ((!rest.length && !len) || globber(rest, strings.slice(1)));
+};
+
+var setproto = function(obj, proto){
+  if (obj.__proto__)
+    obj.__proto__ = proto;
+  else
+    for (var key in proto)
+      obj[key] = proto[key];
+};
+
+
+var Tube = (function(){
+  var globcache = {};
+  var Tube = function(opts){
+    opts = opts || {};
+    if (opts.queue){
+      var c = function(){
+        var args = arguments;
+        // queueOrNextTick (function(){ c.send.apply(c, args) });
+        nextTick (function(){ c.send.apply(c, args) });
+        return c;
+      };
+    } else {
+      var c = function(){
+        c.send.apply(c, arguments);
+        return c;
+      };
+    }
+
+    setproto(c, Tube.proto);
+    c.listeners = {};
+    c.globListeners = {};
+
+    return c;
+  };
+
+  Tube.total = {};
+  Tube.proto = {};
+
+  /*
+  adds fns as listeners to a channel
+
+  on("msg", fn, {opts})
+  on("msg", [fn, fn2], {opts})
+  on("msg msg2 msg3", fn, {opts})
+  on({"msg": fn, "msg2": fn2}, {opts})
+  */
+
+  Tube.proto.on = function(){
+    var chan = this;
+    if (typeof arguments[0] === "string") { 
+    //if (arguments.length > 1) {           // on("msg", f)
+      var msgMap = {};
+      msgMap[arguments[0]] = arguments[1];
+      var opts = arguments[2] || {};
+    } else {                              // on({"msg": f, ...})
+      var msgMap = arguments[0];
+      var opts = arguments[1] || {};
+    }
+
+    for (var string in msgMap){
+      var msgs = string.split(" ");
+      var fs = msgMap[string];
+      if (!Array.isArray(fs)) fs = [fs];
+
+      for(var i=0, f; f=fs[i]; i++){
+        if (!f.uid) f.uid = Uid();
+      }
+
+      for(var i=0, msg; msg=msgs[i]; i++){
+        var listeners = (msg.indexOf("*") === -1) ?
+                          chan.listeners :
+                          chan.globListeners;
+
+        // todo: this probably wastes a lot of memory?
+        // make a copy of the listener, add to it, and replace the listener
+        // why not just push directly?
+        // send might be iterating over it... and that will fuck up the iteration
+
+        listeners[msg] = (msg in listeners) ?
+                           listeners[msg].concat(fs) :
+                           fs.concat();
+      }
+    }
+
+    return chan;
+  };
+
+  /*
+  off()
+  off("a:b:c")
+  off(f)
+  off("a:b:c", f)
+  off("a:b:c d:e:f")
+  off([f, f2])
+  off({"a": f, "b": f2})
+  */
+
+  Tube.proto.off = function(){ var chan = this;
+
+    var listeners, i, msgs, msg;
+
+    // off() : delete all listeners. but replace, instead of delete
+    if (arguments.length === 0) { 
+      chan.listeners = {};
+      chan.globListeners = {};
+      return chan;
+    }
+
+    // off("a:b:c d:e:f")
+    // remove all matching listeners
+    if (arguments.length === 1 && typeof arguments[0] === "string"){
+      // question... will this fuck up send if we delete in the middle of it dispatching?
+      msgs = arguments[0].split(" ");
+
+      for (i=0; msg=msgs[i]; i++){
+        delete chan.listeners[msg];
+        delete chan.globListeners[msg];
+      }
+      return chan;
+    }
+
+    // off(f) or off([f, f2])
+    // remove all matching functions
+    if (typeof arguments[0] === "function" || Array.isArray(arguments[0])) {
+      var fs = (typeof arguments[0] === "function") ? 
+                 [arguments[0]] :
+                 arguments[0];
+      // TODO
+      return chan;
+    }
+
+    // off("a:b:c", f) or off({"a": f, "b": f2})
+    if (arguments.length > 1) {           // off("msg", f)
+      var msgMap = {};
+      msgMap[arguments[0]] = arguments[1];
+    } else {                              // off({"msg": f, ...})
+      var msgMap = arguments[0];
+    }
+
+    for (var string in msgMap){
+      msgs = string.split(" ");
+
+      var fs = msgMap[string];
+      if (typeof fs === "function") fs = [fs];
+
+      for(var i=0; msg=msgs[i]; i++){
+        if (msg in chan.listeners)
+          listeners = chan.listeners;
+        else if (msg in chan.globListeners)
+          listeners = chan.globListeners;
+        else
+          continue;
+
+        // gotta do this carefully in case we are still iterating through the listener in send
+        // build a new array and assign it to the property, instead of mutating it.
+
+        // console.log(" length of listeners[" + msg + "]: " + listeners[msg].length)
+        // console.log(listeners[msg].join(","));
+        // console.log(fs.join(","));
+
+        listeners[msg] = listeners[msg].filter(
+                           function(f){ return fs.indexOf(f) === -1 }
+                         );
+
+        // console.log(" length of listeners[" + msg + "]: " + listeners[msg].length)
+
+      }
+    }
+
+    return chan;
+
+  };
+
+  /*
+  c = Tube()
+  c.on("foo", fn)
+  c("foo", "bar", [])
+
+  will call fn("bar", [], "foo")
+  */
+
+  Tube.proto.send = function(msgString /*, data... */){
+    // todo: don't do this?
+    if (!Tube.total[msgString]) Tube.total[msgString] = 0
+    Tube.total[msgString]+=1;
+
+    var listener,
+        listeners = this.listeners,
+        globListeners = this.globListeners,
+        //args = Array.prototype.splice.call(arguments, 1),
+        msgs = tokenize(msgString),
+        msg, f;
+
+    if (arguments.length) {
+      var args = Array.prototype.splice.call(arguments, 1);
+      args.push(msgString);
+
+    } else {
+      var args = [];
+    }
+
+    for (var m=0; msg=msgs[m]; m++){
+
+      var fsToRun = [];
+      var uidKeyFnValue = {};
+      var uidKeyMsgStringValue = {};
+
+      // note this will die on errors
+      // todo: implement http://dean.edwards.name/weblog/2009/03/callbacks-vs-events/
+      // exact matches
+      if (listener = listeners[msg]) {
+        for (var i=0; f=listener[i]; i++){
+            // fsToRun.push([f, msg]);
+          uidKeyFnValue[f.uid] = f;
+          uidKeyMsgStringValue[f.uid] = msg;
+        }
+      }
+
+      // glob matches
+      var msgSplit = msg.split(":");
+
+      for (var pattern in globListeners){
+
+        if (pattern !== "*") { // * always matches
+          var patternSplit = globcache[pattern] || (globcache[pattern] = pattern.split(":"));
+          if (!globber(patternSplit, msgSplit)) continue;
+        }
+
+        listener = globListeners[pattern];
+
+        for (var i=0; f=listener[i]; i++){
+          //f.apply(window, args); // hm possibly pass the actual message to the func
+          // fsToRun.push([f, msg]);
+          uidKeyFnValue[f.uid] = f;
+          uidKeyMsgStringValue[f.uid] = msg;
+        }
+      }
+
+      var fns = [];
+      for (var f in uidKeyFnValue) fns.push(uidKeyFnValue[f]);
+
+      for (var i=0, f; f=fns[i]; i++)
+        f.apply(f, args);
+
+    }
+    return this;
+  };
+
+  return Tube;
+})()
+
diff --git a/js/client/util.js b/js/client/util.js
new file mode 100644
index 0000000..92d8129
--- /dev/null
+++ b/js/client/util.js
@@ -0,0 +1,15 @@
+function shuffle(a){
+	var aa = new Array(a.length);
+	aa[0] = a[0];
+
+	for (var i = 1; i < a.length; i++) {
+		var j = Math.floor( Math.random() * i );
+		aa[i] = aa[j];
+		aa[j] = a[i];
+	}
+	return aa;
+}
+function sample(a, n) {
+	var aa = shuffle(a);
+	return aa.slice(0,n);
+}
diff --git a/js/worker.concat.js b/js/worker.concat.js
new file mode 100644
index 0000000..3be4680
--- /dev/null
+++ b/js/worker.concat.js
@@ -0,0 +1,1473 @@
+/**

+* This class lets you encode animated GIF files

+* Base class :  http://www.java2s.com/Code/Java/2D-Graphics-GUI/AnimatedGifEncoder.htm

+* @author Kevin Weiner (original Java version - kweiner@fmsware.com)

+* @author Thibault Imbert (AS3 version - bytearray.org)

+* @version 0.1 AS3 implementation

+*/

+

+//import flash.utils.ByteArray;

+//import flash.display.BitmapData;

+//import flash.display.Bitmap;

+//import org.bytearray.gif.encoder.NeuQuant

+//import flash.net.URLRequestHeader;

+//import flash.net.URLRequestMethod;

+//import flash.net.URLRequest;

+//import flash.net.navigateToURL;

+

+GIFEncoder = function() {

+	for(var i = 0, chr = {}; i < 256; i++) {

+		chr[i] = String.fromCharCode(i);

+  }

+			

+	function ByteArray(){

+		this.bin = [];

+	}

+

+	ByteArray.prototype.getData = function(){

+		for(var v = '', l = this.bin.length, i = 0; i < l; i++) {

+			v += chr[this.bin[i]];

+		}

+		return v;

+	}

+	ByteArray.prototype.writeByte = function(val){

+		this.bin.push(val);

+	}

+	ByteArray.prototype.writeUTFBytes = function(string) {

+		for(var l = string.length, i = 0; i < l; i++) {

+			this.writeByte(string.charCodeAt(i));

+		}

+	}

+	ByteArray.prototype.writeBytes = function(array, offset, length) {

+		for(var l = length || array.length, i = offset||0; i < l; i++) {

+			this.writeByte(array[i]);

+		}

+	}

+

+	var exports = {};

+	var width/*int*/ // image size

+	var height/*int*/;

+	var transparent/***/ = null; // transparent color if given

+	var transIndex/*int*/; // transparent index in color table

+	var repeat/*int*/ = -1; // no repeat

+	var delay/*int*/ = 0; // frame delay (hundredths)

+	var started/*Boolean*/ = false; // ready to output frames

+	var out/*ByteArray*/;

+	var image/*Bitmap*/; // current frame

+	var pixels/*ByteArray*/; // BGR byte array from frame

+	var indexedPixels/*ByteArray*/ // converted frame indexed to palette

+	var colorDepth/*int*/; // number of bit planes

+	var colorTab/*ByteArray*/; // RGB palette

+	var usedEntry/*Array*/ = new Array; // active palette entries

+	var palSize/*int*/ = 7; // color table size (bits-1)

+	var dispose/*int*/ = -1; // disposal code (-1 = use default)

+	var closeStream/*Boolean*/ = false; // close stream when finished

+	var firstFrame/*Boolean*/ = true;

+	var sizeSet/*Boolean*/ = false; // if false, get size from first frame

+	var sample/*int*/ = 1; // default sample interval for quantizer

+	var neuquantBrain = null;  // allow loading in a prefab neural net

+

+	/**

+	* Sets the delay time between each frame, or changes it for subsequent frames

+	* (applies to last frame added)

+	* int delay time in milliseconds

+	* @param ms

+	*/

+	

+	var setDelay = exports.setDelay = function setDelay(ms/*int*/) {

+		delay = Math.round(ms / 10);

+	}

+	

+	/**

+	* Sets the GIF frame disposal code for the last added frame and any

+	* 

+	* subsequent frames. Default is 0 if no transparent color has been set,

+	* otherwise 2.

+	* @param code

+	* int disposal code.

+	*/

+	

+	var setDispose = exports.setDispose = function setDispose(code/*int*/) {

+		if (code >= 0) dispose = code;

+	}

+	

+	/**

+	* Sets the number of times the set of GIF frames should be played. Default is

+	* 1; 0 means play indefinitely. Must be invoked before the first image is

+	* added.

+	* 

+	* @param iter

+	* int number of iterations.

+	* @return

+	*/

+	

+	var setRepeat = exports.setRepeat = function setRepeat(iter/*int*/) {

+		if (iter >= 0) repeat = iter;

+	}

+	

+	/**

+	* Sets the transparent color for the last added frame and any subsequent

+	* frames. Since all colors are subject to modification in the quantization

+	* process, the color in the final palette for each frame closest to the given

+	* color becomes the transparent color for that frame. May be set to null to

+	* indicate no transparent color.

+	* @param

+	* Color to be treated as transparent on display.

+	*/

+	

+	var setTransparent = exports.setTransparent = function setTransparent(c/*Number*/) {

+		transparent = c;

+	}

+	

+	/**

+	* The addFrame method takes an incoming BitmapData object to create each frames

+	* @param

+	* BitmapData object to be treated as a GIF's frame

+	*/

+	

+	/*Boolean*/

+	var addFrame = exports.addFrame = function addFrame(im/*BitmapData*/, is_imageData) {

+		if ((im == null) || ! started || out == null) {

+			throw new Error ("Please call start method before calling addFrame");

+			return false;

+		}

+		

+		var ok/*Boolean*/ = true;

+

+		try {

+			if ( ! is_imageData) {

+				image = im.getImageData(0,0, im.canvas.width, im.canvas.height).data;

+				if ( ! sizeSet) {

+					setSize(im.canvas.width, im.canvas.height);

+				}

+			}

+			else {

+				image = im;

+			}

+			getImagePixels(); // convert to correct format if necessary

+			analyzePixels(); // build color table & map pixels

+			

+			if (firstFrame) {

+				writeLSD(); // logical screen descriptior

+				writePalette(); // global color table

+				if (repeat >= 0) {

+					// use NS app extension to indicate reps

+					writeNetscapeExt();

+				}

+			}

+			

+			writeGraphicCtrlExt(); // write graphic control extension

+			writeImageDesc(); // image descriptor

+			if (!firstFrame) {

+				writePalette(); // local color table

+			}

+			writePixels(); // encode and write pixel data

+			firstFrame = false;

+		}

+		catch (e/*Error*/) {

+			ok = false;

+		}

+		return ok;

+	}

+	

+	/**

+	* Adds final trailer to the GIF stream, if you don't call the finish method

+	* the GIF stream will not be valid.

+	*/

+	

+	/*Boolean*/

+	var finish = exports.finish = function finish() {

+		if ( ! started) {

+			return false;

+		}

+

+		var ok/*Boolean*/ = true;

+		started = false;

+		try {

+			out.writeByte(0x3b); // gif trailer

+		}

+		catch (e/*Error*/) {

+			ok = false;

+		}

+		return ok;

+	}

+	

+	/**

+	* Resets some members so that a new stream can be started.

+	* This method is actually called by the start method

+	*/

+	

+	var reset = function reset () {

+		// reset for subsequent use

+		transIndex = 0;

+		image = null;

+		pixels = null;

+		indexedPixels = null;

+		colorTab = null;

+		closeStream = false;

+		firstFrame = true;

+	}

+

+	/**

+	* * Sets frame rate in frames per second. Equivalent to

+	* <code>setDelay(1000/fps)</code>.

+	* @param fps

+	* float frame rate (frames per second)         

+	*/

+	

+	var setFrameRate = exports.setFrameRate = function setFrameRate(fps/*Number*/) {

+		if (fps != 0xf) {

+			delay = Math.round(100/fps);

+		}

+	}

+	

+	/**

+	* Sets quality of color quantization (conversion of images to the maximum 256

+	* colors allowed by the GIF specification). Lower values (minimum = 1)

+	* produce better colors, but slow processing significantly. 10 is the

+	* default, and produces good color mapping at reasonable speeds. Values

+	* greater than 20 do not yield significant improvements in speed.

+	* @param quality

+	* int greater than 0.

+	* @return

+	*/

+	

+	var setQuality = exports.setQuality = function setQuality(quality/*int*/) {

+		sample = Math.max(1, quality);

+	}

+	

+	/**

+	* Sets the GIF frame size. The default size is the size of the first frame

+	* added if this method is not invoked.

+	* @param w

+	* int frame width.

+	* @param h

+	* int frame width.

+	*/

+	

+	var setSize = exports.setSize = function setSize(w/*int*/, h/*int*/) {

+		if (started && !firstFrame) {

+			return;

+		}

+		width = w;

+		height = h;

+		if (width < 1) width = 320;

+		if (height < 1) height = 240;

+		sizeSet = true;

+	}

+	

+	/**

+	*	After running the Neuquant on some test frames, it can be exported and then loaded

+	* into an uninitialized NQ instance on another worker and used accordingly.

+	*/

+	var setNeuquant = exports.setNeuquant = function setNeuquant(neuquant, colors){

+		neuquantBrain = neuquant;

+		colorTab = colors;

+	}

+	

+	/**

+	* Initiates GIF file creation on the given stream.

+	* @param os

+	* OutputStream on which GIF images are written.

+	* @return false if initial write failed.

+	*/

+	

+	var start = exports.start = function start() {

+		reset(); 

+		var ok/*Boolean*/ = true;

+		closeStream = false;

+		out = new ByteArray;

+		try {

+			out.writeUTFBytes("GIF89a"); // header

+		} catch (e/*Error*/) {

+			ok = false;

+		}

+		

+		return started = ok;

+	}

+	

+	var cont = exports.cont = function cont() {

+		reset(); 

+		var ok = true;

+		closeStream = false;

+		out = new ByteArray ();

+		return started = ok;

+	}

+	

+	/**

+	* Analyzes image colors and creates color map.

+	*/

+	

+	var analyzePixels = function analyzePixels() {

+		var len = pixels.length;

+		var nPix = len / 3;

+		indexedPixels = [];

+		// initialize quantizer

+		

+		var nq;

+		if (neuquantBrain && colorTab) {

+			nq = new NeuQuant();

+			nq.load(neuquantBrain);

+		}

+		else {

+			nq = new NeuQuant (pixels, len, sample);

+			colorTab = nq.process(); // create reduced palette

+		}

+		

+		// map image pixels to new palette

+		var k = 0;

+		for (var j = 0; j < nPix; j++) {

+			var index = nq.map(pixels[k++] & 0xff, pixels[k++] & 0xff, pixels[k++] & 0xff);

+			usedEntry[index] = true;

+			indexedPixels[j] = index;

+		}

+		pixels = null;

+		colorDepth = 8;

+		palSize = 7;

+		

+		// get closest match to transparent color if specified

+		if (transparent != null) {

+			transIndex = findClosest(transparent);

+		}

+	}

+	

+	/**

+	* Returns index of palette color closest to c

+	*/

+	

+	var findClosest = function findClosest(c/*Number*/) {

+		if (colorTab == null) return -1;

+		var r = (c & 0xFF0000) >> 16;

+		var g = (c & 0x00FF00) >> 8;

+		var b = (c & 0x0000FF);

+		var minpos = 0;

+		var dmin = 256 * 256 * 256;

+		var len = colorTab.length;

+		

+		for (var i = 0; i < len;) {

+			var dr = r - (colorTab[i++] & 0xff);

+			var dg = g - (colorTab[i++] & 0xff);

+			var db = b - (colorTab[i] & 0xff);

+			var d = dr * dr + dg * dg + db * db;

+			var index = i / 3;

+			if (usedEntry[index] && (d < dmin)) {

+				dmin = d;

+				minpos = index;

+			}

+			i++;

+		}

+		return minpos;

+	}

+	

+	/**

+	* Extracts image pixels into byte array "pixels

+	*/

+	

+	var getImagePixels = function getImagePixels() {

+		var w = width;

+		var h = height;

+		pixels = [];

+		var data = image;

+		var count/*int*/ = 0;

+			

+		for ( var i/*int*/ = 0; i < h; i++ ) {

+			for (var j/*int*/ = 0; j < w; j++ ) {

+				var b = (i*w*4)+j*4;

+				pixels[count++] = data[b];

+				pixels[count++] = data[b+1];

+				pixels[count++] = data[b+2];

+			}

+		}

+	}

+	

+	/**

+	* Writes Graphic Control Extension

+	*/

+	

+	var writeGraphicCtrlExt = function writeGraphicCtrlExt() {

+		out.writeByte(0x21); // extension introducer

+		out.writeByte(0xf9); // GCE label

+		out.writeByte(4); // data block size

+		var transp/*int*/

+		var disp/*int*/;

+		if (transparent == null) {

+			transp = 0;

+			disp = 0; // dispose = no action

+		}

+		else {

+			transp = 1;

+			disp = 2; // force clear if using transparent color

+		}

+		if (dispose >= 0) {

+			disp = dispose & 7; // user override

+		}

+		disp <<= 2;

+		// packed fields

+		out.writeByte(0 | // 1:3 reserved

+				disp | // 4:6 disposal

+				0 | // 7 user input - 0 = none

+				transp); // 8 transparency flag

+	

+		WriteShort(delay); // delay x 1/100 sec

+		out.writeByte(transIndex); // transparent color index

+		out.writeByte(0); // block terminator

+	}

+

+	/**

+	* Writes Image Descriptor

+	*/

+	

+	var writeImageDesc = function writeImageDesc() {

+		out.writeByte(0x2c); // image separator

+		WriteShort(0); // image position x,y = 0,0

+		WriteShort(0);

+		WriteShort(width); // image size

+		WriteShort(height);

+

+		// packed fields

+		if (firstFrame) {

+			// no LCT - GCT is used for first (or only) frame

+			out.writeByte(0);

+		}

+		else {

+			// specify normal LCT

+			out.writeByte(0x80 | // 1 local color table 1=yes

+					0 | // 2 interlace - 0=no

+					0 | // 3 sorted - 0=no

+					0 | // 4-5 reserved

+					palSize); // 6-8 size of color table

+		}

+	}

+	

+	/**

+	* Writes Logical Screen Descriptor

+	*/

+	

+	var writeLSD = function writeLSD() {

+		// logical screen size

+		WriteShort(width);

+		WriteShort(height);

+		// packed fields

+		out.writeByte((0x80 | // 1 : global color table flag = 1 (gct used)

+				0x70 | // 2-4 : color resolution = 7

+				0x00 | // 5 : gct sort flag = 0

+				palSize)); // 6-8 : gct size

+

+		out.writeByte(0); // background color index

+		out.writeByte(0); // pixel aspect ratio - assume 1:1

+	}

+	

+	/**

+	* Writes Netscape application extension to define repeat count.

+	*/

+	

+	var writeNetscapeExt = function writeNetscapeExt() {

+		out.writeByte(0x21); // extension introducer

+		out.writeByte(0xff); // app extension label

+		out.writeByte(11); // block size

+		out.writeUTFBytes("NETSCAPE" + "2.0"); // app id + auth code

+		out.writeByte(3); // sub-block size

+		out.writeByte(1); // loop sub-block id

+		WriteShort(repeat); // loop count (extra iterations, 0=repeat forever)

+		out.writeByte(0); // block terminator

+	}

+	

+	/**

+	* Writes color table

+	*/

+	var writePalette = function writePalette() {

+		out.writeBytes(colorTab);

+		var n/*int*/ = (3 * 256) - colorTab.length;

+		for (var i/*int*/ = 0; i < n; i++) {

+			out.writeByte(0);

+		}

+	}

+	

+	var WriteShort = function WriteShort (pValue/*int*/) { 

+		out.writeByte( pValue & 0xFF );

+		out.writeByte( (pValue >> 8) & 0xFF);

+	}

+	

+	/**

+	* Encodes and writes pixel data

+	*/

+	var writePixels = function writePixels() {

+		var myencoder = new LZWEncoder(width, height, indexedPixels, colorDepth);

+		myencoder.encode(out);

+	}

+	

+	/**

+	* retrieves the GIF stream

+	*/

+	var stream = exports.stream = function stream () {

+		return out; 

+	}

+	

+	var setProperties = exports.setProperties = function setProperties(has_start, is_first) {

+		started = has_start;

+		firstFrame = is_first;

+	}

+	

+	return exports;

+}

+

+;/**

+* This class handles LZW encoding

+* Adapted from Jef Poskanzer's Java port by way of J. M. G. Elliott.

+* @author Kevin Weiner (original Java version - kweiner@fmsware.com)

+* @author Thibault Imbert (AS3 version - bytearray.org)

+* @version 0.1 AS3 implementation

+*/

+

+//import flash.utils.ByteArray;

+

+LZWEncoder = function()

+{

+		var exports = {};

+	/*private_static*/ var EOF/*int*/ = -1;

+	/*private*/ var imgW/*int*/;

+	/*private*/ var imgH/*int*/

+	/*private*/ var pixAry/*ByteArray*/;

+	/*private*/ var initCodeSize/*int*/;

+	/*private*/ var remaining/*int*/;

+	/*private*/ var curPixel/*int*/;

+	

+	// GIFCOMPR.C - GIF Image compression routines

+	// Lempel-Ziv compression based on 'compress'. GIF modifications by

+	// David Rowley (mgardi@watdcsu.waterloo.edu)

+	// General DEFINEs

+	

+	/*private_static*/ var BITS/*int*/ = 12;

+	/*private_static*/ var HSIZE/*int*/ = 5003; // 80% occupancy

+	

+	// GIF Image compression - modified 'compress'

+	// Based on: compress.c - File compression ala IEEE Computer, June 1984.

+	// By Authors: Spencer W. Thomas (decvax!harpo!utah-cs!utah-gr!thomas)

+	// Jim McKie (decvax!mcvax!jim)

+	// Steve Davies (decvax!vax135!petsd!peora!srd)

+	// Ken Turkowski (decvax!decwrl!turtlevax!ken)

+	// James A. Woods (decvax!ihnp4!ames!jaw)

+	// Joe Orost (decvax!vax135!petsd!joe)

+	

+	/*private*/ var n_bits/*int*/ // number of bits/code

+	/*private*/ var maxbits/*int*/ = BITS; // user settable max # bits/code

+	/*private*/ var maxcode/*int*/ // maximum code, given n_bits

+	/*private*/ var maxmaxcode/*int*/ = 1 << BITS; // should NEVER generate this code

+	/*private*/ var htab/*Array*/ = new Array;

+	/*private*/ var codetab/*Array*/ = new Array;

+	/*private*/ var hsize/*int*/ = HSIZE; // for dynamic table sizing

+	/*private*/ var free_ent/*int*/ = 0; // first unused entry

+	

+	// block compression parameters -- after all codes are used up,

+	// and compression rate changes, start over.

+	

+	/*private*/ var clear_flg/*Boolean*/ = false;

+	

+	// Algorithm: use open addressing double hashing (no chaining) on the

+	// prefix code / next character combination. We do a variant of Knuth's

+	// algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime

+	// secondary probe. Here, the modular division first probe is gives way

+	// to a faster exclusive-or manipulation. Also do block compression with

+	// an adaptive reset, whereby the code table is cleared when the compression

+	// ratio decreases, but after the table fills. The variable-length output

+	// codes are re-sized at this point, and a special CLEAR code is generated

+	// for the decompressor. Late addition: construct the table according to

+	// file size for noticeable speed improvement on small files. Please direct

+	// questions about this implementation to ames!jaw.

+	

+	/*private*/ var g_init_bits/*int*/;

+	/*private*/ var ClearCode/*int*/;

+	/*private*/ var EOFCode/*int*/;

+	

+	// output

+	// Output the given code.

+	// Inputs:

+	// code: A n_bits-bit integer. If == -1, then EOF. This assumes

+	// that n_bits =< wordsize - 1.

+	// Outputs:

+	// Outputs code to the file.

+	// Assumptions:

+	// Chars are 8 bits long.

+	// Algorithm:

+	// Maintain a BITS character long buffer (so that 8 codes will

+	// fit in it exactly). Use the VAX insv instruction to insert each

+	// code in turn. When the buffer fills up empty it and start over.

+	

+	/*private*/ var cur_accum/*int*/ = 0;

+	/*private*/ var cur_bits/*int*/ = 0;

+	/*private*/ var masks/*Array*/ = [ 0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF, 0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF ];

+	

+	// Number of characters so far in this 'packet'

+	/*private*/ var a_count/*int*/;

+	

+	// Define the storage for the packet accumulator

+	/*private*/ var accum/*ByteArray*/ = [];

+	

+	var LZWEncoder = exports.LZWEncoder = function LZWEncoder (width/*int*/, height/*int*/, pixels/*ByteArray*/, color_depth/*int*/)

+	{

+		

+		imgW = width;

+		imgH = height;

+		pixAry = pixels;

+		initCodeSize = Math.max(2, color_depth);

+		

+	}

+	

+	// Add a character to the end of the current packet, and if it is 254

+	// characters, flush the packet to disk.

+	var char_out = function char_out(c/*Number*/, outs/*ByteArray*/)/*void*/

+	{

+		accum[a_count++] = c;

+		if (a_count >= 254) flush_char(outs);

+		

+	}

+	

+	// Clear out the hash table

+	// table clear for block compress

+	

+	var cl_block = function cl_block(outs/*ByteArray*/)/*void*/

+	{

+		

+		cl_hash(hsize);

+		free_ent = ClearCode + 2;

+		clear_flg = true;

+		output(ClearCode, outs);

+		

+	}

+	

+	// reset code table

+	var cl_hash = function cl_hash(hsize/*int*/)/*void*/

+	{

+		

+		for (var i/*int*/ = 0; i < hsize; ++i) htab[i] = -1;

+		

+	}

+	

+	var compress = exports.compress = function compress(init_bits/*int*/, outs/*ByteArray*/)/*void*/

+	

+	{

+		var fcode/*int*/;

+		var i/*int*/ /* = 0 */;

+		var c/*int*/;

+		var ent/*int*/;

+		var disp/*int*/;

+		var hsize_reg/*int*/;

+		var hshift/*int*/;

+		

+		// Set up the globals: g_init_bits - initial number of bits

+		g_init_bits = init_bits;

+		

+		// Set up the necessary values

+		clear_flg = false;

+		n_bits = g_init_bits;

+		maxcode = MAXCODE(n_bits);

+

+		ClearCode = 1 << (init_bits - 1);

+		EOFCode = ClearCode + 1;

+		free_ent = ClearCode + 2;

+

+		a_count = 0; // clear packet

+	

+		ent = nextPixel();

+

+		hshift = 0;

+		for (fcode = hsize; fcode < 65536; fcode *= 2)

+			++hshift;

+		hshift = 8 - hshift; // set hash code range bound

+

+		hsize_reg = hsize;

+		cl_hash(hsize_reg); // clear hash table

+	

+		output(ClearCode, outs);

+	

+		outer_loop: while ((c = nextPixel()) != EOF)

+		

+		{

+			

+			fcode = (c << maxbits) + ent;

+			i = (c << hshift) ^ ent; // xor hashing

+

+			if (htab[i] == fcode)

+			{

+			ent = codetab[i];

+			continue;

+			} else if (htab[i] >= 0) // non-empty slot

+			{

+				disp = hsize_reg - i; // secondary hash (after G. Knott)

+				if (i == 0)

+				disp = 1;

+				do 

+				{

+					

+					if ((i -= disp) < 0) i += hsize_reg;

+

+					if (htab[i] == fcode)

+					{

+					ent = codetab[i];

+					continue outer_loop;

+					}

+				} while (htab[i] >= 0);

+			}

+			

+			output(ent, outs);

+			ent = c;

+			if (free_ent < maxmaxcode)

+			{

+				codetab[i] = free_ent++; // code -> hashtable

+				htab[i] = fcode;

+			} else cl_block(outs);

+		}

+		

+		// Put out the final code.

+		output(ent, outs);

+		output(EOFCode, outs);

+		

+	}

+	

+	// ----------------------------------------------------------------------------

+	var encode = exports.encode = function encode(os/*ByteArray*/)/*void*/

+	{

+		os.writeByte(initCodeSize); // write "initial code size" byte

+		remaining = imgW * imgH; // reset navigation variables

+		curPixel = 0;

+		compress(initCodeSize + 1, os); // compress and write the pixel data

+		os.writeByte(0); // write block terminator

+		

+	}

+	

+	// Flush the packet to disk, and reset the accumulator

+	var flush_char = function flush_char(outs/*ByteArray*/)/*void*/

+	{

+		

+		if (a_count > 0)

+		{

+			outs.writeByte(a_count);

+			outs.writeBytes(accum, 0, a_count);

+			a_count = 0;

+		}

+		

+	}

+	

+	var MAXCODE = function MAXCODE(n_bits/*int*/)/*int*/

+	{

+		

+		return (1 << n_bits) - 1;

+		

+	}

+	

+	// ----------------------------------------------------------------------------

+	// Return the next pixel from the image

+	// ----------------------------------------------------------------------------

+	

+	var nextPixel = function nextPixel()/*int*/

+	{

+		

+		if (remaining == 0) return EOF;

+		

+		--remaining;

+		

+		var pix/*Number*/ = pixAry[curPixel++];

+		

+		return pix & 0xff;

+		

+	}

+	

+	var output = function output(code/*int*/, outs/*ByteArray*/)/*void*/

+	

+	{

+		cur_accum &= masks[cur_bits];

+		

+		if (cur_bits > 0) cur_accum |= (code << cur_bits);

+		else cur_accum = code;

+		

+		cur_bits += n_bits;

+		

+		while (cur_bits >= 8)

+		

+		{

+			

+			char_out((cur_accum & 0xff), outs);

+			cur_accum >>= 8;

+			cur_bits -= 8;

+			

+		}

+		

+		// If the next entry is going to be too big for the code size,

+		// then increase it, if possible.

+		

+		if (free_ent > maxcode || clear_flg)

+		{

+			

+			if (clear_flg)

+			{

+				

+				maxcode = MAXCODE(n_bits = g_init_bits);

+				clear_flg = false;

+				

+			} else

+			{

+				

+				++n_bits;

+				

+				if (n_bits == maxbits) maxcode = maxmaxcode;

+				

+				else maxcode = MAXCODE(n_bits);

+				

+			}

+			

+		}

+		

+		if (code == EOFCode) 

+		{

+			

+			// At EOF, write the rest of the buffer.

+			while (cur_bits > 0) 

+			{

+				

+				char_out((cur_accum & 0xff), outs);

+				cur_accum >>= 8;

+				cur_bits -= 8;

+			}

+			

+			

+			flush_char(outs);

+			

+		}

+		

+	}

+	LZWEncoder.apply(this, arguments);

+	 return exports;

+}

+

+;/*

+* NeuQuant Neural-Net Quantization Algorithm

+* ------------------------------------------

+* 

+* Copyright (c) 1994 Anthony Dekker

+* 

+* NEUQUANT Neural-Net quantization algorithm by Anthony Dekker, 1994. See

+* "Kohonen neural networks for optimal colour quantization" in "Network:

+* Computation in Neural Systems" Vol. 5 (1994) pp 351-367. for a discussion of

+* the algorithm.

+* 

+* Any party obtaining a copy of these files from the author, directly or

+* indirectly, is granted, free of charge, a full and unrestricted irrevocable,

+* world-wide, paid up, royalty-free, nonexclusive right and license to deal in

+* this software and documentation files (the "Software"), including without

+* limitation the rights to use, copy, modify, merge, publish, distribute,

+* sublicense, and/or sell copies of the Software, and to permit persons who

+* receive copies from any such party to do so, with the only requirement being

+* that this copyright notice remain intact.

+*/

+

+/*

+* This class handles Neural-Net quantization algorithm

+* @author Kevin Weiner (original Java version - kweiner@fmsware.com)

+* @author Thibault Imbert (AS3 version - bytearray.org)

+* @version 0.1 AS3 implementation

+*/

+

+//import flash.utils.ByteArray;

+

+NeuQuant = function() {

+	var exports = {};

+	var netsize = 128; /* number of colours used */

+	

+	/* four primes near 500 - assume no image has a length so large */

+	/* that it is divisible by all four primes */

+	

+	var prime1 = 499;

+	var prime2 = 491;

+	var prime3 = 487;

+	var prime4 = 503;

+	var minpicturebytes = (3 * prime4);

+	

+	/* minimum size for input image */

+	/*

+	* Program Skeleton ---------------- [select samplefac in range 1..30] [read

+	* image from input file] pic = (unsigned char*) malloc(3*width*height);

+	* initnet(pic,3*width*height,samplefac); learn(); unbiasnet(); [write output

+	* image header, using writecolourmap(f)] inxbuild(); write output image using

+	* inxsearch(b,g,r)

+	*/

+

+	/*

+	* Network Definitions -------------------

+	*/

+	

+	var maxnetpos = (netsize - 1);

+	var netbiasshift = 4; /* bias for colour values */

+	var ncycles = 100; /* no. of learning cycles */

+	

+	/* defs for freq and bias */

+	var intbiasshift = 16; /* bias for fractions */

+	var intbias = (1 << intbiasshift);

+	var gammashift = 10; /* gamma = 1024 */

+	var gamma = (1 << gammashift);

+	var betashift = 10;

+	var beta = (intbias >> betashift); /* beta = 1/1024 */

+	var betagamma = (intbias << (gammashift - betashift));

+	

+	/* defs for decreasing radius factor */

+	var initrad = (netsize >> 3); /* for 256 cols, radius starts */

+	var radiusbiasshift = 6; /* at 32.0 biased by 6 bits */

+	var radiusbias = (1 << radiusbiasshift);

+	var initradius = (initrad * radiusbias); /* and decreases by a */

+	var radiusdec = 30; /* factor of 1/30 each cycle */

+	

+	/* defs for decreasing alpha factor */

+	var alphabiasshift = 10; /* alpha starts at 1.0 */

+	var initalpha = (1 << alphabiasshift);

+	var alphadec /* biased by 10 bits */

+	

+	/* radbias and alpharadbias used for radpower calculation */

+	var radbiasshift = 8;

+	var radbias = (1 << radbiasshift);

+	var alpharadbshift = (alphabiasshift + radbiasshift);

+	

+	var alpharadbias = (1 << alpharadbshift);

+	

+	/*

+	* Types and Global Variables --------------------------

+	*/

+	

+	var thepicture/*ByteArray*//* the input image itself */

+	var lengthcount; /* lengthcount = H*W*3 */

+	var samplefac; /* sampling factor 1..30 */

+	

+	// typedef int pixel[4]; /* BGRc */

+	var network; /* the network itself - [netsize][4] */

+	var netindex = new Array();

+	

+	/* for network lookup - really 256 */

+	var bias = new Array();

+	

+	/* bias and freq arrays for learning */

+	var freq = new Array();

+	var radpower = new Array();

+	

+	var NeuQuant = exports.NeuQuant = function NeuQuant(thepic, len, sample) {

+

+		// with no input, assume we'll load in a lobotomized neuquant later.

+		// otherwise, initialize the neural net stuff

+

+		if (thepic && len && sample) {

+			var i;

+			var p;

+			

+			thepicture = thepic;

+			lengthcount = len;

+			samplefac = sample;

+			

+			network = new Array(netsize);

+			

+			for (i = 0; i < netsize; i++) {

+				network[i] = new Array(4);

+				p = network[i];

+				p[0] = p[1] = p[2] = (i << (netbiasshift + 8)) / netsize;

+				freq[i] = intbias / netsize; /* 1/netsize */

+				bias[i] = 0;

+			}

+		}

+	}

+	

+	var colorMap = function colorMap() {

+		var map/*ByteArray*/ = [];

+		var index = new Array(netsize);

+		for (var i = 0; i < netsize; i++) {

+			index[network[i][3]] = i;

+		}

+		var k = 0;

+		for (var l = 0; l < netsize; l++) {

+			var j = index[l];

+			map[k++] = (network[j][0]);

+			map[k++] = (network[j][1]);

+			map[k++] = (network[j][2]);

+		}

+		return map;

+	}

+	

+	/*

+	 * Insertion sort of network and building of netindex[0..255] (to do after

+	 * unbias)

+	 * -------------------------------------------------------------------------------

+	 */

+	 

+	 var inxbuild = function inxbuild() {

+		var i;

+		var j;

+		var smallpos;

+		var smallval;

+		var p;

+		var q;

+		var previouscol

+		var startpos

+		

+		previouscol = 0;

+		startpos = 0;

+		for (i = 0; i < netsize; i++) {

+			p = network[i];

+			smallpos = i;

+			smallval = p[1]; /* index on g */

+			/* find smallest in i..netsize-1 */

+			for (j = i + 1; j < netsize; j++) {

+				q = network[j];

+				if (q[1] < smallval) { /* index on g */

+					smallpos = j;

+					smallval = q[1]; /* index on g */

+				}

+			}

+			

+			q = network[smallpos];

+			/* swap p (i) and q (smallpos) entries */

+			

+			if (i != smallpos) {

+				j = q[0];

+				q[0] = p[0];

+				p[0] = j;

+				j = q[1];

+				q[1] = p[1];

+				p[1] = j;

+				j = q[2];

+				q[2] = p[2];

+				p[2] = j;

+				j = q[3];

+				q[3] = p[3];

+				p[3] = j;

+			}

+			

+			/* smallval entry is now in position i */

+			

+			if (smallval != previouscol) {

+				netindex[previouscol] = (startpos + i) >> 1;

+				

+				for (j = previouscol + 1; j < smallval; j++) netindex[j] = i;

+				

+				previouscol = smallval;

+				startpos = i;

+			}

+		}

+		

+		netindex[previouscol] = (startpos + maxnetpos) >> 1;

+		for (j = previouscol + 1; j < 256; j++) netindex[j] = maxnetpos; /* really 256 */

+	 }

+	 

+	 /*

+	 * Main Learning Loop ------------------

+	 */

+	 

+	 var learn = function learn() {

+		 var i;

+		 var j;

+		 var b;

+		 var g

+		 var r;

+		 var radius;

+		 var rad;

+		 var alpha;

+		 var step;

+		 var delta;

+		 var samplepixels;

+		 var p/*ByteArray*/;

+		 var pix;

+		 var lim;

+		 

+		 if (lengthcount < minpicturebytes) samplefac = 1;

+		 

+		 alphadec = 30 + ((samplefac - 1) / 3);

+		 p = thepicture;

+		 pix = 0;

+		 lim = lengthcount;

+		 samplepixels = lengthcount / (3 * samplefac);

+		 delta = samplepixels / ncycles;

+		 alpha = initalpha;

+		 radius = initradius;

+		 

+		 rad = radius >> radiusbiasshift;

+		 if (rad <= 1) rad = 0;

+		 

+		 for (i = 0; i < rad; i++) radpower[i] = alpha * (((rad * rad - i * i) * radbias) / (rad * rad));

+		 

+		 if (lengthcount < minpicturebytes) step = 3;

+		 else if ((lengthcount % prime1) != 0) step = 3 * prime1;

+		 else if ((lengthcount % prime2) != 0) step = 3 * prime2;

+		 else if ((lengthcount % prime3) != 0) step = 3 * prime3;

+		 else step = 3 * prime4;

+		 

+		 i = 0;

+		 

+		 while (i < samplepixels) {

+			 b = (p[pix + 0] & 0xff) << netbiasshift;

+			 g = (p[pix + 1] & 0xff) << netbiasshift;

+			 r = (p[pix + 2] & 0xff) << netbiasshift;

+			 j = contest(b, g, r);

+			 

+			 altersingle(alpha, j, b, g, r);

+			 

+			 if (rad != 0) alterneigh(rad, j, b, g, r); /* alter neighbours */

+			 

+			 pix += step;

+			 

+			 if (pix >= lim) pix -= lengthcount;

+			 

+			 i++;

+			 

+			 if (delta == 0) delta = 1;

+			 

+			 if (i % delta == 0) {

+				 alpha -= alpha / alphadec;

+				 radius -= radius / radiusdec;

+				 rad = radius >> radiusbiasshift;

+				 

+				 if (rad <= 1) rad = 0;

+				 

+				 for (j = 0; j < rad; j++) radpower[j] = alpha * (((rad * rad - j * j) * radbias) / (rad * rad));

+			 }

+		 }

+	 }

+

+

+	/* Save the neural network so we can load it back in on another worker.

+	*/

+	var save = exports.save = function(){

+		var data = {

+			netindex: netindex,

+			netsize: netsize,

+			network: network

+		};

+		return data;

+	}

+	var load = exports.load = function(data){

+		netindex = data.netindex;

+		netsize = data.netsize;

+		network = data.network;

+	}

+	

+	

+	 /*

+	 ** Search for BGR values 0..255 (after net is unbiased) and return colour

+	 * index

+	 * ----------------------------------------------------------------------------

+	 */

+	

+	var map = exports.map = function map(b, g, r) {

+		var i;

+		var j;

+		var dist

+		var a;

+		var bestd;

+		var p;

+		var best;

+		 

+		bestd = 1000; /* biggest possible dist is 256*3 */

+		best = -1;

+		i = netindex[g]; /* index on g */

+		j = i - 1; /* start at netindex[g] and work outwards */

+

+		while ((i < netsize) || (j >= 0)) {

+			if (i < netsize) {

+				p = network[i];

+				dist = p[1] - g; /* inx key */

+				if (dist >= bestd) i = netsize; /* stop iter */

+				else {

+					i++;

+

+					if (dist < 0) dist = -dist;

+

+					a = p[0] - b;

+

+					if (a < 0) a = -a;

+

+					dist += a;

+

+					if (dist < bestd) {

+						a = p[2] - r;

+					

+						if (a < 0) a = -a;

+					

+						dist += a;

+					

+						if (dist < bestd) {

+							bestd = dist;

+							best = p[3];

+						}

+					}

+				}

+			}

+			if (j >= 0) {

+				p = network[j];

+			

+				dist = g - p[1]; /* inx key - reverse dif */

+			

+				if (dist >= bestd) j = -1; /* stop iter */

+				else { 

+					j--;

+					if (dist < 0) dist = -dist;

+					a = p[0] - b;

+					if (a < 0) a = -a;

+					dist += a;

+				

+					if (dist < bestd) {

+						a = p[2] - r;

+						if (a < 0)a = -a;

+						dist += a;

+						if (dist < bestd) {

+							bestd = dist;

+							best = p[3];

+						}

+					}

+				}

+			}

+		}

+		return best;

+	}

+	

+	var process = exports.process = function process() {

+		learn();

+		unbiasnet();

+		inxbuild();

+		return colorMap();

+	}

+	

+	/*

+	* Unbias network to give byte values 0..255 and record position i to prepare

+	* for sort

+	* -----------------------------------------------------------------------------------

+	*/

+	

+	var unbiasnet = function unbiasnet() {

+		var i;

+		var j;

+		for (i = 0; i < netsize; i++) {

+			network[i][0] >>= netbiasshift;

+			network[i][1] >>= netbiasshift;

+			network[i][2] >>= netbiasshift;

+			network[i][3] = i; /* record colour no */

+		}

+	}

+	

+	/*

+	* Move adjacent neurons by precomputed alpha*(1-((i-j)^2/[r]^2)) in

+	* radpower[|i-j|]

+	* ---------------------------------------------------------------------------------

+	*/

+	

+	var alterneigh = function alterneigh(rad, i, b, g, r) {

+		var j;

+		var k;

+		var lo;

+		var hi;

+		var a;

+		var m;

+		var p;

+

+		lo = i - rad;

+		if (lo < -1) lo = -1;

+		

+		hi = i + rad;

+		

+		if (hi > netsize) hi = netsize;

+		

+		j = i + 1;

+		k = i - 1;

+		m = 1;

+		

+		while ((j < hi) || (k > lo)) {

+			a = radpower[m++];

+			if (j < hi) {

+				p = network[j++];

+

+				try {

+					p[0] -= (a * (p[0] - b)) / alpharadbias;

+					p[1] -= (a * (p[1] - g)) / alpharadbias;

+					p[2] -= (a * (p[2] - r)) / alpharadbias;

+				} catch (e/*Error*/) {} // prevents 1.3 miscompilation

+			}

+			

+			if (k > lo) {

+				p = network[k--];

+				try { 

+					p[0] -= (a * (p[0] - b)) / alpharadbias;

+					p[1] -= (a * (p[1] - g)) / alpharadbias;

+					p[2] -= (a * (p[2] - r)) / alpharadbias;

+				} catch (e/*Error*/) {}

+			}

+		}

+	}

+	

+	/*

+	* Move neuron i towards biased (b,g,r) by factor alpha

+	* ----------------------------------------------------

+	*/

+	

+	var altersingle = function altersingle(alpha, i, b, g, r) {

+		/* alter hit neuron */

+		var n = network[i];

+		n[0] -= (alpha * (n[0] - b)) / initalpha;

+		n[1] -= (alpha * (n[1] - g)) / initalpha;

+		n[2] -= (alpha * (n[2] - r)) / initalpha;

+	}

+	

+	/*

+	* Search for biased BGR values ----------------------------

+	*/

+	

+	var contest = function contest(b, g, r) {

+		/* finds closest neuron (min dist) and updates freq */

+		/* finds best neuron (min dist-bias) and returns position */

+		/* for frequently chosen neurons, freq[i] is high and bias[i] is negative */

+		/* bias[i] = gamma*((1/netsize)-freq[i]) */

+		

+		var i;

+		var dist;

+		var a;

+		var biasdist;

+		var betafreq;

+		var bestpos;

+		var bestbiaspos;

+		var bestd;

+		var bestbiasd;

+		var n;

+		

+		bestd = ~(1 << 31);

+		bestbiasd = bestd;

+		bestpos = -1;

+		bestbiaspos = bestpos;

+		

+		for (i = 0; i < netsize; i++) {

+			n = network[i];

+			dist = n[0] - b;

+			

+			if (dist < 0) dist = -dist;

+			

+			a = n[1] - g;

+			

+			if (a < 0) a = -a;

+			

+			dist += a;

+			

+			a = n[2] - r;

+			

+			if (a < 0) a = -a;

+			

+			dist += a;

+			

+			if (dist < bestd) {

+				bestd = dist;

+				bestpos = i;

+			}

+			

+			biasdist = dist - ((bias[i]) >> (intbiasshift - netbiasshift));

+			

+			if (biasdist < bestbiasd) {

+				bestbiasd = biasdist;

+				bestbiaspos = i;

+			}

+			

+			betafreq = (freq[i] >> betashift);

+			freq[i] -= betafreq;

+			bias[i] += (betafreq << gammashift);

+		}

+		

+		freq[bestpos] += beta;

+		bias[bestpos] -= betagamma;

+		return (bestbiaspos);

+	}

+	

+	NeuQuant.apply(this, arguments);

+	return exports;

+}

+;importScripts('LZWEncoder.js', 'NeuQuant.js', 'GIFEncoder.js');
+
+self.onmessage = function(event) {
+	var data = event.data;
+	var task = data['task'];
+	switch (task) {
+		case 'encode':
+			encode (data);
+			break;
+		case 'quantize':
+			quantize(data);
+			break;
+		case 'close':
+		  self.close();
+		  break;
+	}
+}
+
+function log(msg) {
+  self.postMessage({
+  	task: 'message',
+		message: msg
+	});
+}
+
+function quantize (data) {
+  var imageData = data["imageData"];
+	var pixels = discardAlphaChannel( imageData.data );
+
+	var nq = new NeuQuant (pixels, pixels.length, 1);
+	var colortab = nq.process();
+
+  self.postMessage({
+  	task: 'quantize',
+		neuquant: nq.save(),
+		colortab: colortab
+	});
+}
+
+function discardAlphaChannel( imageData ) {
+	var pixels = [];
+
+	for ( var i = 0, b = 0, _len = imageData.length; i < _len; b += 4 ) {
+		pixels[i++] = imageData[b];
+		pixels[i++] = imageData[b+1];
+		pixels[i++] = imageData[b+2];
+	}
+	return pixels;
+}
+
+function encode (data) {
+  var frame_index = data["frame_index"];
+  var frame_length = data["frame_length"];
+  var height = data["height"];
+  var width = data["width"];
+  var imageData = data["imageData"];
+  var delay = data["delay"];
+  var neuquant = data["neuquant"];
+  var colortab = data["colortab"];
+
+  // Create a new GIFEncoder for every new worker
+  var encoder = new GIFEncoder();
+  encoder.setRepeat(0); 	// loop forever
+  encoder.setQuality(1);
+  encoder.setSize(width, height);
+  encoder.setDelay(delay);
+
+  if (frame_index == 0) {
+    encoder.start();
+  }
+  else {
+    encoder.cont();
+    encoder.setProperties(true, false); //started, firstFrame
+  }
+
+	// Load the neural net here because the color table gets clobbered by encoder.start();
+  encoder.setNeuquant(neuquant, colortab);
+  encoder.addFrame(imageData, true);
+
+  if(frame_length == frame_index) {
+    encoder.finish();
+  }
+
+  self.postMessage({
+  	task: 'encode',
+		frame_index: frame_index,
+		frame_data: encoder.stream().getData()
+	});
+	// on the page, search for the GIF89a to see the frame_index
+	
+	delete encoder;
+	delete data;
+};
+
diff --git a/js/worker.min.js b/js/worker.min.js
new file mode 100644
index 0000000..91c5f07
--- /dev/null
+++ b/js/worker.min.js
@@ -0,0 +1 @@
+var workerURL = URL.createObjectURL( new Blob([ '(',function(){function log(a){self.postMessage({task:"message",message:a})}function quantize(a){var b=a.imageData,c=discardAlphaChannel(b.data),d=new NeuQuant(c,c.length,1),e=d.process();self.postMessage({task:"quantize",neuquant:d.save(),colortab:e})}function discardAlphaChannel(a){for(var b=[],c=0,d=0,e=a.length;e>c;d+=4)b[c++]=a[d],b[c++]=a[d+1],b[c++]=a[d+2];return b}function encode(a){var b=a.frame_index,c=a.frame_length,d=a.height,e=a.width,f=a.imageData,g=a.delay,h=a.neuquant,i=a.colortab,j=new GIFEncoder;j.setRepeat(0),j.setQuality(1),j.setSize(e,d),j.setDelay(g),0==b?j.start():(j.cont(),j.setProperties(!0,!1)),j.setNeuquant(h,i),j.addFrame(f,!0),c==b&&j.finish(),self.postMessage({task:"encode",frame_index:b,frame_data:j.stream().getData()}),delete j,delete a}GIFEncoder=function(){function a(){this.bin=[]}for(var b=0,c={};256>b;b++)c[b]=String.fromCharCode(b);a.prototype.getData=function(){for(var a="",b=this.bin.length,d=0;b>d;d++)a+=c[this.bin[d]];return a},a.prototype.writeByte=function(a){this.bin.push(a)},a.prototype.writeUTFBytes=function(a){for(var b=a.length,c=0;b>c;c++)this.writeByte(a.charCodeAt(c))},a.prototype.writeBytes=function(a,b,c){for(var d=c||a.length,e=b||0;d>e;e++)this.writeByte(a[e])};{var d,e,f,g,h,i,j,k,l,m={},n=null,o=-1,p=0,q=!1,r=new Array,s=7,t=-1,u=!1,v=!0,w=!1,x=1,y=null,z=(m.setDelay=function(a){p=Math.round(a/10)},m.setDispose=function(a){a>=0&&(t=a)},m.setRepeat=function(a){a>=0&&(o=a)},m.setTransparent=function(a){n=a},m.addFrame=function(a,b){if(null==a||!q||null==g)throw new Error("Please call start method before calling addFrame");var c=!0;try{b?h=a:(h=a.getImageData(0,0,a.canvas.width,a.canvas.height).data,w||A(a.canvas.width,a.canvas.height)),D(),B(),v&&(G(),I(),o>=0&&H()),E(),F(),v||I(),K(),v=!1}catch(d){c=!1}return c},m.finish=function(){if(!q)return!1;var a=!0;q=!1;try{g.writeByte(59)}catch(b){a=!1}return a},function(){f=0,h=null,i=null,j=null,l=null,u=!1,v=!0}),A=(m.setFrameRate=function(a){15!=a&&(p=Math.round(100/a))},m.setQuality=function(a){x=Math.max(1,a)},m.setSize=function(a,b){(!q||v)&&(d=a,e=b,1>d&&(d=320),1>e&&(e=240),w=!0)}),B=(m.setNeuquant=function(a,b){y=a,l=b},m.start=function(){z();var b=!0;u=!1,g=new a;try{g.writeUTFBytes("GIF89a")}catch(c){b=!1}return q=b},m.cont=function(){z();var b=!0;return u=!1,g=new a,q=b},function(){var a=i.length,b=a/3;j=[];var c;y&&l?(c=new NeuQuant,c.load(y)):(c=new NeuQuant(i,a,x),l=c.process());for(var d=0,e=0;b>e;e++){var g=c.map(255&i[d++],255&i[d++],255&i[d++]);r[g]=!0,j[e]=g}i=null,k=8,s=7,null!=n&&(f=C(n))}),C=function(a){if(null==l)return-1;for(var b=(16711680&a)>>16,c=(65280&a)>>8,d=255&a,e=0,f=16777216,g=l.length,h=0;g>h;){var i=b-(255&l[h++]),j=c-(255&l[h++]),k=d-(255&l[h]),m=i*i+j*j+k*k,n=h/3;r[n]&&f>m&&(f=m,e=n),h++}return e},D=function(){var a=d,b=e;i=[];for(var c=h,f=0,g=0;b>g;g++)for(var j=0;a>j;j++){var k=g*a*4+4*j;i[f++]=c[k],i[f++]=c[k+1],i[f++]=c[k+2]}},E=function(){g.writeByte(33),g.writeByte(249),g.writeByte(4);var a,b;null==n?(a=0,b=0):(a=1,b=2),t>=0&&(b=7&t),b<<=2,g.writeByte(0|b|0|a),J(p),g.writeByte(f),g.writeByte(0)},F=function(){g.writeByte(44),J(0),J(0),J(d),J(e),g.writeByte(v?0:128|s)},G=function(){J(d),J(e),g.writeByte(240|s),g.writeByte(0),g.writeByte(0)},H=function(){g.writeByte(33),g.writeByte(255),g.writeByte(11),g.writeUTFBytes("NETSCAPE2.0"),g.writeByte(3),g.writeByte(1),J(o),g.writeByte(0)},I=function(){g.writeBytes(l);for(var a=768-l.length,b=0;a>b;b++)g.writeByte(0)},J=function(a){g.writeByte(255&a),g.writeByte(a>>8&255)},K=function(){var a=new LZWEncoder(d,e,j,k);a.encode(g)};m.stream=function(){return g},m.setProperties=function(a,b){q=a,v=b}}return m},LZWEncoder=function(){var a,b,c,d,e,f,g,h,i,j,k,l,m={},n=-1,o=12,p=5003,q=o,r=1<<o,s=new Array,t=new Array,u=p,v=0,w=!1,x=0,y=0,z=[0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535],A=[],B=m.LZWEncoder=function(e,f,g,h){a=e,b=f,c=g,d=Math.max(2,h)},C=function(a,b){A[l++]=a,l>=254&&G(b)},D=function(a){E(u),v=j+2,w=!0,J(j,a)},E=function(a){for(var b=0;a>b;++b)s[b]=-1},F=m.compress=function(a,b){var c,d,e,f,m,o,p;for(i=a,w=!1,g=i,h=H(g),j=1<<a-1,k=j+1,v=j+2,l=0,f=I(),p=0,c=u;65536>c;c*=2)++p;p=8-p,o=u,E(o),J(j,b);a:for(;(e=I())!=n;)if(c=(e<<q)+f,d=e<<p^f,s[d]!=c){if(s[d]>=0){m=o-d,0==d&&(m=1);do if((d-=m)<0&&(d+=o),s[d]==c){f=t[d];continue a}while(s[d]>=0)}J(f,b),f=e,r>v?(t[d]=v++,s[d]=c):D(b)}else f=t[d];J(f,b),J(k,b)},G=(m.encode=function(c){c.writeByte(d),e=a*b,f=0,F(d+1,c),c.writeByte(0)},function(a){l>0&&(a.writeByte(l),a.writeBytes(A,0,l),l=0)}),H=function(a){return(1<<a)-1},I=function(){if(0==e)return n;--e;var a=c[f++];return 255&a},J=function(a,b){for(x&=z[y],y>0?x|=a<<y:x=a,y+=g;y>=8;)C(255&x,b),x>>=8,y-=8;if((v>h||w)&&(w?(h=H(g=i),w=!1):(++g,h=g==q?r:H(g))),a==k){for(;y>0;)C(255&x,b),x>>=8,y-=8;G(b)}};return B.apply(this,arguments),m},NeuQuant=function(){var a,b,c,d,e,f={},g=128,h=499,i=491,j=487,k=503,l=3*k,m=g-1,n=4,o=100,p=16,q=1<<p,r=10,s=10,t=q>>s,u=q<<r-s,v=g>>3,w=6,x=1<<w,y=v*x,z=30,A=10,B=1<<A,C=8,D=1<<C,E=A+C,F=1<<E,G=new Array,H=new Array,I=new Array,J=new Array,K=f.NeuQuant=function(a,f,h){if(a&&f&&h){var i,j;for(b=a,c=f,d=h,e=new Array(g),i=0;g>i;i++)e[i]=new Array(4),j=e[i],j[0]=j[1]=j[2]=(i<<n+8)/g,I[i]=q/g,H[i]=0}},L=function(){for(var a=[],b=new Array(g),c=0;g>c;c++)b[e[c][3]]=c;for(var d=0,f=0;g>f;f++){var h=b[f];a[d++]=e[h][0],a[d++]=e[h][1],a[d++]=e[h][2]}return a},M=function(){var a,b,c,d,f,h,i,j;for(i=0,j=0,a=0;g>a;a++){for(f=e[a],c=a,d=f[1],b=a+1;g>b;b++)h=e[b],h[1]<d&&(c=b,d=h[1]);if(h=e[c],a!=c&&(b=h[0],h[0]=f[0],f[0]=b,b=h[1],h[1]=f[1],f[1]=b,b=h[2],h[2]=f[2],f[2]=b,b=h[3],h[3]=f[3],f[3]=b),d!=i){for(G[i]=j+a>>1,b=i+1;d>b;b++)G[b]=a;i=d,j=a}}for(G[i]=j+m>>1,b=i+1;256>b;b++)G[b]=m},N=function(){var e,f,g,m,p,q,r,s,t,u,v,x,A,C;for(l>c&&(d=1),a=30+(d-1)/3,x=b,A=0,C=c,v=c/(3*d),u=v/o,s=B,q=y,r=q>>w,1>=r&&(r=0),e=0;r>e;e++)J[e]=s*((r*r-e*e)*D/(r*r));for(t=l>c?3:c%h!=0?3*h:c%i!=0?3*i:c%j!=0?3*j:3*k,e=0;v>e;)if(g=(255&x[A+0])<<n,m=(255&x[A+1])<<n,p=(255&x[A+2])<<n,f=R(g,m,p),Q(s,f,g,m,p),0!=r&&P(r,f,g,m,p),A+=t,A>=C&&(A-=c),e++,0==u&&(u=1),e%u==0)for(s-=s/a,q-=q/z,r=q>>w,1>=r&&(r=0),f=0;r>f;f++)J[f]=s*((r*r-f*f)*D/(r*r))},O=(f.save=function(){var a={netindex:G,netsize:g,network:e};return a},f.load=function(a){G=a.netindex,g=a.netsize,e=a.network},f.map=function(a,b,c){var d,f,h,i,j,k,l;for(j=1e3,l=-1,d=G[b],f=d-1;g>d||f>=0;)g>d&&(k=e[d],h=k[1]-b,h>=j?d=g:(d++,0>h&&(h=-h),i=k[0]-a,0>i&&(i=-i),h+=i,j>h&&(i=k[2]-c,0>i&&(i=-i),h+=i,j>h&&(j=h,l=k[3])))),f>=0&&(k=e[f],h=b-k[1],h>=j?f=-1:(f--,0>h&&(h=-h),i=k[0]-a,0>i&&(i=-i),h+=i,j>h&&(i=k[2]-c,0>i&&(i=-i),h+=i,j>h&&(j=h,l=k[3]))));return l},f.process=function(){return N(),O(),M(),L()},function(){var a;for(a=0;g>a;a++)e[a][0]>>=n,e[a][1]>>=n,e[a][2]>>=n,e[a][3]=a}),P=function(a,b,c,d,f){var h,i,j,k,l,m,n;for(j=b-a,-1>j&&(j=-1),k=b+a,k>g&&(k=g),h=b+1,i=b-1,m=1;k>h||i>j;){if(l=J[m++],k>h){n=e[h++];try{n[0]-=l*(n[0]-c)/F,n[1]-=l*(n[1]-d)/F,n[2]-=l*(n[2]-f)/F}catch(o){}}if(i>j){n=e[i--];try{n[0]-=l*(n[0]-c)/F,n[1]-=l*(n[1]-d)/F,n[2]-=l*(n[2]-f)/F}catch(o){}}}},Q=function(a,b,c,d,f){var g=e[b];g[0]-=a*(g[0]-c)/B,g[1]-=a*(g[1]-d)/B,g[2]-=a*(g[2]-f)/B},R=function(a,b,c){var d,f,h,i,j,k,l,m,o,q;for(m=~(1<<31),o=m,k=-1,l=k,d=0;g>d;d++)q=e[d],f=q[0]-a,0>f&&(f=-f),h=q[1]-b,0>h&&(h=-h),f+=h,h=q[2]-c,0>h&&(h=-h),f+=h,m>f&&(m=f,k=d),i=f-(H[d]>>p-n),o>i&&(o=i,l=d),j=I[d]>>s,I[d]-=j,H[d]+=j<<r;return I[k]+=t,H[k]-=u,l};return K.apply(this,arguments),f},importScripts("LZWEncoder.js","NeuQuant.js","GIFEncoder.js"),self.onmessage=function(a){var b=a.data,c=b.task;switch(c){case"encode":encode(b);break;case"quantize":quantize(b);break;case"close":self.close()}};}.toString(),')()' ], { type: 'application/javascript' } ) )
\ No newline at end of file
diff --git a/js/worker/GIFEncoder.js b/js/worker/GIFEncoder.js
new file mode 100755
index 0000000..01d3618
--- /dev/null
+++ b/js/worker/GIFEncoder.js
@@ -0,0 +1,513 @@
+/**

+* This class lets you encode animated GIF files

+* Base class :  http://www.java2s.com/Code/Java/2D-Graphics-GUI/AnimatedGifEncoder.htm

+* @author Kevin Weiner (original Java version - kweiner@fmsware.com)

+* @author Thibault Imbert (AS3 version - bytearray.org)

+* @version 0.1 AS3 implementation

+*/

+

+//import flash.utils.ByteArray;

+//import flash.display.BitmapData;

+//import flash.display.Bitmap;

+//import org.bytearray.gif.encoder.NeuQuant

+//import flash.net.URLRequestHeader;

+//import flash.net.URLRequestMethod;

+//import flash.net.URLRequest;

+//import flash.net.navigateToURL;

+

+GIFEncoder = function() {

+	for(var i = 0, chr = {}; i < 256; i++) {

+		chr[i] = String.fromCharCode(i);

+  }

+			

+	function ByteArray(){

+		this.bin = [];

+	}

+

+	ByteArray.prototype.getData = function(){

+		for(var v = '', l = this.bin.length, i = 0; i < l; i++) {

+			v += chr[this.bin[i]];

+		}

+		return v;

+	}

+	ByteArray.prototype.writeByte = function(val){

+		this.bin.push(val);

+	}

+	ByteArray.prototype.writeUTFBytes = function(string) {

+		for(var l = string.length, i = 0; i < l; i++) {

+			this.writeByte(string.charCodeAt(i));

+		}

+	}

+	ByteArray.prototype.writeBytes = function(array, offset, length) {

+		for(var l = length || array.length, i = offset||0; i < l; i++) {

+			this.writeByte(array[i]);

+		}

+	}

+

+	var exports = {};

+	var width/*int*/ // image size

+	var height/*int*/;

+	var transparent/***/ = null; // transparent color if given

+	var transIndex/*int*/; // transparent index in color table

+	var repeat/*int*/ = -1; // no repeat

+	var delay/*int*/ = 0; // frame delay (hundredths)

+	var started/*Boolean*/ = false; // ready to output frames

+	var out/*ByteArray*/;

+	var image/*Bitmap*/; // current frame

+	var pixels/*ByteArray*/; // BGR byte array from frame

+	var indexedPixels/*ByteArray*/ // converted frame indexed to palette

+	var colorDepth/*int*/; // number of bit planes

+	var colorTab/*ByteArray*/; // RGB palette

+	var usedEntry/*Array*/ = new Array; // active palette entries

+	var palSize/*int*/ = 7; // color table size (bits-1)

+	var dispose/*int*/ = -1; // disposal code (-1 = use default)

+	var closeStream/*Boolean*/ = false; // close stream when finished

+	var firstFrame/*Boolean*/ = true;

+	var sizeSet/*Boolean*/ = false; // if false, get size from first frame

+	var sample/*int*/ = 1; // default sample interval for quantizer

+	var neuquantBrain = null;  // allow loading in a prefab neural net

+

+	/**

+	* Sets the delay time between each frame, or changes it for subsequent frames

+	* (applies to last frame added)

+	* int delay time in milliseconds

+	* @param ms

+	*/

+	

+	var setDelay = exports.setDelay = function setDelay(ms/*int*/) {

+		delay = Math.round(ms / 10);

+	}

+	

+	/**

+	* Sets the GIF frame disposal code for the last added frame and any

+	* 

+	* subsequent frames. Default is 0 if no transparent color has been set,

+	* otherwise 2.

+	* @param code

+	* int disposal code.

+	*/

+	

+	var setDispose = exports.setDispose = function setDispose(code/*int*/) {

+		if (code >= 0) dispose = code;

+	}

+	

+	/**

+	* Sets the number of times the set of GIF frames should be played. Default is

+	* 1; 0 means play indefinitely. Must be invoked before the first image is

+	* added.

+	* 

+	* @param iter

+	* int number of iterations.

+	* @return

+	*/

+	

+	var setRepeat = exports.setRepeat = function setRepeat(iter/*int*/) {

+		if (iter >= 0) repeat = iter;

+	}

+	

+	/**

+	* Sets the transparent color for the last added frame and any subsequent

+	* frames. Since all colors are subject to modification in the quantization

+	* process, the color in the final palette for each frame closest to the given

+	* color becomes the transparent color for that frame. May be set to null to

+	* indicate no transparent color.

+	* @param

+	* Color to be treated as transparent on display.

+	*/

+	

+	var setTransparent = exports.setTransparent = function setTransparent(c/*Number*/) {

+		transparent = c;

+	}

+	

+	/**

+	* The addFrame method takes an incoming BitmapData object to create each frames

+	* @param

+	* BitmapData object to be treated as a GIF's frame

+	*/

+	

+	/*Boolean*/

+	var addFrame = exports.addFrame = function addFrame(im/*BitmapData*/, is_imageData) {

+		if ((im == null) || ! started || out == null) {

+			throw new Error ("Please call start method before calling addFrame");

+			return false;

+		}

+		

+		var ok/*Boolean*/ = true;

+

+		try {

+			if ( ! is_imageData) {

+				image = im.getImageData(0,0, im.canvas.width, im.canvas.height).data;

+				if ( ! sizeSet) {

+					setSize(im.canvas.width, im.canvas.height);

+				}

+			}

+			else {

+				image = im;

+			}

+			getImagePixels(); // convert to correct format if necessary

+			analyzePixels(); // build color table & map pixels

+			

+			if (firstFrame) {

+				writeLSD(); // logical screen descriptior

+				writePalette(); // global color table

+				if (repeat >= 0) {

+					// use NS app extension to indicate reps

+					writeNetscapeExt();

+				}

+			}

+			

+			writeGraphicCtrlExt(); // write graphic control extension

+			writeImageDesc(); // image descriptor

+			if (!firstFrame) {

+				writePalette(); // local color table

+			}

+			writePixels(); // encode and write pixel data

+			firstFrame = false;

+		}

+		catch (e/*Error*/) {

+			ok = false;

+		}

+		return ok;

+	}

+	

+	/**

+	* Adds final trailer to the GIF stream, if you don't call the finish method

+	* the GIF stream will not be valid.

+	*/

+	

+	/*Boolean*/

+	var finish = exports.finish = function finish() {

+		if ( ! started) {

+			return false;

+		}

+

+		var ok/*Boolean*/ = true;

+		started = false;

+		try {

+			out.writeByte(0x3b); // gif trailer

+		}

+		catch (e/*Error*/) {

+			ok = false;

+		}

+		return ok;

+	}

+	

+	/**

+	* Resets some members so that a new stream can be started.

+	* This method is actually called by the start method

+	*/

+	

+	var reset = function reset () {

+		// reset for subsequent use

+		transIndex = 0;

+		image = null;

+		pixels = null;

+		indexedPixels = null;

+		colorTab = null;

+		closeStream = false;

+		firstFrame = true;

+	}

+

+	/**

+	* * Sets frame rate in frames per second. Equivalent to

+	* <code>setDelay(1000/fps)</code>.

+	* @param fps

+	* float frame rate (frames per second)         

+	*/

+	

+	var setFrameRate = exports.setFrameRate = function setFrameRate(fps/*Number*/) {

+		if (fps != 0xf) {

+			delay = Math.round(100/fps);

+		}

+	}

+	

+	/**

+	* Sets quality of color quantization (conversion of images to the maximum 256

+	* colors allowed by the GIF specification). Lower values (minimum = 1)

+	* produce better colors, but slow processing significantly. 10 is the

+	* default, and produces good color mapping at reasonable speeds. Values

+	* greater than 20 do not yield significant improvements in speed.

+	* @param quality

+	* int greater than 0.

+	* @return

+	*/

+	

+	var setQuality = exports.setQuality = function setQuality(quality/*int*/) {

+		sample = Math.max(1, quality);

+	}

+	

+	/**

+	* Sets the GIF frame size. The default size is the size of the first frame

+	* added if this method is not invoked.

+	* @param w

+	* int frame width.

+	* @param h

+	* int frame width.

+	*/

+	

+	var setSize = exports.setSize = function setSize(w/*int*/, h/*int*/) {

+		if (started && !firstFrame) {

+			return;

+		}

+		width = w;

+		height = h;

+		if (width < 1) width = 320;

+		if (height < 1) height = 240;

+		sizeSet = true;

+	}

+	

+	/**

+	*	After running the Neuquant on some test frames, it can be exported and then loaded

+	* into an uninitialized NQ instance on another worker and used accordingly.

+	*/

+	var setNeuquant = exports.setNeuquant = function setNeuquant(neuquant, colors){

+		neuquantBrain = neuquant;

+		colorTab = colors;

+	}

+	

+	/**

+	* Initiates GIF file creation on the given stream.

+	* @param os

+	* OutputStream on which GIF images are written.

+	* @return false if initial write failed.

+	*/

+	

+	var start = exports.start = function start() {

+		reset(); 

+		var ok/*Boolean*/ = true;

+		closeStream = false;

+		out = new ByteArray;

+		try {

+			out.writeUTFBytes("GIF89a"); // header

+		} catch (e/*Error*/) {

+			ok = false;

+		}

+		

+		return started = ok;

+	}

+	

+	var cont = exports.cont = function cont() {

+		reset(); 

+		var ok = true;

+		closeStream = false;

+		out = new ByteArray ();

+		return started = ok;

+	}

+	

+	/**

+	* Analyzes image colors and creates color map.

+	*/

+	

+	var analyzePixels = function analyzePixels() {

+		var len = pixels.length;

+		var nPix = len / 3;

+		indexedPixels = [];

+		// initialize quantizer

+		

+		var nq;

+		if (neuquantBrain && colorTab) {

+			nq = new NeuQuant();

+			nq.load(neuquantBrain);

+		}

+		else {

+			nq = new NeuQuant (pixels, len, sample);

+			colorTab = nq.process(); // create reduced palette

+		}

+		

+		// map image pixels to new palette

+		var k = 0;

+		for (var j = 0; j < nPix; j++) {

+			var index = nq.map(pixels[k++] & 0xff, pixels[k++] & 0xff, pixels[k++] & 0xff);

+			usedEntry[index] = true;

+			indexedPixels[j] = index;

+		}

+		pixels = null;

+		colorDepth = 8;

+		palSize = 7;

+		

+		// get closest match to transparent color if specified

+		if (transparent != null) {

+			transIndex = findClosest(transparent);

+		}

+	}

+	

+	/**

+	* Returns index of palette color closest to c

+	*/

+	

+	var findClosest = function findClosest(c/*Number*/) {

+		if (colorTab == null) return -1;

+		var r = (c & 0xFF0000) >> 16;

+		var g = (c & 0x00FF00) >> 8;

+		var b = (c & 0x0000FF);

+		var minpos = 0;

+		var dmin = 256 * 256 * 256;

+		var len = colorTab.length;

+		

+		for (var i = 0; i < len;) {

+			var dr = r - (colorTab[i++] & 0xff);

+			var dg = g - (colorTab[i++] & 0xff);

+			var db = b - (colorTab[i] & 0xff);

+			var d = dr * dr + dg * dg + db * db;

+			var index = i / 3;

+			if (usedEntry[index] && (d < dmin)) {

+				dmin = d;

+				minpos = index;

+			}

+			i++;

+		}

+		return minpos;

+	}

+	

+	/**

+	* Extracts image pixels into byte array "pixels

+	*/

+	

+	var getImagePixels = function getImagePixels() {

+		var w = width;

+		var h = height;

+		pixels = [];

+		var data = image;

+		var count/*int*/ = 0;

+			

+		for ( var i/*int*/ = 0; i < h; i++ ) {

+			for (var j/*int*/ = 0; j < w; j++ ) {

+				var b = (i*w*4)+j*4;

+				pixels[count++] = data[b];

+				pixels[count++] = data[b+1];

+				pixels[count++] = data[b+2];

+			}

+		}

+	}

+	

+	/**

+	* Writes Graphic Control Extension

+	*/

+	

+	var writeGraphicCtrlExt = function writeGraphicCtrlExt() {

+		out.writeByte(0x21); // extension introducer

+		out.writeByte(0xf9); // GCE label

+		out.writeByte(4); // data block size

+		var transp/*int*/

+		var disp/*int*/;

+		if (transparent == null) {

+			transp = 0;

+			disp = 0; // dispose = no action

+		}

+		else {

+			transp = 1;

+			disp = 2; // force clear if using transparent color

+		}

+		if (dispose >= 0) {

+			disp = dispose & 7; // user override

+		}

+		disp <<= 2;

+		// packed fields

+		out.writeByte(0 | // 1:3 reserved

+				disp | // 4:6 disposal

+				0 | // 7 user input - 0 = none

+				transp); // 8 transparency flag

+	

+		WriteShort(delay); // delay x 1/100 sec

+		out.writeByte(transIndex); // transparent color index

+		out.writeByte(0); // block terminator

+	}

+

+	/**

+	* Writes Image Descriptor

+	*/

+	

+	var writeImageDesc = function writeImageDesc() {

+		out.writeByte(0x2c); // image separator

+		WriteShort(0); // image position x,y = 0,0

+		WriteShort(0);

+		WriteShort(width); // image size

+		WriteShort(height);

+

+		// packed fields

+		if (firstFrame) {

+			// no LCT - GCT is used for first (or only) frame

+			out.writeByte(0);

+		}

+		else {

+			// specify normal LCT

+			out.writeByte(0x80 | // 1 local color table 1=yes

+					0 | // 2 interlace - 0=no

+					0 | // 3 sorted - 0=no

+					0 | // 4-5 reserved

+					palSize); // 6-8 size of color table

+		}

+	}

+	

+	/**

+	* Writes Logical Screen Descriptor

+	*/

+	

+	var writeLSD = function writeLSD() {

+		// logical screen size

+		WriteShort(width);

+		WriteShort(height);

+		// packed fields

+		out.writeByte((0x80 | // 1 : global color table flag = 1 (gct used)

+				0x70 | // 2-4 : color resolution = 7

+				0x00 | // 5 : gct sort flag = 0

+				palSize)); // 6-8 : gct size

+

+		out.writeByte(0); // background color index

+		out.writeByte(0); // pixel aspect ratio - assume 1:1

+	}

+	

+	/**

+	* Writes Netscape application extension to define repeat count.

+	*/

+	

+	var writeNetscapeExt = function writeNetscapeExt() {

+		out.writeByte(0x21); // extension introducer

+		out.writeByte(0xff); // app extension label

+		out.writeByte(11); // block size

+		out.writeUTFBytes("NETSCAPE" + "2.0"); // app id + auth code

+		out.writeByte(3); // sub-block size

+		out.writeByte(1); // loop sub-block id

+		WriteShort(repeat); // loop count (extra iterations, 0=repeat forever)

+		out.writeByte(0); // block terminator

+	}

+	

+	/**

+	* Writes color table

+	*/

+	var writePalette = function writePalette() {

+		out.writeBytes(colorTab);

+		var n/*int*/ = (3 * 256) - colorTab.length;

+		for (var i/*int*/ = 0; i < n; i++) {

+			out.writeByte(0);

+		}

+	}

+	

+	var WriteShort = function WriteShort (pValue/*int*/) { 

+		out.writeByte( pValue & 0xFF );

+		out.writeByte( (pValue >> 8) & 0xFF);

+	}

+	

+	/**

+	* Encodes and writes pixel data

+	*/

+	var writePixels = function writePixels() {

+		var myencoder = new LZWEncoder(width, height, indexedPixels, colorDepth);

+		myencoder.encode(out);

+	}

+	

+	/**

+	* retrieves the GIF stream

+	*/

+	var stream = exports.stream = function stream () {

+		return out; 

+	}

+	

+	var setProperties = exports.setProperties = function setProperties(has_start, is_first) {

+		started = has_start;

+		firstFrame = is_first;

+	}

+	

+	return exports;

+}

+

diff --git a/js/worker/LZWEncoder.js b/js/worker/LZWEncoder.js
new file mode 100644
index 0000000..e3c512a
--- /dev/null
+++ b/js/worker/LZWEncoder.js
@@ -0,0 +1,328 @@
+/**

+* This class handles LZW encoding

+* Adapted from Jef Poskanzer's Java port by way of J. M. G. Elliott.

+* @author Kevin Weiner (original Java version - kweiner@fmsware.com)

+* @author Thibault Imbert (AS3 version - bytearray.org)

+* @version 0.1 AS3 implementation

+*/

+

+//import flash.utils.ByteArray;

+

+LZWEncoder = function()

+{

+		var exports = {};

+	/*private_static*/ var EOF/*int*/ = -1;

+	/*private*/ var imgW/*int*/;

+	/*private*/ var imgH/*int*/

+	/*private*/ var pixAry/*ByteArray*/;

+	/*private*/ var initCodeSize/*int*/;

+	/*private*/ var remaining/*int*/;

+	/*private*/ var curPixel/*int*/;

+	

+	// GIFCOMPR.C - GIF Image compression routines

+	// Lempel-Ziv compression based on 'compress'. GIF modifications by

+	// David Rowley (mgardi@watdcsu.waterloo.edu)

+	// General DEFINEs

+	

+	/*private_static*/ var BITS/*int*/ = 12;

+	/*private_static*/ var HSIZE/*int*/ = 5003; // 80% occupancy

+	

+	// GIF Image compression - modified 'compress'

+	// Based on: compress.c - File compression ala IEEE Computer, June 1984.

+	// By Authors: Spencer W. Thomas (decvax!harpo!utah-cs!utah-gr!thomas)

+	// Jim McKie (decvax!mcvax!jim)

+	// Steve Davies (decvax!vax135!petsd!peora!srd)

+	// Ken Turkowski (decvax!decwrl!turtlevax!ken)

+	// James A. Woods (decvax!ihnp4!ames!jaw)

+	// Joe Orost (decvax!vax135!petsd!joe)

+	

+	/*private*/ var n_bits/*int*/ // number of bits/code

+	/*private*/ var maxbits/*int*/ = BITS; // user settable max # bits/code

+	/*private*/ var maxcode/*int*/ // maximum code, given n_bits

+	/*private*/ var maxmaxcode/*int*/ = 1 << BITS; // should NEVER generate this code

+	/*private*/ var htab/*Array*/ = new Array;

+	/*private*/ var codetab/*Array*/ = new Array;

+	/*private*/ var hsize/*int*/ = HSIZE; // for dynamic table sizing

+	/*private*/ var free_ent/*int*/ = 0; // first unused entry

+	

+	// block compression parameters -- after all codes are used up,

+	// and compression rate changes, start over.

+	

+	/*private*/ var clear_flg/*Boolean*/ = false;

+	

+	// Algorithm: use open addressing double hashing (no chaining) on the

+	// prefix code / next character combination. We do a variant of Knuth's

+	// algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime

+	// secondary probe. Here, the modular division first probe is gives way

+	// to a faster exclusive-or manipulation. Also do block compression with

+	// an adaptive reset, whereby the code table is cleared when the compression

+	// ratio decreases, but after the table fills. The variable-length output

+	// codes are re-sized at this point, and a special CLEAR code is generated

+	// for the decompressor. Late addition: construct the table according to

+	// file size for noticeable speed improvement on small files. Please direct

+	// questions about this implementation to ames!jaw.

+	

+	/*private*/ var g_init_bits/*int*/;

+	/*private*/ var ClearCode/*int*/;

+	/*private*/ var EOFCode/*int*/;

+	

+	// output

+	// Output the given code.

+	// Inputs:

+	// code: A n_bits-bit integer. If == -1, then EOF. This assumes

+	// that n_bits =< wordsize - 1.

+	// Outputs:

+	// Outputs code to the file.

+	// Assumptions:

+	// Chars are 8 bits long.

+	// Algorithm:

+	// Maintain a BITS character long buffer (so that 8 codes will

+	// fit in it exactly). Use the VAX insv instruction to insert each

+	// code in turn. When the buffer fills up empty it and start over.

+	

+	/*private*/ var cur_accum/*int*/ = 0;

+	/*private*/ var cur_bits/*int*/ = 0;

+	/*private*/ var masks/*Array*/ = [ 0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF, 0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF ];

+	

+	// Number of characters so far in this 'packet'

+	/*private*/ var a_count/*int*/;

+	

+	// Define the storage for the packet accumulator

+	/*private*/ var accum/*ByteArray*/ = [];

+	

+	var LZWEncoder = exports.LZWEncoder = function LZWEncoder (width/*int*/, height/*int*/, pixels/*ByteArray*/, color_depth/*int*/)

+	{

+		

+		imgW = width;

+		imgH = height;

+		pixAry = pixels;

+		initCodeSize = Math.max(2, color_depth);

+		

+	}

+	

+	// Add a character to the end of the current packet, and if it is 254

+	// characters, flush the packet to disk.

+	var char_out = function char_out(c/*Number*/, outs/*ByteArray*/)/*void*/

+	{

+		accum[a_count++] = c;

+		if (a_count >= 254) flush_char(outs);

+		

+	}

+	

+	// Clear out the hash table

+	// table clear for block compress

+	

+	var cl_block = function cl_block(outs/*ByteArray*/)/*void*/

+	{

+		

+		cl_hash(hsize);

+		free_ent = ClearCode + 2;

+		clear_flg = true;

+		output(ClearCode, outs);

+		

+	}

+	

+	// reset code table

+	var cl_hash = function cl_hash(hsize/*int*/)/*void*/

+	{

+		

+		for (var i/*int*/ = 0; i < hsize; ++i) htab[i] = -1;

+		

+	}

+	

+	var compress = exports.compress = function compress(init_bits/*int*/, outs/*ByteArray*/)/*void*/

+	

+	{

+		var fcode/*int*/;

+		var i/*int*/ /* = 0 */;

+		var c/*int*/;

+		var ent/*int*/;

+		var disp/*int*/;

+		var hsize_reg/*int*/;

+		var hshift/*int*/;

+		

+		// Set up the globals: g_init_bits - initial number of bits

+		g_init_bits = init_bits;

+		

+		// Set up the necessary values

+		clear_flg = false;

+		n_bits = g_init_bits;

+		maxcode = MAXCODE(n_bits);

+

+		ClearCode = 1 << (init_bits - 1);

+		EOFCode = ClearCode + 1;

+		free_ent = ClearCode + 2;

+

+		a_count = 0; // clear packet

+	

+		ent = nextPixel();

+

+		hshift = 0;

+		for (fcode = hsize; fcode < 65536; fcode *= 2)

+			++hshift;

+		hshift = 8 - hshift; // set hash code range bound

+

+		hsize_reg = hsize;

+		cl_hash(hsize_reg); // clear hash table

+	

+		output(ClearCode, outs);

+	

+		outer_loop: while ((c = nextPixel()) != EOF)

+		

+		{

+			

+			fcode = (c << maxbits) + ent;

+			i = (c << hshift) ^ ent; // xor hashing

+

+			if (htab[i] == fcode)

+			{

+			ent = codetab[i];

+			continue;

+			} else if (htab[i] >= 0) // non-empty slot

+			{

+				disp = hsize_reg - i; // secondary hash (after G. Knott)

+				if (i == 0)

+				disp = 1;

+				do 

+				{

+					

+					if ((i -= disp) < 0) i += hsize_reg;

+

+					if (htab[i] == fcode)

+					{

+					ent = codetab[i];

+					continue outer_loop;

+					}

+				} while (htab[i] >= 0);

+			}

+			

+			output(ent, outs);

+			ent = c;

+			if (free_ent < maxmaxcode)

+			{

+				codetab[i] = free_ent++; // code -> hashtable

+				htab[i] = fcode;

+			} else cl_block(outs);

+		}

+		

+		// Put out the final code.

+		output(ent, outs);

+		output(EOFCode, outs);

+		

+	}

+	

+	// ----------------------------------------------------------------------------

+	var encode = exports.encode = function encode(os/*ByteArray*/)/*void*/

+	{

+		os.writeByte(initCodeSize); // write "initial code size" byte

+		remaining = imgW * imgH; // reset navigation variables

+		curPixel = 0;

+		compress(initCodeSize + 1, os); // compress and write the pixel data

+		os.writeByte(0); // write block terminator

+		

+	}

+	

+	// Flush the packet to disk, and reset the accumulator

+	var flush_char = function flush_char(outs/*ByteArray*/)/*void*/

+	{

+		

+		if (a_count > 0)

+		{

+			outs.writeByte(a_count);

+			outs.writeBytes(accum, 0, a_count);

+			a_count = 0;

+		}

+		

+	}

+	

+	var MAXCODE = function MAXCODE(n_bits/*int*/)/*int*/

+	{

+		

+		return (1 << n_bits) - 1;

+		

+	}

+	

+	// ----------------------------------------------------------------------------

+	// Return the next pixel from the image

+	// ----------------------------------------------------------------------------

+	

+	var nextPixel = function nextPixel()/*int*/

+	{

+		

+		if (remaining == 0) return EOF;

+		

+		--remaining;

+		

+		var pix/*Number*/ = pixAry[curPixel++];

+		

+		return pix & 0xff;

+		

+	}

+	

+	var output = function output(code/*int*/, outs/*ByteArray*/)/*void*/

+	

+	{

+		cur_accum &= masks[cur_bits];

+		

+		if (cur_bits > 0) cur_accum |= (code << cur_bits);

+		else cur_accum = code;

+		

+		cur_bits += n_bits;

+		

+		while (cur_bits >= 8)

+		

+		{

+			

+			char_out((cur_accum & 0xff), outs);

+			cur_accum >>= 8;

+			cur_bits -= 8;

+			

+		}

+		

+		// If the next entry is going to be too big for the code size,

+		// then increase it, if possible.

+		

+		if (free_ent > maxcode || clear_flg)

+		{

+			

+			if (clear_flg)

+			{

+				

+				maxcode = MAXCODE(n_bits = g_init_bits);

+				clear_flg = false;

+				

+			} else

+			{

+				

+				++n_bits;

+				

+				if (n_bits == maxbits) maxcode = maxmaxcode;

+				

+				else maxcode = MAXCODE(n_bits);

+				

+			}

+			

+		}

+		

+		if (code == EOFCode) 

+		{

+			

+			// At EOF, write the rest of the buffer.

+			while (cur_bits > 0) 

+			{

+				

+				char_out((cur_accum & 0xff), outs);

+				cur_accum >>= 8;

+				cur_bits -= 8;

+			}

+			

+			

+			flush_char(outs);

+			

+		}

+		

+	}

+	LZWEncoder.apply(this, arguments);

+	 return exports;

+}

+

diff --git a/js/worker/NeuQuant.js b/js/worker/NeuQuant.js
new file mode 100644
index 0000000..91424ba
--- /dev/null
+++ b/js/worker/NeuQuant.js
@@ -0,0 +1,538 @@
+/*

+* NeuQuant Neural-Net Quantization Algorithm

+* ------------------------------------------

+* 

+* Copyright (c) 1994 Anthony Dekker

+* 

+* NEUQUANT Neural-Net quantization algorithm by Anthony Dekker, 1994. See

+* "Kohonen neural networks for optimal colour quantization" in "Network:

+* Computation in Neural Systems" Vol. 5 (1994) pp 351-367. for a discussion of

+* the algorithm.

+* 

+* Any party obtaining a copy of these files from the author, directly or

+* indirectly, is granted, free of charge, a full and unrestricted irrevocable,

+* world-wide, paid up, royalty-free, nonexclusive right and license to deal in

+* this software and documentation files (the "Software"), including without

+* limitation the rights to use, copy, modify, merge, publish, distribute,

+* sublicense, and/or sell copies of the Software, and to permit persons who

+* receive copies from any such party to do so, with the only requirement being

+* that this copyright notice remain intact.

+*/

+

+/*

+* This class handles Neural-Net quantization algorithm

+* @author Kevin Weiner (original Java version - kweiner@fmsware.com)

+* @author Thibault Imbert (AS3 version - bytearray.org)

+* @version 0.1 AS3 implementation

+*/

+

+//import flash.utils.ByteArray;

+

+NeuQuant = function() {

+	var exports = {};

+	var netsize = 128; /* number of colours used */

+	

+	/* four primes near 500 - assume no image has a length so large */

+	/* that it is divisible by all four primes */

+	

+	var prime1 = 499;

+	var prime2 = 491;

+	var prime3 = 487;

+	var prime4 = 503;

+	var minpicturebytes = (3 * prime4);

+	

+	/* minimum size for input image */

+	/*

+	* Program Skeleton ---------------- [select samplefac in range 1..30] [read

+	* image from input file] pic = (unsigned char*) malloc(3*width*height);

+	* initnet(pic,3*width*height,samplefac); learn(); unbiasnet(); [write output

+	* image header, using writecolourmap(f)] inxbuild(); write output image using

+	* inxsearch(b,g,r)

+	*/

+

+	/*

+	* Network Definitions -------------------

+	*/

+	

+	var maxnetpos = (netsize - 1);

+	var netbiasshift = 4; /* bias for colour values */

+	var ncycles = 100; /* no. of learning cycles */

+	

+	/* defs for freq and bias */

+	var intbiasshift = 16; /* bias for fractions */

+	var intbias = (1 << intbiasshift);

+	var gammashift = 10; /* gamma = 1024 */

+	var gamma = (1 << gammashift);

+	var betashift = 10;

+	var beta = (intbias >> betashift); /* beta = 1/1024 */

+	var betagamma = (intbias << (gammashift - betashift));

+	

+	/* defs for decreasing radius factor */

+	var initrad = (netsize >> 3); /* for 256 cols, radius starts */

+	var radiusbiasshift = 6; /* at 32.0 biased by 6 bits */

+	var radiusbias = (1 << radiusbiasshift);

+	var initradius = (initrad * radiusbias); /* and decreases by a */

+	var radiusdec = 30; /* factor of 1/30 each cycle */

+	

+	/* defs for decreasing alpha factor */

+	var alphabiasshift = 10; /* alpha starts at 1.0 */

+	var initalpha = (1 << alphabiasshift);

+	var alphadec /* biased by 10 bits */

+	

+	/* radbias and alpharadbias used for radpower calculation */

+	var radbiasshift = 8;

+	var radbias = (1 << radbiasshift);

+	var alpharadbshift = (alphabiasshift + radbiasshift);

+	

+	var alpharadbias = (1 << alpharadbshift);

+	

+	/*

+	* Types and Global Variables --------------------------

+	*/

+	

+	var thepicture/*ByteArray*//* the input image itself */

+	var lengthcount; /* lengthcount = H*W*3 */

+	var samplefac; /* sampling factor 1..30 */

+	

+	// typedef int pixel[4]; /* BGRc */

+	var network; /* the network itself - [netsize][4] */

+	var netindex = new Array();

+	

+	/* for network lookup - really 256 */

+	var bias = new Array();

+	

+	/* bias and freq arrays for learning */

+	var freq = new Array();

+	var radpower = new Array();

+	

+	var NeuQuant = exports.NeuQuant = function NeuQuant(thepic, len, sample) {

+

+		// with no input, assume we'll load in a lobotomized neuquant later.

+		// otherwise, initialize the neural net stuff

+

+		if (thepic && len && sample) {

+			var i;

+			var p;

+			

+			thepicture = thepic;

+			lengthcount = len;

+			samplefac = sample;

+			

+			network = new Array(netsize);

+			

+			for (i = 0; i < netsize; i++) {

+				network[i] = new Array(4);

+				p = network[i];

+				p[0] = p[1] = p[2] = (i << (netbiasshift + 8)) / netsize;

+				freq[i] = intbias / netsize; /* 1/netsize */

+				bias[i] = 0;

+			}

+		}

+	}

+	

+	var colorMap = function colorMap() {

+		var map/*ByteArray*/ = [];

+		var index = new Array(netsize);

+		for (var i = 0; i < netsize; i++) {

+			index[network[i][3]] = i;

+		}

+		var k = 0;

+		for (var l = 0; l < netsize; l++) {

+			var j = index[l];

+			map[k++] = (network[j][0]);

+			map[k++] = (network[j][1]);

+			map[k++] = (network[j][2]);

+		}

+		return map;

+	}

+	

+	/*

+	 * Insertion sort of network and building of netindex[0..255] (to do after

+	 * unbias)

+	 * -------------------------------------------------------------------------------

+	 */

+	 

+	 var inxbuild = function inxbuild() {

+		var i;

+		var j;

+		var smallpos;

+		var smallval;

+		var p;

+		var q;

+		var previouscol

+		var startpos

+		

+		previouscol = 0;

+		startpos = 0;

+		for (i = 0; i < netsize; i++) {

+			p = network[i];

+			smallpos = i;

+			smallval = p[1]; /* index on g */

+			/* find smallest in i..netsize-1 */

+			for (j = i + 1; j < netsize; j++) {

+				q = network[j];

+				if (q[1] < smallval) { /* index on g */

+					smallpos = j;

+					smallval = q[1]; /* index on g */

+				}

+			}

+			

+			q = network[smallpos];

+			/* swap p (i) and q (smallpos) entries */

+			

+			if (i != smallpos) {

+				j = q[0];

+				q[0] = p[0];

+				p[0] = j;

+				j = q[1];

+				q[1] = p[1];

+				p[1] = j;

+				j = q[2];

+				q[2] = p[2];

+				p[2] = j;

+				j = q[3];

+				q[3] = p[3];

+				p[3] = j;

+			}

+			

+			/* smallval entry is now in position i */

+			

+			if (smallval != previouscol) {

+				netindex[previouscol] = (startpos + i) >> 1;

+				

+				for (j = previouscol + 1; j < smallval; j++) netindex[j] = i;

+				

+				previouscol = smallval;

+				startpos = i;

+			}

+		}

+		

+		netindex[previouscol] = (startpos + maxnetpos) >> 1;

+		for (j = previouscol + 1; j < 256; j++) netindex[j] = maxnetpos; /* really 256 */

+	 }

+	 

+	 /*

+	 * Main Learning Loop ------------------

+	 */

+	 

+	 var learn = function learn() {

+		 var i;

+		 var j;

+		 var b;

+		 var g

+		 var r;

+		 var radius;

+		 var rad;

+		 var alpha;

+		 var step;

+		 var delta;

+		 var samplepixels;

+		 var p/*ByteArray*/;

+		 var pix;

+		 var lim;

+		 

+		 if (lengthcount < minpicturebytes) samplefac = 1;

+		 

+		 alphadec = 30 + ((samplefac - 1) / 3);

+		 p = thepicture;

+		 pix = 0;

+		 lim = lengthcount;

+		 samplepixels = lengthcount / (3 * samplefac);

+		 delta = samplepixels / ncycles;

+		 alpha = initalpha;

+		 radius = initradius;

+		 

+		 rad = radius >> radiusbiasshift;

+		 if (rad <= 1) rad = 0;

+		 

+		 for (i = 0; i < rad; i++) radpower[i] = alpha * (((rad * rad - i * i) * radbias) / (rad * rad));

+		 

+		 if (lengthcount < minpicturebytes) step = 3;

+		 else if ((lengthcount % prime1) != 0) step = 3 * prime1;

+		 else if ((lengthcount % prime2) != 0) step = 3 * prime2;

+		 else if ((lengthcount % prime3) != 0) step = 3 * prime3;

+		 else step = 3 * prime4;

+		 

+		 i = 0;

+		 

+		 while (i < samplepixels) {

+			 b = (p[pix + 0] & 0xff) << netbiasshift;

+			 g = (p[pix + 1] & 0xff) << netbiasshift;

+			 r = (p[pix + 2] & 0xff) << netbiasshift;

+			 j = contest(b, g, r);

+			 

+			 altersingle(alpha, j, b, g, r);

+			 

+			 if (rad != 0) alterneigh(rad, j, b, g, r); /* alter neighbours */

+			 

+			 pix += step;

+			 

+			 if (pix >= lim) pix -= lengthcount;

+			 

+			 i++;

+			 

+			 if (delta == 0) delta = 1;

+			 

+			 if (i % delta == 0) {

+				 alpha -= alpha / alphadec;

+				 radius -= radius / radiusdec;

+				 rad = radius >> radiusbiasshift;

+				 

+				 if (rad <= 1) rad = 0;

+				 

+				 for (j = 0; j < rad; j++) radpower[j] = alpha * (((rad * rad - j * j) * radbias) / (rad * rad));

+			 }

+		 }

+	 }

+

+

+	/* Save the neural network so we can load it back in on another worker.

+	*/

+	var save = exports.save = function(){

+		var data = {

+			netindex: netindex,

+			netsize: netsize,

+			network: network

+		};

+		return data;

+	}

+	var load = exports.load = function(data){

+		netindex = data.netindex;

+		netsize = data.netsize;

+		network = data.network;

+	}

+	

+	

+	 /*

+	 ** Search for BGR values 0..255 (after net is unbiased) and return colour

+	 * index

+	 * ----------------------------------------------------------------------------

+	 */

+	

+	var map = exports.map = function map(b, g, r) {

+		var i;

+		var j;

+		var dist

+		var a;

+		var bestd;

+		var p;

+		var best;

+		 

+		bestd = 1000; /* biggest possible dist is 256*3 */

+		best = -1;

+		i = netindex[g]; /* index on g */

+		j = i - 1; /* start at netindex[g] and work outwards */

+

+		while ((i < netsize) || (j >= 0)) {

+			if (i < netsize) {

+				p = network[i];

+				dist = p[1] - g; /* inx key */

+				if (dist >= bestd) i = netsize; /* stop iter */

+				else {

+					i++;

+

+					if (dist < 0) dist = -dist;

+

+					a = p[0] - b;

+

+					if (a < 0) a = -a;

+

+					dist += a;

+

+					if (dist < bestd) {

+						a = p[2] - r;

+					

+						if (a < 0) a = -a;

+					

+						dist += a;

+					

+						if (dist < bestd) {

+							bestd = dist;

+							best = p[3];

+						}

+					}

+				}

+			}

+			if (j >= 0) {

+				p = network[j];

+			

+				dist = g - p[1]; /* inx key - reverse dif */

+			

+				if (dist >= bestd) j = -1; /* stop iter */

+				else { 

+					j--;

+					if (dist < 0) dist = -dist;

+					a = p[0] - b;

+					if (a < 0) a = -a;

+					dist += a;

+				

+					if (dist < bestd) {

+						a = p[2] - r;

+						if (a < 0)a = -a;

+						dist += a;

+						if (dist < bestd) {

+							bestd = dist;

+							best = p[3];

+						}

+					}

+				}

+			}

+		}

+		return best;

+	}

+	

+	var process = exports.process = function process() {

+		learn();

+		unbiasnet();

+		inxbuild();

+		return colorMap();

+	}

+	

+	/*

+	* Unbias network to give byte values 0..255 and record position i to prepare

+	* for sort

+	* -----------------------------------------------------------------------------------

+	*/

+	

+	var unbiasnet = function unbiasnet() {

+		var i;

+		var j;

+		for (i = 0; i < netsize; i++) {

+			network[i][0] >>= netbiasshift;

+			network[i][1] >>= netbiasshift;

+			network[i][2] >>= netbiasshift;

+			network[i][3] = i; /* record colour no */

+		}

+	}

+	

+	/*

+	* Move adjacent neurons by precomputed alpha*(1-((i-j)^2/[r]^2)) in

+	* radpower[|i-j|]

+	* ---------------------------------------------------------------------------------

+	*/

+	

+	var alterneigh = function alterneigh(rad, i, b, g, r) {

+		var j;

+		var k;

+		var lo;

+		var hi;

+		var a;

+		var m;

+		var p;

+

+		lo = i - rad;

+		if (lo < -1) lo = -1;

+		

+		hi = i + rad;

+		

+		if (hi > netsize) hi = netsize;

+		

+		j = i + 1;

+		k = i - 1;

+		m = 1;

+		

+		while ((j < hi) || (k > lo)) {

+			a = radpower[m++];

+			if (j < hi) {

+				p = network[j++];

+

+				try {

+					p[0] -= (a * (p[0] - b)) / alpharadbias;

+					p[1] -= (a * (p[1] - g)) / alpharadbias;

+					p[2] -= (a * (p[2] - r)) / alpharadbias;

+				} catch (e/*Error*/) {} // prevents 1.3 miscompilation

+			}

+			

+			if (k > lo) {

+				p = network[k--];

+				try { 

+					p[0] -= (a * (p[0] - b)) / alpharadbias;

+					p[1] -= (a * (p[1] - g)) / alpharadbias;

+					p[2] -= (a * (p[2] - r)) / alpharadbias;

+				} catch (e/*Error*/) {}

+			}

+		}

+	}

+	

+	/*

+	* Move neuron i towards biased (b,g,r) by factor alpha

+	* ----------------------------------------------------

+	*/

+	

+	var altersingle = function altersingle(alpha, i, b, g, r) {

+		/* alter hit neuron */

+		var n = network[i];

+		n[0] -= (alpha * (n[0] - b)) / initalpha;

+		n[1] -= (alpha * (n[1] - g)) / initalpha;

+		n[2] -= (alpha * (n[2] - r)) / initalpha;

+	}

+	

+	/*

+	* Search for biased BGR values ----------------------------

+	*/

+	

+	var contest = function contest(b, g, r) {

+		/* finds closest neuron (min dist) and updates freq */

+		/* finds best neuron (min dist-bias) and returns position */

+		/* for frequently chosen neurons, freq[i] is high and bias[i] is negative */

+		/* bias[i] = gamma*((1/netsize)-freq[i]) */

+		

+		var i;

+		var dist;

+		var a;

+		var biasdist;

+		var betafreq;

+		var bestpos;

+		var bestbiaspos;

+		var bestd;

+		var bestbiasd;

+		var n;

+		

+		bestd = ~(1 << 31);

+		bestbiasd = bestd;

+		bestpos = -1;

+		bestbiaspos = bestpos;

+		

+		for (i = 0; i < netsize; i++) {

+			n = network[i];

+			dist = n[0] - b;

+			

+			if (dist < 0) dist = -dist;

+			

+			a = n[1] - g;

+			

+			if (a < 0) a = -a;

+			

+			dist += a;

+			

+			a = n[2] - r;

+			

+			if (a < 0) a = -a;

+			

+			dist += a;

+			

+			if (dist < bestd) {

+				bestd = dist;

+				bestpos = i;

+			}

+			

+			biasdist = dist - ((bias[i]) >> (intbiasshift - netbiasshift));

+			

+			if (biasdist < bestbiasd) {

+				bestbiasd = biasdist;

+				bestbiaspos = i;

+			}

+			

+			betafreq = (freq[i] >> betashift);

+			freq[i] -= betafreq;

+			bias[i] += (betafreq << gammashift);

+		}

+		

+		freq[bestpos] += beta;

+		bias[bestpos] -= betagamma;

+		return (bestbiaspos);

+	}

+	

+	NeuQuant.apply(this, arguments);

+	return exports;

+}

diff --git a/js/worker/worker.js b/js/worker/worker.js
new file mode 100644
index 0000000..2a69592
--- /dev/null
+++ b/js/worker/worker.js
@@ -0,0 +1,94 @@
+importScripts('LZWEncoder.js', 'NeuQuant.js', 'GIFEncoder.js');
+
+self.onmessage = function(event) {
+	var data = event.data;
+	var task = data['task'];
+	switch (task) {
+		case 'encode':
+			encode (data);
+			break;
+		case 'quantize':
+			quantize(data);
+			break;
+		case 'close':
+		  self.close();
+		  break;
+	}
+}
+
+function log(msg) {
+  self.postMessage({
+  	task: 'message',
+		message: msg
+	});
+}
+
+function quantize (data) {
+  var imageData = data["imageData"];
+	var pixels = discardAlphaChannel( imageData.data );
+
+	var nq = new NeuQuant (pixels, pixels.length, 1);
+	var colortab = nq.process();
+
+  self.postMessage({
+  	task: 'quantize',
+		neuquant: nq.save(),
+		colortab: colortab
+	});
+}
+
+function discardAlphaChannel( imageData ) {
+	var pixels = [];
+
+	for ( var i = 0, b = 0, _len = imageData.length; i < _len; b += 4 ) {
+		pixels[i++] = imageData[b];
+		pixels[i++] = imageData[b+1];
+		pixels[i++] = imageData[b+2];
+	}
+	return pixels;
+}
+
+function encode (data) {
+  var frame_index = data["frame_index"];
+  var frame_length = data["frame_length"];
+  var height = data["height"];
+  var width = data["width"];
+  var imageData = data["imageData"];
+  var delay = data["delay"];
+  var neuquant = data["neuquant"];
+  var colortab = data["colortab"];
+
+  // Create a new GIFEncoder for every new worker
+  var encoder = new GIFEncoder();
+  encoder.setRepeat(0); 	// loop forever
+  encoder.setQuality(1);
+  encoder.setSize(width, height);
+  encoder.setDelay(delay);
+
+  if (frame_index == 0) {
+    encoder.start();
+  }
+  else {
+    encoder.cont();
+    encoder.setProperties(true, false); //started, firstFrame
+  }
+
+	// Load the neural net here because the color table gets clobbered by encoder.start();
+  encoder.setNeuquant(neuquant, colortab);
+  encoder.addFrame(imageData, true);
+
+  if(frame_length == frame_index) {
+    encoder.finish();
+  }
+
+  self.postMessage({
+  	task: 'encode',
+		frame_index: frame_index,
+		frame_data: encoder.stream().getData()
+	});
+	// on the page, search for the GIF89a to see the frame_index
+	
+	delete encoder;
+	delete data;
+};
+