/*++ BUILD Version: 0002    // Increment this if a change has global effects

Copyright (c) 2000 Microsoft Corporation

Module Name:

    wincodec.idl

Abstract:

    This module contains the public data structures and API definitions
    needed for the Windows still image codecs.

Revision History:

--*/

import "wtypes.idl";
import "propidl.idl";
import "objidl.idl";
import "ocidl.idl";

/*=========================================================================*\
    Includes
\*=========================================================================*/

cpp_quote("#include <intsafe.h>")

/*=========================================================================*\
    SDK Version
\*=========================================================================*/

cpp_quote("#define WINCODEC_SDK_VERSION 0x0236")

cpp_quote("DEFINE_GUID(CLSID_WICImagingFactory, 0xcacaf262, 0x9370, 0x4615, 0xa1, 0x3b, 0x9f, 0x55, 0x39, 0xda, 0x4c, 0xa);")


/*=========================================================================*\
    GUID Identifiers for the vendors
\*=========================================================================*/

cpp_quote("DEFINE_GUID(GUID_VendorMicrosoft, 0xf0e749ca, 0xedef, 0x4589, 0xa7, 0x3a, 0xee, 0xe, 0x62, 0x6a, 0x2a, 0x2b);")
cpp_quote("DEFINE_GUID(GUID_VendorMicrosoftBuiltIn, 0x257a30fd, 0x6b6, 0x462b, 0xae, 0xa4, 0x63, 0xf7, 0xb, 0x86, 0xe5, 0x33);")


/*=========================================================================*\
    GUID Identifiers for the codecs
\*=========================================================================*/

cpp_quote("DEFINE_GUID(CLSID_WICBmpDecoder,  0x6b462062, 0x7cbf, 0x400d, 0x9f, 0xdb, 0x81, 0x3d, 0xd1, 0x0f, 0x27, 0x78);")
cpp_quote("DEFINE_GUID(CLSID_WICPngDecoder,  0x389ea17b, 0x5078, 0x4cde, 0xb6, 0xef, 0x25, 0xc1, 0x51, 0x75, 0xc7, 0x51);")
cpp_quote("DEFINE_GUID(CLSID_WICIcoDecoder,  0xc61bfcdf, 0x2e0f, 0x4aad, 0xa8, 0xd7, 0xe0, 0x6b, 0xaf, 0xeb, 0xcd, 0xfe);")
cpp_quote("DEFINE_GUID(CLSID_WICJpegDecoder, 0x9456a480, 0xe88b, 0x43ea, 0x9e, 0x73, 0x0b, 0x2d, 0x9b, 0x71, 0xb1, 0xca);")
cpp_quote("DEFINE_GUID(CLSID_WICGifDecoder,  0x381dda3c, 0x9ce9, 0x4834, 0xa2, 0x3e, 0x1f, 0x98, 0xf8, 0xfc, 0x52, 0xbe);")
cpp_quote("DEFINE_GUID(CLSID_WICTiffDecoder, 0xb54e85d9, 0xfe23, 0x499f, 0x8b, 0x88, 0x6a, 0xce, 0xa7, 0x13, 0x75, 0x2b);")
cpp_quote("DEFINE_GUID(CLSID_WICWmpDecoder,  0xa26cec36, 0x234c, 0x4950, 0xae, 0x16, 0xe3, 0x4a, 0xac, 0xe7, 0x1d, 0x0d);")

cpp_quote("DEFINE_GUID(CLSID_WICBmpEncoder,  0x69be8bb4, 0xd66d, 0x47c8, 0x86, 0x5a, 0xed, 0x15, 0x89, 0x43, 0x37, 0x82);")
cpp_quote("DEFINE_GUID(CLSID_WICPngEncoder,  0x27949969, 0x876a, 0x41d7, 0x94, 0x47, 0x56, 0x8f, 0x6a, 0x35, 0xa4, 0xdc);")
cpp_quote("DEFINE_GUID(CLSID_WICJpegEncoder, 0x1a34f5c1, 0x4a5a, 0x46dc, 0xb6, 0x44, 0x1f, 0x45, 0x67, 0xe7, 0xa6, 0x76);")
cpp_quote("DEFINE_GUID(CLSID_WICGifEncoder,  0x114f5598, 0x0b22, 0x40a0, 0x86, 0xa1, 0xc8, 0x3e, 0xa4, 0x95, 0xad, 0xbd);")
cpp_quote("DEFINE_GUID(CLSID_WICTiffEncoder, 0x0131be10, 0x2001, 0x4c5f, 0xa9, 0xb0, 0xcc, 0x88, 0xfa, 0xb6, 0x4c, 0xe8);")
cpp_quote("DEFINE_GUID(CLSID_WICWmpEncoder,  0xac4ce3cb, 0xe1c1, 0x44cd, 0x82, 0x15, 0x5a, 0x16, 0x65, 0x50, 0x9e, 0xc2);")


/*=========================================================================*\
    GUID Identifiers for the image container formats
\*=========================================================================*/

cpp_quote("DEFINE_GUID(GUID_ContainerFormatBmp,  0x0af1d87e, 0xfcfe, 0x4188, 0xbd, 0xeb, 0xa7, 0x90, 0x64, 0x71, 0xcb, 0xe3);")
cpp_quote("DEFINE_GUID(GUID_ContainerFormatPng,  0x1b7cfaf4, 0x713f, 0x473c, 0xbb, 0xcd, 0x61, 0x37, 0x42, 0x5f, 0xae, 0xaf);")
cpp_quote("DEFINE_GUID(GUID_ContainerFormatIco,  0xa3a860c4, 0x338f, 0x4c17, 0x91, 0x9a, 0xfb, 0xa4, 0xb5, 0x62, 0x8f, 0x21);")
cpp_quote("DEFINE_GUID(GUID_ContainerFormatJpeg, 0x19e4a5aa, 0x5662, 0x4fc5, 0xa0, 0xc0, 0x17, 0x58, 0x02, 0x8e, 0x10, 0x57);")
cpp_quote("DEFINE_GUID(GUID_ContainerFormatTiff, 0x163bcc30, 0xe2e9, 0x4f0b, 0x96, 0x1d, 0xa3, 0xe9, 0xfd, 0xb7, 0x88, 0xa3);")
cpp_quote("DEFINE_GUID(GUID_ContainerFormatGif,  0x1f8a5601, 0x7d4d, 0x4cbd, 0x9c, 0x82, 0x1b, 0xc8, 0xd4, 0xee, 0xb9, 0xa5);")
cpp_quote("DEFINE_GUID(GUID_ContainerFormatWmp,  0x57a37caa, 0x367a, 0x4540, 0x91, 0x6b, 0xf1, 0x83, 0xc5, 0x09, 0x3a, 0x4b);")


/*=========================================================================*\
    Category Identifiers
\*=========================================================================*/

cpp_quote("DEFINE_GUID(CLSID_WICImagingCategories, 0xfae3d380, 0xfea4, 0x4623, 0x8c, 0x75, 0xc6, 0xb6, 0x11, 0x10, 0xb6, 0x81);")
cpp_quote("DEFINE_GUID(CATID_WICBitmapDecoders,    0x7ed96837, 0x96f0, 0x4812, 0xb2, 0x11, 0xf1, 0x3c, 0x24, 0x11, 0x7e, 0xd3);")
cpp_quote("DEFINE_GUID(CATID_WICBitmapEncoders,    0xac757296, 0x3522, 0x4e11, 0x98, 0x62, 0xc1, 0x7b, 0xe5, 0xa1, 0x76, 0x7e);")
cpp_quote("DEFINE_GUID(CATID_WICPixelFormats,      0x2b46e70f, 0xcda7, 0x473e, 0x89, 0xf6, 0xdc, 0x96, 0x30, 0xa2, 0x39, 0x0b);")
cpp_quote("DEFINE_GUID(CATID_WICFormatConverters,  0x7835eae8, 0xbf14, 0x49d1, 0x93, 0xce, 0x53, 0x3a, 0x40, 0x7b, 0x22, 0x48);")
cpp_quote("DEFINE_GUID(CATID_WICMetadataReader,    0x05af94d8, 0x7174, 0x4cd2, 0xbe, 0x4a, 0x41, 0x24, 0xb8, 0x0e, 0xe4, 0xb8);")
cpp_quote("DEFINE_GUID(CATID_WICMetadataWriter,    0xabe3b9a4, 0x257d, 0x4b97, 0xbd, 0x1a, 0x29, 0x4a, 0xf4, 0x96, 0x22, 0x2e);")


/*=========================================================================*\
    Format converters
\*=========================================================================*/

cpp_quote("DEFINE_GUID(CLSID_WICDefaultFormatConverter, 0x1a3f11dc, 0xb514, 0x4b17, 0x8c, 0x5f, 0x21, 0x54, 0x51, 0x38, 0x52, 0xf1);")
cpp_quote("DEFINE_GUID(CLSID_WICFormatConverterHighColor, 0xac75d454, 0x9f37, 0x48f8, 0xb9, 0x72, 0x4e, 0x19, 0xbc, 0x85, 0x60, 0x11);")
cpp_quote("DEFINE_GUID(CLSID_WICFormatConverterNChannel, 0xc17cabb2, 0xd4a3, 0x47d7, 0xa5, 0x57, 0x33, 0x9b, 0x2e, 0xfb, 0xd4, 0xf1);")
cpp_quote("DEFINE_GUID(CLSID_WICFormatConverterWMPhoto, 0x9cb5172b, 0xd600, 0x46ba, 0xab, 0x77, 0x77, 0xbb, 0x7e, 0x3a, 0x00, 0xd9);")


/*=========================================================================*\
    Interface forward declarations :
\*=========================================================================*/

interface IWICImagingFactory;
interface IWICPalette;
interface IWICBitmap;
interface IWICBitmapLock;
interface IWICBitmapSource;
interface IWICFastMetadataEncoder;
interface IWICBitmapCodecInfo;
interface IWICBitmapDecoderInfo;
interface IWICBitmapEncoderInfo;
interface IWICBitmapDecoder;
interface IWICBitmapEncoder;
interface IWICBitmapFrameDecode;
interface IWICBitmapFrameEncode;
interface IWICBitmapSourceTransform;
interface IWICBitmapScaler;
interface IWICBitmapClipper;
interface IWICBitmapFlipRotator;
interface IWICFormatConverter;
interface IWICComponentInfo;
interface IWICStream;
interface IWICEnumMetadataItem;
interface IWICMetadataQueryReader;
interface IWICMetadataQueryWriter;


/*=========================================================================*\
    Color
\*=========================================================================*/

typedef UINT32 WICColor;


/*=========================================================================*\
    Rect
\*=========================================================================*/

typedef [public] struct WICRect
{
    INT X;
    INT Y;
    INT Width;
    INT Height;
} WICRect;


/*=========================================================================*\
    Definition of a wire pointer.
\*=========================================================================*/

cpp_quote("typedef BYTE* WICInProcPointer;")
cpp_quote("#if 0")
typedef [wire_marshal(UINT_PTR)] void* WICInProcPointer;
cpp_quote("#endif")


/*=========================================================================*\
    WICColorContextType
\*=========================================================================*/

typedef [public] enum WICColorContextType
{
    WICColorContextUninitialized = 0x00000000,
    WICColorContextProfile  = 0x00000001,
    WICColorContextExifColorSpace = 0x00000002,
} WICColorContextType;


#define CODEC_FORCE_DWORD 0x7FFFFFFF


/*=========================================================================*\
    Pixel Format GUIDs
\*=========================================================================*/

typedef [public] REFGUID REFWICPixelFormatGUID;
typedef [public] GUID WICPixelFormatGUID;

/* Undefined formats */
cpp_quote("#define GUID_WICPixelFormatUndefined GUID_WICPixelFormatDontCare" )
cpp_quote("DEFINE_GUID(GUID_WICPixelFormatDontCare, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x00);")

/* Indexed formats */
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat1bppIndexed, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x01);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat2bppIndexed, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x02);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat4bppIndexed, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x03);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat8bppIndexed, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x04);")

/* Grayscale formats */
cpp_quote("DEFINE_GUID(GUID_WICPixelFormatBlackWhite, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x05);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat2bppGray,   0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x06);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat4bppGray,   0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x07);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat8bppGray,   0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x08);")

/* Alpha only format */
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat8bppAlpha, 0xe6cd0116, 0xeeba, 0x4161, 0xaa, 0x85, 0x27, 0xdd, 0x9f, 0xb3, 0xa8, 0x95);")

/* sRGB formats (gamma is approx. 2.2) */
/* For a full definition, see the sRGB spec */

/* 16bpp formats */
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat16bppBGR555, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x09);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat16bppBGR565, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x0a);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat16bppBGRA5551, 0x05ec7c2b, 0xf1e6, 0x4961, 0xad, 0x46, 0xe1, 0xcc, 0x81, 0x0a, 0x87, 0xd2);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat16bppGray,   0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x0b);")

/* 24bpp formats */
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat24bppBGR, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x0c);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat24bppRGB, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x0d);")

/* 32bpp format */
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat32bppBGR,   0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x0e);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat32bppBGRA,  0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x0f);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat32bppPBGRA, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x10);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat32bppGrayFloat,  0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x11);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat32bppRGBA, 0xf5c7ad2d, 0x6a8d, 0x43dd, 0xa7, 0xa8, 0xa2, 0x99, 0x35, 0x26, 0x1a, 0xe9);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat32bppPRGBA, 0x3cc4a650, 0xa527, 0x4d37, 0xa9, 0x16, 0x31, 0x42, 0xc7, 0xeb, 0xed, 0xba);")

/* 48bpp formats */
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat48bppRGB, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x15);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat48bppBGR, 0xe605a384, 0xb468, 0x46ce, 0xbb, 0x2e, 0x36, 0xf1, 0x80, 0xe6, 0x43, 0x13);")

/* 64bpp format */
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat64bppRGBA,  0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x16);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat64bppBGRA,  0x1562ff7c, 0xd352, 0x46f9, 0x97, 0x9e, 0x42, 0x97, 0x6b, 0x79, 0x22, 0x46);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat64bppPRGBA, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x17);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat64bppPBGRA, 0x8c518e8e, 0xa4ec, 0x468b, 0xae, 0x70, 0xc9, 0xa3, 0x5a, 0x9c, 0x55, 0x30);")

/* scRGB formats. Gamma is 1.0 */
/* For a full definition, see the scRGB spec */

/* 16bpp format */
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat16bppGrayFixedPoint, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x13);")

/* 32bpp format */
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat32bppBGR101010, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x14);")

/* 48bpp format */
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat48bppRGBFixedPoint, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x12);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat48bppBGRFixedPoint, 0x49ca140e, 0xcab6, 0x493b, 0x9d, 0xdf, 0x60, 0x18, 0x7c, 0x37, 0x53, 0x2a);")

/* 96bpp format */
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat96bppRGBFixedPoint, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x18);")

 /* Floating point scRGB formats */
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat128bppRGBAFloat,  0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x19);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat128bppPRGBAFloat, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x1a);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat128bppRGBFloat,   0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x1b);")

 /* CMYK formats */
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat32bppCMYK, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x1c);")

 /* Extended formats */
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat64bppRGBAFixedPoint, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x1d);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat64bppBGRAFixedPoint, 0x356de33c, 0x54d2, 0x4a23, 0xbb, 0x4, 0x9b, 0x7b, 0xf9, 0xb1, 0xd4, 0x2d);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat64bppRGBFixedPoint, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x40);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat128bppRGBAFixedPoint, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x1e);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat128bppRGBFixedPoint, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x41);")

cpp_quote("DEFINE_GUID(GUID_WICPixelFormat64bppRGBAHalf, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x3a);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat64bppRGBHalf, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x42);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat48bppRGBHalf, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x3b);")

cpp_quote("DEFINE_GUID(GUID_WICPixelFormat32bppRGBE, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x3d);")

cpp_quote("DEFINE_GUID(GUID_WICPixelFormat16bppGrayHalf, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x3e);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat32bppGrayFixedPoint, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x3f);")

cpp_quote("DEFINE_GUID(GUID_WICPixelFormat32bppRGBA1010102, 0x25238D72, 0xFCF9, 0x4522, 0xb5, 0x14, 0x55, 0x78, 0xe5, 0xad, 0x55, 0xe0);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat32bppRGBA1010102XR, 0x00DE6B9A, 0xC101, 0x434b, 0xb5, 0x02, 0xd0, 0x16, 0x5e, 0xe1, 0x12, 0x2c);")

/* More CMYK formats and n-Channel formats */
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat64bppCMYK, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x1f);")

cpp_quote("DEFINE_GUID(GUID_WICPixelFormat24bpp3Channels, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x20);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat32bpp4Channels, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x21);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat40bpp5Channels, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x22);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat48bpp6Channels, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x23);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat56bpp7Channels, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x24);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat64bpp8Channels, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x25);")

cpp_quote("DEFINE_GUID(GUID_WICPixelFormat48bpp3Channels, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x26);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat64bpp4Channels, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x27);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat80bpp5Channels, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x28);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat96bpp6Channels, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x29);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat112bpp7Channels, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x2a);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat128bpp8Channels, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x2b);")

cpp_quote("DEFINE_GUID(GUID_WICPixelFormat40bppCMYKAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x2c);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat80bppCMYKAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x2d);")

cpp_quote("DEFINE_GUID(GUID_WICPixelFormat32bpp3ChannelsAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x2e);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat40bpp4ChannelsAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x2f);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat48bpp5ChannelsAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x30);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat56bpp6ChannelsAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x31);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat64bpp7ChannelsAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x32);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat72bpp8ChannelsAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x33);")

cpp_quote("DEFINE_GUID(GUID_WICPixelFormat64bpp3ChannelsAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x34);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat80bpp4ChannelsAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x35);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat96bpp5ChannelsAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x36);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat112bpp6ChannelsAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x37);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat128bpp7ChannelsAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x38);")
cpp_quote("DEFINE_GUID(GUID_WICPixelFormat144bpp8ChannelsAlpha, 0x6fddc324, 0x4e03, 0x4bfe, 0xb1, 0x85, 0x3d, 0x77, 0x76, 0x8d, 0xc9, 0x39);")


/*=========================================================================*\
    WICBitmapCreateCacheOptions
\*=========================================================================*/

typedef [public] enum WICBitmapCreateCacheOption
{
    WICBitmapNoCache                       = 0x00000000,
    WICBitmapCacheOnDemand                 = 0x00000001,
    WICBitmapCacheOnLoad                   = 0x00000002,
    WICBITMAPCREATECACHEOPTION_FORCE_DWORD = CODEC_FORCE_DWORD
} WICBitmapCreateCacheOption;


/*=========================================================================*\
    WICDecodeOptions
\*=========================================================================*/

typedef [public] enum WICDecodeOptions
{
    WICDecodeMetadataCacheOnDemand     = 0x00000000,
    WICDecodeMetadataCacheOnLoad       = 0x00000001,
    WICMETADATACACHEOPTION_FORCE_DWORD = CODEC_FORCE_DWORD
} WICDecodeOptions;


/*=========================================================================*\
    WICBitmapEncoderCacheOption
\*=========================================================================*/

typedef [public] enum WICBitmapEncoderCacheOption
{
   WICBitmapEncoderCacheInMemory           = 0x00000000,
   WICBitmapEncoderCacheTempFile           = 0x00000001,
   WICBitmapEncoderNoCache                 = 0x00000002,
   WICBITMAPENCODERCACHEOPTION_FORCE_DWORD = CODEC_FORCE_DWORD
} WICBitmapEncoderCacheOption;


/*=========================================================================*\
    WICComponentType
\*=========================================================================*/

typedef [public] enum WICComponentType
{
    WICDecoder                   = 0x00000001,
    WICEncoder                   = 0x00000002,
    WICPixelFormatConverter      = 0x00000004,
    WICMetadataReader            = 0x00000008,
    WICMetadataWriter            = 0x00000010,
    WICPixelFormat               = 0x00000020,
    WICAllComponents             = 0x0000003F,
    WICCOMPONENTTYPE_FORCE_DWORD = CODEC_FORCE_DWORD
} WICComponentType;


/*=========================================================================*\
    WICComponentEnumerateOptions
\*=========================================================================*/

typedef [public] enum WICComponentEnumerateOptions
{
    WICComponentEnumerateDefault             = 0x00000000,
    WICComponentEnumerateRefresh             = 0x00000001,
    WICComponentEnumerateDisabled            = 0x80000000,
    WICComponentEnumerateUnsigned            = 0x40000000,
    WICComponentEnumerateBuiltInOnly         = 0x20000000,
    WICCOMPONENTENUMERATEOPTIONS_FORCE_DWORD = CODEC_FORCE_DWORD
} WICComponentEnumerateOptions;


/*=========================================================================*\
    WICBitmapPattern
\*=========================================================================*/

typedef [public] struct WICBitmapPattern
{
    ULARGE_INTEGER Position;
    ULONG Length;
    [size_is(Length)] BYTE *Pattern;
    [size_is(Length)] BYTE *Mask;
    BOOL  EndOfStream;

}   WICBitmapPattern;


/*=========================================================================*\
    WICBitmapInterpolationMode
\*=========================================================================*/

typedef [public] enum WICBitmapInterpolationMode
{
    // Nearest Neighbor filtering. Also known as nearest pixel or nearest point
    // sampling.

    WICBitmapInterpolationModeNearestNeighbor = 0x00000000,

    // Linear filtering.

    WICBitmapInterpolationModeLinear          = 0x00000001,

    // Cubic filtering. May include linear pre-filtering or decimation.

    WICBitmapInterpolationModeCubic           = 0x00000002,

    // Fant filtering.

    WICBitmapInterpolationModeFant            = 0x00000003,

    WICBITMAPINTERPOLATIONMODE_FORCE_DWORD    = CODEC_FORCE_DWORD
} WICBitmapInterpolationMode;


/*=========================================================================*\
    WICBitmapPaletteType
\*=========================================================================*/

typedef [public] enum WICBitmapPaletteType
{
    // Arbitrary custom palette provided by caller.

    WICBitmapPaletteTypeCustom           = 0x00000000,

    // Optimal palette generated using a median-cut algorithm.

    WICBitmapPaletteTypeMedianCut        = 0x00000001,

    // Black and white palette.

    WICBitmapPaletteTypeFixedBW          = 0x00000002,

    // Symmetric halftone palettes.
    // Each of these halftone palettes will be a superset of the system palette.
    // E.g. Halftone8 will have it's 8-color on-off primaries and the 16 system
    // colors added. With duplicates removed, that leaves 16 colors.

    WICBitmapPaletteTypeFixedHalftone8   = 0x00000003, // 8-color, on-off primaries
    WICBitmapPaletteTypeFixedHalftone27  = 0x00000004, // 3 intensity levels of each color
    WICBitmapPaletteTypeFixedHalftone64  = 0x00000005, // 4 intensity levels of each color
    WICBitmapPaletteTypeFixedHalftone125 = 0x00000006, // 5 intensity levels of each color
    WICBitmapPaletteTypeFixedHalftone216 = 0x00000007, // 6 intensity levels of each color

    // Convenient web palette, same as WICBitmapPaletteTypeFixedHalftone216

    WICBitmapPaletteTypeFixedWebPalette  = WICBitmapPaletteTypeFixedHalftone216,

    // Assymetric halftone palettes.
    // These are somewhat less useful than the symmetric ones, but are
    // included for completeness. These do not include all of the system
    // colors.

    WICBitmapPaletteTypeFixedHalftone252 = 0x00000008, // 6-red, 7-green, 6-blue intensities
    WICBitmapPaletteTypeFixedHalftone256 = 0x00000009, // 8-red, 8-green, 4-blue intensities

    WICBitmapPaletteTypeFixedGray4       = 0x0000000A, //   4 shades of gray
    WICBitmapPaletteTypeFixedGray16      = 0x0000000B, //  16 shades of gray
    WICBitmapPaletteTypeFixedGray256     = 0x0000000C, // 256 shades of gray

    WICBITMAPPALETTETYPE_FORCE_DWORD     = CODEC_FORCE_DWORD
} WICBitmapPaletteType;


/*=========================================================================*\
    WICBitmapDitherType
\*=========================================================================*/

typedef [public] enum WICBitmapDitherType
{
    // Solid color - picks the nearest matching color with no attempt to
    // halftone or dither. May be used on an arbitrary palette.

    WICBitmapDitherTypeNone           = 0x00000000,
    WICBitmapDitherTypeSolid          = 0x00000000,

    // Ordered dithers and spiral dithers must be used with a fixed palette or
    // a fixed palette translation.

    // NOTE: DitherOrdered4x4 is unique in that it may apply to 16bpp
    // conversions also.

    WICBitmapDitherTypeOrdered4x4     = 0x00000001,

    WICBitmapDitherTypeOrdered8x8     = 0x00000002,
    WICBitmapDitherTypeOrdered16x16   = 0x00000003,
    WICBitmapDitherTypeSpiral4x4      = 0x00000004,
    WICBitmapDitherTypeSpiral8x8      = 0x00000005,
    WICBitmapDitherTypeDualSpiral4x4  = 0x00000006,
    WICBitmapDitherTypeDualSpiral8x8  = 0x00000007,

    // Error diffusion. May be used with any palette.

    WICBitmapDitherTypeErrorDiffusion = 0x00000008,

    WICBITMAPDITHERTYPE_FORCE_DWORD   = CODEC_FORCE_DWORD
} WICBitmapDitherType;


/*=========================================================================*\
    WICBitmapAlphaChannelOption
\*=========================================================================*/

typedef [public] enum WICBitmapAlphaChannelOption
{
    WICBitmapUseAlpha                        = 0x00000000,
    WICBitmapUsePremultipliedAlpha           = 0x00000001,
    WICBitmapIgnoreAlpha                     = 0x00000002,
    WICBITMAPALPHACHANNELOPTIONS_FORCE_DWORD = CODEC_FORCE_DWORD
} WICBitmapAlphaChannelOption;


/*=========================================================================*\
    WICBitmapTransformOptions
\*=========================================================================*/

typedef [public] enum WICBitmapTransformOptions
{
    WICBitmapTransformRotate0             = 0x00000000,
    WICBitmapTransformRotate90            = 0x00000001,
    WICBitmapTransformRotate180           = 0x00000002,
    WICBitmapTransformRotate270           = 0x00000003,
    WICBitmapTransformFlipHorizontal      = 0x00000008,
    WICBitmapTransformFlipVertical        = 0x00000010,
    WICBITMAPTRANSFORMOPTIONS_FORCE_DWORD = CODEC_FORCE_DWORD
} WICBitmapTransformOptions;


/*=========================================================================*\
    WICBitmapLockFlags
\*=========================================================================*/

typedef [public] enum WICBitmapLockFlags
{
   WICBitmapLockRead              = 0x00000001,
   WICBitmapLockWrite             = 0x00000002,
   WICBITMAPLOCKFLAGS_FORCE_DWORD = CODEC_FORCE_DWORD
} WICBitmapLockFlags;


/*=========================================================================*\
    WICBitmapDecoderCapabilities
\*=========================================================================*/

typedef [public] enum WICBitmapDecoderCapabilities
{
    WICBitmapDecoderCapabilitySameEncoder          = 0x00000001,
    WICBitmapDecoderCapabilityCanDecodeAllImages   = 0x00000002,
    WICBitmapDecoderCapabilityCanDecodeSomeImages  = 0x00000004,
    WICBitmapDecoderCapabilityCanEnumerateMetadata = 0x00000008,
    WICBitmapDecoderCapabilityCanDecodeThumbnail   = 0x00000010,
    WICBITMAPDECODERCAPABILITIES_FORCE_DWORD       = CODEC_FORCE_DWORD
} WICBitmapDecoderCapabilities;


/*=========================================================================*\
    WICProgressOperation
\*=========================================================================*/

typedef [public] enum WICProgressOperation
{
    WICProgressOperationCopyPixels   = 0x00000001,
    WICProgressOperationWritePixels  = 0x00000002,
    WICProgressOperationAll          = 0x0000FFFF,
    WICPROGRESSOPERATION_FORCE_DWORD = CODEC_FORCE_DWORD
} WICProgressOperation;


/*=========================================================================*\
    WICProgressNotification
\*=========================================================================*/

typedef [public] enum WICProgressNotification
{
    WICProgressNotificationBegin        = 0x00010000,
    WICProgressNotificationEnd          = 0x00020000,
    WICProgressNotificationFrequent     = 0x00040000,
    WICProgressNotificationAll          = 0xFFFF0000,
    WICPROGRESSNOTIFICATION_FORCE_DWORD = CODEC_FORCE_DWORD
} WICProgressNotification;


/*=========================================================================*\
    WICComponentSigning
\*=========================================================================*/

typedef [public] enum WICComponentSigning
{
    WICComponentSigned              = 0x00000001,
    WICComponentUnsigned            = 0x00000002,
    WICComponentSafe                = 0x00000004,
    WICComponentDisabled            = 0x80000000,
    WICCOMPONENTSIGNING_FORCE_DWORD = CODEC_FORCE_DWORD
} WICComponentSigning;


/*=========================================================================*\
    WICGifLogicalScreenDescriptorProperties 
\*=========================================================================*/

typedef [public] enum WICGifLogicalScreenDescriptorProperties
{
    // This part is for Logical Screen Descriptor
    WICGifLogicalScreenSignature                        = 0x00000001,	
    WICGifLogicalScreenDescriptorWidth                  = 0x00000002,
    WICGifLogicalScreenDescriptorHeight                 = 0x00000003,
    WICGifLogicalScreenDescriptorGlobalColorTableFlag   = 0x00000004,
    WICGifLogicalScreenDescriptorColorResolution        = 0x00000005,
    WICGifLogicalScreenDescriptorSortFlag               = 0x00000006,
    WICGifLogicalScreenDescriptorGlobalColorTableSize   = 0x00000007,
    WICGifLogicalScreenDescriptorBackgroundColorIndex   = 0x00000008,
    WICGifLogicalScreenDescriptorPixelAspectRatio       = 0x00000009,
    WICGifLogicalScreenDescriptorProperties_FORCE_DWORD = CODEC_FORCE_DWORD

} WICGifLogicalScreenDescriptorProperties;


/*=========================================================================*\
    WICGifImageDescriptorProperties 
\*=========================================================================*/

typedef [public] enum WICGifImageDescriptorProperties
{
    // This part is for Image Descriptor
    WICGifImageDescriptorLeft                   = 0x00000001,
    WICGifImageDescriptorTop                    = 0x00000002,
    WICGifImageDescriptorWidth                  = 0x00000003,
    WICGifImageDescriptorHeight                 = 0x00000004,
    WICGifImageDescriptorLocalColorTableFlag    = 0x00000005,
    WICGifImageDescriptorInterlaceFlag          = 0x00000006,
    WICGifImageDescriptorSortFlag               = 0x00000007,
    WICGifImageDescriptorLocalColorTableSize    = 0x00000008,
    WICGifImageDescriptorProperties_FORCE_DWORD = CODEC_FORCE_DWORD
} WICGifImageDescriptorProperties;


/*=========================================================================*\
    WICGifGraphicControlExtensionProperties 
\*=========================================================================*/

typedef [public] enum WICGifGraphicControlExtensionProperties
{
    // This part is for Graphic Control Extension
    WICGifGraphicControlExtensionDisposal               = 0x00000001,
    WICGifGraphicControlExtensionUserInputFlag          = 0x00000002,
    WICGifGraphicControlExtensionTransparencyFlag       = 0x00000003,
    WICGifGraphicControlExtensionDelay                  = 0x00000004,
    WICGifGraphicControlExtensionTransparentColorIndex  = 0x00000005,
    WICGifGraphicControlExtensionProperties_FORCE_DWORD = CODEC_FORCE_DWORD
} WICGifGraphicControlExtensionProperties;


/*=========================================================================*\
    WICGifApplicationExtensionProperties 
\*=========================================================================*/

typedef [public] enum WICGifApplicationExtensionProperties
{
    // This part is for Application Extension	 
    WICGifApplicationExtensionApplication            = 0x00000001,
    WICGifApplicationExtensionData                   = 0x00000002,
    WICGifApplicationExtensionProperties_FORCE_DWORD = CODEC_FORCE_DWORD
} WICGifApplicationExtensionProperties;


/*=========================================================================*\
    WICGifCommentExtensionProperties
\*=========================================================================*/

typedef [public] enum WICGifCommentExtensionProperties
{
    WICGifCommentExtensionText                   = 0x00000001,
    WICGifCommentExtensionProperties_FORCE_DWORD = CODEC_FORCE_DWORD
} WICGifCommentExtensionProperties;

/*=========================================================================*\
    WICJpegCommentProperties
\*=========================================================================*/

typedef [public] enum WICJpegCommentProperties
{
    WICJpegCommentText                   = 0x00000001,
    WICJpegCommentProperties_FORCE_DWORD = CODEC_FORCE_DWORD
} WICJpegCommentProperties;

/*=========================================================================*\
    WICJpegLuminanceProperties
\*=========================================================================*/

typedef [public] enum WICJpegLuminanceProperties
{
    WICJpegLuminanceTable                  = 0x00000001,
    WICJpegLuminanceProperties_FORCE_DWORD = CODEC_FORCE_DWORD
} WICJpegLuminanceProperties;

/*=========================================================================*\
    WICJpegChrominanceProperties
\*=========================================================================*/

typedef [public] enum WICJpegChrominanceProperties
{
    WICJpegChrominanceTable                  = 0x00000001,
    WICJpegChrominanceProperties_FORCE_DWORD = CODEC_FORCE_DWORD
} WICJpegChrominanceProperties;

/*=========================================================================*\
    WIC8BIMIptcProperties
\*=========================================================================*/

typedef [public] enum WIC8BIMIptcProperties
{
    WIC8BIMIptcPString                      = 0x00000000,
    WIC8BIMIptcEmbeddedIPTC                 = 0x00000001,
    WIC8BIMIptcProperties_FORCE_DWORD = CODEC_FORCE_DWORD
} WIC8BIMIptcProperties;

/*=========================================================================*\
    WIC8BIMResolutionInfoProperties
\*=========================================================================*/

typedef [public] enum WIC8BIMResolutionInfoProperties
{
    WIC8BIMResolutionInfoPString            = 0x00000001,
    WIC8BIMResolutionInfoHResolution        = 0x00000002,
    WIC8BIMResolutionInfoHResolutionUnit    = 0x00000003,
    WIC8BIMResolutionInfoWidthUnit          = 0x00000004,
    WIC8BIMResolutionInfoVResolution        = 0x00000005,
    WIC8BIMResolutionInfoVResolutionUnit    = 0x00000006,
    WIC8BIMResolutionInfoHeightUnit         = 0x00000007,
    WIC8BIMResolutionInfoProperties_FORCE_DWORD = CODEC_FORCE_DWORD
} WIC8BIMResolutionInfoProperties;

/*=========================================================================*\
    WIC8BIMIptcDigestProperties
\*=========================================================================*/

typedef [public] enum WIC8BIMIptcDigestProperties
{
    WIC8BIMIptcDigestPString                    = 0x00000001,
    WIC8BIMIptcDigestIptcDigest                 = 0x00000002,
    WIC8BIMIptcDigestProperties_FORCE_DWORD = CODEC_FORCE_DWORD
} WIC8BIMIptcDigestProperties;

/*=========================================================================*\
    WICPngGamaProperties
\*=========================================================================*/

typedef [public] enum WICPngGamaProperties
{
    WICPngGamaGamma                  = 0x00000001,
    WICPngGamaProperties_FORCE_DWORD = CODEC_FORCE_DWORD
} WICPngGamaProperties;


/*=========================================================================*\
    WICPngBkgdProperties
\*=========================================================================*/

typedef [public] enum WICPngBkgdProperties
{
    WICPngBkgdBackgroundColor        = 0x00000001,
    WICPngBkgdProperties_FORCE_DWORD = CODEC_FORCE_DWORD
} WICPngBkgdProperties;


/*=========================================================================*\
    WICPngItxtProperties
\*=========================================================================*/

typedef [public] enum WICPngItxtProperties
{
    WICPngItxtKeyword                = 0x00000001,
    WICPngItxtCompressionFlag        = 0x00000002,
    WICPngItxtLanguageTag            = 0x00000003,
    WICPngItxtTranslatedKeyword      = 0x00000004,
    WICPngItxtText                   = 0x00000005,
    WICPngItxtProperties_FORCE_DWORD = CODEC_FORCE_DWORD
} WICPngItxtProperties;


/*=========================================================================*\
    WICPngChrmProperties
\*=========================================================================*/

typedef [public] enum WICPngChrmProperties
{
    WICPngChrmWhitePointX            = 0x00000001,
    WICPngChrmWhitePointY            = 0x00000002,
    WICPngChrmRedX                   = 0x00000003,
    WICPngChrmRedY                   = 0x00000004,
    WICPngChrmGreenX                 = 0x00000005,
    WICPngChrmGreenY                 = 0x00000006,
    WICPngChrmBlueX                  = 0x00000007,
    WICPngChrmBlueY                  = 0x0000008,
    WICPngChrmProperties_FORCE_DWORD = CODEC_FORCE_DWORD
} WICPngChrmProperties;


/*=========================================================================*\
    WICPngHistProperties
\*=========================================================================*/

typedef [public] enum WICPngHistProperties
{
    WICPngHistFrequencies            = 0x00000001,
    WICPngHistProperties_FORCE_DWORD = CODEC_FORCE_DWORD
} WICPngHistProperties;


/*=========================================================================*\
    WICPngIccpProperties
\*=========================================================================*/

typedef [public] enum WICPngIccpProperties
{
    WICPngIccpProfileName            = 0x00000001,
    WICPngIccpProfileData            = 0x00000002,
    WICPngIccpProperties_FORCE_DWORD = CODEC_FORCE_DWORD
} WICPngIccpProperties;


/*=========================================================================*\
    WICPngSrgbProperties
\*=========================================================================*/

typedef [public] enum WICPngSrgbProperties
{
    WICPngSrgbRenderingIntent        = 0x00000001,
    WICPngSrgbProperties_FORCE_DWORD = CODEC_FORCE_DWORD
} WICPngSrgbProperties;


/*=========================================================================*\
    WICPngTimeProperties
\*=========================================================================*/

typedef [public] enum WICPngTimeProperties
{
    WICPngTimeYear                   = 0x00000001,
    WICPngTimeMonth                  = 0x00000002,
    WICPngTimeDay                    = 0x00000003,
    WICPngTimeHour                   = 0x00000004,
    WICPngTimeMinute                 = 0x00000005,
    WICPngTimeSecond                 = 0x00000006,
    WICPngTimeProperties_FORCE_DWORD = CODEC_FORCE_DWORD
} WICPngTimeProperties;


/*=========================================================================*\
    WICSectionAccessLevel
\*=========================================================================*/

typedef [public] enum WICSectionAccessLevel
{
    WICSectionAccessLevelRead         = 0x00000001,
    WICSectionAccessLevelReadWrite    = 0x00000003,
    WICSectionAccessLevel_FORCE_DWORD = CODEC_FORCE_DWORD
} WICSectionAccessLevel;


/*=========================================================================*\
    WICPixelFormatNumericRepresentation
\*=========================================================================*/

typedef [public] enum WICPixelFormatNumericRepresentation
{
    WICPixelFormatNumericRepresentationUnspecified     = 0x00000000,
    WICPixelFormatNumericRepresentationIndexed         = 0x00000001,
    WICPixelFormatNumericRepresentationUnsignedInteger = 0x00000002,
    WICPixelFormatNumericRepresentationSignedInteger   = 0x00000003,
    WICPixelFormatNumericRepresentationFixed           = 0x00000004,
    WICPixelFormatNumericRepresentationFloat           = 0x00000005,
    WICPixelFormatNumericRepresentation_FORCE_DWORD    = CODEC_FORCE_DWORD
} WICPixelFormatNumericRepresentation;


/*=========================================================================*\
    IWICPalette -  Palette
\*=========================================================================*/

[
   object,
   uuid(00000040-a8f2-4877-ba0a-fd2b6645fb94)
]
interface IWICPalette : IUnknown
{
    // Initialize the palette to one of the pre-defined palette types in
    // the PaletteType enumeration. A transparent color can be included
    // if desired. If the pre-defined palette has fewer than 256 entries,
    // one entry is appended for the transparent color - otherwise index
    // 255 is replaced with the transparent color.

    HRESULT InitializePredefined(
        [in] WICBitmapPaletteType ePaletteType,
        [in] BOOL fAddTransparentColor
        );

    // Build a custom palette. If a transparent color is required it should be
    // included in the array of input colors.

    HRESULT InitializeCustom(
        [in, size_is(cCount)] WICColor *pColors,
        [in] UINT cCount
        );

    // Compute an optimal palette from a given surface. The number of colors to
    // generate is controlled by cColors. If a transparent color is desired,
    // one of the cColors entries will be a transparent color - i.e. the count
    // will not be increased beyond cColors.

    HRESULT InitializeFromBitmap(
        [in] IWICBitmapSource *pISurface,
        [in] UINT cCount,
        [in] BOOL fAddTransparentColor
        );

    // Initialize the palette to be a copy of an existing palette.

    HRESULT InitializeFromPalette(
        [in] IWICPalette *pIPalette
        );

    HRESULT GetType(
        [out] WICBitmapPaletteType *pePaletteType
        );

    HRESULT GetColorCount(
        [out] UINT *pcCount
        );

    HRESULT GetColors(
        [in] UINT cCount,
        [out, size_is(cCount)] WICColor *pColors,
        [out] UINT *pcActualColors
        );

    HRESULT IsBlackWhite(
        [out] BOOL *pfIsBlackWhite
        );

    HRESULT IsGrayscale(
        [out] BOOL *pfIsGrayscale
        );

    HRESULT HasAlpha(
        [out] BOOL *pfHasAlpha
        );
};


/*=========================================================================*\
    IWICBitmapSource -  Source bitmap/imaging functionality
\*=========================================================================*/

[
   object,
   uuid(00000120-a8f2-4877-ba0a-fd2b6645fb94)
]
interface IWICBitmapSource : IUnknown
{
    HRESULT GetSize(
        [out] UINT *puiWidth,
        [out] UINT *puiHeight
        );

    HRESULT GetPixelFormat(
        [out] WICPixelFormatGUID *pPixelFormat
        );

    HRESULT GetResolution(
        [out] double *pDpiX,
        [out] double *pDpiY
        );

    HRESULT CopyPalette(
        [in] IWICPalette *pIPalette
        );

    HRESULT CopyPixels(
        [in, unique] const WICRect *prc,
        [in] UINT cbStride,
        [in] UINT cbBufferSize,
        [out, size_is(cbBufferSize)] BYTE *pbBuffer
        );
};


/*=========================================================================*\
    IWICFormatConverter
\*=========================================================================*/

[
   object,
   uuid(00000301-a8f2-4877-ba0a-fd2b6645fb94)
]
interface IWICFormatConverter : IWICBitmapSource
{
    HRESULT Initialize(
        [in] IWICBitmapSource *pISource,
        [in] REFWICPixelFormatGUID dstFormat,
        [in] WICBitmapDitherType dither,
        [in, unique] IWICPalette *pIPalette,
        [in] double alphaThresholdPercent,
        [in] WICBitmapPaletteType paletteTranslate
        );

    HRESULT CanConvert(
        [in] REFWICPixelFormatGUID srcPixelFormat,
        [in] REFWICPixelFormatGUID dstPixelFormat,
        [out] BOOL *pfCanConvert);

};


/*=========================================================================*\
    IWICBitmapScaler
\*=========================================================================*/

[
   object,
   uuid(00000302-a8f2-4877-ba0a-fd2b6645fb94)
]
interface IWICBitmapScaler : IWICBitmapSource
{
    HRESULT Initialize(
        [in] IWICBitmapSource *pISource,
        [in] UINT uiWidth,
        [in] UINT uiHeight,
        [in] WICBitmapInterpolationMode mode
        );
};


/*=========================================================================*\
    IWICBitmapClipper
\*=========================================================================*/

[
   object,
   uuid(E4FBCF03-223D-4e81-9333-D635556DD1B5)
]
interface IWICBitmapClipper : IWICBitmapSource
{
    HRESULT Initialize(
        [in] IWICBitmapSource *pISource,
        [in] const WICRect *prc
        );
};


/*=========================================================================*\
    IWICBitmapFlipRotator
\*=========================================================================*/

[
   object,
   uuid(5009834F-2D6A-41ce-9E1B-17C5AFF7A782)
]
interface IWICBitmapFlipRotator : IWICBitmapSource
{
    HRESULT Initialize(
        [in] IWICBitmapSource *pISource,
        [in] WICBitmapTransformOptions options
        );
};


/*=========================================================================*\
    IWICBitmapLock - WIC Lock object for bitmaps.
\*=========================================================================*/

[
   object,
   uuid(00000123-a8f2-4877-ba0a-fd2b6645fb94)
]
interface IWICBitmapLock : IUnknown
{
    HRESULT GetSize(
        [out] UINT *puiWidth,
        [out] UINT *puiHeight
        );

    HRESULT GetStride(
        [out] UINT *pcbStride
        );

    HRESULT GetDataPointer(
        [out] UINT *pcbBufferSize,
        [out, size_is( , *pcbBufferSize)] WICInProcPointer *ppbData
        );

    HRESULT GetPixelFormat(
        [out] WICPixelFormatGUID *pPixelFormat
        );
};


/*=========================================================================*\
    IWICBitmap - WIC Bitmap cache interface
\*=========================================================================*/

[
   object,
   uuid(00000121-a8f2-4877-ba0a-fd2b6645fb94)
]
interface IWICBitmap : IWICBitmapSource
{
    HRESULT Lock(
        [in, unique] const WICRect *prcLock,
        [in] DWORD flags,
        [out] IWICBitmapLock **ppILock
        );

    HRESULT SetPalette(
        [in] IWICPalette *pIPalette
        );

    HRESULT SetResolution(
        [in] double dpiX,
        [in] double dpiY
        );
};


/*=========================================================================*\
    IWICColorContext - WIC color context
\*=========================================================================*/

[
   object,
   uuid(3C613A02-34B2-44ea-9A7C-45AEA9C6FD6D)
]
interface IWICColorContext : IUnknown
{
    HRESULT InitializeFromFilename(
        [in] LPCWSTR wzFilename
        );

    HRESULT InitializeFromMemory(
        [in, size_is(cbBufferSize)] const BYTE *pbBuffer,
        [in] UINT cbBufferSize
        );

    HRESULT InitializeFromExifColorSpace(
        [in] UINT value
        );

    HRESULT GetType(
        [out] WICColorContextType *pType
        );

    HRESULT GetProfileBytes(
        [in] UINT cbBuffer,
        [in, out, unique, size_is(cbBuffer)] BYTE *pbBuffer,
        [out] UINT *pcbActual
        );

    HRESULT GetExifColorSpace(
        [out] UINT *pValue
        );

};


/*=========================================================================*\
    IWICColorTransform - WIC color transform
\*=========================================================================*/

[
   object,
   uuid(B66F034F-D0E2-40ab-B436-6DE39E321A94)
]
interface IWICColorTransform : IWICBitmapSource
{
    HRESULT Initialize(
         [in] IWICBitmapSource *pIBitmapSource,
         [in] IWICColorContext *pIContextSource,
         [in] IWICColorContext *pIContextDest,
         [in] REFWICPixelFormatGUID pixelFmtDest
         );
};


/*=========================================================================*\
    IWICFastMetadataEncoder
\*=========================================================================*/

[
   object,
   uuid(B84E2C09-78C9-4AC4-8BD3-524AE1663A2F)
]
interface IWICFastMetadataEncoder  : IUnknown
{
    HRESULT Commit(
        );

    HRESULT GetMetadataQueryWriter(
        [out] IWICMetadataQueryWriter **ppIMetadataQueryWriter
        );
};


/*=========================================================================*\
    IWICStream - WIC Bitmap Stream
\*=========================================================================*/

[
   object,
   uuid(135FF860-22B7-4ddf-B0F6-218F4F299A43)
]
interface IWICStream : IStream
{
    HRESULT InitializeFromIStream(
        [in] IStream *pIStream
        );

    HRESULT InitializeFromFilename(
        [in] LPCWSTR wzFileName,
        [in] DWORD dwDesiredAccess
        );

    HRESULT InitializeFromMemory(
        [in, size_is(cbBufferSize)] WICInProcPointer pbBuffer,
        [in] DWORD cbBufferSize
        );

    HRESULT InitializeFromIStreamRegion(
        [in] IStream *pIStream,
        [in] ULARGE_INTEGER ulOffset,
        [in] ULARGE_INTEGER ulMaxSize
        );
};


/*=========================================================================*\
    IWICEnumMetadataItem
\*=========================================================================*/

[
   object,
   uuid(DC2BB46D-3F07-481E-8625-220C4AEDBB33)
]
interface IWICEnumMetadataItem : IUnknown
{
     HRESULT Next(
        [in] ULONG celt,
        [in, out, unique, size_is(celt)] PROPVARIANT *rgeltSchema,
        [in, out, size_is(celt)] PROPVARIANT *rgeltId,
        [in, out, optional, size_is(celt)] PROPVARIANT *rgeltValue,
        [out, optional] ULONG *pceltFetched
        );

    HRESULT Skip(
        [in] ULONG celt
        ) ;

    HRESULT Reset();

    HRESULT Clone(
        [out] IWICEnumMetadataItem **ppIEnumMetadataItem
        );
}


/*=========================================================================*\
    IWICMetadataQueryReader - Metadata Query Reader
\*=========================================================================*/

[
   object,
   uuid(30989668-E1C9-4597-B395-458EEDB808DF)
]
interface IWICMetadataQueryReader : IUnknown
{
    HRESULT GetContainerFormat(
        [out] GUID *pguidContainerFormat
        );

    HRESULT GetLocation(
        [in] UINT cchMaxLength,
        [in, out, unique, size_is(cchMaxLength)] WCHAR *wzNamespace,
        [out] UINT *pcchActualLength
        );

    HRESULT GetMetadataByName(
        [in] LPCWSTR wzName,
        [in, out, unique] PROPVARIANT *pvarValue
        );

    HRESULT GetEnumerator(
        [out] IEnumString **ppIEnumString
        );
}


/*=========================================================================*\
    IWICMetadataQueryWriter - Metadata Query Writer
\*=========================================================================*/

[
   object,
   uuid(A721791A-0DEF-4d06-BD91-2118BF1DB10B)
]
interface IWICMetadataQueryWriter : IWICMetadataQueryReader
{
    HRESULT SetMetadataByName(
       [in] LPCWSTR wzName,
       [in] const PROPVARIANT *pvarValue
       );

    HRESULT RemoveMetadataByName(
       [in] LPCWSTR wzName
       );
}


/*=========================================================================*\
    IWICBitmapEncoder -  Bitmap Encoder
\*=========================================================================*/

[
   object,
   uuid(00000103-a8f2-4877-ba0a-fd2b6645fb94)
]
interface IWICBitmapEncoder : IUnknown
{
    HRESULT Initialize(
        [in] IStream *pIStream,
        [in] WICBitmapEncoderCacheOption cacheOption
        );

    HRESULT GetContainerFormat(
        [out] GUID *pguidContainerFormat
        );

    HRESULT GetEncoderInfo(
        [out] IWICBitmapEncoderInfo **ppIEncoderInfo
        );

    HRESULT SetColorContexts(
        [in] UINT cCount,
        [in, size_is(cCount)] IWICColorContext **ppIColorContext
        );

    HRESULT SetPalette(
        [in] IWICPalette *pIPalette
        );

    HRESULT SetThumbnail(
        [in] IWICBitmapSource *pIThumbnail
        );

    HRESULT SetPreview(
        [in] IWICBitmapSource *pIPreview
        );

    HRESULT CreateNewFrame(
        [out] IWICBitmapFrameEncode **ppIFrameEncode,
        [in, out, unique] IPropertyBag2 **ppIEncoderOptions
        );

    HRESULT Commit(
        );

    HRESULT GetMetadataQueryWriter(
        [out] IWICMetadataQueryWriter **ppIMetadataQueryWriter
        );
};


/*=========================================================================*\
    IWICBitmapFrameEncode -  Bitmap Frame Encoder
\*=========================================================================*/

[
   object,
   uuid(00000105-a8f2-4877-ba0a-fd2b6645fb94)
]
interface IWICBitmapFrameEncode : IUnknown
{
    HRESULT Initialize(
        [in, unique] IPropertyBag2 *pIEncoderOptions
        );

    HRESULT SetSize(
        [in] UINT uiWidth,
        [in] UINT uiHeight
        );

    HRESULT SetResolution(
        [in] double dpiX,
        [in] double dpiY
        );

    HRESULT SetPixelFormat(
        [in, out] WICPixelFormatGUID *pPixelFormat
        );

    HRESULT SetColorContexts(
        [in] UINT cCount,
        [in, size_is(cCount)] IWICColorContext **ppIColorContext
        );

    HRESULT SetPalette(
        [in] IWICPalette *pIPalette
        );

    HRESULT SetThumbnail(
        [in] IWICBitmapSource *pIThumbnail
        );

    HRESULT WritePixels(
        [in] UINT lineCount,
        [in] UINT cbStride,
        [in] UINT cbBufferSize,
        [in, size_is(cbBufferSize)] BYTE *pbPixels
        );

    HRESULT WriteSource(
        [in] IWICBitmapSource *pIBitmapSource,
        [in, unique] WICRect *prc
        );

    HRESULT Commit(
        );

    HRESULT GetMetadataQueryWriter(
        [out] IWICMetadataQueryWriter **ppIMetadataQueryWriter
        );
};


/*=========================================================================*\
    IWICBitmapDecoder -  Bitmap Decoder
\*=========================================================================*/

[
   object,
   uuid(9EDDE9E7-8DEE-47ea-99DF-E6FAF2ED44BF)
]
interface IWICBitmapDecoder : IUnknown
{
    HRESULT QueryCapability(
        [in] IStream *pIStream,
        [out] DWORD *pdwCapability
        );

    HRESULT Initialize(
        [in] IStream *pIStream,
        [in] WICDecodeOptions cacheOptions
        );

    HRESULT GetContainerFormat(
        [out] GUID *pguidContainerFormat
        );

    HRESULT GetDecoderInfo(
        [out] IWICBitmapDecoderInfo **ppIDecoderInfo
        );

    HRESULT CopyPalette(
        [in] IWICPalette *pIPalette
        );

    HRESULT GetMetadataQueryReader(
        [out] IWICMetadataQueryReader **ppIMetadataQueryReader
        );

    HRESULT GetPreview(
        [out] IWICBitmapSource **ppIBitmapSource
        );

    HRESULT GetColorContexts(
        [in] UINT cCount,
        [in, out, unique, size_is(cCount)]  IWICColorContext **ppIColorContexts,
        [out] UINT *pcActualCount);


    HRESULT GetThumbnail(
        [out] IWICBitmapSource **ppIThumbnail
        );

    HRESULT GetFrameCount(
        [out] UINT *pCount
        );

    HRESULT GetFrame(
        [in] UINT index,
        [out] IWICBitmapFrameDecode **ppIBitmapFrame
        );
};


/*=========================================================================*\
    IWICBitmapSourceTransform
\*=========================================================================*/

[
   object,
   uuid(3B16811B-6A43-4ec9-B713-3D5A0C13B940)
]
interface IWICBitmapSourceTransform : IUnknown
{
    HRESULT CopyPixels(
       [in, unique] const WICRect *prc,
       [in] UINT uiWidth,
       [in] UINT uiHeight,
       [in, unique] WICPixelFormatGUID *pguidDstFormat,
       [in] WICBitmapTransformOptions dstTransform,
       [in] UINT nStride,
       [in] UINT cbBufferSize,
       [out, size_is(cbBufferSize)] BYTE *pbBuffer
       );

    HRESULT GetClosestSize(
       [in, out] UINT *puiWidth,
       [in, out] UINT *puiHeight
       );

    HRESULT GetClosestPixelFormat(
       [in, out] WICPixelFormatGUID *pguidDstFormat
       );

    HRESULT DoesSupportTransform(
       [in] WICBitmapTransformOptions dstTransform,
       [out] BOOL *pfIsSupported
       );
};


/*=========================================================================*\
    IWICBitmapFrameDecode -  Bitmap Decoder
\*=========================================================================*/

[
   object,
   uuid(3B16811B-6A43-4ec9-A813-3D930C13B940)
]
interface IWICBitmapFrameDecode : IWICBitmapSource
{
   HRESULT GetMetadataQueryReader(
       [out] IWICMetadataQueryReader **ppIMetadataQueryReader
       );

   HRESULT GetColorContexts(
        [in] UINT cCount,
        [in, out, unique, size_is(cCount)]  IWICColorContext **ppIColorContexts,
        [out] UINT *pcActualCount);

   HRESULT GetThumbnail(
       [out] IWICBitmapSource **ppIThumbnail
       );
};


/*=========================================================================*\
    IWICProgressiveLevelControl -  Progressive Decoding
\*=========================================================================*/

[
    object,
    uuid(DAAC296F-7AA5-4dbf-8D15-225C5976F891)
]
interface IWICProgressiveLevelControl : IUnknown
{
    HRESULT GetLevelCount( 
        [out, retval] UINT * pcLevels 
        );

    HRESULT GetCurrentLevel(
        [out, retval] UINT * pnLevel
        );

    HRESULT SetCurrentLevel(
        [in] UINT nLevel
        );
}


/*=========================================================================*\
    IWICProgressCallback - Cross apartment callback interface
\*=========================================================================*/

[
   object,
   uuid(4776F9CD-9517-45FA-BF24-E89C5EC5C60C)
]
interface IWICProgressCallback : IUnknown
{
    HRESULT Notify(
        [in] ULONG uFrameNum,
        [in] WICProgressOperation operation,
        [in] double dblProgress
        );
}


/*=========================================================================*\
    IWICBitmapCodecProgressNotification - Register Progress Notifications
\*=========================================================================*/

[
   object,
   uuid(64C1024E-C3CF-4462-8078-88C2B11C46D9)
]
interface IWICBitmapCodecProgressNotification : IUnknown
{
    typedef [unique] HRESULT __stdcall (*PFNProgressNotification)(
        LPVOID pvData,
        ULONG uFrameNum,
        WICProgressOperation operation,
        double dblProgress
        );

    [local]
    HRESULT RegisterProgressNotification(
            [in, unique, annotation("__in_opt")] PFNProgressNotification pfnProgressNotification,
            [in, unique, annotation("__in_opt")] LPVOID pvData,
            [in] DWORD dwProgressFlags /* WICProgressOperation | WICProgressNotification */
            );

    [call_as(RegisterProgressNotification)]
    HRESULT Remote_RegisterProgressNotification(
        [in, unique] IWICProgressCallback *pICallback,
        [in] DWORD dwProgressFlags
        );
};


/*=========================================================================*\
    IWICComponentInfo
\*=========================================================================*/

[
   object,
   uuid(23BC3F0A-698B-4357-886B-F24D50671334)
]
interface IWICComponentInfo : IUnknown
{
    HRESULT GetComponentType(
        [out] WICComponentType *pType
        );

    HRESULT GetCLSID(
        [out] CLSID *pclsid
        );

    HRESULT GetSigningStatus(
        [out] DWORD * pStatus   // WICComponentSigning flags
        );

    HRESULT GetAuthor(
        [in] UINT cchAuthor,
        [in, out, unique, size_is(cchAuthor)] WCHAR *wzAuthor,
        [out] UINT *pcchActual
        );

    HRESULT GetVendorGUID(
        [out] GUID *pguidVendor
        );

    HRESULT GetVersion(
        [in] UINT cchVersion,
        [in, out, unique, size_is(cchVersion)] WCHAR *wzVersion,
        [out]  UINT *pcchActual
        );

    HRESULT GetSpecVersion(
        [in] UINT cchSpecVersion,
        [in, out, unique, size_is(cchSpecVersion)] WCHAR *wzSpecVersion,
        [out] UINT *pcchActual
        );

    HRESULT GetFriendlyName(
        [in] UINT cchFriendlyName,
        [in, out, unique, size_is(cchFriendlyName)] WCHAR *wzFriendlyName,
        [out] UINT *pcchActual
        );
};


/*=========================================================================*\
    IWICFormatConverterInfo
\*=========================================================================*/

[
   object,
   uuid(9F34FB65-13F4-4f15-BC57-3726B5E53D9F)
]
interface IWICFormatConverterInfo : IWICComponentInfo
{
    HRESULT GetPixelFormats(
        [in] UINT cFormats,
        [in, out, unique, size_is(cFormats)] WICPixelFormatGUID * pPixelFormatGUIDs,
        [out] UINT *pcActual);

    HRESULT CreateInstance(
        [out] IWICFormatConverter **ppIConverter);
}


/*=========================================================================*\
    IWICBitmapCodecInfo
\*=========================================================================*/

[
   object,
   uuid(E87A44C4-B76E-4c47-8B09-298EB12A2714)
]
interface IWICBitmapCodecInfo : IWICComponentInfo
{
    HRESULT GetContainerFormat(
        [out] GUID *pguidContainerFormat
        );

    HRESULT GetPixelFormats(
        [in] UINT cFormats,
        [in, out, unique, size_is(cFormats)] GUID *pguidPixelFormats,
        [out] UINT *pcActual);

    HRESULT GetColorManagementVersion(
        [in] UINT cchColorManagementVersion,
        [in, out, unique, size_is(cchColorManagementVersion)] WCHAR *wzColorManagementVersion,
        [out] UINT *pcchActual
        );

    HRESULT GetDeviceManufacturer(
        [in] UINT cchDeviceManufacturer,
        [in, out, unique, size_is(cchDeviceManufacturer)] WCHAR *wzDeviceManufacturer,
        [out] UINT *pcchActual
        );

    HRESULT GetDeviceModels(
        [in] UINT cchDeviceModels,
        [in, out, unique, size_is(cchDeviceModels)] WCHAR *wzDeviceModels,
        [out] UINT *pcchActual
        );

    HRESULT GetMimeTypes(
        [in] UINT cchMimeTypes,
        [in, out, unique, size_is(cchMimeTypes)] WCHAR *wzMimeTypes,
        [out] UINT *pcchActual
        );

    HRESULT GetFileExtensions(
        [in] UINT cchFileExtensions,
        [in, out, unique, size_is(cchFileExtensions)] WCHAR *wzFileExtensions,
        [out] UINT *pcchActual
        );

    HRESULT DoesSupportAnimation(
        [out] BOOL *pfSupportAnimation
        );

    HRESULT DoesSupportChromakey(
        [out] BOOL *pfSupportChromakey
        );

    HRESULT DoesSupportLossless(
        [out] BOOL *pfSupportLossless
        );

    HRESULT DoesSupportMultiframe(
        [out] BOOL *pfSupportMultiframe
        );

    HRESULT MatchesMimeType(
        [in] LPCWSTR wzMimeType,
        [out] BOOL *pfMatches
        );
};


/*=========================================================================*\
    IWICBitmapEncoderInfo
\*=========================================================================*/

[
   object,
   uuid(94C9B4EE-A09F-4f92-8A1E-4A9BCE7E76FB)
]
interface IWICBitmapEncoderInfo : IWICBitmapCodecInfo
{
    HRESULT CreateInstance(
        [out] IWICBitmapEncoder **ppIBitmapEncoder
        );
};


/*=========================================================================*\
    IWICBitmapDecoderInfo
\*=========================================================================*/

[
   object,
   uuid(D8CD007F-D08F-4191-9BFC-236EA7F0E4B5)
]
interface IWICBitmapDecoderInfo : IWICBitmapCodecInfo
{
    [local]
    HRESULT GetPatterns(
        [in] UINT cbSizePatterns,
        [out, size_is(*pcPatterns), unique, annotation("__out_bcount_part_opt(cbSizePatterns, *pcbPatternsActual)")] WICBitmapPattern *pPatterns,
        [out, unique, annotation("__inout_opt")] UINT *pcPatterns,
        [out, annotation("__inout_opt")] UINT *pcbPatternsActual
        );

    [call_as(GetPatterns)]
    HRESULT Remote_GetPatterns(
        [out, size_is(, *pcPatterns)] WICBitmapPattern **ppPatterns,
        [out] UINT *pcPatterns 
        );

    HRESULT MatchesPattern(
        [in] IStream *pIStream,
        [out] BOOL *pfMatches
        );

    HRESULT CreateInstance(
        [out] IWICBitmapDecoder **ppIBitmapDecoder
        );
};


/*=========================================================================*\
    IWICPixelFormatInfo
\*=========================================================================*/

[
   object,
   uuid(E8EDA601-3D48-431a-AB44-69059BE88BBE)
]
interface IWICPixelFormatInfo : IWICComponentInfo
{
    HRESULT GetFormatGUID(
        [out] GUID* pFormat
        );

    HRESULT GetColorContext(
        [out] IWICColorContext **ppIColorContext
        );

    HRESULT GetBitsPerPixel(
        [out] UINT *puiBitsPerPixel
        );

    HRESULT GetChannelCount(
        [out] UINT *puiChannelCount
        );

    HRESULT GetChannelMask(
        [in] UINT uiChannelIndex,
        [in] UINT cbMaskBuffer,
        [in, out, unique, size_is(cbMaskBuffer)] BYTE *pbMaskBuffer,
        [out] UINT *pcbActual
        );
}


/*=========================================================================*\
    IWICPixelFormatInfo2
\*=========================================================================*/

[
   object,
   uuid(A9DB33A2-AF5F-43C7-B679-74F5984B5AA4)
]
interface IWICPixelFormatInfo2 : IWICPixelFormatInfo
{
    HRESULT SupportsTransparency(
        [out] BOOL *pfSupportsTransparency
        );

    HRESULT GetNumericRepresentation(
        [out] WICPixelFormatNumericRepresentation *pNumericRepresentation
        );
}


/*=========================================================================*\
    IWICImagingFactory
\*=========================================================================*/

[
   object,
   uuid(ec5ec8a9-c395-4314-9c77-54d7a935ff70)
]
interface IWICImagingFactory : IUnknown
{
    HRESULT CreateDecoderFromFilename(
        [in] LPCWSTR wzFilename,
        [in, unique] const GUID *pguidVendor,
        [in]  DWORD dwDesiredAccess,
        [in] WICDecodeOptions metadataOptions,
        [out, retval] IWICBitmapDecoder **ppIDecoder
        );

    HRESULT CreateDecoderFromStream(
        [in] IStream *pIStream,
        [in, unique] const GUID *pguidVendor,
        [in] WICDecodeOptions metadataOptions,
        [out, retval] IWICBitmapDecoder **ppIDecoder
        );

    HRESULT CreateDecoderFromFileHandle(
        [in] ULONG_PTR hFile,
        [in, unique] const GUID *pguidVendor,
        [in] WICDecodeOptions metadataOptions,
        [out, retval] IWICBitmapDecoder **ppIDecoder
        );

    HRESULT CreateComponentInfo(
        [in] REFCLSID clsidComponent,
        [out] IWICComponentInfo **ppIInfo
        );

    HRESULT CreateDecoder(
        [in] REFGUID guidContainerFormat,
        [in, unique] const GUID *pguidVendor,
        [out, retval] IWICBitmapDecoder **ppIDecoder
        );

    HRESULT CreateEncoder(
        [in] REFGUID guidContainerFormat,
        [in, unique] const GUID *pguidVendor,
        [out, retval] IWICBitmapEncoder **ppIEncoder
        );

    HRESULT CreatePalette(
        [out] IWICPalette **ppIPalette
        );

    HRESULT CreateFormatConverter(
        [out] IWICFormatConverter **ppIFormatConverter
        );

    HRESULT CreateBitmapScaler(
        [out] IWICBitmapScaler **ppIBitmapScaler
        );

    HRESULT CreateBitmapClipper(
        [out] IWICBitmapClipper **ppIBitmapClipper
        );

    HRESULT CreateBitmapFlipRotator(
        [out] IWICBitmapFlipRotator **ppIBitmapFlipRotator
        );

    HRESULT CreateStream(
        [out] IWICStream **ppIWICStream
        );

    HRESULT CreateColorContext(
        [out] IWICColorContext **ppIWICColorContext
        );

    HRESULT CreateColorTransformer(
        [out] IWICColorTransform **ppIWICColorTransform
        );

    /* Bitmap creation */

    HRESULT CreateBitmap(
        [in] UINT uiWidth,
        [in] UINT uiHeight,
        [in] REFWICPixelFormatGUID pixelFormat,
        [in] WICBitmapCreateCacheOption option,
        [out] IWICBitmap **ppIBitmap
        );

    HRESULT CreateBitmapFromSource(
        [in] IWICBitmapSource *pIBitmapSource,
        [in] WICBitmapCreateCacheOption option,
        [out] IWICBitmap **ppIBitmap
        );

    HRESULT CreateBitmapFromSourceRect(
        [in] IWICBitmapSource *pIBitmapSource,
        [in] UINT x,
        [in] UINT y,
        [in] UINT width,
        [in] UINT height,
        [out] IWICBitmap **ppIBitmap
        );

    HRESULT CreateBitmapFromMemory(
        [in] UINT uiWidth,
        [in] UINT uiHeight,
        [in] REFWICPixelFormatGUID pixelFormat,
        [in] UINT cbStride,
        [in] UINT cbBufferSize,
        [in, size_is(cbBufferSize)] BYTE *pbBuffer,
        [out] IWICBitmap **ppIBitmap
        );

    HRESULT CreateBitmapFromHBITMAP(
        [in] HBITMAP hBitmap,
        [in, unique] HPALETTE hPalette,
        [in] WICBitmapAlphaChannelOption options,
        [out] IWICBitmap **ppIBitmap
        );

    HRESULT CreateBitmapFromHICON(
        [in] HICON hIcon,
        [out] IWICBitmap **ppIBitmap
        );

    HRESULT CreateComponentEnumerator(
        [in] DWORD componentTypes,           /* WICComponentType */
        [in] DWORD options,                  /* WICComponentEnumerateOptions */
        [out] IEnumUnknown **ppIEnumUnknown
        );

    HRESULT CreateFastMetadataEncoderFromDecoder(
        [in] IWICBitmapDecoder *pIDecoder,
        [out] IWICFastMetadataEncoder **ppIFastEncoder
        );

    HRESULT CreateFastMetadataEncoderFromFrameDecode(
        [in] IWICBitmapFrameDecode *pIFrameDecoder,
        [out] IWICFastMetadataEncoder **ppIFastEncoder
        );

    HRESULT CreateQueryWriter(
        [in] REFGUID guidMetadataFormat,
        [in, unique] const GUID *pguidVendor,
        [out] IWICMetadataQueryWriter **ppIQueryWriter
        );

    HRESULT CreateQueryWriterFromReader(
        [in] IWICMetadataQueryReader *pIQueryReader,
        [in, unique] const GUID *pguidVendor,
        [out] IWICMetadataQueryWriter **ppIQueryWriter
        );
};


/*=========================================================================*\
    APIs
\*=========================================================================*/

cpp_quote("HRESULT WINAPI WICConvertBitmapSource(" )
cpp_quote("     __in REFWICPixelFormatGUID dstFormat, // Destination pixel format" )
cpp_quote("     __in_ecount(1) IWICBitmapSource  *pISrc,    // Source bitmap" )
cpp_quote("     __deref_out_ecount(1) IWICBitmapSource **ppIDst   // Destination bitmap, a copy or addrefed source" )
cpp_quote("     );" )

cpp_quote("HRESULT WINAPI WICCreateBitmapFromSection(" )
cpp_quote("     __in UINT width," )
cpp_quote("     __in UINT height," )
cpp_quote("     __in REFWICPixelFormatGUID pixelFormat," )
cpp_quote("     __in HANDLE hSection," )
cpp_quote("     __in UINT stride," )
cpp_quote("     __in UINT offset," )
cpp_quote("     __deref_out_ecount(1) IWICBitmap **ppIBitmap" )
cpp_quote("     );" )

cpp_quote("HRESULT WINAPI WICCreateBitmapFromSectionEx(" )
cpp_quote("     __in UINT width," )
cpp_quote("     __in UINT height," )
cpp_quote("     __in REFWICPixelFormatGUID pixelFormat," )
cpp_quote("     __in HANDLE hSection," )
cpp_quote("     __in UINT stride," )
cpp_quote("     __in UINT offset," )
cpp_quote("     __in WICSectionAccessLevel desiredAccessLevel," )
cpp_quote("     __deref_out_ecount(1) IWICBitmap **ppIBitmap" )
cpp_quote("     );" )

cpp_quote("HRESULT WINAPI WICMapGuidToShortName(")
cpp_quote("    __in_ecount(1) REFGUID guid,")
cpp_quote("    __in UINT cchName,")
cpp_quote("    __inout_ecount_opt(cchName) WCHAR *wzName,")
cpp_quote("    __out_ecount(1) UINT *pcchActual")
cpp_quote("   );")

cpp_quote("HRESULT WINAPI WICMapShortNameToGuid(")
cpp_quote("    __in_ecount(1) const WCHAR *wzName,")
cpp_quote("    __out_ecount(1) GUID *pguid")
cpp_quote("   );")

cpp_quote("HRESULT WINAPI WICMapSchemaToName(")
cpp_quote("    __in_ecount(1) REFGUID guidMetadataFormat,")
cpp_quote("    __in_ecount(1) LPWSTR pwzSchema,")
cpp_quote("    __in UINT cchName,")
cpp_quote("    __inout_ecount_opt(cchName) WCHAR *wzName,")
cpp_quote("    __out_ecount(1) UINT *pcchActual")
cpp_quote("    );")


/*=========================================================================*\
    Errors
\*=========================================================================*/

cpp_quote("#define FACILITY_WINCODEC_ERR 0x898")
cpp_quote("#define WINCODEC_ERR_BASE 0x2000")

cpp_quote("#define MAKE_WINCODECHR(sev, code) MAKE_HRESULT(sev, FACILITY_WINCODEC_ERR, (WINCODEC_ERR_BASE + code))")
cpp_quote("#define MAKE_WINCODECHR_ERR(code) MAKE_WINCODECHR(1, code)")

cpp_quote("#define WINCODEC_ERR_GENERIC_ERROR                    E_FAIL")
cpp_quote("#define WINCODEC_ERR_INVALIDPARAMETER                 E_INVALIDARG")
cpp_quote("#define WINCODEC_ERR_OUTOFMEMORY                      E_OUTOFMEMORY")
cpp_quote("#define WINCODEC_ERR_NOTIMPLEMENTED                   E_NOTIMPL")
cpp_quote("#define WINCODEC_ERR_ABORTED                          E_ABORT")
cpp_quote("#define WINCODEC_ERR_ACCESSDENIED                     E_ACCESSDENIED")
cpp_quote("#define WINCODEC_ERR_VALUEOVERFLOW                    INTSAFE_E_ARITHMETIC_OVERFLOW")

cpp_quote("#define WINCODEC_ERR_WRONGSTATE                       MAKE_WINCODECHR_ERR(0xf04)")
cpp_quote("#define WINCODEC_ERR_VALUEOUTOFRANGE                  MAKE_WINCODECHR_ERR(0xf05)")
cpp_quote("#define WINCODEC_ERR_UNKNOWNIMAGEFORMAT               MAKE_WINCODECHR_ERR(0xf07)")
cpp_quote("#define WINCODEC_ERR_UNSUPPORTEDVERSION               MAKE_WINCODECHR_ERR(0xf0B)")
cpp_quote("#define WINCODEC_ERR_NOTINITIALIZED                   MAKE_WINCODECHR_ERR(0xf0C)")
cpp_quote("#define WINCODEC_ERR_ALREADYLOCKED                    MAKE_WINCODECHR_ERR(0xf0D)")

cpp_quote("#define WINCODEC_ERR_PROPERTYNOTFOUND                 MAKE_WINCODECHR_ERR(0xf40)")
cpp_quote("#define WINCODEC_ERR_PROPERTYNOTSUPPORTED             MAKE_WINCODECHR_ERR(0xf41)")
cpp_quote("#define WINCODEC_ERR_PROPERTYSIZE                     MAKE_WINCODECHR_ERR(0xf42)")

cpp_quote("#define WINCODEC_ERR_CODECPRESENT                     MAKE_WINCODECHR_ERR(0xf43)")
cpp_quote("#define WINCODEC_ERR_CODECNOTHUMBNAIL                 MAKE_WINCODECHR_ERR(0xf44)")
cpp_quote("#define WINCODEC_ERR_PALETTEUNAVAILABLE               MAKE_WINCODECHR_ERR(0xf45)")
cpp_quote("#define WINCODEC_ERR_CODECTOOMANYSCANLINES            MAKE_WINCODECHR_ERR(0xf46)")
cpp_quote("#define WINCODEC_ERR_INTERNALERROR                    MAKE_WINCODECHR_ERR(0xf48)")
cpp_quote("#define WINCODEC_ERR_SOURCERECTDOESNOTMATCHDIMENSIONS MAKE_WINCODECHR_ERR(0xf49)")
cpp_quote("#define WINCODEC_ERR_COMPONENTNOTFOUND                MAKE_WINCODECHR_ERR(0xf50)")
cpp_quote("#define WINCODEC_ERR_IMAGESIZEOUTOFRANGE              MAKE_WINCODECHR_ERR(0xf51)")
cpp_quote("#define WINCODEC_ERR_TOOMUCHMETADATA                  MAKE_WINCODECHR_ERR(0xf52)")

cpp_quote("#define WINCODEC_ERR_BADIMAGE                         MAKE_WINCODECHR_ERR(0xf60)")
cpp_quote("#define WINCODEC_ERR_BADHEADER                        MAKE_WINCODECHR_ERR(0xf61)")
cpp_quote("#define WINCODEC_ERR_FRAMEMISSING                     MAKE_WINCODECHR_ERR(0xf62)")
cpp_quote("#define WINCODEC_ERR_BADMETADATAHEADER                MAKE_WINCODECHR_ERR(0xf63)")
cpp_quote("#define WINCODEC_ERR_BADSTREAMDATA                    MAKE_WINCODECHR_ERR(0xf70)")
cpp_quote("#define WINCODEC_ERR_STREAMWRITE                      MAKE_WINCODECHR_ERR(0xf71)")
cpp_quote("#define WINCODEC_ERR_STREAMREAD                       MAKE_WINCODECHR_ERR(0xf72)")
cpp_quote("#define WINCODEC_ERR_STREAMNOTAVAILABLE               MAKE_WINCODECHR_ERR(0xf73)")
cpp_quote("#define WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT           MAKE_WINCODECHR_ERR(0xf80)")
cpp_quote("#define WINCODEC_ERR_UNSUPPORTEDOPERATION             MAKE_WINCODECHR_ERR(0xf81)")

cpp_quote("#define WINCODEC_ERR_INVALIDREGISTRATION              MAKE_WINCODECHR_ERR(0xf8A)")
cpp_quote("#define WINCODEC_ERR_COMPONENTINITIALIZEFAILURE       MAKE_WINCODECHR_ERR(0xf8B)")
cpp_quote("#define WINCODEC_ERR_INSUFFICIENTBUFFER               MAKE_WINCODECHR_ERR(0xf8C)")
cpp_quote("#define WINCODEC_ERR_DUPLICATEMETADATAPRESENT         MAKE_WINCODECHR_ERR(0xf8D)")
cpp_quote("#define WINCODEC_ERR_PROPERTYUNEXPECTEDTYPE           MAKE_WINCODECHR_ERR(0xf8E)")
cpp_quote("#define WINCODEC_ERR_UNEXPECTEDSIZE                   MAKE_WINCODECHR_ERR(0xf8F)")

cpp_quote("#define WINCODEC_ERR_INVALIDQUERYREQUEST              MAKE_WINCODECHR_ERR(0xf90)")
cpp_quote("#define WINCODEC_ERR_UNEXPECTEDMETADATATYPE           MAKE_WINCODECHR_ERR(0xf91)")
cpp_quote("#define WINCODEC_ERR_REQUESTONLYVALIDATMETADATAROOT   MAKE_WINCODECHR_ERR(0xf92)")
cpp_quote("#define WINCODEC_ERR_INVALIDQUERYCHARACTER            MAKE_WINCODECHR_ERR(0xf93)")
cpp_quote("#define WINCODEC_ERR_WIN32ERROR                       MAKE_WINCODECHR_ERR(0xf94)")
cpp_quote("#define WINCODEC_ERR_INVALIDPROGRESSIVELEVEL          MAKE_WINCODECHR_ERR(0xf95)")


/*=========================================================================*\
    Parameter Structures
\*=========================================================================*/


/*=========================================================================*\
    WICTiffCompressionOption
\*=========================================================================*/

typedef [public] enum WICTiffCompressionOption
{
    WICTiffCompressionDontCare           = 0x00000000,
    WICTiffCompressionNone               = 0x00000001,
    WICTiffCompressionCCITT3             = 0x00000002,
    WICTiffCompressionCCITT4             = 0x00000003,
    WICTiffCompressionLZW                = 0x00000004,
    WICTiffCompressionRLE                = 0x00000005,
    WICTiffCompressionZIP                = 0x00000006,
    WICTiffCompressionLZWHDifferencing   = 0x00000007,
    WICTIFFCOMPRESSIONOPTION_FORCE_DWORD = CODEC_FORCE_DWORD
} WICTiffCompressionOption;

/*=========================================================================*\
    WICJpegYCrCbSubsamplingOption
\*=========================================================================*/

typedef [public] enum WICJpegYCrCbSubsamplingOption
{
    WICJpegYCrCbSubsamplingDefault      = 0x00000000,
    WICJpegYCrCbSubsampling420          = 0x00000001,
    WICJpegYCrCbSubsampling422          = 0x00000002,
    WICJpegYCrCbSubsampling444          = 0x00000003,
    WICJPEGYCRCBSUBSAMPLING_FORCE_DWORD = CODEC_FORCE_DWORD
} WICJpegYCrCbSubsamplingOption;


/*=========================================================================*\
    WICPngFilterOption
\*=========================================================================*/

typedef [public] enum WICPngFilterOption
{
    WICPngFilterUnspecified        = 0x00000000,
    WICPngFilterNone               = 0x00000001,
    WICPngFilterSub                = 0x00000002,
    WICPngFilterUp                 = 0x00000003,
    WICPngFilterAverage            = 0x00000004,
    WICPngFilterPaeth              = 0x00000005,
    WICPngFilterAdaptive           = 0x00000006,
    WICPNGFILTEROPTION_FORCE_DWORD = CODEC_FORCE_DWORD
} WICPngFilterOption;


/*=========================================================================*\
    Raw Structures and Interfaces
\*=========================================================================*/


/*=========================================================================*\
    WICNamedWhitePoint
\*=========================================================================*/

typedef [public] enum WICNamedWhitePoint
{
    WICWhitePointDefault           = 0x00000001,
    WICWhitePointDaylight          = 0x00000002,
    WICWhitePointCloudy            = 0x00000004,
    WICWhitePointShade             = 0x00000008,
    WICWhitePointTungsten          = 0x00000010,
    WICWhitePointFluorescent       = 0x00000020,
    WICWhitePointFlash             = 0x00000040,
    WICWhitePointUnderwater        = 0x00000080,
    WICWhitePointCustom            = 0x00000100,   // when using a picture (grey-card) as white-balance
    WICWhitePointAutoWhiteBalance  = 0x00000200,
    WICWhitePointAsShot            = WICWhitePointDefault,
    WICNAMEDWHITEPOINT_FORCE_DWORD = CODEC_FORCE_DWORD
} WICNamedWhitePoint;


/*=========================================================================*\
    WICRawCapabilities
\*=========================================================================*/

typedef [public] enum WICRawCapabilities
{
    WICRawCapabilityNotSupported   = 0x00000000,
    WICRawCapabilityGetSupported   = 0x00000001,
    WICRawCapabilityFullySupported = 0x00000002,    // Get & Set supported
    WICRAWCAPABILITIES_FORCE_DWORD = CODEC_FORCE_DWORD
} WICRawCapabilities;


/*=========================================================================*\
    WICRawRotationCapabilities
\*=========================================================================*/

typedef [public] enum WICRawRotationCapabilities
{
    WICRawRotationCapabilityNotSupported           = 0x00000000,
    WICRawRotationCapabilityGetSupported           = 0x00000001,
    WICRawRotationCapabilityNinetyDegreesSupported = 0x00000002,    // Get & Set supported.  Only multiple of 90 degree angles supported.
    WICRawRotationCapabilityFullySupported         = 0x00000003,    // Get & Set supported.  Any rotation angle supported.
    WICRAWROTATIONCAPABILITIES_FORCE_DWORD         = CODEC_FORCE_DWORD
} WICRawRotationCapabilities;


/*=========================================================================*\
    WICRawCapabilitesInfo
\*=========================================================================*/

typedef [public] struct WICRawCapabilitiesInfo
{
    UINT                        cbSize;
    UINT                        CodecMajorVersion;
    UINT                        CodecMinorVersion;
    WICRawCapabilities          ExposureCompensationSupport;
    WICRawCapabilities          ContrastSupport;
    WICRawCapabilities          RGBWhitePointSupport;
    WICRawCapabilities          NamedWhitePointSupport;
    UINT                        NamedWhitePointSupportMask;
    WICRawCapabilities          KelvinWhitePointSupport;
    WICRawCapabilities          GammaSupport;
    WICRawCapabilities          TintSupport;
    WICRawCapabilities          SaturationSupport;
    WICRawCapabilities          SharpnessSupport;
    WICRawCapabilities          NoiseReductionSupport;
    WICRawCapabilities          DestinationColorProfileSupport;
    WICRawCapabilities          ToneCurveSupport;
    WICRawRotationCapabilities  RotationSupport;
    WICRawCapabilities          RenderModeSupport;
} WICRawCapabilitiesInfo;


/*=========================================================================*\
    WICRawParameterSet
\*=========================================================================*/

typedef [public] enum WICRawParameterSet
{
    WICAsShotParameterSet          = 0x00000001,
    WICUserAdjustedParameterSet    = 0x00000002,
    WICAutoAdjustedParameterSet    = 0x00000003,
    WICRAWPARAMETERSET_FORCE_DWORD = CODEC_FORCE_DWORD
} WICRawParameterSet;


/*=========================================================================*\
    WICRawRenderMode
\*=========================================================================*/

typedef [public] enum WICRawRenderMode
{
    WICRawRenderModeDraft        = 0x00000001,   // Favor speed over quality
    WICRawRenderModeNormal       = 0x00000002,   // Balance speed with quality
    WICRawRenderModeBestQuality  = 0x00000003,   // Favor quality over speed
    WICRAWRENDERMODE_FORCE_DWORD = CODEC_FORCE_DWORD
} WICRawRenderMode;


/*=========================================================================*\
    WICRawToneCurvePoint
\*=========================================================================*/

typedef [public] struct WICRawToneCurvePoint
{
    double  Input;
    double  Output;
} WICRawToneCurvePoint;


/*=========================================================================*\
    WICRawToneCurve
\*=========================================================================*/

typedef [public] struct WICRawToneCurve
{
    UINT                    cPoints;
    WICRawToneCurvePoint    aPoints[1];
} WICRawToneCurve;


/*=========================================================================*\
    IWICDevelopRawNotificationCallback
\*=========================================================================*/

cpp_quote("#define WICRawChangeNotification_ExposureCompensation       0x00000001")
cpp_quote("#define WICRawChangeNotification_NamedWhitePoint            0x00000002")
cpp_quote("#define WICRawChangeNotification_KelvinWhitePoint           0x00000004")
cpp_quote("#define WICRawChangeNotification_RGBWhitePoint              0x00000008")
cpp_quote("#define WICRawChangeNotification_Contrast                   0x00000010")
cpp_quote("#define WICRawChangeNotification_Gamma                      0x00000020")
cpp_quote("#define WICRawChangeNotification_Sharpness                  0x00000040")
cpp_quote("#define WICRawChangeNotification_Saturation                 0x00000080")
cpp_quote("#define WICRawChangeNotification_Tint                       0x00000100")
cpp_quote("#define WICRawChangeNotification_NoiseReduction             0x00000200")
cpp_quote("#define WICRawChangeNotification_DestinationColorContext    0x00000400")
cpp_quote("#define WICRawChangeNotification_ToneCurve                  0x00000800")
cpp_quote("#define WICRawChangeNotification_Rotation                   0x00001000")
cpp_quote("#define WICRawChangeNotification_RenderMode                 0x00002000")

[
    object,
    uuid(95c75a6e-3e8c-4ec2-85a8-aebcc551e59b)
]
interface IWICDevelopRawNotificationCallback : IUnknown
{
    // Called when one of the parameters in IWICDevelopRaw gets changed or updated.
    // Notification mask is a bitmask constructed from the WICRawChangeNotification_*
    // values to specify which parameter(s) changed.  Return S_OK if the notification
    // is handled, or a descriptive error if not.

    HRESULT Notify([in] UINT NotificationMask);
}


/*=========================================================================*\
    IWICDevelopRaw -  Raw Develop
\*=========================================================================*/

[
   object,
   uuid(fbec5e44-f7be-4b65-b7f8-c0c81fef026d)
]
interface IWICDevelopRaw : IWICBitmapFrameDecode
{
    // Return the set of supported capabilities for this raw file

    [local] 
    HRESULT QueryRawCapabilitiesInfo(
        [in, out] WICRawCapabilitiesInfo *pInfo
        );

    [call_as(QueryRawCapabilitiesInfo)]
    HRESULT Remote_QueryRawCapabilitiesInfo(
        [in, out] WICRawCapabilitiesInfo *pInfo
        );


    // Load the desired parameter set as the current
    // working parameter set

    HRESULT LoadParameterSet(
        [in] WICRawParameterSet ParameterSet
        );

    // Get an IPropertyBag2 that contains the current
    // parameters to hand off to the encoder for saving

    HRESULT GetCurrentParameterSet(
        [out] IPropertyBag2 **ppCurrentParameterSet
        );

    // Set/Get the exposure compensation desired for final output
    // Valid range for ev is -5.0 to +5.0 (stops)

    HRESULT SetExposureCompensation(
        [in] double ev
        );

    HRESULT GetExposureCompensation(
        [out] double *pEV
        );

    // Get/Set the white point as an RGB value.

    HRESULT SetWhitePointRGB(
        [in] UINT Red,
        [in] UINT Green,
        [in] UINT Blue
        );

    HRESULT GetWhitePointRGB(
        [out] UINT *pRed,
        [out] UINT *pGreen,
        [out] UINT *pBlue
        );

    // Set/Get white point as a preset named value

    HRESULT SetNamedWhitePoint(
        [in] WICNamedWhitePoint WhitePoint
        );

    HRESULT GetNamedWhitePoint(
        [out] WICNamedWhitePoint *pWhitePoint
        );

    // Set the white point in kelvin
    // Defined max range is 1,500 - 30,000

    HRESULT SetWhitePointKelvin(
        [in] UINT WhitePointKelvin
        );

    HRESULT GetWhitePointKelvin(
        [out] UINT *pWhitePointKelvin
        );

    HRESULT GetKelvinRangeInfo(
        [out] UINT *pMinKelvinTemp,
        [out] UINT *pMaxKelvinTemp,
        [out] UINT *pKelvinTempStepValue
        );

    // Set/Get the amount of contrast to apply to the final output
    // Valid range for Contrast is -1.0 to 1.0.

    HRESULT SetContrast(
        [in] double Contrast
        );

    HRESULT GetContrast(
        [out] double *pContrast
        );

    // Set/Get the gamma to use for output pixels
    // Valid range for Gamma is 0.0 to 5.0, with 1.0 being
    // the default.

    HRESULT SetGamma(
        [in] double Gamma
        );

    HRESULT GetGamma(
        [out] double *pGamma
        );

    // Set/Get the sharpness of the final output.
    // Valid range is 0.0 to 1.0.  0.0 is no sharpening
    // applied to the image at all, 1.0 is full/most allowed sharpening

    HRESULT SetSharpness(
        [in] double Sharpness
        );

    HRESULT GetSharpness(
        [out] double *pSharpness
        );

    // Set/Get saturation of the final output
    // Valid range is -1.0 to 1.0.  -1.0 is full
    // de-saturation, 1.0 is full saturation.

    HRESULT SetSaturation(
        [in] double Saturation
        );

    HRESULT GetSaturation(
        [out] double *pSaturation
        );

    // Set/Get the tint of the final output
    // Valid range is -1.0 to +1.0.  Scale is defined as orthogonal to color
    // temperature.  (Green/Magenta bias)

    HRESULT SetTint(
        [in] double Tint
        );

    HRESULT GetTint(
        [out] double *pTint
        );

    // Set/Get noise reduction of the final output
    // Valid range is 0.0 to 1.0.  0.0 is no noise
    // reduction applied.  1.0 is full/most allowed noise
    // reduction applied.

    HRESULT SetNoiseReduction(
        [in] double NoiseReduction
        );

    HRESULT GetNoiseReduction(
        [out] double *pNoiseReduction
        );

    // Set desired color profile of final output.  You can
    // get the color context via IWICBitmapFrameDecode::GetColorContext()

    HRESULT SetDestinationColorContext(
        [in, unique] IWICColorContext *pColorContext
        );

    // Set/Get the tone curve to use for final output.
    // Assume linear interpolation between points.

    [local]
    HRESULT SetToneCurve(
        [in] UINT cbToneCurveSize,
        [in, annotation("__in_bcount(cbToneCurveSize)")] const WICRawToneCurve *pToneCurve
        );

    [call_as(SetToneCurve)]
    HRESULT Remote_SetToneCurve(
        [in] UINT cPoints,
        [in, size_is(cPoints)] const WICRawToneCurvePoint *aPoints
        );

    // Get the tone curve currently in use.  To get the required
    // size of the buffer, pass in NULL for the pToneCurve parameter
    // and *pcbActualToneCurveBufferSize will contain the required size upon
    // exit.

    [local]
    HRESULT GetToneCurve(
        [in] UINT cbToneCurveBufferSize,
        [out, unique, annotation("__out_bcount_part_opt(cbToneCurveBufferSize, *pcbActualToneCurveBufferSize)")] WICRawToneCurve *pToneCurve,
        [out, unique, annotation("__inout_opt")] UINT *pcbActualToneCurveBufferSize
        );

    [call_as(GetToneCurve)]
    HRESULT Remote_GetToneCurve(
        [out] UINT * pcPoints,
        [out, size_is(, *pcPoints)] WICRawToneCurvePoint **paPoints
        );

    // Set the desired rotation angle of the output of CopyPixels.
    // The parameter pRotation is in units of degrees and the sign is positive
    // clockwise. So a rotation of 90.0 would be a rotation of 90 degrees
    // clockwise (data along the left side of the sensor would be rendered on
    // the top rows of the output image.

    HRESULT SetRotation([in] double Rotation);

    // Gets the current rotation angle used for CopyPixels.

    HRESULT GetRotation([out] double *pRotation);

    // Set the desired render mode for CopyPixels

    HRESULT SetRenderMode([in] WICRawRenderMode RenderMode);

    // Get the current render mode used for CopyPixels

    HRESULT GetRenderMode([out] WICRawRenderMode *pRenderMode);

    // Set the callback function to call when parameters change

    HRESULT SetNotificationCallback([in, unique] IWICDevelopRawNotificationCallback *pCallback);
};

