位置：首页>> 软件编程>> C#编程>> c# 制作gif的四种方法

c# 制作gif的四种方法

作者：小y　　发布时间：2023-03-17 20:01:08　

标签：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. 
/// ALWAYS ALWAYS ALWAYS wire this up in a using block 
/// Disposing the encoder will complete the file. 
/// 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. 
/// ALWAYS ALWAYS ALWAYS wire this in a using block 
/// Disposing the encoder will complete the file. 
/// 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

投稿

c# 制作gif的四种方法

猜你喜欢