/* * File Source Filter * * Copyright 2003 Robert Shearman * * 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 NONAMELESSUNION #define NONAMELESSSTRUCT #include "quartz_private.h" #include "wine/debug.h" #include "uuids.h" #include "vfwmsgs.h" #include "winbase.h" #include "winreg.h" #include "shlwapi.h" #include WINE_DEFAULT_DEBUG_CHANNEL(quartz); static const AM_MEDIA_TYPE default_mt = { {0xe436eb83,0x524f,0x11ce,{0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70}}, /* MEDIATYPE_Stream */ {0,0,0,{0,0,0,0,0,0,0,0}}, TRUE, FALSE, 1, {0,0,0,{0,0,0,0,0,0,0,0}}, NULL, 0, NULL }; struct request { IMediaSample *sample; DWORD_PTR cookie; OVERLAPPED ovl; }; typedef struct AsyncReader { struct strmbase_filter filter; IFileSourceFilter IFileSourceFilter_iface; struct strmbase_source source; IAsyncReader IAsyncReader_iface; LPOLESTR pszFileName; AM_MEDIA_TYPE mt; ALLOCATOR_PROPERTIES allocProps; HANDLE file, port, io_thread; CRITICAL_SECTION sample_cs; BOOL flushing; struct request *requests; unsigned int max_requests; CONDITION_VARIABLE sample_cv; } AsyncReader; static const struct strmbase_source_ops source_ops; static inline AsyncReader *impl_from_strmbase_filter(struct strmbase_filter *iface) { return CONTAINING_RECORD(iface, AsyncReader, filter); } static inline AsyncReader *impl_from_IFileSourceFilter(IFileSourceFilter *iface) { return CONTAINING_RECORD(iface, AsyncReader, IFileSourceFilter_iface); } static const IFileSourceFilterVtbl FileSource_Vtbl; static const IAsyncReaderVtbl FileAsyncReader_Vtbl; static int byte_from_hex_char(WCHAR c) { if ('0' <= c && c <= '9') return c - '0'; if ('a' <= c && c <= 'f') return c - 'a' + 10; if ('A' <= c && c <= 'F') return c - 'A' + 10; return -1; } static BOOL process_pattern_string(const WCHAR *pattern, HANDLE file) { ULONG size, offset, i, ret_size; BYTE *mask, *expect, *actual; int d; BOOL ret = TRUE; /* format: "offset, size, mask, value" */ offset = wcstol(pattern, NULL, 10); if (!(pattern = wcschr(pattern, ','))) return FALSE; pattern++; size = wcstol(pattern, NULL, 10); mask = heap_alloc(size); expect = heap_alloc(size); memset(mask, 0xff, size); if (!(pattern = wcschr(pattern, ','))) { heap_free(mask); heap_free(expect); return FALSE; } pattern++; while (byte_from_hex_char(*pattern) == -1 && (*pattern != ',')) pattern++; for (i = 0; (d = byte_from_hex_char(*pattern)) != -1 && (i/2 < size); pattern++, i++) { if (i % 2) mask[i / 2] |= d; else mask[i / 2] = d << 4; } if (!(pattern = wcschr(pattern, ','))) { heap_free(mask); heap_free(expect); return FALSE; } pattern++; while (byte_from_hex_char(*pattern) == -1 && (*pattern != ',')) pattern++; for (i = 0; (d = byte_from_hex_char(*pattern)) != -1 && (i/2 < size); pattern++, i++) { if (i % 2) expect[i / 2] |= d; else expect[i / 2] = d << 4; } actual = heap_alloc(size); SetFilePointer(file, offset, NULL, FILE_BEGIN); if (!ReadFile(file, actual, size, &ret_size, NULL) || ret_size != size) { heap_free(actual); heap_free(expect); heap_free(mask); return FALSE; } for (i = 0; i < size; ++i) { if ((actual[i] & mask[i]) != expect[i]) { ret = FALSE; break; } } heap_free(actual); heap_free(expect); heap_free(mask); /* If there is a following tuple, then we must match that as well. */ if (ret && (pattern = wcschr(pattern, ','))) return process_pattern_string(pattern + 1, file); return ret; } BOOL get_media_type(const WCHAR *filename, GUID *majortype, GUID *subtype, GUID *source_clsid) { WCHAR extensions_path[278] = {'M','e','d','i','a',' ','T','y','p','e','\\','E','x','t','e','n','s','i','o','n','s','\\',0}; static const WCHAR wszExtensions[] = {'E','x','t','e','n','s','i','o','n','s',0}; static const WCHAR wszMediaType[] = {'M','e','d','i','a',' ','T','y','p','e',0}; DWORD majortype_idx, size; const WCHAR *ext; HKEY parent_key; HANDLE file; if ((ext = wcsrchr(filename, '.'))) { WCHAR guidstr[39]; HKEY key; wcscat(extensions_path, ext); if (!RegOpenKeyExW(HKEY_CLASSES_ROOT, extensions_path, 0, KEY_READ, &key)) { size = sizeof(guidstr); if (majortype && !RegQueryValueExW(key, L"Media Type", NULL, NULL, (BYTE *)guidstr, &size)) CLSIDFromString(guidstr, majortype); size = sizeof(guidstr); if (subtype && !RegQueryValueExW(key, L"Subtype", NULL, NULL, (BYTE *)guidstr, &size)) CLSIDFromString(guidstr, subtype); size = sizeof(guidstr); if (source_clsid && !RegQueryValueExW(key, L"Source Filter", NULL, NULL, (BYTE *)guidstr, &size)) CLSIDFromString(guidstr, source_clsid); RegCloseKey(key); return FALSE; } } if ((file = CreateFileW(filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE) { WARN("Failed to open file %s, error %u.\n", debugstr_w(filename), GetLastError()); return FALSE; } if (RegOpenKeyExW(HKEY_CLASSES_ROOT, wszMediaType, 0, KEY_READ, &parent_key)) { CloseHandle(file); return FALSE; } for (majortype_idx = 0; ; ++majortype_idx) { WCHAR majortype_str[39]; HKEY majortype_key; DWORD subtype_idx; size = ARRAY_SIZE(majortype_str); if (RegEnumKeyExW(parent_key, majortype_idx, majortype_str, &size, NULL, NULL, NULL, NULL)) break; if (!wcscmp(majortype_str, wszExtensions)) continue; if (RegOpenKeyExW(parent_key, majortype_str, 0, KEY_READ, &majortype_key)) continue; for (subtype_idx = 0; ; ++subtype_idx) { WCHAR subtype_str[39], *pattern; DWORD value_idx, max_size; HKEY subtype_key; size = ARRAY_SIZE(subtype_str); if (RegEnumKeyExW(majortype_key, subtype_idx, subtype_str, &size, NULL, NULL, NULL, NULL)) break; if (RegOpenKeyExW(majortype_key, subtype_str, 0, KEY_READ, &subtype_key)) continue; if (RegQueryInfoKeyW(subtype_key, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &max_size, NULL, NULL)) continue; pattern = heap_alloc(max_size); for (value_idx = 0; ; ++value_idx) { /* The longest name we should encounter is "Source Filter". */ WCHAR value_name[14], source_clsid_str[39]; DWORD value_len = ARRAY_SIZE(value_name); size = max_size; if (RegEnumValueW(subtype_key, value_idx, value_name, &value_len, NULL, NULL, (BYTE *)pattern, &max_size)) break; if (!wcscmp(value_name, L"Source Filter")) continue; if (!process_pattern_string(pattern, file)) continue; if (majortype) CLSIDFromString(majortype_str, majortype); if (subtype) CLSIDFromString(subtype_str, subtype); size = sizeof(source_clsid_str); if (source_clsid && !RegQueryValueExW(subtype_key, L"Source Filter", NULL, NULL, (BYTE *)source_clsid_str, &size)) CLSIDFromString(source_clsid_str, source_clsid); heap_free(pattern); RegCloseKey(subtype_key); RegCloseKey(majortype_key); RegCloseKey(parent_key); CloseHandle(file); return TRUE; } heap_free(pattern); RegCloseKey(subtype_key); } RegCloseKey(majortype_key); } RegCloseKey(parent_key); CloseHandle(file); return FALSE; } static struct strmbase_pin *async_reader_get_pin(struct strmbase_filter *iface, unsigned int index) { AsyncReader *filter = impl_from_strmbase_filter(iface); if (!index && filter->pszFileName) return &filter->source.pin; return NULL; } static void async_reader_destroy(struct strmbase_filter *iface) { AsyncReader *filter = impl_from_strmbase_filter(iface); if (filter->pszFileName) { unsigned int i; if (filter->source.pin.peer) IPin_Disconnect(filter->source.pin.peer); IPin_Disconnect(&filter->source.pin.IPin_iface); if (filter->requests) { for (i = 0; i < filter->max_requests; ++i) CloseHandle(filter->requests[i].ovl.hEvent); free(filter->requests); } CloseHandle(filter->file); filter->sample_cs.DebugInfo->Spare[0] = 0; DeleteCriticalSection(&filter->sample_cs); strmbase_source_cleanup(&filter->source); CoTaskMemFree(filter->pszFileName); FreeMediaType(&filter->mt); } PostQueuedCompletionStatus(filter->port, 0, 1, NULL); WaitForSingleObject(filter->io_thread, INFINITE); CloseHandle(filter->io_thread); CloseHandle(filter->port); strmbase_filter_cleanup(&filter->filter); CoTaskMemFree(filter); } static HRESULT async_reader_query_interface(struct strmbase_filter *iface, REFIID iid, void **out) { AsyncReader *filter = impl_from_strmbase_filter(iface); if (IsEqualGUID(iid, &IID_IFileSourceFilter)) { *out = &filter->IFileSourceFilter_iface; IUnknown_AddRef((IUnknown *)*out); return S_OK; } return E_NOINTERFACE; } static const struct strmbase_filter_ops filter_ops = { .filter_get_pin = async_reader_get_pin, .filter_destroy = async_reader_destroy, .filter_query_interface = async_reader_query_interface, }; static DWORD CALLBACK io_thread(void *arg) { AsyncReader *filter = arg; struct request *req; OVERLAPPED *ovl; ULONG_PTR key; DWORD size; BOOL ret; for (;;) { ret = GetQueuedCompletionStatus(filter->port, &size, &key, &ovl, INFINITE); if (ret && key) break; EnterCriticalSection(&filter->sample_cs); req = CONTAINING_RECORD(ovl, struct request, ovl); TRACE("Got sample %u.\n", req - filter->requests); assert(req >= filter->requests && req < filter->requests + filter->max_requests); if (ret) WakeConditionVariable(&filter->sample_cv); else { ERR("GetQueuedCompletionStatus() returned failure, error %u.\n", GetLastError()); req->sample = NULL; } LeaveCriticalSection(&filter->sample_cs); } return 0; } HRESULT AsyncReader_create(IUnknown *outer, void **out) { AsyncReader *pAsyncRead; pAsyncRead = CoTaskMemAlloc(sizeof(AsyncReader)); if (!pAsyncRead) return E_OUTOFMEMORY; strmbase_filter_init(&pAsyncRead->filter, outer, &CLSID_AsyncReader, &filter_ops); pAsyncRead->IFileSourceFilter_iface.lpVtbl = &FileSource_Vtbl; pAsyncRead->IAsyncReader_iface.lpVtbl = &FileAsyncReader_Vtbl; pAsyncRead->pszFileName = NULL; InitializeCriticalSection(&pAsyncRead->sample_cs); pAsyncRead->sample_cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": FileAsyncReader.sample_cs"); InitializeConditionVariable(&pAsyncRead->sample_cv); pAsyncRead->port = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0); pAsyncRead->io_thread = CreateThread(NULL, 0, io_thread, pAsyncRead, 0, NULL); *out = &pAsyncRead->filter.IUnknown_inner; TRACE("-- created at %p\n", pAsyncRead); return S_OK; } static HRESULT WINAPI FileSource_QueryInterface(IFileSourceFilter * iface, REFIID riid, LPVOID * ppv) { AsyncReader *This = impl_from_IFileSourceFilter(iface); return IBaseFilter_QueryInterface(&This->filter.IBaseFilter_iface, riid, ppv); } static ULONG WINAPI FileSource_AddRef(IFileSourceFilter * iface) { AsyncReader *This = impl_from_IFileSourceFilter(iface); return IBaseFilter_AddRef(&This->filter.IBaseFilter_iface); } static ULONG WINAPI FileSource_Release(IFileSourceFilter * iface) { AsyncReader *This = impl_from_IFileSourceFilter(iface); return IBaseFilter_Release(&This->filter.IBaseFilter_iface); } static HRESULT WINAPI FileSource_Load(IFileSourceFilter * iface, LPCOLESTR pszFileName, const AM_MEDIA_TYPE * pmt) { HANDLE hFile; AsyncReader *This = impl_from_IFileSourceFilter(iface); TRACE("%p->(%s, %p)\n", This, debugstr_w(pszFileName), pmt); strmbase_dump_media_type(pmt); if (!pszFileName) return E_POINTER; /* open file */ /* FIXME: check the sharing values that native uses */ hFile = CreateFileW(pszFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL); if (hFile == INVALID_HANDLE_VALUE) { return HRESULT_FROM_WIN32(GetLastError()); } if (This->pszFileName) { free(This->pszFileName); FreeMediaType(&This->mt); } if (!(This->pszFileName = wcsdup(pszFileName))) { CloseHandle(hFile); return E_OUTOFMEMORY; } strmbase_source_init(&This->source, &This->filter, L"Output", &source_ops); BaseFilterImpl_IncrementPinVersion(&This->filter); This->file = hFile; This->flushing = FALSE; This->requests = NULL; if (!pmt) { CopyMediaType(&This->mt, &default_mt); if (get_media_type(pszFileName, &This->mt.majortype, &This->mt.subtype, NULL)) { TRACE("Found major type %s, subtype %s.\n", debugstr_guid(&This->mt.majortype), debugstr_guid(&This->mt.subtype)); } } else CopyMediaType(&This->mt, pmt); return S_OK; } static HRESULT WINAPI FileSource_GetCurFile(IFileSourceFilter *iface, LPOLESTR *ppszFileName, AM_MEDIA_TYPE *mt) { AsyncReader *This = impl_from_IFileSourceFilter(iface); TRACE("filter %p, filename %p, mt %p.\n", This, ppszFileName, mt); if (!ppszFileName) return E_POINTER; /* copy file name & media type if available, otherwise clear the outputs */ if (This->pszFileName) { *ppszFileName = CoTaskMemAlloc((wcslen(This->pszFileName) + 1) * sizeof(WCHAR)); wcscpy(*ppszFileName, This->pszFileName); if (mt) CopyMediaType(mt, &This->mt); } else { *ppszFileName = NULL; if (mt) memset(mt, 0, sizeof(AM_MEDIA_TYPE)); } return S_OK; } static const IFileSourceFilterVtbl FileSource_Vtbl = { FileSource_QueryInterface, FileSource_AddRef, FileSource_Release, FileSource_Load, FileSource_GetCurFile }; static inline AsyncReader *impl_from_strmbase_pin(struct strmbase_pin *iface) { return CONTAINING_RECORD(iface, AsyncReader, source.pin); } static inline AsyncReader *impl_from_strmbase_source(struct strmbase_source *iface) { return CONTAINING_RECORD(iface, AsyncReader, source); } static inline AsyncReader *impl_from_IAsyncReader(IAsyncReader *iface) { return CONTAINING_RECORD(iface, AsyncReader, IAsyncReader_iface); } static HRESULT source_query_accept(struct strmbase_pin *iface, const AM_MEDIA_TYPE *mt) { AsyncReader *filter = impl_from_strmbase_pin(iface); if (IsEqualGUID(&mt->majortype, &filter->mt.majortype) && (!IsEqualGUID(&mt->subtype, &GUID_NULL) || IsEqualGUID(&filter->mt.subtype, &GUID_NULL))) return S_OK; return S_FALSE; } static HRESULT source_get_media_type(struct strmbase_pin *iface, unsigned int index, AM_MEDIA_TYPE *mt) { AsyncReader *filter = impl_from_strmbase_pin(iface); if (index > 1) return VFW_S_NO_MORE_ITEMS; if (index == 0) CopyMediaType(mt, &filter->mt); else if (index == 1) CopyMediaType(mt, &default_mt); return S_OK; } static HRESULT source_query_interface(struct strmbase_pin *iface, REFIID iid, void **out) { AsyncReader *filter = impl_from_strmbase_pin(iface); if (IsEqualGUID(iid, &IID_IAsyncReader)) *out = &filter->IAsyncReader_iface; else return E_NOINTERFACE; IUnknown_AddRef((IUnknown *)*out); return S_OK; } /* Function called as a helper to IPin_Connect */ /* specific AM_MEDIA_TYPE - it cannot be NULL */ /* this differs from standard OutputPin_AttemptConnection only in that it * doesn't need the IMemInputPin interface on the receiving pin */ static HRESULT WINAPI FileAsyncReaderPin_AttemptConnection(struct strmbase_source *This, IPin *pReceivePin, const AM_MEDIA_TYPE *pmt) { HRESULT hr; TRACE("%p->(%p, %p)\n", This, pReceivePin, pmt); /* FIXME: call queryacceptproc */ This->pin.peer = pReceivePin; IPin_AddRef(pReceivePin); CopyMediaType(&This->pin.mt, pmt); hr = IPin_ReceiveConnection(pReceivePin, &This->pin.IPin_iface, pmt); if (FAILED(hr)) { IPin_Release(This->pin.peer); This->pin.peer = NULL; FreeMediaType(&This->pin.mt); } TRACE(" -- %x\n", hr); return hr; } static HRESULT WINAPI FileAsyncReaderPin_DecideBufferSize(struct strmbase_source *iface, IMemAllocator *pAlloc, ALLOCATOR_PROPERTIES *ppropInputRequest) { AsyncReader *This = impl_from_strmbase_source(iface); ALLOCATOR_PROPERTIES actual; if (ppropInputRequest->cbAlign && ppropInputRequest->cbAlign != This->allocProps.cbAlign) FIXME("Requested Buffer cbAlign mismatch %i,%i\n",This->allocProps.cbAlign, ppropInputRequest->cbAlign); if (ppropInputRequest->cbPrefix) FIXME("Requested Buffer cbPrefix mismatch %i,%i\n",This->allocProps.cbPrefix, ppropInputRequest->cbPrefix); if (ppropInputRequest->cbBuffer) FIXME("Requested Buffer cbBuffer mismatch %i,%i\n",This->allocProps.cbBuffer, ppropInputRequest->cbBuffer); if (ppropInputRequest->cBuffers) FIXME("Requested Buffer cBuffers mismatch %i,%i\n",This->allocProps.cBuffers, ppropInputRequest->cBuffers); return IMemAllocator_SetProperties(pAlloc, &This->allocProps, &actual); } static const struct strmbase_source_ops source_ops = { .base.pin_query_accept = source_query_accept, .base.pin_get_media_type = source_get_media_type, .base.pin_query_interface = source_query_interface, .pfnAttemptConnection = FileAsyncReaderPin_AttemptConnection, .pfnDecideBufferSize = FileAsyncReaderPin_DecideBufferSize, .pfnDecideAllocator = BaseOutputPinImpl_DecideAllocator, }; static HRESULT WINAPI FileAsyncReader_QueryInterface(IAsyncReader *iface, REFIID iid, void **out) { AsyncReader *filter = impl_from_IAsyncReader(iface); return IPin_QueryInterface(&filter->source.pin.IPin_iface, iid, out); } static ULONG WINAPI FileAsyncReader_AddRef(IAsyncReader * iface) { AsyncReader *filter = impl_from_IAsyncReader(iface); return IPin_AddRef(&filter->source.pin.IPin_iface); } static ULONG WINAPI FileAsyncReader_Release(IAsyncReader * iface) { AsyncReader *filter = impl_from_IAsyncReader(iface); return IPin_Release(&filter->source.pin.IPin_iface); } static HRESULT WINAPI FileAsyncReader_RequestAllocator(IAsyncReader *iface, IMemAllocator *preferred, ALLOCATOR_PROPERTIES *props, IMemAllocator **ret_allocator) { AsyncReader *filter = impl_from_IAsyncReader(iface); IMemAllocator *allocator; unsigned int i; HRESULT hr; TRACE("filter %p, preferred %p, props %p, ret_allocator %p.\n", filter, preferred, props, ret_allocator); if (!props->cbAlign) props->cbAlign = 1; *ret_allocator = NULL; if (preferred) IMemAllocator_AddRef(allocator = preferred); else if (FAILED(hr = CoCreateInstance(&CLSID_MemoryAllocator, NULL, CLSCTX_INPROC, &IID_IMemAllocator, (void **)&allocator))) return hr; if (FAILED(hr = IMemAllocator_SetProperties(allocator, props, props))) { IMemAllocator_Release(allocator); return hr; } if (filter->requests) { for (i = 0; i < filter->max_requests; ++i) CloseHandle(filter->requests[i].ovl.hEvent); free(filter->requests); } filter->max_requests = props->cBuffers; TRACE("Maximum request count: %u.\n", filter->max_requests); if (!(filter->requests = calloc(filter->max_requests, sizeof(filter->requests[0])))) { IMemAllocator_Release(allocator); return E_OUTOFMEMORY; } for (i = 0; i < filter->max_requests; ++i) filter->requests[i].ovl.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL); filter->allocProps = *props; *ret_allocator = allocator; return S_OK; } static HRESULT WINAPI FileAsyncReader_Request(IAsyncReader *iface, IMediaSample *sample, DWORD_PTR cookie) { AsyncReader *filter = impl_from_IAsyncReader(iface); REFERENCE_TIME start, end; struct request *req; unsigned int i; HRESULT hr; BYTE *data; TRACE("filter %p, sample %p, cookie %#lx.\n", filter, sample, cookie); if (!sample) return E_POINTER; if (FAILED(hr = IMediaSample_GetTime(sample, &start, &end))) return hr; if (FAILED(hr = IMediaSample_GetPointer(sample, &data))) return hr; EnterCriticalSection(&filter->sample_cs); if (filter->flushing) { LeaveCriticalSection(&filter->sample_cs); return VFW_E_WRONG_STATE; } for (i = 0; i < filter->max_requests; ++i) { if (!filter->requests[i].sample) break; } assert(i < filter->max_requests); req = &filter->requests[i]; req->ovl.u.s.Offset = BYTES_FROM_MEDIATIME(start); req->ovl.u.s.OffsetHigh = BYTES_FROM_MEDIATIME(start) >> 32; /* No reference is taken. */ if (ReadFile(filter->file, data, BYTES_FROM_MEDIATIME(end - start), NULL, &req->ovl) || GetLastError() == ERROR_IO_PENDING) { hr = S_OK; req->sample = sample; req->cookie = cookie; } else hr = HRESULT_FROM_WIN32(GetLastError()); LeaveCriticalSection(&filter->sample_cs); return hr; } static HRESULT WINAPI FileAsyncReader_WaitForNext(IAsyncReader *iface, DWORD timeout, IMediaSample **sample, DWORD_PTR *cookie) { AsyncReader *filter = impl_from_IAsyncReader(iface); unsigned int i; TRACE("filter %p, timeout %u, sample %p, cookie %p.\n", filter, timeout, sample, cookie); *sample = NULL; *cookie = 0; EnterCriticalSection(&filter->sample_cs); do { if (filter->flushing) { LeaveCriticalSection(&filter->sample_cs); return VFW_E_WRONG_STATE; } for (i = 0; i < filter->max_requests; ++i) { struct request *req = &filter->requests[i]; DWORD size; if (req->sample && GetOverlappedResult(filter->file, &req->ovl, &size, FALSE)) { REFERENCE_TIME start, end; IMediaSample_SetActualDataLength(req->sample, size); start = MEDIATIME_FROM_BYTES(((ULONGLONG)req->ovl.u.s.OffsetHigh << 32) + req->ovl.u.s.Offset); end = start + MEDIATIME_FROM_BYTES(size); IMediaSample_SetTime(req->sample, &start, &end); *sample = req->sample; *cookie = req->cookie; req->sample = NULL; LeaveCriticalSection(&filter->sample_cs); TRACE("Returning sample %u.\n", i); return S_OK; } } } while (SleepConditionVariableCS(&filter->sample_cv, &filter->sample_cs, timeout)); LeaveCriticalSection(&filter->sample_cs); return VFW_E_TIMEOUT; } static BOOL sync_read(HANDLE file, LONGLONG offset, LONG length, BYTE *buffer, DWORD *read_len) { OVERLAPPED ovl = {0}; BOOL ret; ovl.hEvent = (HANDLE)((ULONG_PTR)CreateEventW(NULL, TRUE, FALSE, NULL) | 1); ovl.u.s.Offset = (DWORD)offset; ovl.u.s.OffsetHigh = offset >> 32; *read_len = 0; ret = ReadFile(file, buffer, length, NULL, &ovl); if (ret || GetLastError() == ERROR_IO_PENDING) ret = GetOverlappedResult(file, &ovl, read_len, TRUE); TRACE("Returning %u bytes.\n", *read_len); CloseHandle(ovl.hEvent); return ret; } static HRESULT WINAPI FileAsyncReader_SyncReadAligned(IAsyncReader *iface, IMediaSample *sample) { AsyncReader *filter = impl_from_IAsyncReader(iface); REFERENCE_TIME start_time, end_time; DWORD read_len; BYTE *buffer; LONG length; HRESULT hr; BOOL ret; TRACE("filter %p, sample %p.\n", filter, sample); hr = IMediaSample_GetTime(sample, &start_time, &end_time); if (SUCCEEDED(hr)) hr = IMediaSample_GetPointer(sample, &buffer); if (SUCCEEDED(hr)) { length = BYTES_FROM_MEDIATIME(end_time - start_time); ret = sync_read(filter->file, BYTES_FROM_MEDIATIME(start_time), length, buffer, &read_len); if (ret) hr = (read_len == length) ? S_OK : S_FALSE; else if (GetLastError() == ERROR_HANDLE_EOF) hr = S_OK; else hr = HRESULT_FROM_WIN32(GetLastError()); } if (SUCCEEDED(hr)) IMediaSample_SetActualDataLength(sample, read_len); return hr; } static HRESULT WINAPI FileAsyncReader_SyncRead(IAsyncReader *iface, LONGLONG offset, LONG length, BYTE *buffer) { AsyncReader *filter = impl_from_IAsyncReader(iface); DWORD read_len; HRESULT hr; BOOL ret; TRACE("filter %p, offset %s, length %d, buffer %p.\n", filter, wine_dbgstr_longlong(offset), length, buffer); ret = sync_read(filter->file, offset, length, buffer, &read_len); if (ret) hr = (read_len == length) ? S_OK : S_FALSE; else if (GetLastError() == ERROR_HANDLE_EOF) hr = S_FALSE; else hr = HRESULT_FROM_WIN32(GetLastError()); return hr; } static HRESULT WINAPI FileAsyncReader_Length(IAsyncReader *iface, LONGLONG *total, LONGLONG *available) { AsyncReader *filter = impl_from_IAsyncReader(iface); DWORD low, high; TRACE("iface %p, total %p, available %p.\n", iface, total, available); if ((low = GetFileSize(filter->file, &high)) == -1 && GetLastError() != NO_ERROR) return HRESULT_FROM_WIN32(GetLastError()); *available = *total = (LONGLONG)low | (LONGLONG)high << (sizeof(DWORD) * 8); return S_OK; } static HRESULT WINAPI FileAsyncReader_BeginFlush(IAsyncReader * iface) { AsyncReader *filter = impl_from_IAsyncReader(iface); unsigned int i; TRACE("iface %p.\n", iface); EnterCriticalSection(&filter->sample_cs); filter->flushing = TRUE; for (i = 0; i < filter->max_requests; ++i) filter->requests[i].sample = NULL; CancelIoEx(filter->file, NULL); WakeAllConditionVariable(&filter->sample_cv); LeaveCriticalSection(&filter->sample_cs); return S_OK; } static HRESULT WINAPI FileAsyncReader_EndFlush(IAsyncReader * iface) { AsyncReader *filter = impl_from_IAsyncReader(iface); TRACE("iface %p.\n", iface); EnterCriticalSection(&filter->sample_cs); filter->flushing = FALSE; LeaveCriticalSection(&filter->sample_cs); return S_OK; } static const IAsyncReaderVtbl FileAsyncReader_Vtbl = { FileAsyncReader_QueryInterface, FileAsyncReader_AddRef, FileAsyncReader_Release, FileAsyncReader_RequestAllocator, FileAsyncReader_Request, FileAsyncReader_WaitForNext, FileAsyncReader_SyncReadAligned, FileAsyncReader_SyncRead, FileAsyncReader_Length, FileAsyncReader_BeginFlush, FileAsyncReader_EndFlush, };