| /* |
| * Unit tests for the avi splitter functions |
| * |
| * Copyright (C) 2007 Google (Lei Zhang) |
| * Copyright (C) 2008 Google (Maarten Lankhorst) |
| * |
| * 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 "wine/test.h" |
| #include "dshow.h" |
| #include "tlhelp32.h" |
| |
| static HANDLE (WINAPI *pCreateToolhelp32Snapshot)(DWORD, DWORD); |
| static BOOL (WINAPI *pThread32First)(HANDLE, LPTHREADENTRY32); |
| static BOOL (WINAPI *pThread32Next)(HANDLE, LPTHREADENTRY32); |
| |
| static IUnknown *pAviSplitter = NULL; |
| |
| static int count_threads(void) |
| { |
| THREADENTRY32 te; |
| int threads; |
| HANDLE h; |
| |
| h = pCreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0); |
| te.dwSize = sizeof(te); |
| |
| if (h == INVALID_HANDLE_VALUE) |
| return -1; |
| |
| pThread32First(h, &te); |
| if (te.th32OwnerProcessID == GetCurrentProcessId()) |
| threads = 1; |
| else |
| threads = 0; |
| |
| while (pThread32Next(h, &te)) |
| if (te.th32OwnerProcessID == GetCurrentProcessId()) |
| ++threads; |
| |
| CloseHandle(h); |
| return threads; |
| } |
| |
| static BOOL create_avisplitter(void) |
| { |
| HRESULT hr; |
| |
| hr = CoCreateInstance(&CLSID_AviSplitter, NULL, CLSCTX_INPROC_SERVER, |
| &IID_IUnknown, (LPVOID*)&pAviSplitter); |
| return (hr == S_OK && pAviSplitter != NULL); |
| } |
| |
| static void release_avisplitter(void) |
| { |
| HRESULT hr; |
| |
| Sleep(1000); |
| hr = IUnknown_Release(pAviSplitter); |
| |
| /* Looks like wine has a reference leak somewhere on test_threads tests, |
| * it passes in windows |
| */ |
| ok(hr == 0, "IUnknown_Release failed with %d\n", (INT)hr); |
| |
| while (hr > 0) |
| hr = IUnknown_Release(pAviSplitter); |
| pAviSplitter = NULL; |
| } |
| |
| static void test_query_interface(void) |
| { |
| HRESULT hr; |
| ULONG ref; |
| IUnknown *iface= NULL; |
| |
| #define TEST_INTERFACE(riid,expected) do { \ |
| hr = IUnknown_QueryInterface(pAviSplitter, &riid, (void**)&iface); \ |
| ok( hr == expected, #riid" should %s got %08X\n", expected==S_OK ? "exist" : "not be present", GetLastError() ); \ |
| if (hr == S_OK) { \ |
| ref = IUnknown_Release(iface); \ |
| ok(ref == 1, "Reference is %u, expected 1\n", ref); \ |
| } \ |
| iface = NULL; \ |
| } while(0) |
| |
| TEST_INTERFACE(IID_IBaseFilter,S_OK); |
| TEST_INTERFACE(IID_IMediaSeeking,E_NOINTERFACE); |
| TEST_INTERFACE(IID_IKsPropertySet,E_NOINTERFACE); |
| TEST_INTERFACE(IID_IMediaPosition,E_NOINTERFACE); |
| TEST_INTERFACE(IID_IQualityControl,E_NOINTERFACE); |
| TEST_INTERFACE(IID_IQualProp,E_NOINTERFACE); |
| #undef TEST_INTERFACE |
| } |
| |
| static void test_pin(IPin *pin) |
| { |
| IMemInputPin *mpin = NULL; |
| |
| IPin_QueryInterface(pin, &IID_IMemInputPin, (void **)&mpin); |
| |
| ok(mpin == NULL, "IMemInputPin found!\n"); |
| if (mpin) |
| IMemInputPin_Release(mpin); |
| /* TODO */ |
| } |
| |
| static void test_basefilter(void) |
| { |
| IEnumPins *pin_enum = NULL; |
| IBaseFilter *base = NULL; |
| IPin *pins[2]; |
| ULONG ref; |
| HRESULT hr; |
| |
| IUnknown_QueryInterface(pAviSplitter, &IID_IBaseFilter, (void **)&base); |
| if (base == NULL) |
| { |
| /* test_query_interface handles this case */ |
| skip("No IBaseFilter\n"); |
| return; |
| } |
| |
| hr = IBaseFilter_EnumPins(base, NULL); |
| ok(hr == E_POINTER, "hr = %08x and not E_POINTER\n", hr); |
| |
| hr= IBaseFilter_EnumPins(base, &pin_enum); |
| ok(hr == S_OK, "hr = %08x and not S_OK\n", hr); |
| |
| hr = IEnumPins_Next(pin_enum, 1, NULL, NULL); |
| ok(hr == E_POINTER, "hr = %08x and not E_POINTER\n", hr); |
| |
| hr = IEnumPins_Next(pin_enum, 2, pins, NULL); |
| ok(hr == E_INVALIDARG, "hr = %08x and not E_INVALIDARG\n", hr); |
| |
| pins[0] = (void *)0xdead; |
| pins[1] = (void *)0xdeed; |
| |
| hr = IEnumPins_Next(pin_enum, 2, pins, &ref); |
| ok(hr == S_FALSE, "hr = %08x instead of S_FALSE\n", hr); |
| ok(pins[0] != (void *)0xdead && pins[0] != NULL, |
| "pins[0] = %p\n", pins[0]); |
| if (pins[0] != (void *)0xdead && pins[0] != NULL) |
| { |
| test_pin(pins[0]); |
| IPin_Release(pins[0]); |
| } |
| |
| ok(pins[1] == (void *)0xdeed, "pins[1] = %p\n", pins[1]); |
| |
| ref = IEnumPins_Release(pin_enum); |
| ok(ref == 0, "ref is %u and not 0!\n", ref); |
| |
| IBaseFilter_Release(base); |
| } |
| |
| static void test_filesourcefilter(void) |
| { |
| static const WCHAR prefix[] = {'w','i','n',0}; |
| static const struct |
| { |
| const char *label; |
| const char *data; |
| DWORD size; |
| const GUID *subtype; |
| } |
| tests[] = |
| { |
| { |
| "AVI", |
| "\x52\x49\x46\x46xxxx\x41\x56\x49\x20", |
| 12, |
| &MEDIASUBTYPE_Avi, |
| }, |
| { |
| "MPEG1 System", |
| "\x00\x00\x01\xBA\x21\x00\x01\x00\x01\x80\x00\x01\x00\x00\x01\xBB", |
| 16, |
| &MEDIASUBTYPE_MPEG1System, |
| }, |
| { |
| "MPEG1 Video", |
| "\x00\x00\x01\xB3", |
| 4, |
| &MEDIASUBTYPE_MPEG1Video, |
| }, |
| { |
| "MPEG1 Audio", |
| "\xFF\xE0", |
| 2, |
| &MEDIASUBTYPE_MPEG1Audio, |
| }, |
| { |
| "MPEG2 Program", |
| "\x00\x00\x01\xBA\x40", |
| 5, |
| &MEDIASUBTYPE_MPEG2_PROGRAM, |
| }, |
| { |
| "WAVE", |
| "\x52\x49\x46\x46xxxx\x57\x41\x56\x45", |
| 12, |
| &MEDIASUBTYPE_WAVE, |
| }, |
| { |
| "unknown format", |
| "Hello World", |
| 11, |
| NULL, /* FIXME: should be &MEDIASUBTYPE_NULL */ |
| }, |
| }; |
| WCHAR path[MAX_PATH], temp[MAX_PATH]; |
| IFileSourceFilter *filesource; |
| DWORD ret, written; |
| IBaseFilter *base; |
| AM_MEDIA_TYPE mt; |
| OLECHAR *olepath; |
| BOOL success; |
| HANDLE file; |
| HRESULT hr; |
| int i; |
| |
| ret = GetTempPathW(MAX_PATH, temp); |
| ok(ret, "GetTempPathW failed with error %u\n", GetLastError()); |
| ret = GetTempFileNameW(temp, prefix, 0, path); |
| ok(ret, "GetTempFileNameW failed with error %u\n", GetLastError()); |
| |
| for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++) |
| { |
| trace("Running test for %s\n", tests[i].label); |
| |
| file = CreateFileW(path, GENERIC_READ | GENERIC_WRITE, 0, NULL, |
| CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); |
| ok(file != INVALID_HANDLE_VALUE, "CreateFileW failed with error %u\n", GetLastError()); |
| success = WriteFile(file, tests[i].data, tests[i].size, &written, NULL); |
| ok(success, "WriteFile failed with error %u\n", GetLastError()); |
| ok(written == tests[i].size, "could not write test data\n"); |
| CloseHandle(file); |
| |
| hr = CoCreateInstance(&CLSID_AsyncReader, NULL, CLSCTX_INPROC_SERVER, |
| &IID_IBaseFilter, (void **)&base); |
| ok(hr == S_OK, "CoCreateInstance failed with %08x\n", hr); |
| hr = IBaseFilter_QueryInterface(base, &IID_IFileSourceFilter, (void **)&filesource); |
| ok(hr == S_OK, "IBaseFilter_QueryInterface failed with %08x\n", hr); |
| |
| olepath = (void *)0xdeadbeef; |
| hr = IFileSourceFilter_GetCurFile(filesource, &olepath, NULL); |
| ok(hr == S_OK, "expected S_OK, got %08x\n", hr); |
| ok(olepath == NULL, "expected NULL, got %p\n", olepath); |
| |
| hr = IFileSourceFilter_Load(filesource, NULL, NULL); |
| ok(hr == E_POINTER, "expected E_POINTER, got %08x\n", hr); |
| |
| hr = IFileSourceFilter_Load(filesource, path, NULL); |
| ok(hr == S_OK, "IFileSourceFilter_Load failed with %08x\n", hr); |
| |
| hr = IFileSourceFilter_GetCurFile(filesource, NULL, &mt); |
| ok(hr == E_POINTER, "expected E_POINTER, got %08x\n", hr); |
| |
| olepath = NULL; |
| hr = IFileSourceFilter_GetCurFile(filesource, &olepath, NULL); |
| ok(hr == S_OK, "expected S_OK, got %08x\n", hr); |
| CoTaskMemFree(olepath); |
| |
| olepath = NULL; |
| memset(&mt, 0x11, sizeof(mt)); |
| hr = IFileSourceFilter_GetCurFile(filesource, &olepath, &mt); |
| ok(hr == S_OK, "expected S_OK, got %08x\n", hr); |
| ok(!lstrcmpW(olepath, path), |
| "expected %s, got %s\n", wine_dbgstr_w(path), wine_dbgstr_w(olepath)); |
| if (tests[i].subtype) |
| { |
| ok(IsEqualGUID(&mt.majortype, &MEDIATYPE_Stream), |
| "expected MEDIATYPE_Stream, got %s\n", wine_dbgstr_guid(&mt.majortype)); |
| ok(IsEqualGUID(&mt.subtype, tests[i].subtype), |
| "expected %s, got %s\n", wine_dbgstr_guid(tests[i].subtype), wine_dbgstr_guid(&mt.subtype)); |
| } |
| CoTaskMemFree(olepath); |
| |
| IFileSourceFilter_Release(filesource); |
| IBaseFilter_Release(base); |
| |
| success = DeleteFileW(path); |
| ok(success, "DeleteFileW failed with error %u\n", GetLastError()); |
| } |
| } |
| |
| static const WCHAR wfile[] = {'t','e','s','t','.','a','v','i',0}; |
| static const char afile[] = "test.avi"; |
| |
| /* This test doesn't use the quartz filtergraph because it makes it impossible |
| * to be certain that a thread is really one owned by the avi splitter. |
| * A lot of the decoder filters will also have their own thread, and Windows' |
| * filtergraph has a separate thread for start/stop/seeking requests. |
| * By avoiding the filtergraph altogether and connecting streams directly to |
| * the null renderer I am sure that this is not the case here. |
| */ |
| static void test_threads(void) |
| { |
| IFileSourceFilter *pfile = NULL; |
| IBaseFilter *preader = NULL, *pavi = NULL; |
| IEnumPins *enumpins = NULL; |
| IPin *filepin = NULL, *avipin = NULL; |
| HRESULT hr; |
| int baselevel, curlevel, expected; |
| HANDLE file = NULL; |
| PIN_DIRECTION dir = PINDIR_OUTPUT; |
| char buffer[13]; |
| DWORD readbytes; |
| FILTER_STATE state; |
| |
| /* We need another way of counting threads on NT4. Skip these tests (for now) */ |
| if (!pCreateToolhelp32Snapshot || !pThread32First || !pThread32Next) |
| { |
| win_skip("Needed thread functions are not available (NT4)\n"); |
| return; |
| } |
| |
| /* Before doing anything (the thread count at the start differs per OS) */ |
| baselevel = count_threads(); |
| |
| file = CreateFileW(wfile, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, |
| NULL, OPEN_EXISTING, 0, NULL); |
| if (file == INVALID_HANDLE_VALUE) |
| { |
| skip("Could not read test file \"%s\", skipping test\n", afile); |
| return; |
| } |
| |
| memset(buffer, 0, 13); |
| readbytes = 12; |
| ReadFile(file, buffer, readbytes, &readbytes, NULL); |
| CloseHandle(file); |
| if (strncmp(buffer, "RIFF", 4) || strcmp(buffer + 8, "AVI ")) |
| { |
| skip("%s is not an avi riff file, not doing the avi splitter test\n", |
| afile); |
| return; |
| } |
| |
| hr = IUnknown_QueryInterface(pAviSplitter, &IID_IFileSourceFilter, |
| (void **)&pfile); |
| ok(hr == E_NOINTERFACE, |
| "Avi splitter returns unexpected error: %08x\n", hr); |
| if (pfile) |
| IFileSourceFilter_Release(pfile); |
| pfile = NULL; |
| |
| hr = CoCreateInstance(&CLSID_AsyncReader, NULL, CLSCTX_INPROC_SERVER, |
| &IID_IBaseFilter, (LPVOID*)&preader); |
| ok(hr == S_OK, "Could not create asynchronous reader: %08x\n", hr); |
| if (hr != S_OK) |
| goto fail; |
| |
| hr = IBaseFilter_QueryInterface(preader, &IID_IFileSourceFilter, |
| (void**)&pfile); |
| ok(hr == S_OK, "Could not get IFileSourceFilter: %08x\n", hr); |
| if (hr != S_OK) |
| goto fail; |
| |
| hr = IUnknown_QueryInterface(pAviSplitter, &IID_IBaseFilter, |
| (void**)&pavi); |
| ok(hr == S_OK, "Could not get base filter: %08x\n", hr); |
| if (hr != S_OK) |
| goto fail; |
| |
| hr = IFileSourceFilter_Load(pfile, wfile, NULL); |
| if (hr != S_OK) |
| { |
| trace("Could not load file\n"); |
| goto fail; |
| } |
| |
| hr = IBaseFilter_EnumPins(preader, &enumpins); |
| ok(hr == S_OK, "No enumpins: %08x\n", hr); |
| if (hr != S_OK) |
| goto fail; |
| |
| hr = IEnumPins_Next(enumpins, 1, &filepin, NULL); |
| ok(hr == S_OK, "No pin: %08x\n", hr); |
| if (hr != S_OK) |
| goto fail; |
| |
| IEnumPins_Release(enumpins); |
| enumpins = NULL; |
| |
| hr = IBaseFilter_EnumPins(pavi, &enumpins); |
| ok(hr == S_OK, "No enumpins: %08x\n", hr); |
| if (hr != S_OK) |
| goto fail; |
| |
| hr = IEnumPins_Next(enumpins, 1, &avipin, NULL); |
| ok(hr == S_OK, "No pin: %08x\n", hr); |
| if (hr != S_OK) |
| goto fail; |
| |
| curlevel = count_threads(); |
| ok(curlevel == baselevel, |
| "The thread count should be %d not %d\n", baselevel, curlevel); |
| |
| hr = IPin_Connect(filepin, avipin, NULL); |
| ok(hr == S_OK, "Could not connect: %08x\n", hr); |
| if (hr != S_OK) |
| goto fail; |
| |
| expected = 1 + baselevel; |
| curlevel = count_threads(); |
| ok(curlevel == expected, |
| "The thread count should be %d not %d\n", expected, curlevel); |
| |
| IPin_Release(avipin); |
| avipin = NULL; |
| |
| IEnumPins_Reset(enumpins); |
| |
| /* Windows puts the pins in the order: Outputpins - Inputpin, |
| * wine does the reverse, just don't test it for now |
| * Hate to admit it, but windows way makes more sense |
| */ |
| while (IEnumPins_Next(enumpins, 1, &avipin, NULL) == S_OK) |
| { |
| IPin_QueryDirection(avipin, &dir); |
| if (dir == PINDIR_OUTPUT) |
| { |
| /* Well, connect it to a null renderer! */ |
| IBaseFilter *pnull = NULL; |
| IEnumPins *nullenum = NULL; |
| IPin *nullpin = NULL; |
| |
| hr = CoCreateInstance(&CLSID_NullRenderer, NULL, |
| CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (LPVOID*)&pnull); |
| ok(hr == S_OK, "Could not create null renderer: %08x\n", hr); |
| if (hr != S_OK) |
| break; |
| |
| IBaseFilter_EnumPins(pnull, &nullenum); |
| IEnumPins_Next(nullenum, 1, &nullpin, NULL); |
| IEnumPins_Release(nullenum); |
| IPin_QueryDirection(nullpin, &dir); |
| |
| hr = IPin_Connect(avipin, nullpin, NULL); |
| ok(hr == S_OK, "Failed to connect output pin: %08x\n", hr); |
| IPin_Release(nullpin); |
| if (hr != S_OK) |
| { |
| IBaseFilter_Release(pnull); |
| break; |
| } |
| IBaseFilter_Run(pnull, 0); |
| ++expected; |
| } |
| |
| IPin_Release(avipin); |
| avipin = NULL; |
| } |
| |
| if (avipin) |
| IPin_Release(avipin); |
| avipin = NULL; |
| |
| if (hr != S_OK) |
| goto fail2; |
| /* At this point there is a minimalistic connected avi splitter that can |
| * be used for all sorts of source filter tests. However that still needs |
| * to be written at a later time. |
| * |
| * Interesting tests: |
| * - Can you disconnect an output pin while running? |
| * Expecting: Yes |
| * - Can you disconnect the pullpin while running? |
| * Expecting: No |
| * - Is the reference count incremented during playback or when connected? |
| * Does this happen once for every output pin? Or is there something else |
| * going on. |
| * Expecting: You tell me |
| */ |
| |
| IBaseFilter_Run(preader, 0); |
| IBaseFilter_Run(pavi, 0); |
| IBaseFilter_GetState(pavi, INFINITE, &state); |
| |
| curlevel = count_threads(); |
| ok(curlevel == expected, |
| "The thread count should be %d not %d\n", expected, curlevel); |
| |
| IBaseFilter_Pause(pavi); |
| IBaseFilter_Pause(preader); |
| IBaseFilter_Stop(pavi); |
| IBaseFilter_Stop(preader); |
| IBaseFilter_GetState(pavi, INFINITE, &state); |
| IBaseFilter_GetState(preader, INFINITE, &state); |
| |
| fail2: |
| IEnumPins_Reset(enumpins); |
| while (IEnumPins_Next(enumpins, 1, &avipin, NULL) == S_OK) |
| { |
| IPin *to = NULL; |
| |
| IPin_QueryDirection(avipin, &dir); |
| IPin_ConnectedTo(avipin, &to); |
| if (to) |
| { |
| IPin_Release(to); |
| |
| if (dir == PINDIR_OUTPUT) |
| { |
| PIN_INFO info; |
| IPin_QueryPinInfo(to, &info); |
| |
| /* Release twice: Once normal, second from the |
| * previous while loop |
| */ |
| IBaseFilter_Stop(info.pFilter); |
| IPin_Disconnect(to); |
| IPin_Disconnect(avipin); |
| IBaseFilter_Release(info.pFilter); |
| IBaseFilter_Release(info.pFilter); |
| } |
| else |
| { |
| IPin_Disconnect(to); |
| IPin_Disconnect(avipin); |
| } |
| } |
| IPin_Release(avipin); |
| avipin = NULL; |
| } |
| |
| fail: |
| if (hr != S_OK) |
| skip("Prerequisites not matched, skipping remainder of test\n"); |
| if (enumpins) |
| IEnumPins_Release(enumpins); |
| |
| if (avipin) |
| IPin_Release(avipin); |
| if (filepin) |
| { |
| IPin *to = NULL; |
| |
| IPin_ConnectedTo(filepin, &to); |
| if (to) |
| { |
| IPin_Disconnect(filepin); |
| IPin_Disconnect(to); |
| } |
| IPin_Release(filepin); |
| } |
| |
| if (preader) |
| IBaseFilter_Release(preader); |
| if (pavi) |
| IBaseFilter_Release(pavi); |
| if (pfile) |
| IFileSourceFilter_Release(pfile); |
| |
| curlevel = count_threads(); |
| todo_wine |
| ok(curlevel == baselevel, |
| "The thread count should be %d not %d\n", baselevel, curlevel); |
| } |
| |
| START_TEST(avisplitter) |
| { |
| HMODULE kernel32 = GetModuleHandleA("kernel32.dll"); |
| |
| pCreateToolhelp32Snapshot = (void*)GetProcAddress(kernel32, "CreateToolhelp32Snapshot"); |
| pThread32First = (void*)GetProcAddress(kernel32, "Thread32First"); |
| pThread32Next = (void*)GetProcAddress(kernel32, "Thread32Next"); |
| |
| CoInitialize(NULL); |
| |
| if (!create_avisplitter()) |
| { |
| skip("Could not create avisplitter\n"); |
| return; |
| } |
| |
| test_query_interface(); |
| test_basefilter(); |
| test_filesourcefilter(); |
| test_threads(); |
| |
| release_avisplitter(); |
| |
| CoUninitialize(); |
| } |
