#include "quartz_private.h"
#include "wine/debug.h"
#include "uuids.h"
#include "vfwmsgs.h"
#include "winbase.h"
#include "winreg.h"
#include "shlwapi.h"
#include <assert.h>

Include dependency graph for filesource.c:

Classes
struct	request

struct	async_reader

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (quartz)

static struct async_reader *	impl_from_strmbase_filter (struct strmbase_filter *iface)

static struct async_reader *	impl_from_IFileSourceFilter (IFileSourceFilter *iface)

static int	byte_from_hex_char (WCHAR c)

static BOOL	process_pattern_string (const WCHAR *pattern, HANDLE file)

BOOL	get_media_type (const WCHAR filename, GUID majortype, GUID subtype, GUID source_clsid)

static struct strmbase_pin *	async_reader_get_pin (struct strmbase_filter *iface, unsigned int index)

static void	async_reader_destroy (struct strmbase_filter *iface)

static HRESULT	async_reader_query_interface (struct strmbase_filter iface, REFIID iid, void *out)

static DWORD CALLBACK	io_thread (void *arg)

HRESULT	async_reader_create (IUnknown outer, IUnknown *out)

static HRESULT WINAPI	FileSource_QueryInterface (IFileSourceFilter iface, REFIID riid, LPVOID ppv)

static ULONG WINAPI	FileSource_AddRef (IFileSourceFilter *iface)

static ULONG WINAPI	FileSource_Release (IFileSourceFilter *iface)

static HRESULT WINAPI	FileSource_Load (IFileSourceFilter iface, LPCOLESTR pszFileName, const AM_MEDIA_TYPE pmt)

static HRESULT WINAPI	FileSource_GetCurFile (IFileSourceFilter iface, LPOLESTR ppszFileName, AM_MEDIA_TYPE *mt)

static struct async_reader *	impl_from_strmbase_pin (struct strmbase_pin *iface)

static struct async_reader *	impl_from_IAsyncReader (IAsyncReader *iface)

static HRESULT	source_query_accept (struct strmbase_pin iface, const AM_MEDIA_TYPE mt)

static HRESULT	source_get_media_type (struct strmbase_pin iface, unsigned int index, AM_MEDIA_TYPE mt)

static HRESULT	source_query_interface (struct strmbase_pin iface, REFIID iid, void *out)

static HRESULT WINAPI	FileAsyncReaderPin_AttemptConnection (struct strmbase_source This, IPin pReceivePin, const AM_MEDIA_TYPE *pmt)

static HRESULT WINAPI	FileAsyncReader_QueryInterface (IAsyncReader iface, REFIID iid, void *out)

static ULONG WINAPI	FileAsyncReader_AddRef (IAsyncReader *iface)

static ULONG WINAPI	FileAsyncReader_Release (IAsyncReader *iface)

static HRESULT WINAPI	FileAsyncReader_RequestAllocator (IAsyncReader iface, IMemAllocator preferred, ALLOCATOR_PROPERTIES props, IMemAllocator *ret_allocator)

static HRESULT WINAPI	FileAsyncReader_Request (IAsyncReader iface, IMediaSample sample, DWORD_PTR cookie)

static HRESULT WINAPI	FileAsyncReader_WaitForNext (IAsyncReader iface, DWORD timeout, IMediaSample sample, DWORD_PTR cookie)

static BOOL	sync_read (HANDLE file, LONGLONG offset, LONG length, BYTE buffer, DWORD read_len)

static HRESULT WINAPI	FileAsyncReader_SyncReadAligned (IAsyncReader iface, IMediaSample sample)

static HRESULT WINAPI	FileAsyncReader_SyncRead (IAsyncReader iface, LONGLONG offset, LONG length, BYTE buffer)

static HRESULT WINAPI	FileAsyncReader_Length (IAsyncReader iface, LONGLONG total, LONGLONG *available)

static HRESULT WINAPI	FileAsyncReader_BeginFlush (IAsyncReader *iface)

static HRESULT WINAPI	FileAsyncReader_EndFlush (IAsyncReader *iface)

Variables
static const AM_MEDIA_TYPE	default_mt

static const struct strmbase_source_ops	source_ops

static const IFileSourceFilterVtbl	FileSource_Vtbl

static const IAsyncReaderVtbl	FileAsyncReader_Vtbl

static const struct strmbase_filter_ops	filter_ops

Function Documentation

◆ async_reader_create()

HRESULT async_reader_create	(	IUnknown *	outer,
		IUnknown **	out
	)

Definition at line 430 of file filesource.c.

{
    struct async_reader *object;
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    strmbase_filter_init(&object->filter, outer, &CLSID_AsyncReader, &filter_ops);
 
    object->IFileSourceFilter_iface.lpVtbl = &FileSource_Vtbl;
    object->IAsyncReader_iface.lpVtbl = &FileAsyncReader_Vtbl;
 
    InitializeCriticalSectionEx(&object->sample_cs, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
    object->sample_cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": FileAsyncReader.sample_cs");
    InitializeConditionVariable(&object->sample_cv);
    object->port = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
    object->io_thread = CreateThread(NULL, 0, io_thread, object, 0, NULL);
 
    TRACE("Created file source %p.\n", object);
    *out = &object->filter.IUnknown_inner;
    return S_OK;
}

◆ async_reader_destroy()

static void async_reader_destroy ( struct strmbase_filter * iface )

static

Definition at line 333 of file filesource.c.

{
    struct async_reader *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);
        strmbase_source_cleanup(&filter->source);
 
        free(filter->pszFileName);
        FreeMediaType(&filter->mt);
    }
 
    filter->sample_cs.DebugInfo->Spare[0] = 0;
    DeleteCriticalSection(&filter->sample_cs);
 
    PostQueuedCompletionStatus(filter->port, 0, 1, NULL);
    WaitForSingleObject(filter->io_thread, INFINITE);
    CloseHandle(filter->io_thread);
    CloseHandle(filter->port);
 
    strmbase_filter_cleanup(&filter->filter);
    free(filter);
}

◆ async_reader_get_pin()

static struct strmbase_pin * async_reader_get_pin	(	struct strmbase_filter *	iface,
		unsigned int	index
	)

static

Definition at line 324 of file filesource.c.

{
    struct async_reader *filter = impl_from_strmbase_filter(iface);
 
    if (!index && filter->pszFileName)
        return &filter->source.pin;
    return NULL;
}

◆ async_reader_query_interface()

static HRESULT async_reader_query_interface	(	struct strmbase_filter *	iface,
		REFIID	iid,
		void **	out
	)

static

Definition at line 371 of file filesource.c.

{
    struct async_reader *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;
}

◆ byte_from_hex_char()

static int byte_from_hex_char ( WCHAR c )

static

Definition at line 104 of file filesource.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;
}

Referenced by process_pattern_string().

◆ FileAsyncReader_AddRef()

static ULONG WINAPI FileAsyncReader_AddRef ( IAsyncReader * iface )

static

Definition at line 661 of file filesource.c.

{
    struct async_reader *filter = impl_from_IAsyncReader(iface);
    return IPin_AddRef(&filter->source.pin.IPin_iface);
}

◆ FileAsyncReader_BeginFlush()

static HRESULT WINAPI FileAsyncReader_BeginFlush ( IAsyncReader * iface )

static

Definition at line 917 of file filesource.c.

{
    struct async_reader *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;
}

◆ FileAsyncReader_EndFlush()

static HRESULT WINAPI FileAsyncReader_EndFlush ( IAsyncReader * iface )

static

Definition at line 937 of file filesource.c.

{
    struct async_reader *filter = impl_from_IAsyncReader(iface);
 
    TRACE("iface %p.\n", iface);
 
    EnterCriticalSection(&filter->sample_cs);
 
    filter->flushing = FALSE;
 
    LeaveCriticalSection(&filter->sample_cs);
 
    return S_OK;
}

◆ FileAsyncReader_Length()

static HRESULT WINAPI FileAsyncReader_Length	(	IAsyncReader *	iface,
		LONGLONG *	total,
		LONGLONG *	available
	)

static

Definition at line 906 of file filesource.c.

{
    struct async_reader *filter = impl_from_IAsyncReader(iface);
 
    TRACE("iface %p, total %p, available %p.\n", iface, total, available);
 
    *available = *total = filter->file_size.QuadPart;
 
    return S_OK;
}

◆ FileAsyncReader_QueryInterface()

static HRESULT WINAPI FileAsyncReader_QueryInterface	(	IAsyncReader *	iface,
		REFIID	iid,
		void **	out
	)

static

Definition at line 655 of file filesource.c.

{
    struct async_reader *filter = impl_from_IAsyncReader(iface);
    return IPin_QueryInterface(&filter->source.pin.IPin_iface, iid, out);
}

◆ FileAsyncReader_Release()

static ULONG WINAPI FileAsyncReader_Release ( IAsyncReader * iface )

static

Definition at line 667 of file filesource.c.

{
    struct async_reader *filter = impl_from_IAsyncReader(iface);
    return IPin_Release(&filter->source.pin.IPin_iface);
}

◆ FileAsyncReader_Request()

static HRESULT WINAPI FileAsyncReader_Request	(	IAsyncReader *	iface,
		IMediaSample *	sample,
		DWORD_PTR	cookie
	)

static

Definition at line 722 of file filesource.c.

{
    struct async_reader *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 %#Ix.\n", filter, sample, cookie);
 
    if (!sample)
        return E_POINTER;
 
    if (FAILED(hr = IMediaSample_GetTime(sample, &start, &end)))
        return hr;
 
    if (BYTES_FROM_MEDIATIME(start) >= filter->file_size.QuadPart)
        return HRESULT_FROM_WIN32(ERROR_HANDLE_EOF);
 
    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.Offset = BYTES_FROM_MEDIATIME(start);
    req->ovl.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;
}

◆ FileAsyncReader_RequestAllocator()

static HRESULT WINAPI FileAsyncReader_RequestAllocator	(	IAsyncReader *	iface,
		IMemAllocator *	preferred,
		ALLOCATOR_PROPERTIES *	props,
		IMemAllocator **	ret_allocator
	)

static

Definition at line 673 of file filesource.c.

{
    struct async_reader *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);
 
    *ret_allocator = allocator;
    return S_OK;
}

◆ FileAsyncReader_SyncRead()

static HRESULT WINAPI FileAsyncReader_SyncRead	(	IAsyncReader *	iface,
		LONGLONG	offset,
		LONG	length,
		BYTE *	buffer
	)

static

Definition at line 884 of file filesource.c.

{
    struct async_reader *filter = impl_from_IAsyncReader(iface);
    DWORD read_len;
    HRESULT hr;
    BOOL ret;
 
    TRACE("filter %p, offset %s, length %ld, 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;
}

◆ FileAsyncReader_SyncReadAligned()

static HRESULT WINAPI FileAsyncReader_SyncReadAligned	(	IAsyncReader *	iface,
		IMediaSample *	sample
	)

static

Definition at line 849 of file filesource.c.

{
    struct async_reader *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;
}

◆ FileAsyncReader_WaitForNext()

static HRESULT WINAPI FileAsyncReader_WaitForNext	(	IAsyncReader *	iface,
		DWORD	timeout,
		IMediaSample **	sample,
		DWORD_PTR *	cookie
	)

static

Definition at line 778 of file filesource.c.

{
    struct async_reader *filter = impl_from_IAsyncReader(iface);
    unsigned int i;
 
    TRACE("filter %p, timeout %lu, 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.OffsetHigh << 32) + req->ovl.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;
}

◆ FileAsyncReaderPin_AttemptConnection()

static HRESULT WINAPI FileAsyncReaderPin_AttemptConnection	(	struct strmbase_source *	This,
		IPin *	pReceivePin,
		const AM_MEDIA_TYPE *	pmt
	)

static

Definition at line 621 of file filesource.c.

{
    HRESULT hr;
 
    TRACE("%p->(%p, %p)\n", This, pReceivePin, pmt);
 
    if (This->pin.ops->pin_query_accept(&This->pin, pmt) != S_OK)
        return VFW_E_TYPE_NOT_ACCEPTED;
 
    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);
    }
 
    return hr;
}

◆ FileSource_AddRef()

static ULONG WINAPI FileSource_AddRef ( IFileSourceFilter * iface )

static

Definition at line 459 of file filesource.c.

{
    struct async_reader *filter = impl_from_IFileSourceFilter(iface);
    return IBaseFilter_AddRef(&filter->filter.IBaseFilter_iface);
}

◆ FileSource_GetCurFile()

static HRESULT WINAPI FileSource_GetCurFile	(	IFileSourceFilter *	iface,
		LPOLESTR *	ppszFileName,
		AM_MEDIA_TYPE *	mt
	)

static

Definition at line 532 of file filesource.c.

{
    struct async_reader *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;
}

◆ FileSource_Load()

static HRESULT WINAPI FileSource_Load	(	IFileSourceFilter *	iface,
		LPCOLESTR	pszFileName,
		const AM_MEDIA_TYPE *	pmt
	)

static

Definition at line 471 of file filesource.c.

{
    struct async_reader *This = impl_from_IFileSourceFilter(iface);
    HANDLE hFile;
 
    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 | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
 
    if (hFile == INVALID_HANDLE_VALUE)
    {
        return HRESULT_FROM_WIN32(GetLastError());
    }
 
    if (!GetFileSizeEx(hFile, &This->file_size))
    {
        WARN("Could not get file size.\n");
        CloseHandle(hFile);
        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;
}

◆ FileSource_QueryInterface()

static HRESULT WINAPI FileSource_QueryInterface	(	IFileSourceFilter *	iface,
		REFIID	riid,
		LPVOID *	ppv
	)

static

Definition at line 453 of file filesource.c.

{
    struct async_reader *filter = impl_from_IFileSourceFilter(iface);
    return IBaseFilter_QueryInterface(&filter->filter.IBaseFilter_iface, riid, ppv);
}

◆ FileSource_Release()

static ULONG WINAPI FileSource_Release ( IFileSourceFilter * iface )

static

Definition at line 465 of file filesource.c.

{
    struct async_reader *filter = impl_from_IFileSourceFilter(iface);
    return IBaseFilter_Release(&filter->filter.IBaseFilter_iface);
}

◆ get_media_type()

BOOL get_media_type	(	const WCHAR *	filename,
		GUID *	majortype,
		GUID *	subtype,
		GUID *	source_clsid
	)

Definition at line 198 of file filesource.c.

{
    WCHAR extensions_path[278] = L"Media Type\\Extensions\\";
    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 | FILE_SHARE_DELETE, NULL,
            OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)
    {
        WARN("Failed to open file %s, error %lu.\n", debugstr_w(filename), GetLastError());
        return FALSE;
    }
 
    if (RegOpenKeyExW(HKEY_CLASSES_ROOT, L"Media Type", 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, L"Extensions"))
            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;
}

Referenced by FileSource_Load(), FilterGraph2_AddSourceFilter(), and source_get_media_type().

◆ impl_from_IAsyncReader()

static struct async_reader * impl_from_IAsyncReader ( IAsyncReader * iface )

inlinestatic

Definition at line 573 of file filesource.c.

{
    return CONTAINING_RECORD(iface, struct async_reader, IAsyncReader_iface);
}

Referenced by FileAsyncReader_AddRef(), FileAsyncReader_BeginFlush(), FileAsyncReader_EndFlush(), FileAsyncReader_Length(), FileAsyncReader_QueryInterface(), FileAsyncReader_Release(), FileAsyncReader_Request(), FileAsyncReader_RequestAllocator(), FileAsyncReader_SyncRead(), FileAsyncReader_SyncReadAligned(), and FileAsyncReader_WaitForNext().

◆ impl_from_IFileSourceFilter()

static struct async_reader * impl_from_IFileSourceFilter ( IFileSourceFilter * iface )

inlinestatic

Definition at line 96 of file filesource.c.

{
    return CONTAINING_RECORD(iface, struct async_reader, IFileSourceFilter_iface);
}

Referenced by FileSource_AddRef(), FileSource_GetCurFile(), FileSource_Load(), FileSource_QueryInterface(), and FileSource_Release().

◆ impl_from_strmbase_filter()

static struct async_reader * impl_from_strmbase_filter ( struct strmbase_filter * iface )

inlinestatic

Definition at line 91 of file filesource.c.

{
    return CONTAINING_RECORD(iface, struct async_reader, filter);
}

Referenced by async_reader_destroy(), async_reader_get_pin(), and async_reader_query_interface().

◆ impl_from_strmbase_pin()

static struct async_reader * impl_from_strmbase_pin ( struct strmbase_pin * iface )

inlinestatic

Definition at line 568 of file filesource.c.

{
    return CONTAINING_RECORD(iface, struct async_reader, source.pin);
}

Referenced by source_get_media_type(), source_query_accept(), and source_query_interface().

◆ io_thread()

static DWORD CALLBACK io_thread ( void * arg )

static

Definition at line 392 of file filesource.c.

{
    struct async_reader *filter = arg;
    struct request *req;
    OVERLAPPED *ovl;
    ULONG_PTR key;
    DWORD size;
    BOOL ret;
 
    SetThreadDescription(GetCurrentThread(), L"wine_qz_async_reader_io");
 
    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 %Iu.\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 %lu.\n", GetLastError());
            req->sample = NULL;
        }
 
        LeaveCriticalSection(&filter->sample_cs);
    }
 
    return 0;
}

Referenced by async_reader_create().

◆ process_pattern_string()

static BOOL process_pattern_string	(	const WCHAR *	pattern,
		HANDLE	file
	)

static

Definition at line 112 of file filesource.c.

{
    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;
}

Referenced by get_media_type(), and process_pattern_string().

◆ source_get_media_type()

static HRESULT source_get_media_type	(	struct strmbase_pin *	iface,
		unsigned int	index,
		AM_MEDIA_TYPE *	mt
	)

static

Definition at line 590 of file filesource.c.

{
    struct async_reader *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;
}

◆ source_query_accept()

static HRESULT source_query_accept	(	struct strmbase_pin *	iface,
		const AM_MEDIA_TYPE *	mt
	)

static

Definition at line 578 of file filesource.c.

{
    struct async_reader *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;
}

◆ source_query_interface()

static HRESULT source_query_interface	(	struct strmbase_pin *	iface,
		REFIID	iid,
		void **	out
	)

static

Definition at line 604 of file filesource.c.

{
    struct async_reader *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;
}

◆ sync_read()

static BOOL sync_read	(	HANDLE	file,
		LONGLONG	offset,
		LONG	length,
		BYTE *	buffer,
		DWORD *	read_len
	)

static

Definition at line 828 of file filesource.c.

{
    OVERLAPPED ovl = {0};
    BOOL ret;
 
    ovl.hEvent = (HANDLE)((ULONG_PTR)CreateEventW(NULL, TRUE, FALSE, NULL) | 1);
    ovl.Offset = (DWORD)offset;
    ovl.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 %lu bytes.\n", *read_len);
 
    CloseHandle(ovl.hEvent);
    return ret;
}

Referenced by FileAsyncReader_SyncRead(), and FileAsyncReader_SyncReadAligned().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( quartz )

Variable Documentation

◆ default_mt

const AM_MEDIA_TYPE default_mt

static

Initial value:

=
{
    {0xe436eb83,0x524f,0x11ce,{0x9f,0x53,0x00,0x20,0xaf,0x0b,0xa7,0x70}},   
    {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
}

Definition at line 50 of file filesource.c.

Referenced by FileSource_Load(), and source_get_media_type().

◆ FileAsyncReader_Vtbl

static const IAsyncReaderVtbl FileAsyncReader_Vtbl

static

Initial value:

= 
{
    FileAsyncReader_QueryInterface,
    FileAsyncReader_AddRef,
    FileAsyncReader_Release,
    FileAsyncReader_RequestAllocator,
    FileAsyncReader_Request,
    FileAsyncReader_WaitForNext,
    FileAsyncReader_SyncReadAligned,
    FileAsyncReader_SyncRead,
    FileAsyncReader_Length,
    FileAsyncReader_BeginFlush,
    FileAsyncReader_EndFlush,
}

Definition at line 102 of file filesource.c.

Referenced by async_reader_create().

◆ FileSource_Vtbl

static const IFileSourceFilterVtbl FileSource_Vtbl

static

Initial value:

= 
{
    FileSource_QueryInterface,
    FileSource_AddRef,
    FileSource_Release,
    FileSource_Load,
    FileSource_GetCurFile
}

Definition at line 101 of file filesource.c.

Referenced by async_reader_create().

◆ filter_ops

const struct strmbase_filter_ops filter_ops

static

Initial value:

=
{
    .filter_get_pin = async_reader_get_pin,
    .filter_destroy = async_reader_destroy,
    .filter_query_interface = async_reader_query_interface,
}

Definition at line 385 of file filesource.c.

Referenced by async_reader_create().

◆ source_ops

static const struct strmbase_source_ops source_ops

static

Initial value:

=
{
    .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,
}

Definition at line 89 of file filesource.c.

Referenced by FileSource_Load().

Classes

Functions

Variables

Function Documentation

◆ async_reader_create()

◆ async_reader_destroy()

◆ async_reader_get_pin()

◆ async_reader_query_interface()

◆ byte_from_hex_char()

◆ FileAsyncReader_AddRef()

◆ FileAsyncReader_BeginFlush()

◆ FileAsyncReader_EndFlush()

◆ FileAsyncReader_Length()

◆ FileAsyncReader_QueryInterface()

◆ FileAsyncReader_Release()

◆ FileAsyncReader_Request()

◆ FileAsyncReader_RequestAllocator()

◆ FileAsyncReader_SyncRead()

◆ FileAsyncReader_SyncReadAligned()

◆ FileAsyncReader_WaitForNext()

◆ FileAsyncReaderPin_AttemptConnection()

◆ FileSource_AddRef()

◆ FileSource_GetCurFile()

◆ FileSource_Load()

◆ FileSource_QueryInterface()

◆ FileSource_Release()

◆ get_media_type()

◆ impl_from_IAsyncReader()

◆ impl_from_IFileSourceFilter()

◆ impl_from_strmbase_filter()

◆ impl_from_strmbase_pin()

◆ io_thread()

◆ process_pattern_string()

◆ source_get_media_type()

◆ source_query_accept()

◆ source_query_interface()

◆ sync_read()

◆ WINE_DEFAULT_DEBUG_CHANNEL()

Variable Documentation

◆ default_mt

◆ FileAsyncReader_Vtbl

◆ FileSource_Vtbl

◆ filter_ops

◆ source_ops