/* * AVI decompressor filter unit tests * * Copyright 2018 Zebediah Figura * * 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 */ #define COBJMACROS #include "dshow.h" #include "vfw.h" #include "wmcodecdsp.h" #include "wine/strmbase.h" #include "wine/test.h" static const DWORD test_handler = mmioFOURCC('w','t','s','t'); static const GUID test_subtype = {mmioFOURCC('w','t','s','t'),0x0000,0x0010,{0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71}}; static IBaseFilter *create_avi_dec(void) { IBaseFilter *filter = NULL; HRESULT hr = CoCreateInstance(&CLSID_AVIDec, NULL, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (void **)&filter); ok(hr == S_OK, "Got hr %#x.\n", hr); return filter; } static inline BOOL compare_media_types(const AM_MEDIA_TYPE *a, const AM_MEDIA_TYPE *b) { return !memcmp(a, b, offsetof(AM_MEDIA_TYPE, pbFormat)) && !memcmp(a->pbFormat, b->pbFormat, a->cbFormat); } static ULONG get_refcount(void *iface) { IUnknown *unknown = iface; IUnknown_AddRef(unknown); return IUnknown_Release(unknown); } static BITMAPINFOHEADER sink_bih; static LRESULT CALLBACK vfw_driver_proc(DWORD_PTR id, HDRVR driver, UINT msg, LPARAM lparam1, LPARAM lparam2) { if (winetest_debug > 1) trace("id %#lx, driver %p, msg %#x, lparam1 %#lx, lparam2 %#lx.\n", id, driver, msg, lparam1, lparam2); switch (msg) { case DRV_LOAD: case DRV_ENABLE: case DRV_OPEN: case DRV_CLOSE: case DRV_DISABLE: case DRV_FREE: return 1; case ICM_DECOMPRESS_GET_FORMAT: { BITMAPINFOHEADER *out = (BITMAPINFOHEADER *)lparam2; BITMAPINFOHEADER *in = (BITMAPINFOHEADER *)lparam1; if (!out) return sizeof(BITMAPINFOHEADER); ok(!memcmp(in, &sink_bih, sizeof(BITMAPINFOHEADER)), "Input types didn't match.\n"); out->biSize = sizeof(BITMAPINFOHEADER); out->biCompression = mmioFOURCC('I','4','2','0'); out->biWidth = 32; out->biHeight = 24; out->biBitCount = 12; out->biSizeImage = 32 * 24 * 12 / 8; return ICERR_OK; } case ICM_DECOMPRESS_QUERY: { BITMAPINFOHEADER *out = (BITMAPINFOHEADER *)lparam2; BITMAPINFOHEADER *in = (BITMAPINFOHEADER *)lparam1; if (in->biCompression != test_handler || in->biBitCount != 16) return ICERR_BADFORMAT; if (out && out->biCompression != mmioFOURCC('I','4','2','0')) return ICERR_BADFORMAT; return ICERR_OK; } case ICM_DECOMPRESS_GET_PALETTE: return ICERR_UNSUPPORTED; case ICM_GETINFO: { ICINFO *info = (ICINFO *)lparam1; info->fccType = ICTYPE_VIDEO; info->fccHandler = test_handler; return sizeof(ICINFO); } default: ok(0, "Got unexpected message %#x.\n", msg); return ICERR_UNSUPPORTED; } } #define check_interface(a, b, c) check_interface_(__LINE__, a, b, c) static void check_interface_(unsigned int line, void *iface_ptr, REFIID iid, BOOL supported) { IUnknown *iface = iface_ptr; HRESULT hr, expected_hr; IUnknown *unk; expected_hr = supported ? S_OK : E_NOINTERFACE; hr = IUnknown_QueryInterface(iface, iid, (void **)&unk); ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x, expected %#x.\n", hr, expected_hr); if (SUCCEEDED(hr)) IUnknown_Release(unk); } static void test_interfaces(void) { IBaseFilter *filter = create_avi_dec(); IPin *pin; check_interface(filter, &IID_IBaseFilter, TRUE); check_interface(filter, &IID_IMediaFilter, TRUE); check_interface(filter, &IID_IPersist, TRUE); check_interface(filter, &IID_IUnknown, TRUE); check_interface(filter, &IID_IAMFilterMiscFlags, FALSE); check_interface(filter, &IID_IBasicAudio, FALSE); check_interface(filter, &IID_IBasicVideo, FALSE); check_interface(filter, &IID_IKsPropertySet, FALSE); check_interface(filter, &IID_IMediaPosition, FALSE); check_interface(filter, &IID_IMediaSeeking, FALSE); check_interface(filter, &IID_IPersistPropertyBag, FALSE); check_interface(filter, &IID_IPin, FALSE); check_interface(filter, &IID_IQualityControl, FALSE); check_interface(filter, &IID_IQualProp, FALSE); check_interface(filter, &IID_IReferenceClock, FALSE); check_interface(filter, &IID_IVideoWindow, FALSE); IBaseFilter_FindPin(filter, L"In", &pin); check_interface(pin, &IID_IMemInputPin, TRUE); check_interface(pin, &IID_IPin, TRUE); todo_wine check_interface(pin, &IID_IQualityControl, TRUE); check_interface(pin, &IID_IUnknown, TRUE); check_interface(pin, &IID_IMediaPosition, FALSE); check_interface(pin, &IID_IMediaSeeking, FALSE); IPin_Release(pin); IBaseFilter_FindPin(filter, L"Out", &pin); check_interface(pin, &IID_IPin, TRUE); todo_wine check_interface(pin, &IID_IMediaPosition, TRUE); check_interface(pin, &IID_IMediaSeeking, TRUE); check_interface(pin, &IID_IQualityControl, TRUE); check_interface(pin, &IID_IUnknown, TRUE); check_interface(pin, &IID_IAsyncReader, FALSE); IPin_Release(pin); IBaseFilter_Release(filter); } static const GUID test_iid = {0x33333333}; static LONG outer_ref = 1; static HRESULT WINAPI outer_QueryInterface(IUnknown *iface, REFIID iid, void **out) { if (IsEqualGUID(iid, &IID_IUnknown) || IsEqualGUID(iid, &IID_IBaseFilter) || IsEqualGUID(iid, &test_iid)) { *out = (IUnknown *)0xdeadbeef; return S_OK; } ok(0, "unexpected call %s\n", wine_dbgstr_guid(iid)); return E_NOINTERFACE; } static ULONG WINAPI outer_AddRef(IUnknown *iface) { return InterlockedIncrement(&outer_ref); } static ULONG WINAPI outer_Release(IUnknown *iface) { return InterlockedDecrement(&outer_ref); } static const IUnknownVtbl outer_vtbl = { outer_QueryInterface, outer_AddRef, outer_Release, }; static IUnknown test_outer = {&outer_vtbl}; static void test_aggregation(void) { IBaseFilter *filter, *filter2; IUnknown *unk, *unk2; HRESULT hr; ULONG ref; filter = (IBaseFilter *)0xdeadbeef; hr = CoCreateInstance(&CLSID_AVIDec, &test_outer, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (void **)&filter); ok(hr == E_NOINTERFACE, "Got hr %#x.\n", hr); ok(!filter, "Got interface %p.\n", filter); hr = CoCreateInstance(&CLSID_AVIDec, &test_outer, CLSCTX_INPROC_SERVER, &IID_IUnknown, (void **)&unk); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(outer_ref == 1, "Got unexpected refcount %d.\n", outer_ref); ok(unk != &test_outer, "Returned IUnknown should not be outer IUnknown.\n"); ref = get_refcount(unk); ok(ref == 1, "Got unexpected refcount %d.\n", ref); ref = IUnknown_AddRef(unk); ok(ref == 2, "Got unexpected refcount %d.\n", ref); ok(outer_ref == 1, "Got unexpected refcount %d.\n", outer_ref); ref = IUnknown_Release(unk); ok(ref == 1, "Got unexpected refcount %d.\n", ref); ok(outer_ref == 1, "Got unexpected refcount %d.\n", outer_ref); hr = IUnknown_QueryInterface(unk, &IID_IUnknown, (void **)&unk2); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(unk2 == unk, "Got unexpected IUnknown %p.\n", unk2); IUnknown_Release(unk2); hr = IUnknown_QueryInterface(unk, &IID_IBaseFilter, (void **)&filter); ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IBaseFilter_QueryInterface(filter, &IID_IUnknown, (void **)&unk2); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(unk2 == (IUnknown *)0xdeadbeef, "Got unexpected IUnknown %p.\n", unk2); hr = IBaseFilter_QueryInterface(filter, &IID_IBaseFilter, (void **)&filter2); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(filter2 == (IBaseFilter *)0xdeadbeef, "Got unexpected IBaseFilter %p.\n", filter2); hr = IUnknown_QueryInterface(unk, &test_iid, (void **)&unk2); ok(hr == E_NOINTERFACE, "Got hr %#x.\n", hr); ok(!unk2, "Got unexpected IUnknown %p.\n", unk2); hr = IBaseFilter_QueryInterface(filter, &test_iid, (void **)&unk2); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(unk2 == (IUnknown *)0xdeadbeef, "Got unexpected IUnknown %p.\n", unk2); IBaseFilter_Release(filter); ref = IUnknown_Release(unk); ok(!ref, "Got unexpected refcount %d.\n", ref); ok(outer_ref == 1, "Got unexpected refcount %d.\n", outer_ref); } static void test_enum_pins(void) { IBaseFilter *filter = create_avi_dec(); IEnumPins *enum1, *enum2; ULONG count, ref; IPin *pins[3]; HRESULT hr; ref = get_refcount(filter); ok(ref == 1, "Got unexpected refcount %d.\n", ref); hr = IBaseFilter_EnumPins(filter, NULL); ok(hr == E_POINTER, "Got hr %#x.\n", hr); hr = IBaseFilter_EnumPins(filter, &enum1); ok(hr == S_OK, "Got hr %#x.\n", hr); ref = get_refcount(filter); ok(ref == 2, "Got unexpected refcount %d.\n", ref); ref = get_refcount(enum1); ok(ref == 1, "Got unexpected refcount %d.\n", ref); hr = IEnumPins_Next(enum1, 1, NULL, NULL); ok(hr == E_POINTER, "Got hr %#x.\n", hr); hr = IEnumPins_Next(enum1, 1, pins, NULL); ok(hr == S_OK, "Got hr %#x.\n", hr); ref = get_refcount(filter); ok(ref == 3, "Got unexpected refcount %d.\n", ref); ref = get_refcount(pins[0]); ok(ref == 3, "Got unexpected refcount %d.\n", ref); ref = get_refcount(enum1); ok(ref == 1, "Got unexpected refcount %d.\n", ref); IPin_Release(pins[0]); ref = get_refcount(filter); ok(ref == 2, "Got unexpected refcount %d.\n", ref); hr = IEnumPins_Next(enum1, 1, pins, NULL); ok(hr == S_OK, "Got hr %#x.\n", hr); ref = get_refcount(filter); ok(ref == 3, "Got unexpected refcount %d.\n", ref); ref = get_refcount(pins[0]); ok(ref == 3, "Got unexpected refcount %d.\n", ref); ref = get_refcount(enum1); ok(ref == 1, "Got unexpected refcount %d.\n", ref); IPin_Release(pins[0]); ref = get_refcount(filter); ok(ref == 2, "Got unexpected refcount %d.\n", ref); hr = IEnumPins_Next(enum1, 1, pins, NULL); ok(hr == S_FALSE, "Got hr %#x.\n", hr); hr = IEnumPins_Reset(enum1); ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IEnumPins_Next(enum1, 1, pins, &count); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(count == 1, "Got count %u.\n", count); IPin_Release(pins[0]); hr = IEnumPins_Next(enum1, 1, pins, &count); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(count == 1, "Got count %u.\n", count); IPin_Release(pins[0]); hr = IEnumPins_Next(enum1, 1, pins, &count); ok(hr == S_FALSE, "Got hr %#x.\n", hr); ok(!count, "Got count %u.\n", count); hr = IEnumPins_Reset(enum1); ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IEnumPins_Next(enum1, 2, pins, NULL); ok(hr == E_INVALIDARG, "Got hr %#x.\n", hr); hr = IEnumPins_Next(enum1, 2, pins, &count); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(count == 2, "Got count %u.\n", count); IPin_Release(pins[0]); IPin_Release(pins[1]); hr = IEnumPins_Next(enum1, 2, pins, &count); ok(hr == S_FALSE, "Got hr %#x.\n", hr); ok(!count, "Got count %u.\n", count); hr = IEnumPins_Reset(enum1); ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IEnumPins_Next(enum1, 3, pins, &count); ok(hr == S_FALSE, "Got hr %#x.\n", hr); ok(count == 2, "Got count %u.\n", count); IPin_Release(pins[0]); IPin_Release(pins[1]); hr = IEnumPins_Reset(enum1); ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IEnumPins_Clone(enum1, &enum2); ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IEnumPins_Skip(enum1, 3); ok(hr == S_FALSE, "Got hr %#x.\n", hr); hr = IEnumPins_Skip(enum1, 2); ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IEnumPins_Skip(enum1, 1); ok(hr == S_FALSE, "Got hr %#x.\n", hr); hr = IEnumPins_Next(enum1, 1, pins, NULL); ok(hr == S_FALSE, "Got hr %#x.\n", hr); hr = IEnumPins_Next(enum2, 1, pins, NULL); ok(hr == S_OK, "Got hr %#x.\n", hr); IPin_Release(pins[0]); IEnumPins_Release(enum2); IEnumPins_Release(enum1); ref = IBaseFilter_Release(filter); ok(!ref, "Got outstanding refcount %d.\n", ref); } static void test_find_pin(void) { IBaseFilter *filter = create_avi_dec(); IEnumPins *enum_pins; IPin *pin, *pin2; HRESULT hr; ULONG ref; hr = IBaseFilter_EnumPins(filter, &enum_pins); ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IBaseFilter_FindPin(filter, L"In", &pin); ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IEnumPins_Next(enum_pins, 1, &pin2, NULL); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(pin == pin2, "Pins didn't match.\n"); IPin_Release(pin); IPin_Release(pin2); hr = IBaseFilter_FindPin(filter, L"Out", &pin); ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IEnumPins_Next(enum_pins, 1, &pin2, NULL); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(pin == pin2, "Pins didn't match.\n"); IPin_Release(pin); IPin_Release(pin2); hr = IBaseFilter_FindPin(filter, L"XForm In", &pin); ok(hr == VFW_E_NOT_FOUND, "Got hr %#x.\n", hr); hr = IBaseFilter_FindPin(filter, L"XForm Out", &pin); ok(hr == VFW_E_NOT_FOUND, "Got hr %#x.\n", hr); hr = IBaseFilter_FindPin(filter, L"input pin", &pin); ok(hr == VFW_E_NOT_FOUND, "Got hr %#x.\n", hr); hr = IBaseFilter_FindPin(filter, L"output pin", &pin); ok(hr == VFW_E_NOT_FOUND, "Got hr %#x.\n", hr); IEnumPins_Release(enum_pins); ref = IBaseFilter_Release(filter); ok(!ref, "Got outstanding refcount %d.\n", ref); } static void test_pin_info(void) { IBaseFilter *filter = create_avi_dec(); PIN_DIRECTION dir; PIN_INFO info; HRESULT hr; WCHAR *id; ULONG ref; IPin *pin; hr = IBaseFilter_FindPin(filter, L"In", &pin); ok(hr == S_OK, "Got hr %#x.\n", hr); ref = get_refcount(filter); ok(ref == 2, "Got unexpected refcount %d.\n", ref); ref = get_refcount(pin); ok(ref == 2, "Got unexpected refcount %d.\n", ref); hr = IPin_QueryPinInfo(pin, &info); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(info.pFilter == filter, "Expected filter %p, got %p.\n", filter, info.pFilter); ok(info.dir == PINDIR_INPUT, "Got direction %d.\n", info.dir); todo_wine ok(!wcscmp(info.achName, L"XForm In"), "Got name %s.\n", wine_dbgstr_w(info.achName)); ref = get_refcount(filter); ok(ref == 3, "Got unexpected refcount %d.\n", ref); ref = get_refcount(pin); ok(ref == 3, "Got unexpected refcount %d.\n", ref); IBaseFilter_Release(info.pFilter); hr = IPin_QueryDirection(pin, &dir); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(dir == PINDIR_INPUT, "Got direction %d.\n", dir); hr = IPin_QueryId(pin, &id); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(!wcscmp(id, L"In"), "Got id %s.\n", wine_dbgstr_w(id)); CoTaskMemFree(id); hr = IPin_QueryInternalConnections(pin, NULL, NULL); ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); IPin_Release(pin); hr = IBaseFilter_FindPin(filter, L"Out", &pin); ok(hr == S_OK, "Got hr %#x.\n", hr); check_interface(pin, &IID_IPin, TRUE); check_interface(pin, &IID_IMediaSeeking, TRUE); hr = IPin_QueryPinInfo(pin, &info); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(info.pFilter == filter, "Expected filter %p, got %p.\n", filter, info.pFilter); ok(info.dir == PINDIR_OUTPUT, "Got direction %d.\n", info.dir); todo_wine ok(!wcscmp(info.achName, L"XForm Out"), "Got name %s.\n", wine_dbgstr_w(info.achName)); IBaseFilter_Release(info.pFilter); hr = IPin_QueryDirection(pin, &dir); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(dir == PINDIR_OUTPUT, "Got direction %d.\n", dir); hr = IPin_QueryId(pin, &id); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(!wcscmp(id, L"Out"), "Got id %s.\n", wine_dbgstr_w(id)); CoTaskMemFree(id); hr = IPin_QueryInternalConnections(pin, NULL, NULL); ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); IPin_Release(pin); ref = IBaseFilter_Release(filter); ok(!ref, "Got outstanding refcount %d.\n", ref); } static void test_media_types(void) { IBaseFilter *filter = create_avi_dec(); AM_MEDIA_TYPE mt = {{0}}, *pmt; VIDEOINFOHEADER vih = {{0}}; IEnumMediaTypes *enummt; HRESULT hr; ULONG ref; IPin *pin; IBaseFilter_FindPin(filter, L"In", &pin); hr = IPin_EnumMediaTypes(pin, &enummt); ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IEnumMediaTypes_Next(enummt, 1, &pmt, NULL); ok(hr == S_FALSE, "Got hr %#x.\n", hr); IEnumMediaTypes_Release(enummt); mt.majortype = MEDIATYPE_Video; mt.subtype = test_subtype; mt.formattype = FORMAT_VideoInfo; mt.cbFormat = sizeof(VIDEOINFOHEADER); mt.pbFormat = (BYTE *)&vih; vih.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); vih.bmiHeader.biCompression = test_handler; vih.bmiHeader.biWidth = 32; vih.bmiHeader.biHeight = 24; vih.bmiHeader.biBitCount = 16; hr = IPin_QueryAccept(pin, &mt); ok(hr == S_OK, "Got hr %#x.\n", hr); vih.bmiHeader.biBitCount = 32; hr = IPin_QueryAccept(pin, &mt); todo_wine ok(hr == S_FALSE, "Got hr %#x.\n", hr); vih.bmiHeader.biBitCount = 16; mt.bFixedSizeSamples = TRUE; mt.bTemporalCompression = TRUE; mt.lSampleSize = 123; hr = IPin_QueryAccept(pin, &mt); ok(hr == S_OK, "Got hr %#x.\n", hr); /* Some versions of quartz check the major type; some do not. */ mt.subtype = MEDIASUBTYPE_NULL; hr = IPin_QueryAccept(pin, &mt); todo_wine ok(hr == S_FALSE, "Got hr %#x.\n", hr); mt.subtype = MEDIASUBTYPE_RGB24; hr = IPin_QueryAccept(pin, &mt); todo_wine ok(hr == S_FALSE, "Got hr %#x.\n", hr); mt.subtype = test_subtype; mt.formattype = GUID_NULL; hr = IPin_QueryAccept(pin, &mt); todo_wine ok(hr == S_FALSE, "Got hr %#x.\n", hr); mt.formattype = FORMAT_None; hr = IPin_QueryAccept(pin, &mt); todo_wine ok(hr == S_FALSE, "Got hr %#x.\n", hr); mt.formattype = FORMAT_VideoInfo; IPin_Release(pin); IBaseFilter_FindPin(filter, L"Out", &pin); hr = IPin_EnumMediaTypes(pin, &enummt); ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IEnumMediaTypes_Next(enummt, 1, &pmt, NULL); ok(hr == S_FALSE, "Got hr %#x.\n", hr); mt.subtype = MEDIASUBTYPE_RGB24; vih.bmiHeader.biCompression = BI_RGB; vih.bmiHeader.biBitCount = 24; vih.bmiHeader.biSizeImage= 32 * 24 * 3; hr = IPin_QueryAccept(pin, &mt); ok(hr == S_FALSE, "Got hr %#x.\n", hr); IEnumMediaTypes_Release(enummt); IPin_Release(pin); ref = IBaseFilter_Release(filter); ok(!ref, "Got outstanding refcount %d.\n", ref); } static void test_enum_media_types(void) { IBaseFilter *filter = create_avi_dec(); IEnumMediaTypes *enum1, *enum2; AM_MEDIA_TYPE *mts[1]; ULONG ref, count; HRESULT hr; IPin *pin; IBaseFilter_FindPin(filter, L"In", &pin); hr = IPin_EnumMediaTypes(pin, &enum1); ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IEnumMediaTypes_Next(enum1, 1, mts, NULL); ok(hr == S_FALSE, "Got hr %#x.\n", hr); hr = IEnumMediaTypes_Next(enum1, 1, mts, &count); ok(hr == S_FALSE, "Got hr %#x.\n", hr); ok(!count, "Got count %u.\n", count); hr = IEnumMediaTypes_Reset(enum1); ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IEnumMediaTypes_Next(enum1, 1, mts, NULL); ok(hr == S_FALSE, "Got hr %#x.\n", hr); hr = IEnumMediaTypes_Clone(enum1, &enum2); ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IEnumMediaTypes_Skip(enum1, 1); ok(hr == S_FALSE, "Got hr %#x.\n", hr); hr = IEnumMediaTypes_Next(enum2, 1, mts, NULL); ok(hr == S_FALSE, "Got hr %#x.\n", hr); IEnumMediaTypes_Release(enum1); IEnumMediaTypes_Release(enum2); IPin_Release(pin); IBaseFilter_FindPin(filter, L"Out", &pin); hr = IPin_EnumMediaTypes(pin, &enum1); ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IEnumMediaTypes_Next(enum1, 1, mts, NULL); ok(hr == S_FALSE, "Got hr %#x.\n", hr); hr = IEnumMediaTypes_Next(enum1, 1, mts, &count); ok(hr == S_FALSE, "Got hr %#x.\n", hr); ok(!count, "Got count %u.\n", count); hr = IEnumMediaTypes_Reset(enum1); ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IEnumMediaTypes_Next(enum1, 1, mts, NULL); ok(hr == S_FALSE, "Got hr %#x.\n", hr); hr = IEnumMediaTypes_Clone(enum1, &enum2); ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IEnumMediaTypes_Skip(enum1, 1); ok(hr == S_FALSE, "Got hr %#x.\n", hr); hr = IEnumMediaTypes_Next(enum2, 1, mts, NULL); ok(hr == S_FALSE, "Got hr %#x.\n", hr); IEnumMediaTypes_Release(enum1); IEnumMediaTypes_Release(enum2); IPin_Release(pin); ref = IBaseFilter_Release(filter); ok(!ref, "Got outstanding refcount %d.\n", ref); } static void test_unconnected_filter_state(void) { IBaseFilter *filter = create_avi_dec(); FILTER_STATE state; HRESULT hr; ULONG ref; hr = IBaseFilter_GetState(filter, 0, &state); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(state == State_Stopped, "Got state %u.\n", state); hr = IBaseFilter_Pause(filter); todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IBaseFilter_GetState(filter, 0, &state); ok(hr == S_OK, "Got hr %#x.\n", hr); todo_wine ok(state == State_Paused, "Got state %u.\n", state); hr = IBaseFilter_Run(filter, 0); todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IBaseFilter_GetState(filter, 0, &state); ok(hr == S_OK, "Got hr %#x.\n", hr); todo_wine ok(state == State_Running, "Got state %u.\n", state); hr = IBaseFilter_Pause(filter); todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IBaseFilter_GetState(filter, 0, &state); ok(hr == S_OK, "Got hr %#x.\n", hr); todo_wine ok(state == State_Paused, "Got state %u.\n", state); hr = IBaseFilter_Stop(filter); ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IBaseFilter_GetState(filter, 0, &state); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(state == State_Stopped, "Got state %u.\n", state); hr = IBaseFilter_Run(filter, 0); todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IBaseFilter_GetState(filter, 0, &state); ok(hr == S_OK, "Got hr %#x.\n", hr); todo_wine ok(state == State_Running, "Got state %u.\n", state); hr = IBaseFilter_Stop(filter); ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IBaseFilter_GetState(filter, 0, &state); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(state == State_Stopped, "Got state %u.\n", state); ref = IBaseFilter_Release(filter); ok(!ref, "Got outstanding refcount %d.\n", ref); } struct testfilter { struct strmbase_filter filter; struct strmbase_source source; struct strmbase_sink sink; const AM_MEDIA_TYPE *mt; }; static inline struct testfilter *impl_from_strmbase_filter(struct strmbase_filter *iface) { return CONTAINING_RECORD(iface, struct testfilter, filter); } static struct strmbase_pin *testfilter_get_pin(struct strmbase_filter *iface, unsigned int index) { struct testfilter *filter = impl_from_strmbase_filter(iface); if (!index) return &filter->source.pin; else if (index == 1) return &filter->sink.pin; return NULL; } static void testfilter_destroy(struct strmbase_filter *iface) { struct testfilter *filter = impl_from_strmbase_filter(iface); strmbase_source_cleanup(&filter->source); strmbase_sink_cleanup(&filter->sink); strmbase_filter_cleanup(&filter->filter); } static const struct strmbase_filter_ops testfilter_ops = { .filter_get_pin = testfilter_get_pin, .filter_destroy = testfilter_destroy, }; static HRESULT testsource_query_accept(struct strmbase_pin *iface, const AM_MEDIA_TYPE *mt) { return S_OK; } static HRESULT WINAPI testsource_DecideAllocator(struct strmbase_source *iface, IMemInputPin *peer, IMemAllocator **allocator) { return S_OK; } static const struct strmbase_source_ops testsource_ops = { .base.pin_query_accept = testsource_query_accept, .base.pin_get_media_type = strmbase_pin_get_media_type, .pfnAttemptConnection = BaseOutputPinImpl_AttemptConnection, .pfnDecideAllocator = testsource_DecideAllocator, }; static HRESULT testsink_query_interface(struct strmbase_pin *iface, REFIID iid, void **out) { struct testfilter *filter = impl_from_strmbase_filter(iface->filter); if (IsEqualGUID(iid, &IID_IMemInputPin)) *out = &filter->sink.IMemInputPin_iface; else return E_NOINTERFACE; IUnknown_AddRef((IUnknown *)*out); return S_OK; } static HRESULT testsink_query_accept(struct strmbase_pin *iface, const AM_MEDIA_TYPE *mt) { struct testfilter *filter = impl_from_strmbase_filter(iface->filter); if (filter->mt && !compare_media_types(mt, filter->mt)) return S_FALSE; return S_OK; } static HRESULT testsink_get_media_type(struct strmbase_pin *iface, unsigned int index, AM_MEDIA_TYPE *mt) { struct testfilter *filter = impl_from_strmbase_filter(iface->filter); if (!index && filter->mt) { CopyMediaType(mt, filter->mt); return S_OK; } return VFW_S_NO_MORE_ITEMS; } static HRESULT WINAPI testsink_Receive(struct strmbase_sink *iface, IMediaSample *sample) { struct testfilter *filter = impl_from_strmbase_filter(iface->pin.filter); Quality q = {Famine, 500, 100 * 10000, 240 * 10000}; IQualityControl *qc; HRESULT hr; IPin_QueryInterface(filter->sink.pin.peer, &IID_IQualityControl, (void **)&qc); hr = IQualityControl_Notify(qc, &filter->filter.IBaseFilter_iface, q); ok(hr == S_OK, "Got hr %#x.\n", hr); IQualityControl_Release(qc); return S_OK; } static const struct strmbase_sink_ops testsink_ops = { .base.pin_query_interface = testsink_query_interface, .base.pin_query_accept = testsink_query_accept, .base.pin_get_media_type = testsink_get_media_type, .pfnReceive = testsink_Receive, }; static void testfilter_init(struct testfilter *filter) { static const GUID clsid = {0xabacab}; memset(filter, 0, sizeof(*filter)); strmbase_filter_init(&filter->filter, NULL, &clsid, &testfilter_ops); strmbase_source_init(&filter->source, &filter->filter, L"source", &testsource_ops); strmbase_sink_init(&filter->sink, &filter->filter, L"sink", &testsink_ops, NULL); } static void test_sink_allocator(IMemInputPin *input) { IMemAllocator *req_allocator, *ret_allocator; ALLOCATOR_PROPERTIES props, ret_props; HRESULT hr; hr = IMemInputPin_GetAllocatorRequirements(input, &props); ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); hr = IMemInputPin_GetAllocator(input, &ret_allocator); todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); if (hr == S_OK) { hr = IMemAllocator_GetProperties(ret_allocator, &props); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(!props.cBuffers, "Got %d buffers.\n", props.cBuffers); ok(!props.cbBuffer, "Got size %d.\n", props.cbBuffer); ok(!props.cbAlign, "Got alignment %d.\n", props.cbAlign); ok(!props.cbPrefix, "Got prefix %d.\n", props.cbPrefix); hr = IMemInputPin_NotifyAllocator(input, ret_allocator, TRUE); ok(hr == S_OK, "Got hr %#x.\n", hr); IMemAllocator_Release(ret_allocator); } hr = IMemInputPin_NotifyAllocator(input, NULL, TRUE); ok(hr == E_POINTER, "Got hr %#x.\n", hr); CoCreateInstance(&CLSID_MemoryAllocator, NULL, CLSCTX_INPROC_SERVER, &IID_IMemAllocator, (void **)&req_allocator); props.cBuffers = 1; props.cbBuffer = 256; props.cbAlign = 1; props.cbPrefix = 0; hr = IMemAllocator_SetProperties(req_allocator, &props, &ret_props); ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IMemInputPin_NotifyAllocator(input, req_allocator, TRUE); ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IMemInputPin_GetAllocator(input, &ret_allocator); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(ret_allocator == req_allocator, "Allocators didn't match.\n"); IMemAllocator_Release(req_allocator); IMemAllocator_Release(ret_allocator); } static void test_connect_pin(void) { VIDEOINFOHEADER req_format = { .bmiHeader.biSize = sizeof(BITMAPINFOHEADER), .bmiHeader.biCompression = test_handler, .bmiHeader.biWidth = 32, .bmiHeader.biHeight = 24, .bmiHeader.biBitCount = 16, }; AM_MEDIA_TYPE req_mt = { .majortype = MEDIATYPE_Video, .subtype = test_subtype, .formattype = FORMAT_VideoInfo, .lSampleSize = 888, .cbFormat = sizeof(req_format), .pbFormat = (BYTE *)&req_format, }; struct testfilter testsource, testsink; IBaseFilter *filter = create_avi_dec(); AM_MEDIA_TYPE mt, source_mt, *pmt; IPin *sink, *source, *peer; IEnumMediaTypes *enummt; IMediaControl *control; IMemInputPin *meminput; IFilterGraph2 *graph; unsigned int i; HRESULT hr; ULONG ref; CoCreateInstance(&CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, &IID_IFilterGraph2, (void **)&graph); testfilter_init(&testsource); testfilter_init(&testsink); IFilterGraph2_AddFilter(graph, &testsink.filter.IBaseFilter_iface, L"sink"); IFilterGraph2_AddFilter(graph, &testsource.filter.IBaseFilter_iface, L"source"); IFilterGraph2_AddFilter(graph, filter, L"AVI decoder"); IBaseFilter_FindPin(filter, L"In", &sink); IBaseFilter_FindPin(filter, L"Out", &source); IPin_QueryInterface(sink, &IID_IMemInputPin, (void **)&meminput); IFilterGraph2_QueryInterface(graph, &IID_IMediaControl, (void **)&control); /* Test sink connection. */ peer = (IPin *)0xdeadbeef; hr = IPin_ConnectedTo(sink, &peer); ok(hr == VFW_E_NOT_CONNECTED, "Got hr %#x.\n", hr); ok(!peer, "Got peer %p.\n", peer); hr = IPin_ConnectionMediaType(sink, &mt); ok(hr == VFW_E_NOT_CONNECTED, "Got hr %#x.\n", hr); req_mt.subtype = MEDIASUBTYPE_RGB24; hr = IFilterGraph2_ConnectDirect(graph, &testsource.source.pin.IPin_iface, sink, &req_mt); ok(hr == VFW_E_TYPE_NOT_ACCEPTED, "Got hr %#x.\n", hr); req_mt.subtype = test_subtype; hr = IFilterGraph2_ConnectDirect(graph, &testsource.source.pin.IPin_iface, sink, &req_mt); ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IPin_ConnectedTo(sink, &peer); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(peer == &testsource.source.pin.IPin_iface, "Got peer %p.\n", peer); IPin_Release(peer); hr = IPin_ConnectionMediaType(sink, &mt); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(compare_media_types(&mt, &req_mt), "Media types didn't match.\n"); ok(compare_media_types(&testsource.source.pin.mt, &req_mt), "Media types didn't match.\n"); sink_bih = req_format.bmiHeader; hr = IPin_EnumMediaTypes(source, &enummt); ok(hr == S_OK, "Got hr %#x.\n", hr); for (i = 0; i < 9; ++i) { static const struct { const GUID *subtype; DWORD compression; WORD bpp; } expect[9] = { {&MEDIASUBTYPE_CLJR, mmioFOURCC('C','L','J','R'), 8}, {&MEDIASUBTYPE_UYVY, mmioFOURCC('U','Y','V','Y'), 16}, {&MEDIASUBTYPE_YUY2, mmioFOURCC('Y','U','Y','2'), 16}, {&MEDIASUBTYPE_RGB32, BI_RGB, 32}, {&MEDIASUBTYPE_RGB24, BI_RGB, 24}, {&MEDIASUBTYPE_RGB565, BI_BITFIELDS, 16}, {&MEDIASUBTYPE_RGB555, BI_RGB, 16}, {&MEDIASUBTYPE_RGB8, BI_RGB, 8}, {&MEDIASUBTYPE_I420, mmioFOURCC('I','4','2','0'), 12}, }; VIDEOINFOHEADER expect_format = { .bmiHeader.biSize = sizeof(BITMAPINFOHEADER), .bmiHeader.biWidth = 32, .bmiHeader.biHeight = 24, .bmiHeader.biBitCount = expect[i].bpp, .bmiHeader.biCompression = expect[i].compression, .bmiHeader.biSizeImage = 32 * 24 * expect[i].bpp / 8, }; AM_MEDIA_TYPE expect_mt = { .majortype = MEDIATYPE_Video, .subtype = *expect[i].subtype, .bFixedSizeSamples = TRUE, .lSampleSize = 32 * 24 * expect[i].bpp / 8, .formattype = FORMAT_VideoInfo, .cbFormat = sizeof(VIDEOINFOHEADER), .pbFormat = (BYTE *)&expect_format, }; hr = IEnumMediaTypes_Next(enummt, 1, &pmt, NULL); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(!memcmp(pmt, &expect_mt, offsetof(AM_MEDIA_TYPE, cbFormat)), "%u: Media types didn't match.\n", i); ok(!memcmp(pmt->pbFormat, &expect_format, sizeof(VIDEOINFOHEADER)), "%u: Format blocks didn't match.\n", i); if (i == 5) { const VIDEOINFO *format = (VIDEOINFO *)pmt->pbFormat; ok(pmt->cbFormat == offsetof(VIDEOINFO, dwBitMasks[3]), "Got format size %u.\n", pmt->cbFormat); ok(format->dwBitMasks[iRED] == 0xf800, "Got red bit mask %#x.\n", format->dwBitMasks[iRED]); ok(format->dwBitMasks[iGREEN] == 0x07e0, "Got green bit mask %#x.\n", format->dwBitMasks[iGREEN]); ok(format->dwBitMasks[iBLUE] == 0x001f, "Got blue bit mask %#x.\n", format->dwBitMasks[iBLUE]); } hr = IPin_QueryAccept(source, pmt); ok(hr == (i == 8 ? S_OK : S_FALSE), "Got hr %#x.\n", hr); if (i == 8) CopyMediaType(&source_mt, pmt); DeleteMediaType(pmt); } hr = IEnumMediaTypes_Next(enummt, 1, &pmt, NULL); ok(hr == S_FALSE, "Got hr %#x.\n", hr); IEnumMediaTypes_Release(enummt); test_sink_allocator(meminput); /* Test source connection. */ peer = (IPin *)0xdeadbeef; hr = IPin_ConnectedTo(source, &peer); ok(hr == VFW_E_NOT_CONNECTED, "Got hr %#x.\n", hr); ok(!peer, "Got peer %p.\n", peer); hr = IPin_ConnectionMediaType(source, &mt); ok(hr == VFW_E_NOT_CONNECTED, "Got hr %#x.\n", hr); /* Exact connection. */ CopyMediaType(&req_mt, &source_mt); hr = IFilterGraph2_ConnectDirect(graph, source, &testsink.sink.pin.IPin_iface, &req_mt); ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IPin_ConnectedTo(source, &peer); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(peer == &testsink.sink.pin.IPin_iface, "Got peer %p.\n", peer); IPin_Release(peer); hr = IPin_ConnectionMediaType(source, &mt); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(compare_media_types(&mt, &req_mt), "Media types didn't match.\n"); ok(compare_media_types(&testsink.sink.pin.mt, &req_mt), "Media types didn't match.\n"); hr = IFilterGraph2_Disconnect(graph, source); ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IFilterGraph2_Disconnect(graph, source); ok(hr == S_FALSE, "Got hr %#x.\n", hr); ok(testsink.sink.pin.peer == source, "Got peer %p.\n", testsink.sink.pin.peer); IFilterGraph2_Disconnect(graph, &testsink.sink.pin.IPin_iface); req_mt.lSampleSize = 999; req_mt.bTemporalCompression = req_mt.bFixedSizeSamples = TRUE; hr = IFilterGraph2_ConnectDirect(graph, source, &testsink.sink.pin.IPin_iface, &req_mt); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(compare_media_types(&testsink.sink.pin.mt, &req_mt), "Media types didn't match.\n"); IFilterGraph2_Disconnect(graph, source); IFilterGraph2_Disconnect(graph, &testsink.sink.pin.IPin_iface); req_mt.formattype = FORMAT_None; hr = IFilterGraph2_ConnectDirect(graph, source, &testsink.sink.pin.IPin_iface, &req_mt); ok(hr == VFW_E_TYPE_NOT_ACCEPTED, "Got hr %#x.\n", hr); req_mt.formattype = FORMAT_VideoInfo; /* Connection with wildcards. */ hr = IFilterGraph2_ConnectDirect(graph, source, &testsink.sink.pin.IPin_iface, NULL); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(compare_media_types(&testsink.sink.pin.mt, &source_mt), "Media types didn't match.\n"); IFilterGraph2_Disconnect(graph, source); IFilterGraph2_Disconnect(graph, &testsink.sink.pin.IPin_iface); req_mt.majortype = GUID_NULL; hr = IFilterGraph2_ConnectDirect(graph, source, &testsink.sink.pin.IPin_iface, &req_mt); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(compare_media_types(&testsink.sink.pin.mt, &source_mt), "Media types didn't match.\n"); IFilterGraph2_Disconnect(graph, source); IFilterGraph2_Disconnect(graph, &testsink.sink.pin.IPin_iface); req_mt.subtype = MEDIASUBTYPE_RGB32; hr = IFilterGraph2_ConnectDirect(graph, source, &testsink.sink.pin.IPin_iface, &req_mt); ok(hr == VFW_E_NO_ACCEPTABLE_TYPES, "Got hr %#x.\n", hr); req_mt.subtype = GUID_NULL; hr = IFilterGraph2_ConnectDirect(graph, source, &testsink.sink.pin.IPin_iface, &req_mt); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(compare_media_types(&testsink.sink.pin.mt, &source_mt), "Media types didn't match.\n"); IFilterGraph2_Disconnect(graph, source); IFilterGraph2_Disconnect(graph, &testsink.sink.pin.IPin_iface); req_mt.formattype = FORMAT_None; hr = IFilterGraph2_ConnectDirect(graph, source, &testsink.sink.pin.IPin_iface, &req_mt); ok(hr == VFW_E_NO_ACCEPTABLE_TYPES, "Got hr %#x.\n", hr); req_mt.majortype = MEDIATYPE_Video; req_mt.subtype = MEDIASUBTYPE_I420; req_mt.formattype = GUID_NULL; hr = IFilterGraph2_ConnectDirect(graph, source, &testsink.sink.pin.IPin_iface, &req_mt); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(compare_media_types(&testsink.sink.pin.mt, &source_mt), "Media types didn't match.\n"); IFilterGraph2_Disconnect(graph, source); IFilterGraph2_Disconnect(graph, &testsink.sink.pin.IPin_iface); req_mt.subtype = MEDIASUBTYPE_RGB32; hr = IFilterGraph2_ConnectDirect(graph, source, &testsink.sink.pin.IPin_iface, &req_mt); ok(hr == VFW_E_NO_ACCEPTABLE_TYPES, "Got hr %#x.\n", hr); req_mt.subtype = GUID_NULL; hr = IFilterGraph2_ConnectDirect(graph, source, &testsink.sink.pin.IPin_iface, &req_mt); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(compare_media_types(&testsink.sink.pin.mt, &source_mt), "Media types didn't match.\n"); IFilterGraph2_Disconnect(graph, source); IFilterGraph2_Disconnect(graph, &testsink.sink.pin.IPin_iface); req_mt.majortype = MEDIATYPE_Audio; hr = IFilterGraph2_ConnectDirect(graph, source, &testsink.sink.pin.IPin_iface, &req_mt); ok(hr == VFW_E_NO_ACCEPTABLE_TYPES, "Got hr %#x.\n", hr); /* Our sink's proposed media type is sort of broken, but Windows 8+ returns * VFW_E_INVALIDMEDIATYPE for even perfectly reasonable ones. */ testsink.mt = &req_mt; hr = IFilterGraph2_ConnectDirect(graph, source, &testsink.sink.pin.IPin_iface, NULL); ok(hr == VFW_E_NO_ACCEPTABLE_TYPES || broken(hr == VFW_E_INVALIDMEDIATYPE) /* Win8+ */, "Got hr %#x.\n", hr); req_mt.majortype = MEDIATYPE_Video; req_mt.subtype = MEDIASUBTYPE_I420; req_mt.formattype = FORMAT_VideoInfo; hr = IFilterGraph2_ConnectDirect(graph, source, &testsink.sink.pin.IPin_iface, NULL); ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IFilterGraph2_Disconnect(graph, sink); ok(hr == S_OK, "Got hr %#x.\n", hr); hr = IFilterGraph2_Disconnect(graph, sink); ok(hr == S_FALSE, "Got hr %#x.\n", hr); ok(testsource.source.pin.peer == sink, "Got peer %p.\n", testsource.source.pin.peer); IFilterGraph2_Disconnect(graph, &testsource.source.pin.IPin_iface); IMemInputPin_Release(meminput); IPin_Release(sink); IPin_Release(source); IMediaControl_Release(control); ref = IFilterGraph2_Release(graph); ok(!ref, "Got outstanding refcount %d.\n", ref); ref = IBaseFilter_Release(filter); ok(!ref, "Got outstanding refcount %d.\n", ref); ref = IBaseFilter_Release(&testsource.filter.IBaseFilter_iface); ok(!ref, "Got outstanding refcount %d.\n", ref); ref = IBaseFilter_Release(&testsink.filter.IBaseFilter_iface); ok(!ref, "Got outstanding refcount %d.\n", ref); } START_TEST(avidec) { BOOL ret; ret = ICInstall(ICTYPE_VIDEO, test_handler, (LPARAM)vfw_driver_proc, NULL, ICINSTALL_FUNCTION); ok(ret, "Failed to install driver.\n"); CoInitialize(NULL); test_interfaces(); test_aggregation(); test_enum_pins(); test_find_pin(); test_pin_info(); test_media_types(); test_enum_media_types(); test_unconnected_filter_state(); test_connect_pin(); CoUninitialize(); ret = ICRemove(ICTYPE_VIDEO, test_handler, 0); ok(ret, "Failed to remove driver.\n"); }