C# 制作GIF的方法4种方法

方法一:使用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);
        }
View Code

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

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

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

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

// Made 19th of month 9 of 2015.

// ============================ LZWEncoder ==============================
// = Adapted from Jef Poskanzer's Java port by way of J. M. G. Elliott. =
// =                           K Weiner 12/00                           =
// ======================================================================
// GIFCOMPR.C       - GIF Image compression routines
//
// Lempel-Ziv compression based on 'compress'. GIF modifications by
// David Rowley (mgardi@watdcsu.waterloo.edu)
// GIF Image compression - modified 'compress'
//
// Based on: compress.c - File compression ala IEEE Computer, June 1984.
//
// By Authors:  Spencer W. Thomas      (decvax!harpo!utah-cs!utah-gr!thomas)
//              Jim McKie              (decvax!mcvax!jim)
//              Steve Davies           (decvax!vax135!petsd!peora!srd)
//              Ken Turkowski          (decvax!decwrl!turtlevax!ken)
//              James A. Woods         (decvax!ihnp4!ames!jaw)
//              Joe Orost              (decvax!vax135!petsd!joe)

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

public class AnimatedGifEncoder
{
    protected int width; // image size
    protected int height;
    protected Color transparent = Color.Empty; // transparent color if given
    protected int transIndex; // transparent index in color table
    protected int repeat = -1; // no repeat
    protected int delay = 0; // frame delay (hundredths)
    protected bool started = false; // ready to output frames
                                    //    protected BinaryWriter bw;
    protected FileStream fs;

    protected Image image; // current frame
    protected byte[] pixels; // BGR byte array from frame
    protected byte[] indexedPixels; // converted frame indexed to palette
    protected int colorDepth; // number of bit planes
    protected byte[] colorTab; // RGB palette
    protected bool[] usedEntry = new bool[256]; // active palette entries
    protected int palSize = 7; // color table size (bits-1)
    protected int dispose = -1; // disposal code (-1 = use default)
    protected bool closeStream = false; // close stream when finished
    protected bool firstFrame = true;
    protected bool sizeSet = false; // if false, get size from first frame
    protected int sample = 10; // default sample interval for quantizer

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

    /// <summary>
    /// Sets the GIF frame disposal code for the last added frame
    /// and any subsequent frames. Default is 0 if no transparent
    /// color has been set, otherwise 2
    /// </summary>
    /// <param name="code">int disposal code</param>
    public void SetDispose(int code)
    {
        if (code >= 0)
            dispose = code;
    }
    
    /// <summary>
    /// Sets the number of times the set of GIF frames
    /// should be played. Default is 1; 0 means play
    /// indefinitely. Must be invoked before the first
    /// image is added
    /// </summary>
    /// <param name="iter">int number of iterations</param>
    public void SetRepeat(int iter)
    {
        if (iter >= 0)
            repeat = iter;
    }
    
    /// <summary>
    /// Sets the transparent color for the last added frame
    /// and any subsequent frames.
    /// Since all colors are subject to modification
    /// in the quantization process, the color in the final
    /// palette for each frame closest to the given color
    /// becomes the transparent color for that frame.
    /// May be set to null to indicate no transparent color
    /// </summary>
    /// <param name="c">Color to be treated as transparent on display</param>
    public void SetTransparent(Color c) {
        transparent = c;
    }

    /// <summary>
    /// Adds next GIF frame. The frame is not written immediately, but is
    /// actually deferred until the next frame is received so that timing
    /// data can be inserted. Invoking <code>finish()</code> flushes all
    /// frames. If <code>setSize</code> was not invoked, the size of the
    /// first image is used for all subsequent frames
    /// </summary>
    /// <param name="im">BufferedImage containing frame to write</param>
    /// <returns>true if successful</returns>
    public bool AddFrame(Image im)
    {
        if ((im == null) || !started)
            return false;

        bool ok = true;
        try
        {
            if (!sizeSet) // use first frame's size
                SetSize(im.Width, im.Height);
            image = im;
            GetImagePixels(); // convert to correct format if necessary
            AnalyzePixels(); // build color table & map pixels
            if (firstFrame)
            {
                WriteLSD(); // logical screen descriptior
                WritePalette(); // global color table
                if (repeat >= 0) // use NS app extension to indicate reps
                    WriteNetscapeExt();
            }
            WriteGraphicCtrlExt(); // write graphic control extension
            WriteImageDesc(); // image descriptor
            if (!firstFrame) // local color table
                WritePalette();
            WritePixels(); // encode and write pixel data
            firstFrame = false;
        }
        catch (IOException) { ok = false; }

        return ok;
    }

    
    /// Flushes any pending data and closes output file.
    /// If writing to an OutputStream, the stream is not closed
    /// </summary>
    /// <returns>true if successful</returns>
    public bool Finish()
    {
        if (!started) return false;
        bool ok = true;
        started = false;
        try
        {
            fs.WriteByte(0x3b); // gif trailer
            fs.Flush();
            if (closeStream)
                fs.Close();
        }
        catch (IOException) { ok = false; }

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

        return ok;
    }

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

    /// <summary>
    /// Sets quality of color quantization (conversion of images
    /// to the maximum 256 colors allowed by the GIF specification).
    /// Lower values (minimum = 1) produce better colors, but slow
    /// processing significantly. 10 is the default, and produces
    /// good color mapping at reasonable speeds. Values greater
    /// than 20 do not yield significant improvements in speed
    /// </summary>
    /// <param name="quality">int greater than 0</param>
    public void SetQuality(int quality)
    {
        if (quality < 1) quality = 1;
        sample = quality;
    }

    /// <summary>
    /// Sets the GIF frame size. The default size is the
    /// size of the first frame added if this method is
    /// not invoked
    /// </summary>
    /// <param name="w">int frame width</param>
    /// <param name="h">int frame height</param>
    public void SetSize(int w, int h)
    {
        if (started && !firstFrame) return;
        width = w;
        height = h;
        if (width < 1) width = 320;
        if (height < 1) height = 240;
        sizeSet = true;
    }

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

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

    /// <summary>
    /// Analyzes image colors and creates color map.
    /// </summary>
    protected void AnalyzePixels()
    {
        int len = pixels.Length;
        int nPix = len / 3;
        indexedPixels = new byte[nPix];
        NeuQuant nq = new NeuQuant(pixels, len, sample);
        // initialize quantizer
        colorTab = nq.Process(); // create reduced palette
                                    // convert map from BGR to RGB
                                    //            for (int i = 0; i < colorTab.Length; i += 3) 
                                    //            {
                                    //                byte temp = colorTab[i];
                                    //                colorTab[i] = colorTab[i + 2];
                                    //                colorTab[i + 2] = temp;
                                    //                usedEntry[i / 3] = false;
                                    //            }
                                    // map image pixels to new palette
        int k = 0;
        for (int i = 0; i < nPix; i++)
        {
            int index =
                nq.Map(pixels[k++] & 0xff,
                pixels[k++] & 0xff,
                pixels[k++] & 0xff);
            usedEntry[index] = true;
            indexedPixels[i] = (byte)index;
        }
        pixels = null;
        colorDepth = 8;
        palSize = 7;
        // get closest match to transparent color if specified
        if (transparent != Color.Empty)
        {
            transIndex = FindClosest(transparent);
        }
    }
    
    /// <summary>
    /// Returns index of palette color closest to c
    /// </summary>
    /// <param name="c">The original colour</param>
    /// <returns>The most similar colour index</returns>
    protected int FindClosest(Color c)
    {
        if (colorTab == null) return -1;
        int r = c.R;
        int g = c.G;
        int b = c.B;
        int minpos = 0;
        int dmin = 256 * 256 * 256;
        int len = colorTab.Length;
        for (int i = 0; i < len;)
        {
            int dr = r - (colorTab[i++] & 0xff);
            int dg = g - (colorTab[i++] & 0xff);
            int db = b - (colorTab[i] & 0xff);
            int d = dr * dr + dg * dg + db * db;
            int index = i / 3;
            if (usedEntry[index] && (d < dmin))
            {
                dmin = d;
                minpos = index;
            }
            i++;
        }
        return minpos;
    }

    /// <summary>
    /// Extracts image pixels into byte array "pixels"
    /// </summary>
    protected void GetImagePixels()
    {
        int w = image.Width;
        int h = image.Height;
        //        int type = image.GetType().;
        if ((w != width)
            || (h != height)
            )
        {
            // create new image with right size/format
            Image temp =
                new Bitmap(width, height);
            Graphics g = Graphics.FromImage(temp);
            g.DrawImage(image, 0, 0);
            image = temp;
            g.Dispose();
        }
        pixels = new Byte[3 * image.Width * image.Height];
        int count = 0;
        using (var bmp = new Bitmap(image)) // Temp Bitmap
        {
            // Lock the image
            BitmapData data = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height),
                ImageLockMode.ReadOnly, bmp.PixelFormat);

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

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

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

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

            // Loop through the bitmap rows
            for (int yy = 0; yy < yyMax; yy++)
            {
                // Loop through the bitmap pixels in the row
                for (int xx = 0; xx < xxMax; xx += bytesPerPixel)
                {
                    // CurrentIndex    Get the row    Get the column
                    int ci =        yy * data.Stride + xx;
                    
                    pixels[count++] = bytes[ci + 2]; // Red
                    pixels[count++] = bytes[ci + 1]; // Green
                    pixels[count++] = bytes[ci    ]; // Blue
                }
            }

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

    /// <summary>
    /// Writes Graphic Control Extension
    /// </summary>
    protected void WriteGraphicCtrlExt()
    {
        fs.WriteByte(0x21); // extension introducer
        fs.WriteByte(0xf9); // GCE label
        fs.WriteByte(4); // data block size
        int transp, disp;
        if (transparent == Color.Empty)
        {
            transp = 0;
            disp = 0; // dispose = no action
        }
        else
        {
            transp = 1;
            disp = 2; // force clear if using transparent color
        }
        if (dispose >= 0)
        {
            disp = dispose & 7; // user override
        }
        disp <<= 2;

        // packed fields
        fs.WriteByte(Convert.ToByte(0 | // 1:3 reserved
            disp | // 4:6 disposal
            0 | // 7   user input - 0 = none
            transp)); // 8   transparency flag

        WriteShort(delay); // delay x 1/100 sec
        fs.WriteByte(Convert.ToByte(transIndex)); // transparent color index
        fs.WriteByte(0); // block terminator
    }
    
    /// <summary>
    /// Writes Image Descriptor
    /// </summary>
    protected void WriteImageDesc()
    {
        fs.WriteByte(0x2c); // image separator
        WriteShort(0); // image position x,y = 0,0
        WriteShort(0);
        WriteShort(width); // image size
        WriteShort(height);
        // packed fields
        if (firstFrame)
        {
            // no LCT  - GCT is used for first (or only) frame
            fs.WriteByte(0);
        }
        else
        {
            // specify normal LCT
            fs.WriteByte(Convert.ToByte(0x80 | // 1 local color table  1=yes
                0 | // 2 interlace - 0=no
                0 | // 3 sorted - 0=no
                0 | // 4-5 reserved
                palSize)); // 6-8 size of color table
        }
    }

    /// <summary>
    /// Writes Logical Screen Descriptor
    /// </summary>
    protected void WriteLSD()
    {
        // logical screen size
        WriteShort(width);
        WriteShort(height);
        // packed fields
        fs.WriteByte(Convert.ToByte(0x80 | // 1   : global color table flag = 1 (gct used)
            0x70 | // 2-4 : color resolution = 7
            0x00 | // 5   : gct sort flag = 0
            palSize)); // 6-8 : gct size

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

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

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



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



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

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


public class GifDecoder : IDisposable
{

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

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

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

    protected Stream inStream;
    protected int status;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /// <summary>
    /// Gets the "Netscape" iteration count, if any.
    /// A count of 0 means repeat indefinitiely.
    /// </summary>
    /// <returns>Iteration count if one was specified, else 1</returns>
    public int GetLoopCount() {
        return loopCount;
    }
    
    /// <summary>
    /// Creates new frame image from current data (and previous
    /// frames as specified by their disposition codes)
    /// </summary>
    /// <param name="bitmap">Current bitmap data</param>
    /// <returns>Pixels array</returns>
    int[] GetPixels(Bitmap bitmap)
    {
        int[] pixels = new int[3 * image.Width * image.Height];
        int count = 0;

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

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

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

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

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

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

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

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

        return pixels;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        // copy each source line to the appropriate place in the destination
        int pass = 1;
        int inc = 8;
        int iline = 0;
        for (int i = 0; i < ih; i++)
        {
            int line = i;
            if (interlace)
            {
                if (iline >= ih)
                {
                    pass++;
                    switch (pass)
                    {
                        case 2:
                            iline = 4;
                            break;
                        case 3:
                            iline = 2;
                            inc = 4;
                            break;
                        case 4:
                            iline = 1;
                            inc = 2;
                            break;
                    }
                }
                line = iline;
                iline += inc;
            }
            line += iy;
            if (line < height)
            {
                int k = line * width;
                int dx = k + ix; // start of line in dest
                int dlim = dx + iw; // end of dest line
                if ((k + width) < dlim)
                {
                    dlim = k + width; // past dest edge
                }
                int sx = i * iw; // start of line in source
                while (dx < dlim)
                {
                    // map color and insert in destination
                    int index = ((int)pixels[sx++]) & 0xff;
                    int c = act[index];
                    if (c != 0)
                    {
                        dest[dx] = c;
                    }
                    dx++;
                }
            }
        }
        SetPixels(dest);
    }
    
    /// <summary>
    /// Gets the image contents of frame n
    /// </summary>
    /// <param name="n">The n'th frame</param>
    /// <returns>BufferedImage representation of frame, or null if n is invalid</returns>
    public Image GetFrame(int n)
    {
        Image im = null;
        if ((n >= 0) && (n < frameCount))
            im = ((GifFrame)frames[n]).image;

        return im;
    }

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

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

        return status;
    }

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

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

        //  Initialize GIF data stream decoder.

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

        //  Decode GIF pixel stream.

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

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

                //  Get the next code.

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

                //  Interpret the code

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

                //  Add a new string to the string table,

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

            //  Pop a pixel off the pixel stack.

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

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

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

    /// <summary>
    /// Initializes or re-initializes reader
    /// </summary>
    protected void Init()
    {
        status = STATUS_OK;
        frameCount = 0;
        frames = new ArrayList();
        gct = null;
        lct = null;
    }
    
    /// <summary>
    /// Reads a single byte from the input stream.
    /// </summary>
    /// <returns>The byte read</returns>
    protected int Read()
    {
        int curByte = 0;
        try
        {
            curByte = inStream.ReadByte();
        }
        catch (IOException)
        {
            status = STATUS_FORMAT_ERROR;
        }
        return curByte;
    }

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

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

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

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

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

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

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

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

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

                default:
                    status = STATUS_FORMAT_ERROR;
                    break;
            }
        }
    }

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

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

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

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

        ReadLSD();
        if (gctFlag && !Error())
        {
            gct = ReadColorTable(gctSize);
            bgColor = gct[bgIndex];
        }
    }
    
    /// <summary>
    /// Reads next frame image
    /// </summary>
    protected void ReadImage()
    {
        ix = ReadShort(); // (sub)image position & size
        iy = ReadShort();
        iw = ReadShort();
        ih = ReadShort();

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

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

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

        if (Error()) return;

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

        if (Error()) return;

        frameCount++;

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

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

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

        if (transparency)
            act[transIndex] = save;

        ResetFrame();

    }

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

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

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

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

    /// <summary>
    /// Reads Netscape extenstion to obtain iteration count
    /// </summary>
    protected void ReadNetscapeExt()
    {
        do
        {
            ReadBlock();
            if (block[0] == 1)
            {
                // loop count sub-block
                int b1 = ((int)block[1]) & 0xff;
                int b2 = ((int)block[2]) & 0xff;
                loopCount = (b2 << 8) | b1;
            }
        } while ((blockSize > 0) && !Error());
    }
    
    /// <summary>
    /// Reads next 16-bit value, LSB first
    /// </summary>
    /// <returns>short read</returns>
    protected int ReadShort()
    {
        // read 16-bit value, LSB first
        return Read() | (Read() << 8);
    }

    /// <summary>
    /// Resets frame state for reading next image
    /// </summary>
    protected void ResetFrame()
    {
        lastDispose = dispose;
        lastRect = new Rectangle(ix, iy, iw, ih);
        lastImage = image;
        lastBgColor = bgColor;
        transparency = false;
        delay = 0;
        lct = null;
    }
    
        /// <summary>
        /// Skips variable length blocks up to and including
        /// next zero length block
        /// </summary>
    protected void Skip()
    {
        do
        {
            ReadBlock();
        } while ((blockSize > 0) && !Error());
    }

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


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

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

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

    int n_bits; // number of bits/code
    int maxbits = BITS; // user settable max # bits/code
    int maxcode; // maximum code, given n_bits
    int maxmaxcode = 1 << BITS; // should NEVER generate this code

    int[] htab = new int[HSIZE];
    int[] codetab = new int[HSIZE];

    int hsize = HSIZE; // for dynamic table sizing

    int free_ent = 0; // first unused entry

    // block compression parameters -- after all codes are used up,
    // and compression rate changes, start over.
    bool clear_flg = false;

    // Algorithm:  use open addressing double hashing (no chaining) on the
    // prefix code / next character combination. We do a variant of Knuth's
    // algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime
    // secondary probe. Here, the modular division first probe is gives way
    // to a faster exclusive-or manipulation. Also do block compression with
    // an adaptive reset, whereby the code table is cleared when the compression
    // ratio decreases, but after the table fills. The variable-length output
    // codes are re-sized at this point, and a special CLEAR code is generated
    // for the decompressor. Late addition:  construct the table according to
    // file size for noticeable speed improvement on small files. Please direct
    // questions about this implementation to ames!jaw.

    int g_init_bits;

    int ClearCode;
    int EOFCode;

    // output
    //
    // Output the given code.
    // Inputs:
    //      code:   A n_bits-bit integer. If == -1, then EOF. This assumes
    //              that n_bits =< wordsize - 1.
    // Outputs:
    //      Outputs code to the file.
    // Assumptions:
    //      Chars are 8 bits long.
    // Algorithm:
    //      Maintain a BITS character long buffer (so that 8 codes will
    // fit in it exactly). Use the VAX insv instruction to insert each
    // code in turn. When the buffer fills up empty it and start over.

    int cur_accum = 0;
    int cur_bits = 0;

    int [] masks =
    {
        0x0000,
        0x0001,
        0x0003,
        0x0007,
        0x000F,
        0x001F,
        0x003F,
        0x007F,
        0x00FF,
        0x01FF,
        0x03FF,
        0x07FF,
        0x0FFF,
        0x1FFF,
        0x3FFF,
        0x7FFF,
        0xFFFF };

    // Number of characters so far in this 'packet'
    int a_count;

    // Define the storage for the packet accumulator
    byte[] accum = new byte[256];

    //----------------------------------------------------------------------------
    public LZWEncoder(int width, int height, byte[] pixels, int color_depth) 
    {
        imgW = width;
        imgH = height;
        pixAry = pixels;
        initCodeSize = Math.Max(2, color_depth);
    }
    
    // Add a character to the end of the current packet, and if it is 254
    // characters, flush the packet to disk.
    void Add(byte c, Stream outs)
    {
        accum[a_count++] = c;
        if (a_count >= 254)
            Flush(outs);
    }
    
    // Clear out the hash table

    // table clear for block compress
    void ClearTable(Stream outs)
    {
        ResetCodeTable(hsize);
        free_ent = ClearCode + 2;
        clear_flg = true;

        Output(ClearCode, outs);
    }
    
    // reset code table
    void ResetCodeTable(int hsize) 
    {
        for (int i = 0; i < hsize; ++i)
            htab[i] = -1;
    }
    
    void Compress(int init_bits, Stream outs)
    {
        int fcode;
        int i;
        int c;
        int ent;
        int disp;
        int hsize_reg;
        int hshift;

        // Set up the globals:  g_init_bits - initial number of bits
        g_init_bits = init_bits;

        // Set up the necessary values
        clear_flg = false;
        n_bits = g_init_bits;
        maxcode = MaxCode(n_bits);

        ClearCode = 1 << (init_bits - 1);
        EOFCode = ClearCode + 1;
        free_ent = ClearCode + 2;

        a_count = 0; // clear packet

        ent = NextPixel();

        hshift = 0;
        for (fcode = hsize; fcode < 65536; fcode *= 2)
            ++hshift;
        hshift = 8 - hshift; // set hash code range bound

        hsize_reg = hsize;
        ResetCodeTable(hsize_reg); // clear hash table

        Output(ClearCode, outs);

        outer_loop:
        while ((c = NextPixel()) != EOF) 
        {
            fcode = (c << maxbits) + ent;
            i = (c << hshift) ^ ent; // xor hashing

            if (htab[i] == fcode) 
            {
                ent = codetab[i];
                continue;
            } 
            else if (htab[i] >= 0) // non-empty slot
            {
                disp = hsize_reg - i; // secondary hash (after G. Knott)
                if (i == 0)
                    disp = 1;
                do 
                {
                    if ((i -= disp) < 0)
                        i += hsize_reg;

                    if (htab[i] == fcode) 
                    {
                        ent = codetab[i];
                        goto outer_loop;
                    }
                } while (htab[i] >= 0);
            }
            Output(ent, outs);
            ent = c;
            if (free_ent < maxmaxcode) 
            {
                codetab[i] = free_ent++; // code -> hashtable
                htab[i] = fcode;
            } 
            else
            ClearTable(outs);
        }
        // Put out the final code.
        Output(ent, outs);
        Output(EOFCode, outs);
    }
    
    //----------------------------------------------------------------------------
    public void Encode( Stream os)
    {
        os.WriteByte( Convert.ToByte( initCodeSize) ); // write "initial code size" byte

        remaining = imgW * imgH; // reset navigation variables
        curPixel = 0;

        Compress(initCodeSize + 1, os); // compress and write the pixel data

        os.WriteByte(0); // write block terminator
    }
    
    // Flush the packet to disk, and reset the accumulator
    void Flush(Stream outs)
    {
        if (a_count > 0) 
        {
            outs.WriteByte( Convert.ToByte( a_count ));
            outs.Write(accum, 0, a_count);
            a_count = 0;
        }
    }
    
    int MaxCode(int n_bits) 
    {
        return (1 << n_bits) - 1;
    }
    
    //----------------------------------------------------------------------------
    // Return the next pixel from the image
    //----------------------------------------------------------------------------
    int NextPixel() 
    {
        if (remaining == 0)
            return EOF;

        --remaining;

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

            return pix & 0xff;
        }
        return 0xff;
    }
    
    void Output(int code, Stream outs)
    {
        cur_accum &= masks[cur_bits];

        if (cur_bits > 0)
            cur_accum |= (code << cur_bits);
        else
            cur_accum = code;

        cur_bits += n_bits;

        while (cur_bits >= 8) 
        {
            Add((byte) (cur_accum & 0xff), outs);
            cur_accum >>= 8;
            cur_bits -= 8;
        }

        // If the next entry is going to be too big for the code size,
        // then increase it, if possible.
        if (free_ent > maxcode || clear_flg) 
        {
            if (clear_flg) 
            {
                maxcode = MaxCode(n_bits = g_init_bits);
                clear_flg = false;
            } 
            else 
            {
                ++n_bits;
                if (n_bits == maxbits)
                    maxcode = maxmaxcode;
                else
                    maxcode = MaxCode(n_bits);
            }
        }

        if (code == EOFCode) 
        {
            // At EOF, write the rest of the buffer.
            while (cur_bits > 0) 
            {
                Add((byte) (cur_accum & 0xff), outs);
                cur_accum >>= 8;
                cur_bits -= 8;
            }

            Flush(outs);
        }
    }
}

public class NeuQuant
{
    protected static readonly int netsize = 256; // number of colours used 
                                                    // four primes near 500 - assume no image has a length so large 
                                                    // that it is divisible by all four primes 
    protected static readonly int prime1 = 499;
    protected static readonly int prime2 = 491;
    protected static readonly int prime3 = 487;
    protected static readonly int prime4 = 503;
    protected static readonly int minpicturebytes = (3 * prime4);
    // minimum size for input image 
    // Program Skeleton
    /*    [select samplefac in range 1..30]
        [read image from input file]
        pic = (unsigned char*) malloc(3*width*height);
        initnet(pic,3*width*height,samplefac);
        learn();
        unbiasnet();
        [write output image header, using writecolourmap(f)]
        inxbuild();
        write output image using inxsearch(b,g,r) */

    // Network Definitions
    protected static readonly int maxnetpos = (netsize - 1);
    protected static readonly int netbiasshift = 4; // bias for colour values 
    protected static readonly int ncycles = 100; // no. of learning cycles 

    // defs for freq and bias */
    protected static readonly int intbiasshift = 16; // bias for fractions 
    protected static readonly int intbias = (((int)1) << intbiasshift);
    protected static readonly int gammashift = 10; // gamma = 1024 
    protected static readonly int gamma = (((int)1) << gammashift);
    protected static readonly int betashift = 10;
    protected static readonly int beta = (intbias >> betashift); // beta = 1/1024 
    protected static readonly int betagamma =
        (intbias << (gammashift - betashift));

    // defs for decreasing radius factor 
    protected static readonly int initrad = (netsize >> 3); // for 256 cols, radius starts 
    protected static readonly int radiusbiasshift = 6; // at 32.0 biased by 6 bits 
    protected static readonly int radiusbias = (((int)1) << radiusbiasshift);
    protected static readonly int initradius = (initrad * radiusbias); // and decreases by a 
    protected static readonly int radiusdec = 30; // factor of 1/30 each cycle 

    // defs for decreasing alpha factor 
    protected static readonly int alphabiasshift = 10; // alpha starts at 1.0 
    protected static readonly int initalpha = (((int)1) << alphabiasshift);

    protected int alphadec; // biased by 10 bits 

    // radbias and alpharadbias used for radpower calculation 
    protected static readonly int radbiasshift = 8;
    protected static readonly int radbias = (((int)1) << radbiasshift);
    protected static readonly int alpharadbshift = (alphabiasshift + radbiasshift);
    protected static readonly int alpharadbias = (((int)1) << alpharadbshift);

    // Types and Global Variables

    protected byte[] thepicture; // the input image itself 
    protected int lengthcount; // lengthcount = H*W*3 

    protected int samplefac; // sampling factor 1..30 

    //   typedef int pixel[4];                // BGRc 
    protected int[][] network; // the network itself - [netsize][4] 

    protected int[] netindex = new int[256];
    // for network lookup - really 256 

    protected int[] bias = new int[netsize];
    // bias and freq arrays for learning 
    protected int[] freq = new int[netsize];
    protected int[] radpower = new int[initrad];
    // radpower for precomputation 

    // Initialise network in range (0,0,0) to (255,255,255) and set parameters
    public NeuQuant(byte[] thepic, int len, int sample)
    {

        int i;
        int[] p;

        thepicture = thepic;
        lengthcount = len;
        samplefac = sample;

        network = new int[netsize][];
        for (i = 0; i < netsize; i++)
        {
            network[i] = new int[4];
            p = network[i];
            p[0] = p[1] = p[2] = (i << (netbiasshift + 8)) / netsize;
            freq[i] = intbias / netsize; // 1/netsize 
            bias[i] = 0;
        }
    }

    public byte[] ColorMap()
    {
        byte[] map = new byte[3 * netsize];
        int[] index = new int[netsize];
        for (int i = 0; i < netsize; i++)
            index[network[i][3]] = i;
        int k = 0;
        for (int i = 0; i < netsize; i++)
        {
            int j = index[i];
            map[k++] = (byte)(network[j][0]);
            map[k++] = (byte)(network[j][1]);
            map[k++] = (byte)(network[j][2]);
        }
        return map;
    }

    // Insertion sort of network and building of netindex[0..255] (to do after unbias)
    public void Inxbuild()
    {

        int i, j, smallpos, smallval;
        int[] p;
        int[] q;
        int previouscol, startpos;

        previouscol = 0;
        startpos = 0;
        for (i = 0; i < netsize; i++)
        {
            p = network[i];
            smallpos = i;
            smallval = p[1]; // index on g 
                                // find smallest in i..netsize-1 
            for (j = i + 1; j < netsize; j++)
            {
                q = network[j];
                if (q[1] < smallval)
                { // index on g 
                    smallpos = j;
                    smallval = q[1]; // index on g 
                }
            }
            q = network[smallpos];
            // swap p (i) and q (smallpos) entries 
            if (i != smallpos)
            {
                j = q[0];
                q[0] = p[0];
                p[0] = j;
                j = q[1];
                q[1] = p[1];
                p[1] = j;
                j = q[2];
                q[2] = p[2];
                p[2] = j;
                j = q[3];
                q[3] = p[3];
                p[3] = j;
            }
            // smallval entry is now in position i 
            if (smallval != previouscol)
            {
                netindex[previouscol] = (startpos + i) >> 1;
                for (j = previouscol + 1; j < smallval; j++)
                    netindex[j] = i;
                previouscol = smallval;
                startpos = i;
            }
        }
        netindex[previouscol] = (startpos + maxnetpos) >> 1;
        for (j = previouscol + 1; j < 256; j++)
            netindex[j] = maxnetpos; // really 256 
    }

    // Main Learning Loop
    public void Learn()
    {

        int i, j, b, g, r;
        int radius, rad, alpha, step, delta, samplepixels;
        byte[] p;
        int pix, lim;

        if (lengthcount < minpicturebytes)
            samplefac = 1;
        alphadec = 30 + ((samplefac - 1) / 3);
        p = thepicture;
        pix = 0;
        lim = lengthcount;
        samplepixels = lengthcount / (3 * samplefac);
        delta = samplepixels / ncycles;
        alpha = initalpha;
        radius = initradius;

        rad = radius >> radiusbiasshift;
        if (rad <= 1)
            rad = 0;
        for (i = 0; i < rad; i++)
            radpower[i] =
                alpha * (((rad * rad - i * i) * radbias) / (rad * rad));

        //fprintf(stderr,"beginning 1D learning: initial radius=%d\n", rad);

        if (lengthcount < minpicturebytes)
            step = 3;
        else if ((lengthcount % prime1) != 0)
            step = 3 * prime1;
        else
        {
            if ((lengthcount % prime2) != 0)
                step = 3 * prime2;
            else
            {
                if ((lengthcount % prime3) != 0)
                    step = 3 * prime3;
                else
                    step = 3 * prime4;
            }
        }

        i = 0;
        while (i < samplepixels)
        {
            b = (p[pix + 0] & 0xff) << netbiasshift;
            g = (p[pix + 1] & 0xff) << netbiasshift;
            r = (p[pix + 2] & 0xff) << netbiasshift;
            j = Contest(b, g, r);

            Altersingle(alpha, j, b, g, r);
            if (rad != 0)
                Alterneigh(rad, j, b, g, r); // alter neighbours 

            pix += step;
            if (pix >= lim)
                pix -= lengthcount;

            i++;
            if (delta == 0)
                delta = 1;
            if (i % delta == 0)
            {
                alpha -= alpha / alphadec;
                radius -= radius / radiusdec;
                rad = radius >> radiusbiasshift;
                if (rad <= 1)
                    rad = 0;
                for (j = 0; j < rad; j++)
                    radpower[j] =
                        alpha * (((rad * rad - j * j) * radbias) / (rad * rad));
            }
        }
        //fprintf(stderr,"finished 1D learning: readonly alpha=%f !\n",((float)alpha)/initalpha);
    }

    // Search for BGR values 0..255 (after net is unbiased) and return colour index
    public int Map(int b, int g, int r)
    {

        int i, j, dist, a, bestd;
        int[] p;
        int best;

        bestd = 1000; // biggest possible dist is 256*3 
        best = -1;
        i = netindex[g]; // index on g 
        j = i - 1; // start at netindex[g] and work outwards 

        while ((i < netsize) || (j >= 0))
        {
            if (i < netsize)
            {
                p = network[i];
                dist = p[1] - g; // inx key 
                if (dist >= bestd)
                    i = netsize; // stop iter 
                else
                {
                    i++;
                    if (dist < 0)
                        dist = -dist;
                    a = p[0] - b;
                    if (a < 0)
                        a = -a;
                    dist += a;
                    if (dist < bestd)
                    {
                        a = p[2] - r;
                        if (a < 0)
                            a = -a;
                        dist += a;
                        if (dist < bestd)
                        {
                            bestd = dist;
                            best = p[3];
                        }
                    }
                }
            }
            if (j >= 0)
            {
                p = network[j];
                dist = g - p[1]; // inx key - reverse dif 
                if (dist >= bestd)
                    j = -1; // stop iter 
                else
                {
                    j--;
                    if (dist < 0)
                        dist = -dist;
                    a = p[0] - b;
                    if (a < 0)
                        a = -a;
                    dist += a;
                    if (dist < bestd)
                    {
                        a = p[2] - r;
                        if (a < 0)
                            a = -a;
                        dist += a;
                        if (dist < bestd)
                        {
                            bestd = dist;
                            best = p[3];
                        }
                    }
                }
            }
        }
        return (best);
    }
    public byte[] Process()
    {
        Learn();
        Unbiasnet();
        Inxbuild();
        return ColorMap();
    }

    // Unbias network to give byte values 0..255 and record position i to prepare for sort
    public void Unbiasnet()
    {
        int i;

        for (i = 0; i < netsize; i++)
        {
            network[i][0] >>= netbiasshift;
            network[i][1] >>= netbiasshift;
            network[i][2] >>= netbiasshift;
            network[i][3] = i; // record colour no 
        }
    }

    // Move adjacent neurons by precomputed alpha*(1-((i-j)^2/[r]^2)) in radpower[|i-j|]
    protected void Alterneigh(int rad, int i, int b, int g, int r)
    {

        int j, k, lo, hi, a, m;
        int[] p;

        lo = i - rad;
        if (lo < -1)
            lo = -1;
        hi = i + rad;
        if (hi > netsize)
            hi = netsize;

        j = i + 1;
        k = i - 1;
        m = 1;
        while ((j < hi) || (k > lo))
        {
            a = radpower[m++];
            if (j < hi)
            {
                p = network[j++];
                try
                {
                    p[0] -= (a * (p[0] - b)) / alpharadbias;
                    p[1] -= (a * (p[1] - g)) / alpharadbias;
                    p[2] -= (a * (p[2] - r)) / alpharadbias;
                }
                catch { } // prevents 1.3 miscompilation
            }
            if (k > lo)
            {
                p = network[k--];
                try
                {
                    p[0] -= (a * (p[0] - b)) / alpharadbias;
                    p[1] -= (a * (p[1] - g)) / alpharadbias;
                    p[2] -= (a * (p[2] - r)) / alpharadbias;
                }
                catch { }
            }
        }
    }

    // Move neuron i towards biased (b,g,r) by factor alpha
    protected void Altersingle(int alpha, int i, int b, int g, int r)
    {

        // alter hit neuron 
        int[] n = network[i];
        n[0] -= (alpha * (n[0] - b)) / initalpha;
        n[1] -= (alpha * (n[1] - g)) / initalpha;
        n[2] -= (alpha * (n[2] - r)) / initalpha;
    }

    // Search for biased BGR values
    protected int Contest(int b, int g, int r)
    {

        // finds closest neuron (min dist) and updates freq 
        // finds best neuron (min dist-bias) and returns position 
        // for frequently chosen neurons, freq[i] is high and bias[i] is negative 
        // bias[i] = gamma*((1/netsize)-freq[i]) 

        int i, dist, a, biasdist, betafreq;
        int bestpos, bestbiaspos, bestd, bestbiasd;
        int[] n;

        bestd = ~(((int)1) << 31);
        bestbiasd = bestd;
        bestpos = -1;
        bestbiaspos = bestpos;

        for (i = 0; i < netsize; i++)
        {
            n = network[i];
            dist = n[0] - b;
            if (dist < 0)
                dist = -dist;
            a = n[1] - g;
            if (a < 0)
                a = -a;
            dist += a;
            a = n[2] - r;
            if (a < 0)
                a = -a;
            dist += a;
            if (dist < bestd)
            {
                bestd = dist;
                bestpos = i;
            }
            biasdist = dist - ((bias[i]) >> (intbiasshift - netbiasshift));
            if (biasdist < bestbiasd)
            {
                bestbiasd = biasdist;
                bestbiaspos = i;
            }
            betafreq = (freq[i] >> betashift);
            freq[i] -= betafreq;
            bias[i] += (betafreq << gammashift);
        }
        freq[bestpos] += beta;
        bias[bestpos] -= betagamma;
        return (bestbiaspos);
    }
}
View Code

 

方法四:使用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();
        }
    }
}
View Code

使用方法:

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

 

posted @ 2020-10-27 10:52  小y  阅读(192)  评论(0编辑  收藏