windowscodecs: Add support for IMILBitmapSource interface.
Dmitry Timoshkov
dmitry at baikal.ru
Sun May 19 22:14:52 CDT 2013
---
dlls/windowscodecs/bitmap.c | 250 ++++++++++++++++++++++++++++++++-
dlls/windowscodecs/tests/bitmap.c | 145 +++++++++++++++++++
dlls/windowscodecs/wincodecs_private.h | 40 ++++++
3 files changed, 434 insertions(+), 1 deletion(-)
diff --git a/dlls/windowscodecs/bitmap.c b/dlls/windowscodecs/bitmap.c
index f8904df..646f3a7 100644
--- a/dlls/windowscodecs/bitmap.c
+++ b/dlls/windowscodecs/bitmap.c
@@ -33,9 +33,15 @@
WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
+/* WARNING: .NET Media Integration Layer (MIL) directly dereferences
+ * BitmapImpl members and depends on its exact layout.
+ */
typedef struct BitmapImpl {
- IWICBitmap IWICBitmap_iface;
+ IMILUnknown1 IMILUnknown1_iface;
LONG ref;
+ IMILBitmapSource IMILBitmapSource_iface;
+ IWICBitmap IWICBitmap_iface;
+ IMILUnknown2 IMILUnknown2_iface;
IWICPalette *palette;
int palette_set;
LONG lock; /* 0 if not locked, -1 if locked for writing, count if locked for reading */
@@ -61,6 +67,21 @@ static inline BitmapImpl *impl_from_IWICBitmap(IWICBitmap *iface)
return CONTAINING_RECORD(iface, BitmapImpl, IWICBitmap_iface);
}
+static inline BitmapImpl *impl_from_IMILBitmapSource(IMILBitmapSource *iface)
+{
+ return CONTAINING_RECORD(iface, BitmapImpl, IMILBitmapSource_iface);
+}
+
+static inline BitmapImpl *impl_from_IMILUnknown1(IMILUnknown1 *iface)
+{
+ return CONTAINING_RECORD(iface, BitmapImpl, IMILUnknown1_iface);
+}
+
+static inline BitmapImpl *impl_from_IMILUnknown2(IMILUnknown2 *iface)
+{
+ return CONTAINING_RECORD(iface, BitmapImpl, IMILUnknown2_iface);
+}
+
static inline BitmapLockImpl *impl_from_IWICBitmapLock(IWICBitmapLock *iface)
{
return CONTAINING_RECORD(iface, BitmapLockImpl, IWICBitmapLock_iface);
@@ -228,6 +249,10 @@ static HRESULT WINAPI BitmapImpl_QueryInterface(IWICBitmap *iface, REFIID iid,
{
*ppv = &This->IWICBitmap_iface;
}
+ else if (IsEqualIID(&IID_IMILBitmapSource, iid))
+ {
+ *ppv = &This->IMILBitmapSource_iface;
+ }
else
{
*ppv = NULL;
@@ -446,6 +471,226 @@ static const IWICBitmapVtbl BitmapImpl_Vtbl = {
BitmapImpl_SetResolution
};
+static HRESULT WINAPI IMILBitmapImpl_QueryInterface(IMILBitmapSource *iface, REFIID iid,
+ void **ppv)
+{
+ BitmapImpl *This = impl_from_IMILBitmapSource(iface);
+ TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
+
+ if (!ppv) return E_INVALIDARG;
+
+ if (IsEqualIID(&IID_IUnknown, iid) ||
+ IsEqualIID(&IID_IMILBitmapSource, iid))
+ {
+ *ppv = &This->IMILBitmapSource_iface;
+ IUnknown_AddRef((IUnknown*)*ppv);
+ return S_OK;
+ }
+
+ *ppv = NULL;
+ return E_NOINTERFACE;
+}
+
+static ULONG WINAPI IMILBitmapImpl_AddRef(IMILBitmapSource *iface)
+{
+ BitmapImpl *This = impl_from_IMILBitmapSource(iface);
+ return IWICBitmap_AddRef(&This->IWICBitmap_iface);
+}
+
+static ULONG WINAPI IMILBitmapImpl_Release(IMILBitmapSource *iface)
+{
+ BitmapImpl *This = impl_from_IMILBitmapSource(iface);
+ return IWICBitmap_Release(&This->IWICBitmap_iface);
+}
+
+static HRESULT WINAPI IMILBitmapImpl_GetSize(IMILBitmapSource *iface,
+ UINT *puiWidth, UINT *puiHeight)
+{
+ BitmapImpl *This = impl_from_IMILBitmapSource(iface);
+ return IWICBitmap_GetSize(&This->IWICBitmap_iface, puiWidth, puiHeight);
+}
+
+static const struct
+{
+ const GUID *WIC_format;
+ int enum_format;
+} pixel_fmt_map[] =
+{
+ { &GUID_WICPixelFormatDontCare, 0 },
+ { &GUID_WICPixelFormat1bppIndexed, 1 },
+ { &GUID_WICPixelFormat2bppIndexed, 2 },
+ { &GUID_WICPixelFormat4bppIndexed, 3 },
+ { &GUID_WICPixelFormat8bppIndexed, 4 },
+ { &GUID_WICPixelFormatBlackWhite, 5 },
+ { &GUID_WICPixelFormat2bppGray, 6 },
+ { &GUID_WICPixelFormat4bppGray, 7 },
+ { &GUID_WICPixelFormat8bppGray, 8 },
+ { &GUID_WICPixelFormat16bppBGR555, 9 },
+ { &GUID_WICPixelFormat16bppBGR565, 0x0a },
+ { &GUID_WICPixelFormat16bppGray, 0x0b },
+ { &GUID_WICPixelFormat24bppBGR, 0x0c },
+ { &GUID_WICPixelFormat24bppRGB, 0x0d },
+ { &GUID_WICPixelFormat32bppBGR, 0x0e },
+ { &GUID_WICPixelFormat32bppBGRA, 0x0f },
+ { &GUID_WICPixelFormat32bppPBGRA, 0x10 },
+ { &GUID_WICPixelFormat48bppRGB, 0x15 },
+ { &GUID_WICPixelFormat64bppRGBA, 0x16 },
+ { &GUID_WICPixelFormat64bppPRGBA, 0x17 },
+ { &GUID_WICPixelFormat32bppCMYK, 0x1c }
+};
+
+static HRESULT WINAPI IMILBitmapImpl_GetPixelFormat(IMILBitmapSource *iface,
+ int *pPixelFormat)
+{
+ BitmapImpl *This = impl_from_IMILBitmapSource(iface);
+ int i;
+
+ TRACE("(%p,%p)\n", iface, pPixelFormat);
+
+ if (!pPixelFormat) return E_INVALIDARG;
+
+ *pPixelFormat = 0;
+
+ for (i = 0; i < sizeof(pixel_fmt_map)/sizeof(pixel_fmt_map[0]); i++)
+ {
+ if (IsEqualGUID(pixel_fmt_map[i].WIC_format, &This->pixelformat))
+ {
+ *pPixelFormat = pixel_fmt_map[i].enum_format;
+ break;
+ }
+ }
+
+ return S_OK;
+}
+
+static HRESULT WINAPI IMILBitmapImpl_GetResolution(IMILBitmapSource *iface,
+ double *pDpiX, double *pDpiY)
+{
+ BitmapImpl *This = impl_from_IMILBitmapSource(iface);
+ return IWICBitmap_GetResolution(&This->IWICBitmap_iface, pDpiX, pDpiY);
+}
+
+static HRESULT WINAPI IMILBitmapImpl_CopyPalette(IMILBitmapSource *iface,
+ IWICPalette *pIPalette)
+{
+ BitmapImpl *This = impl_from_IMILBitmapSource(iface);
+ return IWICBitmap_CopyPalette(&This->IWICBitmap_iface, pIPalette);
+}
+
+static HRESULT WINAPI IMILBitmapImpl_CopyPixels(IMILBitmapSource *iface,
+ const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer)
+{
+ BitmapImpl *This = impl_from_IMILBitmapSource(iface);
+ return IWICBitmap_CopyPixels(&This->IWICBitmap_iface, prc, cbStride, cbBufferSize, pbBuffer);
+}
+
+static HRESULT WINAPI IMILBitmapImpl_UnknownMethod1(IMILBitmapSource *iface, void **ppv)
+{
+ BitmapImpl *This = impl_from_IMILBitmapSource(iface);
+
+ TRACE("(%p,%p)\n", iface, ppv);
+
+ if (!ppv) return E_INVALIDARG;
+
+ *ppv = &This->IMILUnknown1_iface;
+ IUnknown_AddRef((IUnknown*)*ppv);
+
+ return S_OK;
+}
+
+static const IMILBitmapSourceVtbl IMILBitmapImpl_Vtbl = {
+ IMILBitmapImpl_QueryInterface,
+ IMILBitmapImpl_AddRef,
+ IMILBitmapImpl_Release,
+ IMILBitmapImpl_GetSize,
+ IMILBitmapImpl_GetPixelFormat,
+ IMILBitmapImpl_GetResolution,
+ IMILBitmapImpl_CopyPalette,
+ IMILBitmapImpl_CopyPixels,
+ IMILBitmapImpl_UnknownMethod1,
+};
+
+static HRESULT WINAPI IMILUnknown1Impl_QueryInterface(IMILUnknown1 *iface, REFIID iid,
+ void **ppv)
+{
+ BitmapImpl *This = impl_from_IMILUnknown1(iface);
+
+ TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
+
+ if (!ppv) return E_INVALIDARG;
+
+ if (IsEqualIID(&IID_IUnknown, iid))
+ {
+ *ppv = iface;
+ IUnknown_AddRef((IUnknown*)*ppv);
+ return S_OK;
+ }
+
+ return IWICBitmap_QueryInterface(&This->IWICBitmap_iface, iid, ppv);
+}
+
+static ULONG WINAPI IMILUnknown1Impl_AddRef(IMILUnknown1 *iface)
+{
+ BitmapImpl *This = impl_from_IMILUnknown1(iface);
+ return IWICBitmap_AddRef(&This->IWICBitmap_iface);
+}
+
+static ULONG WINAPI IMILUnknown1Impl_Release(IMILUnknown1 *iface)
+{
+ BitmapImpl *This = impl_from_IMILUnknown1(iface);
+ return IWICBitmap_Release(&This->IWICBitmap_iface);
+}
+
+static const IMILUnknown1Vtbl IMILUnknown1Impl_Vtbl = {
+ IMILUnknown1Impl_QueryInterface,
+ IMILUnknown1Impl_AddRef,
+ IMILUnknown1Impl_Release,
+};
+
+static HRESULT WINAPI IMILUnknown2Impl_QueryInterface(IMILUnknown2 *iface, REFIID iid,
+ void **ppv)
+{
+ BitmapImpl *This = impl_from_IMILUnknown2(iface);
+
+ TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
+
+ if (!ppv) return E_INVALIDARG;
+
+ if (IsEqualIID(&IID_IUnknown, iid))
+ {
+ *ppv = iface;
+ IUnknown_AddRef((IUnknown*)*ppv);
+ return S_OK;
+ }
+
+ return IWICBitmap_QueryInterface(&This->IWICBitmap_iface, iid, ppv);
+}
+
+static ULONG WINAPI IMILUnknown2Impl_AddRef(IMILUnknown2 *iface)
+{
+ BitmapImpl *This = impl_from_IMILUnknown2(iface);
+ return IWICBitmap_AddRef(&This->IWICBitmap_iface);
+}
+
+static ULONG WINAPI IMILUnknown2Impl_Release(IMILUnknown2 *iface)
+{
+ BitmapImpl *This = impl_from_IMILUnknown2(iface);
+ return IWICBitmap_Release(&This->IWICBitmap_iface);
+}
+
+static HRESULT WINAPI IMILUnknown2Impl_UnknownMethod1(IMILUnknown2 *iface, void *arg1, void *arg2)
+{
+ FIXME("(%p,%p,%p): stub\n", iface, arg1, arg2);
+ return E_NOTIMPL;
+}
+
+static const IMILUnknown2Vtbl IMILUnknown2Impl_Vtbl = {
+ IMILUnknown2Impl_QueryInterface,
+ IMILUnknown2Impl_AddRef,
+ IMILUnknown2Impl_Release,
+ IMILUnknown2Impl_UnknownMethod1,
+};
+
HRESULT BitmapImpl_Create(UINT uiWidth, UINT uiHeight,
UINT stride, UINT datasize, BYTE *bits,
REFWICPixelFormatGUID pixelFormat, WICBitmapCreateCacheOption option,
@@ -476,6 +721,9 @@ HRESULT BitmapImpl_Create(UINT uiWidth, UINT uiHeight,
if (bits) memcpy(data, bits, datasize);
This->IWICBitmap_iface.lpVtbl = &BitmapImpl_Vtbl;
+ This->IMILBitmapSource_iface.lpVtbl = &IMILBitmapImpl_Vtbl;
+ This->IMILUnknown1_iface.lpVtbl = &IMILUnknown1Impl_Vtbl;
+ This->IMILUnknown2_iface.lpVtbl = &IMILUnknown2Impl_Vtbl;
This->ref = 1;
This->palette = NULL;
This->palette_set = 0;
diff --git a/dlls/windowscodecs/tests/bitmap.c b/dlls/windowscodecs/tests/bitmap.c
index 742f45f..ee07825 100644
--- a/dlls/windowscodecs/tests/bitmap.c
+++ b/dlls/windowscodecs/tests/bitmap.c
@@ -29,6 +29,36 @@
#include "wincodec.h"
#include "wine/test.h"
+#include "initguid.h"
+DEFINE_GUID(IID_IMILBitmapSource,0x7543696a,0xbc8d,0x46b0,0x5f,0x81,0x8d,0x95,0x72,0x89,0x72,0xbe);
+
+#define INTERFACE IMILBitmapSource
+DECLARE_INTERFACE_(IMILBitmapSource,IUnknown)
+{
+ /*** IUnknown methods ***/
+ STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID,void **) PURE;
+ STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+ STDMETHOD_(ULONG,Release)(THIS) PURE;
+ /*** IMILBitmapSource methods ***/
+ STDMETHOD_(HRESULT,GetSize)(THIS_ UINT *,UINT *);
+ STDMETHOD_(HRESULT,GetPixelFormat)(THIS_ int *);
+ STDMETHOD_(HRESULT,GetResolution)(THIS_ double *,double *);
+ STDMETHOD_(HRESULT,CopyPalette)(THIS_ IWICPalette *);
+ STDMETHOD_(HRESULT,CopyPixels)(THIS_ const WICRect *,UINT,UINT,BYTE *);
+ STDMETHOD_(HRESULT,UnknownMethod1)(THIS_ void **);
+};
+#undef INTERFACE
+
+#define INTERFACE IMILUnknown1
+DECLARE_INTERFACE_(IMILUnknown1,IUnknown)
+{
+ /*** IUnknown methods ***/
+ STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID,void **) PURE;
+ STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+ STDMETHOD_(ULONG,Release)(THIS) PURE;
+};
+#undef INTERFACE
+
static IWICImagingFactory *factory;
static const char *debugstr_guid(const GUID *guid)
@@ -519,6 +549,7 @@ static void test_CreateBitmapFromMemory(void)
hr = IWICImagingFactory_CreateBitmapFromMemory(factory, 3, 3, &GUID_WICPixelFormat24bppBGR,
9, sizeof(data3x3), data3x3, &bitmap);
ok(hr == S_OK, "IWICImagingFactory_CreateBitmapFromMemory error %#x\n", hr);
+ if (FAILED(hr)) return;
hr = IWICBitmap_GetSize(bitmap, &width, &height);
ok(hr == S_OK, "IWICBitmap_GetSize error %#x\n", hr);
@@ -769,6 +800,119 @@ todo_wine
DeleteObject(hpal);
}
+static const struct
+{
+ const GUID *guid;
+ const char *name;
+ HRESULT hr;
+} MIL_iface[] =
+{
+#define IFACE_NAME(iface_name) \
+ { &IID_##iface_name, #iface_name, E_NOINTERFACE }
+#define IFACE_NAME_OK(iface_name) \
+ { &IID_##iface_name, #iface_name, S_OK }
+ IFACE_NAME_OK(IUnknown),
+ IFACE_NAME(IWICPalette),
+ IFACE_NAME_OK(IWICBitmap),
+ IFACE_NAME(IWICBitmapLock),
+ IFACE_NAME_OK(IWICBitmapSource),
+ IFACE_NAME(IWICFastMetadataEncoder),
+ IFACE_NAME(IWICBitmapCodecInfo),
+ IFACE_NAME(IWICBitmapDecoderInfo),
+ IFACE_NAME(IWICBitmapEncoderInfo),
+ IFACE_NAME(IWICBitmapDecoder),
+ IFACE_NAME(IWICBitmapEncoder),
+ IFACE_NAME(IWICBitmapFrameDecode),
+ IFACE_NAME(IWICBitmapFrameEncode),
+#ifdef IWICBitmapSourceTransform
+ IFACE_NAME(IWICBitmapSourceTransform),
+#endif
+ IFACE_NAME(IWICBitmapScaler),
+ IFACE_NAME(IWICBitmapClipper),
+ IFACE_NAME(IWICBitmapFlipRotator),
+ IFACE_NAME(IWICFormatConverter),
+ IFACE_NAME(IWICComponentInfo),
+ IFACE_NAME(IWICStream),
+ IFACE_NAME(IWICEnumMetadataItem),
+ IFACE_NAME(IWICMetadataQueryReader),
+ IFACE_NAME(IWICMetadataQueryWriter),
+ IFACE_NAME_OK(IMILBitmapSource)
+#undef IFACE_NAME
+#undef IFACE_NAME_OK
+};
+
+static void test_IMILBitmap(void)
+{
+ HRESULT hr;
+ IWICBitmap *bitmap;
+ IMILBitmapSource *source;
+ IUnknown *unknown1, *unknown2;
+ WICPixelFormatGUID format;
+ int MIL_format, i;
+ UINT width, height;
+ double dpix, dpiy;
+
+ hr = IWICImagingFactory_CreateBitmap(factory, 1, 1, &GUID_WICPixelFormat24bppBGR,
+ WICBitmapCacheOnLoad, &bitmap);
+ ok(hr == S_OK, "CreateBitmap error %#x\n", hr);
+
+ hr = IWICBitmap_GetPixelFormat(bitmap, &format);
+ ok(hr == S_OK, "GetPixelFormat error %#x\n", hr);
+ ok(IsEqualGUID(&format, &GUID_WICPixelFormat24bppBGR), "wrong format %s\n", debugstr_guid(&format));
+
+ hr = IWICBitmap_GetResolution(bitmap, &dpix, &dpiy);
+ ok(hr == S_OK, "GetResolution error %#x\n", hr);
+ ok(dpix == 0.0, "got %f, expected 0.0\n", dpix);
+ ok(dpiy == 0.0, "got %f, expected 0.0\n", dpiy);
+
+ hr = IWICBitmap_SetResolution(bitmap, 12.0, 34.0);
+ ok(hr == S_OK, "SetResolution error %#x\n", hr);
+
+ hr = IWICBitmap_GetResolution(bitmap, &dpix, &dpiy);
+ ok(hr == S_OK, "GetResolution error %#x\n", hr);
+ ok(dpix == 12.0, "got %f, expected 12.0\n", dpix);
+ ok(dpiy == 34.0, "got %f, expected 34.0\n", dpiy);
+
+ hr = IWICBitmap_GetSize(bitmap, &width, &height);
+ ok(hr == S_OK, "GetSize error %#x\n", hr);
+ ok(width == 1, "got %u, expected 1\n", width);
+ ok(height == 1, "got %u, expected 1\n", height);
+
+ hr = IWICBitmap_QueryInterface(bitmap, &IID_IMILBitmapSource, (void **)&source);
+ ok(hr == S_OK, "QueryInterface error %#x\n", hr);
+
+ hr = source->lpVtbl->GetPixelFormat(source, &MIL_format);
+ ok(hr == S_OK, "GetPixelFormat error %#x\n", hr);
+ ok(MIL_format == 0x0c, "wrong format %d\n", MIL_format);
+
+ hr = source->lpVtbl->GetResolution(source, &dpix, &dpiy);
+ ok(hr == S_OK, "GetResolution error %#x\n", hr);
+ ok(dpix == 12.0, "got %f, expected 12.0\n", dpix);
+ ok(dpiy == 34.0, "got %f, expected 34.0\n", dpiy);
+
+ hr = source->lpVtbl->GetSize(source, &width, &height);
+ ok(hr == S_OK, "GetSize error %#x\n", hr);
+ ok(width == 1, "got %u, expected 1\n", width);
+ ok(height == 1, "got %u, expected 1\n", height);
+
+ unknown1 = (void *)0xdeadbeef;
+ hr = source->lpVtbl->UnknownMethod1(source, (void **)&unknown1);
+ ok(hr == S_OK, "UnknownMethod1 error %#x\n", hr);
+ trace("unknown1 => %p\n", unknown1);
+
+ for (i = 0; i < sizeof(MIL_iface)/sizeof(MIL_iface[0]); i++)
+ {
+ unknown2 = (void *)0xdeadbeef;
+ hr = unknown1->lpVtbl->QueryInterface(unknown1, MIL_iface[i].guid, (void **)&unknown2);
+ ok(hr == MIL_iface[i].hr, "QI(%s) => %p (%#x)\n", MIL_iface[i].name, unknown2, hr);
+ if (hr == S_OK) unknown2->lpVtbl->Release(unknown2);
+ }
+
+ unknown1->lpVtbl->Release(unknown1);
+ source->lpVtbl->Release(source);
+ IWICBitmap_Release(bitmap);
+}
+
START_TEST(bitmap)
{
HRESULT hr;
@@ -784,6 +928,7 @@ START_TEST(bitmap)
test_CreateBitmapFromMemory();
test_CreateBitmapFromHICON();
test_CreateBitmapFromHBITMAP();
+ test_IMILBitmap();
IWICImagingFactory_Release(factory);
diff --git a/dlls/windowscodecs/wincodecs_private.h b/dlls/windowscodecs/wincodecs_private.h
index dddb327..29f7726 100644
--- a/dlls/windowscodecs/wincodecs_private.h
+++ b/dlls/windowscodecs/wincodecs_private.h
@@ -27,6 +27,46 @@ DEFINE_GUID(GUID_WineContainerFormatTga, 0x0c44fda1,0xa5c5,0x4298,0x96,0x85,0x47
DEFINE_GUID(GUID_VendorWine, 0xddf46da1,0x7dc1,0x404e,0x98,0xf2,0xef,0xa4,0x8d,0xfc,0x95,0x0a);
+DEFINE_GUID(IID_IMILBitmapSource,0x7543696a,0xbc8d,0x46b0,0x5f,0x81,0x8d,0x95,0x72,0x89,0x72,0xbe);
+#define INTERFACE IMILBitmapSource
+DECLARE_INTERFACE_(IMILBitmapSource,IUnknown)
+{
+ /*** IUnknown methods ***/
+ STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID,void **) PURE;
+ STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+ STDMETHOD_(ULONG,Release)(THIS) PURE;
+ /*** IMILBitmapSource methods ***/
+ STDMETHOD_(HRESULT,GetSize)(THIS_ UINT *,UINT *);
+ STDMETHOD_(HRESULT,GetPixelFormat)(THIS_ int *);
+ STDMETHOD_(HRESULT,GetResolution)(THIS_ double *,double *);
+ STDMETHOD_(HRESULT,CopyPalette)(THIS_ IWICPalette *);
+ STDMETHOD_(HRESULT,CopyPixels)(THIS_ const WICRect *,UINT,UINT,BYTE *);
+ STDMETHOD_(HRESULT,UnknownMethod1)(THIS_ void **);
+};
+#undef INTERFACE
+
+#define INTERFACE IMILUnknown1
+DECLARE_INTERFACE_(IMILUnknown1,IUnknown)
+{
+ /*** IUnknown methods ***/
+ STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID,void **) PURE;
+ STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+ STDMETHOD_(ULONG,Release)(THIS) PURE;
+};
+#undef INTERFACE
+
+#define INTERFACE IMILUnknown2
+DECLARE_INTERFACE_(IMILUnknown2,IUnknown)
+{
+ /*** IUnknown methods ***/
+ STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID,void **) PURE;
+ STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+ STDMETHOD_(ULONG,Release)(THIS) PURE;
+ /*** unknown methods ***/
+ STDMETHOD_(HRESULT,UnknownMethod1)(THIS_ void *, void *) PURE;
+};
+#undef INTERFACE
+
extern HRESULT FormatConverter_CreateInstance(IUnknown *pUnkOuter, REFIID riid, void** ppv) DECLSPEC_HIDDEN;
extern HRESULT ComponentFactory_CreateInstance(IUnknown *pUnkOuter, REFIID riid, void** ppv) DECLSPEC_HIDDEN;
extern HRESULT BmpDecoder_CreateInstance(IUnknown *pUnkOuter, REFIID riid, void** ppv) DECLSPEC_HIDDEN;
--
1.8.2.3
More information about the wine-patches
mailing list