public static void GetHistogramEXT(HistogramTargetEXT target, bool reset, PixelFormat format, PixelType type, IntPtr values)
		{
			Debug.Assert(Delegates.pglGetHistogramEXT != null, "pglGetHistogramEXT not implemented");
			Delegates.pglGetHistogramEXT((Int32)target, reset, (Int32)format, (Int32)type, values);
			CallLog("glGetHistogramEXT({0}, {1}, {2}, {3}, 0x{4})", target, reset, format, type, values.ToString("X8"));
			DebugCheckErrors();
		}

        /// <summary>The quantize.</summary>
        /// <param name="image">The image.</param>
        /// <param name="pixelFormat">The pixel format.</param>
        /// <param name="useDither">The use dither.</param>
        /// <returns>The quantized image with the recalculated color palette.</returns>
        public static Bitmap Quantize(Image image, PixelFormat pixelFormat, bool useDither)
        {
            Bitmap tryBitmap = image as Bitmap;

            if (tryBitmap != null && tryBitmap.PixelFormat == PixelFormat.Format32bppArgb)
            {
                // The image passed to us is ALREADY a bitmap in the right format. No need to create
                // a copy and work from there.
                return DoQuantize(tryBitmap, pixelFormat, useDither);
            }

            // We use these values a lot
            int width = image.Width;
            int height = image.Height;
            Rectangle sourceRect = Rectangle.FromLTRB(0, 0, width, height);

            // Create a 24-bit rgb version of the source image
            using (Bitmap bitmapSource = new Bitmap(width, height, PixelFormat.Format32bppArgb))
            {
                using (Graphics grfx = Graphics.FromImage(bitmapSource))
                {
                    grfx.DrawImage(image, sourceRect, 0, 0, width, height, GraphicsUnit.Pixel);
                }

                return DoQuantize(bitmapSource, pixelFormat, useDither);
            }
        }

        public static int BytesPerPixel(PixelFormat pixelFormat)
        {
            int bytesPerPixel;

            // calculate bytes per pixel
            switch ( pixelFormat )
            {
                case PixelFormat.Format8bppIndexed:
                    bytesPerPixel = 1;
                    break;
                case PixelFormat.Format16bppGrayScale:
                    bytesPerPixel = 2;
                    break;
                case PixelFormat.Format24bppRgb:
                    bytesPerPixel = 3;
                    break;
                case PixelFormat.Format32bppRgb:
                case PixelFormat.Format32bppArgb:
                case PixelFormat.Format32bppPArgb:
                    bytesPerPixel = 4;
                    break;
                case PixelFormat.Format48bppRgb:
                    bytesPerPixel = 6;
                    break;
                case PixelFormat.Format64bppArgb:
                case PixelFormat.Format64bppPArgb:
                    bytesPerPixel = 8;
                    break;
                default:
                    throw new UnsupportedImageFormatException( "Can not create image with specified pixel format." );
            }
            return bytesPerPixel;
        }

        /// <summary>
        /// Converts a depth frame to the corresponding System.Drawing.Bitmap.
        /// </summary>
        /// <param name="frame">The specified depth frame.</param>
        /// <param name="format">Pixel format of the depth frame.</param>
        /// <param name="mode">Depth frame mode.</param>
        /// <returns>The corresponding System.Drawing.Bitmap representation of the depth frame.</returns>
        public static Bitmap ToBitmap(this DepthImageFrame frame, PixelFormat format, DepthImageMode mode)
        {
            short[] pixelData = new short[frame.PixelDataLength];
            frame.CopyPixelDataTo(pixelData);

            byte[] pixels;

            switch (mode)
            {
                case DepthImageMode.Raw:
                    pixels = GenerateRawFrame(frame, pixelData);
                    break;
                case DepthImageMode.Dark:
                    pixels = GenerateDarkFrame(frame, pixelData);
                    break;
                case DepthImageMode.Colors:
                    pixels = GenerateColoredFrame(frame, pixelData);
                    break;
                default:
                    pixels = GenerateRawFrame(frame, pixelData);
                    break;
            }

            return pixels.ToBitmap(frame.Width, frame.Height, format);
        }

 public VideoPacketDecoderWorker(PixelFormat pixelFormat, bool skipFrames, Action<VideoFrame> onFrameDecoded)
 {
   _pixelFormat = pixelFormat;
   _skipFrames = skipFrames;
   _onFrameDecoded = onFrameDecoded;
   _packetQueue = new ConcurrentQueue<VideoPacket>();
 }

 Int32 Build1DMipmap(TextureTarget target, Int32 internalFormat, Int32 width, PixelFormat format, PixelType type, IntPtr data)
 {
     unsafe
     {
         return Delegates.gluBuild1DMipmaps((TextureTarget)target, (Int32)internalFormat, (Int32)width, (PixelFormat)format, (PixelType)type, (IntPtr)data);
     }
 }

 /// <summary>
 /// Takes screenshot of the window (supports multiple monitors) and then lets user to select the wanted area and returns that area.
 /// Also returns the rectangle of the selected part inside of the window.
 /// </summary>
 public static Image Snip(IntPtr hWnd, out Rectangle rect, PixelFormat format = PixelFormat.Format24bppRgb) {
     NativeWin32.SetForegroundWindow(hWnd);
     
     Rect r;
     if (!NativeWin32.GetWindowRect(hWnd, out r)) {
         rect = Rectangle.Empty;
         return null;
     } 
     rect = new Rectangle(Convert.ToInt32(r.X), Convert.ToInt32(r.Y), Convert.ToInt32(r.Width), Convert.ToInt32(r.Height));
     
     var bmp = ScreenShot.Create(hWnd);
     Graph = Graphics.FromImage(bmp);
     Graph.SmoothingMode = SmoothingMode.None;
     
     using (var snipper = new SnippingTool(bmp) {SpecificWindowMode = true}) {
         snipper.Location = new Point(rect.Left, rect.Top);
         NativeWin32.SetForegroundWindow(snipper.Handle);
          
         if (snipper.ShowDialog() == DialogResult.OK) {
             rect = snipper.rcSelect;
             return snipper.Image;
         }
     }
     rect = Rectangle.Empty;
     return null;
 }

        /// <summary>
        /// Determines whether [is pixel format supported by graphics object] [the specified format].
        /// </summary>
        /// <param name="format">The format.</param>
        /// <returns><c>true</c> if [is pixel format supported by graphics object] [the specified format]; otherwise, <c>false</c>.</returns>
        public static bool IsPixelFormatSupportedByGraphicsObject(PixelFormat format)
        {
            // http://msdn.microsoft.com/en-us/library/system.drawing.graphics.fromimage.aspx

            if ((format & PixelFormat.Indexed) == PixelFormat.Indexed)
            {
                return false;
            }
            if ((format & PixelFormat.Undefined) == PixelFormat.Undefined)
            {
                return false;
            }
            if ((format & PixelFormat.DontCare) == PixelFormat.DontCare)
            {
                return false;
            }
            if ((format & PixelFormat.Format16bppArgb1555) == PixelFormat.Format16bppArgb1555)
            {
                return false;
            }
            if ((format & PixelFormat.Format16bppGrayScale) == PixelFormat.Format16bppGrayScale)
            {
                return false;
            }

            return true;
        }

 Int32 Build1DMipmapLevel(TextureTarget target, Int32 internalFormat, Int32 width, PixelFormat format, PixelType type, Int32 level, Int32 @base, Int32 max, IntPtr data)
 {
     unsafe
     {
         return Delegates.gluBuild1DMipmapLevels((TextureTarget)target, (Int32)internalFormat, (Int32)width, (PixelFormat)format, (PixelType)type, (Int32)level, (Int32)@base, (Int32)max, (IntPtr)data);
     }
 }

 static PixelFormats()
 {
     Bgr101010 = new PixelFormat("Bgr101010", 32);
     Bgr24 = new PixelFormat("Bgr24", 24);
     Bgr32 = new PixelFormat("Bgr32", 32);
     Bgr555 = new PixelFormat("Bgr555", 16);
     Bgr565 = new PixelFormat("Bgr565", 16);
     Bgra32 = new PixelFormat("Bgra32", 32);
     BlackWhite = new PixelFormat("BlackWhite", 1);
     Cmyk32 = new PixelFormat("Cmyk32", 32);
     Default = new PixelFormat("Default", 0);
     Gray16 = new PixelFormat("Gray16", 16);
     Gray2 = new PixelFormat("Gray2", 2);
     Gray32Float = new PixelFormat("Gray32Float", 32);
     Gray4 = new PixelFormat("Gray4", 4);
     Gray8 = new PixelFormat("Gray8", 8);
     Indexed1 = new PixelFormat("Indexed1", 1);
     Indexed2 = new PixelFormat("Indexed2", 2);
     Indexed4 = new PixelFormat("Indexed4", 4);
     Indexed8 = new PixelFormat("Indexed8", 8);
     Pbgra32 = new PixelFormat("Pbgra32", 32);
     Prgba128Float = new PixelFormat("Prgba128Float", 128);
     Prgba64 = new PixelFormat("Prgba64", 64);
     Rgb128Float = new PixelFormat("Rgb128Float", 128);
     Rgb24 = new PixelFormat("Rgb24", 24);
     Rgb48 = new PixelFormat("Rgb48", 48);
     Rgba128Float = new PixelFormat("Rgba128Float", 128);
     Rgba64 = new PixelFormat("Rgba64", 64);
 }

		public static void GetConvolutionFilterEXT(ConvolutionTargetEXT target, PixelFormat format, PixelType type, IntPtr image)
		{
			Debug.Assert(Delegates.pglGetConvolutionFilterEXT != null, "pglGetConvolutionFilterEXT not implemented");
			Delegates.pglGetConvolutionFilterEXT((Int32)target, (Int32)format, (Int32)type, image);
			CallLog("glGetConvolutionFilterEXT({0}, {1}, {2}, 0x{3})", target, format, type, image.ToString("X8"));
			DebugCheckErrors();
		}

 public EmptyTexture2D( int width, int height, int channels, PixelFormat format )
 {
     this.Width = width;
     this.Height = height;
     this.Channels = channels;
     this.Format = format;
 }

		public static Bitmap region(Rectangle area, bool cursor = true, PixelFormat pixel_format = PixelFormat.Format32bppRgb) {
			var bmp = new Bitmap(area.Width - 2, area.Height - 2, pixel_format);
			Graphics g = Graphics.FromImage(bmp);
			g.CopyFromScreen(area.X, area.Y, 0, 0, bmp.Size, CopyPixelOperation.SourceCopy);
			
			if (cursor)
			{
				CURSORINFO cursor_info;
				cursor_info.cbSize = Marshal.SizeOf(typeof (CURSORINFO));

				if (GetCursorInfo(out cursor_info))
					if (cursor_info.flags == (int)0x0001)
					{
						var hdc = g.GetHdc();
						DrawIconEx(
                            hdc, cursor_info.ptScreenPos.x - area.X, cursor_info.ptScreenPos.y - area.Y, cursor_info.hCursor,
                            0, 0, 0, IntPtr.Zero, (int)0x0003
                        );
						g.ReleaseHdc();
					}
			}
			
			g.Dispose();
			return bmp;
		}

 /// <summary>
 /// Initializes a new instance of the <see cref="DisplayMode"/> class.
 /// </summary>
 /// <param name="format">The format.</param>
 /// <param name="width">The width.</param>
 /// <param name="height">The height.</param>
 /// <param name="refreshRate">The refresh rate.</param>
 public DisplayMode(PixelFormat format, int width, int height, Rational refreshRate)
 {
     Format = format;
     Width = width;
     Height = height;
     RefreshRate = refreshRate;
 }

        /// <summary>
        /// Converts a color frame to a System.Drawing.Bitmap.
        /// </summary>
        /// <param name="frame">A ColorImageFrame generated from a Kinect sensor.</param>
        /// <param name="format">Image format.</param>
        /// <returns>The specified frame in a System.Drawing.Bitmap format.</returns>
        public static Bitmap ToBitmap(this ColorImageFrame frame, PixelFormat format)
        {
            byte[] pixels = new byte[frame.PixelDataLength];
            frame.CopyPixelDataTo(pixels);

            return pixels.ToBitmap(frame.Width, frame.Height, format);
        }

        internal ComBitmap(IntPtr bitmapData, int width, int height, int stride, PixelFormat format)
        {
            _bitmapData = bitmapData;

            _myBitmap = new Bitmap(width, height, stride, format, bitmapData);
            _myBitmap.RotateFlip(RotateFlipType.RotateNoneFlipY);
        }

 public IPixelFormat CreatePixelFormat(PixelFormat format, uint pixelWidth, uint pixelHeight, out byte[] buffer)
 {
     switch (format)
     {
         case PixelFormat.Gray:
             {
                 return new FormatGray(
                     RasterBufferFactory.CreateBuffer(pixelWidth, pixelHeight, 3, 3, out buffer),
                     IoC.Instance.Resolve<IBlenderGray>(), 3, 2);
             }
         case PixelFormat.RGB:
             {
                 return new FormatRGB(
                    RasterBufferFactory.CreateBuffer(pixelWidth, pixelHeight, 3, 3, out buffer),
                     IoC.Instance.Resolve<IBlender>("rgb"));
             }
         case PixelFormat.RGBA:
             {
                 return new FormatRGBA(
                     RasterBufferFactory.CreateBuffer(pixelWidth, pixelHeight, 4, 4, out buffer),
                     IoC.Instance.Resolve<IBlender>("bgra"));
             }
         default:
             throw new InvalidOperationException();
     }
 }

        public static Bitmap BlpToBitmap(MemoryStream ms, PixelFormat pf)
        {
            if (ms.Length == 0) return null;

            int width, height;
            uint type, subtype;

            byte[] srcBlp = ms.GetBuffer();

            //////////////////////////////
            // get required texture size
            //////////////////////////////

            uint textureSize = LoadBLP(IntPtr.Zero, srcBlp, out width, out height, out type, out subtype, false);

            IntPtr scan0 = Marshal.AllocHGlobal((int)textureSize);

            LoadBLP(scan0, srcBlp, out width, out height, out type, out subtype, false);

            Bitmap bmp = new Bitmap(width, height,
                (int)(textureSize / height),
                pf == PixelFormat.DontCare ? PixelFormat.Format32bppRgb : pf,
                scan0);

            return bmp;
        }

        //
        protected override void OnCreateTexture( string definitionName, ref Vec2I size, ref PixelFormat format )
        {
            base.OnCreateTexture( definitionName, ref size, ref format );

            if( definitionName == "scene" || definitionName == "temp" )
                size = Owner.DimensionsInPixels.Size / 2;
        }

        private static byte[] ConvertFrom24BppTo32Bpp(byte[] sourcePixels, PixelFormat destinationPixelFormat, PixelFormat sourcePixelFormat)
        {
            var newLength = (sourcePixels.Length / 3) << 2;
            var destinationPixels = new byte[newLength];
            var destinationPixelIndex = 0;

            var sourceColorSpace = ColorSpaces.RGB24BPP;
            var destinationColorSpace = ColorSpaces.RGBAlpha32BPP;

            for (var pixelIndex = 0; pixelIndex < sourcePixels.Length; pixelIndex += 3)
            {
                destinationPixels[destinationPixelIndex + destinationColorSpace.RedPosition] =
                    sourcePixels[pixelIndex + sourceColorSpace.RedPosition];

                destinationPixels[destinationPixelIndex + destinationColorSpace.GreenPosition] =
                    sourcePixels[pixelIndex + sourceColorSpace.GreenPosition];

                destinationPixels[destinationPixelIndex + destinationColorSpace.BluePosition] =
                    sourcePixels[pixelIndex + sourceColorSpace.BluePosition];

                destinationPixels[destinationPixelIndex + destinationColorSpace.AlphaPosition] = 0xff;

                destinationPixelIndex += 4;
            }

            return destinationPixels;
        }