gembin

OSGi, Eclipse Equinox, ECF, Virgo, Gemini, Apache Felix, Karaf, Aires, Camel, Eclipse RCP

HBase, Hadoop, ZooKeeper, Cassandra

Flex4, AS3, Swiz framework, GraniteDS, BlazeDS etc.

There is nothing that software can't fix. Unfortunately, there is also nothing that software can't completely fuck up. That gap is called talent.

About Me

 

AnimatedGifEncoder.java源码(处理GIF图片)

 
 

import java.io.*;
import java.awt.*;
import java.awt.image.*;

/**
 * Class AnimatedGifEncoder - Encodes a GIF file consisting of one or
 * more frames.
 * <pre>
 * Example:
 *    AnimatedGifEncoder e = new AnimatedGifEncoder();
 *    e.start(outputFileName);
 *    e.setDelay(1000);   // 1 frame per sec
 *    e.addFrame(image1);
 *    e.addFrame(image2);
 *    e.finish();
 * </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 restrictions
 * on use of the associated LZWEncoder class.  Please forward any corrections
 * to kweiner@fmsware.com.
 *
 * @author Kevin Weiner, FM Software
 * @version 1.03 November 2003
 *
 */

public class AnimatedGifEncoder {

 protected int width; // image size
 protected int height;
 protected Color transparent = null; // transparent color if given
 protected int transIndex; // transparent index in color table
 protected int repeat = -1; // no repeat
 protected int delay = 0; // frame delay (hundredths)
 protected boolean started = false; // ready to output frames
 protected OutputStream out;
 protected BufferedImage image; // current frame
 protected byte[] pixels; // BGR byte array from frame
 protected byte[] indexedPixels; // converted frame indexed to palette
 protected int colorDepth; // number of bit planes
 protected byte[] colorTab; // RGB palette
 protected boolean[] usedEntry = new boolean[256]; // active palette entries
 protected int palSize = 7; // color table size (bits-1)
 protected int dispose = -1; // disposal code (-1 = use default)
 protected boolean closeStream = false; // close stream when finished
 protected boolean firstFrame = true;
 protected boolean sizeSet = false; // if false, get size from first frame
 protected int sample = 10; // default sample interval for quantizer

 /**
  * Sets the delay time between each frame, or changes it
  * for subsequent frames (applies to last frame added).
  *
  * @param ms int delay time in milliseconds
  */
 public void setDelay(int ms) {
  delay = Math.round(ms / 10.0f);
 }
 
 /**
  * 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.
  */
 public void setDispose(int code) {
  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
  */
 public void setRepeat(int iter) {
  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 c Color to be treated as transparent on display.
  */
 public void setTransparent(Color c) {
  transparent = c;
 }
 
 /**
  * Adds next GIF frame.  The frame is not written immediately, but is
  * actually deferred until the next frame is received so that timing
  * data can be inserted.  Invoking <code>finish()</code> flushes all
  * frames.  If <code>setSize</code> was not invoked, the size of the
  * first image is used for all subsequent frames.
  *
  * @param im BufferedImage containing frame to write.
  * @return true if successful.
  */
 public boolean addFrame(BufferedImage im) {
  if ((im == null) || !started) {
   return false;
  }
  boolean ok = true;
  try {
   if (!sizeSet) {
    // use first frame's size
    setSize(im.getWidth(), im.getHeight());
   }
   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 (IOException e) {
   ok = false;
  }

  return ok;
 }
 
 /**
  * Flushes any pending data and closes output file.
  * If writing to an OutputStream, the stream is not
  * closed.
  */
 public boolean finish() {
  if (!started) return false;
  boolean ok = true;
  started = false;
  try {
   out.write(0x3b); // gif trailer
   out.flush();
   if (closeStream) {
    out.close();
   }
  } catch (IOException e) {
   ok = false;
  }

  // reset for subsequent use
  transIndex = 0;
  out = null;
  image = null;
  pixels = null;
  indexedPixels = null;
  colorTab = null;
  closeStream = false;
  firstFrame = true;

  return ok;
 }
 
 /**
  * Sets frame rate in frames per second.  Equivalent to
  * <code>setDelay(1000/fps)</code>.
  *
  * @param fps float frame rate (frames per second)
  */
 public void setFrameRate(float fps) {
  if (fps != 0f) {
   delay = Math.round(100f / 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
  */
 public void setQuality(int quality) {
  if (quality < 1) quality = 1;
  sample = 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.
  */
 public void setSize(int w, int h) {
  if (started && !firstFrame) return;
  width = w;
  height = h;
  if (width < 1) width = 320;
  if (height < 1) height = 240;
  sizeSet = true;
 }
 
 /**
  * Initiates GIF file creation on the given stream.  The stream
  * is not closed automatically.
  *
  * @param os OutputStream on which GIF images are written.
  * @return false if initial write failed.
  */
 public boolean start(OutputStream os) {
  if (os == null) return false;
  boolean ok = true;
  closeStream = false;
  out = os;
  try {
   writeString("GIF89a"); // header
  } catch (IOException e) {
   ok = false;
  }
  return started = ok;
 }
 
 /**
  * Initiates writing of a GIF file with the specified name.
  *
  * @param file String containing output file name.
  * @return false if open or initial write failed.
  */
 public boolean start(String file) {
  boolean ok = true;
  try {
   out = new BufferedOutputStream(new FileOutputStream(file));
   ok = start(out);
   closeStream = true;
  } catch (IOException e) {
   ok = false;
  }
  return started = ok;
 }
 
 /**
  * Analyzes image colors and creates color map.
  */
 protected void analyzePixels() {
  int len = pixels.length;
  int nPix = len / 3;
  indexedPixels = new byte[nPix];
  NeuQuant nq = new NeuQuant(pixels, len, sample);
  // initialize quantizer
  colorTab = nq.process(); // create reduced palette
  // convert map from BGR to RGB
  for (int i = 0; i < colorTab.length; i += 3) {
   byte temp = colorTab[i];
   colorTab[i] = colorTab[i + 2];
   colorTab[i + 2] = temp;
   usedEntry[i / 3] = false;
  }
  // map image pixels to new palette
  int k = 0;
  for (int i = 0; i < nPix; i++) {
   int index =
    nq.map(pixels[k++] & 0xff,
        pixels[k++] & 0xff,
        pixels[k++] & 0xff);
   usedEntry[index] = true;
   indexedPixels[i] = (byte) 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
  *
  */
 protected int findClosest(Color c) {
  if (colorTab == null) return -1;
  int r = c.getRed();
  int g = c.getGreen();
  int b = c.getBlue();
  int minpos = 0;
  int dmin = 256 * 256 * 256;
  int len = colorTab.length;
  for (int i = 0; i < len;) {
   int dr = r - (colorTab[i++] & 0xff);
   int dg = g - (colorTab[i++] & 0xff);
   int db = b - (colorTab[i] & 0xff);
   int d = dr * dr + dg * dg + db * db;
   int index = i / 3;
   if (usedEntry[index] && (d < dmin)) {
    dmin = d;
    minpos = index;
   }
   i++;
  }
  return minpos;
 }
 
 /**
  * Extracts image pixels into byte array "pixels"
  */
 protected void getImagePixels() {
  int w = image.getWidth();
  int h = image.getHeight();
  int type = image.getType();
  if ((w != width)
   || (h != height)
   || (type != BufferedImage.TYPE_3BYTE_BGR)) {
   // create new image with right size/format
   BufferedImage temp =
    new BufferedImage(width, height, BufferedImage.TYPE_3BYTE_BGR);
   Graphics2D g = temp.createGraphics();
   g.drawImage(image, 0, 0, null);
   image = temp;
  }
  pixels = ((DataBufferByte) image.getRaster().getDataBuffer()).getData();
 }
 
 /**
  * Writes Graphic Control Extension
  */
 protected void writeGraphicCtrlExt() throws IOException {
  out.write(0x21); // extension introducer
  out.write(0xf9); // GCE label
  out.write(4); // data block size
  int transp, disp;
  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.write(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.write(transIndex); // transparent color index
  out.write(0); // block terminator
 }
 
 /**
  * Writes Image Descriptor
  */
 protected void writeImageDesc() throws IOException {
  out.write(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.write(0);
  } else {
   // specify normal LCT
   out.write(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
  */
 protected void writeLSD() throws IOException {
  // logical screen size
  writeShort(width);
  writeShort(height);
  // packed fields
  out.write((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.write(0); // background color index
  out.write(0); // pixel aspect ratio - assume 1:1
 }
 
 /**
  * Writes Netscape application extension to define
  * repeat count.
  */
 protected void writeNetscapeExt() throws IOException {
  out.write(0x21); // extension introducer
  out.write(0xff); // app extension label
  out.write(11); // block size
  writeString("NETSCAPE" + "2.0"); // app id + auth code
  out.write(3); // sub-block size
  out.write(1); // loop sub-block id
  writeShort(repeat); // loop count (extra iterations, 0=repeat forever)
  out.write(0); // block terminator
 }
 
 /**
  * Writes color table
  */
 protected void writePalette() throws IOException {
  out.write(colorTab, 0, colorTab.length);
  int n = (3 * 256) - colorTab.length;
  for (int i = 0; i < n; i++) {
   out.write(0);
  }
 }
 
 /**
  * Encodes and writes pixel data
  */
 protected void writePixels() throws IOException {
  LZWEncoder encoder =
   new LZWEncoder(width, height, indexedPixels, colorDepth);
  encoder.encode(out);
 }
 
 /**
  *    Write 16-bit value to output stream, LSB first
  */
 protected void writeShort(int value) throws IOException {
  out.write(value & 0xff);
  out.write((value >> 8) & 0xff);
 }
 
 /**
  * Writes string to output stream
  */
 protected void writeString(String s) throws IOException {
  for (int i = 0; i < s.length(); i++) {
   out.write((byte) s.charAt(i));
  }
 }
}

posted on 2007-09-21 11:15 gembin 阅读(4413) 评论(0)  编辑  收藏


只有注册用户登录后才能发表评论。


网站导航:
 

导航

统计

常用链接

留言簿(6)

随笔分类(440)

随笔档案(378)

文章档案(6)

新闻档案(1)

相册

收藏夹(9)

Adobe

Android

AS3

Blog-Links

Build

Design Pattern

Eclipse

Favorite Links

Flickr

Game Dev

HBase

Identity Management

IT resources

JEE

Language

OpenID

OSGi

SOA

Version Control

最新随笔

搜索

积分与排名

最新评论

阅读排行榜

评论排行榜

free counters