diff --git a/src/Generator/Program.cs b/src/Generator/Program.cs index 64abd67..f71ef9b 100644 --- a/src/Generator/Program.cs +++ b/src/Generator/Program.cs @@ -21,7 +21,7 @@ public static class Program "Graphics.Direct3D12.json", "Graphics.Direct3D.Dxc.json", "Graphics.Direct2D.Common.json", - //"Graphics.Imaging.json", + "Graphics.Imaging.json", //"Graphics.DirectWrite.json", }; @@ -68,6 +68,11 @@ public static class Program { "System.Com.ISequentialStream", "Com.ISequentialStream" }, { "System.Com.IStream", "Com.IStream" }, { "System.Com.IMalloc", "Com.IMalloc" }, + { "System.Com.IEnumUnknown", "Com.IEnumUnknown" }, + { "System.Com.IEnumString", "Com.IEnumString" }, + { "System.Com.StructuredStorage.PROPVARIANT", "Com.Variant" }, + { "System.Com.StructuredStorage.PROPBAG2", "Com.PropertyBagMetadata" }, + { "System.Com.StructuredStorage.IPropertyBag2", "Com.IPropertyBag2" }, { "Graphics.Gdi.HMONITOR", "IntPtr" }, { "Graphics.Gdi.HDC", "IntPtr" }, @@ -599,6 +604,10 @@ public static class Program "InvalidNumRenderTargets", "SetRenderTargets", "CreateSharedResource", + "ExifColorSpace", + "NoCache", + "CacheOnDemand", + "CacheOnLoad", }; private static readonly HashSet s_preserveCaps = new(StringComparer.OrdinalIgnoreCase) @@ -677,6 +686,11 @@ public static class Program // Dxc { "DXC_OUT_KIND", "DXC_OUT" }, + + // WIC + { "WICColorContextType", "WICColorContext" }, + { "WICBitmapCreateCacheOption", "WICBitmap" }, + { "WICDecodeOptions", "WICDecodeMetadata" }, }; private static readonly Dictionary s_knownEnumValueNames = new() @@ -817,6 +831,9 @@ public static class Program { "IDxcValidator2::ValidateWithDebug::Flags", "DxcValidatorFlags" }, { "IDxcVersionInfo::GetFlags::pFlags", "DxcVersionInfoFlags" }, { "IDxcVersionInfo2::GetFlags::pFlags", "DxcVersionInfoFlags" }, + + // WIC + { "IWICImagingFactory::CreateDecoderFromFilename::dwDesiredAccess", "NativeFileAccess" }, }; private static readonly HashSet s_visitedEnums = new(); @@ -851,6 +868,7 @@ public static class Program } // Generate docs + //DocGenerator.Generate(new[] { "WIC" }, Path.Combine(outputPath, "Imaging.xml")); //DocGenerator.Generate(new[] { "DWRITE" }, Path.Combine(outputPath, "DirectWrite.xml")); //DocGenerator.Generate(new[] { "D3D" }, Path.Combine(outputPath, "Direct3D.xml")); //DocGenerator.Generate(new[] { "DXGI" }, Path.Combine(outputPath, "Dxgi.xml")); @@ -1119,6 +1137,15 @@ public static class Program continue; } + // PROPVARIANT + //if (comType.Name == "IWICEnumMetadataItem" || + // comType.Name == "IWICMetadataReader" || + // comType.Name == "IWICMetadataBlockReader" || + // comType.Name == "IWICMetadataBlockWriter") + //{ + // continue; + //} + if (!regionWritten) { writer.WriteLine("#region COM Types"); @@ -1259,9 +1286,25 @@ public static class Program private static void GenerateEnum(CodeWriter writer, ApiType enumType, bool autoGenerated) { - string csTypeName = GetDataTypeName(enumType.Name, out string enumPrefix); + string csTypeName; + string enumPrefix = string.Empty; + + if (enumType.Name.StartsWith("WIC")) + { + csTypeName = enumType.Name; + + if (s_knownTypesPrefixes.TryGetValue(enumType.Name, out string? knowPrefix)) + { + enumPrefix = knowPrefix!; + } + } + else + { + csTypeName = GetDataTypeName(enumType.Name, out enumPrefix); + AddCsMapping(writer.Api, enumType.Name, csTypeName); + } + string baseTypeName = GetTypeName(enumType.IntegerBase); - AddCsMapping(writer.Api, enumType.Name, csTypeName); if (!autoGenerated) { @@ -1300,6 +1343,11 @@ public static class Program baseTypeName = "byte"; } + if (enumType.Name == "WICColorContextType") + { + + } + using (writer.PushBlock($"public enum {csTypeName} : {baseTypeName}")) { if (isFlags && @@ -1360,6 +1408,11 @@ public static class Program private static string GetEnumItemName(ApiType enumType, ApiEnumValue enumItem, string enumPrefix) { + if (string.IsNullOrEmpty(enumPrefix)) + { + return enumItem.Name; + } + string enumValueName = GetPrettyFieldName(enumItem.Name, enumPrefix); // D3D11 has some enum name "issues" @@ -1635,7 +1688,6 @@ public static class Program List> methodsToGenerate) { string csTypeName = comType.Name; - //AddCsMapping(writer.Api, comType.Name, csTypeName); writer.WriteLine($"/// "); @@ -1719,8 +1771,14 @@ public static class Program vtblIndex = 3; } + bool needNewLine = false; foreach (KeyValuePair methodPair in methodsToGenerate) { + if (needNewLine) + { + writer.WriteLine(); + } + ApiFunction method = methodPair.Key; string docName = methodPair.Value; @@ -1738,7 +1796,7 @@ public static class Program string parameterType = string.Empty; - if (method.Name == "Compile" && parameter.Name == "pArguments") + if (method.Name == "GetFrame" && parameter.Name == "ppIBitmapFrame") { } @@ -1787,6 +1845,13 @@ public static class Program parameterType += "*"; } } + else if (parameter.Attrs.Any(item => item is string str && str == "RetVal")) + { + if (!IsPrimitive(parameter.Type)) + { + parameterType += "*"; + } + } parameterName = CleanupName(parameterName); @@ -1858,8 +1923,8 @@ public static class Program writer.Write("return "); writer.WriteLine($"((delegate* unmanaged[Stdcall]<{comType.Name}*, {argumentTypesString}>)(lpVtbl[{vtblIndex}]))(({comType.Name}*)Unsafe.AsPointer(ref this){argumentNamesString});"); } - writer.WriteLine(); + needNewLine = true; vtblIndex++; } } diff --git a/src/Vortice.Win32/Com/IEnumString.cs b/src/Vortice.Win32/Com/IEnumString.cs new file mode 100644 index 0000000..30b180f --- /dev/null +++ b/src/Vortice.Win32/Com/IEnumString.cs @@ -0,0 +1,94 @@ +// Copyright © Amer Koleci and Contributors. +// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information. + +using System.Diagnostics; +using System.Runtime.CompilerServices; + +namespace Win32.Com; + +[Guid("00000101-0000-0000-C000-000000000046")] +[NativeTypeName("struct IEnumString : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IEnumString +{ + public static ref readonly Guid IID_IEnumString + { + get + { + ReadOnlySpan data = new byte[] { + 0x01, 0x01, 0x00, 0x00, + 0x00, 0x00, + 0x00, 0x00, + 0xC0, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x46 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IEnumString)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((ISequentialStream*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((ISequentialStream*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((ISequentialStream*)Unsafe.AsPointer(ref this)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult Next([NativeTypeName("ULONG")] uint celt, [NativeTypeName("LPOLESTR *")] ushort** rgelt, [NativeTypeName("ULONG *")] uint* pceltFetched) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IEnumString*)Unsafe.AsPointer(ref this), celt, rgelt, pceltFetched); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult Skip([NativeTypeName("ULONG")] uint celt) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IEnumString*)Unsafe.AsPointer(ref this), celt); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult Reset() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IEnumString*)Unsafe.AsPointer(ref this)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult Clone(IEnumString** ppenum) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IEnumString*)Unsafe.AsPointer(ref this), ppenum); + } +} diff --git a/src/Vortice.Win32/Com/IEnumUnknown.cs b/src/Vortice.Win32/Com/IEnumUnknown.cs new file mode 100644 index 0000000..c0d0915 --- /dev/null +++ b/src/Vortice.Win32/Com/IEnumUnknown.cs @@ -0,0 +1,95 @@ +// Copyright © Amer Koleci and Contributors. +// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information. + +using System.Diagnostics; +using System.Runtime.CompilerServices; + +namespace Win32.Com; + +[Guid("00000100-0000-0000-C000-000000000046")] +[NativeTypeName("struct IEnumUnknown : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IEnumUnknown +{ + public static ref readonly Guid IID_IEnumUnknown + { + get + { + ReadOnlySpan data = new byte[] { + 0x00, 0x01, 0x00, 0x00, + 0x00, 0x00, + 0x00, 0x00, + 0xC0, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x46 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IEnumUnknown)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((ISequentialStream*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((ISequentialStream*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((ISequentialStream*)Unsafe.AsPointer(ref this)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult Next([NativeTypeName("ULONG")] uint celt, IUnknown** rgelt, [NativeTypeName("ULONG *")] uint* pceltFetched) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IEnumUnknown*)Unsafe.AsPointer(ref this), celt, rgelt, pceltFetched); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult Skip([NativeTypeName("ULONG")] uint celt) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IEnumUnknown*)Unsafe.AsPointer(ref this), celt); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult Reset() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IEnumUnknown*)Unsafe.AsPointer(ref this)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult Clone(IEnumUnknown** ppenum) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IEnumUnknown*)Unsafe.AsPointer(ref this), ppenum); + } +} diff --git a/src/Vortice.Win32/Com/IErrorLog.cs b/src/Vortice.Win32/Com/IErrorLog.cs new file mode 100644 index 0000000..eae7791 --- /dev/null +++ b/src/Vortice.Win32/Com/IErrorLog.cs @@ -0,0 +1,74 @@ +// Copyright © Amer Koleci and Contributors. +// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information. + +using System.Diagnostics; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices.ComTypes; + +namespace Win32.Com; + +[Guid("3127CA40-446E-11CE-8135-00AA004BB851")] +[NativeTypeName("struct IErrorLog : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IErrorLog +{ + public static ref readonly Guid IID_IErrorLog + { + get + { + ReadOnlySpan data = new byte[] { + 0x40, 0xCA, 0x27, 0x31, + 0x6E, 0x44, + 0xCE, 0x11, + 0x81, + 0x35, + 0x00, + 0xAA, + 0x00, + 0x4B, + 0xB8, + 0x51 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IErrorLog)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((ISequentialStream*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((ISequentialStream*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((ISequentialStream*)Unsafe.AsPointer(ref this)); + } + + //[MethodImpl(MethodImplOptions.AggressiveInlining)] + //[VtblIndex(3)] + //public HResult AddError([NativeTypeName("LPCOLESTR")] ushort* pszPropName, EXCEPINFO* pExcepInfo) + //{ + // return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IErrorLog*)Unsafe.AsPointer(ref this), pszPropName, pExcepInfo); + //} +} diff --git a/src/Vortice.Win32/Com/IMalloc.cs b/src/Vortice.Win32/Com/IMalloc.cs index 0049b5b..42b0ace 100644 --- a/src/Vortice.Win32/Com/IMalloc.cs +++ b/src/Vortice.Win32/Com/IMalloc.cs @@ -78,7 +78,6 @@ public unsafe partial struct IMalloc return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IMalloc*)Unsafe.AsPointer(ref this), pv, cb); } - /// [MethodImpl(MethodImplOptions.AggressiveInlining)] [VtblIndex(5)] public void Free(void* pv) diff --git a/src/Vortice.Win32/Com/IPropertyBag2.cs b/src/Vortice.Win32/Com/IPropertyBag2.cs new file mode 100644 index 0000000..61e211a --- /dev/null +++ b/src/Vortice.Win32/Com/IPropertyBag2.cs @@ -0,0 +1,100 @@ +// Copyright © Amer Koleci and Contributors. +// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information. + +using System.Diagnostics; +using System.Runtime.CompilerServices; + +namespace Win32.Com; + +[Guid("22F55882-280B-11D0-A8A9-00A0C90C2004")] +[NativeTypeName("struct IPropertyBag2 : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IPropertyBag2 +{ + public static ref readonly Guid IID_IPropertyBag2 + { + get + { + ReadOnlySpan data = new byte[] { + 0x82, 0x58, 0xF5, 0x22, + 0x0B, 0x28, + 0xD0, 0x11, + 0xA8, + 0xA9, + 0x00, + 0xA0, + 0xC9, + 0x0C, + 0x20, + 0x04 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IPropertyBag2)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((ISequentialStream*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((ISequentialStream*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((ISequentialStream*)Unsafe.AsPointer(ref this)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult Read(uint cProperties, PropertyBagMetadata* pPropBag, IErrorLog* pErrLog, Variant* pvarValue, HResult* phrError) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IPropertyBag2*)Unsafe.AsPointer(ref this), cProperties, pPropBag, pErrLog, pvarValue, phrError); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult Write([NativeTypeName("ULONG")] uint cProperties, PropertyBagMetadata* pPropBag, Variant* pvarValue) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IPropertyBag2*)Unsafe.AsPointer(ref this), cProperties, pPropBag, pvarValue); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult CountProperties(uint* pcProperties) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IPropertyBag2*)Unsafe.AsPointer(ref this), pcProperties); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetPropertyInfo(uint iProperty, uint cProperties, PropertyBagMetadata* pPropBag, uint* pcProperties) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IPropertyBag2*)Unsafe.AsPointer(ref this), iProperty, cProperties, pPropBag, pcProperties); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult LoadObject(ushort* pstrName, uint dwHint, IUnknown* pUnkObject, IErrorLog* pErrLog) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IPropertyBag2*)Unsafe.AsPointer(ref this), pstrName, dwHint, pUnkObject, pErrLog); + } +} diff --git a/src/Vortice.Win32/Com/IStream.cs b/src/Vortice.Win32/Com/IStream.cs index 3766a47..ac1650b 100644 --- a/src/Vortice.Win32/Com/IStream.cs +++ b/src/Vortice.Win32/Com/IStream.cs @@ -115,21 +115,19 @@ public unsafe partial struct IStream return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IStream*)Unsafe.AsPointer(ref this)); } - ///// - //[MethodImpl(MethodImplOptions.AggressiveInlining)] - //[VtblIndex(10)] - //public HRESULT LockRegion(ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, [NativeTypeName("DWORD")] uint dwLockType) - //{ - // return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IStream*)Unsafe.AsPointer(ref this), libOffset, cb, dwLockType); - //} + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult LockRegion(ULargeInterger libOffset, ULargeInterger cb, [NativeTypeName("DWORD")] uint dwLockType) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IStream*)Unsafe.AsPointer(ref this), libOffset, cb, dwLockType); + } - ///// - //[MethodImpl(MethodImplOptions.AggressiveInlining)] - //[VtblIndex(11)] - //public HRESULT UnlockRegion(ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, [NativeTypeName("DWORD")] uint dwLockType) - //{ - // return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IStream*)Unsafe.AsPointer(ref this), libOffset, cb, dwLockType); - //} + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult UnlockRegion(ULargeInterger libOffset, ULargeInterger cb, [NativeTypeName("DWORD")] uint dwLockType) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IStream*)Unsafe.AsPointer(ref this), libOffset, cb, dwLockType); + } ///// //[MethodImpl(MethodImplOptions.AggressiveInlining)] diff --git a/src/Vortice.Win32/Com/PropertyBagMetadata.cs b/src/Vortice.Win32/Com/PropertyBagMetadata.cs new file mode 100644 index 0000000..cd57a4c --- /dev/null +++ b/src/Vortice.Win32/Com/PropertyBagMetadata.cs @@ -0,0 +1,34 @@ +// Copyright © Amer Koleci and Contributors. +// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information. + +using static Win32.StringUtilities; + +namespace Win32.Com; + +public enum PropertyBagMetadataType +{ + Undefined, + Data, + Url, + Object, + Stream, + Storage, + Moniker +} + +/// PROPBAG2 +[NativeTypeName("struct PROPBAG2")] +public unsafe partial struct PropertyBagMetadata +{ + public PropertyBagMetadataType Type; + public VariantFullType VariantType; + public ushort ClipboardFormat; + public uint Hint; + public ushort* pstrName; + public Guid ClassId; + + public readonly string? GetName() + { + return GetString(pstrName); + } +} diff --git a/src/Vortice.Win32/Com/Variant.cs b/src/Vortice.Win32/Com/Variant.cs new file mode 100644 index 0000000..47a498f --- /dev/null +++ b/src/Vortice.Win32/Com/Variant.cs @@ -0,0 +1,391 @@ +// Copyright © Amer Koleci and Contributors. +// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information. + +using System.Globalization; + +namespace Win32.Com; + +/// +/// Variant COM. +/// +/// PROPVARIANT +[NativeTypeName("struct PROPVARIANT")] +public unsafe partial struct Variant +{ + private VariantFullType vt; + private ushort reserved1; + private ushort reserved2; + private ushort reserved3; + private VariantValue variantValue; + + /// + /// Gets the type of the element. + /// + /// + /// The type of the element. + /// + public VariantElementType ElementType + { + get => vt.ElementType; + set => vt = new(value, vt.Type); + } + + /// + /// Gets the type. + /// + public VariantType Type + { + get => vt.Type; + set => vt = new(vt.ElementType, value); + } + +#if TODO + /// + /// Gets or sets the value. + /// + /// + /// The value. + /// + public unsafe object Value + { + get + { + switch (Type) + { + case VariantType.Default: + switch (ElementType) + { + case VariantElementType.Empty: + case VariantElementType.Null: + return null; + case VariantElementType.Blob: + { + var buffer = new byte[(int)variantValue.recordValue.RecordInfo]; + if (buffer.Length > 0) + { + MemoryHelpers.Read(variantValue.recordValue.RecordPointer, buffer, + buffer.Length); + } + + return buffer; + } + case VariantElementType.Bool: + return variantValue.intValue != 0; + case VariantElementType.Byte: + return variantValue.signedByteValue; + case VariantElementType.UByte: + return variantValue.byteValue; + case VariantElementType.UShort: + return variantValue.ushortValue; + case VariantElementType.Short: + return variantValue.shortValue; + case VariantElementType.UInt: + case VariantElementType.UInt1: + return variantValue.uintValue; + case VariantElementType.Int: + case VariantElementType.Int1: + return variantValue.intValue; + case VariantElementType.ULong: + return variantValue.ulongValue; + case VariantElementType.Long: + return variantValue.longValue; + case VariantElementType.Float: + return variantValue.floatValue; + case VariantElementType.Double: + return variantValue.doubleValue; + case VariantElementType.BinaryString: + throw new NotSupportedException(); + case VariantElementType.StringPointer: + return Marshal.PtrToStringAnsi(variantValue.pointerValue); + case VariantElementType.WStringPointer: + return Marshal.PtrToStringUni(variantValue.pointerValue); + case VariantElementType.ComUnknown: + case VariantElementType.Dispatch: + return new ComObject(variantValue.pointerValue); + case VariantElementType.IntPointer: + case VariantElementType.Pointer: + return variantValue.pointerValue; + case VariantElementType.FileTime: + return DateTime.FromFileTime(variantValue.longValue); + default: + return null; + } + case VariantType.Vector: + var size = (int)variantValue.recordValue.RecordInfo; + var recordValuePointer = variantValue.recordValue.RecordPointer; + switch (ElementType) + { + case VariantElementType.Bool: + { + Span span = stackalloc Bool32[size]; + MemoryHelpers.Read(recordValuePointer, span, size); + return BooleanHelpers.ConvertToBoolArray(span); + } + case VariantElementType.Byte: + { + var array = new sbyte[size]; + MemoryHelpers.Read(recordValuePointer, array, size); + return array; + } + case VariantElementType.UByte: + { + var array = new byte[size]; + MemoryHelpers.Read(recordValuePointer, array, size); + return array; + } + case VariantElementType.UShort: + { + var array = new ushort[size]; + MemoryHelpers.Read(recordValuePointer, array, size); + return array; + } + case VariantElementType.Short: + { + var array = new short[size]; + MemoryHelpers.Read(recordValuePointer, array, size); + return array; + } + case VariantElementType.UInt: + case VariantElementType.UInt1: + { + var array = new uint[size]; + MemoryHelpers.Read(recordValuePointer, array, size); + return array; + } + case VariantElementType.Int: + case VariantElementType.Int1: + { + var array = new int[size]; + MemoryHelpers.Read(recordValuePointer, array, size); + return array; + } + case VariantElementType.ULong: + { + var array = new ulong[size]; + MemoryHelpers.Read(recordValuePointer, array, size); + return array; + } + case VariantElementType.Long: + { + var array = new long[size]; + MemoryHelpers.Read(recordValuePointer, array, size); + return array; + } + case VariantElementType.Float: + { + var array = new float[size]; + MemoryHelpers.Read(recordValuePointer, array, size); + return array; + } + case VariantElementType.Double: + { + var array = new double[size]; + MemoryHelpers.Read(recordValuePointer, array, size); + return array; + } + case VariantElementType.BinaryString: + { + throw new NotSupportedException(); + } + case VariantElementType.StringPointer: + { + var array = new string[size]; + for (var i = 0; i < size; i++) + array[i] = Marshal.PtrToStringAnsi( + ((IntPtr*)recordValuePointer)[i] + ); + return array; + } + case VariantElementType.WStringPointer: + { + var array = new string[size]; + for (var i = 0; i < size; i++) + array[i] = Marshal.PtrToStringUni( + ((IntPtr*)recordValuePointer)[i] + ); + return array; + } + case VariantElementType.ComUnknown: + case VariantElementType.Dispatch: + { + var comArray = new ComObject[size]; + for (var i = 0; i < size; i++) + comArray[i] = new ComObject(((IntPtr*)recordValuePointer)[i]); + return comArray; + } + case VariantElementType.IntPointer: + case VariantElementType.Pointer: + { + var array = new IntPtr[size]; + MemoryHelpers.Read(recordValuePointer, array, size); + return array; + } + case VariantElementType.FileTime: + { + var fileTimeArray = new DateTime[size]; + for (var i = 0; i < size; i++) + fileTimeArray[i] = + DateTime.FromFileTime(((long*)recordValuePointer)[i]); + return fileTimeArray; + } + default: + return null; + } + } + + return null; + } + set + { + if (value == null) + { + Type = VariantType.Default; + ElementType = VariantElementType.Null; + return; + } + + var type = value.GetType(); + + Type = VariantType.Default; + if (type.GetType().IsPrimitive) + { + if (type == typeof(byte)) + { + ElementType = VariantElementType.UByte; + variantValue.byteValue = (byte)value; + return; + } + + if (type == typeof(sbyte)) + { + ElementType = VariantElementType.Byte; + variantValue.signedByteValue = (sbyte)value; + return; + } + + if (type == typeof(int)) + { + ElementType = VariantElementType.Int; + variantValue.intValue = (int)value; + return; + } + + if (type == typeof(uint)) + { + ElementType = VariantElementType.UInt; + variantValue.uintValue = (uint)value; + return; + } + + if (type == typeof(long)) + { + ElementType = VariantElementType.Long; + variantValue.longValue = (long)value; + return; + } + + if (type == typeof(ulong)) + { + ElementType = VariantElementType.ULong; + variantValue.ulongValue = (ulong)value; + return; + } + + if (type == typeof(short)) + { + ElementType = VariantElementType.Short; + variantValue.shortValue = (short)value; + return; + } + + if (type == typeof(ushort)) + { + ElementType = VariantElementType.UShort; + variantValue.ushortValue = (ushort)value; + return; + } + + if (type == typeof(float)) + { + ElementType = VariantElementType.Float; + variantValue.floatValue = (float)value; + return; + } + + if (type == typeof(double)) + { + ElementType = VariantElementType.Double; + variantValue.doubleValue = (double)value; + return; + } + } + else + { + switch (value) + { + case ComObject obj: + ElementType = VariantElementType.ComUnknown; + variantValue.pointerValue = obj.NativePointer; + return; + case DateTime dateTime: + ElementType = VariantElementType.FileTime; + variantValue.longValue = dateTime.ToFileTime(); + return; + case string str: + ElementType = VariantElementType.WStringPointer; + variantValue.pointerValue = Marshal.StringToCoTaskMemUni(str); + return; + } + } + + throw new ArgumentException( + string.Format(CultureInfo.InvariantCulture, "Type [{0}] is not handled", type.Name) + ); + } + } +#endif + + [StructLayout(LayoutKind.Explicit)] + private struct VariantValue + { + [FieldOffset(0)] public sbyte signedByteValue; + [FieldOffset(0)] public byte byteValue; + [FieldOffset(0)] public short shortValue; + [FieldOffset(0)] public ushort ushortValue; + [FieldOffset(0)] public int intValue; + [FieldOffset(0)] public uint uintValue; + [FieldOffset(0)] public long longValue; + [FieldOffset(0)] public ulong ulongValue; + [FieldOffset(0)] public LargeInterger largeIntergerValue; + [FieldOffset(0)] public ULargeInterger ulargeIntergerValue; + [FieldOffset(0)] public float floatValue; + [FieldOffset(0)] public double doubleValue; + [FieldOffset(0)] public short boolValue; + [FieldOffset(0)] public IntPtr pointerValue; + [FieldOffset(0)] public IUnknown* unkownValue; + [FieldOffset(0)] public IStream* pStream; + [FieldOffset(0)] public CurrencyValue currencyValue; + [FieldOffset(0)] public RecordValue recordValue; + + [StructLayout(LayoutKind.Sequential)] + public struct CurrencyLowHigh + { + public uint LowValue; + public int HighValue; + } + + [StructLayout(LayoutKind.Explicit)] + public struct CurrencyValue + { + [FieldOffset(0)] public CurrencyLowHigh LowHigh; + [FieldOffset(0)] public long longValue; + } + + [StructLayout(LayoutKind.Sequential)] + public struct RecordValue + { + public IntPtr RecordInfo; + public IntPtr RecordPointer; + } + } +} diff --git a/src/Vortice.Win32/Com/VariantElementType.cs b/src/Vortice.Win32/Com/VariantElementType.cs new file mode 100644 index 0000000..9ad250b --- /dev/null +++ b/src/Vortice.Win32/Com/VariantElementType.cs @@ -0,0 +1,56 @@ +// Copyright © Amer Koleci and Contributors. +// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information. + +namespace Win32.Com; + +/// +/// Type of a simple variant value. +/// +public enum VariantElementType : ushort +{ + Empty = 0, + Null = 1, + Short = 2, + Int = 3, + Float = 4, + Double = 5, + Currency = 6, + Date = 7, + BinaryString = 8, + Dispatch = 9, + Error = 10, + Bool = 11, + Variant = 12, + ComUnknown = 13, + Decimal = 14, + Byte = 16, + UByte = 17, + UShort = 18, + UInt = 19, + Long = 20, + ULong = 21, + Int1 = 22, + UInt1 = 23, + Void = 24, + Result = 25, + Pointer = 26, + SafeArray = 27, + ConstantArray = 28, + UserDefined = 29, + StringPointer = 30, + WStringPointer = 31, + Recor = 36, + IntPointer = 37, + UIntPointer = 38, + FileTime = 64, + Blob = 65, + Stream = 66, + Storage = 67, + StreamedObject = 68, + StoredObject = 69, + BlobObject = 70, + ClipData = 71, + Clsid = 72, + VersionedStream = 73, + BinaryStringBlob = 0xfff, +} diff --git a/src/Vortice.Win32/Com/VariantFullType.cs b/src/Vortice.Win32/Com/VariantFullType.cs new file mode 100644 index 0000000..171e461 --- /dev/null +++ b/src/Vortice.Win32/Com/VariantFullType.cs @@ -0,0 +1,40 @@ +// Copyright © Amer Koleci and Contributors. +// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information. + +using System.Diagnostics; +using System.Runtime.CompilerServices; + +namespace Win32.Com; + +/// +/// Type of a variant +/// +[StructLayout(LayoutKind.Sequential)] +public readonly struct VariantFullType : IEquatable +{ + private readonly ushort vt; + + public VariantElementType ElementType => (VariantElementType)(vt & 0x0fff); + public VariantType Type => (VariantType)(vt & 0xf000); + + public VariantFullType(short value) => vt = unchecked((ushort)value); + public VariantFullType(ushort value) => vt = value; + + public static implicit operator short(VariantFullType value) => unchecked((short)value.vt); + public static implicit operator ushort(VariantFullType value) => value.vt; + public static implicit operator VariantFullType(short value) => new(value); + public static implicit operator VariantFullType(ushort value) => new(value); + + public VariantFullType(VariantElementType elementType, VariantType type) + { + vt = (ushort)((ushort)type | (ushort)elementType); + } + + public bool Equals(VariantFullType other) => vt == other.vt; + public override bool Equals(object obj) => obj is VariantFullType other && Equals(other); + public override int GetHashCode() => vt.GetHashCode(); + public static bool operator ==(VariantFullType left, VariantFullType right) => left.Equals(right); + public static bool operator !=(VariantFullType left, VariantFullType right) => !left.Equals(right); + + public override string ToString() => $"{ElementType} {Type}"; +} diff --git a/src/Vortice.Win32/Com/VariantType.cs b/src/Vortice.Win32/Com/VariantType.cs new file mode 100644 index 0000000..b7da954 --- /dev/null +++ b/src/Vortice.Win32/Com/VariantType.cs @@ -0,0 +1,36 @@ +// Copyright © Amer Koleci and Contributors. +// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information. + +namespace Win32.Com; + +/// +/// Type of a variant +/// +[Flags] +public enum VariantType : ushort +{ + /// + /// Simple value + /// + Default = 0x0000, + + /// + /// Vector value. + /// + Vector = 0x1000, + + /// + /// Array value. + /// + Array = 0x2000, + + /// + /// By reference. + /// + ByRef = 0x4000, + + /// + /// Reserved value. + /// + Reserved = 0x8000, +} diff --git a/src/Vortice.Win32/Generated/DirectWrite.xml b/src/Vortice.Win32/Generated/DirectWrite.xml new file mode 100644 index 0000000..4384cb3 --- /dev/null +++ b/src/Vortice.Win32/Generated/DirectWrite.xml @@ -0,0 +1,3307 @@ + + + + + Indicates how much any visible DIPs (device independent pixels) overshoot each side of the layout or inline objects. + Microsoft Docs: + + + + The distance from the left-most visible DIP to its left-alignment edge. + + + The distance from the top-most visible DIP to its top alignment edge. + + + The distance from the right-most visible DIP to its right-alignment edge. + + + The distance from the bottom-most visible DIP to its lower-alignment edge. + + + + Identifies a string in a font. + Microsoft Docs: + + + + Unspecified font property identifier. + + + The full name of the font, for example "Arial Bold", from name id 4 in the name table. + + + GDI-compatible family name. Because GDI allows a maximum of four fonts per family, fonts in the same family may have different GDI-compatible family names, + for example "Arial", "Arial Narrow", "Arial Black". + + + The postscript name of the font, for example "GillSans-Bold", from name id 6 in the name table. + + + Script/language tag to identify the scripts or languages that the font was primarily designed to support. + + + Script/language tag to identify the scripts or languages that the font declares it is able to support. + + + Semantic tag to describe the font, for example Fancy, Decorative, Handmade, Sans-serif, Swiss, Pixel, Futuristic. + + + Weight of the font represented as a decimal string in the range 1-999. + + + Stretch of the font represented as a decimal string in the range 1-9. + + + Style of the font represented as a decimal string in the range 0-2. + + + Total number of properties. + + + Family name preferred by the designer. This enables font designers to group more than four fonts in a single family without losing compatibility with + GDI. This name is typically only present if it differs from the GDI-compatible family name. + + + Family name for the weight-width-slope model. + + + Face name of the font, for example Regular or Bold. + + + + Specifies the word wrapping to be used in a particular multiline paragraph. + Microsoft Docs: + + + + Indicates that words are broken across lines to avoid text overflowing the layout box. + + + Indicates that words are kept within the same line even when it overflows the layout box. This option is often used with scrolling to reveal overflow text. + + +
Note  Windows 8.1 and later only.
+
 
+Words are broken across lines to avoid text overflowing the layout box. + Emergency wrapping occurs if the word is larger than the maximum width. + + +
Note  Windows 8.1 and later only.
+
 
+When emergency wrapping, only wrap whole words, never breaking words when the layout width is too small for even a single word. + + +
Note  Windows 8.1 and later only.
+
 
+Wrap between any valid character clusters. + + + + Defines constants that specify the mechanism by which a font came to be included in a font set. + Microsoft Docs: + + + + Specifies that the font source is unknown, or is not any of the other defined font source types. + + + Specifies that the font source is a font file that's installed for all users on the device. + + + Specifies that the font source is a font file that's installed for the current user. + + + Specifies that the font source is an APPX package, which includes one or more font files. The font source name is the full name of the package. + + + Specifies that the font source is a font provider for downloadable fonts. + + + + Represents the internal structure of a device pixel (that is, the physical arrangement of red, green, and blue color components) that is assumed for purposes of rendering text. + Microsoft Docs: + + + + The red, green, and blue color components of each pixel are assumed to occupy the same point. + + + Each pixel is composed of three vertical stripes, with red on the left, green in the center, and + blue on the right. This is the most common pixel geometry for LCD monitors. + + + Each pixel is composed of three vertical stripes, with blue on the left, green in the center, and + red on the right. + + + + Defines constants that specify attributes for a font axis. + Microsoft Docs: + + + + Specifies no attributes. + + + Specifies that this axis is implemented as a variation axis in a variable font, with a continuous range of values, such as a range of weights from 100..900. Otherwise, it is either a static axis that holds a single point, or it has a range but doesn't vary, such as optical size in the Skia Heading font (which covers a range of points but doesn't interpolate any new glyph outlines). + + + Specifies that this axis is recommended to be remain hidden in user interfaces. The font developer may recommend this if an axis is intended to be accessed only programmatically, or is meant for font-internal or font-developer use only. The axis may be exposed in lower-level font inspection utilities, but should not be exposed in common nor even advanced-mode user interfaces in content-authoring apps. + + + + Contains a set of typographic features to be applied during text shaping. + Microsoft Docs: + + + + A pointer to a structure that specifies properties used to identify and execute typographic features in the font. + + + A value that indicates the number of features being applied to a font face. + + + + The type of a font represented by a single font file. Font formats that consist of multiple files, for example Type 1 .PFM and .PFB, have separate enum values for each of the file types. + Microsoft Docs: + + + + Font type is not recognized by the DirectWrite font system. + + + OpenType font with CFF outlines. + + + OpenType font with TrueType outlines. + + + Type 1 PFM font. + + + Type 1 PFB font. + + + Vector .FON font. + + + Bitmap .FON font. + + + OpenType font that contains a TrueType collection. + + + + The DWRITE_PANOSE_XASCENT enumeration contains values that specify the relative size of the lowercase letters. + Microsoft Docs: + + + + Any xascent. + + + No fit for xascent. + + + Very low xascent. + + + Low xascent. + + + Medium xascent. + + + High xascent. + + + Very high xascent. + + + + Specifies the type of DirectWrite factory object. + Microsoft Docs: + + + + Indicates that the DirectWrite factory is a shared factory and that it allows for the reuse of cached font data across multiple in-process components. Such factories also take advantage of cross process font caching components for better performance. + + + Indicates that the DirectWrite factory object is isolated. Objects created from the isolated factory do not interact with internal DirectWrite state from other components. + + + + The DWRITE_PANOSE_DECORATIVE_CLASS enumeration contains values that specify the general look of the character face. + Microsoft Docs: + + + + Any class of decorative typeface. + + + No fit for decorative typeface. + + + Derivative decorative typeface. + + + Nonstandard topology decorative typeface. + + + Nonstandard elements decorative typeface. + + + Nonstandard aspect decorative typeface. + + + Initials decorative typeface. + + + Cartoon decorative typeface. + + + Picture stems decorative typeface. + + + Ornamented decorative typeface. + + + Text and background decorative typeface. + + + Collage decorative typeface. + + + Montage decorative typeface. + + + + The DWRITE_PANOSE_CHARACTER_RANGES enumeration contains values that specify the type of characters available in the font. + Microsoft Docs: + + + + Any range. + + + No fit for range. + + + The range includes extended collection. + + + The range includes literals. + + + The range doesn't include lower case. + + + The range includes small capitals. + + + + The DWRITE_PANOSE_FAMILY enumeration contains values that specify the kind of typeface classification. + Microsoft Docs: + + + + Any typeface classification. + + + No fit typeface classification. + + + Text display typeface classification. + + + Script (or hand written) typeface classification. + + + Decorative typeface classification. + + + Symbol typeface classification. + + + Pictorial (or symbol) typeface classification. + + + + The DWRITE_PANOSE_SYMBOL_ASPECT_RATIO enumeration contains values that specify the aspect ratio of symbolic characters. + Microsoft Docs: + + + + Any aspect ratio of symbolic characters. + + + No fit for aspect ratio of symbolic characters. + + + No width aspect ratio of symbolic characters. + + + Exceptionally wide symbolic characters. + + + Super wide symbolic characters. + + + Very wide symbolic characters. + + + Wide symbolic characters. + + + Normal aspect ratio of symbolic characters. + + + Narrow symbolic characters. + + + Very narrow symbolic characters. + + + + The DWRITE_PANOSE_ARM_STYLE enumeration contains values that specify the style of termination of stems and rounded letterforms for text. + Microsoft Docs: + + + + Any arm style. + + + No fit arm style. + + + The arm style is straight horizontal. + + + The arm style is straight wedge. + + + The arm style is straight vertical. + + + The arm style is straight single serif. + + + The arm style is straight double serif. + + + The arm style is non-straight horizontal. + + + The arm style is non-straight wedge. + + + The arm style is non-straight vertical. + + + The arm style is non-straight single serif. + + + The arm style is non-straight double serif. + + + The arm style is straight horizontal. + + + The arm style is straight vertical. + + + The arm style is non-straight horizontal. + + + The arm style is non-straight wedge. + + + The arm style is non-straight vertical. + + + The arm style is non-straight single serif. + + + The arm style is non-straight double serif. + + + + The DWRITE_PANOSE_TOOL_KIND enumeration contains values that specify the kind of tool that is used to create character forms. + Microsoft Docs: + + + + Any kind of tool. + + + No fit for the kind of tool. + + + Flat NIB tool. + + + Pressure point tool. + + + Engraved tool. + + + Ball tool. + + + Brush tool. + + + Rough tool. + + + Felt-pen-brush-tip tool. + + + Wild-brush tool. + + + + Specifies which formats are supported in the font, either at a font-wide level or per glyph. + Microsoft Docs: + + + + Indicates no data is available for this glyph. + + + The glyph has TrueType outlines. + + + The glyph has CFF outlines. + + + The glyph has multilayered COLR data. + + + The glyph has SVG outlines as standard XML. Fonts may store the content gzip'd rather than plain text, indicated by the first two bytes as gzip header {0x1F 0x8B}. + + + The glyph has PNG image data, with standard PNG IHDR. + + + The glyph has JPEG image data, with standard JIFF SOI header. + + + The glyph has TIFF image data. + + + The glyph has raw 32-bit premultiplied BGRA data. + + + + Defines constants that specify how font families are grouped together. + Microsoft Docs: + + + + Families are grouped by the typographic family name preferred by the font author. The family can contain as many faces as the font author wants. This corresponds to DWRITE_FONT_PROPERTY_ID_TYPOGRAPHIC_FAMILY_NAME. + + + Families are grouped by the weight-stretch-style family name, where all faces that differ only by those three axes are grouped into the same family, but any other axes go into a distinct family. For example, the Sitka family with six different optical sizes yields six separate families (Sitka Caption, Display, Text, Subheading, Heading, Banner...). This corresponds to DWRITE_FONT_PROPERTY_ID_WEIGHT_STRETCH_STYLE_FAMILY_NAME. + + + + Indicates the measuring method used for text layout. + Microsoft Docs: + + + + Specifies that text is measured using glyph ideal metrics whose values are independent to the current display resolution. + + + Specifies that text is measured using glyph display-compatible metrics whose values tuned for the current display resolution. + + + Specifies that text is measured using the same glyph display metrics as text measured by GDI using a font created with CLEARTYPE_NATURAL_QUALITY. + + + + Represents the degree to which a font has been stretched compared to a font's normal aspect ratio. + Microsoft Docs: + + + + Predefined font stretch : Not known (0). + + + Predefined font stretch : Ultra-condensed (1). + + + Predefined font stretch : Extra-condensed (2). + + + Predefined font stretch : Condensed (3). + + + Predefined font stretch : Semi-condensed (4). + + + Predefined font stretch : Normal (5). + + + Predefined font stretch : Medium (5). + + + Predefined font stretch : Semi-expanded (6). + + + Predefined font stretch : Expanded (7). + + + Predefined font stretch : Extra-expanded (8). + + + Predefined font stretch : Ultra-expanded (9). + + + + The DWRITE_PANOSE_FINIALS enumeration contains values that specify how character ends and miniscule ascenders are treated. + Microsoft Docs: + + + + Any finials. + + + No fit for finials. + + + No loops. + + + No closed loops. + + + No open loops. + + + Sharp with no loops. + + + Sharp with closed loops. + + + Sharp with open loops. + + + Tapered with no loops. + + + Tapered with closed loops. + + + Tapered with open loops. + + + Round with no loops. + + + Round with closed loops. + + + Round with open loops. + + + + The DWRITE_PANOSE_LINING enumeration contains values that specify the handling of the outline for the decorative typeface. + Microsoft Docs: + + + + Any lining. + + + No fit for lining. + + + No lining. + + + The lining is inline. + + + The lining is outline. + + + The lining is engraved. + + + The lining is shadowed. + + + The lining is relief. + + + The lining is backdrop. + + + + The DWRITE_PANOSE_WEIGHT enumeration contains values that specify the weight of characters. + Microsoft Docs: + + + + Any weight. + + + No fit weight. + + + Very light weight. + + + Light weight. + + + Thin weight. + + + Book weight. + + + Medium weight. + + + Demi weight. + + + Bold weight. + + + Heavy weight. + + + Black weight. + + + Extra black weight. + + + Extra black weight. + + + + The DWRITE_PANOSE_SCRIPT_TOPOLOGY enumeration contains values that specify the topology of letterforms. + Microsoft Docs: + + + + Any script topology. + + + No fit for script topology. + + + Script topology is roman disconnected. + + + Script topology is roman trailing. + + + Script topology is roman connected. + + + Script topology is cursive disconnected. + + + Script topology is cursive trailing. + + + Script topology is cursive connected. + + + Script topology is black-letter disconnected. + + + Script topology is black-letter trailing. + + + Script topology is black-letter connected. + + + + The DWRITE_PANOSE_ASPECT_RATIO enumeration contains values that specify info about the ratio between width and height of the character face. + Microsoft Docs: + + + + Any aspect ratio. + + + No fit for aspect ratio. + + + Very condensed aspect ratio. + + + Condensed aspect ratio. + + + Normal aspect ratio. + + + Expanded aspect ratio. + + + Very expanded aspect ratio. + + + + The DWRITE_CARET_METRICS structure specifies the metrics for caret placement in a font. + Microsoft Docs: + + + + Vertical rise of the caret in font design units. Rise / Run yields the caret angle. Rise = 1 for perfectly upright fonts (non-italic). + + + Horizontal run of the caret in font design units. Rise / Run yields the caret angle. Run = 0 for perfectly upright fonts (non-italic). + + + Horizontal offset of the caret, in font design units, along the baseline for good appearance. Offset = 0 for perfectly upright fonts (non-italic). + + + + Specifies the alignment of paragraph text along the reading direction axis, relative to the leading and trailing edge of the layout box. + Microsoft Docs: + + + + The leading edge of the paragraph text is aligned to the leading edge of the layout box. + + + The trailing edge of the paragraph text is aligned to the trailing edge of the layout box. + + + The center of the paragraph text is aligned to the center of the layout box. + + + Align text to the leading side, and also justify text to fill the lines. + + + + The DWRITE_PANOSE_XHEIGHT enumeration contains values that specify info about the relative size of lowercase letters and the treatment of diacritic marks (xheight). + Microsoft Docs: + + + + Any xheight. + + + No fit xheight. + + + Constant small xheight. + + + Constant standard xheight. + + + Constant large xheight. + + + Ducking small xheight. + + + Ducking standard xheight. + + + Ducking large xheight. + + + Constant standard xheight. + + + Ducking standard xheight. + + + + Contains information regarding the size and placement of strikethroughs. + Microsoft Docs: + + + + A value that indicates the width of the strikethrough, measured parallel to the baseline. + + + A value that indicates the thickness of the strikethrough, measured perpendicular to the baseline. + + + A value that indicates the offset of the strikethrough from the baseline. + A positive offset represents a position below the baseline and + a negative offset is above. Typically, the offset will be negative. + + + Reading direction of the text associated with the strikethrough. + This value is used to interpret whether the width value runs horizontally + or vertically. + + + Flow direction of the text associated with the strikethrough. + This value is used to interpret whether the thickness value advances top to + bottom, left to right, or right to left. + + + An array of characters containing the locale of the text that is the strikethrough is being drawn over. + + + The measuring mode can be useful to the renderer to determine how underlines are rendered, such as rounding the thickness to a whole pixel in GDI-compatible modes. + + + + Contains the metrics associated with text after layout. + Microsoft Docs: + + + + A value that indicates the left-most point of formatted text relative to the layout box, + while excluding any glyph overhang. + + + A value that indicates the top-most point of formatted text relative to the layout box, while excluding any glyph overhang. + + + A value that indicates the width of the formatted text, while ignoring trailing whitespace + at the end of each line. + + + The width of the formatted text, taking into account the + trailing whitespace at the end of each line. + + + The height of the formatted text. The height of an empty string + is set to the same value as that of the default font. + + + The initial width given to the layout. It can be either larger or smaller than the + text content width, depending on whether the text + was wrapped. + + + Initial height given to the layout. Depending on the length of the text, it may be larger or smaller than the text content height. + + + The maximum reordering count of any line of text, used + to calculate the most number of hit-testing boxes needed. + If the layout has no bidirectional text, or no text at all, + the minimum level is 1. + + + Total number of lines. + + + + Represents the density of a typeface, in terms of the lightness or heaviness of the strokes. + Microsoft Docs: + + + + Predefined font weight : Thin (100). + + + Predefined font weight : Extra-light (200). + + + Predefined font weight : Ultra-light (200). + + + Predefined font weight : Light (300). + + + Predefined font weight : Semi-Light (350). + + + Predefined font weight : Normal (400). + + + Predefined font weight : Regular (400). + + + Predefined font weight : Medium (500). + + + Predefined font weight : Demi-bold (600). + + + Predefined font weight : Semi-bold (600). + + + Predefined font weight : Bold (700). + + + Predefined font weight : Extra-bold (800). + + + Predefined font weight : Ultra-bold (800). + + + Predefined font weight : Black (900). + + + Predefined font weight : Heavy (900). + + + Predefined font weight : Extra-black (950). + + + Predefined font weight : Ultra-black (950). + + + + The DWRITE_SCRIPT_PROPERTIES structure specifies script properties for caret navigation and justification. + Microsoft Docs: + + + + The standardized four character code for the given script. + +
Note  These only include the general Unicode scripts, not any additional ISO 15924 scripts for bibliographic distinction.
+
 
 + + + The standardized numeric code, ranging 0-999. + + + Number of characters to estimate look-ahead for complex scripts. Latin and all Kana are generally 1. Indic scripts are up to 15, and most others are 8. + +
Note  Combining marks and variation selectors can produce clusters that are longer than these look-aheads, so this estimate is considered typical language use. Diacritics must be tested explicitly separately.
+
 
 + + + Appropriate character to elongate the given script for justification. For example: + +
    +
  • Arabic - U+0640 Tatweel
    • +
  • Ogham - U+1680 Ogham Space Mark
    • +
 + + + Restrict the caret to whole clusters, like Thai and Devanagari. Scripts such as Arabic by default allow navigation between clusters. Others like Thai always navigate across whole clusters. + + + The language uses dividers between words, such as spaces between Latin or the Ethiopic wordspace. Examples include Latin, Greek, Devanagari, and Ethiopic. Chinese, Korean, and Thai are excluded. + + + The characters are discrete units from each other. This includes both block scripts and clustered scripts. Examples include Latin, Greek, Cyrillic, Hebrew, Chinese, and Thai. + + + The language is a block script, expanding between characters. Examples include Chinese, Japanese, Korean, and Bopomofo. + + + The language is justified within glyph clusters, not just between glyph clusters, such as the character sequence of Thai Lu and Sara Am (U+E026, U+E033), which form a single cluster but still expand between them. Examples include Thai, Lao, and Khmer. + + + The script's clusters are connected to each other (such as the baseline-linked Devanagari), and no separation is added between characters. + +
Note  Cursively linked scripts like Arabic are also connected (but not all connected scripts are cursive).
+
 
+Examples include Devanagari, Arabic, Syriac, Bengala, Gurmukhi, and Ogham. Latin, Chinese, and Thaana are excluded. + + + The script is naturally cursive (Arabic and Syriac), meaning it uses other justification methods like kashida extension rather than inter-character spacing. + +
Note   Although other scripts like Latin and Japanese might actually support handwritten cursive forms, they are not considered cursive scripts.
+
 
+Examples include Arabic, Syriac, and Mongolian. Thaana, Devanagari, Latin, and Chinese are excluded. + + + Reserved + + + + Contains information about the width, thickness, offset, run height, reading direction, and flow direction of an underline. + Microsoft Docs: + + + + A value that indicates the width of the underline, measured parallel to the baseline. + + + A value that indicates the thickness of the underline, measured perpendicular to the baseline. + + + A value that indicates the offset of the underline from the baseline. A positive offset represents a position below the baseline (away from the text) and a negative offset is above (toward the text). + + + A value that indicates the height of the tallest run where the underline is applied. + + + A value that indicates the reading direction of the text associated with the underline. This value is used to interpret whether the width value runs horizontally or vertically. + + + A value that indicates the flow direction of the text associated with the underline. This value is used to interpret whether the thickness value advances top to bottom, left to right, or right to left. + + + An array of characters which contains the locale of the text that the underline is being drawn under. For example, in vertical text, the underline belongs on the left for Chinese but on the right for Japanese. + + + The measuring mode can be useful to the renderer to determine how underlines are rendered, such as rounding the thickness to a whole pixel in GDI-compatible modes. + + + + The optical margin alignment mode. + Microsoft Docs: + + + + Align to the default origin and side-bearings of the glyph. + + + Align to the ink of the glyphs, such that the black box abuts the margins. + + + + The DWRITE_VERTICAL_GLYPH_ORIENTATION enumeration contains values that specify the desired kind of glyph orientation for the text. + Microsoft Docs: + + + + The default glyph orientation. In vertical layout, naturally horizontal scripts (Latin, Thai, Arabic, Devanagari) rotate 90 degrees clockwise, while ideographic scripts (Chinese, Japanese, Korean) remain upright, 0 degrees. + + + Stacked glyph orientation. Ideographic scripts and scripts that permit stacking (Latin, Hebrew) are stacked in vertical reading layout. Connected scripts (Arabic, Syriac, 'Phags-pa, Ogham), which would otherwise look broken if glyphs were kept at 0 degrees, remain connected and rotate. + + + + Describes the region obtained by a hit test. + Microsoft Docs: + + + + The first text position within the hit region. + + + The number of text positions within the hit region. + + + The x-coordinate of the upper-left corner of the hit region. + + + The y-coordinate of the upper-left corner of the hit region. + + + The width of the hit region. + + + The height of the hit region. + + + The BIDI level of the text positions within the hit region. + + + true if the hit region contains text; otherwise, false. + + + true if the text range is trimmed; otherwise, false. + + + + The optional adjustment to a glyph's position. + Microsoft Docs: + + + + The offset in the advance direction of the run. A positive advance offset moves the glyph to the right (in pre-transform coordinates) if the run is left-to-right or to the left if the run is right-to-left. + + + The offset in the ascent direction, that is, the direction ascenders point. A positive ascender offset moves the glyph up (in pre-transform coordinates). A negative ascender offset moves the glyph down. + + + + The DWRITE_PANOSE_ASPECT enumeration contains values that specify the ratio between the width and height of the character face. + Microsoft Docs: + + + + Any aspect. + + + No fit for aspect. + + + Super condensed aspect. + + + Very condensed aspect. + + + Condensed aspect. + + + Normal aspect. + + + Extended aspect. + + + Very extended aspect. + + + Super extended aspect. + + + Monospace aspect. + + + + Shaping output properties for an output glyph. + Microsoft Docs: + + + + Indicates that the glyph is shaped alone. + + + Reserved for future use. + + + + The DWRITE_TEXT_ANTIALIAS_MODE enumeration contains values that specify the type of antialiasing to use for text when the rendering mode calls for antialiasing. + Microsoft Docs: + + + + ClearType antialiasing computes coverage independently for the red, green, and blue color elements of each pixel. This allows for more detail than conventional antialiasing. However, because there is no one alpha value for each pixel, ClearType is not suitable for rendering text onto a transparent intermediate bitmap. + + + Grayscale antialiasing computes one coverage value for each pixel. Because the alpha value of each pixel is well-defined, text can be rendered onto a transparent bitmap, which can then be composited with other content. + +
Note  Grayscale rendering with IDWriteBitmapRenderTarget1 uses premultiplied alpha.
+
 
 + + + + The DWRITE_PANOSE_SPACING enumeration contains values that specify character spacing (monospace versus proportional). + Microsoft Docs: + + + + Any spacing. + + + No fit for spacing. + + + Spacing is proportional. + + + Spacing is monospace. + + + + The informational string enumeration which identifies a string embedded in a font file. + Microsoft Docs: + + + + Indicates the string containing the unspecified name ID. + + + Indicates the string containing the copyright notice provided by the font. + + + Indicates the string containing a version number. + + + Indicates the string containing the trademark information provided by the font. + + + Indicates the string containing the name of the font manufacturer. + + + Indicates the string containing the name of the font designer. + + + Indicates the string containing the URL of the font designer (with protocol, e.g., http://, ftp://). + + + Indicates the string containing the description of the font. This may also contain revision information, usage recommendations, history, features, and so on. + + + Indicates the string containing the URL of the font vendor (with protocol, e.g., http://, ftp://). If a unique serial number is embedded in the URL, it can be used to register the font. + + + Indicates the string containing the description of how the font may be legally used, or different example scenarios for licensed use. + + + Indicates the string containing the URL where additional licensing information can be found. + + + Indicates the string containing the GDI-compatible family name. Since GDI allows a maximum of four fonts per family, fonts in the same family may have different GDI-compatible family names (e.g., "Arial", "Arial Narrow", "Arial Black"). + + + Indicates the string containing a GDI-compatible subfamily name. + + + Contains sample text for display in font lists. This can be the font name or any other text that the designer thinks is the best + +example to display the font in. + + + The full name of the font, like Arial Bold, from name id 4 in the name table + + + The postscript name of the font, like GillSans-Bold, from name id 6 in the name table. + + + The postscript CID findfont name, from name id 20 in the name table + + + Indicates the string containing the family name preferred by the designer. This enables font designers to group more than four fonts in a single family without losing compatibility with GDI. This name is typically only present if it differs from the GDI-compatible family name. + + + Indicates the string containing the subfamily name preferred by the designer. This name is typically only present if it differs from the GDI-compatible subfamily name. + + + + Creates an OpenType tag for a font axis. + Microsoft Docs: + The first character in the tag. + The second character in the tag. + The third character in the tag. + The fourth character in the tag. + + + + + The DWRITE_JUSTIFICATION_OPPORTUNITY structure specifies justification info per glyph. + Microsoft Docs: + + + + Minimum amount of expansion to apply to the side of the glyph. This might vary from zero to infinity, typically being zero except for kashida. + + + Maximum amount of expansion to apply to the side of the glyph. This might vary from zero to infinity, being zero for fixed-size characters and connected scripts, and non-zero for discrete scripts, and non-zero for cursive scripts at expansion points. + + + Maximum amount of compression to apply to the side of the glyph. This might vary from zero up to the glyph cluster size. + + + Priority of this expansion point. Larger priorities are applied later, while priority zero does nothing. + + + Priority of this compression point. Larger priorities are applied later, while priority zero does nothing. + + + Allow this expansion point to use up any remaining slack space even after all expansion priorities have been used up. + + + Allow this compression point to use up any remaining space even after all compression priorities have been used up. + + + Apply expansion and compression to the leading edge of the glyph. This bit is FALSE (0) for connected scripts, fixed-size characters, and diacritics. It is generally FALSE within a multi-glyph cluster, unless the script allows expansion of glyphs within a cluster, like Thai. + + + Apply expansion and compression to the trailing edge of the glyph. This bit is FALSE (0) for connected scripts, fixed-size characters, and diacritics. It is generally FALSE within a multi-glyph cluster, unless the script allows expansion of glyphs within a cluster, like Thai. + + + Reserved + + + + Line breakpoint characteristics of a character. + Microsoft Docs: + + + + Indicates a breaking condition before the character. + + + Indicates a breaking condition after the character. + + + Indicates that the character is some form of whitespace, which may be meaningful for justification. + + + Indicates that the character is a soft hyphen, often used to indicate hyphenation points inside words. + + + Reserved for future use. + + + + Specifies the alignment of paragraph text along the flow direction axis, relative to the top and bottom of the flow's layout box. + Microsoft Docs: + + + + The top of the text flow is aligned to the top edge of the layout box. + + + The bottom of the text flow is aligned to the bottom edge of the layout box. + + + The center of the flow is aligned to the center of the layout box. + + + + The DWRITE_PANOSE_FILL enumeration contains values that specify the type of fill and line treatment. + Microsoft Docs: + + + + Any fill. + + + No fit for fill. + + + The fill is the standard solid fill. + + + No fill. + + + The fill is patterned fill. + + + The fill is complex fill. + + + The fill is shaped fill. + + + The fill is drawn distressed. + + + + Creates an OpenType tag as a 32-bit integer, such that the first character in the tag is the lowest byte (least significant on little endian architectures), which can be used to compare with tags in the font file. + Microsoft Docs: + The first character in the tag. + The second character in the tag. + The third character in the tag. + The fourth character in the tag. + + + + + The DWRITE_PANOSE union describes typeface classification values that you use with IDWriteFont1::GetPanose to select and match the font. + Microsoft Docs: + + + + A 10-byte array of typeface classification values. + + + A DWRITE_PANOSE_FAMILY-typed value that specifies the typeface classification values to get. + + + The text structure. + + + A DWRITE_PANOSE_SERIF_STYLE-typed value that specifies the serif style of text. + + + A DWRITE_PANOSE_WEIGHT-typed value that specifies the weight of the text. + + + A DWRITE_PANOSE_PROPORTION-typed value that specifies the proportion for the text. + + + A DWRITE_PANOSE_CONTRAST-typed value that specifies the contrast for the text. + + + A DWRITE_PANOSE_STROKE_VARIATION-typed value that specifies the stroke variation for the text. + + + A DWRITE_PANOSE_ARM_STYLE-typed value that specifies the arm style of text. + + + A DWRITE_PANOSE_LETTERFORM-typed value that specifies the letter form for the text. + + + A DWRITE_PANOSE_MIDLINE-typed value that specifies the midline for the text. + + + A DWRITE_PANOSE_XHEIGHT-typed value that specifies the relative size of lowercase text. + + + The script structure. + + + A DWRITE_PANOSE_TOOL_KIND-typed value that specifies the kind of tool for the script. + + + A DWRITE_PANOSE_SPACING-typed value that specifies the spacing of the script. + + + A DWRITE_PANOSE_ASPECT_RATIO-typed value that specifies the aspect ratio of the script. + + + A DWRITE_PANOSE_SCRIPT_TOPOLOGY-typed value that specifies the script topology. + + + A DWRITE_PANOSE_SCRIPT_FORM-typed value that specifies the script form. + + + A DWRITE_PANOSE_FINIALS-typed value that specifies the script finials. + + + A DWRITE_PANOSE_XASCENT-typed value that specifies the relative size of lowercase letters. + + + The decorative structure. + + + A DWRITE_PANOSE_DECORATIVE_CLASS-typed value that specifies the class of the decorative typeface. + + + A DWRITE_PANOSE_ASPECT-typed value that specifies the aspect of the decorative typeface. + + + The serif variant of the decorative typeface. + + + A DWRITE_PANOSE_FILL-typed value that specifies the fill of the decorative typeface. + + + A DWRITE_PANOSE_LINING-typed value that specifies the lining of the decorative typeface. + + + A DWRITE_PANOSE_DECORATIVE_TOPOLOGY-typed value that specifies the decorative topology. + + + A DWRITE_PANOSE_CHARACTER_RANGES-typed value that specifies the character range of the decorative typeface. + + + The symbol structure. + + + A DWRITE_PANOSE_SYMBOL_KIND-typed value that specifies the kind of symbol set. + + + A DWRITE_PANOSE_SYMBOL_ASPECT_RATIO-typed value that specifies the aspect ratio and contrast of the symbol typeface. + + + A DWRITE_PANOSE_SYMBOL_ASPECT_RATIO-typed value that specifies the aspect ratio 94 of the symbol typeface. + + + A DWRITE_PANOSE_SYMBOL_ASPECT_RATIO-typed value that specifies the aspect ratio 119 of the symbol typeface. + + + A DWRITE_PANOSE_SYMBOL_ASPECT_RATIO-typed value that specifies the aspect ratio 157 of the symbol typeface. + + + A DWRITE_PANOSE_SYMBOL_ASPECT_RATIO-typed value that specifies the aspect ratio 163 of the symbol typeface. + + + A DWRITE_PANOSE_SYMBOL_ASPECT_RATIO-typed value that specifies the aspect ratio 211 of the symbol typeface. + + + + The DWRITE_GLYPH_ORIENTATION_ANGLE enumeration contains values that specify how the glyph is oriented to the x-axis. + Microsoft Docs: + + + + Glyph orientation is upright. + + + Glyph orientation is rotated 90 degrees clockwise. + + + Glyph orientation is upside-down. + + + Glyph orientation is rotated 270 degrees clockwise. + + + + Contains the information needed by renderers to draw glyph runs. + Microsoft Docs: + + + + The physical font face object to draw with. + + + The logical size of the font in DIPs (equals 1/96 inch), not points. + + + The number of glyphs in the glyph run. + + + A pointer to an array of indices to render for the glyph run. + + + A pointer to an array containing glyph advance widths for the glyph run. + + + A pointer to an array containing glyph offsets for the glyph run. + + + If true, specifies that glyphs are rotated 90 degrees to the left and vertical metrics are used. Vertical writing is achieved by specifying isSideways = true and rotating the entire run 90 degrees to the right via a rotate transform. + + + The implicit resolved bidi level of the run. Odd levels indicate right-to-left languages like Hebrew and Arabic, while even levels indicate left-to-right languages like English and Japanese (when written horizontally). For right-to-left languages, the text origin is on the right, and text should be drawn to the left. + + + + Contains properties describing the geometric measurement of an application-defined inline object. + Microsoft Docs: + + + + The width of the inline object. + + + The height of the inline object. + + + The distance from the top of the object to the point where it is lined up with the adjacent text. + If the baseline is at the bottom, then baseline simply equals height. + + + A Boolean flag that indicates whether the object is to be placed upright or alongside the text baseline for vertical text. + + + + Indicates the file format of a complete font face. + Microsoft Docs: + + + + OpenType font face with CFF outlines. + + + OpenType font face with TrueType outlines. + + + A Type 1 font face. + + + A vector .FON format font face. + + + A bitmap .FON format font face. + + + Font face type is not recognized by the DirectWrite font system. + + + The font data includes only the CFF table from an OpenType CFF font. This font face type can be used only for embedded fonts (i.e., custom font file loaders) and the resulting font face object supports only the minimum functionality necessary to render glyphs. + + + OpenType font face that is a part of a TrueType collection. + + + + The DWRITE_PANOSE_PROPORTION enumeration contains values that specify the proportion of the glyph shape by considering additional detail to standard characters. + Microsoft Docs: + + + + Any proportion for the text. + + + No fit proportion for the text. + + + Old style proportion for the text. + + + Modern proportion for the text. + + + Extra width proportion for the text. + + + Expanded proportion for the text. + + + Condensed proportion for the text. + + + Very expanded proportion for the text. + + + Very condensed proportion for the text. + + + Monospaced proportion for the text. + + + + Represents a range of bytes in a font file. + Microsoft Docs: + + + + Starting offset of the fragment from the beginning of the file. + + + Size of the file fragment, in bytes. + + + + The method used for line spacing in a text layout. + Microsoft Docs: + + + + Line spacing depends solely on the content, adjusting to accommodate the size of fonts and inline objects. + + + Lines are explicitly set to uniform spacing, regardless of the size of fonts and inline objects. This can be useful to avoid the uneven appearance that can occur from font fallback. + + + Line spacing and baseline distances are proportional to the computed values based on the content, the size of the fonts and inline objects. + + +
Note  This value is only available on Windows 10 or later and it can be used with IDWriteTextLayout3::SetLineSpacing, + but can not be used with IDWriteTextFormat::SetLineSpacing.
+
 
 + + + + Specifies the location of a resource. + Microsoft Docs: + + + + The resource is remote, and information about it is unknown, including the file size and date. If you attempt to create a font or file stream, the creation will fail until locality becomes at least partial. + + + The resource is partially local, which means you can query the size and date of the file stream. With this type, you also might be able to create a font face and retrieve the particular glyphs for metrics and drawing, but not all the glyphs will be present. + + + The resource is completely local, and all font functions can be called without concern of missing data or errors related to network connectivity. + + + + Indicates the condition at the edges of inline object or text used to determine line-breaking behavior. + Microsoft Docs: + + + + Indicates whether a break is allowed by determining the condition of the neighboring text span or inline object. + + + Indicates that a line break is allowed, unless overruled by the condition of the + neighboring text span or inline object, either prohibited by a + "may not break" condition or forced by a "must break" condition. + + + Indicates that there should be no line break, unless overruled by a "must break" condition from + the neighboring text span or inline object. + + + Indicates that the line break must happen, regardless of the condition of the adjacent + text span or inline object. + + + + The DWRITE_PANOSE_SCRIPT_FORM enumeration contains values that specify the general look of the character face, with consideration of its slope and tails. + Microsoft Docs: + + + + Any script form. + + + No fit for script form. + + + Script form is upright with no wrapping. + + + Script form is upright with some wrapping. + + + Script form is upright with more wrapping. + + + Script form is upright with extreme wrapping. + + + Script form is oblique with no wrapping. + + + Script form is oblique with some wrapping. + + + Script form is oblique with more wrapping. + + + Script form is oblique with extreme wrapping. + + + Script form is exaggerated with no wrapping. + + + Script form is exaggerated with some wrapping. + + + Script form is exaggerated with more wrapping. + + + Script form is exaggerated with extreme wrapping. + + + + Contains the metrics associated with text after layout. + Microsoft Docs: + + + + The height of the formatted text taking into account the trailing whitespace at the end of each line. This is + pertinent for vertical text. + + + + Contains the information needed by renderers to draw glyph runs with glyph color information. + Microsoft Docs: + + + + Glyph run to draw for this layer. + + + Pointer to the glyph run description for this layer. This may be NULL. For example, when the original glyph run is split into multiple layers, one layer might have a description and the others have none. + + + X coordinate of the baseline origin for the layer. + + + Y coordinate of the baseline origin for the layer. + + + Color value of the run; if all members are zero, the run should be drawn using the current brush. + + + Zero-based index into the font’s color palette; if this is 0xFFFF, the run should be drawn using the current brush. + + + + Represents a method of rendering glyphs. + Microsoft Docs: + + + + Specifies that the rendering mode is determined automatically, based on the font and size. + + + Specifies that no anti-aliasing is performed. Each pixel is either set to the foreground color of the text or retains the color of the background. + + + Specifies that antialiasing is performed in the horizontal direction and the appearance of glyphs is layout-compatible with GDI using CLEARTYPE_QUALITY. + Use DWRITE_MEASURING_MODE_GDI_CLASSIC to get glyph advances. The antialiasing may be either ClearType or grayscale depending on the text antialiasing mode. + + + Specifies that antialiasing is performed in the horizontal direction and the appearance of glyphs is layout-compatible with GDI using CLEARTYPE_NATURAL_QUALITY. + Glyph advances are close to the font design advances, but are still rounded to whole pixels. Use DWRITE_MEASURING_MODE_GDI_NATURAL to get glyph advances. + The antialiasing may be either ClearType or grayscale depending on the text antialiasing mode. + + + Specifies that antialiasing is performed in the horizontal direction. This rendering mode allows glyphs to be positioned with subpixel precision and + is therefore suitable + for natural (i.e., resolution-independent) layout. The antialiasing may be either ClearType or grayscale depending on the text antialiasing mode. + + + Similar to natural mode except that antialiasing is performed in both the horizontal and vertical directions. + This is typically used at larger sizes to make curves and diagonal lines look smoother. The antialiasing may be either ClearType or grayscale depending + on the text antialiasing mode. + + + Specifies that rendering should bypass the rasterizer and use the outlines directly. This is typically used at very large sizes. + + + + Specifies a range of text positions where format is applied in the text represented by an IDWriteTextLayout object. + Microsoft Docs: + + + + The start position of the text range. + + + The number positions in the text range. + + + + Specifies properties used to identify and execute typographic features in the current font face. + Microsoft Docs: + + + + The feature OpenType name identifier. + + + The execution parameter of the feature. + + + + Specifies algorithmic style simulations to be applied to the font face. Bold and oblique simulations can be combined via bitwise OR operation. + Microsoft Docs: + + + + Indicates that no simulations are applied to the font face. + + + Indicates that algorithmic emboldening is applied to the font face. DWRITE_FONT_SIMULATIONS_BOLD increases weight by applying a widening algorithm to the glyph outline. This may be used to simulate a bold weight where no designed bold weight is available. + + + Indicates that algorithmic italicization is applied to the font face. DWRITE_FONT_SIMULATIONS_OBLIQUE applies obliquing (shear) to the glyph outline. This may be used to simulate an oblique/italic style where no designed oblique/italic style is available. + + + + The DWRITE_PANOSE_DECORATIVE_TOPOLOGY enumeration contains values that specify the overall shape characteristics of the font. + Microsoft Docs: + + + + Any decorative topology. + + + No fit for decorative topology. + + + Standard decorative topology. + + + Square decorative topology. + + + Multiple segment decorative topology. + + + Art deco decorative topology. + + + Uneven weighting decorative topology. + + + Diverse arms decorative topology. + + + Diverse forms decorative topology. + + + Lombardic forms decorative topology. + + + Upper case in lower case decorative topology. + + + The decorative topology is implied. + + + Horseshoe E and A decorative topology. + + + Cursive decorative topology. + + + Blackletter decorative topology. + + + Swash variance decorative topology. + + + + Specifies how glyphs are rendered. + Microsoft Docs: + + + + Specifies that the rendering mode is determined automatically, based on the font and size. + + + Specifies that no anti-aliasing is performed. Each pixel is either set to the foreground color of the text or retains the color of the background. + + + Specifies that antialiasing is performed in the horizontal direction and the appearance of glyphs is layout-compatible with GDI using CLEARTYPE_QUALITY. + Use DWRITE_MEASURING_MODE_GDI_CLASSIC to get glyph advances. The antialiasing may be either ClearType or grayscale depending on the text antialiasing mode. + + + Specifies that antialiasing is performed in the horizontal direction and the appearance of glyphs is layout-compatible with GDI using CLEARTYPE_NATURAL_QUALITY. + Glyph advances are close to the font design advances, but are still rounded to whole pixels. Use DWRITE_MEASURING_MODE_GDI_NATURAL to get glyph advances. + The antialiasing may be either ClearType or grayscale depending on the text antialiasing mode. + + + Specifies that antialiasing is performed in the horizontal direction. This rendering mode allows glyphs to be positioned with subpixel precision and + is therefore suitable for natural (i.e., resolution-independent) layout. + The antialiasing may be either ClearType or grayscale depending on the text antialiasing mode. + + + Similar to natural mode except that antialiasing is performed in both the horizontal and vertical directions. + This is typically used at larger sizes to make curves and diagonal lines look smoother. + The antialiasing may be either ClearType or grayscale depending on the text antialiasing mode. + + + Specifies that rendering should bypass the rasterizer and use the outlines directly. This is typically used at very large sizes. + + + Similar to natural symmetric mode except that when possible, text should be rasterized in a downsampled form. + + + + Represents a color glyph run. The IDWriteFactory4::TranslateColorGlyphRun method returns an ordered collection of color glyph runs of varying types depending on what the font supports. + Microsoft Docs: + + + + Type of glyph image format for this color run. Exactly one type will be set since TranslateColorGlyphRun has already broken down the run into separate parts. + + + Measuring mode to use for this glyph run. + + + + Specify whether DWRITE_FONT_METRICS::lineGap value should be part of the line metrics. + Microsoft Docs: + + + + The usage of the font line gap depends on the method used for text layout. + + + The font line gap is excluded from line spacing. + + + The font line gap is included in line spacing. + + + + Represents the minimum and maximum range of the possible values for a font axis. + Microsoft Docs: + + + + The four-character identifier of the font axis (for example, weight, width, slant, italic, and so on). + + + The minimum value supported by this axis. + + + The maximum value supported by this axis. + + + + Stores the association of text and its writing system script, as well as some display attributes. + Microsoft Docs: + + + + The zero-based index representation of writing system script. + + + A value that indicates additional shaping requirement of text. + + + + Contains information about a formatted line of text. + Microsoft Docs: + + + + White space before the content of the line. This is included in the line height and baseline distances. +If the line is formatted horizontally either with a uniform line spacing or with proportional +line spacing, this value represents the extra space above the content. + + + White space after the content of the line. This is included in the height of the line. +If the line is formatted horizontally either with a uniform line spacing or with proportional +line spacing, this value represents the extra space below the content. + + + + The DWRITE_PANOSE_SERIF_STYLE enumeration contains values that specify the appearance of the serif text. + Microsoft Docs: + + + + Any appearance of the serif text. + + + No fit appearance of the serif text. + + + Cove appearance of the serif text. + + + Obtuse cove appearance of the serif text. + + + Square cove appearance of the serif text. + + + Obtuse square cove appearance of the serif text. + + + Square appearance of the serif text. + + + Thin appearance of the serif text. + + + Oval appearance of the serif text. + + + Exaggerated appearance of the serif text. + + + Triangle appearance of the serif text. + + + Normal sans appearance of the serif text. + + + Obtuse sans appearance of the serif text. + + + Perpendicular sans appearance of the serif text. + + + Flared appearance of the serif text. + + + Rounded appearance of the serif text. + + + Script appearance of the serif text. + + + Perpendicular sans appearance of the serif text. + + + Oval appearance of the serif text. + + + + The DWRITE_MATRIX structure specifies the graphics transform to be applied to rendered glyphs. + Microsoft Docs: + + + + A value indicating the horizontal scaling / cosine of rotation. + + + A value indicating the vertical shear / sine of rotation. + + + A value indicating the horizontal shear / negative sine of rotation. + + + A value indicating the vertical scaling / cosine of rotation. + + + A value indicating the horizontal shift (always orthogonal regardless of rotation). + + + A value indicating the vertical shift (always orthogonal regardless of rotation.) + + + + Specifies how to apply number substitution on digits and related punctuation. + Microsoft Docs: + + + + Specifies that the substitution method should be determined based on the LOCALE_IDIGITSUBSTITUTION value of the specified text culture. + + + If the culture is Arabic or Persian, specifies that the number shapes depend on the context. Either traditional or nominal number shapes are used, depending on the nearest preceding strong character or (if there is none) the reading direction of the paragraph. + + + Specifies that code points 0x30-0x39 are always rendered as nominal numeral shapes (ones of the European number), that is, no substitution is performed. + + + Specifies that numbers are rendered using the national number shapes as specified by the LOCALE_SNATIVEDIGITS value of the specified text culture. + + + Specifies that numbers are rendered using the traditional shapes for the specified culture. For most cultures, this is the same as NativeNational. However, NativeNational results in Latin numbers for some Arabic cultures, whereasDWRITE_NUMBER_SUBSTITUTION_METHOD_TRADITIONAL results in arabic numbers for all Arabic cultures. + + + + Sets the vertical spacing between lines of text. + Microsoft Docs: + + + + Method used to determine line spacing. + + + Spacing between lines. The interpretation of this parameter depends upon the line spacing method, as follows: + +
    +
  • Line spacing: ignored
    • +
  • uniform line spacing: explicit distance in DIPs between lines
    • +
  • proportional line spacing: a scaling factor to be applied to the computed line height; + for each line, the height of the line is computed as for default line spacing, and the scaling factor is applied to that value.
    • +
 + + + Distance from top of line to baseline. + The interpretation of this parameter depends upon the line spacing method, as follows: + +
    +
  • default line spacing: ignored
    • +
  • uniform line spacing: explicit distance in DIPs from the top of the line to the baseline
    • +
  • proportional line spacing: a scaling factor applied to the computed baseline; for each line, + the baseline distance is computed as for default line spacing, and the scaling factor is applied to that value.
    • +
 + + + Proportion of the entire leading distributed before the line. The allowed value is between 0 and 1.0. The remaining + leading is distributed after the line. It is ignored for the default and uniform line spacing methods. + The leading that is available to distribute before or after the line depends on the values of the height and + baseline parameters. + + + Specify whether DWRITE_FONT_METRICS::lineGap value should be part of the line metrics. + + + + Indicates the direction of how lines of text are placed relative to one another. + Microsoft Docs: + + + + Specifies that text lines are placed from top to bottom. + + + Specifies that text lines are placed from bottom to top. + + + Specifies that text lines are placed from left to right. + + + Specifies that text lines are placed from right to left. + + + + Data for a single glyph from GetGlyphImageData. + Microsoft Docs: + + + + Pointer to the glyph data. + + + Size of glyph data in bytes. + + + Unique identifier for the glyph data. Clients may use this to cache a parsed/decompressed version and tell whether a repeated call to the same font returns the same data. + + + Pixels per em of the returned data. For non-scalable raster data (PNG/TIFF/JPG), this can be larger or smaller than requested from GetGlyphImageData when there isn't an exact match. + For scaling intermediate sizes, use: desired pixels per em * font em size / actual pixels per em. + + + Size of image when the format is pixel data. + + + Left origin along the horizontal Roman baseline. + + + Right origin along the horizontal Roman baseline. + + + Top origin along the vertical central baseline. + + + Bottom origin along vertical central baseline. + + + + Specifies whether to enable grid-fitting of glyph outlines (also known as hinting). + Microsoft Docs: + + + + Choose grid fitting based on the font's table information. + + + Always disable grid fitting, using the ideal glyph outlines. + + + Enable grid fitting, adjusting glyph outlines for device pixel display. + + + + Specifies the trimming option for text overflowing the layout box. + Microsoft Docs: + + + + A value that specifies the text granularity used to trim text overflowing the layout box. + + + A character code used as the delimiter that signals the beginning of the portion of text to be preserved. + Text starting from the Nth occurence of the delimiter (where N equals delimiterCount) counting backwards from the end of the text block will be preserved. + For example, given the text is a path like c:\A\B\C\D\file.txt and delimiter equal to '\' and delimiterCount equal to 1, the file.txt portion of the text would be preserved. + Specifying a delimiterCount of 2 would preserve D\file.txt. + + + The delimiter count, counting from the end of the text, to preserve text from. + + + + Specifies the container format of a font resource. A container format is distinct from a font file format (DWRITE_FONT_FILE_TYPE) because the container describes the container in which the underlying font file is packaged. + Microsoft Docs: + + + + + Identifies a type of alpha texture. + Microsoft Docs: + + + + Specifies an alpha texture for aliased text rendering (that is, each pixel is either fully opaque or fully transparent), with one byte per pixel. + + + Specifies an alpha texture for ClearType text rendering, with three bytes per pixel in the horizontal dimension and one byte per pixel in the vertical dimension. + + + + The DWRITE_BASELINE enumeration contains values that specify the baseline for text alignment. + Microsoft Docs: + + + + The Roman baseline for horizontal; the Central baseline for vertical. + + + The baseline that is used by alphabetic scripts such as Latin, Greek, and Cyrillic. + + + Central baseline, which is generally used for vertical text. + + + Mathematical baseline, which math characters are centered on. + + + Hanging baseline, which is used in scripts like Devanagari. + + + Ideographic bottom baseline for CJK, left in vertical. + + + Ideographic top baseline for CJK, right in vertical. + + + The bottom-most extent in horizontal, left-most in vertical. + + + The top-most extent in horizontal, right-most in vertical. + + + + The DWRITE_PANOSE_MIDLINE enumeration contains values that specify info about the placement of midline across uppercase characters and the treatment of diagonal stem apexes. + Microsoft Docs: + + + + Any midline. + + + No fit midline. + + + Standard trimmed midline. + + + Standard pointed midline. + + + Standard serifed midline. + + + High trimmed midline. + + + High pointed midline. + + + High serifed midline. + + + Constant trimmed midline. + + + Constant pointed midline. + + + Constant serifed midline. + + + Low trimmed midline. + + + Low pointed midline. + + + Low serifed midline. + + + + Contains information about a glyph cluster. + Microsoft Docs: + + + + The total advance width of all glyphs in the cluster. + + + The number of text positions in the cluster. + + + Indicates whether a line can be broken right after the cluster. + + + Indicates whether the cluster corresponds to a whitespace character. + + + Indicates whether the cluster corresponds to a newline character. + + + Indicates whether the cluster corresponds to a soft hyphen character. + + + Indicates whether the cluster is read from right to left. + + + Reserved for future use. + + + + The DWRITE_UNICODE_RANGE structure specifies the range of Unicode code points. + Microsoft Docs: + + + + The first code point in the Unicode range. + + + The last code point in the Unicode range. + + + + The DWRITE_PANOSE_SYMBOL_KIND enumeration contains values that specify the kind of symbol set. + Microsoft Docs: + + + + Any kind of symbol set. + + + No fit for the kind of symbol set. + + + The kind of symbol set is montages. + + + The kind of symbol set is pictures. + + + The kind of symbol set is shapes. + + + The kind of symbol set is scientific symbols. + + + The kind of symbol set is music symbols. + + + The kind of symbol set is expert symbols. + + + The kind of symbol set is patterns. + + + The kind of symbol set is boarders. + + + The kind of symbol set is icons. + + + The kind of symbol set is logos. + + + The kind of symbol set is industry specific. + + + + Specifies the metrics of an individual glyph. + Microsoft Docs: + + + + Specifies the X offset from the glyph origin to the left edge of the black box. The glyph origin is the current horizontal writing position. A negative value means the black box extends to the left of the origin (often true for lowercase italic 'f'). + + + Specifies the X offset from the origin of the current glyph to the origin of the next glyph when writing horizontally. + + + Specifies the X offset from the right edge of the black box to the origin of the next glyph when writing horizontally. The value is negative when the right edge of the black box overhangs the layout box. + + + Specifies the vertical offset from the vertical origin to the top of the black box. Thus, a positive value adds whitespace whereas a negative value means the glyph overhangs the top of the layout box. + + + Specifies the Y offset from the vertical origin of the current glyph to the vertical origin of the next glyph when writing vertically. Note that the term "origin" by itself denotes the horizontal origin. The vertical origin is different. Its Y coordinate is specified by verticalOriginY value, and its X coordinate is half the advanceWidth to the right of the horizontal origin. + + + Specifies the vertical distance from the bottom edge of the black box to the advance height. This is positive when the bottom edge of the black box is within the layout box, or negative when the bottom edge of black box overhangs the layout box. + + + Specifies the Y coordinate of a glyph's vertical origin, in the font's design coordinate system. The y coordinate of a glyph's vertical origin is the sum of the glyph's top side bearing and the top (that is, yMax) of the glyph's bounding box. + + + + Specifies the direction in which reading progresses. + Microsoft Docs: + + + + Indicates that reading progresses from left to right. + + + Indicates that reading progresses from right to left. + + +
Note  Windows 8.1 and later only.
+
 
+Indicates that reading progresses from top to bottom. + + +
Note  Windows 8.1 and later only.
+
 
+ Indicates that reading progresses from bottom to top. + + + + The DWRITE_OUTLINE_THRESHOLD enumeration contains values that specify the policy used by the IDWriteFontFace1::GetRecommendedRenderingMode method to determine whether to render glyphs in outline mode. + Microsoft Docs: + + + + Graphics system renders anti-aliased outlines. + + + Graphics system renders aliased outlines. + + + + The DWRITE_PANOSE_CONTRAST enumeration contains values that specify the ratio between thickest and thinnest point of the stroke for a letter such as uppercase 'O'. + Microsoft Docs: + + + + Any contrast. + + + No fit contrast. + + + No contrast. + + + Very low contrast. + + + Low contrast. + + + Medium low contrast. + + + Medium contrast. + + + Medium high contrast. + + + High contrast. + + + Very high contrast. + + + Horizontal low contrast. + + + Horizontal medium contrast. + + + Horizontal high contrast. + + + Broken contrast. + + + + Represents a value for a font axis. Used when querying and creating font instances. + Microsoft Docs: + + + + The four-character identifier of the font axis (for example, weight, width, slant, italic, and so on). + + + A value for the axis specified in axisTag. The meaning and range of the value depends on the semantics of the particular axis. Certain well-known axes have standard ranges and defaults. Here are some examples. + +- Weight (1..1000, default == 400) +- Width (>0, default == 100) +- Slant (-90..90, default == -20) +- Italic (0 or 1) + + + + The DWRITE_PANOSE_LETTERFORM enumeration contains values that specify the roundness of letterform for text. + Microsoft Docs: + + + + Any letterform. + + + No fit letterform. + + + Normal contact letterform. + + + Normal weighted letterform. + + + Normal boxed letterform. + + + Normal flattened letterform. + + + Normal rounded letterform. + + + Normal off-center letterform. + + + Normal square letterform. + + + Oblique contact letterform. + + + Oblique weighted letterform. + + + Oblique boxed letterform. + + + Oblique flattened letterform. + + + Oblique rounded letterform. + + + Oblique off-center letterform. + + + Oblique square letterform. + + + + Font property used for filtering font sets and building a font set with explicit properties. + Microsoft Docs: + + + + Specifies the requested font property, such as DWRITE_FONT_PROPERTY_ID_FAMILY_NAME. + + + Specifies the value, such as "Segoe UI". + + + Specifies the locale to use, such as "en-US". Simply leave this empty when used + with the font set filtering functions, as they will find a match regardless of + language. For passing to AddFontFaceReference, the localeName specifies the language + of the property value. + + + + Indicates additional shaping requirements for text. + Microsoft Docs: + + + + Indicates that there is no additional shaping requirements for text. Text is shaped with the writing system default behavior. + + + Indicates that text should leave no visible control or format control characters. + + + + The DWRITE_PANOSE_STROKE_VARIATION enumeration contains values that specify the relationship between thin and thick stems of text characters. + Microsoft Docs: + + + + Any stroke variation for text characters. + + + No fit stroke variation for text characters. + + + No stroke variation for text characters. + + + The stroke variation for text characters is gradual diagonal. + + + The stroke variation for text characters is gradual transitional. + + + The stroke variation for text characters is gradual vertical. + + + The stroke variation for text characters is gradual horizontal. + + + The stroke variation for text characters is rapid vertical. + + + The stroke variation for text characters is rapid horizontal. + + + The stroke variation for text characters is instant vertical. + + + The stroke variation for text characters is instant horizontal. + + + + Defines constants that specify certain axes that can be applied automatically in layout during font selection. + Microsoft Docs: + + + + Specifies that no axes are automatically applied. + + + Specifies that—when no value is specified via DWRITE_FONT_AXIS_TAG_OPTICAL_SIZE—an appropriate optical value should be automatically chosen based on the font size (via IDWriteTextLayout::SetFontSize). You can still apply the 'opsz' value over text ranges via IDWriteTextFormat3::SetFontAxisValues, which take priority. + + + + Contains shaping output properties for an output glyph. + Microsoft Docs: + + + + Indicates that the glyph has justification applied. + + + Indicates that the glyph is the start of a cluster. + + + Indicates that the glyph is a diacritic mark. + + + Indicates that the glyph is a word boundary with no visible space. + + + Reserved for future use. + + + + Defines constants that specify a four-character identifier for a font axis. + Microsoft Docs: + + + + Specifies the weight axis, using the identifier 'w','g','h','t'. + + + Specifies the width axis, using the identifier 'w','d','t','h'. + + + Specifies the slant axis, using the identifier 's','l','n','t'. + + + Specifies the optical size axis, using the identifier 'o','p','s','z'. + + + Specifies the italic axis, using the identifier 'i','t','a','l'. + + + + Represents the style of a font face as normal, italic, or oblique. + Microsoft Docs: + + + + Font style : Normal. + + + Font style : Oblique. + + + Font style : Italic. + + + + Contains additional properties related to those in DWRITE_GLYPH_RUN. + Microsoft Docs: + + + + An array of characters containing the locale name associated with this run. + + + An array of characters containing the text associated with the glyphs. + + + The number of characters in UTF16 code-units. Note that this may be different than the number of glyphs. + + + An array of indices to the glyph indices array, of the first glyphs of all the glyph clusters of the glyphs to render. + + + Corresponding text position in the string this glyph run came from. This is relative to the beginning of the string represented by the IDWriteTextLayout object. + + + + A value that indicates the typographic feature of text supplied by the font. + Microsoft Docs: + + + + Replaces figures separated by a slash with an alternative form. + +Equivalent OpenType tag: 'afrc' + + + Turns capital characters into petite capitals. It is generally used for words which would otherwise be set in all caps, such as acronyms, but which are desired in petite-cap form to avoid disrupting the flow of text. See the pcap feature description for notes on the relationship of caps, smallcaps and petite caps. + +Equivalent OpenType tag: 'c2pc' + + + Turns capital characters into small capitals. It is generally used for words which would otherwise be set in all caps, such as acronyms, but which are desired in small-cap form to avoid disrupting the flow of text. + +Equivalent OpenType tag: 'c2sc' + + + In specified situations, replaces default glyphs with alternate forms which provide better joining behavior. Used in script typefaces which are designed to have some or all of their glyphs join. + +Equivalent OpenType tag: 'calt' + + + Shifts various punctuation marks up to a position that works better with all-capital sequences or sets of lining figures; also changes oldstyle figures to lining figures. By default, glyphs in a text face are designed to work with lowercase characters. Some characters should be shifted vertically to fit the higher visual center of all-capital or lining text. Also, lining figures are the same height (or close to it) as capitals, and fit much better with all-capital text. + +Equivalent OpenType tag: 'case' + + + To minimize the number of glyph alternates, it is sometimes desired to decompose a character into two glyphs. Additionally, it may be preferable to compose two characters into a single glyph for better glyph processing. This feature permits such composition/decomposition. The feature should be processed as the first feature processed, and should be processed only when it is called. + +Equivalent OpenType tag: 'ccmp' + + + Replaces a sequence of glyphs with a single glyph which is preferred for typographic purposes. Unlike other ligature features, clig specifies the context in which the ligature is recommended. This capability is important in some script designs and for swash ligatures. + +Equivalent OpenType tag: 'clig' + + + Globally adjusts inter-glyph spacing for all-capital text. Most typefaces contain capitals and lowercase characters, and the capitals are positioned to work with the lowercase. When capitals are used for words, they need more space between them for legibility and esthetics. This feature would not apply to monospaced designs. Of course the user may want to override this behavior in order to do more pronounced letterspacing for esthetic reasons. + + + +Equivalent OpenType tag: 'cpsp' + + + Replaces default character glyphs with corresponding swash glyphs in a specified context. Note that there may be more than one swash alternate for a given character. + + + +Equivalent OpenType tag: 'cswh' + + + In cursive scripts like Arabic, this feature cursively positions adjacent glyphs. + +Equivalent OpenType tag: 'curs' + + + The default. + + + Replaces a sequence of glyphs with a single glyph which is preferred for typographic purposes. This feature covers those ligatures which may be used for special effect, at the user's preference. + +Equivalent OpenType tag: 'dlig' + + + Replaces standard forms in Japanese fonts with corresponding forms preferred by typographers. For example, a user would invoke this feature to replace kanji character U+5516 with U+555E. + + +Equivalent OpenType tag: 'expt' + + + Replaces figures separated by a slash with 'common' (diagonal) fractions. + +Equivalent OpenType tag: 'frac' + + + Replaces glyphs set on other widths with glyphs set on full (usually em) widths. In a CJKV font, this may include "lower ASCII" Latin characters and various symbols. In a European font, this feature replaces proportionally-spaced glyphs with monospaced glyphs, which are generally set on widths of 0.6 em. For example, a user may invoke this feature in a Japanese font to get full monospaced Latin glyphs instead of the corresponding proportionally-spaced versions. + +Equivalent OpenType tag: 'fwid' + + + Produces the half forms of consonants in Indic scripts. For example, in Hindi (Devanagari script), the conjunct KKa, obtained by doubling the Ka, is denoted with a half form of Ka followed by the full form. + +Equivalent OpenType tag: 'half' + + + Produces the halant forms of consonants in Indic scripts. For example, in Sanskrit (Devanagari script), syllable final consonants are frequently required in their halant form. + +Equivalent OpenType tag: 'haln' + + + Respaces glyphs designed to be set on full-em widths, fitting them onto half-em widths. This differs from hwid in that it does not substitute new glyphs. + +Equivalent OpenType tag: 'halt' + + + Replaces the default (current) forms with the historical alternates. While some ligatures are also used for historical effect, this feature deals only with single characters. Some fonts include the historical forms as alternates, so they can be used for a 'period' effect. + +Equivalent OpenType tag: 'hist' + + + Replaces standard kana with forms that have been specially designed for only horizontal writing. This is a typographic optimization for improved fit and more even color. + +Equivalent OpenType tag: 'hkna' + + + Replaces the default (current) forms with the historical alternates. Some ligatures were in common use in the past, but appear anachronistic today. Some fonts include the historical forms as alternates, so they can be used for a 'period' effect. + +Equivalent OpenType tag: 'hlig' + + + Replaces glyphs on proportional widths, or fixed widths other than half an em, with glyphs on half-em (en) widths. Many CJKV fonts have glyphs which are set on multiple widths; this feature selects the half-em version. There are various contexts in which this is the preferred behavior, including compatibility with older desktop documents. + +Equivalent OpenType tag: 'hwid' + + + Used to access the JIS X 0212-1990 glyphs for the cases when the JIS X 0213:2004 form is encoded. The JIS X 0212-1990 (aka, "Hojo Kanji") and JIS X 0213:2004 character sets overlap significantly. In some cases their prototypical glyphs differ. When building fonts that support both JIS X 0212-1990 and JIS X 0213:2004 (such as those supporting the Adobe-Japan 1-6 character collection), it is recommended that JIS X 0213:2004 forms be the preferred encoded form. + +Equivalent OpenType tag: 'hojo' + + + The National Language Council (NLC) of Japan has defined new glyph shapes for a number of JIS characters, which were incorporated into JIS X 0213:2004 as new prototypical forms. The 'jp04' feature is A subset of the 'nlck' feature, and is used to access these prototypical glyphs in a manner that maintains the integrity of JIS X 0213:2004. + +Equivalent OpenType tag: 'jp04' + + + Replaces default (JIS90) Japanese glyphs with the corresponding forms from the JIS C 6226-1978 (JIS78) specification. + +Equivalent OpenType tag: 'jp78' + + + Replaces default (JIS90) Japanese glyphs with the corresponding forms from the JIS X 0208-1983 (JIS83) specification. + +Equivalent OpenType tag: 'jp83' + + + Replaces Japanese glyphs from the JIS78 or JIS83 specifications with the corresponding forms from the JIS X 0208-1990 (JIS90) specification. + +Equivalent OpenType tag: 'jp90' + + + Adjusts amount of space between glyphs, generally to provide optically consistent spacing between glyphs. Although a well-designed typeface has consistent inter-glyph spacing overall, some glyph combinations require adjustment for improved legibility. Besides standard adjustment in the horizontal direction, this feature can supply size-dependent kerning data via device tables, "cross-stream" kerning in the Y text direction, and adjustment of glyph placement independent of the advance adjustment. Note that this feature may apply to runs of more than two glyphs, and would not be used in monospaced fonts. Also note that this feature does not apply to text set vertically. + +Equivalent OpenType tag: 'kern' + + + Replaces a sequence of glyphs with a single glyph which is preferred for typographic purposes. This feature covers the ligatures which the designer/manufacturer judges should be used in normal conditions. + +Equivalent OpenType tag: 'liga' + + + Changes selected figures from oldstyle to the default lining form. For example, a user may invoke this feature in order to get lining figures, which fit better with all-capital text. This feature overrides results of the Oldstyle Figures feature (onum). + +Equivalent OpenType tag: 'lnum' + + + Enables localized forms of glyphs to be substituted for default forms. Many scripts used to write multiple languages over wide geographical areas have developed localized variant forms of specific letters, which are used by individual literary communities. For example, a number of letters in the Bulgarian and Serbian alphabets have forms distinct from their Russian counterparts and from each other. In some cases the localized form differs only subtly from the script 'norm', in others the forms are radically distinct. + +Equivalent OpenType tag: 'locl' + + + Positions mark glyphs with respect to base glyphs. For example, in Arabic script positioning the Hamza above the Yeh. + +Equivalent OpenType tag: 'mark' + + + Replaces standard typographic forms of Greek glyphs with corresponding forms commonly used in mathematical notation (which are a subset of the Greek alphabet). + +Equivalent OpenType tag: 'mgrk' + + + Positions marks with respect to other marks. Required in various non-Latin scripts like Arabic. For example, in Arabic, the ligaturised mark Ha with Hamza above it can also be obtained by positioning these marks relative to one another. + +Equivalent OpenType tag: 'mkmk' + + + Replaces default glyphs with various notational forms (such as glyphs placed in open or solid circles, squares, parentheses, diamonds or rounded boxes). In some cases an annotation form may already be present, but the user may want a different one. + +Equivalent OpenType tag: 'nalt' + + + Used to access glyphs made from glyph shapes defined by the National Language Council (NLC) of Japan for a number of JIS characters in 2000. + +Equivalent OpenType tag: 'nlck' + + + Changes selected figures from the default lining style to oldstyle form. For example, a user may invoke this feature to get oldstyle figures, which fit better into the flow of normal upper- and lowercase text. This feature overrides results of the Lining Figures feature (lnum). + +Equivalent OpenType tag: 'onum' + + + Replaces default alphabetic glyphs with the corresponding ordinal forms for use after figures. One exception to the follows-a-figure rule is the numero character (U+2116), which is actually a ligature substitution, but is best accessed through this feature. + +Equivalent OpenType tag: 'ordn' + + + Respaces glyphs designed to be set on full-em widths, fitting them onto individual (more or less proportional) horizontal widths. This differs from pwid in that it does not substitute new glyphs (GPOS, not GSUB feature). The user may prefer the monospaced form, or may simply want to ensure that the glyph is well-fit and not rotated in vertical setting (Latin forms designed for proportional spacing would be rotated). + +Equivalent OpenType tag: 'palt' + + + Turns lowercase characters into petite capitals. Forms related to petite capitals, such as specially designed figures, may be included. Some fonts contain an additional size of capital letters, shorter than the regular smallcaps and it is referred to as petite caps. Such forms are most likely to be found in designs with a small lowercase x-height, where they better harmonise with lowercase text than the taller smallcaps (for examples of petite caps, see the Emigre type families Mrs Eaves and Filosofia). + +Equivalent OpenType tag: 'pcap' + + + Replaces figure glyphs set on uniform (tabular) widths with corresponding glyphs set on glyph-specific (proportional) widths. Tabular widths will generally be the default, but this cannot be safely assumed. Of course this feature would not be present in monospaced designs. + +Equivalent OpenType tag: 'pnum' + + + Replaces glyphs set on uniform widths (typically full or half-em) with proportionally spaced glyphs. The proportional variants are often used for the Latin characters in CJKV fonts, but may also be used for Kana in Japanese fonts. + +Equivalent OpenType tag: 'pwid' + + + Replaces glyphs on other widths with glyphs set on widths of one quarter of an em (half an en). The characters involved are normally figures and some forms of punctuation. + +Equivalent OpenType tag: 'qwid' + + + Replaces a sequence of glyphs with a single glyph which is preferred for typographic purposes. This feature covers those ligatures, which the script determines as required to be used in normal conditions. This feature is important for some scripts to ensure correct glyph formation. + +Equivalent OpenType tag: 'rlig' + + + Identifies glyphs in the font which have been designed for "ruby", from the old typesetting term for four-point-sized type. Japanese typesetting often uses smaller kana glyphs, generally in superscripted form, to clarify the meaning of kanji which may be unfamiliar to the reader. + +Equivalent OpenType tag: 'ruby' + + + Replaces the default forms with the stylistic alternates. Many fonts contain alternate glyph designs for a purely esthetic effect; these don't always fit into a clear category like swash or historical. As in the case of swash glyphs, there may be more than one alternate form. + +Equivalent OpenType tag: 'salt' + + + Replaces lining or oldstyle figures with inferior figures (smaller glyphs which sit lower than the standard baseline, primarily for chemical or mathematical notation). May also replace lowercase characters with alphabetic inferiors. + +Equivalent OpenType tag: 'sinf' + + + Turns lowercase characters into small capitals. This corresponds to the common SC font layout. It is generally used for display lines set in Large & small caps, such as titles. Forms related to small capitals, such as oldstyle figures, may be included. + +Equivalent OpenType tag: 'smcp' + + + Replaces 'traditional' Chinese or Japanese forms with the corresponding 'simplified' forms. + +Equivalent OpenType tag: 'smpl' + + + In addition to, or instead of, stylistic alternatives of individual glyphs (see 'salt' feature), some fonts may contain sets of stylistic variant glyphs corresponding to portions of the character set, such as multiple variants for lowercase letters in a Latin font. Glyphs in stylistic sets may be designed to harmonise visually, interract in particular ways, or otherwise work together. Examples of fonts including stylistic sets are Zapfino Linotype and Adobe's Poetica. Individual features numbered sequentially with the tag name convention 'ss01' 'ss02' 'ss03' . 'ss20' provide a mechanism for glyphs in these sets to be associated via GSUB lookup indexes to default forms and to each other, and for users to select from available stylistic sets + +Equivalent OpenType tag: 'ss01' + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. + +Equivalent OpenType tag: 'ss02' + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. + +Equivalent OpenType tag: 'ss03' + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. + +Equivalent OpenType tag: 'ss04' + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. + +Equivalent OpenType tag: 'ss05' + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. + +Equivalent OpenType tag: 'ss06' + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. + +Equivalent OpenType tag: 'ss07' + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. + +Equivalent OpenType tag: 'ss08' + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. + +Equivalent OpenType tag: 'ss09' + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. + +Equivalent OpenType tag: 'ss10' + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. + +Equivalent OpenType tag: 'ss11' + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. + +Equivalent OpenType tag: 'ss12' + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. + +Equivalent OpenType tag: 'ss13' + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. + +Equivalent OpenType tag: 'ss14' + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. + +Equivalent OpenType tag: 'ss15' + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. + +Equivalent OpenType tag: 'ss16' + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. + +Equivalent OpenType tag: 'ss17' + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. + +Equivalent OpenType tag: 'ss18' + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. + +Equivalent OpenType tag: 'ss19' + + + See the description for DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1. + +Equivalent OpenType tag: 'ss20' + + + May replace a default glyph with a subscript glyph, or it may combine a glyph substitution with positioning adjustments for proper placement. + +Equivalent OpenType tag: 'subs' + + + Replaces lining or oldstyle figures with superior figures (primarily for footnote indication), and replaces lowercase letters with superior letters (primarily for abbreviated French titles). + +Equivalent OpenType tag: 'sups' + + + Replaces default character glyphs with corresponding swash glyphs. Note that there may be more than one swash alternate for a given character. + +Equivalent OpenType tag: 'swsh' + + + Replaces the default glyphs with corresponding forms designed specifically for titling. These may be all-capital and/or larger on the body, and adjusted for viewing at larger sizes. + +Equivalent OpenType tag: 'titl' + + + Replaces 'simplified' Japanese kanji forms with the corresponding 'traditional' forms. This is equivalent to the Traditional Forms feature, but explicitly limited to the traditional forms considered proper for use in personal names (as many as 205 glyphs in some fonts). + +Equivalent OpenType tag: 'tnam' + + + Replaces figure glyphs set on proportional widths with corresponding glyphs set on uniform (tabular) widths. Tabular widths will generally be the default, but this cannot be safely assumed. Of course this feature would not be present in monospaced designs. + +Equivalent OpenType tag: 'tnum' + + + Replaces 'simplified' Chinese hanzi or Japanese kanji forms with the corresponding 'traditional' forms. + +Equivalent OpenType tag: 'trad' + + + Replaces glyphs on other widths with glyphs set on widths of one third of an em. The characters involved are normally figures and some forms of punctuation. + +Equivalent OpenType tag: 'twid' + + + Maps upper- and lowercase letters to a mixed set of lowercase and small capital forms, resulting in a single case alphabet (for an example of unicase, see the Emigre type family Filosofia). The letters substituted may vary from font to font, as appropriate to the design. If aligning to the x-height, smallcap glyphs may be substituted, or specially designed unicase forms might be used. Substitutions might also include specially designed figures. + + +Equivalent OpenType tag: 'unic' + + + Indicates that the font is displayed vertically. + + + Replaces normal figures with figures adjusted for vertical display. + + + Allows the user to change from the default 0 to a slashed form. Some fonts contain both a default form of zero, and an alternative form which uses a diagonal slash through the counter. Especially in condensed designs, it can be difficult to distinguish between 0 and O (zero and capital O) in any situation where capitals and lining figures may be arbitrarily mixed. + +Equivalent OpenType tag: 'zero' + + + + Specifies the text granularity used to trim text overflowing the layout box. + Microsoft Docs: + + + + No trimming occurs. Text flows beyond the layout width. + + + Trimming occurs at a character cluster boundary. + + + Trimming occurs at a word boundary. + + + + Contains information about a formatted line of text. + Microsoft Docs: + + + + The number of text positions in the text line. + This includes any trailing whitespace and newline characters. + + + The number of whitespace positions at the end of the text line. + Newline sequences are considered whitespace. + + + The number of characters in the newline sequence at the end of the text line. + If the count is zero, then the text line was either wrapped or it is the end of the text. + + + The height of the text line. + + + The distance from the top of the text line to its baseline. + + + The line is trimmed. + + + + The DWRITE_FONT_METRICS structure specifies the metrics that are applicable to all glyphs within the font face. + Microsoft Docs: + + + + The number of font design units per em unit. Font files use their own coordinate system of font design units. A font design unit is the smallest measurable unit in the em square, an imaginary square that is used to size and align glyphs. The concept of em square is used as a reference scale factor when defining font size and device transformation semantics. The size of one em square is also commonly used to compute the paragraph identation value. + + + The ascent value of the font face in font design units. Ascent is the distance from the top of font character alignment box to the English baseline. + + + The descent value of the font face in font design units. Descent is the distance from the bottom of font character alignment box to the English baseline. + + + The line gap in font design units. Recommended additional white space to add between lines to improve legibility. The recommended line spacing (baseline-to-baseline distance) is the sum of ascent, descent, and lineGap. The line gap is usually positive or zero but can be negative, in which case the recommended line spacing is less than the height of the character alignment box. + + + The cap height value of the font face in font design units. Cap height is the distance from the English baseline to the top of a typical English capital. Capital "H" is often used as a reference character for the purpose of calculating the cap height value. + + + The x-height value of the font face in font design units. x-height is the distance from the English baseline to the top of lowercase letter "x", or a similar lowercase character. + + + The underline position value of the font face in font design units. Underline position is the position of underline relative to the English baseline. The value is usually made negative in order to place the underline below the baseline. + + + The suggested underline thickness value of the font face in font design units. + + + The strikethrough position value of the font face in font design units. Strikethrough position is the position of strikethrough relative to the English baseline. The value is usually made positive in order to place the strikethrough above the baseline. + + + The suggested strikethrough thickness value of the font face in font design units. + + + + The DWRITE_FONT_METRICS1 structure specifies the metrics that are applicable to all glyphs within the font face. + Microsoft Docs: + + + + Left edge of accumulated bounding blackbox of all glyphs in the font. + + + Top edge of accumulated bounding blackbox of all glyphs in the font. + + + Right edge of accumulated bounding blackbox of all glyphs in the font. + + + Bottom edge of accumulated bounding blackbox of all glyphs in the font. + + + Horizontal position of the subscript relative to the baseline origin. This is typically negative (to the left) in italic and oblique fonts, and zero in regular fonts. + + + Vertical position of the subscript relative to the baseline. This is typically negative. + + + Horizontal size of the subscript em box in design units, used to scale the simulated subscript relative to the full em box size. This is the numerator of the scaling ratio where denominator is the design units per em. If this member is zero, the font does not specify a scale factor, and the client uses its own policy. + + + Vertical size of the subscript em box in design units, used to scale the simulated subscript relative to the full em box size. This is the numerator of the scaling ratio where denominator is the design units per em. If this member is zero, the font does not specify a scale factor, and the client uses its own policy. + + + Horizontal position of the superscript relative to the baseline origin. This is typically positive (to the right) in italic and oblique fonts, and zero in regular fonts. + + + Vertical position of the superscript relative to the baseline. This is typically positive. + + + Horizontal size of the superscript em box in design units, used to scale the simulated superscript relative to the full em box size. This is the numerator of the scaling ratio where denominator is the design units per em. If this member is zero, the font does not specify a scale factor, and the client should use its own policy. + + + Vertical size of the superscript em box in design units, used to scale the simulated superscript relative to the full em box size. This is the numerator of the scaling ratio where denominator is the design units per em. If this member is zero, the font does not specify a scale factor, and the client should use its own policy. + + + A Boolean value that indicates that the ascent, descent, and lineGap are based on newer 'typographic' values in the font, rather than legacy values. + + \ No newline at end of file diff --git a/src/Vortice.Win32/Generated/Graphics/Direct2D.Common.cs b/src/Vortice.Win32/Generated/Graphics/Direct2D.Common.cs index 77b255a..d34c96a 100644 --- a/src/Vortice.Win32/Generated/Graphics/Direct2D.Common.cs +++ b/src/Vortice.Win32/Generated/Graphics/Direct2D.Common.cs @@ -478,7 +478,6 @@ public unsafe partial struct ID2D1SimplifiedGeometrySink { return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID2D1SimplifiedGeometrySink*)Unsafe.AsPointer(ref this)); } - } #endregion Com Types diff --git a/src/Vortice.Win32/Generated/Graphics/Direct3D.Dxc.cs b/src/Vortice.Win32/Generated/Graphics/Direct3D.Dxc.cs index 4bb8d4f..aefa9b2 100644 --- a/src/Vortice.Win32/Generated/Graphics/Direct3D.Dxc.cs +++ b/src/Vortice.Win32/Generated/Graphics/Direct3D.Dxc.cs @@ -511,7 +511,6 @@ public unsafe partial struct IDxcBlob { return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDxcBlob*)Unsafe.AsPointer(ref this)); } - } /// @@ -598,7 +597,6 @@ public unsafe partial struct IDxcBlobEncoding { return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDxcBlobEncoding*)Unsafe.AsPointer(ref this), pKnown, pCodePage); } - } /// @@ -701,7 +699,6 @@ public unsafe partial struct IDxcBlobUtf16 { return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDxcBlobUtf16*)Unsafe.AsPointer(ref this)); } - } /// @@ -804,7 +801,6 @@ public unsafe partial struct IDxcBlobUtf8 { return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDxcBlobUtf8*)Unsafe.AsPointer(ref this)); } - } /// @@ -875,7 +871,6 @@ public unsafe partial struct IDxcIncludeHandler { return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcIncludeHandler*)Unsafe.AsPointer(ref this), pFilename, ppIncludeSource); } - } /// @@ -978,7 +973,6 @@ public unsafe partial struct IDxcCompilerArgs { return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDxcCompilerArgs*)Unsafe.AsPointer(ref this), pDefines, defineCount); } - } /// @@ -1121,7 +1115,6 @@ public unsafe partial struct IDxcLibrary { return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDxcLibrary*)Unsafe.AsPointer(ref this), pBlob, pBlobEncoding); } - } /// @@ -1208,7 +1201,6 @@ public unsafe partial struct IDxcOperationResult { return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDxcOperationResult*)Unsafe.AsPointer(ref this), ppErrors); } - } /// @@ -1295,7 +1287,6 @@ public unsafe partial struct IDxcCompiler { return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDxcCompiler*)Unsafe.AsPointer(ref this), pSource, ppDisassembly); } - } /// @@ -1390,7 +1381,6 @@ public unsafe partial struct IDxcCompiler2 { return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDxcCompiler2*)Unsafe.AsPointer(ref this), pSource, pSourceName, pEntryPoint, pTargetProfile, pArguments, argCount, pDefines, defineCount, pIncludeHandler, ppResult, ppDebugBlobName, ppDebugBlob); } - } /// @@ -1469,7 +1459,6 @@ public unsafe partial struct IDxcLinker { return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDxcLinker*)Unsafe.AsPointer(ref this), pEntryName, pTargetProfile, pLibNames, libCount, pArguments, argCount, ppResult); } - } /// @@ -1636,7 +1625,6 @@ public unsafe partial struct IDxcUtils { return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDxcUtils*)Unsafe.AsPointer(ref this), pPDBBlob, ppHash, ppContainer); } - } /// @@ -1763,7 +1751,6 @@ public unsafe partial struct IDxcResult { return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDxcResult*)Unsafe.AsPointer(ref this)); } - } /// @@ -1842,7 +1829,6 @@ public unsafe partial struct IDxcExtraOutputs { return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDxcExtraOutputs*)Unsafe.AsPointer(ref this), uIndex, iid, ppvObject, ppOutputType, ppOutputName); } - } /// @@ -1921,7 +1907,6 @@ public unsafe partial struct IDxcCompiler3 { return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDxcCompiler3*)Unsafe.AsPointer(ref this), pObject, riid, ppResult); } - } /// @@ -1992,7 +1977,6 @@ public unsafe partial struct IDxcValidator { return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcValidator*)Unsafe.AsPointer(ref this), pShader, Flags, ppResult); } - } /// @@ -2071,7 +2055,6 @@ public unsafe partial struct IDxcValidator2 { return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDxcValidator2*)Unsafe.AsPointer(ref this), pShader, Flags, pOptDebugBitcode, ppResult); } - } /// @@ -2166,7 +2149,6 @@ public unsafe partial struct IDxcContainerBuilder { return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDxcContainerBuilder*)Unsafe.AsPointer(ref this), ppResult); } - } /// @@ -2237,7 +2219,6 @@ public unsafe partial struct IDxcAssembler { return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcAssembler*)Unsafe.AsPointer(ref this), pShader, ppResult); } - } /// @@ -2348,7 +2329,6 @@ public unsafe partial struct IDxcContainerReflection { return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDxcContainerReflection*)Unsafe.AsPointer(ref this), idx, iid, ppvObject); } - } /// @@ -2451,7 +2431,6 @@ public unsafe partial struct IDxcOptimizerPass { return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDxcOptimizerPass*)Unsafe.AsPointer(ref this), argIndex, ppResult); } - } /// @@ -2538,7 +2517,6 @@ public unsafe partial struct IDxcOptimizer { return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDxcOptimizer*)Unsafe.AsPointer(ref this), pBlob, ppOptions, optionCount, pOutputModule, ppOutputText); } - } /// @@ -2617,7 +2595,6 @@ public unsafe partial struct IDxcVersionInfo { return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDxcVersionInfo*)Unsafe.AsPointer(ref this), pFlags); } - } /// @@ -2704,7 +2681,6 @@ public unsafe partial struct IDxcVersionInfo2 { return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDxcVersionInfo2*)Unsafe.AsPointer(ref this), pCommitCount, pCommitHash); } - } /// @@ -2775,7 +2751,6 @@ public unsafe partial struct IDxcVersionInfo3 { return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDxcVersionInfo3*)Unsafe.AsPointer(ref this), pVersionString); } - } /// @@ -3030,7 +3005,6 @@ public unsafe partial struct IDxcPdbUtils { return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((IDxcPdbUtils*)Unsafe.AsPointer(ref this), pRootSignature); } - } #endregion Com Types diff --git a/src/Vortice.Win32/Generated/Graphics/Direct3D.cs b/src/Vortice.Win32/Generated/Graphics/Direct3D.cs index 1958665..bceb106 100644 --- a/src/Vortice.Win32/Generated/Graphics/Direct3D.cs +++ b/src/Vortice.Win32/Generated/Graphics/Direct3D.cs @@ -1296,7 +1296,6 @@ public unsafe partial struct ID3DBlob { return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3DBlob*)Unsafe.AsPointer(ref this)); } - } /// @@ -1375,7 +1374,6 @@ public unsafe partial struct ID3DDestructionNotifier { return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3DDestructionNotifier*)Unsafe.AsPointer(ref this), callbackID); } - } /// @@ -1399,7 +1397,6 @@ public unsafe partial struct ID3DInclude { return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((ID3DInclude*)Unsafe.AsPointer(ref this), pData); } - } #endregion Com Types diff --git a/src/Vortice.Win32/Generated/Graphics/Direct3D11.cs b/src/Vortice.Win32/Generated/Graphics/Direct3D11.cs index 1af26d6..9aa94e7 100644 --- a/src/Vortice.Win32/Generated/Graphics/Direct3D11.cs +++ b/src/Vortice.Win32/Generated/Graphics/Direct3D11.cs @@ -13492,7 +13492,6 @@ public unsafe partial struct ID3D11DeviceChild { return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11DeviceChild*)Unsafe.AsPointer(ref this), guid, pData); } - } /// @@ -13595,7 +13594,6 @@ public unsafe partial struct ID3D11DepthStencilState { ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11DepthStencilState*)Unsafe.AsPointer(ref this), pDesc); } - } /// @@ -13698,7 +13696,6 @@ public unsafe partial struct ID3D11BlendState { ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11BlendState*)Unsafe.AsPointer(ref this), pDesc); } - } /// @@ -13801,7 +13798,6 @@ public unsafe partial struct ID3D11RasterizerState { ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11RasterizerState*)Unsafe.AsPointer(ref this), pDesc); } - } /// @@ -13920,7 +13916,6 @@ public unsafe partial struct ID3D11Resource { return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11Resource*)Unsafe.AsPointer(ref this)); } - } /// @@ -14047,7 +14042,6 @@ public unsafe partial struct ID3D11Buffer { ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11Buffer*)Unsafe.AsPointer(ref this), pDesc); } - } /// @@ -14174,7 +14168,6 @@ public unsafe partial struct ID3D11Texture1D { ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11Texture1D*)Unsafe.AsPointer(ref this), pDesc); } - } /// @@ -14301,7 +14294,6 @@ public unsafe partial struct ID3D11Texture2D { ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11Texture2D*)Unsafe.AsPointer(ref this), pDesc); } - } /// @@ -14428,7 +14420,6 @@ public unsafe partial struct ID3D11Texture3D { ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11Texture3D*)Unsafe.AsPointer(ref this), pDesc); } - } /// @@ -14531,7 +14522,6 @@ public unsafe partial struct ID3D11View { ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11View*)Unsafe.AsPointer(ref this), ppResource); } - } /// @@ -14642,7 +14632,6 @@ public unsafe partial struct ID3D11ShaderResourceView { ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11ShaderResourceView*)Unsafe.AsPointer(ref this), pDesc); } - } /// @@ -14753,7 +14742,6 @@ public unsafe partial struct ID3D11RenderTargetView { ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11RenderTargetView*)Unsafe.AsPointer(ref this), pDesc); } - } /// @@ -14864,7 +14852,6 @@ public unsafe partial struct ID3D11DepthStencilView { ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11DepthStencilView*)Unsafe.AsPointer(ref this), pDesc); } - } /// @@ -14975,7 +14962,6 @@ public unsafe partial struct ID3D11UnorderedAccessView { ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11UnorderedAccessView*)Unsafe.AsPointer(ref this), pDesc); } - } /// @@ -15070,7 +15056,6 @@ public unsafe partial struct ID3D11VertexShader { return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11VertexShader*)Unsafe.AsPointer(ref this), guid, pData); } - } /// @@ -15165,7 +15150,6 @@ public unsafe partial struct ID3D11HullShader { return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11HullShader*)Unsafe.AsPointer(ref this), guid, pData); } - } /// @@ -15260,7 +15244,6 @@ public unsafe partial struct ID3D11DomainShader { return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11DomainShader*)Unsafe.AsPointer(ref this), guid, pData); } - } /// @@ -15355,7 +15338,6 @@ public unsafe partial struct ID3D11GeometryShader { return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11GeometryShader*)Unsafe.AsPointer(ref this), guid, pData); } - } /// @@ -15450,7 +15432,6 @@ public unsafe partial struct ID3D11PixelShader { return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11PixelShader*)Unsafe.AsPointer(ref this), guid, pData); } - } /// @@ -15545,7 +15526,6 @@ public unsafe partial struct ID3D11ComputeShader { return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11ComputeShader*)Unsafe.AsPointer(ref this), guid, pData); } - } /// @@ -15640,7 +15620,6 @@ public unsafe partial struct ID3D11InputLayout { return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11InputLayout*)Unsafe.AsPointer(ref this), guid, pData); } - } /// @@ -15743,7 +15722,6 @@ public unsafe partial struct ID3D11SamplerState { ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11SamplerState*)Unsafe.AsPointer(ref this), pDesc); } - } /// @@ -15846,7 +15824,6 @@ public unsafe partial struct ID3D11Asynchronous { return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11Asynchronous*)Unsafe.AsPointer(ref this)); } - } /// @@ -15957,7 +15934,6 @@ public unsafe partial struct ID3D11Query { ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11Query*)Unsafe.AsPointer(ref this), pDesc); } - } /// @@ -16068,7 +16044,6 @@ public unsafe partial struct ID3D11Predicate { return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11Predicate*)Unsafe.AsPointer(ref this), guid, pData); } - } /// @@ -16179,7 +16154,6 @@ public unsafe partial struct ID3D11Counter { ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11Counter*)Unsafe.AsPointer(ref this), pDesc); } - } /// @@ -16306,7 +16280,6 @@ public unsafe partial struct ID3D11ClassInstance { ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11ClassInstance*)Unsafe.AsPointer(ref this), pTypeName, pBufferLength); } - } /// @@ -16417,7 +16390,6 @@ public unsafe partial struct ID3D11ClassLinkage { return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11ClassLinkage*)Unsafe.AsPointer(ref this), pClassTypeName, ConstantBufferOffset, ConstantVectorOffset, TextureOffset, SamplerOffset, ppInstance); } - } /// @@ -16520,7 +16492,6 @@ public unsafe partial struct ID3D11CommandList { return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D11CommandList*)Unsafe.AsPointer(ref this)); } - } /// @@ -17479,7 +17450,6 @@ public unsafe partial struct ID3D11DeviceContext { return ((delegate* unmanaged[Stdcall])(lpVtbl[114]))((ID3D11DeviceContext*)Unsafe.AsPointer(ref this), RestoreDeferredContextState, ppCommandList); } - } /// @@ -17590,7 +17560,6 @@ public unsafe partial struct ID3D11VideoDecoder { return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11VideoDecoder*)Unsafe.AsPointer(ref this), pDriverHandle); } - } /// @@ -17733,7 +17702,6 @@ public unsafe partial struct ID3D11VideoProcessorEnumerator { return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D11VideoProcessorEnumerator*)Unsafe.AsPointer(ref this), Filter, pRange); } - } /// @@ -17844,7 +17812,6 @@ public unsafe partial struct ID3D11VideoProcessor { ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11VideoProcessor*)Unsafe.AsPointer(ref this), pCaps); } - } /// @@ -17963,7 +17930,6 @@ public unsafe partial struct ID3D11AuthenticatedChannel { ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11AuthenticatedChannel*)Unsafe.AsPointer(ref this), pChannelHandle); } - } /// @@ -18098,7 +18064,6 @@ public unsafe partial struct ID3D11CryptoSession { ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11CryptoSession*)Unsafe.AsPointer(ref this), pCryptoSessionHandle); } - } /// @@ -18209,7 +18174,6 @@ public unsafe partial struct ID3D11VideoDecoderOutputView { ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11VideoDecoderOutputView*)Unsafe.AsPointer(ref this), pDesc); } - } /// @@ -18320,7 +18284,6 @@ public unsafe partial struct ID3D11VideoProcessorInputView { ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11VideoProcessorInputView*)Unsafe.AsPointer(ref this), pDesc); } - } /// @@ -18431,7 +18394,6 @@ public unsafe partial struct ID3D11VideoProcessorOutputView { ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11VideoProcessorOutputView*)Unsafe.AsPointer(ref this), pDesc); } - } /// @@ -18990,7 +18952,6 @@ public unsafe partial struct ID3D11VideoContext { ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((ID3D11VideoContext*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pEnable, pRotation); } - } /// @@ -19189,7 +19150,6 @@ public unsafe partial struct ID3D11VideoDevice { return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((ID3D11VideoDevice*)Unsafe.AsPointer(ref this), guid, pData); } - } /// @@ -19572,7 +19532,6 @@ public unsafe partial struct ID3D11Device { return ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((ID3D11Device*)Unsafe.AsPointer(ref this)); } - } /// @@ -19707,7 +19666,6 @@ public unsafe partial struct ID3D11Debug { return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11Debug*)Unsafe.AsPointer(ref this), pContext); } - } /// @@ -19786,7 +19744,6 @@ public unsafe partial struct ID3D11SwitchToRef { return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11SwitchToRef*)Unsafe.AsPointer(ref this)); } - } /// @@ -19865,7 +19822,6 @@ public unsafe partial struct ID3D11TracingDevice { return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11TracingDevice*)Unsafe.AsPointer(ref this), pShader, Options); } - } /// @@ -19936,7 +19892,6 @@ public unsafe partial struct ID3D11RefTrackingOptions { return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11RefTrackingOptions*)Unsafe.AsPointer(ref this), uOptions); } - } /// @@ -20007,7 +19962,6 @@ public unsafe partial struct ID3D11RefDefaultTrackingOptions { return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11RefDefaultTrackingOptions*)Unsafe.AsPointer(ref this), ResourceTypeFlags, Options); } - } /// @@ -20350,7 +20304,6 @@ public unsafe partial struct ID3D11InfoQueue { return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D11InfoQueue*)Unsafe.AsPointer(ref this)); } - } /// @@ -20461,7 +20414,6 @@ public unsafe partial struct ID3D11BlendState1 { ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11BlendState1*)Unsafe.AsPointer(ref this), pDesc); } - } /// @@ -20572,7 +20524,6 @@ public unsafe partial struct ID3D11RasterizerState1 { ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D11RasterizerState1*)Unsafe.AsPointer(ref this), pDesc); } - } /// @@ -20667,7 +20618,6 @@ public unsafe partial struct ID3DDeviceContextState { return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3DDeviceContextState*)Unsafe.AsPointer(ref this), guid, pData); } - } /// @@ -21778,7 +21728,6 @@ public unsafe partial struct ID3D11DeviceContext1 { ((delegate* unmanaged[Stdcall])(lpVtbl[133]))((ID3D11DeviceContext1*)Unsafe.AsPointer(ref this), pResourceView, pRects, NumRects); } - } /// @@ -22449,7 +22398,6 @@ public unsafe partial struct ID3D11VideoContext1 { return ((delegate* unmanaged[Stdcall])(lpVtbl[78]))((ID3D11VideoContext1*)Unsafe.AsPointer(ref this), pVideoProcessor, OutputWidth, OutputHeight, OutputFormat, StreamCount, pStreams, pBehaviorHints); } - } /// @@ -22680,7 +22628,6 @@ public unsafe partial struct ID3D11VideoDevice1 { return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((ID3D11VideoDevice1*)Unsafe.AsPointer(ref this), pInputDesc, InputColorSpace, pInputConfig, pFrameRate, pRecommendedOutputDesc); } - } /// @@ -22831,7 +22778,6 @@ public unsafe partial struct ID3D11VideoProcessorEnumerator1 { return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D11VideoProcessorEnumerator1*)Unsafe.AsPointer(ref this), InputFormat, InputColorSpace, OutputFormat, OutputColorSpace, pSupported); } - } /// @@ -23270,7 +23216,6 @@ public unsafe partial struct ID3D11Device1 { return ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((ID3D11Device1*)Unsafe.AsPointer(ref this), lpName, dwDesiredAccess, returnedInterface, ppResource); } - } /// @@ -23365,7 +23310,6 @@ public unsafe partial struct ID3DUserDefinedAnnotation { return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3DUserDefinedAnnotation*)Unsafe.AsPointer(ref this)); } - } /// @@ -24556,7 +24500,6 @@ public unsafe partial struct ID3D11DeviceContext2 { ((delegate* unmanaged[Stdcall])(lpVtbl[143]))((ID3D11DeviceContext2*)Unsafe.AsPointer(ref this)); } - } /// @@ -25027,7 +24970,6 @@ public unsafe partial struct ID3D11Device2 { return ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((ID3D11Device2*)Unsafe.AsPointer(ref this), Format, SampleCount, Flags, pNumQualityLevels); } - } /// @@ -25162,7 +25104,6 @@ public unsafe partial struct ID3D11Texture2D1 { ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11Texture2D1*)Unsafe.AsPointer(ref this), pDesc); } - } /// @@ -25297,7 +25238,6 @@ public unsafe partial struct ID3D11Texture3D1 { ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D11Texture3D1*)Unsafe.AsPointer(ref this), pDesc); } - } /// @@ -25416,7 +25356,6 @@ public unsafe partial struct ID3D11RasterizerState2 { ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11RasterizerState2*)Unsafe.AsPointer(ref this), pDesc); } - } /// @@ -25535,7 +25474,6 @@ public unsafe partial struct ID3D11ShaderResourceView1 { ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11ShaderResourceView1*)Unsafe.AsPointer(ref this), pDesc1); } - } /// @@ -25654,7 +25592,6 @@ public unsafe partial struct ID3D11RenderTargetView1 { ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11RenderTargetView1*)Unsafe.AsPointer(ref this), pDesc1); } - } /// @@ -25773,7 +25710,6 @@ public unsafe partial struct ID3D11UnorderedAccessView1 { ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11UnorderedAccessView1*)Unsafe.AsPointer(ref this), pDesc1); } - } /// @@ -25892,7 +25828,6 @@ public unsafe partial struct ID3D11Query1 { ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11Query1*)Unsafe.AsPointer(ref this), pDesc1); } - } /// @@ -27107,7 +27042,6 @@ public unsafe partial struct ID3D11DeviceContext3 { ((delegate* unmanaged[Stdcall])(lpVtbl[146]))((ID3D11DeviceContext3*)Unsafe.AsPointer(ref this), pHwProtectionEnable); } - } /// @@ -27226,7 +27160,6 @@ public unsafe partial struct ID3D11Fence { return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D11Fence*)Unsafe.AsPointer(ref this), Value, hEvent); } - } /// @@ -28457,7 +28390,6 @@ public unsafe partial struct ID3D11DeviceContext4 { return ((delegate* unmanaged[Stdcall])(lpVtbl[148]))((ID3D11DeviceContext4*)Unsafe.AsPointer(ref this), pFence, Value); } - } /// @@ -29016,7 +28948,6 @@ public unsafe partial struct ID3D11Device3 { ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((ID3D11Device3*)Unsafe.AsPointer(ref this), pDstData, DstRowPitch, DstDepthPitch, pSrcResource, SrcSubresource, pSrcBox); } - } /// @@ -29591,7 +29522,6 @@ public unsafe partial struct ID3D11Device4 { ((delegate* unmanaged[Stdcall])(lpVtbl[66]))((ID3D11Device4*)Unsafe.AsPointer(ref this), dwCookie); } - } /// @@ -30182,7 +30112,6 @@ public unsafe partial struct ID3D11Device5 { return ((delegate* unmanaged[Stdcall])(lpVtbl[68]))((ID3D11Device5*)Unsafe.AsPointer(ref this), InitialValue, Flags, ReturnedInterface, ppFence); } - } /// @@ -30277,7 +30206,6 @@ public unsafe partial struct ID3D11Multithread { return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11Multithread*)Unsafe.AsPointer(ref this)); } - } /// @@ -30980,7 +30908,6 @@ public unsafe partial struct ID3D11VideoContext2 { ((delegate* unmanaged[Stdcall])(lpVtbl[82]))((ID3D11VideoContext2*)Unsafe.AsPointer(ref this), pVideoProcessor, StreamIndex, pType, Size, pMetaData); } - } /// @@ -31227,7 +31154,6 @@ public unsafe partial struct ID3D11VideoDevice2 { return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((ID3D11VideoDevice2*)Unsafe.AsPointer(ref this), pCryptoSession, flags, DataSize, pData); } - } /// @@ -31946,7 +31872,6 @@ public unsafe partial struct ID3D11VideoContext3 { return ((delegate* unmanaged[Stdcall])(lpVtbl[84]))((ID3D11VideoContext3*)Unsafe.AsPointer(ref this), pDecoder, NumBuffers, pBufferDesc); } - } /// @@ -32069,7 +31994,6 @@ public unsafe partial struct ID3D11ShaderReflectionType { return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), pBase); } - } /// @@ -32136,7 +32060,6 @@ public unsafe partial struct ID3D11ShaderReflectionVariable { return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11ShaderReflectionVariable*)Unsafe.AsPointer(ref this), uArrayIndex); } - } /// @@ -32195,7 +32118,6 @@ public unsafe partial struct ID3D11ShaderReflectionConstantBuffer { return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((ID3D11ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Name); } - } /// @@ -32410,7 +32332,6 @@ public unsafe partial struct ID3D11ShaderReflection { return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this)); } - } /// @@ -32489,7 +32410,6 @@ public unsafe partial struct ID3D11LibraryReflection { return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D11LibraryReflection*)Unsafe.AsPointer(ref this), FunctionIndex); } - } /// @@ -32580,7 +32500,6 @@ public unsafe partial struct ID3D11FunctionReflection { return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), ParameterIndex); } - } /// @@ -32623,7 +32542,6 @@ public unsafe partial struct ID3D11FunctionParameterReflection { return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((ID3D11FunctionParameterReflection*)Unsafe.AsPointer(ref this), pDesc); } - } /// @@ -32766,7 +32684,6 @@ public unsafe partial struct ID3D11ModuleInstance { return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D11ModuleInstance*)Unsafe.AsPointer(ref this), pSrvName, uDstUavSlot, uCount); } - } /// @@ -32837,7 +32754,6 @@ public unsafe partial struct ID3D11Module { return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11Module*)Unsafe.AsPointer(ref this), pNamespace, ppModuleInstance); } - } /// @@ -32924,7 +32840,6 @@ public unsafe partial struct ID3D11Linker { return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D11Linker*)Unsafe.AsPointer(ref this), uCBufferSlot, uCBufferEntry); } - } /// @@ -33114,7 +33029,6 @@ public unsafe partial struct ID3D11FunctionLinkingGraph { return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11FunctionLinkingGraph*)Unsafe.AsPointer(ref this), uFlags, ppBuffer); } - } /// @@ -33241,7 +33155,6 @@ public unsafe partial struct ID3D11ShaderTrace { return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D11ShaderTrace*)Unsafe.AsPointer(ref this), stepIndex, readRegisterIndex, pRegister, pValue); } - } /// @@ -33312,7 +33225,6 @@ public unsafe partial struct ID3D11ShaderTraceFactory { return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D11ShaderTraceFactory*)Unsafe.AsPointer(ref this), pShader, pTraceDesc, ppShaderTrace); } - } #endregion Com Types diff --git a/src/Vortice.Win32/Generated/Graphics/Direct3D12.cs b/src/Vortice.Win32/Generated/Graphics/Direct3D12.cs index 00c4aa3..71864d1 100644 --- a/src/Vortice.Win32/Generated/Graphics/Direct3D12.cs +++ b/src/Vortice.Win32/Generated/Graphics/Direct3D12.cs @@ -12171,7 +12171,6 @@ public unsafe partial struct ID3D12Object { return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12Object*)Unsafe.AsPointer(ref this), Name); } - } /// @@ -12274,7 +12273,6 @@ public unsafe partial struct ID3D12DeviceChild { return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12DeviceChild*)Unsafe.AsPointer(ref this), riid, ppvDevice); } - } /// @@ -12377,7 +12375,6 @@ public unsafe partial struct ID3D12RootSignature { return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12RootSignature*)Unsafe.AsPointer(ref this), Name); } - } /// @@ -12448,7 +12445,6 @@ public unsafe partial struct ID3D12RootSignatureDeserializer { return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12RootSignatureDeserializer*)Unsafe.AsPointer(ref this)); } - } /// @@ -12527,7 +12523,6 @@ public unsafe partial struct ID3D12VersionedRootSignatureDeserializer { return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12VersionedRootSignatureDeserializer*)Unsafe.AsPointer(ref this)); } - } /// @@ -12630,7 +12625,6 @@ public unsafe partial struct ID3D12Pageable { return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Pageable*)Unsafe.AsPointer(ref this), Name); } - } /// @@ -12741,7 +12735,6 @@ public unsafe partial struct ID3D12Heap { return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12Heap*)Unsafe.AsPointer(ref this)); } - } /// @@ -12900,7 +12893,6 @@ public unsafe partial struct ID3D12Resource { return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((ID3D12Resource*)Unsafe.AsPointer(ref this), pHeapProperties, pHeapFlags); } - } /// @@ -13011,7 +13003,6 @@ public unsafe partial struct ID3D12CommandAllocator { return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12CommandAllocator*)Unsafe.AsPointer(ref this)); } - } /// @@ -13138,7 +13129,6 @@ public unsafe partial struct ID3D12Fence { return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12Fence*)Unsafe.AsPointer(ref this), Value); } - } /// @@ -13273,7 +13263,6 @@ public unsafe partial struct ID3D12Fence1 { return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12Fence1*)Unsafe.AsPointer(ref this)); } - } /// @@ -13384,7 +13373,6 @@ public unsafe partial struct ID3D12PipelineState { return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12PipelineState*)Unsafe.AsPointer(ref this), ppBlob); } - } /// @@ -13511,7 +13499,6 @@ public unsafe partial struct ID3D12DescriptorHeap { return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12DescriptorHeap*)Unsafe.AsPointer(ref this)); } - } /// @@ -13614,7 +13601,6 @@ public unsafe partial struct ID3D12QueryHeap { return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12QueryHeap*)Unsafe.AsPointer(ref this), Name); } - } /// @@ -13717,7 +13703,6 @@ public unsafe partial struct ID3D12CommandSignature { return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12CommandSignature*)Unsafe.AsPointer(ref this), Name); } - } /// @@ -13828,7 +13813,6 @@ public unsafe partial struct ID3D12CommandList { return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12CommandList*)Unsafe.AsPointer(ref this)); } - } /// @@ -14347,7 +14331,6 @@ public unsafe partial struct ID3D12GraphicsCommandList { ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((ID3D12GraphicsCommandList*)Unsafe.AsPointer(ref this), pCommandSignature, MaxCommandCount, pArgumentBuffer, ArgumentBufferOffset, pCountBuffer, CountBufferOffset); } - } /// @@ -14914,7 +14897,6 @@ public unsafe partial struct ID3D12GraphicsCommandList1 { ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((ID3D12GraphicsCommandList1*)Unsafe.AsPointer(ref this), Mask); } - } /// @@ -15489,7 +15471,6 @@ public unsafe partial struct ID3D12GraphicsCommandList2 { ((delegate* unmanaged[Stdcall])(lpVtbl[66]))((ID3D12GraphicsCommandList2*)Unsafe.AsPointer(ref this), Count, pParams, pModes); } - } /// @@ -15680,7 +15661,6 @@ public unsafe partial struct ID3D12CommandQueue { return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((ID3D12CommandQueue*)Unsafe.AsPointer(ref this)); } - } /// @@ -16071,7 +16051,6 @@ public unsafe partial struct ID3D12Device { return ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((ID3D12Device*)Unsafe.AsPointer(ref this)); } - } /// @@ -16214,7 +16193,6 @@ public unsafe partial struct ID3D12PipelineLibrary { return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((ID3D12PipelineLibrary*)Unsafe.AsPointer(ref this), pData, DataSizeInBytes); } - } /// @@ -16365,7 +16343,6 @@ public unsafe partial struct ID3D12PipelineLibrary1 { return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((ID3D12PipelineLibrary1*)Unsafe.AsPointer(ref this), pName, pDesc, riid, ppPipelineState); } - } /// @@ -16780,7 +16757,6 @@ public unsafe partial struct ID3D12Device1 { return ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((ID3D12Device1*)Unsafe.AsPointer(ref this), NumObjects, ppObjects, pPriorities); } - } /// @@ -17203,7 +17179,6 @@ public unsafe partial struct ID3D12Device2 { return ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((ID3D12Device2*)Unsafe.AsPointer(ref this), pDesc, riid, ppPipelineState); } - } /// @@ -17650,7 +17625,6 @@ public unsafe partial struct ID3D12Device3 { return ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((ID3D12Device3*)Unsafe.AsPointer(ref this), Flags, NumObjects, ppObjects, pFenceToSignal, FenceValueToSignal); } - } /// @@ -17769,7 +17743,6 @@ public unsafe partial struct ID3D12ProtectedSession { return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12ProtectedSession*)Unsafe.AsPointer(ref this)); } - } /// @@ -17896,7 +17869,6 @@ public unsafe partial struct ID3D12ProtectedResourceSession { return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12ProtectedResourceSession*)Unsafe.AsPointer(ref this)); } - } /// @@ -18391,7 +18363,6 @@ public unsafe partial struct ID3D12Device4 { return ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((ID3D12Device4*)Unsafe.AsPointer(ref this), visibleMask, numResourceDescs, pResourceDescs, pResourceAllocationInfo1); } - } /// @@ -18462,7 +18433,6 @@ public unsafe partial struct ID3D12LifetimeOwner { ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12LifetimeOwner*)Unsafe.AsPointer(ref this), NewState); } - } /// @@ -18557,7 +18527,6 @@ public unsafe partial struct ID3D12SwapChainAssistant { return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12SwapChainAssistant*)Unsafe.AsPointer(ref this)); } - } /// @@ -18668,7 +18637,6 @@ public unsafe partial struct ID3D12LifetimeTracker { return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12LifetimeTracker*)Unsafe.AsPointer(ref this), pObject); } - } /// @@ -18771,7 +18739,6 @@ public unsafe partial struct ID3D12StateObject { return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12StateObject*)Unsafe.AsPointer(ref this), Name); } - } /// @@ -18866,7 +18833,6 @@ public unsafe partial struct ID3D12StateObjectProperties { ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12StateObjectProperties*)Unsafe.AsPointer(ref this), PipelineStackSizeInBytes); } - } /// @@ -19425,7 +19391,6 @@ public unsafe partial struct ID3D12Device5 { return ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((ID3D12Device5*)Unsafe.AsPointer(ref this), SerializedDataType, pIdentifierToCheck); } - } /// @@ -19512,7 +19477,6 @@ public unsafe partial struct ID3D12DeviceRemovedExtendedDataSettings { ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12DeviceRemovedExtendedDataSettings*)Unsafe.AsPointer(ref this), Enablement); } - } /// @@ -19607,7 +19571,6 @@ public unsafe partial struct ID3D12DeviceRemovedExtendedDataSettings1 { ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12DeviceRemovedExtendedDataSettings1*)Unsafe.AsPointer(ref this), Enablement); } - } /// @@ -19686,7 +19649,6 @@ public unsafe partial struct ID3D12DeviceRemovedExtendedData { return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12DeviceRemovedExtendedData*)Unsafe.AsPointer(ref this), pOutput); } - } /// @@ -19781,7 +19743,6 @@ public unsafe partial struct ID3D12DeviceRemovedExtendedData1 { return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12DeviceRemovedExtendedData1*)Unsafe.AsPointer(ref this), pOutput); } - } /// @@ -19892,7 +19853,6 @@ public unsafe partial struct ID3D12DeviceRemovedExtendedData2 { return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12DeviceRemovedExtendedData2*)Unsafe.AsPointer(ref this)); } - } /// @@ -20459,7 +20419,6 @@ public unsafe partial struct ID3D12Device6 { return ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((ID3D12Device6*)Unsafe.AsPointer(ref this), Mode, MeasurementsAction, hEventToSignalUponCompletion, pbFurtherMeasurementsDesired); } - } /// @@ -20594,7 +20553,6 @@ public unsafe partial struct ID3D12ProtectedResourceSession1 { return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12ProtectedResourceSession1*)Unsafe.AsPointer(ref this)); } - } /// @@ -21177,7 +21135,6 @@ public unsafe partial struct ID3D12Device7 { return ((delegate* unmanaged[Stdcall])(lpVtbl[67]))((ID3D12Device7*)Unsafe.AsPointer(ref this), pDesc, riid, ppSession); } - } /// @@ -21800,7 +21757,6 @@ public unsafe partial struct ID3D12Device8 { ((delegate* unmanaged[Stdcall])(lpVtbl[72]))((ID3D12Device8*)Unsafe.AsPointer(ref this), pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes); } - } /// @@ -21967,7 +21923,6 @@ public unsafe partial struct ID3D12Resource1 { return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((ID3D12Resource1*)Unsafe.AsPointer(ref this), riid, ppProtectedSession); } - } /// @@ -22142,7 +22097,6 @@ public unsafe partial struct ID3D12Resource2 { return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((ID3D12Resource2*)Unsafe.AsPointer(ref this)); } - } /// @@ -22261,7 +22215,6 @@ public unsafe partial struct ID3D12Heap1 { return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((ID3D12Heap1*)Unsafe.AsPointer(ref this), riid, ppProtectedSession); } - } /// @@ -22844,7 +22797,6 @@ public unsafe partial struct ID3D12GraphicsCommandList3 { ((delegate* unmanaged[Stdcall])(lpVtbl[67]))((ID3D12GraphicsCommandList3*)Unsafe.AsPointer(ref this), pProtectedResourceSession); } - } /// @@ -22955,7 +22907,6 @@ public unsafe partial struct ID3D12MetaCommand { return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12MetaCommand*)Unsafe.AsPointer(ref this), Stage, ParameterIndex); } - } /// @@ -23610,7 +23561,6 @@ public unsafe partial struct ID3D12GraphicsCommandList4 { ((delegate* unmanaged[Stdcall])(lpVtbl[76]))((ID3D12GraphicsCommandList4*)Unsafe.AsPointer(ref this), pDesc); } - } /// @@ -23745,7 +23695,6 @@ public unsafe partial struct ID3D12ShaderCacheSession { return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((ID3D12ShaderCacheSession*)Unsafe.AsPointer(ref this)); } - } /// @@ -24392,7 +24341,6 @@ public unsafe partial struct ID3D12Device9 { return ((delegate* unmanaged[Stdcall])(lpVtbl[75]))((ID3D12Device9*)Unsafe.AsPointer(ref this), pDesc, CreatorID, riid, ppCommandQueue); } - } /// @@ -24471,7 +24419,6 @@ public unsafe partial struct ID3D12Tools { return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12Tools*)Unsafe.AsPointer(ref this)); } - } /// @@ -24542,7 +24489,6 @@ public unsafe partial struct ID3D12Debug { ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12Debug*)Unsafe.AsPointer(ref this)); } - } /// @@ -24629,7 +24575,6 @@ public unsafe partial struct ID3D12Debug1 { ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12Debug1*)Unsafe.AsPointer(ref this), Enable); } - } /// @@ -24700,7 +24645,6 @@ public unsafe partial struct ID3D12Debug2 { ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12Debug2*)Unsafe.AsPointer(ref this), Flags); } - } /// @@ -24795,7 +24739,6 @@ public unsafe partial struct ID3D12Debug3 { ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12Debug3*)Unsafe.AsPointer(ref this), Flags); } - } /// @@ -24898,7 +24841,6 @@ public unsafe partial struct ID3D12Debug4 { ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12Debug4*)Unsafe.AsPointer(ref this)); } - } /// @@ -25009,7 +24951,6 @@ public unsafe partial struct ID3D12Debug5 { ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((ID3D12Debug5*)Unsafe.AsPointer(ref this), Enable); } - } /// @@ -25096,7 +25037,6 @@ public unsafe partial struct ID3D12DebugDevice1 { return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12DebugDevice1*)Unsafe.AsPointer(ref this), Flags); } - } /// @@ -25183,7 +25123,6 @@ public unsafe partial struct ID3D12DebugDevice { return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12DebugDevice*)Unsafe.AsPointer(ref this), Flags); } - } /// @@ -25286,7 +25225,6 @@ public unsafe partial struct ID3D12DebugDevice2 { return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12DebugDevice2*)Unsafe.AsPointer(ref this), Type, pData, DataSize); } - } /// @@ -25357,7 +25295,6 @@ public unsafe partial struct ID3D12DebugCommandQueue { return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12DebugCommandQueue*)Unsafe.AsPointer(ref this), pResource, Subresource, State); } - } /// @@ -25444,7 +25381,6 @@ public unsafe partial struct ID3D12DebugCommandList1 { return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12DebugCommandList1*)Unsafe.AsPointer(ref this), Type, pData, DataSize); } - } /// @@ -25531,7 +25467,6 @@ public unsafe partial struct ID3D12DebugCommandList { return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((ID3D12DebugCommandList*)Unsafe.AsPointer(ref this)); } - } /// @@ -25634,7 +25569,6 @@ public unsafe partial struct ID3D12DebugCommandList2 { return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((ID3D12DebugCommandList2*)Unsafe.AsPointer(ref this), Type, pData, DataSize); } - } /// @@ -25729,7 +25663,6 @@ public unsafe partial struct ID3D12SharingContract { ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12SharingContract*)Unsafe.AsPointer(ref this), guid); } - } /// @@ -26072,7 +26005,6 @@ public unsafe partial struct ID3D12InfoQueue { return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((ID3D12InfoQueue*)Unsafe.AsPointer(ref this)); } - } /// @@ -26431,7 +26363,6 @@ public unsafe partial struct ID3D12InfoQueue1 { return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((ID3D12InfoQueue1*)Unsafe.AsPointer(ref this), CallbackCookie); } - } /// @@ -26502,7 +26433,6 @@ public unsafe partial struct ID3D12SDKConfiguration { return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12SDKConfiguration*)Unsafe.AsPointer(ref this), SDKVersion, SDKPath); } - } /// @@ -27173,7 +27103,6 @@ public unsafe partial struct ID3D12GraphicsCommandList5 { ((delegate* unmanaged[Stdcall])(lpVtbl[78]))((ID3D12GraphicsCommandList5*)Unsafe.AsPointer(ref this), shadingRateImage); } - } /// @@ -27852,7 +27781,6 @@ public unsafe partial struct ID3D12GraphicsCommandList6 { ((delegate* unmanaged[Stdcall])(lpVtbl[79]))((ID3D12GraphicsCommandList6*)Unsafe.AsPointer(ref this), ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ); } - } /// @@ -27975,7 +27903,6 @@ public unsafe partial struct ID3D12ShaderReflectionType { return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), pBase); } - } /// @@ -28042,7 +27969,6 @@ public unsafe partial struct ID3D12ShaderReflectionVariable { return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((ID3D12ShaderReflectionVariable*)Unsafe.AsPointer(ref this), uArrayIndex); } - } /// @@ -28101,7 +28027,6 @@ public unsafe partial struct ID3D12ShaderReflectionConstantBuffer { return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((ID3D12ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Name); } - } /// @@ -28316,7 +28241,6 @@ public unsafe partial struct ID3D12ShaderReflection { return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this)); } - } /// @@ -28395,7 +28319,6 @@ public unsafe partial struct ID3D12LibraryReflection { return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((ID3D12LibraryReflection*)Unsafe.AsPointer(ref this), FunctionIndex); } - } /// @@ -28486,7 +28409,6 @@ public unsafe partial struct ID3D12FunctionReflection { return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), ParameterIndex); } - } /// @@ -28529,7 +28451,6 @@ public unsafe partial struct ID3D12FunctionParameterReflection { return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((ID3D12FunctionParameterReflection*)Unsafe.AsPointer(ref this), pDesc); } - } #endregion Com Types diff --git a/src/Vortice.Win32/Generated/Graphics/Dxgi.cs b/src/Vortice.Win32/Generated/Graphics/Dxgi.cs index 03e2d3d..c6634c8 100644 --- a/src/Vortice.Win32/Generated/Graphics/Dxgi.cs +++ b/src/Vortice.Win32/Generated/Graphics/Dxgi.cs @@ -2518,7 +2518,6 @@ public unsafe partial struct IDXGIObject { return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDXGIObject*)Unsafe.AsPointer(ref this), riid, ppParent); } - } /// @@ -2621,7 +2620,6 @@ public unsafe partial struct IDXGIDeviceSubObject { return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDXGIDeviceSubObject*)Unsafe.AsPointer(ref this), riid, ppDevice); } - } /// @@ -2756,7 +2754,6 @@ public unsafe partial struct IDXGIResource { return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDXGIResource*)Unsafe.AsPointer(ref this), pEvictionPriority); } - } /// @@ -2875,7 +2872,6 @@ public unsafe partial struct IDXGIKeyedMutex { return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDXGIKeyedMutex*)Unsafe.AsPointer(ref this), Key); } - } /// @@ -3002,7 +2998,6 @@ public unsafe partial struct IDXGISurface { return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDXGISurface*)Unsafe.AsPointer(ref this)); } - } /// @@ -3145,7 +3140,6 @@ public unsafe partial struct IDXGISurface1 { return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDXGISurface1*)Unsafe.AsPointer(ref this), pDirtyRect); } - } /// @@ -3264,7 +3258,6 @@ public unsafe partial struct IDXGIAdapter { return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDXGIAdapter*)Unsafe.AsPointer(ref this), InterfaceName, pUMDVersion); } - } /// @@ -3455,7 +3448,6 @@ public unsafe partial struct IDXGIOutput { return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDXGIOutput*)Unsafe.AsPointer(ref this), pStats); } - } /// @@ -3638,7 +3630,6 @@ public unsafe partial struct IDXGISwapChain { return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDXGISwapChain*)Unsafe.AsPointer(ref this), pLastPresentCount); } - } /// @@ -3773,7 +3764,6 @@ public unsafe partial struct IDXGIFactory { return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDXGIFactory*)Unsafe.AsPointer(ref this), Module, ppAdapter); } - } /// @@ -3908,7 +3898,6 @@ public unsafe partial struct IDXGIDevice { return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDXGIDevice*)Unsafe.AsPointer(ref this), pPriority); } - } /// @@ -4059,7 +4048,6 @@ public unsafe partial struct IDXGIFactory1 { return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDXGIFactory1*)Unsafe.AsPointer(ref this)); } - } /// @@ -4186,7 +4174,6 @@ public unsafe partial struct IDXGIAdapter1 { return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDXGIAdapter1*)Unsafe.AsPointer(ref this), pDesc); } - } /// @@ -4337,7 +4324,6 @@ public unsafe partial struct IDXGIDevice1 { return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDXGIDevice1*)Unsafe.AsPointer(ref this), pMaxLatency); } - } /// @@ -4416,7 +4402,6 @@ public unsafe partial struct IDXGIDisplayControl { ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDXGIDisplayControl*)Unsafe.AsPointer(ref this), enabled); } - } /// @@ -4575,7 +4560,6 @@ public unsafe partial struct IDXGIOutputDuplication { return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDXGIOutputDuplication*)Unsafe.AsPointer(ref this)); } - } /// @@ -4726,7 +4710,6 @@ public unsafe partial struct IDXGISurface2 { return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDXGISurface2*)Unsafe.AsPointer(ref this), riid, ppParentResource, pSubresourceIndex); } - } /// @@ -4877,7 +4860,6 @@ public unsafe partial struct IDXGIResource1 { return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDXGIResource1*)Unsafe.AsPointer(ref this), pAttributes, dwAccess, lpName, pHandle); } - } /// @@ -5052,7 +5034,6 @@ public unsafe partial struct IDXGIDevice2 { return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDXGIDevice2*)Unsafe.AsPointer(ref this), hEvent); } - } /// @@ -5323,7 +5304,6 @@ public unsafe partial struct IDXGISwapChain1 { return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((IDXGISwapChain1*)Unsafe.AsPointer(ref this), pRotation); } - } /// @@ -5562,7 +5542,6 @@ public unsafe partial struct IDXGIFactory2 { return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IDXGIFactory2*)Unsafe.AsPointer(ref this), pDevice, pDesc, pRestrictToOutput, ppSwapChain); } - } /// @@ -5697,7 +5676,6 @@ public unsafe partial struct IDXGIAdapter2 { return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDXGIAdapter2*)Unsafe.AsPointer(ref this), pDesc); } - } /// @@ -5920,7 +5898,6 @@ public unsafe partial struct IDXGIOutput1 { return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IDXGIOutput1*)Unsafe.AsPointer(ref this), pDevice, ppOutputDuplication); } - } /// @@ -6103,7 +6080,6 @@ public unsafe partial struct IDXGIDevice3 { ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDXGIDevice3*)Unsafe.AsPointer(ref this)); } - } /// @@ -6430,7 +6406,6 @@ public unsafe partial struct IDXGISwapChain2 { return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((IDXGISwapChain2*)Unsafe.AsPointer(ref this), pMatrix); } - } /// @@ -6661,7 +6636,6 @@ public unsafe partial struct IDXGIOutput2 { return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IDXGIOutput2*)Unsafe.AsPointer(ref this)); } - } /// @@ -6908,7 +6882,6 @@ public unsafe partial struct IDXGIFactory3 { return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IDXGIFactory3*)Unsafe.AsPointer(ref this)); } - } /// @@ -7043,7 +7016,6 @@ public unsafe partial struct IDXGIDecodeSwapChain { return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDXGIDecodeSwapChain*)Unsafe.AsPointer(ref this)); } - } /// @@ -7122,7 +7094,6 @@ public unsafe partial struct IDXGIFactoryMedia { return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDXGIFactoryMedia*)Unsafe.AsPointer(ref this), pDevice, hSurface, pDesc, pYuvDecodeBuffers, pRestrictToOutput, ppSwapChain); } - } /// @@ -7209,7 +7180,6 @@ public unsafe partial struct IDXGISwapChainMedia { return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDXGISwapChainMedia*)Unsafe.AsPointer(ref this), DesiredPresentDuration, pClosestSmallerPresentDuration, pClosestLargerPresentDuration); } - } /// @@ -7448,7 +7418,6 @@ public unsafe partial struct IDXGIOutput3 { return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IDXGIOutput3*)Unsafe.AsPointer(ref this), EnumFormat, pConcernedDevice, pFlags); } - } /// @@ -7807,7 +7776,6 @@ public unsafe partial struct IDXGISwapChain3 { return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((IDXGISwapChain3*)Unsafe.AsPointer(ref this), BufferCount, Width, Height, Format, SwapChainFlags, pCreationNodeMask, ppPresentQueue); } - } /// @@ -8054,7 +8022,6 @@ public unsafe partial struct IDXGIOutput4 { return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IDXGIOutput4*)Unsafe.AsPointer(ref this), Format, ColorSpace, pConcernedDevice, pFlags); } - } /// @@ -8317,7 +8284,6 @@ public unsafe partial struct IDXGIFactory4 { return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((IDXGIFactory4*)Unsafe.AsPointer(ref this), riid, ppvAdapter); } - } /// @@ -8500,7 +8466,6 @@ public unsafe partial struct IDXGIAdapter3 { ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDXGIAdapter3*)Unsafe.AsPointer(ref this), dwCookie); } - } /// @@ -8755,7 +8720,6 @@ public unsafe partial struct IDXGIOutput5 { return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((IDXGIOutput5*)Unsafe.AsPointer(ref this), pDevice, Flags, SupportedFormatsCount, pSupportedFormats, ppOutputDuplication); } - } /// @@ -9122,7 +9086,6 @@ public unsafe partial struct IDXGISwapChain4 { return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((IDXGISwapChain4*)Unsafe.AsPointer(ref this), Type, Size, pMetaData); } - } /// @@ -9321,7 +9284,6 @@ public unsafe partial struct IDXGIDevice4 { return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDXGIDevice4*)Unsafe.AsPointer(ref this), NumResources, ppResources, pResults); } - } /// @@ -9592,7 +9554,6 @@ public unsafe partial struct IDXGIFactory5 { return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((IDXGIFactory5*)Unsafe.AsPointer(ref this), Feature, pFeatureSupportData, FeatureSupportDataSize); } - } /// @@ -9783,7 +9744,6 @@ public unsafe partial struct IDXGIAdapter4 { return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDXGIAdapter4*)Unsafe.AsPointer(ref this), pDesc); } - } /// @@ -10054,7 +10014,6 @@ public unsafe partial struct IDXGIOutput6 { return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((IDXGIOutput6*)Unsafe.AsPointer(ref this), pFlags); } - } /// @@ -10333,7 +10292,6 @@ public unsafe partial struct IDXGIFactory6 { return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((IDXGIFactory6*)Unsafe.AsPointer(ref this), Adapter, GpuPreference, riid, ppvAdapter); } - } /// @@ -10628,7 +10586,6 @@ public unsafe partial struct IDXGIFactory7 { return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((IDXGIFactory7*)Unsafe.AsPointer(ref this), dwCookie); } - } /// @@ -10987,7 +10944,6 @@ public unsafe partial struct IDXGIInfoQueue { return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((IDXGIInfoQueue*)Unsafe.AsPointer(ref this), Producer); } - } /// @@ -11058,7 +11014,6 @@ public unsafe partial struct IDXGIDebug { return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDXGIDebug*)Unsafe.AsPointer(ref this), apiid, flags); } - } /// @@ -11153,7 +11108,6 @@ public unsafe partial struct IDXGIDebug1 { return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDXGIDebug1*)Unsafe.AsPointer(ref this)); } - } /// @@ -11232,7 +11186,6 @@ public unsafe partial struct IDXGraphicsAnalysis { ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDXGraphicsAnalysis*)Unsafe.AsPointer(ref this)); } - } #endregion Com Types diff --git a/src/Vortice.Win32/Generated/Graphics/Imaging.cs b/src/Vortice.Win32/Generated/Graphics/Imaging.cs new file mode 100644 index 0000000..1bb768c --- /dev/null +++ b/src/Vortice.Win32/Generated/Graphics/Imaging.cs @@ -0,0 +1,14621 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +using System; +using System.Diagnostics; +using System.Runtime.CompilerServices; +using System.Diagnostics.CodeAnalysis; + +#if !NET6_0_OR_GREATER +using MemoryMarshal = Win32.MemoryMarshal; +#endif + +namespace Win32.Graphics.Imaging; + +public static partial class Apis +{ + public const uint WINCODEC_SDK_VERSION1 = 566; + public const uint WINCODEC_SDK_VERSION2 = 567; + public static ref readonly Guid CLSID_WICImagingFactory + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x62, 0xF2, 0xCA, 0xCA, + 0x70, 0x93, + 0x15, 0x46, + 0xA1, + 0x3B, + 0x9F, + 0x55, + 0x39, + 0xDA, + 0x4C, + 0x0A + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICImagingFactory1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x62, 0xF2, 0xCA, 0xCA, + 0x70, 0x93, + 0x15, 0x46, + 0xA1, + 0x3B, + 0x9F, + 0x55, + 0x39, + 0xDA, + 0x4C, + 0x0A + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICImagingFactory2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xE8, 0x06, 0x7D, 0x31, + 0x24, 0x5F, + 0x3D, 0x43, + 0xBD, + 0xF7, + 0x79, + 0xCE, + 0x68, + 0xD8, + 0xAB, + 0xC2 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public const uint WINCODEC_SDK_VERSION = 567; + public static ref readonly Guid GUID_VendorMicrosoft + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xCA, 0x49, 0xE7, 0xF0, + 0xEF, 0xED, + 0x89, 0x45, + 0xA7, + 0x3A, + 0xEE, + 0x0E, + 0x62, + 0x6A, + 0x2A, + 0x2B + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_VendorMicrosoftBuiltIn + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xFD, 0x30, 0x7A, 0x25, + 0xB6, 0x06, + 0x2B, 0x46, + 0xAE, + 0xA4, + 0x63, + 0xF7, + 0x0B, + 0x86, + 0xE5, + 0x33 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICPngDecoder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x7B, 0xA1, 0x9E, 0x38, + 0x78, 0x50, + 0xDE, 0x4C, + 0xB6, + 0xEF, + 0x25, + 0xC1, + 0x51, + 0x75, + 0xC7, + 0x51 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICPngDecoder1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x7B, 0xA1, 0x9E, 0x38, + 0x78, 0x50, + 0xDE, 0x4C, + 0xB6, + 0xEF, + 0x25, + 0xC1, + 0x51, + 0x75, + 0xC7, + 0x51 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICPngDecoder2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x5B, 0x94, 0x18, 0xE0, + 0x86, 0xAA, + 0x08, 0x40, + 0x9B, + 0xD4, + 0x67, + 0x77, + 0xA1, + 0xE4, + 0x0C, + 0x11 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICBmpDecoder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x62, 0x20, 0x46, 0x6B, + 0xBF, 0x7C, + 0x0D, 0x40, + 0x9F, + 0xDB, + 0x81, + 0x3D, + 0xD1, + 0x0F, + 0x27, + 0x78 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICIcoDecoder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xDF, 0xFC, 0x1B, 0xC6, + 0x0F, 0x2E, + 0xAD, 0x4A, + 0xA8, + 0xD7, + 0xE0, + 0x6B, + 0xAF, + 0xEB, + 0xCD, + 0xFE + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICJpegDecoder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x80, 0xA4, 0x56, 0x94, + 0x8B, 0xE8, + 0xEA, 0x43, + 0x9E, + 0x73, + 0x0B, + 0x2D, + 0x9B, + 0x71, + 0xB1, + 0xCA + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICGifDecoder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x3C, 0xDA, 0x1D, 0x38, + 0xE9, 0x9C, + 0x34, 0x48, + 0xA2, + 0x3E, + 0x1F, + 0x98, + 0xF8, + 0xFC, + 0x52, + 0xBE + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICTiffDecoder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xD9, 0x85, 0x4E, 0xB5, + 0x23, 0xFE, + 0x9F, 0x49, + 0x8B, + 0x88, + 0x6A, + 0xCE, + 0xA7, + 0x13, + 0x75, + 0x2B + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICWmpDecoder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x36, 0xEC, 0x6C, 0xA2, + 0x4C, 0x23, + 0x50, 0x49, + 0xAE, + 0x16, + 0xE3, + 0x4A, + 0xAC, + 0xE7, + 0x1D, + 0x0D + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICDdsDecoder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x9F, 0x69, 0x53, 0x90, + 0x41, 0xA3, + 0x9D, 0x42, + 0x9E, + 0x90, + 0xEE, + 0x43, + 0x7C, + 0xF8, + 0x0C, + 0x73 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICBmpEncoder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xB4, 0x8B, 0xBE, 0x69, + 0x6D, 0xD6, + 0xC8, 0x47, + 0x86, + 0x5A, + 0xED, + 0x15, + 0x89, + 0x43, + 0x37, + 0x82 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICPngEncoder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x69, 0x99, 0x94, 0x27, + 0x6A, 0x87, + 0xD7, 0x41, + 0x94, + 0x47, + 0x56, + 0x8F, + 0x6A, + 0x35, + 0xA4, + 0xDC + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICJpegEncoder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xC1, 0xF5, 0x34, 0x1A, + 0x5A, 0x4A, + 0xDC, 0x46, + 0xB6, + 0x44, + 0x1F, + 0x45, + 0x67, + 0xE7, + 0xA6, + 0x76 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICGifEncoder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x98, 0x55, 0x4F, 0x11, + 0x22, 0x0B, + 0xA0, 0x40, + 0x86, + 0xA1, + 0xC8, + 0x3E, + 0xA4, + 0x95, + 0xAD, + 0xBD + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICTiffEncoder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x10, 0xBE, 0x31, 0x01, + 0x01, 0x20, + 0x5F, 0x4C, + 0xA9, + 0xB0, + 0xCC, + 0x88, + 0xFA, + 0xB6, + 0x4C, + 0xE8 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICWmpEncoder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xCB, 0xE3, 0x4C, 0xAC, + 0xC1, 0xE1, + 0xCD, 0x44, + 0x82, + 0x15, + 0x5A, + 0x16, + 0x65, + 0x50, + 0x9E, + 0xC2 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICDdsEncoder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x94, 0xDE, 0x1D, 0xA6, + 0xCE, 0x66, + 0xC1, 0x4A, + 0x88, + 0x1B, + 0x71, + 0x68, + 0x05, + 0x88, + 0x89, + 0x5E + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICAdngDecoder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x11, 0x94, 0x1D, 0x98, + 0x9E, 0x90, + 0xA7, 0x42, + 0x8F, + 0x5D, + 0xA7, + 0x47, + 0xFF, + 0x05, + 0x2E, + 0xDB + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICJpegQualcommPhoneEncoder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x62, 0x5C, 0xED, 0x68, + 0x34, 0xF5, + 0x79, 0x49, + 0xB2, + 0xB3, + 0x68, + 0x6A, + 0x12, + 0xB2, + 0xB3, + 0x4C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICHeifDecoder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x0A, 0xA8, 0xA4, 0xE9, + 0xFE, 0x44, + 0xE4, 0x4D, + 0x89, + 0x71, + 0x71, + 0x50, + 0xB1, + 0x0A, + 0x51, + 0x99 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICHeifEncoder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xC1, 0xCE, 0xBE, 0x0D, + 0xB3, 0x9E, + 0x60, 0x48, + 0x9C, + 0x6F, + 0xDD, + 0xBE, + 0x86, + 0x63, + 0x45, + 0x75 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICWebpDecoder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x86, 0xE8, 0x93, 0x76, + 0xC9, 0x51, + 0x70, 0x40, + 0x84, + 0x19, + 0x9F, + 0x70, + 0x73, + 0x8E, + 0xC8, + 0xFA + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICRAWDecoder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x02, 0x57, 0x94, 0x41, + 0x02, 0x83, + 0xA6, 0x44, + 0x94, + 0x45, + 0xAC, + 0x98, + 0xE8, + 0xAF, + 0xA0, + 0x86 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_ContainerFormatBmp + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x7E, 0xD8, 0xF1, 0x0A, + 0xFE, 0xFC, + 0x88, 0x41, + 0xBD, + 0xEB, + 0xA7, + 0x90, + 0x64, + 0x71, + 0xCB, + 0xE3 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_ContainerFormatPng + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xF4, 0xFA, 0x7C, 0x1B, + 0x3F, 0x71, + 0x3C, 0x47, + 0xBB, + 0xCD, + 0x61, + 0x37, + 0x42, + 0x5F, + 0xAE, + 0xAF + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_ContainerFormatIco + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xC4, 0x60, 0xA8, 0xA3, + 0x8F, 0x33, + 0x17, 0x4C, + 0x91, + 0x9A, + 0xFB, + 0xA4, + 0xB5, + 0x62, + 0x8F, + 0x21 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_ContainerFormatJpeg + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xAA, 0xA5, 0xE4, 0x19, + 0x62, 0x56, + 0xC5, 0x4F, + 0xA0, + 0xC0, + 0x17, + 0x58, + 0x02, + 0x8E, + 0x10, + 0x57 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_ContainerFormatTiff + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x30, 0xCC, 0x3B, 0x16, + 0xE9, 0xE2, + 0x0B, 0x4F, + 0x96, + 0x1D, + 0xA3, + 0xE9, + 0xFD, + 0xB7, + 0x88, + 0xA3 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_ContainerFormatGif + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x01, 0x56, 0x8A, 0x1F, + 0x4D, 0x7D, + 0xBD, 0x4C, + 0x9C, + 0x82, + 0x1B, + 0xC8, + 0xD4, + 0xEE, + 0xB9, + 0xA5 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_ContainerFormatWmp + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xAA, 0x7C, 0xA3, 0x57, + 0x7A, 0x36, + 0x40, 0x45, + 0x91, + 0x6B, + 0xF1, + 0x83, + 0xC5, + 0x09, + 0x3A, + 0x4B + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_ContainerFormatDds + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x95, 0xCB, 0x67, 0x99, + 0x85, 0x2E, + 0xC8, 0x4A, + 0x8C, + 0xA2, + 0x83, + 0xD7, + 0xCC, + 0xD4, + 0x25, + 0xC9 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_ContainerFormatAdng + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x0D, 0x6D, 0xFF, 0xF3, + 0xC0, 0x38, + 0xC4, 0x41, + 0xB1, + 0xFE, + 0x1F, + 0x38, + 0x24, + 0xF1, + 0x7B, + 0x84 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_ContainerFormatHeif + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x21, 0x25, 0xE6, 0xE1, + 0x87, 0x67, + 0x5B, 0x40, + 0xA3, + 0x39, + 0x50, + 0x07, + 0x15, + 0xB5, + 0x76, + 0x3F + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_ContainerFormatWebp + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xE2, 0xB0, 0x94, 0xE0, + 0xF2, 0x67, + 0xB3, 0x45, + 0xB0, + 0xEA, + 0x11, + 0x53, + 0x37, + 0xCA, + 0x7C, + 0xF3 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_ContainerFormatRaw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x60, 0xCE, 0x99, 0xFE, + 0x9C, 0xF1, + 0x3C, 0x43, + 0xA3, + 0xAE, + 0x00, + 0xAC, + 0xEF, + 0xA9, + 0xCA, + 0x21 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICImagingCategories + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x80, 0xD3, 0xE3, 0xFA, + 0xA4, 0xFE, + 0x23, 0x46, + 0x8C, + 0x75, + 0xC6, + 0xB6, + 0x11, + 0x10, + 0xB6, + 0x81 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CATID_WICBitmapDecoders + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x37, 0x68, 0xD9, 0x7E, + 0xF0, 0x96, + 0x12, 0x48, + 0xB2, + 0x11, + 0xF1, + 0x3C, + 0x24, + 0x11, + 0x7E, + 0xD3 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CATID_WICBitmapEncoders + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x96, 0x72, 0x75, 0xAC, + 0x22, 0x35, + 0x11, 0x4E, + 0x98, + 0x62, + 0xC1, + 0x7B, + 0xE5, + 0xA1, + 0x76, + 0x7E + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CATID_WICPixelFormats + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x0F, 0xE7, 0x46, 0x2B, + 0xA7, 0xCD, + 0x3E, 0x47, + 0x89, + 0xF6, + 0xDC, + 0x96, + 0x30, + 0xA2, + 0x39, + 0x0B + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CATID_WICFormatConverters + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xE8, 0xEA, 0x35, 0x78, + 0x14, 0xBF, + 0xD1, 0x49, + 0x93, + 0xCE, + 0x53, + 0x3A, + 0x40, + 0x7B, + 0x22, + 0x48 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CATID_WICMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xD8, 0x94, 0xAF, 0x05, + 0x74, 0x71, + 0xD2, 0x4C, + 0xBE, + 0x4A, + 0x41, + 0x24, + 0xB8, + 0x0E, + 0xE4, + 0xB8 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CATID_WICMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xA4, 0xB9, 0xE3, 0xAB, + 0x7D, 0x25, + 0x97, 0x4B, + 0xBD, + 0x1A, + 0x29, + 0x4A, + 0xF4, + 0x96, + 0x22, + 0x2E + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICDefaultFormatConverter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xDC, 0x11, 0x3F, 0x1A, + 0x14, 0xB5, + 0x17, 0x4B, + 0x8C, + 0x5F, + 0x21, + 0x54, + 0x51, + 0x38, + 0x52, + 0xF1 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICFormatConverterHighColor + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x54, 0xD4, 0x75, 0xAC, + 0x37, 0x9F, + 0xF8, 0x48, + 0xB9, + 0x72, + 0x4E, + 0x19, + 0xBC, + 0x85, + 0x60, + 0x11 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICFormatConverterNChannel + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xB2, 0xAB, 0x7C, 0xC1, + 0xA3, 0xD4, + 0xD7, 0x47, + 0xA5, + 0x57, + 0x33, + 0x9B, + 0x2E, + 0xFB, + 0xD4, + 0xF1 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICFormatConverterWMPhoto + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x2B, 0x17, 0xB5, 0x9C, + 0x00, 0xD6, + 0xBA, 0x46, + 0xAB, + 0x77, + 0x77, + 0xBB, + 0x7E, + 0x3A, + 0x00, + 0xD9 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICPlanarFormatConverter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xB8, 0x32, 0x41, 0x18, + 0xF8, 0x32, + 0x84, 0x47, + 0x91, + 0x31, + 0xDD, + 0x72, + 0x24, + 0xB2, + 0x34, + 0x38 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public const uint WIC_JPEG_MAX_COMPONENT_COUNT = 4; + public const uint WIC_JPEG_MAX_TABLE_INDEX = 3; + public const uint WIC_JPEG_SAMPLE_FACTORS_ONE = 17; + public const uint WIC_JPEG_SAMPLE_FACTORS_THREE_420 = 1118498; + public const uint WIC_JPEG_SAMPLE_FACTORS_THREE_422 = 1118497; + public const uint WIC_JPEG_SAMPLE_FACTORS_THREE_440 = 1118482; + public const uint WIC_JPEG_SAMPLE_FACTORS_THREE_444 = 1118481; + public const uint WIC_JPEG_QUANTIZATION_BASELINE_ONE = 0; + public const uint WIC_JPEG_QUANTIZATION_BASELINE_THREE = 65792; + public const uint WIC_JPEG_HUFFMAN_BASELINE_ONE = 0; + public const uint WIC_JPEG_HUFFMAN_BASELINE_THREE = 1118464; + public static ref readonly Guid GUID_WICPixelFormatDontCare + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x00 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat1bppIndexed + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x01 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat2bppIndexed + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x02 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat4bppIndexed + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x03 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat8bppIndexed + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x04 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormatBlackWhite + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x05 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat2bppGray + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x06 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat4bppGray + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x07 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat8bppGray + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x08 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat8bppAlpha + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x16, 0x01, 0xCD, 0xE6, + 0xBA, 0xEE, + 0x61, 0x41, + 0xAA, + 0x85, + 0x27, + 0xDD, + 0x9F, + 0xB3, + 0xA8, + 0x95 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat16bppBGR555 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x09 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat16bppBGR565 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x0A + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat16bppBGRA5551 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x2B, 0x7C, 0xEC, 0x05, + 0xE6, 0xF1, + 0x61, 0x49, + 0xAD, + 0x46, + 0xE1, + 0xCC, + 0x81, + 0x0A, + 0x87, + 0xD2 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat16bppGray + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x0B + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat24bppBGR + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x0C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat24bppRGB + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x0D + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat32bppBGR + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x0E + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat32bppBGRA + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x0F + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat32bppPBGRA + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x10 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat32bppGrayFloat + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x11 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat32bppRGB + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x95, 0x6B, 0x8C, 0xD9, + 0xFE, 0x3E, + 0xD6, 0x47, + 0xBB, + 0x25, + 0xEB, + 0x17, + 0x48, + 0xAB, + 0x0C, + 0xF1 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat32bppRGBA + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x2D, 0xAD, 0xC7, 0xF5, + 0x8D, 0x6A, + 0xDD, 0x43, + 0xA7, + 0xA8, + 0xA2, + 0x99, + 0x35, + 0x26, + 0x1A, + 0xE9 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat32bppPRGBA + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x50, 0xA6, 0xC4, 0x3C, + 0x27, 0xA5, + 0x37, 0x4D, + 0xA9, + 0x16, + 0x31, + 0x42, + 0xC7, + 0xEB, + 0xED, + 0xBA + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat48bppRGB + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x15 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat48bppBGR + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x84, 0xA3, 0x05, 0xE6, + 0x68, 0xB4, + 0xCE, 0x46, + 0xBB, + 0x2E, + 0x36, + 0xF1, + 0x80, + 0xE6, + 0x43, + 0x13 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat64bppRGB + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x11, 0x21, 0x18, 0xA1, + 0x6D, 0x18, + 0x42, 0x4D, + 0xBC, + 0x6A, + 0x9C, + 0x83, + 0x03, + 0xA8, + 0xDF, + 0xF9 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat64bppRGBA + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x16 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat64bppBGRA + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x7C, 0xFF, 0x62, 0x15, + 0x52, 0xD3, + 0xF9, 0x46, + 0x97, + 0x9E, + 0x42, + 0x97, + 0x6B, + 0x79, + 0x22, + 0x46 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat64bppPRGBA + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x17 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat64bppPBGRA + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x8E, 0x8E, 0x51, 0x8C, + 0xEC, 0xA4, + 0x8B, 0x46, + 0xAE, + 0x70, + 0xC9, + 0xA3, + 0x5A, + 0x9C, + 0x55, + 0x30 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat16bppGrayFixedPoint + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x13 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat32bppBGR101010 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x14 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat48bppRGBFixedPoint + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x12 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat48bppBGRFixedPoint + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x0E, 0x14, 0xCA, 0x49, + 0xB6, 0xCA, + 0x3B, 0x49, + 0x9D, + 0xDF, + 0x60, + 0x18, + 0x7C, + 0x37, + 0x53, + 0x2A + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat96bppRGBFixedPoint + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x18 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat96bppRGBFloat + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x8F, 0xD7, 0xFE, 0xE3, + 0xDB, 0xE8, + 0xCF, 0x4A, + 0x84, + 0xC1, + 0xE9, + 0x7F, + 0x61, + 0x36, + 0xB3, + 0x27 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat128bppRGBAFloat + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x19 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat128bppPRGBAFloat + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x1A + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat128bppRGBFloat + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x1B + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat32bppCMYK + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x1C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat64bppRGBAFixedPoint + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x1D + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat64bppBGRAFixedPoint + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x3C, 0xE3, 0x6D, 0x35, + 0xD2, 0x54, + 0x23, 0x4A, + 0xBB, + 0x04, + 0x9B, + 0x7B, + 0xF9, + 0xB1, + 0xD4, + 0x2D + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat64bppRGBFixedPoint + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x40 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat128bppRGBAFixedPoint + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x1E + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat128bppRGBFixedPoint + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x41 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat64bppRGBAHalf + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x3A + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat64bppPRGBAHalf + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xC2, 0x26, 0xAD, 0x58, + 0x23, 0xC6, + 0x9D, 0x4D, + 0xB3, + 0x20, + 0x38, + 0x7E, + 0x49, + 0xF8, + 0xC4, + 0x42 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat64bppRGBHalf + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x42 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat48bppRGBHalf + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x3B + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat32bppRGBE + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x3D + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat16bppGrayHalf + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x3E + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat32bppGrayFixedPoint + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x3F + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat32bppRGBA1010102 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x72, 0x8D, 0x23, 0x25, + 0xF9, 0xFC, + 0x22, 0x45, + 0xB5, + 0x14, + 0x55, + 0x78, + 0xE5, + 0xAD, + 0x55, + 0xE0 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat32bppRGBA1010102XR + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x9A, 0x6B, 0xDE, 0x00, + 0x01, 0xC1, + 0x4B, 0x43, + 0xB5, + 0x02, + 0xD0, + 0x16, + 0x5E, + 0xE1, + 0x12, + 0x2C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat32bppR10G10B10A2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xB5, 0x1B, 0x4E, 0x60, + 0x3C, 0x8A, + 0x65, 0x4B, + 0xB1, + 0x1C, + 0xBC, + 0x0B, + 0x8D, + 0xD7, + 0x5B, + 0x7F + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat32bppR10G10B10A2HDR10 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x5D, 0x5C, 0x21, 0x9C, + 0xCC, 0x1A, + 0x0E, 0x4F, + 0xA4, + 0xBC, + 0x70, + 0xFB, + 0x3A, + 0xE8, + 0xFD, + 0x28 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat64bppCMYK + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x1F + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat24bpp3Channels + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x20 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat32bpp4Channels + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x21 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat40bpp5Channels + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x22 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat48bpp6Channels + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x23 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat56bpp7Channels + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x24 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat64bpp8Channels + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x25 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat48bpp3Channels + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x26 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat64bpp4Channels + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x27 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat80bpp5Channels + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x28 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat96bpp6Channels + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x29 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat112bpp7Channels + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x2A + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat128bpp8Channels + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x2B + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat40bppCMYKAlpha + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x2C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat80bppCMYKAlpha + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x2D + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat32bpp3ChannelsAlpha + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x2E + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat40bpp4ChannelsAlpha + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x2F + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat48bpp5ChannelsAlpha + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x30 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat56bpp6ChannelsAlpha + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x31 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat64bpp7ChannelsAlpha + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x32 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat72bpp8ChannelsAlpha + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x33 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat64bpp3ChannelsAlpha + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x34 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat80bpp4ChannelsAlpha + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x35 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat96bpp5ChannelsAlpha + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x36 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat112bpp6ChannelsAlpha + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x37 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat128bpp7ChannelsAlpha + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x38 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat144bpp8ChannelsAlpha + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xC3, 0xDD, 0x6F, + 0x03, 0x4E, + 0xFE, 0x4B, + 0xB1, + 0x85, + 0x3D, + 0x77, + 0x76, + 0x8D, + 0xC9, + 0x39 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat8bppY + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x54, 0xDB, 0xB4, 0x91, + 0xF9, 0x2D, + 0xF0, 0x42, + 0xB4, + 0x49, + 0x29, + 0x09, + 0xBB, + 0x3D, + 0xF8, + 0x8E + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat8bppCb + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x24, 0xF2, 0x39, 0x13, + 0xFE, 0x6B, + 0x3E, 0x4C, + 0x93, + 0x02, + 0xE4, + 0xF3, + 0xA6, + 0xD0, + 0xCA, + 0x2A + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat8bppCr + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x53, 0x50, 0x14, 0xB8, + 0x16, 0x21, + 0xF0, 0x49, + 0x88, + 0x35, + 0xED, + 0x84, + 0x4B, + 0x20, + 0x5C, + 0x51 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat16bppCbCr + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x6E, 0xBA, 0x95, 0xFF, + 0xE0, 0x11, + 0x63, 0x42, + 0xBB, + 0x45, + 0x01, + 0x72, + 0x1F, + 0x34, + 0x60, + 0xA4 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat16bppYQuantizedDctCoefficients + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x33, 0xF4, 0x55, 0xA3, + 0xE8, 0x48, + 0x42, 0x4A, + 0x84, + 0xD8, + 0xE2, + 0xAA, + 0x26, + 0xCA, + 0x80, + 0xA4 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat16bppCbQuantizedDctCoefficients + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x61, 0xFF, 0xC4, 0xD2, + 0xA5, 0x56, + 0xC2, 0x49, + 0x8B, + 0x5C, + 0x4C, + 0x19, + 0x25, + 0x96, + 0x48, + 0x37 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_WICPixelFormat16bppCrQuantizedDctCoefficients + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xF0, 0x54, 0xE3, 0x2F, + 0x80, 0x16, + 0xD8, 0x42, + 0x92, + 0x31, + 0xE7, + 0x3C, + 0x05, + 0x65, + 0xBF, + 0xC1 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public const uint FACILITY_WINCODEC_ERR = 2200; + public const uint WINCODEC_ERR_BASE = 8192; + public const int WINCODEC_ERR_GENERIC_ERROR = -2147467259; + public const int WINCODEC_ERR_INVALIDPARAMETER = -2147024809; + public const int WINCODEC_ERR_OUTOFMEMORY = -2147024882; + public const int WINCODEC_ERR_NOTIMPLEMENTED = -2147467263; + public const int WINCODEC_ERR_ABORTED = -2147467260; + public const int WINCODEC_ERR_ACCESSDENIED = -2147024891; + public const uint WICRawChangeNotification_ExposureCompensation = 1; + public const uint WICRawChangeNotification_NamedWhitePoint = 2; + public const uint WICRawChangeNotification_KelvinWhitePoint = 4; + public const uint WICRawChangeNotification_RGBWhitePoint = 8; + public const uint WICRawChangeNotification_Contrast = 16; + public const uint WICRawChangeNotification_Gamma = 32; + public const uint WICRawChangeNotification_Sharpness = 64; + public const uint WICRawChangeNotification_Saturation = 128; + public const uint WICRawChangeNotification_Tint = 256; + public const uint WICRawChangeNotification_NoiseReduction = 512; + public const uint WICRawChangeNotification_DestinationColorContext = 1024; + public const uint WICRawChangeNotification_ToneCurve = 2048; + public const uint WICRawChangeNotification_Rotation = 4096; + public const uint WICRawChangeNotification_RenderMode = 8192; + public static ref readonly Guid GUID_MetadataFormatUnknown + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x2F, 0x59, 0x5E, 0xA4, + 0x78, 0x90, + 0x7C, 0x4A, + 0xAD, + 0xB5, + 0x4E, + 0xDC, + 0x4F, + 0xD6, + 0x1B, + 0x1F + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatIfd + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xC6, 0x96, 0x73, 0x53, + 0x8A, 0x2D, + 0xB6, 0x4B, + 0x9B, + 0xF8, + 0x2F, + 0x0A, + 0x8E, + 0x2A, + 0x3A, + 0xDF + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatSubIfd + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x28, 0xE1, 0xA2, 0x58, + 0xB9, 0x2D, + 0x57, 0x4E, + 0xBB, + 0x14, + 0x51, + 0x77, + 0x89, + 0x1E, + 0xD3, + 0x31 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatExif + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x9D, 0x4F, 0x3C, 0x1C, + 0x4A, 0xB8, + 0x7D, 0x46, + 0x94, + 0x93, + 0x36, + 0xCF, + 0xBD, + 0x59, + 0xEA, + 0x57 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatGps + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x8A, 0xAB, 0x34, 0x71, + 0x51, 0x93, + 0xAD, 0x44, + 0xAF, + 0x62, + 0x44, + 0x8D, + 0xB6, + 0xB5, + 0x02, + 0xEC + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatInterop + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x8E, 0x6F, 0x68, 0xED, + 0x1F, 0x68, + 0x8B, 0x4C, + 0xBD, + 0x41, + 0xA8, + 0xAD, + 0xDB, + 0xF6, + 0xB3, + 0xFC + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatApp0 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x28, 0x70, 0x00, 0x79, + 0x8D, 0x26, + 0xD6, 0x45, + 0xA3, + 0xC2, + 0x35, + 0x4E, + 0x6A, + 0x50, + 0x4B, + 0xC9 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatApp1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xC3, 0xDF, 0xD3, 0x8F, + 0x51, 0xF9, + 0x2B, 0x49, + 0x81, + 0x7F, + 0x69, + 0xC2, + 0xE6, + 0xD9, + 0xA5, + 0xB0 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatApp13 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xA2, 0x56, 0x65, 0x32, + 0x02, 0xF5, + 0x54, 0x43, + 0x9C, + 0xC0, + 0x8E, + 0x3F, + 0x48, + 0xEA, + 0xF6, + 0xB5 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatIPTC + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x14, 0x09, 0xAB, 0x4F, + 0x29, 0xE1, + 0x87, 0x40, + 0xA1, + 0xD1, + 0xBC, + 0x81, + 0x2D, + 0x45, + 0xA7, + 0xB5 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatIRB + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x66, 0x0D, 0x10, 0x16, + 0x70, 0x85, + 0xB9, 0x4B, + 0xB9, + 0x2D, + 0xFD, + 0xA4, + 0xB2, + 0x3E, + 0xCE, + 0x67 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormat8BIMIPTC + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x8C, 0x56, 0x10, 0x00, + 0x52, 0x08, + 0x6A, 0x4E, + 0xB1, + 0x91, + 0x5C, + 0x33, + 0xAC, + 0x5B, + 0x04, + 0x30 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormat8BIMResolutionInfo + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x5D, 0x30, 0x9F, 0x73, + 0xDB, 0x81, + 0xCB, 0x43, + 0xAC, + 0x5E, + 0x55, + 0x01, + 0x3E, + 0xF9, + 0xF0, + 0x03 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormat8BIMIPTCDigest + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x85, 0x22, 0xA3, 0x1C, + 0xCD, 0x9C, + 0x86, 0x47, + 0x8B, + 0xD8, + 0x79, + 0x53, + 0x9D, + 0xB6, + 0xA0, + 0x06 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatXMP + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x38, 0xCC, 0x5A, 0xBB, + 0x16, 0xF2, + 0xEC, 0x4C, + 0xA6, + 0xC5, + 0x5F, + 0x6E, + 0x73, + 0x97, + 0x63, + 0xA9 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatThumbnail + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xE9, 0xCE, 0x3D, 0x24, + 0x03, 0x87, + 0xEE, 0x40, + 0x8E, + 0xF0, + 0x22, + 0xA6, + 0x00, + 0xB8, + 0x05, + 0x8C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatChunktEXt + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x36, 0x89, 0x8D, 0x56, + 0xA9, 0xC0, + 0x23, 0x49, + 0x90, + 0x5D, + 0xDF, + 0x2B, + 0x38, + 0x23, + 0x8F, + 0xBC + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatXMPStruct + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xF1, 0x3C, 0x38, 0x22, + 0x17, 0xED, + 0x2E, 0x4E, + 0xAF, + 0x17, + 0xD8, + 0x5B, + 0x8F, + 0x6B, + 0x30, + 0xD0 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatXMPBag + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x5F, 0xCA, 0x3C, 0x83, + 0xB7, 0xDC, + 0x16, 0x45, + 0x80, + 0x6F, + 0x65, + 0x96, + 0xAB, + 0x26, + 0xDC, + 0xE4 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatXMPSeq + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x02, 0xDF, 0xE8, 0x63, + 0x6C, 0xEB, + 0x6C, 0x45, + 0xA2, + 0x24, + 0xB2, + 0x5E, + 0x79, + 0x4F, + 0xD6, + 0x48 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatXMPAlt + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x75, 0xA6, 0x08, 0x7B, + 0xAA, 0x91, + 0x1B, 0x48, + 0xA7, + 0x98, + 0x4D, + 0xA9, + 0x49, + 0x08, + 0x61, + 0x3B + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatLSD + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x1E, 0x03, 0x56, 0xE2, + 0x99, 0x62, + 0x29, 0x49, + 0xB9, + 0x8D, + 0x5A, + 0xC8, + 0x84, + 0xAF, + 0xBA, + 0x92 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatIMD + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x86, 0xB0, 0x2B, 0xBD, + 0x52, 0x4D, + 0xDD, 0x48, + 0x96, + 0x77, + 0xDB, + 0x48, + 0x3E, + 0x85, + 0xAE, + 0x8F + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatGCE + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xD8, 0xCA, 0x25, 0x2A, + 0xEB, 0xDE, + 0x69, 0x4C, + 0xA7, + 0x88, + 0x0E, + 0xC2, + 0x26, + 0x6D, + 0xCA, + 0xFD + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatAPE + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xC2, 0x3D, 0x04, 0x2E, + 0x67, 0xC9, + 0x05, 0x4E, + 0x87, + 0x5E, + 0x61, + 0x8B, + 0xF6, + 0x7E, + 0x85, + 0xC3 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatJpegChrominance + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xCF, 0x0D, 0x3D, 0xF7, + 0xC6, 0xCE, + 0x85, 0x4F, + 0x9B, + 0x0E, + 0x1C, + 0x39, + 0x56, + 0xB1, + 0xBE, + 0xF7 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatJpegLuminance + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x07, 0x80, 0x90, 0x86, + 0xFC, 0xED, + 0x60, 0x48, + 0x8D, + 0x4B, + 0x4E, + 0xE6, + 0xE8, + 0x3E, + 0x60, + 0x58 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatJpegComment + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x33, 0x5F, 0x0E, 0x22, + 0xD3, 0xAF, + 0x4E, 0x47, + 0x9D, + 0x31, + 0x7D, + 0x4F, + 0xE7, + 0x30, + 0xF5, + 0x57 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatGifComment + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xE0, 0xE0, 0xB6, 0xC4, + 0xB4, 0xCF, + 0xD3, 0x4A, + 0xAB, + 0x33, + 0x9A, + 0xAD, + 0x23, + 0x55, + 0xA3, + 0x4A + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatChunkgAMA + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xA5, 0x35, 0x09, 0xF0, + 0x5D, 0x1D, + 0xD1, 0x4C, + 0x81, + 0xB2, + 0x93, + 0x24, + 0xD7, + 0xEC, + 0xA7, + 0x81 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatChunkbKGD + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x71, 0x35, 0x4D, 0xE1, + 0x47, 0x6B, + 0xEA, 0x4D, + 0xB6, + 0x0A, + 0x87, + 0xCE, + 0x0A, + 0x78, + 0xDF, + 0xB7 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatChunkiTXt + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x29, 0xC7, 0xBE, 0xC2, + 0x68, 0x0B, + 0x77, 0x4B, + 0xAA, + 0x0E, + 0x62, + 0x95, + 0xA6, + 0xAC, + 0x18, + 0x14 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatChunkcHRM + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x5B, 0x65, 0xB3, 0x9D, + 0x42, 0x28, + 0xB3, 0x44, + 0x80, + 0x67, + 0x12, + 0xE9, + 0xB3, + 0x75, + 0x55, + 0x6A + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatChunkhIST + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xDA, 0x82, 0x9A, 0xC5, + 0x74, 0xDB, + 0xA4, 0x48, + 0xBD, + 0x6A, + 0xB6, + 0x9C, + 0x49, + 0x31, + 0xEF, + 0x95 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatChunkiCCP + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xAB, 0x49, 0x43, 0xEB, + 0x85, 0xB6, + 0x0F, 0x45, + 0x91, + 0xB5, + 0xE8, + 0x02, + 0xE8, + 0x92, + 0x53, + 0x6C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatChunksRGB + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x36, 0xFD, 0x15, 0xC1, + 0x6F, 0xCC, + 0x3F, 0x4E, + 0x83, + 0x63, + 0x52, + 0x4B, + 0x87, + 0xC6, + 0xB0, + 0xD9 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatChunktIME + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x2D, 0xAE, 0x00, 0x6B, + 0x4B, 0xE2, + 0x0A, 0x46, + 0x98, + 0xB6, + 0x87, + 0x8B, + 0xD0, + 0x30, + 0x72, + 0xFD + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatDds + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x03, 0x46, 0x06, 0x4A, + 0x33, 0x8C, + 0x60, 0x4E, + 0x9C, + 0x29, + 0x13, + 0x62, + 0x31, + 0x70, + 0x2D, + 0x08 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatHeif + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xE1, 0xF3, 0x7E, 0x81, + 0x88, 0x12, + 0xF4, 0x45, + 0xA8, + 0x52, + 0x26, + 0x0D, + 0x9E, + 0x7C, + 0xCE, + 0x83 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatHeifHDR + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x8A, 0x8D, 0x8B, 0x56, + 0x65, 0x1E, + 0x8C, 0x43, + 0x89, + 0x68, + 0xD6, + 0x0E, + 0x10, + 0x12, + 0xBE, + 0xB9 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatWebpANIM + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xA6, 0xFD, 0xC4, 0x6D, + 0xE6, 0x78, + 0x02, 0x41, + 0xAE, + 0x35, + 0xBC, + 0xFA, + 0x1E, + 0xDC, + 0xC7, + 0x8B + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid GUID_MetadataFormatWebpANMF + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xEE, 0x05, 0xC1, 0x43, + 0x3B, 0xB9, + 0xBB, 0x4A, + 0xB0, + 0x03, + 0xA0, + 0x8C, + 0x0D, + 0x87, + 0x04, + 0x71 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICUnknownMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xC2, 0x45, 0x97, 0x69, + 0x66, 0x50, + 0x82, 0x4B, + 0xA8, + 0xE3, + 0xD4, + 0x04, + 0x78, + 0xDB, + 0xEC, + 0x8C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICUnknownMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x86, 0xCA, 0x9C, 0xA0, + 0xBA, 0x27, + 0x39, 0x4F, + 0x90, + 0x53, + 0x12, + 0x1F, + 0xA4, + 0xDC, + 0x08, + 0xFC + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICApp0MetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xA2, 0x33, 0xC6, 0xF3, + 0xC8, 0x46, + 0x8E, 0x49, + 0x8F, + 0xBB, + 0xCC, + 0x6F, + 0x72, + 0x1B, + 0xBC, + 0xDE + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICApp0MetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x33, 0x4B, 0x32, 0x43, + 0x8F, 0xA7, + 0x0F, 0x48, + 0x91, + 0x11, + 0x96, + 0x38, + 0xAA, + 0xCC, + 0xC8, + 0x32 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICApp1MetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x69, 0x60, 0x36, 0xEE, + 0x32, 0x18, + 0x0F, 0x42, + 0xB3, + 0x81, + 0x04, + 0x79, + 0xAD, + 0x06, + 0x6F, + 0x19 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICApp1MetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x13, 0x35, 0xE3, 0xDD, + 0x4E, 0x77, + 0xCD, 0x4B, + 0xAE, + 0x79, + 0x02, + 0xF4, + 0xAD, + 0xFE, + 0x62, + 0xFC + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICApp13MetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x19, 0xA9, 0x19, 0x7B, + 0xD6, 0xA9, + 0xE5, 0x49, + 0xBD, + 0x45, + 0x02, + 0xC3, + 0x4E, + 0x4E, + 0x4C, + 0xD5 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICApp13MetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x50, 0x3C, 0x7E, 0xAA, + 0x4C, 0x86, + 0x04, 0x46, + 0xBC, + 0x04, + 0x8B, + 0x0B, + 0x76, + 0xE6, + 0x37, + 0xF6 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICIfdMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x56, 0x46, 0x91, 0x8F, + 0x0A, 0x9D, + 0xB2, 0x4E, + 0x90, + 0x19, + 0x0B, + 0xF9, + 0x6D, + 0x8A, + 0x9E, + 0xE6 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICIfdMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x28, 0xFC, 0xEB, 0xB1, + 0xBD, 0xC9, + 0xA2, 0x47, + 0x8D, + 0x33, + 0xB9, + 0x48, + 0x76, + 0x97, + 0x77, + 0xA7 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICSubIfdMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x09, 0x2F, 0xD4, 0x50, + 0xD1, 0xEC, + 0x41, 0x4B, + 0xB6, + 0x5D, + 0xDA, + 0x1F, + 0xDA, + 0xA7, + 0x56, + 0x63 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICSubIfdMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x86, 0x53, 0xDE, 0x8A, + 0x9B, 0x8E, + 0x4C, 0x4F, + 0xAC, + 0xF2, + 0xF0, + 0x00, + 0x87, + 0x06, + 0xB2, + 0x38 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICExifMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x60, 0x38, 0x40, 0xD9, + 0x7F, 0x29, + 0x49, 0x4A, + 0xBF, + 0x9B, + 0x77, + 0x89, + 0x81, + 0x50, + 0xA4, + 0x42 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICExifMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xDA, 0x4C, 0xA1, 0xC9, + 0x39, 0xC3, + 0x0B, 0x46, + 0x90, + 0x78, + 0xD4, + 0xDE, + 0xBC, + 0xFA, + 0xBE, + 0x91 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICGpsMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x0B, 0x79, 0x97, 0x36, + 0x3B, 0x22, + 0x4E, 0x48, + 0x99, + 0x25, + 0xC4, + 0x86, + 0x92, + 0x18, + 0xF1, + 0x7A + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICGpsMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xE4, 0x13, 0x8C, 0xCB, + 0xB5, 0x62, + 0x96, 0x4C, + 0xA4, + 0x8B, + 0x6B, + 0xA6, + 0xAC, + 0xE3, + 0x9C, + 0x76 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICInteropMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x98, 0xB8, 0xC8, 0xB5, + 0x74, 0x00, + 0x9F, 0x45, + 0xB7, + 0x00, + 0x86, + 0x0D, + 0x46, + 0x51, + 0xEA, + 0x14 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICInteropMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x45, 0xC6, 0x2E, 0x12, + 0x7E, 0xCD, + 0xD8, 0x44, + 0xB1, + 0x86, + 0x2C, + 0x8C, + 0x20, + 0xC3, + 0xB5, + 0x0F + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICThumbnailMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x59, 0x29, 0x01, 0xFB, + 0xF6, 0xF4, + 0xD7, 0x44, + 0x9D, + 0x09, + 0xDA, + 0xA0, + 0x87, + 0xA9, + 0xDB, + 0x57 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICThumbnailMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x0C, 0xB2, 0x49, 0xD0, + 0xD0, 0x5D, + 0xFE, 0x44, + 0xB0, + 0xB3, + 0x8F, + 0x92, + 0xC8, + 0xE6, + 0xD0, + 0x80 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICIPTCMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x59, 0x29, 0x01, 0x03, + 0xF6, 0xF4, + 0xD7, 0x44, + 0x9D, + 0x09, + 0xDA, + 0xA0, + 0x87, + 0xA9, + 0xDB, + 0x57 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICIPTCMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x0C, 0xB2, 0x49, 0x12, + 0xD0, 0x5D, + 0xFE, 0x44, + 0xB0, + 0xB3, + 0x8F, + 0x92, + 0xC8, + 0xE6, + 0xD0, + 0x80 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICIRBMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xD7, 0xD3, 0xDC, 0xD4, + 0xC2, 0xB4, + 0xD9, 0x47, + 0xA6, + 0xBF, + 0xB8, + 0x9B, + 0xA3, + 0x96, + 0xA4, + 0xA3 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICIRBMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x35, 0x19, 0x5C, 0x5C, + 0x35, 0x02, + 0x34, 0x44, + 0x80, + 0xBC, + 0x25, + 0x1B, + 0xC1, + 0xEC, + 0x39, + 0xC6 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WIC8BIMIPTCMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x8C, 0x66, 0x10, 0x00, + 0x01, 0x08, + 0xA6, 0x4D, + 0xA4, + 0xA4, + 0x82, + 0x65, + 0x22, + 0xB6, + 0xD2, + 0x8F + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WIC8BIMIPTCMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x26, 0x82, 0x10, 0x00, + 0x41, 0xEE, + 0xA2, 0x44, + 0x9E, + 0x9C, + 0x4B, + 0xE4, + 0xD5, + 0xB1, + 0xD2, + 0xCD + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WIC8BIMResolutionInfoMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x7A, 0x13, 0x05, 0x58, + 0x48, 0xE3, + 0x7C, 0x4F, + 0xB3, + 0xCC, + 0x6D, + 0xB9, + 0x96, + 0x5A, + 0x05, + 0x99 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WIC8BIMResolutionInfoMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x0E, 0xFE, 0xF2, 0x4F, + 0x4A, 0xE7, + 0x71, 0x4B, + 0x98, + 0xC4, + 0xAB, + 0x7D, + 0xC1, + 0x67, + 0x07, + 0xBA + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WIC8BIMIPTCDigestMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x1E, 0x5F, 0x80, 0x02, + 0xAA, 0xD5, + 0x5B, 0x41, + 0x82, + 0xC5, + 0x61, + 0xC0, + 0x33, + 0xA9, + 0x88, + 0xA6 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WIC8BIMIPTCDigestMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x2B, 0xE6, 0xB5, 0x2D, + 0x67, 0x0D, + 0x5F, 0x49, + 0x8F, + 0x9D, + 0xC2, + 0xF0, + 0x18, + 0x86, + 0x47, + 0xAC + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICPngTextMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xCC, 0xAF, 0x59, 0x4B, + 0xC3, 0xB8, + 0x8A, 0x40, + 0xB6, + 0x70, + 0x89, + 0xE5, + 0xFA, + 0xB6, + 0xFD, + 0xA7 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICPngTextMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xB9, 0xAF, 0xEB, 0xB5, + 0x3E, 0x25, + 0x72, 0x4A, + 0xA7, + 0x44, + 0x07, + 0x62, + 0xD2, + 0x68, + 0x56, + 0x83 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICXMPMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xDF, 0x24, 0xB6, 0x72, + 0x11, 0xAE, + 0x48, 0x49, + 0xA6, + 0x5C, + 0x35, + 0x1E, + 0xB0, + 0x82, + 0x94, + 0x19 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICXMPMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x4E, 0xE1, 0x65, 0x17, + 0xD4, 0x1B, + 0x2E, 0x46, + 0xB6, + 0xB1, + 0x59, + 0x0B, + 0xF1, + 0x26, + 0x2A, + 0xC6 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICXMPStructMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x9A, 0x0D, 0xB9, 0x01, + 0x09, 0x82, + 0xF7, 0x47, + 0x9C, + 0x52, + 0xE1, + 0x24, + 0x4B, + 0xF5, + 0x0C, + 0xED + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICXMPStructMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x93, 0x1F, 0xC2, 0x22, + 0xDB, 0x7D, + 0x1C, 0x41, + 0x9B, + 0x17, + 0xC5, + 0xB7, + 0xBD, + 0x06, + 0x4A, + 0xBC + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICXMPBagMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x30, 0x9A, 0xE7, 0xE7, + 0x2C, 0x4F, + 0xAB, 0x4F, + 0x8D, + 0x00, + 0x39, + 0x4F, + 0x2D, + 0x6B, + 0xBE, + 0xBE + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICXMPBagMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x8C, 0x2C, 0x82, 0xED, + 0xBE, 0xD6, + 0x01, 0x43, + 0xA6, + 0x31, + 0x0E, + 0x14, + 0x16, + 0xBA, + 0xD2, + 0x8F + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICXMPSeqMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x53, 0xE7, 0x12, 0x7F, + 0x71, 0xFC, + 0xD7, 0x43, + 0xA5, + 0x1D, + 0x92, + 0xF3, + 0x59, + 0x77, + 0xAB, + 0xB5 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICXMPSeqMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xDE, 0xD1, 0x68, 0x6D, + 0x32, 0xD4, + 0x0F, 0x4B, + 0x92, + 0x3A, + 0x09, + 0x11, + 0x83, + 0xA9, + 0xBD, + 0xA7 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICXMPAltMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xC2, 0xDC, 0x94, 0xAA, + 0xB0, 0xB8, + 0x98, 0x48, + 0xB8, + 0x35, + 0x00, + 0x0A, + 0xAB, + 0xD7, + 0x43, + 0x93 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICXMPAltMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x6C, 0x2A, 0x6C, 0x07, + 0x8F, 0xF7, + 0x46, 0x4C, + 0xA7, + 0x23, + 0x35, + 0x83, + 0xE7, + 0x08, + 0x76, + 0xEA + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICLSDMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x93, 0x07, 0x07, 0x41, + 0xE4, 0x59, + 0x9A, 0x47, + 0xA1, + 0xF7, + 0x95, + 0x4A, + 0xDC, + 0x2E, + 0xF5, + 0xFC + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICLSDMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xE7, 0x37, 0xC0, 0x73, + 0xD9, 0xE5, + 0x54, 0x49, + 0x87, + 0x6A, + 0x6D, + 0xA8, + 0x1D, + 0x6E, + 0x57, + 0x68 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICGCEMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x5D, 0x34, 0x2E, 0xB9, + 0x2D, 0xF5, + 0xF3, 0x41, + 0xB5, + 0x62, + 0x08, + 0x1B, + 0xC7, + 0x72, + 0xE3, + 0xB9 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICGCEMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x76, 0xDC, 0x95, 0xAF, + 0xB2, 0x16, + 0xF4, 0x47, + 0xB3, + 0xEA, + 0x3C, + 0x31, + 0x79, + 0x66, + 0x93, + 0xE7 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICIMDMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x67, 0xA2, 0x47, 0x74, + 0x15, 0x00, + 0xC8, 0x42, + 0xA8, + 0xF1, + 0xFB, + 0x3B, + 0x94, + 0xC6, + 0x83, + 0x61 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICIMDMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x1F, 0x07, 0x89, 0x8C, + 0x2E, 0x45, + 0x95, 0x4E, + 0x96, + 0x82, + 0x9D, + 0x10, + 0x24, + 0x62, + 0x71, + 0x72 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICAPEMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x3A, 0xB9, 0x67, 0x17, + 0x21, 0xB0, + 0xEA, 0x44, + 0x92, + 0x0F, + 0x86, + 0x3C, + 0x11, + 0xF4, + 0xF7, + 0x68 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICAPEMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xCA, 0xDF, 0x6E, 0xBD, + 0x90, 0x28, + 0x2F, 0x48, + 0xB2, + 0x33, + 0x8D, + 0x73, + 0x39, + 0xA1, + 0xCF, + 0x8D + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICJpegChrominanceMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x4B, 0x90, 0xB1, 0x50, + 0x8F, 0xF2, + 0x74, 0x45, + 0x93, + 0xF4, + 0x0B, + 0xAD, + 0xE8, + 0x2C, + 0x69, + 0xE9 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICJpegChrominanceMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xF0, 0x66, 0xF5, 0x3F, + 0x6B, 0x6E, + 0xD4, 0x49, + 0x96, + 0xE6, + 0xB7, + 0x88, + 0x86, + 0x69, + 0x2C, + 0x62 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICJpegLuminanceMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x88, 0x2F, 0x6F, 0x35, + 0xA6, 0x05, + 0x28, 0x47, + 0xB9, + 0xA4, + 0x1B, + 0xFB, + 0xCE, + 0x04, + 0xD8, + 0x38 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICJpegLuminanceMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xBC, 0x3A, 0x58, 0x1D, + 0x0E, 0x8A, + 0x57, 0x46, + 0x99, + 0x82, + 0xA3, + 0x80, + 0xCA, + 0x58, + 0xFB, + 0x4B + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICJpegCommentMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x7C, 0x34, 0x66, 0x9F, + 0xC4, 0x60, + 0x4D, 0x4C, + 0xAB, + 0x58, + 0xD2, + 0x35, + 0x86, + 0x85, + 0xF6, + 0x07 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICJpegCommentMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x6F, 0x23, 0x73, 0xE5, + 0xB1, 0x55, + 0xDA, 0x4E, + 0x81, + 0xEA, + 0x9F, + 0x65, + 0xDB, + 0x02, + 0x90, + 0xD3 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICGifCommentMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x3B, 0x7D, 0x55, 0x32, + 0xDC, 0x69, + 0x95, 0x4F, + 0x83, + 0x6E, + 0xF5, + 0x97, + 0x2B, + 0x2F, + 0x61, + 0x59 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICGifCommentMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xFC, 0x97, 0x27, 0xA0, + 0xAE, 0xC4, + 0x8C, 0x41, + 0xAF, + 0x95, + 0xE6, + 0x37, + 0xC7, + 0xEA, + 0xD2, + 0xA1 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICPngGamaMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x39, 0xCA, 0x92, 0x36, + 0x82, 0xE0, + 0x50, 0x43, + 0x9E, + 0x1F, + 0x37, + 0x04, + 0xCB, + 0x08, + 0x3C, + 0xD5 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICPngGamaMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x13, 0x6D, 0x03, 0xFF, + 0x4B, 0x5D, + 0xDD, 0x46, + 0xB1, + 0x0F, + 0x10, + 0x66, + 0x93, + 0xD9, + 0xFE, + 0x4F + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICPngBkgdMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xA6, 0xA4, 0xE7, 0x0C, + 0xE8, 0x03, + 0x60, 0x4A, + 0x9D, + 0x15, + 0x28, + 0x2E, + 0xF3, + 0x2E, + 0xE7, + 0xDA + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICPngBkgdMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xFD, 0xF2, 0xE3, 0x68, + 0xAE, 0x31, + 0x41, 0x44, + 0xBB, + 0x6A, + 0xFD, + 0x70, + 0x47, + 0x52, + 0x5F, + 0x90 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICPngItxtMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xFA, 0xB2, 0xBF, 0xAA, + 0x1E, 0x3E, + 0x8F, 0x4A, + 0x89, + 0x77, + 0x55, + 0x56, + 0xFB, + 0x94, + 0xEA, + 0x23 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICPngItxtMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x19, 0x97, 0x87, 0x31, + 0x51, 0xE7, + 0xF8, 0x4D, + 0x98, + 0x1D, + 0x68, + 0xDF, + 0xF6, + 0x77, + 0x04, + 0xED + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICPngChrmMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x36, 0x5F, 0x0B, 0xF9, + 0x7B, 0x36, + 0x2A, 0x40, + 0x9D, + 0xD1, + 0xBC, + 0x0F, + 0xD5, + 0x9D, + 0x8F, + 0x62 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICPngChrmMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xEB, 0xE3, 0x3C, 0xE2, + 0x08, 0x56, + 0x83, 0x4E, + 0xBC, + 0xEF, + 0x27, + 0xB1, + 0x98, + 0x7E, + 0x51, + 0xD7 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICPngHistMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xB7, 0x0B, 0x7A, 0x87, + 0x13, 0xA3, + 0x91, 0x44, + 0x87, + 0xB5, + 0x2E, + 0x6D, + 0x05, + 0x94, + 0xF5, + 0x20 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICPngHistMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x49, 0xE7, 0x03, 0x8A, + 0x2E, 0x67, + 0x6E, 0x44, + 0xBF, + 0x1F, + 0x2C, + 0x11, + 0xD2, + 0x33, + 0xB6, + 0xFF + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICPngIccpMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x3B, 0xE6, 0xD3, 0xF5, + 0x0F, 0xCB, + 0x28, 0x46, + 0xA4, + 0x78, + 0x6D, + 0x82, + 0x44, + 0xBE, + 0x36, + 0xB1 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICPngIccpMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x5F, 0x1E, 0x67, 0x16, + 0xE6, 0x0C, + 0xC4, 0x4C, + 0x97, + 0x68, + 0xE8, + 0x9F, + 0xE5, + 0x01, + 0x8A, + 0xDE + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICPngSrgbMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x0C, 0x36, 0x40, 0xFB, + 0x7E, 0x54, + 0x56, 0x49, + 0xA3, + 0xB9, + 0xD4, + 0x41, + 0x88, + 0x59, + 0xBA, + 0x66 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICPngSrgbMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xC6, 0x35, 0xEE, 0xA6, + 0xEC, 0x87, + 0xDF, 0x47, + 0x9F, + 0x22, + 0x1D, + 0x5A, + 0xAD, + 0x84, + 0x0C, + 0x82 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICPngTimeMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x02, 0xDF, 0x4E, 0xD9, + 0xE5, 0xEF, + 0x0D, 0x4F, + 0x85, + 0xC8, + 0xF5, + 0xA6, + 0x8B, + 0x30, + 0x00, + 0xB1 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICPngTimeMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x00, 0x84, 0xB7, 0x1A, + 0xA3, 0xB5, + 0x91, 0x4D, + 0x8A, + 0xCE, + 0x33, + 0xFC, + 0xD1, + 0x49, + 0x9B, + 0xE6 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICDdsMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xCA, 0x88, 0x6C, 0x27, + 0x33, 0x75, + 0x86, 0x4A, + 0xB6, + 0x76, + 0x66, + 0xB3, + 0x60, + 0x80, + 0xD4, + 0x84 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICDdsMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xBD, 0x8B, 0x68, 0xFD, + 0xED, 0x31, + 0xB7, 0x4D, + 0xA7, + 0x23, + 0x93, + 0x49, + 0x27, + 0xD3, + 0x83, + 0x67 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICHeifMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x3F, 0xFC, 0xDD, 0xAC, + 0xEC, 0x85, + 0xBC, 0x41, + 0xBD, + 0xEF, + 0x1B, + 0xC2, + 0x62, + 0xE4, + 0xDB, + 0x05 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICHeifMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x79, 0x5E, 0xE4, 0x3A, + 0xBC, 0x40, + 0x01, 0x44, + 0xAC, + 0xE5, + 0xDD, + 0x3C, + 0xB1, + 0x6E, + 0x6A, + 0xFE + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICHeifHDRMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x3D, 0xDE, 0x38, 0x24, + 0xD9, 0x94, + 0xE8, 0x4B, + 0x84, + 0xA8, + 0x4D, + 0xE9, + 0x5A, + 0x57, + 0x5E, + 0x75 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICWebpAnimMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x11, 0x99, 0x6F, 0x07, + 0x48, 0xA3, + 0x5C, 0x46, + 0xA8, + 0x07, + 0xA2, + 0x52, + 0xF3, + 0xF2, + 0xD3, + 0xDE + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static ref readonly Guid CLSID_WICWebpAnmfMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x03, 0x0B, 0xA1, 0x85, + 0xF6, 0xC9, + 0x9F, 0x43, + 0xBE, + 0x5E, + 0xC0, + 0xFB, + 0xEF, + 0x67, + 0x80, + 0x7C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + +} + +#region Enums +/// +/// WICColorContextType +public enum WICColorContextType : int +{ + /// + /// WICColorContextUninitialized + Uninitialized = 0, + /// + /// WICColorContextProfile + Profile = 1, + /// + /// WICColorContextExifColorSpace + ExifColorSpace = 2, +} + +/// +/// WICBitmapCreateCacheOption +public enum WICBitmapCreateCacheOption : int +{ + /// + /// WICBitmapNoCache + NoCache = 0, + /// + /// WICBitmapCacheOnDemand + CacheOnDemand = 1, + /// + /// WICBitmapCacheOnLoad + CacheOnLoad = 2, +} + +/// +/// WICDecodeOptions +public enum WICDecodeOptions : int +{ + /// + /// WICDecodeMetadataCacheOnDemand + CacheOnDemand = 0, + /// + /// WICDecodeMetadataCacheOnLoad + CacheOnLoad = 1, +} + +/// +/// WICBitmapEncoderCacheOption +public enum WICBitmapEncoderCacheOption : int +{ + /// + /// WICBitmapEncoderCacheInMemory + WICBitmapEncoderCacheInMemory = 0, + /// + /// WICBitmapEncoderCacheTempFile + WICBitmapEncoderCacheTempFile = 1, + /// + /// WICBitmapEncoderNoCache + WICBitmapEncoderNoCache = 2, +} + +/// +/// WICComponentType +public enum WICComponentType : int +{ + /// + /// WICDecoder + WICDecoder = 1, + /// + /// WICEncoder + WICEncoder = 2, + /// + /// WICPixelFormatConverter + WICPixelFormatConverter = 4, + /// + /// WICMetadataReader + WICMetadataReader = 8, + /// + /// WICMetadataWriter + WICMetadataWriter = 16, + /// + /// WICPixelFormat + WICPixelFormat = 32, + /// + /// WICAllComponents + WICAllComponents = 63, +} + +/// +/// WICComponentEnumerateOptions +public enum WICComponentEnumerateOptions : int +{ + /// + /// WICComponentEnumerateDefault + WICComponentEnumerateDefault = 0, + /// + /// WICComponentEnumerateRefresh + WICComponentEnumerateRefresh = 1, + /// + /// WICComponentEnumerateDisabled + WICComponentEnumerateDisabled = -2147483648, + /// + /// WICComponentEnumerateUnsigned + WICComponentEnumerateUnsigned = 1073741824, + /// + /// WICComponentEnumerateBuiltInOnly + WICComponentEnumerateBuiltInOnly = 536870912, +} + +/// +/// WICBitmapInterpolationMode +public enum WICBitmapInterpolationMode : int +{ + /// + /// WICBitmapInterpolationModeNearestNeighbor + WICBitmapInterpolationModeNearestNeighbor = 0, + /// + /// WICBitmapInterpolationModeLinear + WICBitmapInterpolationModeLinear = 1, + /// + /// WICBitmapInterpolationModeCubic + WICBitmapInterpolationModeCubic = 2, + /// + /// WICBitmapInterpolationModeFant + WICBitmapInterpolationModeFant = 3, + /// + /// WICBitmapInterpolationModeHighQualityCubic + WICBitmapInterpolationModeHighQualityCubic = 4, +} + +/// +/// WICBitmapPaletteType +public enum WICBitmapPaletteType : int +{ + /// + /// WICBitmapPaletteTypeCustom + WICBitmapPaletteTypeCustom = 0, + /// + /// WICBitmapPaletteTypeMedianCut + WICBitmapPaletteTypeMedianCut = 1, + /// + /// WICBitmapPaletteTypeFixedBW + WICBitmapPaletteTypeFixedBW = 2, + /// + /// WICBitmapPaletteTypeFixedHalftone8 + WICBitmapPaletteTypeFixedHalftone8 = 3, + /// + /// WICBitmapPaletteTypeFixedHalftone27 + WICBitmapPaletteTypeFixedHalftone27 = 4, + /// + /// WICBitmapPaletteTypeFixedHalftone64 + WICBitmapPaletteTypeFixedHalftone64 = 5, + /// + /// WICBitmapPaletteTypeFixedHalftone125 + WICBitmapPaletteTypeFixedHalftone125 = 6, + /// + /// WICBitmapPaletteTypeFixedHalftone216 + WICBitmapPaletteTypeFixedHalftone216 = 7, + /// + /// WICBitmapPaletteTypeFixedWebPalette + WICBitmapPaletteTypeFixedWebPalette = 7, + /// + /// WICBitmapPaletteTypeFixedHalftone252 + WICBitmapPaletteTypeFixedHalftone252 = 8, + /// + /// WICBitmapPaletteTypeFixedHalftone256 + WICBitmapPaletteTypeFixedHalftone256 = 9, + /// + /// WICBitmapPaletteTypeFixedGray4 + WICBitmapPaletteTypeFixedGray4 = 10, + /// + /// WICBitmapPaletteTypeFixedGray16 + WICBitmapPaletteTypeFixedGray16 = 11, + /// + /// WICBitmapPaletteTypeFixedGray256 + WICBitmapPaletteTypeFixedGray256 = 12, +} + +/// +/// WICBitmapDitherType +public enum WICBitmapDitherType : int +{ + /// + /// WICBitmapDitherTypeNone + WICBitmapDitherTypeNone = 0, + /// + /// WICBitmapDitherTypeSolid + WICBitmapDitherTypeSolid = 0, + /// + /// WICBitmapDitherTypeOrdered4x4 + WICBitmapDitherTypeOrdered4x4 = 1, + /// + /// WICBitmapDitherTypeOrdered8x8 + WICBitmapDitherTypeOrdered8x8 = 2, + /// + /// WICBitmapDitherTypeOrdered16x16 + WICBitmapDitherTypeOrdered16x16 = 3, + /// + /// WICBitmapDitherTypeSpiral4x4 + WICBitmapDitherTypeSpiral4x4 = 4, + /// + /// WICBitmapDitherTypeSpiral8x8 + WICBitmapDitherTypeSpiral8x8 = 5, + /// + /// WICBitmapDitherTypeDualSpiral4x4 + WICBitmapDitherTypeDualSpiral4x4 = 6, + /// + /// WICBitmapDitherTypeDualSpiral8x8 + WICBitmapDitherTypeDualSpiral8x8 = 7, + /// + /// WICBitmapDitherTypeErrorDiffusion + WICBitmapDitherTypeErrorDiffusion = 8, +} + +/// +/// WICBitmapAlphaChannelOption +public enum WICBitmapAlphaChannelOption : int +{ + /// + /// WICBitmapUseAlpha + WICBitmapUseAlpha = 0, + /// + /// WICBitmapUsePremultipliedAlpha + WICBitmapUsePremultipliedAlpha = 1, + /// + /// WICBitmapIgnoreAlpha + WICBitmapIgnoreAlpha = 2, +} + +/// +/// WICBitmapTransformOptions +public enum WICBitmapTransformOptions : int +{ + /// + /// WICBitmapTransformRotate0 + WICBitmapTransformRotate0 = 0, + /// + /// WICBitmapTransformRotate90 + WICBitmapTransformRotate90 = 1, + /// + /// WICBitmapTransformRotate180 + WICBitmapTransformRotate180 = 2, + /// + /// WICBitmapTransformRotate270 + WICBitmapTransformRotate270 = 3, + /// + /// WICBitmapTransformFlipHorizontal + WICBitmapTransformFlipHorizontal = 8, + /// + /// WICBitmapTransformFlipVertical + WICBitmapTransformFlipVertical = 16, +} + +/// +/// WICBitmapLockFlags +[Flags] +public enum WICBitmapLockFlags : int +{ + None = 0, + /// + /// WICBitmapLockRead + WICBitmapLockRead = 1, + /// + /// WICBitmapLockWrite + WICBitmapLockWrite = 2, +} + +/// +/// WICBitmapDecoderCapabilities +public enum WICBitmapDecoderCapabilities : int +{ + /// + /// WICBitmapDecoderCapabilitySameEncoder + WICBitmapDecoderCapabilitySameEncoder = 1, + /// + /// WICBitmapDecoderCapabilityCanDecodeAllImages + WICBitmapDecoderCapabilityCanDecodeAllImages = 2, + /// + /// WICBitmapDecoderCapabilityCanDecodeSomeImages + WICBitmapDecoderCapabilityCanDecodeSomeImages = 4, + /// + /// WICBitmapDecoderCapabilityCanEnumerateMetadata + WICBitmapDecoderCapabilityCanEnumerateMetadata = 8, + /// + /// WICBitmapDecoderCapabilityCanDecodeThumbnail + WICBitmapDecoderCapabilityCanDecodeThumbnail = 16, +} + +/// +/// WICProgressOperation +public enum WICProgressOperation : int +{ + /// + /// WICProgressOperationCopyPixels + WICProgressOperationCopyPixels = 1, + /// + /// WICProgressOperationWritePixels + WICProgressOperationWritePixels = 2, + /// + /// WICProgressOperationAll + WICProgressOperationAll = 65535, +} + +/// +/// WICProgressNotification +public enum WICProgressNotification : int +{ + /// + /// WICProgressNotificationBegin + WICProgressNotificationBegin = 65536, + /// + /// WICProgressNotificationEnd + WICProgressNotificationEnd = 131072, + /// + /// WICProgressNotificationFrequent + WICProgressNotificationFrequent = 262144, + /// + /// WICProgressNotificationAll + WICProgressNotificationAll = -65536, +} + +/// +/// WICComponentSigning +public enum WICComponentSigning : int +{ + /// + /// WICComponentSigned + WICComponentSigned = 1, + /// + /// WICComponentUnsigned + WICComponentUnsigned = 2, + /// + /// WICComponentSafe + WICComponentSafe = 4, + /// + /// WICComponentDisabled + WICComponentDisabled = -2147483648, +} + +/// +/// WICGifLogicalScreenDescriptorProperties +public enum WICGifLogicalScreenDescriptorProperties : uint +{ + /// + /// WICGifLogicalScreenSignature + WICGifLogicalScreenSignature = 1, + /// + /// WICGifLogicalScreenDescriptorWidth + WICGifLogicalScreenDescriptorWidth = 2, + /// + /// WICGifLogicalScreenDescriptorHeight + WICGifLogicalScreenDescriptorHeight = 3, + /// + /// WICGifLogicalScreenDescriptorGlobalColorTableFlag + WICGifLogicalScreenDescriptorGlobalColorTableFlag = 4, + /// + /// WICGifLogicalScreenDescriptorColorResolution + WICGifLogicalScreenDescriptorColorResolution = 5, + /// + /// WICGifLogicalScreenDescriptorSortFlag + WICGifLogicalScreenDescriptorSortFlag = 6, + /// + /// WICGifLogicalScreenDescriptorGlobalColorTableSize + WICGifLogicalScreenDescriptorGlobalColorTableSize = 7, + /// + /// WICGifLogicalScreenDescriptorBackgroundColorIndex + WICGifLogicalScreenDescriptorBackgroundColorIndex = 8, + /// + /// WICGifLogicalScreenDescriptorPixelAspectRatio + WICGifLogicalScreenDescriptorPixelAspectRatio = 9, +} + +/// +/// WICGifImageDescriptorProperties +public enum WICGifImageDescriptorProperties : uint +{ + /// + /// WICGifImageDescriptorLeft + WICGifImageDescriptorLeft = 1, + /// + /// WICGifImageDescriptorTop + WICGifImageDescriptorTop = 2, + /// + /// WICGifImageDescriptorWidth + WICGifImageDescriptorWidth = 3, + /// + /// WICGifImageDescriptorHeight + WICGifImageDescriptorHeight = 4, + /// + /// WICGifImageDescriptorLocalColorTableFlag + WICGifImageDescriptorLocalColorTableFlag = 5, + /// + /// WICGifImageDescriptorInterlaceFlag + WICGifImageDescriptorInterlaceFlag = 6, + /// + /// WICGifImageDescriptorSortFlag + WICGifImageDescriptorSortFlag = 7, + /// + /// WICGifImageDescriptorLocalColorTableSize + WICGifImageDescriptorLocalColorTableSize = 8, +} + +/// +/// WICGifGraphicControlExtensionProperties +public enum WICGifGraphicControlExtensionProperties : uint +{ + /// + /// WICGifGraphicControlExtensionDisposal + WICGifGraphicControlExtensionDisposal = 1, + /// + /// WICGifGraphicControlExtensionUserInputFlag + WICGifGraphicControlExtensionUserInputFlag = 2, + /// + /// WICGifGraphicControlExtensionTransparencyFlag + WICGifGraphicControlExtensionTransparencyFlag = 3, + /// + /// WICGifGraphicControlExtensionDelay + WICGifGraphicControlExtensionDelay = 4, + /// + /// WICGifGraphicControlExtensionTransparentColorIndex + WICGifGraphicControlExtensionTransparentColorIndex = 5, +} + +/// +/// WICGifApplicationExtensionProperties +public enum WICGifApplicationExtensionProperties : uint +{ + /// + /// WICGifApplicationExtensionApplication + WICGifApplicationExtensionApplication = 1, + /// + /// WICGifApplicationExtensionData + WICGifApplicationExtensionData = 2, +} + +/// +/// WICGifCommentExtensionProperties +public enum WICGifCommentExtensionProperties : uint +{ + /// + /// WICGifCommentExtensionText + WICGifCommentExtensionText = 1, +} + +/// +/// WICJpegCommentProperties +public enum WICJpegCommentProperties : uint +{ + /// + /// WICJpegCommentText + WICJpegCommentText = 1, +} + +/// +/// WICJpegLuminanceProperties +public enum WICJpegLuminanceProperties : uint +{ + /// + /// WICJpegLuminanceTable + WICJpegLuminanceTable = 1, +} + +/// +/// WICJpegChrominanceProperties +public enum WICJpegChrominanceProperties : uint +{ + /// + /// WICJpegChrominanceTable + WICJpegChrominanceTable = 1, +} + +/// +/// WIC8BIMIptcProperties +public enum WIC8BIMIptcProperties : uint +{ + /// + /// WIC8BIMIptcPString + WIC8BIMIptcPString = 0, + /// + /// WIC8BIMIptcEmbeddedIPTC + WIC8BIMIptcEmbeddedIPTC = 1, +} + +/// +/// WIC8BIMResolutionInfoProperties +public enum WIC8BIMResolutionInfoProperties : uint +{ + /// + /// WIC8BIMResolutionInfoPString + WIC8BIMResolutionInfoPString = 1, + /// + /// WIC8BIMResolutionInfoHResolution + WIC8BIMResolutionInfoHResolution = 2, + /// + /// WIC8BIMResolutionInfoHResolutionUnit + WIC8BIMResolutionInfoHResolutionUnit = 3, + /// + /// WIC8BIMResolutionInfoWidthUnit + WIC8BIMResolutionInfoWidthUnit = 4, + /// + /// WIC8BIMResolutionInfoVResolution + WIC8BIMResolutionInfoVResolution = 5, + /// + /// WIC8BIMResolutionInfoVResolutionUnit + WIC8BIMResolutionInfoVResolutionUnit = 6, + /// + /// WIC8BIMResolutionInfoHeightUnit + WIC8BIMResolutionInfoHeightUnit = 7, +} + +/// +/// WIC8BIMIptcDigestProperties +public enum WIC8BIMIptcDigestProperties : uint +{ + /// + /// WIC8BIMIptcDigestPString + WIC8BIMIptcDigestPString = 1, + /// + /// WIC8BIMIptcDigestIptcDigest + WIC8BIMIptcDigestIptcDigest = 2, +} + +/// +/// WICPngGamaProperties +public enum WICPngGamaProperties : uint +{ + /// + /// WICPngGamaGamma + WICPngGamaGamma = 1, +} + +/// +/// WICPngBkgdProperties +public enum WICPngBkgdProperties : uint +{ + /// + /// WICPngBkgdBackgroundColor + WICPngBkgdBackgroundColor = 1, +} + +/// +/// WICPngItxtProperties +public enum WICPngItxtProperties : uint +{ + /// + /// WICPngItxtKeyword + WICPngItxtKeyword = 1, + /// + /// WICPngItxtCompressionFlag + WICPngItxtCompressionFlag = 2, + /// + /// WICPngItxtLanguageTag + WICPngItxtLanguageTag = 3, + /// + /// WICPngItxtTranslatedKeyword + WICPngItxtTranslatedKeyword = 4, + /// + /// WICPngItxtText + WICPngItxtText = 5, +} + +/// +/// WICPngChrmProperties +public enum WICPngChrmProperties : uint +{ + /// + /// WICPngChrmWhitePointX + WICPngChrmWhitePointX = 1, + /// + /// WICPngChrmWhitePointY + WICPngChrmWhitePointY = 2, + /// + /// WICPngChrmRedX + WICPngChrmRedX = 3, + /// + /// WICPngChrmRedY + WICPngChrmRedY = 4, + /// + /// WICPngChrmGreenX + WICPngChrmGreenX = 5, + /// + /// WICPngChrmGreenY + WICPngChrmGreenY = 6, + /// + /// WICPngChrmBlueX + WICPngChrmBlueX = 7, + /// + /// WICPngChrmBlueY + WICPngChrmBlueY = 8, +} + +/// +/// WICPngHistProperties +public enum WICPngHistProperties : uint +{ + /// + /// WICPngHistFrequencies + WICPngHistFrequencies = 1, +} + +/// +/// WICPngIccpProperties +public enum WICPngIccpProperties : uint +{ + /// + /// WICPngIccpProfileName + WICPngIccpProfileName = 1, + /// + /// WICPngIccpProfileData + WICPngIccpProfileData = 2, +} + +/// +/// WICPngSrgbProperties +public enum WICPngSrgbProperties : uint +{ + /// + /// WICPngSrgbRenderingIntent + WICPngSrgbRenderingIntent = 1, +} + +/// +/// WICPngTimeProperties +public enum WICPngTimeProperties : uint +{ + /// + /// WICPngTimeYear + WICPngTimeYear = 1, + /// + /// WICPngTimeMonth + WICPngTimeMonth = 2, + /// + /// WICPngTimeDay + WICPngTimeDay = 3, + /// + /// WICPngTimeHour + WICPngTimeHour = 4, + /// + /// WICPngTimeMinute + WICPngTimeMinute = 5, + /// + /// WICPngTimeSecond + WICPngTimeSecond = 6, +} + +/// +/// WICHeifProperties +public enum WICHeifProperties : uint +{ + /// + /// WICHeifOrientation + WICHeifOrientation = 1, +} + +/// +/// WICHeifHdrProperties +public enum WICHeifHdrProperties : uint +{ + /// + /// WICHeifHdrMaximumLuminanceLevel + WICHeifHdrMaximumLuminanceLevel = 1, + /// + /// WICHeifHdrMaximumFrameAverageLuminanceLevel + WICHeifHdrMaximumFrameAverageLuminanceLevel = 2, + /// + /// WICHeifHdrMinimumMasteringDisplayLuminanceLevel + WICHeifHdrMinimumMasteringDisplayLuminanceLevel = 3, + /// + /// WICHeifHdrMaximumMasteringDisplayLuminanceLevel + WICHeifHdrMaximumMasteringDisplayLuminanceLevel = 4, + /// + /// WICHeifHdrCustomVideoPrimaries + WICHeifHdrCustomVideoPrimaries = 5, +} + +/// +/// WICWebpAnimProperties +public enum WICWebpAnimProperties : uint +{ + /// + /// WICWebpAnimLoopCount + WICWebpAnimLoopCount = 1, +} + +/// +/// WICWebpAnmfProperties +public enum WICWebpAnmfProperties : uint +{ + /// + /// WICWebpAnmfFrameDuration + WICWebpAnmfFrameDuration = 1, +} + +/// +/// WICSectionAccessLevel +public enum WICSectionAccessLevel : uint +{ + /// + /// WICSectionAccessLevelRead + WICSectionAccessLevelRead = 1, + /// + /// WICSectionAccessLevelReadWrite + WICSectionAccessLevelReadWrite = 3, +} + +/// +/// WICPixelFormatNumericRepresentation +public enum WICPixelFormatNumericRepresentation : uint +{ + /// + /// WICPixelFormatNumericRepresentationUnspecified + WICPixelFormatNumericRepresentationUnspecified = 0, + /// + /// WICPixelFormatNumericRepresentationIndexed + WICPixelFormatNumericRepresentationIndexed = 1, + /// + /// WICPixelFormatNumericRepresentationUnsignedInteger + WICPixelFormatNumericRepresentationUnsignedInteger = 2, + /// + /// WICPixelFormatNumericRepresentationSignedInteger + WICPixelFormatNumericRepresentationSignedInteger = 3, + /// + /// WICPixelFormatNumericRepresentationFixed + WICPixelFormatNumericRepresentationFixed = 4, + /// + /// WICPixelFormatNumericRepresentationFloat + WICPixelFormatNumericRepresentationFloat = 5, +} + +/// +/// WICPlanarOptions +public enum WICPlanarOptions : int +{ + /// + /// WICPlanarOptionsDefault + WICPlanarOptionsDefault = 0, + /// + /// WICPlanarOptionsPreserveSubsampling + WICPlanarOptionsPreserveSubsampling = 1, +} + +/// +/// WICJpegIndexingOptions +public enum WICJpegIndexingOptions : uint +{ + /// + /// WICJpegIndexingOptionsGenerateOnDemand + WICJpegIndexingOptionsGenerateOnDemand = 0, + /// + /// WICJpegIndexingOptionsGenerateOnLoad + WICJpegIndexingOptionsGenerateOnLoad = 1, +} + +/// +/// WICJpegTransferMatrix +public enum WICJpegTransferMatrix : uint +{ + /// + /// WICJpegTransferMatrixIdentity + WICJpegTransferMatrixIdentity = 0, + /// + /// WICJpegTransferMatrixBT601 + WICJpegTransferMatrixBT601 = 1, +} + +/// +/// WICJpegScanType +public enum WICJpegScanType : uint +{ + /// + /// WICJpegScanTypeInterleaved + WICJpegScanTypeInterleaved = 0, + /// + /// WICJpegScanTypePlanarComponents + WICJpegScanTypePlanarComponents = 1, + /// + /// WICJpegScanTypeProgressive + WICJpegScanTypeProgressive = 2, +} + +/// +/// WICTiffCompressionOption +public enum WICTiffCompressionOption : int +{ + /// + /// WICTiffCompressionDontCare + WICTiffCompressionDontCare = 0, + /// + /// WICTiffCompressionNone + WICTiffCompressionNone = 1, + /// + /// WICTiffCompressionCCITT3 + WICTiffCompressionCCITT3 = 2, + /// + /// WICTiffCompressionCCITT4 + WICTiffCompressionCCITT4 = 3, + /// + /// WICTiffCompressionLZW + WICTiffCompressionLZW = 4, + /// + /// WICTiffCompressionRLE + WICTiffCompressionRLE = 5, + /// + /// WICTiffCompressionZIP + WICTiffCompressionZIP = 6, + /// + /// WICTiffCompressionLZWHDifferencing + WICTiffCompressionLZWHDifferencing = 7, +} + +/// +/// WICJpegYCrCbSubsamplingOption +public enum WICJpegYCrCbSubsamplingOption : int +{ + /// + /// WICJpegYCrCbSubsamplingDefault + WICJpegYCrCbSubsamplingDefault = 0, + /// + /// WICJpegYCrCbSubsampling420 + WICJpegYCrCbSubsampling420 = 1, + /// + /// WICJpegYCrCbSubsampling422 + WICJpegYCrCbSubsampling422 = 2, + /// + /// WICJpegYCrCbSubsampling444 + WICJpegYCrCbSubsampling444 = 3, + /// + /// WICJpegYCrCbSubsampling440 + WICJpegYCrCbSubsampling440 = 4, +} + +/// +/// WICPngFilterOption +public enum WICPngFilterOption : int +{ + /// + /// WICPngFilterUnspecified + WICPngFilterUnspecified = 0, + /// + /// WICPngFilterNone + WICPngFilterNone = 1, + /// + /// WICPngFilterSub + WICPngFilterSub = 2, + /// + /// WICPngFilterUp + WICPngFilterUp = 3, + /// + /// WICPngFilterAverage + WICPngFilterAverage = 4, + /// + /// WICPngFilterPaeth + WICPngFilterPaeth = 5, + /// + /// WICPngFilterAdaptive + WICPngFilterAdaptive = 6, +} + +/// +/// WICNamedWhitePoint +public enum WICNamedWhitePoint : int +{ + /// + /// WICWhitePointDefault + WICWhitePointDefault = 1, + /// + /// WICWhitePointDaylight + WICWhitePointDaylight = 2, + /// + /// WICWhitePointCloudy + WICWhitePointCloudy = 4, + /// + /// WICWhitePointShade + WICWhitePointShade = 8, + /// + /// WICWhitePointTungsten + WICWhitePointTungsten = 16, + /// + /// WICWhitePointFluorescent + WICWhitePointFluorescent = 32, + /// + /// WICWhitePointFlash + WICWhitePointFlash = 64, + /// + /// WICWhitePointUnderwater + WICWhitePointUnderwater = 128, + /// + /// WICWhitePointCustom + WICWhitePointCustom = 256, + /// + /// WICWhitePointAutoWhiteBalance + WICWhitePointAutoWhiteBalance = 512, + /// + /// WICWhitePointAsShot + WICWhitePointAsShot = 1, +} + +/// +/// WICRawCapabilities +public enum WICRawCapabilities : int +{ + /// + /// WICRawCapabilityNotSupported + WICRawCapabilityNotSupported = 0, + /// + /// WICRawCapabilityGetSupported + WICRawCapabilityGetSupported = 1, + /// + /// WICRawCapabilityFullySupported + WICRawCapabilityFullySupported = 2, +} + +/// +/// WICRawRotationCapabilities +public enum WICRawRotationCapabilities : int +{ + /// + /// WICRawRotationCapabilityNotSupported + WICRawRotationCapabilityNotSupported = 0, + /// + /// WICRawRotationCapabilityGetSupported + WICRawRotationCapabilityGetSupported = 1, + /// + /// WICRawRotationCapabilityNinetyDegreesSupported + WICRawRotationCapabilityNinetyDegreesSupported = 2, + /// + /// WICRawRotationCapabilityFullySupported + WICRawRotationCapabilityFullySupported = 3, +} + +/// +/// WICRawParameterSet +public enum WICRawParameterSet : int +{ + /// + /// WICAsShotParameterSet + WICAsShotParameterSet = 1, + /// + /// WICUserAdjustedParameterSet + WICUserAdjustedParameterSet = 2, + /// + /// WICAutoAdjustedParameterSet + WICAutoAdjustedParameterSet = 3, +} + +/// +/// WICRawRenderMode +public enum WICRawRenderMode : int +{ + /// + /// WICRawRenderModeDraft + WICRawRenderModeDraft = 1, + /// + /// WICRawRenderModeNormal + WICRawRenderModeNormal = 2, + /// + /// WICRawRenderModeBestQuality + WICRawRenderModeBestQuality = 3, +} + +/// +/// WICDdsDimension +public enum WICDdsDimension : int +{ + /// + /// WICDdsTexture1D + WICDdsTexture1D = 0, + /// + /// WICDdsTexture2D + WICDdsTexture2D = 1, + /// + /// WICDdsTexture3D + WICDdsTexture3D = 2, + /// + /// WICDdsTextureCube + WICDdsTextureCube = 3, +} + +/// +/// WICDdsAlphaMode +public enum WICDdsAlphaMode : int +{ + /// + /// WICDdsAlphaModeUnknown + WICDdsAlphaModeUnknown = 0, + /// + /// WICDdsAlphaModeStraight + WICDdsAlphaModeStraight = 1, + /// + /// WICDdsAlphaModePremultiplied + WICDdsAlphaModePremultiplied = 2, + /// + /// WICDdsAlphaModeOpaque + WICDdsAlphaModeOpaque = 3, + /// + /// WICDdsAlphaModeCustom + WICDdsAlphaModeCustom = 4, +} + +/// +/// WICMetadataCreationOptions +public enum WICMetadataCreationOptions : int +{ + /// + /// WICMetadataCreationDefault + WICMetadataCreationDefault = 0, + /// + /// WICMetadataCreationAllowUnknown + WICMetadataCreationAllowUnknown = 0, + /// + /// WICMetadataCreationFailUnknown + WICMetadataCreationFailUnknown = 65536, + /// + /// WICMetadataCreationMask + WICMetadataCreationMask = -65536, +} + +/// +/// WICPersistOptions +public enum WICPersistOptions : int +{ + /// + /// WICPersistOptionDefault + WICPersistOptionDefault = 0, + /// + /// WICPersistOptionLittleEndian + WICPersistOptionLittleEndian = 0, + /// + /// WICPersistOptionBigEndian + WICPersistOptionBigEndian = 1, + /// + /// WICPersistOptionStrictFormat + WICPersistOptionStrictFormat = 2, + /// + /// WICPersistOptionNoCacheStream + WICPersistOptionNoCacheStream = 4, + /// + /// WICPersistOptionPreferUTF8 + WICPersistOptionPreferUTF8 = 8, + /// + /// WICPersistOptionMask + WICPersistOptionMask = 65535, +} + +#endregion Enums + +#region Structs +/// +/// WICRect +public partial struct Wicrect +{ + /// + public int X; + + /// + public int Y; + + /// + public int Width; + + /// + public int Height; +} + +/// +/// WICBitmapPattern +public partial struct Wicbitmappattern +{ + /// + public ULargeInterger Position; + + /// + public uint Length; + + /// + public unsafe byte* Pattern; + + /// + public unsafe byte* Mask; + + /// + public Bool32 EndOfStream; +} + +/// +/// WICImageParameters +public partial struct Wicimageparameters +{ + /// + public Graphics.Direct2D.Common.PixelFormat PixelFormat; + + /// + public float DpiX; + + /// + public float DpiY; + + /// + public float Top; + + /// + public float Left; + + /// + public uint PixelWidth; + + /// + public uint PixelHeight; +} + +/// +/// WICBitmapPlaneDescription +public partial struct Wicbitmapplanedescription +{ + /// + public Guid Format; + + /// + public uint Width; + + /// + public uint Height; +} + +/// +/// WICBitmapPlane +public partial struct Wicbitmapplane +{ + /// + public Guid Format; + + /// + public unsafe byte* pbBuffer; + + /// + public uint cbStride; + + /// + public uint cbBufferSize; +} + +/// +/// WICJpegFrameHeader +public partial struct Wicjpegframeheader +{ + /// + public uint Width; + + /// + public uint Height; + + /// + public WICJpegTransferMatrix TransferMatrix; + + /// + public WICJpegScanType ScanType; + + /// + public uint cComponents; + + /// + public uint ComponentIdentifiers; + + /// + public uint SampleFactors; + + /// + public uint QuantizationTableIndices; +} + +/// +/// WICJpegScanHeader +public partial struct Wicjpegscanheader +{ + /// + public uint cComponents; + + /// + public uint RestartInterval; + + /// + public uint ComponentSelectors; + + /// + public uint HuffmanTableIndices; + + /// + public byte StartSpectralSelection; + + /// + public byte EndSpectralSelection; + + /// + public byte SuccessiveApproximationHigh; + + /// + public byte SuccessiveApproximationLow; +} + +/// +/// WICRawCapabilitiesInfo +public partial struct Wicrawcapabilitiesinfo +{ + /// + public uint cbSize; + + /// + public uint CodecMajorVersion; + + /// + public uint CodecMinorVersion; + + /// + public WICRawCapabilities ExposureCompensationSupport; + + /// + public WICRawCapabilities ContrastSupport; + + /// + public WICRawCapabilities RGBWhitePointSupport; + + /// + public WICRawCapabilities NamedWhitePointSupport; + + /// + public uint NamedWhitePointSupportMask; + + /// + public WICRawCapabilities KelvinWhitePointSupport; + + /// + public WICRawCapabilities GammaSupport; + + /// + public WICRawCapabilities TintSupport; + + /// + public WICRawCapabilities SaturationSupport; + + /// + public WICRawCapabilities SharpnessSupport; + + /// + public WICRawCapabilities NoiseReductionSupport; + + /// + public WICRawCapabilities DestinationColorProfileSupport; + + /// + public WICRawCapabilities ToneCurveSupport; + + /// + public WICRawRotationCapabilities RotationSupport; + + /// + public WICRawCapabilities RenderModeSupport; +} + +/// +/// WICRawToneCurvePoint +public partial struct Wicrawtonecurvepoint +{ + /// + public double Input; + + /// + public double Output; +} + +/// +/// WICRawToneCurve +public partial struct Wicrawtonecurve +{ + /// + public uint cPoints; + + /// + public aPoints__FixedBuffer aPoints; + + public unsafe struct aPoints__FixedBuffer + { + public Wicrawtonecurvepoint e0; + + [UnscopedRef] + public ref Wicrawtonecurvepoint this[int index] + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + return ref AsSpan()[index]; + } + } + + [UnscopedRef] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public Span AsSpan() + { + return MemoryMarshal.CreateSpan(ref e0, 1); + } + } +} + +/// +/// WICDdsParameters +public partial struct Wicddsparameters +{ + /// + public uint Width; + + /// + public uint Height; + + /// + public uint Depth; + + /// + public uint MipLevels; + + /// + public uint ArraySize; + + /// + public Graphics.Dxgi.Common.Format DxgiFormat; + + /// + public WICDdsDimension Dimension; + + /// + public WICDdsAlphaMode AlphaMode; +} + +/// +/// WICDdsFormatInfo +public partial struct Wicddsformatinfo +{ + /// + public Graphics.Dxgi.Common.Format DxgiFormat; + + /// + public uint BytesPerBlock; + + /// + public uint BlockWidth; + + /// + public uint BlockHeight; +} + +/// +/// WICMetadataPattern +public partial struct Wicmetadatapattern +{ + /// + public ULargeInterger Position; + + /// + public uint Length; + + /// + public unsafe byte* Pattern; + + /// + public unsafe byte* Mask; + + /// + public ULargeInterger DataOffset; +} + +/// +/// WICMetadataHeader +public partial struct Wicmetadataheader +{ + /// + public ULargeInterger Position; + + /// + public uint Length; + + /// + public unsafe byte* Header; + + /// + public ULargeInterger DataOffset; +} + +#endregion Structs + +#region COM Types +/// +/// IWICPalette +[Guid("00000040-a8f2-4877-ba0a-fd2b6645fb94")] +[NativeTypeName("struct IWICPalette : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IWICPalette +{ + public static ref readonly Guid IID_IWICPalette + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x40, 0x00, 0x00, 0x00, + 0xF2, 0xA8, + 0x77, 0x48, + 0xBA, + 0x0A, + 0xFD, + 0x2B, + 0x66, + 0x45, + 0xFB, + 0x94 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICPalette)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult InitializePredefined(WICBitmapPaletteType ePaletteType, Bool32 fAddTransparentColor) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICPalette*)Unsafe.AsPointer(ref this), ePaletteType, fAddTransparentColor); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult InitializeCustom(uint* pColors, uint cCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICPalette*)Unsafe.AsPointer(ref this), pColors, cCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult InitializeFromBitmap(IWICBitmapSource* pISurface, uint cCount, Bool32 fAddTransparentColor) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICPalette*)Unsafe.AsPointer(ref this), pISurface, cCount, fAddTransparentColor); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult InitializeFromPalette(IWICPalette* pIPalette) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICPalette*)Unsafe.AsPointer(ref this), pIPalette); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetType(WICBitmapPaletteType* pePaletteType) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICPalette*)Unsafe.AsPointer(ref this), pePaletteType); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetColorCount(uint* pcCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICPalette*)Unsafe.AsPointer(ref this), pcCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetColors(uint cCount, uint* pColors, uint* pcActualColors) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IWICPalette*)Unsafe.AsPointer(ref this), cCount, pColors, pcActualColors); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult IsBlackWhite(Bool32* pfIsBlackWhite) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IWICPalette*)Unsafe.AsPointer(ref this), pfIsBlackWhite); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult IsGrayscale(Bool32* pfIsGrayscale) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IWICPalette*)Unsafe.AsPointer(ref this), pfIsGrayscale); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult HasAlpha(Bool32* pfHasAlpha) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IWICPalette*)Unsafe.AsPointer(ref this), pfHasAlpha); + } +} + +/// +/// IWICBitmapSource +[Guid("00000120-a8f2-4877-ba0a-fd2b6645fb94")] +[NativeTypeName("struct IWICBitmapSource : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IWICBitmapSource +{ + public static ref readonly Guid IID_IWICBitmapSource + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x20, 0x01, 0x00, 0x00, + 0xF2, 0xA8, + 0x77, 0x48, + 0xBA, + 0x0A, + 0xFD, + 0x2B, + 0x66, + 0x45, + 0xFB, + 0x94 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICBitmapSource)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetSize(uint* puiWidth, uint* puiHeight) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICBitmapSource*)Unsafe.AsPointer(ref this), puiWidth, puiHeight); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPixelFormat(Guid* pPixelFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICBitmapSource*)Unsafe.AsPointer(ref this), pPixelFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetResolution(double* pDpiX, double* pDpiY) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICBitmapSource*)Unsafe.AsPointer(ref this), pDpiX, pDpiY); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CopyPalette(IWICPalette* pIPalette) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICBitmapSource*)Unsafe.AsPointer(ref this), pIPalette); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CopyPixels(Wicrect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICBitmapSource*)Unsafe.AsPointer(ref this), prc, cbStride, cbBufferSize, pbBuffer); + } +} + +/// +/// IWICFormatConverter +[Guid("00000301-a8f2-4877-ba0a-fd2b6645fb94")] +[NativeTypeName("struct IWICFormatConverter : IWICBitmapSource")] +[NativeInheritance("IWICBitmapSource")] +public unsafe partial struct IWICFormatConverter +{ + public static ref readonly Guid IID_IWICFormatConverter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x01, 0x03, 0x00, 0x00, + 0xF2, 0xA8, + 0x77, 0x48, + 0xBA, + 0x0A, + 0xFD, + 0x2B, + 0x66, + 0x45, + 0xFB, + 0x94 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICFormatConverter)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetSize(uint* puiWidth, uint* puiHeight) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICFormatConverter*)Unsafe.AsPointer(ref this), puiWidth, puiHeight); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPixelFormat(Guid* pPixelFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICFormatConverter*)Unsafe.AsPointer(ref this), pPixelFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetResolution(double* pDpiX, double* pDpiY) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICFormatConverter*)Unsafe.AsPointer(ref this), pDpiX, pDpiY); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CopyPalette(IWICPalette* pIPalette) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICFormatConverter*)Unsafe.AsPointer(ref this), pIPalette); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CopyPixels(Wicrect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICFormatConverter*)Unsafe.AsPointer(ref this), prc, cbStride, cbBufferSize, pbBuffer); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult Initialize(IWICBitmapSource* pISource, Guid* dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICFormatConverter*)Unsafe.AsPointer(ref this), pISource, dstFormat, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult CanConvert(Guid* srcPixelFormat, Guid* dstPixelFormat, Bool32* pfCanConvert) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IWICFormatConverter*)Unsafe.AsPointer(ref this), srcPixelFormat, dstPixelFormat, pfCanConvert); + } +} + +/// +/// IWICPlanarFormatConverter +[Guid("bebee9cb-83b0-4dcc-8132-b0aaa55eac96")] +[NativeTypeName("struct IWICPlanarFormatConverter : IWICBitmapSource")] +[NativeInheritance("IWICBitmapSource")] +public unsafe partial struct IWICPlanarFormatConverter +{ + public static ref readonly Guid IID_IWICPlanarFormatConverter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xCB, 0xE9, 0xBE, 0xBE, + 0xB0, 0x83, + 0xCC, 0x4D, + 0x81, + 0x32, + 0xB0, + 0xAA, + 0xA5, + 0x5E, + 0xAC, + 0x96 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICPlanarFormatConverter)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetSize(uint* puiWidth, uint* puiHeight) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICPlanarFormatConverter*)Unsafe.AsPointer(ref this), puiWidth, puiHeight); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPixelFormat(Guid* pPixelFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICPlanarFormatConverter*)Unsafe.AsPointer(ref this), pPixelFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetResolution(double* pDpiX, double* pDpiY) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICPlanarFormatConverter*)Unsafe.AsPointer(ref this), pDpiX, pDpiY); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CopyPalette(IWICPalette* pIPalette) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICPlanarFormatConverter*)Unsafe.AsPointer(ref this), pIPalette); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CopyPixels(Wicrect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICPlanarFormatConverter*)Unsafe.AsPointer(ref this), prc, cbStride, cbBufferSize, pbBuffer); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult Initialize(IWICBitmapSource** ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICPlanarFormatConverter*)Unsafe.AsPointer(ref this), ppPlanes, cPlanes, dstFormat, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult CanConvert(Guid* pSrcPixelFormats, uint cSrcPlanes, Guid* dstPixelFormat, Bool32* pfCanConvert) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IWICPlanarFormatConverter*)Unsafe.AsPointer(ref this), pSrcPixelFormats, cSrcPlanes, dstPixelFormat, pfCanConvert); + } +} + +/// +/// IWICBitmapScaler +[Guid("00000302-a8f2-4877-ba0a-fd2b6645fb94")] +[NativeTypeName("struct IWICBitmapScaler : IWICBitmapSource")] +[NativeInheritance("IWICBitmapSource")] +public unsafe partial struct IWICBitmapScaler +{ + public static ref readonly Guid IID_IWICBitmapScaler + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x02, 0x03, 0x00, 0x00, + 0xF2, 0xA8, + 0x77, 0x48, + 0xBA, + 0x0A, + 0xFD, + 0x2B, + 0x66, + 0x45, + 0xFB, + 0x94 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICBitmapScaler)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetSize(uint* puiWidth, uint* puiHeight) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICBitmapScaler*)Unsafe.AsPointer(ref this), puiWidth, puiHeight); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPixelFormat(Guid* pPixelFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICBitmapScaler*)Unsafe.AsPointer(ref this), pPixelFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetResolution(double* pDpiX, double* pDpiY) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICBitmapScaler*)Unsafe.AsPointer(ref this), pDpiX, pDpiY); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CopyPalette(IWICPalette* pIPalette) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICBitmapScaler*)Unsafe.AsPointer(ref this), pIPalette); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CopyPixels(Wicrect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICBitmapScaler*)Unsafe.AsPointer(ref this), prc, cbStride, cbBufferSize, pbBuffer); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult Initialize(IWICBitmapSource* pISource, uint uiWidth, uint uiHeight, WICBitmapInterpolationMode mode) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICBitmapScaler*)Unsafe.AsPointer(ref this), pISource, uiWidth, uiHeight, mode); + } +} + +/// +/// IWICBitmapClipper +[Guid("e4fbcf03-223d-4e81-9333-d635556dd1b5")] +[NativeTypeName("struct IWICBitmapClipper : IWICBitmapSource")] +[NativeInheritance("IWICBitmapSource")] +public unsafe partial struct IWICBitmapClipper +{ + public static ref readonly Guid IID_IWICBitmapClipper + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x03, 0xCF, 0xFB, 0xE4, + 0x3D, 0x22, + 0x81, 0x4E, + 0x93, + 0x33, + 0xD6, + 0x35, + 0x55, + 0x6D, + 0xD1, + 0xB5 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICBitmapClipper)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetSize(uint* puiWidth, uint* puiHeight) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICBitmapClipper*)Unsafe.AsPointer(ref this), puiWidth, puiHeight); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPixelFormat(Guid* pPixelFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICBitmapClipper*)Unsafe.AsPointer(ref this), pPixelFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetResolution(double* pDpiX, double* pDpiY) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICBitmapClipper*)Unsafe.AsPointer(ref this), pDpiX, pDpiY); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CopyPalette(IWICPalette* pIPalette) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICBitmapClipper*)Unsafe.AsPointer(ref this), pIPalette); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CopyPixels(Wicrect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICBitmapClipper*)Unsafe.AsPointer(ref this), prc, cbStride, cbBufferSize, pbBuffer); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult Initialize(IWICBitmapSource* pISource, Wicrect* prc) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICBitmapClipper*)Unsafe.AsPointer(ref this), pISource, prc); + } +} + +/// +/// IWICBitmapFlipRotator +[Guid("5009834f-2d6a-41ce-9e1b-17c5aff7a782")] +[NativeTypeName("struct IWICBitmapFlipRotator : IWICBitmapSource")] +[NativeInheritance("IWICBitmapSource")] +public unsafe partial struct IWICBitmapFlipRotator +{ + public static ref readonly Guid IID_IWICBitmapFlipRotator + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x4F, 0x83, 0x09, 0x50, + 0x6A, 0x2D, + 0xCE, 0x41, + 0x9E, + 0x1B, + 0x17, + 0xC5, + 0xAF, + 0xF7, + 0xA7, + 0x82 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICBitmapFlipRotator)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetSize(uint* puiWidth, uint* puiHeight) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICBitmapFlipRotator*)Unsafe.AsPointer(ref this), puiWidth, puiHeight); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPixelFormat(Guid* pPixelFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICBitmapFlipRotator*)Unsafe.AsPointer(ref this), pPixelFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetResolution(double* pDpiX, double* pDpiY) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICBitmapFlipRotator*)Unsafe.AsPointer(ref this), pDpiX, pDpiY); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CopyPalette(IWICPalette* pIPalette) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICBitmapFlipRotator*)Unsafe.AsPointer(ref this), pIPalette); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CopyPixels(Wicrect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICBitmapFlipRotator*)Unsafe.AsPointer(ref this), prc, cbStride, cbBufferSize, pbBuffer); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult Initialize(IWICBitmapSource* pISource, WICBitmapTransformOptions options) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICBitmapFlipRotator*)Unsafe.AsPointer(ref this), pISource, options); + } +} + +/// +/// IWICBitmapLock +[Guid("00000123-a8f2-4877-ba0a-fd2b6645fb94")] +[NativeTypeName("struct IWICBitmapLock : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IWICBitmapLock +{ + public static ref readonly Guid IID_IWICBitmapLock + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x23, 0x01, 0x00, 0x00, + 0xF2, 0xA8, + 0x77, 0x48, + 0xBA, + 0x0A, + 0xFD, + 0x2B, + 0x66, + 0x45, + 0xFB, + 0x94 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICBitmapLock)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetSize(uint* puiWidth, uint* puiHeight) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICBitmapLock*)Unsafe.AsPointer(ref this), puiWidth, puiHeight); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetStride(uint* pcbStride) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICBitmapLock*)Unsafe.AsPointer(ref this), pcbStride); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetDataPointer(uint* pcbBufferSize, byte** ppbData) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICBitmapLock*)Unsafe.AsPointer(ref this), pcbBufferSize, ppbData); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetPixelFormat(Guid* pPixelFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICBitmapLock*)Unsafe.AsPointer(ref this), pPixelFormat); + } +} + +/// +/// IWICBitmap +[Guid("00000121-a8f2-4877-ba0a-fd2b6645fb94")] +[NativeTypeName("struct IWICBitmap : IWICBitmapSource")] +[NativeInheritance("IWICBitmapSource")] +public unsafe partial struct IWICBitmap +{ + public static ref readonly Guid IID_IWICBitmap + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x21, 0x01, 0x00, 0x00, + 0xF2, 0xA8, + 0x77, 0x48, + 0xBA, + 0x0A, + 0xFD, + 0x2B, + 0x66, + 0x45, + 0xFB, + 0x94 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICBitmap)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetSize(uint* puiWidth, uint* puiHeight) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICBitmap*)Unsafe.AsPointer(ref this), puiWidth, puiHeight); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPixelFormat(Guid* pPixelFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICBitmap*)Unsafe.AsPointer(ref this), pPixelFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetResolution(double* pDpiX, double* pDpiY) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICBitmap*)Unsafe.AsPointer(ref this), pDpiX, pDpiY); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CopyPalette(IWICPalette* pIPalette) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICBitmap*)Unsafe.AsPointer(ref this), pIPalette); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CopyPixels(Wicrect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICBitmap*)Unsafe.AsPointer(ref this), prc, cbStride, cbBufferSize, pbBuffer); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult Lock(Wicrect* prcLock, uint flags, IWICBitmapLock* ppILock) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICBitmap*)Unsafe.AsPointer(ref this), prcLock, flags, ppILock); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult SetPalette(IWICPalette* pIPalette) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IWICBitmap*)Unsafe.AsPointer(ref this), pIPalette); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult SetResolution(double dpiX, double dpiY) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IWICBitmap*)Unsafe.AsPointer(ref this), dpiX, dpiY); + } +} + +/// +/// IWICColorContext +[Guid("3c613a02-34b2-44ea-9a7c-45aea9c6fd6d")] +[NativeTypeName("struct IWICColorContext : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IWICColorContext +{ + public static ref readonly Guid IID_IWICColorContext + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x02, 0x3A, 0x61, 0x3C, + 0xB2, 0x34, + 0xEA, 0x44, + 0x9A, + 0x7C, + 0x45, + 0xAE, + 0xA9, + 0xC6, + 0xFD, + 0x6D + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICColorContext)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult InitializeFromFilename(ushort* wzFilename) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICColorContext*)Unsafe.AsPointer(ref this), wzFilename); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult InitializeFromMemory(byte* pbBuffer, uint cbBufferSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICColorContext*)Unsafe.AsPointer(ref this), pbBuffer, cbBufferSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult InitializeFromExifColorSpace(uint value) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICColorContext*)Unsafe.AsPointer(ref this), value); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetType(WICColorContextType* pType) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICColorContext*)Unsafe.AsPointer(ref this), pType); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetProfileBytes(uint cbBuffer, byte* pbBuffer, uint* pcbActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICColorContext*)Unsafe.AsPointer(ref this), cbBuffer, pbBuffer, pcbActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetExifColorSpace(uint* pValue) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICColorContext*)Unsafe.AsPointer(ref this), pValue); + } +} + +/// +/// IWICColorTransform +[Guid("b66f034f-d0e2-40ab-b436-6de39e321a94")] +[NativeTypeName("struct IWICColorTransform : IWICBitmapSource")] +[NativeInheritance("IWICBitmapSource")] +public unsafe partial struct IWICColorTransform +{ + public static ref readonly Guid IID_IWICColorTransform + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x4F, 0x03, 0x6F, 0xB6, + 0xE2, 0xD0, + 0xAB, 0x40, + 0xB4, + 0x36, + 0x6D, + 0xE3, + 0x9E, + 0x32, + 0x1A, + 0x94 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICColorTransform)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetSize(uint* puiWidth, uint* puiHeight) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICColorTransform*)Unsafe.AsPointer(ref this), puiWidth, puiHeight); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPixelFormat(Guid* pPixelFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICColorTransform*)Unsafe.AsPointer(ref this), pPixelFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetResolution(double* pDpiX, double* pDpiY) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICColorTransform*)Unsafe.AsPointer(ref this), pDpiX, pDpiY); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CopyPalette(IWICPalette* pIPalette) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICColorTransform*)Unsafe.AsPointer(ref this), pIPalette); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CopyPixels(Wicrect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICColorTransform*)Unsafe.AsPointer(ref this), prc, cbStride, cbBufferSize, pbBuffer); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult Initialize(IWICBitmapSource* pIBitmapSource, IWICColorContext* pIContextSource, IWICColorContext* pIContextDest, Guid* pixelFmtDest) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICColorTransform*)Unsafe.AsPointer(ref this), pIBitmapSource, pIContextSource, pIContextDest, pixelFmtDest); + } +} + +/// +/// IWICFastMetadataEncoder +[Guid("b84e2c09-78c9-4ac4-8bd3-524ae1663a2f")] +[NativeTypeName("struct IWICFastMetadataEncoder : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IWICFastMetadataEncoder +{ + public static ref readonly Guid IID_IWICFastMetadataEncoder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x09, 0x2C, 0x4E, 0xB8, + 0xC9, 0x78, + 0xC4, 0x4A, + 0x8B, + 0xD3, + 0x52, + 0x4A, + 0xE1, + 0x66, + 0x3A, + 0x2F + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICFastMetadataEncoder)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult Commit() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICFastMetadataEncoder*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetMetadataQueryWriter(IWICMetadataQueryWriter* ppIMetadataQueryWriter) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICFastMetadataEncoder*)Unsafe.AsPointer(ref this), ppIMetadataQueryWriter); + } +} + +/// +/// IWICStream +[Guid("135ff860-22b7-4ddf-b0f6-218f4f299a43")] +[NativeTypeName("struct IWICStream : IStream")] +[NativeInheritance("IStream")] +public unsafe partial struct IWICStream +{ + public static ref readonly Guid IID_IWICStream + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x60, 0xF8, 0x5F, 0x13, + 0xB7, 0x22, + 0xDF, 0x4D, + 0xB0, + 0xF6, + 0x21, + 0x8F, + 0x4F, + 0x29, + 0x9A, + 0x43 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICStream)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult InitializeFromIStream(Com.IStream* pIStream) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IWICStream*)Unsafe.AsPointer(ref this), pIStream); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + public HResult InitializeFromFilename(ushort* wzFileName, uint dwDesiredAccess) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IWICStream*)Unsafe.AsPointer(ref this), wzFileName, dwDesiredAccess); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + public HResult InitializeFromMemory(byte* pbBuffer, uint cbBufferSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IWICStream*)Unsafe.AsPointer(ref this), pbBuffer, cbBufferSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult InitializeFromIStreamRegion(Com.IStream* pIStream, ULargeInterger* ulOffset, ULargeInterger* ulMaxSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICStream*)Unsafe.AsPointer(ref this), pIStream, ulOffset, ulMaxSize); + } +} + +/// +/// IWICEnumMetadataItem +[Guid("dc2bb46d-3f07-481e-8625-220c4aedbb33")] +[NativeTypeName("struct IWICEnumMetadataItem : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IWICEnumMetadataItem +{ + public static ref readonly Guid IID_IWICEnumMetadataItem + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x6D, 0xB4, 0x2B, 0xDC, + 0x07, 0x3F, + 0x1E, 0x48, + 0x86, + 0x25, + 0x22, + 0x0C, + 0x4A, + 0xED, + 0xBB, + 0x33 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICEnumMetadataItem)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult Next(uint celt, Com.Variant** rgeltSchema, Com.Variant** rgeltId, Com.Variant** rgeltValue, uint* pceltFetched) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICEnumMetadataItem*)Unsafe.AsPointer(ref this), celt, rgeltSchema, rgeltId, rgeltValue, pceltFetched); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult Skip(uint celt) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICEnumMetadataItem*)Unsafe.AsPointer(ref this), celt); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult Reset() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICEnumMetadataItem*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult Clone(IWICEnumMetadataItem* ppIEnumMetadataItem) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICEnumMetadataItem*)Unsafe.AsPointer(ref this), ppIEnumMetadataItem); + } +} + +/// +/// IWICMetadataQueryReader +[Guid("30989668-e1c9-4597-b395-458eedb808df")] +[NativeTypeName("struct IWICMetadataQueryReader : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IWICMetadataQueryReader +{ + public static ref readonly Guid IID_IWICMetadataQueryReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x68, 0x96, 0x98, 0x30, + 0xC9, 0xE1, + 0x97, 0x45, + 0xB3, + 0x95, + 0x45, + 0x8E, + 0xED, + 0xB8, + 0x08, + 0xDF + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICMetadataQueryReader)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetContainerFormat(Guid* pguidContainerFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICMetadataQueryReader*)Unsafe.AsPointer(ref this), pguidContainerFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetLocation(uint cchMaxLength, ushort* wzNamespace, uint* pcchActualLength) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICMetadataQueryReader*)Unsafe.AsPointer(ref this), cchMaxLength, wzNamespace, pcchActualLength); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetMetadataByName(ushort* wzName, Com.Variant* pvarValue) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICMetadataQueryReader*)Unsafe.AsPointer(ref this), wzName, pvarValue); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetEnumerator(Com.IEnumString* ppIEnumString) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICMetadataQueryReader*)Unsafe.AsPointer(ref this), ppIEnumString); + } +} + +/// +/// IWICMetadataQueryWriter +[Guid("a721791a-0def-4d06-bd91-2118bf1db10b")] +[NativeTypeName("struct IWICMetadataQueryWriter : IWICMetadataQueryReader")] +[NativeInheritance("IWICMetadataQueryReader")] +public unsafe partial struct IWICMetadataQueryWriter +{ + public static ref readonly Guid IID_IWICMetadataQueryWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x1A, 0x79, 0x21, 0xA7, + 0xEF, 0x0D, + 0x06, 0x4D, + 0xBD, + 0x91, + 0x21, + 0x18, + 0xBF, + 0x1D, + 0xB1, + 0x0B + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICMetadataQueryWriter)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetContainerFormat(Guid* pguidContainerFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICMetadataQueryWriter*)Unsafe.AsPointer(ref this), pguidContainerFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetLocation(uint cchMaxLength, ushort* wzNamespace, uint* pcchActualLength) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICMetadataQueryWriter*)Unsafe.AsPointer(ref this), cchMaxLength, wzNamespace, pcchActualLength); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetMetadataByName(ushort* wzName, Com.Variant* pvarValue) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICMetadataQueryWriter*)Unsafe.AsPointer(ref this), wzName, pvarValue); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetEnumerator(Com.IEnumString* ppIEnumString) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICMetadataQueryWriter*)Unsafe.AsPointer(ref this), ppIEnumString); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetMetadataByName(ushort* wzName, Com.Variant* pvarValue) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICMetadataQueryWriter*)Unsafe.AsPointer(ref this), wzName, pvarValue); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult RemoveMetadataByName(ushort* wzName) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICMetadataQueryWriter*)Unsafe.AsPointer(ref this), wzName); + } +} + +/// +/// IWICBitmapEncoder +[Guid("00000103-a8f2-4877-ba0a-fd2b6645fb94")] +[NativeTypeName("struct IWICBitmapEncoder : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IWICBitmapEncoder +{ + public static ref readonly Guid IID_IWICBitmapEncoder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x03, 0x01, 0x00, 0x00, + 0xF2, 0xA8, + 0x77, 0x48, + 0xBA, + 0x0A, + 0xFD, + 0x2B, + 0x66, + 0x45, + 0xFB, + 0x94 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICBitmapEncoder)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult Initialize(Com.IStream* pIStream, WICBitmapEncoderCacheOption cacheOption) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICBitmapEncoder*)Unsafe.AsPointer(ref this), pIStream, cacheOption); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetContainerFormat(Guid* pguidContainerFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICBitmapEncoder*)Unsafe.AsPointer(ref this), pguidContainerFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetEncoderInfo(IWICBitmapEncoderInfo* ppIEncoderInfo) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICBitmapEncoder*)Unsafe.AsPointer(ref this), ppIEncoderInfo); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetColorContexts(uint cCount, IWICColorContext** ppIColorContext) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICBitmapEncoder*)Unsafe.AsPointer(ref this), cCount, ppIColorContext); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetPalette(IWICPalette* pIPalette) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICBitmapEncoder*)Unsafe.AsPointer(ref this), pIPalette); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult SetThumbnail(IWICBitmapSource* pIThumbnail) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICBitmapEncoder*)Unsafe.AsPointer(ref this), pIThumbnail); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult SetPreview(IWICBitmapSource* pIPreview) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IWICBitmapEncoder*)Unsafe.AsPointer(ref this), pIPreview); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult CreateNewFrame(IWICBitmapFrameEncode* ppIFrameEncode, Com.IPropertyBag2* ppIEncoderOptions) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IWICBitmapEncoder*)Unsafe.AsPointer(ref this), ppIFrameEncode, ppIEncoderOptions); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult Commit() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IWICBitmapEncoder*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetMetadataQueryWriter(IWICMetadataQueryWriter* ppIMetadataQueryWriter) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IWICBitmapEncoder*)Unsafe.AsPointer(ref this), ppIMetadataQueryWriter); + } +} + +/// +/// IWICBitmapFrameEncode +[Guid("00000105-a8f2-4877-ba0a-fd2b6645fb94")] +[NativeTypeName("struct IWICBitmapFrameEncode : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IWICBitmapFrameEncode +{ + public static ref readonly Guid IID_IWICBitmapFrameEncode + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x05, 0x01, 0x00, 0x00, + 0xF2, 0xA8, + 0x77, 0x48, + 0xBA, + 0x0A, + 0xFD, + 0x2B, + 0x66, + 0x45, + 0xFB, + 0x94 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICBitmapFrameEncode)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult Initialize(Com.IPropertyBag2* pIEncoderOptions) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICBitmapFrameEncode*)Unsafe.AsPointer(ref this), pIEncoderOptions); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult SetSize(uint uiWidth, uint uiHeight) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICBitmapFrameEncode*)Unsafe.AsPointer(ref this), uiWidth, uiHeight); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetResolution(double dpiX, double dpiY) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICBitmapFrameEncode*)Unsafe.AsPointer(ref this), dpiX, dpiY); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPixelFormat(Guid* pPixelFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICBitmapFrameEncode*)Unsafe.AsPointer(ref this), pPixelFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetColorContexts(uint cCount, IWICColorContext** ppIColorContext) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICBitmapFrameEncode*)Unsafe.AsPointer(ref this), cCount, ppIColorContext); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult SetPalette(IWICPalette* pIPalette) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICBitmapFrameEncode*)Unsafe.AsPointer(ref this), pIPalette); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult SetThumbnail(IWICBitmapSource* pIThumbnail) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IWICBitmapFrameEncode*)Unsafe.AsPointer(ref this), pIThumbnail); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult WritePixels(uint lineCount, uint cbStride, uint cbBufferSize, byte* pbPixels) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IWICBitmapFrameEncode*)Unsafe.AsPointer(ref this), lineCount, cbStride, cbBufferSize, pbPixels); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult WriteSource(IWICBitmapSource* pIBitmapSource, Wicrect* prc) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IWICBitmapFrameEncode*)Unsafe.AsPointer(ref this), pIBitmapSource, prc); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult Commit() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IWICBitmapFrameEncode*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult GetMetadataQueryWriter(IWICMetadataQueryWriter* ppIMetadataQueryWriter) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IWICBitmapFrameEncode*)Unsafe.AsPointer(ref this), ppIMetadataQueryWriter); + } +} + +/// +/// IWICPlanarBitmapFrameEncode +[Guid("f928b7b8-2221-40c1-b72e-7e82f1974d1a")] +[NativeTypeName("struct IWICPlanarBitmapFrameEncode : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IWICPlanarBitmapFrameEncode +{ + public static ref readonly Guid IID_IWICPlanarBitmapFrameEncode + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xB8, 0xB7, 0x28, 0xF9, + 0x21, 0x22, + 0xC1, 0x40, + 0xB7, + 0x2E, + 0x7E, + 0x82, + 0xF1, + 0x97, + 0x4D, + 0x1A + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICPlanarBitmapFrameEncode)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult WritePixels(uint lineCount, Wicbitmapplane* pPlanes, uint cPlanes) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICPlanarBitmapFrameEncode*)Unsafe.AsPointer(ref this), lineCount, pPlanes, cPlanes); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult WriteSource(IWICBitmapSource** ppPlanes, uint cPlanes, Wicrect* prcSource) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICPlanarBitmapFrameEncode*)Unsafe.AsPointer(ref this), ppPlanes, cPlanes, prcSource); + } +} + +/// +/// IWICBitmapDecoder +[Guid("9edde9e7-8dee-47ea-99df-e6faf2ed44bf")] +[NativeTypeName("struct IWICBitmapDecoder : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IWICBitmapDecoder +{ + public static ref readonly Guid IID_IWICBitmapDecoder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xE7, 0xE9, 0xDD, 0x9E, + 0xEE, 0x8D, + 0xEA, 0x47, + 0x99, + 0xDF, + 0xE6, + 0xFA, + 0xF2, + 0xED, + 0x44, + 0xBF + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICBitmapDecoder)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult QueryCapability(Com.IStream* pIStream, uint* pdwCapability) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICBitmapDecoder*)Unsafe.AsPointer(ref this), pIStream, pdwCapability); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult Initialize(Com.IStream* pIStream, WICDecodeOptions cacheOptions) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICBitmapDecoder*)Unsafe.AsPointer(ref this), pIStream, cacheOptions); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetContainerFormat(Guid* pguidContainerFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICBitmapDecoder*)Unsafe.AsPointer(ref this), pguidContainerFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetDecoderInfo(IWICBitmapDecoderInfo* ppIDecoderInfo) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICBitmapDecoder*)Unsafe.AsPointer(ref this), ppIDecoderInfo); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CopyPalette(IWICPalette* pIPalette) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICBitmapDecoder*)Unsafe.AsPointer(ref this), pIPalette); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetMetadataQueryReader(IWICMetadataQueryReader* ppIMetadataQueryReader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICBitmapDecoder*)Unsafe.AsPointer(ref this), ppIMetadataQueryReader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetPreview(IWICBitmapSource* ppIBitmapSource) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IWICBitmapDecoder*)Unsafe.AsPointer(ref this), ppIBitmapSource); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetColorContexts(uint cCount, IWICColorContext** ppIColorContexts, uint* pcActualCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IWICBitmapDecoder*)Unsafe.AsPointer(ref this), cCount, ppIColorContexts, pcActualCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetThumbnail(IWICBitmapSource* ppIThumbnail) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IWICBitmapDecoder*)Unsafe.AsPointer(ref this), ppIThumbnail); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetFrameCount(uint* pCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IWICBitmapDecoder*)Unsafe.AsPointer(ref this), pCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult GetFrame(uint index, IWICBitmapFrameDecode* ppIBitmapFrame) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IWICBitmapDecoder*)Unsafe.AsPointer(ref this), index, ppIBitmapFrame); + } +} + +/// +/// IWICBitmapSourceTransform +[Guid("3b16811b-6a43-4ec9-b713-3d5a0c13b940")] +[NativeTypeName("struct IWICBitmapSourceTransform : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IWICBitmapSourceTransform +{ + public static ref readonly Guid IID_IWICBitmapSourceTransform + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x1B, 0x81, 0x16, 0x3B, + 0x43, 0x6A, + 0xC9, 0x4E, + 0xB7, + 0x13, + 0x3D, + 0x5A, + 0x0C, + 0x13, + 0xB9, + 0x40 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICBitmapSourceTransform)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult CopyPixels(Wicrect* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICBitmapSourceTransform*)Unsafe.AsPointer(ref this), prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBuffer); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetClosestSize(uint* puiWidth, uint* puiHeight) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICBitmapSourceTransform*)Unsafe.AsPointer(ref this), puiWidth, puiHeight); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetClosestPixelFormat(Guid* pguidDstFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICBitmapSourceTransform*)Unsafe.AsPointer(ref this), pguidDstFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult DoesSupportTransform(WICBitmapTransformOptions dstTransform, Bool32* pfIsSupported) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICBitmapSourceTransform*)Unsafe.AsPointer(ref this), dstTransform, pfIsSupported); + } +} + +/// +/// IWICPlanarBitmapSourceTransform +[Guid("3aff9cce-be95-4303-b927-e7d16ff4a613")] +[NativeTypeName("struct IWICPlanarBitmapSourceTransform : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IWICPlanarBitmapSourceTransform +{ + public static ref readonly Guid IID_IWICPlanarBitmapSourceTransform + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xCE, 0x9C, 0xFF, 0x3A, + 0x95, 0xBE, + 0x03, 0x43, + 0xB9, + 0x27, + 0xE7, + 0xD1, + 0x6F, + 0xF4, + 0xA6, + 0x13 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICPlanarBitmapSourceTransform)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult DoesSupportTransform(uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, Guid* pguidDstFormats, Wicbitmapplanedescription* pPlaneDescriptions, uint cPlanes, Bool32* pfIsSupported) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICPlanarBitmapSourceTransform*)Unsafe.AsPointer(ref this), puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupported); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CopyPixels(Wicrect* prcSource, uint uiWidth, uint uiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, Wicbitmapplane* pDstPlanes, uint cPlanes) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICPlanarBitmapSourceTransform*)Unsafe.AsPointer(ref this), prcSource, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanes, cPlanes); + } +} + +/// +/// IWICBitmapFrameDecode +[Guid("3b16811b-6a43-4ec9-a813-3d930c13b940")] +[NativeTypeName("struct IWICBitmapFrameDecode : IWICBitmapSource")] +[NativeInheritance("IWICBitmapSource")] +public unsafe partial struct IWICBitmapFrameDecode +{ + public static ref readonly Guid IID_IWICBitmapFrameDecode + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x1B, 0x81, 0x16, 0x3B, + 0x43, 0x6A, + 0xC9, 0x4E, + 0xA8, + 0x13, + 0x3D, + 0x93, + 0x0C, + 0x13, + 0xB9, + 0x40 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICBitmapFrameDecode)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetSize(uint* puiWidth, uint* puiHeight) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICBitmapFrameDecode*)Unsafe.AsPointer(ref this), puiWidth, puiHeight); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPixelFormat(Guid* pPixelFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICBitmapFrameDecode*)Unsafe.AsPointer(ref this), pPixelFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetResolution(double* pDpiX, double* pDpiY) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICBitmapFrameDecode*)Unsafe.AsPointer(ref this), pDpiX, pDpiY); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CopyPalette(IWICPalette* pIPalette) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICBitmapFrameDecode*)Unsafe.AsPointer(ref this), pIPalette); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CopyPixels(Wicrect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICBitmapFrameDecode*)Unsafe.AsPointer(ref this), prc, cbStride, cbBufferSize, pbBuffer); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetMetadataQueryReader(IWICMetadataQueryReader* ppIMetadataQueryReader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICBitmapFrameDecode*)Unsafe.AsPointer(ref this), ppIMetadataQueryReader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetColorContexts(uint cCount, IWICColorContext** ppIColorContexts, uint* pcActualCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IWICBitmapFrameDecode*)Unsafe.AsPointer(ref this), cCount, ppIColorContexts, pcActualCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetThumbnail(IWICBitmapSource* ppIThumbnail) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IWICBitmapFrameDecode*)Unsafe.AsPointer(ref this), ppIThumbnail); + } +} + +/// +/// IWICProgressiveLevelControl +[Guid("daac296f-7aa5-4dbf-8d15-225c5976f891")] +[NativeTypeName("struct IWICProgressiveLevelControl : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IWICProgressiveLevelControl +{ + public static ref readonly Guid IID_IWICProgressiveLevelControl + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x6F, 0x29, 0xAC, 0xDA, + 0xA5, 0x7A, + 0xBF, 0x4D, + 0x8D, + 0x15, + 0x22, + 0x5C, + 0x59, + 0x76, + 0xF8, + 0x91 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICProgressiveLevelControl)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetLevelCount(uint* pcLevels) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICProgressiveLevelControl*)Unsafe.AsPointer(ref this), pcLevels); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetCurrentLevel(uint* pnLevel) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICProgressiveLevelControl*)Unsafe.AsPointer(ref this), pnLevel); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetCurrentLevel(uint nLevel) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICProgressiveLevelControl*)Unsafe.AsPointer(ref this), nLevel); + } +} + +/// +/// IWICProgressCallback +[Guid("4776f9cd-9517-45fa-bf24-e89c5ec5c60c")] +[NativeTypeName("struct IWICProgressCallback : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IWICProgressCallback +{ + public static ref readonly Guid IID_IWICProgressCallback + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xCD, 0xF9, 0x76, 0x47, + 0x17, 0x95, + 0xFA, 0x45, + 0xBF, + 0x24, + 0xE8, + 0x9C, + 0x5E, + 0xC5, + 0xC6, + 0x0C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICProgressCallback)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult Notify(uint uFrameNum, WICProgressOperation operation, double dblProgress) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICProgressCallback*)Unsafe.AsPointer(ref this), uFrameNum, operation, dblProgress); + } +} + +/// +/// IWICBitmapCodecProgressNotification +[Guid("64c1024e-c3cf-4462-8078-88c2b11c46d9")] +[NativeTypeName("struct IWICBitmapCodecProgressNotification : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IWICBitmapCodecProgressNotification +{ + public static ref readonly Guid IID_IWICBitmapCodecProgressNotification + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x4E, 0x02, 0xC1, 0x64, + 0xCF, 0xC3, + 0x62, 0x44, + 0x80, + 0x78, + 0x88, + 0xC2, + 0xB1, + 0x1C, + 0x46, + 0xD9 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICBitmapCodecProgressNotification)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult RegisterProgressNotification(delegate* unmanaged[Stdcall] pfnProgressNotification, void* pvData, uint dwProgressFlags) + { + return ((delegate* unmanaged[Stdcall], void*, uint, int>)(lpVtbl[3]))((IWICBitmapCodecProgressNotification*)Unsafe.AsPointer(ref this), pfnProgressNotification, pvData, dwProgressFlags); + } +} + +/// +/// IWICComponentInfo +[Guid("23bc3f0a-698b-4357-886b-f24d50671334")] +[NativeTypeName("struct IWICComponentInfo : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IWICComponentInfo +{ + public static ref readonly Guid IID_IWICComponentInfo + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x0A, 0x3F, 0xBC, 0x23, + 0x8B, 0x69, + 0x57, 0x43, + 0x88, + 0x6B, + 0xF2, + 0x4D, + 0x50, + 0x67, + 0x13, + 0x34 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICComponentInfo)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetComponentType(WICComponentType* pType) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICComponentInfo*)Unsafe.AsPointer(ref this), pType); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetCLSID(Guid* pclsid) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICComponentInfo*)Unsafe.AsPointer(ref this), pclsid); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetSigningStatus(uint* pStatus) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICComponentInfo*)Unsafe.AsPointer(ref this), pStatus); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetAuthor(uint cchAuthor, ushort* wzAuthor, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICComponentInfo*)Unsafe.AsPointer(ref this), cchAuthor, wzAuthor, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetVendorGUID(Guid* pguidVendor) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICComponentInfo*)Unsafe.AsPointer(ref this), pguidVendor); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetVersion(uint cchVersion, ushort* wzVersion, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICComponentInfo*)Unsafe.AsPointer(ref this), cchVersion, wzVersion, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetSpecVersion(uint cchSpecVersion, ushort* wzSpecVersion, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IWICComponentInfo*)Unsafe.AsPointer(ref this), cchSpecVersion, wzSpecVersion, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetFriendlyName(uint cchFriendlyName, ushort* wzFriendlyName, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IWICComponentInfo*)Unsafe.AsPointer(ref this), cchFriendlyName, wzFriendlyName, pcchActual); + } +} + +/// +/// IWICFormatConverterInfo +[Guid("9f34fb65-13f4-4f15-bc57-3726b5e53d9f")] +[NativeTypeName("struct IWICFormatConverterInfo : IWICComponentInfo")] +[NativeInheritance("IWICComponentInfo")] +public unsafe partial struct IWICFormatConverterInfo +{ + public static ref readonly Guid IID_IWICFormatConverterInfo + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x65, 0xFB, 0x34, 0x9F, + 0xF4, 0x13, + 0x15, 0x4F, + 0xBC, + 0x57, + 0x37, + 0x26, + 0xB5, + 0xE5, + 0x3D, + 0x9F + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICFormatConverterInfo)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetComponentType(WICComponentType* pType) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICFormatConverterInfo*)Unsafe.AsPointer(ref this), pType); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetCLSID(Guid* pclsid) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICFormatConverterInfo*)Unsafe.AsPointer(ref this), pclsid); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetSigningStatus(uint* pStatus) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICFormatConverterInfo*)Unsafe.AsPointer(ref this), pStatus); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetAuthor(uint cchAuthor, ushort* wzAuthor, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICFormatConverterInfo*)Unsafe.AsPointer(ref this), cchAuthor, wzAuthor, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetVendorGUID(Guid* pguidVendor) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICFormatConverterInfo*)Unsafe.AsPointer(ref this), pguidVendor); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetVersion(uint cchVersion, ushort* wzVersion, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICFormatConverterInfo*)Unsafe.AsPointer(ref this), cchVersion, wzVersion, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetSpecVersion(uint cchSpecVersion, ushort* wzSpecVersion, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IWICFormatConverterInfo*)Unsafe.AsPointer(ref this), cchSpecVersion, wzSpecVersion, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetFriendlyName(uint cchFriendlyName, ushort* wzFriendlyName, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IWICFormatConverterInfo*)Unsafe.AsPointer(ref this), cchFriendlyName, wzFriendlyName, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetPixelFormats(uint cFormats, Guid* pPixelFormatGUIDs, uint* pcActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IWICFormatConverterInfo*)Unsafe.AsPointer(ref this), cFormats, pPixelFormatGUIDs, pcActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult CreateInstance(IWICFormatConverter* ppIConverter) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IWICFormatConverterInfo*)Unsafe.AsPointer(ref this), ppIConverter); + } +} + +/// +/// IWICBitmapCodecInfo +[Guid("e87a44c4-b76e-4c47-8b09-298eb12a2714")] +[NativeTypeName("struct IWICBitmapCodecInfo : IWICComponentInfo")] +[NativeInheritance("IWICComponentInfo")] +public unsafe partial struct IWICBitmapCodecInfo +{ + public static ref readonly Guid IID_IWICBitmapCodecInfo + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xC4, 0x44, 0x7A, 0xE8, + 0x6E, 0xB7, + 0x47, 0x4C, + 0x8B, + 0x09, + 0x29, + 0x8E, + 0xB1, + 0x2A, + 0x27, + 0x14 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICBitmapCodecInfo)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetComponentType(WICComponentType* pType) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICBitmapCodecInfo*)Unsafe.AsPointer(ref this), pType); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetCLSID(Guid* pclsid) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICBitmapCodecInfo*)Unsafe.AsPointer(ref this), pclsid); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetSigningStatus(uint* pStatus) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICBitmapCodecInfo*)Unsafe.AsPointer(ref this), pStatus); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetAuthor(uint cchAuthor, ushort* wzAuthor, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICBitmapCodecInfo*)Unsafe.AsPointer(ref this), cchAuthor, wzAuthor, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetVendorGUID(Guid* pguidVendor) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICBitmapCodecInfo*)Unsafe.AsPointer(ref this), pguidVendor); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetVersion(uint cchVersion, ushort* wzVersion, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICBitmapCodecInfo*)Unsafe.AsPointer(ref this), cchVersion, wzVersion, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetSpecVersion(uint cchSpecVersion, ushort* wzSpecVersion, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IWICBitmapCodecInfo*)Unsafe.AsPointer(ref this), cchSpecVersion, wzSpecVersion, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetFriendlyName(uint cchFriendlyName, ushort* wzFriendlyName, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IWICBitmapCodecInfo*)Unsafe.AsPointer(ref this), cchFriendlyName, wzFriendlyName, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetContainerFormat(Guid* pguidContainerFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IWICBitmapCodecInfo*)Unsafe.AsPointer(ref this), pguidContainerFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetPixelFormats(uint cFormats, Guid* pguidPixelFormats, uint* pcActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IWICBitmapCodecInfo*)Unsafe.AsPointer(ref this), cFormats, pguidPixelFormats, pcActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult GetColorManagementVersion(uint cchColorManagementVersion, ushort* wzColorManagementVersion, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IWICBitmapCodecInfo*)Unsafe.AsPointer(ref this), cchColorManagementVersion, wzColorManagementVersion, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult GetDeviceManufacturer(uint cchDeviceManufacturer, ushort* wzDeviceManufacturer, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IWICBitmapCodecInfo*)Unsafe.AsPointer(ref this), cchDeviceManufacturer, wzDeviceManufacturer, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult GetDeviceModels(uint cchDeviceModels, ushort* wzDeviceModels, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IWICBitmapCodecInfo*)Unsafe.AsPointer(ref this), cchDeviceModels, wzDeviceModels, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult GetMimeTypes(uint cchMimeTypes, ushort* wzMimeTypes, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IWICBitmapCodecInfo*)Unsafe.AsPointer(ref this), cchMimeTypes, wzMimeTypes, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult GetFileExtensions(uint cchFileExtensions, ushort* wzFileExtensions, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IWICBitmapCodecInfo*)Unsafe.AsPointer(ref this), cchFileExtensions, wzFileExtensions, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult DoesSupportAnimation(Bool32* pfSupportAnimation) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IWICBitmapCodecInfo*)Unsafe.AsPointer(ref this), pfSupportAnimation); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult DoesSupportChromakey(Bool32* pfSupportChromakey) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IWICBitmapCodecInfo*)Unsafe.AsPointer(ref this), pfSupportChromakey); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult DoesSupportLossless(Bool32* pfSupportLossless) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IWICBitmapCodecInfo*)Unsafe.AsPointer(ref this), pfSupportLossless); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult DoesSupportMultiframe(Bool32* pfSupportMultiframe) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IWICBitmapCodecInfo*)Unsafe.AsPointer(ref this), pfSupportMultiframe); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult MatchesMimeType(ushort* wzMimeType, Bool32* pfMatches) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IWICBitmapCodecInfo*)Unsafe.AsPointer(ref this), wzMimeType, pfMatches); + } +} + +/// +/// IWICBitmapEncoderInfo +[Guid("94c9b4ee-a09f-4f92-8a1e-4a9bce7e76fb")] +[NativeTypeName("struct IWICBitmapEncoderInfo : IWICBitmapCodecInfo")] +[NativeInheritance("IWICBitmapCodecInfo")] +public unsafe partial struct IWICBitmapEncoderInfo +{ + public static ref readonly Guid IID_IWICBitmapEncoderInfo + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xEE, 0xB4, 0xC9, 0x94, + 0x9F, 0xA0, + 0x92, 0x4F, + 0x8A, + 0x1E, + 0x4A, + 0x9B, + 0xCE, + 0x7E, + 0x76, + 0xFB + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICBitmapEncoderInfo)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetContainerFormat(Guid* pguidContainerFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICBitmapEncoderInfo*)Unsafe.AsPointer(ref this), pguidContainerFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPixelFormats(uint cFormats, Guid* pguidPixelFormats, uint* pcActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICBitmapEncoderInfo*)Unsafe.AsPointer(ref this), cFormats, pguidPixelFormats, pcActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetColorManagementVersion(uint cchColorManagementVersion, ushort* wzColorManagementVersion, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICBitmapEncoderInfo*)Unsafe.AsPointer(ref this), cchColorManagementVersion, wzColorManagementVersion, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetDeviceManufacturer(uint cchDeviceManufacturer, ushort* wzDeviceManufacturer, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICBitmapEncoderInfo*)Unsafe.AsPointer(ref this), cchDeviceManufacturer, wzDeviceManufacturer, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetDeviceModels(uint cchDeviceModels, ushort* wzDeviceModels, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICBitmapEncoderInfo*)Unsafe.AsPointer(ref this), cchDeviceModels, wzDeviceModels, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetMimeTypes(uint cchMimeTypes, ushort* wzMimeTypes, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICBitmapEncoderInfo*)Unsafe.AsPointer(ref this), cchMimeTypes, wzMimeTypes, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetFileExtensions(uint cchFileExtensions, ushort* wzFileExtensions, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IWICBitmapEncoderInfo*)Unsafe.AsPointer(ref this), cchFileExtensions, wzFileExtensions, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult DoesSupportAnimation(Bool32* pfSupportAnimation) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IWICBitmapEncoderInfo*)Unsafe.AsPointer(ref this), pfSupportAnimation); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult DoesSupportChromakey(Bool32* pfSupportChromakey) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IWICBitmapEncoderInfo*)Unsafe.AsPointer(ref this), pfSupportChromakey); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult DoesSupportLossless(Bool32* pfSupportLossless) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IWICBitmapEncoderInfo*)Unsafe.AsPointer(ref this), pfSupportLossless); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult DoesSupportMultiframe(Bool32* pfSupportMultiframe) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IWICBitmapEncoderInfo*)Unsafe.AsPointer(ref this), pfSupportMultiframe); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult MatchesMimeType(ushort* wzMimeType, Bool32* pfMatches) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IWICBitmapEncoderInfo*)Unsafe.AsPointer(ref this), wzMimeType, pfMatches); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult GetComponentType(WICComponentType* pType) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IWICBitmapEncoderInfo*)Unsafe.AsPointer(ref this), pType); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult GetCLSID(Guid* pclsid) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IWICBitmapEncoderInfo*)Unsafe.AsPointer(ref this), pclsid); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult GetSigningStatus(uint* pStatus) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IWICBitmapEncoderInfo*)Unsafe.AsPointer(ref this), pStatus); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult GetAuthor(uint cchAuthor, ushort* wzAuthor, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IWICBitmapEncoderInfo*)Unsafe.AsPointer(ref this), cchAuthor, wzAuthor, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult GetVendorGUID(Guid* pguidVendor) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IWICBitmapEncoderInfo*)Unsafe.AsPointer(ref this), pguidVendor); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult GetVersion(uint cchVersion, ushort* wzVersion, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IWICBitmapEncoderInfo*)Unsafe.AsPointer(ref this), cchVersion, wzVersion, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult GetSpecVersion(uint cchSpecVersion, ushort* wzSpecVersion, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IWICBitmapEncoderInfo*)Unsafe.AsPointer(ref this), cchSpecVersion, wzSpecVersion, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult GetFriendlyName(uint cchFriendlyName, ushort* wzFriendlyName, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IWICBitmapEncoderInfo*)Unsafe.AsPointer(ref this), cchFriendlyName, wzFriendlyName, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult CreateInstance(IWICBitmapEncoder* ppIBitmapEncoder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IWICBitmapEncoderInfo*)Unsafe.AsPointer(ref this), ppIBitmapEncoder); + } +} + +/// +/// IWICBitmapDecoderInfo +[Guid("d8cd007f-d08f-4191-9bfc-236ea7f0e4b5")] +[NativeTypeName("struct IWICBitmapDecoderInfo : IWICBitmapCodecInfo")] +[NativeInheritance("IWICBitmapCodecInfo")] +public unsafe partial struct IWICBitmapDecoderInfo +{ + public static ref readonly Guid IID_IWICBitmapDecoderInfo + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x7F, 0x00, 0xCD, 0xD8, + 0x8F, 0xD0, + 0x91, 0x41, + 0x9B, + 0xFC, + 0x23, + 0x6E, + 0xA7, + 0xF0, + 0xE4, + 0xB5 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICBitmapDecoderInfo)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetContainerFormat(Guid* pguidContainerFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICBitmapDecoderInfo*)Unsafe.AsPointer(ref this), pguidContainerFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPixelFormats(uint cFormats, Guid* pguidPixelFormats, uint* pcActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICBitmapDecoderInfo*)Unsafe.AsPointer(ref this), cFormats, pguidPixelFormats, pcActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetColorManagementVersion(uint cchColorManagementVersion, ushort* wzColorManagementVersion, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICBitmapDecoderInfo*)Unsafe.AsPointer(ref this), cchColorManagementVersion, wzColorManagementVersion, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetDeviceManufacturer(uint cchDeviceManufacturer, ushort* wzDeviceManufacturer, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICBitmapDecoderInfo*)Unsafe.AsPointer(ref this), cchDeviceManufacturer, wzDeviceManufacturer, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetDeviceModels(uint cchDeviceModels, ushort* wzDeviceModels, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICBitmapDecoderInfo*)Unsafe.AsPointer(ref this), cchDeviceModels, wzDeviceModels, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetMimeTypes(uint cchMimeTypes, ushort* wzMimeTypes, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICBitmapDecoderInfo*)Unsafe.AsPointer(ref this), cchMimeTypes, wzMimeTypes, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetFileExtensions(uint cchFileExtensions, ushort* wzFileExtensions, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IWICBitmapDecoderInfo*)Unsafe.AsPointer(ref this), cchFileExtensions, wzFileExtensions, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult DoesSupportAnimation(Bool32* pfSupportAnimation) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IWICBitmapDecoderInfo*)Unsafe.AsPointer(ref this), pfSupportAnimation); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult DoesSupportChromakey(Bool32* pfSupportChromakey) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IWICBitmapDecoderInfo*)Unsafe.AsPointer(ref this), pfSupportChromakey); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult DoesSupportLossless(Bool32* pfSupportLossless) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IWICBitmapDecoderInfo*)Unsafe.AsPointer(ref this), pfSupportLossless); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult DoesSupportMultiframe(Bool32* pfSupportMultiframe) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IWICBitmapDecoderInfo*)Unsafe.AsPointer(ref this), pfSupportMultiframe); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult MatchesMimeType(ushort* wzMimeType, Bool32* pfMatches) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IWICBitmapDecoderInfo*)Unsafe.AsPointer(ref this), wzMimeType, pfMatches); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult GetComponentType(WICComponentType* pType) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IWICBitmapDecoderInfo*)Unsafe.AsPointer(ref this), pType); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult GetCLSID(Guid* pclsid) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IWICBitmapDecoderInfo*)Unsafe.AsPointer(ref this), pclsid); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult GetSigningStatus(uint* pStatus) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IWICBitmapDecoderInfo*)Unsafe.AsPointer(ref this), pStatus); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult GetAuthor(uint cchAuthor, ushort* wzAuthor, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IWICBitmapDecoderInfo*)Unsafe.AsPointer(ref this), cchAuthor, wzAuthor, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult GetVendorGUID(Guid* pguidVendor) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IWICBitmapDecoderInfo*)Unsafe.AsPointer(ref this), pguidVendor); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult GetVersion(uint cchVersion, ushort* wzVersion, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IWICBitmapDecoderInfo*)Unsafe.AsPointer(ref this), cchVersion, wzVersion, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult GetSpecVersion(uint cchSpecVersion, ushort* wzSpecVersion, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IWICBitmapDecoderInfo*)Unsafe.AsPointer(ref this), cchSpecVersion, wzSpecVersion, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult GetFriendlyName(uint cchFriendlyName, ushort* wzFriendlyName, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IWICBitmapDecoderInfo*)Unsafe.AsPointer(ref this), cchFriendlyName, wzFriendlyName, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult GetPatterns(uint cbSizePatterns, Wicbitmappattern* pPatterns, uint* pcPatterns, uint* pcbPatternsActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IWICBitmapDecoderInfo*)Unsafe.AsPointer(ref this), cbSizePatterns, pPatterns, pcPatterns, pcbPatternsActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult MatchesPattern(Com.IStream* pIStream, Bool32* pfMatches) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IWICBitmapDecoderInfo*)Unsafe.AsPointer(ref this), pIStream, pfMatches); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult CreateInstance(IWICBitmapDecoder* ppIBitmapDecoder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IWICBitmapDecoderInfo*)Unsafe.AsPointer(ref this), ppIBitmapDecoder); + } +} + +/// +/// IWICPixelFormatInfo +[Guid("e8eda601-3d48-431a-ab44-69059be88bbe")] +[NativeTypeName("struct IWICPixelFormatInfo : IWICComponentInfo")] +[NativeInheritance("IWICComponentInfo")] +public unsafe partial struct IWICPixelFormatInfo +{ + public static ref readonly Guid IID_IWICPixelFormatInfo + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x01, 0xA6, 0xED, 0xE8, + 0x48, 0x3D, + 0x1A, 0x43, + 0xAB, + 0x44, + 0x69, + 0x05, + 0x9B, + 0xE8, + 0x8B, + 0xBE + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICPixelFormatInfo)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetComponentType(WICComponentType* pType) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICPixelFormatInfo*)Unsafe.AsPointer(ref this), pType); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetCLSID(Guid* pclsid) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICPixelFormatInfo*)Unsafe.AsPointer(ref this), pclsid); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetSigningStatus(uint* pStatus) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICPixelFormatInfo*)Unsafe.AsPointer(ref this), pStatus); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetAuthor(uint cchAuthor, ushort* wzAuthor, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICPixelFormatInfo*)Unsafe.AsPointer(ref this), cchAuthor, wzAuthor, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetVendorGUID(Guid* pguidVendor) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICPixelFormatInfo*)Unsafe.AsPointer(ref this), pguidVendor); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetVersion(uint cchVersion, ushort* wzVersion, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICPixelFormatInfo*)Unsafe.AsPointer(ref this), cchVersion, wzVersion, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetSpecVersion(uint cchSpecVersion, ushort* wzSpecVersion, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IWICPixelFormatInfo*)Unsafe.AsPointer(ref this), cchSpecVersion, wzSpecVersion, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetFriendlyName(uint cchFriendlyName, ushort* wzFriendlyName, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IWICPixelFormatInfo*)Unsafe.AsPointer(ref this), cchFriendlyName, wzFriendlyName, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetFormatGUID(Guid* pFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IWICPixelFormatInfo*)Unsafe.AsPointer(ref this), pFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetColorContext(IWICColorContext* ppIColorContext) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IWICPixelFormatInfo*)Unsafe.AsPointer(ref this), ppIColorContext); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult GetBitsPerPixel(uint* puiBitsPerPixel) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IWICPixelFormatInfo*)Unsafe.AsPointer(ref this), puiBitsPerPixel); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult GetChannelCount(uint* puiChannelCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IWICPixelFormatInfo*)Unsafe.AsPointer(ref this), puiChannelCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult GetChannelMask(uint uiChannelIndex, uint cbMaskBuffer, byte* pbMaskBuffer, uint* pcbActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IWICPixelFormatInfo*)Unsafe.AsPointer(ref this), uiChannelIndex, cbMaskBuffer, pbMaskBuffer, pcbActual); + } +} + +/// +/// IWICPixelFormatInfo2 +[Guid("a9db33a2-af5f-43c7-b679-74f5984b5aa4")] +[NativeTypeName("struct IWICPixelFormatInfo2 : IWICPixelFormatInfo")] +[NativeInheritance("IWICPixelFormatInfo")] +public unsafe partial struct IWICPixelFormatInfo2 +{ + public static ref readonly Guid IID_IWICPixelFormatInfo2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xA2, 0x33, 0xDB, 0xA9, + 0x5F, 0xAF, + 0xC7, 0x43, + 0xB6, + 0x79, + 0x74, + 0xF5, + 0x98, + 0x4B, + 0x5A, + 0xA4 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICPixelFormatInfo2)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetFormatGUID(Guid* pFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICPixelFormatInfo2*)Unsafe.AsPointer(ref this), pFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetColorContext(IWICColorContext* ppIColorContext) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICPixelFormatInfo2*)Unsafe.AsPointer(ref this), ppIColorContext); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetBitsPerPixel(uint* puiBitsPerPixel) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICPixelFormatInfo2*)Unsafe.AsPointer(ref this), puiBitsPerPixel); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetChannelCount(uint* puiChannelCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICPixelFormatInfo2*)Unsafe.AsPointer(ref this), puiChannelCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetChannelMask(uint uiChannelIndex, uint cbMaskBuffer, byte* pbMaskBuffer, uint* pcbActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICPixelFormatInfo2*)Unsafe.AsPointer(ref this), uiChannelIndex, cbMaskBuffer, pbMaskBuffer, pcbActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetComponentType(WICComponentType* pType) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICPixelFormatInfo2*)Unsafe.AsPointer(ref this), pType); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetCLSID(Guid* pclsid) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IWICPixelFormatInfo2*)Unsafe.AsPointer(ref this), pclsid); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetSigningStatus(uint* pStatus) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IWICPixelFormatInfo2*)Unsafe.AsPointer(ref this), pStatus); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetAuthor(uint cchAuthor, ushort* wzAuthor, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IWICPixelFormatInfo2*)Unsafe.AsPointer(ref this), cchAuthor, wzAuthor, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetVendorGUID(Guid* pguidVendor) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IWICPixelFormatInfo2*)Unsafe.AsPointer(ref this), pguidVendor); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult GetVersion(uint cchVersion, ushort* wzVersion, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IWICPixelFormatInfo2*)Unsafe.AsPointer(ref this), cchVersion, wzVersion, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult GetSpecVersion(uint cchSpecVersion, ushort* wzSpecVersion, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IWICPixelFormatInfo2*)Unsafe.AsPointer(ref this), cchSpecVersion, wzSpecVersion, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult GetFriendlyName(uint cchFriendlyName, ushort* wzFriendlyName, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IWICPixelFormatInfo2*)Unsafe.AsPointer(ref this), cchFriendlyName, wzFriendlyName, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult SupportsTransparency(Bool32* pfSupportsTransparency) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IWICPixelFormatInfo2*)Unsafe.AsPointer(ref this), pfSupportsTransparency); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult GetNumericRepresentation(WICPixelFormatNumericRepresentation* pNumericRepresentation) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IWICPixelFormatInfo2*)Unsafe.AsPointer(ref this), pNumericRepresentation); + } +} + +/// +/// IWICImagingFactory +[Guid("ec5ec8a9-c395-4314-9c77-54d7a935ff70")] +[NativeTypeName("struct IWICImagingFactory : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IWICImagingFactory +{ + public static ref readonly Guid IID_IWICImagingFactory + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xA9, 0xC8, 0x5E, 0xEC, + 0x95, 0xC3, + 0x14, 0x43, + 0x9C, + 0x77, + 0x54, + 0xD7, + 0xA9, + 0x35, + 0xFF, + 0x70 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICImagingFactory)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult CreateDecoderFromFilename(ushort* wzFilename, Guid* pguidVendor, NativeFileAccess dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICImagingFactory*)Unsafe.AsPointer(ref this), wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CreateDecoderFromStream(Com.IStream* pIStream, Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICImagingFactory*)Unsafe.AsPointer(ref this), pIStream, pguidVendor, metadataOptions, ppIDecoder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult CreateDecoderFromFileHandle(nuint hFile, Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICImagingFactory*)Unsafe.AsPointer(ref this), hFile, pguidVendor, metadataOptions, ppIDecoder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CreateComponentInfo(Guid* clsidComponent, IWICComponentInfo* ppIInfo) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICImagingFactory*)Unsafe.AsPointer(ref this), clsidComponent, ppIInfo); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CreateDecoder(Guid* guidContainerFormat, Guid* pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICImagingFactory*)Unsafe.AsPointer(ref this), guidContainerFormat, pguidVendor, ppIDecoder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult CreateEncoder(Guid* guidContainerFormat, Guid* pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICImagingFactory*)Unsafe.AsPointer(ref this), guidContainerFormat, pguidVendor, ppIEncoder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult CreatePalette(IWICPalette* ppIPalette) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IWICImagingFactory*)Unsafe.AsPointer(ref this), ppIPalette); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult CreateFormatConverter(IWICFormatConverter* ppIFormatConverter) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IWICImagingFactory*)Unsafe.AsPointer(ref this), ppIFormatConverter); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult CreateBitmapScaler(IWICBitmapScaler* ppIBitmapScaler) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IWICImagingFactory*)Unsafe.AsPointer(ref this), ppIBitmapScaler); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult CreateBitmapClipper(IWICBitmapClipper* ppIBitmapClipper) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IWICImagingFactory*)Unsafe.AsPointer(ref this), ppIBitmapClipper); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult CreateBitmapFlipRotator(IWICBitmapFlipRotator* ppIBitmapFlipRotator) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IWICImagingFactory*)Unsafe.AsPointer(ref this), ppIBitmapFlipRotator); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult CreateStream(IWICStream* ppIWICStream) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IWICImagingFactory*)Unsafe.AsPointer(ref this), ppIWICStream); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult CreateColorContext(IWICColorContext* ppIWICColorContext) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IWICImagingFactory*)Unsafe.AsPointer(ref this), ppIWICColorContext); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult CreateColorTransformer(IWICColorTransform* ppIWICColorTransform) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IWICImagingFactory*)Unsafe.AsPointer(ref this), ppIWICColorTransform); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap* ppIBitmap) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IWICImagingFactory*)Unsafe.AsPointer(ref this), uiWidth, uiHeight, pixelFormat, option, ppIBitmap); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult CreateBitmapFromSource(IWICBitmapSource* pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap* ppIBitmap) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IWICImagingFactory*)Unsafe.AsPointer(ref this), pIBitmapSource, option, ppIBitmap); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult CreateBitmapFromSourceRect(IWICBitmapSource* pIBitmapSource, uint x, uint y, uint width, uint height, IWICBitmap* ppIBitmap) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IWICImagingFactory*)Unsafe.AsPointer(ref this), pIBitmapSource, x, y, width, height, ppIBitmap); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, IWICBitmap* ppIBitmap) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IWICImagingFactory*)Unsafe.AsPointer(ref this), uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBuffer, ppIBitmap); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult CreateBitmapFromHBITMAP(IntPtr hBitmap, IntPtr hPalette, WICBitmapAlphaChannelOption options, IWICBitmap* ppIBitmap) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IWICImagingFactory*)Unsafe.AsPointer(ref this), hBitmap, hPalette, options, ppIBitmap); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult CreateBitmapFromHICON(IntPtr hIcon, IWICBitmap* ppIBitmap) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IWICImagingFactory*)Unsafe.AsPointer(ref this), hIcon, ppIBitmap); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult CreateComponentEnumerator(uint componentTypes, uint options, Com.IEnumUnknown* ppIEnumUnknown) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IWICImagingFactory*)Unsafe.AsPointer(ref this), componentTypes, options, ppIEnumUnknown); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult CreateFastMetadataEncoderFromDecoder(IWICBitmapDecoder* pIDecoder, IWICFastMetadataEncoder* ppIFastEncoder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IWICImagingFactory*)Unsafe.AsPointer(ref this), pIDecoder, ppIFastEncoder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult CreateFastMetadataEncoderFromFrameDecode(IWICBitmapFrameDecode* pIFrameDecoder, IWICFastMetadataEncoder* ppIFastEncoder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IWICImagingFactory*)Unsafe.AsPointer(ref this), pIFrameDecoder, ppIFastEncoder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public HResult CreateQueryWriter(Guid* guidMetadataFormat, Guid* pguidVendor, IWICMetadataQueryWriter* ppIQueryWriter) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((IWICImagingFactory*)Unsafe.AsPointer(ref this), guidMetadataFormat, pguidVendor, ppIQueryWriter); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult CreateQueryWriterFromReader(IWICMetadataQueryReader* pIQueryReader, Guid* pguidVendor, IWICMetadataQueryWriter* ppIQueryWriter) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((IWICImagingFactory*)Unsafe.AsPointer(ref this), pIQueryReader, pguidVendor, ppIQueryWriter); + } +} + +/// +/// IWICDevelopRawNotificationCallback +[Guid("95c75a6e-3e8c-4ec2-85a8-aebcc551e59b")] +[NativeTypeName("struct IWICDevelopRawNotificationCallback : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IWICDevelopRawNotificationCallback +{ + public static ref readonly Guid IID_IWICDevelopRawNotificationCallback + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x6E, 0x5A, 0xC7, 0x95, + 0x8C, 0x3E, + 0xC2, 0x4E, + 0x85, + 0xA8, + 0xAE, + 0xBC, + 0xC5, + 0x51, + 0xE5, + 0x9B + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICDevelopRawNotificationCallback)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult Notify(uint NotificationMask) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICDevelopRawNotificationCallback*)Unsafe.AsPointer(ref this), NotificationMask); + } +} + +/// +/// IWICDevelopRaw +[Guid("fbec5e44-f7be-4b65-b7f8-c0c81fef026d")] +[NativeTypeName("struct IWICDevelopRaw : IWICBitmapFrameDecode")] +[NativeInheritance("IWICBitmapFrameDecode")] +public unsafe partial struct IWICDevelopRaw +{ + public static ref readonly Guid IID_IWICDevelopRaw + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x44, 0x5E, 0xEC, 0xFB, + 0xBE, 0xF7, + 0x65, 0x4B, + 0xB7, + 0xF8, + 0xC0, + 0xC8, + 0x1F, + 0xEF, + 0x02, + 0x6D + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICDevelopRaw)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetMetadataQueryReader(IWICMetadataQueryReader* ppIMetadataQueryReader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), ppIMetadataQueryReader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetColorContexts(uint cCount, IWICColorContext** ppIColorContexts, uint* pcActualCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), cCount, ppIColorContexts, pcActualCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetThumbnail(IWICBitmapSource* ppIThumbnail) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), ppIThumbnail); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetSize(uint* puiWidth, uint* puiHeight) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), puiWidth, puiHeight); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetPixelFormat(Guid* pPixelFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), pPixelFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetResolution(double* pDpiX, double* pDpiY) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), pDpiX, pDpiY); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult CopyPalette(IWICPalette* pIPalette) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), pIPalette); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult CopyPixels(Wicrect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), prc, cbStride, cbBufferSize, pbBuffer); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult QueryRawCapabilitiesInfo(Wicrawcapabilitiesinfo* pInfo) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), pInfo); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult LoadParameterSet(WICRawParameterSet ParameterSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), ParameterSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult GetCurrentParameterSet(Com.IPropertyBag2* ppCurrentParameterSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), ppCurrentParameterSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult SetExposureCompensation(double ev) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), ev); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult GetExposureCompensation(double* pEV) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), pEV); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult SetWhitePointRGB(uint Red, uint Green, uint Blue) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), Red, Green, Blue); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult GetWhitePointRGB(uint* pRed, uint* pGreen, uint* pBlue) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), pRed, pGreen, pBlue); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult SetNamedWhitePoint(WICNamedWhitePoint WhitePoint) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), WhitePoint); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult GetNamedWhitePoint(WICNamedWhitePoint* pWhitePoint) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), pWhitePoint); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult SetWhitePointKelvin(uint WhitePointKelvin) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), WhitePointKelvin); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult GetWhitePointKelvin(uint* pWhitePointKelvin) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), pWhitePointKelvin); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult GetKelvinRangeInfo(uint* pMinKelvinTemp, uint* pMaxKelvinTemp, uint* pKelvinTempStepValue) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), pMinKelvinTemp, pMaxKelvinTemp, pKelvinTempStepValue); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult SetContrast(double Contrast) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), Contrast); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult GetContrast(double* pContrast) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), pContrast); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult SetGamma(double Gamma) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), Gamma); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public HResult GetGamma(double* pGamma) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), pGamma); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult SetSharpness(double Sharpness) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), Sharpness); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult GetSharpness(double* pSharpness) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), pSharpness); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult SetSaturation(double Saturation) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), Saturation); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult GetSaturation(double* pSaturation) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), pSaturation); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public HResult SetTint(double Tint) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), Tint); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult GetTint(double* pTint) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), pTint); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public HResult SetNoiseReduction(double NoiseReduction) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), NoiseReduction); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public HResult GetNoiseReduction(double* pNoiseReduction) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), pNoiseReduction); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public HResult SetDestinationColorContext(IWICColorContext* pColorContext) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), pColorContext); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public HResult SetToneCurve(uint cbToneCurveSize, Wicrawtonecurve* pToneCurve) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), cbToneCurveSize, pToneCurve); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public HResult GetToneCurve(uint cbToneCurveBufferSize, Wicrawtonecurve* pToneCurve, uint* pcbActualToneCurveBufferSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), cbToneCurveBufferSize, pToneCurve, pcbActualToneCurveBufferSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public HResult SetRotation(double Rotation) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), Rotation); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public HResult GetRotation(double* pRotation) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), pRotation); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public HResult SetRenderMode(WICRawRenderMode RenderMode) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), RenderMode); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public HResult GetRenderMode(WICRawRenderMode* pRenderMode) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), pRenderMode); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public HResult SetNotificationCallback(IWICDevelopRawNotificationCallback* pCallback) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((IWICDevelopRaw*)Unsafe.AsPointer(ref this), pCallback); + } +} + +/// +/// IWICDdsDecoder +[Guid("409cd537-8532-40cb-9774-e2feb2df4e9c")] +[NativeTypeName("struct IWICDdsDecoder : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IWICDdsDecoder +{ + public static ref readonly Guid IID_IWICDdsDecoder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x37, 0xD5, 0x9C, 0x40, + 0x32, 0x85, + 0xCB, 0x40, + 0x97, + 0x74, + 0xE2, + 0xFE, + 0xB2, + 0xDF, + 0x4E, + 0x9C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICDdsDecoder)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetParameters(Wicddsparameters* pParameters) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICDdsDecoder*)Unsafe.AsPointer(ref this), pParameters); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetFrame(uint arrayIndex, uint mipLevel, uint sliceIndex, IWICBitmapFrameDecode** ppIBitmapFrame) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICDdsDecoder*)Unsafe.AsPointer(ref this), arrayIndex, mipLevel, sliceIndex, ppIBitmapFrame); + } +} + +/// +/// IWICDdsEncoder +[Guid("5cacdb4c-407e-41b3-b936-d0f010cd6732")] +[NativeTypeName("struct IWICDdsEncoder : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IWICDdsEncoder +{ + public static ref readonly Guid IID_IWICDdsEncoder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x4C, 0xDB, 0xAC, 0x5C, + 0x7E, 0x40, + 0xB3, 0x41, + 0xB9, + 0x36, + 0xD0, + 0xF0, + 0x10, + 0xCD, + 0x67, + 0x32 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICDdsEncoder)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult SetParameters(Wicddsparameters* pParameters) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICDdsEncoder*)Unsafe.AsPointer(ref this), pParameters); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetParameters(Wicddsparameters* pParameters) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICDdsEncoder*)Unsafe.AsPointer(ref this), pParameters); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult CreateNewFrame(IWICBitmapFrameEncode* ppIFrameEncode, uint* pArrayIndex, uint* pMipLevel, uint* pSliceIndex) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICDdsEncoder*)Unsafe.AsPointer(ref this), ppIFrameEncode, pArrayIndex, pMipLevel, pSliceIndex); + } +} + +/// +/// IWICDdsFrameDecode +[Guid("3d4c0c61-18a4-41e4-bd80-481a4fc9f464")] +[NativeTypeName("struct IWICDdsFrameDecode : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IWICDdsFrameDecode +{ + public static ref readonly Guid IID_IWICDdsFrameDecode + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x61, 0x0C, 0x4C, 0x3D, + 0xA4, 0x18, + 0xE4, 0x41, + 0xBD, + 0x80, + 0x48, + 0x1A, + 0x4F, + 0xC9, + 0xF4, + 0x64 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICDdsFrameDecode)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetSizeInBlocks(uint* pWidthInBlocks, uint* pHeightInBlocks) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICDdsFrameDecode*)Unsafe.AsPointer(ref this), pWidthInBlocks, pHeightInBlocks); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetFormatInfo(Wicddsformatinfo* pFormatInfo) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICDdsFrameDecode*)Unsafe.AsPointer(ref this), pFormatInfo); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult CopyBlocks(Wicrect* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICDdsFrameDecode*)Unsafe.AsPointer(ref this), prcBoundsInBlocks, cbStride, cbBufferSize, pbBuffer); + } +} + +/// +/// IWICJpegFrameDecode +[Guid("8939f66e-c46a-4c21-a9d1-98b327ce1679")] +[NativeTypeName("struct IWICJpegFrameDecode : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IWICJpegFrameDecode +{ + public static ref readonly Guid IID_IWICJpegFrameDecode + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x6E, 0xF6, 0x39, 0x89, + 0x6A, 0xC4, + 0x21, 0x4C, + 0xA9, + 0xD1, + 0x98, + 0xB3, + 0x27, + 0xCE, + 0x16, + 0x79 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICJpegFrameDecode)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult DoesSupportIndexing(Bool32* pfIndexingSupported) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICJpegFrameDecode*)Unsafe.AsPointer(ref this), pfIndexingSupported); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult SetIndexing(WICJpegIndexingOptions options, uint horizontalIntervalSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICJpegFrameDecode*)Unsafe.AsPointer(ref this), options, horizontalIntervalSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult ClearIndexing() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICJpegFrameDecode*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetAcHuffmanTable(uint scanIndex, uint tableIndex, Graphics.Dxgi.Common.JpegAcHuffmanTable* pAcHuffmanTable) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICJpegFrameDecode*)Unsafe.AsPointer(ref this), scanIndex, tableIndex, pAcHuffmanTable); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetDcHuffmanTable(uint scanIndex, uint tableIndex, Graphics.Dxgi.Common.JpegDcHuffmanTable* pDcHuffmanTable) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICJpegFrameDecode*)Unsafe.AsPointer(ref this), scanIndex, tableIndex, pDcHuffmanTable); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetQuantizationTable(uint scanIndex, uint tableIndex, Graphics.Dxgi.Common.JpegQuantizationTable* pQuantizationTable) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICJpegFrameDecode*)Unsafe.AsPointer(ref this), scanIndex, tableIndex, pQuantizationTable); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetFrameHeader(Wicjpegframeheader* pFrameHeader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IWICJpegFrameDecode*)Unsafe.AsPointer(ref this), pFrameHeader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetScanHeader(uint scanIndex, Wicjpegscanheader* pScanHeader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IWICJpegFrameDecode*)Unsafe.AsPointer(ref this), scanIndex, pScanHeader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult CopyScan(uint scanIndex, uint scanOffset, uint cbScanData, byte* pbScanData, uint* pcbScanDataActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IWICJpegFrameDecode*)Unsafe.AsPointer(ref this), scanIndex, scanOffset, cbScanData, pbScanData, pcbScanDataActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult CopyMinimalStream(uint streamOffset, uint cbStreamData, byte* pbStreamData, uint* pcbStreamDataActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IWICJpegFrameDecode*)Unsafe.AsPointer(ref this), streamOffset, cbStreamData, pbStreamData, pcbStreamDataActual); + } +} + +/// +/// IWICJpegFrameEncode +[Guid("2f0c601f-d2c6-468c-abfa-49495d983ed1")] +[NativeTypeName("struct IWICJpegFrameEncode : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IWICJpegFrameEncode +{ + public static ref readonly Guid IID_IWICJpegFrameEncode + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x1F, 0x60, 0x0C, 0x2F, + 0xC6, 0xD2, + 0x8C, 0x46, + 0xAB, + 0xFA, + 0x49, + 0x49, + 0x5D, + 0x98, + 0x3E, + 0xD1 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICJpegFrameEncode)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetAcHuffmanTable(uint scanIndex, uint tableIndex, Graphics.Dxgi.Common.JpegAcHuffmanTable* pAcHuffmanTable) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICJpegFrameEncode*)Unsafe.AsPointer(ref this), scanIndex, tableIndex, pAcHuffmanTable); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetDcHuffmanTable(uint scanIndex, uint tableIndex, Graphics.Dxgi.Common.JpegDcHuffmanTable* pDcHuffmanTable) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICJpegFrameEncode*)Unsafe.AsPointer(ref this), scanIndex, tableIndex, pDcHuffmanTable); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetQuantizationTable(uint scanIndex, uint tableIndex, Graphics.Dxgi.Common.JpegQuantizationTable* pQuantizationTable) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICJpegFrameEncode*)Unsafe.AsPointer(ref this), scanIndex, tableIndex, pQuantizationTable); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult WriteScan(uint cbScanData, byte* pbScanData) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICJpegFrameEncode*)Unsafe.AsPointer(ref this), cbScanData, pbScanData); + } +} + +/// +/// IWICMetadataBlockReader +[Guid("feaa2a8d-b3f3-43e4-b25c-d1de990a1ae1")] +[NativeTypeName("struct IWICMetadataBlockReader : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IWICMetadataBlockReader +{ + public static ref readonly Guid IID_IWICMetadataBlockReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x8D, 0x2A, 0xAA, 0xFE, + 0xF3, 0xB3, + 0xE4, 0x43, + 0xB2, + 0x5C, + 0xD1, + 0xDE, + 0x99, + 0x0A, + 0x1A, + 0xE1 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICMetadataBlockReader)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetContainerFormat(Guid* pguidContainerFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICMetadataBlockReader*)Unsafe.AsPointer(ref this), pguidContainerFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetCount(uint* pcCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICMetadataBlockReader*)Unsafe.AsPointer(ref this), pcCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetReaderByIndex(uint nIndex, IWICMetadataReader* ppIMetadataReader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICMetadataBlockReader*)Unsafe.AsPointer(ref this), nIndex, ppIMetadataReader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetEnumerator(Com.IEnumUnknown* ppIEnumMetadata) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICMetadataBlockReader*)Unsafe.AsPointer(ref this), ppIEnumMetadata); + } +} + +/// +/// IWICMetadataBlockWriter +[Guid("08fb9676-b444-41e8-8dbe-6a53a542bff1")] +[NativeTypeName("struct IWICMetadataBlockWriter : IWICMetadataBlockReader")] +[NativeInheritance("IWICMetadataBlockReader")] +public unsafe partial struct IWICMetadataBlockWriter +{ + public static ref readonly Guid IID_IWICMetadataBlockWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x76, 0x96, 0xFB, 0x08, + 0x44, 0xB4, + 0xE8, 0x41, + 0x8D, + 0xBE, + 0x6A, + 0x53, + 0xA5, + 0x42, + 0xBF, + 0xF1 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICMetadataBlockWriter)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetContainerFormat(Guid* pguidContainerFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICMetadataBlockWriter*)Unsafe.AsPointer(ref this), pguidContainerFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetCount(uint* pcCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICMetadataBlockWriter*)Unsafe.AsPointer(ref this), pcCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetReaderByIndex(uint nIndex, IWICMetadataReader* ppIMetadataReader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICMetadataBlockWriter*)Unsafe.AsPointer(ref this), nIndex, ppIMetadataReader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetEnumerator(Com.IEnumUnknown* ppIEnumMetadata) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICMetadataBlockWriter*)Unsafe.AsPointer(ref this), ppIEnumMetadata); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult InitializeFromBlockReader(IWICMetadataBlockReader* pIMDBlockReader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICMetadataBlockWriter*)Unsafe.AsPointer(ref this), pIMDBlockReader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetWriterByIndex(uint nIndex, IWICMetadataWriter* ppIMetadataWriter) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICMetadataBlockWriter*)Unsafe.AsPointer(ref this), nIndex, ppIMetadataWriter); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult AddWriter(IWICMetadataWriter* pIMetadataWriter) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IWICMetadataBlockWriter*)Unsafe.AsPointer(ref this), pIMetadataWriter); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult SetWriterByIndex(uint nIndex, IWICMetadataWriter* pIMetadataWriter) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IWICMetadataBlockWriter*)Unsafe.AsPointer(ref this), nIndex, pIMetadataWriter); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult RemoveWriterByIndex(uint nIndex) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IWICMetadataBlockWriter*)Unsafe.AsPointer(ref this), nIndex); + } +} + +/// +/// IWICMetadataReader +[Guid("9204fe99-d8fc-4fd5-a001-9536b067a899")] +[NativeTypeName("struct IWICMetadataReader : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IWICMetadataReader +{ + public static ref readonly Guid IID_IWICMetadataReader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x99, 0xFE, 0x04, 0x92, + 0xFC, 0xD8, + 0xD5, 0x4F, + 0xA0, + 0x01, + 0x95, + 0x36, + 0xB0, + 0x67, + 0xA8, + 0x99 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICMetadataReader)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetMetadataFormat(Guid* pguidMetadataFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICMetadataReader*)Unsafe.AsPointer(ref this), pguidMetadataFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetMetadataHandlerInfo(IWICMetadataHandlerInfo* ppIHandler) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICMetadataReader*)Unsafe.AsPointer(ref this), ppIHandler); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetCount(uint* pcCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICMetadataReader*)Unsafe.AsPointer(ref this), pcCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetValueByIndex(uint nIndex, Com.Variant* pvarSchema, Com.Variant* pvarId, Com.Variant* pvarValue) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICMetadataReader*)Unsafe.AsPointer(ref this), nIndex, pvarSchema, pvarId, pvarValue); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetValue(Com.Variant* pvarSchema, Com.Variant* pvarId, Com.Variant* pvarValue) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICMetadataReader*)Unsafe.AsPointer(ref this), pvarSchema, pvarId, pvarValue); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetEnumerator(IWICEnumMetadataItem* ppIEnumMetadata) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICMetadataReader*)Unsafe.AsPointer(ref this), ppIEnumMetadata); + } +} + +/// +/// IWICMetadataWriter +[Guid("f7836e16-3be0-470b-86bb-160d0aecd7de")] +[NativeTypeName("struct IWICMetadataWriter : IWICMetadataReader")] +[NativeInheritance("IWICMetadataReader")] +public unsafe partial struct IWICMetadataWriter +{ + public static ref readonly Guid IID_IWICMetadataWriter + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x16, 0x6E, 0x83, 0xF7, + 0xE0, 0x3B, + 0x0B, 0x47, + 0x86, + 0xBB, + 0x16, + 0x0D, + 0x0A, + 0xEC, + 0xD7, + 0xDE + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICMetadataWriter)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetMetadataFormat(Guid* pguidMetadataFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICMetadataWriter*)Unsafe.AsPointer(ref this), pguidMetadataFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetMetadataHandlerInfo(IWICMetadataHandlerInfo* ppIHandler) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICMetadataWriter*)Unsafe.AsPointer(ref this), ppIHandler); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetCount(uint* pcCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICMetadataWriter*)Unsafe.AsPointer(ref this), pcCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetValueByIndex(uint nIndex, Com.Variant* pvarSchema, Com.Variant* pvarId, Com.Variant* pvarValue) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICMetadataWriter*)Unsafe.AsPointer(ref this), nIndex, pvarSchema, pvarId, pvarValue); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetValue(Com.Variant* pvarSchema, Com.Variant* pvarId, Com.Variant* pvarValue) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICMetadataWriter*)Unsafe.AsPointer(ref this), pvarSchema, pvarId, pvarValue); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetEnumerator(IWICEnumMetadataItem* ppIEnumMetadata) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICMetadataWriter*)Unsafe.AsPointer(ref this), ppIEnumMetadata); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult SetValue(Com.Variant* pvarSchema, Com.Variant* pvarId, Com.Variant* pvarValue) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IWICMetadataWriter*)Unsafe.AsPointer(ref this), pvarSchema, pvarId, pvarValue); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult SetValueByIndex(uint nIndex, Com.Variant* pvarSchema, Com.Variant* pvarId, Com.Variant* pvarValue) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IWICMetadataWriter*)Unsafe.AsPointer(ref this), nIndex, pvarSchema, pvarId, pvarValue); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult RemoveValue(Com.Variant* pvarSchema, Com.Variant* pvarId) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IWICMetadataWriter*)Unsafe.AsPointer(ref this), pvarSchema, pvarId); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult RemoveValueByIndex(uint nIndex) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IWICMetadataWriter*)Unsafe.AsPointer(ref this), nIndex); + } +} + +/// +/// IWICStreamProvider +[Guid("449494bc-b468-4927-96d7-ba90d31ab505")] +[NativeTypeName("struct IWICStreamProvider : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IWICStreamProvider +{ + public static ref readonly Guid IID_IWICStreamProvider + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xBC, 0x94, 0x94, 0x44, + 0x68, 0xB4, + 0x27, 0x49, + 0x96, + 0xD7, + 0xBA, + 0x90, + 0xD3, + 0x1A, + 0xB5, + 0x05 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICStreamProvider)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetStream(Com.IStream* ppIStream) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICStreamProvider*)Unsafe.AsPointer(ref this), ppIStream); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPersistOptions(uint* pdwPersistOptions) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICStreamProvider*)Unsafe.AsPointer(ref this), pdwPersistOptions); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetPreferredVendorGUID(Guid* pguidPreferredVendor) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICStreamProvider*)Unsafe.AsPointer(ref this), pguidPreferredVendor); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult RefreshStream() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICStreamProvider*)Unsafe.AsPointer(ref this)); + } +} + +/// +/// IWICPersistStream +[Guid("00675040-6908-45f8-86a3-49c7dfd6d9ad")] +[NativeTypeName("struct IWICPersistStream : IPersistStream")] +[NativeInheritance("IPersistStream")] +public unsafe partial struct IWICPersistStream +{ + public static ref readonly Guid IID_IWICPersistStream + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x40, 0x50, 0x67, 0x00, + 0x08, 0x69, + 0xF8, 0x45, + 0x86, + 0xA3, + 0x49, + 0xC7, + 0xDF, + 0xD6, + 0xD9, + 0xAD + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICPersistStream)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult LoadEx(Com.IStream* pIStream, Guid* pguidPreferredVendor, uint dwPersistOptions) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IWICPersistStream*)Unsafe.AsPointer(ref this), pIStream, pguidPreferredVendor, dwPersistOptions); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + public HResult SaveEx(Com.IStream* pIStream, uint dwPersistOptions, Bool32 fClearDirty) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IWICPersistStream*)Unsafe.AsPointer(ref this), pIStream, dwPersistOptions, fClearDirty); + } +} + +/// +/// IWICMetadataHandlerInfo +[Guid("aba958bf-c672-44d1-8d61-ce6df2e682c2")] +[NativeTypeName("struct IWICMetadataHandlerInfo : IWICComponentInfo")] +[NativeInheritance("IWICComponentInfo")] +public unsafe partial struct IWICMetadataHandlerInfo +{ + public static ref readonly Guid IID_IWICMetadataHandlerInfo + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xBF, 0x58, 0xA9, 0xAB, + 0x72, 0xC6, + 0xD1, 0x44, + 0x8D, + 0x61, + 0xCE, + 0x6D, + 0xF2, + 0xE6, + 0x82, + 0xC2 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICMetadataHandlerInfo)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetComponentType(WICComponentType* pType) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICMetadataHandlerInfo*)Unsafe.AsPointer(ref this), pType); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetCLSID(Guid* pclsid) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICMetadataHandlerInfo*)Unsafe.AsPointer(ref this), pclsid); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetSigningStatus(uint* pStatus) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICMetadataHandlerInfo*)Unsafe.AsPointer(ref this), pStatus); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetAuthor(uint cchAuthor, ushort* wzAuthor, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICMetadataHandlerInfo*)Unsafe.AsPointer(ref this), cchAuthor, wzAuthor, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetVendorGUID(Guid* pguidVendor) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICMetadataHandlerInfo*)Unsafe.AsPointer(ref this), pguidVendor); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetVersion(uint cchVersion, ushort* wzVersion, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICMetadataHandlerInfo*)Unsafe.AsPointer(ref this), cchVersion, wzVersion, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetSpecVersion(uint cchSpecVersion, ushort* wzSpecVersion, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IWICMetadataHandlerInfo*)Unsafe.AsPointer(ref this), cchSpecVersion, wzSpecVersion, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetFriendlyName(uint cchFriendlyName, ushort* wzFriendlyName, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IWICMetadataHandlerInfo*)Unsafe.AsPointer(ref this), cchFriendlyName, wzFriendlyName, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetMetadataFormat(Guid* pguidMetadataFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IWICMetadataHandlerInfo*)Unsafe.AsPointer(ref this), pguidMetadataFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetContainerFormats(uint cContainerFormats, Guid* pguidContainerFormats, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IWICMetadataHandlerInfo*)Unsafe.AsPointer(ref this), cContainerFormats, pguidContainerFormats, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult GetDeviceManufacturer(uint cchDeviceManufacturer, ushort* wzDeviceManufacturer, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IWICMetadataHandlerInfo*)Unsafe.AsPointer(ref this), cchDeviceManufacturer, wzDeviceManufacturer, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult GetDeviceModels(uint cchDeviceModels, ushort* wzDeviceModels, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IWICMetadataHandlerInfo*)Unsafe.AsPointer(ref this), cchDeviceModels, wzDeviceModels, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult DoesRequireFullStream(Bool32* pfRequiresFullStream) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IWICMetadataHandlerInfo*)Unsafe.AsPointer(ref this), pfRequiresFullStream); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult DoesSupportPadding(Bool32* pfSupportsPadding) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IWICMetadataHandlerInfo*)Unsafe.AsPointer(ref this), pfSupportsPadding); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult DoesRequireFixedSize(Bool32* pfFixedSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IWICMetadataHandlerInfo*)Unsafe.AsPointer(ref this), pfFixedSize); + } +} + +/// +/// IWICMetadataReaderInfo +[Guid("eebf1f5b-07c1-4447-a3ab-22acaf78a804")] +[NativeTypeName("struct IWICMetadataReaderInfo : IWICMetadataHandlerInfo")] +[NativeInheritance("IWICMetadataHandlerInfo")] +public unsafe partial struct IWICMetadataReaderInfo +{ + public static ref readonly Guid IID_IWICMetadataReaderInfo + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x5B, 0x1F, 0xBF, 0xEE, + 0xC1, 0x07, + 0x47, 0x44, + 0xA3, + 0xAB, + 0x22, + 0xAC, + 0xAF, + 0x78, + 0xA8, + 0x04 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICMetadataReaderInfo)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetMetadataFormat(Guid* pguidMetadataFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICMetadataReaderInfo*)Unsafe.AsPointer(ref this), pguidMetadataFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetContainerFormats(uint cContainerFormats, Guid* pguidContainerFormats, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICMetadataReaderInfo*)Unsafe.AsPointer(ref this), cContainerFormats, pguidContainerFormats, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetDeviceManufacturer(uint cchDeviceManufacturer, ushort* wzDeviceManufacturer, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICMetadataReaderInfo*)Unsafe.AsPointer(ref this), cchDeviceManufacturer, wzDeviceManufacturer, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetDeviceModels(uint cchDeviceModels, ushort* wzDeviceModels, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICMetadataReaderInfo*)Unsafe.AsPointer(ref this), cchDeviceModels, wzDeviceModels, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult DoesRequireFullStream(Bool32* pfRequiresFullStream) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICMetadataReaderInfo*)Unsafe.AsPointer(ref this), pfRequiresFullStream); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult DoesSupportPadding(Bool32* pfSupportsPadding) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICMetadataReaderInfo*)Unsafe.AsPointer(ref this), pfSupportsPadding); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult DoesRequireFixedSize(Bool32* pfFixedSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IWICMetadataReaderInfo*)Unsafe.AsPointer(ref this), pfFixedSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetComponentType(WICComponentType* pType) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IWICMetadataReaderInfo*)Unsafe.AsPointer(ref this), pType); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetCLSID(Guid* pclsid) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IWICMetadataReaderInfo*)Unsafe.AsPointer(ref this), pclsid); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetSigningStatus(uint* pStatus) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IWICMetadataReaderInfo*)Unsafe.AsPointer(ref this), pStatus); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult GetAuthor(uint cchAuthor, ushort* wzAuthor, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IWICMetadataReaderInfo*)Unsafe.AsPointer(ref this), cchAuthor, wzAuthor, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult GetVendorGUID(Guid* pguidVendor) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IWICMetadataReaderInfo*)Unsafe.AsPointer(ref this), pguidVendor); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult GetVersion(uint cchVersion, ushort* wzVersion, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IWICMetadataReaderInfo*)Unsafe.AsPointer(ref this), cchVersion, wzVersion, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult GetSpecVersion(uint cchSpecVersion, ushort* wzSpecVersion, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IWICMetadataReaderInfo*)Unsafe.AsPointer(ref this), cchSpecVersion, wzSpecVersion, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult GetFriendlyName(uint cchFriendlyName, ushort* wzFriendlyName, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IWICMetadataReaderInfo*)Unsafe.AsPointer(ref this), cchFriendlyName, wzFriendlyName, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult GetPatterns(Guid* guidContainerFormat, uint cbSize, Wicmetadatapattern* pPattern, uint* pcCount, uint* pcbActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IWICMetadataReaderInfo*)Unsafe.AsPointer(ref this), guidContainerFormat, cbSize, pPattern, pcCount, pcbActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult MatchesPattern(Guid* guidContainerFormat, Com.IStream* pIStream, Bool32* pfMatches) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IWICMetadataReaderInfo*)Unsafe.AsPointer(ref this), guidContainerFormat, pIStream, pfMatches); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult CreateInstance(IWICMetadataReader* ppIReader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IWICMetadataReaderInfo*)Unsafe.AsPointer(ref this), ppIReader); + } +} + +/// +/// IWICMetadataWriterInfo +[Guid("b22e3fba-3925-4323-b5c1-9ebfc430f236")] +[NativeTypeName("struct IWICMetadataWriterInfo : IWICMetadataHandlerInfo")] +[NativeInheritance("IWICMetadataHandlerInfo")] +public unsafe partial struct IWICMetadataWriterInfo +{ + public static ref readonly Guid IID_IWICMetadataWriterInfo + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xBA, 0x3F, 0x2E, 0xB2, + 0x25, 0x39, + 0x23, 0x43, + 0xB5, + 0xC1, + 0x9E, + 0xBF, + 0xC4, + 0x30, + 0xF2, + 0x36 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICMetadataWriterInfo)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetMetadataFormat(Guid* pguidMetadataFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICMetadataWriterInfo*)Unsafe.AsPointer(ref this), pguidMetadataFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetContainerFormats(uint cContainerFormats, Guid* pguidContainerFormats, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICMetadataWriterInfo*)Unsafe.AsPointer(ref this), cContainerFormats, pguidContainerFormats, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetDeviceManufacturer(uint cchDeviceManufacturer, ushort* wzDeviceManufacturer, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICMetadataWriterInfo*)Unsafe.AsPointer(ref this), cchDeviceManufacturer, wzDeviceManufacturer, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetDeviceModels(uint cchDeviceModels, ushort* wzDeviceModels, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICMetadataWriterInfo*)Unsafe.AsPointer(ref this), cchDeviceModels, wzDeviceModels, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult DoesRequireFullStream(Bool32* pfRequiresFullStream) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICMetadataWriterInfo*)Unsafe.AsPointer(ref this), pfRequiresFullStream); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult DoesSupportPadding(Bool32* pfSupportsPadding) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICMetadataWriterInfo*)Unsafe.AsPointer(ref this), pfSupportsPadding); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult DoesRequireFixedSize(Bool32* pfFixedSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IWICMetadataWriterInfo*)Unsafe.AsPointer(ref this), pfFixedSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetComponentType(WICComponentType* pType) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IWICMetadataWriterInfo*)Unsafe.AsPointer(ref this), pType); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetCLSID(Guid* pclsid) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IWICMetadataWriterInfo*)Unsafe.AsPointer(ref this), pclsid); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetSigningStatus(uint* pStatus) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IWICMetadataWriterInfo*)Unsafe.AsPointer(ref this), pStatus); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult GetAuthor(uint cchAuthor, ushort* wzAuthor, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IWICMetadataWriterInfo*)Unsafe.AsPointer(ref this), cchAuthor, wzAuthor, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult GetVendorGUID(Guid* pguidVendor) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IWICMetadataWriterInfo*)Unsafe.AsPointer(ref this), pguidVendor); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult GetVersion(uint cchVersion, ushort* wzVersion, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IWICMetadataWriterInfo*)Unsafe.AsPointer(ref this), cchVersion, wzVersion, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult GetSpecVersion(uint cchSpecVersion, ushort* wzSpecVersion, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IWICMetadataWriterInfo*)Unsafe.AsPointer(ref this), cchSpecVersion, wzSpecVersion, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult GetFriendlyName(uint cchFriendlyName, ushort* wzFriendlyName, uint* pcchActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IWICMetadataWriterInfo*)Unsafe.AsPointer(ref this), cchFriendlyName, wzFriendlyName, pcchActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult GetHeader(Guid* guidContainerFormat, uint cbSize, Wicmetadataheader* pHeader, uint* pcbActual) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IWICMetadataWriterInfo*)Unsafe.AsPointer(ref this), guidContainerFormat, cbSize, pHeader, pcbActual); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult CreateInstance(IWICMetadataWriter* ppIWriter) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IWICMetadataWriterInfo*)Unsafe.AsPointer(ref this), ppIWriter); + } +} + +/// +/// IWICComponentFactory +[Guid("412d0c3a-9650-44fa-af5b-dd2a06c8e8fb")] +[NativeTypeName("struct IWICComponentFactory : IWICImagingFactory")] +[NativeInheritance("IWICImagingFactory")] +public unsafe partial struct IWICComponentFactory +{ + public static ref readonly Guid IID_IWICComponentFactory + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x3A, 0x0C, 0x2D, 0x41, + 0x50, 0x96, + 0xFA, 0x44, + 0xAF, + 0x5B, + 0xDD, + 0x2A, + 0x06, + 0xC8, + 0xE8, + 0xFB + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IWICComponentFactory)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult CreateDecoderFromFilename(ushort* wzFilename, Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CreateDecoderFromStream(Com.IStream* pIStream, Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), pIStream, pguidVendor, metadataOptions, ppIDecoder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult CreateDecoderFromFileHandle(nuint hFile, Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), hFile, pguidVendor, metadataOptions, ppIDecoder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CreateComponentInfo(Guid* clsidComponent, IWICComponentInfo* ppIInfo) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), clsidComponent, ppIInfo); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CreateDecoder(Guid* guidContainerFormat, Guid* pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), guidContainerFormat, pguidVendor, ppIDecoder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult CreateEncoder(Guid* guidContainerFormat, Guid* pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), guidContainerFormat, pguidVendor, ppIEncoder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult CreatePalette(IWICPalette* ppIPalette) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), ppIPalette); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult CreateFormatConverter(IWICFormatConverter* ppIFormatConverter) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), ppIFormatConverter); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult CreateBitmapScaler(IWICBitmapScaler* ppIBitmapScaler) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), ppIBitmapScaler); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult CreateBitmapClipper(IWICBitmapClipper* ppIBitmapClipper) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), ppIBitmapClipper); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult CreateBitmapFlipRotator(IWICBitmapFlipRotator* ppIBitmapFlipRotator) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), ppIBitmapFlipRotator); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult CreateStream(IWICStream* ppIWICStream) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), ppIWICStream); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult CreateColorContext(IWICColorContext* ppIWICColorContext) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), ppIWICColorContext); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult CreateColorTransformer(IWICColorTransform* ppIWICColorTransform) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), ppIWICColorTransform); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap* ppIBitmap) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), uiWidth, uiHeight, pixelFormat, option, ppIBitmap); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult CreateBitmapFromSource(IWICBitmapSource* pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap* ppIBitmap) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), pIBitmapSource, option, ppIBitmap); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult CreateBitmapFromSourceRect(IWICBitmapSource* pIBitmapSource, uint x, uint y, uint width, uint height, IWICBitmap* ppIBitmap) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), pIBitmapSource, x, y, width, height, ppIBitmap); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, IWICBitmap* ppIBitmap) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBuffer, ppIBitmap); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult CreateBitmapFromHBITMAP(IntPtr hBitmap, IntPtr hPalette, WICBitmapAlphaChannelOption options, IWICBitmap* ppIBitmap) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), hBitmap, hPalette, options, ppIBitmap); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult CreateBitmapFromHICON(IntPtr hIcon, IWICBitmap* ppIBitmap) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), hIcon, ppIBitmap); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult CreateComponentEnumerator(uint componentTypes, uint options, Com.IEnumUnknown* ppIEnumUnknown) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), componentTypes, options, ppIEnumUnknown); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult CreateFastMetadataEncoderFromDecoder(IWICBitmapDecoder* pIDecoder, IWICFastMetadataEncoder* ppIFastEncoder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), pIDecoder, ppIFastEncoder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult CreateFastMetadataEncoderFromFrameDecode(IWICBitmapFrameDecode* pIFrameDecoder, IWICFastMetadataEncoder* ppIFastEncoder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), pIFrameDecoder, ppIFastEncoder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public HResult CreateQueryWriter(Guid* guidMetadataFormat, Guid* pguidVendor, IWICMetadataQueryWriter* ppIQueryWriter) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), guidMetadataFormat, pguidVendor, ppIQueryWriter); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult CreateQueryWriterFromReader(IWICMetadataQueryReader* pIQueryReader, Guid* pguidVendor, IWICMetadataQueryWriter* ppIQueryWriter) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), pIQueryReader, pguidVendor, ppIQueryWriter); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult CreateMetadataReader(Guid* guidMetadataFormat, Guid* pguidVendor, uint dwOptions, Com.IStream* pIStream, IWICMetadataReader* ppIReader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), guidMetadataFormat, pguidVendor, dwOptions, pIStream, ppIReader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult CreateMetadataReaderFromContainer(Guid* guidContainerFormat, Guid* pguidVendor, uint dwOptions, Com.IStream* pIStream, IWICMetadataReader* ppIReader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), guidContainerFormat, pguidVendor, dwOptions, pIStream, ppIReader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult CreateMetadataWriter(Guid* guidMetadataFormat, Guid* pguidVendor, uint dwMetadataOptions, IWICMetadataWriter* ppIWriter) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), guidMetadataFormat, pguidVendor, dwMetadataOptions, ppIWriter); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public HResult CreateMetadataWriterFromReader(IWICMetadataReader* pIReader, Guid* pguidVendor, IWICMetadataWriter* ppIWriter) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), pIReader, pguidVendor, ppIWriter); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult CreateQueryReaderFromBlockReader(IWICMetadataBlockReader* pIBlockReader, IWICMetadataQueryReader* ppIQueryReader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), pIBlockReader, ppIQueryReader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public HResult CreateQueryWriterFromBlockWriter(IWICMetadataBlockWriter* pIBlockWriter, IWICMetadataQueryWriter* ppIQueryWriter) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), pIBlockWriter, ppIQueryWriter); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public HResult CreateEncoderPropertyBag(Com.PropertyBagMetadata** ppropOptions, uint cCount, Com.IPropertyBag2* ppIPropertyBag) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((IWICComponentFactory*)Unsafe.AsPointer(ref this), ppropOptions, cCount, ppIPropertyBag); + } +} + +#endregion Com Types + +#region Functions +public static unsafe partial class Apis +{ + [DllImport("WindowsCodecs", ExactSpelling = true)] + public static extern HResult WICConvertBitmapSource(Guid* dstFormat, IWICBitmapSource* pISrc, IWICBitmapSource* ppIDst); + + [DllImport("WindowsCodecs", ExactSpelling = true)] + public static extern HResult WICCreateBitmapFromSection(uint width, uint height, Guid* pixelFormat, IntPtr hSection, uint stride, uint offset, IWICBitmap* ppIBitmap); + + [DllImport("WindowsCodecs", ExactSpelling = true)] + public static extern HResult WICCreateBitmapFromSectionEx(uint width, uint height, Guid* pixelFormat, IntPtr hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, IWICBitmap* ppIBitmap); + + [DllImport("WindowsCodecs", ExactSpelling = true)] + public static extern HResult WICMapGuidToShortName(Guid* guid, uint cchName, ushort* wzName, uint* pcchActual); + + [DllImport("WindowsCodecs", ExactSpelling = true)] + public static extern HResult WICMapShortNameToGuid(ushort* wzName, Guid* pguid); + + [DllImport("WindowsCodecs", ExactSpelling = true)] + public static extern HResult WICMapSchemaToName(Guid* guidMetadataFormat, ushort* pwzSchema, uint cchName, ushort* wzName, uint* pcchActual); + + [DllImport("WindowsCodecs", ExactSpelling = true)] + public static extern HResult WICMatchMetadataContent(Guid* guidContainerFormat, Guid* pguidVendor, Com.IStream* pIStream, Guid* pguidMetadataFormat); + + [DllImport("WindowsCodecs", ExactSpelling = true)] + public static extern HResult WICSerializeMetadataContent(Guid* guidContainerFormat, IWICMetadataWriter* pIWriter, uint dwPersistOptions, Com.IStream* pIStream); + + [DllImport("WindowsCodecs", ExactSpelling = true)] + public static extern HResult WICGetMetadataContentSize(Guid* guidContainerFormat, IWICMetadataWriter* pIWriter, ULargeInterger* pcbSize); + +} +#endregion Functions diff --git a/src/Vortice.Win32/Generated/Imaging.xml b/src/Vortice.Win32/Generated/Imaging.xml new file mode 100644 index 0000000..f474f7c --- /dev/null +++ b/src/Vortice.Win32/Generated/Imaging.xml @@ -0,0 +1,4482 @@ + + + + + Creates a new instance of a query writer. + Microsoft Docs: + The GUID for the desired metadata format. + The GUID for the preferred metadata writer vendor. Use NULL if no preferred vendor. + When this method returns, contains a pointer to a new IWICMetadataQueryWriter. + + + + + Creates a new instance of the fast metadata encoder based on the given image frame. + Microsoft Docs: + The IWICBitmapFrameDecode to create the IWICFastMetadataEncoder from. + When this method returns, contains a pointer to a new fast metadata encoder. + + + + + Retrieves the image's container format. + Microsoft Docs: + A pointer that receives the image's container format GUID. + + + + + Copies pixels into the destination planes. Configured by the supplied input parameters. + Microsoft Docs: + The source rectangle of pixels to copy. + The width to scale the source bitmap. This parameter must be equal to a value obtainable through IWICPlanarBitmapSourceTransform:: DoesSupportTransform. + The height to scale the source bitmap. This parameter must be equal to a value obtainable through IWICPlanarBitmapSourceTransform:: DoesSupportTransform. + The desired rotation or flip to perform prior to the pixel copy. A rotate can be combined with a flip horizontal or a flip vertical, see WICBitmapTransformOptions. + Used to specify additional configuration options for the transform. See WICPlanarOptions for more detail. + +WIC JPEG Decoder: +WICPlanarOptionsPreserveSubsampling can be specified to retain the subsampling ratios when downscaling. By default, the JPEG decoder attempts to preserve quality by downscaling only the Y plane in some cases, changing the image to 4:4:4 chroma subsampling. + Specifies the pixel format and output buffer for each component plane. The number of planes and pixel format of each plane must match values obtainable through IWICPlanarBitmapSourceTransform::DoesSupportTransform. + The number of component planes specified by the pDstPlanes parameter. + + + + + Writes metadata into a given stream. + Microsoft Docs: + The container format GUID. + The metadata writer to write metadata to the stream. + The WICPersistOptions options to use when writing the metadata. + A pointer to the stream in which to write the metadata. + + + + + Exposes methods that provide access to all of the codec's top level metadata blocks. + Microsoft Docs: + + + + + Retrieves the component's WICComponentType. + Microsoft Docs: + A pointer that receives the WICComponentType. + + + + + Specifies the JPEG YCrCB subsampling options. + Microsoft Docs: + + + + The default subsampling option. + + + Subsampling option that uses both horizontal and vertical decimation. + + + Subsampling option that uses horizontal decimation . + + + Subsampling option that uses no decimation. + + + Subsampling option that uses 2x vertical downsampling only. This option is only available in Windows 8.1 and later. + + + + Retrieves a copy of the DC Huffman table for the specified scan and table. + Microsoft Docs: + The zero-based index of the scan for which data is retrieved. + The index of the DC Huffman table to retrieve. + A pointer that receives the table data. This parameter must not be NULL. + + + + + Sets the physical resolution of the output image. + Microsoft Docs: + The horizontal resolution value. + The vertical resolution value. + + + + + Exposes methods for writing compressed JPEG scan data directly to the WIC encoder's output stream. Also provides access to the Huffman and quantization tables. + Microsoft Docs: + + + + + Specifies the rotation capabilities of the codec. + Microsoft Docs: + + + + Rotation is not supported. + + + Set operations for rotation is not supported. + + + 90 degree rotations are supported. + + + All rotation angles are supported. + + + + Retrieves the container GUID associated with the codec. + Microsoft Docs: + Receives the container GUID. + + + + + Represents a JPEG frame header. + Microsoft Docs: + + + + The width of the JPEG frame. + + + The height of the JPEG frame. + + + The transfer matrix of the JPEG frame. + + + The scan type of the JPEG frame. + + + The number of components in the frame. + + + The component identifiers. + + + The sample factors. Use one of the following constants, described in IWICJpegFrameDecode Constants. + +
    +
  • WIC_JPEG_SAMPLE_FACTORS_ONE
    • +
  • WIC_JPEG_SAMPLE_FACTORS_THREE_420
    • +
  • WIC_JPEG_SAMPLE_FACTORS_THREE_422
    • +
  • WIC_JPEG_SAMPLE_FACTORS_THREE_440
    • +
  • WIC_JPEG_SAMPLE_FACTORS_THREE_444
    • +
 + + + The format of the quantization table indices. Use one of the following constants, described in IWICJpegFrameDecode Constants. + +
    +
  • WIC_JPEG_QUANTIZATION_BASELINE_ONE
    • +
  • WIC_JPEG_QUANTIZATION_BASELINE_THREE
    • +
 + + + + Sets the global preview for the image. + Microsoft Docs: + The IWICBitmapSource to use as the global preview. + + + + + Creates a new instance of the IWICBitmapEncoder class. + Microsoft Docs: + The GUID for the desired container format. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ValueMeaning
+
+
GUID_ContainerFormatBmp
+
+		 +The BMP container format GUID. + +
+
+
GUID_ContainerFormatPng
+
+		 +The PNG container format GUID. + +
+
+
GUID_ContainerFormatIco
+
+		 +The ICO container format GUID. + +
+
+
GUID_ContainerFormatJpeg
+
+		 +The JPEG container format GUID. + +
+
+
GUID_ContainerFormatTiff
+
+		 +The TIFF container format GUID. + +
+
+
GUID_ContainerFormatGif
+
+		 +The GIF container format GUID. + +
+
+
GUID_ContainerFormatWmp
+
+		 +The HD Photo container format GUID. + +
+ The GUID for the preferred encoder vendor. + + + + + + + + + + + + + + + + + + +
ValueMeaning
+
+
NULL
+
+		 +No preferred codec vendor. + +
+
+
GUID_VendorMicrosoft
+
+		 +Prefer to use Microsoft encoder. + +
+
+
GUID_VendorMicrosoftBuiltIn
+
+		 +Prefer to use the native Microsoft encoder. + +
+ A pointer that receives a pointer to a new IWICBitmapEncoder. + + + + + Exposes methods for setting or removing metadata blocks and items to an encoder or its image frames using a metadata query expression. + Microsoft Docs: + + + + + Gets the tint value of the raw image. + Microsoft Docs: + A pointer that receives the tint value of the raw image. The default value is the "as-shot" setting if it exists or 0.0. The value range for sharpness is -1.0 through +1.0. The -1.0 lower limit represents a full green bias to the image, while the 1.0 upper limit represents a full magenta bias. + + + + + Creates a new IWICFormatConverter instance. + Microsoft Docs: + A pointer that receives a new IWICFormatConverter instance. + + + + + Defines raw codec capabilites. + Microsoft Docs: + + + + Size of the WICRawCapabilitiesInfo structure. + + + The codec's major version. + + + The codec's minor version. + + + The WICRawCapabilities of exposure compensation support. + + + The WICRawCapabilities of contrast support. + + + The WICRawCapabilities of RGB white point support. + + + The WICRawCapabilities of WICNamedWhitePoint support. + + + The WICNamedWhitePoint mask. + + + The WICRawCapabilities of kelvin white point support. + + + The WICRawCapabilities of gamma support. + + + The WICRawCapabilities of tint support. + + + The WICRawCapabilities of saturation support. + + + The WICRawCapabilities of sharpness support. + + + The WICRawCapabilities of noise reduction support. + + + The WICRawCapabilities of destination color profile support. + + + The WICRawCapabilities of tone curve support. + + + The WICRawRotationCapabilities of rotation support. + + + The WICRawCapabilities of WICRawRenderMode support. + + + + Creates a new instance of an IWICBitmapScaler. + Microsoft Docs: + A pointer that receives a pointer to a new IWICBitmapScaler. + + + + + Retrieves the device models that support the metadata handler. + Microsoft Docs: + The length of the wzDeviceModels buffer. + Pointer that receives the device models supported by the metadata handler. + The actual length needed to retrieve the device models. + + + + + Specifies the animation frame properties of a WebP image. + Microsoft Docs: + + + + The time to wait before displaying the next frame, in milliseconds. + + + + Copies scan-line data from a caller-supplied buffer to the IWICBitmapFrameEncode object. + Microsoft Docs: + The number of lines to encode. + The stride of the image pixels. + The size of the pixel buffer. + A pointer to the pixel buffer. + + + + + Retrieves the component's specification version. + Microsoft Docs: + The size of the wzSpecVersion buffer. + When this method returns, contain a culture invarient string of the component's specification version. The version form is NN.NN.NN.NN. + A pointer that receives the actual length of the component's specification version. The specification version is optional; if a value is not specified by the component, the length returned is 0. + + + + + Retrieves a metadata query writer for the encoder. + Microsoft Docs: + When this method returns, contains a pointer to the encoder's metadata query writer. + + + + + Creates a new instance of the IWICBitmapDecoder class based on the given file. + Microsoft Docs: + A pointer to a null-terminated string that specifies the name of an object to create or open. + The GUID for the preferred decoder vendor. Use NULL if no preferred vendor. + The access to the object, which can be read, write, or both. + + + + + + + + + + + + + + + +
ValueMeaning
+
+
GENERIC_READ
+
+		 +Read access. + +
+
+
GENERIC_WRITE
+
+		 +Write access. + +
+  + +For more information, see Generic Access Rights. + The WICDecodeOptions to use when creating the decoder. + A pointer that receives a pointer to the new IWICBitmapDecoder. + + + + + Exposes methods for obtaining information about and controlling progressive decoding. + Microsoft Docs: + + + + + Retrieves the color manangement version number the codec supports. + Microsoft Docs: + The size of the version buffer. Use 0 on first call to determine needed buffer size. + Receives the color management version number. Use NULL on first call to determine needed buffer size. + The actual buffer size needed to retrieve the full color management version number. + + + + + Allows planar component image pixels to be written to an encoder. + Microsoft Docs: + + + + + Specifies the animation properties of a WebP image. + Microsoft Docs: + + + + The number of times the animation loops. A value of 0 indicates that the animation will loop infinitely. + + + + Returns a IWICBitmapSource that is backed by the pixels of a Windows Graphics Device Interface (GDI) section handle. + Microsoft Docs: + The width of the bitmap pixels. + The height of the bitmap pixels. + The pixel format of the bitmap. + The section handle. This is a file mapping object handle returned by the CreateFileMapping function. + The byte count of each scanline. + The offset into the section. + A pointer that receives the bitmap. + + + + + Specifies the Portable Network Graphics (PNG) background (bKGD) chunk metadata properties. + Microsoft Docs: + + + + Indicates the background color. There are three possible types, depending on the image's pixel format. + + + + Exposes methods that provide basic information about the registered metadata handler. + Microsoft Docs: + + + + + Specifies the Portable Network Graphics (PNG) gAMA chunk metadata properties. + Microsoft Docs: + + + + [VT_UI4] Indicates the gamma value. + + + + Specifies the application extension metadata properties for a Graphics Interchange Format (GIF) image. + Microsoft Docs: + + + + [VT_UI1 | VT_VECTOR] Indicates a string that identifies the application. + + + [VT_UI1 \| VT_VECTOR] Indicates data that is exposed by the application. + + + + Exposes methods that produce a clipped version of the input bitmap for a specified rectangular region of interest. + Microsoft Docs: + + + + + Exposes methods that provide information about a pixel format converter. + Microsoft Docs: + + + + + Retrieves information about which capabilities are supported for a raw image. + Microsoft Docs: + A pointer that receives WICRawCapabilitiesInfo that provides the capabilities supported by the raw image. + + + + + Represents an IWICBitmapSource that converts the image data from one pixel format to another, handling dithering and halftoning to indexed formats, palette translation and alpha thresholding. + Microsoft Docs: + + + + + Retrieves the current path relative to the root metadata block. + Microsoft Docs: + The length of the wzNamespace buffer. + Pointer that receives the current namespace location. + The actual buffer length that was needed to retrieve the current namespace location. + + + + + Gets the pixel format GUID. + Microsoft Docs: + Pointer that receives the pixel format GUID. + + + + + Skips to given number of objects. + Microsoft Docs: + The number of objects to skip. + + + + + Sets the metadata item to the specified index. + Microsoft Docs: + The index to place the metadata item. + Pointer to the schema property of the metadata item. + Pointer to the id property of the metadata item. + Pointer to the metadata value to set at the given index. + + + + + Retrieves a value indicating whether the codec supports lossless formats. + Microsoft Docs: + Receives TRUE if the codec supports lossless formats; otherwise, FALSE. + + + + + Retrieves a comma delimited sequence of mime types associated with the codec. + Microsoft Docs: + The size of the mime types buffer. Use 0 on first call to determine needed buffer size. + Receives the mime types associated with the codec. Use NULL on first call to determine needed buffer size. + The actual buffer size needed to retrieve all mime types associated with the codec. + + + + + Creates a new instance of the IWICColorContext class. + Microsoft Docs: + A pointer that receives a pointer to a new IWICColorContext. + + + + + Initialize the palette based on a given palette. + Microsoft Docs: + Pointer to the source palette. + + + + + Specifies the render intent of the next CopyPixels call. + Microsoft Docs: + + + + Use speed priority mode. + + + Use normal priority mode. Balance of speed and quality. + + + Use best quality mode. + + + + Retrieves the encoder's container format. + Microsoft Docs: + A pointer that receives the encoder's container format GUID. + + + + + Initializes the bitmap scaler with the provided parameters. + Microsoft Docs: + The input bitmap source. + The destination width. + The desination height. + The WICBitmapInterpolationMode to use when scaling. + + + + + Determines if the source pixel format can be converted to the destination pixel format. + Microsoft Docs: + The source pixel format. + The destionation pixel format. + A pointer that receives a value indicating whether the source pixel format can be converted to the destination pixel format. + + + + + Encodes ID2D1Image interfaces to an IWICBitmapEncoder. + Microsoft Docs: + + + + + Provides access to a single frame of DDS image data in its native DXGI_FORMAT form, as well as information about the image data. + Microsoft Docs: + + + + + Exposes methods that provide access to underlining metadata content. This interface is implemented by independent software vendors (ISVs) to create new metadata readers. + Microsoft Docs: + + + + + Gets an enumerator of all metadata items at the current relative location within the metadata hierarchy. + Microsoft Docs: + A pointer to a variable that receives a pointer to the IEnumString interface for the enumerator that contains query strings that can be used in the current IWICMetadataQueryReader. + + + + + Retrieves the Exchangeable Image File (EXIF) color space color context. + Microsoft Docs: + A pointer that receives the EXIF color space color context. + + + + + + + + + + + + + + + + + + +
ValueMeaning
+
+
1
+
+		 +A sRGB color space. + +
+
+
2
+
+		 +An Adobe RGB color space. + +
+
+
3 through 65534
+
+		 +Unused. + +
+ + + + + Sets the current WICRawRenderMode. + Microsoft Docs: + The render mode to use. + + + + + Sets the desired gamma value. + Microsoft Docs: + The desired gamma value. + + + + + Exposes methods used to create components for the Windows Imaging Component (WIC) such as decoders, encoders and pixel format converters. + Microsoft Docs: + + + + + Exposes methods that provide basic information about the registered metadata writer. + Microsoft Docs: + + + + + Retrieves the metadata query reader from the decoder. + Microsoft Docs: + Receives a pointer to the decoder's IWICMetadataQueryReader. + + + + + Creates a IWICMetadataQueryReader from the given IWICMetadataBlockReader. + Microsoft Docs: + Pointer to the block reader to base the query reader on. + A pointer that receives a pointer to the new metadata query reader. + + + + + Writes lines from the source planes to the encoded format. + Microsoft Docs: + Specifies an array of IWICBitmapSource that represent image planes. + The number of component planes specified by the planes parameter. + The source rectangle of pixels to encode from the IWICBitmapSource planes. Null indicates the entire source. The source rect width must match the width set through SetSize. Repeated WriteSource calls can be made as long as the total accumulated source rect height is the same as set through SetSize. + + + + + Gets the number of levels of progressive decoding supported by the CODEC. + Microsoft Docs: + Indicates the number of levels supported by the CODEC. + + + + + Specifies the type of palette used for an indexed image format. + Microsoft Docs: + + + + An arbitrary custom palette provided by caller. + + + An optimal palette generated using a median-cut algorithm. Derived from the colors in an image. + + + A black and white palette. + + + A palette that has its 8-color on-off primaries and the 16 system colors added. With duplicates removed, 16 colors are available. + + + A palette that has 3 intensity levels of each primary: 27-color on-off primaries and the 16 system colors added. With duplicates removed, 35 colors are available. + + + A palette that has 4 intensity levels of each primary: 64-color on-off primaries and the 16 system colors added. With duplicates removed, 72 colors are available. + + + A palette that has 5 intensity levels of each primary: 125-color on-off primaries and the 16 system colors added. With duplicates removed, 133 colors are available. + + + A palette that has 6 intensity levels of each primary: 216-color on-off primaries and the 16 system colors added. With duplicates removed, 224 colors are available. This is the same as WICBitmapPaletteFixedHalftoneWeb. + + + A palette that has 6 intensity levels of each primary: 216-color on-off primaries and the 16 system colors added. With duplicates removed, 224 colors are available. This is the same as WICBitmapPaletteTypeFixedHalftone216. + + + A palette that has its 252-color on-off primaries and the 16 system colors added. With duplicates removed, 256 colors are available. + + + A palette that has its 256-color on-off primaries and the 16 system colors added. With duplicates removed, 256 colors are available. + + + A palette that has 4 shades of gray. + + + A palette that has 16 shades of gray. + + + A palette that has 256 shades of gray. + + + + Initializes the bitmap flip rotator with the provided parameters. + Microsoft Docs: + The input bitmap source. + The WICBitmapTransformOptions to flip or rotate the image. + + + + + Creates a new instance of a query writer based on the given query reader. The query writer will be pre-populated with metadata from the query reader. + Microsoft Docs: + The IWICMetadataQueryReader to create the IWICMetadataQueryWriter from. + The GUID for the preferred metadata writer vendor. Use NULL if no preferred vendor. + When this method returns, contains a pointer to a new metadata writer. + + + + + Specifies metadata creation options. + Microsoft Docs: + + + + The default metadata creation options. The default value is WICMetadataCreationAllowUnknown. + + + Allow unknown metadata creation. + + + Fail on unknown metadata creation. + + + The WICMetadataCreationOptions mask. + + + + Determines if the handler requires a full stream. + Microsoft Docs: + Pointer that receives TRUE if a full stream is required; otherwise, FALSE. + + + + + Creates a new instance of the fast metadata encoder based on the given IWICBitmapDecoder. + Microsoft Docs: + The decoder to create the fast metadata encoder from. + When this method returns, contains a pointer to the new IWICFastMetadataEncoder. + + + + + Defines methods for decoding individual image frames of an encoded file. + Microsoft Docs: + + + + + Sets the saturation value of the raw image. + Microsoft Docs: + The saturation value of the raw image. The value range for saturation is 0.0 through 1.0. A value of 0.0 represents an image with a fully de-saturated image, while a value of 1.0 represents the highest amount of saturation that can be applied. + + + + + Gets the metadata handler info associated with the reader. + Microsoft Docs: + Pointer that receives a pointer to the IWICMetadataHandlerInfo. + + + + + Provides access to the stride value for the memory. + Microsoft Docs: + + + + + + Allows a format converter to be initialized with a planar source. + Microsoft Docs: + + + + + Sets the named white point of the raw file. + Microsoft Docs: + A bitwise combination of the enumeration values. + + + + + Exposes methods that provide information about an encoder. + Microsoft Docs: + + + + + Retrieves a metadata query writer for fast metadata encoding. + Microsoft Docs: + When this method returns, contains a pointer to the fast metadata encoder's metadata query writer. + + + + + Initializes the encoder with an IStream which tells the encoder where to encode the bits. + Microsoft Docs: + The output stream. + The WICBitmapEncoderCacheOption used on initialization. + + + + + Specifies the capability support of a raw image. + Microsoft Docs: + + + + The capability is not supported. + + + The capability supports only get operations. + + + The capability supports get and set operations. + + + + Specifies the comment extension metadata properties for a Graphics Interchange Format (GIF) image. + Microsoft Docs: + + + + [VT_LPSTR] Indicates the comment text. + + + + Represents a resized version of the input bitmap using a resampling or filtering algorithm. + Microsoft Docs: + + + + + Determines if a stream contains a metadata item pattern. + Microsoft Docs: + The container format of the metadata item. + The stream to search for the metadata pattern. + Pointer that receives TRUE if the stream contains the pattern; otherwise, FALSE. + + + + + Initializes the color context using an Exchangeable Image File (EXIF) color space. + Microsoft Docs: + The value of the EXIF color space. + + + + + + + + + + + + + + +
ValueMeaning
+
+
1
+
+		 +A sRGB color space. + +
+
+
2
+
+		 +An Adobe RGB color space. + +
+ + + + + Indicates whether the palette contains an entry that is non-opaque (that is, an entry with an alpha that is less than 1). + Microsoft Docs: + Pointer that receives TRUE if the palette contains a transparent color; otherwise, FALSE. + + + + + Requests pixel data as it is natively stored within the DDS file. + Microsoft Docs: + The rectangle to copy from the source. A NULL value specifies the entire texture. + +If the texture uses a block-compressed DXGI_FORMAT, all values of the rectangle are expressed in number of blocks, not pixels. + The stride, in bytes, of the destination buffer. This represents the number of bytes from the buffer pointer to the next row of data. If the texture uses a block-compressed DXGI_FORMAT, a "row of data" is defined as a row of blocks which contains multiple pixel scanlines. + The size, in bytes, of the destination buffer. + A pointer to the destination buffer. + + + + + Sets the tone curve for the raw image. + Microsoft Docs: + The size of the pToneCurve structure. + The desired tone curve. + + + + + Creates a IWICMetadataQueryWriter from the given IWICMetadataBlockWriter. + Microsoft Docs: + Pointer to the metadata block reader to base the metadata query writer on. + A pointer that receives a pointer to the new metadata query writer. + + + + + Retrieves a list of GUIDs that signify which pixel formats the converter supports. + Microsoft Docs: + The size of the pPixelFormatGUIDs array. + Pointer to a GUID array that receives the pixel formats the converter supports. + The actual array size needed to retrieve all pixel formats supported by the converter. + + + + + Represents a metadata pattern. + Microsoft Docs: + + + + The position of the pattern. + + + The length of the pattern. + + + Pointer to the pattern. + + + Pointer to the pattern mask. + + + The offset location of the pattern. + + + + Exposes methods that represent a decoder. + Microsoft Docs: + + + + + Gets the metadata patterns associated with the metadata reader. + Microsoft Docs: + The cointainer format GUID. + The size, in bytes, of the pPattern buffer. + Pointer that receives the metadata patterns. + Pointer that receives the number of metadata patterns. + Pointer that receives the size, in bytes, needed to obtain the metadata patterns. + + + + + Specifies the Portable Network Graphics (PNG) cHRM chunk metadata properties for CIE XYZ chromaticity. + Microsoft Docs: + + + + [VT_UI4] Indicates the whitepoint x value ratio. + + + [VT_UI4] Indicates the whitepoint y value ratio. + + + [VT_UI4] Indicates the red x value ratio. + + + [VT_UI4] Indicates the red y value ratio. + + + [VT_UI4] Indicates the green x value ratio. + + + [VT_UI4] Indicates the green y value ratio. + + + [VT_UI4] Indicates the blue x value ratio. + + + [VT_UI4] Indicates the blue y value ratio. + + + + IWICProgressCallback interface is documented only for compliance; its use is not recommended and may be altered or unavailable in the future. Instead, and use RegisterProgressNotification. + Microsoft Docs: + + + + + Gets the bits per pixel (BPP) of the pixel format. + Microsoft Docs: + Pointer that receives the BPP of the pixel format. + + + + + Returns a IWICBitmapSource that is backed by the pixels of a Windows Graphics Device Interface (GDI) section handle. + Microsoft Docs: + The width of the bitmap pixels. + The height of the bitmap pixels. + The pixel format of the bitmap. + The section handle. This is a file mapping object handle returned by the CreateFileMapping function. + The byte count of each scanline. + The offset into the section. + The desired access level. + A pointer that receives the bitmap. + + + + + Initializes a stream from another stream. Access rights are inherited from the underlying stream. + Microsoft Docs: + The initialize stream. + + + + + Creates an instance of an IWICMetadataWriter. + Microsoft Docs: + Pointer that receives a pointer to a metadata writer. + + + + + Gets the metadata query readers container format. + Microsoft Docs: + Pointer that receives the cointainer format GUID. + + + + + Gets the number of channels the pixel format contains. + Microsoft Docs: + Pointer that receives the channel count. + + + + + Retrieves the color context type. + Microsoft Docs: + A pointer that receives the WICColorContextType of the color context. + + + + + Gets the preferred vendor GUID. + Microsoft Docs: + Pointer that receives the preferred vendor GUID. + + + + + Creates a new instance of the IWICFormatConverter class. + Microsoft Docs: + A pointer that receives a pointer to a new IWICFormatConverter. + + + + + Gets the pixel format of for the locked area of pixels. This can be used to compute the number of bytes-per-pixel in the locked area. + Microsoft Docs: + A pointer that receives the pixel format GUID of the locked area. + + + + + Creates a IWICBitmap from a IWICBitmapSource. + Microsoft Docs: + The IWICBitmapSource to create the bitmap from. + The cache options of the new bitmap. This can be one of the values in the WICBitmapCreateCacheOption enumeration. + + + + + + + + + + + + + + + + + + +
ValueMeaning
+
WICBitmapNoCache
+
+		 +Do not create a system memory copy. Share the bitmap with the source. + + +
+
WICBitmapCacheOnDemand
+
+		 +Create a system memory copy when the bitmap is first used. + + +
+
WICBitmapCacheOnLoad
+
+		 +Create a system memory copy when this method is called. + + +
+ A pointer that receives a pointer to the new bitmap. + + + + + Creates an IWICBitmap from an icon handle. + Microsoft Docs: + The icon handle to create the new bitmap from. + A pointer that receives a pointer to the new bitmap. + + + + + Specifies the HDR properties of a High Efficiency Image Format (HEIF) image. + Microsoft Docs: + + + + [VT_UI2] Specifies the maximum luminance level of the content in Nits. + + + [VT_UI2] Specifies the maximum average per-frame luminance level of the content in Nits. + + + [VT_UI2] Specifies the maximum luminance of the display on which the content was authored, in Nits. + + + [VT_UI2] Specifies the maximum luminance of the display on which the content was authored, in Nits. + + + [VT_BLOB] Specifies custom color primaries for a video media type. The value of this property is a MT_CUSTOM_VIDEO_PRIMARIESstructure, returned as an array of bytes (VT_BLOB). + + + + Retrieves the IWICColorContext objects of the image. + Microsoft Docs: + The number of color contexts to retrieve. + +This value must be the size of, or smaller than, the size available to ppIColorContexts. + A pointer that receives a pointer to the IWICColorContext. + A pointer that receives the number of color contexts contained in the image. + + + + + Specifies decode options. + Microsoft Docs: + + + + Cache metadata when needed. + + + Cache metadata when decoder is loaded. + + + + Exposes methods used for in-place metadata editing. A fast metadata encoder enables you to add and remove metadata to an image without having to fully re-encode the image. + Microsoft Docs: + + + + + Creates an IWICBitmap from a memory block. + Microsoft Docs: + The width of the new bitmap. + The height of the new bitmap. + The pixel format of the new bitmap. For valid pixel formats, see Native Pixel Formats. + The number of bytes between successive scanlines in pbBuffer. + The size of pbBuffer. + The buffer used to create the bitmap. + A pointer that receives a pointer to the new bitmap. + + + + + Initializes the color context from the given file. + Microsoft Docs: + The name of the file. + + + + + Specifies the properties of a High Efficiency Image Format (HEIF) image. + Microsoft Docs: + + + + [VT_UI2] Indicates the orientation of the image. + +The value of this property uses the same numbering scheme as the System.Photo.Orientation property. For example, a value of 1 (PHOTO_ORIENTATION_NORMAL) indicates a 0 degree rotation. + + + + Retrieves the capabilities of the decoder based on the specified stream. + Microsoft Docs: + The stream to retrieve the decoder capabilities from. + The WICBitmapDecoderCapabilities of the decoder. + + + + + Returns whether the format supports transparent pixels. + Microsoft Docs: + Returns TRUE if the pixel format supports transparency; otherwise, FALSE. + + + + + Specifies the Portable Network Graphics (PNG) filters available for compression optimization. + Microsoft Docs: + + + + Indicates an unspecified PNG filter. This enables WIC to algorithmically choose the best filtering option for the image. + + + Indicates no PNG filter. + + + Indicates a PNG sub filter. + + + Indicates a PNG up filter. + + + Indicates a PNG average filter. + + + Indicates a PNG paeth filter. + + + Indicates a PNG adaptive filter. This enables WIC to choose the best filtering mode on a per-scanline basis. + + + + Initializes a palette to the custom color entries provided. + Microsoft Docs: + Pointer to the color array. + The number of colors in pColors. + + + + + Creates a new instance of the IWICBitmapDecoder class based on the given IStream. + Microsoft Docs: + The stream to create the decoder from. + The GUID for the preferred decoder vendor. Use NULL if no preferred vendor. + The WICDecodeOptions to use when creating the decoder. + A pointer that receives a pointer to a new IWICBitmapDecoder. + + + + + Retrieves the width and height, in pixels, of the locked rectangle. + Microsoft Docs: + A pointer that receives the width of the locked rectangle. + A pointer that receives the height of the locked rectangle. + + + + + Specifies the dimension type of the data contained in DDS image. + Microsoft Docs: + + + + DDS image contains a 1-dimensional texture . + + + DDS image contains a 2-dimensional texture . + + + DDS image contains a 3-dimensional texture . + + + The DDS image contains a cube texture represented as an array of 6 faces. + + + + Finalizes metadata changes to the image stream. + Microsoft Docs: + + + + + Retrieves the file pattern signatures supported by the decoder. + Microsoft Docs: + The array size of the pPatterns array. + Receives a list of WICBitmapPattern objects supported by the decoder. + Receives the number of patterns the decoder supports. + Receives the actual buffer size needed to retrieve all pattern signatures supported by the decoder. + + + + + Adds a top-level metadata block by adding a IWICMetadataWriter for it. + Microsoft Docs: + A pointer to the metadata writer to add to the image. + + + + + Retrieves the number of colors in the color table. + Microsoft Docs: + Pointer that receives the number of colors in the color table. + + + + + Enables writing DDS format specific information to an encoder. + Microsoft Docs: + + + + + Initializes an IWICMetadataBlockWriter from the given IWICMetadataBlockReader. This will prepopulate the metadata block writer with all the metadata in the metadata block reader. + Microsoft Docs: + Pointer to the IWICMetadataBlockReader used to initialize the block writer. + + + + + Specifies the Portable Network Graphics (PNG) sRGB chunk metadata properties. + Microsoft Docs: + + + + [VT_UI1] Indicates the rendering intent for an sRGB color space image. The rendering intents have the following meaning. + + + + + + + + + + + + + + + + + + + + + + +
ValueMeaning
0Perceptual
1Relative colorimetric
2Saturation
3Absolute colorimetric
 + + + + Gets the current WICRawRenderMode. + Microsoft Docs: + A pointer that receives the current WICRawRenderMode. + + + + + Gets DDS-specific data. + Microsoft Docs: + Points to the structure where the information is returned. + + + + + Gets the information about the current Kelvin range of the raw image. + Microsoft Docs: + A pointer that receives the minimum Kelvin temperature. + A pointer that receives the maximum Kelvin temperature. + A pointer that receives the Kelvin step value. + + + + + Represents metadata header. + Microsoft Docs: + + + + The position of the header. + + + The length of the header. + + + Pointer to the header. + + + The offset of the header. + + + + Gets the current set of parameters. + Microsoft Docs: + A pointer that receives a pointer to the current set of parameters. + + + + + Requests that the encoder use the specified pixel format. + Microsoft Docs: + On input, the requested pixel format GUID. On output, the closest pixel format GUID supported by the encoder; this may be different than the requested format. For a list of pixel format GUIDs, see Native Pixel Formats. + + + + + Defines methods for setting an encoder's properties such as thumbnails, frames, and palettes. + Microsoft Docs: + + + + + Copies pixel data using the supplied input parameters. + Microsoft Docs: + The rectangle of pixels to copy. + The width to scale the source bitmap. This parameter must equal the value obtainable through IWICBitmapSourceTransform::GetClosestSize. + The height to scale the source bitmap. This parameter must equal the value obtainable through IWICBitmapSourceTransform::GetClosestSize. + The GUID of desired pixel format in which the pixels should be returned. + + +This GUID must be a format obtained through an GetClosestPixelFormat call. + The desired rotation or flip to perform prior to the pixel copy. + + +The transform must be an operation supported by an DoesSupportTransform call. + +If a dstTransform is specified, nStride is the transformed stride and is based on the pguidDstFormat pixel format, not the original source's pixel format. + The stride of the destination buffer. + The size of the destination buffer. + The output buffer. + + + + + Provides access to planar Y’CbCr pixel formats where pixel components are stored in separate component planes. + Microsoft Docs: + + + + + Specifies additional options to an IWICPlanarBitmapSourceTransform implementation. + Microsoft Docs: + + + + No options specified. + + + +WIC JPEG Decoder: The default behavior for iDCT scaling is to preserve quality when downscaling by downscaling only the Y plane in some cases, and the image may change to 4:4:4 chroma subsampling. + + + Asks the source to preserve the size ratio between planes when scaling. + +WIC JPEG Decoder: Specifying this option causes the JPEG decoder to scale luma and chroma planes by the same amount, so a 4:2:0 chroma subsampled image outputs 4:2:0 data when downscaling by 2x, 4x, or 8x. + + + + Gets the width and height, in blocks, of the DDS image. + Microsoft Docs: + The width of the DDS image in blocks. + The height of the DDS image in blocks. + + + + + Retrieves a value indicating whether the codec supports animation. + Microsoft Docs: + Receives TRUE if the codec supports images with timing information; otherwise, FALSE. + + + + + Creates an IWICBitmap object. + Microsoft Docs: + The width of the new bitmap . + The height of the new bitmap. + The pixel format of the new bitmap. + The cache creation options of the new bitmap. This can be one of the values in the WICBitmapCreateCacheOption enumeration. + + + + + + + + + + + + + + + + + + +
ValueMeaning
+
WICBitmapCacheOnDemand
+
+		 +Allocates system memory for the bitmap at initialization. + +
+
WICBitmapCacheOnLoad
+
+		 +Allocates system memory for the bitmap when the bitmap is first used. + +
+
WICBitmapNoCache
+
+		 +This option is not valid for this method and should not be used. + +
+ A pointer that receives a pointer to the new bitmap. + + + + + Retrieves a copy of the AC Huffman table for the specified scan and table. + Microsoft Docs: + The zero-based index of the scan for which data is retrieved. + The index of the AC Huffman table to retrieve. Valid indices for a given scan can be determined by retrieving the scan header with IWICJpegFrameDecode::GetScanHeader. + A pointer that receives the table data. This parameter must not be NULL. + + + + + Sets the desired WICRawParameterSet option. + Microsoft Docs: + The desired WICRawParameterSet option. + + + + + Determines whether a specific transform option is supported natively by the implementation of the IWICBitmapSourceTransform interface. + Microsoft Docs: + The WICBitmapTransformOptions to check if they are supported. + A pointer that receives a value specifying whether the transform option is supported. + + + + + Retrieves a value that describes whether a palette is grayscale. + Microsoft Docs: + A pointer to a variable that receives a boolean value that indicates whether the palette is grayscale. TRUE indicates that the palette is grayscale; otherwise FALSE. + + + + + An extension of the WIC factory interface that includes the ability to create an IWICImageEncoder. + Microsoft Docs: + + + + + Sets the frame thumbnail if supported by the codec. + Microsoft Docs: + The bitmap source to use as the thumbnail. + + + + + Retrieves the WICBitmapPaletteType that describes the palette. + Microsoft Docs: + Pointer that receives the palette type of the bimtap. + + + + + Specifies the progress operations to receive notifications for. + Microsoft Docs: + + + + Receive copy pixel operation. + + + Receive write pixel operation. + + + Receive all progress operations available. + + + + Creates a new instance of the IWICColorTransform class. + Microsoft Docs: + A pointer that receives a pointer to a new IWICColorTransform. + + + + + Retrieves the IWICMetadataWriter that resides at the specified index. + Microsoft Docs: + The index of the metadata writer to be retrieved. This index is zero-based. + When this method returns, contains a pointer to the metadata writer that resides at the specified index. + + + + + Exposes methods that provide information about a pixel format. + Microsoft Docs: + + + + + Retrieves an IWICBitmapEncoderInfo for the encoder. + Microsoft Docs: + A pointer that receives a pointer to an IWICBitmapEncoderInfo. + + + + + Retrieves the total number of frames in the image. + Microsoft Docs: + A pointer that receives the total number of frames in the image. + + + + + Exposes methods that enable the encoding of metadata. This interface is implemented by the decoder and its image frames. + Microsoft Docs: + + + + + Retrieves a copy of the DC Huffman table for the specified scan and table. + Microsoft Docs: + The zero-based index of the scan for which data is retrieved. + The index of the DC Huffman table to retrieve. Valid indices for a given scan can be determined by retrieving the scan header with IWICJpegFrameDecode::GetScanHeader. + A pointer that receives the table data. This parameter must not be NULL. + + + + + Encodes the image as a thumbnail to the frame given by the IWICBitmapFrameEncode. + Microsoft Docs: + The Direct2D image that will be encoded. + The frame encoder on which the thumbnail is set. + Additional parameters to control encoding. + + + + + Specifies the Portable Network Graphics (PNG) iCCP chunk metadata properties. + Microsoft Docs: + + + + [VT_LPSTR] Indicates the International Color Consortium (ICC) profile name. + + + [VT_VECTOR \| VT_UI1] Indicates the embedded ICC profile. + + + + Exposes methods that provide enumeration services for individual metadata items. + Microsoft Docs: + + + + + Creates an IWICBitmap from a specified rectangle of an IWICBitmapSource. + Microsoft Docs: + The IWICBitmapSource to create the bitmap from. + The horizontal coordinate of the upper-left corner of the rectangle. + The vertical coordinate of the upper-left corner of the rectangle. + The width of the rectangle and the new bitmap. + The height of the rectangle and the new bitmap. + A pointer that receives a pointer to the new bitmap. + + + + + Specifies the type of dither algorithm to apply when converting between image formats. + Microsoft Docs: + + + + A solid color algorithm without dither. + + + A solid color algorithm without dither. + + + A 4x4 ordered dither algorithm. + + + An 8x8 ordered dither algorithm. + + + A 16x16 ordered dither algorithm. + + + A 4x4 spiral dither algorithm. + + + An 8x8 spiral dither algorithm. + + + A 4x4 dual spiral dither algorithm. + + + An 8x8 dual spiral dither algorithm. + + + An error diffusion algorithm. + + + + Retrieves a small preview of the frame, if supported by the codec. + Microsoft Docs: + A pointer that receives a pointer to the IWICBitmapSource of the thumbnail. + + + + + Retrieves an IWICBitmapDecoderInfo for the image. + Microsoft Docs: + A pointer that receives a pointer to an IWICBitmapDecoderInfo. + + + + + Retrieves a value indicating whether the given mime type matches the mime type of the codec. + Microsoft Docs: + The mime type to compare. + Receives TRUE if the mime types match; otherwise, FALSE. + + + + + Use this method to determine if a desired planar output is supported and allow the caller to choose an optimized code path if it is. + Microsoft Docs: + On input, the desired width. On output, the closest supported width to the desired width; this is the same size or larger than the desired width. + On input, the desired height. On output, the closest supported height to the desired height; this is the same size or larger than the desired width. + The desired rotation or flip operation. Multiple WICBitmapTransformOptions can be combined in this flag parameter, see WICBitmapTransformOptions. + Used to specify additional configuration options for the transform. See WICPlanarOptions for more detail. + + + +WIC JPEG Decoder: + + +WICPlanarOptionsPreserveSubsampling can be specified to retain the subsampling ratios when downscaling. By default, the JPEG decoder attempts to preserve quality by downscaling only the Y plane in some cases, changing the image to 4:4:4 chroma subsampling. + The requested pixel formats of the respective planes. + When *pfIsSupported == TRUE, the array of plane descriptions contains the size and format of each of the planes. + + + +WIC JPEG Decoder: The Cb and Cr planes can be a different size from the values returned by puiWidth and puiHeight due to chroma subsampling. + The number of component planes requested. + Set to TRUE if the requested transforms are natively supported. + + + + + Specifies the desired cache usage. + Microsoft Docs: + + + + Do not cache the bitmap. + + + Cache the bitmap when needed. + + + Cache the bitmap at initialization. + + + + Retrieves the container format of the decoder. + Microsoft Docs: + The container format of the decoder. The native container format GUIDs are listed in WIC GUIDs and CLSIDs. + + + + + Exposes methods for a stream provider. + Microsoft Docs: + + + + + Exposes methods that provide component information. + Microsoft Docs: + + + + + Retrieves a value indicating whether the codec supports multi frame images. + Microsoft Docs: + Receives TRUE if the codec supports multi frame images; otherwise, FALSE. + + + + + Writes lines from the source planes to the encoded format. + Microsoft Docs: + The number of lines to encode. See the Remarks section for WIC Jpeg specific line count restrictions. + Specifies the source buffers for each component plane encoded. + The number of component planes specified by the pPlanes parameter. + + + + + Retrieves a comma delimited list of the file name extensions associated with the codec. + Microsoft Docs: + The size of the file name extension buffer. Use 0 on first call to determine needed buffer size. + Receives a comma delimited list of file name extensions associated with the codec. Use NULL on first call to determine needed buffer size. + The actual buffer size needed to retrieve all file name extensions associated with the codec. + + + + + Gets the white point RGB values. + Microsoft Docs: + A pointer that receives the red white point value. + A pointer that receives the green white point value. + A pointer that receives the blue white point value. + + + + + Creates a new instance of the IWICPalette class. + Microsoft Docs: + A pointer that receives a pointer to a new IWICPalette. + + + + + Creates a copy of the current IWICEnumMetadataItem. + Microsoft Docs: + A pointer that receives a pointer to the IWICEnumMetadataItem copy. + + + + + Obtains a IWICBitmapSource in the desired pixel format from a given IWICBitmapSource. + Microsoft Docs: + The pixel format to convert to. + The source bitmap. + A pointer to the null-initialized destination bitmap pointer. + + + + + Sets the notification callback method. + Microsoft Docs: + Pointer to the notification callback method. + + + + + Specifies the options for indexing a JPEG image. + Microsoft Docs: + + + + Index generation is deferred until IWICBitmapSource::CopyPixels is called on the image. + + + Index generation is performed when the when the image is initially loaded. + + + Forces this enumeration to compile to 32 bits in size. Without this value, some compilers would allow this enumeration to compile to a size other than 32 bits. This value is not used. + + + + Gets the tone curve of the raw image. + Microsoft Docs: + The size of the pToneCurve buffer. + A pointer that receives the WICRawToneCurve of the raw image. + A pointer that receives the size needed to obtain the tone curve structure. + + + + + Specifies the sampling or filtering mode to use when scaling an image. + Microsoft Docs: + + + + A nearest neighbor interpolation algorithm. Also known as nearest pixel or point interpolation. + + +The output pixel is assigned the value of the pixel that the point falls within. No other pixels are considered. + + + A bilinear interpolation algorithm. + + +The output pixel values are computed as a weighted average of the nearest four pixels in a 2x2 grid. + + + A bicubic interpolation algorithm. + + +Destination pixel values are computed as a weighted average of the nearest sixteen pixels in a 4x4 grid. + + + A Fant resampling algorithm. + + +Destination pixel values are computed as a weighted average of the all the pixels that map to the new pixel. + + + A high quality bicubic interpolation algorithm. Destination pixel values are computed using a much denser sampling + kernel than regular cubic. The kernel is resized in response to the scale factor, making it suitable for downscaling by factors greater than 2. + +
Note  This value is supported beginning with Windows 10.
+
 
 + + + + Creates a new instance of an IWICBitmapClipper object. + Microsoft Docs: + A pointer that receives a pointer to a new IWICBitmapClipper. + + + + + This defines parameters that you can use to override the default parameters normally used when encoding an image. + Microsoft Docs: + + + + The pixel format to which the image is processed before it is written to the encoder. + + + The DPI in the x dimension. + + + The DPI in the y dimension. + + + The top corner in pixels of the image space to be encoded to the destination. + + + The left corner in pixels of the image space to be encoded to the destination. + + + The width in pixels of the part of the image to write. + + + The height in pixels of the part of the image to write. + + + + Initializes the bitmap clipper with the provided parameters. + Microsoft Docs: + he input bitmap source. + The rectangle of the bitmap source to clip. + + + + + Gets the named white point of the raw image. + Microsoft Docs: + A pointer that receives the bitwise combination of the enumeration values. + + + + + Initializes the format converter. + Microsoft Docs: + The input bitmap to convert + The destination pixel format GUID. + The WICBitmapDitherType used for conversion. + The palette to use for conversion. + The alpha threshold to use for conversion. + The palette translation type to use for conversion. + + + + + Removes the indexing from a JPEG that has been indexed using IWICJpegFrameDecode::SetIndexing. + Microsoft Docs: + + + + + Gets information about the format in which the DDS image is stored. + Microsoft Docs: + Information about the DDS format. + + + + + Specifies the logical screen descriptor properties for Graphics Interchange Format (GIF) metadata. + Microsoft Docs: + + + + [VT_UI1 | VT_VECTOR] Indicates the signature property. + + + [VT_UI2] Indicates the width in pixels. + + + [VT_UI2] Indicates the height in pixels. + + + [VT_BOOL] Indicates the global color table flag. TRUE if a global color table is present; otherwise, FALSE. + + + [VT_UI1] Indicates the color resolution in bits per pixel. + + + [VT_BOOL] Indicates the sorted color table flag. TRUE if the table is sorted; otherwise, FALSE. + + + [VT_UI1] Indicates the value used to calculate the number of bytes contained in the global color table. + +To calculate the actual size of the color table, raise 2 to the value of the field + 1. + + + [VT_UI1] Indicates the index within the color table to use for the background (pixels not defined in the image). + + + [VT_UI1] Indicates the factor used to compute an approximation of the aspect ratio. + + + + Retrieves the vendor GUID. + Microsoft Docs: + A pointer that receives the component's vendor GUID. + + + + + Sets a metadata item to a specific location. + Microsoft Docs: + The name of the metadata item. + The metadata to set. + + + + + Gets the metadata query writer for the encoder frame. + Microsoft Docs: + When this method returns, contains a pointer to metadata query writer for the encoder frame. + + + + + Exposes methods that support the Lock method. + Microsoft Docs: + + + + + Provides access to a rectangular area of the bitmap. + Microsoft Docs: + The rectangle to be accessed. + The access mode you wish to obtain for the lock. This is a bitwise combination of WICBitmapLockFlags for read, write, or read and write access. + + + + + + + + + + + + + + +
ValueMeaning
+
WICBitmapLockRead
+
+		 +The read access lock. + +
+
WICBitmapLockWrite
+
+		 +The write access lock. + +
+ A pointer that receives the locked memory location. + + + + + Registers a progress notification callback function. + Microsoft Docs: + A function pointer to the application defined progress notification callback function. See ProgressNotificationCallback for the callback signature. + A pointer to component data for the callback method. + The WICProgressOperation and WICProgressNotification flags to use for progress notification. + + + + + Retrieves an IWICMetadataReader for a specified top level metadata block. + Microsoft Docs: + The index of the desired top level metadata block to retrieve. + When this method returns, contains a pointer to the IWICMetadataReader specified by nIndex. + + + + + Retrieves the pixel width and height of the bitmap. + Microsoft Docs: + A pointer that receives the pixel width of the bitmap. + A pointer that receives the pixel height of the bitmap + + + + + Initializes the stream as a substream of another stream. + Microsoft Docs: + Pointer to the input stream. + The stream offset used to create the new stream. + The maximum size of the stream. + + + + + Retrieves the component's version. + Microsoft Docs: + The size of the wzVersion buffer. + A pointer that receives a culture invariant string of the component's version. + A pointer that receives the actual length of the component's version. The version is optional; if a value is not specified by the component, the length returned is 0. + + + + + Retrieves an enumeration of IWICMetadataReader objects representing each of the top level metadata blocks. + Microsoft Docs: + When this method returns, contains a pointer to an enumeration of IWICMetadataReader objects. + + + + + Sets the noise reduction value of the raw image. + Microsoft Docs: + The noise reduction value of the raw image. The default value is the "as-shot" setting if it exists or 0.0. The value range for noise reduction is 0.0 through 1.0. The 0.0 lower limit represents no noise reduction applied to the image, while the 1.0 upper limit represents highest noise reduction amount that can be applied. + + + + + Gets the persist options used when initializing the component with a stream. + Microsoft Docs: + Pointer that receives the persist options used when initializing the component with a stream. If none were provided, WICPersistOptionDefault is returned. + + + + + Provides information and functionality specific to the DDS image format. + Microsoft Docs: + + + + + Retrieves a value indicating whether the codec supports chromakeys. + Microsoft Docs: + Receives TRUE if the codec supports chromakeys; otherwise, FALSE. + + + + + Represents a JPEG frame header. + Microsoft Docs: + + + + The number of components in the scan. + + + The interval of reset markers within the scan. + + + The component identifiers. + + + The format of the quantization table indices. Use one of the following constants, described in IWICJpegFrameDecode Constants. + +
    +
  • WIC_JPEG_HUFFMAN_BASELINE_ONE
    • +
  • WIC_JPEG_HUFFMAN_BASELINE_THREE
    • +
 + + + The start of the spectral selection. + + + The end of the spectral selection. + + + The successive approximation high. + + + The successive approximation low. + + + + Exposes methods that create components used by component developers. This includes metadata readers, writers and other services for use by codec and metadata handler developers. + Microsoft Docs: + + + + + Specifies the identifiers of the metadata items in an 8BIM IPTC block. + Microsoft Docs: + + + + [VT_LPSTR] A name that identifies the 8BIM block. + + + + Exposes methods for offloading certain operations to the underlying IWICBitmapSource implementation. + Microsoft Docs: + + + + + Commits the frame to the image. + Microsoft Docs: + + + + + Retrieves header data from the entire frame. + Microsoft Docs: + A pointer that receives the frame header data. + + + + + Retrieves the color context profile. + Microsoft Docs: + The size of the pbBuffer buffer. + A pointer that receives the color context profile. + A pointer that receives the actual buffer size needed to retrieve the entire color context profile. + + + + + Initializes an IWICColorTransform with a IWICBitmapSource and transforms it from one IWICColorContext to another. + Microsoft Docs: + The bitmap source used to initialize the color transform. + The color context source. + The color context destination. + The GUID of the desired pixel format. + +This parameter is limited to a subset of the native WIC pixel formats, see Remarks for a list. + + + + + Defines constants that specify a primitive type for numeric representation of a WIC pixel format. + Microsoft Docs: + + + + The format is not specified. + + + Specifies that the format is indexed. + + + Specifies that the format is represented as an unsigned integer. + + + Specifies that the format is represented as a signed integer. + + + Specifies that the format is represented as a fixed-point number. + + + Specifies that the format is represented as a floating-point number. + + + This constant contains the maximum DWORD value. + + + + Gets the white point Kelvin temperature of the raw image. + Microsoft Docs: + A pointer that receives the white point Kelvin temperature of the raw image. The default is the "as-shot" setting value. + + + + + Specifies conversion matrix from Y'Cb'Cr' to R'G'B'. + Microsoft Docs: + + + + Specifies the identity transfer matrix. + + + Specifies the BT601 transfer matrix. + + + Forces this enumeration to compile to 32 bits in size. Without this value, some compilers would allow this enumeration to compile to a size other than 32 bits. This value is not used. + + + + Sets the IWICPalette for indexed pixel formats. + Microsoft Docs: + The IWICPalette to use for indexed pixel formats. + +The encoder may change the palette to reflect the pixel formats the encoder supports. + + + + + Exposes methods for retrieving metadata blocks and items from a decoder or its image frames using a metadata query expression. + Microsoft Docs: + + + + + Sets the exposure compensation stop value. + Microsoft Docs: + The exposure compensation value. The value range for exposure compensation is -5.0 through +5.0, which equates to 10 full stops. + + + + + Exposes methods that provide access to writing metadata content. This is implemented by independent software vendors (ISVs) to create new metadata writers. + Microsoft Docs: + + + + + Encodes a bitmap source. + Microsoft Docs: + The bitmap source to encode. + The size rectangle of the bitmap source. + + + + + Represents a rectangle for Windows Imaging Component (WIC) API. + Microsoft Docs: + + + + The horizontal coordinate of the rectangle. + + + The vertical coordinate of the rectangle. + + + The width of the rectangle. + + + The height of the rectangle. + + + + Retrieves the container formats supported by the metadata handler. + Microsoft Docs: + The size of the pguidContainerFormats array. + Pointer to an array that receives the container formats supported by the metadata handler. + The actual number of GUIDs added to the array. + + +To obtain the number of supported container formats, pass NULL to pguidContainerFormats. + + + + + Retrieves the component's class identifier (CLSID) + Microsoft Docs: + A pointer that receives the component's CLSID. + + + + + Initializes a palette using a computed optimized values based on the reference bitmap. + Microsoft Docs: + Pointer to the source bitmap. + The number of colors to initialize the palette with. + A value to indicate whether to add a transparent color. + + + + + Gets the sharpness value of the raw image. + Microsoft Docs: + A pointer that receives the sharpness value of the raw image. The default value is the "as-shot" setting. The value range for sharpness is 0.0 through 1.0. The 0.0 lower limit represents no sharpening applied to the image, while the 1.0 upper limit represents the highest amount of sharpness that can be applied. + + + + + Query if the format converter can convert from one format to another. + Microsoft Docs: + An array of WIC pixel formats that represents source image planes. + The number of source pixel formats specified by the pSrcFormats parameter. + The destination interleaved pixel format. + True if the conversion is supported. + + + + + Exposes methods that refers to a source from which pixels are retrieved, but cannot be written back to. + Microsoft Docs: + + + + + Initializes the decoder with the provided stream. + Microsoft Docs: + The stream to use for initialization. + +The stream contains the encoded pixels which are decoded each time the CopyPixels method on the IWICBitmapFrameDecode interface (see GetFrame) is invoked. + The WICDecodeOptions to use for initialization. + + + + + Retrieves a comma delimited list of device models associated with the codec. + Microsoft Docs: + The size of the device models buffer. Use 0 on first call to determine needed buffer size. + Receives a comma delimited list of device model names associated with the codec. Use NULL on first call to determine needed buffer size. + The actual buffer size needed to retrieve all of the device model names. + + + + + An application-defined callback method used for raw image parameter change notifications. + Microsoft Docs: + A set of IWICDevelopRawNotificationCallback Constants parameter notification flags. + + + + + Retrieves a value indicating whether this decoder supports indexing for efficient random access. + Microsoft Docs: + True if indexing is supported; otherwise, false. + + + + + Exposes methods used for progress notification for encoders and decoders. + Microsoft Docs: + + + + + Creates an IWICMetadataWriter based on the given parameters. + Microsoft Docs: + The GUID of the desired metadata format. + Pointer to the GUID of the desired metadata reader vendor. + The WICPersistOptions and WICMetadataCreationOptions options to use when creating the metadata reader. + A pointer that receives a pointer to the new metadata writer. + + + + + Retrieves a preview image, if supported. + Microsoft Docs: + Receives a pointer to the preview bitmap if supported. + + + + + Determines if the metadata handler requires a fixed size. + Microsoft Docs: + Pointer that receives TRUE if a fixed size is required; otherwise, FALSE. + + + + + Specifies the identifiers of the metadata items in an 8BIMResolutionInfo block. + Microsoft Docs: + + + + [VT_LPSTR] A name that identifies the 8BIM block. + + + [VT_UI4] The horizontal resolution of the image. + + + [VT_UI2] The units that the horizontal resolution is specified in; a 1 indicates pixels per inch and a 2 indicates pixels per centimeter. + + + [VT_UI2] The units that the image width is specified in; a 1 indicates inches, a 2 indicates centimeters, a 3 indicates points, a 4 specifies picas, and a 5 specifies columns. + + + [VT_UI4] The vertical resolution of the image. + + + [VT_UI2] The units that the vertical resolution is specified in; a 1 indicates pixels per inch and a 2 indicates pixels per centimeter. + + + [VT_UI2] The units that the image height is specified in; a 1 indicates inches, a 2 indicates centimeters, a 3 indicates points, a 4 specifies picas, and a 5 specifies columns. + + + + Specifies the Portable Network Graphics (PNG) hIST chunk metadata properties. + Microsoft Docs: + + + + [VT_VECTOR | VT_UI2] Indicates the approximate usage frequency of each color in the color palette. + + + + Creates an IWICMetadataWriter from the given IWICMetadataReader. + Microsoft Docs: + Pointer to the metadata reader to base the metadata writer on. + Pointer to the GUID of the desired metadata reader vendor. + A pointer that receives a pointer to the new metadata writer. + + + + + Gets DDS-specific data. + Microsoft Docs: + A pointer to the structure where the information is returned. + + + + + Retrieves the closest pixel format to which the implementation of IWICBitmapSourceTransform can natively copy pixels, given a desired format. + Microsoft Docs: + A pointer that receives the GUID of the pixel format that is the closest supported pixel format of the desired format. + + + + + Initializes the color context from a memory block. + Microsoft Docs: + The buffer used to initialize the IWICColorContext. + The size of the pbBuffer buffer. + + + + + Specifies access to an IWICBitmap. + Microsoft Docs: + + + + A read access lock. + + + A write access lock. + + + + Sets the white point Kelvin value. + Microsoft Docs: + The white point Kelvin value. Acceptable Kelvin values are 1,500 through 30,000. + + + + + Encodes the given image as the thumbnail to the given WIC bitmap encoder. + Microsoft Docs: + The Direct2D image that will be encoded. + The encoder on which the thumbnail is set. + Additional parameters to control encoding. + + + + + Gets the number of metadata items within the reader. + Microsoft Docs: + Pointer that receives the number of metadata items within the reader. + + + + + Creates an IEnumUnknown object of the specified component types. + Microsoft Docs: + The types of WICComponentType to enumerate. + The WICComponentEnumerateOptions used to enumerate the given component types. + A pointer that receives a pointer to a new component enumerator. + + + + + Creates an instance of an IWICMetadataReader. + Microsoft Docs: + Pointer that receives a pointer to a metadata reader. + + + + + Defines methods that add the concept of writeability and static in-memory representations of bitmaps to IWICBitmapSource. + Microsoft Docs: + + + + + Retrieves a copy of the compressed JPEG scan directly from the WIC decoder frame's output stream. + Microsoft Docs: + The zero-based index of the scan for which data is retrieved. + The byte position in the scan data to begin copying. Use 0 on the first call. If the output buffer size is insufficient to store the entire scan, this offset allows you to resume copying from the end of the previous copy operation. + The size, in bytes, of the pbScanData array. + A pointer that receives the table data. This parameter must not be NULL. + A pointer that receives the size of the scan data actually copied into pbScanData. The size returned may be smaller that the size of cbScanData. This parameter may be NULL. + + + + + Advanced the current position in the enumeration. + Microsoft Docs: + The number of items to be retrieved. + An array of enumerated items. This parameter is optional. + An array of enumerated items. + An array of enumerated items. This parameter is optional. + The number of items that were retrieved. This value is always less than or equal to the number of items requested. + + + + + Sets the destination color context. + Microsoft Docs: + The destination color context. + + + + + Creates an IWICMetadataReader based on the given parameters. + Microsoft Docs: + The GUID of the desired metadata format. + Pointer to the GUID of the desired metadata reader vendor. + The WICPersistOptions and WICMetadataCreationOptions options to use when creating the metadata reader. + Pointer to a stream in which to initialize the reader with. If NULL, the metadata reader will be empty. + A pointer that receives a pointer to the new metadata reader. + + + + + Retrieves a value that describes whether the palette is black and white. + Microsoft Docs: + A pointer to a variable that receives a boolean value that indicates whether the palette is black and white. TRUE indicates that the palette is black and white; otherwise, FALSE. + + + + + Specifies Windows Imaging Component (WIC) options that are used when initializing a component with a stream. + Microsoft Docs: + + + + The default persist options. The default is WICPersistOptionLittleEndian. + + + The data byte order is little endian. + + + The data byte order is big endian. + + + The data format must strictly conform to the specification. + +
Warning  This option is inconsistently implement and should not be relied on.
+
 
 + + + No cache for the metadata stream. + +Certain operations, such as IWICComponentFactory::CreateMetadataWriterFromReader require that the reader have a stream. Therefore, these operations will be unavailable if the reader is initialized with WICPersistOptionNoCacheStream. + + + Use UTF8 instead of the default UTF16. + +
Note  This option is currently unused by WIC.
+
 
 + + + The WICPersistOptions mask. + + + + Commits all changes for the image and closes the stream. + Microsoft Docs: + + + + + Initializes a format converter with a planar source, and specifies the interleaved output pixel format. + Microsoft Docs: + An array of IWICBitmapSource that represents image planes. + The number of component planes specified by the planes parameter. + The destination interleaved pixel format. + The WICBitmapDitherType used for conversion. + The palette to use for conversion. + The alpha threshold to use for conversion. + The palette translation type to use for conversion. + + + + + Creates a new instance of an IWICBitmapFlipRotator object. + Microsoft Docs: + A pointer that receives a pointer to a new IWICBitmapFlipRotator. + + + + + Specifies the pixel format and size of a component plane. + Microsoft Docs: + + + + Describes the pixel format of the plane. + + + Component width of the plane. + + + Component height of the plane. + + + + Initializes the palette to one of the pre-defined palettes specified by WICBitmapPaletteType and optionally adds a transparent color. + Microsoft Docs: + The desired pre-defined palette type. + The optional transparent color to add to the palette. If no transparent color is needed, use 0. When initializing to a grayscale or black and white palette, set this parameter to FALSE. + + + + + Gets the exposure compensation stop value of the raw image. + Microsoft Docs: + A pointer that receives the exposure compensation stop value. The default is the "as-shot" setting. + + + + + Exposes methods that produce a flipped (horizontal or vertical) and/or rotated (by 90 degree increments) bitmap source. The flip is done before the rotation. + Microsoft Docs: + + + + + Retrieves the specified frame of the DDS image. + Microsoft Docs: + The requested index within the texture array. + The requested mip level. + The requested slice within the 3D texture. + A pointer to a IWICBitmapFrameDecode object. + + + + + Specifies the Tagged Image File Format (TIFF) compression options. + Microsoft Docs: + + + + Indicates a suitable compression algorithm based on the image and pixel format. + + + Indicates no compression. + + + Indicates a CCITT3 compression algorithm. This algorithm is only valid for 1bpp pixel formats. + + + Indicates a CCITT4 compression algorithm. This algorithm is only valid for 1bpp pixel formats. + + + Indicates a LZW compression algorithm. + + + Indicates a RLE compression algorithm. This algorithm is only valid for 1bpp pixel formats. + + + Indicates a ZIP compression algorithm. + + + Indicates an LZWH differencing algorithm. + + + + Gets the metadata item value. + Microsoft Docs: + Pointer to the metadata item's schema property. + Pointer to the metadata item's id. + Pointer that receives the metadata value. + + + + + Sets the global palette for the image. + Microsoft Docs: + The IWICPalette to use as the global palette. + + + + + Sets the tint value of the raw image. + Microsoft Docs: + The tint value of the raw image. The default value is the "as-shot" setting if it exists or 0.0. The value range for sharpness is -1.0 through +1.0. The -1.0 lower limit represents a full green bias to the image, while the 1.0 upper limit represents a full magenta bias. + + + + + Specifies the cache options available for an encoder. + Microsoft Docs: + + + + The encoder is cached in memory. This option is not supported. + + + The encoder is cached to a temporary file. This option is not supported. + + + The encoder is not cached. + + + + Specifies the JPEG comment properties. + Microsoft Docs: + + + + Indicates the metadata property is comment text. + + + + Replaces the metadata writer at the specified index location. + Microsoft Docs: + The index position at which to place the metadata writer. This index is zero-based. + A pointer to the IWICMetadataWriter. + + + + + Specifies the DDS image dimension, DXGI_FORMAT and alpha mode of contained data. + Microsoft Docs: + + + + The width, in pixels, of the texture at the largest mip size (mip level 0). + + + The height, in pixels, of the texture at the largest mip size (mip level 0). When the DDS image contains a 1-dimensional texture, this value is equal to 1. + + + The number of slices in the 3D texture. This is equivalent to the depth, in pixels, of the 3D texture at the largest mip size (mip level 0). When the DDS image contains a 1- or 2-dimensional texture, this value is equal to 1. + + + The number of mip levels contained in the DDS image. + + + The number of textures in the array in the DDS image. + + + The DXGI_FORMAT of the DDS pixel data. + + + Specifies the dimension type of the data contained in DDS image (1D, 2D, 3D or cube texture). + + + Specifies the alpha behavior of the DDS image. + + + + Specifies the Portable Network Graphics (PNG) tIME chunk metadata properties. + Microsoft Docs: + + + + [VT_UI2] Indicates the year of the last modification. + + + [VT_UI1] Indicates the month of the last modification. + + + [VT_UI1] Indicates day of the last modification. + + + [VT_UI1] Indicates the hour of the last modification. + + + [VT_UI1] Indicates the minute of the last modification. + + + [VT_UI1] Indicates the second of the last modification. + + + + Specifies component enumeration options. + Microsoft Docs: + + + + Enumerate any components that are not disabled. Because this value is 0x0, it is always included with the other options. + + + Force a read of the registry before enumerating components. + + + Include disabled components in the enumeration. The set of disabled components is disjoint with the set of default enumerated components + + + Include unsigned components in the enumeration. This option has no effect. + + + At the end of component enumeration, filter out any components that are not Windows provided. + + + + Exposes methods that provide access to the capabilites of a raw codec format. + Microsoft Docs: + + + + + Exposes methods that provide information about a decoder. + Microsoft Docs: + + + + + Retrieves the pixel formats the codec supports. + Microsoft Docs: + The size of the pguidPixelFormats array. Use 0 on first call to determine the needed array size. + Receives the supported pixel formats. Use NULL on first call to determine needed array size. + The array size needed to retrieve all supported pixel formats. + + + + + Creates a new IWICBitmapDecoder instance. + Microsoft Docs: + A pointer that receives a pointer to a new instance of the IWICBitmapDecoder. + + + + + Creates a new IWICBitmapFrameEncode instance. + Microsoft Docs: + A pointer that receives a pointer to the new instance of an IWICBitmapFrameEncode. + Optional. Receives the named properties to use for subsequent frame initialization. See Remarks. + + + + + Specifies the access level of a Windows Graphics Device Interface (GDI) section. + Microsoft Docs: + + + + Indicates a read only access level. + + + Indicates a read/write access level. + + + + Encodes the image to the frame given by the IWICBitmapFrameEncode. + Microsoft Docs: + The Direct2D image that will be encoded. + The frame encoder to which the image is written. + Additional parameters to control encoding. + + + + + Specifies the the meaning of pixel color component values contained in the DDS image. + Microsoft Docs: + + + + Alpha behavior is unspecified and must be determined by the reader. + + + The alpha data is straight. + + + The alpha data is premultiplied. + + + The alpha data is opaque (UNORM value of 1). This can be used by a compliant reader as a performance optimization. For example, blending operations can be converted to copies. + + + The alpha channel contains custom data that is not alpha. + + + + Creates an encoder property bag. + Microsoft Docs: + Pointer to an array of PROPBAG2 options used to create the encoder property bag. + The number of PROPBAG2 structures in the ppropOptions array. + A pointer that receives a pointer to an encoder IPropertyBag2. + + + + + Contains members that identify a pattern within an image file which can be used to identify a particular format. + Microsoft Docs: + + + + The offset the pattern is located in the file. + + + The pattern length. + + + The actual pattern. + + + The pattern mask. + + + The end of the stream. + + + + Obtains the GUID associated with the given short name. + Microsoft Docs: + A pointer to the short name. + A pointer that receives the GUID associated with the given short name. + + + + + Specifies the pixel format, buffer, stride and size of a component plane for a planar pixel format. + Microsoft Docs: + + + + Describes the pixel format of the plane. + + + Pointer to the buffer that holds the plane’s pixel components. + + + The stride of the buffer ponted to by pbData. Stride indicates the total number of bytes to go from the beginning of one scanline to the beginning of the next scanline. + + + The total size of the buffer pointed to by pbBuffer. + + + + Gets an enumerator of all the metadata items. + Microsoft Docs: + Pointer that receives a pointer to the metadata enumerator. + + + + + Specifies the desired alpha channel usage. + Microsoft Docs: + + + + Use alpha channel. + + + Use a pre-multiplied alpha channel. + + + Ignore alpha channel. + + + Sentinel value. + + + + Creates a new IWICBitmapEncoder instance. + Microsoft Docs: + A pointer that receives a pointer to a new IWICBitmapEncoder instance. + + + + + Retrieves the name of component's author. + Microsoft Docs: + The size of the wzAuthor buffer. + A pointer that receives the name of the component's author. + The locale of the string depends on the value that the codec wrote to the registry at install time. For built-in components, these strings are always in English. + A pointer that receives the actual length of the component's authors name. The author name is optional; if an author name is not specified by the component, the length returned is 0. + + + + + Retrieves the sampling rate between pixels and physical world measurements. + Microsoft Docs: + A pointer that receives the x-axis dpi resolution. + A pointer that receives the y-axis dpi resolution. + + + + + Retrieves the component's friendly name, which is a human-readable display name for the component. + Microsoft Docs: + The size of the wzFriendlyName buffer. + A pointer that receives the friendly name of the component. + The locale of the string depends on the value that the codec wrote to the registry at install time. For built-in components, these strings are always in English. + A pointer that receives the actual length of the component's friendly name. + + + + + Represents a Windows Imaging Component (WIC) stream for referencing imaging and metadata content. + Microsoft Docs: + + + + + Gets the stream held by the component. + Microsoft Docs: + Pointer that receives a pointer to the stream held by the component. + + + + + Retrieves the metadata format of the metadata handler. + Microsoft Docs: + Pointer that receives the metadata format GUID. + + + + + Gets the noise reduction value of the raw image. + Microsoft Docs: + A pointer that receives the noise reduction value of the raw image. The default value is the "as-shot" setting if it exists or 0.0. The value range for noise reduction is 0.0 through 1.0. The 0.0 lower limit represents no noise reduction applied to the image, while the 1.0 upper limit represents full highest noise reduction amount that can be applied. + + + + + Specifies the type of Windows Imaging Component (WIC) component. + Microsoft Docs: + + + + A WIC decoder. + + + A WIC encoder. + + + A WIC pixel converter. + + + A WIC metadata reader. + + + A WIC metadata writer. + + + A WIC pixel format. + + + All WIC components. + + + + Specifies the parameter set used by a raw codec. + Microsoft Docs: + + + + An as shot parameter set. + + + A user adjusted parameter set. + + + A codec adjusted parameter set. + + + + Sets the desired rotation angle. + Microsoft Docs: + The desired rotation angle. + + + + + Changes the physical resolution of the image. + Microsoft Docs: + The horizontal resolution. + The vertical resolution. + + + + + Retrieves a bitmap thumbnail of the image, if one exists + Microsoft Docs: + Receives a pointer to the IWICBitmapSource of the thumbnail. + + + + + Copies the decoder's IWICPalette . + Microsoft Docs: + AnIWICPalette to which the decoder's global palette is to be copied. Use CreatePalette to create the destination palette before calling CopyPalette. + + + + + Exposes methods that provide information about a particular codec. + Microsoft Docs: + + + + + Exposes methods for decoding JPEG images. Provides access to the Start Of Frame (SOF) header, Start of Scan (SOS) header, the Huffman and Quantization tables, and the compressed JPEG JPEG data. Also enables indexing for efficient random access. + Microsoft Docs: + + + + + Initializes a stream to treat a block of memory as a stream. The stream cannot grow beyond the buffer size. + Microsoft Docs: + Pointer to the buffer used to initialize the stream. + The size of buffer. + + + + + Initializes a stream from a particular file. + Microsoft Docs: + The file used to initialize the stream. + The desired file access mode. + + + + + + + + + + + + + + +
ValueMeaning
+
GENERIC_READ
+
+		 +Read access. + +
+
GENERIC_WRITE
+
+		 +Write access. + +
+ + + + + Gets the pixel format's channel mask. + Microsoft Docs: + The index to the channel mask to retrieve. + The size of the pbMaskBuffer buffer. + Pointer to the mask buffer. + The actual buffer size needed to obtain the channel mask. + + + + + Gets the contrast value of the raw image. + Microsoft Docs: + A pointer that receives the contrast value of the raw image. The default value is the "as-shot" setting. The value range for contrast is 0.0 through 1.0. The 0.0 lower limit represents no contrast applied to the image, while the 1.0 upper limit represents the highest amount of contrast that can be applied. + + + + + Specifies the component signing status. + Microsoft Docs: + + + + A signed component. + + + An unsigned component + + + A component is safe. + + +Components that do not have a binary component to sign, such as a pixel format, should return this value. + + + A component has been disabled. + + + + Sets the output image dimensions for the frame. + Microsoft Docs: + The width of the output image. + The height of the output image. + + + + + Retrieves the number of top level metadata blocks. + Microsoft Docs: + When this method returns, contains the number of top level metadata blocks. + + + + + Retrieves the pixel format of the bitmap source.. + Microsoft Docs: + Receives the pixel format GUID the bitmap is stored in. For a list of available pixel formats, see the Native Pixel Formats topic. + + + + + Retrieves parameters from the Start Of Scan (SOS) marker for the scan with the specified index. + Microsoft Docs: + The index of the scan for which header data is retrieved. + A pointer that receives the frame header data. + + + + + Retrieves the metadata block or item identified by a metadata query expression. + Microsoft Docs: + The query expression to the requested metadata block or item. + When this method returns, contains the metadata block or item requested. + + + + + Retrieves the signing status of the component. + Microsoft Docs: + A pointer that receives the WICComponentSigning status of the component. + + + + + Saves the IWICPersistStream to the given input IStream using the given parameters. + Microsoft Docs: + The stream to save to. + The WICPersistOptions to use when saving. + Indicates whether the "dirty" value will be cleared from all metadata after saving. + + + + + Specifies the identifiers of the metadata items in an 8BIM IPTC digest metadata block. + Microsoft Docs: + + + + [VT_LPSTR] A name that identifies the 8BIM block. + + + [VT_BLOB] The embedded IPTC digest value. + + + + Enables indexing of the JPEG for efficient random access. + Microsoft Docs: + A value specifying whether indexes should be generated immediately or deferred until a future call to IWICBitmapSource::CopyPixels. + The granularity of the indexing, in pixels. + + + + + Loads data from an input stream using the given parameters. + Microsoft Docs: + Pointer to the input stream. + Pointer to the GUID of the preferred vendor . + The WICPersistOptions used to load the stream. + + + + + Notify method is documented only for compliance; its use is not recommended and may be altered or unavailable in the future. Instead, and use RegisterProgressNotification. + Microsoft Docs: + The current frame number. + The operation on which progress is being reported. + The progress value ranging from is 0.0 to 1.0. 0.0 indicates the beginning of the operation. 1.0 indicates the end of the operation. + + + + + Gets the metadata item at the given index. + Microsoft Docs: + The index of the metadata item to retrieve. + Pointer that receives the schema property. + Pointer that receives the id property. + Pointer that receives the metadata value. + + + + + Creates a new instance of IWICBitmapDecoder. + Microsoft Docs: + The GUID for the desired container format. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ValueMeaning
+
+
GUID_ContainerFormatBmp
+
+		 +The BMP container format GUID. + +
+
+
GUID_ContainerFormatPng
+
+		 +The PNG container format GUID. + +
+
+
GUID_ContainerFormatIco
+
+		 +The ICO container format GUID. + +
+
+
GUID_ContainerFormatJpeg
+
+		 +The JPEG container format GUID. + +
+
+
GUID_ContainerFormatTiff
+
+		 +The TIFF container format GUID. + +
+
+
GUID_ContainerFormatGif
+
+		 +The GIF container format GUID. + +
+
+
GUID_ContainerFormatWmp
+
+		 +The HD Photo container format GUID. + +
+ The GUID for the preferred encoder vendor. + + + + + + + + + + + + + + + + + + +
ValueMeaning
+
+
NULL
+
+		 +No preferred codec vendor. + +
+
+
GUID_VendorMicrosoft
+
+		 +Prefer to use Microsoft encoder. + +
+
+
GUID_VendorMicrosoftBuiltIn
+
+		 +Prefer to use the native Microsoft encoder. + +
+ A pointer that receives a pointer to a new IWICBitmapDecoder. You must initialize this IWICBitmapDecoder on a stream using the Initialize method later. + + + + + Gets the decoder's current progressive level. + Microsoft Docs: + Indicates the current level specified. + + + + + Sets DDS-specific data. + Microsoft Docs: + Points to the structure where the information is described. + + + + + Exposes methods that transforms an IWICBitmapSource from one color context to another. + Microsoft Docs: + + + + + Returns the size of the metadata content contained by the specified IWICMetadataWriter. The returned size accounts for the header and the length of the metadata. + Microsoft Docs: + The container GUID. + The IWICMetadataWriter that contains the content. + A pointer that receives the size of the metadata content. + + + + + Retrieves the IWICColorContext associated with the image frame. + Microsoft Docs: + The number of color contexts to retrieve. + +This value must be the size of, or smaller than, the size available to ppIColorContexts. + A pointer that receives a pointer to the IWICColorContext objects. + A pointer that receives the number of color contexts contained in the image frame. + + + + + Gets the pointer to the top left pixel in the locked rectangle. + Microsoft Docs: + A pointer that receives the size of the buffer. + A pointer that receives a pointer to the top left pixel in the locked rectangle. + + + + + Specifies the graphic control extension metadata properties that define the transitions between each frame animation for Graphics Interchange Format (GIF) images. + Microsoft Docs: + + + + [VT_UI1] Indicates the disposal requirements. 0 - no disposal, 1 - do not dispose, 2 - restore to background color, 3 - restore to previous. + + + [VT_BOOL] Indicates the user input flag. TRUE if user input should advance to the next frame; otherwise, FALSE. + + + [VT_BOOL] Indicates the transparency flag. TRUE if a transparent color in is in the color table for this frame; otherwise, FALSE. + + + [VT_UI2] Indicates how long to display the next frame before advancing to the next frame, in units of 1/100th of a second. + + + [VT_UI1] Indicates which color in the palette should be treated as transparent. + + + + Gets the current gamma setting of the raw image. + Microsoft Docs: + A pointer that receives the current gamma setting. + + + + + Gets the saturation value of the raw image. + Microsoft Docs: + A pointer that receives the saturation value of the raw image. The default value is the "as-shot" setting. The value range for saturation is 0.0 through 1.0. A value of 0.0 represents an image with a fully de-saturated image, while a value of 1.0 represents the highest amount of saturation that can be applied. + + + + + Resets the current position to the beginning of the enumeration. + Microsoft Docs: + + + + + Specifies the level to retrieve on the next call to CopyPixels. + Microsoft Docs: + Specifies which level to return next. If greater than the total number of levels supported, an error will be returned. + + + + + Writes scan data to a JPEG frame. + Microsoft Docs: + The size of the data in the pbScanData parameter. + The scan data to write. + + + + + Removes the metadata item at the specified index. + Microsoft Docs: + The index of the metadata item to remove. + + + + + Specifies the JPEG luminance table property. + Microsoft Docs: + + + + [VT_UI2|VT_VECTOR] Indicates the metadata property is a luminance table. + + + + Informs the component that the content of the stream it's holding onto may have changed. The component should respond by dirtying any cached information from the stream. + Microsoft Docs: + + + + + Exposes methods that provide additional load and save methods that take WICPersistOptions. + Microsoft Docs: + + + + + Retrieves a copy of the AC Huffman table for the specified scan and table. + Microsoft Docs: + The zero-based index of the scan for which data is retrieved. + The index of the AC Huffman table to retrieve. + A pointer that receives the table data. This parameter must not be NULL. + + + + + Determines if the metadata handler supports padding. + Microsoft Docs: + Pointer that receives TRUE if padding is supported; otherwise, FALSE. + + + + + Exposes methods for accessing and building a color table, primarily for indexed pixel formats. + Microsoft Docs: + + + + + Retrieves a metadata query reader for the frame. + Microsoft Docs: + When this method returns, contains a pointer to the frame's metadata query reader. + + + + + Specifies the DXGI_FORMAT and block information of a DDS format. + Microsoft Docs: + + + + The DXGI_FORMAT + + + The size of a single block in bytes. For DXGI_FORMAT values that are not block-based, the value is equal to the size of a single pixel in bytes. + + + The width of a single block in pixels. For DXGI_FORMAT values that are not block-based, the value is 1. + + + The height of a single block in pixels. For DXGI_FORMAT values that are not block-based, the value is 1. + + + + Gets the metadata header for the metadata writer. + Microsoft Docs: + The format container GUID to obtain the header for. + The size of the pHeader buffer. + Pointer that receives the WICMetadataHeader. + The actual size of the header. + + + + + Sets the contrast value of the raw image. + Microsoft Docs: + The contrast value of the raw image. The default value is the "as-shot" setting. The value range for contrast is 0.0 through 1.0. The 0.0 lower limit represents no contrast applied to the image, while the 1.0 upper limit represents the highest amount of contrast that can be applied. + + + + + Represents an encoder's individual image frames. + Microsoft Docs: + + + + + Creates a new instance of the IWICBitmapDecoder based on the given file handle. + Microsoft Docs: + The file handle to create the decoder from. + The GUID for the preferred decoder vendor. Use NULL if no preferred vendor. + The WICDecodeOptions to use when creating the decoder. + A pointer that receives a pointer to a new IWICBitmapDecoder. + + + + + Extends IWICPixelFormatInfo by providing additional information about a pixel format. + Microsoft Docs: + + + + + Exposes a callback method for raw image change nofications. + Microsoft Docs: + + + + + Exposes methods for color management. + Microsoft Docs: + + + + + Retrieves a value that indicates whether the codec recognizes the pattern within a specified stream. + Microsoft Docs: + The stream to pattern match within. + A pointer that receives TRUE if the patterns match; otherwise, FALSE. + + + + + Creates a new instance of the IWICStream class. + Microsoft Docs: + A pointer that receives a pointer to a new IWICStream. + + + + + Retrieves the name of the device manufacture associated with the codec. + Microsoft Docs: + The size of the device manufacture's name. Use 0 on first call to determine needed buffer size. + Receives the device manufacture's name. Use NULL on first call to determine needed buffer size. + The actual buffer size needed to retrieve the device manufacture's name. + + + + + Retrieves the color table for indexed pixel formats. + Microsoft Docs: + An IWICPalette. A palette can be created using the CreatePalette method. + + + + + Specifies when the progress notification callback should be called. + Microsoft Docs: + + + + The callback should be called when codec operations begin. + + + The callback should be called when codec operations end. + + + The callback should be called frequently to report status. + + + The callback should be called on all available progress notifications. + + + + Gets the metadata format associated with the reader. + Microsoft Docs: + Pointer that receives the metadata format GUID. + + + + + Specifies the capabilities of the decoder. + Microsoft Docs: + + + + Decoder recognizes the image was encoded with an encoder produced by the same vendor. + + + Decoder can decode all the images within an image container. + + + Decoder can decode some of the images within an image container. + + + Decoder can enumerate the metadata blocks within a container format. + + + Decoder can find and decode a thumbnail. + + + + Exposes methods that provide basic information about the registered metadata reader. + Microsoft Docs: + + + + + Fills out the supplied color array with the colors from the internal color table. The color array should be sized according to the return results from GetColorCount. + Microsoft Docs: + The size of the pColors array. + Pointer that receives the colors of the palette. + The actual size needed to obtain the palette colors. + + + + + Specifies the image descriptor metadata properties for Graphics Interchange Format (GIF) frames. + Microsoft Docs: + + + + [VT_UI2] Indicates the X offset at which to locate this frame within the logical screen. + + + [VT_UI2] Indicates the Y offset at which to locate this frame within the logical screen. + + + [VT_UI2] Indicates width of this frame, in pixels. + + + [VT_UI2] Indicates height of this frame, in pixels. + + + [VT_BOOL] Indicates the local color table flag. TRUE if global color table is present; otherwise, FALSE. + + + [VT_BOOL] Indicates the interlace flag. TRUE if image is interlaced; otherwise, FALSE. + + + [VT_BOOL] Indicates the sorted color table flag. TRUE if the color table is sorted from most frequently to least frequently used color; otherwise, FALSE. + + + [VT_UI1] Indicates the value used to calculate the number of bytes contained in the global color table. + +To calculate the actual size of the color table, raise 2 to the value of the field + 1. + + + + Specifies the memory layout of pixel data in a JPEG image scan. + Microsoft Docs: + + + + The pixel data is stored in an interleaved memory layout. + + + The pixel data is stored in a planar memory layout. + + + The pixel data is stored in a progressive layout. + + + Forces this enumeration to compile to 32 bits in size. Without this value, some compilers would allow this enumeration to compile to a size other than 32 bits. This value is not used. + + + + Obtains a metadata format GUID for a specified container format and vendor that best matches the content within a given stream. + Microsoft Docs: + The container format GUID. + The vendor GUID. + The content stream in which to match a metadata format. + A pointer that receives a metadata format GUID for the given parameters. + + + + + Obtains the short name associated with a given GUID. + Microsoft Docs: + The GUID to retrieve the short name for. + The size of the wzName buffer. + A pointer that receives the short name associated with the GUID. + The actual size needed to retrieve the entire short name associated with the GUID. + + + + + Sets the given metadata item. + Microsoft Docs: + Pointer to the schema property of the metadata item. + Pointer to the id property of the metadata item. + Pointer to the metadata value to set + + + + + Removes a metadata item from a specific location using a metadata query expression. + Microsoft Docs: + The name of the metadata item to remove. + + + + + Retrieves a copy of the quantization table. + Microsoft Docs: + The zero-based index of the scan for which data is retrieved. + The index of the quantization table to retrieve. + A pointer that receives the table data. This parameter must not be NULL. + + + + + Creates a new image encoder object. + Microsoft Docs: + The ID2D1Device object on which the corresponding image encoder is created. + A pointer to a variable that receives a pointer to the IWICImageEncoder interface for the encoder object that you can use to encode Direct2D images. + + + + + Sets the sharpness value of the raw image. + Microsoft Docs: + The sharpness value of the raw image. The default value is the "as-shot" setting. The value range for sharpness is 0.0 through 1.0. The 0.0 lower limit represents no sharpening applied to the image, while the 1.0 upper limit represents the highest amount of sharpness that can be applied. + + + + + Returns the closest dimensions the implementation can natively scale to given the desired dimensions. + Microsoft Docs: + The desired width. A pointer that receives the closest supported width. + The desired height. A pointer that receives the closest supported height. + + + + + Provides access for palette modifications. + Microsoft Docs: + The palette to use for conversion. + + + + + Sets the white point RGB values. + Microsoft Docs: + The red white point value. + The green white point value. + The blue white point value. + + + + + Initializes the frame encoder using the given properties. + Microsoft Docs: + The set of properties to use for IWICBitmapFrameEncode initialization. + + + + + Creates an IWICMetadataReader based on the given parameters. + Microsoft Docs: + The container format GUID to base the reader on. + Pointer to the vendor GUID of the metadata reader. + The WICPersistOptions and WICMetadataCreationOptions options to use when creating the metadata reader. + Pointer to a stream in which to initialize the reader with. If NULL, the metadata reader will be empty. + A pointer that receives a pointer to the new metadata reader + + + + + Gets the current rotation angle. + Microsoft Docs: + A pointer that receives the current rotation angle. + + + + + Retrieves a copy of the quantization table. + Microsoft Docs: + The zero-based index of the scan for which data is retrieved. + The index of the quantization table to retrieve. Valid indices for a given scan can be determined by retrieving the scan header with IWICJpegFrameDecode::GetScanHeader. + A pointer that receives the table data. This parameter must not be NULL. + + + + + Specifies named white balances for raw images. + Microsoft Docs: + + + + The default white balance. + + + A daylight white balance. + + + A cloudy white balance. + + + A shade white balance. + + + A tungsten white balance. + + + A fluorescent white balance. + + + Daylight white balance. + + + A flash white balance. + + + A custom white balance. This is typically used when using a picture (grey-card) as white balance. + + + An automatic balance. + + + An "as shot" white balance. + + + + Specifies the flip and rotation transforms. + Microsoft Docs: + + + + A rotation of 0 degrees. + + + A clockwise rotation of 90 degrees. + + + A clockwise rotation of 180 degrees. + + + A clockwise rotation of 270 degrees. + + + A horizontal flip. Pixels are flipped around the vertical y-axis. + + + A vertical flip. Pixels are flipped around the horizontal x-axis. + + + + Creates a new instance of the IWICComponentInfo class for the given component class identifier (CLSID). + Microsoft Docs: + The CLSID for the desired component. + A pointer that receives a pointer to a new IWICComponentInfo. + + + + + Instructs the object to produce pixels. + Microsoft Docs: + The rectangle to copy. A NULL value specifies the entire bitmap. + The stride of the bitmap + The size of the buffer. + A pointer to the buffer. + + + + + Represents a raw image tone curve. + Microsoft Docs: + + + + The number of tone curve points. + + + The array of tone curve points. + + + + Retrieves the specified frame of the image. + Microsoft Docs: + The particular frame to retrieve. + A pointer that receives a pointer to the IWICBitmapFrameDecode. + + + + + Sets the IWICColorContext objects for the encoder. + Microsoft Docs: + The number of IWICColorContext to set. + A pointer an IWICColorContext pointer containing the color contexts to set for the encoder. + + + + + Gets the pixel format's IWICColorContext. + Microsoft Docs: + Pointer that receives the pixel format's color context. + + + + + Retrieves the device manufacturer of the metadata handler. + Microsoft Docs: + The size of the wzDeviceManufacturer buffer. + Pointer to the buffer that receives the name of the device manufacturer. + The actual string buffer length needed to obtain the entire name of the device manufacturer. + + + + + Removes the metadata writer from the specified index location. + Microsoft Docs: + The index of the metadata writer to remove. + + + + + Sets the global thumbnail for the image. + Microsoft Docs: + The IWICBitmapSource to set as the global thumbnail. + + + + + Specifies the color context types. + Microsoft Docs: + + + + An uninitialized color context. + + + A color context that is a full ICC color profile. + + + A color context that is one of a number of set color spaces (sRGB, AdobeRGB) that are defined in the EXIF specification. + + + + Sets a given number IWICColorContext profiles to the frame. + Microsoft Docs: + The number of IWICColorContext profiles to set. + A pointer to an IWICColorContext pointer containing the color contexts profiles to set to the frame. + + + + + Obtains the name associated with a given schema. + Microsoft Docs: + The metadata format GUID. + The URI string of the schema for which the name is to be retrieved. + The size of the wzName buffer. + A pointer to a buffer that receives the schema's name. + +To obtain the required buffer size, call WICMapSchemaToName with cchName set to 0 and wzName set to NULL. + The actual buffer size needed to retrieve the entire schema name. + + + + + Specifies the Portable Network Graphics (PNG) iTXT chunk metadata properties. + Microsoft Docs: + + + + [VT_LPSTR] Indicates the keywords in the iTXT metadata chunk. + + + [VT_UI1] Indicates whether the text in the iTXT chunk is compressed. 1 if the text is compressed; otherwise, 0. + + + [VT_LPSTR] Indicates the human language used by the translated keyword and the text. + + + [VT_LPWSTR] Indicates a translation of the keyword into the language indicated by the language tag. + + + [VT_LPWSTR] Indicates additional text in the iTXT metadata chunk. + + + + TBD + Microsoft Docs: + The address of a WICPixelFormatNumericRepresentation variable that you've defined. On successful completion, the function sets your variable to the WICPixelFormatNumericRepresentation of the pixel format. + + + + + Creates a new frame to encode. + Microsoft Docs: + A pointer to the newly created frame object. + Points to the location where the array index is returned. + Points to the location where the mip level index is returned. + Points to the location where the slice index is returned. + + + + + Creates an IWICBitmap from a bitmap handle. + Microsoft Docs: + A bitmap handle to create the bitmap from. + A palette handle used to create the bitmap. + The alpha channel options to create the bitmap. + A pointer that receives a pointer to the new bitmap. + + + + + Specifies the JPEG chrominance table property. + Microsoft Docs: + + + + [VT_UI2|VT_VECTOR] Indicates the metadata property is a chrominance table. + + + + Represents a raw image tone curve point. + Microsoft Docs: + + + + The tone curve input. + + + The tone curve output. + + + + Removes the metadata item that matches the given parameters. + Microsoft Docs: + Pointer to the metadata schema property. + Pointer to the metadata id property. + + + diff --git a/src/Vortice.Win32/Graphics/Direct2D/Matrix4x3.cs b/src/Vortice.Win32/Graphics/Direct2D/Matrix4x3.cs index 7a9ae0b..9446d20 100644 --- a/src/Vortice.Win32/Graphics/Direct2D/Matrix4x3.cs +++ b/src/Vortice.Win32/Graphics/Direct2D/Matrix4x3.cs @@ -73,7 +73,7 @@ public readonly struct Matrix4x3 : IEquatable, IFormattable public readonly float M43; /// - /// Initializes a new instance of the struct. + /// Initializes a new instance of the struct. /// /// The value that will be assigned to all components. public Matrix4x3(float value) diff --git a/src/Vortice.Win32/Graphics/Direct3D11/UnorderedAccessViewDescription.cs b/src/Vortice.Win32/Graphics/Direct3D11/UnorderedAccessViewDescription.cs index 774278d..56e4f18 100644 --- a/src/Vortice.Win32/Graphics/Direct3D11/UnorderedAccessViewDescription.cs +++ b/src/Vortice.Win32/Graphics/Direct3D11/UnorderedAccessViewDescription.cs @@ -16,7 +16,7 @@ public unsafe partial struct UnorderedAccessViewDescription /// The index of the mipmap level to use mip slice or FirstElement for BUFFER. /// The index of the first texture to use in an array of textures or NumElements for BUFFER or FirstWSlice for TEXTURE3D. /// Number of textures in the array or WSize for TEXTURE3D. - /// options flags for the resource. + /// options flags for the resource. public UnorderedAccessViewDescription( UavDimension viewDimension, Format format = Format.Unknown, @@ -67,7 +67,7 @@ public unsafe partial struct UnorderedAccessViewDescription /// /// /// - /// options flags for the resource. + /// options flags for the resource. public UnorderedAccessViewDescription( ID3D11Buffer* buffer, Format format, diff --git a/src/Vortice.Win32/Graphics/Imaging/Apis.cs b/src/Vortice.Win32/Graphics/Imaging/Apis.cs new file mode 100644 index 0000000..e19abc8 --- /dev/null +++ b/src/Vortice.Win32/Graphics/Imaging/Apis.cs @@ -0,0 +1,20 @@ +// Copyright © Amer Koleci and Contributors. +// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information. + +using System.Runtime.CompilerServices; +using static Win32.Apis; + +namespace Win32.Graphics.Imaging; + +public static unsafe partial class Apis +{ + public static HResult CreateWICImagingFactory(IWICImagingFactory** factory) + { + return CoCreateInstance( + (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in CLSID_WICImagingFactory)), + null, + CLSCTX_INPROC_SERVER, + __uuidof(), + (void**)factory); + } +} diff --git a/src/Vortice.Win32/Graphics/Imaging/IWICImagingFactoryExtensions.cs b/src/Vortice.Win32/Graphics/Imaging/IWICImagingFactoryExtensions.cs new file mode 100644 index 0000000..787d893 --- /dev/null +++ b/src/Vortice.Win32/Graphics/Imaging/IWICImagingFactoryExtensions.cs @@ -0,0 +1,42 @@ +// Copyright © Amer Koleci and Contributors. +// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information. + +namespace Win32.Graphics.Imaging; + +/// +/// A with extensions for the type. +/// +public static unsafe class IWICImagingFactoryExtensions +{ + public static ComPtr CreateDecoderFromFilename( + this ref IWICImagingFactory factory, + string filename, + FileAccess desiredAccess = FileAccess.Read, + WICDecodeOptions metadataOptions = WICDecodeOptions.CacheOnDemand) + { + return CreateDecoderFromFilename(ref factory, filename.AsSpan(), desiredAccess, metadataOptions); + } + + public static ComPtr CreateDecoderFromFilename( + this ref IWICImagingFactory factory, + ReadOnlySpan filename, + FileAccess desiredAccess = FileAccess.Read, + WICDecodeOptions metadataOptions = WICDecodeOptions.CacheOnDemand) + { + NativeFileAccess nativeAccess = desiredAccess.ToNative(); + + using ComPtr decoder = default; + + fixed (char* filenamePtr = filename) + { + factory.CreateDecoderFromFilename( + (ushort*)filenamePtr, + null, + nativeAccess, + metadataOptions, + decoder.GetAddressOf()).ThrowIfFailed(); + + return decoder.Move(); + } + } +} diff --git a/src/Vortice.Win32/NativeFileAccess.cs b/src/Vortice.Win32/NativeFileAccess.cs new file mode 100644 index 0000000..fbdc0cc --- /dev/null +++ b/src/Vortice.Win32/NativeFileAccess.cs @@ -0,0 +1,34 @@ +// Copyright © Amer Koleci and Contributors. +// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information. + +namespace Win32; + +[Flags] +public enum NativeFileAccess : uint +{ + None = 0, + [NativeTypeName("#define GENERIC_READ (0x80000000L)")] + GenericRead = 0x80000000u, + [NativeTypeName("#define GENERIC_WRITE (0x40000000L)")] + GenericWrite = 0x40000000u, +} + +public static class NativeFileAccessExtensions +{ + public static NativeFileAccess ToNative(this FileAccess access) + { + switch (access) + { + case FileAccess.Read: + return NativeFileAccess.GenericRead; + + case FileAccess.Write: + return NativeFileAccess.GenericWrite; + + case FileAccess.ReadWrite: + return NativeFileAccess.GenericRead | NativeFileAccess.GenericWrite; + default: + return NativeFileAccess.None; + } + } +} diff --git a/src/Vortice.Win32/Win32.cs b/src/Vortice.Win32/Win32.cs index 4ed84eb..4c96e2e 100644 --- a/src/Vortice.Win32/Win32.cs +++ b/src/Vortice.Win32/Win32.cs @@ -3,10 +3,7 @@ using System.ComponentModel; -using System.Diagnostics; -using System.Diagnostics.CodeAnalysis; using System.Runtime.CompilerServices; -using System.Runtime.InteropServices.ComTypes; namespace Win32; @@ -87,6 +84,13 @@ public static unsafe partial class Apis } } + public const int CLSCTX_INPROC_SERVER = 0x1; + public const int CLSCTX_INPROC_HANDLER = 0x2; + public const int CLSCTX_LOCAL_SERVER = 0x4; + public const int CLSCTX_INPROC_SERVER16 = 0x8; + public const int CLSCTX_REMOTE_SERVER = 0x10; + public const int CLSCTX_INPROC_HANDLER16 = 0x20; + [DllImport("ole32", ExactSpelling = true)] - public static extern HResult CoCreateInstance([NativeTypeName("const IID &")] Guid* rclsid, [NativeTypeName("LPUNKNOWN")] IUnknown* pUnkOuter, [NativeTypeName("DWORD")] uint dwClsContext, [NativeTypeName("const IID &")] Guid* riid, [NativeTypeName("LPVOID *")] void** ppv); + public static extern HResult CoCreateInstance(Guid* rclsid, IUnknown* pUnkOuter, uint dwClsContext, Guid* riid, void** ppv); } diff --git a/src/samples/01-ClearScreen/01-ClearScreen.csproj b/src/samples/01-ClearScreen/01-ClearScreen.csproj index 9b0e04f..9bae638 100644 --- a/src/samples/01-ClearScreen/01-ClearScreen.csproj +++ b/src/samples/01-ClearScreen/01-ClearScreen.csproj @@ -1,12 +1,18 @@ Exe - net461;net6.0 + net6.0 true false ClearScreen + + + + + + diff --git a/src/samples/01-ClearScreen/Assets/Textures/10points.png b/src/samples/01-ClearScreen/Assets/Textures/10points.png new file mode 100644 index 0000000..a932146 Binary files /dev/null and b/src/samples/01-ClearScreen/Assets/Textures/10points.png differ diff --git a/src/samples/01-ClearScreen/Program.cs b/src/samples/01-ClearScreen/Program.cs index ab06344..8c69de1 100644 --- a/src/samples/01-ClearScreen/Program.cs +++ b/src/samples/01-ClearScreen/Program.cs @@ -14,6 +14,10 @@ using Win32.Graphics.Dxgi.Common; using System.Numerics; using Win32.Graphics.Direct3D.Dxc; using static Win32.Graphics.Direct3D.Dxc.Apis; +using System.Runtime.CompilerServices; +using System.Security.Claims; +using Win32.Graphics.Imaging; +using static Win32.Graphics.Imaging.Apis; namespace ClearScreen; @@ -45,9 +49,27 @@ public static unsafe class Program DxcCreateInstance(CLSID_DxcCompiler, __uuidof(), compiler.GetVoidAddressOf()); } + private static void TestWic() + { + string assetsPath = Path.Combine(AppContext.BaseDirectory, "Assets", "Textures"); + string textureFile = Path.Combine(assetsPath, "10points.png"); + + using ComPtr wicImagingFactory = default; + + CreateWICImagingFactory(wicImagingFactory.GetAddressOf()).ThrowIfFailed(); + + using ComPtr decoder = wicImagingFactory.Get()->CreateDecoderFromFilename(textureFile); + + using ComPtr wicBitmapFrameDecode = default; + + // Get the first frame of the loaded image (if more are present, they will be ignored) + decoder.Get()->GetFrame(0, wicBitmapFrameDecode.GetAddressOf()).ThrowIfFailed(); + } + public static void Main() { TestDxc(); + TestWic(); using ComPtr factory = default; uint factoryFlags = 0;