dll/win32/windowscodecs/proxy.c

   1 /*
   2  * Misleadingly named convenience functions for accessing WIC.
   3  *
   4  * Copyright 2012 Vincent Povirk for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "wincodecs_private.h"
  22
  23 HRESULT WINAPI IWICBitmapClipper_Initialize_Proxy_W(IWICBitmapClipper *iface,
  24     IWICBitmapSource *pISource, const WICRect *prc)
  25 {
  26     return IWICBitmapClipper_Initialize(iface, pISource, prc);
  27 }
  28
  29 HRESULT WINAPI IWICBitmapCodecInfo_GetContainerFormat_Proxy_W(IWICBitmapCodecInfo *iface,
  30     GUID *pguidContainerFormat)
  31 {
  32     return IWICBitmapCodecInfo_GetContainerFormat(iface, pguidContainerFormat);
  33 }
  34
  35 HRESULT WINAPI IWICBitmapCodecInfo_GetDeviceManufacturer_Proxy_W(IWICBitmapCodecInfo *iface,
  36     UINT cchDeviceManufacturer, WCHAR *wzDeviceManufacturer, UINT *pcchActual)
  37 {
  38     return IWICBitmapCodecInfo_GetDeviceManufacturer(iface, cchDeviceManufacturer, wzDeviceManufacturer, pcchActual);
  39 }
  40
  41 HRESULT WINAPI IWICBitmapCodecInfo_GetDeviceModels_Proxy_W(IWICBitmapCodecInfo *iface,
  42     UINT cchDeviceModels, WCHAR *wzDeviceModels, UINT *pcchActual)
  43 {
  44     return IWICBitmapCodecInfo_GetDeviceModels(iface, cchDeviceModels, wzDeviceModels, pcchActual);
  45 }
  46
  47 HRESULT WINAPI IWICBitmapCodecInfo_GetMimeTypes_Proxy_W(IWICBitmapCodecInfo *iface,
  48     UINT cchMimeTypes, WCHAR *wzMimeTypes, UINT *pcchActual)
  49 {
  50     return IWICBitmapCodecInfo_GetMimeTypes(iface, cchMimeTypes, wzMimeTypes, pcchActual);
  51 }
  52
  53 HRESULT WINAPI IWICBitmapCodecInfo_GetFileExtensions_Proxy_W(IWICBitmapCodecInfo *iface,
  54     UINT cchFileExtensions, WCHAR *wzFileExtensions, UINT *pcchActual)
  55 {
  56     return IWICBitmapCodecInfo_GetFileExtensions(iface, cchFileExtensions, wzFileExtensions, pcchActual);
  57 }
  58
  59 HRESULT WINAPI IWICBitmapCodecInfo_DoesSupportAnimation_Proxy_W(IWICBitmapCodecInfo *iface,
  60     BOOL *pfSupportAnimation)
  61 {
  62     return IWICBitmapCodecInfo_DoesSupportAnimation(iface, pfSupportAnimation);
  63 }
  64
  65 HRESULT WINAPI IWICBitmapCodecInfo_DoesSupportLossless_Proxy_W(IWICBitmapCodecInfo *iface,
  66     BOOL *pfSupportLossless)
  67 {
  68     return IWICBitmapCodecInfo_DoesSupportLossless(iface, pfSupportLossless);
  69 }
  70
  71 HRESULT WINAPI IWICBitmapCodecInfo_DoesSupportMultiframe_Proxy_W(IWICBitmapCodecInfo *iface,
  72     BOOL *pfSupportMultiframe)
  73 {
  74     return IWICBitmapCodecInfo_DoesSupportMultiframe(iface, pfSupportMultiframe);
  75 }
  76
  77 HRESULT WINAPI IWICBitmapDecoder_GetDecoderInfo_Proxy_W(IWICBitmapDecoder *iface,
  78     IWICBitmapDecoderInfo **ppIDecoderInfo)
  79 {
  80     return IWICBitmapDecoder_GetDecoderInfo(iface, ppIDecoderInfo);
  81 }
  82
  83 HRESULT WINAPI IWICBitmapDecoder_CopyPalette_Proxy_W(IWICBitmapDecoder *iface,
  84     IWICPalette *pIPalette)
  85 {
  86     return IWICBitmapDecoder_CopyPalette(iface, pIPalette);
  87 }
  88
  89 HRESULT WINAPI IWICBitmapDecoder_GetMetadataQueryReader_Proxy_W(IWICBitmapDecoder *iface,
  90     IWICMetadataQueryReader **ppIMetadataQueryReader)
  91 {
  92     return IWICBitmapDecoder_GetMetadataQueryReader(iface, ppIMetadataQueryReader);
  93 }
  94
  95 HRESULT WINAPI IWICBitmapDecoder_GetPreview_Proxy_W(IWICBitmapDecoder *iface,
  96     IWICBitmapSource **ppIBitmapSource)
  97 {
  98     return IWICBitmapDecoder_GetPreview(iface, ppIBitmapSource);
  99 }
 100
 101 HRESULT WINAPI IWICBitmapDecoder_GetColorContexts_Proxy_W(IWICBitmapDecoder *iface,
 102     UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
 103 {
 104     return IWICBitmapDecoder_GetColorContexts(iface, cCount, ppIColorContexts, pcActualCount);
 105 }
 106
 107 HRESULT WINAPI IWICBitmapDecoder_GetThumbnail_Proxy_W(IWICBitmapDecoder *iface,
 108     IWICBitmapSource **ppIThumbnail)
 109 {
 110     return IWICBitmapDecoder_GetThumbnail(iface, ppIThumbnail);
 111 }
 112
 113 HRESULT WINAPI IWICBitmapDecoder_GetFrameCount_Proxy_W(IWICBitmapDecoder *iface,
 114     UINT *pCount)
 115 {
 116     return IWICBitmapDecoder_GetFrameCount(iface, pCount);
 117 }
 118
 119 HRESULT WINAPI IWICBitmapDecoder_GetFrame_Proxy_W(IWICBitmapDecoder *iface,
 120     UINT index, IWICBitmapFrameDecode **ppIBitmapFrame)
 121 {
 122     return IWICBitmapDecoder_GetFrame(iface, index, ppIBitmapFrame);
 123 }
 124
 125 HRESULT WINAPI IWICBitmapEncoder_Initialize_Proxy_W(IWICBitmapEncoder *iface,
 126     IStream *pIStream, WICBitmapEncoderCacheOption cacheOption)
 127 {
 128     return IWICBitmapEncoder_Initialize(iface, pIStream, cacheOption);
 129 }
 130
 131 HRESULT WINAPI IWICBitmapEncoder_GetEncoderInfo_Proxy_W(IWICBitmapEncoder *iface,
 132     IWICBitmapEncoderInfo **ppIEncoderInfo)
 133 {
 134     return IWICBitmapEncoder_GetEncoderInfo(iface, ppIEncoderInfo);
 135 }
 136
 137 HRESULT WINAPI IWICBitmapEncoder_SetPalette_Proxy_W(IWICBitmapEncoder *iface,
 138     IWICPalette *pIPalette)
 139 {
 140     return IWICBitmapEncoder_SetPalette(iface, pIPalette);
 141 }
 142
 143 HRESULT WINAPI IWICBitmapEncoder_SetThumbnail_Proxy_W(IWICBitmapEncoder *iface,
 144     IWICBitmapSource *pIThumbnail)
 145 {
 146     return IWICBitmapEncoder_SetThumbnail(iface, pIThumbnail);
 147 }
 148
 149 HRESULT WINAPI IWICBitmapEncoder_CreateNewFrame_Proxy_W(IWICBitmapEncoder *iface,
 150     IWICBitmapFrameEncode **ppIFrameEncode, IPropertyBag2 **ppIEncoderOptions)
 151 {
 152     return IWICBitmapEncoder_CreateNewFrame(iface, ppIFrameEncode, ppIEncoderOptions);
 153 }
 154
 155 HRESULT WINAPI IWICBitmapEncoder_Commit_Proxy_W(IWICBitmapEncoder *iface)
 156 {
 157     return IWICBitmapEncoder_Commit(iface);
 158 }
 159
 160 HRESULT WINAPI IWICBitmapEncoder_GetMetadataQueryWriter_Proxy_W(IWICBitmapEncoder *iface,
 161     IWICMetadataQueryWriter **ppIMetadataQueryWriter)
 162 {
 163     return IWICBitmapEncoder_GetMetadataQueryWriter(iface, ppIMetadataQueryWriter);
 164 }
 165
 166 HRESULT WINAPI IWICBitmapFlipRotator_Initialize_Proxy_W(IWICBitmapFlipRotator *iface,
 167     IWICBitmapSource *pISource, WICBitmapTransformOptions options)
 168 {
 169     return IWICBitmapFlipRotator_Initialize(iface, pISource, options);
 170 }
 171
 172 HRESULT WINAPI IWICBitmapFrameEncode_Initialize_Proxy_W(IWICBitmapFrameEncode *iface,
 173     IPropertyBag2 *pIEncoderOptions)
 174 {
 175     return IWICBitmapFrameEncode_Initialize(iface, pIEncoderOptions);
 176 }
 177
 178 HRESULT WINAPI IWICBitmapFrameEncode_SetSize_Proxy_W(IWICBitmapFrameEncode *iface,
 179     UINT uiWidth, UINT uiHeight)
 180 {
 181     return IWICBitmapFrameEncode_SetSize(iface, uiWidth, uiHeight);
 182 }
 183
 184 HRESULT WINAPI IWICBitmapFrameEncode_SetResolution_Proxy_W(IWICBitmapFrameEncode *iface,
 185     double dpiX, double dpiY)
 186 {
 187     return IWICBitmapFrameEncode_SetResolution(iface, dpiX, dpiY);
 188 }
 189
 190 HRESULT WINAPI IWICBitmapFrameEncode_SetColorContexts_Proxy_W(IWICBitmapFrameEncode *iface,
 191     UINT cCount, IWICColorContext **ppIColorContext)
 192 {
 193     return IWICBitmapFrameEncode_SetColorContexts(iface, cCount, ppIColorContext);
 194 }
 195
 196 HRESULT WINAPI IWICBitmapFrameEncode_SetThumbnail_Proxy_W(IWICBitmapFrameEncode *iface,
 197     IWICBitmapSource *pIThumbnail)
 198 {
 199     return IWICBitmapFrameEncode_SetThumbnail(iface, pIThumbnail);
 200 }
 201
 202 HRESULT WINAPI IWICBitmapFrameEncode_WriteSource_Proxy_W(IWICBitmapFrameEncode *iface,
 203     IWICBitmapSource *pIBitmapSource, WICRect *prc)
 204 {
 205     return IWICBitmapFrameEncode_WriteSource(iface, pIBitmapSource, prc);
 206 }
 207
 208 HRESULT WINAPI IWICBitmapFrameEncode_Commit_Proxy_W(IWICBitmapFrameEncode *iface)
 209 {
 210     return IWICBitmapFrameEncode_Commit(iface);
 211 }
 212
 213 HRESULT WINAPI IWICBitmapFrameEncode_GetMetadataQueryWriter_Proxy_W(IWICBitmapFrameEncode *iface,
 214     IWICMetadataQueryWriter **ppIMetadataQueryWriter)
 215 {
 216     return IWICBitmapFrameEncode_GetMetadataQueryWriter(iface, ppIMetadataQueryWriter);
 217 }
 218
 219 HRESULT WINAPI IWICBitmapLock_GetDataPointer_Proxy_W(IWICBitmapLock *iface,
 220     UINT *pcbBufferSize, BYTE **ppbData)
 221 {
 222     return IWICBitmapLock_GetDataPointer(iface, pcbBufferSize, ppbData);
 223 }
 224
 225 HRESULT WINAPI IWICBitmapLock_GetStride_Proxy_W(IWICBitmapLock *iface,
 226     UINT *pcbStride)
 227 {
 228     return IWICBitmapLock_GetStride(iface, pcbStride);
 229 }
 230
 231 HRESULT WINAPI IWICBitmapScaler_Initialize_Proxy_W(IWICBitmapScaler *iface,
 232     IWICBitmapSource *pISource, UINT uiWidth, UINT uiHeight, WICBitmapInterpolationMode mode)
 233 {
 234     return IWICBitmapScaler_Initialize(iface, pISource, uiWidth, uiHeight, mode);
 235 }
 236
 237 HRESULT WINAPI IWICBitmapSource_GetSize_Proxy_W(IWICBitmapSource *iface,
 238     UINT *puiWidth, UINT *puiHeight)
 239 {
 240     return IWICBitmapSource_GetSize(iface, puiWidth, puiHeight);
 241 }
 242
 243 HRESULT WINAPI IWICBitmapSource_GetPixelFormat_Proxy_W(IWICBitmapSource *iface,
 244     WICPixelFormatGUID *pPixelFormat)
 245 {
 246     return IWICBitmapSource_GetPixelFormat(iface, pPixelFormat);
 247 }
 248
 249 HRESULT WINAPI IWICBitmapSource_GetResolution_Proxy_W(IWICBitmapSource *iface,
 250     double *pDpiX, double *pDpiY)
 251 {
 252     return IWICBitmapSource_GetResolution(iface, pDpiX, pDpiY);
 253 }
 254
 255 HRESULT WINAPI IWICBitmapSource_CopyPalette_Proxy_W(IWICBitmapSource *iface,
 256     IWICPalette *pIPalette)
 257 {
 258     return IWICBitmapSource_CopyPalette(iface, pIPalette);
 259 }
 260
 261 HRESULT WINAPI IWICBitmapSource_CopyPixels_Proxy_W(IWICBitmapSource *iface,
 262     const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer)
 263 {
 264     return IWICBitmapSource_CopyPixels(iface, prc, cbStride, cbBufferSize, pbBuffer);
 265 }
 266
 267 HRESULT WINAPI IWICBitmap_Lock_Proxy_W(IWICBitmap *iface,
 268     const WICRect *prcLock, DWORD flags, IWICBitmapLock **ppILock)
 269 {
 270     return IWICBitmap_Lock(iface, prcLock, flags, ppILock);
 271 }
 272
 273 HRESULT WINAPI IWICBitmap_SetPalette_Proxy_W(IWICBitmap *iface,
 274     IWICPalette *pIPalette)
 275 {
 276     return IWICBitmap_SetPalette(iface, pIPalette);
 277 }
 278
 279 HRESULT WINAPI IWICBitmap_SetResolution_Proxy_W(IWICBitmap *iface,
 280     double dpiX, double dpiY)
 281 {
 282     return IWICBitmap_SetResolution(iface, dpiX, dpiY);
 283 }
 284
 285 HRESULT WINAPI IWICColorContext_InitializeFromMemory_Proxy_W(IWICColorContext *iface,
 286     const BYTE *pbBuffer, UINT cbBufferSize)
 287 {
 288     return IWICColorContext_InitializeFromMemory(iface, pbBuffer, cbBufferSize);
 289 }
 290
 291 HRESULT WINAPI IWICComponentFactory_CreateMetadataWriterFromReader_Proxy_W(IWICComponentFactory *iface,
 292     IWICMetadataReader *pIReader, const GUID *pguidVendor, IWICMetadataWriter **ppIWriter)
 293 {
 294     return IWICComponentFactory_CreateMetadataWriterFromReader(iface, pIReader, pguidVendor, ppIWriter);
 295 }
 296
 297 HRESULT WINAPI IWICComponentFactory_CreateQueryWriterFromBlockWriter_Proxy_W(IWICComponentFactory *iface,
 298     IWICMetadataBlockWriter *pIBlockWriter, IWICMetadataQueryWriter **ppIQueryWriter)
 299 {
 300     return IWICComponentFactory_CreateQueryWriterFromBlockWriter(iface, pIBlockWriter, ppIQueryWriter);
 301 }
 302
 303 HRESULT WINAPI IWICComponentInfo_GetCLSID_Proxy_W(IWICComponentInfo *iface,
 304     CLSID *pclsid)
 305 {
 306     return IWICComponentInfo_GetCLSID(iface, pclsid);
 307 }
 308
 309 HRESULT WINAPI IWICComponentInfo_GetAuthor_Proxy_W(IWICComponentInfo *iface,
 310     UINT cchAuthor, WCHAR *wzAuthor, UINT *pcchActual)
 311 {
 312     return IWICComponentInfo_GetAuthor(iface, cchAuthor, wzAuthor, pcchActual);
 313 }
 314
 315 HRESULT WINAPI IWICComponentInfo_GetVersion_Proxy_W(IWICComponentInfo *iface,
 316     UINT cchVersion, WCHAR *wzVersion, UINT *pcchActual)
 317 {
 318     return IWICComponentInfo_GetVersion(iface, cchVersion, wzVersion, pcchActual);
 319 }
 320
 321 HRESULT WINAPI IWICComponentInfo_GetSpecVersion_Proxy_W(IWICComponentInfo *iface,
 322     UINT cchSpecVersion, WCHAR *wzSpecVersion, UINT *pcchActual)
 323 {
 324     return IWICComponentInfo_GetSpecVersion(iface, cchSpecVersion, wzSpecVersion, pcchActual);
 325 }
 326
 327 HRESULT WINAPI IWICComponentInfo_GetFriendlyName_Proxy_W(IWICComponentInfo *iface,
 328     UINT cchFriendlyName, WCHAR *wzFriendlyName, UINT *pcchActual)
 329 {
 330     return IWICComponentInfo_GetFriendlyName(iface, cchFriendlyName, wzFriendlyName, pcchActual);
 331 }
 332
 333 HRESULT WINAPI IWICFastMetadataEncoder_Commit_Proxy_W(IWICFastMetadataEncoder *iface)
 334 {
 335     return IWICFastMetadataEncoder_Commit(iface);
 336 }
 337
 338 HRESULT WINAPI IWICFastMetadataEncoder_GetMetadataQueryWriter_Proxy_W(IWICFastMetadataEncoder *iface,
 339     IWICMetadataQueryWriter **ppIMetadataQueryWriter)
 340 {
 341     return IWICFastMetadataEncoder_GetMetadataQueryWriter(iface, ppIMetadataQueryWriter);
 342 }
 343
 344 HRESULT WINAPI IWICBitmapFrameDecode_GetMetadataQueryReader_Proxy_W(IWICBitmapFrameDecode *iface,
 345     IWICMetadataQueryReader **ppIMetadataQueryReader)
 346 {
 347     return IWICBitmapFrameDecode_GetMetadataQueryReader(iface, ppIMetadataQueryReader);
 348 }
 349
 350 HRESULT WINAPI IWICBitmapFrameDecode_GetColorContexts_Proxy_W(IWICBitmapFrameDecode *iface,
 351     UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
 352 {
 353     return IWICBitmapFrameDecode_GetColorContexts(iface, cCount, ppIColorContexts, pcActualCount);
 354 }
 355
 356 HRESULT WINAPI IWICBitmapFrameDecode_GetThumbnail_Proxy_W(IWICBitmapFrameDecode *iface,
 357     IWICBitmapSource **ppIThumbnail)
 358 {
 359     return IWICBitmapFrameDecode_GetThumbnail(iface, ppIThumbnail);
 360 }
 361
 362 HRESULT WINAPI IWICFormatConverter_Initialize_Proxy_W(IWICFormatConverter *iface,
 363     IWICBitmapSource *pISource, REFWICPixelFormatGUID dstFormat, WICBitmapDitherType dither,
 364     IWICPalette *pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate)
 365 {
 366     return IWICFormatConverter_Initialize(iface, pISource, dstFormat, dither,
 367         pIPalette, alphaThresholdPercent, paletteTranslate);
 368 }
 369
 370 HRESULT WINAPI IWICImagingFactory_CreateBitmapClipper_Proxy_W(IWICImagingFactory *pFactory,
 371     IWICBitmapClipper **ppIBitmapClipper)
 372 {
 373     return IWICImagingFactory_CreateBitmapClipper(pFactory, ppIBitmapClipper);
 374 }
 375
 376 HRESULT WINAPI IWICImagingFactory_CreateBitmapFlipRotator_Proxy_W(IWICImagingFactory *pFactory,
 377     IWICBitmapFlipRotator **ppIBitmapFlipRotator)
 378 {
 379     return IWICImagingFactory_CreateBitmapFlipRotator(pFactory, ppIBitmapFlipRotator);
 380 }
 381
 382 HRESULT WINAPI IWICImagingFactory_CreateBitmapFromHBITMAP_Proxy_W(IWICImagingFactory *pFactory,
 383     HBITMAP hBitmap, HPALETTE hPalette, WICBitmapAlphaChannelOption options, IWICBitmap **ppIBitmap)
 384 {
 385     return IWICImagingFactory_CreateBitmapFromHBITMAP(pFactory, hBitmap, hPalette, options, ppIBitmap);
 386 }
 387
 388 HRESULT WINAPI IWICImagingFactory_CreateBitmapFromHICON_Proxy_W(IWICImagingFactory *pFactory,
 389     HICON hIcon, IWICBitmap **ppIBitmap)
 390 {
 391     return IWICImagingFactory_CreateBitmapFromHICON(pFactory, hIcon, ppIBitmap);
 392 }
 393
 394 HRESULT WINAPI IWICImagingFactory_CreateBitmapFromMemory_Proxy_W(IWICImagingFactory *pFactory,
 395     UINT uiWidth, UINT uiHeight, REFWICPixelFormatGUID pixelFormat, UINT cbStride,
 396     UINT cbBufferSize, BYTE *pbBuffer, IWICBitmap **ppIBitmap)
 397 {
 398     return IWICImagingFactory_CreateBitmapFromMemory(pFactory, uiWidth, uiHeight,
 399         pixelFormat, cbStride, cbBufferSize, pbBuffer, ppIBitmap);
 400 }
 401
 402 HRESULT WINAPI IWICImagingFactory_CreateBitmapFromSource_Proxy_W(IWICImagingFactory *pFactory,
 403     IWICBitmapSource *piBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap **ppIBitmap)
 404 {
 405     return IWICImagingFactory_CreateBitmapFromSource(pFactory, piBitmapSource, option, ppIBitmap);
 406 }
 407
 408 HRESULT WINAPI IWICImagingFactory_CreateBitmapScaler_Proxy_W(IWICImagingFactory *pFactory,
 409     IWICBitmapScaler **ppIBitmapScaler)
 410 {
 411     return IWICImagingFactory_CreateBitmapScaler(pFactory, ppIBitmapScaler);
 412 }
 413
 414 HRESULT WINAPI IWICImagingFactory_CreateBitmap_Proxy_W(IWICImagingFactory *pFactory,
 415     UINT uiWidth, UINT uiHeight, REFWICPixelFormatGUID pixelFormat,
 416     WICBitmapCreateCacheOption option, IWICBitmap **ppIBitmap)
 417 {
 418     return IWICImagingFactory_CreateBitmap(pFactory, uiWidth, uiHeight,
 419         pixelFormat, option, ppIBitmap);
 420 }
 421
 422 HRESULT WINAPI IWICImagingFactory_CreateComponentInfo_Proxy_W(IWICImagingFactory *pFactory,
 423     REFCLSID clsidComponent, IWICComponentInfo **ppIInfo)
 424 {
 425     return IWICImagingFactory_CreateComponentInfo(pFactory, clsidComponent, ppIInfo);
 426 }
 427
 428 HRESULT WINAPI IWICImagingFactory_CreateDecoderFromFileHandle_Proxy_W(IWICImagingFactory *pFactory,
 429     ULONG_PTR hFile, const GUID *pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder **ppIDecoder)
 430 {
 431     return IWICImagingFactory_CreateDecoderFromFileHandle(pFactory, hFile, pguidVendor, metadataOptions, ppIDecoder);
 432 }
 433
 434 HRESULT WINAPI IWICImagingFactory_CreateDecoderFromFilename_Proxy_W(IWICImagingFactory *pFactory,
 435     LPCWSTR wzFilename, const GUID *pguidVendor, DWORD dwDesiredAccess,
 436     WICDecodeOptions metadataOptions, IWICBitmapDecoder **ppIDecoder)
 437 {
 438     return IWICImagingFactory_CreateDecoderFromFilename(pFactory, wzFilename,
 439         pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder);
 440 }
 441
 442 HRESULT WINAPI IWICImagingFactory_CreateDecoderFromStream_Proxy_W(IWICImagingFactory *pFactory,
 443     IStream *pIStream, const GUID *pguidVendor,
 444     WICDecodeOptions metadataOptions, IWICBitmapDecoder **ppIDecoder)
 445 {
 446     return IWICImagingFactory_CreateDecoderFromStream(pFactory, pIStream, pguidVendor, metadataOptions, ppIDecoder);
 447 }
 448
 449 HRESULT WINAPI IWICImagingFactory_CreateEncoder_Proxy_W(IWICImagingFactory *pFactory,
 450     REFGUID guidContainerFormat, const GUID *pguidVendor, IWICBitmapEncoder **ppIEncoder)
 451 {
 452     return IWICImagingFactory_CreateEncoder(pFactory, guidContainerFormat, pguidVendor, ppIEncoder);
 453 }
 454
 455 HRESULT WINAPI IWICImagingFactory_CreateFastMetadataEncoderFromDecoder_Proxy_W(IWICImagingFactory *pFactory,
 456     IWICBitmapDecoder *pIDecoder, IWICFastMetadataEncoder **ppIFastEncoder)
 457 {
 458     return IWICImagingFactory_CreateFastMetadataEncoderFromDecoder(pFactory, pIDecoder, ppIFastEncoder);
 459 }
 460
 461 HRESULT WINAPI IWICImagingFactory_CreateFastMetadataEncoderFromFrameDecode_Proxy_W(IWICImagingFactory *pFactory,
 462     IWICBitmapFrameDecode *pIFrameDecoder, IWICFastMetadataEncoder **ppIFastEncoder)
 463 {
 464     return IWICImagingFactory_CreateFastMetadataEncoderFromFrameDecode(pFactory, pIFrameDecoder, ppIFastEncoder);
 465 }
 466
 467 HRESULT WINAPI IWICImagingFactory_CreateFormatConverter_Proxy_W(IWICImagingFactory *pFactory,
 468     IWICFormatConverter **ppIFormatConverter)
 469 {
 470     return IWICImagingFactory_CreateFormatConverter(pFactory, ppIFormatConverter);
 471 }
 472
 473 HRESULT WINAPI IWICImagingFactory_CreatePalette_Proxy_W(IWICImagingFactory *pFactory,
 474     IWICPalette **ppIPalette)
 475 {
 476     return IWICImagingFactory_CreatePalette(pFactory, ppIPalette);
 477 }
 478
 479 HRESULT WINAPI IWICImagingFactory_CreateQueryWriterFromReader_Proxy_W(IWICImagingFactory *pFactory,
 480     IWICMetadataQueryReader *pIQueryReader, const GUID *pguidVendor,
 481     IWICMetadataQueryWriter **ppIQueryWriter)
 482 {
 483     return IWICImagingFactory_CreateQueryWriterFromReader(pFactory, pIQueryReader, pguidVendor, ppIQueryWriter);
 484 }
 485
 486 HRESULT WINAPI IWICImagingFactory_CreateQueryWriter_Proxy_W(IWICImagingFactory *pFactory,
 487     REFGUID guidMetadataFormat, const GUID *pguidVendor, IWICMetadataQueryWriter **ppIQueryWriter)
 488 {
 489     return IWICImagingFactory_CreateQueryWriter(pFactory, guidMetadataFormat, pguidVendor, ppIQueryWriter);
 490 }
 491
 492 HRESULT WINAPI IWICImagingFactory_CreateStream_Proxy_W(IWICImagingFactory *pFactory,
 493     IWICStream **ppIWICStream)
 494 {
 495     return IWICImagingFactory_CreateStream(pFactory, ppIWICStream);
 496 }
 497
 498 HRESULT WINAPI IWICMetadataBlockReader_GetCount_Proxy_W(IWICMetadataBlockReader *iface,
 499     UINT *pcCount)
 500 {
 501     return IWICMetadataBlockReader_GetCount(iface, pcCount);
 502 }
 503
 504 HRESULT WINAPI IWICMetadataBlockReader_GetReaderByIndex_Proxy_W(IWICMetadataBlockReader *iface,
 505     UINT nIndex, IWICMetadataReader **ppIMetadataReader)
 506 {
 507     return IWICMetadataBlockReader_GetReaderByIndex(iface, nIndex, ppIMetadataReader);
 508 }
 509
 510 HRESULT WINAPI IWICMetadataQueryReader_GetContainerFormat_Proxy_W(IWICMetadataQueryReader *iface,
 511     GUID *pguidContainerFormat)
 512 {
 513     return IWICMetadataQueryReader_GetContainerFormat(iface, pguidContainerFormat);
 514 }
 515
 516 HRESULT WINAPI IWICMetadataQueryReader_GetLocation_Proxy_W(IWICMetadataQueryReader *iface,
 517     UINT cchMaxLength, WCHAR *wzNamespace, UINT *pcchActualLength)
 518 {
 519     return IWICMetadataQueryReader_GetLocation(iface, cchMaxLength, wzNamespace, pcchActualLength);
 520 }
 521
 522 HRESULT WINAPI IWICMetadataQueryReader_GetMetadataByName_Proxy_W(IWICMetadataQueryReader *iface,
 523     LPCWSTR wzName, PROPVARIANT *pvarValue)
 524 {
 525     return IWICMetadataQueryReader_GetMetadataByName(iface, wzName, pvarValue);
 526 }
 527
 528 HRESULT WINAPI IWICMetadataQueryReader_GetEnumerator_Proxy_W(IWICMetadataQueryReader *iface,
 529     IEnumString **ppIEnumString)
 530 {
 531     return IWICMetadataQueryReader_GetEnumerator(iface, ppIEnumString);
 532 }
 533
 534 HRESULT WINAPI IWICMetadataQueryWriter_SetMetadataByName_Proxy_W(IWICMetadataQueryWriter *iface,
 535     LPCWSTR wzName, const PROPVARIANT *pvarValue)
 536 {
 537     return IWICMetadataQueryWriter_SetMetadataByName(iface, wzName, pvarValue);
 538 }
 539
 540 HRESULT WINAPI IWICMetadataQueryWriter_RemoveMetadataByName_Proxy_W(IWICMetadataQueryWriter *iface,
 541     LPCWSTR wzName)
 542 {
 543     return IWICMetadataQueryWriter_RemoveMetadataByName(iface, wzName);
 544 }
 545
 546 HRESULT WINAPI IWICPalette_InitializePredefined_Proxy_W(IWICPalette *iface,
 547     WICBitmapPaletteType ePaletteType, BOOL fAddTransparentColor)
 548 {
 549     return IWICPalette_InitializePredefined(iface, ePaletteType, fAddTransparentColor);
 550 }
 551
 552 HRESULT WINAPI IWICPalette_InitializeCustom_Proxy_W(IWICPalette *iface,
 553     WICColor *pColors, UINT colorCount)
 554 {
 555     return IWICPalette_InitializeCustom(iface, pColors, colorCount);
 556 }
 557
 558 HRESULT WINAPI IWICPalette_InitializeFromBitmap_Proxy_W(IWICPalette *iface,
 559     IWICBitmapSource *pISurface, UINT colorCount, BOOL fAddTransparentColor)
 560 {
 561     return IWICPalette_InitializeFromBitmap(iface, pISurface, colorCount, fAddTransparentColor);
 562 }
 563
 564 HRESULT WINAPI IWICPalette_InitializeFromPalette_Proxy_W(IWICPalette *iface,
 565     IWICPalette *pIPalette)
 566 {
 567     return IWICPalette_InitializeFromPalette(iface, pIPalette);
 568 }
 569
 570 HRESULT WINAPI IWICPalette_GetType_Proxy_W(IWICPalette *iface,
 571     WICBitmapPaletteType *pePaletteType)
 572 {
 573     return IWICPalette_GetType(iface, pePaletteType);
 574 }
 575
 576 HRESULT WINAPI IWICPalette_GetColorCount_Proxy_W(IWICPalette *iface,
 577     UINT *pcCount)
 578 {
 579     return IWICPalette_GetColorCount(iface, pcCount);
 580 }
 581
 582 HRESULT WINAPI IWICPalette_GetColors_Proxy_W(IWICPalette *iface,
 583     UINT colorCount, WICColor *pColors, UINT *pcActualColors)
 584 {
 585     return IWICPalette_GetColors(iface, colorCount, pColors, pcActualColors);
 586 }
 587
 588 HRESULT WINAPI IWICPalette_HasAlpha_Proxy_W(IWICPalette *iface,
 589     BOOL *pfHasAlpha)
 590 {
 591     return IWICPalette_HasAlpha(iface, pfHasAlpha);
 592 }
 593
 594 HRESULT WINAPI IWICStream_InitializeFromIStream_Proxy_W(IWICStream *iface,
 595     IStream *pIStream)
 596 {
 597     return IWICStream_InitializeFromIStream(iface, pIStream);
 598 }
 599
 600 HRESULT WINAPI IWICStream_InitializeFromMemory_Proxy_W(IWICStream *iface,
 601     BYTE *pbBuffer, DWORD cbBufferSize)
 602 {
 603     return IWICStream_InitializeFromMemory(iface, pbBuffer, cbBufferSize);
 604 }
 605
 606 HRESULT WINAPI WICCreateColorContext_Proxy(IWICImagingFactory *iface, IWICColorContext **ppIWICColorContext)
 607 {
 608     TRACE("%p, %p\n", iface, ppIWICColorContext);
 609
 610     return IWICImagingFactory_CreateColorContext(iface, ppIWICColorContext);
 611 }
 612
 613 HRESULT WINAPI WICCreateImagingFactory_Proxy(UINT SDKVersion, IWICImagingFactory **ppIImagingFactory)
 614 {
 615     TRACE("%x, %p\n", SDKVersion, ppIImagingFactory);
 616
 617     return ComponentFactory_CreateInstance(NULL, &IID_IWICImagingFactory, (void**)ppIImagingFactory);
 618 }