mirror of https://github.com/dahall/Vanara.git
1739 lines
92 KiB
C#
1739 lines
92 KiB
C#
using System;
|
|
|
|
namespace Vanara.PInvoke
|
|
{
|
|
/// <summary>Items from the WindowsCodecs.dll</summary>
|
|
public static partial class WindowsCodecs
|
|
{
|
|
/// <summary>
|
|
/// The format of the quantization table indices. Use one of the following constants, described in IWICJpegFrameDecode Constants.
|
|
/// </summary>
|
|
[PInvokeData("wincodec.h", MSDNShortId = "87A36F9B-CD6B-4343-AAA7-9FDBAD41E38A")]
|
|
public enum WIC_JPEG_HUFFMAN_BASELINE
|
|
{
|
|
/// <summary/>
|
|
WIC_JPEG_HUFFMAN_BASELINE_ONE = 0,
|
|
|
|
/// <summary/>
|
|
WIC_JPEG_HUFFMAN_BASELINE_THREE = 0x111100
|
|
}
|
|
|
|
/// <summary>
|
|
/// The format of the quantization table indices. Use one of the following constants, described in IWICJpegFrameDecode Constants.
|
|
/// </summary>
|
|
[PInvokeData("wincodec.h", MSDNShortId = "BB207D78-9E27-49A4-91E4-601CED109389")]
|
|
public enum WIC_JPEG_QUANTIZATION_BASELINE
|
|
{
|
|
/// <summary/>
|
|
WIC_JPEG_QUANTIZATION_BASELINE_ONE = 0,
|
|
|
|
/// <summary/>
|
|
WIC_JPEG_QUANTIZATION_BASELINE_THREE = 0x10100,
|
|
}
|
|
|
|
/// <summary>The sample factors. Use one of the following constants, described in IWICJpegFrameDecode Constants.</summary>
|
|
[PInvokeData("wincodec.h", MSDNShortId = "BB207D78-9E27-49A4-91E4-601CED109389")]
|
|
public enum WIC_JPEG_SAMPLE_FACTORS
|
|
{
|
|
/// <summary/>
|
|
WIC_JPEG_SAMPLE_FACTORS_ONE = 0x11,
|
|
|
|
/// <summary/>
|
|
WIC_JPEG_SAMPLE_FACTORS_THREE_420 = 0x111122,
|
|
|
|
/// <summary/>
|
|
WIC_JPEG_SAMPLE_FACTORS_THREE_422 = 0x111121,
|
|
|
|
/// <summary/>
|
|
WIC_JPEG_SAMPLE_FACTORS_THREE_440 = 0x111112,
|
|
|
|
/// <summary/>
|
|
WIC_JPEG_SAMPLE_FACTORS_THREE_444 = 0x111111,
|
|
}
|
|
|
|
/// <summary>Specifies the identifiers of the metadata items in an 8BIM IPTC digest metadata block.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wic8bimiptcdigestproperties typedef enum
|
|
// WIC8BIMIptcDigestProperties { WIC8BIMIptcDigestPString, WIC8BIMIptcDigestIptcDigest, WIC8BIMIptcDigestProperties_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "b0dbd1fa-face-4f6f-a943-60d108388b97")]
|
|
public enum WIC8BIMIptcDigestProperties
|
|
{
|
|
/// <summary>[VT_LPSTR] A name that identifies the 8BIM block.</summary>
|
|
WIC8BIMIptcDigestPString = 1,
|
|
|
|
/// <summary>[VT_BLOB] The embedded IPTC digest value.</summary>
|
|
WIC8BIMIptcDigestIptcDigest,
|
|
|
|
/// <summary/>
|
|
WIC8BIMIptcDigestProperties_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the identifiers of the metadata items in an 8BIM IPTC block.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wic8bimiptcproperties typedef enum WIC8BIMIptcProperties
|
|
// { WIC8BIMIptcPString, WIC8BIMIptcEmbeddedIPTC, WIC8BIMIptcProperties_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "c752790c-6392-4406-b006-8f5da9f4e23d")]
|
|
public enum WIC8BIMIptcProperties
|
|
{
|
|
/// <summary>[VT_LPSTR] A name that identifies the 8BIM block.</summary>
|
|
WIC8BIMIptcPString,
|
|
|
|
/// <summary/>
|
|
WIC8BIMIptcEmbeddedIPTC,
|
|
|
|
/// <summary/>
|
|
WIC8BIMIptcProperties_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the identifiers of the metadata items in an 8BIMResolutionInfo block.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wic8bimresolutioninfoproperties typedef enum
|
|
// WIC8BIMResolutionInfoProperties { WIC8BIMResolutionInfoPString, WIC8BIMResolutionInfoHResolution,
|
|
// WIC8BIMResolutionInfoHResolutionUnit, WIC8BIMResolutionInfoWidthUnit, WIC8BIMResolutionInfoVResolution,
|
|
// WIC8BIMResolutionInfoVResolutionUnit, WIC8BIMResolutionInfoHeightUnit, WIC8BIMResolutionInfoProperties_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "a5bb984a-290c-4dd6-8b94-b8a221e78a6b")]
|
|
public enum WIC8BIMResolutionInfoProperties
|
|
{
|
|
/// <summary>[VT_LPSTR] A name that identifies the 8BIM block.</summary>
|
|
WIC8BIMResolutionInfoPString = 1,
|
|
|
|
/// <summary>[VT_UI4] The horizontal resolution of the image.</summary>
|
|
WIC8BIMResolutionInfoHResolution,
|
|
|
|
/// <summary>
|
|
/// [VT_UI2] The units that the horizontal resolution is specified in; a 1 indicates pixels per inch and a 2 indicates pixels
|
|
/// per centimeter.
|
|
/// </summary>
|
|
WIC8BIMResolutionInfoHResolutionUnit,
|
|
|
|
/// <summary>
|
|
/// [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.
|
|
/// </summary>
|
|
WIC8BIMResolutionInfoWidthUnit,
|
|
|
|
/// <summary>[VT_UI4] The vertical resolution of the image.</summary>
|
|
WIC8BIMResolutionInfoVResolution,
|
|
|
|
/// <summary>
|
|
/// [VT_UI2] The units that the vertical resolution is specified in; a 1 indicates pixels per inch and a 2 indicates pixels per centimeter.
|
|
/// </summary>
|
|
WIC8BIMResolutionInfoVResolutionUnit,
|
|
|
|
/// <summary>
|
|
/// [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.
|
|
/// </summary>
|
|
WIC8BIMResolutionInfoHeightUnit,
|
|
|
|
/// <summary/>
|
|
WIC8BIMResolutionInfoProperties_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the desired alpha channel usage.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicbitmapalphachanneloption typedef enum
|
|
// WICBitmapAlphaChannelOption { WICBitmapUseAlpha, WICBitmapUsePremultipliedAlpha, WICBitmapIgnoreAlpha,
|
|
// WICBITMAPALPHACHANNELOPTIONS_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "caa10c35-9af4-4310-b031-3347cf795087")]
|
|
public enum WICBitmapAlphaChannelOption
|
|
{
|
|
/// <summary>Use alpha channel.</summary>
|
|
WICBitmapUseAlpha,
|
|
|
|
/// <summary>Use a pre-multiplied alpha channel.</summary>
|
|
WICBitmapUsePremultipliedAlpha,
|
|
|
|
/// <summary>Ignore alpha channel.</summary>
|
|
WICBitmapIgnoreAlpha,
|
|
|
|
/// <summary>Sentinel value.</summary>
|
|
WICBITMAPALPHACHANNELOPTIONS_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the desired cache usage.</summary>
|
|
/// <remarks>
|
|
/// The <c>CreateBitmap</c> of the IWICImagingFactory interface does not support WICBitmapNoCache when the pixelFormat is a native
|
|
/// pixel format provided by Windows Imaging Component (WIC).
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicbitmapcreatecacheoption typedef enum
|
|
// WICBitmapCreateCacheOption { WICBitmapNoCache, WICBitmapCacheOnDemand, WICBitmapCacheOnLoad,
|
|
// WICBITMAPCREATECACHEOPTION_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "121d394d-e818-44c5-bf44-3b01df61c780")]
|
|
[Flags]
|
|
public enum WICBitmapCreateCacheOption
|
|
{
|
|
/// <summary>Do not cache the bitmap.</summary>
|
|
WICBitmapNoCache = 0,
|
|
|
|
/// <summary>Cache the bitmap when needed.</summary>
|
|
WICBitmapCacheOnDemand = 0x01,
|
|
|
|
/// <summary>Cache the bitmap at initialization.</summary>
|
|
WICBitmapCacheOnLoad = 0x02,
|
|
|
|
/// <summary/>
|
|
WICBITMAPCREATECACHEOPTION_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the capabilities of the decoder.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicbitmapdecodercapabilities typedef enum
|
|
// WICBitmapDecoderCapabilities { WICBitmapDecoderCapabilitySameEncoder, WICBitmapDecoderCapabilityCanDecodeAllImages,
|
|
// WICBitmapDecoderCapabilityCanDecodeSomeImages, WICBitmapDecoderCapabilityCanEnumerateMetadata,
|
|
// WICBitmapDecoderCapabilityCanDecodeThumbnail, WICBITMAPDECODERCAPABILITIES_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "e501b8f7-3c99-461d-be92-dca80f5657c5")]
|
|
[Flags]
|
|
public enum WICBitmapDecoderCapabilities
|
|
{
|
|
/// <summary>Decoder recognizes the image was encoded with an encoder produced by the same vendor.</summary>
|
|
WICBitmapDecoderCapabilitySameEncoder = 0x1,
|
|
|
|
/// <summary>Decoder can decode all the images within an image container.</summary>
|
|
WICBitmapDecoderCapabilityCanDecodeAllImages = 0x2,
|
|
|
|
/// <summary>Decoder can decode some of the images within an image container.</summary>
|
|
WICBitmapDecoderCapabilityCanDecodeSomeImages = 0x4,
|
|
|
|
/// <summary>Decoder can enumerate the metadata blocks within a container format.</summary>
|
|
WICBitmapDecoderCapabilityCanEnumerateMetadata = 0x8,
|
|
|
|
/// <summary>Decoder can find and decode a thumbnail.</summary>
|
|
WICBitmapDecoderCapabilityCanDecodeThumbnail = 0x10,
|
|
|
|
/// <summary/>
|
|
WICBITMAPDECODERCAPABILITIES_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the type of dither algorithm to apply when converting between image formats.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicbitmapdithertype typedef enum WICBitmapDitherType {
|
|
// WICBitmapDitherTypeNone, WICBitmapDitherTypeSolid, WICBitmapDitherTypeOrdered4x4, WICBitmapDitherTypeOrdered8x8,
|
|
// WICBitmapDitherTypeOrdered16x16, WICBitmapDitherTypeSpiral4x4, WICBitmapDitherTypeSpiral8x8, WICBitmapDitherTypeDualSpiral4x4,
|
|
// WICBitmapDitherTypeDualSpiral8x8, WICBitmapDitherTypeErrorDiffusion, WICBITMAPDITHERTYPE_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "e3fd8f37-8ea9-4cdb-853b-d5119b7afdc9")]
|
|
public enum WICBitmapDitherType
|
|
{
|
|
/// <summary>A solid color algorithm without dither.</summary>
|
|
WICBitmapDitherTypeNone = 0,
|
|
|
|
/// <summary>A solid color algorithm without dither.</summary>
|
|
WICBitmapDitherTypeSolid = WICBitmapDitherTypeNone,
|
|
|
|
/// <summary>A 4x4 ordered dither algorithm.</summary>
|
|
WICBitmapDitherTypeOrdered4x4,
|
|
|
|
/// <summary>An 8x8 ordered dither algorithm.</summary>
|
|
WICBitmapDitherTypeOrdered8x8,
|
|
|
|
/// <summary>A 16x16 ordered dither algorithm.</summary>
|
|
WICBitmapDitherTypeOrdered16x16,
|
|
|
|
/// <summary>A 4x4 spiral dither algorithm.</summary>
|
|
WICBitmapDitherTypeSpiral4x4,
|
|
|
|
/// <summary>An 8x8 spiral dither algorithm.</summary>
|
|
WICBitmapDitherTypeSpiral8x8,
|
|
|
|
/// <summary>A 4x4 dual spiral dither algorithm.</summary>
|
|
WICBitmapDitherTypeDualSpiral4x4,
|
|
|
|
/// <summary>An 8x8 dual spiral dither algorithm.</summary>
|
|
WICBitmapDitherTypeDualSpiral8x8,
|
|
|
|
/// <summary>An error diffusion algorithm.</summary>
|
|
WICBitmapDitherTypeErrorDiffusion,
|
|
|
|
/// <summary/>
|
|
WICBITMAPDITHERTYPE_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the cache options available for an encoder.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicbitmapencodercacheoption typedef enum
|
|
// WICBitmapEncoderCacheOption { WICBitmapEncoderCacheInMemory, WICBitmapEncoderCacheTempFile, WICBitmapEncoderNoCache,
|
|
// WICBITMAPENCODERCACHEOPTION_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "cc23cd53-f29b-4e4e-a3d9-038c6f0c5629")]
|
|
[Flags]
|
|
public enum WICBitmapEncoderCacheOption
|
|
{
|
|
/// <summary>The encoder is cached in memory. This option is not supported.</summary>
|
|
WICBitmapEncoderCacheInMemory = 0,
|
|
|
|
/// <summary>The encoder is cached to a temporary file. This option is not supported.</summary>
|
|
WICBitmapEncoderCacheTempFile = 0x1,
|
|
|
|
/// <summary>The encoder is not cached.</summary>
|
|
WICBitmapEncoderNoCache = 0x2,
|
|
|
|
/// <summary/>
|
|
WICBITMAPENCODERCACHEOPTION_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the sampling or filtering mode to use when scaling an image.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicbitmapinterpolationmode typedef enum
|
|
// WICBitmapInterpolationMode { WICBitmapInterpolationModeNearestNeighbor, WICBitmapInterpolationModeLinear,
|
|
// WICBitmapInterpolationModeCubic, WICBitmapInterpolationModeFant, WICBitmapInterpolationModeHighQualityCubic,
|
|
// WICBITMAPINTERPOLATIONMODE_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "7c707ab7-7cd5-418f-921c-e9114da92f2a")]
|
|
public enum WICBitmapInterpolationMode
|
|
{
|
|
/// <summary>
|
|
/// 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.
|
|
/// </summary>
|
|
WICBitmapInterpolationModeNearestNeighbor,
|
|
|
|
/// <summary>
|
|
/// A bilinear interpolation algorithm. The output pixel values are computed as a weighted average of the nearest four pixels in
|
|
/// a 2x2 grid.
|
|
/// </summary>
|
|
WICBitmapInterpolationModeLinear,
|
|
|
|
/// <summary>
|
|
/// A bicubic interpolation algorithm. Destination pixel values are computed as a weighted average of the nearest sixteen pixels
|
|
/// in a 4x4 grid.
|
|
/// </summary>
|
|
WICBitmapInterpolationModeCubic,
|
|
|
|
/// <summary>
|
|
/// A Fant resampling algorithm. Destination pixel values are computed as a weighted average of the all the pixels that map to
|
|
/// the new pixel.
|
|
/// </summary>
|
|
WICBitmapInterpolationModeFant,
|
|
|
|
/// <summary>
|
|
/// 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.
|
|
/// </summary>
|
|
WICBitmapInterpolationModeHighQualityCubic,
|
|
|
|
/// <summary/>
|
|
WICBITMAPINTERPOLATIONMODE_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies access to an IWICBitmap.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicbitmaplockflags typedef enum WICBitmapLockFlags {
|
|
// WICBitmapLockRead, WICBitmapLockWrite, WICBITMAPLOCKFLAGS_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "d4d1bb38-3d1a-4e1e-a889-0491f3c01822")]
|
|
[Flags]
|
|
public enum WICBitmapLockFlags
|
|
{
|
|
/// <summary>A read access lock.</summary>
|
|
WICBitmapLockRead = 1,
|
|
|
|
/// <summary>A write access lock.</summary>
|
|
WICBitmapLockWrite = 2,
|
|
|
|
/// <summary/>
|
|
WICBITMAPLOCKFLAGS_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the type of palette used for an indexed image format.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicbitmappalettetype typedef enum WICBitmapPaletteType {
|
|
// WICBitmapPaletteTypeCustom, WICBitmapPaletteTypeMedianCut, WICBitmapPaletteTypeFixedBW, WICBitmapPaletteTypeFixedHalftone8,
|
|
// WICBitmapPaletteTypeFixedHalftone27, WICBitmapPaletteTypeFixedHalftone64, WICBitmapPaletteTypeFixedHalftone125,
|
|
// WICBitmapPaletteTypeFixedHalftone216, WICBitmapPaletteTypeFixedWebPalette, WICBitmapPaletteTypeFixedHalftone252,
|
|
// WICBitmapPaletteTypeFixedHalftone256, WICBitmapPaletteTypeFixedGray4, WICBitmapPaletteTypeFixedGray16,
|
|
// WICBitmapPaletteTypeFixedGray256, WICBITMAPPALETTETYPE_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "a8192905-2bae-4760-bf2d-64640c46e168")]
|
|
public enum WICBitmapPaletteType
|
|
{
|
|
/// <summary>An arbitrary custom palette provided by caller.</summary>
|
|
WICBitmapPaletteTypeCustom,
|
|
|
|
/// <summary>An optimal palette generated using a median-cut algorithm. Derived from the colors in an image.</summary>
|
|
WICBitmapPaletteTypeMedianCut,
|
|
|
|
/// <summary>A black and white palette.</summary>
|
|
WICBitmapPaletteTypeFixedBW,
|
|
|
|
/// <summary>
|
|
/// A palette that has its 8-color on-off primaries and the 16 system colors added. With duplicates removed, 16 colors are available.
|
|
/// </summary>
|
|
WICBitmapPaletteTypeFixedHalftone8,
|
|
|
|
/// <summary>
|
|
/// 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.
|
|
/// </summary>
|
|
WICBitmapPaletteTypeFixedHalftone27,
|
|
|
|
/// <summary>
|
|
/// 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.
|
|
/// </summary>
|
|
WICBitmapPaletteTypeFixedHalftone64,
|
|
|
|
/// <summary>
|
|
/// 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.
|
|
/// </summary>
|
|
WICBitmapPaletteTypeFixedHalftone125,
|
|
|
|
/// <summary>
|
|
/// 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.
|
|
/// </summary>
|
|
WICBitmapPaletteTypeFixedHalftone216,
|
|
|
|
/// <summary>
|
|
/// 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.
|
|
/// </summary>
|
|
WICBitmapPaletteTypeFixedWebPalette = WICBitmapPaletteTypeFixedHalftone216,
|
|
|
|
/// <summary>
|
|
/// A palette that has its 252-color on-off primaries and the 16 system colors added. With duplicates removed, 256 colors are available.
|
|
/// </summary>
|
|
WICBitmapPaletteTypeFixedHalftone252,
|
|
|
|
/// <summary>
|
|
/// A palette that has its 256-color on-off primaries and the 16 system colors added. With duplicates removed, 256 colors are available.
|
|
/// </summary>
|
|
WICBitmapPaletteTypeFixedHalftone256,
|
|
|
|
/// <summary>A palette that has 4 shades of gray.</summary>
|
|
WICBitmapPaletteTypeFixedGray4,
|
|
|
|
/// <summary>A palette that has 16 shades of gray.</summary>
|
|
WICBitmapPaletteTypeFixedGray16,
|
|
|
|
/// <summary>A palette that has 256 shades of gray.</summary>
|
|
WICBitmapPaletteTypeFixedGray256,
|
|
|
|
/// <summary/>
|
|
WICBITMAPPALETTETYPE_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the flip and rotation transforms.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicbitmaptransformoptions typedef enum
|
|
// WICBitmapTransformOptions { WICBitmapTransformRotate0, WICBitmapTransformRotate90, WICBitmapTransformRotate180,
|
|
// WICBitmapTransformRotate270, WICBitmapTransformFlipHorizontal, WICBitmapTransformFlipVertical,
|
|
// WICBITMAPTRANSFORMOPTIONS_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "e123bb4d-bc75-4f3f-98f1-bea9b008498b")]
|
|
[Flags]
|
|
public enum WICBitmapTransformOptions
|
|
{
|
|
/// <summary>A rotation of 0 degrees.</summary>
|
|
WICBitmapTransformRotate0,
|
|
|
|
/// <summary>A clockwise rotation of 90 degrees.</summary>
|
|
WICBitmapTransformRotate90,
|
|
|
|
/// <summary>A clockwise rotation of 180 degrees.</summary>
|
|
WICBitmapTransformRotate180,
|
|
|
|
/// <summary>A clockwise rotation of 270 degrees.</summary>
|
|
WICBitmapTransformRotate270,
|
|
|
|
/// <summary>A horizontal flip. Pixels are flipped around the vertical y-axis.</summary>
|
|
WICBitmapTransformFlipHorizontal = 0x8,
|
|
|
|
/// <summary>A vertical flip. Pixels are flipped around the horizontal x-axis.</summary>
|
|
WICBitmapTransformFlipVertical = 0x10,
|
|
|
|
/// <summary/>
|
|
WICBITMAPTRANSFORMOPTIONS_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the color context types.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wiccolorcontexttype typedef enum WICColorContextType {
|
|
// WICColorContextUninitialized, WICColorContextProfile, WICColorContextExifColorSpace } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "30fab53b-8edf-488c-a6f2-5224b94e0500")]
|
|
public enum WICColorContextType
|
|
{
|
|
/// <summary>An uninitialized color context.</summary>
|
|
WICColorContextUninitialized,
|
|
|
|
/// <summary>A color context that is a full ICC color profile.</summary>
|
|
WICColorContextProfile,
|
|
|
|
/// <summary>A color context that is one of a number of set color spaces (sRGB, AdobeRGB) that are defined in the EXIF specification.</summary>
|
|
WICColorContextExifColorSpace,
|
|
}
|
|
|
|
/// <summary>Specifies component enumeration options.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wiccomponentenumerateoptions typedef enum
|
|
// WICComponentEnumerateOptions { WICComponentEnumerateDefault, WICComponentEnumerateRefresh, WICComponentEnumerateDisabled,
|
|
// WICComponentEnumerateUnsigned, WICComponentEnumerateBuiltInOnly, WICCOMPONENTENUMERATEOPTIONS_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "52cc0860-6164-4400-8e81-03eb0c44904e")]
|
|
[Flags]
|
|
public enum WICComponentEnumerateOptions : uint
|
|
{
|
|
/// <summary>
|
|
/// Enumerate any components that are not disabled. Because this value is 0x0, it is always included with the other options.
|
|
/// </summary>
|
|
WICComponentEnumerateDefault = 0x0,
|
|
|
|
/// <summary>Force a read of the registry before enumerating components.</summary>
|
|
WICComponentEnumerateRefresh = 0x1,
|
|
|
|
/// <summary>
|
|
/// Include disabled components in the enumeration. The set of disabled components is disjoint with the set of default
|
|
/// enumerated components
|
|
/// </summary>
|
|
WICComponentEnumerateDisabled = 0x80000000,
|
|
|
|
/// <summary>Include unsigned components in the enumeration. This option has no effect.</summary>
|
|
WICComponentEnumerateUnsigned = 0x40000000,
|
|
|
|
/// <summary>At the end of component enumeration, filter out any components that are not Windows provided.</summary>
|
|
WICComponentEnumerateBuiltInOnly = 0x20000000,
|
|
|
|
/// <summary/>
|
|
WICCOMPONENTENUMERATEOPTIONS_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the component signing status.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wiccomponentsigning typedef enum WICComponentSigning {
|
|
// WICComponentSigned, WICComponentUnsigned, WICComponentSafe, WICComponentDisabled, WICCOMPONENTSIGNING_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "64f3de6d-15da-4cc8-ad74-57759bcd4d07")]
|
|
[Flags]
|
|
public enum WICComponentSigning : uint
|
|
{
|
|
/// <summary>A signed component.</summary>
|
|
WICComponentSigned = 0x1,
|
|
|
|
/// <summary>An unsigned component</summary>
|
|
WICComponentUnsigned = 0x2,
|
|
|
|
/// <summary>
|
|
/// A component is safe. Components that do not have a binary component to sign, such as a pixel format, should return this value.
|
|
/// </summary>
|
|
WICComponentSafe = 0x4,
|
|
|
|
/// <summary>A component has been disabled.</summary>
|
|
WICComponentDisabled = 0x80000000,
|
|
|
|
/// <summary/>
|
|
WICCOMPONENTSIGNING_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the type of Windows Imaging Component (WIC) component.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wiccomponenttype typedef enum WICComponentType {
|
|
// WICDecoder, WICEncoder, WICPixelFormatConverter, WICMetadataReader, WICMetadataWriter, WICPixelFormat, WICAllComponents,
|
|
// WICCOMPONENTTYPE_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "eff6b77c-ea4b-4476-8d75-dec5bb2e1745")]
|
|
[Flags]
|
|
public enum WICComponentType
|
|
{
|
|
/// <summary>A WIC decoder.</summary>
|
|
WICDecoder = 0x1,
|
|
|
|
/// <summary>A WIC encoder.</summary>
|
|
WICEncoder = 0x2,
|
|
|
|
/// <summary>A WIC pixel converter.</summary>
|
|
WICPixelFormatConverter = 0x4,
|
|
|
|
/// <summary>A WIC metadata reader.</summary>
|
|
WICMetadataReader = 0x8,
|
|
|
|
/// <summary>A WIC metadata writer.</summary>
|
|
WICMetadataWriter = 0x10,
|
|
|
|
/// <summary>A WIC pixel format.</summary>
|
|
WICPixelFormat = 0x20,
|
|
|
|
/// <summary>All WIC components.</summary>
|
|
WICAllComponents = 0x3f,
|
|
|
|
/// <summary/>
|
|
WICCOMPONENTTYPE_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the the meaning of pixel color component values contained in the DDS image.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicddsalphamode typedef enum WICDdsAlphaMode {
|
|
// WICDdsAlphaModeUnknown, WICDdsAlphaModeStraight, WICDdsAlphaModePremultiplied, WICDdsAlphaModeOpaque, WICDdsAlphaModeCustom,
|
|
// WICDDSALPHAMODE_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "67C9B07F-5259-4032-9EBF-CBC3B8637343")]
|
|
public enum WICDdsAlphaMode
|
|
{
|
|
/// <summary>Alpha behavior is unspecified and must be determined by the reader.</summary>
|
|
WICDdsAlphaModeUnknown,
|
|
|
|
/// <summary>The alpha data is straight.</summary>
|
|
WICDdsAlphaModeStraight,
|
|
|
|
/// <summary>The alpha data is premultiplied.</summary>
|
|
WICDdsAlphaModePremultiplied,
|
|
|
|
/// <summary>
|
|
/// 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.
|
|
/// </summary>
|
|
WICDdsAlphaModeOpaque,
|
|
|
|
/// <summary>The alpha channel contains custom data that is not alpha.</summary>
|
|
WICDdsAlphaModeCustom,
|
|
|
|
/// <summary/>
|
|
WICDDSALPHAMODE_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the dimension type of the data contained in DDS image.</summary>
|
|
/// <remarks>
|
|
/// Both <c>WICDdsTexture2d</c> and <c>WICDdsTextureCube</c> correspond to D3D11_RESOURCE_DIMENSION_TEXTURE2D. When using
|
|
/// ID3D11Device::CreateTexture2D, they are distinguished by the flag D3D11_RESOURCE_MISC_TEXTURECUBE in the structure D3D11_TEXTURE2D_DESC.
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicddsdimension typedef enum WICDdsDimension {
|
|
// WICDdsTexture1D, WICDdsTexture2D, WICDdsTexture3D, WICDdsTextureCube, WICDDSTEXTURE_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "76CEBFD7-EE7D-48C4-9F88-9AD82C9FED55")]
|
|
public enum WICDdsDimension
|
|
{
|
|
/// <summary>DDS image contains a 1-dimensional texture .</summary>
|
|
WICDdsTexture1D,
|
|
|
|
/// <summary>DDS image contains a 2-dimensional texture .</summary>
|
|
WICDdsTexture2D,
|
|
|
|
/// <summary>DDS image contains a 3-dimensional texture .</summary>
|
|
WICDdsTexture3D,
|
|
|
|
/// <summary>The DDS image contains a cube texture represented as an array of 6 faces.</summary>
|
|
WICDdsTextureCube,
|
|
|
|
/// <summary/>
|
|
WICDDSTEXTURE_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies decode options.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicdecodeoptions typedef enum WICDecodeOptions {
|
|
// WICDecodeMetadataCacheOnDemand, WICDecodeMetadataCacheOnLoad, WICMETADATACACHEOPTION_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "27b9d6e1-e171-4c7f-8f96-fa5a93923e35")]
|
|
[Flags]
|
|
public enum WICDecodeOptions
|
|
{
|
|
/// <summary>Cache metadata when needed.</summary>
|
|
WICDecodeMetadataCacheOnDemand = 0,
|
|
|
|
/// <summary>Cache metadata when decoder is loaded.</summary>
|
|
WICDecodeMetadataCacheOnLoad = 0x1,
|
|
|
|
/// <summary/>
|
|
WICMETADATACACHEOPTION_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the application extension metadata properties for a Graphics Interchange Format (GIF) image.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicgifapplicationextensionproperties typedef enum
|
|
// WICGifApplicationExtensionProperties { WICGifApplicationExtensionApplication, WICGifApplicationExtensionData,
|
|
// WICGifApplicationExtensionProperties_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "e60da197-2510-4a13-91e3-896d6027ee57")]
|
|
public enum WICGifApplicationExtensionProperties
|
|
{
|
|
/// <summary>[VT_UI1|VT_VECTOR] Indicates a string that identifies the application.</summary>
|
|
WICGifApplicationExtensionApplication = 1,
|
|
|
|
/// <summary>[VT_UI1|VT_VECTOR] Indicates data that is exposed by the application.</summary>
|
|
WICGifApplicationExtensionData,
|
|
|
|
/// <summary/>
|
|
WICGifApplicationExtensionProperties_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the comment extension metadata properties for a Graphics Interchange Format (GIF) image.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicgifcommentextensionproperties typedef enum
|
|
// WICGifCommentExtensionProperties { WICGifCommentExtensionText, WICGifCommentExtensionProperties_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "900f1c1e-e8d2-4cee-acba-c9c2a45e9bcb")]
|
|
public enum WICGifCommentExtensionProperties
|
|
{
|
|
/// <summary>[VT_LPSTR] Indicates the comment text.</summary>
|
|
WICGifCommentExtensionText = 1,
|
|
|
|
/// <summary/>
|
|
WICGifCommentExtensionProperties_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>
|
|
/// Specifies the graphic control extension metadata properties that define the transitions between each frame animation for
|
|
/// Graphics Interchange Format (GIF) images.
|
|
/// </summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicgifgraphiccontrolextensionproperties typedef enum
|
|
// WICGifGraphicControlExtensionProperties { WICGifGraphicControlExtensionDisposal, WICGifGraphicControlExtensionUserInputFlag,
|
|
// WICGifGraphicControlExtensionTransparencyFlag, WICGifGraphicControlExtensionDelay,
|
|
// WICGifGraphicControlExtensionTransparentColorIndex, WICGifGraphicControlExtensionProperties_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "32fbf62d-0479-4ead-8246-6c757467ccaa")]
|
|
public enum WICGifGraphicControlExtensionProperties
|
|
{
|
|
/// <summary>
|
|
/// [VT_UI1] Indicates the disposal requirements. 0 - no disposal, 1 - do not dispose, 2 - restore to background color, 3 -
|
|
/// restore to previous.
|
|
/// </summary>
|
|
WICGifGraphicControlExtensionDisposal = 1,
|
|
|
|
/// <summary>[VT_BOOL] Indicates the user input flag. TRUE if user input should advance to the next frame; otherwise, FALSE.</summary>
|
|
WICGifGraphicControlExtensionUserInputFlag,
|
|
|
|
/// <summary>
|
|
/// [VT_BOOL] Indicates the transparency flag. TRUE if a transparent color in is in the color table for this frame; otherwise, FALSE.
|
|
/// </summary>
|
|
WICGifGraphicControlExtensionTransparencyFlag,
|
|
|
|
/// <summary>
|
|
/// [VT_UI2] Indicates how long to display the next frame before advancing to the next frame, in units of 1/100th of a second.
|
|
/// </summary>
|
|
WICGifGraphicControlExtensionDelay,
|
|
|
|
/// <summary>[VT_UI1] Indicates which color in the palette should be treated as transparent.</summary>
|
|
WICGifGraphicControlExtensionTransparentColorIndex,
|
|
|
|
/// <summary/>
|
|
WICGifGraphicControlExtensionProperties_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the image descriptor metadata properties for Graphics Interchange Format (GIF) frames.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicgifimagedescriptorproperties typedef enum
|
|
// WICGifImageDescriptorProperties { WICGifImageDescriptorLeft, WICGifImageDescriptorTop, WICGifImageDescriptorWidth,
|
|
// WICGifImageDescriptorHeight, WICGifImageDescriptorLocalColorTableFlag, WICGifImageDescriptorInterlaceFlag,
|
|
// WICGifImageDescriptorSortFlag, WICGifImageDescriptorLocalColorTableSize, WICGifImageDescriptorProperties_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "5488e63b-503b-47cd-99f3-5d359c7e0070")]
|
|
public enum WICGifImageDescriptorProperties
|
|
{
|
|
/// <summary>[VT_UI2] Indicates the X offset at which to locate this frame within the logical screen.</summary>
|
|
WICGifImageDescriptorLeft = 1,
|
|
|
|
/// <summary>[VT_UI2] Indicates the Y offset at which to locate this frame within the logical screen.</summary>
|
|
WICGifImageDescriptorTop,
|
|
|
|
/// <summary>[VT_UI2] Indicates width of this frame, in pixels.</summary>
|
|
WICGifImageDescriptorWidth,
|
|
|
|
/// <summary>[VT_UI2] Indicates height of this frame, in pixels.</summary>
|
|
WICGifImageDescriptorHeight,
|
|
|
|
/// <summary>[VT_BOOL] Indicates the local color table flag. TRUE if global color table is present; otherwise, FALSE.</summary>
|
|
WICGifImageDescriptorLocalColorTableFlag,
|
|
|
|
/// <summary>[VT_BOOL] Indicates the interlace flag. TRUE if image is interlaced; otherwise, FALSE.</summary>
|
|
WICGifImageDescriptorInterlaceFlag,
|
|
|
|
/// <summary>
|
|
/// [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.
|
|
/// </summary>
|
|
WICGifImageDescriptorSortFlag,
|
|
|
|
/// <summary>
|
|
/// [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.
|
|
/// </summary>
|
|
WICGifImageDescriptorLocalColorTableSize,
|
|
|
|
/// <summary/>
|
|
WICGifImageDescriptorProperties_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the logical screen descriptor properties for Graphics Interchange Format (GIF) metadata.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicgiflogicalscreendescriptorproperties typedef enum
|
|
// WICGifLogicalScreenDescriptorProperties { WICGifLogicalScreenSignature, WICGifLogicalScreenDescriptorWidth,
|
|
// WICGifLogicalScreenDescriptorHeight, WICGifLogicalScreenDescriptorGlobalColorTableFlag,
|
|
// WICGifLogicalScreenDescriptorColorResolution, WICGifLogicalScreenDescriptorSortFlag,
|
|
// WICGifLogicalScreenDescriptorGlobalColorTableSize, WICGifLogicalScreenDescriptorBackgroundColorIndex,
|
|
// WICGifLogicalScreenDescriptorPixelAspectRatio, WICGifLogicalScreenDescriptorProperties_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "edeaae2d-ba4a-4d03-b1ce-37bb5cd67e03")]
|
|
public enum WICGifLogicalScreenDescriptorProperties
|
|
{
|
|
/// <summary>[VT_UI1</summary>
|
|
WICGifLogicalScreenSignature = 1,
|
|
|
|
/// <summary>[VT_UI2] Indicates the width in pixels.</summary>
|
|
WICGifLogicalScreenDescriptorWidth,
|
|
|
|
/// <summary>[VT_UI2] Indicates the height in pixels.</summary>
|
|
WICGifLogicalScreenDescriptorHeight,
|
|
|
|
/// <summary>[VT_BOOL] Indicates the global color table flag. TRUE if a global color table is present; otherwise, FALSE.</summary>
|
|
WICGifLogicalScreenDescriptorGlobalColorTableFlag,
|
|
|
|
/// <summary>[VT_UI1] Indicates the color resolution in bits per pixel.</summary>
|
|
WICGifLogicalScreenDescriptorColorResolution,
|
|
|
|
/// <summary>[VT_BOOL] Indicates the sorted color table flag. TRUE if the table is sorted; otherwise, FALSE.</summary>
|
|
WICGifLogicalScreenDescriptorSortFlag,
|
|
|
|
/// <summary>
|
|
/// [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.
|
|
/// </summary>
|
|
WICGifLogicalScreenDescriptorGlobalColorTableSize,
|
|
|
|
/// <summary>[VT_UI1] Indicates the index within the color table to use for the background (pixels not defined in the image).</summary>
|
|
WICGifLogicalScreenDescriptorBackgroundColorIndex,
|
|
|
|
/// <summary>[VT_UI1] Indicates the factor used to compute an approximation of the aspect ratio.</summary>
|
|
WICGifLogicalScreenDescriptorPixelAspectRatio,
|
|
|
|
/// <summary/>
|
|
WICGifLogicalScreenDescriptorProperties_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the HDR properties of a High Efficiency Image Format (HEIF) image.</summary>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// Use IWicMetadataReader::GetValue to retrieve the value of the properties specified with this enumeration. Instantiate the
|
|
/// <c>IWicMetadataReader</c> instance using the GUID <c>CLSID_WICMetadataReader</c>. Call IWicMetadataReader::GetMetadataFormat and
|
|
/// confirm that the value is <c>GUID_MetadataFormatHeifHDR</c> to verify that the metadata format is HEIF HDR metadata.
|
|
/// </para>
|
|
/// <para>
|
|
/// Not all HEIF HDR images will have all of these properties present in the file, so only those properties that are available will
|
|
/// be exposed by the metadata reader.
|
|
/// </para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicheifhdrproperties typedef enum WICHeifHdrProperties {
|
|
// WICHeifHdrMaximumLuminanceLevel, WICHeifHdrMaximumFrameAverageLuminanceLevel, WICHeifHdrMinimumMasteringDisplayLuminanceLevel,
|
|
// WICHeifHdrMaximumMasteringDisplayLuminanceLevel, WICHeifHdrCustomVideoPrimaries, WICHeifHdrProperties_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h")]
|
|
public enum WICHeifHdrProperties
|
|
{
|
|
/// <summary>[VT_UI2] Specifies the maximum luminance level of the content in Nits.</summary>
|
|
WICHeifHdrMaximumLuminanceLevel = 1,
|
|
|
|
/// <summary>[VT_UI2] Specifies the maximum average per-frame luminance level of the content in Nits.</summary>
|
|
WICHeifHdrMaximumFrameAverageLuminanceLevel,
|
|
|
|
/// <summary>[VT_UI2] Specifies the maximum luminance of the display on which the content was authored, in Nits.</summary>
|
|
WICHeifHdrMinimumMasteringDisplayLuminanceLevel,
|
|
|
|
/// <summary>[VT_UI2] Specifies the maximum luminance of the display on which the content was authored, in Nits.</summary>
|
|
WICHeifHdrMaximumMasteringDisplayLuminanceLevel,
|
|
|
|
/// <summary>
|
|
/// [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).
|
|
/// </summary>
|
|
WICHeifHdrCustomVideoPrimaries,
|
|
|
|
/// <summary/>
|
|
WICHeifHdrProperties_FORCE_DWORD,
|
|
}
|
|
|
|
/// <summary>Specifies the JPEG chrominance table property.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicjpegchrominanceproperties typedef enum
|
|
// WICJpegChrominanceProperties { WICJpegChrominanceTable, WICJpegChrominanceProperties_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "edfa5f86-4c8b-4ba7-a017-d3ff9525b659")]
|
|
public enum WICJpegChrominanceProperties
|
|
{
|
|
/// <summary>[VT_UI2|VT_VECTOR] Indicates the metadata property is a chrominance table.</summary>
|
|
WICJpegChrominanceTable = 1,
|
|
|
|
/// <summary/>
|
|
WICJpegChrominanceProperties_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the JPEG comment properties.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicjpegcommentproperties typedef enum
|
|
// WICJpegCommentProperties { WICJpegCommentText, WICJpegCommentProperties_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "aacf1f1a-49c6-4caf-acd5-8bba0415d41a")]
|
|
public enum WICJpegCommentProperties
|
|
{
|
|
/// <summary>Indicates the metadata property is comment text.</summary>
|
|
WICJpegCommentText = 1,
|
|
|
|
/// <summary/>
|
|
WICJpegCommentProperties_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Flags used by the <c>WICJpegScanHeader</c> and <c>WICJpegFrameHeader</c>.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/wic/iwicjpegframedecode-constants
|
|
[PInvokeData("wincodec.h", MSDNShortId = "6C0139F3-DA3E-4D7C-80D5-BC8C2D76C6A9")]
|
|
public enum WICJpegFrameDecode
|
|
{
|
|
/// <summary>The maximum number of components supported by WIC.</summary>
|
|
WIC_JPEG_MAX_COMPONENT_COUNT = 4,
|
|
|
|
/// <summary>The maximum number of tables supported by WIC.</summary>
|
|
WIC_JPEG_MAX_TABLE_INDEX = 3,
|
|
|
|
/// <summary>Sample factor 1.</summary>
|
|
WIC_JPEG_SAMPLE_FACTORS_ONE = 0x11,
|
|
|
|
/// <summary>Sample factor 4:2:0.</summary>
|
|
WIC_JPEG_SAMPLE_FACTORS_THREE_420 = 0x111122,
|
|
|
|
/// <summary>Sample factor 4:2:2.</summary>
|
|
WIC_JPEG_SAMPLE_FACTORS_THREE_422 = 0x111121,
|
|
|
|
/// <summary>Sample factor 4:4:0.</summary>
|
|
WIC_JPEG_SAMPLE_FACTORS_THREE_440 = 0x111112,
|
|
|
|
/// <summary>Sample factor 4:4:4.</summary>
|
|
WIC_JPEG_SAMPLE_FACTORS_THREE_444 = 0x111111,
|
|
|
|
/// <summary>Quantization indices use baseline 1.</summary>
|
|
WIC_JPEG_QUANTIZATION_BASELINE_ONE = 0,
|
|
|
|
/// <summary>Quantization indices use baseline 3.</summary>
|
|
WIC_JPEG_QUANTIZATION_BASELINE_THREE = 0x10100,
|
|
|
|
/// <summary>Huffman indices use baseline 1.</summary>
|
|
WIC_JPEG_HUFFMAN_BASELINE_ONE = 0,
|
|
|
|
/// <summary>Huffman indices use baseline 3.</summary>
|
|
WIC_JPEG_HUFFMAN_BASELINE_THREE = 0x111100,
|
|
}
|
|
|
|
/// <summary>Specifies the options for indexing a JPEG image.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicjpegindexingoptions typedef enum
|
|
// WICJpegIndexingOptions { WICJpegIndexingOptionsGenerateOnDemand, WICJpegIndexingOptionsGenerateOnLoad,
|
|
// WICJpegIndexingOptions_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "AFA9CC1B-847A-4237-9942-EC721FA86E4E")]
|
|
public enum WICJpegIndexingOptions
|
|
{
|
|
/// <summary>Index generation is deferred until IWICBitmapSource::CopyPixels is called on the image.</summary>
|
|
WICJpegIndexingOptionsGenerateOnDemand,
|
|
|
|
/// <summary>Index generation is performed when the when the image is initially loaded.</summary>
|
|
WICJpegIndexingOptionsGenerateOnLoad,
|
|
|
|
/// <summary>
|
|
/// 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.
|
|
/// </summary>
|
|
WICJpegIndexingOptions_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the JPEG luminance table property.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicjpegluminanceproperties typedef enum
|
|
// WICJpegLuminanceProperties { WICJpegLuminanceTable, WICJpegLuminanceProperties_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "391e96a3-372e-43b9-a752-0234d0fd37e1")]
|
|
public enum WICJpegLuminanceProperties
|
|
{
|
|
/// <summary>[VT_UI2|VT_VECTOR] Indicates the metadata property is a luminance table.</summary>
|
|
WICJpegLuminanceTable = 1,
|
|
|
|
/// <summary/>
|
|
WICJpegLuminanceProperties_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the memory layout of pixel data in a JPEG image scan.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicjpegscantype typedef enum WICJpegScanType {
|
|
// WICJpegScanTypeInterleaved, WICJpegScanTypePlanarComponents, WICJpegScanTypeProgressive, WICJpegScanType_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "DC8B42F0-66D3-4425-9AA8-6B8F0D9B8568")]
|
|
public enum WICJpegScanType
|
|
{
|
|
/// <summary>The pixel data is stored in an interleaved memory layout.</summary>
|
|
WICJpegScanTypeInterleaved,
|
|
|
|
/// <summary>The pixel data is stored in a planar memory layout.</summary>
|
|
WICJpegScanTypePlanarComponents,
|
|
|
|
/// <summary>The pixel data is stored in a progressive layout.</summary>
|
|
WICJpegScanTypeProgressive,
|
|
|
|
/// <summary>
|
|
/// 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.
|
|
/// </summary>
|
|
WICJpegScanType_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies conversion matrix from Y'Cb'Cr' to R'G'B'.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicjpegtransfermatrix typedef enum WICJpegTransferMatrix
|
|
// { WICJpegTransferMatrixIdentity, WICJpegTransferMatrixBT601, WICJpegTransferMatrix_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "393342C4-A906-4427-BEAA-842FF77C9E9D")]
|
|
public enum WICJpegTransferMatrix
|
|
{
|
|
/// <summary>Specifies the identity transfer matrix.</summary>
|
|
WICJpegTransferMatrixIdentity,
|
|
|
|
/// <summary>Specifies the BT601 transfer matrix.</summary>
|
|
WICJpegTransferMatrixBT601,
|
|
|
|
/// <summary>
|
|
/// 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.
|
|
/// </summary>
|
|
WICJpegTransferMatrix_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the JPEG YCrCB subsampling options.</summary>
|
|
/// <remarks>The native JPEG encoder uses <c>WICJpegYCrCbSubsampling420</c>.</remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicjpegycrcbsubsamplingoption typedef enum
|
|
// WICJpegYCrCbSubsamplingOption { WICJpegYCrCbSubsamplingDefault, WICJpegYCrCbSubsampling420, WICJpegYCrCbSubsampling422,
|
|
// WICJpegYCrCbSubsampling444, WICJpegYCrCbSubsampling440, WICJPEGYCRCBSUBSAMPLING_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "6ff16a79-35c9-4230-8f1c-a5c40aecc09e")]
|
|
public enum WICJpegYCrCbSubsamplingOption
|
|
{
|
|
/// <summary>The default subsampling option.</summary>
|
|
WICJpegYCrCbSubsamplingDefault,
|
|
|
|
/// <summary>Subsampling option that uses both horizontal and vertical decimation.</summary>
|
|
WICJpegYCrCbSubsampling420,
|
|
|
|
/// <summary>Subsampling option that uses horizontal decimation .</summary>
|
|
WICJpegYCrCbSubsampling422,
|
|
|
|
/// <summary>Subsampling option that uses no decimation.</summary>
|
|
WICJpegYCrCbSubsampling444,
|
|
|
|
/// <summary>
|
|
/// Subsampling option that uses 2x vertical downsampling only. This option is only available in Windows 8.1 and later.
|
|
/// </summary>
|
|
WICJpegYCrCbSubsampling440,
|
|
|
|
/// <summary/>
|
|
WICJPEGYCRCBSUBSAMPLING_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies metadata creation options.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodecsdk/ne-wincodecsdk-wicmetadatacreationoptions typedef enum
|
|
// WICMetadataCreationOptions { WICMetadataCreationDefault, WICMetadataCreationAllowUnknown, WICMetadataCreationFailUnknown,
|
|
// WICMetadataCreationMask } ;
|
|
[PInvokeData("wincodecsdk.h", MSDNShortId = "41fece55-1ce4-455a-99b5-5ff0ecd27e07")]
|
|
public enum WICMetadataCreationOptions
|
|
{
|
|
/// <summary>The default metadata creation options. The default value is WICMetadataCreationAllowUnknown.</summary>
|
|
WICMetadataCreationDefault,
|
|
|
|
/// <summary>Allow unknown metadata creation.</summary>
|
|
WICMetadataCreationAllowUnknown,
|
|
|
|
/// <summary>Fail on unknown metadata creation.</summary>
|
|
WICMetadataCreationFailUnknown,
|
|
|
|
/// <summary>The WICMetadataCreationOptions mask.</summary>
|
|
WICMetadataCreationMask,
|
|
}
|
|
|
|
/// <summary>Specifies named white balances for raw images.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicnamedwhitepoint typedef enum WICNamedWhitePoint {
|
|
// WICWhitePointDefault, WICWhitePointDaylight, WICWhitePointCloudy, WICWhitePointShade, WICWhitePointTungsten,
|
|
// WICWhitePointFluorescent, WICWhitePointFlash, WICWhitePointUnderwater, WICWhitePointCustom, WICWhitePointAutoWhiteBalance,
|
|
// WICWhitePointAsShot, WICNAMEDWHITEPOINT_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "e256a6d6-a035-47c3-a82c-d9aec284de17")]
|
|
[Flags]
|
|
public enum WICNamedWhitePoint
|
|
{
|
|
/// <summary>The default white balance.</summary>
|
|
WICWhitePointDefault = 0x1,
|
|
|
|
/// <summary>A daylight white balance.</summary>
|
|
WICWhitePointDaylight = 0x2,
|
|
|
|
/// <summary>A cloudy white balance.</summary>
|
|
WICWhitePointCloudy = 0x4,
|
|
|
|
/// <summary>A shade white balance.</summary>
|
|
WICWhitePointShade = 0x8,
|
|
|
|
/// <summary>A tungsten white balance.</summary>
|
|
WICWhitePointTungsten = 0x10,
|
|
|
|
/// <summary>A fluorescent white balance.</summary>
|
|
WICWhitePointFluorescent = 0x20,
|
|
|
|
/// <summary>Daylight white balance.</summary>
|
|
WICWhitePointFlash = 0x40,
|
|
|
|
/// <summary>A flash white balance.</summary>
|
|
WICWhitePointUnderwater = 0x80,
|
|
|
|
/// <summary>A custom white balance. This is typically used when using a picture (grey-card) as white balance.</summary>
|
|
WICWhitePointCustom = 0x100,
|
|
|
|
/// <summary>An automatic balance.</summary>
|
|
WICWhitePointAutoWhiteBalance = 0x200,
|
|
|
|
/// <summary>An "as shot" white balance.</summary>
|
|
WICWhitePointAsShot = WICWhitePointDefault,
|
|
|
|
/// <summary/>
|
|
WICNAMEDWHITEPOINT_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies Windows Imaging Component (WIC) options that are used when initializing a component with a stream.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodecsdk/ne-wincodecsdk-wicpersistoptions typedef enum WICPersistOptions {
|
|
// WICPersistOptionDefault, WICPersistOptionLittleEndian, WICPersistOptionBigEndian, WICPersistOptionStrictFormat,
|
|
// WICPersistOptionNoCacheStream, WICPersistOptionPreferUTF8, WICPersistOptionMask } ;
|
|
[PInvokeData("wincodecsdk.h", MSDNShortId = "8c17cfcc-4f09-4cb5-a3fa-4eb865123ad6")]
|
|
public enum WICPersistOptions
|
|
{
|
|
/// <summary>The default persist options. The default is WICPersistOptionLittleEndian.</summary>
|
|
WICPersistOptionDefault,
|
|
|
|
/// <summary>The data byte order is little endian.</summary>
|
|
WICPersistOptionLittleEndian,
|
|
|
|
/// <summary>The data byte order is big endian.</summary>
|
|
WICPersistOptionBigEndian,
|
|
|
|
/// <summary>The data format must strictly conform to the specification.</summary>
|
|
WICPersistOptionStrictFormat,
|
|
|
|
/// <summary>
|
|
/// 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.
|
|
/// </summary>
|
|
WICPersistOptionNoCacheStream,
|
|
|
|
/// <summary>Use UTF8 instead of the default UTF16.</summary>
|
|
WICPersistOptionPreferUTF8,
|
|
|
|
/// <summary>The WICPersistOptions mask.</summary>
|
|
WICPersistOptionMask,
|
|
}
|
|
|
|
/// <summary>Defines constants that specify a primitive type for numeric representation of a WIC pixel format.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicpixelformatnumericrepresentation typedef enum
|
|
// WICPixelFormatNumericRepresentation { WICPixelFormatNumericRepresentationUnspecified, WICPixelFormatNumericRepresentationIndexed,
|
|
// WICPixelFormatNumericRepresentationUnsignedInteger, WICPixelFormatNumericRepresentationSignedInteger,
|
|
// WICPixelFormatNumericRepresentationFixed, WICPixelFormatNumericRepresentationFloat,
|
|
// WICPixelFormatNumericRepresentation_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "10f32ac9-4b0d-4d21-b54a-657513fbd142")]
|
|
public enum WICPixelFormatNumericRepresentation
|
|
{
|
|
/// <summary>The format is not specified.</summary>
|
|
WICPixelFormatNumericRepresentationUnspecified,
|
|
|
|
/// <summary>Specifies that the format is indexed.</summary>
|
|
WICPixelFormatNumericRepresentationIndexed,
|
|
|
|
/// <summary>Specifies that the format is represented as an unsigned integer.</summary>
|
|
WICPixelFormatNumericRepresentationUnsignedInteger,
|
|
|
|
/// <summary>Specifies that the format is represented as a signed integer.</summary>
|
|
WICPixelFormatNumericRepresentationSignedInteger,
|
|
|
|
/// <summary>Specifies that the format is represented as a fixed-point number.</summary>
|
|
WICPixelFormatNumericRepresentationFixed,
|
|
|
|
/// <summary>Specifies that the format is represented as a floating-point number.</summary>
|
|
WICPixelFormatNumericRepresentationFloat,
|
|
|
|
/// <summary>This constant contains the maximum DWORD value.</summary>
|
|
WICPixelFormatNumericRepresentation_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies additional options to an IWICPlanarBitmapSourceTransform implementation.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicplanaroptions typedef enum WICPlanarOptions {
|
|
// WICPlanarOptionsDefault, WICPlanarOptionsPreserveSubsampling, WICPLANAROPTIONS_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "8B7F34AA-77A0-428D-800E-31AB43067102")]
|
|
public enum WICPlanarOptions
|
|
{
|
|
/// <summary>
|
|
/// 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.
|
|
/// </summary>
|
|
WICPlanarOptionsDefault,
|
|
|
|
/// <summary>
|
|
/// 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.
|
|
/// </summary>
|
|
WICPlanarOptionsPreserveSubsampling,
|
|
|
|
/// <summary/>
|
|
WICPLANAROPTIONS_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the Portable Network Graphics (PNG) background (bKGD) chunk metadata properties.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicpngbkgdproperties typedef enum WICPngBkgdProperties {
|
|
// WICPngBkgdBackgroundColor, WICPngBkgdProperties_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "979f6a91-79a2-4eba-8957-e2908636cdc5")]
|
|
public enum WICPngBkgdProperties
|
|
{
|
|
/// <summary>
|
|
/// Indicates the background color. There are three possible types, depending on the image's pixel format.#### VT_UI1Specifies
|
|
/// the index of the background color in an image with an indexed pixel format.#### VT_UI2Specifies the background color in a
|
|
/// grayscale image.#### VT_VECTOR
|
|
/// </summary>
|
|
WICPngBkgdBackgroundColor = 1,
|
|
|
|
/// <summary/>
|
|
WICPngBkgdProperties_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the Portable Network Graphics (PNG) cHRM chunk metadata properties for CIE XYZ chromaticity.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicpngchrmproperties typedef enum WICPngChrmProperties {
|
|
// WICPngChrmWhitePointX, WICPngChrmWhitePointY, WICPngChrmRedX, WICPngChrmRedY, WICPngChrmGreenX, WICPngChrmGreenY,
|
|
// WICPngChrmBlueX, WICPngChrmBlueY, WICPngChrmProperties_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "e4dede53-4c34-4e37-addf-28f51164717f")]
|
|
public enum WICPngChrmProperties
|
|
{
|
|
/// <summary>[VT_UI4] Indicates the whitepoint x value ratio.</summary>
|
|
WICPngChrmWhitePointX = 1,
|
|
|
|
/// <summary>[VT_UI4] Indicates the whitepoint y value ratio.</summary>
|
|
WICPngChrmWhitePointY,
|
|
|
|
/// <summary>[VT_UI4] Indicates the red x value ratio.</summary>
|
|
WICPngChrmRedX,
|
|
|
|
/// <summary>[VT_UI4] Indicates the red y value ratio.</summary>
|
|
WICPngChrmRedY,
|
|
|
|
/// <summary>[VT_UI4] Indicates the green x value ratio.</summary>
|
|
WICPngChrmGreenX,
|
|
|
|
/// <summary>[VT_UI4] Indicates the green y value ratio.</summary>
|
|
WICPngChrmGreenY,
|
|
|
|
/// <summary>[VT_UI4] Indicates the blue x value ratio.</summary>
|
|
WICPngChrmBlueX,
|
|
|
|
/// <summary>[VT_UI4] Indicates the blue y value ratio.</summary>
|
|
WICPngChrmBlueY,
|
|
|
|
/// <summary/>
|
|
WICPngChrmProperties_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the Portable Network Graphics (PNG) filters available for compression optimization.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicpngfilteroption typedef enum WICPngFilterOption {
|
|
// WICPngFilterUnspecified, WICPngFilterNone, WICPngFilterSub, WICPngFilterUp, WICPngFilterAverage, WICPngFilterPaeth,
|
|
// WICPngFilterAdaptive, WICPNGFILTEROPTION_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "468033cf-62e8-4aef-b34f-c833df048115")]
|
|
public enum WICPngFilterOption
|
|
{
|
|
/// <summary>
|
|
/// Indicates an unspecified PNG filter. This enables WIC to algorithmically choose the best filtering option for the image.
|
|
/// </summary>
|
|
WICPngFilterUnspecified,
|
|
|
|
/// <summary>Indicates no PNG filter.</summary>
|
|
WICPngFilterNone,
|
|
|
|
/// <summary>Indicates a PNG sub filter.</summary>
|
|
WICPngFilterSub,
|
|
|
|
/// <summary>Indicates a PNG up filter.</summary>
|
|
WICPngFilterUp,
|
|
|
|
/// <summary>Indicates a PNG average filter.</summary>
|
|
WICPngFilterAverage,
|
|
|
|
/// <summary>Indicates a PNG paeth filter.</summary>
|
|
WICPngFilterPaeth,
|
|
|
|
/// <summary>Indicates a PNG adaptive filter. This enables WIC to choose the best filtering mode on a per-scanline basis.</summary>
|
|
WICPngFilterAdaptive,
|
|
|
|
/// <summary/>
|
|
WICPNGFILTEROPTION_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the Portable Network Graphics (PNG) gAMA chunk metadata properties.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicpnggamaproperties typedef enum WICPngGamaProperties {
|
|
// WICPngGamaGamma, WICPngGamaProperties_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "c70a3507-d598-4e33-872b-353389b19351")]
|
|
public enum WICPngGamaProperties
|
|
{
|
|
/// <summary>[VT_UI4] Indicates the gamma value.</summary>
|
|
WICPngGamaGamma = 1,
|
|
|
|
/// <summary/>
|
|
WICPngGamaProperties_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the Portable Network Graphics (PNG) hIST chunk metadata properties.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicpnghistproperties typedef enum WICPngHistProperties {
|
|
// WICPngHistFrequencies, WICPngHistProperties_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "ab3ddddb-5916-43b8-8688-5361cee05902")]
|
|
public enum WICPngHistProperties
|
|
{
|
|
/// <summary>[VT_VECTOR</summary>
|
|
WICPngHistFrequencies = 1,
|
|
|
|
/// <summary/>
|
|
WICPngHistProperties_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the Portable Network Graphics (PNG) iCCP chunk metadata properties.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicpngiccpproperties typedef enum WICPngIccpProperties {
|
|
// WICPngIccpProfileName, WICPngIccpProfileData, WICPngIccpProperties_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "2c28a4f1-40c2-4886-be5f-0a2e6feb487a")]
|
|
public enum WICPngIccpProperties
|
|
{
|
|
/// <summary>[VT_LPSTR] Indicates the International Color Consortium (ICC) profile name.</summary>
|
|
WICPngIccpProfileName = 1,
|
|
|
|
/// <summary>[VT_VECTOR</summary>
|
|
WICPngIccpProfileData,
|
|
|
|
/// <summary/>
|
|
WICPngIccpProperties_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the Portable Network Graphics (PNG) iTXT chunk metadata properties.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicpngitxtproperties typedef enum WICPngItxtProperties {
|
|
// WICPngItxtKeyword, WICPngItxtCompressionFlag, WICPngItxtLanguageTag, WICPngItxtTranslatedKeyword, WICPngItxtText,
|
|
// WICPngItxtProperties_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "905d37e2-39f3-4990-b737-f9194f798d83")]
|
|
public enum WICPngItxtProperties
|
|
{
|
|
/// <summary>[VT_LPSTR] Indicates the keywords in the iTXT metadata chunk.</summary>
|
|
WICPngItxtKeyword = 1,
|
|
|
|
/// <summary>
|
|
/// [VT_UI1] Indicates whether the text in the iTXT chunk is compressed. 1 if the text is compressed; otherwise, 0.
|
|
/// </summary>
|
|
WICPngItxtCompressionFlag,
|
|
|
|
/// <summary>[VT_LPSTR] Indicates the human language used by the translated keyword and the text.</summary>
|
|
WICPngItxtLanguageTag,
|
|
|
|
/// <summary>[VT_LPWSTR] Indicates a translation of the keyword into the language indicated by the language tag.</summary>
|
|
WICPngItxtTranslatedKeyword,
|
|
|
|
/// <summary>[VT_LPWSTR] Indicates additional text in the iTXT metadata chunk.</summary>
|
|
WICPngItxtText,
|
|
|
|
/// <summary/>
|
|
WICPngItxtProperties_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the Portable Network Graphics (PNG) sRGB chunk metadata properties.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicpngsrgbproperties typedef enum WICPngSrgbProperties {
|
|
// WICPngSrgbRenderingIntent, WICPngSrgbProperties_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "ec9bbdb7-9ce2-44bd-bd84-842394ce4c5f")]
|
|
public enum WICPngSrgbProperties
|
|
{
|
|
/// <summary>
|
|
/// [VT_UI1] Indicates the rendering intent for an sRGB color space image. The rendering intents have the following meaning.
|
|
/// </summary>
|
|
WICPngSrgbRenderingIntent = 1,
|
|
|
|
/// <summary/>
|
|
WICPngSrgbProperties_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the Portable Network Graphics (PNG) tIME chunk metadata properties.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicpngtimeproperties typedef enum WICPngTimeProperties {
|
|
// WICPngTimeYear, WICPngTimeMonth, WICPngTimeDay, WICPngTimeHour, WICPngTimeMinute, WICPngTimeSecond,
|
|
// WICPngTimeProperties_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "202dc399-0173-4995-af74-09ee71e1dcf1")]
|
|
public enum WICPngTimeProperties
|
|
{
|
|
/// <summary>[VT_UI2] Indicates the year of the last modification.</summary>
|
|
WICPngTimeYear = 1,
|
|
|
|
/// <summary>[VT_UI1] Indicates the month of the last modification.</summary>
|
|
WICPngTimeMonth,
|
|
|
|
/// <summary>[VT_UI1] Indicates day of the last modification.</summary>
|
|
WICPngTimeDay,
|
|
|
|
/// <summary>[VT_UI1] Indicates the hour of the last modification.</summary>
|
|
WICPngTimeHour,
|
|
|
|
/// <summary>[VT_UI1] Indicates the minute of the last modification.</summary>
|
|
WICPngTimeMinute,
|
|
|
|
/// <summary>[VT_UI1] Indicates the second of the last modification.</summary>
|
|
WICPngTimeSecond,
|
|
|
|
/// <summary/>
|
|
WICPngTimeProperties_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies when the progress notification callback should be called.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicprogressnotification typedef enum
|
|
// WICProgressNotification { WICProgressNotificationBegin, WICProgressNotificationEnd, WICProgressNotificationFrequent,
|
|
// WICProgressNotificationAll, WICPROGRESSNOTIFICATION_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "6d7ef6f1-2024-4de5-9c2e-8edc6359f79b")]
|
|
[Flags]
|
|
public enum WICProgressNotification : uint
|
|
{
|
|
/// <summary>The callback should be called when codec operations begin.</summary>
|
|
WICProgressNotificationBegin = 0x10000,
|
|
|
|
/// <summary>The callback should be called when codec operations end.</summary>
|
|
WICProgressNotificationEnd = 0x20000,
|
|
|
|
/// <summary>The callback should be called frequently to report status.</summary>
|
|
WICProgressNotificationFrequent = 0x40000,
|
|
|
|
/// <summary>The callback should be called on all available progress notifications.</summary>
|
|
WICProgressNotificationAll = 0xffff0000,
|
|
|
|
/// <summary/>
|
|
WICPROGRESSNOTIFICATION_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the progress operations to receive notifications for.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicprogressoperation typedef enum WICProgressOperation {
|
|
// WICProgressOperationCopyPixels, WICProgressOperationWritePixels, WICProgressOperationAll, WICPROGRESSOPERATION_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "407b982d-7232-42ce-9ff5-7029b7d922a4")]
|
|
[Flags]
|
|
public enum WICProgressOperation
|
|
{
|
|
/// <summary>Receive copy pixel operation.</summary>
|
|
WICProgressOperationCopyPixels = 0x1,
|
|
|
|
/// <summary>Receive write pixel operation.</summary>
|
|
WICProgressOperationWritePixels = 0x2,
|
|
|
|
/// <summary>Receive all progress operations available.</summary>
|
|
WICProgressOperationAll = 0xffff,
|
|
|
|
/// <summary/>
|
|
WICPROGRESSOPERATION_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the capability support of a raw image.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicrawcapabilities typedef enum WICRawCapabilities {
|
|
// WICRawCapabilityNotSupported, WICRawCapabilityGetSupported, WICRawCapabilityFullySupported, WICRAWCAPABILITIES_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "a82edbbe-a069-4ba8-ba15-524830cdf330")]
|
|
public enum WICRawCapabilities
|
|
{
|
|
/// <summary>The capability is not supported.</summary>
|
|
WICRawCapabilityNotSupported,
|
|
|
|
/// <summary>The capability supports only get operations.</summary>
|
|
WICRawCapabilityGetSupported,
|
|
|
|
/// <summary>The capability supports get and set operations.</summary>
|
|
WICRawCapabilityFullySupported,
|
|
|
|
/// <summary/>
|
|
WICRAWCAPABILITIES_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Flags used to by <c>IWICDevelopRawNotificationCallback</c> to indicate which members have changed.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/wic/-wic-codec-iwicdeveloprawnotification-constants
|
|
[PInvokeData("wincodec.h", MSDNShortId = "4e94b4f4-abd9-4395-87ec-a08e49a2cf88")]
|
|
[Flags]
|
|
public enum WICRawChangeNotification
|
|
{
|
|
/// <summary>Mask used to report a exposure compensation change.</summary>
|
|
WICRawChangeNotification_ExposureCompensation = 0x00000001,
|
|
|
|
/// <summary>Mask used to report a WICNamedWhitePoint change.</summary>
|
|
WICRawChangeNotification_NamedWhitePoint = 0x00000002,
|
|
|
|
/// <summary>Mask used to report a kelvin white point change.</summary>
|
|
WICRawChangeNotification_KelvinWhitePoint = 0x00000004,
|
|
|
|
/// <summary>Mask used to report a RGB white point change.</summary>
|
|
WICRawChangeNotification_RGBWhitePoint = 0x00000008,
|
|
|
|
/// <summary>Mask used to report a contrast change.</summary>
|
|
WICRawChangeNotification_Contrast = 0x00000010,
|
|
|
|
/// <summary>Mask used to report a gamma change.</summary>
|
|
WICRawChangeNotification_Gamma = 0x00000020,
|
|
|
|
/// <summary>Mask used to report a sharpness change.</summary>
|
|
WICRawChangeNotification_Sharpness = 0x00000040,
|
|
|
|
/// <summary>Mask used to report a saturation change.</summary>
|
|
WICRawChangeNotification_Saturation = 0x00000080,
|
|
|
|
/// <summary>Mask used to report a tint change.</summary>
|
|
WICRawChangeNotification_Tint = 0x00000100,
|
|
|
|
/// <summary>Mask used to report a noise reduction change.</summary>
|
|
WICRawChangeNotification_NoiseReduction = 0x00000200,
|
|
|
|
/// <summary>Mask used to report a destination color context change.</summary>
|
|
WICRawChangeNotification_DestinationColorContext = 0x00000400,
|
|
|
|
/// <summary>Mask used to report a tone curve change.</summary>
|
|
WICRawChangeNotification_ToneCurve = 0x00000800,
|
|
|
|
/// <summary>Mask used to report a WICRawRotationCapabilities change.</summary>
|
|
WICRawChangeNotification_Rotation = 0x00001000,
|
|
|
|
/// <summary>Mask used to report a WICRawRenderMode change.</summary>
|
|
WICRawChangeNotification_RenderMode = 0x00002000,
|
|
}
|
|
|
|
/// <summary>Specifies the parameter set used by a raw codec.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicrawparameterset typedef enum WICRawParameterSet {
|
|
// WICAsShotParameterSet, WICUserAdjustedParameterSet, WICAutoAdjustedParameterSet, WICRAWPARAMETERSET_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "0c39b769-9523-42ce-942f-761e6d39ec5b")]
|
|
public enum WICRawParameterSet
|
|
{
|
|
/// <summary>An as shot parameter set.</summary>
|
|
WICAsShotParameterSet = 1,
|
|
|
|
/// <summary>A user adjusted parameter set.</summary>
|
|
WICUserAdjustedParameterSet,
|
|
|
|
/// <summary>A codec adjusted parameter set.</summary>
|
|
WICAutoAdjustedParameterSet,
|
|
|
|
/// <summary/>
|
|
WICRAWPARAMETERSET_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the render intent of the next CopyPixels call.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicrawrendermode typedef enum WICRawRenderMode {
|
|
// WICRawRenderModeDraft, WICRawRenderModeNormal, WICRawRenderModeBestQuality, WICRAWRENDERMODE_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "dc020c78-a018-42ee-a500-65a743b96107")]
|
|
public enum WICRawRenderMode
|
|
{
|
|
/// <summary>Use speed priority mode.</summary>
|
|
WICRawRenderModeDraft = 1,
|
|
|
|
/// <summary>Use normal priority mode. Balance of speed and quality.</summary>
|
|
WICRawRenderModeNormal,
|
|
|
|
/// <summary>Use best quality mode.</summary>
|
|
WICRawRenderModeBestQuality,
|
|
|
|
/// <summary/>
|
|
WICRAWRENDERMODE_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the rotation capabilities of the codec.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicrawrotationcapabilities typedef enum
|
|
// WICRawRotationCapabilities { WICRawRotationCapabilityNotSupported, WICRawRotationCapabilityGetSupported,
|
|
// WICRawRotationCapabilityNinetyDegreesSupported, WICRawRotationCapabilityFullySupported, WICRAWROTATIONCAPABILITIES_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "f6713652-7d38-4ac6-80d8-fd53095c50a2")]
|
|
public enum WICRawRotationCapabilities
|
|
{
|
|
/// <summary>Rotation is not supported.</summary>
|
|
WICRawRotationCapabilityNotSupported,
|
|
|
|
/// <summary>Set operations for rotation is not supported.</summary>
|
|
WICRawRotationCapabilityGetSupported,
|
|
|
|
/// <summary>90 degree rotations are supported.</summary>
|
|
WICRawRotationCapabilityNinetyDegreesSupported,
|
|
|
|
/// <summary>All rotation angles are supported.</summary>
|
|
WICRawRotationCapabilityFullySupported,
|
|
|
|
/// <summary/>
|
|
WICRAWROTATIONCAPABILITIES_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the access level of a Windows Graphics Device Interface (GDI) section.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicsectionaccesslevel typedef enum WICSectionAccessLevel
|
|
// { WICSectionAccessLevelRead, WICSectionAccessLevelReadWrite, WICSectionAccessLevel_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "4b08bc8c-d67c-4bc4-a701-2903a971a478")]
|
|
public enum WICSectionAccessLevel
|
|
{
|
|
/// <summary>Indicates a read only access level.</summary>
|
|
WICSectionAccessLevelRead = 1,
|
|
|
|
/// <summary>Indicates a read/write access level.</summary>
|
|
WICSectionAccessLevelReadWrite = 3,
|
|
|
|
/// <summary/>
|
|
WICSectionAccessLevel_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>Specifies the Tagged Image File Format (TIFF) compression options.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wictiffcompressionoption typedef enum
|
|
// WICTiffCompressionOption { WICTiffCompressionDontCare, WICTiffCompressionNone, WICTiffCompressionCCITT3,
|
|
// WICTiffCompressionCCITT4, WICTiffCompressionLZW, WICTiffCompressionRLE, WICTiffCompressionZIP,
|
|
// WICTiffCompressionLZWHDifferencing, WICTIFFCOMPRESSIONOPTION_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "787f6d71-6481-4236-8c3f-1b18bfb7ee88")]
|
|
public enum WICTiffCompressionOption
|
|
{
|
|
/// <summary>Indicates a suitable compression algorithm based on the image and pixel format.</summary>
|
|
WICTiffCompressionDontCare,
|
|
|
|
/// <summary>Indicates no compression.</summary>
|
|
WICTiffCompressionNone,
|
|
|
|
/// <summary>Indicates a CCITT3 compression algorithm. This algorithm is only valid for 1bpp pixel formats.</summary>
|
|
WICTiffCompressionCCITT3,
|
|
|
|
/// <summary>Indicates a CCITT4 compression algorithm. This algorithm is only valid for 1bpp pixel formats.</summary>
|
|
WICTiffCompressionCCITT4,
|
|
|
|
/// <summary>Indicates a LZW compression algorithm.</summary>
|
|
WICTiffCompressionLZW,
|
|
|
|
/// <summary>Indicates a RLE compression algorithm. This algorithm is only valid for 1bpp pixel formats.</summary>
|
|
WICTiffCompressionRLE,
|
|
|
|
/// <summary>Indicates a ZIP compression algorithm.</summary>
|
|
WICTiffCompressionZIP,
|
|
|
|
/// <summary>Indicates an LZWH differencing algorithm.</summary>
|
|
WICTiffCompressionLZWHDifferencing,
|
|
|
|
/// <summary/>
|
|
WICTIFFCOMPRESSIONOPTION_FORCE_DWORD = 0x7fffffff,
|
|
}
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// [Some information relates to pre-released product which may be substantially modified before it's commercially released.
|
|
/// Microsoft makes no warranties, express or implied, with respect to the information provided here.]
|
|
/// </para>
|
|
/// <para>Specifies the animation properties of a WebP image.</para>
|
|
/// </summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicwebpanimproperties typedef enum WICWebpAnimProperties
|
|
// { WICWebpAnimLoopCount, WICWebpAnimProperties_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "BECCBE42-5546-4243-A0B4-1240992D42DC")]
|
|
public enum WICWebpAnimProperties
|
|
{
|
|
/// <summary>The number of times the animation loops. A value of 0 indicates that the animation will loop infinitely.</summary>
|
|
WICWebpAnimLoopCount = 1,
|
|
|
|
/// <summary/>
|
|
WICWebpAnimProperties_FORCE_DWORD,
|
|
}
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// [Some information relates to pre-released product which may be substantially modified before it's commercially released.
|
|
/// Microsoft makes no warranties, express or implied, with respect to the information provided here.]
|
|
/// </para>
|
|
/// <para>Specifies the animation frame properties of a WebP image.</para>
|
|
/// </summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wincodec/ne-wincodec-wicwebpanmfproperties typedef enum WICWebpAnmfProperties
|
|
// { WICWebpAnmfFrameDuration, WICWebpAnmfProperties_FORCE_DWORD } ;
|
|
[PInvokeData("wincodec.h", MSDNShortId = "41C771FD-29FB-431B-B905-37C6A59C0677")]
|
|
public enum WICWebpAnmfProperties
|
|
{
|
|
/// <summary>The time to wait before displaying the next frame, in milliseconds.</summary>
|
|
WICWebpAnmfFrameDuration = 1,
|
|
|
|
/// <summary/>
|
|
WICWebpAnmfProperties_FORCE_DWORD,
|
|
}
|
|
|
|
/// <summary>This document includes GUIDs and class identifiers (CLSIDs) tables of Windows Imaging Component (WIC).</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/wic/-wic-guids-clsids
|
|
[PInvokeData("wincodec.h", MSDNShortId = "2be5cfeb-2dd3-4486-b639-35ee28a7dd7b")]
|
|
public static class WICGuids
|
|
{
|
|
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
|
|
public static readonly Guid CATID_WICBitmapDecoders = new Guid(0x7ed96837, 0x96f0, 0x4812, 0xb2, 0x11, 0xf1, 0x3c, 0x24, 0x11, 0x7e, 0xd3);
|
|
public static readonly Guid CATID_WICBitmapEncoders = new Guid(0xac757296, 0x3522, 0x4e11, 0x98, 0x62, 0xc1, 0x7b, 0xe5, 0xa1, 0x76, 0x7e);
|
|
public static readonly Guid CATID_WICFormatConverters = new Guid(0x7835eae8, 0xbf14, 0x49d1, 0x93, 0xce, 0x53, 0x3a, 0x40, 0x7b, 0x22, 0x48);
|
|
public static readonly Guid CATID_WICMetadataReader = new Guid(0x05af94d8, 0x7174, 0x4cd2, 0xbe, 0x4a, 0x41, 0x24, 0xb8, 0x0e, 0xe4, 0xb8);
|
|
public static readonly Guid CATID_WICMetadataWriter = new Guid(0xabe3b9a4, 0x257d, 0x4b97, 0xbd, 0x1a, 0x29, 0x4a, 0xf4, 0x96, 0x22, 0x2e);
|
|
public static readonly Guid CATID_WICPixelFormats = new Guid(0x2b46e70f, 0xcda7, 0x473e, 0x89, 0xf6, 0xdc, 0x96, 0x30, 0xa2, 0x39, 0x0b);
|
|
public static readonly Guid CLSID_WICAdngDecoder = new Guid(0x981d9411, 0x909e, 0x42a7, 0x8f, 0x5d, 0xa7, 0x47, 0xff, 0x05, 0x2e, 0xdb);
|
|
public static readonly Guid CLSID_WICBmpDecoder = new Guid(0x6b462062, 0x7cbf, 0x400d, 0x9f, 0xdb, 0x81, 0x3d, 0xd1, 0x0f, 0x27, 0x78);
|
|
public static readonly Guid CLSID_WICBmpEncoder = new Guid(0x69be8bb4, 0xd66d, 0x47c8, 0x86, 0x5a, 0xed, 0x15, 0x89, 0x43, 0x37, 0x82);
|
|
public static readonly Guid CLSID_WICDdsDecoder = new Guid(0x9053699f, 0xa341, 0x429d, 0x9e, 0x90, 0xee, 0x43, 0x7c, 0xf8, 0x0c, 0x73);
|
|
public static readonly Guid CLSID_WICDdsEncoder = new Guid(0xa61dde94, 0x66ce, 0x4ac1, 0x88, 0x1b, 0x71, 0x68, 0x05, 0x88, 0x89, 0x5e);
|
|
public static readonly Guid CLSID_WICDefaultFormatConverter = new Guid(0x1a3f11dc, 0xb514, 0x4b17, 0x8c, 0x5f, 0x21, 0x54, 0x51, 0x38, 0x52, 0xf1);
|
|
public static readonly Guid CLSID_WICFormatConverterHighColor = new Guid(0xac75d454, 0x9f37, 0x48f8, 0xb9, 0x72, 0x4e, 0x19, 0xbc, 0x85, 0x60, 0x11);
|
|
public static readonly Guid CLSID_WICFormatConverterNChannel = new Guid(0xc17cabb2, 0xd4a3, 0x47d7, 0xa5, 0x57, 0x33, 0x9b, 0x2e, 0xfb, 0xd4, 0xf1);
|
|
public static readonly Guid CLSID_WICFormatConverterWMPhoto = new Guid(0x9cb5172b, 0xd600, 0x46ba, 0xab, 0x77, 0x77, 0xbb, 0x7e, 0x3a, 0x00, 0xd9);
|
|
public static readonly Guid CLSID_WICGifDecoder = new Guid(0x381dda3c, 0x9ce9, 0x4834, 0xa2, 0x3e, 0x1f, 0x98, 0xf8, 0xfc, 0x52, 0xbe);
|
|
public static readonly Guid CLSID_WICGifEncoder = new Guid(0x114f5598, 0x0b22, 0x40a0, 0x86, 0xa1, 0xc8, 0x3e, 0xa4, 0x95, 0xad, 0xbd);
|
|
public static readonly Guid CLSID_WICHeifDecoder = new Guid(0xe9A4A80a, 0x44fe, 0x4DE4, 0x89, 0x71, 0x71, 0x50, 0XB1, 0X0a, 0X51, 0X99);
|
|
public static readonly Guid CLSID_WICHeifEncoder = new Guid(0x0dbecec1, 0x9eb3, 0x4860, 0x9c, 0x6f, 0xdd, 0xbe, 0x86, 0x63, 0x45, 0x75);
|
|
public static readonly Guid CLSID_WICIcoDecoder = new Guid(0xc61bfcdf, 0x2e0f, 0x4aad, 0xa8, 0xd7, 0xe0, 0x6b, 0xaf, 0xeb, 0xcd, 0xfe);
|
|
public static readonly Guid CLSID_WICImagingCategories = new Guid(0xfae3d380, 0xfea4, 0x4623, 0x8c, 0x75, 0xc6, 0xb6, 0x11, 0x10, 0xb6, 0x81);
|
|
public static readonly Guid CLSID_WICImagingFactory = new Guid(0xcacaf262, 0x9370, 0x4615, 0xa1, 0x3b, 0x9f, 0x55, 0x39, 0xda, 0x4c, 0xa);
|
|
public static readonly Guid CLSID_WICImagingFactory1 = new Guid(0xcacaf262, 0x9370, 0x4615, 0xa1, 0x3b, 0x9f, 0x55, 0x39, 0xda, 0x4c, 0xa);
|
|
public static readonly Guid CLSID_WICImagingFactory2 = new Guid(0x317d06e8, 0x5f24, 0x433d, 0xbd, 0xf7, 0x79, 0xce, 0x68, 0xd8, 0xab, 0xc2);
|
|
public static readonly Guid CLSID_WICJpegDecoder = new Guid(0x9456a480, 0xe88b, 0x43ea, 0x9e, 0x73, 0x0b, 0x2d, 0x9b, 0x71, 0xb1, 0xca);
|
|
public static readonly Guid CLSID_WICJpegEncoder = new Guid(0x1a34f5c1, 0x4a5a, 0x46dc, 0xb6, 0x44, 0x1f, 0x45, 0x67, 0xe7, 0xa6, 0x76);
|
|
public static readonly Guid CLSID_WICJpegQualcommPhoneEncoder = new Guid(0x68ed5c62, 0xf534, 0x4979, 0xb2, 0xb3, 0x68, 0x6a, 0x12, 0xb2, 0xb3, 0x4c);
|
|
public static readonly Guid CLSID_WICPlanarFormatConverter = new Guid(0x184132b8, 0x32f8, 0x4784, 0x91, 0x31, 0xdd, 0x72, 0x24, 0xb2, 0x34, 0x38);
|
|
public static readonly Guid CLSID_WICPngDecoder = new Guid(0x389ea17b, 0x5078, 0x4cde, 0xb6, 0xef, 0x25, 0xc1, 0x51, 0x75, 0xc7, 0x51);
|
|
public static readonly Guid CLSID_WICPngDecoder1 = new Guid(0x389ea17b, 0x5078, 0x4cde, 0xb6, 0xef, 0x25, 0xc1, 0x51, 0x75, 0xc7, 0x51);
|
|
public static readonly Guid CLSID_WICPngDecoder2 = new Guid(0xe018945b, 0xaa86, 0x4008, 0x9b, 0xd4, 0x67, 0x77, 0xa1, 0xe4, 0x0c, 0x11);
|
|
public static readonly Guid CLSID_WICPngEncoder = new Guid(0x27949969, 0x876a, 0x41d7, 0x94, 0x47, 0x56, 0x8f, 0x6a, 0x35, 0xa4, 0xdc);
|
|
public static readonly Guid CLSID_WICRAWDecoder = new Guid(0x41945702, 0x8302, 0x44A6, 0x94, 0x45, 0xAC, 0x98, 0xE8, 0xAF, 0xA0, 0x86);
|
|
public static readonly Guid CLSID_WICTiffDecoder = new Guid(0xb54e85d9, 0xfe23, 0x499f, 0x8b, 0x88, 0x6a, 0xce, 0xa7, 0x13, 0x75, 0x2b);
|
|
public static readonly Guid CLSID_WICTiffEncoder = new Guid(0x0131be10, 0x2001, 0x4c5f, 0xa9, 0xb0, 0xcc, 0x88, 0xfa, 0xb6, 0x4c, 0xe8);
|
|
public static readonly Guid CLSID_WICWebpDecoder = new Guid(0x7693E886, 0x51C9, 0x4070, 0x84, 0x19, 0x9F, 0x70, 0X73, 0X8E, 0XC8, 0XFA);
|
|
public static readonly Guid CLSID_WICWmpDecoder = new Guid(0xa26cec36, 0x234c, 0x4950, 0xae, 0x16, 0xe3, 0x4a, 0xac, 0xe7, 0x1d, 0x0d);
|
|
public static readonly Guid CLSID_WICWmpEncoder = new Guid(0xac4ce3cb, 0xe1c1, 0x44cd, 0x82, 0x15, 0x5a, 0x16, 0x65, 0x50, 0x9e, 0xc2);
|
|
public static readonly Guid GUID_ContainerFormatAdng = new Guid(0xf3ff6d0d, 0x38c0, 0x41c4, 0xb1, 0xfe, 0x1f, 0x38, 0x24, 0xf1, 0x7b, 0x84);
|
|
public static readonly Guid GUID_ContainerFormatBmp = new Guid(0x0af1d87e, 0xfcfe, 0x4188, 0xbd, 0xeb, 0xa7, 0x90, 0x64, 0x71, 0xcb, 0xe3);
|
|
public static readonly Guid GUID_ContainerFormatDds = new Guid(0x9967cb95, 0x2e85, 0x4ac8, 0x8c, 0xa2, 0x83, 0xd7, 0xcc, 0xd4, 0x25, 0xc9);
|
|
public static readonly Guid GUID_ContainerFormatGif = new Guid(0x1f8a5601, 0x7d4d, 0x4cbd, 0x9c, 0x82, 0x1b, 0xc8, 0xd4, 0xee, 0xb9, 0xa5);
|
|
public static readonly Guid GUID_ContainerFormatHeif = new Guid(0xe1e62521, 0x6787, 0x405b, 0xa3, 0x39, 0x50, 0x07, 0x15, 0xb5, 0x76, 0x3f);
|
|
public static readonly Guid GUID_ContainerFormatIco = new Guid(0xa3a860c4, 0x338f, 0x4c17, 0x91, 0x9a, 0xfb, 0xa4, 0xb5, 0x62, 0x8f, 0x21);
|
|
public static readonly Guid GUID_ContainerFormatJpeg = new Guid(0x19e4a5aa, 0x5662, 0x4fc5, 0xa0, 0xc0, 0x17, 0x58, 0x02, 0x8e, 0x10, 0x57);
|
|
public static readonly Guid GUID_ContainerFormatPng = new Guid(0x1b7cfaf4, 0x713f, 0x473c, 0xbb, 0xcd, 0x61, 0x37, 0x42, 0x5f, 0xae, 0xaf);
|
|
public static readonly Guid GUID_ContainerFormatRaw = new Guid(0xfe99ce60, 0xf19c, 0x433c, 0xa3, 0xae, 0x00, 0xac, 0xef, 0xa9, 0xca, 0x21);
|
|
public static readonly Guid GUID_ContainerFormatTiff = new Guid(0x163bcc30, 0xe2e9, 0x4f0b, 0x96, 0x1d, 0xa3, 0xe9, 0xfd, 0xb7, 0x88, 0xa3);
|
|
public static readonly Guid GUID_ContainerFormatWebp = new Guid(0xe094b0e2, 0x67f2, 0x45b3, 0xb0, 0xea, 0x11, 0x53, 0x37, 0xca, 0x7c, 0xf3);
|
|
public static readonly Guid GUID_ContainerFormatWmp = new Guid(0x57a37caa, 0x367a, 0x4540, 0x91, 0x6b, 0xf1, 0x83, 0xc5, 0x09, 0x3a, 0x4b);
|
|
public static readonly Guid GUID_VendorMicrosoft = new Guid(0xf0e749ca, 0xedef, 0x4589, 0xa7, 0x3a, 0xee, 0xe, 0x62, 0x6a, 0x2a, 0x2b);
|
|
public static readonly Guid GUID_VendorMicrosoftBuiltIn = new Guid(0x257a30fd, 0x6b6, 0x462b, 0xae, 0xa4, 0x63, 0xf7, 0xb, 0x86, 0xe5, 0x33);
|
|
public static readonly Guid GUID_WICPixelFormat112bpp6ChannelsAlpha = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x37);
|
|
public static readonly Guid GUID_WICPixelFormat112bpp7Channels = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x2a);
|
|
public static readonly Guid GUID_WICPixelFormat128bpp7ChannelsAlpha = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x38);
|
|
public static readonly Guid GUID_WICPixelFormat128bpp8Channels = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x2b);
|
|
public static readonly Guid GUID_WICPixelFormat128bppPRGBAFloat = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x1a);
|
|
public static readonly Guid GUID_WICPixelFormat128bppRGBAFixedPoint = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x1e);
|
|
public static readonly Guid GUID_WICPixelFormat128bppRGBAFloat = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x19);
|
|
public static readonly Guid GUID_WICPixelFormat128bppRGBFixedPoint = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x41);
|
|
public static readonly Guid GUID_WICPixelFormat128bppRGBFloat = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x1b);
|
|
public static readonly Guid GUID_WICPixelFormat144bpp8ChannelsAlpha = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x39);
|
|
public static readonly Guid GUID_WICPixelFormat16bppBGR555 = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x09);
|
|
public static readonly Guid GUID_WICPixelFormat16bppBGR565 = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x0a);
|
|
public static readonly Guid GUID_WICPixelFormat16bppBGRA5551 = new Guid(0x05ec7c2b, 0xf1e6, 0x4961, 0xad, 0x46, 0xe1, 0xcc, 0x81, 0x0a, 0x87, 0xd2);
|
|
public static readonly Guid GUID_WICPixelFormat16bppCbCr = new Guid(0xFF95BA6E, 0x11E0, 0x4263, 0xBB, 0x45, 0x01, 0x72, 0x1F, 0x34, 0x60, 0xA4);
|
|
public static readonly Guid GUID_WICPixelFormat16bppCbQuantizedDctCoefficients = new Guid(0xD2C4FF61, 0x56A5, 0x49C2, 0x8B, 0x5C, 0x4C, 0x19, 0x25, 0x96, 0x48, 0x37);
|
|
public static readonly Guid GUID_WICPixelFormat16bppCrQuantizedDctCoefficients = new Guid(0x2FE354F0, 0x1680, 0x42D8, 0x92, 0x31, 0xE7, 0x3C, 0x05, 0x65, 0xBF, 0xC1);
|
|
public static readonly Guid GUID_WICPixelFormat16bppGray = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x0b);
|
|
public static readonly Guid GUID_WICPixelFormat16bppGrayFixedPoint = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x13);
|
|
public static readonly Guid GUID_WICPixelFormat16bppGrayHalf = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x3e);
|
|
public static readonly Guid GUID_WICPixelFormat16bppYQuantizedDctCoefficients = new Guid(0xA355F433, 0x48E8, 0x4A42, 0x84, 0xD8, 0xE2, 0xAA, 0x26, 0xCA, 0x80, 0xA4);
|
|
public static readonly Guid GUID_WICPixelFormat1bppIndexed = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x01);
|
|
public static readonly Guid GUID_WICPixelFormat24bpp3Channels = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x20);
|
|
public static readonly Guid GUID_WICPixelFormat24bppBGR = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x0c);
|
|
public static readonly Guid GUID_WICPixelFormat24bppRGB = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x0d);
|
|
public static readonly Guid GUID_WICPixelFormat2bppGray = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x06);
|
|
public static readonly Guid GUID_WICPixelFormat2bppIndexed = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x02);
|
|
public static readonly Guid GUID_WICPixelFormat32bpp3ChannelsAlpha = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x2e);
|
|
public static readonly Guid GUID_WICPixelFormat32bpp4Channels = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x21);
|
|
public static readonly Guid GUID_WICPixelFormat32bppBGR = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x0e);
|
|
public static readonly Guid GUID_WICPixelFormat32bppBGR101010 = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x14);
|
|
public static readonly Guid GUID_WICPixelFormat32bppBGRA = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x0f);
|
|
public static readonly Guid GUID_WICPixelFormat32bppCMYK = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x1c);
|
|
public static readonly Guid GUID_WICPixelFormat32bppGrayFixedPoint = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x3f);
|
|
public static readonly Guid GUID_WICPixelFormat32bppGrayFloat = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x11);
|
|
public static readonly Guid GUID_WICPixelFormat32bppPBGRA = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x10);
|
|
public static readonly Guid GUID_WICPixelFormat32bppPRGBA = new Guid(0x3cc4a650, 0xa527, 0x4d37, 0xa9, 0x16, 0x31, 0x42, 0xc7, 0xeb, 0xed, 0xba);
|
|
public static readonly Guid GUID_WICPixelFormat32bppR10G10B10A2 = new Guid(0x604e1bb5, 0x8a3c, 0x4b65, 0xb1, 0x1c, 0xbc, 0x0b, 0x8d, 0xd7, 0x5b, 0x7f);
|
|
public static readonly Guid GUID_WICPixelFormat32bppR10G10B10A2HDR10 = new Guid(0x9c215c5d, 0x1acc, 0x4f0e, 0xa4, 0xbc, 0x70, 0xfb, 0x3a, 0xe8, 0xfd, 0x28);
|
|
public static readonly Guid GUID_WICPixelFormat32bppRGB = new Guid(0xd98c6b95, 0x3efe, 0x47d6, 0xbb, 0x25, 0xeb, 0x17, 0x48, 0xab, 0x0c, 0xf1);
|
|
public static readonly Guid GUID_WICPixelFormat32bppRGBA = new Guid(0xf5c7ad2d, 0x6a8d, 0x43dd, 0xa7, 0xa8, 0xa2, 0x99, 0x35, 0x26, 0x1a, 0xe9);
|
|
public static readonly Guid GUID_WICPixelFormat32bppRGBA1010102 = new Guid(0x25238D72, 0xFCF9, 0x4522, 0xb5, 0x14, 0x55, 0x78, 0xe5, 0xad, 0x55, 0xe0);
|
|
public static readonly Guid GUID_WICPixelFormat32bppRGBA1010102XR = new Guid(0x00DE6B9A, 0xC101, 0x434b, 0xb5, 0x02, 0xd0, 0x16, 0x5e, 0xe1, 0x12, 0x2c);
|
|
public static readonly Guid GUID_WICPixelFormat32bppRGBE = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x3d);
|
|
public static readonly Guid GUID_WICPixelFormat40bpp4ChannelsAlpha = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x2f);
|
|
public static readonly Guid GUID_WICPixelFormat40bpp5Channels = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x22);
|
|
public static readonly Guid GUID_WICPixelFormat40bppCMYKAlpha = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x2c);
|
|
public static readonly Guid GUID_WICPixelFormat48bpp3Channels = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x26);
|
|
public static readonly Guid GUID_WICPixelFormat48bpp5ChannelsAlpha = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x30);
|
|
public static readonly Guid GUID_WICPixelFormat48bpp6Channels = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x23);
|
|
public static readonly Guid GUID_WICPixelFormat48bppBGR = new Guid(0xe605a384, 0xb468, 0x46ce, 0xbb, 0x2e, 0x36, 0xf1, 0x80, 0xe6, 0x43, 0x13);
|
|
public static readonly Guid GUID_WICPixelFormat48bppBGRFixedPoint = new Guid(0x49ca140e, 0xcab6, 0x493b, 0x9d, 0xdf, 0x60, 0x18, 0x7c, 0x37, 0x53, 0x2a);
|
|
public static readonly Guid GUID_WICPixelFormat48bppRGB = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x15);
|
|
public static readonly Guid GUID_WICPixelFormat48bppRGBFixedPoint = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x12);
|
|
public static readonly Guid GUID_WICPixelFormat48bppRGBHalf = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x3b);
|
|
public static readonly Guid GUID_WICPixelFormat4bppGray = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x07);
|
|
public static readonly Guid GUID_WICPixelFormat4bppIndexed = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x03);
|
|
public static readonly Guid GUID_WICPixelFormat56bpp6ChannelsAlpha = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x31);
|
|
public static readonly Guid GUID_WICPixelFormat56bpp7Channels = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x24);
|
|
public static readonly Guid GUID_WICPixelFormat64bpp3ChannelsAlpha = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x34);
|
|
public static readonly Guid GUID_WICPixelFormat64bpp4Channels = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x27);
|
|
public static readonly Guid GUID_WICPixelFormat64bpp7ChannelsAlpha = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x32);
|
|
public static readonly Guid GUID_WICPixelFormat64bpp8Channels = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x25);
|
|
public static readonly Guid GUID_WICPixelFormat64bppBGRA = new Guid(0x1562ff7c, 0xd352, 0x46f9, 0x97, 0x9e, 0x42, 0x97, 0x6b, 0x79, 0x22, 0x46);
|
|
public static readonly Guid GUID_WICPixelFormat64bppBGRAFixedPoint = new Guid(0x356de33c, 0x54d2, 0x4a23, 0xbb, 0x4, 0x9b, 0x7b, 0xf9, 0xb1, 0xd4, 0x2d);
|
|
public static readonly Guid GUID_WICPixelFormat64bppCMYK = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x1f);
|
|
public static readonly Guid GUID_WICPixelFormat64bppPBGRA = new Guid(0x8c518e8e, 0xa4ec, 0x468b, 0xae, 0x70, 0xc9, 0xa3, 0x5a, 0x9c, 0x55, 0x30);
|
|
public static readonly Guid GUID_WICPixelFormat64bppPRGBA = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x17);
|
|
public static readonly Guid GUID_WICPixelFormat64bppPRGBAHalf = new Guid(0x58ad26c2, 0xc623, 0x4d9d, 0xb3, 0x20, 0x38, 0x7e, 0x49, 0xf8, 0xc4, 0x42);
|
|
public static readonly Guid GUID_WICPixelFormat64bppRGB = new Guid(0xa1182111, 0x186d, 0x4d42, 0xbc, 0x6a, 0x9c, 0x83, 0x03, 0xa8, 0xdf, 0xf9);
|
|
public static readonly Guid GUID_WICPixelFormat64bppRGBA = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x16);
|
|
public static readonly Guid GUID_WICPixelFormat64bppRGBAFixedPoint = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x1d);
|
|
public static readonly Guid GUID_WICPixelFormat64bppRGBAHalf = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x3a);
|
|
public static readonly Guid GUID_WICPixelFormat64bppRGBFixedPoint = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x40);
|
|
public static readonly Guid GUID_WICPixelFormat64bppRGBHalf = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x42);
|
|
public static readonly Guid GUID_WICPixelFormat72bpp8ChannelsAlpha = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x33);
|
|
public static readonly Guid GUID_WICPixelFormat80bpp4ChannelsAlpha = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x35);
|
|
public static readonly Guid GUID_WICPixelFormat80bpp5Channels = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x28);
|
|
public static readonly Guid GUID_WICPixelFormat80bppCMYKAlpha = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x2d);
|
|
public static readonly Guid GUID_WICPixelFormat8bppAlpha = new Guid(0xe6cd0116, 0xeeba, 0x4161, 0xaa, 0x85, 0x27, 0xdd, 0x9f, 0xb3, 0xa8, 0x95);
|
|
public static readonly Guid GUID_WICPixelFormat8bppCb = new Guid(0x1339F224, 0x6BFE, 0x4C3E, 0x93, 0x02, 0xE4, 0xF3, 0xA6, 0xD0, 0xCA, 0x2A);
|
|
public static readonly Guid GUID_WICPixelFormat8bppCr = new Guid(0xB8145053, 0x2116, 0x49F0, 0x88, 0x35, 0xED, 0x84, 0x4B, 0x20, 0x5C, 0x51);
|
|
public static readonly Guid GUID_WICPixelFormat8bppGray = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x08);
|
|
public static readonly Guid GUID_WICPixelFormat8bppIndexed = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x04);
|
|
public static readonly Guid GUID_WICPixelFormat8bppY = new Guid(0x91B4DB54, 0x2DF9, 0x42F0, 0xB4, 0x49, 0x29, 0x09, 0xBB, 0x3D, 0xF8, 0x8E);
|
|
public static readonly Guid GUID_WICPixelFormat96bpp5ChannelsAlpha = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x36);
|
|
public static readonly Guid GUID_WICPixelFormat96bpp6Channels = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x29);
|
|
public static readonly Guid GUID_WICPixelFormat96bppRGBFixedPoint = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x18);
|
|
public static readonly Guid GUID_WICPixelFormat96bppRGBFloat = new Guid(0xe3fed78f, 0xe8db, 0x4acf, 0x84, 0xc1, 0xe9, 0x7f, 0x61, 0x36, 0xb3, 0x27);
|
|
public static readonly Guid GUID_WICPixelFormatBlackWhite = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x05);
|
|
public static readonly Guid GUID_WICPixelFormatDontCare = new Guid(0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x00);
|
|
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
|
|
}
|
|
}
|
|
} |