version update

Res/Gif.Components/AnimatedGifEncoder.cs

@@ -0,0 +1,562 @@
+using System;
+using System.IO;
+using SkiaSharp;
+
+namespace Gif.Components
+{
+    public class AnimatedGifEncoder
+    {
+        protected int width; // image size
+        protected int height;
+        protected SKColor transparent = SKColor.Empty; // 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 bool started = false; // ready to output frames
+                                        //	protected BinaryWriter bw;
+        protected MemoryStream ms;
+        //		protected FileStream fs;
+
+        protected SKBitmap 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 bool[] usedEntry = new bool[256]; // active palette entries
+        protected int palSize = 7; // color table size (bits-1)
+        protected int dispose = -1; // disposal code (-1 = use default)
+        protected bool closeStream = false; // close stream when finished
+        protected bool firstFrame = true;
+        protected bool 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 = (int)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(SKColor 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 bool AddFrame(SKBitmap im)
+        {
+            if ((im == null) || !started)
+            {
+                return false;
+            }
+            bool ok = true;
+            try
+            {
+                if (!sizeSet)
+                {
+                    // use first frame's size
+                    SetSize(im.Width, im.Height);
+                }
+                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)
+            {
+                ok = false;
+            }
+
+            return ok;
+        }
+
+        /**
+		 * Flushes any pending data and closes output file.
+		 * If writing to an OutputStream, the stream is not
+		 * closed.
+		 */
+        public bool Finish()
+        {
+            if (!started) return false;
+            bool ok = true;
+            started = false;
+            try
+            {
+                ms.WriteByte(0x3b); // gif trailer
+                ms.Flush();
+                if (closeStream)
+                {
+                    //					ms.Close();
+                }
+            }
+            catch (IOException)
+            {
+                ok = false;
+            }
+
+            // reset for subsequent use
+            transIndex = 0;
+            //			fs = 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 = (int)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 bool Start(MemoryStream os)
+        {
+            if (os == null) return false;
+            bool ok = true;
+            closeStream = false;
+            ms = os;
+            try
+            {
+                WriteString("GIF89a"); // header
+            }
+            catch (IOException)
+            {
+                ok = false;
+            }
+            return started = ok;
+        }
+
+        /**
+		 * Initiates writing of a GIF file to a memory stream.
+		 *
+		 * @return false if open or initial write failed.
+		 */
+        public bool Start()
+        {
+            bool ok;
+            try
+            {
+                ok = Start(new MemoryStream(10 * 1024));
+                closeStream = true;
+            }
+            catch (IOException)
+            {
+                ok = false;
+            }
+            return started = ok;
+        }
+
+        /**
+		 * Initiates writing of a GIF file with the specified name.
+		 *
+		 * @return false if open or initial write failed.
+		 */
+        public bool Output(string file)
+        {
+            try
+            {
+                FileStream fs = new FileStream(file, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None);
+                fs.Write(ms.ToArray(), 0, (int)ms.Length);
+                fs.Close();
+            }
+            catch (IOException)
+            {
+                return false;
+            }
+            return true;
+        }
+
+        public MemoryStream Output()
+        {
+            return ms;
+        }
+
+        /**
+		 * 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 != SKColor.Empty)
+            {
+                //transIndex = FindClosest(transparent);
+                transIndex = nq.Map(transparent.Blue, transparent.Green, transparent.Red);
+            }
+        }
+
+        /**
+		 * Returns index of palette color closest to c
+		 *
+		 */
+        protected int FindClosest(SKColor c)
+        {
+            if (colorTab == null) return -1;
+            int r = c.Red;
+            int g = c.Green;
+            int b = c.Blue;
+            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.Width;
+            int h = image.Height;
+            //		int type = image.GetType().;
+            if ((w != width)
+                || (h != height)
+                )
+            {
+                // create new image with right size/format
+                //Image temp =
+                //    new Bitmap(width, height);
+                //Graphics g = Graphics.FromImage(temp);
+                //g.DrawImage(image, 0, 0);
+                //image = temp;
+                //g.Dispose();
+                var temp = new SKBitmap(width, height);
+                var canvas = new SKCanvas(temp);
+                canvas.DrawBitmap(image, 0, 0);
+                image = temp;
+                canvas.Dispose();
+            }
+            /*
+				ToDo:
+				improve performance: use unsafe code 
+			*/
+            pixels = new byte[3 * image.Width * image.Height];
+            int count = 0;
+            for (int th = 0; th < image.Height; th++)
+            {
+                for (int tw = 0; tw < image.Width; tw++)
+                {
+                    var color = image.GetPixel(tw, th);
+                    pixels[count] = color.Red;
+                    count++;
+                    pixels[count] = color.Green;
+                    count++;
+                    pixels[count] = color.Blue;
+                    count++;
+                }
+            }
+
+            //		pixels = ((DataBufferByte) image.getRaster().getDataBuffer()).getData();
+        }
+
+        /**
+		 * Writes Graphic Control Extension
+		 */
+        protected void WriteGraphicCtrlExt()
+        {
+            ms.WriteByte(0x21); // extension introducer
+            ms.WriteByte(0xf9); // GCE label
+            ms.WriteByte(4); // data block size
+            int transp, disp;
+            if (transparent == SKColor.Empty)
+            {
+                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
+            ms.WriteByte(Convert.ToByte(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
+            ms.WriteByte(Convert.ToByte(transIndex)); // transparent color index
+            ms.WriteByte(0); // block terminator
+        }
+
+        /**
+		 * Writes Image Descriptor
+		 */
+        protected void WriteImageDesc()
+        {
+            ms.WriteByte(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
+                ms.WriteByte(0);
+            }
+            else
+            {
+                // specify normal LCT
+                ms.WriteByte(Convert.ToByte(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()
+        {
+            // logical screen size
+            WriteShort(width);
+            WriteShort(height);
+            // packed fields
+            ms.WriteByte(Convert.ToByte(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
+
+            ms.WriteByte(0); // background color index
+            ms.WriteByte(0); // pixel aspect ratio - assume 1:1
+        }
+
+        /**
+		 * Writes Netscape application extension to define
+		 * repeat count.
+		 */
+        protected void WriteNetscapeExt()
+        {
+            ms.WriteByte(0x21); // extension introducer
+            ms.WriteByte(0xff); // app extension label
+            ms.WriteByte(11); // block size
+            WriteString("NETSCAPE" + "2.0"); // app id + auth code
+            ms.WriteByte(3); // sub-block size
+            ms.WriteByte(1); // loop sub-block id
+            WriteShort(repeat); // loop count (extra iterations, 0=repeat forever)
+            ms.WriteByte(0); // block terminator
+        }
+
+        /**
+		 * Writes color table
+		 */
+        protected void WritePalette()
+        {
+            ms.Write(colorTab, 0, colorTab.Length);
+            int n = (3 * 256) - colorTab.Length;
+            for (int i = 0; i < n; i++)
+            {
+                ms.WriteByte(0);
+            }
+        }
+
+        /**
+		 * Encodes and writes pixel data
+		 */
+        protected void WritePixels()
+        {
+            LZWEncoder encoder =
+                new LZWEncoder(width, height, indexedPixels, colorDepth);
+            encoder.Encode(ms);
+        }
+
+        /**
+		 *    Write 16-bit value to output stream, LSB first
+		 */
+        protected void WriteShort(int value)
+        {
+            ms.WriteByte(Convert.ToByte(value & 0xff));
+            ms.WriteByte(Convert.ToByte((value >> 8) & 0xff));
+        }
+
+        /**
+		 * Writes string to output stream
+		 */
+        protected void WriteString(string s)
+        {
+            char[] chars = s.ToCharArray();
+            for (int i = 0; i < chars.Length; i++)
+            {
+                ms.WriteByte((byte)chars[i]);
+            }
+        }
+    }
+
+}

Res/Gif.Components/LZWEncoder.cs

@@ -0,0 +1,321 @@
+using System;
+using System.IO;
+
+namespace Gif.Components
+{
+	public class LZWEncoder 
+	{
+
+		private static readonly 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 readonly int BITS = 12;
+
+		static readonly 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.
+		bool 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];
+
+		//----------------------------------------------------------------------------
+		public 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 Add(byte c, Stream outs)
+		{
+			accum[a_count++] = c;
+			if (a_count >= 254)
+				Flush(outs);
+		}
+	
+		// Clear out the hash table
+
+		// table clear for block compress
+		void ClearTable(Stream outs)
+		{
+			ResetCodeTable(hsize);
+			free_ent = ClearCode + 2;
+			clear_flg = true;
+
+			Output(ClearCode, outs);
+		}
+	
+		// reset code table
+		void ResetCodeTable(int hsize) 
+		{
+			for (int i = 0; i < hsize; ++i)
+				htab[i] = -1;
+		}
+	
+		void Compress(int init_bits, Stream outs)
+		{
+			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;
+			ResetCodeTable(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];
+										 goto 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
+							 	ClearTable(outs);
+						 }
+			// Put out the final code.
+			Output(ent, outs);
+			Output(EOFCode, outs);
+		}
+	
+		//----------------------------------------------------------------------------
+		public void Encode( Stream os)
+		{
+			os.WriteByte( Convert.ToByte( 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.WriteByte(0); // write block terminator
+		}
+	
+		// Flush the packet to disk, and reset the accumulator
+		void Flush(Stream outs)
+		{
+			if (a_count > 0) 
+			{
+				outs.WriteByte( Convert.ToByte( a_count ));
+				outs.Write(accum, 0, a_count);
+				a_count = 0;
+			}
+		}
+	
+		int MaxCode(int n_bits) 
+		{
+			return (1 << n_bits) - 1;
+		}
+	
+		//----------------------------------------------------------------------------
+		// Return the next pixel from the image
+		//----------------------------------------------------------------------------
+		private int NextPixel() 
+		{
+            int upperBound = pixAry.GetUpperBound(0);
+
+            return (curPixel <= upperBound) ? (pixAry[curPixel++] & 0xff) : EOF;
+        }
+	
+		void Output(int code, Stream outs)
+		{
+			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) 
+			{
+				Add((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) 
+				{
+					Add((byte) (cur_accum & 0xff), outs);
+					cur_accum >>= 8;
+					cur_bits -= 8;
+				}
+
+				Flush(outs);
+			}
+		}
+	}
+}

Res/Gif.Components/NeuQuant.cs

@@ -0,0 +1,479 @@
+using System;
+
+namespace Gif.Components
+{
+	public class NeuQuant 
+	{
+		protected static readonly int netsize = 256; /* number of colours used */
+		/* four primes near 500 - assume no image has a length so large */
+		/* that it is divisible by all four primes */
+		protected static readonly int prime1 = 499;
+		protected static readonly int prime2 = 491;
+		protected static readonly int prime3 = 487;
+		protected static readonly int prime4 = 503;
+		protected static readonly int minpicturebytes = ( 3 * prime4 );
+		/* minimum size for input image */
+		/* Program Skeleton
+		   ----------------
+		   [select samplefac in range 1..30]
+		   [read image from input file]
+		   pic = (unsigned char*) malloc(3*width*height);
+		   initnet(pic,3*width*height,samplefac);
+		   learn();
+		   unbiasnet();
+		   [write output image header, using writecolourmap(f)]
+		   inxbuild();
+		   write output image using inxsearch(b,g,r)      */
+
+		/* Network Definitions
+		   ------------------- */
+		protected static readonly int maxnetpos = (netsize - 1);
+		protected static readonly int netbiasshift = 4; /* bias for colour values */
+		protected static readonly int ncycles = 100; /* no. of learning cycles */
+
+		/* defs for freq and bias */
+		protected static readonly int intbiasshift = 16; /* bias for fractions */
+		protected static readonly int intbias = (((int) 1) << intbiasshift);
+		protected static readonly int gammashift = 10; /* gamma = 1024 */
+		protected static readonly int gamma = (((int) 1) << gammashift);
+		protected static readonly int betashift = 10;
+		protected static readonly int beta = (intbias >> betashift); /* beta = 1/1024 */
+		protected static readonly int betagamma =
+			(intbias << (gammashift - betashift));
+
+		/* defs for decreasing radius factor */
+		protected static readonly int initrad = (netsize >> 3); /* for 256 cols, radius starts */
+		protected static readonly int radiusbiasshift = 6; /* at 32.0 biased by 6 bits */
+		protected static readonly int radiusbias = (((int) 1) << radiusbiasshift);
+		protected static readonly int initradius = (initrad * radiusbias); /* and decreases by a */
+		protected static readonly int radiusdec = 30; /* factor of 1/30 each cycle */
+
+		/* defs for decreasing alpha factor */
+		protected static readonly int alphabiasshift = 10; /* alpha starts at 1.0 */
+		protected static readonly int initalpha = (((int) 1) << alphabiasshift);
+
+		protected int alphadec; /* biased by 10 bits */
+
+		/* radbias and alpharadbias used for radpower calculation */
+		protected static readonly int radbiasshift = 8;
+		protected static readonly int radbias = (((int) 1) << radbiasshift);
+		protected static readonly int alpharadbshift = (alphabiasshift + radbiasshift);
+		protected static readonly int alpharadbias = (((int) 1) << alpharadbshift);
+
+		/* Types and Global Variables
+		-------------------------- */
+
+		protected byte[] thepicture; /* the input image itself */
+		protected int lengthcount; /* lengthcount = H*W*3 */
+
+		protected int samplefac; /* sampling factor 1..30 */
+
+		//   typedef int pixel[4];                /* BGRc */
+		protected int[][] network; /* the network itself - [netsize][4] */
+
+		protected int[] netindex = new int[256];
+		/* for network lookup - really 256 */
+
+		protected int[] bias = new int[netsize];
+		/* bias and freq arrays for learning */
+		protected int[] freq = new int[netsize];
+		protected int[] radpower = new int[initrad];
+		/* radpower for precomputation */
+
+		/* Initialise network in range (0,0,0) to (255,255,255) and set parameters
+		   ----------------------------------------------------------------------- */
+		public NeuQuant(byte[] thepic, int len, int sample) 
+		{
+
+			int i;
+			int[] p;
+
+			thepicture = thepic;
+			lengthcount = len;
+			samplefac = sample;
+
+			network = new int[netsize][];
+			for (i = 0; i < netsize; i++) 
+			{
+				network[i] = new int[4];
+				p = network[i];
+				p[0] = p[1] = p[2] = (i << (netbiasshift + 8)) / netsize;
+				freq[i] = intbias / netsize; /* 1/netsize */
+				bias[i] = 0;
+			}
+		}
+	
+		public byte[] ColorMap() 
+		{
+			byte[] map = new byte[3 * netsize];
+			int[] index = new int[netsize];
+			for (int i = 0; i < netsize; i++)
+				index[network[i][3]] = i;
+			int k = 0;
+			for (int i = 0; i < netsize; i++) 
+			{
+				int j = index[i];
+				map[k++] = (byte) (network[j][0]);
+				map[k++] = (byte) (network[j][1]);
+				map[k++] = (byte) (network[j][2]);
+			}
+			return map;
+		}
+	
+		/* Insertion sort of network and building of netindex[0..255] (to do after unbias)
+		   ------------------------------------------------------------------------------- */
+		public void Inxbuild() 
+		{
+
+			int i, j, smallpos, smallval;
+			int[] p;
+			int[] q;
+			int previouscol, startpos;
+
+			previouscol = 0;
+			startpos = 0;
+			for (i = 0; i < netsize; i++) 
+			{
+				p = network[i];
+				smallpos = i;
+				smallval = p[1]; /* index on g */
+				/* find smallest in i..netsize-1 */
+				for (j = i + 1; j < netsize; j++) 
+				{
+					q = network[j];
+					if (q[1] < smallval) 
+					{ /* index on g */
+						smallpos = j;
+						smallval = q[1]; /* index on g */
+					}
+				}
+				q = network[smallpos];
+				/* swap p (i) and q (smallpos) entries */
+				if (i != smallpos) 
+				{
+					j = q[0];
+					q[0] = p[0];
+					p[0] = j;
+					j = q[1];
+					q[1] = p[1];
+					p[1] = j;
+					j = q[2];
+					q[2] = p[2];
+					p[2] = j;
+					j = q[3];
+					q[3] = p[3];
+					p[3] = j;
+				}
+				/* smallval entry is now in position i */
+				if (smallval != previouscol) 
+				{
+					netindex[previouscol] = (startpos + i) >> 1;
+					for (j = previouscol + 1; j < smallval; j++)
+						netindex[j] = i;
+					previouscol = smallval;
+					startpos = i;
+				}
+			}
+			netindex[previouscol] = (startpos + maxnetpos) >> 1;
+			for (j = previouscol + 1; j < 256; j++)
+				netindex[j] = maxnetpos; /* really 256 */
+		}
+	
+		/* Main Learning Loop
+		   ------------------ */
+		public void Learn() 
+		{
+
+			int i, j, b, g, r;
+			int radius, rad, alpha, step, delta, samplepixels;
+			byte[] p;
+			int pix, lim;
+
+			if (lengthcount < minpicturebytes)
+				samplefac = 1;
+			alphadec = 30 + ((samplefac - 1) / 3);
+			p = thepicture;
+			pix = 0;
+			lim = lengthcount;
+			samplepixels = lengthcount / (3 * samplefac);
+			delta = samplepixels / ncycles;
+			alpha = initalpha;
+			radius = initradius;
+
+			rad = radius >> radiusbiasshift;
+			if (rad <= 1)
+				rad = 0;
+			for (i = 0; i < rad; i++)
+				radpower[i] =
+					alpha * (((rad * rad - i * i) * radbias) / (rad * rad));
+
+			//fprintf(stderr,"beginning 1D learning: initial radius=%d\n", rad);
+
+			if (lengthcount < minpicturebytes)
+				step = 3;
+			else if ((lengthcount % prime1) != 0)
+				step = 3 * prime1;
+			else 
+			{
+				if ((lengthcount % prime2) != 0)
+					step = 3 * prime2;
+				else 
+				{
+					if ((lengthcount % prime3) != 0)
+						step = 3 * prime3;
+					else
+						step = 3 * prime4;
+				}
+			}
+
+			i = 0;
+			while (i < samplepixels) 
+			{
+				b = (p[pix + 0] & 0xff) << netbiasshift;
+				g = (p[pix + 1] & 0xff) << netbiasshift;
+				r = (p[pix + 2] & 0xff) << netbiasshift;
+				j = Contest(b, g, r);
+
+				Altersingle(alpha, j, b, g, r);
+				if (rad != 0)
+					Alterneigh(rad, j, b, g, r); /* alter neighbours */
+
+				pix += step;
+				if (pix >= lim)
+					pix -= lengthcount;
+
+				i++;
+				if (delta == 0)
+					delta = 1;
+				if (i % delta == 0) 
+				{
+					alpha -= alpha / alphadec;
+					radius -= radius / radiusdec;
+					rad = radius >> radiusbiasshift;
+					if (rad <= 1)
+						rad = 0;
+					for (j = 0; j < rad; j++)
+						radpower[j] =
+							alpha * (((rad * rad - j * j) * radbias) / (rad * rad));
+				}
+			}
+			//fprintf(stderr,"finished 1D learning: readonly alpha=%f !\n",((float)alpha)/initalpha);
+		}
+	
+		/* Search for BGR values 0..255 (after net is unbiased) and return colour index
+		   ---------------------------------------------------------------------------- */
+		public int Map(int b, int g, int r) 
+		{
+
+			int i, j, dist, a, bestd;
+			int[] p;
+			int best;
+
+			bestd = 1000; /* biggest possible dist is 256*3 */
+			best = -1;
+			i = netindex[g]; /* index on g */
+			j = i - 1; /* start at netindex[g] and work outwards */
+
+			while ((i < netsize) || (j >= 0)) 
+			{
+				if (i < netsize) 
+				{
+					p = network[i];
+					dist = p[1] - g; /* inx key */
+					if (dist >= bestd)
+						i = netsize; /* stop iter */
+					else 
+					{
+						i++;
+						if (dist < 0)
+							dist = -dist;
+						a = p[0] - b;
+						if (a < 0)
+							a = -a;
+						dist += a;
+						if (dist < bestd) 
+						{
+							a = p[2] - r;
+							if (a < 0)
+								a = -a;
+							dist += a;
+							if (dist < bestd) 
+							{
+								bestd = dist;
+								best = p[3];
+							}
+						}
+					}
+				}
+				if (j >= 0) 
+				{
+					p = network[j];
+					dist = g - p[1]; /* inx key - reverse dif */
+					if (dist >= bestd)
+						j = -1; /* stop iter */
+					else 
+					{
+						j--;
+						if (dist < 0)
+							dist = -dist;
+						a = p[0] - b;
+						if (a < 0)
+							a = -a;
+						dist += a;
+						if (dist < bestd) 
+						{
+							a = p[2] - r;
+							if (a < 0)
+								a = -a;
+							dist += a;
+							if (dist < bestd) 
+							{
+								bestd = dist;
+								best = p[3];
+							}
+						}
+					}
+				}
+			}
+			return (best);
+		}
+		public byte[] Process() 
+		{
+			Learn();
+			Unbiasnet();
+			Inxbuild();
+			return ColorMap();
+		}
+	
+		/* Unbias network to give byte values 0..255 and record position i to prepare for sort
+		   ----------------------------------------------------------------------------------- */
+		public void Unbiasnet() 
+		{
+
+			int i;
+
+			for (i = 0; i < netsize; i++) 
+			{
+				network[i][0] >>= netbiasshift;
+				network[i][1] >>= netbiasshift;
+				network[i][2] >>= netbiasshift;
+				network[i][3] = i; /* record colour no */
+			}
+		}
+	
+		/* Move adjacent neurons by precomputed alpha*(1-((i-j)^2/[r]^2)) in radpower[|i-j|]
+		   --------------------------------------------------------------------------------- */
+		protected void Alterneigh(int rad, int i, int b, int g, int r) 
+		{
+
+			int j, k, lo, hi, a, m;
+			int[] p;
+
+			lo = i - rad;
+			if (lo < -1)
+				lo = -1;
+			hi = i + rad;
+			if (hi > netsize)
+				hi = netsize;
+
+			j = i + 1;
+			k = i - 1;
+			m = 1;
+			while ((j < hi) || (k > lo)) 
+			{
+				a = radpower[m++];
+				if (j < hi) 
+				{
+					p = network[j++];
+					try 
+					{
+						p[0] -= (a * (p[0] - b)) / alpharadbias;
+						p[1] -= (a * (p[1] - g)) / alpharadbias;
+						p[2] -= (a * (p[2] - r)) / alpharadbias;
+					} 
+					catch (Exception) 
+					{
+					} // prevents 1.3 miscompilation
+				}
+				if (k > lo) 
+				{
+					p = network[k--];
+					try 
+					{
+						p[0] -= (a * (p[0] - b)) / alpharadbias;
+						p[1] -= (a * (p[1] - g)) / alpharadbias;
+						p[2] -= (a * (p[2] - r)) / alpharadbias;
+					} 
+					catch (Exception) 
+					{
+					}
+				}
+			}
+		}
+	
+		/* Move neuron i towards biased (b,g,r) by factor alpha
+		   ---------------------------------------------------- */
+		protected void Altersingle(int alpha, int i, int b, int g, int r) 
+		{
+
+			/* alter hit neuron */
+			int[] n = network[i];
+			n[0] -= (alpha * (n[0] - b)) / initalpha;
+			n[1] -= (alpha * (n[1] - g)) / initalpha;
+			n[2] -= (alpha * (n[2] - r)) / initalpha;
+		}
+	
+		/* Search for biased BGR values
+		   ---------------------------- */
+		protected int Contest(int b, int g, int r) 
+		{
+
+			/* finds closest neuron (min dist) and updates freq */
+			/* finds best neuron (min dist-bias) and returns position */
+			/* for frequently chosen neurons, freq[i] is high and bias[i] is negative */
+			/* bias[i] = gamma*((1/netsize)-freq[i]) */
+
+			int i, dist, a, biasdist, betafreq;
+			int bestpos, bestbiaspos, bestd, bestbiasd;
+			int[] n;
+
+			bestd = ~(((int) 1) << 31);
+			bestbiasd = bestd;
+			bestpos = -1;
+			bestbiaspos = bestpos;
+
+			for (i = 0; i < netsize; i++) 
+			{
+				n = network[i];
+				dist = n[0] - b;
+				if (dist < 0)
+					dist = -dist;
+				a = n[1] - g;
+				if (a < 0)
+					a = -a;
+				dist += a;
+				a = n[2] - r;
+				if (a < 0)
+					a = -a;
+				dist += a;
+				if (dist < bestd) 
+				{
+					bestd = dist;
+					bestpos = i;
+				}
+				biasdist = dist - ((bias[i]) >> (intbiasshift - netbiasshift));
+				if (biasdist < bestbiasd) 
+				{
+					bestbiasd = biasdist;
+					bestbiaspos = i;
+				}
+				betafreq = (freq[i] >> betashift);
+				freq[i] -= betafreq;
+				bias[i] += (betafreq << gammashift);
+			}
+			freq[bestpos] += beta;
+			bias[bestpos] -= betagamma;
+			return (bestbiaspos);
+		}
+	}
+}