| /* | |
| * 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; | |
| } |