diff options
Diffstat (limited to 'js/worker/GIFEncoder.js')
| -rwxr-xr-x | js/worker/GIFEncoder.js | 513 |
1 files changed, 513 insertions, 0 deletions
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;
+}
+
|