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

    ReadLSD();
    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 ReadLSD()
  {

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

以上就是c# 制作gif的四种方法的详细内容，更多关于c# 制作gif的资料请关注我们其它相关文章！