diff --git a/GreenshotPlugin/Core/FastBitmap.cs b/GreenshotPlugin/Core/FastBitmap.cs
new file mode 100644
index 000000000..4a7838d37
--- /dev/null
+++ b/GreenshotPlugin/Core/FastBitmap.cs
@@ -0,0 +1,481 @@
+/*
+ * Greenshot - a free and open source screenshot tool
+ * Copyright (C) 2007-2013  Thomas Braun, Jens Klingen, Robin Krom
+ * 
+ * For more information see: http://getgreenshot.org/
+ * The Greenshot project is hosted on Sourceforge: http://sourceforge.net/projects/greenshot/
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 1 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Drawing.Imaging;
+
+namespace GreenshotPlugin.Core {
+
+	/// <summary>
+	/// The interface for the FastBitmap
+	/// </summary>
+	public interface IFastBitmap : IDisposable {
+		Color GetColorAt(int x, int y);
+		void SetColorAt(int x, int y, Color color);
+		void Lock();
+		void Unlock();
+		Bitmap Bitmap {
+			get;
+		}
+		Size Size {
+			get;
+		}
+		int Height {
+			get;
+		}
+		int Width {
+			get;
+		}
+		bool NeedsDispose {
+			get;
+		}
+	}
+
+	/// <summary>
+	/// The base class for the fast bitmap implementation
+	/// </summary>
+	public unsafe abstract class FastBitmap : IFastBitmap {
+		private static log4net.ILog LOG = log4net.LogManager.GetLogger(typeof(FastBitmap));
+
+		/// <summary>
+		/// If this is set to true, the bitmap will be disposed when disposing the IFastBitmap
+		/// </summary>
+		public bool NeedsDispose {
+			get;
+			protected set;
+		}
+
+		/// <summary>
+		/// The bitmap for which the FastBitmap is creating access
+		/// </summary>
+		protected Bitmap bitmap;
+		protected BitmapData bmData;
+		protected int stride; /* bytes per pixel row */
+		protected bool bitsLocked = false;
+		protected byte* pointer;
+
+		/// <summary>
+		/// Factory for creating a FastBitmap depending on the pixelformat of the source
+		/// </summary>
+		/// <param name="source">Bitmap to access</param>
+		/// <returns>IFastBitmap</returns>
+		public static IFastBitmap Create(Bitmap source) {
+			switch (source.PixelFormat) {
+				case PixelFormat.Format8bppIndexed:
+					return new FastChunkyBitmap(source);
+				case PixelFormat.Format24bppRgb:
+					return new Fast24RGBBitmap(source);
+				case PixelFormat.Format32bppRgb:
+					return new Fast32RGBBitmap(source);
+				case PixelFormat.Format32bppArgb:
+					return new Fast32ARGBBitmap(source);
+				default:
+					throw new NotSupportedException(string.Format("Not supported Pixelformat {0}", source.PixelFormat));
+			}
+		}
+
+		/// <summary>
+		/// Factory for creating a FastBitmap as a destination for the source
+		/// </summary>
+		/// <param name="source">Bitmap to access</param>
+		/// <returns>IFastBitmap</returns>
+		public static IFastBitmap CreateDestinationFor(Bitmap source, PixelFormat pixelFormat) {
+			Bitmap destination = ImageHelper.CloneArea(source, Rectangle.Empty, pixelFormat);
+			IFastBitmap fastBitmap = Create(destination);
+			((FastBitmap)fastBitmap).NeedsDispose = true;
+			return fastBitmap;
+		}
+
+
+		/// <summary>
+		/// Factory for creating a FastBitmap as a destination
+		/// </summary>
+		/// <param name="newSize"></param>
+		/// <param name="pixelFormat"></param>
+		/// <param name="backgroundColor"></param>
+		/// <returns>IFastBitmap</returns>
+		public static IFastBitmap CreateEmpty(Size newSize, PixelFormat pixelFormat, Color backgroundColor) {
+			Bitmap destination = ImageHelper.CreateEmpty(newSize.Width, newSize.Height, pixelFormat, backgroundColor, 96f, 96f);
+			IFastBitmap fastBitmap = Create(destination);
+			((FastBitmap)fastBitmap).NeedsDispose = true;
+			return fastBitmap;
+		}
+
+		protected FastBitmap(Bitmap bitmap) {
+			this.bitmap = bitmap;
+		}
+
+		/// <summary>
+		/// Return the size of the image
+		/// </summary>
+		public Size Size {
+			get {
+				return bitmap.Size;
+			}
+		}
+
+		/// <summary>
+		/// Return the width of the image
+		/// </summary>
+		public int Width {
+			get {
+				return bitmap.Width;
+			}
+		}
+
+		/// <summary>
+		/// Return the height of the image
+		/// </summary>
+		public int Height {
+			get {
+				return bitmap.Height;
+			}
+		}
+
+		/// <summary>
+		/// Returns the underlying bitmap, do not dispose... if it's created for the FastBitmap it will be disposed!
+		/// </summary>
+		public Bitmap Bitmap {
+			get {
+				if (bitsLocked) {
+					throw new NotSupportedException("Can't get a locked bitmap!");
+				}
+				return bitmap;
+			}
+		}
+
+		/// <summary>
+		/// Destructor
+		/// </summary>
+		~FastBitmap() {
+			Dispose(false);
+		}
+
+		/// <summary>
+		/// The public accessible Dispose
+		/// Will call the GarbageCollector to SuppressFinalize, preventing being cleaned twice
+		/// </summary>
+		public void Dispose() {
+			Dispose(true);
+			GC.SuppressFinalize(this);
+		}
+
+		// The bulk of the clean-up code is implemented in Dispose(bool)
+
+		/// <summary>
+		/// This Dispose is called from the Dispose and the Destructor.
+		/// When disposing==true all non-managed resources should be freed too!
+		/// </summary>
+		/// <param name="disposing"></param>
+		protected virtual void Dispose(bool disposing) {
+			Unlock();
+			if (disposing) {
+				if (bitmap != null && NeedsDispose) {
+					bitmap.Dispose();
+				}
+			}
+			bitmap = null;
+			bmData = null;
+			pointer = null;
+		}
+
+		/// <summary>
+		/// Lock the bitmap so we have direct access to the memory
+		/// </summary>
+		public void Lock() {
+			if (Width > 0 && Height > 0 && !bitsLocked) {
+				bmData = bitmap.LockBits(new Rectangle(Point.Empty, Size), ImageLockMode.ReadWrite, bitmap.PixelFormat);
+				bitsLocked = true;
+
+				IntPtr Scan0 = bmData.Scan0;
+				pointer = (byte*)(void*)Scan0;
+				stride = bmData.Stride;
+			}
+		}
+
+		/// <summary>
+		/// Unlock the System Memory
+		/// </summary>
+		public void Unlock() {
+			if (bitsLocked) {
+				bitmap.UnlockBits(bmData);
+				bitsLocked = false;
+			}
+		}
+
+		/// <summary>
+		/// Draw the stored bitmap to the destionation bitmap at the supplied point
+		/// </summary>
+		/// <param name="graphics"></param>
+		/// <param name="destination"></param>
+		public void DrawTo(Graphics graphics, Point destination) {
+			DrawTo(graphics, null, destination);
+		}
+
+		/// <summary>
+		/// Draw the stored Bitmap on the Destination bitmap with the specified rectangle
+		/// Be aware that the stored bitmap will be resized to the specified rectangle!!
+		/// </summary>
+		/// <param name="graphics"></param>
+		/// <param name="destinationRect"></param>
+		public void DrawTo(Graphics graphics, Rectangle destinationRect) {
+			DrawTo(graphics, destinationRect, null);
+		}
+
+		/// <summary>
+		/// private helper to draw the bitmap
+		/// </summary>
+		/// <param name="graphics"></param>
+		/// <param name="destinationRect"></param>
+		/// <param name="destination"></param>
+		private void DrawTo(Graphics graphics, Rectangle? destinationRect, Point? destination) {
+			if (destinationRect.HasValue) {
+				// Does the rect have any pixels?
+				if (destinationRect.Value.Height <= 0 || destinationRect.Value.Width <= 0) {
+					return;
+				}
+			}
+			// Make sure this.bitmap is unlocked, if it was locked
+			bool isLocked = bitsLocked;
+			if (isLocked) {
+				Unlock();
+			}
+
+			if (destinationRect.HasValue) {
+				graphics.DrawImage(this.bitmap, destinationRect.Value);
+			} else if (destination.HasValue) {
+				graphics.DrawImageUnscaled(this.bitmap, destination.Value);
+			}
+			// If it was locked, lock it again
+			if (isLocked) {
+				Lock();
+			}
+		}
+
+		public abstract Color GetColorAt(int x, int y);
+		public abstract void SetColorAt(int x, int y, Color color);
+	}
+
+	public unsafe class FastChunkyBitmap : FastBitmap {
+		// Used for indexed images
+		private Color[] colorEntries;
+		private Dictionary<Color, byte> colorCache = new Dictionary<Color, byte>();
+
+		public FastChunkyBitmap(Bitmap source) : base(source) {
+			colorEntries = bitmap.Palette.Entries;
+		}
+
+		/// <summary>
+		/// Get the color from the specified location
+		/// </summary>
+		/// <param name="x"></param>
+		/// <param name="y"></param>
+		/// <returns>Color</returns>
+		public override Color GetColorAt(int x, int y) {
+			int offset = x + (y * stride);
+			byte colorIndex = pointer[offset];
+			return colorEntries[colorIndex];
+		}
+
+		/// <summary>
+		/// Get the color-index from the specified location
+		/// </summary>
+		/// <param name="x"></param>
+		/// <param name="y"></param>
+		/// <returns>byte with index</returns>
+		public byte GetColorIndexAt(int x, int y) {
+			int offset = x + (y * stride);
+			return pointer[offset];
+		}
+
+		/// <summary>
+		/// Set the color-index at the specified location
+		/// </summary>
+		/// <param name="x"></param>
+		/// <param name="y"></param>
+		/// <param name="color-index"></param>
+		public void SetColorIndexAt(int x, int y, byte colorIndex) {
+			int offset = x + (y * stride);
+			pointer[offset] = colorIndex;
+		}
+
+		/// <summary>
+		/// Set the supplied color at the specified location.
+		/// Throws an ArgumentException if the color is not in the palette
+		/// </summary>
+		/// <param name="x"></param>
+		/// <param name="y"></param>
+		/// <param name="color">Color to set</param>
+		public override void SetColorAt(int x, int y, Color color) {
+			int offset = x + (y * stride);
+			byte colorIndex;
+			if (!colorCache.TryGetValue(color, out colorIndex)) {
+				bool foundColor = false;
+				for (colorIndex = 0; colorIndex < colorEntries.Length; colorIndex++) {
+					if (color == colorEntries[colorIndex]) {
+						colorCache.Add(color, colorIndex);
+						foundColor = true;
+						break;
+					}
+				}
+				if (!foundColor) {
+					throw new ArgumentException("No such color!");
+				}
+			}
+			pointer[offset] = colorIndex;
+		}
+	}
+
+	/// <summary>
+	/// This is the implementation of the IFastBitmap for 24 bit images (no Alpha)
+	/// </summary>
+	public unsafe class Fast24RGBBitmap : FastBitmap {
+
+		public Fast24RGBBitmap(Bitmap source) : base(source) {
+		}
+
+		/// <summary>
+		/// Retrieve the color at location x,y
+		/// Before the first time this is called the Lock() should be called once!
+		/// </summary>
+		/// <param name="x">X coordinate</param>
+		/// <param name="y">Y Coordinate</param>
+		/// <returns>Color</returns>
+		public override Color GetColorAt(int x, int y) {
+			int offset = (x * 3) + (y * stride);
+			return Color.FromArgb(255, pointer[2 + offset], pointer[1 + offset], pointer[offset]);
+		}
+
+		/// <summary>
+		/// Set the color at location x,y
+		/// Before the first time this is called the Lock() should be called once!
+		/// </summary>
+		/// <param name="x"></param>
+		/// <param name="y"></param>
+		/// <param name="color"></param>
+		public override void SetColorAt(int x, int y, Color color) {
+			int offset = (x * 3) + (y * stride);
+			pointer[2 + offset] = color.R;
+			pointer[1 + offset] = color.G;
+			pointer[offset] = color.B;
+		}
+	}
+
+	/// <summary>
+	/// This is the implementation of the IFastBitmap for 32 bit images (no Alpha)
+	/// </summary>
+	public unsafe class Fast32RGBBitmap : FastBitmap {
+		public Fast32RGBBitmap(Bitmap source) : base(source) {
+
+		}
+
+		/// <summary>
+		/// Retrieve the color at location x,y
+		/// Before the first time this is called the Lock() should be called once!
+		/// </summary>
+		/// <param name="x">X coordinate</param>
+		/// <param name="y">Y Coordinate</param>
+		/// <returns>Color</returns>
+		public override Color GetColorAt(int x, int y) {
+			int offset = (x * 4) + (y * stride);
+			return Color.FromArgb(255, pointer[2 + offset], pointer[1 + offset], pointer[offset]);
+		}
+
+		/// <summary>
+		/// Set the color at location x,y
+		/// Before the first time this is called the Lock() should be called once!
+		/// </summary>
+		/// <param name="x"></param>
+		/// <param name="y"></param>
+		/// <param name="color"></param>
+		public override void SetColorAt(int x, int y, Color color) {
+			int offset = (x * 4) + (y * stride);
+			pointer[2 + offset] = color.R;
+			pointer[1 + offset] = color.G;
+			pointer[offset] = color.B;
+		}
+	}
+
+	/// <summary>
+	/// This is the implementation of the IFastBitmap for 32 bit images with Alpha
+	/// </summary>
+	public unsafe class Fast32ARGBBitmap : FastBitmap {
+		public Color BackgroundBlendColor {
+			get;
+			set;
+		}
+		public Fast32ARGBBitmap(Bitmap source) : base(source) {
+			BackgroundBlendColor = Color.White;
+		}
+
+		/// <summary>
+		/// Retrieve the color at location x,y
+		/// </summary>
+		/// <param name="x">X coordinate</param>
+		/// <param name="y">Y Coordinate</param>
+		/// <returns>Color</returns>
+		public override Color GetColorAt(int x, int y) {
+			int offset = (x * 4) + (y * stride);
+			return Color.FromArgb(pointer[3 + offset], pointer[2 + offset], pointer[1 + offset], pointer[offset]);
+		}
+
+		/// <summary>
+		/// Set the color at location x,y
+		/// Before the first time this is called the Lock() should be called once!
+		/// </summary>
+		/// <param name="x"></param>
+		/// <param name="y"></param>
+		/// <param name="color"></param>
+		public override void SetColorAt(int x, int y, Color color) {
+			int offset = (x * 4) + (y * stride);
+			pointer[3 + offset] = color.A;
+			pointer[2 + offset] = color.R;
+			pointer[1 + offset] = color.G;
+			pointer[offset] = color.B;
+		}
+
+		/// <summary>
+		/// Retrieve the color, without alpha (is blended), at location x,y
+		/// Before the first time this is called the Lock() should be called once!
+		/// </summary>
+		/// <param name="x">X coordinate</param>
+		/// <param name="y">Y Coordinate</param>
+		/// <returns>Color</returns>
+		public Color GetColorAtWithoutAlpha(int x, int y) {
+			int offset = (x * 4) + (y * stride);
+			int a = pointer[3 + offset];
+			int red = pointer[2 + offset];
+			int green = pointer[1 + offset];
+			int blue = pointer[offset];
+
+			if (a < 255) {
+				// As the request is to get without alpha, we blend.
+				int rem = 255 - a;
+				red = (red * a + BackgroundBlendColor.R * rem) / 255;
+				green = (green * a + BackgroundBlendColor.G * rem) / 255;
+				blue = (blue * a + BackgroundBlendColor.B * rem) / 255;
+			}
+			return Color.FromArgb(255, red, green, blue);
+		}
+
+	}
+}
diff --git a/GreenshotPlugin/GreenshotPlugin.csproj b/GreenshotPlugin/GreenshotPlugin.csproj
index 6ddf4b4d2..31e9ff7f6 100644
--- a/GreenshotPlugin/GreenshotPlugin.csproj
+++ b/GreenshotPlugin/GreenshotPlugin.csproj
@@ -31,6 +31,7 @@
     <Compile Include="Controls\AnimatingForm.cs">
       <SubType>Form</SubType>
     </Compile>
+    <Compile Include="Core\FastBitmap.cs" />
     <Compile Include="IEInterop\IHTMLBodyElement.cs" />
     <Compile Include="IEInterop\IHTMLCurrentStyle.cs" />
     <Compile Include="IEInterop\IHTMLDocument.cs" />