c# 制作gif的四种方法

方法一：使用AnimatedGif库

Nuget安装包：

Install-Package AnimatedGif -Version 1.0.5

https://www.nuget.org/packages/AnimatedGif/

其源码在：https://github.com/mrousavy/AnimatedGif

代码：

// 33ms delay (~30fps)
using (var gif = AnimatedGif.Create("gif.gif", 33))
{
 var img = Image.FromFile("img.png");
 gif.AddFrame(img, delay: -1, quality: GifQuality.Bit8);
}

方法二：使用微软GifBitmapEncoder

https://docs.microsoft.com/en-us/dotnet/api/system.windows.media.imaging.gifbitmapencoder

GifBitmapEncoder gEnc = new GifBitmapEncoder();
       while (!bStop)
       {
         var img = CopyScreen(); //System.Drawing.Image.FromFile("img.png");
         System.Drawing.Bitmap bmpImage = (Bitmap)img;
         var bmp = bmpImage.GetHbitmap();
         var src = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(
           bmp,
           IntPtr.Zero,
           Int32Rect.Empty,
           BitmapSizeOptions.FromEmptyOptions());
         gEnc.Frames.Add(BitmapFrame.Create(src));

Thread.Sleep(200);
       }

using (FileStream fs = new FileStream("g:\\GifBitmapEncoder.gif", FileMode.Create))
       {
         gEnc.Save(fs);
       }

方法三：使用Ngif

源码地址：https://www.codeproject.com/Articles/11505/NGif-Animated-GIF-Encoder-for-NET

代码：

/* create Gif */
//you should replace filepath
String [] imageFilePaths = new String[]{"c:\\01.png","c:\\02.png","c:\\03.png"};
String outputFilePath = "c:\\test.gif";
AnimatedGifEncoder e = new AnimatedGifEncoder();
e.Start( outputFilePath );
e.SetDelay(500);
//-1:no repeat,0:always repeat
e.SetRepeat(0);
for (int i = 0, count = imageFilePaths.Length; i < count; i++ )
{
e.AddFrame( Image.FromFile( imageFilePaths[i] ) );
}
e.Finish();
/* extract Gif */
string outputPath = "c:\\";
GifDecoder gifDecoder = new GifDecoder();
gifDecoder.Read( "c:\\test.gif" );
for ( int i = 0, count = gifDecoder.GetFrameCount(); i < count; i++ )
{
Image frame = gifDecoder.GetFrame( i ); // frame i
frame.Save( outputPath + Guid.NewGuid().ToString()
           + ".png", ImageFormat.Png );
}

注意，此方法生成时间比较长，必须先收集完图片然后一起生成，不能边收集图片边生成，否则gif速度会飞快，那是因为单帧加入时间太长，收集图片掉帧严重。

比如录制屏幕到gif的过程：

//核心方法：注意收集和生成分离
   private void UseNgif()
   {
     bool bEnd = false;
     Task.Run(()=> {
       DateTime dtend = DateTime.Now.AddSeconds(5);
       while (!bStop && DateTime.Now < dtend)
       {
         var img = CopyScreenToImg(false); //System.Drawing.Image.FromFile("img.png");
         imgcach.Enqueue(img);
         Thread.Sleep(100);
       }
       bEnd = true;
       showMsginline("收集图片完成，图片数为：" + imgcach.Count);
     });
     Task.Run(() => {
       AnimatedGifEncoder ngif = new AnimatedGifEncoder();
       ngif.Start("g:\\Ngif.gif");
       //ngif.SetFrameRate(24);
       ngif.SetDelay(100);
       ngif.SetQuality(15);
       //-1:no repeat,0:always repeat
       ngif.SetRepeat(0);
       while(!bEnd|| imgcach.Count>0)
       {
         showMsginline("当前有图片数"+ imgcach.Count);
         var img2 = GetItemFromQueue(imgcach);
         if (img2 != null)
         {
           ngif.AddFrame(img2);
           Thread.Sleep(2);
         }

}
       ngif.Finish();

showMsg("Ngif生成完成！");
     });
}

其他相关方法：

/// <summary>
   /// 获取屏幕图片
   /// </summary>
   /// <param name="compress">是否压缩</param>
   /// <returns></returns>
   private System.Drawing.Image CopyScreenToImg(bool compress=true)
   {
     System.Drawing.Image img = new Bitmap(w, h);
     Graphics g = Graphics.FromImage(img);
     g.CopyFromScreen(new System.Drawing.Point(x, y), new System.Drawing.Point(0, 0), new System.Drawing.Size(w, h));
     if (compress)
     {
       System.Drawing.Image img2 = Bitmap.FromStream(CompressionImage(img, quality));
       return img2;
     }
     else
       return img;
   }

/// <summary>
   /// 压缩图片的算法
   /// </summary>
   /// <param name="fileStream">图片流</param>
   /// <param name="quality">压缩质量，取值在0-100之间，数值越大质量越高</param>
   /// <returns></returns>
private MemoryStream CompressionImage(System.Drawing.Image img, long quality)
   {
     using (Bitmap bitmap = new Bitmap(img))
     {
       ImageCodecInfo CodecInfo = GetEncoderInfo("image/jpeg");
       System.Drawing.Imaging.Encoder myEncoder = System.Drawing.Imaging.Encoder.Quality;
       EncoderParameters myEncoderParameters = new EncoderParameters(1);
       EncoderParameter myEncoderParameter = new EncoderParameter(myEncoder, quality);
       myEncoderParameters.Param[0] = myEncoderParameter;
       MemoryStream ms = new MemoryStream();
       bitmap.Save(ms, CodecInfo, myEncoderParameters);
       myEncoderParameters.Dispose();
       myEncoderParameter.Dispose();
       return ms;
     }
   }
/// <summary>
   /// 获取图片编码信息
   /// </summary>
   private ImageCodecInfo GetEncoderInfo(String mimeType)
   {
     int j;
     ImageCodecInfo[] encoders;
     encoders = ImageCodecInfo.GetImageEncoders();
     for (j = 0; j < encoders.Length; ++j)
     {
       if (encoders[j].MimeType == mimeType)
         return encoders[j];
     }
     return null;
   }

ConcurrentQueue<System.Drawing.Image> imgcach = new ConcurrentQueue<System.Drawing.Image>();
   //取队列对象
   private T GetItemFromQueue<T>(ConcurrentQueue<T> q)
   {
     T t = default(T);
     if (q.TryDequeue(out t))
     {
       return t;
     }
     else
       return default(T);
   }

如果嫌Ngif单独组件太麻烦，可以直接用下面一个类Gif.cs：

using System;
using System.Collections;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Runtime.InteropServices;

/* Usage to create an animated gif:
* var age = new AnimatedGifEncoder();
* age.Start(outputFile);
* age.SetDelay(ms);
* age.SetRepeat(repeat); // -1: no repeat, 0: always repeat, n: repeat n times
* age.AddFrame(frame_n);
* age.Finish();
*
/* Usage to decode an animated gif:
* var gd = new GifDecoder();
* gd.Read(gifPath);
* for: gd.GetFrameCount(); -> gif.GetFrame(n);
*/

// TODO I'm not sure if this is able to create TRANSPARENT ANIMATED GIFS, if it's not,
// GetPixels(...) should be done the same way SetPixels(...) is done

// Made 19th of month 9 of 2015.

// ============================ LZWEncoder ==============================
// = Adapted from Jef Poskanzer's Java port by way of J. M. G. Elliott. =
// =              K Weiner 12/00              =
// ======================================================================
// GIFCOMPR.C    - GIF Image compression routines
//
// Lempel-Ziv compression based on 'compress'. GIF modifications by
// David Rowley (mgardi@watdcsu.waterloo.edu)
// 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)

// ==================== NeuQuant Neural-Net Quantization Algorithm =======================
// = Copyright (c) 1994 Anthony Dekker                          =
// = NEUQUANT Neural-Net quantization algorithm by Anthony Dekker, 1994.         =
// = See "Kohonen neural networks for optimal colour quantization"            =
// = in "Network: Computation in Neural Systems" Vol. 5 (1994) pp 351-367.        =
// = for a discussion of the algorithm.                         =
// =                                           =
// = Any party obtaining a copy of these files from the author, directly or       =
// = indirectly, is granted, free of charge, a full and unrestricted irrevocable,    =
// = world-wide, paid up, royalty-free, nonexclusive right and license to deal      =
// = in this software and documentation files (the "Software"), including without    =
// = limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, =
// = and/or sell copies of the Software, and to permit persons who receive        =
// = copies from any such party to do so, with the only requirement being        =
// = that this copyright notice remain intact.                      =
// =======================================================================================

public class AnimatedGifEncoder
{
 protected int width; // image size
 protected int height;
 protected Color transparent = Color.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 FileStream fs;

protected Image 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

/// <summary>
 /// Sets the delay time between each frame, or changes it
 /// for subsequent frames (applies to last frame added)
 /// </summary>
 /// <param name="ms">int delay time in milliseconds</param>
 public void SetDelay(int ms) {
   delay = (int)Math.Round(ms / 10.0f);
 }

/// <summary>
 /// 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
 /// </summary>
 /// <param name="code">int disposal code</param>
 public void SetDispose(int code)
 {
   if (code >= 0)
     dispose = code;
 }

/// <summary>
 /// 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
 /// </summary>
 /// <param name="iter">int number of iterations</param>
 public void SetRepeat(int iter)
 {
   if (iter >= 0)
     repeat = iter;
 }

/// <summary>
 /// 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
 /// </summary>
 /// <param name="c">Color to be treated as transparent on display</param>
 public void SetTransparent(Color c) {
   transparent = c;
 }

/// <summary>
 /// 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
 /// </summary>
 /// <param name="im">BufferedImage containing frame to write</param>
 /// <returns>true if successful</returns>
 public bool AddFrame(Image 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)
     {
       Write * (); // 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) // local color table
       WritePalette();
     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
 /// </summary>
 /// <returns>true if successful</returns>
 public bool Finish()
 {
   if (!started) return false;
   bool ok = true;
   started = false;
   try
   {
     fs.WriteByte(0x3b); // gif trailer
     fs.Flush();
     if (closeStream)
       fs.Close();
   }
   catch (IOException) { ok = false; }

// reset for subsequent use
   transIndex = 0;
   fs = null;
   image.Dispose();
   image = null;
   pixels = null;
   indexedPixels = null;
   colorTab = null;
   closeStream = false;
   firstFrame = true;

return ok;
 }

/// <summary>
 /// Sets frame rate in frames per second. Equivalent to
 /// <code>setDelay(1000/fps)</code>
 /// </summary>
 /// <param name="fps">@param fps float frame rate (frames per second)</param>
 public void SetFrameRate(float fps)
 {
   if (fps != 0f)
     delay = (int)Math.Round(100f / fps);
 }

/// <summary>
 /// 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
 /// </summary>
 /// <param name="quality">int greater than 0</param>
 public void SetQuality(int quality)
 {
   if (quality < 1) quality = 1;
   sample = quality;
 }

/// <summary>
 /// Sets the GIF frame size. The default size is the
 /// size of the first frame added if this method is
 /// not invoked
 /// </summary>
 /// <param name="w">int frame width</param>
 /// <param name="h">int frame height</param>
 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;
 }

/// <summary>
 /// Initiates GIF file creation on the given stream. The stream
 /// is not closed automatically.
 /// </summary>
 /// <param name="os">OutputStream on which GIF images are written</param>
 /// <returns>false if initial write failed</returns>
 public bool Start(FileStream os)
 {
   if (os == null) return false;
   bool ok = true;
   closeStream = false;
   fs = os;
   try
   {
     WriteString("GIF89a"); // header
   }
   catch (IOException)
   {
     ok = false;
   }
   return started = ok;
 }

/// <summary>
 /// Initiates writing of a GIF file with the specified name.
 /// </summary>
 /// <param name="file">String containing output file name</param>
 /// <returns>false if open or initial write failed</returns>
 public bool Start(string file)
 {
   bool ok = true;
   try
   {
     //      bw = new BinaryWriter( new FileStream( file, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None ) );
     fs = new FileStream(file, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None);
     ok = Start(fs);
     closeStream = true;
   }
   catch (IOException)
   {
     ok = false;
   }
   return started = ok;
 }

/// <summary>
 /// Analyzes image colors and creates color map.
 /// </summary>
 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 != Color.Empty)
   {
     transIndex = FindClosest(transparent);
   }
 }

/// <summary>
 /// Returns index of palette color closest to c
 /// </summary>
 /// <param name="c">The original colour</param>
 /// <returns>The most similar colour index</returns>
 protected int FindClosest(Color c)
 {
   if (colorTab == null) return -1;
   int r = c.R;
   int g = c.G;
   int b = c.B;
   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;
 }

/// <summary>
 /// Extracts image pixels into byte array "pixels"
 /// </summary>
 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();
   }
   pixels = new Byte[3 * image.Width * image.Height];
   int count = 0;
   using (var bmp = new Bitmap(image)) // Temp Bitmap
   {
     // Lock the image
     BitmapData data = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height),
       ImageLockMode.ReadOnly, bmp.PixelFormat);

// Create a variable to store the locked bytes of the bitmap
     byte[] bytes = new byte[Math.Abs(data.Stride) * bmp.Height];

// Get a pointer to the start of our bitmap in the memory
     IntPtr scan = data.Scan0;

// Copy the bytes from the memory to our byte array
     Marshal.Copy(scan, bytes, 0, bytes.Length);

// Calculate how many bytes there are per pixel and others variables to reduce calculations
     int bytesPerPixel = Image.GetPixelFormatSize(bmp.PixelFormat) / 8;
     int widthInBytes = data.Width * bytesPerPixel; // The total image width in bytes
     int yyMax = bmp.Height; // The maximum Y coordinate given by the area rectangle
     int xxMax = bmp.Width * bytesPerPixel; // The maximum X coordinate given by the area rectangle

// Loop through the bitmap rows
     for (int yy = 0; yy < yyMax; yy++)
     {
       // Loop through the bitmap pixels in the row
       for (int xx = 0; xx < xxMax; xx += bytesPerPixel)
       {
         // CurrentIndex  Get the row  Get the column
         int ci =    yy * data.Stride + xx;

pixels[count++] = bytes[ci + 2]; // Red
         pixels[count++] = bytes[ci + 1]; // Green
         pixels[count++] = bytes[ci  ]; // Blue
       }
     }

// Unlock the bits of the image
     bmp.UnlockBits(data);
   }
 }

/// <summary>
 /// Writes Graphic Control Extension
 /// </summary>
 protected void WriteGraphicCtrlExt()
 {
   fs.WriteByte(0x21); // extension introducer
   fs.WriteByte(0xf9); // GCE label
   fs.WriteByte(4); // data block size
   int transp, disp;
   if (transparent == Color.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
   fs.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
   fs.WriteByte(Convert.ToByte(transIndex)); // transparent color index
   fs.WriteByte(0); // block terminator
 }

/// <summary>
 /// Writes Image Descriptor
 /// </summary>
 protected void WriteImageDesc()
 {
   fs.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
     fs.WriteByte(0);
   }
   else
   {
     // specify normal LCT
     fs.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
   }
 }

/// <summary>
 /// Writes Logical Screen Descriptor
 /// </summary>
 protected void Write * ()
 {
   // logical screen size
   WriteShort(width);
   WriteShort(height);
   // packed fields
   fs.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

fs.WriteByte(0); // background color index
   fs.WriteByte(0); // pixel aspect ratio - assume 1:1
 }

/// <summary>
 /// Writes Netscape application extension to define
 /// repeat count
 /// </summary>
 protected void WriteNetscapeExt()
 {
   fs.WriteByte(0x21); // extension introducer
   fs.WriteByte(0xff); // app extension label
   fs.WriteByte(11); // block size
   WriteString("NETSCAPE" + "2.0"); // app id + auth code
   fs.WriteByte(3); // sub-block size
   fs.WriteByte(1); // loop sub-block id
   WriteShort(repeat); // loop count (extra iterations, 0=repeat forever)
   fs.WriteByte(0); // block terminator
 }

/// <summary>
 /// Writes color table
 /// </summary>
 protected void WritePalette()
 {
   fs.Write(colorTab, 0, colorTab.Length);
   int n = (3 * 256) - colorTab.Length;
   for (int i = 0; i < n; i++)
   {
     fs.WriteByte(0);
   }
 }

/// <summary>
 /// Encodes and writes pixel data
 /// </summary>
 protected void WritePixels()
 {
   LZWEncoder encoder =
     new LZWEncoder(width, height, indexedPixels, colorDepth);
   encoder.Encode(fs);
 }

/// <summary>
 /// Write 16-bit value to output stream, LSB first
 /// </summary>
 /// <param name="value">The short to write</param>
 protected void WriteShort(int value)
 {
   fs.WriteByte(Convert.ToByte(value & 0xff));
   fs.WriteByte(Convert.ToByte((value >> 8) & 0xff));
 }

/// <summary>
 /// Writes string to output stream
 /// </summary>
 /// <param name="s">The string to write</param>
 protected void WriteString(String s)
 {
   char[] chars = s.ToCharArray();
   for (int i = 0; i < chars.Length; i++)
   {
     fs.WriteByte((byte)chars[i]);
   }
 }
}

public class GifDecoder : IDisposable
{

// File read status: No errors.
 public static readonly int STATUS_OK = 0;

// File read status: Error decoding file (may be partially decoded)
 public static readonly int STATUS_FORMAT_ERROR = 1;

// File read status: Unable to open source.
 public static readonly int STATUS_OPEN_ERROR = 2;

protected Stream inStream;
 protected int status;

protected int width; // full image width
 protected int height; // full image height
 protected bool gctFlag; // global color table used
 protected int gctSize; // size of global color table
 protected int loopCount = 1; // iterations; 0 = repeat forever

protected int[] gct; // global color table
 protected int[] lct; // local color table
 protected int[] act; // active color table

protected int bgIndex; // background color index
 protected int bgColor; // background color
 protected int lastBgColor; // previous bg color
 protected int pixelAspect; // pixel aspect ratio

protected bool lctFlag; // local color table flag
 protected bool interlace; // interlace flag
 protected int lctSize; // local color table size

protected int ix, iy, iw, ih; // current image rectangle
 protected Rectangle lastRect; // last image rect
 protected Image image; // current frame
 protected Bitmap bitmap;
 protected Image lastImage; // previous frame

protected byte[] block = new byte[256]; // current data block
 protected int blockSize = 0; // block size

// last graphic control extension info
 protected int dispose = 0;
 // 0=no action; 1=leave in place; 2=restore to bg; 3=restore to prev
 protected int lastDispose = 0;
 protected bool transparency = false; // use transparent color
 protected int delay = 0; // delay in milliseconds
 protected int transIndex; // transparent color index

protected static readonly int MaxStackSize = 4096;
 // max decoder pixel stack size

// LZW decoder working arrays
 protected short[] prefix;
 protected byte[] suffix;
 protected byte[] pixelStack;
 protected byte[] pixels;

protected ArrayList frames; // frames read from current file
 protected int frameCount;

public class GifFrame
 {
   public GifFrame(Image im, int del)
   {
     image = im;
     delay = del;
   }
   public Image image;
   public int delay;
 }

/// <summary>
 /// Gets display duration for specified frame
 /// </summary>
 /// <param name="n">int index of frame</param>
 /// <returns>delay in milliseconds</returns>
 public int GetDelay(int n)
 {
   //
   delay = -1;
   if ((n >= 0) && (n < frameCount))
   {
     delay = ((GifFrame)frames[n]).delay;
   }
   return delay;
 }

/// <summary>
 /// Gets the number of frames read from file
 /// </summary>
 /// <returns>frame count</returns>
 public int GetFrameCount() {
   return frameCount;
 }

/// <summary>
 /// Gets the first (or only) image read
 /// </summary>
 /// <returns>BufferedImage containing first frame, or null if none</returns>
 public Image GetImage() {
   return GetFrame(0);
 }

/// <summary>
 /// Gets the "Netscape" iteration count, if any.
 /// A count of 0 means repeat indefinitiely.
 /// </summary>
 /// <returns>Iteration count if one was specified, else 1</returns>
 public int GetLoopCount() {
   return loopCount;
 }

/// <summary>
 /// Creates new frame image from current data (and previous
 /// frames as specified by their disposition codes)
 /// </summary>
 /// <param name="bitmap">Current bitmap data</param>
 /// <returns>Pixels array</returns>
 int[] GetPixels(Bitmap bitmap)
 {
   int[] pixels = new int[3 * image.Width * image.Height];
   int count = 0;

// Lock the image
   BitmapData data = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height),
     ImageLockMode.ReadOnly, bitmap.PixelFormat);

// Create a variable to store the locked bytes of the bitmap
   byte[] bytes = new byte[Math.Abs(data.Stride) * bitmap.Height];

// Get a pointer to the start of our bitmap in the memory
   IntPtr scan = data.Scan0;

// Copy the bytes from the memory to our byte array
   Marshal.Copy(scan, bytes, 0, bytes.Length);

// Calculate how many bytes there are per pixel and others variables to reduce calculations
   int bytesPerPixel = Image.GetPixelFormatSize(bitmap.PixelFormat) / 8;
   int widthInBytes = data.Width * bytesPerPixel; // The total image width in bytes
   int yyMax = bitmap.Height; // The maximum Y coordinate given by the area rectangle
   int xxMax = bitmap.Width * bytesPerPixel; // The maximum X coordinate given by the area rectangle

// Loop through the bitmap rows
   for (int yy = 0; yy < yyMax; yy++)
   {
     // Loop through the bitmap pixels in the row
     for (int xx = 0; xx < xxMax; xx += bytesPerPixel)
     {
       // CurrentIndex  Get the row  Get the column
       int ci = yy * data.Stride + xx;

pixels[count++] = bytes[ci + 2]; // Red
       pixels[count++] = bytes[ci + 1]; // Green
       pixels[count++] = bytes[ci]; // Blue
     }
   }

// Unlock the bits of the image
   bitmap.UnlockBits(data);

return pixels;
 }

void SetPixels(int[] pixels)
 {
   int count = 0;

// Lock the image
   BitmapData data = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height),
     ImageLockMode.ReadOnly, bitmap.PixelFormat);

// Create a variable to store the locked bytes of the bitmap
   byte[] bytes = new byte[Math.Abs(data.Stride) * bitmap.Height];

// Get a pointer to the start of our bitmap in the memory
   IntPtr scan = data.Scan0;

// Copy the bytes from the memory to our byte array
   Marshal.Copy(scan, bytes, 0, bytes.Length);

// Calculate how many bytes there are per pixel and others variables to reduce calculations
   int bytesPerPixel = Image.GetPixelFormatSize(bitmap.PixelFormat) / 8;
   int widthInBytes = data.Width * bytesPerPixel; // The total image width in bytes
   int yyMax = bitmap.Height; // The maximum Y coordinate given by the area rectangle
   int xxMax = bitmap.Width * bytesPerPixel; // The maximum X coordinate given by the area rectangle

// Loop through the bitmap rows
   for (int yy = 0; yy < yyMax; yy++)
   {
     // Loop through the bitmap pixels in the row
     for (int xx = 0; xx < xxMax; xx += bytesPerPixel)
     {
       Color color = Color.FromArgb(pixels[count++]);

// CurrentIndex  Get the row  Get the column
       int ci =    yy * data.Stride + xx;
       bytes[ci + 3] = color.A; // Alpha?
       bytes[ci + 2] = color.R; // Red
       bytes[ci + 1] = color.G; // Green
       bytes[ci  ] = color.B; // Blue
     }
   }

// Copy back from our destination bytes array to the dst bitmap in the memory
   Marshal.Copy(bytes, 0, scan, bytes.Length);

// Unlock the bits of the image
   bitmap.UnlockBits(data);
 }

protected void SetPixels()
 {
   // expose destination image's pixels as int array
   int[] dest = GetPixels(bitmap);

// fill in starting image contents based on last image's dispose code
   if (lastDispose > 0)
   {
     if (lastDispose == 3)
     {
       // use image before last
       int n = frameCount - 2;
       if (n > 0)
         lastImage = GetFrame(n - 1);
       else
         lastImage = null;
     }

if (lastImage != null)
     {
       //        int[] prev =
       //          ((DataBufferInt) lastImage.getRaster().getDataBuffer()).getData();
       int[] prev = GetPixels(new Bitmap(lastImage));
       Array.Copy(prev, 0, dest, 0, width * height);
       // copy pixels

if (lastDispose == 2)
       {
         // fill last image rect area with background color
         Graphics g = Graphics.FromImage(image);
         Color c = Color.Empty;
         if (transparency)
           c = Color.FromArgb(0, 0, 0, 0); // assume background is transparent
         else
           c = Color.FromArgb(lastBgColor); // use given background color

Brush brush = new SolidBrush(c);
         g.FillRectangle(brush, lastRect);
         brush.Dispose();
         g.Dispose();
       }
     }
   }

// copy each source line to the appropriate place in the destination
   int pass = 1;
   int inc = 8;
   int iline = 0;
   for (int i = 0; i < ih; i++)
   {
     int line = i;
     if (interlace)
     {
       if (iline >= ih)
       {
         pass++;
         switch (pass)
         {
           case 2:
             iline = 4;
             break;
           case 3:
             iline = 2;
             inc = 4;
             break;
           case 4:
             iline = 1;
             inc = 2;
             break;
         }
       }
       line = iline;
       iline += inc;
     }
     line += iy;
     if (line < height)
     {
       int k = line * width;
       int dx = k + ix; // start of line in dest
       int dlim = dx + iw; // end of dest line
       if ((k + width) < dlim)
       {
         dlim = k + width; // past dest edge
       }
       int sx = i * iw; // start of line in source
       while (dx < dlim)
       {
         // map color and insert in destination
         int index = ((int)pixels[sx++]) & 0xff;
         int c = act[index];
         if (c != 0)
         {
           dest[dx] = c;
         }
         dx++;
       }
     }
   }
   SetPixels(dest);
 }

/// <summary>
 /// Gets the image contents of frame n
 /// </summary>
 /// <param name="n">The n'th frame</param>
 /// <returns>BufferedImage representation of frame, or null if n is invalid</returns>
 public Image GetFrame(int n)
 {
   Image im = null;
   if ((n >= 0) && (n < frameCount))
     im = ((GifFrame)frames[n]).image;

return im;
 }

/// <summary>
 /// Gets image size
 /// </summary>
 /// <returns>GIF image dimensions</returns>
 public Size GetFrameSize() {
   return new Size(width, height);
 }

/// <summary>
 /// Reads GIF image from stream
 /// </summary>
 /// <param name="inStream">BufferedInputStream containing GIF file</param>
 /// <returns>read status code (0 = no errors)</returns>
 public int Read(Stream inStream)
 {
   Init();
   if (inStream != null)
   {
     this.inStream = inStream;
     ReadHeader();
     if (!Error())
     {
       ReadContents();
       if (frameCount < 0)
         status = STATUS_FORMAT_ERROR;
     }
     inStream.Close();
   }
   else
     status = STATUS_OPEN_ERROR;

return status;
 }

/// <summary>
 /// Reads GIF file from specified file/URL source
 /// (URL assumed if name contains ":/" or "file:")
 /// </summary>
 /// <param name="name">String containing source</param>
 /// <returns>read status code (0 = no errors)</returns>
 public int Read(String name)
 {
   status = STATUS_OK;
   try
   {
     name = name.Trim().ToLower();
     status = Read(new FileInfo(name).OpenRead());
   }
   catch (IOException)
   {
     status = STATUS_OPEN_ERROR;
   }

return status;
 }

/// <summary>
 /// Decodes LZW image data into pixel array.
 /// Adapted from John Cristy's ImageMagick
 /// </summary>
 protected void DecodeImageData()
 {
   int NullCode = -1;
   int npix = iw * ih;
   int available,
     clear,
     code_mask,
     code_size,
     end_of_information,
     in_code,
     old_code,
     bits,
     code,
     count,
     i,
     datum,
     data_size,
     first,
     top,
     bi,
     pi;

if ((pixels == null) || (pixels.Length < npix))
   {
     pixels = new byte[npix]; // allocate new pixel array
   }
   if (prefix == null) prefix = new short[MaxStackSize];
   if (suffix == null) suffix = new byte[MaxStackSize];
   if (pixelStack == null) pixelStack = new byte[MaxStackSize + 1];

// Initialize GIF data stream decoder.

data_size = Read();
   clear = 1 << data_size;
   end_of_information = clear + 1;
   available = clear + 2;
   old_code = NullCode;
   code_size = data_size + 1;
   code_mask = (1 << code_size) - 1;
   for (code = 0; code < clear; code++)
   {
     prefix[code] = 0;
     suffix[code] = (byte)code;
   }

// Decode GIF pixel stream.

datum = bits = count = first = top = pi = bi = 0;

for (i = 0; i < npix;)
   {
     if (top == 0)
     {
       if (bits < code_size)
       {
         // Load bytes until there are enough bits for a code.
         if (count == 0)
         {
           // Read a new data block.
           count = ReadBlock();
           if (count <= 0)
             break;
           bi = 0;
         }
         datum += (((int)block[bi]) & 0xff) << bits;
         bits += 8;
         bi++;
         count--;
         continue;
       }

// Get the next code.

code = datum & code_mask;
       datum >>= code_size;
       bits -= code_size;

// Interpret the code

if ((code > available) || (code == end_of_information))
         break;
       if (code == clear)
       {
         // Reset decoder.
         code_size = data_size + 1;
         code_mask = (1 << code_size) - 1;
         available = clear + 2;
         old_code = NullCode;
         continue;
       }
       if (old_code == NullCode)
       {
         pixelStack[top++] = suffix[code];
         old_code = code;
         first = code;
         continue;
       }
       in_code = code;
       if (code == available)
       {
         pixelStack[top++] = (byte)first;
         code = old_code;
       }
       while (code > clear)
       {
         pixelStack[top++] = suffix[code];
         code = prefix[code];
       }
       first = ((int)suffix[code]) & 0xff;

// Add a new string to the string table,

if (available >= MaxStackSize)
         break;
       pixelStack[top++] = (byte)first;
       prefix[available] = (short)old_code;
       suffix[available] = (byte)first;
       available++;
       if (((available & code_mask) == 0)
         && (available < MaxStackSize))
       {
         code_size++;
         code_mask += available;
       }
       old_code = in_code;
     }

// Pop a pixel off the pixel stack.

top--;
     pixels[pi++] = pixelStack[top];
     i++;
   }

for (i = pi; i < npix; i++)
   {
     pixels[i] = 0; // clear missing pixels
   }

}

/// <summary>
 /// Returns true if an error was encountered during reading/decoding
 /// </summary>
 /// <returns>true if an error occured</returns>
 protected bool Error()
 {
   return status != STATUS_OK;
 }

/// <summary>
 /// Initializes or re-initializes reader
 /// </summary>
 protected void Init()
 {
   status = STATUS_OK;
   frameCount = 0;
   frames = new ArrayList();
   gct = null;
   lct = null;
 }

/// <summary>
 /// Reads a single byte from the input stream.
 /// </summary>
 /// <returns>The byte read</returns>
 protected int Read()
 {
   int curByte = 0;
   try
   {
     curByte = inStream.ReadByte();
   }
   catch (IOException)
   {
     status = STATUS_FORMAT_ERROR;
   }
   return curByte;
 }

/// <summary>
 /// Reads next variable length block from input.
 /// </summary>
 /// <returns>number of bytes stored in "buffer"</returns>
 protected int ReadBlock()
 {
   blockSize = Read();
   int n = 0;
   if (blockSize > 0)
   {
     try
     {
       int count = 0;
       while (n < blockSize)
       {
         count = inStream.Read(block, n, blockSize - n);
         if (count == -1)
           break;
         n += count;
       }
     }
     catch (IOException)
     {
     }

if (n < blockSize)
     {
       status = STATUS_FORMAT_ERROR;
     }
   }
   return n;
 }

/// <summary>
 /// Reads color table as 256 RGB integer values
 /// </summary>
 /// <param name="ncolors">int number of colors to read</param>
 /// <returns>int array containing 256 colors (packed ARGB with full alpha)</returns>
 protected int[] ReadColorTable(int ncolors)
 {
   int nbytes = 3 * ncolors;
   int[] tab = null;
   byte[] c = new byte[nbytes];
   int n = 0;
   try
   {
     n = inStream.Read(c, 0, c.Length);
   }
   catch (IOException)
   {
   }
   if (n < nbytes)
   {
     status = STATUS_FORMAT_ERROR;
   }
   else
   {
     tab = new int[256]; // max size to avoid bounds checks
     int i = 0;
     int j = 0;
     while (i < ncolors)
     {
       int r = ((int)c[j++]) & 0xff;
       int g = ((int)c[j++]) & 0xff;
       int b = ((int)c[j++]) & 0xff;
       tab[i++] = (int)(0xff000000 | (r << 16) | (g << 8) | b);
     }
   }
   return tab;
 }

/// <summary>
 /// Main file parser. Reads GIF content blocks
 /// </summary>
 protected void ReadContents()
 {
   // read GIF file content blocks
   bool done = false;
   while (!(done || Error()))
   {
     int code = Read();
     switch (code)
     {

case 0x2C: // image separator
         ReadImage();
         break;

case 0x21: // extension
         code = Read();
         switch (code)
         {
           case 0xf9: // graphics control extension
             ReadGraphicControlExt();
             break;

case 0xff: // application extension
             ReadBlock();
             String app = "";
             for (int i = 0; i < 11; i++)
               app += (char)block[i];

if (app.Equals("NETSCAPE2.0"))
               ReadNetscapeExt();
             else
               Skip(); // don't care
             break;

default: // uninteresting extension
             Skip();
             break;
         }
         break;

case 0x3b: // terminator
         done = true;
         break;

case 0x00: // bad byte, but keep going and see what happens
         break;

default:
         status = STATUS_FORMAT_ERROR;
         break;
     }
   }
 }

/// <summary>
 /// Reads Graphics Control Extension values
 /// </summary>
 protected void ReadGraphicControlExt()
 {
   Read(); // block size
   int packed = Read(); // packed fields
   dispose = (packed & 0x1c) >> 2; // disposal method
   if (dispose == 0)
     dispose = 1; // elect to keep old image if discretionary

transparency = (packed & 1) != 0;
   delay = ReadShort() * 10; // delay in milliseconds
   transIndex = Read(); // transparent color index
   Read(); // block terminator
 }

/// <summary>
 /// Reads GIF file header information
 /// </summary>
 protected void ReadHeader()
 {
   String id = "";
   for (int i = 0; i < 6; i++)
     id += (char)Read();

if (!id.StartsWith("GIF"))
   {
     status = STATUS_FORMAT_ERROR;
     return;
   }

Read * ();
   if (gctFlag && !Error())
   {
     gct = ReadColorTable(gctSize);
     bgColor = gct[bgIndex];
   }
 }

/// <summary>
 /// Reads next frame image
 /// </summary>
 protected void ReadImage()
 {
   ix = ReadShort(); // (sub)image position & size
   iy = ReadShort();
   iw = ReadShort();
   ih = ReadShort();

int packed = Read();
   lctFlag = (packed & 0x80) != 0; // 1 - local color table flag
   interlace = (packed & 0x40) != 0; // 2 - interlace flag
                     // 3 - sort flag
                     // 4-5 - reserved
   lctSize = 2 << (packed & 7); // 6-8 - local color table size

if (lctFlag)
   {
     lct = ReadColorTable(lctSize); // read table
     act = lct; // make local table active
   }
   else
   {
     act = gct; // make global table active
     if (bgIndex == transIndex)
       bgColor = 0;
   }
   int save = 0;
   if (transparency)
   {
     save = act[transIndex];
     act[transIndex] = 0; // set transparent color if specified
   }

if (act == null)
     status = STATUS_FORMAT_ERROR; // no color table defined

if (Error()) return;

DecodeImageData(); // decode pixel data
   Skip();

if (Error()) return;

frameCount++;

// create new image to receive frame data
   //    image =
   //      new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB_PRE);

bitmap = new Bitmap(width, height);
   image = bitmap;
   SetPixels(); // transfer pixel data to image

frames.Add(new GifFrame(bitmap, delay)); // add image to frame list

if (transparency)
     act[transIndex] = save;

ResetFrame();

}

/// <summary>
 /// Reads Logical Screen Descriptor
 /// </summary>
 protected void Read * ()
 {

// logical screen size
   width = ReadShort();
   height = ReadShort();

// packed fields
   int packed = Read();
   gctFlag = (packed & 0x80) != 0; // 1  : global color table flag
                   // 2-4 : color resolution
                   // 5  : gct sort flag
   gctSize = 2 << (packed & 7); // 6-8 : gct size

bgIndex = Read(); // background color index
   pixelAspect = Read(); // pixel aspect ratio
 }

/// <summary>
 /// Reads Netscape extenstion to obtain iteration count
 /// </summary>
 protected void ReadNetscapeExt()
 {
   do
   {
     ReadBlock();
     if (block[0] == 1)
     {
       // loop count sub-block
       int b1 = ((int)block[1]) & 0xff;
       int b2 = ((int)block[2]) & 0xff;
       loopCount = (b2 << 8) | b1;
     }
   } while ((blockSize > 0) && !Error());
 }

/// <summary>
 /// Reads next 16-bit value, LSB first
 /// </summary>
 /// <returns>short read</returns>
 protected int ReadShort()
 {
   // read 16-bit value, LSB first
   return Read() | (Read() << 8);
 }

/// <summary>
 /// Resets frame state for reading next image
 /// </summary>
 protected void ResetFrame()
 {
   lastDispose = dispose;
   lastRect = new Rectangle(ix, iy, iw, ih);
   lastImage = image;
   lastBgColor = bgColor;
   transparency = false;
   delay = 0;
   lct = null;
 }

/// <summary>
   /// Skips variable length blocks up to and including
   /// next zero length block
   /// </summary>
 protected void Skip()
 {
   do
   {
     ReadBlock();
   } while ((blockSize > 0) && !Error());
 }

public void Dispose()
 {
   image.Dispose();
   bitmap.Dispose();
   lastImage.Dispose();
 }
}

public class LZWEncoder
{
 static readonly int EOF = -1;

int imgW, imgH;
 byte[] pixAry;
 int initCodeSize;
 int remaining;
 int curPixel;
 // General DEFINEs
 static readonly int BITS = 12;

static readonly int HSIZE = 5003; // 80％ occupancy

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;
   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
 //----------------------------------------------------------------------------
 int NextPixel()
 {
   if (remaining == 0)
     return EOF;

--remaining;

int temp = curPixel + 1;
   if ( temp < pixAry.GetUpperBound( 0 ))
   {
     byte pix = pixAry[curPixel++];

return pix & 0xff;
   }
   return 0xff;
 }

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);
   }
 }
}

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 { } // 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 { }
     }
   }
 }

// 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);
 }
}

方法四：使用GifEncoder.cs

gifencode.cs

using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;

namespace BumpKit
{
 /// <summary>
 /// Encodes multiple images as an animated gif to a stream. <br />
 /// ALWAYS ALWAYS ALWAYS wire this up  in a using block <br />
 /// Disposing the encoder will complete the file. <br />
 /// Uses default .net GIF encoding and adds animation headers.
 /// </summary>
 public class GifEncoder : IDisposable
 {
   #region Header Constants
   private const string FileType = "GIF";
   private const string FileVersion = "89a";
   private const byte FileTrailer = 0x3b;

private const int ApplicationExtensionBlockIdentifier = 0xff21;
   private const byte ApplicationBlockSize = 0x0b;
   private const string ApplicationIdentification = "NETSCAPE2.0";

private const int GraphicControlExtensionBlockIdentifier = 0xf921;
   private const byte GraphicControlExtensionBlockSize = 0x04;

private const long SourceGlobalColorInfoPosition = 10;
   private const long SourceGraphicControlExtensionPosition = 781;
   private const long SourceGraphicControlExtensionLength = 8;
   private const long SourceImageBlockPosition = 789;
   private const long SourceImageBlockHeaderLength = 11;
   private const long SourceColorBlockPosition = 13;
   private const long SourceColorBlockLength = 768;
   #endregion

private bool _isFirstImage = true;
   private int? _width;
   private int? _height;
   private int? _repeatCount;
   private readonly Stream _stream;

// Public Accessors
   public TimeSpan FrameDelay { get; set; }

/// <summary>
   /// Encodes multiple images as an animated gif to a stream. <br />
   /// ALWAYS ALWAYS ALWAYS wire this in a using block <br />
   /// Disposing the encoder will complete the file. <br />
   /// Uses default .net GIF encoding and adds animation headers.
   /// </summary>
   /// <param name="stream">The stream that will be written to.</param>
   /// <param name="width">Sets the width for this gif or null to use the first frame's width.</param>
   /// <param name="height">Sets the height for this gif or null to use the first frame's height.</param>
   public GifEncoder(Stream stream, int? width = null, int? height = null, int? repeatCount = null)
   {
     _stream = stream;
     _width = width;
     _height = height;
     _repeatCount = repeatCount;
   }

/// <summary>
   /// Adds a frame to this animation.
   /// </summary>
   /// <param name="img">The image to add</param>
   /// <param name="x">The positioning x offset this image should be displayed at.</param>
   /// <param name="y">The positioning y offset this image should be displayed at.</param>
   public void AddFrame(Image img, int x = 0, int y = 0, TimeSpan? frameDelay = null)
   {
     using (var gifStream = new MemoryStream())
     {
       img.Save(gifStream, ImageFormat.Gif);
       if (_isFirstImage) // Steal the global color table info
       {
         InitHeader(gifStream, img.Width, img.Height);
       }
       WriteGraphicControlBlock(gifStream, frameDelay.GetValueOrDefault(FrameDelay));
       WriteImageBlock(gifStream, !_isFirstImage, x, y, img.Width, img.Height);
     }
     _isFirstImage = false;
   }

private void InitHeader(Stream sourceGif, int w, int h)
   {
     // File Header
     WriteString(FileType);
     WriteString(FileVersion);
     WriteShort(_width.GetValueOrDefault(w)); // Initial Logical Width
     WriteShort(_height.GetValueOrDefault(h)); // Initial Logical Height
     sourceGif.Position = SourceGlobalColorInfoPosition;
     WriteByte(sourceGif.ReadByte()); // Global Color Table Info
     WriteByte(0); // Background Color Index
     WriteByte(0); // Pixel aspect ratio
     WriteColorTable(sourceGif);

// App Extension Header
     WriteShort(ApplicationExtensionBlockIdentifier);
     WriteByte(ApplicationBlockSize);
     WriteString(ApplicationIdentification);
     WriteByte(3); // Application block length
     WriteByte(1);
     WriteShort(_repeatCount.GetValueOrDefault(0)); // Repeat count for images.
     WriteByte(0); // terminator
   }

private void WriteColorTable(Stream sourceGif)
   {
     sourceGif.Position = SourceColorBlockPosition; // Locating the image color table
     var colorTable = new byte[SourceColorBlockLength];
     sourceGif.Read(colorTable, 0, colorTable.Length);
     _stream.Write(colorTable, 0, colorTable.Length);
   }

private void WriteGraphicControlBlock(Stream sourceGif, TimeSpan frameDelay)
   {
     sourceGif.Position = SourceGraphicControlExtensionPosition; // Locating the source GCE
     var blockhead = new byte[SourceGraphicControlExtensionLength];
     sourceGif.Read(blockhead, 0, blockhead.Length); // Reading source GCE

WriteShort(GraphicControlExtensionBlockIdentifier); // Identifier
     WriteByte(GraphicControlExtensionBlockSize); // Block Size
     WriteByte(blockhead[3] & 0xf7 | 0x08); // Setting disposal flag
     WriteShort(Convert.ToInt32(frameDelay.TotalMilliseconds / 10)); // Setting frame delay
     WriteByte(blockhead[6]); // Transparent color index
     WriteByte(0); // Terminator
   }

private void WriteImageBlock(Stream sourceGif, bool includeColorTable, int x, int y, int h, int w)
   {
     sourceGif.Position = SourceImageBlockPosition; // Locating the image block
     var header = new byte[SourceImageBlockHeaderLength];
     sourceGif.Read(header, 0, header.Length);
     WriteByte(header[0]); // Separator
     WriteShort(x); // Position X
     WriteShort(y); // Position Y
     WriteShort(h); // Height
     WriteShort(w); // Width

if (includeColorTable) // If first frame, use global color table - else use local
     {
       sourceGif.Position = SourceGlobalColorInfoPosition;
       WriteByte(sourceGif.ReadByte() & 0x3f | 0x80); // Enabling local color table
       WriteColorTable(sourceGif);
     }
     else
     {
       WriteByte(header[9] & 0x07 | 0x07); // Disabling local color table
     }

WriteByte(header[10]); // LZW Min Code Size

// Read/Write image data
     sourceGif.Position = SourceImageBlockPosition + SourceImageBlockHeaderLength;

var dataLength = sourceGif.ReadByte();
     while (dataLength > 0)
     {
       var imgData = new byte[dataLength];
       sourceGif.Read(imgData, 0, dataLength);

_stream.WriteByte(Convert.ToByte(dataLength));
       _stream.Write(imgData, 0, dataLength);
       dataLength = sourceGif.ReadByte();
     }

_stream.WriteByte(0); // Terminator

}

private void WriteByte(int value)
   {
     _stream.WriteByte(Convert.ToByte(value));
   }

private void WriteShort(int value)
   {
     _stream.WriteByte(Convert.ToByte(value & 0xff));
     _stream.WriteByte(Convert.ToByte((value >> 8) & 0xff));
   }

private void WriteString(string value)
   {
     _stream.Write(value.ToArray().Select(c => (byte)c).ToArray(), 0, value.Length);
   }

public void Dispose()
   {
     // Complete File
     WriteByte(FileTrailer);

// Pushing data
     _stream.Flush();
   }
 }
}

使用方法：

using (FileStream fs = new FileStream("g:\\gifencoder.gif", FileMode.Create))
using (var encoder = new GifEncoder(fs))
{
   while (!bStop)
   {
    var img = CopyScreen(); //System.Drawing.Image.FromFile("img.png");
     encoder.AddFrame(img);
           Thread.Sleep(200);
   }
}

来源：https://www.cnblogs.com/tuyile006/p/13883475.html