| /* |
| * 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; |
| } |
| } |
