using System;
using System.IO;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media.Imaging;
using System.Windows.Threading; namespace GifImageLib
{ class GifAnimation : Viewbox
{ private class GifFrame : Image
{ public int delayTime; public int disposalMethod; public int left; public int top; public int width; public int height;
} private Canvas canvas = null; private List<GifFrame> frameList = null; private int frameCounter = ;
private int numberOfFrames = ; private int numberOfLoops = -;
private int currentLoop = ; private int logicalWidth = ;
private int logicalHeight = ; private DispatcherTimer frameTimer = null; private GifFrame currentParseGifFrame; public GifAnimation()
{
canvas = new Canvas();
this.Child = canvas;
} private void Reset()
{
if (frameList != null)
{
frameList.Clear();
}
frameList = null;
frameCounter = ;
numberOfFrames = ;
numberOfLoops = -;
currentLoop = ;
logicalWidth = ;
logicalHeight = ;
if (frameTimer != null)
{
frameTimer.Stop();
frameTimer = null;
}
} #region PARSE
private void ParseGif(byte[] gifData)
{
frameList = new List<GifFrame>();
currentParseGifFrame = new GifFrame();
ParseGifDataStream(gifData, );
} private int ParseBlock(byte[] gifData, int offset)
{
switch (gifData[offset])
{
case 0x21:
if (gifData[offset + ] == 0xF9)
{
return ParseGraphicControlExtension(gifData, offset);
}
else
{
return ParseExtensionBlock(gifData, offset);
}
case 0x2C:
offset = ParseGraphicBlock(gifData, offset);
frameList.Add(currentParseGifFrame);
currentParseGifFrame = new GifFrame();
return offset;
case 0x3B:
return -;
default:
throw new Exception("GIF format incorrect: missing graphic block or special-purpose block. ");
}
} private int ParseGraphicControlExtension(byte[] gifData, int offset)
{
int returnOffset = offset;
int length = gifData[offset + ];
returnOffset = offset + length + + ; byte packedField = gifData[offset + ];
currentParseGifFrame.disposalMethod = (packedField & 0x1C) >> ; int delay = BitConverter.ToUInt16(gifData, offset + );
currentParseGifFrame.delayTime = delay;
while (gifData[returnOffset] != 0x00)
{
returnOffset = returnOffset + gifData[returnOffset] + ;
} returnOffset++; return returnOffset;
} private int ParseLogicalScreen(byte[] gifData, int offset)
{
logicalWidth = BitConverter.ToUInt16(gifData, offset);
logicalHeight = BitConverter.ToUInt16(gifData, offset + ); byte packedField = gifData[offset + ];
bool hasGlobalColorTable = (int)(packedField & 0x80) > ? true : false; int currentIndex = offset + ;
if (hasGlobalColorTable)
{
int colorTableLength = packedField & 0x07;
colorTableLength = (int)Math.Pow(, colorTableLength + ) * ;
currentIndex = currentIndex + colorTableLength;
}
return currentIndex;
} private int ParseGraphicBlock(byte[] gifData, int offset)
{
currentParseGifFrame.left = BitConverter.ToUInt16(gifData, offset + );
currentParseGifFrame.top = BitConverter.ToUInt16(gifData, offset + );
currentParseGifFrame.width = BitConverter.ToUInt16(gifData, offset + );
currentParseGifFrame.height = BitConverter.ToUInt16(gifData, offset + );
if (currentParseGifFrame.width > logicalWidth)
{
logicalWidth = currentParseGifFrame.width;
}
if (currentParseGifFrame.height > logicalHeight)
{
logicalHeight = currentParseGifFrame.height;
}
byte packedField = gifData[offset + ];
bool hasLocalColorTable = (int)(packedField & 0x80) > ? true : false; int currentIndex = offset + ;
if (hasLocalColorTable)
{
int colorTableLength = packedField & 0x07;
colorTableLength = (int)Math.Pow(, colorTableLength + ) * ;
currentIndex = currentIndex + colorTableLength;
}
currentIndex++; currentIndex++; while (gifData[currentIndex] != 0x00)
{
int length = gifData[currentIndex];
currentIndex = currentIndex + gifData[currentIndex];
currentIndex++;
}
currentIndex = currentIndex + ;
return currentIndex;
} private int ParseExtensionBlock(byte[] gifData, int offset)
{
int returnOffset = offset;
int length = gifData[offset + ];
returnOffset = offset + length + + ;
if (gifData[offset + ] == 0xFF && length > )
{
string netscape = System.Text.ASCIIEncoding.ASCII.GetString(gifData, offset + , );
if (netscape == "NETSCAPE")
{
numberOfLoops = BitConverter.ToUInt16(gifData, offset + );
if (numberOfLoops > )
{
numberOfLoops++;
}
}
}
while (gifData[returnOffset] != 0x00)
{
returnOffset = returnOffset + gifData[returnOffset] + ;
} returnOffset++; return returnOffset;
} private int ParseHeader(byte[] gifData, int offset)
{
string str = System.Text.ASCIIEncoding.ASCII.GetString(gifData, offset, );
if (str != "GIF")
{
throw new Exception("Not a proper GIF file: missing GIF header");
}
return ;
} private void ParseGifDataStream(byte[] gifData, int offset)
{
offset = ParseHeader(gifData, offset);
offset = ParseLogicalScreen(gifData, offset);
while (offset != -)
{
offset = ParseBlock(gifData, offset);
}
} #endregion public void CreateGifAnimation(MemoryStream memoryStream)
{
Reset(); byte[] gifData = memoryStream.GetBuffer(); // Use GetBuffer so that there is no memory copy GifBitmapDecoder decoder = new GifBitmapDecoder(memoryStream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default); numberOfFrames = decoder.Frames.Count; try
{
ParseGif(gifData);
}
catch
{
throw new FileFormatException("Unable to parse Gif file format.");
} for (int i = ; i < decoder.Frames.Count; i++)
{
frameList[i].Source = decoder.Frames[i];
frameList[i].Visibility = Visibility.Hidden;
canvas.Children.Add(frameList[i]);
Canvas.SetLeft(frameList[i], frameList[i].left);
Canvas.SetTop(frameList[i], frameList[i].top);
Canvas.SetZIndex(frameList[i], i);
}
canvas.Height = logicalHeight;
canvas.Width = logicalWidth; frameList[].Visibility = Visibility.Visible; for (int i = ; i < frameList.Count; i++)
{
Console.WriteLine(frameList[i].disposalMethod.ToString() + " " + frameList[i].width.ToString() + " " + frameList[i].delayTime.ToString());
} if (frameList.Count > )
{
if (numberOfLoops == -)
{
numberOfLoops = ;
}
frameTimer = new System.Windows.Threading.DispatcherTimer();
frameTimer.Tick += NextFrame;
frameTimer.Interval = new TimeSpan(, , , , frameList[].delayTime * );
frameTimer.Start();
}
} public void NextFrame()
{
NextFrame(null, null);
} public void NextFrame(object sender, EventArgs e)
{
frameTimer.Stop();
if (numberOfFrames == ) return;
if (frameList[frameCounter].disposalMethod == )
{
frameList[frameCounter].Visibility = Visibility.Hidden;
}
if (frameList[frameCounter].disposalMethod >= )
{
frameList[frameCounter].Visibility = Visibility.Hidden;
}
frameCounter++; if (frameCounter < numberOfFrames)
{
frameList[frameCounter].Visibility = Visibility.Visible;
frameTimer.Interval = new TimeSpan(, , , , frameList[frameCounter].delayTime * );
frameTimer.Start();
}
else
{
if (numberOfLoops != )
{
currentLoop++;
}
if (currentLoop < numberOfLoops || numberOfLoops == )
{
for (int f = ; f < frameList.Count; f++)
{
frameList[f].Visibility = Visibility.Hidden;
}
frameCounter = ;
frameList[frameCounter].Visibility = Visibility.Visible;
frameTimer.Interval = new TimeSpan(, , , , frameList[frameCounter].delayTime * );
frameTimer.Start();
}
}
}
}
}
GifAnimation
using System.Net;
using System.IO;
using System.Security;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Threading;
using System.Windows.Resources;
using System; namespace GifImageLib
{
public class GifImageExceptionRoutedEventArgs : RoutedEventArgs
{
public Exception ErrorException; public GifImageExceptionRoutedEventArgs(RoutedEvent routedEvent, object obj)
: base(routedEvent, obj)
{
}
} class WebReadState
{
public WebRequest webRequest;
public MemoryStream memoryStream;
public Stream readStream;
public byte[] buffer;
} public class GifImage : System.Windows.Controls.UserControl
{
private GifAnimation gifAnimation = null;
private Image image = null; public GifImage()
{
} public static readonly DependencyProperty ForceGifAnimProperty = DependencyProperty.Register("ForceGifAnim", typeof(bool), typeof(GifImage), new FrameworkPropertyMetadata(false));
public bool ForceGifAnim
{
get
{
return (bool)this.GetValue(ForceGifAnimProperty);
}
set
{
this.SetValue(ForceGifAnimProperty, value);
}
} public static readonly DependencyProperty SourceProperty = DependencyProperty.Register("Source", typeof(string), typeof(GifImage), new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.AffectsMeasure | FrameworkPropertyMetadataOptions.AffectsRender, new PropertyChangedCallback(OnSourceChanged)));
private static void OnSourceChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
GifImage obj = (GifImage)d;
string s = (string)e.NewValue;
obj.CreateFromSourceString(s);
}
public string Source
{
get
{
return (string)this.GetValue(SourceProperty);
}
set
{
this.SetValue(SourceProperty, value);
}
} public static readonly DependencyProperty StretchProperty = DependencyProperty.Register("Stretch", typeof(Stretch), typeof(GifImage), new FrameworkPropertyMetadata(Stretch.Fill, FrameworkPropertyMetadataOptions.AffectsMeasure, new PropertyChangedCallback(OnStretchChanged)));
private static void OnStretchChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
GifImage obj = (GifImage)d;
Stretch s = (Stretch)e.NewValue;
if (obj.gifAnimation != null)
{
obj.gifAnimation.Stretch = s;
}
else if (obj.image != null)
{
obj.image.Stretch = s;
}
}
public Stretch Stretch
{
get
{
return (Stretch)this.GetValue(StretchProperty);
}
set
{
this.SetValue(StretchProperty, value);
}
} public static readonly DependencyProperty StretchDirectionProperty = DependencyProperty.Register("StretchDirection", typeof(StretchDirection), typeof(GifImage), new FrameworkPropertyMetadata(StretchDirection.Both, FrameworkPropertyMetadataOptions.AffectsMeasure, new PropertyChangedCallback(OnStretchDirectionChanged)));
private static void OnStretchDirectionChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
GifImage obj = (GifImage)d;
StretchDirection s = (StretchDirection)e.NewValue;
if (obj.gifAnimation != null)
{
obj.gifAnimation.StretchDirection = s;
}
else if (obj.image != null)
{
obj.image.StretchDirection = s;
}
}
public StretchDirection StretchDirection
{
get
{
return (StretchDirection)this.GetValue(StretchDirectionProperty);
}
set
{
this.SetValue(StretchDirectionProperty, value);
}
} public delegate void ExceptionRoutedEventHandler(object sender, GifImageExceptionRoutedEventArgs args); public static readonly RoutedEvent ImageFailedEvent = EventManager.RegisterRoutedEvent("ImageFailed", RoutingStrategy.Bubble, typeof(ExceptionRoutedEventHandler), typeof(GifImage)); public event ExceptionRoutedEventHandler ImageFailed
{
add
{
AddHandler(ImageFailedEvent, value);
}
remove
{
RemoveHandler(ImageFailedEvent, value);
}
} void image_ImageFailed(object sender, ExceptionRoutedEventArgs e)
{
RaiseImageFailedEvent(e.ErrorException);
} void RaiseImageFailedEvent(Exception exp)
{
GifImageExceptionRoutedEventArgs newArgs = new GifImageExceptionRoutedEventArgs(ImageFailedEvent, this);
newArgs.ErrorException = exp;
RaiseEvent(newArgs);
} private void DeletePreviousImage()
{
if (image != null)
{
this.RemoveLogicalChild(image);
image = null;
}
if (gifAnimation != null)
{
this.RemoveLogicalChild(gifAnimation);
gifAnimation = null;
}
} private void CreateNonGifAnimationImage()
{
image = new Image();
image.ImageFailed += new EventHandler<ExceptionRoutedEventArgs>(image_ImageFailed);
ImageSource src = (ImageSource)(new ImageSourceConverter().ConvertFromString(Source));
image.Source = src;
image.Stretch = Stretch;
image.StretchDirection = StretchDirection;
this.AddChild(image);
} private void CreateGifAnimation(MemoryStream memoryStream)
{
gifAnimation = new GifAnimation();
gifAnimation.CreateGifAnimation(memoryStream);
gifAnimation.Stretch = Stretch;
gifAnimation.StretchDirection = StretchDirection;
this.AddChild(gifAnimation);
} private void CreateFromSourceString(string source)
{
DeletePreviousImage();
Uri uri; try
{
uri = new Uri(source, UriKind.RelativeOrAbsolute);
}
catch (Exception exp)
{
RaiseImageFailedEvent(exp);
return;
} if (source.Trim().ToUpper().EndsWith(".GIF") || ForceGifAnim)
{
if (!uri.IsAbsoluteUri)
{
GetGifStreamFromPack(uri);
}
else
{ string leftPart = uri.GetLeftPart(UriPartial.Scheme); if (leftPart == "http://" || leftPart == "ftp://" || leftPart == "file://")
{
GetGifStreamFromHttp(uri);
}
else if (leftPart == "pack://")
{
GetGifStreamFromPack(uri);
}
else
{
CreateNonGifAnimationImage();
}
}
}
else
{
CreateNonGifAnimationImage();
}
} private delegate void WebRequestFinishedDelegate(MemoryStream memoryStream); private void WebRequestFinished(MemoryStream memoryStream)
{
CreateGifAnimation(memoryStream);
} private delegate void WebRequestErrorDelegate(Exception exp); private void WebRequestError(Exception exp)
{
RaiseImageFailedEvent(exp);
} private void WebResponseCallback(IAsyncResult asyncResult)
{
WebReadState webReadState = (WebReadState)asyncResult.AsyncState;
WebResponse webResponse;
try
{
webResponse = webReadState.webRequest.EndGetResponse(asyncResult);
webReadState.readStream = webResponse.GetResponseStream();
webReadState.buffer = new byte[];
webReadState.readStream.BeginRead(webReadState.buffer, , webReadState.buffer.Length, new AsyncCallback(WebReadCallback), webReadState);
}
catch (WebException exp)
{
this.Dispatcher.Invoke(DispatcherPriority.Render, new WebRequestErrorDelegate(WebRequestError), exp);
}
} private void WebReadCallback(IAsyncResult asyncResult)
{
WebReadState webReadState = (WebReadState)asyncResult.AsyncState;
int count = webReadState.readStream.EndRead(asyncResult);
if (count > )
{
webReadState.memoryStream.Write(webReadState.buffer, , count);
try
{
webReadState.readStream.BeginRead(webReadState.buffer, , webReadState.buffer.Length, new AsyncCallback(WebReadCallback), webReadState);
}
catch (WebException exp)
{
this.Dispatcher.Invoke(DispatcherPriority.Render, new WebRequestErrorDelegate(WebRequestError), exp);
}
}
else
{
this.Dispatcher.Invoke(DispatcherPriority.Render, new WebRequestFinishedDelegate(WebRequestFinished), webReadState.memoryStream);
}
} private void GetGifStreamFromHttp(Uri uri)
{
try
{
WebReadState webReadState = new WebReadState();
webReadState.memoryStream = new MemoryStream();
webReadState.webRequest = WebRequest.Create(uri);
webReadState.webRequest.Timeout = ; webReadState.webRequest.BeginGetResponse(new AsyncCallback(WebResponseCallback), webReadState);
}
catch (SecurityException)
{
CreateNonGifAnimationImage();
}
} private void ReadGifStreamSynch(Stream s)
{
byte[] gifData;
MemoryStream memoryStream;
using (s)
{
memoryStream = new MemoryStream((int)s.Length);
BinaryReader br = new BinaryReader(s);
gifData = br.ReadBytes((int)s.Length);
memoryStream.Write(gifData, , (int)s.Length);
memoryStream.Flush();
}
CreateGifAnimation(memoryStream);
} private void GetGifStreamFromPack(Uri uri)
{
try
{
StreamResourceInfo streamInfo; if (!uri.IsAbsoluteUri)
{
streamInfo = Application.GetContentStream(uri);
if (streamInfo == null)
{
streamInfo = Application.GetResourceStream(uri);
}
}
else
{
if (uri.GetLeftPart(UriPartial.Authority).Contains("siteoforigin"))
{
streamInfo = Application.GetRemoteStream(uri);
}
else
{
streamInfo = Application.GetContentStream(uri);
if (streamInfo == null)
{
streamInfo = Application.GetResourceStream(uri);
}
}
}
if (streamInfo == null)
{
throw new FileNotFoundException("Resource not found.", uri.ToString());
}
ReadGifStreamSynch(streamInfo.Stream);
}
catch (Exception exp)
{
RaiseImageFailedEvent(exp);
}
}
}
}
GifImage
使用：
var image = new GifImage { Source = "Path", Stretch = Stretch.Fill };