add processing 3.0 compatible gifAnimation library

libraries/gifAnimation/examples/gifDisplay/gifDisplay.pde

@@ -0,0 +1,55 @@
+/*
+* Demonstrates the use of the GifAnimation library.
+* the left animation is looping, the one in the middle 
+* plays once on mouse click and the one in the right
+* is a PImage array. 
+* the first two pause if you hit the spacebar.
+*/
+
+import gifAnimation.*;
+
+PImage[] animation;
+Gif loopingGif;
+Gif nonLoopingGif;
+boolean pause = false;
+
+public void setup() {
+  size(400, 200);
+  frameRate(100);
+  
+  println("gifAnimation " + Gif.version());
+  // create the GifAnimation object for playback
+  loopingGif = new Gif(this, "lavalamp.gif");
+  loopingGif.loop();
+  nonLoopingGif = new Gif(this, "lavalamp.gif");
+  nonLoopingGif.play();
+  nonLoopingGif.ignoreRepeat();
+  // create the PImage array for the interactive display
+  animation = Gif.getPImages(this, "lavalamp.gif");
+}
+
+void draw() {
+  background(255 / (float)height * mouseY);
+  image(loopingGif, 10, height / 2 - loopingGif.height / 2);
+  image(nonLoopingGif, width/2 - nonLoopingGif.width/2, height / 2 - nonLoopingGif.height / 2);
+  image(animation[(int) (animation.length / (float) (width) * mouseX)], width - 10 - animation[0].width, height / 2 - animation[0].height / 2);
+}
+
+void mousePressed() {
+  nonLoopingGif.play();
+}
+
+void keyPressed() {
+  if (key == ' ') {
+    if (pause) {
+      nonLoopingGif.play();
+      loopingGif.play();
+      pause = false;
+    } 
+    else {
+      nonLoopingGif.pause();
+      loopingGif.pause();
+      pause = true;
+    }
+  }
+}

libraries/gifAnimation/examples/gifExport/gifExport.pde

@@ -0,0 +1,41 @@
+/*
+* Demonstrates the use of the GifAnimation library.
+ * Exports a GIF-File to the sketch folder if space
+ * bar is pressed. Wow, feels like 90's! ;)
+ */
+
+import gifAnimation.*;
+import processing.opengl.*;
+
+GifMaker gifExport;
+PImage logo;
+float rotation = 0.0;
+
+public void setup() {
+  size(200, 200, OPENGL);
+  frameRate(12);
+  logo = loadImage("processing.png");
+
+  println("gifAnimation " + Gif.version());
+  gifExport = new GifMaker(this, "export.gif");
+  gifExport.setRepeat(0); // make it an "endless" animation
+  gifExport.setTransparent(0,0,0); // make black the transparent color. every black pixel in the animation will be transparent
+  // GIF doesn't know have alpha values like processing. a pixel can only be totally transparent or totally opaque.
+  // set the processing background and the transparent gif color to the same value as the gifs destination background color 
+  // (e.g. the website bg-color). Like this you can have the antialiasing from processing in the gif.
+}
+
+void draw() {
+  background(0);
+  translate(width/2, height/2);
+  rotation+=.1;
+  rotateY(rotation);
+  image(logo, -logo.width/2,-logo.height/2);
+  gifExport.setDelay(1);
+  gifExport.addFrame();
+}
+
+void keyPressed() {
+  gifExport.finish();
+  println("gif saved");
+}

libraries/gifAnimation/library.properties

@@ -0,0 +1,57 @@
+# More on this file here: https://github.com/processing/processing/wiki/Library-Basics
+# UTF-8 supported.
+
+# The name of your Library as you want it formatted.
+name = GifAnimation
+
+# List of authors. Links can be provided using the syntax [author name](url).
+authors = [Patrick Meister, Jerome Saint-Clair](http://www.extrapixel.ch)
+
+# A web page for your Library, NOT a direct link to where to download it.
+url = http://github.com/01010101/GifAnimation
+
+# The category (or categories) of your Library, must be from the following list:
+#   "3D"            "Animation"     "Compilations"      "Data"          
+#   "Fabrication"   "Geometry"      "GUI"               "Hardware"      
+#   "I/O"           "Language"      "Math"              "Simulation"    
+#   "Sound"         "Utilities"     "Typography"        "Video & Vision"
+# 
+# If a value other than those listed is used, your Library will listed as 
+# "Other". Many categories must be comma-separated.
+categories = Animation
+
+# A short sentence (or fragment) to summarize the Library's function. This will 
+# be shown from inside the PDE when the Library is being installed. Avoid 
+# repeating the name of your Library here. Also, avoid saying anything redundant 
+# like mentioning that it's a Library. This should start with a capitalized 
+# letter, and end with a period.
+sentence = A library to play and export GIF animations.
+
+# Additional information suitable for the Processing website. The value of
+# 'sentence' always will be prepended, so you should start by writing the
+# second sentence here. If your Library only works on certain operating systems,
+# mention it here.
+paragraph = Processing v3.x port by [Jerome Saint-Clair (01010101)](http://saint-clair.net/). GIFEncoder & GIFDecoder classes by Kevin Weiner. 
+
+# Links in the 'sentence' and 'paragraph' attributes can be inserted using the
+# same syntax as for authors. 
+# That is, [here is a link to Processing](http://processing.org/)
+
+# A version number that increments once with each release. This is used to 
+# compare different versions of the same Library, and check if an update is 
+# available. You should think of it as a counter, counting the total number of 
+# releases you've had.
+version = 3  # This must be parsable as an int
+
+# The version as the user will see it. If blank, the version attribute will be 
+# used here. This should be a single word, with no spaces.
+prettyVersion = 3.0.0  # This is treated as a String
+
+# The min and max revision of Processing compatible with your Library.
+# Note that these fields use the revision and not the version of Processing, 
+# parsable as an int. For example, the revision number for 2.2.1 is 227. 
+# You can find the revision numbers in the change log: https://raw.githubusercontent.com/processing/processing/master/build/shared/revisions.txt
+# Only use maxRevision (or minRevision), when your Library is known to 
+# break in a later (or earlier) release. Otherwise, use the default value 0.
+minRevision = 3.0
+maxRevision = 0

libraries/gifAnimation/src/Gif.java

@@ -0,0 +1,322 @@
+/*
+ * GifAnimation is a processing library to play gif animations and to 
+ * extract frames from a gif file. It can also export animated GIF animations
+ * This file class is under a GPL license. The Decoder used to open the
+ * gif files was written by Kevin Weiner. please see the separate copyright
+ * notice in the header of the GifDecoder / GifEncoder class.
+ * 
+ * by extrapixel 2007
+ * http://extrapixel.ch
+ * 
+  
+  	This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package gifAnimation;
+
+import java.awt.image.BufferedImage;
+import java.io.*;
+
+import processing.core.*;
+
+public class Gif extends PImage implements PConstants, Runnable {
+	private PApplet parent;
+	Thread runner;
+	// if the animation is currently playing
+	private boolean play;
+	// if the animation is currently looping
+	private boolean loop;
+	// wether the repeat setting from the gif-file should be ignored
+	private boolean ignoreRepeatSetting = false;
+	// nr of repeats specified in the gif-file. 0 means repeat forever
+	private int repeatSetting = 1;
+	// how often this animation has repeated since last call to play()
+	private int repeatCount = 0;
+	// the current frame number
+	private int currentFrame;
+	// array containing the frames as PImages
+	private PImage[] frames;
+	// array containing the delay in ms of every frame
+	private int[] delays;
+	// last time the frame changed
+	private int lastJumpTime;
+	// version
+	private static String version = "3.1";
+
+	public Gif(PApplet parent, String filename) {
+		// this creates a fake image so that the first time this
+		// attempts to draw, something happens that's not an exception
+		super(1, 1, ARGB);
+
+		this.parent = parent;
+
+		// create the GifDecoder
+		GifDecoder gifDecoder = createDecoder(parent, filename);
+
+		// fill up the PImage and the delay arrays
+		frames = extractFrames(gifDecoder);
+		delays = extractDelays(gifDecoder);
+
+		// get the GIFs repeat count
+		repeatSetting = gifDecoder.getLoopCount();
+
+		// re-init our PImage with the new size
+		super.init(frames[0].width, frames[0].height, ARGB);
+		jump(0);
+		parent.registerMethod("dispose", this);
+
+		// and now, make the magic happen
+		runner = new Thread(this);
+		runner.start();
+	}
+
+	public void dispose() {
+		// fin
+		// System.out.println("disposing");
+		stop();
+		runner = null;
+	}
+
+	/*
+	 * the thread's run method
+	 */
+	public void run() {
+		while (Thread.currentThread() == runner) {
+			try {
+				Thread.sleep(5);
+			} catch (InterruptedException e) {
+			}
+
+			if (play) {
+				// if playing, check if we need to go to next frame
+
+				if (parent.millis() - lastJumpTime >= delays[currentFrame]) {
+					// we need to jump
+
+					if (currentFrame == frames.length - 1) {
+						// its the last frame
+						if (loop) {
+							jump(0); // loop is on, so rewind
+						} else if (!ignoreRepeatSetting) {
+							// we're not looping, but we need to respect the
+							// GIF's repeat setting
+							repeatCount++;
+							if (repeatSetting == 0) {
+								// we need to repeat forever
+								jump(0);
+							} else if (repeatCount == repeatSetting) {
+								// stop repeating, we've reached the repeat
+								// setting
+								stop();
+							}
+						} else {
+							// no loop & ignoring the repeat setting, so just
+							// stop.
+							stop();
+						}
+					} else {
+						// go to the next frame
+						jump(currentFrame + 1);
+					}
+				}
+			}
+		}
+	}
+
+	/*
+	 * creates an input stream using processings createInput() method to read
+	 * from the sketch data-directory
+	 */
+	private static InputStream createInputStream(PApplet parent, String filename) {
+		InputStream inputStream = parent.createInput(filename);
+		return inputStream;
+	}
+
+	/*
+	 * in case someone wants to mess with the frames directly, they can get an
+	 * array of PImages containing the animation frames. without having a
+	 * gif-object with a seperate thread
+	 * 
+	 * it takes a filename of a file in the datafolder.
+	 */
+	public static PImage[] getPImages(PApplet parent, String filename) {
+		GifDecoder gifDecoder = createDecoder(parent, filename);
+		return extractFrames(gifDecoder);
+	}
+
+	/*
+	 * probably someone wants all the frames even if he has a playback-gif...
+	 */
+	public PImage[] getPImages() {
+		return frames;
+	}
+
+	/*
+	 * creates a GifDecoder object and loads a gif file
+	 */
+	private static GifDecoder createDecoder(PApplet parent, String filename) {
+		GifDecoder gifDecoder = new GifDecoder();
+		gifDecoder.read(createInputStream(parent, filename));
+		return gifDecoder;
+	}
+
+	/*
+	 * creates a PImage-array of gif frames in a GifDecoder object
+	 */
+	private static PImage[] extractFrames(GifDecoder gifDecoder) {
+		int n = gifDecoder.getFrameCount();
+
+		PImage[] frames = new PImage[n];
+
+		for (int i = 0; i < n; i++) {
+			BufferedImage frame = gifDecoder.getFrame(i);
+			frames[i] = new PImage(frame.getWidth(), frame.getHeight(), ARGB);
+			System.arraycopy(frame.getRGB(0, 0, frame.getWidth(), frame
+					.getHeight(), null, 0, frame.getWidth()), 0,
+					frames[i].pixels, 0, frame.getWidth() * frame.getHeight());
+		}
+		return frames;
+	}
+
+	/*
+	 * creates an int-array of frame delays in the gifDecoder object
+	 */
+	private static int[] extractDelays(GifDecoder gifDecoder) {
+		int n = gifDecoder.getFrameCount();
+		int[] delays = new int[n];
+		for (int i = 0; i < n; i++) {
+			delays[i] = gifDecoder.getDelay(i); // display duration of frame in
+			// milliseconds
+		}
+		return delays;
+	}
+
+	/*
+	 * Can be called to ignore the repeat-count set in the gif-file. this does
+	 * not affect loop()/noLoop() settings.
+	 */
+	public void ignoreRepeat() {
+		ignoreRepeatSetting = true;
+	}
+
+	/*
+	 * returns the number of repeats that is specified in the gif-file 0 means
+	 * repeat forever
+	 */
+	public int getRepeat() {
+		return repeatSetting;
+	}
+
+	/*
+	 * returns true if this GIF object is playing
+	 */
+	public boolean isPlaying() {
+		return play;
+	}
+
+	/*
+	 * returns the current frame number
+	 */
+	public int currentFrame() {
+		return currentFrame;
+	}
+
+	/*
+	 * returns true if the animation is set to loop
+	 */
+	public boolean isLooping() {
+		return loop;
+	}
+
+	/*
+	 * returns true if this animation is set to ignore the file's repeat setting
+	 */
+	public boolean isIgnoringRepeat() {
+		return ignoreRepeatSetting;
+	}
+	
+	/*
+	 * returns the version of the library
+	 */
+	public static String version() {
+		return version;
+	}
+
+	/*
+	 * following methods mimic the behaviour of processing's movie class.
+	 */
+
+	/**
+	 * Begin playing the animation, with no repeat.
+	 */
+	public void play() {
+		play = true;
+		if (!ignoreRepeatSetting) {
+			repeatCount = 0;
+		}
+	}
+
+	/**
+	 * Begin playing the animation, with repeat.
+	 */
+	public void loop() {
+		play = true;
+		loop = true;
+	}
+
+	/**
+	 * Shut off the repeating loop.
+	 */
+	public void noLoop() {
+		loop = false;
+	}
+
+	/**
+	 * Pause the animation at its current frame.
+	 */
+	public void pause() {
+		// System.out.println("pause");
+		play = false;
+	}
+
+	/**
+	 * Stop the animation, and rewind.
+	 */
+	public void stop() {
+		//System.out.println("stop");
+		play = false;
+		currentFrame = 0;
+		repeatCount = 0;
+	}
+
+	/**
+	 * Jump to a specific location (in frames). if the frame does not exist, go
+	 * to last frame
+	 * @param where : file location (in sketch)
+	 */
+	public void jump(int where) {
+		if (frames.length > where) {
+			currentFrame = where;
+
+			// update the pixel-array
+			loadPixels();
+			System.arraycopy(frames[currentFrame].pixels, 0, pixels, 0, width
+					* height);
+			updatePixels();
+
+			// set the jump time
+			lastJumpTime = parent.millis();
+		}
+	}
+
+}

libraries/gifAnimation/src/GifDecoder.java

@@ -0,0 +1,802 @@
+package gifAnimation;
+
+import java.awt.AlphaComposite;
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Graphics2D;
+import java.awt.Rectangle;
+import java.awt.image.BufferedImage;
+import java.awt.image.DataBufferInt;
+import java.io.BufferedInputStream;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.util.ArrayList;
+
+/**
+ * Class GifDecoder - Decodes a GIF file into one or more frames. <br>
+ * 
+ * <pre>
+ *  Example:
+ *     GifDecoder d = new GifDecoder();
+ *     d.read(&quot;sample.gif&quot;);
+ *     int n = d.getFrameCount();
+ *     for (int i = 0; i &lt; n; i++) {
+ *        BufferedImage frame = d.getFrame(i);  // frame i
+ *        int t = d.getDelay(i);  // display duration of frame in milliseconds
+ *        // do something with frame
+ *     }
+ * </pre>
+ * 
+ * No copyright asserted on the source code of this class. May be used for any
+ * purpose, however, refer to the Unisys LZW patent for any additional
+ * restrictions. Please forward any corrections to kweiner@fmsware.com.
+ * 
+ * @author Kevin Weiner, FM Software; LZW decoder adapted from John Cristy's
+ *         ImageMagick.
+ * @version 1.03 November 2003
+ * 
+ */
+
+public class GifDecoder {
+
+	/**
+	 * File read status: No errors.
+	 */
+	public static final int STATUS_OK = 0;
+
+	/**
+	 * File read status: Error decoding file (may be partially decoded)
+	 */
+	public static final int STATUS_FORMAT_ERROR = 1;
+
+	/**
+	 * File read status: Unable to open source.
+	 */
+	public static final int STATUS_OPEN_ERROR = 2;
+
+	protected BufferedInputStream in;
+
+	protected int status;
+
+	protected int width; // full image width
+
+	protected int height; // full image height
+
+	protected boolean gctFlag; // global color table used
+
+	protected int gctSize; // size of global color table
+
+	protected int loopCount = 1; // iterations; 0 = repeat forever
+
+	protected int[] gct; // global color table
+
+	protected int[] lct; // local color table
+
+	protected int[] act; // active color table
+
+	protected int bgIndex; // background color index
+
+	protected int bgColor; // background color
+
+	protected int lastBgColor; // previous bg color
+
+	protected int pixelAspect; // pixel aspect ratio
+
+	protected boolean lctFlag; // local color table flag
+
+	protected boolean interlace; // interlace flag
+
+	protected int lctSize; // local color table size
+
+	protected int ix, iy, iw, ih; // current image rectangle
+
+	protected Rectangle lastRect; // last image rect
+
+	protected BufferedImage image; // current frame
+
+	protected BufferedImage lastImage; // previous frame
+
+	protected byte[] block = new byte[256]; // current data block
+
+	protected int blockSize = 0; // block size
+
+	// last graphic control extension info
+	protected int dispose = 0;
+
+	// 0=no action; 1=leave in place; 2=restore to bg; 3=restore to prev
+	protected int lastDispose = 0;
+
+	protected boolean transparency = false; // use transparent color
+
+	protected int delay = 0; // delay in milliseconds
+
+	protected int transIndex; // transparent color index
+
+	protected static final int MaxStackSize = 4096;
+
+	// max decoder pixel stack size
+
+	// LZW decoder working arrays
+	protected short[] prefix;
+
+	protected byte[] suffix;
+
+	protected byte[] pixelStack;
+
+	protected byte[] pixels;
+
+	protected ArrayList<GifFrame> frames; // frames read from current file
+
+	protected int frameCount;
+
+	static class GifFrame {
+		public GifFrame(BufferedImage im, int del) {
+			image = im;
+			delay = del;
+		}
+
+		public BufferedImage image;
+
+		public int delay;
+	}
+
+	/**
+	 * Gets display duration for specified frame.
+	 * 
+	 * @param n
+	 *          int index of frame
+	 * @return delay in milliseconds
+	 */
+	public int getDelay(int n) {
+		//
+		delay = -1;
+		if ((n >= 0) && (n < frameCount)) {
+			delay = frames.get(n).delay;
+		}
+		return delay;
+	}
+
+	/**
+	 * Gets the number of frames read from file.
+	 * 
+	 * @return frame count
+	 */
+	public int getFrameCount() {
+		return frameCount;
+	}
+
+	/**
+	 * Gets the first (or only) image read.
+	 * 
+	 * @return BufferedImage containing first frame, or null if none.
+	 */
+	public BufferedImage getImage() {
+		return getFrame(0);
+	}
+
+	/**
+	 * Gets the "Netscape" iteration count, if any. A count of 0 means repeat
+	 * indefinitiely.
+	 * 
+	 * @return iteration count if one was specified, else 1.
+	 */
+	public int getLoopCount() {
+		return loopCount;
+	}
+
+	/**
+	 * Creates new frame image from current data (and previous frames as specified
+	 * by their disposition codes).
+	 */
+	protected void setPixels() {
+		// expose destination image's pixels as int array
+		int[] dest = ((DataBufferInt) image.getRaster().getDataBuffer()).getData();
+
+		// fill in starting image contents based on last image's dispose code
+		if (lastDispose > 0) {
+			if (lastDispose == 3) {
+				// use image before last
+				int n = frameCount - 2;
+				if (n > 0) {
+					lastImage = getFrame(n - 1);
+				} else {
+					lastImage = null;
+				}
+			}
+
+			if (lastImage != null) {
+				int[] prev = ((DataBufferInt) lastImage.getRaster().getDataBuffer()).getData();
+				System.arraycopy(prev, 0, dest, 0, width * height);
+				// copy pixels
+
+				if (lastDispose == 2) {
+					// fill last image rect area with background color
+					Graphics2D g = image.createGraphics();
+					Color c = null;
+					if (transparency) {
+						c = new Color(0, 0, 0, 0); // assume background is transparent
+					} else {
+						c = new Color(lastBgColor); // use given background color
+					}
+					g.setColor(c);
+					g.setComposite(AlphaComposite.Src); // replace area
+					g.fill(lastRect);
+					g.dispose();
+				}
+			}
+		}
+
+		// copy each source line to the appropriate place in the destination
+		int pass = 1;
+		int inc = 8;
+		int iline = 0;
+		for (int i = 0; i < ih; i++) {
+			int line = i;
+			if (interlace) {
+				if (iline >= ih) {
+					pass++;
+					switch (pass) {
+					case 2:
+						iline = 4;
+						break;
+					case 3:
+						iline = 2;
+						inc = 4;
+						break;
+					case 4:
+						iline = 1;
+						inc = 2;
+					}
+				}
+				line = iline;
+				iline += inc;
+			}
+			line += iy;
+			if (line < height) {
+				int k = line * width;
+				int dx = k + ix; // start of line in dest
+				int dlim = dx + iw; // end of dest line
+				if ((k + width) < dlim) {
+					dlim = k + width; // past dest edge
+				}
+				int sx = i * iw; // start of line in source
+				while (dx < dlim) {
+					// map color and insert in destination
+					int index = ((int) pixels[sx++]) & 0xff;
+					int c = act[index];
+					if (c != 0) {
+						dest[dx] = c;
+					}
+					dx++;
+				}
+			}
+		}
+	}
+
+	/**
+	 * Gets the image contents of frame n.
+	 * @param n : frame number
+	 * @return BufferedImage representation of frame, or null if n is invalid.
+	 */
+	public BufferedImage getFrame(int n) {
+		BufferedImage im = null;
+		if ((n >= 0) && (n < frameCount)) {
+			im = frames.get(n).image;
+		}
+		return im;
+	}
+
+	/**
+	 * Gets image size.
+	 * 
+	 * @return GIF image dimensions
+	 */
+	public Dimension getFrameSize() {
+		return new Dimension(width, height);
+	}
+
+	/**
+	 * Reads GIF image from stream
+	 * 
+	 * @param is : BufferedInputStream containing GIF file.
+	 * 
+	 * @return read status code (0 = no errors)
+	 */
+	public int read(BufferedInputStream is) {
+		init();
+		if (is != null) {
+			in = is;
+			readHeader();
+			if (!err()) {
+				readContents();
+				if (frameCount < 0) {
+					status = STATUS_FORMAT_ERROR;
+				}
+			}
+		} else {
+			status = STATUS_OPEN_ERROR;
+		}
+		try {
+			is.close();
+		} catch (IOException e) {
+		}
+		return status;
+	}
+
+	/**
+	 * Reads GIF image from stream
+	 * 
+	 * @param is : InputStream containing GIF file.
+	 * 
+	 * @return read status code (0 = no errors)
+	 */
+	public int read(InputStream is) {
+		init();
+		if (is != null) {
+			if (!(is instanceof BufferedInputStream))
+				is = new BufferedInputStream(is);
+			in = (BufferedInputStream) is;
+			readHeader();
+			if (!err()) {
+				readContents();
+				if (frameCount < 0) {
+					status = STATUS_FORMAT_ERROR;
+				}
+			}
+		} else {
+			status = STATUS_OPEN_ERROR;
+		}
+		try {
+			is.close();
+		} catch (IOException e) {
+		}
+		return status;
+	}
+
+	/**
+	 * Reads GIF file from specified file/URL source (URL assumed if name contains
+	 * ":/" or "file:")
+	 * 
+	 * @param name : String containing source
+	 * @return read status code (0 = no errors)
+	 */
+	public int read(String name) {
+		status = STATUS_OK;
+		try {
+			name = name.trim().toLowerCase();
+			if ((name.indexOf("file:") >= 0) || (name.indexOf(":/") > 0)) {
+				URL url = new URL(name);
+				in = new BufferedInputStream(url.openStream());
+			} else {
+				in = new BufferedInputStream(new FileInputStream(name));
+			}
+			status = read(in);
+		} catch (IOException e) {
+			status = STATUS_OPEN_ERROR;
+		}
+
+		return status;
+	}
+
+	/**
+	 * Decodes LZW image data into pixel array. Adapted from John Cristy's
+	 * ImageMagick.
+	 */
+	protected void decodeImageData() {
+		int NullCode = -1;
+		int npix = iw * ih;
+		int available, clear, code_mask, code_size, end_of_information, in_code, old_code, bits, code, count, i, datum, data_size, first, top, bi, pi;
+
+		if ((pixels == null) || (pixels.length < npix)) {
+			pixels = new byte[npix]; // allocate new pixel array
+		}
+		if (prefix == null)
+			prefix = new short[MaxStackSize];
+		if (suffix == null)
+			suffix = new byte[MaxStackSize];
+		if (pixelStack == null)
+			pixelStack = new byte[MaxStackSize + 1];
+
+		// Initialize GIF data stream decoder.
+
+		data_size = read();
+		clear = 1 << data_size;
+		end_of_information = clear + 1;
+		available = clear + 2;
+		old_code = NullCode;
+		code_size = data_size + 1;
+		code_mask = (1 << code_size) - 1;
+		for (code = 0; code < clear; code++) {
+			prefix[code] = 0;
+			suffix[code] = (byte) code;
+		}
+
+		// Decode GIF pixel stream.
+
+		datum = bits = count = first = top = pi = bi = 0;
+
+		for (i = 0; i < npix;) {
+			if (top == 0) {
+				if (bits < code_size) {
+					// Load bytes until there are enough bits for a code.
+					if (count == 0) {
+						// Read a new data block.
+						count = readBlock();
+						if (count <= 0)
+							break;
+						bi = 0;
+					}
+					datum += (((int) block[bi]) & 0xff) << bits;
+					bits += 8;
+					bi++;
+					count--;
+					continue;
+				}
+
+				// Get the next code.
+
+				code = datum & code_mask;
+				datum >>= code_size;
+				bits -= code_size;
+
+				// Interpret the code
+
+				if ((code > available) || (code == end_of_information))
+					break;
+				if (code == clear) {
+					// Reset decoder.
+					code_size = data_size + 1;
+					code_mask = (1 << code_size) - 1;
+					available = clear + 2;
+					old_code = NullCode;
+					continue;
+				}
+				if (old_code == NullCode) {
+					pixelStack[top++] = suffix[code];
+					old_code = code;
+					first = code;
+					continue;
+				}
+				in_code = code;
+				if (code == available) {
+					pixelStack[top++] = (byte) first;
+					code = old_code;
+				}
+				while (code > clear) {
+					pixelStack[top++] = suffix[code];
+					code = prefix[code];
+				}
+				first = ((int) suffix[code]) & 0xff;
+
+				// Add a new string to the string table,
+
+				if (available >= MaxStackSize)
+					break;
+				pixelStack[top++] = (byte) first;
+				prefix[available] = (short) old_code;
+				suffix[available] = (byte) first;
+				available++;
+				if (((available & code_mask) == 0) && (available < MaxStackSize)) {
+					code_size++;
+					code_mask += available;
+				}
+				old_code = in_code;
+			}
+
+			// Pop a pixel off the pixel stack.
+
+			top--;
+			pixels[pi++] = pixelStack[top];
+			i++;
+		}
+
+		for (i = pi; i < npix; i++) {
+			pixels[i] = 0; // clear missing pixels
+		}
+
+	}
+
+	/**
+	 * Returns true if an error was encountered during reading/decoding
+	 */
+	protected boolean err() {
+		return status != STATUS_OK;
+	}
+
+	/**
+	 * Initializes or re-initializes reader
+	 */
+	protected void init() {
+		status = STATUS_OK;
+		frameCount = 0;
+		frames = new ArrayList<GifFrame>();
+		gct = null;
+		lct = null;
+	}
+
+	/**
+	 * Reads a single byte from the input stream.
+	 */
+	protected int read() {
+		int curByte = 0;
+		try {
+			curByte = in.read();
+		} catch (IOException e) {
+			status = STATUS_FORMAT_ERROR;
+		}
+		return curByte;
+	}
+
+	/**
+	 * Reads next variable length block from input.
+	 * 
+	 * @return number of bytes stored in "buffer"
+	 */
+	protected int readBlock() {
+		blockSize = read();
+		int n = 0;
+		if (blockSize > 0) {
+			try {
+				int count = 0;
+				while (n < blockSize) {
+					count = in.read(block, n, blockSize - n);
+					if (count == -1)
+						break;
+					n += count;
+				}
+			} catch (IOException e) {
+			}
+
+			if (n < blockSize) {
+				status = STATUS_FORMAT_ERROR;
+			}
+		}
+		return n;
+	}
+
+	/**
+	 * Reads color table as 256 RGB integer values
+	 * 
+	 * @param ncolors
+	 *          int number of colors to read
+	 * @return int array containing 256 colors (packed ARGB with full alpha)
+	 */
+	protected int[] readColorTable(int ncolors) {
+		int nbytes = 3 * ncolors;
+		int[] tab = null;
+		byte[] c = new byte[nbytes];
+		int n = 0;
+		try {
+			n = in.read(c);
+		} catch (IOException e) {
+		}
+		if (n < nbytes) {
+			status = STATUS_FORMAT_ERROR;
+		} else {
+			tab = new int[256]; // max size to avoid bounds checks
+			int i = 0;
+			int j = 0;
+			while (i < ncolors) {
+				int r = ((int) c[j++]) & 0xff;
+				int g = ((int) c[j++]) & 0xff;
+				int b = ((int) c[j++]) & 0xff;
+				tab[i++] = 0xff000000 | (r << 16) | (g << 8) | b;
+			}
+		}
+		return tab;
+	}
+
+	/**
+	 * Main file parser. Reads GIF content blocks.
+	 */
+	protected void readContents() {
+		// read GIF file content blocks
+		boolean done = false;
+		while (!(done || err())) {
+			int code = read();
+			switch (code) {
+
+			case 0x2C: // image separator
+				readImage();
+				break;
+
+			case 0x21: // extension
+				code = read();
+				switch (code) {
+				case 0xf9: // graphics control extension
+					readGraphicControlExt();
+					break;
+
+				case 0xff: // application extension
+					readBlock();
+					String app = "";
+					for (int i = 0; i < 11; i++) {
+						app += (char) block[i];
+					}
+					if (app.equals("NETSCAPE2.0")) {
+						readNetscapeExt();
+					} else
+						skip(); // don't care
+					break;
+
+				default: // uninteresting extension
+					skip();
+				}
+				break;
+
+			case 0x3b: // terminator
+				done = true;
+				break;
+
+			case 0x00: // bad byte, but keep going and see what happens
+				break;
+
+			default:
+				status = STATUS_FORMAT_ERROR;
+			}
+		}
+	}
+
+	/**
+	 * Reads Graphics Control Extension values
+	 */
+	protected void readGraphicControlExt() {
+		read(); // block size
+		int packed = read(); // packed fields
+		dispose = (packed & 0x1c) >> 2; // disposal method
+		if (dispose == 0) {
+			dispose = 1; // elect to keep old image if discretionary
+		}
+		transparency = (packed & 1) != 0;
+		delay = readShort() * 10; // delay in milliseconds
+		transIndex = read(); // transparent color index
+		read(); // block terminator
+	}
+
+	/**
+	 * Reads GIF file header information.
+	 */
+	protected void readHeader() {
+		String id = "";
+		for (int i = 0; i < 6; i++) {
+			id += (char) read();
+		}
+		if (!id.startsWith("GIF")) {
+			status = STATUS_FORMAT_ERROR;
+			return;
+		}
+
+		readLSD();
+		if (gctFlag && !err()) {
+			gct = readColorTable(gctSize);
+			bgColor = gct[bgIndex];
+		}
+	}
+
+	/**
+	 * Reads next frame image
+	 */
+	protected void readImage() {
+		ix = readShort(); // (sub)image position & size
+		iy = readShort();
+		iw = readShort();
+		ih = readShort();
+
+		int packed = read();
+		lctFlag = (packed & 0x80) != 0; // 1 - local color table flag
+		interlace = (packed & 0x40) != 0; // 2 - interlace flag
+		// 3 - sort flag
+		// 4-5 - reserved
+		lctSize = 2 << (packed & 7); // 6-8 - local color table size
+
+		if (lctFlag) {
+			lct = readColorTable(lctSize); // read table
+			act = lct; // make local table active
+		} else {
+			act = gct; // make global table active
+			if (bgIndex == transIndex)
+				bgColor = 0;
+		}
+		int save = 0;
+		if (transparency) {
+			save = act[transIndex];
+			act[transIndex] = 0; // set transparent color if specified
+		}
+
+		if (act == null) {
+			status = STATUS_FORMAT_ERROR; // no color table defined
+		}
+
+		if (err())
+			return;
+
+		decodeImageData(); // decode pixel data
+		skip();
+
+		if (err())
+			return;
+
+		frameCount++;
+
+		// create new image to receive frame data
+		image = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB_PRE);
+
+		setPixels(); // transfer pixel data to image
+
+		frames.add(new GifFrame(image, delay)); // add image to frame list
+
+		if (transparency) {
+			act[transIndex] = save;
+		}
+		resetFrame();
+
+	}
+
+	/**
+	 * Reads Logical Screen Descriptor
+	 */
+	protected void readLSD() {
+
+		// logical screen size
+		width = readShort();
+		height = readShort();
+
+		// packed fields
+		int packed = read();
+		gctFlag = (packed & 0x80) != 0; // 1 : global color table flag
+		// 2-4 : color resolution
+		// 5 : gct sort flag
+		gctSize = 2 << (packed & 7); // 6-8 : gct size
+
+		bgIndex = read(); // background color index
+		pixelAspect = read(); // pixel aspect ratio
+	}
+
+	/**
+	 * Reads Netscape extension to obtain iteration count
+	 */
+	protected void readNetscapeExt() {
+		do {
+			readBlock();
+			if (block[0] == 1) {
+				// loop count sub-block
+				int b1 = ((int) block[1]) & 0xff;
+				int b2 = ((int) block[2]) & 0xff;
+				loopCount = (b2 << 8) | b1;
+			}
+		} while ((blockSize > 0) && !err());
+	}
+
+	/**
+	 * Reads next 16-bit value, LSB first
+	 */
+	protected int readShort() {
+		// read 16-bit value, LSB first
+		return read() | (read() << 8);
+	}
+
+	/**
+	 * Resets frame state for reading next image.
+	 */
+	protected void resetFrame() {
+		lastDispose = dispose;
+		lastRect = new Rectangle(ix, iy, iw, ih);
+		lastImage = image;
+		lastBgColor = bgColor;
+//		int dispose = 0;
+//		boolean transparency = false;
+//		int delay = 0;
+		lct = null;
+	}
+
+	/**
+	 * Skips variable length blocks up to and including next zero length block.
+	 */
+	protected void skip() {
+		do {
+			readBlock();
+		} while ((blockSize > 0) && !err());
+	}
+}

libraries/gifAnimation/src/GifMaker.java

@@ -0,0 +1,168 @@
+/*
+ * GifAnimation is a processing library to play gif animations and to 
+ * extract frames from a gif file. It can also export animated GIF animations
+ * This file class is under a GPL license. The Decoder used to open the
+ * gif files was written by Kevin Weiner. please see the separate copyright
+ * notice in the header of the GifDecoder / GifEncoder class.
+ * 
+ * by extrapixel 2007
+ * http://extrapixel.ch
+ * 
+  
+  	This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package gifAnimation;
+
+import java.awt.Color;
+import java.awt.image.BufferedImage;
+import processing.core.PApplet;
+import processing.core.PConstants;
+import processing.core.PImage;
+
+public class GifMaker implements PConstants {
+	public final static int DISPOSE_NOTHING = 0;
+	public final static int DISPOSE_KEEP = 1;
+	public final static int DISPOSE_RESTORE_BACKGROUND = 2;
+	public final static int DISPOSE_REMOVE = 3;
+	private GifEncoder encoder;
+	private PApplet parent;
+
+	public GifMaker(PApplet parent, String filename) {
+		this.parent = parent;
+		parent.registerMethod("dispose", this);
+		encoder = initEncoder(filename);
+	}
+
+	public GifMaker(PApplet parent, String filename, int quality) {
+		this(parent, filename);
+		setQuality(quality);
+	}
+
+	public GifMaker(PApplet parent, String filename, int quality, int bgColor) {
+		this(parent, filename, quality);
+		setTransparent(bgColor);
+	}
+
+	/*
+	 * finish stuff up when sketch is killed
+	 */
+	public void dispose() {
+		finish();
+	}
+
+	private GifEncoder initEncoder(String filename) {
+		GifEncoder returnEncoder = new GifEncoder();
+		returnEncoder.start(parent.savePath(filename));
+		return returnEncoder;
+	}
+
+	/*
+	 * adds a delay to the last added frame int in milliseconds
+	 */
+	public void setDelay(int delay) {
+		encoder.setDelay(delay);
+	}
+
+	/*
+	 * set the disposal mode for the last added frame
+	 * 
+	 * from GIF specs: CODE MEANING 00 Nothing special 01 KEEP - retain the
+	 * current image 02 RESTORE BACKGROUND - restore the background color 03
+	 * REMOVE - remove the current image, and restore whatever image was beneath
+	 * it.
+	 */
+	public void setDispose(int dispose) {
+		encoder.setDispose(dispose);
+	}
+
+	/**
+	 * description taken from GifEncoder-class: 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.
+	 */
+	public void setQuality(int quality) {
+		encoder.setQuality(quality);
+	}
+
+	/*
+	 * sets the amount of times the animation should repeat
+	 * 
+	 */
+	public void setRepeat(int repeat) {
+		encoder.setRepeat(repeat);
+	}
+
+	/*
+	 * sets the size of the GIF-file. if this method is not invoked, the size of
+	 * the first added frame will be the image size.
+	 */
+	public void setSize(int width, int height) {
+		encoder.setSize(width, height);
+	}
+
+	/*
+	 * Sets the transparent color. Every pixel with this color will be
+	 * transparent in the output File
+	 */
+	public void setTransparent(int color) {
+		setTransparent((int) parent.red(color), (int) parent.green(color),
+				(int) parent.blue(color));
+	}
+
+	public void setTransparent(float red, float green, float blue) {
+		setTransparent((int) red, (int) green, (int) blue);
+	}
+
+	public void setTransparent(int red, int green, int blue) {
+		encoder.setTransparent(new Color(red, green, blue));
+	}
+
+	/*
+	 * adds a frame to the current animation takes a PImage, or a pixel-array.
+	 * if no parameter is passed, the currently displayed pixels in the sketch
+	 * window is used.
+	 */
+	public void addFrame() {
+		parent.loadPixels();
+		addFrame(parent.pixels, parent.pixelWidth, parent.pixelHeight);
+	}
+
+	public void addFrame(PImage newImage) {
+		addFrame(newImage.pixels, newImage.width, newImage.height);
+	}
+
+	public void addFrame(int[] pixels, int width, int height) {
+		BufferedImage frame = new BufferedImage(width, height,
+				BufferedImage.TYPE_INT_ARGB);
+		frame.setRGB(0, 0, width, height, pixels, 0, width);
+		encoder.addFrame(frame);
+	}
+
+	/*
+	 * finishes off the GIF-file and saves it to the given filename
+	 * in the sketch directory. if the file already exists, it will
+	 * be overridden!
+	 */
+	public boolean finish() {
+		return encoder.finish();
+	}
+
+}