| /* |
| * Misleadingly named convenience functions for accessing WIC. |
| * |
| * Copyright 2012 Vincent Povirk for CodeWeavers |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| |
| #include "config.h" |
| |
| #include <stdarg.h> |
| |
| #define COBJMACROS |
| |
| #include "windef.h" |
| #include "winbase.h" |
| #include "objbase.h" |
| |
| #include "wincodecs_private.h" |
| |
| #include "wine/debug.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(wincodecs); |
| |
| HRESULT WINAPI IPropertyBag2_Write_Proxy(IPropertyBag2 *iface, |
| ULONG cProperties, PROPBAG2 *ppropbag, VARIANT *pvarValue) |
| { |
| return IPropertyBag2_Write(iface, cProperties, ppropbag, pvarValue); |
| } |
| |
| HRESULT WINAPI IWICBitmapClipper_Initialize_Proxy_W(IWICBitmapClipper *iface, |
| IWICBitmapSource *pISource, const WICRect *prc) |
| { |
| return IWICBitmapClipper_Initialize(iface, pISource, prc); |
| } |
| |
| HRESULT WINAPI IWICBitmapCodecInfo_GetContainerFormat_Proxy_W(IWICBitmapCodecInfo *iface, |
| GUID *pguidContainerFormat) |
| { |
| return IWICBitmapCodecInfo_GetContainerFormat(iface, pguidContainerFormat); |
| } |
| |
| HRESULT WINAPI IWICBitmapCodecInfo_GetDeviceManufacturer_Proxy_W(IWICBitmapCodecInfo *iface, |
| UINT cchDeviceManufacturer, WCHAR *wzDeviceManufacturer, UINT *pcchActual) |
| { |
| return IWICBitmapCodecInfo_GetDeviceManufacturer(iface, cchDeviceManufacturer, wzDeviceManufacturer, pcchActual); |
| } |
| |
| HRESULT WINAPI IWICBitmapCodecInfo_GetDeviceModels_Proxy_W(IWICBitmapCodecInfo *iface, |
| UINT cchDeviceModels, WCHAR *wzDeviceModels, UINT *pcchActual) |
| { |
| return IWICBitmapCodecInfo_GetDeviceModels(iface, cchDeviceModels, wzDeviceModels, pcchActual); |
| } |
| |
| HRESULT WINAPI IWICBitmapCodecInfo_GetMimeTypes_Proxy_W(IWICBitmapCodecInfo *iface, |
| UINT cchMimeTypes, WCHAR *wzMimeTypes, UINT *pcchActual) |
| { |
| return IWICBitmapCodecInfo_GetMimeTypes(iface, cchMimeTypes, wzMimeTypes, pcchActual); |
| } |
| |
| HRESULT WINAPI IWICBitmapCodecInfo_GetFileExtensions_Proxy_W(IWICBitmapCodecInfo *iface, |
| UINT cchFileExtensions, WCHAR *wzFileExtensions, UINT *pcchActual) |
| { |
| return IWICBitmapCodecInfo_GetFileExtensions(iface, cchFileExtensions, wzFileExtensions, pcchActual); |
| } |
| |
| HRESULT WINAPI IWICBitmapCodecInfo_DoesSupportAnimation_Proxy_W(IWICBitmapCodecInfo *iface, |
| BOOL *pfSupportAnimation) |
| { |
| return IWICBitmapCodecInfo_DoesSupportAnimation(iface, pfSupportAnimation); |
| } |
| |
| HRESULT WINAPI IWICBitmapCodecInfo_DoesSupportLossless_Proxy_W(IWICBitmapCodecInfo *iface, |
| BOOL *pfSupportLossless) |
| { |
| return IWICBitmapCodecInfo_DoesSupportLossless(iface, pfSupportLossless); |
| } |
| |
| HRESULT WINAPI IWICBitmapCodecInfo_DoesSupportMultiframe_Proxy_W(IWICBitmapCodecInfo *iface, |
| BOOL *pfSupportMultiframe) |
| { |
| return IWICBitmapCodecInfo_DoesSupportMultiframe(iface, pfSupportMultiframe); |
| } |
| |
| HRESULT WINAPI IWICBitmapDecoder_GetDecoderInfo_Proxy_W(IWICBitmapDecoder *iface, |
| IWICBitmapDecoderInfo **ppIDecoderInfo) |
| { |
| return IWICBitmapDecoder_GetDecoderInfo(iface, ppIDecoderInfo); |
| } |
| |
| HRESULT WINAPI IWICBitmapDecoder_CopyPalette_Proxy_W(IWICBitmapDecoder *iface, |
| IWICPalette *pIPalette) |
| { |
| return IWICBitmapDecoder_CopyPalette(iface, pIPalette); |
| } |
| |
| HRESULT WINAPI IWICBitmapDecoder_GetMetadataQueryReader_Proxy_W(IWICBitmapDecoder *iface, |
| IWICMetadataQueryReader **ppIMetadataQueryReader) |
| { |
| return IWICBitmapDecoder_GetMetadataQueryReader(iface, ppIMetadataQueryReader); |
| } |
| |
| HRESULT WINAPI IWICBitmapDecoder_GetPreview_Proxy_W(IWICBitmapDecoder *iface, |
| IWICBitmapSource **ppIBitmapSource) |
| { |
| return IWICBitmapDecoder_GetPreview(iface, ppIBitmapSource); |
| } |
| |
| HRESULT WINAPI IWICBitmapDecoder_GetColorContexts_Proxy_W(IWICBitmapDecoder *iface, |
| UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount) |
| { |
| return IWICBitmapDecoder_GetColorContexts(iface, cCount, ppIColorContexts, pcActualCount); |
| } |
| |
| HRESULT WINAPI IWICBitmapDecoder_GetThumbnail_Proxy_W(IWICBitmapDecoder *iface, |
| IWICBitmapSource **ppIThumbnail) |
| { |
| return IWICBitmapDecoder_GetThumbnail(iface, ppIThumbnail); |
| } |
| |
| HRESULT WINAPI IWICBitmapDecoder_GetFrameCount_Proxy_W(IWICBitmapDecoder *iface, |
| UINT *pCount) |
| { |
| return IWICBitmapDecoder_GetFrameCount(iface, pCount); |
| } |
| |
| HRESULT WINAPI IWICBitmapDecoder_GetFrame_Proxy_W(IWICBitmapDecoder *iface, |
| UINT index, IWICBitmapFrameDecode **ppIBitmapFrame) |
| { |
| return IWICBitmapDecoder_GetFrame(iface, index, ppIBitmapFrame); |
| } |
| |
| HRESULT WINAPI IWICBitmapEncoder_Initialize_Proxy_W(IWICBitmapEncoder *iface, |
| IStream *pIStream, WICBitmapEncoderCacheOption cacheOption) |
| { |
| return IWICBitmapEncoder_Initialize(iface, pIStream, cacheOption); |
| } |
| |
| HRESULT WINAPI IWICBitmapEncoder_GetEncoderInfo_Proxy_W(IWICBitmapEncoder *iface, |
| IWICBitmapEncoderInfo **ppIEncoderInfo) |
| { |
| return IWICBitmapEncoder_GetEncoderInfo(iface, ppIEncoderInfo); |
| } |
| |
| HRESULT WINAPI IWICBitmapEncoder_SetPalette_Proxy_W(IWICBitmapEncoder *iface, |
| IWICPalette *pIPalette) |
| { |
| return IWICBitmapEncoder_SetPalette(iface, pIPalette); |
| } |
| |
| HRESULT WINAPI IWICBitmapEncoder_SetThumbnail_Proxy_W(IWICBitmapEncoder *iface, |
| IWICBitmapSource *pIThumbnail) |
| { |
| return IWICBitmapEncoder_SetThumbnail(iface, pIThumbnail); |
| } |
| |
| HRESULT WINAPI IWICBitmapEncoder_CreateNewFrame_Proxy_W(IWICBitmapEncoder *iface, |
| IWICBitmapFrameEncode **ppIFrameEncode, IPropertyBag2 **ppIEncoderOptions) |
| { |
| return IWICBitmapEncoder_CreateNewFrame(iface, ppIFrameEncode, ppIEncoderOptions); |
| } |
| |
| HRESULT WINAPI IWICBitmapEncoder_Commit_Proxy_W(IWICBitmapEncoder *iface) |
| { |
| return IWICBitmapEncoder_Commit(iface); |
| } |
| |
| HRESULT WINAPI IWICBitmapEncoder_GetMetadataQueryWriter_Proxy_W(IWICBitmapEncoder *iface, |
| IWICMetadataQueryWriter **ppIMetadataQueryWriter) |
| { |
| return IWICBitmapEncoder_GetMetadataQueryWriter(iface, ppIMetadataQueryWriter); |
| } |
| |
| HRESULT WINAPI IWICBitmapFlipRotator_Initialize_Proxy_W(IWICBitmapFlipRotator *iface, |
| IWICBitmapSource *pISource, WICBitmapTransformOptions options) |
| { |
| return IWICBitmapFlipRotator_Initialize(iface, pISource, options); |
| } |
| |
| HRESULT WINAPI IWICBitmapFrameEncode_Initialize_Proxy_W(IWICBitmapFrameEncode *iface, |
| IPropertyBag2 *pIEncoderOptions) |
| { |
| return IWICBitmapFrameEncode_Initialize(iface, pIEncoderOptions); |
| } |
| |
| HRESULT WINAPI IWICBitmapFrameEncode_SetSize_Proxy_W(IWICBitmapFrameEncode *iface, |
| UINT uiWidth, UINT uiHeight) |
| { |
| return IWICBitmapFrameEncode_SetSize(iface, uiWidth, uiHeight); |
| } |
| |
| HRESULT WINAPI IWICBitmapFrameEncode_SetResolution_Proxy_W(IWICBitmapFrameEncode *iface, |
| double dpiX, double dpiY) |
| { |
| return IWICBitmapFrameEncode_SetResolution(iface, dpiX, dpiY); |
| } |
| |
| HRESULT WINAPI IWICBitmapFrameEncode_SetColorContexts_Proxy_W(IWICBitmapFrameEncode *iface, |
| UINT cCount, IWICColorContext **ppIColorContext) |
| { |
| return IWICBitmapFrameEncode_SetColorContexts(iface, cCount, ppIColorContext); |
| } |
| |
| HRESULT WINAPI IWICBitmapFrameEncode_SetThumbnail_Proxy_W(IWICBitmapFrameEncode *iface, |
| IWICBitmapSource *pIThumbnail) |
| { |
| return IWICBitmapFrameEncode_SetThumbnail(iface, pIThumbnail); |
| } |
| |
| HRESULT WINAPI IWICBitmapFrameEncode_WriteSource_Proxy_W(IWICBitmapFrameEncode *iface, |
| IWICBitmapSource *pIBitmapSource, WICRect *prc) |
| { |
| if (prc && (prc->Width <= 0 || prc->Height <= 0)) |
| prc = NULL; |
| |
| return IWICBitmapFrameEncode_WriteSource(iface, pIBitmapSource, prc); |
| } |
| |
| HRESULT WINAPI IWICBitmapFrameEncode_Commit_Proxy_W(IWICBitmapFrameEncode *iface) |
| { |
| return IWICBitmapFrameEncode_Commit(iface); |
| } |
| |
| HRESULT WINAPI IWICBitmapFrameEncode_GetMetadataQueryWriter_Proxy_W(IWICBitmapFrameEncode *iface, |
| IWICMetadataQueryWriter **ppIMetadataQueryWriter) |
| { |
| return IWICBitmapFrameEncode_GetMetadataQueryWriter(iface, ppIMetadataQueryWriter); |
| } |
| |
| HRESULT WINAPI IWICBitmapLock_GetDataPointer_Proxy_W(IWICBitmapLock *iface, |
| UINT *pcbBufferSize, BYTE **ppbData) |
| { |
| return IWICBitmapLock_GetDataPointer(iface, pcbBufferSize, ppbData); |
| } |
| |
| HRESULT WINAPI IWICBitmapLock_GetStride_Proxy_W(IWICBitmapLock *iface, |
| UINT *pcbStride) |
| { |
| return IWICBitmapLock_GetStride(iface, pcbStride); |
| } |
| |
| HRESULT WINAPI IWICBitmapScaler_Initialize_Proxy_W(IWICBitmapScaler *iface, |
| IWICBitmapSource *pISource, UINT uiWidth, UINT uiHeight, WICBitmapInterpolationMode mode) |
| { |
| return IWICBitmapScaler_Initialize(iface, pISource, uiWidth, uiHeight, mode); |
| } |
| |
| HRESULT WINAPI IWICBitmapSource_GetSize_Proxy_W(IWICBitmapSource *iface, |
| UINT *puiWidth, UINT *puiHeight) |
| { |
| return IWICBitmapSource_GetSize(iface, puiWidth, puiHeight); |
| } |
| |
| HRESULT WINAPI IWICBitmapSource_GetPixelFormat_Proxy_W(IWICBitmapSource *iface, |
| WICPixelFormatGUID *pPixelFormat) |
| { |
| return IWICBitmapSource_GetPixelFormat(iface, pPixelFormat); |
| } |
| |
| HRESULT WINAPI IWICBitmapSource_GetResolution_Proxy_W(IWICBitmapSource *iface, |
| double *pDpiX, double *pDpiY) |
| { |
| return IWICBitmapSource_GetResolution(iface, pDpiX, pDpiY); |
| } |
| |
| HRESULT WINAPI IWICBitmapSource_CopyPalette_Proxy_W(IWICBitmapSource *iface, |
| IWICPalette *pIPalette) |
| { |
| return IWICBitmapSource_CopyPalette(iface, pIPalette); |
| } |
| |
| HRESULT WINAPI IWICBitmapSource_CopyPixels_Proxy_W(IWICBitmapSource *iface, |
| const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer) |
| { |
| return IWICBitmapSource_CopyPixels(iface, prc, cbStride, cbBufferSize, pbBuffer); |
| } |
| |
| HRESULT WINAPI IWICBitmap_Lock_Proxy_W(IWICBitmap *iface, |
| const WICRect *prcLock, DWORD flags, IWICBitmapLock **ppILock) |
| { |
| return IWICBitmap_Lock(iface, prcLock, flags, ppILock); |
| } |
| |
| HRESULT WINAPI IWICBitmap_SetPalette_Proxy_W(IWICBitmap *iface, |
| IWICPalette *pIPalette) |
| { |
| return IWICBitmap_SetPalette(iface, pIPalette); |
| } |
| |
| HRESULT WINAPI IWICBitmap_SetResolution_Proxy_W(IWICBitmap *iface, |
| double dpiX, double dpiY) |
| { |
| return IWICBitmap_SetResolution(iface, dpiX, dpiY); |
| } |
| |
| HRESULT WINAPI IWICColorContext_InitializeFromMemory_Proxy_W(IWICColorContext *iface, |
| const BYTE *pbBuffer, UINT cbBufferSize) |
| { |
| return IWICColorContext_InitializeFromMemory(iface, pbBuffer, cbBufferSize); |
| } |
| |
| HRESULT WINAPI IWICComponentFactory_CreateMetadataWriterFromReader_Proxy_W(IWICComponentFactory *iface, |
| IWICMetadataReader *pIReader, const GUID *pguidVendor, IWICMetadataWriter **ppIWriter) |
| { |
| return IWICComponentFactory_CreateMetadataWriterFromReader(iface, pIReader, pguidVendor, ppIWriter); |
| } |
| |
| HRESULT WINAPI IWICComponentFactory_CreateQueryWriterFromBlockWriter_Proxy_W(IWICComponentFactory *iface, |
| IWICMetadataBlockWriter *pIBlockWriter, IWICMetadataQueryWriter **ppIQueryWriter) |
| { |
| return IWICComponentFactory_CreateQueryWriterFromBlockWriter(iface, pIBlockWriter, ppIQueryWriter); |
| } |
| |
| HRESULT WINAPI IWICComponentInfo_GetCLSID_Proxy_W(IWICComponentInfo *iface, |
| CLSID *pclsid) |
| { |
| return IWICComponentInfo_GetCLSID(iface, pclsid); |
| } |
| |
| HRESULT WINAPI IWICComponentInfo_GetAuthor_Proxy_W(IWICComponentInfo *iface, |
| UINT cchAuthor, WCHAR *wzAuthor, UINT *pcchActual) |
| { |
| return IWICComponentInfo_GetAuthor(iface, cchAuthor, wzAuthor, pcchActual); |
| } |
| |
| HRESULT WINAPI IWICComponentInfo_GetVersion_Proxy_W(IWICComponentInfo *iface, |
| UINT cchVersion, WCHAR *wzVersion, UINT *pcchActual) |
| { |
| return IWICComponentInfo_GetVersion(iface, cchVersion, wzVersion, pcchActual); |
| } |
| |
| HRESULT WINAPI IWICComponentInfo_GetSpecVersion_Proxy_W(IWICComponentInfo *iface, |
| UINT cchSpecVersion, WCHAR *wzSpecVersion, UINT *pcchActual) |
| { |
| return IWICComponentInfo_GetSpecVersion(iface, cchSpecVersion, wzSpecVersion, pcchActual); |
| } |
| |
| HRESULT WINAPI IWICComponentInfo_GetFriendlyName_Proxy_W(IWICComponentInfo *iface, |
| UINT cchFriendlyName, WCHAR *wzFriendlyName, UINT *pcchActual) |
| { |
| return IWICComponentInfo_GetFriendlyName(iface, cchFriendlyName, wzFriendlyName, pcchActual); |
| } |
| |
| HRESULT WINAPI IWICFastMetadataEncoder_Commit_Proxy_W(IWICFastMetadataEncoder *iface) |
| { |
| return IWICFastMetadataEncoder_Commit(iface); |
| } |
| |
| HRESULT WINAPI IWICFastMetadataEncoder_GetMetadataQueryWriter_Proxy_W(IWICFastMetadataEncoder *iface, |
| IWICMetadataQueryWriter **ppIMetadataQueryWriter) |
| { |
| return IWICFastMetadataEncoder_GetMetadataQueryWriter(iface, ppIMetadataQueryWriter); |
| } |
| |
| HRESULT WINAPI IWICBitmapFrameDecode_GetMetadataQueryReader_Proxy_W(IWICBitmapFrameDecode *iface, |
| IWICMetadataQueryReader **ppIMetadataQueryReader) |
| { |
| return IWICBitmapFrameDecode_GetMetadataQueryReader(iface, ppIMetadataQueryReader); |
| } |
| |
| HRESULT WINAPI IWICBitmapFrameDecode_GetColorContexts_Proxy_W(IWICBitmapFrameDecode *iface, |
| UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount) |
| { |
| return IWICBitmapFrameDecode_GetColorContexts(iface, cCount, ppIColorContexts, pcActualCount); |
| } |
| |
| HRESULT WINAPI IWICBitmapFrameDecode_GetThumbnail_Proxy_W(IWICBitmapFrameDecode *iface, |
| IWICBitmapSource **ppIThumbnail) |
| { |
| return IWICBitmapFrameDecode_GetThumbnail(iface, ppIThumbnail); |
| } |
| |
| HRESULT WINAPI IWICFormatConverter_Initialize_Proxy_W(IWICFormatConverter *iface, |
| IWICBitmapSource *pISource, REFWICPixelFormatGUID dstFormat, WICBitmapDitherType dither, |
| IWICPalette *pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) |
| { |
| return IWICFormatConverter_Initialize(iface, pISource, dstFormat, dither, |
| pIPalette, alphaThresholdPercent, paletteTranslate); |
| } |
| |
| HRESULT WINAPI IWICImagingFactory_CreateBitmapClipper_Proxy_W(IWICImagingFactory *pFactory, |
| IWICBitmapClipper **ppIBitmapClipper) |
| { |
| return IWICImagingFactory_CreateBitmapClipper(pFactory, ppIBitmapClipper); |
| } |
| |
| HRESULT WINAPI IWICImagingFactory_CreateBitmapFlipRotator_Proxy_W(IWICImagingFactory *pFactory, |
| IWICBitmapFlipRotator **ppIBitmapFlipRotator) |
| { |
| return IWICImagingFactory_CreateBitmapFlipRotator(pFactory, ppIBitmapFlipRotator); |
| } |
| |
| HRESULT WINAPI IWICImagingFactory_CreateBitmapFromHBITMAP_Proxy_W(IWICImagingFactory *pFactory, |
| HBITMAP hBitmap, HPALETTE hPalette, WICBitmapAlphaChannelOption options, IWICBitmap **ppIBitmap) |
| { |
| return IWICImagingFactory_CreateBitmapFromHBITMAP(pFactory, hBitmap, hPalette, options, ppIBitmap); |
| } |
| |
| HRESULT WINAPI IWICImagingFactory_CreateBitmapFromHICON_Proxy_W(IWICImagingFactory *pFactory, |
| HICON hIcon, IWICBitmap **ppIBitmap) |
| { |
| return IWICImagingFactory_CreateBitmapFromHICON(pFactory, hIcon, ppIBitmap); |
| } |
| |
| HRESULT WINAPI IWICImagingFactory_CreateBitmapFromMemory_Proxy_W(IWICImagingFactory *pFactory, |
| UINT uiWidth, UINT uiHeight, REFWICPixelFormatGUID pixelFormat, UINT cbStride, |
| UINT cbBufferSize, BYTE *pbBuffer, IWICBitmap **ppIBitmap) |
| { |
| return IWICImagingFactory_CreateBitmapFromMemory(pFactory, uiWidth, uiHeight, |
| pixelFormat, cbStride, cbBufferSize, pbBuffer, ppIBitmap); |
| } |
| |
| HRESULT WINAPI IWICImagingFactory_CreateBitmapFromSource_Proxy_W(IWICImagingFactory *pFactory, |
| IWICBitmapSource *piBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap **ppIBitmap) |
| { |
| return IWICImagingFactory_CreateBitmapFromSource(pFactory, piBitmapSource, option, ppIBitmap); |
| } |
| |
| HRESULT WINAPI IWICImagingFactory_CreateBitmapScaler_Proxy_W(IWICImagingFactory *pFactory, |
| IWICBitmapScaler **ppIBitmapScaler) |
| { |
| return IWICImagingFactory_CreateBitmapScaler(pFactory, ppIBitmapScaler); |
| } |
| |
| HRESULT WINAPI IWICImagingFactory_CreateBitmap_Proxy_W(IWICImagingFactory *pFactory, |
| UINT uiWidth, UINT uiHeight, REFWICPixelFormatGUID pixelFormat, |
| WICBitmapCreateCacheOption option, IWICBitmap **ppIBitmap) |
| { |
| return IWICImagingFactory_CreateBitmap(pFactory, uiWidth, uiHeight, |
| pixelFormat, option, ppIBitmap); |
| } |
| |
| HRESULT WINAPI IWICImagingFactory_CreateComponentInfo_Proxy_W(IWICImagingFactory *pFactory, |
| REFCLSID clsidComponent, IWICComponentInfo **ppIInfo) |
| { |
| return IWICImagingFactory_CreateComponentInfo(pFactory, clsidComponent, ppIInfo); |
| } |
| |
| HRESULT WINAPI IWICImagingFactory_CreateDecoderFromFileHandle_Proxy_W(IWICImagingFactory *pFactory, |
| ULONG_PTR hFile, const GUID *pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder **ppIDecoder) |
| { |
| return IWICImagingFactory_CreateDecoderFromFileHandle(pFactory, hFile, pguidVendor, metadataOptions, ppIDecoder); |
| } |
| |
| HRESULT WINAPI IWICImagingFactory_CreateDecoderFromFilename_Proxy_W(IWICImagingFactory *pFactory, |
| LPCWSTR wzFilename, const GUID *pguidVendor, DWORD dwDesiredAccess, |
| WICDecodeOptions metadataOptions, IWICBitmapDecoder **ppIDecoder) |
| { |
| return IWICImagingFactory_CreateDecoderFromFilename(pFactory, wzFilename, |
| pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); |
| } |
| |
| HRESULT WINAPI IWICImagingFactory_CreateDecoderFromStream_Proxy_W(IWICImagingFactory *pFactory, |
| IStream *pIStream, const GUID *pguidVendor, |
| WICDecodeOptions metadataOptions, IWICBitmapDecoder **ppIDecoder) |
| { |
| return IWICImagingFactory_CreateDecoderFromStream(pFactory, pIStream, pguidVendor, metadataOptions, ppIDecoder); |
| } |
| |
| HRESULT WINAPI IWICImagingFactory_CreateEncoder_Proxy_W(IWICImagingFactory *pFactory, |
| REFGUID guidContainerFormat, const GUID *pguidVendor, IWICBitmapEncoder **ppIEncoder) |
| { |
| return IWICImagingFactory_CreateEncoder(pFactory, guidContainerFormat, pguidVendor, ppIEncoder); |
| } |
| |
| HRESULT WINAPI IWICImagingFactory_CreateFastMetadataEncoderFromDecoder_Proxy_W(IWICImagingFactory *pFactory, |
| IWICBitmapDecoder *pIDecoder, IWICFastMetadataEncoder **ppIFastEncoder) |
| { |
| return IWICImagingFactory_CreateFastMetadataEncoderFromDecoder(pFactory, pIDecoder, ppIFastEncoder); |
| } |
| |
| HRESULT WINAPI IWICImagingFactory_CreateFastMetadataEncoderFromFrameDecode_Proxy_W(IWICImagingFactory *pFactory, |
| IWICBitmapFrameDecode *pIFrameDecoder, IWICFastMetadataEncoder **ppIFastEncoder) |
| { |
| return IWICImagingFactory_CreateFastMetadataEncoderFromFrameDecode(pFactory, pIFrameDecoder, ppIFastEncoder); |
| } |
| |
| HRESULT WINAPI IWICImagingFactory_CreateFormatConverter_Proxy_W(IWICImagingFactory *pFactory, |
| IWICFormatConverter **ppIFormatConverter) |
| { |
| return IWICImagingFactory_CreateFormatConverter(pFactory, ppIFormatConverter); |
| } |
| |
| HRESULT WINAPI IWICImagingFactory_CreatePalette_Proxy_W(IWICImagingFactory *pFactory, |
| IWICPalette **ppIPalette) |
| { |
| return IWICImagingFactory_CreatePalette(pFactory, ppIPalette); |
| } |
| |
| HRESULT WINAPI IWICImagingFactory_CreateQueryWriterFromReader_Proxy_W(IWICImagingFactory *pFactory, |
| IWICMetadataQueryReader *pIQueryReader, const GUID *pguidVendor, |
| IWICMetadataQueryWriter **ppIQueryWriter) |
| { |
| return IWICImagingFactory_CreateQueryWriterFromReader(pFactory, pIQueryReader, pguidVendor, ppIQueryWriter); |
| } |
| |
| HRESULT WINAPI IWICImagingFactory_CreateQueryWriter_Proxy_W(IWICImagingFactory *pFactory, |
| REFGUID guidMetadataFormat, const GUID *pguidVendor, IWICMetadataQueryWriter **ppIQueryWriter) |
| { |
| return IWICImagingFactory_CreateQueryWriter(pFactory, guidMetadataFormat, pguidVendor, ppIQueryWriter); |
| } |
| |
| HRESULT WINAPI IWICImagingFactory_CreateStream_Proxy_W(IWICImagingFactory *pFactory, |
| IWICStream **ppIWICStream) |
| { |
| return IWICImagingFactory_CreateStream(pFactory, ppIWICStream); |
| } |
| |
| HRESULT WINAPI IWICMetadataBlockReader_GetCount_Proxy_W(IWICMetadataBlockReader *iface, |
| UINT *pcCount) |
| { |
| return IWICMetadataBlockReader_GetCount(iface, pcCount); |
| } |
| |
| HRESULT WINAPI IWICMetadataBlockReader_GetReaderByIndex_Proxy_W(IWICMetadataBlockReader *iface, |
| UINT nIndex, IWICMetadataReader **ppIMetadataReader) |
| { |
| return IWICMetadataBlockReader_GetReaderByIndex(iface, nIndex, ppIMetadataReader); |
| } |
| |
| HRESULT WINAPI IWICMetadataQueryReader_GetContainerFormat_Proxy_W(IWICMetadataQueryReader *iface, |
| GUID *pguidContainerFormat) |
| { |
| return IWICMetadataQueryReader_GetContainerFormat(iface, pguidContainerFormat); |
| } |
| |
| HRESULT WINAPI IWICMetadataQueryReader_GetLocation_Proxy_W(IWICMetadataQueryReader *iface, |
| UINT cchMaxLength, WCHAR *wzNamespace, UINT *pcchActualLength) |
| { |
| return IWICMetadataQueryReader_GetLocation(iface, cchMaxLength, wzNamespace, pcchActualLength); |
| } |
| |
| HRESULT WINAPI IWICMetadataQueryReader_GetMetadataByName_Proxy_W(IWICMetadataQueryReader *iface, |
| LPCWSTR wzName, PROPVARIANT *pvarValue) |
| { |
| return IWICMetadataQueryReader_GetMetadataByName(iface, wzName, pvarValue); |
| } |
| |
| HRESULT WINAPI IWICMetadataQueryReader_GetEnumerator_Proxy_W(IWICMetadataQueryReader *iface, |
| IEnumString **ppIEnumString) |
| { |
| return IWICMetadataQueryReader_GetEnumerator(iface, ppIEnumString); |
| } |
| |
| HRESULT WINAPI IWICMetadataQueryWriter_SetMetadataByName_Proxy_W(IWICMetadataQueryWriter *iface, |
| LPCWSTR wzName, const PROPVARIANT *pvarValue) |
| { |
| return IWICMetadataQueryWriter_SetMetadataByName(iface, wzName, pvarValue); |
| } |
| |
| HRESULT WINAPI IWICMetadataQueryWriter_RemoveMetadataByName_Proxy_W(IWICMetadataQueryWriter *iface, |
| LPCWSTR wzName) |
| { |
| return IWICMetadataQueryWriter_RemoveMetadataByName(iface, wzName); |
| } |
| |
| HRESULT WINAPI IWICPalette_InitializePredefined_Proxy_W(IWICPalette *iface, |
| WICBitmapPaletteType ePaletteType, BOOL fAddTransparentColor) |
| { |
| return IWICPalette_InitializePredefined(iface, ePaletteType, fAddTransparentColor); |
| } |
| |
| HRESULT WINAPI IWICPalette_InitializeCustom_Proxy_W(IWICPalette *iface, |
| WICColor *pColors, UINT colorCount) |
| { |
| return IWICPalette_InitializeCustom(iface, pColors, colorCount); |
| } |
| |
| HRESULT WINAPI IWICPalette_InitializeFromBitmap_Proxy_W(IWICPalette *iface, |
| IWICBitmapSource *pISurface, UINT colorCount, BOOL fAddTransparentColor) |
| { |
| return IWICPalette_InitializeFromBitmap(iface, pISurface, colorCount, fAddTransparentColor); |
| } |
| |
| HRESULT WINAPI IWICPalette_InitializeFromPalette_Proxy_W(IWICPalette *iface, |
| IWICPalette *pIPalette) |
| { |
| return IWICPalette_InitializeFromPalette(iface, pIPalette); |
| } |
| |
| HRESULT WINAPI IWICPalette_GetType_Proxy_W(IWICPalette *iface, |
| WICBitmapPaletteType *pePaletteType) |
| { |
| return IWICPalette_GetType(iface, pePaletteType); |
| } |
| |
| HRESULT WINAPI IWICPalette_GetColorCount_Proxy_W(IWICPalette *iface, |
| UINT *pcCount) |
| { |
| return IWICPalette_GetColorCount(iface, pcCount); |
| } |
| |
| HRESULT WINAPI IWICPalette_GetColors_Proxy_W(IWICPalette *iface, |
| UINT colorCount, WICColor *pColors, UINT *pcActualColors) |
| { |
| return IWICPalette_GetColors(iface, colorCount, pColors, pcActualColors); |
| } |
| |
| HRESULT WINAPI IWICPalette_HasAlpha_Proxy_W(IWICPalette *iface, |
| BOOL *pfHasAlpha) |
| { |
| return IWICPalette_HasAlpha(iface, pfHasAlpha); |
| } |
| |
| HRESULT WINAPI IWICStream_InitializeFromIStream_Proxy_W(IWICStream *iface, |
| IStream *pIStream) |
| { |
| return IWICStream_InitializeFromIStream(iface, pIStream); |
| } |
| |
| HRESULT WINAPI IWICStream_InitializeFromMemory_Proxy_W(IWICStream *iface, |
| BYTE *pbBuffer, DWORD cbBufferSize) |
| { |
| return IWICStream_InitializeFromMemory(iface, pbBuffer, cbBufferSize); |
| } |
| |
| HRESULT WINAPI WICCreateColorContext_Proxy(IWICImagingFactory *iface, IWICColorContext **ppIWICColorContext) |
| { |
| TRACE("%p, %p\n", iface, ppIWICColorContext); |
| |
| return IWICImagingFactory_CreateColorContext(iface, ppIWICColorContext); |
| } |
| |
| HRESULT WINAPI WICCreateImagingFactory_Proxy(UINT SDKVersion, IWICImagingFactory **ppIImagingFactory) |
| { |
| TRACE("%x, %p\n", SDKVersion, ppIImagingFactory); |
| |
| return ComponentFactory_CreateInstance(&IID_IWICImagingFactory, (void**)ppIImagingFactory); |
| } |
| |
| HRESULT WINAPI WICSetEncoderFormat_Proxy(IWICBitmapSource *pSourceIn, |
| IWICPalette *pIPalette, IWICBitmapFrameEncode *pIFrameEncode, |
| IWICBitmapSource **ppSourceOut) |
| { |
| HRESULT hr; |
| WICPixelFormatGUID pixelformat, framepixelformat; |
| |
| TRACE("%p,%p,%p,%p\n", pSourceIn, pIPalette, pIFrameEncode, ppSourceOut); |
| |
| if (pIPalette) FIXME("ignoring palette\n"); |
| |
| if (!pSourceIn || !pIFrameEncode || !ppSourceOut) |
| return E_INVALIDARG; |
| |
| *ppSourceOut = NULL; |
| |
| hr = IWICBitmapSource_GetPixelFormat(pSourceIn, &pixelformat); |
| |
| if (SUCCEEDED(hr)) |
| { |
| framepixelformat = pixelformat; |
| hr = IWICBitmapFrameEncode_SetPixelFormat(pIFrameEncode, &framepixelformat); |
| } |
| |
| if (SUCCEEDED(hr)) |
| { |
| if (IsEqualGUID(&pixelformat, &framepixelformat)) |
| { |
| *ppSourceOut = pSourceIn; |
| IWICBitmapSource_AddRef(pSourceIn); |
| } |
| else |
| { |
| hr = WICConvertBitmapSource(&framepixelformat, pSourceIn, ppSourceOut); |
| } |
| } |
| |
| return hr; |
| } |