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