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