ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Sweden-Number/dlls/quartz/filesource.c

1118 lines
33 KiB
C
Raw Blame History

/*
* 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 <assert.h>
WINE_DEFAULT_DEBUG_CHANNEL(quartz);
static const WCHAR wszOutputPinName[] = { 'O','u','t','p','u','t',0 };
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
};
typedef struct DATAREQUEST
{
IMediaSample *pSample;
DWORD_PTR dwUserData;
OVERLAPPED ovl;
} DATAREQUEST;
typedef struct AsyncReader
{
struct strmbase_filter filter;
IFileSourceFilter IFileSourceFilter_iface;
struct strmbase_source source;
IAsyncReader IAsyncReader_iface;
LPOLESTR pszFileName;
AM_MEDIA_TYPE *pmt;
ALLOCATOR_PROPERTIES allocProps;
HANDLE file;
BOOL flushing;
unsigned int queued_number;
unsigned int samples;
unsigned int oldest_sample;
CRITICAL_SECTION sample_cs;
DATAREQUEST *sample_list;
/* Have a handle for every sample, and then one more as flushing handle */
HANDLE *handle_list;
} 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 const WCHAR mediatype_name[] = {
'M', 'e', 'd', 'i', 'a', ' ', 'T', 'y', 'p', 'e', 0 };
static const WCHAR subtype_name[] = {
'S', 'u', 'b', 't', 'y', 'p', 'e', 0 };
static const WCHAR source_filter_name[] = {
'S','o','u','r','c','e',' ','F','i','l','t','e','r',0};
static unsigned char byte_from_hex_char(WCHAR wHex)
{
switch (towlower(wHex))
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
return (wHex - '0') & 0xf;
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
return (wHex - 'a' + 10) & 0xf;
default:
return 0;
}
}
static BOOL process_pattern_string(const WCHAR *pattern, HANDLE file)
{
ULONG size, offset, i, ret_size;
BYTE *mask, *expect, *actual;
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 (!iswxdigit(*pattern) && (*pattern != ','))
pattern++;
for (i = 0; iswxdigit(*pattern) && (i/2 < size); pattern++, i++)
{
if (i % 2)
mask[i / 2] |= byte_from_hex_char(*pattern);
else
mask[i / 2] = byte_from_hex_char(*pattern) << 4;
}
if (!(pattern = wcschr(pattern, ',')))
{
heap_free(mask);
heap_free(expect);
return FALSE;
}
pattern++;
while (!iswxdigit(*pattern) && (*pattern != ','))
pattern++;
for (i = 0; iswxdigit(*pattern) && (i/2 < size); pattern++, i++)
{
if (i % 2)
expect[i / 2] |= byte_from_hex_char(*pattern);
else
expect[i / 2] = byte_from_hex_char(*pattern) << 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, mediatype_name, NULL, NULL, (BYTE *)guidstr, &size))
CLSIDFromString(guidstr, majortype);
size = sizeof(guidstr);
if (subtype && !RegQueryValueExW(key, subtype_name, NULL, NULL, (BYTE *)guidstr, &size))
CLSIDFromString(guidstr, subtype);
size = sizeof(guidstr);
if (source_clsid && !RegQueryValueExW(key, source_filter_name, 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, source_filter_name))
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, source_filter_name,
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);
CoTaskMemFree(filter->sample_list);
if (filter->handle_list)
{
for (i = 0; i <= filter->samples; ++i)
CloseHandle(filter->handle_list[i]);
CoTaskMemFree(filter->handle_list);
}
CloseHandle(filter->file);
filter->sample_cs.DebugInfo->Spare[0] = 0;
DeleteCriticalSection(&filter->sample_cs);
strmbase_source_cleanup(&filter->source);
}
CoTaskMemFree(filter->pszFileName);
if (filter->pmt)
DeleteMediaType(filter->pmt);
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,
};
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;
pAsyncRead->pmt = 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());
}
strmbase_source_init(&This->source, &This->filter, wszOutputPinName, &source_ops);
BaseFilterImpl_IncrementPinVersion(&This->filter);
This->file = hFile;
This->flushing = FALSE;
This->sample_list = NULL;
This->handle_list = NULL;
This->queued_number = 0;
InitializeCriticalSection(&This->sample_cs);
This->sample_cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": FileAsyncReader.sample_cs");
CoTaskMemFree(This->pszFileName);
if (This->pmt)
DeleteMediaType(This->pmt);
This->pszFileName = CoTaskMemAlloc((lstrlenW(pszFileName) + 1) * sizeof(WCHAR));
lstrcpyW(This->pszFileName, pszFileName);
This->pmt = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE));
if (!pmt)
{
CopyMediaType(This->pmt, &default_mt);
if (get_media_type(pszFileName, &This->pmt->majortype, &This->pmt->subtype, NULL))
{
TRACE("Found major type %s, subtype %s.\n",
debugstr_guid(&This->pmt->majortype), debugstr_guid(&This->pmt->subtype));
}
}
else
CopyMediaType(This->pmt, pmt);
return S_OK;
}
static HRESULT WINAPI FileSource_GetCurFile(IFileSourceFilter * iface, LPOLESTR * ppszFileName, AM_MEDIA_TYPE * pmt)
{
AsyncReader *This = impl_from_IFileSourceFilter(iface);
TRACE("%p->(%p, %p)\n", This, ppszFileName, pmt);
if (!ppszFileName)
return E_POINTER;
/* copy file name & media type if available, otherwise clear the outputs */
if (This->pszFileName)
{
*ppszFileName = CoTaskMemAlloc((lstrlenW(This->pszFileName) + 1) * sizeof(WCHAR));
lstrcpyW(*ppszFileName, This->pszFileName);
}
else
*ppszFileName = NULL;
if (pmt)
{
if (This->pmt)
CopyMediaType(pmt, This->pmt);
else
ZeroMemory(pmt, sizeof(*pmt));
}
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 *pmt)
{
AsyncReader *filter = impl_from_strmbase_pin(iface);
if (IsEqualGUID(&pmt->majortype, &filter->pmt->majortype) &&
IsEqualGUID(&pmt->subtype, &filter->pmt->subtype))
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->pmt);
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);
}
#define DEF_ALIGNMENT 1
static HRESULT WINAPI FileAsyncReader_RequestAllocator(IAsyncReader * iface, IMemAllocator * pPreferred, ALLOCATOR_PROPERTIES * pProps, IMemAllocator ** ppActual)
{
AsyncReader *This = impl_from_IAsyncReader(iface);
HRESULT hr = S_OK;
TRACE("%p->(%p, %p, %p)\n", This, pPreferred, pProps, ppActual);
if (!pProps->cbAlign || (pProps->cbAlign % DEF_ALIGNMENT) != 0)
pProps->cbAlign = DEF_ALIGNMENT;
if (pPreferred)
{
hr = IMemAllocator_SetProperties(pPreferred, pProps, pProps);
/* FIXME: check we are still aligned */
if (SUCCEEDED(hr))
{
IMemAllocator_AddRef(pPreferred);
*ppActual = pPreferred;
TRACE("FileAsyncReader_RequestAllocator -- %x\n", hr);
goto done;
}
}
pPreferred = NULL;
hr = CoCreateInstance(&CLSID_MemoryAllocator, NULL, CLSCTX_INPROC, &IID_IMemAllocator, (LPVOID *)&pPreferred);
if (SUCCEEDED(hr))
{
hr = IMemAllocator_SetProperties(pPreferred, pProps, pProps);
/* FIXME: check we are still aligned */
if (SUCCEEDED(hr))
{
*ppActual = pPreferred;
TRACE("FileAsyncReader_RequestAllocator -- %x\n", hr);
}
}
done:
if (SUCCEEDED(hr))
{
CoTaskMemFree(This->sample_list);
if (This->handle_list)
{
int x;
for (x = 0; x <= This->samples; ++x)
CloseHandle(This->handle_list[x]);
CoTaskMemFree(This->handle_list);
}
This->samples = pProps->cBuffers;
This->oldest_sample = 0;
TRACE("Samples: %u\n", This->samples);
This->sample_list = CoTaskMemAlloc(sizeof(This->sample_list[0]) * pProps->cBuffers);
This->handle_list = CoTaskMemAlloc(sizeof(HANDLE) * pProps->cBuffers * 2);
if (This->sample_list && This->handle_list)
{
int x;
ZeroMemory(This->sample_list, sizeof(This->sample_list[0]) * pProps->cBuffers);
for (x = 0; x < This->samples; ++x)
{
This->sample_list[x].ovl.hEvent = This->handle_list[x] = CreateEventW(NULL, 0, 0, NULL);
if (x + 1 < This->samples)
This->handle_list[This->samples + 1 + x] = This->handle_list[x];
}
This->handle_list[This->samples] = CreateEventW(NULL, 1, 0, NULL);
This->allocProps = *pProps;
}
else
{
hr = E_OUTOFMEMORY;
CoTaskMemFree(This->sample_list);
CoTaskMemFree(This->handle_list);
This->samples = 0;
This->sample_list = NULL;
This->handle_list = NULL;
}
}
if (FAILED(hr))
{
*ppActual = NULL;
if (pPreferred)
IMemAllocator_Release(pPreferred);
}
TRACE("-- %x\n", hr);
return hr;
}
/* we could improve the Request/WaitForNext mechanism by allowing out of order samples.
* however, this would be quite complicated to do and may be a bit error prone */
static HRESULT WINAPI FileAsyncReader_Request(IAsyncReader * iface, IMediaSample * pSample, DWORD_PTR dwUser)
{
AsyncReader *This = impl_from_IAsyncReader(iface);
HRESULT hr = S_OK;
REFERENCE_TIME Start;
REFERENCE_TIME Stop;
LPBYTE pBuffer = NULL;
TRACE("%p->(%p, %lx)\n", This, pSample, dwUser);
if (!pSample)
return E_POINTER;
/* get start and stop positions in bytes */
if (SUCCEEDED(hr))
hr = IMediaSample_GetTime(pSample, &Start, &Stop);
if (SUCCEEDED(hr))
hr = IMediaSample_GetPointer(pSample, &pBuffer);
EnterCriticalSection(&This->sample_cs);
if (This->flushing)
{
LeaveCriticalSection(&This->sample_cs);
return VFW_E_WRONG_STATE;
}
if (SUCCEEDED(hr))
{
DWORD dwLength = (DWORD) BYTES_FROM_MEDIATIME(Stop - Start);
DATAREQUEST *pDataRq;
int x;
/* Try to insert above the waiting sample if possible */
for (x = This->oldest_sample; x < This->samples; ++x)
{
if (!This->sample_list[x].pSample)
break;
}
if (x >= This->samples)
for (x = 0; x < This->oldest_sample; ++x)
{
if (!This->sample_list[x].pSample)
break;
}
/* There must be a sample we have found */
assert(x < This->samples);
++This->queued_number;
pDataRq = This->sample_list + x;
pDataRq->ovl.u.s.Offset = (DWORD) BYTES_FROM_MEDIATIME(Start);
pDataRq->ovl.u.s.OffsetHigh = (DWORD)(BYTES_FROM_MEDIATIME(Start) >> (sizeof(DWORD) * 8));
pDataRq->dwUserData = dwUser;
/* we violate traditional COM rules here by maintaining
* a reference to the sample, but not calling AddRef, but
* that's what MSDN says to do */
pDataRq->pSample = pSample;
/* this is definitely not how it is implemented on Win9x
* as they do not support async reads on files, but it is
* sooo much easier to use this than messing around with threads!
*/
if (!ReadFile(This->file, pBuffer, dwLength, NULL, &pDataRq->ovl))
hr = HRESULT_FROM_WIN32(GetLastError());
/* ERROR_IO_PENDING is not actually an error since this is what we want! */
if (hr == HRESULT_FROM_WIN32(ERROR_IO_PENDING))
hr = S_OK;
}
LeaveCriticalSection(&This->sample_cs);
TRACE("-- %x\n", hr);
return hr;
}
static HRESULT WINAPI FileAsyncReader_WaitForNext(IAsyncReader * iface, DWORD dwTimeout, IMediaSample ** ppSample, DWORD_PTR * pdwUser)
{
AsyncReader *This = impl_from_IAsyncReader(iface);
HRESULT hr = S_OK;
DWORD buffer = ~0;
TRACE("%p->(%u, %p, %p)\n", This, dwTimeout, ppSample, pdwUser);
*ppSample = NULL;
*pdwUser = 0;
EnterCriticalSection(&This->sample_cs);
if (!This->flushing)
{
LONG oldest = This->oldest_sample;
if (!This->queued_number)
{
/* It could be that nothing is queued right now, but that can be fixed */
WARN("Called without samples in queue and not flushing!!\n");
}
LeaveCriticalSection(&This->sample_cs);
/* wait for an object to read, or time out */
buffer = WaitForMultipleObjectsEx(This->samples+1, This->handle_list + oldest, FALSE, dwTimeout, TRUE);
EnterCriticalSection(&This->sample_cs);
if (buffer <= This->samples)
{
/* Re-scale the buffer back to normal */
buffer += oldest;
/* Uh oh, we overshot the flusher handle, renormalize it back to 0..Samples-1 */
if (buffer > This->samples)
buffer -= This->samples + 1;
assert(buffer <= This->samples);
}
if (buffer >= This->samples)
{
if (buffer != This->samples)
{
FIXME("Returned: %u (%08x)\n", buffer, GetLastError());
hr = VFW_E_TIMEOUT;
}
else
hr = VFW_E_WRONG_STATE;
buffer = ~0;
}
else
--This->queued_number;
}
if (This->flushing && buffer == ~0)
{
for (buffer = 0; buffer < This->samples; ++buffer)
{
if (This->sample_list[buffer].pSample)
{
ResetEvent(This->handle_list[buffer]);
break;
}
}
if (buffer == This->samples)
{
assert(!This->queued_number);
hr = VFW_E_TIMEOUT;
}
else
{
--This->queued_number;
hr = S_OK;
}
}
if (SUCCEEDED(hr))
{
REFERENCE_TIME rtStart, rtStop;
DATAREQUEST *pDataRq = This->sample_list + buffer;
DWORD dwBytes = 0;
/* get any errors */
if (!This->flushing && !GetOverlappedResult(This->file, &pDataRq->ovl, &dwBytes, FALSE))
hr = HRESULT_FROM_WIN32(GetLastError());
/* Return the sample no matter what so it can be destroyed */
*ppSample = pDataRq->pSample;
*pdwUser = pDataRq->dwUserData;
if (This->flushing)
hr = VFW_E_WRONG_STATE;
if (FAILED(hr))
dwBytes = 0;
/* Set the time on the sample */
IMediaSample_SetActualDataLength(pDataRq->pSample, dwBytes);
rtStart = (DWORD64)pDataRq->ovl.u.s.Offset + ((DWORD64)pDataRq->ovl.u.s.OffsetHigh << 32);
rtStart = MEDIATIME_FROM_BYTES(rtStart);
rtStop = rtStart + MEDIATIME_FROM_BYTES(dwBytes);
IMediaSample_SetTime(pDataRq->pSample, &rtStart, &rtStop);
This->sample_list[buffer].pSample = NULL;
assert(This->oldest_sample < This->samples);
if (buffer == This->oldest_sample)
{
LONG x;
for (x = This->oldest_sample + 1; x < This->samples; ++x)
if (This->sample_list[x].pSample)
break;
if (x >= This->samples)
for (x = 0; x < This->oldest_sample; ++x)
if (This->sample_list[x].pSample)
break;
if (This->oldest_sample == x)
/* No samples found, reset to 0 */
x = 0;
This->oldest_sample = x;
}
}
LeaveCriticalSection(&This->sample_cs);
TRACE("-- %x\n", hr);
return hr;
}
static BOOL sync_read(HANDLE file, LONGLONG offset, LONG length, BYTE *buffer, DWORD *read_len)
{
OVERLAPPED ovl = {0};
BOOL ret;
ovl.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
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);
TRACE("iface %p.\n", iface);
EnterCriticalSection(&filter->sample_cs);
filter->flushing = TRUE;
CancelIoEx(filter->file, NULL);
SetEvent(filter->handle_list[filter->samples]);
LeaveCriticalSection(&filter->sample_cs);
return S_OK;
}
static HRESULT WINAPI FileAsyncReader_EndFlush(IAsyncReader * iface)
{
AsyncReader *filter = impl_from_IAsyncReader(iface);
int x;
TRACE("iface %p.\n", iface);
EnterCriticalSection(&filter->sample_cs);
ResetEvent(filter->handle_list[filter->samples]);
filter->flushing = FALSE;
for (x = 0; x < filter->samples; ++x)
assert(!filter->sample_list[x].pSample);
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,
};
Reference in New Issue View Git Blame Copy Permalink