From: R��mi Bernon rbernon@codeweavers.com
--- dlls/qasf/tests/asfreader.c | 373 ++++++++++++++++++++++++++++++++++++ 1 file changed, 373 insertions(+)
diff --git a/dlls/qasf/tests/asfreader.c b/dlls/qasf/tests/asfreader.c index d8276ba1951..258838937ae 100644 --- a/dlls/qasf/tests/asfreader.c +++ b/dlls/qasf/tests/asfreader.c @@ -606,6 +606,377 @@ static void test_filter_state(void) ok(!ref, "Got ref %ld.\n", ref); }
+struct test_sink +{ + struct strmbase_sink sink; + + DWORD receive_tid; + HANDLE receive_event; + BOOL receive_can_block; + IMemAllocator *allocator; +}; + +static inline struct test_sink *impl_from_IMemInputPin(IMemInputPin *iface) +{ + return CONTAINING_RECORD(iface, struct test_sink, sink.IMemInputPin_iface); +} + +static HRESULT WINAPI test_mem_input_pin_QueryInterface(IMemInputPin *iface, REFIID iid, void **out) +{ + struct test_sink *pin = impl_from_IMemInputPin(iface); + return IPin_QueryInterface(&pin->sink.pin.IPin_iface, iid, out); +} + +static ULONG WINAPI test_mem_input_pin_AddRef(IMemInputPin *iface) +{ + struct test_sink *pin = impl_from_IMemInputPin(iface); + return IPin_AddRef(&pin->sink.pin.IPin_iface); +} + +static ULONG WINAPI test_mem_input_pin_Release(IMemInputPin *iface) +{ + struct test_sink *pin = impl_from_IMemInputPin(iface); + return IPin_Release(&pin->sink.pin.IPin_iface); +} + +static HRESULT WINAPI test_mem_input_pin_GetAllocator(IMemInputPin *iface, + IMemAllocator **allocator) +{ + struct test_sink *pin = impl_from_IMemInputPin(iface); + if (!pin->allocator) + return VFW_E_NO_ALLOCATOR; + IMemAllocator_AddRef((*allocator = pin->allocator)); + return S_OK; +} + +static HRESULT WINAPI test_mem_input_pin_NotifyAllocator(IMemInputPin *iface, + IMemAllocator *allocator, BOOL read_only) +{ + struct test_sink *pin = impl_from_IMemInputPin(iface); + IMemAllocator_AddRef((pin->allocator = allocator)); + return S_OK; +} + +static HRESULT WINAPI test_mem_input_pin_GetAllocatorRequirements(IMemInputPin *iface, + ALLOCATOR_PROPERTIES *props) +{ + memset(props, 0, sizeof(*props)); + return S_OK; +} + +static HRESULT WINAPI test_mem_input_pin_Receive(IMemInputPin *iface, + IMediaSample *sample) +{ + struct test_sink *pin = impl_from_IMemInputPin(iface); + + pin->receive_tid = GetCurrentThreadId(); + SetEvent(pin->receive_event); + + todo_wine + ok(0, "Unexpected call.\n"); + + return S_OK; +} + +static HRESULT WINAPI test_mem_input_pin_ReceiveMultiple(IMemInputPin *iface, + IMediaSample **samples, LONG count, LONG *processed) +{ + struct test_sink *pin = impl_from_IMemInputPin(iface); + + pin->receive_tid = GetCurrentThreadId(); + SetEvent(pin->receive_event); + + *processed = count; + return S_OK; +} + +static HRESULT WINAPI test_mem_input_pin_ReceiveCanBlock(IMemInputPin *iface) +{ + struct test_sink *pin = impl_from_IMemInputPin(iface); + return pin->receive_can_block ? S_OK : S_FALSE; +} + +static const IMemInputPinVtbl test_mem_input_pin_vtbl = +{ + test_mem_input_pin_QueryInterface, + test_mem_input_pin_AddRef, + test_mem_input_pin_Release, + test_mem_input_pin_GetAllocator, + test_mem_input_pin_NotifyAllocator, + test_mem_input_pin_GetAllocatorRequirements, + test_mem_input_pin_Receive, + test_mem_input_pin_ReceiveMultiple, + test_mem_input_pin_ReceiveCanBlock, +}; + +struct test_filter +{ + struct strmbase_filter filter; + struct test_sink video; + struct test_sink audio; +}; + +static inline struct test_filter *impl_from_strmbase_filter(struct strmbase_filter *iface) +{ + return CONTAINING_RECORD(iface, struct test_filter, filter); +} + +static inline struct strmbase_sink *impl_from_strmbase_pin(struct strmbase_pin *iface) +{ + return CONTAINING_RECORD(iface, struct strmbase_sink, pin); +} + +static struct strmbase_pin *test_filter_get_pin(struct strmbase_filter *iface, unsigned int index) +{ + struct test_filter *filter = impl_from_strmbase_filter(iface); + if (index == 0) + return &filter->video.sink.pin; + if (index == 1) + return &filter->audio.sink.pin; + return NULL; +} + +static void test_filter_destroy(struct strmbase_filter *iface) +{ + struct test_filter *filter = impl_from_strmbase_filter(iface); + strmbase_sink_cleanup(&filter->audio.sink); + strmbase_sink_cleanup(&filter->video.sink); + strmbase_filter_cleanup(&filter->filter); +} + +static const struct strmbase_filter_ops test_filter_ops = +{ + .filter_get_pin = test_filter_get_pin, + .filter_destroy = test_filter_destroy, +}; + +static HRESULT test_sink_query_interface(struct strmbase_pin *iface, REFIID iid, void **out) +{ + struct strmbase_sink *sink = impl_from_strmbase_pin(iface); + + if (IsEqualGUID(iid, &IID_IMemInputPin)) + *out = &sink->IMemInputPin_iface; + else + return E_NOINTERFACE; + + IUnknown_AddRef((IUnknown *)*out); + return S_OK; +} + +static const struct strmbase_sink_ops test_sink_ops = +{ + .base.pin_query_interface = test_sink_query_interface, +}; + +static void test_filter_init(struct test_filter *filter) +{ + static const GUID clsid = {0xabacab}; + memset(filter, 0, sizeof(*filter)); + strmbase_filter_init(&filter->filter, NULL, &clsid, &test_filter_ops); + strmbase_sink_init(&filter->video.sink, &filter->filter, L"Video", &test_sink_ops, NULL); + filter->video.sink.IMemInputPin_iface.lpVtbl = &test_mem_input_pin_vtbl; + strmbase_sink_init(&filter->audio.sink, &filter->filter, L"Audio", &test_sink_ops, NULL); + filter->audio.sink.IMemInputPin_iface.lpVtbl = &test_mem_input_pin_vtbl; +} + +static void test_threading(BOOL receive_can_block) +{ + static const WAVEFORMATEX pcm_format = + { + .wFormatTag = WAVE_FORMAT_MSAUDIO1, + .nChannels = 1, + .nSamplesPerSec = 44100, + .nBlockAlign = 2, + .nAvgBytesPerSec = 88200, + .wBitsPerSample = 16, + .cbSize = 0, + }; + static const VIDEOINFOHEADER nv12_info = + { + .rcSource = {0, 0, 64, 48}, + .rcTarget = {0, 0, 64, 48}, + .bmiHeader = + { + .biSize = sizeof(BITMAPINFOHEADER), + .biWidth = 64, + .biHeight = 48, + .biPlanes = 1, + .biBitCount = 12, + .biCompression = MAKEFOURCC('N','V','1','2'), + .biSizeImage = 64 * 48 * 3 / 2, + }, + }; + static const MSAUDIO1WAVEFORMAT msaudio1_format = + { + .wfx.wFormatTag = WAVE_FORMAT_MSAUDIO1, + .wfx.nChannels = 1, + .wfx.nSamplesPerSec = 44100, + .wfx.nBlockAlign = 743, + .wfx.nAvgBytesPerSec = 16000, + .wfx.wBitsPerSample = 16, + .wfx.cbSize = sizeof(MSAUDIO1WAVEFORMAT) - sizeof(WAVEFORMATEX), + .wEncodeOptions = 1, + }; + static const VIDEOINFOHEADER2 wmv1_info2 = + { + .rcSource = {0, 0, 64, 48}, + .rcTarget = {0, 0, 64, 48}, + .dwBitRate = 189464, + .dwPictAspectRatioX = 64, + .dwPictAspectRatioY = 48, + .bmiHeader = + { + .biSize = sizeof(BITMAPINFOHEADER), + .biWidth = 64, + .biHeight = 48, + .biPlanes = 1, + .biBitCount = 24, + .biCompression = MAKEFOURCC('W','M','V','1'), + .biSizeImage = 64 * 48 * 3, + }, + }; + AM_MEDIA_TYPE audio_mt = + { + .majortype = MEDIATYPE_Audio, + .subtype = MEDIASUBTYPE_MSAUDIO1, + .bFixedSizeSamples = TRUE, + .lSampleSize = 743, + .formattype = FORMAT_WaveFormatEx, + .cbFormat = sizeof(MSAUDIO1WAVEFORMAT), + .pbFormat = (BYTE *)&msaudio1_format, + }; + AM_MEDIA_TYPE video_mt = + { + .majortype = MEDIATYPE_Video, + .subtype = WMMEDIASUBTYPE_WMV1, + .formattype = FORMAT_VideoInfo2, + .bTemporalCompression = TRUE, + .cbFormat = sizeof(VIDEOINFOHEADER2), + .pbFormat = (BYTE *)&wmv1_info2, + }; + AM_MEDIA_TYPE wine_audio_mt = + { + .majortype = MEDIATYPE_Audio, + .subtype = MEDIASUBTYPE_PCM, + .bFixedSizeSamples = TRUE, + .formattype = FORMAT_WaveFormatEx, + .cbFormat = sizeof(WAVEFORMATEX), + .pbFormat = (BYTE *)&pcm_format, + }; + AM_MEDIA_TYPE wine_video_mt = + { + .majortype = MEDIATYPE_Video, + .subtype = MEDIASUBTYPE_NV12, + .formattype = FORMAT_VideoInfo, + .bTemporalCompression = TRUE, + .cbFormat = sizeof(VIDEOINFOHEADER), + .pbFormat = (BYTE *)&nv12_info, + }; + + const WCHAR *filename = load_resource(L"test.wmv"); + IBaseFilter *filter = create_asf_reader(); + IFileSourceFilter *file_source; + struct test_filter test_sink; + IFilterGraph *graph; + FILTER_STATE state; + HRESULT hr; + IPin *pin; + DWORD ret; + ULONG ref; + + winetest_push_context("blocking %u", !!receive_can_block); + + test_filter_init(&test_sink); + + test_sink.video.receive_event = CreateEventW(NULL, FALSE, FALSE, NULL); + ok(!!test_sink.video.receive_event, "CreateEventW failed, error %lu\n", GetLastError()); + test_sink.audio.receive_event = CreateEventW(NULL, FALSE, FALSE, NULL); + ok(!!test_sink.audio.receive_event, "CreateEventW failed, error %lu\n", GetLastError()); + + test_sink.video.receive_can_block = receive_can_block; + test_sink.audio.receive_can_block = receive_can_block; + + hr = IBaseFilter_QueryInterface(filter, &IID_IFileSourceFilter, (void **)&file_source); + ok(hr == S_OK, "Got hr %#lx.\n", hr); + hr = IFileSourceFilter_Load(file_source, filename, NULL); + ok(hr == S_OK, "Got hr %#lx.\n", hr); + IFileSourceFilter_Release(file_source); + + hr = CoCreateInstance(&CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, + &IID_IFilterGraph, (void **)&graph); + ok(hr == S_OK, "Got hr %#lx.\n", hr); + hr = IFilterGraph_AddFilter(graph, filter, NULL); + ok(hr == S_OK, "Got hr %#lx.\n", hr); + IFilterGraph_Release(graph); + + hr = IBaseFilter_FindPin(filter, L"Raw Video 0", &pin); + ok(hr == S_OK, "Got hr %#lx.\n", hr); + hr = IPin_Connect(pin, &test_sink.video.sink.pin.IPin_iface, &video_mt); + todo_wine + ok(hr == S_OK, "Got hr %#lx.\n", hr); + if (hr != S_OK) + { + hr = IPin_Connect(pin, &test_sink.video.sink.pin.IPin_iface, &wine_video_mt); + ok(hr == S_OK, "Got hr %#lx.\n", hr); + } + IPin_Release(pin); + + hr = IBaseFilter_FindPin(filter, L"Raw Audio 1", &pin); + ok(hr == S_OK, "Got hr %#lx.\n", hr); + hr = IPin_Connect(pin, &test_sink.audio.sink.pin.IPin_iface, &audio_mt); + todo_wine + ok(hr == S_OK, "Got hr %#lx.\n", hr); + if (hr != S_OK) + { + hr = IPin_Connect(pin, &test_sink.audio.sink.pin.IPin_iface, &wine_audio_mt); + ok(hr == S_OK, "Got hr %#lx.\n", hr); + } + IPin_Release(pin); + + hr = IBaseFilter_Run(filter, GetTickCount() * 10000); + ok(hr == S_OK, "Got hr %#lx.\n", hr); + hr = IBaseFilter_GetState(filter, 0, &state); + ok(hr == S_OK, "Got hr %#lx.\n", hr); + ok(state == State_Running, "Got state %#x.\n", state); + + ret = WaitForSingleObject(test_sink.video.receive_event, 500); + ok(!ret, "Wait timed out.\n"); + ret = WaitForSingleObject(test_sink.audio.receive_event, 500); + ok(!ret, "Wait timed out.\n"); + + ok(test_sink.video.receive_tid != GetCurrentThreadId(), "got wrong thread\n"); + ok(test_sink.audio.receive_tid != GetCurrentThreadId(), "got wrong thread\n"); + if (receive_can_block) + { + todo_wine + ok(test_sink.audio.receive_tid != test_sink.video.receive_tid, "got wrong thread\n"); + } + else + ok(test_sink.audio.receive_tid == test_sink.video.receive_tid, "got wrong thread\n"); + + hr = IBaseFilter_Stop(filter); + ok(hr == S_OK, "Got hr %#lx.\n", hr); + hr = IBaseFilter_GetState(filter, 0, &state); + ok(hr == S_OK, "Got hr %#lx.\n", hr); + ok(state == State_Stopped, "Got state %#x.\n", state); + + ref = IBaseFilter_Release(filter); + ok(!ref, "Got ref %ld.\n", ref); + + if (test_sink.video.allocator) + IMemAllocator_Release(test_sink.video.allocator); + if (test_sink.audio.allocator) + IMemAllocator_Release(test_sink.audio.allocator); + + CloseHandle(test_sink.video.receive_event); + CloseHandle(test_sink.audio.receive_event); + + ref = IBaseFilter_Release(&test_sink.filter.IBaseFilter_iface); + ok(!ref, "Got outstanding refcount %ld.\n", ref); + + winetest_pop_context(); +} + START_TEST(asfreader) { CoInitializeEx(NULL, COINIT_MULTITHREADED); @@ -614,6 +985,8 @@ START_TEST(asfreader) test_aggregation(); test_filesourcefilter(); test_filter_state(); + test_threading(FALSE); + test_threading(TRUE);
CoUninitialize(); }