JAVA 由图片合成gif文件

1、需要四个类，直接应用到项目中，不需要做太多改动，除了导包： 

2、jpgToGif函数需要传入两个参数，第一个参数为要合成的图片路径数组，第二个参数为合成的GIF图片将存在的路径。 

例如： 第一个参数为 String pic[] = {"d:/1.jpg","d:/2.jpg"}; 

            第二个参数为 String newPic = "d:/test.gif"; 

            最终合成的gif文件为test.gif,由1.jpg和2.jpg合成

 public class JpgToGif {
        public void jpgToGif(String pic[], StringnewPic) {
           try {
            AnimatedGifEncoder1 e= new AnimatedGifEncoder1();
            e.setRepeat(1);
            e.start(newPic);
            for (int i = 0; i <pic.length; i++) {
                // 设置播放的延迟时间
               e.setDelay(300);
               Bitmap src = BitmapFactory.decodeFile(pic[i]);
               e.addFrame(src); // 添加到帧中
            }
            e.finish();// 刷新任何未决的数据，并关闭输出文件
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
   第二个类：
public class LZWEncoder {
    private static final int EOF = -1;

    private int imgW, imgH;
    private byte[] pixAry;
    private int initCodeSize;
    private int remaining;
    private int curPixel;

    // GIFCOMPR.C - GIF Image compression routines
    //
    // Lempel-Ziv compression based on 'compress'. GIF modificationsby
    // David Rowley (mgardi@watdcsu.waterloo.edu)

    // General DEFINEs

    static final int BITS = 12;

    static final int HSIZE = 5003; // 80% occupancy

    // GIF Image compression - modified 'compress'
    //
    // Based on: compress.c - File compression ala IEEEComputer, June 1984.
    //
    // By Authors: Spencer W. Thomas(decvax!harpo!utah-cs!utah-gr!thomas)
    // Jim McKie (decvax!mcvax!jim)
    // Steve Davies (decvax!vax135!petsd!peora!srd)
    // Ken Turkowski (decvax!decwrl!turtlevax!ken)
    // James A. Woods (decvax!ihnp4!ames!jaw)
    // Joe Orost (decvax!vax135!petsd!joe)

    int n_bits; // number of bits/code
    int maxbits = BITS; // user settable max # bits/code
    int maxcode; // maximum code, given n_bits
    int maxmaxcode = 1 << BITS; // should NEVER generatethis code

    int[] htab = new int[HSIZE];
    int[] codetab = new int[HSIZE];

    int hsize = HSIZE; // for dynamic table sizing

    int free_ent = 0; // first unused entry

    // block compression parameters -- after all codes are usedup,
    // and compression rate changes, start over.
    boolean clear_flg = false;

    // Algorithm: use open addressing double hashing (nochaining) on the
    // prefix code / next character combination. We do a variantof Knuth's
    // algorithm D (vol. 3, sec. 6.4) along with G. Knott'srelatively-prime
    // secondary probe. Here, the modular division first probeis gives way
    // to a faster exclusive-or manipulation. Also do blockcompression with
    // an adaptive reset, whereby the code table is cleared whenthe compression
    // ratio decreases, but after the table fills. Thevariable-length output
    // codes are re-sized at this point, and a special CLEARcode is generated
    // for the decompressor. Late addition: construct the tableaccording to
    // file size for noticeable speed improvement on smallfiles. Please direct
    // questions about this implementation to ames!jaw.

    int g_init_bits;

    int ClearCode;
    int EOFCode;

    // output
    //
    // Output the given code.
    // Inputs:
    // code: A n_bits-bit integer. If == -1, then EOF. Thisassumes
    // that n_bits =< wordsize - 1.
    // Outputs:
    // Outputs code to the file.
    // Assumptions:
    // Chars are 8 bits long.
    // Algorithm:
    // Maintain a BITS character long buffer (so that 8 codeswill
    // fit in it exactly). Use the VAX insv instruction toinsert each
    // code in turn. When the buffer fills up empty it and startover.

    int cur_accum = 0;
    int cur_bits = 0;

    int masks[] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F,0x001F, 0x003F,
            0x007F, 0x00FF,0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF,
            0x7FFF, 0xFFFF };

    // Number of characters so far in this 'packet'
    int a_count;

    // Define the storage for the packet accumulator
    byte[] accum = new byte[256];

    //----------------------------------------------------------------------------
    LZWEncoder(int width, int height, byte[] pixels, int color_depth){
        imgW = width;
        imgH = height;
        pixAry = pixels;
        initCodeSize = Math.max(2, color_depth);
    }

    // Add a character to the end of the current packet, and ifit is 254
    // characters, flush the packet to disk.
    void char_out(byte c, OutputStream outs) throws IOException{
        accum[a_count++] = c;
        if (a_count >= 254)
            flush_char(outs);
    }

    // Clear out the hash table

    // table clear for block compress
    void cl_block(OutputStream outs) throws IOException {
        cl_hash(hsize);
        free_ent = ClearCode + 2;
        clear_flg = true;

        output(ClearCode, outs);
    }

    // reset code table
    void cl_hash(int hsize) {
        for (int i = 0; i < hsize; ++i)
            htab[i] = -1;
    }

    void compress(int init_bits, OutputStream outs) throwsIOException {
        int fcode;
        int i /* = 0 */;
        int c;
        int ent;
        int disp;
        int hsize_reg;
        int hshift;

        // Set up the globals: g_init_bits -initial number of bits
        g_init_bits = init_bits;

        // Set up the necessary values
        clear_flg = false;
        n_bits = g_init_bits;
        maxcode = MAXCODE(n_bits);

        ClearCode = 1 << (init_bits - 1);
        EOFCode = ClearCode + 1;
        free_ent = ClearCode + 2;

        a_count = 0; // clear packet

        ent = nextPixel();

        hshift = 0;
        for (fcode = hsize; fcode < 65536;fcode *= 2)
            ++hshift;
        hshift = 8 - hshift; // set hash coderange bound

        hsize_reg = hsize;
        cl_hash(hsize_reg); // clear hash table

        output(ClearCode, outs);

        outer_loop: while ((c = nextPixel()) !=EOF) {
            fcode = (c <<maxbits) + ent;
            i = (c <<hshift) ^ ent; // xor hashing

            if (htab[i] == fcode){
                ent= codetab[i];
               continue;
            } else if (htab[i]>= 0) // non-empty slot
            {
               disp = hsize_reg - i; // secondary hash (after G. Knott)
                if(i == 0)
                   disp = 1;
                do{
                   if ((i -= disp) < 0)
                       i += hsize_reg;

                   if (htab[i] == fcode) {
                       ent = codetab[i];
                       continue outer_loop;
                   }
                }while (htab[i] >= 0);
            }
            output(ent, outs);
            ent = c;
            if (free_ent <maxmaxcode) {
               codetab[i] = free_ent++; // code -> hashtable
               htab[i] = fcode;
            } else
               cl_block(outs);
        }
        // Put out the final code.
        output(ent, outs);
        output(EOFCode, outs);
    }

    // ----------------------------------------------------------------------------
    void encode(OutputStream os) throws IOException {
        os.write(initCodeSize); // write"initial code size" byte

        remaining = imgW * imgH