[PATCH v4 0/4] MR3789: Improve media session handling of unexpected errors.

[Santino Mazza (＠tati1454)]

--
  v4: mf: Handle errors with source event generator in session.

https://gitlab.winehq.org/wine/wine/-/merge_requests/3789

[PATCH v4 1/4] mf/test: Test error cases in media sesssion.

[Santino Mazza]

From: Santino Mazza

---
 dlls/mf/tests/mf.c | 146 +++++++++++++++++++++++++++++++++++----------
 1 file changed, 115 insertions(+), 31 deletions(-)

diff --git a/dlls/mf/tests/mf.c b/dlls/mf/tests/mf.c
index aefc1b92b4d..1e46897bac8 100644
--- a/dlls/mf/tests/mf.c
+++ b/dlls/mf/tests/mf.c
@@ -48,18 +48,12 @@
 #define SET_EXPECT(func) \
     expect_ ## func = TRUE

-#define CHECK_EXPECT2(func) \
+#define CHECK_EXPECT(func) \
     do { \
         ok(expect_ ##func, "unexpected call " #func  "\n"); \
         called_ ## func = TRUE; \
     }while(0)

-#define CHECK_EXPECT(func) \
-    do { \
-        CHECK_EXPECT2(func);     \
-        expect_ ## func = FALSE; \
-    }while(0)
-
 #define CHECK_CALLED(func) \
     do { \
         ok(called_ ## func, "expected " #func "\n"); \
@@ -272,6 +266,7 @@ static void init_sink_node(IMFStreamSink *stream_sink, MF_CONNECT_METHOD method,
 }

DEFINE_EXPECT(test_source_BeginGetEvent);
+DEFINE_EXPECT(test_source_EndGetEvent);
 DEFINE_EXPECT(test_source_QueueEvent);
 DEFINE_EXPECT(test_source_Start);

@@ -279,7 +274,9 @@ struct test_source
 {
     IMFMediaSource IMFMediaSource_iface;
     LONG refcount;
-    HRESULT begin_get_event_res;
+    IMFMediaEventQueue *queue;
+    HRESULT begin_get_event_hr, end_get_event_hr,
+            start_hr, queue_event_hr;
     IMFPresentationDescriptor *pd;
 };

@@ -319,6 +316,8 @@ static ULONG WINAPI test_source_Release(IMFMediaSource *iface)

if (!refcount)
     {
+        IMFMediaEventQueue_Shutdown(source->queue);
+        IMFMediaEventQueue_Release(source->queue);
         IMFPresentationDescriptor_Release(source->pd);
         free(source);
     }
@@ -336,20 +335,33 @@ static HRESULT WINAPI test_source_BeginGetEvent(IMFMediaSource *iface, IMFAsyncC
 {
     struct test_source *source = impl_from_IMFMediaSource(iface);
     CHECK_EXPECT(test_source_BeginGetEvent);
-    return source->begin_get_event_res;
+    if (source->begin_get_event_hr == S_OK)
+        return IMFMediaEventQueue_BeginGetEvent(source->queue, callback, state);
+    else return source->begin_get_event_hr;
 }

static HRESULT WINAPI test_source_EndGetEvent(IMFMediaSource *iface, IMFAsyncResult *result, IMFMediaEvent **event)
 {
-    ok(0, "Unexpected call.\n");
-    return E_NOTIMPL;
+    struct test_source *source = impl_from_IMFMediaSource(iface);
+    CHECK_EXPECT(test_source_EndGetEvent);
+
+    if (source->end_get_event_hr == S_OK)
+        return IMFMediaEventQueue_EndGetEvent(source->queue, result, event);
+    else {
+        *event = NULL;
+        return source->end_get_event_hr;
+    }
 }

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);
     CHECK_EXPECT(test_source_QueueEvent);
-    return E_NOTIMPL;
+
+    if (source->queue_event_hr == S_OK)
+        return IMFMediaEventQueue_QueueEventParamVar(source->queue, event_type, ext_type, hr, value);
+    else return source->queue_event_hr;
 }

static HRESULT WINAPI test_source_GetCharacteristics(IMFMediaSource *iface, DWORD *flags)
@@ -367,8 +379,14 @@ static HRESULT WINAPI test_source_CreatePresentationDescriptor(IMFMediaSource *i
 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);
     CHECK_EXPECT(test_source_Start);
-    return E_NOTIMPL;
+    if (source->start_hr == S_OK)
+    {
+        IMFMediaEventQueue_QueueEventParamUnk(source->queue, MESourceStarted, &GUID_NULL, S_OK, NULL);
+        return S_OK;
+    }
+    else return source->start_hr;
 }

static HRESULT WINAPI test_source_Stop(IMFMediaSource *iface)
@@ -413,12 +431,25 @@ static IMFMediaSource *create_test_source(IMFPresentationDescriptor *pd)
     source = calloc(1, sizeof(*source));
     source->IMFMediaSource_iface.lpVtbl = &test_source_vtbl;
     source->refcount = 1;
-    source->begin_get_event_res = E_NOTIMPL;
+    source->begin_get_event_hr = E_NOTIMPL;
+    source->end_get_event_hr = E_NOTIMPL;
+    source->queue_event_hr = E_NOTIMPL;
+    source->start_hr = E_NOTIMPL;
+    MFCreateEventQueue(&source->queue);
     IMFPresentationDescriptor_AddRef((source->pd = pd));

return &source->IMFMediaSource_iface;
 }

+static void test_media_source_reinitialize_queue(IMFMediaSource *iface)
+{
+    struct test_source *source = impl_from_IMFMediaSource(iface);
+
+    IMFMediaEventQueue_Shutdown(source->queue);
+    IMFMediaEventQueue_Release(source->queue);
+    MFCreateEventQueue(&source->queue);
+}
+
 static HRESULT WINAPI test_unk_QueryInterface(IUnknown *iface, REFIID riid, void **obj)
 {
     if (IsEqualIID(riid, &IID_IUnknown))
@@ -2495,6 +2526,9 @@ static void test_media_session_events(void)
     /* test IMFMediaSession_Start with source returning an error in BeginGetEvent */
     source_impl = impl_from_IMFMediaSource(source);

+    source_impl->begin_get_event_hr = 0x80001234;
+    source_impl->end_get_event_hr = MF_E_SHUTDOWN;
+    source_impl->start_hr = MF_E_SHUTDOWN;
     hr = MFCreateMediaSession(NULL, &session);
     ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);

@@ -2506,34 +2540,27 @@ static void test_media_session_events(void)
     ok(propvar.punkVal != (IUnknown *)topology, "got punkVal %p\n", propvar.punkVal);
     PropVariantClear(&propvar);

-    source_impl->begin_get_event_res = 0x80001234;
-
     SET_EXPECT(test_source_BeginGetEvent);
-    SET_EXPECT(test_source_QueueEvent);
-    SET_EXPECT(test_source_Start);
-
     propvar.vt = VT_EMPTY;
     hr = IMFMediaSession_Start(session, &GUID_NULL, &propvar);
     ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
     hr = wait_media_event_until_blocking(session, callback, MESessionStarted, 1000, &propvar);
     ok(hr == 0x80001234, "Unexpected hr %#lx.\n", hr);
     ok(propvar.vt == VT_EMPTY, "got vt %u\n", propvar.vt);
-    ok(propvar.punkVal != (IUnknown *)topology, "got punkVal %p\n", propvar.punkVal);
-    PropVariantClear(&propvar);
-
     CHECK_CALLED(test_source_BeginGetEvent);
-    CHECK_NOT_CALLED(test_source_Start);

+    SET_EXPECT(test_source_QueueEvent);
     hr = IMFMediaSession_ClearTopologies(session);
     ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    hr = wait_media_event(session, callback, MESessionTopologiesCleared, 1000, &propvar);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    ok(propvar.vt == VT_EMPTY, "got vt %u\n", propvar.vt);

hr = IMFMediaSession_Shutdown(session);
     ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
     ok(media_sink.shutdown, "media sink didn't shutdown.\n");
     media_sink.shutdown = FALSE;

-    source_impl->begin_get_event_res = E_NOTIMPL;
-
     CLEAR_CALLED(test_source_BeginGetEvent);
     CLEAR_CALLED(test_source_QueueEvent);
     CLEAR_CALLED(test_source_Start);
@@ -2554,18 +2581,18 @@ static void test_media_session_events(void)
     ok(propvar.punkVal != (IUnknown *)topology, "got punkVal %p\n", propvar.punkVal);
     PropVariantClear(&propvar);

-    source_impl = impl_from_IMFMediaSource(source);
-    source_impl->begin_get_event_res = S_OK;
+    source_impl->begin_get_event_hr = S_OK;
+    source_impl->end_get_event_hr = MF_E_SHUTDOWN;
+    source_impl->start_hr = 0x80001234;

SET_EXPECT(test_source_BeginGetEvent);
-    SET_EXPECT(test_source_QueueEvent);
     SET_EXPECT(test_source_Start);

propvar.vt = VT_EMPTY;
     hr = IMFMediaSession_Start(session, &GUID_NULL, &propvar);
     ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
     hr = wait_media_event_until_blocking(session, callback, MESessionStarted, 1000, &propvar);
-    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
+    ok(hr == 0x80001234, "Unexpected hr %#lx.\n", hr);
     ok(propvar.vt == VT_EMPTY, "got vt %u\n", propvar.vt);
     ok(propvar.punkVal != (IUnknown *)topology, "got punkVal %p\n", propvar.punkVal);
     PropVariantClear(&propvar);
@@ -2576,17 +2603,74 @@ static void test_media_session_events(void)
     hr = IMFMediaSession_ClearTopologies(session);
     ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);

+    SET_EXPECT(test_source_QueueEvent);
     hr = IMFMediaSession_Shutdown(session);
     ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
     ok(media_sink.shutdown, "media sink didn't shutdown.\n");
     media_sink.shutdown = FALSE;

-    source_impl->begin_get_event_res = E_NOTIMPL;
-
     CLEAR_CALLED(test_source_BeginGetEvent);
     CLEAR_CALLED(test_source_QueueEvent);
     CLEAR_CALLED(test_source_Start);

+    test_media_source_reinitialize_queue(source);
+
+    /* sometimes briefly leaking */
+    IMFMediaSession_Release(session);
+
+
+    /* test IMFMediaSession_Start when event queue fails. */
+    hr = MFCreateMediaSession(NULL, &session);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+
+    hr = IMFMediaSession_SetTopology(session, 0, topology);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    hr = wait_media_event(session, callback, MESessionTopologySet, 1000, &propvar);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    ok(propvar.vt == VT_UNKNOWN, "got vt %u\n", propvar.vt);
+    ok(propvar.punkVal != (IUnknown *)topology, "got punkVal %p\n", propvar.punkVal);
+    PropVariantClear(&propvar);
+
+    SET_EXPECT(test_source_BeginGetEvent);
+    SET_EXPECT(test_source_EndGetEvent);
+    SET_EXPECT(test_source_Start);
+    source_impl->begin_get_event_hr = S_OK;
+    source_impl->end_get_event_hr = 0x80001234;
+    source_impl->start_hr = S_OK;
+    propvar.vt = VT_EMPTY;
+    hr = IMFMediaSession_Start(session, &GUID_NULL, &propvar);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    hr = wait_media_event_until_blocking(session, callback, MEError, 1000, &propvar);
+    todo_wine ok(hr == 0x80001234, "Unexpected hr %#lx.\n", hr);
+    ok(propvar.vt == VT_EMPTY, "got vt %u\n", propvar.vt);
+    CHECK_CALLED(test_source_BeginGetEvent);
+    CHECK_CALLED(test_source_EndGetEvent);
+    CHECK_CALLED(test_source_Start);
+
+    source_impl->begin_get_event_hr = MF_E_SHUTDOWN;
+    propvar.vt = VT_EMPTY;
+    hr = IMFMediaSession_Start(session, &GUID_NULL, &propvar);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    todo_wine
+    hr = wait_media_event_until_blocking(session, callback, MESessionStarted, 1000, &propvar);
+    ok(hr == WAIT_TIMEOUT, "Unexpected hr %#lx.\n", hr); /* New commands are not handled */
+
+    hr = IMFMediaSession_ClearTopologies(session);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    hr = IMFMediaSession_BeginGetEvent(session, callback, NULL);
+    ok(hr == MF_S_MULTIPLE_BEGIN || hr == MF_E_MULTIPLE_BEGIN /* Win 7 */, "Unexpected hr %#lx\n", hr);
+
+    SET_EXPECT(test_source_QueueEvent);
+    hr = IMFMediaSession_Shutdown(session);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    ok(media_sink.shutdown, "media sink didn't shutdown.\n");
+    media_sink.shutdown = FALSE;
+
+    test_media_source_reinitialize_queue(source);
+
+    hr =  IMFMediaEventQueue_Shutdown(source_impl->queue);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+
     /* sometimes briefly leaking */
     IMFMediaSession_Release(session);

[PATCH v4 2/4] mf/test: Move stream sink stub above media sink stub.

[Santino Mazza]

From: Santino Mazza

---
 dlls/mf/tests/mf.c | 212 ++++++++++++++++++++++-----------------------
 1 file changed, 106 insertions(+), 106 deletions(-)

diff --git a/dlls/mf/tests/mf.c b/dlls/mf/tests/mf.c
index 1e46897bac8..71845772a64 100644
--- a/dlls/mf/tests/mf.c
+++ b/dlls/mf/tests/mf.c
@@ -1647,23 +1647,25 @@ static const IMFMediaTypeHandlerVtbl test_handler_vtbl =

static const struct test_handler test_handler = {.IMFMediaTypeHandler_iface.lpVtbl = &test_handler_vtbl};

-struct test_media_sink
+struct test_stream_sink
 {
-    IMFMediaSink IMFMediaSink_iface;
-    BOOL shutdown;
+    IMFStreamSink IMFStreamSink_iface;
+    IMFMediaTypeHandler *handler;
+    IMFMediaSink *media_sink;
 };

-static struct test_media_sink *impl_from_IMFMediaSink(IMFMediaSink *iface)
+static struct test_stream_sink *impl_from_IMFStreamSink(IMFStreamSink *iface)
 {
-    return CONTAINING_RECORD(iface, struct test_media_sink, IMFMediaSink_iface);
+    return CONTAINING_RECORD(iface, struct test_stream_sink, IMFStreamSink_iface);
 }

-static HRESULT WINAPI test_media_sink_QueryInterface(IMFMediaSink *iface, REFIID riid, void **obj)
+static HRESULT WINAPI test_stream_sink_QueryInterface(IMFStreamSink *iface, REFIID riid, void **obj)
 {
-    if (IsEqualIID(riid, &IID_IMFMediaSink)
+    if (IsEqualIID(riid, &IID_IMFStreamSink)
+            || IsEqualIID(riid, &IID_IMFMediaEventGenerator)
             || IsEqualIID(riid, &IID_IUnknown))
     {
-        IMFMediaSink_AddRef((*obj = iface));
+        IMFStreamSink_AddRef((*obj = iface));
         return S_OK;
     }

@@ -1671,110 +1673,132 @@ static HRESULT WINAPI test_media_sink_QueryInterface(IMFMediaSink *iface, REFIID
     return E_NOINTERFACE;
 }

-static ULONG WINAPI test_media_sink_AddRef(IMFMediaSink *iface)
+static ULONG WINAPI test_stream_sink_AddRef(IMFStreamSink *iface)
 {
     return 2;
 }

-static ULONG WINAPI test_media_sink_Release(IMFMediaSink *iface)
+static ULONG WINAPI test_stream_sink_Release(IMFStreamSink *iface)
 {
     return 1;
 }

-static HRESULT WINAPI test_media_sink_GetCharacteristics(IMFMediaSink *iface, DWORD *characteristics)
+static HRESULT WINAPI test_stream_sink_GetEvent(IMFStreamSink *iface, DWORD flags, IMFMediaEvent **event)
 {
-    *characteristics = 0;
-    return S_OK;
+    ok(0, "Unexpected call.\n");
+    return E_NOTIMPL;
 }

-static HRESULT WINAPI test_media_sink_AddStreamSink(IMFMediaSink *iface,
-        DWORD stream_sink_id, IMFMediaType *media_type, IMFStreamSink **stream_sink)
+static HRESULT WINAPI test_stream_sink_BeginGetEvent(IMFStreamSink *iface, IMFAsyncCallback *callback, IUnknown *state)
 {
     ok(0, "Unexpected call.\n");
     return E_NOTIMPL;
 }

-static HRESULT WINAPI test_media_sink_RemoveStreamSink(IMFMediaSink *iface, DWORD stream_sink_id)
+static HRESULT WINAPI test_stream_sink_EndGetEvent(IMFStreamSink *iface, IMFAsyncResult *result,
+        IMFMediaEvent **event)
 {
     ok(0, "Unexpected call.\n");
     return E_NOTIMPL;
 }

-static HRESULT WINAPI test_media_sink_GetStreamSinkCount(IMFMediaSink *iface, DWORD *count)
+static HRESULT WINAPI test_stream_sink_QueueEvent(IMFStreamSink *iface, MediaEventType event_type,
+        REFGUID ext_type, HRESULT hr, const PROPVARIANT *value)
 {
     ok(0, "Unexpected call.\n");
     return E_NOTIMPL;
 }

-static HRESULT WINAPI test_media_sink_GetStreamSinkByIndex(IMFMediaSink *iface, DWORD index, IMFStreamSink **sink)
+static HRESULT WINAPI test_stream_sink_GetMediaSink(IMFStreamSink *iface, IMFMediaSink **sink)
 {
+    struct test_stream_sink *impl = impl_from_IMFStreamSink(iface);
+
+    if (impl->media_sink)
+    {
+        IMFMediaSink_AddRef((*sink = impl->media_sink));
+        return S_OK;
+    }
+
+    todo_wine
     ok(0, "Unexpected call.\n");
     return E_NOTIMPL;
 }

-static HRESULT WINAPI test_media_sink_GetStreamSinkById(IMFMediaSink *iface, DWORD stream_sink_id, IMFStreamSink **sink)
+static HRESULT WINAPI test_stream_sink_GetIdentifier(IMFStreamSink *iface, DWORD *id)
 {
     ok(0, "Unexpected call.\n");
     return E_NOTIMPL;
 }

-static HRESULT WINAPI test_media_sink_SetPresentationClock(IMFMediaSink *iface, IMFPresentationClock *clock)
+static HRESULT WINAPI test_stream_sink_GetMediaTypeHandler(IMFStreamSink *iface, IMFMediaTypeHandler **handler)
+{
+    struct test_stream_sink *impl = impl_from_IMFStreamSink(iface);
+
+    if (impl->handler)
+    {
+        IMFMediaTypeHandler_AddRef((*handler = impl->handler));
+        return S_OK;
+    }
+
+    ok(0, "Unexpected call.\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI test_stream_sink_ProcessSample(IMFStreamSink *iface, IMFSample *sample)
 {
     ok(0, "Unexpected call.\n");
     return E_NOTIMPL;
 }

-static HRESULT WINAPI test_media_sink_GetPresentationClock(IMFMediaSink *iface, IMFPresentationClock **clock)
+static HRESULT WINAPI test_stream_sink_PlaceMarker(IMFStreamSink *iface, MFSTREAMSINK_MARKER_TYPE marker_type,
+        const PROPVARIANT *marker_value, const PROPVARIANT *context)
 {
     ok(0, "Unexpected call.\n");
     return E_NOTIMPL;
 }

-static HRESULT WINAPI test_media_sink_Shutdown(IMFMediaSink *iface)
+static HRESULT WINAPI test_stream_sink_Flush(IMFStreamSink *iface)
 {
-    struct test_media_sink *sink = impl_from_IMFMediaSink(iface);
-    ok(!sink->shutdown, "Unexpected call.\n");
-    sink->shutdown = TRUE;
-    return S_OK;
+    ok(0, "Unexpected call.\n");
+    return E_NOTIMPL;
 }

-static const IMFMediaSinkVtbl test_media_sink_vtbl =
+static const IMFStreamSinkVtbl test_stream_sink_vtbl =
 {
-    test_media_sink_QueryInterface,
-    test_media_sink_AddRef,
-    test_media_sink_Release,
-    test_media_sink_GetCharacteristics,
-    test_media_sink_AddStreamSink,
-    test_media_sink_RemoveStreamSink,
-    test_media_sink_GetStreamSinkCount,
-    test_media_sink_GetStreamSinkByIndex,
-    test_media_sink_GetStreamSinkById,
-    test_media_sink_SetPresentationClock,
-    test_media_sink_GetPresentationClock,
-    test_media_sink_Shutdown,
+    test_stream_sink_QueryInterface,
+    test_stream_sink_AddRef,
+    test_stream_sink_Release,
+    test_stream_sink_GetEvent,
+    test_stream_sink_BeginGetEvent,
+    test_stream_sink_EndGetEvent,
+    test_stream_sink_QueueEvent,
+    test_stream_sink_GetMediaSink,
+    test_stream_sink_GetIdentifier,
+    test_stream_sink_GetMediaTypeHandler,
+    test_stream_sink_ProcessSample,
+    test_stream_sink_PlaceMarker,
+    test_stream_sink_Flush,
 };

-static const struct test_media_sink test_media_sink = {.IMFMediaSink_iface.lpVtbl = &test_media_sink_vtbl};
+static const struct test_stream_sink test_stream_sink = {.IMFStreamSink_iface.lpVtbl = &test_stream_sink_vtbl};

-struct test_stream_sink
+struct test_media_sink
 {
-    IMFStreamSink IMFStreamSink_iface;
-    IMFMediaTypeHandler *handler;
-    IMFMediaSink *media_sink;
+    IMFMediaSink IMFMediaSink_iface;
+    BOOL shutdown;
 };

-static struct test_stream_sink *impl_from_IMFStreamSink(IMFStreamSink *iface)
+static struct test_media_sink *impl_from_IMFMediaSink(IMFMediaSink *iface)
 {
-    return CONTAINING_RECORD(iface, struct test_stream_sink, IMFStreamSink_iface);
+    return CONTAINING_RECORD(iface, struct test_media_sink, IMFMediaSink_iface);
 }

-static HRESULT WINAPI test_stream_sink_QueryInterface(IMFStreamSink *iface, REFIID riid, void **obj)
+static HRESULT WINAPI test_media_sink_QueryInterface(IMFMediaSink *iface, REFIID riid, void **obj)
 {
-    if (IsEqualIID(riid, &IID_IMFStreamSink)
-            || IsEqualIID(riid, &IID_IMFMediaEventGenerator)
+    if (IsEqualIID(riid, &IID_IMFMediaSink)
             || IsEqualIID(riid, &IID_IUnknown))
     {
-        IMFStreamSink_AddRef((*obj = iface));
+        IMFMediaSink_AddRef((*obj = iface));
         return S_OK;
     }

@@ -1782,114 +1806,90 @@ static HRESULT WINAPI test_stream_sink_QueryInterface(IMFStreamSink *iface, REFI
     return E_NOINTERFACE;
 }

-static ULONG WINAPI test_stream_sink_AddRef(IMFStreamSink *iface)
+static ULONG WINAPI test_media_sink_AddRef(IMFMediaSink *iface)
 {
     return 2;
 }

-static ULONG WINAPI test_stream_sink_Release(IMFStreamSink *iface)
+static ULONG WINAPI test_media_sink_Release(IMFMediaSink *iface)
 {
     return 1;
 }

-static HRESULT WINAPI test_stream_sink_GetEvent(IMFStreamSink *iface, DWORD flags, IMFMediaEvent **event)
-{
-    ok(0, "Unexpected call.\n");
-    return E_NOTIMPL;
-}
-
-static HRESULT WINAPI test_stream_sink_BeginGetEvent(IMFStreamSink *iface, IMFAsyncCallback *callback, IUnknown *state)
+static HRESULT WINAPI test_media_sink_GetCharacteristics(IMFMediaSink *iface, DWORD *characteristics)
 {
-    ok(0, "Unexpected call.\n");
-    return E_NOTIMPL;
+    *characteristics = 0;
+    return S_OK;
 }

-static HRESULT WINAPI test_stream_sink_EndGetEvent(IMFStreamSink *iface, IMFAsyncResult *result,
-        IMFMediaEvent **event)
+static HRESULT WINAPI test_media_sink_AddStreamSink(IMFMediaSink *iface,
+        DWORD stream_sink_id, IMFMediaType *media_type, IMFStreamSink **stream_sink)
 {
     ok(0, "Unexpected call.\n");
     return E_NOTIMPL;
 }

-static HRESULT WINAPI test_stream_sink_QueueEvent(IMFStreamSink *iface, MediaEventType event_type,
-        REFGUID ext_type, HRESULT hr, const PROPVARIANT *value)
+static HRESULT WINAPI test_media_sink_RemoveStreamSink(IMFMediaSink *iface, DWORD stream_sink_id)
 {
     ok(0, "Unexpected call.\n");
     return E_NOTIMPL;
 }

-static HRESULT WINAPI test_stream_sink_GetMediaSink(IMFStreamSink *iface, IMFMediaSink **sink)
+static HRESULT WINAPI test_media_sink_GetStreamSinkCount(IMFMediaSink *iface, DWORD *count)
 {
-    struct test_stream_sink *impl = impl_from_IMFStreamSink(iface);
-
-    if (impl->media_sink)
-    {
-        IMFMediaSink_AddRef((*sink = impl->media_sink));
-        return S_OK;
-    }
-
-    todo_wine
     ok(0, "Unexpected call.\n");
     return E_NOTIMPL;
 }

-static HRESULT WINAPI test_stream_sink_GetIdentifier(IMFStreamSink *iface, DWORD *id)
+static HRESULT WINAPI test_media_sink_GetStreamSinkByIndex(IMFMediaSink *iface, DWORD index, IMFStreamSink **sink)
 {
     ok(0, "Unexpected call.\n");
     return E_NOTIMPL;
 }

-static HRESULT WINAPI test_stream_sink_GetMediaTypeHandler(IMFStreamSink *iface, IMFMediaTypeHandler **handler)
+static HRESULT WINAPI test_media_sink_GetStreamSinkById(IMFMediaSink *iface, DWORD stream_sink_id, IMFStreamSink **sink)
 {
-    struct test_stream_sink *impl = impl_from_IMFStreamSink(iface);
-
-    if (impl->handler)
-    {
-        IMFMediaTypeHandler_AddRef((*handler = impl->handler));
-        return S_OK;
-    }
-
     ok(0, "Unexpected call.\n");
     return E_NOTIMPL;
 }

-static HRESULT WINAPI test_stream_sink_ProcessSample(IMFStreamSink *iface, IMFSample *sample)
+static HRESULT WINAPI test_media_sink_SetPresentationClock(IMFMediaSink *iface, IMFPresentationClock *clock)
 {
     ok(0, "Unexpected call.\n");
     return E_NOTIMPL;
 }

-static HRESULT WINAPI test_stream_sink_PlaceMarker(IMFStreamSink *iface, MFSTREAMSINK_MARKER_TYPE marker_type,
-        const PROPVARIANT *marker_value, const PROPVARIANT *context)
+static HRESULT WINAPI test_media_sink_GetPresentationClock(IMFMediaSink *iface, IMFPresentationClock **clock)
 {
     ok(0, "Unexpected call.\n");
     return E_NOTIMPL;
 }

-static HRESULT WINAPI test_stream_sink_Flush(IMFStreamSink *iface)
+static HRESULT WINAPI test_media_sink_Shutdown(IMFMediaSink *iface)
 {
-    ok(0, "Unexpected call.\n");
-    return E_NOTIMPL;
+    struct test_media_sink *sink = impl_from_IMFMediaSink(iface);
+    ok(!sink->shutdown, "Unexpected call.\n");
+    sink->shutdown = TRUE;
+    return S_OK;
 }

-static const IMFStreamSinkVtbl test_stream_sink_vtbl =
+static const IMFMediaSinkVtbl test_media_sink_vtbl =
 {
-    test_stream_sink_QueryInterface,
-    test_stream_sink_AddRef,
-    test_stream_sink_Release,
-    test_stream_sink_GetEvent,
-    test_stream_sink_BeginGetEvent,
-    test_stream_sink_EndGetEvent,
-    test_stream_sink_QueueEvent,
-    test_stream_sink_GetMediaSink,
-    test_stream_sink_GetIdentifier,
-    test_stream_sink_GetMediaTypeHandler,
-    test_stream_sink_ProcessSample,
-    test_stream_sink_PlaceMarker,
-    test_stream_sink_Flush,
+    test_media_sink_QueryInterface,
+    test_media_sink_AddRef,
+    test_media_sink_Release,
+    test_media_sink_GetCharacteristics,
+    test_media_sink_AddStreamSink,
+    test_media_sink_RemoveStreamSink,
+    test_media_sink_GetStreamSinkCount,
+    test_media_sink_GetStreamSinkByIndex,
+    test_media_sink_GetStreamSinkById,
+    test_media_sink_SetPresentationClock,
+    test_media_sink_GetPresentationClock,
+    test_media_sink_Shutdown,
 };

-static const struct test_stream_sink test_stream_sink = {.IMFStreamSink_iface.lpVtbl = &test_stream_sink_vtbl};
+static const struct test_media_sink test_media_sink = {.IMFMediaSink_iface.lpVtbl = &test_media_sink_vtbl};

struct test_callback
 {

[PATCH v4 3/4] mf/test: Test error case when session is streaming.

[Santino Mazza]

From: Santino Mazza

---
 dlls/mf/tests/mf.c | 693 ++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 630 insertions(+), 63 deletions(-)

diff --git a/dlls/mf/tests/mf.c b/dlls/mf/tests/mf.c
index 71845772a64..9efd4083980 100644
--- a/dlls/mf/tests/mf.c
+++ b/dlls/mf/tests/mf.c
@@ -265,8 +265,171 @@ static void init_sink_node(IMFStreamSink *stream_sink, MF_CONNECT_METHOD method,
     }
 }

+struct test_media_stream
+{
+    IMFMediaStream IMFMediaStream_iface;
+    IMFMediaEventQueue *queue;
+    IMFStreamDescriptor *sd;
+    IMFMediaSource *source;
+    LONG refcount;
+    HRESULT request_sample_hr;
+};
+
+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))
+    {
+        IMFMediaStream_AddRef((*out = iface));
+        return S_OK;
+    }
+
+    *out = NULL;
+    return E_NOINTERFACE;
+}
+
+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;
+
+    refcount = InterlockedDecrement(&stream->refcount);
+    if (refcount == 0)
+    {
+        IMFMediaEventQueue_Release(stream->queue);
+        IMFMediaSource_Release(stream->source);
+        IMFStreamDescriptor_Release(stream->sd);
+        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->queue, flags, event);
+}
+
+static HRESULT WINAPI test_media_stream_BeginGetEvent(IMFMediaStream *iface, IMFAsyncCallback *callback, IUnknown *unk)
+{
+    struct test_media_stream *stream = impl_from_IMFMediaStream(iface);
+    return IMFMediaEventQueue_BeginGetEvent(stream->queue, callback, unk);
+}
+
+static HRESULT WINAPI test_media_stream_EndGetEvent(IMFMediaStream *iface, IMFAsyncResult *result, IMFMediaEvent **event)
+{
+    struct test_media_stream *stream = impl_from_IMFMediaStream(iface);
+    return IMFMediaEventQueue_EndGetEvent(stream->queue, result, event);
+}
+
+static HRESULT WINAPI test_media_stream_QueueEvent(IMFMediaStream *iface, MediaEventType met, REFGUID type, HRESULT hr, const PROPVARIANT *pv)
+{
+    struct test_media_stream *stream = impl_from_IMFMediaStream(iface);
+    return IMFMediaEventQueue_QueueEventParamVar(stream->queue, met, type, hr, pv);
+}
+
+static HRESULT WINAPI test_media_stream_GetMediaSource(IMFMediaStream *iface, IMFMediaSource **source)
+{
+    struct test_media_stream *stream = impl_from_IMFMediaStream(iface);
+    todo_wine ok(0, "Call not expected\n");
+    IMFMediaSource_AddRef(stream->source);
+    *source = stream->source;
+    return S_OK;
+}
+
+static HRESULT WINAPI test_media_stream_GetStreamDescriptor(IMFMediaStream *iface, IMFStreamDescriptor **descriptor)
+{
+    struct test_media_stream *stream = impl_from_IMFMediaStream(iface);
+
+    IMFStreamDescriptor_AddRef(stream->sd);
+    *descriptor = stream->sd;
+    return S_OK;
+}
+
+static HRESULT WINAPI test_media_stream_RequestSample(IMFMediaStream *iface, IUnknown *token)
+{
+    struct test_media_stream *stream = impl_from_IMFMediaStream(iface);
+    IMFSample *sample;
+    IMFMediaBuffer *buffer;
+
+    if (stream->request_sample_hr != S_OK) return stream->request_sample_hr;
+
+    MFCreateSample(&sample);
+    MFCreateMemoryBuffer(4, &buffer);
+    IMFMediaBuffer_SetCurrentLength(buffer, 4);
+    IMFSample_SetSampleTime(sample, 0);
+    IMFSample_SetSampleDuration(sample, 1);
+    IMFSample_AddBuffer(sample, buffer);
+    if (token)
+        IMFSample_SetUnknown(sample, &MFSampleExtension_Token, token);
+    IMFMediaEventQueue_QueueEventParamUnk(stream->queue, MEMediaSample, &GUID_NULL, S_OK, (IUnknown*)sample);
+    IMFSample_Release(sample);
+    IMFMediaBuffer_Release(buffer);
+    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,
+};
+
+static void start_media_stream(IMFMediaStream *iface)
+{
+    struct test_media_stream *stream = impl_from_IMFMediaStream(iface);
+
+    IMFMediaEventQueue_QueueEventParamUnk(stream->queue, MEStreamStarted, &GUID_NULL, S_OK, NULL);
+}
+
+static struct test_media_stream *create_test_media_stream(IMFStreamDescriptor *sd, IMFMediaSource *source)
+{
+    struct test_media_stream *stream;
+
+    stream = calloc(1, sizeof(*stream));
+    stream->IMFMediaStream_iface.lpVtbl = &test_media_stream_vtbl;
+    stream->refcount = 1;
+
+    if (sd)
+    {
+        IMFStreamDescriptor_AddRef(sd);
+        stream->sd = sd;
+    }
+
+    if (source)
+    {
+        IMFMediaSource_AddRef(source);
+        stream->source = source;
+    }
+
+    MFCreateEventQueue(&stream->queue);
+
+    return stream;
+}
+
 DEFINE_EXPECT(test_source_BeginGetEvent);
 DEFINE_EXPECT(test_source_EndGetEvent);
+DEFINE_EXPECT(test_source_GetEvent);
 DEFINE_EXPECT(test_source_QueueEvent);
 DEFINE_EXPECT(test_source_Start);

@@ -278,6 +441,7 @@ struct test_source
     HRESULT begin_get_event_hr, end_get_event_hr,
             start_hr, queue_event_hr;
     IMFPresentationDescriptor *pd;
+    struct test_media_stream *stream;
 };

static struct test_source *impl_from_IMFMediaSource(IMFMediaSource *iface)
@@ -316,7 +480,6 @@ static ULONG WINAPI test_source_Release(IMFMediaSource *iface)

if (!refcount)
     {
-        IMFMediaEventQueue_Shutdown(source->queue);
         IMFMediaEventQueue_Release(source->queue);
         IMFPresentationDescriptor_Release(source->pd);
         free(source);
@@ -327,8 +490,9 @@ static ULONG WINAPI test_source_Release(IMFMediaSource *iface)

static HRESULT WINAPI test_source_GetEvent(IMFMediaSource *iface, DWORD flags, IMFMediaEvent **event)
 {
-    ok(0, "Unexpected call.\n");
-    return E_NOTIMPL;
+    struct test_source *source = impl_from_IMFMediaSource(iface);
+    CHECK_EXPECT(test_source_GetEvent);
+    return IMFMediaEventQueue_GetEvent(source->queue, flags, event);
 }

static HRESULT WINAPI test_source_BeginGetEvent(IMFMediaSource *iface, IMFAsyncCallback *callback, IUnknown *state)
@@ -380,9 +544,25 @@ static HRESULT WINAPI test_source_Start(IMFMediaSource *iface, IMFPresentationDe
         const PROPVARIANT *start_position)
 {
     struct test_source *source = impl_from_IMFMediaSource(iface);
+    IMFStreamDescriptor *sd;
+    struct test_media_stream *stream;
+    BOOL selected;
+
     CHECK_EXPECT(test_source_Start);
     if (source->start_hr == S_OK)
     {
+        if (source->stream)
+        {
+            IMFMediaEventQueue_Shutdown(source->stream->queue);
+            IMFMediaStream_Release(&source->stream->IMFMediaStream_iface);
+        }
+        IMFPresentationDescriptor_GetStreamDescriptorByIndex(source->pd, 0, &selected, &sd);
+        stream = create_test_media_stream(sd, iface);
+        source->stream = stream;
+        IMFStreamDescriptor_Release(sd);
+
+        IMFMediaEventQueue_QueueEventParamUnk(source->queue, MENewStream, &GUID_NULL, S_OK, (IUnknown*)&stream->IMFMediaStream_iface);
+        start_media_stream(&stream->IMFMediaStream_iface);
         IMFMediaEventQueue_QueueEventParamUnk(source->queue, MESourceStarted, &GUID_NULL, S_OK, NULL);
         return S_OK;
     }
@@ -403,8 +583,11 @@ static HRESULT WINAPI test_source_Pause(IMFMediaSource *iface)

static HRESULT WINAPI test_source_Shutdown(IMFMediaSource *iface)
 {
-    ok(0, "Unexpected call.\n");
-    return E_NOTIMPL;
+    struct test_source *source = impl_from_IMFMediaSource(iface);
+    IMFMediaEventQueue_Shutdown(source->queue);
+    IMFMediaEventQueue_Shutdown(source->stream->queue);
+    IMFMediaStream_Release(&source->stream->IMFMediaStream_iface);
+    return S_OK;
 }

static const IMFMediaSourceVtbl test_source_vtbl =
@@ -1650,6 +1833,8 @@ static const struct test_handler test_handler = {.IMFMediaTypeHandler_iface.lpVt
 struct test_stream_sink
 {
     IMFStreamSink IMFStreamSink_iface;
+    LONG refcount;
+    IMFMediaEventQueue *queue;
     IMFMediaTypeHandler *handler;
     IMFMediaSink *media_sink;
 };
@@ -1675,38 +1860,55 @@ static HRESULT WINAPI test_stream_sink_QueryInterface(IMFStreamSink *iface, REFI

static ULONG WINAPI test_stream_sink_AddRef(IMFStreamSink *iface)
 {
-    return 2;
+    struct test_stream_sink *stream_sink = impl_from_IMFStreamSink(iface);
+    return InterlockedIncrement(&stream_sink->refcount);
 }

static ULONG WINAPI test_stream_sink_Release(IMFStreamSink *iface)
 {
-    return 1;
+    struct test_stream_sink *stream = impl_from_IMFStreamSink(iface);
+    ULONG refcount;
+
+    refcount = InterlockedDecrement(&stream->refcount);
+
+    if (refcount == 0)
+    {
+        if (stream->queue)
+            IMFMediaEventQueue_Release(stream->queue);
+        if (stream->handler)
+            IMFMediaTypeHandler_Release(stream->handler);
+        if (stream->media_sink)
+            IMFMediaSink_Release(stream->media_sink);
+        free(stream);
+    }
+
+    return refcount;
 }

static HRESULT WINAPI test_stream_sink_GetEvent(IMFStreamSink *iface, DWORD flags, IMFMediaEvent **event)
 {
-    ok(0, "Unexpected call.\n");
-    return E_NOTIMPL;
+    struct test_stream_sink *stream_sink = impl_from_IMFStreamSink(iface);
+    return IMFMediaEventQueue_GetEvent(stream_sink->queue, flags, event);
 }

static HRESULT WINAPI test_stream_sink_BeginGetEvent(IMFStreamSink *iface, IMFAsyncCallback *callback, IUnknown *state)
 {
-    ok(0, "Unexpected call.\n");
-    return E_NOTIMPL;
+    struct test_stream_sink *stream_sink = impl_from_IMFStreamSink(iface);
+    return IMFMediaEventQueue_BeginGetEvent(stream_sink->queue, callback, state);
 }

static HRESULT WINAPI test_stream_sink_EndGetEvent(IMFStreamSink *iface, IMFAsyncResult *result,
         IMFMediaEvent **event)
 {
-    ok(0, "Unexpected call.\n");
-    return E_NOTIMPL;
+    struct test_stream_sink *stream_sink = impl_from_IMFStreamSink(iface);
+    return IMFMediaEventQueue_EndGetEvent(stream_sink->queue, result, event);
 }

static HRESULT WINAPI test_stream_sink_QueueEvent(IMFStreamSink *iface, MediaEventType event_type,
         REFGUID ext_type, HRESULT hr, const PROPVARIANT *value)
 {
-    ok(0, "Unexpected call.\n");
-    return E_NOTIMPL;
+    struct test_stream_sink *stream_sink = impl_from_IMFStreamSink(iface);
+    return IMFMediaEventQueue_QueueEventParamVar(stream_sink->queue, event_type, ext_type, hr, value);
 }

static HRESULT WINAPI test_stream_sink_GetMediaSink(IMFStreamSink *iface, IMFMediaSink **sink)
@@ -1746,8 +1948,8 @@ static HRESULT WINAPI test_stream_sink_GetMediaTypeHandler(IMFStreamSink *iface,

static HRESULT WINAPI test_stream_sink_ProcessSample(IMFStreamSink *iface, IMFSample *sample)
 {
-    ok(0, "Unexpected call.\n");
-    return E_NOTIMPL;
+    IMFStreamSink_QueueEvent(iface, MEStreamSinkRequestSample, &GUID_NULL, S_OK, NULL);
+    return S_OK;
 }

static HRESULT WINAPI test_stream_sink_PlaceMarker(IMFStreamSink *iface, MFSTREAMSINK_MARKER_TYPE marker_type,
@@ -1780,11 +1982,42 @@ static const IMFStreamSinkVtbl test_stream_sink_vtbl =
     test_stream_sink_Flush,
 };

-static const struct test_stream_sink test_stream_sink = {.IMFStreamSink_iface.lpVtbl = &test_stream_sink_vtbl};
+static struct test_stream_sink *create_test_stream_sink(IMFMediaSink *media_sink, IMFMediaTypeHandler *handler)
+{
+    struct test_stream_sink *stream_sink;
+
+    stream_sink = calloc(1, sizeof(*stream_sink));
+    stream_sink->refcount = 1;
+
+    stream_sink->IMFStreamSink_iface.lpVtbl = &test_stream_sink_vtbl;
+
+    if (media_sink)
+    {
+        IMFMediaSink_AddRef(media_sink);
+        stream_sink->media_sink = media_sink;
+    }
+
+    if (handler)
+    {
+        IMFMediaTypeHandler_AddRef(handler);
+        stream_sink->handler = handler;
+    }
+
+    MFCreateEventQueue(&stream_sink->queue);
+
+    return stream_sink;
+}
+

struct test_media_sink
 {
     IMFMediaSink IMFMediaSink_iface;
+    IMFMediaEventGenerator IMFMediaEventGenerator_iface;
+    IMFClockStateSink IMFClockStateSink_iface;
+    LONG refcount;
+    struct test_stream_sink *stream;
+    IMFMediaEventQueue *queue;
+    IMFPresentationClock *clock;
     BOOL shutdown;
 };

@@ -1793,27 +2026,65 @@ static struct test_media_sink *impl_from_IMFMediaSink(IMFMediaSink *iface)
     return CONTAINING_RECORD(iface, struct test_media_sink, IMFMediaSink_iface);
 }

+static struct test_media_sink *impl_from_IMFClockStateSink(IMFClockStateSink *iface)
+{
+    return CONTAINING_RECORD(iface, struct test_media_sink, IMFClockStateSink_iface);
+}
+
+static struct test_media_sink *impl_from_IMFMediaEventGenerator(IMFMediaEventGenerator *iface)
+{
+    return CONTAINING_RECORD(iface, struct test_media_sink, IMFMediaEventGenerator_iface);
+}
+
+
 static HRESULT WINAPI test_media_sink_QueryInterface(IMFMediaSink *iface, REFIID riid, void **obj)
 {
+    struct test_media_sink *sink = impl_from_IMFMediaSink(iface);
+
     if (IsEqualIID(riid, &IID_IMFMediaSink)
             || IsEqualIID(riid, &IID_IUnknown))
     {
         IMFMediaSink_AddRef((*obj = iface));
-        return S_OK;
+    }
+    else if (IsEqualIID(riid, &IID_IMFMediaEventGenerator))
+    {
+        IMFMediaEventGenerator_AddRef((*obj = &sink->IMFMediaEventGenerator_iface));
+    }
+    else if (IsEqualIID(riid, &IID_IMFClockStateSink))
+    {
+        IMFClockStateSink_AddRef((*obj = &sink->IMFClockStateSink_iface));
+    }
+    else
+    {
+        *obj = NULL;
+        return E_NOINTERFACE;
     }

-    *obj = NULL;
-    return E_NOINTERFACE;
+    return S_OK;
 }

static ULONG WINAPI test_media_sink_AddRef(IMFMediaSink *iface)
 {
-    return 2;
+    struct test_media_sink *sink = impl_from_IMFMediaSink(iface);
+    return InterlockedIncrement(&sink->refcount);
 }

static ULONG WINAPI test_media_sink_Release(IMFMediaSink *iface)
 {
-    return 1;
+    struct test_media_sink *sink = impl_from_IMFMediaSink(iface);
+    ULONG refcount;
+
+    refcount = InterlockedDecrement(&sink->refcount);
+    if (refcount == 0)
+    {
+        if (sink->queue)
+            IMFMediaEventQueue_Release(sink->queue);
+        if (sink->clock)
+            IMFPresentationClock_Release(sink->clock);
+        free(sink);
+    }
+
+    return refcount;
 }

static HRESULT WINAPI test_media_sink_GetCharacteristics(IMFMediaSink *iface, DWORD *characteristics)
@@ -1837,14 +2108,16 @@ static HRESULT WINAPI test_media_sink_RemoveStreamSink(IMFMediaSink *iface, DWOR

static HRESULT WINAPI test_media_sink_GetStreamSinkCount(IMFMediaSink *iface, DWORD *count)
 {
-    ok(0, "Unexpected call.\n");
-    return E_NOTIMPL;
+    *count = 1;
+    return S_OK;
 }

static HRESULT WINAPI test_media_sink_GetStreamSinkByIndex(IMFMediaSink *iface, DWORD index, IMFStreamSink **sink)
 {
-    ok(0, "Unexpected call.\n");
-    return E_NOTIMPL;
+    struct test_media_sink *media_sink = impl_from_IMFMediaSink(iface);
+    IMFStreamSink_AddRef(&media_sink->stream->IMFStreamSink_iface);
+    *sink = &media_sink->stream->IMFStreamSink_iface;
+    return S_OK;
 }

static HRESULT WINAPI test_media_sink_GetStreamSinkById(IMFMediaSink *iface, DWORD stream_sink_id, IMFStreamSink **sink)
@@ -1855,20 +2128,42 @@ static HRESULT WINAPI test_media_sink_GetStreamSinkById(IMFMediaSink *iface, DWO

static HRESULT WINAPI test_media_sink_SetPresentationClock(IMFMediaSink *iface, IMFPresentationClock *clock)
 {
-    ok(0, "Unexpected call.\n");
-    return E_NOTIMPL;
+    struct test_media_sink *sink = impl_from_IMFMediaSink(iface);
+
+    IMFPresentationClock_AddRef(clock);
+    sink->clock = clock;
+    IMFPresentationClock_AddClockStateSink(sink->clock, &sink->IMFClockStateSink_iface);
+    return S_OK;
 }

static HRESULT WINAPI test_media_sink_GetPresentationClock(IMFMediaSink *iface, IMFPresentationClock **clock)
 {
-    ok(0, "Unexpected call.\n");
-    return E_NOTIMPL;
+    struct test_media_sink *sink = impl_from_IMFMediaSink(iface);
+
+    if (sink->clock == NULL)
+        return MF_E_NO_CLOCK;
+    IMFPresentationClock_AddRef(sink->clock);
+    *clock = sink->clock;
+    return S_OK;
 }

static HRESULT WINAPI test_media_sink_Shutdown(IMFMediaSink *iface)
 {
     struct test_media_sink *sink = impl_from_IMFMediaSink(iface);
     ok(!sink->shutdown, "Unexpected call.\n");
+    if (sink->clock)
+        IMFPresentationClock_Release(sink->clock);
+    sink->clock = NULL;
+
+    if (sink->stream)
+    {
+        IMFMediaEventQueue_Shutdown(sink->stream->queue);
+        IMFStreamSink_Release(&sink->stream->IMFStreamSink_iface);
+        sink->stream = NULL;
+    }
+
+    IMFMediaEventQueue_Shutdown(sink->queue);
+
     sink->shutdown = TRUE;
     return S_OK;
 }
@@ -1889,7 +2184,144 @@ static const IMFMediaSinkVtbl test_media_sink_vtbl =
     test_media_sink_Shutdown,
 };

-static const struct test_media_sink test_media_sink = {.IMFMediaSink_iface.lpVtbl = &test_media_sink_vtbl};
+static HRESULT WINAPI test_media_sink_clock_sink_QueryInterface(IMFClockStateSink *iface, REFIID riid, void **obj)
+{
+    struct test_media_sink *sink = impl_from_IMFClockStateSink(iface);
+    return IMFMediaSink_QueryInterface(&sink->IMFMediaSink_iface, riid, obj);
+}
+
+static ULONG WINAPI test_media_sink_clock_sink_AddRef(IMFClockStateSink *iface)
+{
+    struct test_media_sink *sink = impl_from_IMFClockStateSink(iface);
+    return IMFMediaSink_AddRef(&sink->IMFMediaSink_iface);
+}
+
+static ULONG WINAPI test_media_sink_clock_sink_Release(IMFClockStateSink *iface)
+{
+    struct test_media_sink *sink = impl_from_IMFClockStateSink(iface);
+    return IMFMediaSink_Release(&sink->IMFMediaSink_iface);
+}
+
+static HRESULT WINAPI test_media_sink_clock_sink_OnClockStart(IMFClockStateSink *iface, MFTIME time, LONGLONG offset)
+{
+    struct test_media_sink *sink = impl_from_IMFClockStateSink(iface);
+
+    IMFStreamSink_QueueEvent(&sink->stream->IMFStreamSink_iface, MEStreamSinkStarted, &GUID_NULL, S_OK, NULL);
+    IMFStreamSink_QueueEvent(&sink->stream->IMFStreamSink_iface, MEStreamSinkRequestSample, &GUID_NULL, S_OK, NULL);
+    return S_OK;
+}
+
+static HRESULT WINAPI test_media_sink_clock_sink_OnClockStop(IMFClockStateSink *iface, MFTIME time)
+{
+    ok(0, "Unexpected call\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI test_media_sink_clock_sink_OnClockPause(IMFClockStateSink *iface, MFTIME time)
+{
+    ok(0, "Unexpected call\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI test_media_sink_clock_sink_OnClockRestart(IMFClockStateSink *iface, MFTIME time)
+{
+    ok(0, "Unexpected call\n");
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI test_media_sink_clock_sink_OnClockSetRate(IMFClockStateSink *iface, MFTIME time, float rate)
+{
+    ok(0, "Unexpected call\n");
+    return E_NOTIMPL;
+}
+
+static const IMFClockStateSinkVtbl test_media_sink_clock_sink_vtbl =
+{
+    test_media_sink_clock_sink_QueryInterface,
+    test_media_sink_clock_sink_AddRef,
+    test_media_sink_clock_sink_Release,
+    test_media_sink_clock_sink_OnClockStart,
+    test_media_sink_clock_sink_OnClockStop,
+    test_media_sink_clock_sink_OnClockPause,
+    test_media_sink_clock_sink_OnClockRestart,
+    test_media_sink_clock_sink_OnClockSetRate,
+};
+
+static HRESULT WINAPI test_media_sink_events_QueryInterface(IMFMediaEventGenerator *iface, REFIID riid, void **obj)
+{
+    struct test_media_sink *sink = impl_from_IMFMediaEventGenerator(iface);
+    return IMFMediaSink_QueryInterface(&sink->IMFMediaSink_iface, riid, obj);
+}
+
+static ULONG WINAPI test_media_sink_events_AddRef(IMFMediaEventGenerator *iface)
+{
+    struct test_media_sink *sink = impl_from_IMFMediaEventGenerator(iface);
+    return IMFMediaSink_AddRef(&sink->IMFMediaSink_iface);
+}
+
+static ULONG WINAPI test_media_sink_events_Release(IMFMediaEventGenerator *iface)
+{
+    struct test_media_sink *sink = impl_from_IMFMediaEventGenerator(iface);
+    return IMFMediaSink_Release(&sink->IMFMediaSink_iface);
+}
+
+static HRESULT WINAPI test_media_sink_events_GetEvent(IMFMediaEventGenerator *iface, DWORD flags, IMFMediaEvent **event)
+{
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI test_media_sink_events_BeginGetEvent(IMFMediaEventGenerator *iface, IMFAsyncCallback *callback, IUnknown *unk)
+{
+    struct test_media_sink *sink = impl_from_IMFMediaEventGenerator(iface);
+    return IMFMediaEventQueue_BeginGetEvent(sink->queue, callback, unk);
+}
+
+static HRESULT WINAPI test_media_sink_events_EndGetEvent(IMFMediaEventGenerator *iface, IMFAsyncResult *result, IMFMediaEvent **event)
+{
+    struct test_media_sink *sink = impl_from_IMFMediaEventGenerator(iface);
+    return IMFMediaEventQueue_EndGetEvent(sink->queue, result, event);
+}
+
+static HRESULT WINAPI test_media_sink_events_QueueEvent(IMFMediaEventGenerator *iface, MediaEventType met, REFGUID type, HRESULT hr, const PROPVARIANT *var)
+{
+    struct test_media_sink *sink = impl_from_IMFMediaEventGenerator(iface);
+    return IMFMediaEventQueue_QueueEventParamVar(sink->queue, met, type, hr, var);
+}
+
+static const IMFMediaEventGeneratorVtbl test_media_sink_events_vtbl =
+{
+    test_media_sink_events_QueryInterface,
+    test_media_sink_events_AddRef,
+    test_media_sink_events_Release,
+    test_media_sink_events_GetEvent,
+    test_media_sink_events_BeginGetEvent,
+    test_media_sink_events_EndGetEvent,
+    test_media_sink_events_QueueEvent,
+};
+
+static void test_media_sink_reinitialize(struct test_media_sink *media_sink, IMFMediaTypeHandler *handler)
+{
+    media_sink->shutdown = FALSE;
+    MFCreateEventQueue(&media_sink->queue);
+    media_sink->stream = create_test_stream_sink(&media_sink->IMFMediaSink_iface, handler);
+}
+
+static struct test_media_sink *create_test_media_sink(IMFMediaTypeHandler *handler) {
+    struct test_media_sink *sink;
+
+    sink = calloc(1, sizeof(*sink));
+    sink->refcount = 1;
+
+    sink->IMFMediaSink_iface.lpVtbl = &test_media_sink_vtbl;
+    sink->IMFMediaEventGenerator_iface.lpVtbl = &test_media_sink_events_vtbl;
+    sink->IMFClockStateSink_iface.lpVtbl = &test_media_sink_clock_sink_vtbl;
+
+    sink->stream = create_test_stream_sink(&sink->IMFMediaSink_iface, handler);
+
+    MFCreateEventQueue(&sink->queue);
+
+    return sink;
+}

struct test_callback
 {
@@ -1966,6 +2398,7 @@ static HRESULT WINAPI testcallback_Invoke(IMFAsyncCallback *iface, IMFAsyncResul

hr = IMFAsyncResult_GetState(result, &object);
         ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+        if (!object) return S_OK;
         hr = IMFMediaEventGenerator_EndGetEvent((IMFMediaEventGenerator *)object,
                 result, &callback->media_event);
         ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
@@ -2140,14 +2573,14 @@ static void test_media_session_events(void)
         ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 2 * 8),
     };

-    struct test_stream_sink stream_sink = test_stream_sink;
-    struct test_media_sink media_sink = test_media_sink;
     struct test_handler handler = test_handler;
     struct test_source *source_impl;
+    struct test_media_sink *media_sink;
     IMFAsyncCallback *callback, *callback2;
     IMFMediaType *input_type, *output_type;
     IMFTopologyNode *src_node, *sink_node;
     IMFPresentationDescriptor *pd;
+    MFCLOCK_STATE clock_status;
     IMFMediaSession *session;
     IMFStreamDescriptor *sd;
     IMFAsyncResult *result;
@@ -2158,8 +2591,8 @@ static void test_media_session_events(void)
     HRESULT hr;
     ULONG ref;

-    stream_sink.handler = &handler.IMFMediaTypeHandler_iface;
-    stream_sink.media_sink = &media_sink.IMFMediaSink_iface;
+
+    media_sink = create_test_media_sink(&handler.IMFMediaTypeHandler_iface);

hr = MFStartup(MF_VERSION, MFSTARTUP_FULL);
     ok(hr == S_OK, "Startup failure, hr %#lx.\n", hr);
@@ -2287,7 +2720,7 @@ static void test_media_session_events(void)

hr = MFCreateTopologyNode(MF_TOPOLOGY_OUTPUT_NODE, &sink_node);
     ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
-    init_sink_node(&stream_sink.IMFStreamSink_iface, -1, sink_node);
+    init_sink_node(&media_sink->stream->IMFStreamSink_iface, -1, sink_node);

hr = MFCreateMediaType(&output_type);
     ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
@@ -2325,8 +2758,12 @@ static void test_media_session_events(void)

hr = IMFMediaSession_Shutdown(session);
     ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
-    ok(!media_sink.shutdown, "media sink is shutdown.\n");
-    media_sink.shutdown = FALSE;
+    ok(!media_sink->shutdown, "media sink is shutdown.\n");
+    if (media_sink->shutdown)
+    {
+        test_media_sink_reinitialize(media_sink, &handler.IMFMediaTypeHandler_iface);
+        init_sink_node(&media_sink->stream->IMFStreamSink_iface, -1, sink_node);
+    }

/* sometimes briefly leaking */
     IMFMediaSession_Release(session);
@@ -2363,8 +2800,9 @@ static void test_media_session_events(void)

hr = IMFMediaSession_Shutdown(session);
     ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
-    ok(media_sink.shutdown, "media sink didn't shutdown.\n");
-    media_sink.shutdown = FALSE;
+    ok(media_sink->shutdown, "media sink didn't shutdown.\n");
+    test_media_sink_reinitialize(media_sink, &handler.IMFMediaTypeHandler_iface);
+    init_sink_node(&media_sink->stream->IMFStreamSink_iface, -1, sink_node);

/* sometimes briefly leaking */
     IMFMediaSession_Release(session);
@@ -2400,8 +2838,9 @@ static void test_media_session_events(void)

hr = IMFMediaSession_Shutdown(session);
     ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
-    ok(media_sink.shutdown, "media sink didn't shutdown.\n");
-    media_sink.shutdown = FALSE;
+    ok(media_sink->shutdown, "media sink didn't shutdown.\n");
+    test_media_sink_reinitialize(media_sink, &handler.IMFMediaTypeHandler_iface);
+    init_sink_node(&media_sink->stream->IMFStreamSink_iface, -1, sink_node);

/* sometimes briefly leaking */
     IMFMediaSession_Release(session);
@@ -2438,8 +2877,9 @@ static void test_media_session_events(void)

hr = IMFMediaSession_Shutdown(session);
     ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
-    ok(media_sink.shutdown, "media sink didn't shutdown.\n");
-    media_sink.shutdown = FALSE;
+    ok(media_sink->shutdown, "media sink didn't shutdown.\n");
+    test_media_sink_reinitialize(media_sink, &handler.IMFMediaTypeHandler_iface);
+    init_sink_node(&media_sink->stream->IMFStreamSink_iface, -1, sink_node);

/* sometimes briefly leaking */
     IMFMediaSession_Release(session);
@@ -2477,8 +2917,9 @@ static void test_media_session_events(void)

hr = IMFMediaSession_Shutdown(session);
     ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
-    ok(media_sink.shutdown, "media sink didn't shutdown.\n");
-    media_sink.shutdown = FALSE;
+    ok(media_sink->shutdown, "media sink didn't shutdown.\n");
+    test_media_sink_reinitialize(media_sink, &handler.IMFMediaTypeHandler_iface);
+    init_sink_node(&media_sink->stream->IMFStreamSink_iface, -1, sink_node);

/* sometimes briefly leaking */
     IMFMediaSession_Release(session);
@@ -2516,8 +2957,9 @@ static void test_media_session_events(void)

hr = IMFMediaSession_Shutdown(session);
     ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
-    ok(media_sink.shutdown, "media sink didn't shutdown.\n");
-    media_sink.shutdown = FALSE;
+    ok(media_sink->shutdown, "media sink didn't shutdown.\n");
+    test_media_sink_reinitialize(media_sink, &handler.IMFMediaTypeHandler_iface);
+    init_sink_node(&media_sink->stream->IMFStreamSink_iface, -1, sink_node);

/* sometimes briefly leaking */
     IMFMediaSession_Release(session);
@@ -2558,8 +3000,9 @@ static void test_media_session_events(void)

hr = IMFMediaSession_Shutdown(session);
     ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
-    ok(media_sink.shutdown, "media sink didn't shutdown.\n");
-    media_sink.shutdown = FALSE;
+    ok(media_sink->shutdown, "media sink didn't shutdown.\n");
+    test_media_sink_reinitialize(media_sink, &handler.IMFMediaTypeHandler_iface);
+    init_sink_node(&media_sink->stream->IMFStreamSink_iface, -1, sink_node);

CLEAR_CALLED(test_source_BeginGetEvent);
     CLEAR_CALLED(test_source_QueueEvent);
@@ -2606,14 +3049,16 @@ static void test_media_session_events(void)
     SET_EXPECT(test_source_QueueEvent);
     hr = IMFMediaSession_Shutdown(session);
     ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
-    ok(media_sink.shutdown, "media sink didn't shutdown.\n");
-    media_sink.shutdown = FALSE;
+    ok(media_sink->shutdown, "media sink didn't shutdown.\n");
+    test_media_sink_reinitialize(media_sink, &handler.IMFMediaTypeHandler_iface);
+    init_sink_node(&media_sink->stream->IMFStreamSink_iface, -1, sink_node);
+
+    test_media_source_reinitialize_queue(source);

CLEAR_CALLED(test_source_BeginGetEvent);
     CLEAR_CALLED(test_source_QueueEvent);
     CLEAR_CALLED(test_source_Start);

-    test_media_source_reinitialize_queue(source);

/* sometimes briefly leaking */
     IMFMediaSession_Release(session);
@@ -2663,14 +3108,132 @@ static void test_media_session_events(void)
     SET_EXPECT(test_source_QueueEvent);
     hr = IMFMediaSession_Shutdown(session);
     ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
-    ok(media_sink.shutdown, "media sink didn't shutdown.\n");
-    media_sink.shutdown = FALSE;
+    ok(media_sink->shutdown, "media sink didn't shutdown.\n");
+    test_media_sink_reinitialize(media_sink, &handler.IMFMediaTypeHandler_iface);
+    init_sink_node(&media_sink->stream->IMFStreamSink_iface, -1, sink_node);

test_media_source_reinitialize_queue(source);

-    hr =  IMFMediaEventQueue_Shutdown(source_impl->queue);
+    /* sometimes briefly leaking */
+    IMFMediaSession_Release(session);
+
+
+    /* test IMFMediaSession_Start when event queue fails. */
+    hr = MFCreateMediaSession(NULL, &session);
     ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);

+    hr = IMFMediaSession_SetTopology(session, 0, topology);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    hr = wait_media_event(session, callback, MESessionTopologySet, 1000, &propvar);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    ok(propvar.vt == VT_UNKNOWN, "got vt %u\n", propvar.vt);
+    ok(propvar.punkVal != (IUnknown *)topology, "got punkVal %p\n", propvar.punkVal);
+    PropVariantClear(&propvar);
+
+    SET_EXPECT(test_source_BeginGetEvent);
+    SET_EXPECT(test_source_EndGetEvent);
+    SET_EXPECT(test_source_Start);
+    source_impl->begin_get_event_hr = S_OK;
+    source_impl->end_get_event_hr = S_OK;
+    source_impl->start_hr = S_OK;
+    propvar.vt = VT_EMPTY;
+    hr = IMFMediaSession_Start(session, &GUID_NULL, &propvar);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    hr = wait_media_event_until_blocking(session, callback, MESessionStarted, 1000, &propvar);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    ok(propvar.vt == VT_EMPTY, "got vt %u\n", propvar.vt);
+
+    hr = IMFPresentationClock_GetState(media_sink->clock, 0, &clock_status);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    ok(clock_status == MFCLOCK_STATE_RUNNING, "Expected running got %d\n", clock_status);
+
+    Sleep(1000);
+    SET_EXPECT(test_source_EndGetEvent);
+    source_impl->end_get_event_hr = MF_E_SHUTDOWN;
+    source_impl->queue_event_hr = S_OK;
+    hr = IMFMediaSource_QueueEvent(source, MESourceUnknown, &GUID_NULL, S_OK, NULL);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    hr = wait_media_event_until_blocking(session, callback, MEError, 1000, &propvar);
+    todo_wine ok(hr == MF_E_SHUTDOWN, "Unexpected hr %#lx.\n", hr);
+    ok(propvar.vt == VT_EMPTY, "got vt %u\n", propvar.vt);
+    CHECK_CALLED(test_source_BeginGetEvent);
+    CHECK_CALLED(test_source_EndGetEvent);
+    CHECK_CALLED(test_source_Start);
+
+    hr = IMFPresentationClock_GetState(media_sink->clock, 0, &clock_status);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    ok(clock_status == MFCLOCK_STATE_RUNNING, "Expected running got %d\n", clock_status);
+
+    hr = IMFMediaSession_ClearTopologies(session);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+
+    SET_EXPECT(test_source_QueueEvent);
+    hr = IMFMediaSession_Shutdown(session);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    ok(media_sink->shutdown, "media sink didn't shutdown.\n");
+    test_media_sink_reinitialize(media_sink, &handler.IMFMediaTypeHandler_iface);
+    init_sink_node(&media_sink->stream->IMFStreamSink_iface, -1, sink_node);
+
+    test_media_source_reinitialize_queue(source);
+
+    /* sometimes briefly leaking */
+    IMFMediaSession_Release(session);
+
+
+    /* Test media session when sample request fails while streaming. */
+    hr = MFCreateMediaSession(NULL, &session);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+
+    hr = IMFMediaSession_SetTopology(session, 0, topology);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    hr = wait_media_event(session, callback, MESessionTopologySet, 1000, &propvar);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    ok(propvar.vt == VT_UNKNOWN, "got vt %u\n", propvar.vt);
+    ok(propvar.punkVal != (IUnknown *)topology, "got punkVal %p\n", propvar.punkVal);
+    PropVariantClear(&propvar);
+
+    SET_EXPECT(test_source_BeginGetEvent);
+    SET_EXPECT(test_source_EndGetEvent);
+    SET_EXPECT(test_source_Start);
+    source_impl->begin_get_event_hr = S_OK;
+    source_impl->end_get_event_hr = S_OK;
+    source_impl->start_hr = S_OK;
+    propvar.vt = VT_EMPTY;
+    hr = IMFMediaSession_Start(session, &GUID_NULL, &propvar);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    hr = wait_media_event_until_blocking(session, callback, MESessionStarted, 1000, &propvar);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    ok(propvar.vt == VT_EMPTY, "got vt %u\n", propvar.vt);
+    ok(source_impl->stream != NULL, "Source stream is null\n");
+    CHECK_CALLED(test_source_BeginGetEvent);
+    CHECK_CALLED(test_source_EndGetEvent);
+    CHECK_CALLED(test_source_Start);
+
+    hr = IMFPresentationClock_GetState(media_sink->clock, 0, &clock_status);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    ok(clock_status == MFCLOCK_STATE_RUNNING, "Expected running got %d\n", clock_status);
+
+    Sleep(1000);
+    source_impl->stream->request_sample_hr = 0x80001234;
+
+    hr = wait_media_event_until_blocking(session, callback, MEError, 1000, &propvar);
+    todo_wine ok(hr == 0x80001234, "Unexpected hr %#lx.\n", hr);
+    ok(propvar.vt == VT_EMPTY, "got vt %u\n", propvar.vt);
+
+    hr = IMFPresentationClock_GetState(media_sink->clock, 0, &clock_status);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    ok(clock_status == MFCLOCK_STATE_RUNNING, "Expected running got %d\n", clock_status);
+
+    hr = IMFMediaSession_ClearTopologies(session);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+
+    SET_EXPECT(test_source_EndGetEvent);
+    SET_EXPECT(test_source_GetEvent);
+    SET_EXPECT(test_source_QueueEvent);
+    hr = IMFMediaSession_Shutdown(session);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    ok(media_sink->shutdown, "media sink didn't shutdown.\n");
+
     /* sometimes briefly leaking */
     IMFMediaSession_Release(session);

@@ -2689,6 +3252,8 @@ static void test_media_session_events(void)
     ref = IMFTopology_Release(topology);
     ok(ref == 0, "Release returned %ld\n", ref);

+    IMFMediaSource_Shutdown(source);
+    IMFMediaSink_Release(&media_sink->IMFMediaSink_iface);
     ref = IMFMediaSource_Release(source);
     ok(ref == 0, "Release returned %ld\n", ref);
     ref = IMFPresentationDescriptor_Release(pd);
@@ -3367,7 +3932,7 @@ static void test_topology_loader(void)

IMFTopologyNode *src_node, *sink_node, *src_node2, *sink_node2, *mft_node;
     IMFSampleGrabberSinkCallback *grabber_callback = create_test_grabber_callback();
-    struct test_stream_sink stream_sink = test_stream_sink;
+    struct test_stream_sink *stream_sink;
     IMFMediaType *media_type, *input_type, *output_type;
     IMFTopology *topology, *topology2, *full_topology;
     struct test_handler handler = test_handler;
@@ -3387,7 +3952,7 @@ static void test_topology_loader(void)
     BOOL ret;
     LONG ref;

-    stream_sink.handler = &handler.IMFMediaTypeHandler_iface;
+    stream_sink = create_test_stream_sink(NULL, &handler.IMFMediaTypeHandler_iface);

hr = MFStartup(MF_VERSION, MFSTARTUP_FULL);
     ok(hr == S_OK, "Startup failure, hr %#lx.\n", hr);
@@ -3578,7 +4143,7 @@ static void test_topology_loader(void)
         source = create_test_source(pd);

init_source_node(source, test->source_method, src_node, pd, sd);
-        init_sink_node(&stream_sink.IMFStreamSink_iface, test->sink_method, sink_node);
+        init_sink_node(&stream_sink->IMFStreamSink_iface, test->sink_method, sink_node);

hr = IMFTopology_GetCount(topology, &count);
         ok(hr == S_OK, "Failed to get attribute count, hr %#lx.\n", hr);
@@ -6654,7 +7219,7 @@ static void test_MFGetTopoNodeCurrentType(void)
     };
     IMFMediaType *media_type, *input_types[2], *output_types[2];
     IMFStreamDescriptor *input_descriptor, *output_descriptor;
-    struct test_stream_sink stream_sink = test_stream_sink;
+    struct test_stream_sink *stream_sink;
     IMFMediaTypeHandler *input_handler, *output_handler;
     IMFTransform *transform;
     IMFTopologyNode *node;
@@ -6671,6 +7236,8 @@ static void test_MFGetTopoNodeCurrentType(void)
     hr = CoInitialize(NULL);
     ok(hr == S_OK, "Failed to initialize, hr %#lx.\n", hr);

+    stream_sink = create_test_stream_sink(NULL, NULL);
+
     hr = MFCreateMediaType(&input_types[0]);
     ok(hr == S_OK, "Failed to create media type, hr %#lx.\n", hr);
     init_media_type(input_types[0], media_type_desc, -1);
@@ -6809,8 +7376,8 @@ static void test_MFGetTopoNodeCurrentType(void)
     hr = pMFGetTopoNodeCurrentType(node, 0, TRUE, &media_type);
     ok(hr == MF_E_INVALIDSTREAMNUMBER, "Unexpected hr %#lx.\n", hr);

-    stream_sink.handler = output_handler;
-    hr = IMFTopologyNode_SetObject(node, (IUnknown *)&stream_sink.IMFStreamSink_iface);
+    stream_sink->handler = output_handler;
+    hr = IMFTopologyNode_SetObject(node, (IUnknown *)&stream_sink->IMFStreamSink_iface);
     ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
     hr = pMFGetTopoNodeCurrentType(node, 0, FALSE, &media_type);
     ok(hr == MF_E_NOT_INITIALIZED, "Unexpected hr %#lx.\n", hr);

[PATCH v4 4/4] mf: Handle errors with source event generator in session.

[Santino Mazza]

From: Santino Mazza

---
 dlls/mf/session.c  | 7 ++++++-
 dlls/mf/tests/mf.c | 5 ++---
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/dlls/mf/session.c b/dlls/mf/session.c
index b5b631fb00a..3cb16a0e582 100644
--- a/dlls/mf/session.c
+++ b/dlls/mf/session.c
@@ -3679,7 +3679,9 @@ static HRESULT WINAPI session_events_callback_Invoke(IMFAsyncCallback *iface, IM
     if (FAILED(hr = IMFMediaEventGenerator_EndGetEvent(event_source, result, &event)))
     {
         WARN("Failed to get event from %p, hr %#lx.\n", event_source, hr);
-        goto failed;
+        IMFMediaEventQueue_QueueEventParamVar(session->event_queue, MEError, &GUID_NULL, hr, NULL);
+        IMFMediaEventGenerator_Release(event_source);
+        return hr;
     }

if (FAILED(hr = IMFMediaEvent_GetType(event, &event_type)))
@@ -3876,7 +3878,10 @@ failed:
         IMFMediaEvent_Release(event);

if (FAILED(hr = IMFMediaEventGenerator_BeginGetEvent(event_source, iface, (IUnknown *)event_source)))
+    {
         WARN("Failed to re-subscribe, hr %#lx.\n", hr);
+        IMFMediaEventQueue_QueueEventParamVar(session->event_queue, MEError, &GUID_NULL, hr, NULL);
+    }

IMFMediaEventGenerator_Release(event_source);

diff --git a/dlls/mf/tests/mf.c b/dlls/mf/tests/mf.c
index 9efd4083980..51be22840bb 100644
--- a/dlls/mf/tests/mf.c
+++ b/dlls/mf/tests/mf.c
@@ -3086,7 +3086,7 @@ static void test_media_session_events(void)
     hr = IMFMediaSession_Start(session, &GUID_NULL, &propvar);
     ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
     hr = wait_media_event_until_blocking(session, callback, MEError, 1000, &propvar);
-    todo_wine ok(hr == 0x80001234, "Unexpected hr %#lx.\n", hr);
+    ok(hr == 0x80001234, "Unexpected hr %#lx.\n", hr);
     ok(propvar.vt == VT_EMPTY, "got vt %u\n", propvar.vt);
     CHECK_CALLED(test_source_BeginGetEvent);
     CHECK_CALLED(test_source_EndGetEvent);
@@ -3096,7 +3096,6 @@ static void test_media_session_events(void)
     propvar.vt = VT_EMPTY;
     hr = IMFMediaSession_Start(session, &GUID_NULL, &propvar);
     ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
-    todo_wine
     hr = wait_media_event_until_blocking(session, callback, MESessionStarted, 1000, &propvar);
     ok(hr == WAIT_TIMEOUT, "Unexpected hr %#lx.\n", hr); /* New commands are not handled */

@@ -3154,7 +3153,7 @@ static void test_media_session_events(void)
     hr = IMFMediaSource_QueueEvent(source, MESourceUnknown, &GUID_NULL, S_OK, NULL);
     ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
     hr = wait_media_event_until_blocking(session, callback, MEError, 1000, &propvar);
-    todo_wine ok(hr == MF_E_SHUTDOWN, "Unexpected hr %#lx.\n", hr);
+    ok(hr == MF_E_SHUTDOWN, "Unexpected hr %#lx.\n", hr);
     ok(propvar.vt == VT_EMPTY, "got vt %u\n", propvar.vt);
     CHECK_CALLED(test_source_BeginGetEvent);
     CHECK_CALLED(test_source_EndGetEvent);

[Nikolay Sivov (＠nsivov)]

Nikolay Sivov (@nsivov) commented about dlls/mf/session.c:
>      IMFMediaEvent_Release(event);
>
>  if (FAILED(hr = IMFMediaEventGenerator_BeginGetEvent(event_source, iface, (IUnknown *)event_source)))
> - {
>     WARN("Failed to re-subscribe, hr %#lx.\n", hr);
> -
>    IMFMediaEventQueue_QueueEventParamVar(session->event_queue, MEError, &GUID_NULL, hr, NULL);
> - }

For a quick check I commented out MEError on BeginGetEvent() failure, and that made no difference for tests.

[Santino Mazza (＠tati1454)]

On Thu Oct 19 20:45:54 2023 +0000, Nikolay Sivov wrote:
> For a quick check I commented out MEError on BeginGetEvent() failure,
> and that made no difference for tests.

That's because I didn't test for BeginGetEvent failing after EndGetEvent, I assumed it was going to be the same behaviour as if EndGetEvent failed.

[Nikolay Sivov (＠nsivov)]

On Fri Oct 20 15:10:22 2023 +0000, Santino Mazza wrote:
> That's because I didn't test for BeginGetEvent failing after
> EndGetEvent, I assumed it was going to be the same behaviour as if
> EndGetEvent failed.

Regarding tests, it's becoming unmanageable in my opinion, all these stubs with different paths. It's fine to have tests diff squashed and attached here for reference, and not included with a fix. That's once you can confirm that Begin() call part is correct.

[Santino Mazza (＠tati1454)]

On Fri Oct 20 15:42:41 2023 +0000, Nikolay Sivov wrote:
> Regarding tests, it's becoming unmanageable in my opinion, all these
> stubs with different paths. It's fine to have tests diff squashed and
> attached here for reference, and not included with a fix. That's once
> you can confirm that Begin() call part is correct.

I agree, I think they are useful for testing more cases like this though, but it's hard to find a way to make them more manageable. Should I just push the fix removing the tests and attach the diff for them?

[Santino Mazza (＠tati1454)]

On Fri Oct 20 15:49:03 2023 +0000, Santino Mazza wrote:
> I agree, I think they are useful for testing more cases like this
> though, but it's hard to find a way to make them more manageable. Should
> I just push the fix removing the tests and attach the diff for them?

mmm, apparently if an error occurs when trying to re-subscribe it emits an event, but it doesn't emit MEError, it emits the same event as the one it received.