code: 
  package UI;
  
  import java.io.OutputStream;
  import java.io.IOException;
  
  //==============================================================================
  //  Adapted from Jef Poskanzer's Java port by way of J. M. G. Elliott.
  //  K Weiner 12/00
  
  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 modifications by
  	// 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 IEEE Computer, 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 generate this 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 used up,
  	// and compression rate changes, start over.
  	boolean clear_flg = false;
  
  	// Algorithm:  use open addressing double hashing (no chaining) on the
  	// prefix code / next character combination.  We do a variant of Knuth's
  	// algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime
  	// secondary probe.  Here, the modular division first probe is gives way
  	// to a faster exclusive-or manipulation.  Also do block compression with
  	// an adaptive reset, whereby the code table is cleared when the compression
  	// ratio decreases, but after the table fills.  The variable-length output
  	// codes are re-sized at this point, and a special CLEAR code is generated
  	// for the decompressor.  Late addition:  construct the table according to
  	// file size for noticeable speed improvement on small files.  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.  This assumes
  	//              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 codes will
  	// fit in it exactly).  Use the VAX insv instruction to insert each
  	// code in turn.  When the buffer fills up empty it and start over.
  
  	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 if it 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) throws IOException {
  		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 code range 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; // reset navigation variables
  		curPixel = 0;
  
  		compress(initCodeSize + 1, os); // compress and write the pixel data
  
  		os.write(0); // write block terminator
  	}
  	
  	// Flush the packet to disk, and reset the accumulator
  	void flush_char(OutputStream outs) throws IOException {
  		if (a_count > 0) {
  			outs.write(a_count);
  			outs.write(accum, 0, a_count);
  			a_count = 0;
  		}
  	}
  	
  	final int MAXCODE(int n_bits) {
  		return (1 << n_bits) - 1;
  	}
  	
  	//----------------------------------------------------------------------------
  	// Return the next pixel from the image
  	//----------------------------------------------------------------------------
  	private int nextPixel() {
  		if (remaining == 0)
  			return EOF;
  
  		--remaining;
  
  		byte pix = pixAry[curPixel++];
  
  		return pix & 0xff;
  	}
  	
  	void output(int code, OutputStream outs) throws IOException {
  		cur_accum &= masks[cur_bits];
  
  		if (cur_bits > 0)
  			cur_accum |= (code << cur_bits);
  		else
  			cur_accum = code;
  
  		cur_bits += n_bits;
  
  		while (cur_bits >= 8) {
  			char_out((byte) (cur_accum & 0xff), outs);
  			cur_accum >>= 8;
  			cur_bits -= 8;
  		}
  
  		// If the next entry is going to be too big for the code size,
  		// then increase it, if possible.
  		if (free_ent > maxcode || clear_flg) {
  			if (clear_flg) {
  				maxcode = MAXCODE(n_bits = g_init_bits);
  				clear_flg = false;
  			} else {
  				++n_bits;
  				if (n_bits == maxbits)
  					maxcode = maxmaxcode;
  				else
  					maxcode = MAXCODE(n_bits);
  			}
  		}
  
  		if (code == EOFCode) {
  			// At EOF, write the rest of the buffer.
  			while (cur_bits > 0) {
  				char_out((byte) (cur_accum & 0xff), outs);
  				cur_accum >>= 8;
  				cur_bits -= 8;
  			}
  
  			flush_char(outs);
  		}
  	}
  }
  