<rt id="bn8ez"></rt>
<label id="bn8ez"></label>

  • <span id="bn8ez"></span>

    <label id="bn8ez"><meter id="bn8ez"></meter></label>

    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 閱讀(4995) 評(píng)論(0)  編輯  收藏


    只有注冊(cè)用戶(hù)登錄后才能發(fā)表評(píng)論。


    網(wǎng)站導(dǎo)航:
     

    導(dǎo)航

    統(tǒng)計(jì)

    常用鏈接

    留言簿(6)

    隨筆分類(lèi)(440)

    隨筆檔案(378)

    文章檔案(6)

    新聞檔案(1)

    相冊(cè)

    收藏夾(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

    最新隨筆

    搜索

    積分與排名

    最新評(píng)論

    閱讀排行榜

    評(píng)論排行榜

    free counters
    主站蜘蛛池模板: 在线播放高清国语自产拍免费| 成人免费ā片在线观看| 国产va精品免费观看| 毛片在线全部免费观看| 免费A级毛片无码免费视| 亚洲国产精品日韩专区AV| 亚洲毛片免费观看| 黄页网站在线视频免费| 亚洲高清国产拍精品青青草原 | 亚洲精品美女久久7777777| 久久免费看黄a级毛片| 亚洲男人的天堂一区二区| 亚洲欧洲精品视频在线观看| 久久成人国产精品免费软件| 国产成人亚洲精品狼色在线| 三级毛片在线免费观看| 亚洲精品在线免费看| 在线观看视频免费完整版| 美女被暴羞羞免费视频| 亚洲精品乱码久久久久久| 老湿机一区午夜精品免费福利| 亚洲A∨精品一区二区三区| 中国精品一级毛片免费播放| 91亚洲va在线天线va天堂va国产| 可以免费看黄的网站| 亚洲性色高清完整版在线观看| 丝瓜app免费下载网址进入ios| 亚洲国产精品一区二区久久| 成人午夜18免费看| a级毛片视频免费观看| 亚洲国产精品自在拍在线播放 | 亚洲一区电影在线观看| 国产精品免费久久| 免费乱码中文字幕网站| 国产在线精品观看免费观看| 亚洲国产高清在线| 日韩免费观看视频| 久9热免费精品视频在线观看| 亚洲精品亚洲人成在线| 亚洲中文字幕日产乱码高清app| 无码国产精品一区二区免费式直播|