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