Back to index...

	/*
	* Copyright (c) 1995, 2006, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code 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
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	/*-
	* Reads GIF images from an InputStream and reports the
	* image data to an InputStreamImageSource object.
	*
	* The algorithm is copyright of CompuServe.
	*/
	package sun.awt.image;

	import java.util.Vector;
	import java.util.Hashtable;
	import java.io.InputStream;
	import java.io.IOException;
	import java.awt.image.*;

	/**
	* Gif Image converter
	*
	* @author Arthur van Hoff
	* @author Jim Graham
	*/
	public class GifImageDecoder extends ImageDecoder {
	private static final boolean verbose = false;

	private static final int IMAGESEP = 0x2c;
	private static final int EXBLOCK = 0x21;
	private static final int EX_GRAPHICS_CONTROL= 0xf9;
	private static final int EX_COMMENT = 0xfe;
	private static final int EX_APPLICATION = 0xff;
	private static final int TERMINATOR = 0x3b;
	private static final int TRANSPARENCYMASK = 0x01;
	private static final int INTERLACEMASK = 0x40;
	private static final int COLORMAPMASK = 0x80;

	int num_global_colors;
	byte[] global_colormap;
	int trans_pixel = -1;
	IndexColorModel global_model;

	Hashtable props = new Hashtable();

	byte[] saved_image;
	IndexColorModel saved_model;

	int global_width;
	int global_height;
	int global_bgpixel;

	GifFrame curframe;

	public GifImageDecoder(InputStreamImageSource src, InputStream is) {
	super(src, is);
	}

	/**
	* An error has occurred. Throw an exception.
	*/
	private static void error(String s1) throws ImageFormatException {
	throw new ImageFormatException(s1);
	}

	/**
	* Read a number of bytes into a buffer.
	* @return number of bytes that were not read due to EOF or error
	*/
	private int readBytes(byte buf[], int off, int len) {
	while (len > 0) {
	try {
	int n = input.read(buf, off, len);
	if (n < 0) {
	break;
	}
	off += n;
	len -= n;
	} catch (IOException e) {
	break;
	}
	}
	return len;
	}

	private static final int ExtractByte(byte buf[], int off) {
	return (buf[off] & 0xFF);
	}

	private static final int ExtractWord(byte buf[], int off) {
	return (buf[off] & 0xFF) \| ((buf[off + 1] & 0xFF) << 8);
	}

	/**
	* produce an image from the stream.
	*/
	public void produceImage() throws IOException, ImageFormatException {
	try {
	readHeader();

	int totalframes = 0;
	int frameno = 0;
	int nloops = -1;
	int disposal_method = 0;
	int delay = -1;
	boolean loopsRead = false;
	boolean isAnimation = false;

	while (!aborted) {
	int code;

	switch (code = input.read()) {
	case EXBLOCK:
	switch (code = input.read()) {
	case EX_GRAPHICS_CONTROL: {
	byte buf[] = new byte[6];
	if (readBytes(buf, 0, 6) != 0) {
	return;//error("corrupt GIF file");
	}
	if ((buf[0] != 4) \|\| (buf[5] != 0)) {
	return;//error("corrupt GIF file (GCE size)");
	}
	// Get the index of the transparent color
	delay = ExtractWord(buf, 2) * 10;
	if (delay > 0 && !isAnimation) {
	isAnimation = true;
	ImageFetcher.startingAnimation();
	}
	disposal_method = (buf[1] >> 2) & 7;
	if ((buf[1] & TRANSPARENCYMASK) != 0) {
	trans_pixel = ExtractByte(buf, 4);
	} else {
	trans_pixel = -1;
	}
	break;
	}

	case EX_COMMENT:
	case EX_APPLICATION:
	default:
	boolean loop_tag = false;
	String comment = "";
	while (true) {
	int n = input.read();
	if (n <= 0) {
	break;
	}
	byte buf[] = new byte[n];
	if (readBytes(buf, 0, n) != 0) {
	return;//error("corrupt GIF file");
	}
	if (code == EX_COMMENT) {
	comment += new String(buf, 0);
	} else if (code == EX_APPLICATION) {
	if (loop_tag) {
	if (n == 3 && buf[0] == 1) {
	if (loopsRead) {
	ExtractWord(buf, 1);
	}
	else {
	nloops = ExtractWord(buf, 1);
	loopsRead = true;
	}
	} else {
	loop_tag = false;
	}
	}
	if ("NETSCAPE2.0".equals(new String(buf, 0))) {
	loop_tag = true;
	}
	}
	}
	if (code == EX_COMMENT) {
	props.put("comment", comment);
	}
	if (loop_tag && !isAnimation) {
	isAnimation = true;
	ImageFetcher.startingAnimation();
	}
	break;

	case -1:
	return; //error("corrupt GIF file");
	}
	break;

	case IMAGESEP:
	if (!isAnimation) {
	input.mark(0); // we don't need the mark buffer
	}
	try {
	if (!readImage(totalframes == 0,
	disposal_method,
	delay)) {
	return;
	}
	} catch (Exception e) {
	if (verbose) {
	e.printStackTrace();
	}
	return;
	}
	frameno++;
	totalframes++;
	break;

	default:
	case -1:
	if (verbose) {
	if (code == -1) {
	System.err.println("Premature EOF in GIF file," +
	" frame " + frameno);
	} else {
	System.err.println("corrupt GIF file (parse) ["
	+ code + "].");
	}
	}
	if (frameno == 0) {
	return;
	}
	// NOBREAK

	case TERMINATOR:
	if (nloops == 0 \|\| nloops-- >= 0) {
	try {
	if (curframe != null) {
	curframe.dispose();
	curframe = null;
	}
	input.reset();
	saved_image = null;
	saved_model = null;
	frameno = 0;
	break;
	} catch (IOException e) {
	return; // Unable to reset input buffer
	}
	}
	if (verbose && frameno != 1) {
	System.out.println("processing GIF terminator,"
	+ " frames: " + frameno
	+ " total: " + totalframes);
	}
	imageComplete(ImageConsumer.STATICIMAGEDONE, true);
	return;
	}
	}
	} finally {
	close();
	}
	}

	/**
	* Read Image header
	*/
	private void readHeader() throws IOException, ImageFormatException {
	// Create a buffer
	byte buf[] = new byte[13];

	// Read the header
	if (readBytes(buf, 0, 13) != 0) {
	throw new IOException();
	}

	// Check header
	if ((buf[0] != 'G') \|\| (buf[1] != 'I') \|\| (buf[2] != 'F')) {
	error("not a GIF file.");
	}

	// Global width&height
	global_width = ExtractWord(buf, 6);
	global_height = ExtractWord(buf, 8);

	// colormap info
	int ch = ExtractByte(buf, 10);
	if ((ch & COLORMAPMASK) == 0) {
	// no global colormap so make up our own
	// If there is a local colormap, it will override what we
	// have here. If there is not a local colormap, the rules
	// for GIF89 say that we can use whatever colormap we want.
	// This means that we should probably put in a full 256 colormap
	// at some point. REMIND!
	num_global_colors = 2;
	global_bgpixel = 0;
	global_colormap = new byte[2*3];
	global_colormap[0] = global_colormap[1] = global_colormap[2] = (byte)0;
	global_colormap[3] = global_colormap[4] = global_colormap[5] = (byte)255;

	}
	else {
	num_global_colors = 1 << ((ch & 0x7) + 1);

	global_bgpixel = ExtractByte(buf, 11);

	if (buf[12] != 0) {
	props.put("aspectratio", ""+((ExtractByte(buf, 12) + 15) / 64.0));
	}

	// Read colors
	global_colormap = new byte[num_global_colors * 3];
	if (readBytes(global_colormap, 0, num_global_colors * 3) != 0) {
	throw new IOException();
	}
	}
	input.mark(Integer.MAX_VALUE); // set this mark in case this is an animated GIF
	}

	/**
	* The ImageConsumer hints flag for a non-interlaced GIF image.
	*/
	private static final int normalflags =
	ImageConsumer.TOPDOWNLEFTRIGHT \| ImageConsumer.COMPLETESCANLINES \|
	ImageConsumer.SINGLEPASS \| ImageConsumer.SINGLEFRAME;

	/**
	* The ImageConsumer hints flag for an interlaced GIF image.
	*/
	private static final int interlaceflags =
	ImageConsumer.RANDOMPIXELORDER \| ImageConsumer.COMPLETESCANLINES \|
	ImageConsumer.SINGLEPASS \| ImageConsumer.SINGLEFRAME;

	private short prefix[] = new short[4096];
	private byte suffix[] = new byte[4096];
	private byte outCode[] = new byte[4097];

	private static native void initIDs();

	static {
	/* ensure that the necessary native libraries are loaded */
	NativeLibLoader.loadLibraries();
	initIDs();
	}

	private native boolean parseImage(int x, int y, int width, int height,
	boolean interlace, int initCodeSize,
	byte block[], byte rasline[],
	IndexColorModel model);

	private int sendPixels(int x, int y, int width, int height,
	byte rasline[], ColorModel model) {
	int rasbeg, rasend, x2;
	if (y < 0) {
	height += y;
	y = 0;
	}
	if (y + height > global_height) {
	height = global_height - y;
	}
	if (height <= 0) {
	return 1;
	}
	// rasline[0] == pixel at coordinate (x,y)
	// rasline[width] == pixel at coordinate (x+width, y)
	if (x < 0) {
	rasbeg = -x;
	width += x; // same as (width -= rasbeg)
	x2 = 0; // same as (x2 = x + rasbeg)
	} else {
	rasbeg = 0;
	// width -= 0; // same as (width -= rasbeg)
	x2 = x; // same as (x2 = x + rasbeg)
	}
	// rasline[rasbeg] == pixel at coordinate (x2,y)
	// rasline[width] == pixel at coordinate (x+width, y)
	// rasline[rasbeg + width] == pixel at coordinate (x2+width, y)
	if (x2 + width > global_width) {
	width = global_width - x2;
	}
	if (width <= 0) {
	return 1;
	}
	rasend = rasbeg + width;
	// rasline[rasbeg] == pixel at coordinate (x2,y)
	// rasline[rasend] == pixel at coordinate (x2+width, y)
	int off = y * global_width + x2;
	boolean save = (curframe.disposal_method == GifFrame.DISPOSAL_SAVE);
	if (trans_pixel >= 0 && !curframe.initialframe) {
	if (saved_image != null && model.equals(saved_model)) {
	for (int i = rasbeg; i < rasend; i++, off++) {
	byte pixel = rasline[i];
	if ((pixel & 0xff) == trans_pixel) {
	rasline[i] = saved_image[off];
	} else if (save) {
	saved_image[off] = pixel;
	}
	}
	} else {
	// We have to do this the hard way - only transmit
	// the non-transparent sections of the line...
	// Fix for 6301050: the interlacing is ignored in this case
	// in order to avoid artefacts in case of animated images.
	int runstart = -1;
	int count = 1;
	for (int i = rasbeg; i < rasend; i++, off++) {
	byte pixel = rasline[i];
	if ((pixel & 0xff) == trans_pixel) {
	if (runstart >= 0) {
	count = setPixels(x + runstart, y,
	i - runstart, 1,
	model, rasline,
	runstart, 0);
	if (count == 0) {
	break;
	}
	}
	runstart = -1;
	} else {
	if (runstart < 0) {
	runstart = i;
	}
	if (save) {
	saved_image[off] = pixel;
	}
	}
	}
	if (runstart >= 0) {
	count = setPixels(x + runstart, y,
	rasend - runstart, 1,
	model, rasline,
	runstart, 0);
	}
	return count;
	}
	} else if (save) {
	System.arraycopy(rasline, rasbeg, saved_image, off, width);
	}
	int count = setPixels(x2, y, width, height, model,
	rasline, rasbeg, 0);
	return count;
	}

	/**
	* Read Image data
	*/
	private boolean readImage(boolean first, int disposal_method, int delay)
	throws IOException
	{
	if (curframe != null && !curframe.dispose()) {
	abort();
	return false;
	}

	long tm = 0;

	if (verbose) {
	tm = System.currentTimeMillis();
	}

	// Allocate the buffer
	byte block[] = new byte[256 + 3];

	// Read the image descriptor
	if (readBytes(block, 0, 10) != 0) {
	throw new IOException();
	}
	int x = ExtractWord(block, 0);
	int y = ExtractWord(block, 2);
	int width = ExtractWord(block, 4);
	int height = ExtractWord(block, 6);

	/*
	* Majority of gif images have
	* same logical screen and frame dimensions.
	* Also, Photoshop and Mozilla seem to use the logical
	* screen dimension (from the global stream header)
	* if frame dimension is invalid.
	*
	* We use similar heuristic and trying to recover
	* frame width from logical screen dimension and
	* frame offset.
	*/
	if (width == 0 && global_width != 0) {
	width = global_width - x;
	}
	if (height == 0 && global_height != 0) {
	height = global_height - y;
	}

	boolean interlace = (block[8] & INTERLACEMASK) != 0;

	IndexColorModel model = global_model;

	if ((block[8] & COLORMAPMASK) != 0) {
	// We read one extra byte above so now when we must
	// transfer that byte as the first colormap byte
	// and manually read the code size when we are done
	int num_local_colors = 1 << ((block[8] & 0x7) + 1);

	// Read local colors
	byte[] local_colormap = new byte[num_local_colors * 3];
	local_colormap[0] = block[9];
	if (readBytes(local_colormap, 1, num_local_colors * 3 - 1) != 0) {
	throw new IOException();
	}

	// Now read the "real" code size byte which follows
	// the local color table
	if (readBytes(block, 9, 1) != 0) {
	throw new IOException();
	}
	if (trans_pixel >= num_local_colors) {
	// Fix for 4233748: extend colormap to contain transparent pixel
	num_local_colors = trans_pixel + 1;
	local_colormap = grow_colormap(local_colormap, num_local_colors);
	}
	model = new IndexColorModel(8, num_local_colors, local_colormap,
	0, false, trans_pixel);
	} else if (model == null
	\|\| trans_pixel != model.getTransparentPixel()) {
	if (trans_pixel >= num_global_colors) {
	// Fix for 4233748: extend colormap to contain transparent pixel
	num_global_colors = trans_pixel + 1;
	global_colormap = grow_colormap(global_colormap, num_global_colors);
	}
	model = new IndexColorModel(8, num_global_colors, global_colormap,
	0, false, trans_pixel);
	global_model = model;
	}

	// Notify the consumers
	if (first) {
	if (global_width == 0) global_width = width;
	if (global_height == 0) global_height = height;

	setDimensions(global_width, global_height);
	setProperties(props);
	setColorModel(model);
	headerComplete();
	}

	if (disposal_method == GifFrame.DISPOSAL_SAVE && saved_image == null) {
	saved_image = new byte[global_width * global_height];
	/*
	* If height of current image is smaller than the global height,
	* fill the gap with transparent pixels.
	*/
	if ((height < global_height) && (model != null)) {
	byte tpix = (byte)model.getTransparentPixel();
	if (tpix >= 0) {
	byte trans_rasline[] = new byte[global_width];
	for (int i=0; i<global_width;i++) {
	trans_rasline[i] = tpix;
	}

	setPixels(0, 0, global_width, y,
	model, trans_rasline, 0, 0);
	setPixels(0, y+height, global_width,
	global_height-height-y, model, trans_rasline,
	0, 0);
	}
	}
	}

	int hints = (interlace ? interlaceflags : normalflags);
	setHints(hints);

	curframe = new GifFrame(this, disposal_method, delay,
	(curframe == null), model,
	x, y, width, height);

	// allocate the raster data
	byte rasline[] = new byte[width];

	if (verbose) {
	System.out.print("Reading a " + width + " by " + height + " " +
	(interlace ? "" : "non-") + "interlaced image...");
	}
	int initCodeSize = ExtractByte(block, 9);
	if (initCodeSize >= 12) {
	if (verbose) {
	System.out.println("Invalid initial code size: " +
	initCodeSize);
	}
	return false;
	}
	boolean ret = parseImage(x, y, width, height,
	interlace, initCodeSize,
	block, rasline, model);

	if (!ret) {
	abort();
	}

	if (verbose) {
	System.out.println("done in "
	+ (System.currentTimeMillis() - tm)
	+ "ms");
	}

	return ret;
	}

	public static byte[] grow_colormap(byte[] colormap, int newlen) {
	byte[] newcm = new byte[newlen * 3];
	System.arraycopy(colormap, 0, newcm, 0, colormap.length);
	return newcm;
	}
	}

	class GifFrame {
	private static final boolean verbose = false;
	private static IndexColorModel trans_model;

	static final int DISPOSAL_NONE = 0x00;
	static final int DISPOSAL_SAVE = 0x01;
	static final int DISPOSAL_BGCOLOR = 0x02;
	static final int DISPOSAL_PREVIOUS = 0x03;

	GifImageDecoder decoder;

	int disposal_method;
	int delay;

	IndexColorModel model;

	int x;
	int y;
	int width;
	int height;

	boolean initialframe;

	public GifFrame(GifImageDecoder id, int dm, int dl, boolean init,
	IndexColorModel cm, int x, int y, int w, int h) {
	this.decoder = id;
	this.disposal_method = dm;
	this.delay = dl;
	this.model = cm;
	this.initialframe = init;
	this.x = x;
	this.y = y;
	this.width = w;
	this.height = h;
	}

	private void setPixels(int x, int y, int w, int h,
	ColorModel cm, byte[] pix, int off, int scan) {
	decoder.setPixels(x, y, w, h, cm, pix, off, scan);
	}

	public boolean dispose() {
	if (decoder.imageComplete(ImageConsumer.SINGLEFRAMEDONE, false) == 0) {
	return false;
	} else {
	if (delay > 0) {
	try {
	if (verbose) {
	System.out.println("sleeping: "+delay);
	}
	Thread.sleep(delay);
	} catch (InterruptedException e) {
	return false;
	}
	} else {
	Thread.yield();
	}

	if (verbose && disposal_method != 0) {
	System.out.println("disposal method: "+disposal_method);
	}

	int global_width = decoder.global_width;
	int global_height = decoder.global_height;

	if (x < 0) {
	width += x;
	x = 0;
	}
	if (x + width > global_width) {
	width = global_width - x;
	}
	if (width <= 0) {
	disposal_method = DISPOSAL_NONE;
	} else {
	if (y < 0) {
	height += y;
	y = 0;
	}
	if (y + height > global_height) {
	height = global_height - y;
	}
	if (height <= 0) {
	disposal_method = DISPOSAL_NONE;
	}
	}

	switch (disposal_method) {
	case DISPOSAL_PREVIOUS:
	byte[] saved_image = decoder.saved_image;
	IndexColorModel saved_model = decoder.saved_model;
	if (saved_image != null) {
	setPixels(x, y, width, height,
	saved_model, saved_image,
	y * global_width + x, global_width);
	}
	break;
	case DISPOSAL_BGCOLOR:
	byte tpix;
	if (model.getTransparentPixel() < 0) {
	model = trans_model;
	if (model == null) {
	model = new IndexColorModel(8, 1,
	new byte[4], 0, true);
	trans_model = model;
	}
	tpix = 0;
	} else {
	tpix = (byte) model.getTransparentPixel();
	}
	byte[] rasline = new byte[width];
	if (tpix != 0) {
	for (int i = 0; i < width; i++) {
	rasline[i] = tpix;
	}
	}

	// clear saved_image using transparent pixels
	// this will be used as the background in the next display
	if( decoder.saved_image != null ) {
	for( int i = 0; i < global_width * global_height; i ++ )
	decoder.saved_image[i] = tpix;
	}

	setPixels(x, y, width, height, model, rasline, 0, 0);
	break;
	case DISPOSAL_SAVE:
	decoder.saved_model = model;
	break;
	}
	}
	return true;
	}
	}

Back to index...