protected override void RunOverride(ListView.ListViewItemCollection collection, object tag)
{
IWICImagingFactory factory = (IWICImagingFactory) new WICImagingFactory();
IWICBitmapDecoderInfo info = null;
try
{
info = (IWICBitmapDecoderInfo)factory.CreateComponentInfo(Parent.Clsid);
string[] mimes = Extensions.GetString(info.GetMimeTypes).Split(',');
foreach (string ext in Extensions.GetString(info.GetFileExtensions).Split(','))
{
using (RegistryKey rk = OpenSubKey(collection, Registry.ClassesRoot, ext, new DataEntry[] { new DataEntry("File Extension", ext) }))
{
if (rk != null)
{
Check(collection, ext, rk, info);
}
}
}
}
finally
{
factory.ReleaseComObject();
info.ReleaseComObject();
}
}
void CheckCopyPalette(MainForm form, DataEntry[] de, Action <IWICPalette> method)
{
IWICImagingFactory factory = (IWICImagingFactory) new WICImagingFactory();
IWICPalette palette = factory.CreatePalette();
try
{
method(palette);
try
{
if (palette.GetColorCount() == 0)
{
form.Add(this, method.ToString(Resources._0_ZeroColorPalette), de);
}
}
catch (Exception e)
{
form.Add(this, method.ToString(Resources._0_IncorrectStatePalette), de, new DataEntry(e));
}
}
catch (Exception e)
{
form.CheckHRESULT(this, WinCodecError.WINCODEC_ERR_PALETTEUNAVAILABLE, e, de);
}
finally
{
palette.ReleaseComObject();
factory.ReleaseComObject();
}
}
private bool CheckConvertion(MainForm form, IWICFormatConverterInfo info, Guid from, Guid to)
{
if (from == to)
{
return(true);
}
IWICImagingFactory factory = (IWICImagingFactory) new WICImagingFactory();
IWICPalette palette = factory.CreatePalette();
palette.InitializePredefined(WICBitmapPaletteType.WICBitmapPaletteTypeFixedBW, false);
IWICBitmap bitmap = null;
IWICFormatConverter converter = null;
try
{
try
{
converter = info.CreateInstance();
}
catch (Exception e)
{
form.Add(this, e.TargetSite.ToString(Resources._0_Failed), new DataEntry(e));
return(false);
}
try
{
bitmap = factory.CreateBitmap(1, 1, from, WICBitmapCreateCacheOption.WICBitmapCacheOnLoad);
bitmap.SetPalette(palette);
}
catch (Exception e)
{
form.Add(this, e.TargetSite.ToString(Resources._0_Failed), new DataEntry(e), new DataEntry(Resources.PixelFormat, from));
return(false);
}
try
{
converter.Initialize(bitmap, to, WICBitmapDitherType.WICBitmapDitherTypeNone, palette, 0, WICBitmapPaletteType.WICBitmapPaletteTypeCustom);
}
catch (Exception e)
{
form.CheckHRESULT(this, WinCodecError.WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT, e, new DataEntry(Resources.Source, from), new DataEntry(Resources.Destination, to));
return(false);
}
return(true);
}
finally
{
palette.ReleaseComObject();
converter.ReleaseComObject();
bitmap.ReleaseComObject();
factory.ReleaseComObject();
}
}
private void Check(MainForm form, IWICFormatConverterInfo info, object tag)
{
Guid[] pixelFormats = PixelFormatInfoRule.CheckPixelFormats(form, this, info.GetPixelFormats);
Type type = Type.GetTypeFromCLSID(Parent.Clsid);
if (type == null)
{
form.Add(this, Resources.PixelFormatConverterNotCreatable);
}
else
{
IWICImagingFactory factory = (IWICImagingFactory) new WICImagingFactory();
foreach (Guid g in pixelFormats)
{
bool supportsTo = false;
bool supportsFrom = false;
foreach (Guid c in canonical)
{
supportsTo |= CheckConvertion(form, info, g, c);
supportsFrom |= CheckConvertion(form, info, c, g);
}
if (!supportsTo)
{
form.Add(this, Resources.ToCannonicalNotSupported, new DataEntry(Resources.PixelFormat, g));
}
if (!supportsFrom)
{
form.Add(this, Resources.FromCannonicalNotSupported, new DataEntry(Resources.PixelFormat, g));
}
}
}
}
public static IWICBitmapEncoder CreateEncoder(this IWICImagingFactory factory, Guid guidContainerFormat, Guid?pguidVendor = null)
{
using (var pguidVendorPtr = CoTaskMemPtr.From(pguidVendor))
{
return(factory.CreateEncoder(guidContainerFormat, pguidVendorPtr));
}
}
public static IWICMetadataQueryWriter CreateQueryWriter(this IWICImagingFactory imagingFactory, Guid guidMetadataFormat, Guid?pguidVendor = null)
{
using (var pguidVendorPtr = CoTaskMemPtr.From(pguidVendor))
{
return(imagingFactory.CreateQueryWriter(guidMetadataFormat, pguidVendorPtr));
}
}
public static IWICMetadataQueryWriter CreateQueryWriterFromReader(this IWICImagingFactory imagingFactory, IWICMetadataQueryReader pIQueryReader, Guid?pguidVendor = null)
{
using (var pguidVendorPtr = CoTaskMemPtr.From(pguidVendor))
{
return(imagingFactory.CreateQueryWriterFromReader(pIQueryReader, pguidVendorPtr));
}
}
public static IComObject <IWICBitmapDecoder> CreateDecoderFromFilename(this IWICImagingFactory factory, string fileName, Guid?guidVendor = null, FileAccess desiredAccess = FileAccess.Read, WICDecodeOptions metadataOptions = WICDecodeOptions.WICDecodeMetadataCacheOnDemand)
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
if (fileName == null)
{
throw new ArgumentNullException(nameof(factory));
}
const uint GENERIC_READ = 0x80000000;
const uint GENERIC_WRITE = 0x40000000;
using (var guid = new ComMemory(guidVendor))
{
uint acc = 0;
if (desiredAccess.HasFlag(FileAccess.Read))
{
acc |= GENERIC_READ;
}
if (desiredAccess.HasFlag(FileAccess.Read))
{
acc |= GENERIC_WRITE;
}
factory.CreateDecoderFromFilename(fileName, guid.Pointer, acc, metadataOptions, out var value).ThrowOnError();
return(new ComObject <IWICBitmapDecoder>(value));
}
}
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));
}
}
protected override void RunOverride(MainForm form, object tag)
{
bool info2Supported = false;
IWICImagingFactory factory = (IWICImagingFactory) new WICImagingFactory();
IWICPixelFormatInfo2 info = null;
try
{
info = factory.CreateComponentInfo(Parent.Clsid) as IWICPixelFormatInfo2;
info2Supported = info != null;
}
finally
{
info.ReleaseComObject();
factory.ReleaseComObject();
}
if (info2Supported)
{
ComponentInfoHelper.Check <IWICPixelFormatInfo2, object>(form, Parent.Clsid, Check, tag, this, false);
}
else
{
ComponentInfoHelper.Check <IWICPixelFormatInfo, object>(form, Parent.Clsid, Check, tag, this, false);
}
}
public static void CheckEquals <TInfo>(MainForm form, Func <TInfo> method, RuleBase <ComponentRuleGroup> rule, Func <TInfo, TInfo, DataEntry[][]> compare)
where TInfo : class, IWICComponentInfo
{
IWICImagingFactory factory = (IWICImagingFactory) new WICImagingFactory();
TInfo info = factory.CreateComponentInfo(rule.Parent.Clsid) as TInfo;
TInfo i = null;
try
{
i = method();
if (i == null)
{
form.Add(rule, method.ToString(Resources._0_NULL));
}
else
{
foreach (DataEntry[] de in compare(info, i))
{
form.Add(rule, string.Format(CultureInfo.CurrentUICulture, Resources.InconsistentComponentInfo, typeof(TInfo).Name, method.ToString("{0}")), de);
}
}
}
catch (Exception e)
{
form.Add(rule, method.ToString(Resources._0_Failed), new DataEntry(e));
}
finally
{
i.ReleaseComObject();
info.ReleaseComObject();
factory.ReleaseComObject();
}
}
public static void FillBlobFromBitmapSource(this IWICImagingFactory factory, IWICBitmapSource source, IntPtr blob, int bufferStride, int bufferSize, Guid imageFormat)
{
IWICBitmapSource iwicbitmapSource = factory.ConvertFormat(source, imageFormat);
iwicbitmapSource.FillBlobFromBitmapSource(blob, bufferStride, bufferSize);
GraphicsInteropNativeMethods.SafeReleaseComObject(iwicbitmapSource);
}
static Guid[] GetAllPixelFormats()
{
List <Guid> res = new List <Guid>();
IWICImagingFactory factory = (IWICImagingFactory) new WICImagingFactory();
IEnumUnknown eu = factory.CreateComponentEnumerator(WICComponentType.WICPixelFormat, WICComponentEnumerateOptions.WICComponentEnumerateRefresh);
int hr = 0;
object[] o = new object[1];
while (hr == 0)
{
uint fetched = 0;
hr = eu.Next(1, o, ref fetched);
if (fetched == 1)
{
IWICPixelFormatInfo info = (IWICPixelFormatInfo)o[0];
Guid guid;
info.GetFormatGUID(out guid);
res.Add(guid);
info.ReleaseComObject();
}
o.ReleaseComObject();
}
return(res.ToArray());
}
public static IWICBitmapDecoder CreateDecoderFromFileHandle(this IWICImagingFactory imagingFactory, IntPtr hFile, WICDecodeOptions metadataOptions, Guid?pguidVendor = null)
{
using (var pguidVendorPtr = CoTaskMemPtr.From(pguidVendor))
{
return(imagingFactory.CreateDecoderFromFileHandle(hFile, pguidVendorPtr, metadataOptions));
}
}
public static void Save(this IWICImagingFactory factory, IWICBitmapSource imageSource, IWICStream stream, Guid encoderId)
{
if (factory == null)
{
throw new ArgumentNullException("factory");
}
if (imageSource == null)
{
throw new ArgumentNullException("imageSource");
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
IWICBitmapEncoder iwicbitmapEncoder = factory.CreateEncoder(ref encoderId, null);
iwicbitmapEncoder.Initialize(stream, WICBitmapEncoderCacheOption.WICBitmapEncoderNoCache);
IWICBitmapFrameEncode iwicbitmapFrameEncode;
iwicbitmapEncoder.CreateNewFrame(out iwicbitmapFrameEncode, null);
iwicbitmapFrameEncode.Initialize(null);
iwicbitmapFrameEncode.WriteSource(imageSource, null);
iwicbitmapFrameEncode.Commit();
iwicbitmapEncoder.Commit();
GraphicsInteropNativeMethods.SafeReleaseComObject(iwicbitmapEncoder);
GraphicsInteropNativeMethods.SafeReleaseComObject(iwicbitmapFrameEncode);
}
private void DetectSalientRegions(IWICImagingFactory factory, IWICBitmapSource bitmapSource)
{
int num;
int num2;
bitmapSource.GetSize(out num, out num2);
int patchSize = Math.Max((num + num2) / 2 / 50, 4);
SaliencyMap saliencyMap = new SaliencyMap(new ArgbImage(factory, bitmapSource), patchSize, 1f);
this.TiledImage = saliencyMap.TiledImage;
float saliencyThreshold = this.SaliencyThreshold;
this.SalientObjects = SalientObjectAnalysis.GroupSalientTiles(this.TiledImage, ref saliencyThreshold, 8);
this.SaliencyThreshold = saliencyThreshold;
this.TotalSalience = 0f;
float num3 = -1f;
foreach (float num4 in from region in this.SalientObjects
select region.Region.Cluster.Mass)
{
float num5 = num4;
if (num3 < num5)
{
num3 = num5;
}
this.TotalSalience += num5;
}
foreach (SalientObject salientObject in this.SalientObjects)
{
salientObject.SaliencePortion = salientObject.Region.Cluster.Mass / this.TotalSalience;
salientObject.IsPrimary = (salientObject.Region.Cluster.Mass >= num3);
}
}
public static IWICBitmapDecoder CreateDecoderFromFilename(this IWICImagingFactory imagingFactory, string wzFilename, Guid?pguidVendor = null, WICDecodeOptions metadataOptions = WICDecodeOptions.WICDecodeMetadataCacheOnDemand)
{
using (var pguidVendorPtr = CoTaskMemPtr.From(pguidVendor))
{
return(imagingFactory.CreateDecoderFromFilename(wzFilename, pguidVendorPtr, StreamAccessMode.GENERIC_READ, metadataOptions));
}
}
public TestApplication(bool headless = false)
: base(headless)
{
using FileStream stream = File.OpenRead("Screenshot.jpg");
using var wicFactory = new IWICImagingFactory();
using IWICStream? wicStream = wicFactory.CreateStream(stream);
using IWICBitmapDecoder decoder = wicFactory.CreateDecoderFromStream(wicStream !);
}
internal static IWICImagingFactory GetImagingFactory()
{
if (ImagingFactory == null)
{
ImagingFactory = (IWICImagingFactory) new WICImagingFactory();
}
return(ImagingFactory);
}
public static IWICImagingFactory CreateImagingFactory()
{
if (factory == null)
{
factory = NativeMethods.WICCreateImagingFactory_Proxy(SDKVersion: 566U);
}
return(factory);
}
public static void Main()
{
var wicFactory = new IWICImagingFactory();
D2D1.D2D1CreateFactory(FactoryType.SingleThreaded, out ID2D1Factory d2dFactory);
const string fileName = "output.jpg";
const int width = 512;
const int height = 512;
var rectangleGeometry = d2dFactory.CreateRoundedRectangleGeometry(new RoundedRectangle(new RectangleF(128, 128, width - 128 * 2, height - 128 * 2), 32, 32));
var wicBitmap = wicFactory.CreateBitmap(width, height, Vortice.DirectX.WIC.PixelFormat.Format32bppBGR, BitmapCreateCacheOption.CacheOnLoad);
var renderTargetProperties = new RenderTargetProperties(new Vortice.DirectX.Direct2D.PixelFormat(Format.Unknown, Vortice.DirectX.Direct2D.AlphaMode.Unknown));
var d2dRenderTarget = d2dFactory.CreateWicBitmapRenderTarget(wicBitmap, renderTargetProperties);
var solidColorBrush = d2dRenderTarget.CreateSolidColorBrush(new Color4(1.0f));
d2dRenderTarget.BeginDraw();
d2dRenderTarget.Clear(new Color4(0.0f, 0.0f, 0.0f, 1.0f));
d2dRenderTarget.FillGeometry(rectangleGeometry, solidColorBrush, null);
d2dRenderTarget.EndDraw();
if (File.Exists(fileName))
{
File.Delete(fileName);
}
using (var stream = wicFactory.CreateStream())
{
stream.Initialize(fileName, FileAccess.Write);
// Initialize a Jpeg encoder with this stream
using (var encoder = wicFactory.CreateEncoder(ContainerFormat.Jpeg))
{
encoder.Initialize(stream);
// Create a Frame encoder
var props = new SharpGen.Runtime.Win32.PropertyBag(IntPtr.Zero);
var bitmapFrameEncode = encoder.CreateNewFrame(props);
bitmapFrameEncode.Initialize(null);
bitmapFrameEncode.SetSize(width, height);
var pixelFormatGuid = Vortice.DirectX.WIC.PixelFormat.FormatDontCare;
bitmapFrameEncode.SetPixelFormat(ref pixelFormatGuid);
bitmapFrameEncode.WriteSource(wicBitmap, null);
bitmapFrameEncode.Commit();
encoder.Commit();
}
}
using (var app = new TestApplication())
{
app.Run();
}
}
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();
}
}
private void LoadFromWic(IWICImagingFactory factory, IWICBitmapSource bitmapSource, Guid wicImageFormat)
{
int width;
int height;
bitmapSource.GetSize(out width, out height);
this.EnsureBuffer(width, height);
factory.FillBlobFromBitmapSource(bitmapSource, this.Image, wicImageFormat);
}
protected ImageBase(Stream stream, Guid wicImageFormat) : this()
{
IWICImagingFactory iwicimagingFactory = WicUtility.CreateFactory();
IWICBitmapFrameDecode iwicbitmapFrameDecode = iwicimagingFactory.Load(stream);
this.LoadFromWic(iwicimagingFactory, iwicbitmapFrameDecode, wicImageFormat);
GraphicsInteropNativeMethods.SafeReleaseComObject(iwicimagingFactory);
GraphicsInteropNativeMethods.SafeReleaseComObject(iwicbitmapFrameDecode);
}
private void Detect(ImageSource imageSource)
{
IWICImagingFactory iwicimagingFactory = WicUtility.CreateFactory();
IWICBitmapFrameDecode iwicbitmapFrameDecode = iwicimagingFactory.Load(imageSource.ImageStream);
this.DetectSalientRegions(iwicimagingFactory, iwicbitmapFrameDecode);
GraphicsInteropNativeMethods.SafeReleaseComObject(iwicbitmapFrameDecode);
GraphicsInteropNativeMethods.SafeReleaseComObject(iwicimagingFactory);
}
public static void Save(this IWICImagingFactory factory, IWICBitmapSource imageSource, string fileName)
{
if (factory == null)
{
throw new ArgumentNullException("factory");
}
if (imageSource == null)
{
throw new ArgumentNullException("imageSource");
}
if (fileName == null)
{
throw new ArgumentNullException("fileName");
}
string extension = Path.GetExtension(fileName);
if (string.IsNullOrEmpty(extension))
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "File name '{0}' does not have an extension so encoder type can not be determined.", new object[]
{
fileName
}));
}
Guid encoderId;
if (extension.Equals(".jpg", StringComparison.OrdinalIgnoreCase) || extension.Equals(".jpeg", StringComparison.OrdinalIgnoreCase))
{
encoderId = WicGuids.GUID_ContainerFormatJpeg;
}
else if (extension.Equals(".png", StringComparison.OrdinalIgnoreCase))
{
encoderId = WicGuids.GUID_ContainerFormatPng;
}
else if (extension.Equals(".bmp", StringComparison.OrdinalIgnoreCase))
{
encoderId = WicGuids.GUID_ContainerFormatBmp;
}
else
{
if (!extension.Equals(".tiff", StringComparison.OrdinalIgnoreCase))
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "File name '{0}' has extension {1} which we can't handle.", new object[]
{
fileName,
extension
}));
}
encoderId = WicGuids.GUID_ContainerFormatTiff;
}
IWICStream iwicstream;
factory.CreateStream(out iwicstream);
iwicstream.InitializeFromFilename(fileName, GenericAccess.GENERIC_WRITE);
factory.Save(imageSource, iwicstream, encoderId);
GraphicsInteropNativeMethods.SafeReleaseComObject(iwicstream);
}
public static IComObject <IWICBitmap> CreateBitmapFromHICON(this IWICImagingFactory factory, IntPtr iconHandle)
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
factory.CreateBitmapFromHICON(iconHandle, out var value).ThrowOnError();
return(new ComObject <IWICBitmap>(value));
}
public static IComObject <IWICBitmap> CreateBitmap(this IWICImagingFactory factory, int width, int height, Guid pixelFormat, WICBitmapCreateCacheOption option = WICBitmapCreateCacheOption.WICBitmapNoCache)
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
factory.CreateBitmap(width, height, pixelFormat, option, out var value).ThrowOnError();
return(new ComObject <IWICBitmap>(value));
}
public static IComObject <IWICBitmapScaler> CreateBitmapScaler(this IWICImagingFactory factory)
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
factory.CreateBitmapScaler(out var value).ThrowOnError();
return(new ComObject <IWICBitmapScaler>(value));
}
public static IComObject <IWICColorContext> CreateColorContext(this IWICImagingFactory factory)
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
factory.CreateColorContext(out var value).ThrowOnError();
return(new ComObject <IWICColorContext>(value));
}
private void InitializeDeviceIndependantResources()
{
m_wicImagingFactory = new WICImagingFactory() as IWICImagingFactory;
}
internal static IWICImagingFactory GetImagingFactory()
{
if (ImagingFactory == null)
ImagingFactory = (IWICImagingFactory)new WICImagingFactory();
return ImagingFactory;
}
