public void TestCreateDecoderMultithread()
{
var factory = GetImagingFactory();
using (Stream sourceStream = File.Open(@"..\..\..\PanasonicRW2.Tests\P1350577.RW2", FileMode.Open, FileAccess.Read, FileShare.Read))
{
Guid nul = Guid.Empty;
var stream = new StreamComWrapper(sourceStream);
IWICBitmapDecoder decoder = factory.CreateDecoderFromStream(stream, nul, WICDecodeOptions.WICDecodeMetadataCacheOnDemand);
decoder.Initialize(stream, WICDecodeOptions.WICDecodeMetadataCacheOnLoad);
Parallel.For(0, 8, new ParallelOptions {
MaxDegreeOfParallelism = 8
}, (i) =>
{
IWICBitmapFrameDecode frame;
decoder.GetFrame(0, out frame);
uint w, h;
frame.GetSize(out w, out h);
var buf = new byte[w * h * 3];
frame.CopyPixels(new WICRect {
Height = (int)h, Width = (int)w
}, w * 3, (uint)buf.Length, buf);
});
}
Marshal.ReleaseComObject(factory);
}
public static IEnumerable <IWICBitmapFrameDecode> GetFrames(this IWICBitmapDecoder bitmapDecoder)
{
for (int i = 0, n = bitmapDecoder.GetFrameCount(); i < n; ++i)
{
yield return(bitmapDecoder.GetFrame(i));
}
}
public static ComObject <IWICBitmapSource> LoadBitmapSource(string filePath, WICDecodeOptions metadataOptions = WICDecodeOptions.WICDecodeMetadataCacheOnDemand)
{
if (filePath == null)
{
throw new ArgumentNullException(nameof(filePath));
}
var wfac = (IWICImagingFactory) new WICImagingFactory();
IWICBitmapDecoder decoder = null;
IWICBitmapFrameDecode frame = null;
try
{
wfac.CreateDecoderFromFilename(filePath, IntPtr.Zero, (uint)GenericAccessRights.GENERIC_READ, metadataOptions, out decoder).ThrowOnError();
decoder.GetFrame(0, out frame).ThrowOnError();
wfac.CreateFormatConverter(out var converter).ThrowOnError();
var format = WICConstants.GUID_WICPixelFormat32bppPBGRA;
converter.Initialize(frame, ref format, WICBitmapDitherType.WICBitmapDitherTypeNone, null, 0, WICBitmapPaletteType.WICBitmapPaletteTypeCustom).ThrowOnError();
return(new ComObject <IWICBitmapSource>(converter));
}
finally
{
ComObject.Release(frame);
ComObject.Release(decoder);
ComObject.Release(wfac);
}
}
static void Main(string[] args)
{
IWICImagingFactory factory = (IWICImagingFactory) new WICImagingFactory();
IWICBitmapDecoder decoder = null;
IWICBitmapFrameDecode frame = null;
IWICFormatConverter formatConverter = null;
try
{
const string filename = @"<filename>";
decoder = factory.CreateDecoderFromFilename(filename, null, NativeMethods.GenericAccessRights.GENERIC_READ,
WICDecodeOptions.WICDecodeMetadataCacheOnDemand);
uint count = decoder.GetFrameCount();
frame = decoder.GetFrame(0);
uint width = 0;
uint height = 0;
frame.GetSize(out width, out height);
Guid pixelFormat;
frame.GetPixelFormat(out pixelFormat);
// The frame can use many different pixel formats.
// You can copy the raw pixel values by calling "frame.CopyPixels( )".
// This method needs a buffer that can hold all bytes.
// The total number of bytes is: width x height x bytes per pixel
// The disadvantage of this solution is that you have to deal with all possible pixel formats.
// You can make your life easy by converting the frame to a pixel format of
// your choice. The code below shows how to convert the pixel format to 24-bit RGB.
formatConverter = factory.CreateFormatConverter();
formatConverter.Initialize(frame,
Consts.GUID_WICPixelFormat24bppRGB,
WICBitmapDitherType.WICBitmapDitherTypeNone,
null,
0.0,
WICBitmapPaletteType.WICBitmapPaletteTypeCustom);
uint bytesPerPixel = 3; // Because we have converted the frame to 24-bit RGB
uint stride = width * bytesPerPixel;
byte[] bytes = new byte[stride * height];
formatConverter.CopyPixels(null, stride, stride * height, bytes);
}
finally
{
frame.ReleaseComObject();
decoder.ReleaseComObject();
factory.ReleaseComObject();
}
}
public static IComObject <IWICBitmapFrameDecode> GetFrame(this IWICBitmapDecoder decoder, int index)
{
if (decoder == null)
{
throw new ArgumentNullException(nameof(decoder));
}
decoder.GetFrame(index, out var value).ThrowOnError();
return(new ComObject <IWICBitmapFrameDecode>(value));
}
private static ID2D1Bitmap1 CreateD2dBitmap(
IWICImagingFactory imagingFactory,
string filename,
ID2D1DeviceContext renderTarget)
{
using IWICBitmapDecoder decoder = imagingFactory.CreateDecoderFromFileName(filename);
using IWICBitmapFrameDecode frame = decoder.GetFrame(0);
using IWICFormatConverter converter = imagingFactory.CreateFormatConverter();
converter.Initialize(frame, PixelFormat.Format32bppPBGRA, BitmapDitherType.None, null, 0, BitmapPaletteType.Custom);
return(renderTarget.CreateBitmapFromWicBitmap(converter, null));
}
static void Main(string[] args)
{
// This example requires the NuGet package 'stakx.WIC'.
// https://www.nuget.org/packages/stakx.WIC/
// https://github.com/stakx/WIC
const string filename = @"<filename>";
IWICImagingFactory factory = new WICImagingFactory();
IWICBitmapDecoder decoder = null;
IWICBitmapFrameDecode frame = null;
IWICFormatConverter formatConverter = null;
decoder = factory.CreateDecoderFromFilename(filename, IntPtr.Zero, StreamAccessMode.GENERIC_READ,
WICDecodeOptions.WICDecodeMetadataCacheOnDemand);
int count = decoder.GetFrameCount();
frame = decoder.GetFrame(0);
int width = 0;
int height = 0;
frame.GetSize(out width, out height);
Guid pixelFormat = frame.GetPixelFormat();
// The frame can use many different pixel formats.
// You can copy the raw pixel values by calling "frame.CopyPixels( )".
// This method needs a buffer that can hold all bytes.
// The total number of bytes is: width x height x bytes per pixel
// The disadvantage of this solution is that you have to deal with all possible pixel formats.
// You can make your life easy by converting the frame to a pixel format of
// your choice. The code below shows how to convert the pixel format to 24-bit RGB.
formatConverter = factory.CreateFormatConverter();
formatConverter.Initialize(frame,
GUID_WICPixelFormat24bppRGB,
WICBitmapDitherType.WICBitmapDitherTypeNone,
null,
0.0,
WICBitmapPaletteType.WICBitmapPaletteTypeCustom);
int bytesPerPixel = 3; // Because we have converted the frame to 24-bit RGB
int stride = width * bytesPerPixel;
byte[] bytes = new byte[stride * height];
formatConverter.CopyPixels(IntPtr.Zero, stride, stride * height, bytes);
}
public static IWICFormatConverter CreateWicImage(IWICImagingFactory wic, string fileName)
{
using (IWICBitmapDecoder decoder = wic.CreateDecoderFromFileName(fileName))
using (IWICStream decodeStream = wic.CreateStream(fileName, FileAccess.Read))
{
decoder.Initialize(decodeStream, DecodeOptions.CacheOnDemand);
using (IWICBitmapFrameDecode decodeFrame = decoder.GetFrame(0))
{
var converter = wic.CreateFormatConverter();
converter.Initialize(decodeFrame, PixelFormat.Format32bppPBGRA, BitmapDitherType.None, null, 0, BitmapPaletteType.Custom);
return(converter);
}
}
}
public static byte[] WicResize(IWICComponentFactory factory, byte[] photoBytes, int width, int height, int quality)
{
IWICBitmapDecoder decoder = null;
var inputStream = factory.CreateStream();
try {
inputStream.InitializeFromMemory(photoBytes, (uint)photoBytes.Length);
decoder = factory.CreateDecoderFromStream(inputStream, null,
WICDecodeOptions.WICDecodeMetadataCacheOnLoad);
return(WicResize(factory, decoder.GetFrame(0), width, height, quality));
} finally {
Marshal.ReleaseComObject(decoder);
Marshal.ReleaseComObject(inputStream);
}
}
private static WicBitmapSource LoadBitmapSource(Stream stream, int frameIndex, WICDecodeOptions metadataOptions)
{
var wfac = (IWICImagingFactory) new WICImagingFactory();
IWICBitmapDecoder decoder = null;
try
{
decoder = wfac.CreateDecoderFromStream(new ManagedIStream(stream), null, metadataOptions);
return(new WicBitmapSource(decoder.GetFrame(frameIndex), decoder.GetContainerFormat()));
}
finally
{
Release(decoder);
Release(wfac);
}
}
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);
}
}
}
private static WicBitmapSource LoadBitmapSource(string filePath, int frameIndex, WICDecodeOptions metadataOptions)
{
var wfac = (IWICImagingFactory) new WICImagingFactory();
IWICBitmapDecoder decoder = null;
try
{
decoder = wfac.CreateDecoderFromFilename(filePath, null, GenericAccessRights.GENERIC_READ, metadataOptions);
return(new WicBitmapSource(decoder.GetFrame(frameIndex), decoder.GetContainerFormat()));
}
finally
{
Release(decoder);
Release(wfac);
}
}
public static IWICBitmapFrameDecode Load(this IWICImagingFactory factory, string fileName)
{
if (factory == null)
{
throw new ArgumentNullException("factory");
}
if (fileName == null)
{
throw new ArgumentNullException("fileName");
}
IWICBitmapDecoder iwicbitmapDecoder = factory.CreateDecoderFromFilename(fileName, null, GenericAccess.GENERIC_READ, WICDecodeOptions.WICDecodeMetadataCacheOnDemand);
IWICBitmapFrameDecode result;
iwicbitmapDecoder.GetFrame(0, out result);
GraphicsInteropNativeMethods.SafeReleaseComObject(iwicbitmapDecoder);
return(result);
}
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 void filesListView_SelectedIndexChanged(object sender, EventArgs e)
{
if (filesListView.SelectedItems.Count > 0)
{
string file = filesListView.SelectedItems[0].Text;
if (decoder != null)
{
decoder.ReleaseComObject();
decoder = null;
}
if (frame != null)
{
frame.ReleaseComObject();
frame = null;
}
IWICImagingFactory factory = (IWICImagingFactory) new WICImagingFactory();
decoder = factory.CreateDecoderFromFilename(file, null, NativeMethods.GenericAccessRights.GENERIC_READ, WICDecodeOptions.WICDecodeMetadataCacheOnLoad);
if (decoder != null)
{
uint frameCount = decoder.GetFrameCount();
if (frameCount > 0)
{
frame = decoder.GetFrame(0);
}
if (frame != null)
{
setupMode = true;
SetupDevelopRaw();
setupMode = false;
DisplayImage();
}
}
factory.ReleaseComObject();
}
}
public GifPlayer(string filePath)
{
WICImagingFactory factory = WicImagingFactory = new WICImagingFactory();
IWICBitmapDecoder gifDecoder = WicBitmapDecoder = factory.CreateDecoderFromFilename(filePath,
null, // Do not prefer a particular vendor
WICDecodeOptions.WICDecodeMetadataCacheOnDemand);
var wicMetadataQueryReader = gifDecoder.GetMetadataQueryReader();
GetBackgroundColor(wicMetadataQueryReader);
var propertyVariant = new PROPVARIANT();
wicMetadataQueryReader.GetMetadataByName("/logscrdesc/Width", ref propertyVariant);
if ((propertyVariant.Type & VARTYPE.VT_UI2) == VARTYPE.VT_UI2)
{
Width = propertyVariant.Value.UI2;
}
// 清空一下
propertyVariant = new PROPVARIANT();
wicMetadataQueryReader.GetMetadataByName("/logscrdesc/Height", ref propertyVariant);
if ((propertyVariant.Type & VARTYPE.VT_UI2) == VARTYPE.VT_UI2)
{
Height = propertyVariant.Value.UI2;
}
// 清空一下
propertyVariant = new PROPVARIANT();
wicMetadataQueryReader.GetMetadataByName("/logscrdesc/PixelAspectRatio", ref propertyVariant);
if ((propertyVariant.Type & VARTYPE.VT_UI1) == VARTYPE.VT_UI1)
{
var pixelAspRatio = propertyVariant.Value.UI2;
if (pixelAspRatio != 0)
{
// Need to calculate the ratio. The value in uPixelAspRatio
// allows specifying widest pixel 4:1 to the tallest pixel of
// 1:4 in increments of 1/64th
float pixelAspRatioFloat = (pixelAspRatio + 15F) / 64F;
// Calculate the image width and height in pixel based on the
// pixel aspect ratio. Only shrink the image.
if (pixelAspRatioFloat > 1.0F)
{
WidthGifImagePixel = Width;
HeightGifImagePixel = (ushort)(Height / pixelAspRatioFloat);
}
else
{
WidthGifImagePixel = (ushort)(Width * pixelAspRatioFloat);
HeightGifImagePixel = Height;
}
}
else
{
// The value is 0, so its ratio is 1
WidthGifImagePixel = Width;
HeightGifImagePixel = Height;
}
}
var frameCount = gifDecoder.GetFrameCount();
for (int i = 0; i < frameCount; i++)
{
var wicBitmapFrameDecode = gifDecoder.GetFrame(i);
var wicFormatConverter = factory.CreateFormatConverter();
wicFormatConverter.Initialize(wicBitmapFrameDecode, WICPixelFormat.WICPixelFormat24bppBGR, WICBitmapDitherType.WICBitmapDitherTypeNone, null, 0, WICBitmapPaletteType.WICBitmapPaletteTypeCustom);
const int bytesPerPixel = 3;// BGR 格式
var size = wicFormatConverter.GetSize();
var imageByte = new byte[size.Width * size.Height * bytesPerPixel];
wicFormatConverter.CopyPixels(24, imageByte);
}
}
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);
}
}
private static Image DecodeMultiframe(WICFlags flags, ImageDescription metadata, IWICBitmapDecoder decoder)
{
var image = Image.New(metadata);
Guid sourceGuid;
if (!ToWIC(metadata.Format, out sourceGuid))
{
return(null);
}
for (var index = 0; index < metadata.ArraySize; ++index)
{
var pixelBuffer = image.PixelBuffer[index, 0];
using (var frame = decoder.GetFrame(index))
{
var pfGuid = frame.PixelFormat;
var size = frame.Size;
if (pfGuid == sourceGuid)
{
if (size.Width == metadata.Width && size.Height == metadata.Height)
{
// This frame does not need resized or format converted, just copy...
frame.CopyPixels(pixelBuffer.RowStride, pixelBuffer.BufferStride, pixelBuffer.DataPointer);
}
else
{
// This frame needs resizing, but not format converted
using (var scaler = Factory.CreateBitmapScaler())
{
scaler.Initialize(frame, metadata.Width, metadata.Height, GetWICInterp(flags));
scaler.CopyPixels(pixelBuffer.RowStride, pixelBuffer.BufferStride, pixelBuffer.DataPointer);
}
}
}
else
{
// This frame required format conversion
using (var converter = Factory.CreateFormatConverter())
{
converter.Initialize(frame, pfGuid, GetWICDither(flags), null, 0, BitmapPaletteType.Custom);
if (size.Width == metadata.Width && size.Height == metadata.Height)
{
converter.CopyPixels(pixelBuffer.RowStride, pixelBuffer.BufferStride, pixelBuffer.DataPointer);
}
else
{
// This frame needs resizing, but not format converted
using (var scaler = Factory.CreateBitmapScaler())
{
scaler.Initialize(frame, metadata.Width, metadata.Height, GetWICInterp(flags));
scaler.CopyPixels(pixelBuffer.RowStride, pixelBuffer.BufferStride, pixelBuffer.DataPointer);
}
}
}
}
}
}
return(image);
}
protected override void RunOverride(MainForm form, object tag)
{
bool hasFile = false;
bool processed = false;
IWICImagingFactory factory = (IWICImagingFactory) new WICImagingFactory();
IWICBitmapDecoderInfo info = null;
IWICBitmapDecoder decoder = null;
try
{
info = (IWICBitmapDecoderInfo)factory.CreateComponentInfo(Parent.Clsid);
foreach (string file in GetDecodableFiles(form, Parent.Clsid))
{
decoder.ReleaseComObject();
decoder = info.CreateInstance();
hasFile = true;
IWICStream stream = factory.CreateStream();
stream.InitializeFromFilename(file, NativeMethods.GenericAccessRights.GENERIC_READ);
try
{
decoder.Initialize(stream, WICDecodeOptions.WICDecodeMetadataCacheOnDemand);
if (ProcessDecoder(form, decoder, new DataEntry[] { new DataEntry(file) }, tag))
{
for (uint index = 0; index < decoder.GetFrameCount(); index++)
{
IWICBitmapFrameDecode frame = decoder.GetFrame(index);
try
{
if (ProcessFrameDecode(form, frame, new DataEntry[] { new DataEntry(file), new DataEntry(index) }, tag))
{
processed = true;
}
}
finally
{
frame.ReleaseComObject();
}
}
}
else
{
processed = true;
}
}
catch (Exception e)
{
form.Add(this, e.TargetSite.ToString(Resources._0_Failed), new DataEntry(file), new DataEntry(e));
}
finally
{
stream.ReleaseComObject();
}
}
}
finally
{
factory.ReleaseComObject();
info.ReleaseComObject();
decoder.ReleaseComObject();
}
if (!hasFile)
{
form.Add(Parent, string.Format(CultureInfo.CurrentUICulture, Resources.NoFilesFor_0, Parent.Text));
}
else if (!processed)
{
form.Add(this, string.Format(CultureInfo.CurrentUICulture, Resources.NoFilesFor_0, Text));
}
}
private void Initialize(IWICBitmapDecoder decoder)
{
Exception exception = null;
IWICBitmapFrameDecode source = null;
IWICFormatConverter converter = null;
var factory = m_directCanvasFactory.WicImagingFactory;
int hr = 0;
hr = decoder.GetFrame(0, out source);
if (hr != 0)
{
exception = new Exception(string.Format("Could not get the frame from the decoder."));
goto cleanup;
}
hr = factory.CreateFormatConverter(out converter);
if (hr != 0)
{
exception = new Exception(string.Format("Could not create the format converter"));
goto cleanup;
}
hr = converter.Initialize(source,
ref WICFormats.WICPixelFormat32bppPBGRA,
WICBitmapDitherType.WICBitmapDitherTypeNone,
null,
0,
WICBitmapPaletteType.WICBitmapPaletteTypeMedianCut);
if (hr != 0)
{
exception = new Exception(string.Format("Could not initialize the converter"));
goto cleanup;
}
bool canConvert;
hr = converter.CanConvert(ref WICFormats.WICPixelFormat32bppPBGRA,
ref WICFormats.WICPixelFormat32bppBGRA,
out canConvert);
if (hr != 0)
{
exception = new Exception(string.Format("Could not convert color formats"));
goto cleanup;
}
hr = factory.CreateBitmapFromSource(converter,
WICBitmapCreateCacheOption.WICBitmapCacheOnLoad,
out m_internalBitmap);
if (hr != 0)
{
exception = new Exception(string.Format("Could not create bitmap"));
goto cleanup;
}
cleanup:
if (converter != null)
Marshal.ReleaseComObject(converter);
if (source != null)
Marshal.ReleaseComObject(source);
if (decoder != null)
Marshal.ReleaseComObject(decoder);
if (exception != null)
throw exception;
else
Initialize();
}
internal static Image LoadFromWICMemory(IntPtr pSource, int size, bool makeACopy, GCHandle?handle)
{
var flags = WICFlags.AllFrames;
Image image = null;
// Create input stream for memory
using (var stream = Factory.CreateStream(new DataStream(pSource, size, true, false)))
{
// If the decoder is unable to decode the image, than return null
IWICBitmapDecoder decoder = null;
try
{
decoder = Factory.CreateDecoderFromStream(stream, DecodeOptions.CacheOnDemand);
using (var frame = decoder.GetFrame(0))
{
// Get metadata
Guid convertGuid;
var tempDesc = DecodeMetadata(flags, decoder, frame, out convertGuid);
// If not supported.
if (!tempDesc.HasValue)
{
return(null);
}
var mdata = tempDesc.Value;
if (mdata.ArraySize > 1 && (flags & WICFlags.AllFrames) != 0)
{
return(DecodeMultiframe(flags, mdata, decoder));
}
image = DecodeSingleFrame(flags, mdata, convertGuid, frame);
}
}
catch
{
image = null;
}
finally
{
if (decoder != null)
{
decoder.Dispose();
}
}
}
// For WIC, we are not keeping the original buffer.
if (image != null && !makeACopy)
{
if (handle.HasValue)
{
handle.Value.Free();
}
else
{
SdxUtilities.FreeMemory(pSource);
}
}
return(image);
}
