方法一：使用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 ", 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 ! ",((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); } }