public static IWICBitmapDecoder CreateDecoderFromStream(this IWICImagingFactory imagingFactory, IStream stream, WICDecodeOptions metadataOptions, Guid?pguidVendor = null)
{
using (var pguidVendorPtr = CoTaskMemPtr.From(pguidVendor))
{
return(imagingFactory.CreateDecoderFromStream(stream, pguidVendorPtr, metadataOptions));
}
}
public static Size GetTextureDimensions(IWICImagingFactory factory, Stream stream)
{
IWICStream wicStream = factory.CreateStream();
wicStream.Initialize(stream);
using (IWICBitmapDecoder decoder = factory.CreateDecoderFromStream(wicStream, DecodeOptions.CacheOnDemand))
{
var frame = decoder.GetFrame(0);
using (frame)
{
stream.Seek(0, SeekOrigin.Begin);
return(frame.Size);
}
}
}
public static IComObject <IWICBitmapDecoder> CreateDecoderFromStream(this IWICImagingFactory factory, IStream stream, Guid?guidVendor = null, WICDecodeOptions metadataOptions = WICDecodeOptions.WICDecodeMetadataCacheOnDemand)
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
if (stream == null)
{
throw new ArgumentNullException(nameof(factory));
}
using (var guid = new ComMemory(guidVendor))
{
factory.CreateDecoderFromStream(stream, guid.Pointer, metadataOptions, out var value).ThrowOnError();
return(new ComObject <IWICBitmapDecoder>(value));
}
}
public static IWICBitmapFrameDecode Load(this IWICImagingFactory factory, Stream stream)
{
if (factory == null)
{
throw new ArgumentNullException("factory");
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
StreamWrapper pIStream = new StreamWrapper(stream);
IWICBitmapDecoder iwicbitmapDecoder = factory.CreateDecoderFromStream(pIStream, null, WICDecodeOptions.WICDecodeMetadataCacheOnDemand);
IWICBitmapFrameDecode result;
iwicbitmapDecoder.GetFrame(0, out result);
GraphicsInteropNativeMethods.SafeReleaseComObject(iwicbitmapDecoder);
return(result);
}
private static SafeHBITMAP _CreateHBITMAPFromImageStream(Stream imgStream, out Size bitmapSize)
{
IWICImagingFactory pImagingFactory = null;
IWICBitmapDecoder pDecoder = null;
IWICStream pStream = null;
IWICBitmapFrameDecode pDecodedFrame = null;
IWICFormatConverter pBitmapSourceFormatConverter = null;
IWICBitmapFlipRotator pBitmapFlipRotator = null;
SafeHBITMAP hbmp = null;
try
{
using (var istm = new ManagedIStream(imgStream))
{
pImagingFactory = CLSID.CoCreateInstance <IWICImagingFactory>(CLSID.WICImagingFactory);
pStream = pImagingFactory.CreateStream();
pStream.InitializeFromIStream(istm);
// Create an object that will decode the encoded image
Guid vendor = Guid.Empty;
pDecoder = pImagingFactory.CreateDecoderFromStream(pStream, ref vendor, WICDecodeMetadata.CacheOnDemand);
pDecodedFrame = pDecoder.GetFrame(0);
pBitmapSourceFormatConverter = pImagingFactory.CreateFormatConverter();
// Convert the image from whatever format it is in to 32bpp premultiplied alpha BGRA
Guid pixelFormat = WICPixelFormat.WICPixelFormat32bppPBGRA;
pBitmapSourceFormatConverter.Initialize(pDecodedFrame, ref pixelFormat, WICBitmapDitherType.None, IntPtr.Zero, 0, WICBitmapPaletteType.Custom);
pBitmapFlipRotator = pImagingFactory.CreateBitmapFlipRotator();
pBitmapFlipRotator.Initialize(pBitmapSourceFormatConverter, WICBitmapTransform.FlipVertical);
int width, height;
pBitmapFlipRotator.GetSize(out width, out height);
bitmapSize = new Size {
Width = width, Height = height
};
var bmi = new BITMAPINFO
{
bmiHeader = new BITMAPINFOHEADER
{
biSize = Marshal.SizeOf(typeof(BITMAPINFOHEADER)),
biWidth = width,
biHeight = height,
biPlanes = 1,
biBitCount = 32,
biCompression = BI.RGB,
biSizeImage = (width * height * 4),
},
};
// Create a 32bpp DIB. This DIB must have an alpha channel for UpdateLayeredWindow to succeed.
IntPtr pBitmapBits;
hbmp = NativeMethods.CreateDIBSection(null, ref bmi, out pBitmapBits, IntPtr.Zero, 0);
// Copy the decoded image to the new buffer which backs the HBITMAP
var rect = new WICRect {
X = 0, Y = 0, Width = width, Height = height
};
pBitmapFlipRotator.CopyPixels(ref rect, width * 4, bmi.bmiHeader.biSizeImage, pBitmapBits);
var ret = hbmp;
hbmp = null;
return(ret);
}
}
finally
{
Utility.SafeRelease(ref pImagingFactory);
Utility.SafeRelease(ref pDecoder);
Utility.SafeRelease(ref pStream);
Utility.SafeRelease(ref pDecodedFrame);
Utility.SafeRelease(ref pBitmapFlipRotator);
Utility.SafeRelease(ref pBitmapSourceFormatConverter);
Utility.SafeDispose(ref hbmp);
}
}
private T LoadBitmapFromMemory <T>(IntPtr sourceBuffer, uint sourceBufferSize, Guid pixelFormat, CreateBitmapDelegate <T> createBitmap)
{
IWICImagingFactory imagingFactory = null;
IWICStream wicStream = null;
IWICBitmapDecoder decoder = null;
IWICBitmapFrameDecode frame = null;
IWICFormatConverter formatConverter = null;
try
{
imagingFactory = new IWICImagingFactory();
wicStream = imagingFactory.CreateStream();
wicStream.InitializeFromMemory(sourceBuffer, sourceBufferSize);
decoder = imagingFactory.CreateDecoderFromStream(
wicStream,
Guid.Empty,
WICDecodeOptions.WICDecodeMetadataCacheOnLoad
);
frame = decoder.GetFrame(0);
IWICBitmapSource source;
if (frame.GetPixelFormat() == pixelFormat)
{
source = frame;
}
else
{
formatConverter = imagingFactory.CreateFormatConverter();
formatConverter.Initialize(
frame,
WICPixelFormat.GUID_WICPixelFormat32bppPBGRA,
WICBitmapDitherType.WICBitmapDitherTypeNone,
null,
0.0f,
WICBitmapPaletteType.WICBitmapPaletteTypeCustom
);
source = formatConverter;
}
source.GetSize(out uint width, out uint height);
if (width * 4UL > int.MaxValue || height * 4UL > int.MaxValue || 4UL * width * height > int.MaxValue)
{
throw new IOException($"Image is too large: {width}x{height}.");
}
WicBitmapSource bitmapSource = new WicBitmapSource(source, (int)width, (int)height);
return(createBitmap(bitmapSource));
}
finally
{
SafeRelease(formatConverter);
SafeRelease(frame);
SafeRelease(decoder);
SafeRelease(wicStream);
SafeRelease(imagingFactory);
}
}
public static IWICBitmapDecoder CreateDecoderFromStream(this IWICImagingFactory imagingFactory, Stream stream, WICDecodeOptions metadataOptions, Guid?pguidVendor = null)
{
return(imagingFactory.CreateDecoderFromStream(stream.AsCOMStream(), metadataOptions, pguidVendor));
}