2019-01-29 03:31:00 +01:00
|
|
|
/*
|
|
|
|
* Copyright 2018 Alistair Leslie-Hughes
|
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdarg.h>
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
#define COBJMACROS
|
|
|
|
|
|
|
|
#include "windef.h"
|
|
|
|
#include "winbase.h"
|
|
|
|
#include "winuser.h"
|
|
|
|
#include "winreg.h"
|
|
|
|
|
2019-04-09 12:45:10 +02:00
|
|
|
#include "initguid.h"
|
|
|
|
#include "ole2.h"
|
|
|
|
|
|
|
|
DEFINE_GUID(GUID_NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
|
|
|
|
|
2019-03-11 11:28:07 +01:00
|
|
|
#undef INITGUID
|
2019-04-09 12:45:10 +02:00
|
|
|
#include "guiddef.h"
|
2019-01-29 03:31:00 +01:00
|
|
|
#include "mfapi.h"
|
|
|
|
#include "mfidl.h"
|
|
|
|
#include "mferror.h"
|
|
|
|
#include "mfreadwrite.h"
|
|
|
|
|
2019-04-09 12:45:10 +02:00
|
|
|
#include "wine/heap.h"
|
2019-01-29 03:31:00 +01:00
|
|
|
#include "wine/test.h"
|
|
|
|
|
|
|
|
static HRESULT (WINAPI *pMFCreateMFByteStreamOnStream)(IStream *stream, IMFByteStream **bytestream);
|
|
|
|
|
|
|
|
static void init_functions(void)
|
|
|
|
{
|
|
|
|
HMODULE mod = GetModuleHandleA("mfplat.dll");
|
|
|
|
|
|
|
|
#define X(f) if (!(p##f = (void*)GetProcAddress(mod, #f))) return;
|
|
|
|
X(MFCreateMFByteStreamOnStream);
|
|
|
|
#undef X
|
|
|
|
}
|
|
|
|
|
2019-11-04 21:02:45 +01:00
|
|
|
enum source_state
|
|
|
|
{
|
|
|
|
SOURCE_STOPPED = 0,
|
|
|
|
SOURCE_RUNNING,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct test_media_stream
|
|
|
|
{
|
|
|
|
IMFMediaStream IMFMediaStream_iface;
|
|
|
|
LONG refcount;
|
|
|
|
IMFMediaSource *source;
|
|
|
|
IMFStreamDescriptor *sd;
|
|
|
|
IMFMediaEventQueue *event_queue;
|
|
|
|
BOOL is_new;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct test_media_stream *impl_from_IMFMediaStream(IMFMediaStream *iface)
|
|
|
|
{
|
|
|
|
return CONTAINING_RECORD(iface, struct test_media_stream, IMFMediaStream_iface);
|
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI test_media_stream_QueryInterface(IMFMediaStream *iface, REFIID riid, void **out)
|
|
|
|
{
|
|
|
|
if (IsEqualIID(riid, &IID_IMFMediaStream)
|
|
|
|
|| IsEqualIID(riid, &IID_IMFMediaEventGenerator)
|
|
|
|
|| IsEqualIID(riid, &IID_IUnknown))
|
|
|
|
{
|
|
|
|
*out = iface;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
*out = NULL;
|
|
|
|
return E_NOINTERFACE;
|
|
|
|
}
|
|
|
|
|
|
|
|
IMFMediaStream_AddRef(iface);
|
|
|
|
return S_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ULONG WINAPI test_media_stream_AddRef(IMFMediaStream *iface)
|
|
|
|
{
|
|
|
|
struct test_media_stream *stream = impl_from_IMFMediaStream(iface);
|
|
|
|
return InterlockedIncrement(&stream->refcount);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ULONG WINAPI test_media_stream_Release(IMFMediaStream *iface)
|
|
|
|
{
|
|
|
|
struct test_media_stream *stream = impl_from_IMFMediaStream(iface);
|
|
|
|
ULONG refcount = InterlockedDecrement(&stream->refcount);
|
|
|
|
|
|
|
|
if (!refcount)
|
|
|
|
{
|
|
|
|
IMFMediaEventQueue_Release(stream->event_queue);
|
|
|
|
heap_free(stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
return refcount;
|
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI test_media_stream_GetEvent(IMFMediaStream *iface, DWORD flags, IMFMediaEvent **event)
|
|
|
|
{
|
|
|
|
struct test_media_stream *stream = impl_from_IMFMediaStream(iface);
|
|
|
|
return IMFMediaEventQueue_GetEvent(stream->event_queue, flags, event);
|
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI test_media_stream_BeginGetEvent(IMFMediaStream *iface, IMFAsyncCallback *callback, IUnknown *state)
|
|
|
|
{
|
|
|
|
struct test_media_stream *stream = impl_from_IMFMediaStream(iface);
|
|
|
|
ok(callback != NULL && state == (IUnknown *)iface, "Unexpected arguments.\n");
|
|
|
|
return IMFMediaEventQueue_BeginGetEvent(stream->event_queue, callback, state);
|
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI test_media_stream_EndGetEvent(IMFMediaStream *iface, IMFAsyncResult *result, IMFMediaEvent **event)
|
|
|
|
{
|
|
|
|
struct test_media_stream *stream = impl_from_IMFMediaStream(iface);
|
|
|
|
ok(!!result && !!event, "Unexpected arguments.\n");
|
|
|
|
return IMFMediaEventQueue_EndGetEvent(stream->event_queue, result, event);
|
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI test_media_stream_QueueEvent(IMFMediaStream *iface, MediaEventType event_type, REFGUID ext_type,
|
|
|
|
HRESULT hr, const PROPVARIANT *value)
|
|
|
|
{
|
|
|
|
struct test_media_stream *stream = impl_from_IMFMediaStream(iface);
|
|
|
|
return IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, event_type, ext_type, hr, value);
|
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI test_media_stream_GetMediaSource(IMFMediaStream *iface, IMFMediaSource **source)
|
|
|
|
{
|
|
|
|
struct test_media_stream *stream = impl_from_IMFMediaStream(iface);
|
|
|
|
|
|
|
|
*source = stream->source;
|
|
|
|
IMFMediaSource_AddRef(*source);
|
|
|
|
|
|
|
|
return S_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI test_media_stream_GetStreamDescriptor(IMFMediaStream *iface, IMFStreamDescriptor **sd)
|
|
|
|
{
|
|
|
|
struct test_media_stream *stream = impl_from_IMFMediaStream(iface);
|
|
|
|
|
|
|
|
*sd = stream->sd;
|
|
|
|
IMFStreamDescriptor_AddRef(*sd);
|
|
|
|
|
|
|
|
return S_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI test_media_stream_RequestSample(IMFMediaStream *iface, IUnknown *token)
|
|
|
|
{
|
|
|
|
struct test_media_stream *stream = impl_from_IMFMediaStream(iface);
|
|
|
|
IMFMediaBuffer *buffer;
|
|
|
|
IMFSample *sample;
|
|
|
|
HRESULT hr;
|
|
|
|
|
|
|
|
hr = MFCreateSample(&sample);
|
|
|
|
ok(hr == S_OK, "Failed to create a sample, hr %#x.\n", hr);
|
|
|
|
hr = IMFSample_SetSampleTime(sample, 123);
|
|
|
|
ok(hr == S_OK, "Failed to set sample time, hr %#x.\n", hr);
|
|
|
|
if (token)
|
|
|
|
IMFSample_SetUnknown(sample, &MFSampleExtension_Token, token);
|
|
|
|
|
|
|
|
/* Reader expects buffers, empty samples are considered an error. */
|
|
|
|
hr = MFCreateMemoryBuffer(8, &buffer);
|
|
|
|
ok(hr == S_OK, "Failed to create a buffer, hr %#x.\n", hr);
|
|
|
|
hr = IMFSample_AddBuffer(sample, buffer);
|
|
|
|
ok(hr == S_OK, "Failed to add a buffer, hr %#x.\n", hr);
|
|
|
|
IMFMediaBuffer_Release(buffer);
|
|
|
|
|
|
|
|
hr = IMFMediaEventQueue_QueueEventParamUnk(stream->event_queue, MEMediaSample, &GUID_NULL, S_OK,
|
|
|
|
(IUnknown *)sample);
|
|
|
|
ok(hr == S_OK, "Failed to submit event, hr %#x.\n", hr);
|
|
|
|
IMFSample_Release(sample);
|
|
|
|
|
|
|
|
return S_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const IMFMediaStreamVtbl test_media_stream_vtbl =
|
|
|
|
{
|
|
|
|
test_media_stream_QueryInterface,
|
|
|
|
test_media_stream_AddRef,
|
|
|
|
test_media_stream_Release,
|
|
|
|
test_media_stream_GetEvent,
|
|
|
|
test_media_stream_BeginGetEvent,
|
|
|
|
test_media_stream_EndGetEvent,
|
|
|
|
test_media_stream_QueueEvent,
|
|
|
|
test_media_stream_GetMediaSource,
|
|
|
|
test_media_stream_GetStreamDescriptor,
|
|
|
|
test_media_stream_RequestSample,
|
|
|
|
};
|
|
|
|
|
|
|
|
#define TEST_SOURCE_NUM_STREAMS 3
|
|
|
|
|
|
|
|
struct test_source
|
|
|
|
{
|
|
|
|
IMFMediaSource IMFMediaSource_iface;
|
|
|
|
LONG refcount;
|
|
|
|
IMFMediaEventQueue *event_queue;
|
|
|
|
IMFPresentationDescriptor *pd;
|
|
|
|
struct test_media_stream *streams[TEST_SOURCE_NUM_STREAMS];
|
|
|
|
enum source_state state;
|
|
|
|
CRITICAL_SECTION cs;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct test_source *impl_from_IMFMediaSource(IMFMediaSource *iface)
|
|
|
|
{
|
|
|
|
return CONTAINING_RECORD(iface, struct test_source, IMFMediaSource_iface);
|
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI test_source_QueryInterface(IMFMediaSource *iface, REFIID riid, void **out)
|
|
|
|
{
|
|
|
|
if (IsEqualIID(riid, &IID_IMFMediaSource)
|
|
|
|
|| IsEqualIID(riid, &IID_IMFMediaEventGenerator)
|
|
|
|
|| IsEqualIID(riid, &IID_IUnknown))
|
|
|
|
{
|
|
|
|
*out = iface;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
*out = NULL;
|
|
|
|
return E_NOINTERFACE;
|
|
|
|
}
|
|
|
|
|
|
|
|
IMFMediaSource_AddRef(iface);
|
|
|
|
return S_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ULONG WINAPI test_source_AddRef(IMFMediaSource *iface)
|
|
|
|
{
|
|
|
|
struct test_source *source = impl_from_IMFMediaSource(iface);
|
|
|
|
return InterlockedIncrement(&source->refcount);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ULONG WINAPI test_source_Release(IMFMediaSource *iface)
|
|
|
|
{
|
|
|
|
struct test_source *source = impl_from_IMFMediaSource(iface);
|
|
|
|
ULONG refcount = InterlockedDecrement(&source->refcount);
|
|
|
|
|
|
|
|
if (!refcount)
|
|
|
|
{
|
|
|
|
IMFMediaEventQueue_Release(source->event_queue);
|
|
|
|
heap_free(source);
|
|
|
|
}
|
|
|
|
|
|
|
|
return refcount;
|
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI test_source_GetEvent(IMFMediaSource *iface, DWORD flags, IMFMediaEvent **event)
|
|
|
|
{
|
|
|
|
struct test_source *source = impl_from_IMFMediaSource(iface);
|
|
|
|
return IMFMediaEventQueue_GetEvent(source->event_queue, flags, event);
|
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI test_source_BeginGetEvent(IMFMediaSource *iface, IMFAsyncCallback *callback, IUnknown *state)
|
|
|
|
{
|
|
|
|
struct test_source *source = impl_from_IMFMediaSource(iface);
|
|
|
|
ok(callback != NULL && state == (IUnknown *)iface, "Unexpected arguments source %p, %p, state %p.\n", iface, callback, state);
|
|
|
|
return IMFMediaEventQueue_BeginGetEvent(source->event_queue, callback, state);
|
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI test_source_EndGetEvent(IMFMediaSource *iface, IMFAsyncResult *result, IMFMediaEvent **event)
|
|
|
|
{
|
|
|
|
struct test_source *source = impl_from_IMFMediaSource(iface);
|
|
|
|
return IMFMediaEventQueue_EndGetEvent(source->event_queue, result, event);
|
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI test_source_QueueEvent(IMFMediaSource *iface, MediaEventType event_type, REFGUID ext_type,
|
|
|
|
HRESULT hr, const PROPVARIANT *value)
|
|
|
|
{
|
|
|
|
struct test_source *source = impl_from_IMFMediaSource(iface);
|
|
|
|
return IMFMediaEventQueue_QueueEventParamVar(source->event_queue, event_type, ext_type, hr, value);
|
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI test_source_GetCharacteristics(IMFMediaSource *iface, DWORD *flags)
|
|
|
|
{
|
|
|
|
*flags = MFMEDIASOURCE_CAN_SEEK;
|
|
|
|
|
|
|
|
return S_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI test_source_CreatePresentationDescriptor(IMFMediaSource *iface, IMFPresentationDescriptor **pd)
|
|
|
|
{
|
|
|
|
struct test_source *source = impl_from_IMFMediaSource(iface);
|
|
|
|
IMFStreamDescriptor *sds[ARRAY_SIZE(source->streams)];
|
|
|
|
IMFMediaType *media_type;
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
EnterCriticalSection(&source->cs);
|
|
|
|
|
|
|
|
if (source->pd)
|
|
|
|
{
|
|
|
|
*pd = source->pd;
|
|
|
|
IMFPresentationDescriptor_AddRef(*pd);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
for (i = 0; i < ARRAY_SIZE(source->streams); ++i)
|
|
|
|
{
|
|
|
|
MFCreateMediaType(&media_type);
|
|
|
|
|
|
|
|
IMFMediaType_SetGUID(media_type, &MF_MT_MAJOR_TYPE, &MFMediaType_Audio);
|
|
|
|
IMFMediaType_SetGUID(media_type, &MF_MT_SUBTYPE, &MFAudioFormat_PCM);
|
|
|
|
|
|
|
|
MFCreateStreamDescriptor(i, 1, &media_type, &sds[i]);
|
|
|
|
|
|
|
|
IMFMediaType_Release(media_type);
|
|
|
|
}
|
|
|
|
|
|
|
|
MFCreatePresentationDescriptor(ARRAY_SIZE(sds), sds, &source->pd);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(sds); ++i)
|
|
|
|
IMFStreamDescriptor_Release(sds[i]);
|
|
|
|
|
|
|
|
*pd = source->pd;
|
|
|
|
IMFPresentationDescriptor_AddRef(*pd);
|
|
|
|
}
|
|
|
|
|
|
|
|
LeaveCriticalSection(&source->cs);
|
|
|
|
|
|
|
|
return hr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static BOOL is_stream_selected(IMFPresentationDescriptor *pd, DWORD index)
|
|
|
|
{
|
|
|
|
IMFStreamDescriptor *sd;
|
|
|
|
BOOL selected = FALSE;
|
|
|
|
|
|
|
|
if (SUCCEEDED(IMFPresentationDescriptor_GetStreamDescriptorByIndex(pd, index, &selected, &sd)))
|
|
|
|
IMFStreamDescriptor_Release(sd);
|
|
|
|
|
|
|
|
return selected;
|
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI test_source_Start(IMFMediaSource *iface, IMFPresentationDescriptor *pd, const GUID *time_format,
|
|
|
|
const PROPVARIANT *start_position)
|
|
|
|
{
|
|
|
|
struct test_source *source = impl_from_IMFMediaSource(iface);
|
|
|
|
MediaEventType event_type;
|
|
|
|
PROPVARIANT var;
|
|
|
|
int i;
|
|
|
|
|
2019-11-20 11:12:17 +01:00
|
|
|
ok(time_format && IsEqualGUID(time_format, &GUID_NULL), "Unexpected time format %s.\n",
|
|
|
|
wine_dbgstr_guid(time_format));
|
|
|
|
ok(start_position && (start_position->vt == VT_I8 || start_position->vt == VT_EMPTY),
|
|
|
|
"Unexpected position type.\n");
|
|
|
|
|
2019-11-04 21:02:45 +01:00
|
|
|
EnterCriticalSection(&source->cs);
|
|
|
|
|
|
|
|
event_type = source->state == SOURCE_RUNNING ? MESourceSeeked : MESourceStarted;
|
|
|
|
IMFMediaEventQueue_QueueEventParamVar(source->event_queue, event_type, &GUID_NULL, S_OK, NULL);
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(source->streams); ++i)
|
|
|
|
{
|
|
|
|
if (!is_stream_selected(pd, i))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
var.vt = VT_UNKNOWN;
|
|
|
|
var.punkVal = (IUnknown *)&source->streams[i]->IMFMediaStream_iface;
|
|
|
|
event_type = source->streams[i]->is_new ? MENewStream : MEUpdatedStream;
|
|
|
|
source->streams[i]->is_new = FALSE;
|
|
|
|
IMFMediaEventQueue_QueueEventParamVar(source->event_queue, event_type, &GUID_NULL, S_OK, &var);
|
|
|
|
|
|
|
|
event_type = source->state == SOURCE_RUNNING ? MEStreamSeeked : MEStreamStarted;
|
|
|
|
IMFMediaEventQueue_QueueEventParamVar(source->streams[i]->event_queue, event_type, &GUID_NULL,
|
|
|
|
S_OK, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
source->state = SOURCE_RUNNING;
|
|
|
|
|
|
|
|
LeaveCriticalSection(&source->cs);
|
|
|
|
|
|
|
|
return S_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI test_source_Stop(IMFMediaSource *iface)
|
|
|
|
{
|
|
|
|
ok(0, "Unexpected call.\n");
|
|
|
|
return E_NOTIMPL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI test_source_Pause(IMFMediaSource *iface)
|
|
|
|
{
|
|
|
|
ok(0, "Unexpected call.\n");
|
|
|
|
return E_NOTIMPL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI test_source_Shutdown(IMFMediaSource *iface)
|
|
|
|
{
|
|
|
|
struct test_source *source = impl_from_IMFMediaSource(iface);
|
|
|
|
|
|
|
|
IMFMediaEventQueue_Shutdown(source->event_queue);
|
|
|
|
|
|
|
|
return S_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const IMFMediaSourceVtbl test_source_vtbl =
|
|
|
|
{
|
|
|
|
test_source_QueryInterface,
|
|
|
|
test_source_AddRef,
|
|
|
|
test_source_Release,
|
|
|
|
test_source_GetEvent,
|
|
|
|
test_source_BeginGetEvent,
|
|
|
|
test_source_EndGetEvent,
|
|
|
|
test_source_QueueEvent,
|
|
|
|
test_source_GetCharacteristics,
|
|
|
|
test_source_CreatePresentationDescriptor,
|
|
|
|
test_source_Start,
|
|
|
|
test_source_Stop,
|
|
|
|
test_source_Pause,
|
|
|
|
test_source_Shutdown,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct test_media_stream *create_test_stream(DWORD stream_index, IMFMediaSource *source)
|
|
|
|
{
|
|
|
|
struct test_media_stream *stream;
|
|
|
|
IMFPresentationDescriptor *pd;
|
|
|
|
BOOL selected;
|
|
|
|
|
|
|
|
stream = heap_alloc_zero(sizeof(*stream));
|
|
|
|
stream->IMFMediaStream_iface.lpVtbl = &test_media_stream_vtbl;
|
|
|
|
stream->refcount = 1;
|
|
|
|
MFCreateEventQueue(&stream->event_queue);
|
|
|
|
stream->source = source;
|
|
|
|
IMFMediaSource_AddRef(stream->source);
|
|
|
|
stream->is_new = TRUE;
|
|
|
|
|
|
|
|
IMFMediaSource_CreatePresentationDescriptor(source, &pd);
|
|
|
|
IMFPresentationDescriptor_GetStreamDescriptorByIndex(pd, stream_index, &selected, &stream->sd);
|
|
|
|
IMFPresentationDescriptor_Release(pd);
|
|
|
|
|
|
|
|
return stream;
|
|
|
|
}
|
|
|
|
|
|
|
|
static IMFMediaSource *create_test_source(void)
|
|
|
|
{
|
|
|
|
struct test_source *source;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
source = heap_alloc_zero(sizeof(*source));
|
|
|
|
source->IMFMediaSource_iface.lpVtbl = &test_source_vtbl;
|
|
|
|
source->refcount = 1;
|
|
|
|
MFCreateEventQueue(&source->event_queue);
|
|
|
|
InitializeCriticalSection(&source->cs);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(source->streams); ++i)
|
|
|
|
source->streams[i] = create_test_stream(i, &source->IMFMediaSource_iface);
|
|
|
|
|
|
|
|
return &source->IMFMediaSource_iface;
|
|
|
|
}
|
|
|
|
|
2019-04-09 12:45:10 +02:00
|
|
|
static IMFByteStream *get_resource_stream(const char *name)
|
|
|
|
{
|
|
|
|
IMFByteStream *bytestream;
|
|
|
|
IStream *stream;
|
|
|
|
DWORD written;
|
|
|
|
HRESULT hr;
|
|
|
|
HRSRC res;
|
|
|
|
void *ptr;
|
|
|
|
|
|
|
|
res = FindResourceA(NULL, name, (const char *)RT_RCDATA);
|
|
|
|
ok(res != 0, "Resource %s wasn't found.\n", name);
|
|
|
|
|
|
|
|
ptr = LockResource(LoadResource(GetModuleHandleA(NULL), res));
|
|
|
|
|
|
|
|
hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
|
|
|
|
ok(hr == S_OK, "Failed to create memory stream, hr %#x.\n", hr);
|
|
|
|
|
|
|
|
hr = IStream_Write(stream, ptr, SizeofResource(GetModuleHandleA(NULL), res), &written);
|
|
|
|
ok(hr == S_OK, "Failed to write stream content, hr %#x.\n", hr);
|
|
|
|
|
|
|
|
hr = pMFCreateMFByteStreamOnStream(stream, &bytestream);
|
|
|
|
ok(hr == S_OK, "Failed to create bytestream, hr %#x.\n", hr);
|
|
|
|
IStream_Release(stream);
|
|
|
|
|
|
|
|
return bytestream;
|
|
|
|
}
|
|
|
|
|
2019-02-21 13:34:57 +01:00
|
|
|
static void test_factory(void)
|
|
|
|
{
|
|
|
|
IMFReadWriteClassFactory *factory, *factory2;
|
|
|
|
HRESULT hr;
|
|
|
|
|
2019-02-21 13:34:58 +01:00
|
|
|
CoInitialize(NULL);
|
|
|
|
|
2019-02-21 13:34:57 +01:00
|
|
|
hr = CoCreateInstance(&CLSID_MFReadWriteClassFactory, NULL, CLSCTX_INPROC_SERVER, &IID_IMFReadWriteClassFactory,
|
|
|
|
(void **)&factory);
|
|
|
|
ok(hr == S_OK, "Failed to create class factory, hr %#x.\n", hr);
|
|
|
|
|
|
|
|
hr = CoCreateInstance(&CLSID_MFReadWriteClassFactory, (IUnknown *)factory, CLSCTX_INPROC_SERVER, &IID_IMFReadWriteClassFactory,
|
|
|
|
(void **)&factory2);
|
|
|
|
ok(hr == CLASS_E_NOAGGREGATION, "Unexpected hr %#x.\n", hr);
|
|
|
|
|
|
|
|
IMFReadWriteClassFactory_Release(factory);
|
2019-02-21 13:34:58 +01:00
|
|
|
|
|
|
|
CoUninitialize();
|
2019-02-21 13:34:57 +01:00
|
|
|
}
|
|
|
|
|
2019-04-09 12:45:10 +02:00
|
|
|
struct async_callback
|
|
|
|
{
|
|
|
|
IMFSourceReaderCallback IMFSourceReaderCallback_iface;
|
|
|
|
LONG refcount;
|
|
|
|
HANDLE event;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct async_callback *impl_from_IMFSourceReaderCallback(IMFSourceReaderCallback *iface)
|
|
|
|
{
|
|
|
|
return CONTAINING_RECORD(iface, struct async_callback, IMFSourceReaderCallback_iface);
|
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI async_callback_QueryInterface(IMFSourceReaderCallback *iface, REFIID riid, void **out)
|
|
|
|
{
|
|
|
|
if (IsEqualIID(riid, &IID_IMFSourceReaderCallback) ||
|
|
|
|
IsEqualIID(riid, &IID_IUnknown))
|
|
|
|
{
|
|
|
|
*out = iface;
|
|
|
|
IMFSourceReaderCallback_AddRef(iface);
|
|
|
|
return S_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
*out = NULL;
|
|
|
|
return E_NOINTERFACE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ULONG WINAPI async_callback_AddRef(IMFSourceReaderCallback *iface)
|
|
|
|
{
|
|
|
|
struct async_callback *callback = impl_from_IMFSourceReaderCallback(iface);
|
|
|
|
return InterlockedIncrement(&callback->refcount);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ULONG WINAPI async_callback_Release(IMFSourceReaderCallback *iface)
|
|
|
|
{
|
|
|
|
struct async_callback *callback = impl_from_IMFSourceReaderCallback(iface);
|
|
|
|
ULONG refcount = InterlockedDecrement(&callback->refcount);
|
|
|
|
|
|
|
|
if (!refcount)
|
|
|
|
{
|
|
|
|
heap_free(callback);
|
|
|
|
}
|
|
|
|
|
|
|
|
return refcount;
|
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI async_callback_OnReadSample(IMFSourceReaderCallback *iface, HRESULT hr, DWORD stream_index,
|
|
|
|
DWORD stream_flags, LONGLONG timestamp, IMFSample *sample)
|
|
|
|
{
|
|
|
|
ok(0, "Unexpected call.\n");
|
|
|
|
return E_NOTIMPL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI async_callback_OnFlush(IMFSourceReaderCallback *iface, DWORD stream_index)
|
|
|
|
{
|
|
|
|
ok(0, "Unexpected call.\n");
|
|
|
|
return E_NOTIMPL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static HRESULT WINAPI async_callback_OnEvent(IMFSourceReaderCallback *iface, DWORD stream_index, IMFMediaEvent *event)
|
|
|
|
{
|
|
|
|
ok(0, "Unexpected call.\n");
|
|
|
|
return E_NOTIMPL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const IMFSourceReaderCallbackVtbl async_callback_vtbl =
|
|
|
|
{
|
|
|
|
async_callback_QueryInterface,
|
|
|
|
async_callback_AddRef,
|
|
|
|
async_callback_Release,
|
|
|
|
async_callback_OnReadSample,
|
|
|
|
async_callback_OnFlush,
|
|
|
|
async_callback_OnEvent,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct async_callback *create_async_callback(void)
|
|
|
|
{
|
|
|
|
struct async_callback *callback;
|
|
|
|
|
|
|
|
callback = heap_alloc(sizeof(*callback));
|
|
|
|
callback->IMFSourceReaderCallback_iface.lpVtbl = &async_callback_vtbl;
|
|
|
|
callback->refcount = 1;
|
|
|
|
|
|
|
|
return callback;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_source_reader(void)
|
|
|
|
{
|
2019-04-19 10:06:11 +02:00
|
|
|
IMFMediaType *mediatype, *mediatype2;
|
2019-04-19 10:06:15 +02:00
|
|
|
DWORD stream_flags, actual_index;
|
2019-04-09 12:45:10 +02:00
|
|
|
struct async_callback *callback;
|
|
|
|
IMFAttributes *attributes;
|
|
|
|
IMFSourceReader *reader;
|
|
|
|
IMFMediaSource *source;
|
|
|
|
IMFByteStream *stream;
|
2019-04-19 10:06:15 +02:00
|
|
|
LONGLONG timestamp;
|
|
|
|
IMFSample *sample;
|
2019-04-09 12:45:10 +02:00
|
|
|
BOOL selected;
|
|
|
|
HRESULT hr;
|
|
|
|
|
|
|
|
if (!pMFCreateMFByteStreamOnStream)
|
2019-04-10 12:37:21 +02:00
|
|
|
{
|
|
|
|
win_skip("MFCreateMFByteStreamOnStream() not found\n");
|
2019-04-09 12:45:10 +02:00
|
|
|
return;
|
2019-04-10 12:37:21 +02:00
|
|
|
}
|
2019-04-09 12:45:10 +02:00
|
|
|
|
|
|
|
stream = get_resource_stream("test.wav");
|
|
|
|
|
|
|
|
hr = MFCreateSourceReaderFromByteStream(stream, NULL, &reader);
|
|
|
|
todo_wine
|
|
|
|
ok(hr == S_OK, "Failed to create source reader, hr %#x.\n", hr);
|
|
|
|
|
|
|
|
if (FAILED(hr))
|
|
|
|
{
|
|
|
|
IMFByteStream_Release(stream);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Access underlying media source object. */
|
|
|
|
hr = IMFSourceReader_GetServiceForStream(reader, MF_SOURCE_READER_MEDIASOURCE, &GUID_NULL, &IID_IMFMediaSource,
|
|
|
|
(void **)&source);
|
|
|
|
ok(hr == S_OK, "Failed to get media source interface, hr %#x.\n", hr);
|
|
|
|
IMFMediaSource_Release(source);
|
|
|
|
|
|
|
|
/* Stream selection. */
|
|
|
|
hr = IMFSourceReader_GetStreamSelection(reader, MF_SOURCE_READER_FIRST_VIDEO_STREAM, &selected);
|
|
|
|
ok(hr == MF_E_INVALIDSTREAMNUMBER, "Unexpected hr %#x.\n", hr);
|
|
|
|
|
|
|
|
hr = IMFSourceReader_GetStreamSelection(reader, 100, &selected);
|
|
|
|
ok(hr == MF_E_INVALIDSTREAMNUMBER, "Unexpected hr %#x.\n", hr);
|
|
|
|
|
|
|
|
selected = FALSE;
|
|
|
|
hr = IMFSourceReader_GetStreamSelection(reader, MF_SOURCE_READER_FIRST_AUDIO_STREAM, &selected);
|
|
|
|
ok(hr == S_OK, "Failed to get stream selection, hr %#x.\n", hr);
|
|
|
|
ok(selected, "Unexpected selection.\n");
|
|
|
|
|
|
|
|
selected = FALSE;
|
|
|
|
hr = IMFSourceReader_GetStreamSelection(reader, 0, &selected);
|
|
|
|
ok(hr == S_OK, "Failed to get stream selection, hr %#x.\n", hr);
|
|
|
|
ok(selected, "Unexpected selection.\n");
|
|
|
|
|
|
|
|
hr = IMFSourceReader_SetStreamSelection(reader, MF_SOURCE_READER_FIRST_VIDEO_STREAM, TRUE);
|
|
|
|
ok(hr == MF_E_INVALIDSTREAMNUMBER, "Unexpected hr %#x.\n", hr);
|
|
|
|
|
|
|
|
hr = IMFSourceReader_SetStreamSelection(reader, 100, TRUE);
|
|
|
|
ok(hr == MF_E_INVALIDSTREAMNUMBER, "Unexpected hr %#x.\n", hr);
|
|
|
|
|
|
|
|
hr = IMFSourceReader_SetStreamSelection(reader, MF_SOURCE_READER_FIRST_AUDIO_STREAM, FALSE);
|
|
|
|
ok(hr == S_OK, "Failed to deselect a stream, hr %#x.\n", hr);
|
|
|
|
|
|
|
|
selected = TRUE;
|
|
|
|
hr = IMFSourceReader_GetStreamSelection(reader, MF_SOURCE_READER_FIRST_AUDIO_STREAM, &selected);
|
|
|
|
ok(hr == S_OK, "Failed to get stream selection, hr %#x.\n", hr);
|
|
|
|
ok(!selected, "Unexpected selection.\n");
|
|
|
|
|
|
|
|
hr = IMFSourceReader_SetStreamSelection(reader, MF_SOURCE_READER_ALL_STREAMS, TRUE);
|
|
|
|
ok(hr == S_OK, "Failed to deselect a stream, hr %#x.\n", hr);
|
|
|
|
|
|
|
|
selected = FALSE;
|
|
|
|
hr = IMFSourceReader_GetStreamSelection(reader, MF_SOURCE_READER_FIRST_AUDIO_STREAM, &selected);
|
|
|
|
ok(hr == S_OK, "Failed to get stream selection, hr %#x.\n", hr);
|
|
|
|
ok(selected, "Unexpected selection.\n");
|
|
|
|
|
|
|
|
/* Native media type. */
|
|
|
|
hr = IMFSourceReader_GetNativeMediaType(reader, MF_SOURCE_READER_FIRST_VIDEO_STREAM, 0, &mediatype);
|
|
|
|
ok(hr == MF_E_INVALIDSTREAMNUMBER, "Unexpected hr %#x.\n", hr);
|
|
|
|
|
|
|
|
hr = IMFSourceReader_GetNativeMediaType(reader, 100, 0, &mediatype);
|
|
|
|
ok(hr == MF_E_INVALIDSTREAMNUMBER, "Unexpected hr %#x.\n", hr);
|
|
|
|
|
|
|
|
hr = IMFSourceReader_GetNativeMediaType(reader, MF_SOURCE_READER_FIRST_AUDIO_STREAM, 0, &mediatype);
|
|
|
|
ok(hr == S_OK, "Failed to get native mediatype, hr %#x.\n", hr);
|
2019-04-19 10:06:11 +02:00
|
|
|
hr = IMFSourceReader_GetNativeMediaType(reader, MF_SOURCE_READER_FIRST_AUDIO_STREAM, 0, &mediatype2);
|
|
|
|
ok(hr == S_OK, "Failed to get native mediatype, hr %#x.\n", hr);
|
|
|
|
ok(mediatype != mediatype2, "Unexpected media type instance.\n");
|
|
|
|
IMFMediaType_Release(mediatype2);
|
2019-04-09 12:45:10 +02:00
|
|
|
IMFMediaType_Release(mediatype);
|
|
|
|
|
|
|
|
/* MF_SOURCE_READER_CURRENT_TYPE_INDEX is Win8+ */
|
|
|
|
hr = IMFSourceReader_GetNativeMediaType(reader, MF_SOURCE_READER_FIRST_AUDIO_STREAM,
|
|
|
|
MF_SOURCE_READER_CURRENT_TYPE_INDEX, &mediatype);
|
|
|
|
ok(hr == S_OK || broken(hr == MF_E_NO_MORE_TYPES), "Failed to get native mediatype, hr %#x.\n", hr);
|
|
|
|
if (SUCCEEDED(hr))
|
|
|
|
IMFMediaType_Release(mediatype);
|
|
|
|
|
|
|
|
hr = IMFSourceReader_GetNativeMediaType(reader, MF_SOURCE_READER_FIRST_AUDIO_STREAM, 1, &mediatype);
|
|
|
|
ok(hr == MF_E_NO_MORE_TYPES, "Unexpected hr %#x.\n", hr);
|
|
|
|
|
|
|
|
/* Current media type. */
|
|
|
|
hr = IMFSourceReader_GetCurrentMediaType(reader, MF_SOURCE_READER_FIRST_VIDEO_STREAM, &mediatype);
|
|
|
|
ok(hr == MF_E_INVALIDSTREAMNUMBER, "Unexpected hr %#x.\n", hr);
|
|
|
|
|
|
|
|
hr = IMFSourceReader_GetCurrentMediaType(reader, 100, &mediatype);
|
|
|
|
ok(hr == MF_E_INVALIDSTREAMNUMBER, "Unexpected hr %#x.\n", hr);
|
|
|
|
|
|
|
|
hr = IMFSourceReader_GetCurrentMediaType(reader, MF_SOURCE_READER_FIRST_AUDIO_STREAM, &mediatype);
|
|
|
|
ok(hr == S_OK, "Failed to get current media type, hr %#x.\n", hr);
|
|
|
|
IMFMediaType_Release(mediatype);
|
|
|
|
|
|
|
|
hr = IMFSourceReader_GetCurrentMediaType(reader, 0, &mediatype);
|
|
|
|
ok(hr == S_OK, "Failed to get current media type, hr %#x.\n", hr);
|
|
|
|
IMFMediaType_Release(mediatype);
|
|
|
|
|
2019-04-19 10:06:15 +02:00
|
|
|
hr = IMFSourceReader_ReadSample(reader, MF_SOURCE_READER_FIRST_AUDIO_STREAM, 0, &actual_index, &stream_flags,
|
|
|
|
×tamp, &sample);
|
|
|
|
ok(hr == S_OK, "Failed to get a sample, hr %#x.\n", hr);
|
|
|
|
ok(actual_index == 0, "Unexpected stream index %u\n", actual_index);
|
|
|
|
ok(!stream_flags, "Unexpected stream flags %#x.\n", stream_flags);
|
|
|
|
IMFSample_Release(sample);
|
|
|
|
|
|
|
|
/* There is no video stream. */
|
|
|
|
hr = IMFSourceReader_ReadSample(reader, MF_SOURCE_READER_FIRST_VIDEO_STREAM, 0, &actual_index, &stream_flags,
|
|
|
|
×tamp, &sample);
|
|
|
|
ok(hr == MF_E_INVALIDSTREAMNUMBER, "Unexpected hr %#x.\n", hr);
|
|
|
|
ok(actual_index == MF_SOURCE_READER_FIRST_VIDEO_STREAM, "Unexpected stream index %u\n", actual_index);
|
|
|
|
ok(stream_flags == MF_SOURCE_READERF_ERROR, "Unexpected stream flags %#x.\n", stream_flags);
|
|
|
|
|
2019-04-22 09:52:27 +02:00
|
|
|
hr = IMFSourceReader_ReadSample(reader, MF_SOURCE_READER_FIRST_VIDEO_STREAM, 0, NULL, &stream_flags, ×tamp,
|
|
|
|
&sample);
|
|
|
|
ok(hr == MF_E_INVALIDSTREAMNUMBER, "Unexpected hr %#x.\n", hr);
|
|
|
|
|
|
|
|
hr = IMFSourceReader_ReadSample(reader, MF_SOURCE_READER_FIRST_VIDEO_STREAM, 0, NULL, NULL, ×tamp, &sample);
|
|
|
|
ok(hr == E_POINTER, "Unexpected hr %#x.\n", hr);
|
|
|
|
|
2019-04-19 10:06:15 +02:00
|
|
|
hr = IMFSourceReader_ReadSample(reader, MF_SOURCE_READER_FIRST_AUDIO_STREAM, 0, &actual_index, &stream_flags,
|
|
|
|
×tamp, &sample);
|
|
|
|
ok(hr == S_OK, "Failed to get a sample, hr %#x.\n", hr);
|
|
|
|
ok(actual_index == 0, "Unexpected stream index %u\n", actual_index);
|
|
|
|
ok(stream_flags == MF_SOURCE_READERF_ENDOFSTREAM, "Unexpected stream flags %#x.\n", stream_flags);
|
|
|
|
ok(!sample, "Unexpected sample object.\n");
|
|
|
|
|
|
|
|
hr = IMFSourceReader_ReadSample(reader, MF_SOURCE_READER_FIRST_AUDIO_STREAM, MF_SOURCE_READER_CONTROLF_DRAIN,
|
|
|
|
&actual_index, &stream_flags, ×tamp, &sample);
|
|
|
|
ok(hr == S_OK, "Failed to get a sample, hr %#x.\n", hr);
|
|
|
|
ok(actual_index == 0, "Unexpected stream index %u\n", actual_index);
|
|
|
|
ok(stream_flags == MF_SOURCE_READERF_ENDOFSTREAM, "Unexpected stream flags %#x.\n", stream_flags);
|
|
|
|
ok(!sample, "Unexpected sample object.\n");
|
|
|
|
|
|
|
|
hr = IMFSourceReader_ReadSample(reader, MF_SOURCE_READER_FIRST_AUDIO_STREAM, MF_SOURCE_READER_CONTROLF_DRAIN,
|
|
|
|
&actual_index, &stream_flags, ×tamp, NULL);
|
|
|
|
ok(hr == E_POINTER, "Unexpected hr %#x.\n", hr);
|
|
|
|
|
|
|
|
hr = IMFSourceReader_ReadSample(reader, MF_SOURCE_READER_FIRST_AUDIO_STREAM, MF_SOURCE_READER_CONTROLF_DRAIN,
|
|
|
|
&actual_index, NULL, ×tamp, &sample);
|
|
|
|
ok(hr == E_POINTER, "Unexpected hr %#x.\n", hr);
|
|
|
|
|
|
|
|
hr = IMFSourceReader_ReadSample(reader, MF_SOURCE_READER_FIRST_AUDIO_STREAM, MF_SOURCE_READER_CONTROLF_DRAIN,
|
|
|
|
NULL, &stream_flags, ×tamp, &sample);
|
|
|
|
ok(hr == S_OK, "Failed to get a sample, hr %#x.\n", hr);
|
|
|
|
ok(stream_flags == MF_SOURCE_READERF_ENDOFSTREAM, "Unexpected stream flags %#x.\n", stream_flags);
|
|
|
|
ok(!sample, "Unexpected sample object.\n");
|
|
|
|
|
|
|
|
hr = IMFSourceReader_ReadSample(reader, MF_SOURCE_READER_FIRST_AUDIO_STREAM, MF_SOURCE_READER_CONTROLF_DRAIN,
|
|
|
|
&actual_index, &stream_flags, NULL, &sample);
|
|
|
|
ok(hr == S_OK, "Failed to get a sample, hr %#x.\n", hr);
|
|
|
|
ok(actual_index == 0, "Unexpected stream index %u\n", actual_index);
|
|
|
|
ok(stream_flags == MF_SOURCE_READERF_ENDOFSTREAM, "Unexpected stream flags %#x.\n", stream_flags);
|
|
|
|
ok(!sample, "Unexpected sample object.\n");
|
|
|
|
|
|
|
|
hr = IMFSourceReader_ReadSample(reader, MF_SOURCE_READER_ANY_STREAM, MF_SOURCE_READER_CONTROLF_DRAIN,
|
|
|
|
&actual_index, &stream_flags, NULL, &sample);
|
|
|
|
ok(hr == S_OK, "Failed to get a sample, hr %#x.\n", hr);
|
|
|
|
ok(actual_index == 0, "Unexpected stream index %u\n", actual_index);
|
|
|
|
ok(stream_flags == MF_SOURCE_READERF_ENDOFSTREAM, "Unexpected stream flags %#x.\n", stream_flags);
|
|
|
|
ok(!sample, "Unexpected sample object.\n");
|
|
|
|
|
2019-04-09 12:45:10 +02:00
|
|
|
/* Flush. */
|
|
|
|
hr = IMFSourceReader_Flush(reader, MF_SOURCE_READER_FIRST_VIDEO_STREAM);
|
|
|
|
ok(hr == MF_E_INVALIDSTREAMNUMBER, "Unexpected hr %#x.\n", hr);
|
|
|
|
|
|
|
|
hr = IMFSourceReader_Flush(reader, 100);
|
|
|
|
ok(hr == MF_E_INVALIDSTREAMNUMBER, "Unexpected hr %#x.\n", hr);
|
|
|
|
|
|
|
|
hr = IMFSourceReader_Flush(reader, MF_SOURCE_READER_FIRST_AUDIO_STREAM);
|
|
|
|
ok(hr == S_OK, "Failed to flush stream, hr %#x.\n", hr);
|
|
|
|
|
|
|
|
hr = IMFSourceReader_Flush(reader, MF_SOURCE_READER_FIRST_AUDIO_STREAM);
|
|
|
|
ok(hr == S_OK, "Failed to flush stream, hr %#x.\n", hr);
|
|
|
|
|
|
|
|
hr = IMFSourceReader_Flush(reader, MF_SOURCE_READER_ALL_STREAMS);
|
|
|
|
ok(hr == S_OK, "Failed to flush all streams, hr %#x.\n", hr);
|
|
|
|
|
|
|
|
IMFSourceReader_Release(reader);
|
|
|
|
|
|
|
|
/* Async mode. */
|
|
|
|
callback = create_async_callback();
|
|
|
|
|
|
|
|
hr = MFCreateAttributes(&attributes, 1);
|
|
|
|
ok(hr == S_OK, "Failed to create attributes object, hr %#x.\n", hr);
|
|
|
|
|
|
|
|
hr = IMFAttributes_SetUnknown(attributes, &MF_SOURCE_READER_ASYNC_CALLBACK,
|
|
|
|
(IUnknown *)&callback->IMFSourceReaderCallback_iface);
|
|
|
|
ok(hr == S_OK, "Failed to set attribute value, hr %#x.\n", hr);
|
|
|
|
IMFSourceReaderCallback_Release(&callback->IMFSourceReaderCallback_iface);
|
|
|
|
|
|
|
|
hr = MFCreateSourceReaderFromByteStream(stream, attributes, &reader);
|
|
|
|
ok(hr == S_OK, "Failed to create source reader, hr %#x.\n", hr);
|
|
|
|
IMFAttributes_Release(attributes);
|
|
|
|
|
|
|
|
IMFSourceReader_Release(reader);
|
|
|
|
|
|
|
|
IMFByteStream_Release(stream);
|
|
|
|
}
|
|
|
|
|
2019-11-04 21:02:45 +01:00
|
|
|
static void test_source_reader_from_media_source(void)
|
|
|
|
{
|
|
|
|
struct async_callback *callback;
|
|
|
|
IMFSourceReader *reader;
|
|
|
|
IMFMediaSource *source;
|
|
|
|
HRESULT hr;
|
|
|
|
DWORD actual_index, stream_flags;
|
|
|
|
IMFSample *sample;
|
|
|
|
LONGLONG timestamp;
|
|
|
|
IMFAttributes *attributes;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
source = create_test_source();
|
|
|
|
ok(!!source, "Failed to create test source.\n");
|
|
|
|
|
|
|
|
hr = MFCreateSourceReaderFromMediaSource(source, NULL, &reader);
|
|
|
|
ok(hr == S_OK, "Failed to create source reader, hr %#x.\n", hr);
|
|
|
|
|
|
|
|
/* MF_SOURCE_READER_ANY_STREAM */
|
|
|
|
hr = IMFSourceReader_SetStreamSelection(reader, 0, FALSE);
|
|
|
|
ok(hr == S_OK, "Failed to select a stream, hr %#x.\n", hr);
|
|
|
|
|
|
|
|
hr = IMFSourceReader_SetStreamSelection(reader, 1, TRUE);
|
|
|
|
ok(hr == S_OK, "Failed to select a stream, hr %#x.\n", hr);
|
|
|
|
|
|
|
|
hr = IMFSourceReader_ReadSample(reader, MF_SOURCE_READER_ANY_STREAM, 0, &actual_index, &stream_flags,
|
|
|
|
×tamp, &sample);
|
|
|
|
todo_wine {
|
|
|
|
ok(hr == S_OK, "Failed to get a sample, hr %#x.\n", hr);
|
|
|
|
if (SUCCEEDED(hr))
|
|
|
|
{
|
|
|
|
ok(actual_index == 1, "Unexpected stream index %u\n", actual_index);
|
|
|
|
ok(!stream_flags, "Unexpected stream flags %#x.\n", stream_flags);
|
|
|
|
ok(timestamp == 123, "Unexpected timestamp.\n");
|
|
|
|
ok(!!sample, "Expected sample object.\n");
|
|
|
|
IMFSample_Release(sample);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
hr = IMFSourceReader_SetStreamSelection(reader, 0, TRUE);
|
|
|
|
ok(hr == S_OK, "Failed to select a stream, hr %#x.\n", hr);
|
|
|
|
|
|
|
|
hr = IMFSourceReader_SetStreamSelection(reader, 2, TRUE);
|
|
|
|
ok(hr == S_OK, "Failed to select a stream, hr %#x.\n", hr);
|
|
|
|
|
|
|
|
for (i = 0; i < 2 * TEST_SOURCE_NUM_STREAMS; ++i)
|
|
|
|
{
|
|
|
|
hr = IMFSourceReader_ReadSample(reader, MF_SOURCE_READER_ANY_STREAM, 0, &actual_index, &stream_flags,
|
|
|
|
×tamp, &sample);
|
|
|
|
todo_wine
|
|
|
|
ok(hr == S_OK, "Failed to get a sample, hr %#x.\n", hr);
|
|
|
|
if (SUCCEEDED(hr))
|
|
|
|
{
|
|
|
|
ok(actual_index == (i < TEST_SOURCE_NUM_STREAMS ? i : 0), "%d: Unexpected stream index %u\n",
|
|
|
|
i, actual_index);
|
|
|
|
ok(!stream_flags, "Unexpected stream flags %#x.\n", stream_flags);
|
|
|
|
ok(timestamp == 123, "Unexpected timestamp.\n");
|
|
|
|
ok(!!sample, "Expected sample object.\n");
|
|
|
|
IMFSample_Release(sample);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
IMFSourceReader_Release(reader);
|
|
|
|
IMFMediaSource_Release(source);
|
|
|
|
|
2019-11-20 11:12:17 +01:00
|
|
|
/* Request from stream 0. */
|
|
|
|
source = create_test_source();
|
|
|
|
ok(!!source, "Failed to create test source.\n");
|
|
|
|
|
|
|
|
hr = MFCreateSourceReaderFromMediaSource(source, NULL, &reader);
|
|
|
|
ok(hr == S_OK, "Failed to create source reader, hr %#x.\n", hr);
|
|
|
|
|
|
|
|
hr = IMFSourceReader_SetStreamSelection(reader, 0, TRUE);
|
|
|
|
ok(hr == S_OK, "Failed to select a stream, hr %#x.\n", hr);
|
|
|
|
|
|
|
|
hr = IMFSourceReader_ReadSample(reader, 0, 0, &actual_index, &stream_flags, ×tamp, &sample);
|
|
|
|
ok(hr == S_OK, "Failed to get a sample, hr %#x.\n", hr);
|
|
|
|
ok(actual_index == 0, "Unexpected stream index %u\n", actual_index);
|
|
|
|
ok(!stream_flags, "Unexpected stream flags %#x.\n", stream_flags);
|
|
|
|
ok(timestamp == 123, "Unexpected timestamp.\n");
|
|
|
|
ok(!!sample, "Expected sample object.\n");
|
|
|
|
IMFSample_Release(sample);
|
|
|
|
|
|
|
|
IMFSourceReader_Release(reader);
|
|
|
|
IMFMediaSource_Release(source);
|
|
|
|
|
2019-11-04 21:02:45 +01:00
|
|
|
/* Async mode. */
|
|
|
|
source = create_test_source();
|
|
|
|
ok(!!source, "Failed to create test source.\n");
|
|
|
|
|
2019-11-20 11:12:17 +01:00
|
|
|
callback = create_async_callback();
|
|
|
|
|
|
|
|
hr = MFCreateAttributes(&attributes, 1);
|
|
|
|
ok(hr == S_OK, "Failed to create attributes object, hr %#x.\n", hr);
|
|
|
|
|
|
|
|
hr = IMFAttributes_SetUnknown(attributes, &MF_SOURCE_READER_ASYNC_CALLBACK,
|
|
|
|
(IUnknown *)&callback->IMFSourceReaderCallback_iface);
|
|
|
|
ok(hr == S_OK, "Failed to set attribute value, hr %#x.\n", hr);
|
|
|
|
IMFSourceReaderCallback_Release(&callback->IMFSourceReaderCallback_iface);
|
|
|
|
|
2019-11-04 21:02:45 +01:00
|
|
|
hr = MFCreateSourceReaderFromMediaSource(source, attributes, &reader);
|
|
|
|
ok(hr == S_OK, "Failed to create source reader, hr %#x.\n", hr);
|
|
|
|
|
|
|
|
hr = IMFSourceReader_SetStreamSelection(reader, 0, TRUE);
|
|
|
|
ok(hr == S_OK, "Failed to select a stream, hr %#x.\n", hr);
|
|
|
|
|
|
|
|
/* Return values are delivered to callback only. */
|
|
|
|
hr = IMFSourceReader_ReadSample(reader, 0, 0, &actual_index, &stream_flags, ×tamp, &sample);
|
|
|
|
ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
|
|
|
|
|
|
|
|
hr = IMFSourceReader_ReadSample(reader, 0, 0, NULL, &stream_flags, ×tamp, &sample);
|
|
|
|
ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
|
|
|
|
|
|
|
|
hr = IMFSourceReader_ReadSample(reader, 0, 0, NULL, NULL, ×tamp, &sample);
|
|
|
|
ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
|
|
|
|
|
|
|
|
hr = IMFSourceReader_ReadSample(reader, 0, 0, NULL, NULL, NULL, &sample);
|
|
|
|
ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr);
|
|
|
|
|
|
|
|
IMFSourceReader_Release(reader);
|
|
|
|
}
|
|
|
|
|
2019-01-29 03:31:00 +01:00
|
|
|
START_TEST(mfplat)
|
|
|
|
{
|
|
|
|
HRESULT hr;
|
|
|
|
|
|
|
|
hr = MFStartup(MF_VERSION, MFSTARTUP_FULL);
|
|
|
|
ok(hr == S_OK, "got 0x%08x\n", hr);
|
|
|
|
|
|
|
|
init_functions();
|
|
|
|
|
2019-02-21 13:34:57 +01:00
|
|
|
test_factory();
|
2019-04-09 12:45:10 +02:00
|
|
|
test_source_reader();
|
2019-11-04 21:02:45 +01:00
|
|
|
test_source_reader_from_media_source();
|
2019-01-29 03:31:00 +01:00
|
|
|
|
2019-04-06 21:02:42 +02:00
|
|
|
hr = MFShutdown();
|
|
|
|
ok(hr == S_OK, "Failed to shut down, hr %#x.\n", hr);
|
2019-01-29 03:31:00 +01:00
|
|
|
}
|