[PATCH 0/9] MR3245: mf/session: Test native MFT call pattern, and request more samples from upstream if necessary.
This is similar to https://gitlab.winehq.org/wine/wine/-/merge_requests/2684, https://gitlab.winehq.org/wine/wine/-/merge_requests/3004 or https://gitlab.winehq.org/wine/wine/-/merge_requests/3139 but it validates the session transform node behavior with tests. The tests are added after the changes because they otherwise don't pass and making them pass would be unnecessarily complicated. I also have some local tests for MF_TOPONODE_WORKQUEUE_ID attributes and how it is supposed to behave. It basically creates new serialized work queues for every source node and assign them to every node downstream. Any sample request or processing operation is done in the associated queue. When joining streams, queues are assigned downstream one after another and the last assigned queue is used when requesting samples upstream, but when samples are received and processed downstream it looks like the current queue of the source node is used for every downstream operations. The request behavior seems to be the same when work queues are used, with round robin input requests, and single ProcessInput call followed by ProcessOutput loop until it fails. This is yet not optimally efficient, and could be improved, for the following reasons: 1) All session operations are serialized together, even unrelated streams, and ProcessInput / ProcessOutput calls may be costly and stalling the pipeline. I believe that native probably allows parallel processing of unrelated stream requests, this needs to be confirmed. 2) MFT_MESSAGE_COMMAND_DRAIN message use isn't ideal, the message forces the transform to process all queued input synchronously, which can take a long time. I haven't checked exactly what native does but I believe it instead uses MFT_MESSAGE_NOTIFY_END_OF_STREAM messages, which would allow us to notify and drain the GStreamer decoder asynchronously. 3) MFT_MESSAGE_COMMAND_DRAIN also doesn't distinguish between input streams and needs to be sent globally. It's unclear how it should be used when multiple input streams are involved, and when one stream ends its segment then start a new segment while other streams don't have yet reached EOS. MFT_MESSAGE_NOTIFY_END_OF_STREAM messages have a stream ID parameter and would be more appropriate to handle separate input streams independently. -- https://gitlab.winehq.org/wine/wine/-/merge_requests/3245
From: Rémi Bernon <rbernon(a)codeweavers.com> --- dlls/mf/session.c | 48 +++++++++++++++++++++++++++++++---------------- 1 file changed, 32 insertions(+), 16 deletions(-) diff --git a/dlls/mf/session.c b/dlls/mf/session.c index 555a71dcdf7..c629399d10e 100644 --- a/dlls/mf/session.c +++ b/dlls/mf/session.c @@ -3128,6 +3128,8 @@ static HRESULT transform_node_pull_samples(const struct media_session *session, /* Collect returned samples for all streams. */ for (i = 0; i < node->u.transform.output_count; ++i) { + struct transform_stream *stream = &node->u.transform.outputs[i]; + if (buffers[i].pEvents) IMFCollection_Release(buffers[i].pEvents); @@ -3137,7 +3139,7 @@ static HRESULT transform_node_pull_samples(const struct media_session *session, IMFQualityManager_NotifyProcessOutput(session->quality_manager, node->node, i, buffers[i].pSample); queued_sample = transform_create_sample(buffers[i].pSample); - list_add_tail(&node->u.transform.outputs[i].samples, &queued_sample->entry); + list_add_tail(&stream->samples, &queued_sample->entry); } if (buffers[i].pSample) @@ -3189,17 +3191,21 @@ static void session_deliver_sample_to_node(struct media_session *session, IMFTop } break; case MF_TOPOLOGY_TRANSFORM_NODE: + { + struct transform_stream *input_stream = &topo_node->u.transform.inputs[input]; transform_node_pull_samples(session, topo_node); sample_entry = transform_create_sample(sample); - list_add_tail(&topo_node->u.transform.inputs[input].samples, &sample_entry->entry); + list_add_tail(&input_stream->samples, &sample_entry->entry); for (i = 0; i < topo_node->u.transform.input_count; ++i) { + struct transform_stream *stream = &topo_node->u.transform.inputs[i]; + stream_id = transform_node_get_stream_id(topo_node, FALSE, i); - LIST_FOR_EACH_ENTRY_SAFE(sample_entry, sample_entry2, &topo_node->u.transform.inputs[i].samples, - struct sample, entry) + + LIST_FOR_EACH_ENTRY_SAFE(sample_entry, sample_entry2, &stream->samples, struct sample, entry) { if (sample_entry->sample) { @@ -3212,7 +3218,7 @@ static void session_deliver_sample_to_node(struct media_session *session, IMFTop } else { - transform_stream_drop_samples(&topo_node->u.transform.inputs[i]); + transform_stream_drop_samples(stream); drain = TRUE; } } @@ -3231,28 +3237,32 @@ static void session_deliver_sample_to_node(struct media_session *session, IMFTop { for (i = 0; i < topo_node->u.transform.output_count; ++i) { - if ((sample_entry = transform_create_sample(NULL))) - list_add_tail(&topo_node->u.transform.outputs[i].samples, &sample_entry->entry); + struct transform_stream *stream = &topo_node->u.transform.outputs[i]; + + if ((sample_entry = transform_create_sample(NULL))) + list_add_tail(&stream->samples, &sample_entry->entry); } } /* Push down all available output. */ for (i = 0; i < topo_node->u.transform.output_count; ++i) { + struct transform_stream *stream = &topo_node->u.transform.outputs[i]; + if (FAILED(IMFTopologyNode_GetOutput(node, i, &downstream_node, &downstream_input))) { WARN("Failed to get connected node for output %u.\n", i); continue; } - LIST_FOR_EACH_ENTRY_SAFE(sample_entry, sample_entry2, &topo_node->u.transform.outputs[i].samples, + LIST_FOR_EACH_ENTRY_SAFE(sample_entry, sample_entry2, &stream->samples, struct sample, entry) { - if (!topo_node->u.transform.outputs[i].requests) + if (!stream->requests) break; session_deliver_sample_to_node(session, downstream_node, downstream_input, sample_entry->sample); - topo_node->u.transform.outputs[i].requests--; + stream->requests--; transform_release_sample(sample_entry); } @@ -3261,6 +3271,7 @@ static void session_deliver_sample_to_node(struct media_session *session, IMFTop } break; + } case MF_TOPOLOGY_TEE_NODE: FIXME("Unhandled downstream node type %d.\n", node_type); break; @@ -3293,20 +3304,22 @@ static void session_deliver_pending_samples(struct media_session *session, IMFTo /* Push down all available output. */ for (i = 0; i < topo_node->u.transform.output_count; ++i) { + struct transform_stream *stream = &topo_node->u.transform.outputs[i]; + if (FAILED(IMFTopologyNode_GetOutput(node, i, &downstream_node, &downstream_input))) { WARN("Failed to get connected node for output %u.\n", i); continue; } - LIST_FOR_EACH_ENTRY_SAFE(sample_entry, sample_entry2, &topo_node->u.transform.outputs[i].samples, + LIST_FOR_EACH_ENTRY_SAFE(sample_entry, sample_entry2, &stream->samples, struct sample, entry) { - if (!topo_node->u.transform.outputs[i].requests) + if (!stream->requests) break; session_deliver_sample_to_node(session, downstream_node, downstream_input, sample_entry->sample); - topo_node->u.transform.outputs[i].requests--; + stream->requests--; transform_release_sample(sample_entry); } @@ -3342,14 +3355,16 @@ static HRESULT session_request_sample_from_node(struct media_session *session, I WARN("Sample request failed, hr %#lx.\n", hr); break; case MF_TOPOLOGY_TRANSFORM_NODE: + { + struct transform_stream *stream = &topo_node->u.transform.outputs[output]; - if (list_empty(&topo_node->u.transform.outputs[output].samples)) + if (list_empty(&stream->samples)) { /* Forward request to upstream node. */ if (SUCCEEDED(hr = IMFTopologyNode_GetInput(node, 0 /* FIXME */, &upstream_node, &upstream_output))) { if (SUCCEEDED(hr = session_request_sample_from_node(session, upstream_node, upstream_output))) - topo_node->u.transform.outputs[output].requests++; + stream->requests++; IMFTopologyNode_Release(upstream_node); } } @@ -3357,7 +3372,7 @@ static HRESULT session_request_sample_from_node(struct media_session *session, I { if (SUCCEEDED(hr = IMFTopologyNode_GetOutput(node, output, &downstream_node, &downstream_input))) { - sample = LIST_ENTRY(list_head(&topo_node->u.transform.outputs[output].samples), struct sample, entry); + sample = LIST_ENTRY(list_head(&stream->samples), struct sample, entry); session_deliver_sample_to_node(session, downstream_node, downstream_input, sample->sample); transform_release_sample(sample); IMFTopologyNode_Release(downstream_node); @@ -3365,6 +3380,7 @@ static HRESULT session_request_sample_from_node(struct media_session *session, I } break; + } case MF_TOPOLOGY_TEE_NODE: FIXME("Unhandled upstream node type %d.\n", node_type); default: -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/3245
From: Rémi Bernon <rbernon(a)codeweavers.com> --- dlls/mf/session.c | 98 +++++++++++++++++++---------------------------- 1 file changed, 39 insertions(+), 59 deletions(-) diff --git a/dlls/mf/session.c b/dlls/mf/session.c index c629399d10e..254fea6dfe4 100644 --- a/dlls/mf/session.c +++ b/dlls/mf/session.c @@ -3151,12 +3151,47 @@ static HRESULT transform_node_pull_samples(const struct media_session *session, return hr; } +static void session_deliver_sample_to_node(struct media_session *session, IMFTopologyNode *node, unsigned int input, + IMFSample *sample); + +static void transform_node_deliver_samples(struct media_session *session, struct topo_node *topo_node) +{ + IMFTopologyNode *up_node = topo_node->node, *down_node; + struct sample *sample, *next; + DWORD output, input; + HRESULT hr; + + /* Push down all available output. */ + for (output = 0; output < topo_node->u.transform.output_count; ++output) + { + struct transform_stream *stream = &topo_node->u.transform.outputs[output]; + + if (FAILED(hr = IMFTopologyNode_GetOutput(up_node, output, &down_node, &input))) + { + WARN("Failed to node %p/%lu output, hr %#lx.\n", up_node, output, hr); + continue; + } + + LIST_FOR_EACH_ENTRY_SAFE(sample, next, &stream->samples, struct sample, entry) + { + if (!stream->requests) + break; + + session_deliver_sample_to_node(session, down_node, input, sample->sample); + stream->requests--; + + transform_release_sample(sample); + } + + IMFTopologyNode_Release(down_node); + } +} + static void session_deliver_sample_to_node(struct media_session *session, IMFTopologyNode *node, unsigned int input, IMFSample *sample) { struct sample *sample_entry, *sample_entry2; - DWORD stream_id, downstream_input; - IMFTopologyNode *downstream_node; + DWORD stream_id; struct topo_node *topo_node; MF_TOPOLOGY_TYPE node_type; BOOL drain = FALSE; @@ -3244,32 +3279,7 @@ static void session_deliver_sample_to_node(struct media_session *session, IMFTop } } - /* Push down all available output. */ - for (i = 0; i < topo_node->u.transform.output_count; ++i) - { - struct transform_stream *stream = &topo_node->u.transform.outputs[i]; - - if (FAILED(IMFTopologyNode_GetOutput(node, i, &downstream_node, &downstream_input))) - { - WARN("Failed to get connected node for output %u.\n", i); - continue; - } - - LIST_FOR_EACH_ENTRY_SAFE(sample_entry, sample_entry2, &stream->samples, - struct sample, entry) - { - if (!stream->requests) - break; - - session_deliver_sample_to_node(session, downstream_node, downstream_input, sample_entry->sample); - stream->requests--; - - transform_release_sample(sample_entry); - } - - IMFTopologyNode_Release(downstream_node); - } - + transform_node_deliver_samples(session, topo_node); break; } case MF_TOPOLOGY_TEE_NODE: @@ -3282,13 +3292,9 @@ static void session_deliver_sample_to_node(struct media_session *session, IMFTop static void session_deliver_pending_samples(struct media_session *session, IMFTopologyNode *node) { - struct sample *sample_entry, *sample_entry2; - IMFTopologyNode *downstream_node; struct topo_node *topo_node; MF_TOPOLOGY_TYPE node_type; - DWORD downstream_input; TOPOID node_id; - unsigned int i; IMFTopologyNode_GetNodeType(node, &node_type); IMFTopologyNode_GetTopoNodeID(node, &node_id); @@ -3298,34 +3304,8 @@ static void session_deliver_pending_samples(struct media_session *session, IMFTo switch (node_type) { case MF_TOPOLOGY_TRANSFORM_NODE: - transform_node_pull_samples(session, topo_node); - - /* Push down all available output. */ - for (i = 0; i < topo_node->u.transform.output_count; ++i) - { - struct transform_stream *stream = &topo_node->u.transform.outputs[i]; - - if (FAILED(IMFTopologyNode_GetOutput(node, i, &downstream_node, &downstream_input))) - { - WARN("Failed to get connected node for output %u.\n", i); - continue; - } - - LIST_FOR_EACH_ENTRY_SAFE(sample_entry, sample_entry2, &stream->samples, - struct sample, entry) - { - if (!stream->requests) - break; - - session_deliver_sample_to_node(session, downstream_node, downstream_input, sample_entry->sample); - stream->requests--; - - transform_release_sample(sample_entry); - } - - IMFTopologyNode_Release(downstream_node); - } + transform_node_deliver_samples(session, topo_node); break; default: FIXME("Unexpected node type %u.\n", node_type); -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/3245
From: Rémi Bernon <rbernon(a)codeweavers.com> --- dlls/mf/session.c | 102 ++++++++++++++++------------------------------ 1 file changed, 36 insertions(+), 66 deletions(-) diff --git a/dlls/mf/session.c b/dlls/mf/session.c index 254fea6dfe4..23ac8917e80 100644 --- a/dlls/mf/session.c +++ b/dlls/mf/session.c @@ -196,7 +196,7 @@ struct topo_node } sink; struct { - struct transform_stream *inputs; + BOOL *inputs_eos; DWORD *input_map; unsigned int input_count; @@ -699,11 +699,9 @@ static void release_topo_node(struct topo_node *node) IMFMediaSource_Release(node->u.source.source); break; case MF_TOPOLOGY_TRANSFORM_NODE: - for (i = 0; i < node->u.transform.input_count; ++i) - transform_stream_drop_samples(&node->u.transform.inputs[i]); for (i = 0; i < node->u.transform.output_count; ++i) transform_stream_drop_samples(&node->u.transform.outputs[i]); - free(node->u.transform.inputs); + free(node->u.transform.inputs_eos); free(node->u.transform.outputs); free(node->u.transform.input_map); free(node->u.transform.output_map); @@ -1513,11 +1511,7 @@ static HRESULT session_set_transform_stream_info(struct topo_node *node) { node->u.transform.input_map = input_map; node->u.transform.output_map = output_map; - - streams = calloc(input_count, sizeof(*streams)); - for (i = 0; i < input_count; ++i) - list_init(&streams[i].samples); - node->u.transform.inputs = streams; + node->u.transform.inputs_eos = calloc(input_count, sizeof(*node->u.transform.inputs_eos)); node->u.transform.input_count = input_count; streams = calloc(output_count, sizeof(*streams)); @@ -3151,6 +3145,38 @@ static HRESULT transform_node_pull_samples(const struct media_session *session, return hr; } +static BOOL transform_node_is_end_of_stream(struct topo_node *topo_node) +{ + UINT i; + + for (i = 0; i < topo_node->u.transform.input_count; i++) + if (!topo_node->u.transform.inputs_eos[i]) + return FALSE; + + return TRUE; +} + +static void transform_node_push_sample(const struct media_session *session, struct topo_node *topo_node, + UINT input, IMFSample *sample) +{ + HRESULT hr; + + if ((topo_node->u.transform.inputs_eos[input] = !sample)) + { + if (!transform_node_is_end_of_stream(topo_node)) + return; + + if (FAILED(hr = IMFTransform_ProcessMessage(topo_node->object.transform, MFT_MESSAGE_COMMAND_DRAIN, 0))) + WARN("Drain command failed for transform, hr %#lx.\n", hr); + } + else + { + UINT id = transform_node_get_stream_id(topo_node, FALSE, input); + if (FAILED(hr = IMFTransform_ProcessInput(topo_node->object.transform, id, sample, 0))) + WARN("Failed to process input for stream %u/%u, hr %#lx.\n", input, id, hr); + } +} + static void session_deliver_sample_to_node(struct media_session *session, IMFTopologyNode *node, unsigned int input, IMFSample *sample); @@ -3190,13 +3216,9 @@ static void transform_node_deliver_samples(struct media_session *session, struct static void session_deliver_sample_to_node(struct media_session *session, IMFTopologyNode *node, unsigned int input, IMFSample *sample) { - struct sample *sample_entry, *sample_entry2; - DWORD stream_id; struct topo_node *topo_node; MF_TOPOLOGY_TYPE node_type; - BOOL drain = FALSE; TOPOID node_id; - unsigned int i; HRESULT hr; if (session->quality_manager) @@ -3226,62 +3248,10 @@ static void session_deliver_sample_to_node(struct media_session *session, IMFTop } break; case MF_TOPOLOGY_TRANSFORM_NODE: - { - struct transform_stream *input_stream = &topo_node->u.transform.inputs[input]; - - transform_node_pull_samples(session, topo_node); - - sample_entry = transform_create_sample(sample); - list_add_tail(&input_stream->samples, &sample_entry->entry); - - for (i = 0; i < topo_node->u.transform.input_count; ++i) - { - struct transform_stream *stream = &topo_node->u.transform.inputs[i]; - - stream_id = transform_node_get_stream_id(topo_node, FALSE, i); - - LIST_FOR_EACH_ENTRY_SAFE(sample_entry, sample_entry2, &stream->samples, struct sample, entry) - { - if (sample_entry->sample) - { - if ((hr = IMFTransform_ProcessInput(topo_node->object.transform, stream_id, - sample_entry->sample, 0)) == MF_E_NOTACCEPTING) - break; - if (FAILED(hr)) - WARN("Failed to process input for stream %u/%lu, hr %#lx.\n", i, stream_id, hr); - transform_release_sample(sample_entry); - } - else - { - transform_stream_drop_samples(stream); - drain = TRUE; - } - } - } - - if (drain) - { - if (FAILED(hr = IMFTransform_ProcessMessage(topo_node->object.transform, MFT_MESSAGE_COMMAND_DRAIN, 0))) - WARN("Drain command failed for transform, hr %#lx.\n", hr); - } - + transform_node_push_sample(session, topo_node, input, sample); transform_node_pull_samples(session, topo_node); - - /* Remaining unprocessed input has been discarded, now queue markers for every output. */ - if (drain) - { - for (i = 0; i < topo_node->u.transform.output_count; ++i) - { - struct transform_stream *stream = &topo_node->u.transform.outputs[i]; - - if ((sample_entry = transform_create_sample(NULL))) - list_add_tail(&stream->samples, &sample_entry->entry); - } - } - transform_node_deliver_samples(session, topo_node); break; - } case MF_TOPOLOGY_TEE_NODE: FIXME("Unhandled downstream node type %d.\n", node_type); break; -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/3245
From: Rémi Bernon <rbernon(a)codeweavers.com> --- dlls/mf/session.c | 84 ++++++++++++++++++++++++++--------------------- 1 file changed, 46 insertions(+), 38 deletions(-) diff --git a/dlls/mf/session.c b/dlls/mf/session.c index 23ac8917e80..c8198353cb5 100644 --- a/dlls/mf/session.c +++ b/dlls/mf/session.c @@ -672,20 +672,41 @@ static void session_set_caps(struct media_session *session, DWORD caps) IMFMediaEvent_Release(event); } -static void transform_release_sample(struct sample *sample) +static HRESULT transform_stream_push_sample(struct transform_stream *stream, IMFSample *sample) { - list_remove(&sample->entry); - if (sample->sample) - IMFSample_Release(sample->sample); - free(sample); + struct sample *entry; + + if (!(entry = calloc(1, sizeof(*entry)))) + return E_OUTOFMEMORY; + + entry->sample = sample; + IMFSample_AddRef(entry->sample); + + list_add_tail(&stream->samples, &entry->entry); + return S_OK; +} + +static HRESULT transform_stream_pop_sample(struct transform_stream *stream, IMFSample **sample) +{ + struct sample *entry; + struct list *ptr; + + if (!(ptr = list_head(&stream->samples))) + return E_FAIL; + + entry = LIST_ENTRY(ptr, struct sample, entry); + list_remove(&entry->entry); + *sample = entry->sample; + free(entry); + return S_OK; } static void transform_stream_drop_samples(struct transform_stream *stream) { - struct sample *sample, *sample2; + IMFSample *sample; - LIST_FOR_EACH_ENTRY_SAFE(sample, sample2, &stream->samples, struct sample, entry) - transform_release_sample(sample); + while (SUCCEEDED(transform_stream_pop_sample(stream, &sample))) + IMFSample_Release(sample); } static void release_topo_node(struct topo_node *node) @@ -3028,20 +3049,6 @@ static void session_set_sink_stream_state(struct media_session *session, IMFStre } } -static struct sample *transform_create_sample(IMFSample *sample) -{ - struct sample *sample_entry = calloc(1, sizeof(*sample_entry)); - - if (sample_entry) - { - sample_entry->sample = sample; - if (sample_entry->sample) - IMFSample_AddRef(sample_entry->sample); - } - - return sample_entry; -} - static HRESULT transform_get_external_output_sample(const struct media_session *session, struct topo_node *transform, unsigned int output_index, const MFT_OUTPUT_STREAM_INFO *stream_info, IMFSample **sample) { @@ -3090,7 +3097,6 @@ static HRESULT transform_node_pull_samples(const struct media_session *session, { MFT_OUTPUT_STREAM_INFO stream_info; MFT_OUTPUT_DATA_BUFFER *buffers; - struct sample *queued_sample; HRESULT hr = E_UNEXPECTED; DWORD status = 0; unsigned int i; @@ -3131,9 +3137,8 @@ static HRESULT transform_node_pull_samples(const struct media_session *session, { if (session->quality_manager) IMFQualityManager_NotifyProcessOutput(session->quality_manager, node->node, i, buffers[i].pSample); - - queued_sample = transform_create_sample(buffers[i].pSample); - list_add_tail(&stream->samples, &queued_sample->entry); + if (FAILED(hr = transform_stream_push_sample(stream, buffers[i].pSample))) + WARN("Failed to queue output sample, hr %#lx\n", hr); } if (buffers[i].pSample) @@ -3182,9 +3187,10 @@ static void session_deliver_sample_to_node(struct media_session *session, IMFTop static void transform_node_deliver_samples(struct media_session *session, struct topo_node *topo_node) { + BOOL draining = transform_node_is_end_of_stream(topo_node); IMFTopologyNode *up_node = topo_node->node, *down_node; - struct sample *sample, *next; DWORD output, input; + IMFSample *sample; HRESULT hr; /* Push down all available output. */ @@ -3198,15 +3204,17 @@ static void transform_node_deliver_samples(struct media_session *session, struct continue; } - LIST_FOR_EACH_ENTRY_SAFE(sample, next, &stream->samples, struct sample, entry) + while (stream->requests && SUCCEEDED(hr = transform_stream_pop_sample(stream, &sample))) { - if (!stream->requests) - break; - - session_deliver_sample_to_node(session, down_node, input, sample->sample); + session_deliver_sample_to_node(session, down_node, input, sample); stream->requests--; + IMFSample_Release(sample); + } - transform_release_sample(sample); + while (stream->requests && draining) + { + session_deliver_sample_to_node(session, down_node, input, NULL); + stream->requests--; } IMFTopologyNode_Release(down_node); @@ -3289,7 +3297,7 @@ static HRESULT session_request_sample_from_node(struct media_session *session, I DWORD downstream_input, upstream_output; struct topo_node *topo_node; MF_TOPOLOGY_TYPE node_type; - struct sample *sample; + IMFSample *sample; TOPOID node_id; HRESULT hr; @@ -3308,7 +3316,7 @@ static HRESULT session_request_sample_from_node(struct media_session *session, I { struct transform_stream *stream = &topo_node->u.transform.outputs[output]; - if (list_empty(&stream->samples)) + if (FAILED(hr = transform_stream_pop_sample(stream, &sample))) { /* Forward request to upstream node. */ if (SUCCEEDED(hr = IMFTopologyNode_GetInput(node, 0 /* FIXME */, &upstream_node, &upstream_output))) @@ -3322,11 +3330,11 @@ static HRESULT session_request_sample_from_node(struct media_session *session, I { if (SUCCEEDED(hr = IMFTopologyNode_GetOutput(node, output, &downstream_node, &downstream_input))) { - sample = LIST_ENTRY(list_head(&stream->samples), struct sample, entry); - session_deliver_sample_to_node(session, downstream_node, downstream_input, sample->sample); - transform_release_sample(sample); + session_deliver_sample_to_node(session, downstream_node, downstream_input, sample); IMFTopologyNode_Release(downstream_node); } + + IMFSample_Release(sample); } break; -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/3245
From: Rémi Bernon <rbernon(a)codeweavers.com> --- dlls/mf/session.c | 76 ++++++++++++++++++++++++++++++++++------------- 1 file changed, 56 insertions(+), 20 deletions(-) diff --git a/dlls/mf/session.c b/dlls/mf/session.c index c8198353cb5..89c05e42764 100644 --- a/dlls/mf/session.c +++ b/dlls/mf/session.c @@ -199,6 +199,7 @@ struct topo_node BOOL *inputs_eos; DWORD *input_map; unsigned int input_count; + unsigned int next_input; struct transform_stream *outputs; DWORD *output_map; @@ -3161,6 +3162,17 @@ static BOOL transform_node_is_end_of_stream(struct topo_node *topo_node) return TRUE; } +static BOOL transform_node_has_requests(struct topo_node *topo_node) +{ + UINT i; + + for (i = 0; i < topo_node->u.transform.output_count; i++) + if (topo_node->u.transform.outputs[i].requests) + return TRUE; + + return FALSE; +} + static void transform_node_push_sample(const struct media_session *session, struct topo_node *topo_node, UINT input, IMFSample *sample) { @@ -3194,7 +3206,7 @@ static void transform_node_deliver_samples(struct media_session *session, struct HRESULT hr; /* Push down all available output. */ - for (output = 0; output < topo_node->u.transform.output_count; ++output) + for (output = 0, hr = S_OK; SUCCEEDED(hr) && output < topo_node->u.transform.output_count; ++output) { struct transform_stream *stream = &topo_node->u.transform.outputs[output]; @@ -3204,8 +3216,16 @@ static void transform_node_deliver_samples(struct media_session *session, struct continue; } - while (stream->requests && SUCCEEDED(hr = transform_stream_pop_sample(stream, &sample))) + while (stream->requests) { + if (FAILED(hr = transform_stream_pop_sample(stream, &sample))) + { + if (FAILED(hr = transform_node_pull_samples(session, topo_node))) + break; + if (FAILED(hr = transform_stream_pop_sample(stream, &sample))) + break; + } + session_deliver_sample_to_node(session, down_node, input, sample); stream->requests--; IMFSample_Release(sample); @@ -3219,6 +3239,20 @@ static void transform_node_deliver_samples(struct media_session *session, struct IMFTopologyNode_Release(down_node); } + + if (transform_node_has_requests(topo_node)) + { + input = topo_node->u.transform.next_input++ % topo_node->u.transform.input_count; + + if (FAILED(hr = IMFTopologyNode_GetInput(topo_node->node, input, &up_node, &output))) + WARN("Failed to get node %p/%lu input, hr %#lx\n", topo_node->node, input, hr); + else + { + if (FAILED(hr = session_request_sample_from_node(session, up_node, output))) + WARN("Failed to request sample from upstream node %p/%lu, hr %#lx\n", up_node, output, hr); + IMFTopologyNode_Release(up_node); + } + } } static void session_deliver_sample_to_node(struct media_session *session, IMFTopologyNode *node, unsigned int input, @@ -3293,13 +3327,13 @@ static void session_deliver_pending_samples(struct media_session *session, IMFTo static HRESULT session_request_sample_from_node(struct media_session *session, IMFTopologyNode *node, DWORD output) { - IMFTopologyNode *downstream_node, *upstream_node; - DWORD downstream_input, upstream_output; + IMFTopologyNode *down_node; struct topo_node *topo_node; MF_TOPOLOGY_TYPE node_type; + HRESULT hr = S_OK; IMFSample *sample; TOPOID node_id; - HRESULT hr; + DWORD input; IMFTopologyNode_GetNodeType(node, &node_type); IMFTopologyNode_GetTopoNodeID(node, &node_id); @@ -3316,27 +3350,29 @@ static HRESULT session_request_sample_from_node(struct media_session *session, I { struct transform_stream *stream = &topo_node->u.transform.outputs[output]; - if (FAILED(hr = transform_stream_pop_sample(stream, &sample))) + if (FAILED(hr = IMFTopologyNode_GetOutput(node, output, &down_node, &input))) { - /* Forward request to upstream node. */ - if (SUCCEEDED(hr = IMFTopologyNode_GetInput(node, 0 /* FIXME */, &upstream_node, &upstream_output))) - { - if (SUCCEEDED(hr = session_request_sample_from_node(session, upstream_node, upstream_output))) - stream->requests++; - IMFTopologyNode_Release(upstream_node); - } + WARN("Failed to node %p/%lu output, hr %#lx.\n", node, output, hr); + break; } - else - { - if (SUCCEEDED(hr = IMFTopologyNode_GetOutput(node, output, &downstream_node, &downstream_input))) - { - session_deliver_sample_to_node(session, downstream_node, downstream_input, sample); - IMFTopologyNode_Release(downstream_node); - } + if (SUCCEEDED(transform_stream_pop_sample(stream, &sample))) + { + session_deliver_sample_to_node(session, down_node, input, sample); IMFSample_Release(sample); } + else if (transform_node_has_requests(topo_node)) + { + /* there's already requests pending, just increase the counter */ + stream->requests++; + } + else + { + stream->requests++; + transform_node_deliver_samples(session, topo_node); + } + IMFTopologyNode_Release(down_node); break; } case MF_TOPOLOGY_TEE_NODE: -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/3245
From: Rémi Bernon <rbernon(a)codeweavers.com> --- dlls/mf/tests/mf.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/dlls/mf/tests/mf.c b/dlls/mf/tests/mf.c index fa538e8ad9f..72170b6be5f 100644 --- a/dlls/mf/tests/mf.c +++ b/dlls/mf/tests/mf.c @@ -4951,7 +4951,7 @@ static void test_sample_grabber_orientation(GUID subtype) if (!(source = create_media_source(L"test.mp4", L"video/mp4"))) { win_skip("MP4 media source is not supported, skipping tests.\n"); - return; + goto done; } callback = create_test_callback(TRUE); @@ -5064,10 +5064,11 @@ static void test_sample_grabber_orientation(GUID subtype) IMFMediaSession_Release(session); IMFMediaSource_Release(source); + IMFSampleGrabberSinkCallback_Release(&grabber_callback->IMFSampleGrabberSinkCallback_iface); + +done: hr = MFShutdown(); ok(hr == S_OK, "Unexpected hr %#lx.\n", hr); - - IMFSampleGrabberSinkCallback_Release(&grabber_callback->IMFSampleGrabberSinkCallback_iface); } static void test_quality_manager(void) -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/3245
From: Rémi Bernon <rbernon(a)codeweavers.com> --- dlls/mf/tests/mf.c | 761 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 761 insertions(+) diff --git a/dlls/mf/tests/mf.c b/dlls/mf/tests/mf.c index 72170b6be5f..d0136efce49 100644 --- a/dlls/mf/tests/mf.c +++ b/dlls/mf/tests/mf.c @@ -7051,6 +7051,766 @@ static void test_mpeg4_media_sink(void) IMFMediaType_Release(audio_type); } +struct test_transform +{ + IMFTransform IMFTransform_iface; + LONG refcount; + + CRITICAL_SECTION cs; + CONDITION_VARIABLE results_cond; + BOOL shutdown; + + UINT input_count; + IMFMediaType *available_input_types[4]; + IMFMediaType *input_types[4]; + IMFSample *input_samples[4]; + HRESULT input_results[4]; + HANDLE process_input_event[4]; + + UINT output_count; + IMFMediaType *available_output_types[4]; + IMFMediaType *output_types[4]; + IMFSample *output_samples[4]; + HRESULT output_results[4]; + HANDLE process_output_event[4]; +}; + +static HRESULT WINAPI test_transform_QueryInterface(IMFTransform *iface, REFIID iid, void **out) +{ + struct test_transform *impl = CONTAINING_RECORD(iface, struct test_transform, IMFTransform_iface); + + if (IsEqualGUID(iid, &IID_IUnknown) + || IsEqualGUID(iid, &IID_IMFTransform)) + *out = &impl->IMFTransform_iface; + else + { + *out = NULL; + return E_NOINTERFACE; + } + + IUnknown_AddRef((IUnknown *)*out); + return S_OK; +} + +static ULONG WINAPI test_transform_AddRef(IMFTransform *iface) +{ + struct test_transform *impl = CONTAINING_RECORD(iface, struct test_transform, IMFTransform_iface); + ULONG refcount = InterlockedIncrement(&impl->refcount); + return refcount; +} + +static ULONG WINAPI test_transform_Release(IMFTransform *iface) +{ + struct test_transform *impl = CONTAINING_RECORD(iface, struct test_transform, IMFTransform_iface); + ULONG refcount = InterlockedDecrement(&impl->refcount); + UINT i; + + if (!refcount) + { + for (i = 0; i < impl->input_count; i++) + CloseHandle(impl->process_input_event[i]); + for (i = 0; i < impl->output_count; i++) + CloseHandle(impl->process_output_event[i]); + DeleteCriticalSection(&impl->cs); + free(impl); + } + + return refcount; +} + +static HRESULT WINAPI test_transform_GetStreamLimits(IMFTransform *iface, DWORD *input_minimum, + DWORD *input_maximum, DWORD *output_minimum, DWORD *output_maximum) +{ + return E_NOTIMPL; +} + +static HRESULT WINAPI test_transform_GetStreamCount(IMFTransform *iface, DWORD *inputs, DWORD *outputs) +{ + struct test_transform *impl = CONTAINING_RECORD(iface, struct test_transform, IMFTransform_iface); + *inputs = impl->input_count; + *outputs = impl->output_count; + return S_OK; +} + +static HRESULT WINAPI test_transform_GetStreamIDs(IMFTransform *iface, DWORD input_size, DWORD *inputs, + DWORD output_size, DWORD *outputs) +{ + struct test_transform *impl = CONTAINING_RECORD(iface, struct test_transform, IMFTransform_iface); + UINT i; + + for (i = 0; i < impl->input_count; ++i) + inputs[i] = i; + for (i = 0; i < impl->output_count; ++i) + outputs[i] = i; + + return S_OK; +} + +static HRESULT WINAPI test_transform_GetInputStreamInfo(IMFTransform *iface, DWORD id, MFT_INPUT_STREAM_INFO *info) +{ + info->cbAlignment = 0; + info->cbSize = 0x1000; + info->dwFlags = 0; + info->cbMaxLookahead = 0; + info->hnsMaxLatency = 0; + return S_OK; +} + +static HRESULT WINAPI test_transform_GetOutputStreamInfo(IMFTransform *iface, DWORD id, MFT_OUTPUT_STREAM_INFO *info) +{ + info->cbAlignment = 0; + info->cbSize = 0x1000; + info->dwFlags = MFT_OUTPUT_STREAM_PROVIDES_SAMPLES; + return S_OK; +} + +static HRESULT WINAPI test_transform_GetAttributes(IMFTransform *iface, IMFAttributes **attributes) +{ + return E_NOTIMPL; +} + +static HRESULT WINAPI test_transform_GetInputStreamAttributes(IMFTransform *iface, DWORD id, IMFAttributes **attributes) +{ + return E_NOTIMPL; +} + +static HRESULT WINAPI test_transform_GetOutputStreamAttributes(IMFTransform *iface, DWORD id, IMFAttributes **attributes) +{ + return E_NOTIMPL; +} + +static HRESULT WINAPI test_transform_DeleteInputStream(IMFTransform *iface, DWORD id) +{ + return E_NOTIMPL; +} + +static HRESULT WINAPI test_transform_AddInputStreams(IMFTransform *iface, DWORD streams, DWORD *ids) +{ + return E_NOTIMPL; +} + +static HRESULT WINAPI test_transform_GetInputAvailableType(IMFTransform *iface, DWORD id, DWORD index, + IMFMediaType **type) +{ + struct test_transform *impl = CONTAINING_RECORD(iface, struct test_transform, IMFTransform_iface); + HRESULT hr; + + EnterCriticalSection(&impl->cs); + if (impl->shutdown) + hr = MF_E_SHUTDOWN; + else if (index >= impl->input_count) + hr = MF_E_NO_MORE_TYPES; + else + { + IMFMediaType_AddRef((*type = impl->available_input_types[index])); + hr = S_OK; + } + LeaveCriticalSection(&impl->cs); + return hr; +} + +static HRESULT WINAPI test_transform_GetOutputAvailableType(IMFTransform *iface, DWORD id, + DWORD index, IMFMediaType **type) +{ + struct test_transform *impl = CONTAINING_RECORD(iface, struct test_transform, IMFTransform_iface); + HRESULT hr; + + EnterCriticalSection(&impl->cs); + if (impl->shutdown) + hr = MF_E_SHUTDOWN; + else if (index >= impl->output_count) + hr = MF_E_NO_MORE_TYPES; + else + { + IMFMediaType_AddRef((*type = impl->available_output_types[index])); + hr = S_OK; + } + LeaveCriticalSection(&impl->cs); + return hr; +} + +static HRESULT WINAPI test_transform_SetInputType(IMFTransform *iface, DWORD id, IMFMediaType *type, DWORD flags) +{ + struct test_transform *impl = CONTAINING_RECORD(iface, struct test_transform, IMFTransform_iface); + HRESULT hr; + + EnterCriticalSection(&impl->cs); + if (impl->shutdown) + hr = MF_E_SHUTDOWN; + else if (id >= impl->input_count) + hr = MF_E_INVALIDSTREAMNUMBER; + else + { + IMFMediaType_AddRef((impl->input_types[id] = type)); + hr = S_OK; + } + LeaveCriticalSection(&impl->cs); + return hr; +} + +static HRESULT WINAPI test_transform_SetOutputType(IMFTransform *iface, DWORD id, IMFMediaType *type, DWORD flags) +{ + struct test_transform *impl = CONTAINING_RECORD(iface, struct test_transform, IMFTransform_iface); + HRESULT hr; + + EnterCriticalSection(&impl->cs); + if (impl->shutdown) + hr = MF_E_SHUTDOWN; + else if (id >= impl->output_count) + hr = MF_E_INVALIDSTREAMNUMBER; + else + { + IMFMediaType_AddRef((impl->output_types[id] = type)); + hr = S_OK; + } + LeaveCriticalSection(&impl->cs); + return hr; +} + +static HRESULT WINAPI test_transform_GetInputCurrentType(IMFTransform *iface, DWORD id, IMFMediaType **type) +{ + struct test_transform *impl = CONTAINING_RECORD(iface, struct test_transform, IMFTransform_iface); + HRESULT hr; + + EnterCriticalSection(&impl->cs); + if (impl->shutdown) + hr = MF_E_SHUTDOWN; + else if (id >= impl->input_count) + hr = MF_E_INVALIDSTREAMNUMBER; + else if (!impl->input_types[id]) + hr = MF_E_TRANSFORM_TYPE_NOT_SET; + else + { + IMFMediaType_AddRef((*type = impl->input_types[id])); + hr = S_OK; + } + LeaveCriticalSection(&impl->cs); + return hr; +} + +static HRESULT WINAPI test_transform_GetOutputCurrentType(IMFTransform *iface, DWORD id, IMFMediaType **type) +{ + struct test_transform *impl = CONTAINING_RECORD(iface, struct test_transform, IMFTransform_iface); + HRESULT hr; + + EnterCriticalSection(&impl->cs); + if (impl->shutdown) + hr = MF_E_SHUTDOWN; + else if (id >= impl->output_count) + hr = MF_E_INVALIDSTREAMNUMBER; + else if (!impl->output_types[id]) + hr = MF_E_TRANSFORM_TYPE_NOT_SET; + else + { + IMFMediaType_AddRef((*type = impl->output_types[id])); + hr = S_OK; + } + LeaveCriticalSection(&impl->cs); + return hr; +} + +static HRESULT WINAPI test_transform_GetInputStatus(IMFTransform *iface, DWORD id, DWORD *flags) +{ + return E_NOTIMPL; +} + +static HRESULT WINAPI test_transform_GetOutputStatus(IMFTransform *iface, DWORD *flags) +{ + return E_NOTIMPL; +} + +static HRESULT WINAPI test_transform_SetOutputBounds(IMFTransform *iface, LONGLONG lower, LONGLONG upper) +{ + return E_NOTIMPL; +} + +static HRESULT WINAPI test_transform_ProcessEvent(IMFTransform *iface, DWORD id, IMFMediaEvent *event) +{ + return E_NOTIMPL; +} + +static HRESULT WINAPI test_transform_ProcessMessage(IMFTransform *iface, MFT_MESSAGE_TYPE message, ULONG_PTR param) +{ + return S_OK; +} + +static HRESULT WINAPI test_transform_ProcessInput(IMFTransform *iface, DWORD id, IMFSample *sample, DWORD flags) +{ + struct test_transform *impl = CONTAINING_RECORD(iface, struct test_transform, IMFTransform_iface); + HRESULT hr; + + EnterCriticalSection(&impl->cs); + + if (impl->shutdown) + hr = MF_E_SHUTDOWN; + else + { + if (impl->input_samples[id]) + IMFSample_Release(impl->input_samples[id]); + + impl->input_results[id] = E_PENDING; + IMFSample_AddRef((impl->input_samples[id] = sample)); + SetEvent(impl->process_input_event[id]); + + while ((hr = impl->input_results[id]) == E_PENDING && !impl->shutdown) + SleepConditionVariableCS(&impl->results_cond, &impl->cs, INFINITE); + } + + LeaveCriticalSection(&impl->cs); + return hr; +} + +static HRESULT WINAPI test_transform_ProcessOutput(IMFTransform *iface, DWORD flags, DWORD count, + MFT_OUTPUT_DATA_BUFFER *samples, DWORD *status) +{ + struct test_transform *impl = CONTAINING_RECORD(iface, struct test_transform, IMFTransform_iface); + HRESULT hr, result; + UINT i; + + EnterCriticalSection(&impl->cs); + + if (impl->shutdown) + hr = MF_E_SHUTDOWN; + else + { + for (i = 0; i < count; ++i) + { + UINT id = samples[i].dwStreamID; + ok(!samples[i].pEvents, "got pEvents\n"); + ok(!samples[i].pSample, "got pSample\n"); + ok(!samples[i].dwStatus, "got dwStatus\n"); + ok(id == i, "got dwStreamID %#lx\n", samples[i].dwStreamID); + + impl->output_results[id] = E_PENDING; + SetEvent(impl->process_output_event[id]); + } + + for (i = 0, hr = MF_E_TRANSFORM_NEED_MORE_INPUT; i < count; ++i) + { + UINT id = samples[i].dwStreamID; + while ((result = impl->output_results[id]) == E_PENDING && !impl->shutdown) + SleepConditionVariableCS(&impl->results_cond, &impl->cs, INFINITE); + samples[i].pSample = impl->output_samples[id]; + impl->output_samples[id] = NULL; + if (FAILED(result)) + samples[i].dwStatus = MFT_OUTPUT_DATA_BUFFER_NO_SAMPLE; + else + hr = S_OK; + } + + *status = 0; + } + + LeaveCriticalSection(&impl->cs); + return hr; +} + +static const IMFTransformVtbl test_transform_vtbl = +{ + test_transform_QueryInterface, + test_transform_AddRef, + test_transform_Release, + test_transform_GetStreamLimits, + test_transform_GetStreamCount, + test_transform_GetStreamIDs, + test_transform_GetInputStreamInfo, + test_transform_GetOutputStreamInfo, + test_transform_GetAttributes, + test_transform_GetInputStreamAttributes, + test_transform_GetOutputStreamAttributes, + test_transform_DeleteInputStream, + test_transform_AddInputStreams, + test_transform_GetInputAvailableType, + test_transform_GetOutputAvailableType, + test_transform_SetInputType, + test_transform_SetOutputType, + test_transform_GetInputCurrentType, + test_transform_GetOutputCurrentType, + test_transform_GetInputStatus, + test_transform_GetOutputStatus, + test_transform_SetOutputBounds, + test_transform_ProcessEvent, + test_transform_ProcessMessage, + test_transform_ProcessInput, + test_transform_ProcessOutput, +}; + +HRESULT test_transform_create(UINT input_count, IMFMediaType **input_types, + UINT output_count, IMFMediaType **output_types, IMFTransform **out) +{ + struct test_transform *impl; + UINT i; + + if (!(impl = calloc(1, sizeof(*impl)))) + return E_OUTOFMEMORY; + impl->IMFTransform_iface.lpVtbl = &test_transform_vtbl; + impl->refcount = 1; + + impl->input_count = input_count; + impl->output_count = output_count; + + for (i = 0; i < input_count; i++) + { + IMFMediaType_AddRef((impl->available_input_types[i] = input_types[i])); + impl->process_input_event[i] = CreateEventW(NULL, FALSE, FALSE, NULL); + } + for (i = 0; i < output_count; i++) + { + IMFMediaType_AddRef((impl->available_output_types[i] = output_types[i])); + impl->process_output_event[i] = CreateEventW(NULL, FALSE, FALSE, NULL); + } + + InitializeCriticalSection(&impl->cs); + + *out = &impl->IMFTransform_iface; + return S_OK; +} + +static DWORD test_transform_wait_process_input(IMFTransform *iface, DWORD timeout) +{ + struct test_transform *impl = CONTAINING_RECORD(iface, struct test_transform, IMFTransform_iface); + return WaitForMultipleObjects(impl->input_count, impl->process_input_event, FALSE, timeout); +} + +static void test_transform_get_input(IMFTransform *iface, UINT index, IMFSample **sample) +{ + struct test_transform *impl = CONTAINING_RECORD(iface, struct test_transform, IMFTransform_iface); + + EnterCriticalSection(&impl->cs); + impl->input_results[index] = sample ? S_OK : MF_E_NOTACCEPTING; + if (sample) + *sample = impl->input_samples[index]; + else if (impl->input_samples[index]) + IMFSample_Release(impl->input_samples[index]); + impl->input_samples[index] = NULL; + LeaveCriticalSection(&impl->cs); + WakeAllConditionVariable(&impl->results_cond); +} + +static DWORD test_transform_wait_process_output(IMFTransform *iface, DWORD timeout) +{ + struct test_transform *impl = CONTAINING_RECORD(iface, struct test_transform, IMFTransform_iface); + return WaitForMultipleObjects(impl->output_count, impl->process_output_event, FALSE, timeout); +} + +static void test_transform_set_output(IMFTransform *iface, UINT index, IMFSample *sample) +{ + struct test_transform *impl = CONTAINING_RECORD(iface, struct test_transform, IMFTransform_iface); + + EnterCriticalSection(&impl->cs); + impl->output_results[index] = sample ? S_OK : MF_E_TRANSFORM_NEED_MORE_INPUT; + if ((impl->output_samples[index] = sample)) + IMFSample_AddRef(sample); + LeaveCriticalSection(&impl->cs); + WakeAllConditionVariable(&impl->results_cond); +} + +static void test_transform_shutdown(IMFTransform *iface) +{ + struct test_transform *impl = CONTAINING_RECORD(iface, struct test_transform, IMFTransform_iface); + UINT i; + + EnterCriticalSection(&impl->cs); + impl->shutdown = TRUE; + for (i = 0; i < impl->input_count; i++) + { + impl->input_results[i] = MF_E_SHUTDOWN; + if (impl->input_samples[i]) + IMFSample_Release(impl->input_samples[i]); + impl->input_samples[i] = NULL; + } + for (i = 0; i < impl->output_count; i++) + { + impl->output_results[i] = MF_E_SHUTDOWN; + if (impl->output_samples[i]) + IMFSample_Release(impl->output_samples[i]); + impl->output_samples[i] = NULL; + } + LeaveCriticalSection(&impl->cs); + WakeAllConditionVariable(&impl->results_cond); +} + +static IMFTopologyNode *test_transform_create_source_node(IMFTopology *topology, + IMFMediaSource *source, UINT index, IMFMediaType **media_type) +{ + IMFPresentationDescriptor *pd; + IMFMediaTypeHandler *handler; + IMFStreamDescriptor *sd; + IMFTopologyNode *node; + BOOL selected; + HRESULT hr; + + /* create source node */ + hr = MFCreateTopologyNode(MF_TOPOLOGY_SOURCESTREAM_NODE, &node); + ok(hr == S_OK, "got hr %#lx\n", hr); + hr = IMFTopology_AddNode(topology, node); + ok(hr == S_OK, "got hr %#lx\n", hr); + + hr = IMFMediaSource_CreatePresentationDescriptor(source, &pd); + ok(hr == S_OK, "got hr %#lx\n", hr); + hr = IMFPresentationDescriptor_SelectStream(pd, index); + ok(hr == S_OK, "got hr %#lx\n", hr); + hr = IMFPresentationDescriptor_GetStreamDescriptorByIndex(pd, index, &selected, &sd); + ok(hr == S_OK, "got hr %#lx\n", hr); + + hr = IMFStreamDescriptor_GetMediaTypeHandler(sd, &handler); + ok(hr == S_OK, "got hr %#lx\n", hr); + hr = IMFMediaTypeHandler_GetMediaTypeByIndex(handler, 0, media_type); + ok(hr == S_OK, "got hr %#lx\n", hr); + IMFMediaTypeHandler_Release(handler); + + hr = IMFTopologyNode_SetUnknown(node, &MF_TOPONODE_SOURCE, (IUnknown *)source); + ok(hr == S_OK, "got hr %#lx\n", hr); + hr = IMFTopologyNode_SetUnknown(node, &MF_TOPONODE_STREAM_DESCRIPTOR, (IUnknown *)sd); + ok(hr == S_OK, "got hr %#lx\n", hr); + IMFStreamDescriptor_Release(sd); + hr = IMFTopologyNode_SetUnknown(node, &MF_TOPONODE_PRESENTATION_DESCRIPTOR, (IUnknown *)pd); + ok(hr == S_OK, "got hr %#lx\n", hr); + IMFPresentationDescriptor_Release(pd); + + return node; +} + +static IMFTopologyNode *test_transform_create_transform_node(IMFTopology *topology, + UINT input_count, IMFMediaType **input_types, UINT output_count, IMFMediaType **output_types, + IMFTransform **transform) +{ + IMFTopologyNode *node; + HRESULT hr; + + hr = MFCreateTopologyNode(MF_TOPOLOGY_TRANSFORM_NODE, &node); + ok(hr == S_OK, "got hr %#lx\n", hr); + hr = IMFTopology_AddNode(topology, node); + ok(hr == S_OK, "got hr %#lx\n", hr); + hr = test_transform_create(input_count, input_types, output_count, output_types, transform); + ok(hr == S_OK, "got hr %#lx\n", hr); + hr = IMFTopologyNode_SetObject(node, (IUnknown *)*transform); + ok(hr == S_OK, "got hr %#lx\n", hr); + hr = IMFTopologyNode_SetUINT32(node, &MF_TOPONODE_CONNECT_METHOD, MF_CONNECT_DIRECT); + ok(hr == S_OK, "got hr %#lx\n", hr); + + return node; +} + +static IMFTopologyNode *test_transform_create_output_node(IMFTopology *topology, + IMFMediaType *media_type, IMFSampleGrabberSinkCallback *callback) +{ + IMFStreamSink *stream_sink; + IMFMediaSink *media_sink; + IMFTopologyNode *node; + IMFActivate *activate; + HRESULT hr; + + /* create output node */ + hr = MFCreateTopologyNode(MF_TOPOLOGY_OUTPUT_NODE, &node); + ok(hr == S_OK, "got hr %#lx\n", hr); + hr = IMFTopology_AddNode(topology, node); + ok(hr == S_OK, "got hr %#lx\n", hr); + + hr = MFCreateSampleGrabberSinkActivate(media_type, callback, &activate); + ok(hr == S_OK, "got hr %#lx\n", hr); + hr = IMFActivate_SetUINT32(activate, &MF_SAMPLEGRABBERSINK_IGNORE_CLOCK, 1); + ok(hr == S_OK, "got hr %#lx\n", hr); + hr = IMFActivate_ActivateObject(activate, &IID_IMFMediaSink, (void **)&media_sink); + ok(hr == S_OK, "got hr %#lx\n", hr); + IMFActivate_Release(activate); + + hr = IMFMediaSink_GetStreamSinkByIndex(media_sink, 0, &stream_sink); + ok(hr == S_OK, "got hr %#lx\n", hr); + IMFMediaSink_Release(media_sink); + hr = IMFTopologyNode_SetObject(node, (IUnknown *)stream_sink); + ok(hr == S_OK, "got hr %#lx\n", hr); + IMFStreamSink_Release(stream_sink); + hr = IMFTopologyNode_SetUINT32(node, &MF_TOPONODE_CONNECT_METHOD, MF_CONNECT_DIRECT); + ok(hr == S_OK, "got hr %#lx\n", hr); + + return node; +} + +static void test_media_session_transform_simple(void) +{ + IMFAsyncCallback *media_event_callback; + IMFSampleGrabberSinkCallback *grabber_callback; + IMFTopologyNode *up_node, *node; + IMFMediaType *media_type; + IMFMediaSession *session; + LONGLONG time, duration; + IMFTransform *transform; + IMFMediaSource *source; + UINT32 i; + IMFTopology *topology; + PROPVARIANT propvar; + IMFSample *sample; + HRESULT hr; + DWORD res; + + hr = MFStartup(MF_VERSION, MFSTARTUP_FULL); + ok(hr == S_OK, "got hr %#lx\n", hr); + + if (!(source = create_media_source(L"test.mp4", L"video/mp4"))) + { + win_skip("MP4 media source is not supported, skipping tests.\n"); + goto done; + } + + grabber_callback = create_test_grabber_callback(); + media_event_callback = create_test_callback(TRUE); + + hr = MFCreateMediaSession(NULL, &session); + ok(hr == S_OK, "got hr %#lx\n", hr); + + + /* create the topology with 1 source -> MFT -> 1 output */ + + hr = MFCreateTopology(&topology); + ok(hr == S_OK, "got hr %#lx\n", hr); + + up_node = test_transform_create_source_node(topology, source, 0, &media_type); + + node = test_transform_create_transform_node(topology, 1, &media_type, 1, &media_type, &transform); + hr = IMFTopologyNode_ConnectOutput(up_node, 0, node, 0); + ok(hr == S_OK, "got hr %#lx\n", hr); + IMFTopologyNode_Release(up_node); + up_node = node; + + node = test_transform_create_output_node(topology, media_type, grabber_callback); + IMFMediaType_Release(media_type); + hr = IMFTopologyNode_ConnectOutput(up_node, 0, node, 0); + ok(hr == S_OK, "got hr %#lx\n", hr); + IMFTopologyNode_Release(up_node); + IMFTopologyNode_Release(node); + IMFMediaSource_Release(source); + + + hr = IMFMediaSession_SetTopology(session, 0, topology); + ok(hr == S_OK, "got hr %#lx\n", hr); + + hr = wait_media_event(session, media_event_callback, MESessionTopologySet, 1000, &propvar); + ok(hr == S_OK, "got 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); + IMFTopology_Release(topology); + IMFTopology_AddRef((topology = (IMFTopology *)propvar.punkVal)); + PropVariantClear(&propvar); + + hr = wait_media_event(session, media_event_callback, MESessionTopologyStatus, 1000, &propvar); + ok(hr == S_OK, "got 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); + + hr = IMFMediaSession_Start(session, &GUID_NULL, &propvar); + ok(hr == S_OK, "got hr %#lx\n", hr); + + + /* starts with a ProcessOutput call */ + + res = test_transform_wait_process_input(transform, 0); + ok(res == WAIT_TIMEOUT, "got res %#lx\n", res); + res = test_transform_wait_process_output(transform, 1000); + ok(res == 0, "got res %#lx\n", res); + + /* ProcessOutput call loops until it fails */ + + for (i = 0, time = 0, duration = 1000; i < 20; i++) + { + IMFMediaBuffer *buffer; + + winetest_push_context("%u", i); + + hr = MFCreateSample(&sample); + ok(hr == S_OK, "got hr %#lx\n", hr); + hr = MFCreateMemoryBuffer(0x1000, &buffer); + ok(hr == S_OK, "got hr %#lx\n", hr); + hr = IMFSample_AddBuffer(sample, buffer); + ok(hr == S_OK, "got hr %#lx\n", hr); + IMFMediaBuffer_Release(buffer); + + hr = IMFSample_SetSampleTime(sample, time + duration); + ok(hr == S_OK, "got hr %#lx\n", hr); + hr = IMFSample_SetSampleDuration(sample, duration); + ok(hr == S_OK, "got hr %#lx\n", hr); + + test_transform_set_output(transform, 0, sample); + + IMFSample_Release(sample); + time += duration; + + res = test_transform_wait_process_output(transform, 1000); + ok(res == 0, "got res %#lx\n", res); + + winetest_pop_context(); + } + + res = test_transform_wait_process_input(transform, 0); + ok(res == WAIT_TIMEOUT, "got res %#lx\n", res); + res = test_transform_wait_process_output(transform, 0); + ok(res == WAIT_TIMEOUT, "got res %#lx\n", res); + test_transform_set_output(transform, 0, NULL); + + for (i = 0; i < 10; i++) + { + winetest_push_context("%u", i); + + /* a single ProcessInput call */ + res = test_transform_wait_process_input(transform, 1000); + ok(res == 0, "got res %#lx\n", res); + res = test_transform_wait_process_input(transform, 0); + ok(res == WAIT_TIMEOUT, "got res %#lx\n", res); + res = test_transform_wait_process_output(transform, 0); + ok(res == WAIT_TIMEOUT, "got res %#lx\n", res); + + /* take the sample and return S_OK */ + test_transform_get_input(transform, 0, &sample); + + /* ProcessOutput call loop */ + res = test_transform_wait_process_output(transform, 1000); + ok(res == 0, "got res %#lx\n", res); + test_transform_set_output(transform, 0, sample); + + res = test_transform_wait_process_output(transform, 1000); + ok(res == 0, "got res %#lx\n", res); + test_transform_set_output(transform, 0, NULL); + + IMFSample_Release(sample); + + + /* returning MF_E_NOTACCEPTING doesn't change the pattern */ + res = test_transform_wait_process_input(transform, 1000); + ok(res == 0, "got res %#lx\n", res); + res = test_transform_wait_process_input(transform, 0); + ok(res == WAIT_TIMEOUT, "got res %#lx\n", res); + res = test_transform_wait_process_output(transform, 0); + ok(res == WAIT_TIMEOUT, "got res %#lx\n", res); + /* release the sample and return MF_E_NOTACCEPTING */ + test_transform_get_input(transform, 0, NULL); + + /* ProcessOutput call loop */ + res = test_transform_wait_process_output(transform, 1000); + ok(res == 0, "got res %#lx\n", res); + test_transform_set_output(transform, 0, NULL); + /* needs to fail at least twice */ + res = test_transform_wait_process_output(transform, 1000); + ok(res == 0, "got res %#lx\n", res); + test_transform_set_output(transform, 0, NULL); + + winetest_pop_context(); + } + + test_transform_shutdown(transform); + + IMFTransform_Release(transform); + hr = IMFMediaSession_Shutdown(session); + ok(hr == S_OK, "got hr %#lx\n", hr); + IMFMediaSession_Release(session); + + IMFAsyncCallback_Release(media_event_callback); + +done: + hr = MFShutdown(); + ok(hr == S_OK, "got hr %#lx\n", hr); +} + START_TEST(mf) { init_functions(); @@ -7085,4 +7845,5 @@ START_TEST(mf) test_MFGetTopoNodeCurrentType(); test_MFRequireProtectedEnvironment(); test_mpeg4_media_sink(); + test_media_session_transform_simple(); } -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/3245
From: Rémi Bernon <rbernon(a)codeweavers.com> --- dlls/mf/tests/mf.c | 209 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 209 insertions(+) diff --git a/dlls/mf/tests/mf.c b/dlls/mf/tests/mf.c index d0136efce49..77f768de4d7 100644 --- a/dlls/mf/tests/mf.c +++ b/dlls/mf/tests/mf.c @@ -7811,6 +7811,214 @@ done: ok(hr == S_OK, "got hr %#lx\n", hr); } +static void test_media_session_transform_multiple_outputs(void) +{ + IMFAsyncCallback *media_event_callback; + IMFSampleGrabberSinkCallback *grabber_callback; + IMFTopologyNode *up_node, *node; + IMFMediaType *media_types[2]; + IMFMediaSession *session; + LONGLONG time, duration; + IMFTransform *transform; + IMFMediaSource *source; + UINT32 i; + IMFTopology *topology; + PROPVARIANT propvar; + IMFSample *sample; + HRESULT hr; + DWORD res; + + hr = MFStartup(MF_VERSION, MFSTARTUP_FULL); + ok(hr == S_OK, "got hr %#lx\n", hr); + + if (!(source = create_media_source(L"test.mp4", L"video/mp4"))) + { + win_skip("MP4 media source is not supported, skipping tests.\n"); + goto done; + } + + grabber_callback = create_test_grabber_callback(); + media_event_callback = create_test_callback(TRUE); + + hr = MFCreateMediaSession(NULL, &session); + ok(hr == S_OK, "got hr %#lx\n", hr); + + + /* create the topology with 1 source -> MFT -> 2 output */ + hr = MFCreateTopology(&topology); + ok(hr == S_OK, "got hr %#lx\n", hr); + + up_node = test_transform_create_source_node(topology, source, 0, &media_types[0]); + IMFMediaType_AddRef((media_types[1] = media_types[0])); + + node = test_transform_create_transform_node(topology, 1, media_types, 2, media_types, &transform); + hr = IMFTopologyNode_ConnectOutput(up_node, 0, node, 0); + ok(hr == S_OK, "got hr %#lx\n", hr); + IMFTopologyNode_Release(up_node); + up_node = node; + + node = test_transform_create_output_node(topology, media_types[0], grabber_callback); + IMFMediaType_Release(media_types[0]); + hr = IMFTopologyNode_ConnectOutput(up_node, 0, node, 0); + ok(hr == S_OK, "got hr %#lx\n", hr); + IMFTopologyNode_Release(node); + + node = test_transform_create_output_node(topology, media_types[1], grabber_callback); + IMFMediaType_Release(media_types[1]); + hr = IMFTopologyNode_ConnectOutput(up_node, 1, node, 0); + ok(hr == S_OK, "got hr %#lx\n", hr); + IMFTopologyNode_Release(node); + + IMFTopologyNode_Release(up_node); + IMFMediaSource_Release(source); + + + hr = IMFMediaSession_SetTopology(session, 0, topology); + ok(hr == S_OK, "got hr %#lx\n", hr); + + hr = wait_media_event(session, media_event_callback, MESessionTopologySet, 1000, &propvar); + ok(hr == S_OK, "got 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); + IMFTopology_Release(topology); + IMFTopology_AddRef((topology = (IMFTopology *)propvar.punkVal)); + PropVariantClear(&propvar); + + hr = wait_media_event(session, media_event_callback, MESessionTopologyStatus, 1000, &propvar); + ok(hr == S_OK, "got 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); + + hr = IMFMediaSession_Start(session, &GUID_NULL, &propvar); + ok(hr == S_OK, "got hr %#lx\n", hr); + + + /* starts with a ProcessOutput call for every stream */ + + res = test_transform_wait_process_input(transform, 0); + ok(res == WAIT_TIMEOUT, "got res %#lx\n", res); + res = test_transform_wait_process_output(transform, 1000); + ok(res == 0, "got res %#lx\n", res); + res = test_transform_wait_process_output(transform, 1000); + ok(res == 1, "got res %#lx\n", res); + + /* ProcessOutput call loops until it fails */ + + for (i = 0, time = 0, duration = 1000; i < 20; i++) + { + IMFMediaBuffer *buffer; + + winetest_push_context("%u", i); + + hr = MFCreateSample(&sample); + ok(hr == S_OK, "got hr %#lx\n", hr); + hr = MFCreateMemoryBuffer(0x1000, &buffer); + ok(hr == S_OK, "got hr %#lx\n", hr); + hr = IMFSample_AddBuffer(sample, buffer); + ok(hr == S_OK, "got hr %#lx\n", hr); + IMFMediaBuffer_Release(buffer); + + hr = IMFSample_SetSampleTime(sample, time + duration); + ok(hr == S_OK, "got hr %#lx\n", hr); + hr = IMFSample_SetSampleDuration(sample, duration); + ok(hr == S_OK, "got hr %#lx\n", hr); + + test_transform_set_output(transform, 0, sample); + test_transform_set_output(transform, 1, sample); + IMFSample_Release(sample); + time += duration; + + res = test_transform_wait_process_output(transform, 1000); + ok(res == 0, "got res %#lx\n", res); + res = test_transform_wait_process_output(transform, 1000); + ok(res == 1, "got res %#lx\n", res); + + winetest_pop_context(); + } + + res = test_transform_wait_process_input(transform, 0); + ok(res == WAIT_TIMEOUT, "got res %#lx\n", res); + res = test_transform_wait_process_output(transform, 0); + ok(res == WAIT_TIMEOUT, "got res %#lx\n", res); + test_transform_set_output(transform, 0, NULL); + test_transform_set_output(transform, 1, NULL); + + for (i = 0; i < 10; i++) + { + winetest_push_context("%u", i); + + /* a single ProcessInput call */ + res = test_transform_wait_process_input(transform, 1000); + ok(res == 0, "got res %#lx\n", res); + res = test_transform_wait_process_input(transform, 0); + ok(res == WAIT_TIMEOUT, "got res %#lx\n", res); + res = test_transform_wait_process_output(transform, 0); + ok(res == WAIT_TIMEOUT, "got res %#lx\n", res); + + /* take the sample and return S_OK */ + test_transform_get_input(transform, 0, &sample); + + /* ProcessOutput call loop */ + res = test_transform_wait_process_output(transform, 1000); + ok(res == 0, "got res %#lx\n", res); + res = test_transform_wait_process_output(transform, 1000); + ok(res == 1, "got res %#lx\n", res); + test_transform_set_output(transform, 0, NULL); + test_transform_set_output(transform, 1, sample); + + res = test_transform_wait_process_output(transform, 1000); + ok(res == 0, "got res %#lx\n", res); + res = test_transform_wait_process_output(transform, 1000); + ok(res == 1, "got res %#lx\n", res); + test_transform_set_output(transform, 0, NULL); + test_transform_set_output(transform, 1, NULL); + + IMFSample_Release(sample); + + + /* returning MF_E_NOTACCEPTING doesn't change the pattern */ + res = test_transform_wait_process_input(transform, 1000); + ok(res == 0, "got res %#lx\n", res); + res = test_transform_wait_process_input(transform, 0); + ok(res == WAIT_TIMEOUT, "got res %#lx\n", res); + res = test_transform_wait_process_output(transform, 0); + ok(res == WAIT_TIMEOUT, "got res %#lx\n", res); + /* release the sample and return MF_E_NOTACCEPTING */ + test_transform_get_input(transform, 0, NULL); + + /* ProcessOutput call loop */ + res = test_transform_wait_process_output(transform, 1000); + ok(res == 0, "got res %#lx\n", res); + res = test_transform_wait_process_output(transform, 1000); + ok(res == 1, "got res %#lx\n", res); + test_transform_set_output(transform, 0, NULL); + test_transform_set_output(transform, 1, NULL); + /* needs to fail at least twice */ + res = test_transform_wait_process_output(transform, 1000); + ok(res == 0, "got res %#lx\n", res); + res = test_transform_wait_process_output(transform, 1000); + ok(res == 1, "got res %#lx\n", res); + test_transform_set_output(transform, 0, NULL); + test_transform_set_output(transform, 1, NULL); + + winetest_pop_context(); + } + + test_transform_shutdown(transform); + + IMFTransform_Release(transform); + hr = IMFMediaSession_Shutdown(session); + ok(hr == S_OK, "got hr %#lx\n", hr); + IMFMediaSession_Release(session); + + IMFAsyncCallback_Release(media_event_callback); + +done: + hr = MFShutdown(); + ok(hr == S_OK, "got hr %#lx\n", hr); +} + START_TEST(mf) { init_functions(); @@ -7846,4 +8054,5 @@ START_TEST(mf) test_MFRequireProtectedEnvironment(); test_mpeg4_media_sink(); test_media_session_transform_simple(); + test_media_session_transform_multiple_outputs(); } -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/3245
From: Rémi Bernon <rbernon(a)codeweavers.com> --- dlls/mf/tests/mf.c | 192 +++++++++++++++++++++++++++++ dlls/mf/tests/multiple-streams.mp4 | Bin 0 -> 20789 bytes dlls/mf/tests/resource.rc | 15 +++ 3 files changed, 207 insertions(+) create mode 100644 dlls/mf/tests/multiple-streams.mp4 diff --git a/dlls/mf/tests/mf.c b/dlls/mf/tests/mf.c index 77f768de4d7..26df3ddcad4 100644 --- a/dlls/mf/tests/mf.c +++ b/dlls/mf/tests/mf.c @@ -8019,6 +8019,197 @@ done: ok(hr == S_OK, "got hr %#lx\n", hr); } +static void test_media_session_transform_multiple_sources(void) +{ + IMFAsyncCallback *media_event_callback; + IMFSampleGrabberSinkCallback *grabber_callback; + IMFTopologyNode *up_nodes[2], *node; + IMFMediaType *media_types[2]; + UINT32 i; + IMFMediaSession *session; + LONGLONG time, duration; + IMFTransform *transform; + IMFMediaSource *source; + IMFTopology *topology; + PROPVARIANT propvar; + DWORD res, stream; + IMFSample *sample; + HRESULT hr; + + hr = MFStartup(MF_VERSION, MFSTARTUP_FULL); + ok(hr == S_OK, "got hr %#lx\n", hr); + + if (!(source = create_media_source(L"multiple-streams.mp4", L"video/mp4"))) + { + win_skip("MP4 media source is not supported, skipping tests.\n"); + goto done; + } + + grabber_callback = create_test_grabber_callback(); + media_event_callback = create_test_callback(TRUE); + + hr = MFCreateMediaSession(NULL, &session); + ok(hr == S_OK, "got hr %#lx\n", hr); + + + /* create the topology with 2 sources -> MFT -> 1 output */ + hr = MFCreateTopology(&topology); + ok(hr == S_OK, "got hr %#lx\n", hr); + + up_nodes[0] = test_transform_create_source_node(topology, source, 0, &media_types[0]); + up_nodes[1] = test_transform_create_source_node(topology, source, 1, &media_types[1]); + + node = test_transform_create_transform_node(topology, 2, media_types, 1, media_types, &transform); + hr = IMFTopologyNode_ConnectOutput(up_nodes[0], 0, node, 0); + ok(hr == S_OK, "got hr %#lx\n", hr); + IMFTopologyNode_Release(up_nodes[0]); + hr = IMFTopologyNode_ConnectOutput(up_nodes[1], 0, node, 1); + ok(hr == S_OK, "got hr %#lx\n", hr); + IMFTopologyNode_Release(up_nodes[1]); + up_nodes[0] = node; + + node = test_transform_create_output_node(topology, media_types[0], grabber_callback); + IMFMediaType_Release(media_types[0]); + hr = IMFTopologyNode_ConnectOutput(up_nodes[0], 0, node, 0); + ok(hr == S_OK, "got hr %#lx\n", hr); + IMFTopologyNode_Release(up_nodes[0]); + IMFTopologyNode_Release(node); + IMFMediaSource_Release(source); + + + hr = IMFMediaSession_SetTopology(session, 0, topology); + ok(hr == S_OK, "got hr %#lx\n", hr); + + hr = wait_media_event(session, media_event_callback, MESessionTopologySet, 1000, &propvar); + ok(hr == S_OK, "got 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); + IMFTopology_Release(topology); + IMFTopology_AddRef((topology = (IMFTopology *)propvar.punkVal)); + PropVariantClear(&propvar); + + hr = wait_media_event(session, media_event_callback, MESessionTopologyStatus, 1000, &propvar); + ok(hr == S_OK, "got 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); + + hr = IMFMediaSession_Start(session, &GUID_NULL, &propvar); + ok(hr == S_OK, "got hr %#lx\n", hr); + + + /* starts with a ProcessOutput call */ + + res = test_transform_wait_process_input(transform, 0); + ok(res == WAIT_TIMEOUT, "got res %#lx\n", res); + res = test_transform_wait_process_output(transform, 1000); + ok(res == 0, "got res %#lx\n", res); + + /* ProcessOutput call loops until it fails */ + + for (i = 0, time = 0, duration = 1000; i < 20; i++) + { + IMFMediaBuffer *buffer; + + winetest_push_context("%u", i); + + hr = MFCreateSample(&sample); + ok(hr == S_OK, "got hr %#lx\n", hr); + hr = MFCreateMemoryBuffer(0x1000, &buffer); + ok(hr == S_OK, "got hr %#lx\n", hr); + hr = IMFSample_AddBuffer(sample, buffer); + ok(hr == S_OK, "got hr %#lx\n", hr); + IMFMediaBuffer_Release(buffer); + + hr = IMFSample_SetSampleTime(sample, time + duration); + ok(hr == S_OK, "got hr %#lx\n", hr); + hr = IMFSample_SetSampleDuration(sample, duration); + ok(hr == S_OK, "got hr %#lx\n", hr); + + test_transform_set_output(transform, 0, sample); + + IMFSample_Release(sample); + time += duration; + + res = test_transform_wait_process_output(transform, 1000); + ok(res == 0, "got res %#lx\n", res); + + winetest_pop_context(); + } + + res = test_transform_wait_process_input(transform, 0); + ok(res == WAIT_TIMEOUT, "got res %#lx\n", res); + res = test_transform_wait_process_output(transform, 0); + ok(res == WAIT_TIMEOUT, "got res %#lx\n", res); + test_transform_set_output(transform, 0, NULL); + + for (i = 0; i < 10; i++) + { + winetest_push_context("%u", i); + + /* a single ProcessInput call for stream 0 or 1, depending on the media source */ + res = test_transform_wait_process_input(transform, 1000); + ok(res == 0 || res == 1, "got res %#lx\n", res); + stream = res; + res = test_transform_wait_process_input(transform, 0); + ok(res == WAIT_TIMEOUT, "got res %#lx\n", res); + res = test_transform_wait_process_output(transform, 0); + ok(res == WAIT_TIMEOUT, "got res %#lx\n", res); + + /* take the sample and return S_OK */ + test_transform_get_input(transform, stream, &sample); + + /* ProcessOutput call loop */ + res = test_transform_wait_process_output(transform, 1000); + ok(res == 0, "got res %#lx\n", res); + test_transform_set_output(transform, 0, sample); + + res = test_transform_wait_process_output(transform, 1000); + ok(res == 0, "got res %#lx\n", res); + test_transform_set_output(transform, 0, NULL); + + IMFSample_Release(sample); + + + /* a single ProcessInput call for stream 0 or 1, depending on the media source */ + res = test_transform_wait_process_input(transform, 1000); + ok(res == 0 || res == 1, "got res %#lx\n", res); + stream = res; + res = test_transform_wait_process_input(transform, 0); + ok(res == WAIT_TIMEOUT, "got res %#lx\n", res); + res = test_transform_wait_process_output(transform, 0); + ok(res == WAIT_TIMEOUT, "got res %#lx\n", res); + + /* release the sample and return MF_E_NOTACCEPTING */ + test_transform_get_input(transform, stream, NULL); + + /* ProcessOutput call loop */ + res = test_transform_wait_process_output(transform, 1000); + ok(res == 0, "got res %#lx\n", res); + test_transform_set_output(transform, 0, NULL); + + /* needs to fail at least twice */ + res = test_transform_wait_process_output(transform, 1000); + ok(res == 0, "got res %#lx\n", res); + test_transform_set_output(transform, 0, NULL); + + winetest_pop_context(); + } + + test_transform_shutdown(transform); + + IMFTransform_Release(transform); + hr = IMFMediaSession_Shutdown(session); + ok(hr == S_OK, "got hr %#lx\n", hr); + IMFMediaSession_Release(session); + + IMFAsyncCallback_Release(media_event_callback); + +done: + hr = MFShutdown(); + ok(hr == S_OK, "got hr %#lx\n", hr); +} + START_TEST(mf) { init_functions(); @@ -8055,4 +8246,5 @@ START_TEST(mf) test_mpeg4_media_sink(); test_media_session_transform_simple(); test_media_session_transform_multiple_outputs(); + test_media_session_transform_multiple_sources(); } diff --git a/dlls/mf/tests/multiple-streams.mp4 b/dlls/mf/tests/multiple-streams.mp4 new file mode 100644 index 0000000000000000000000000000000000000000..ffb333bd89812b050005af0684cccd4d90c65643 GIT binary patch literal 20789 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 W0QddhvkWA$$(6$Yge!?)uKa&B-o<YK literal 0 HcmV?d00001 diff --git a/dlls/mf/tests/resource.rc b/dlls/mf/tests/resource.rc index d9595c68980..9f9a0d8a4e5 100644 --- a/dlls/mf/tests/resource.rc +++ b/dlls/mf/tests/resource.rc @@ -133,3 +133,18 @@ rgb24frame.bmp RCDATA rgb24frame.bmp */ /* @makedep: test.mp4 */ test.mp4 RCDATA test.mp4 + +/* Generated with: +gst-launch-1.0 \ + audiotestsrc num-buffers=60 ! audio/x-raw,format=F32LE,channels=1 ! \ + taginject tags="language-code=eng" ! \ + audioconvert ! audioresample ! avenc_aac ! mux. \ + \ + audiotestsrc num-buffers=60 ! audio/x-raw,format=S16LE,layout=interleaved ! \ + taginject tags="language-code=fre" ! \ + audioconvert ! audioresample ! lamemp3enc ! mux. \ + \ + mp4mux name=mux ! filesink location=dlls/mf/tests/multiple-streams.mp4 +*/ +/* @makedep: multiple-streams.mp4 */ +multiple-streams.mp4 RCDATA multiple-streams.mp4 -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/3245
Hi, It looks like your patch introduced the new failures shown below. Please investigate and fix them before resubmitting your patch. If they are not new, fixing them anyway would help a lot. Otherwise please ask for the known failures list to be updated. The tests also ran into some preexisting test failures. If you know how to fix them that would be helpful. See the TestBot job for the details: The full results can be found at: https://testbot.winehq.org/JobDetails.pl?Key=134486 Your paranoid android. === w1064v1507 (64 bit report) === mf: mf.c:2942: Test failed: WaitForSingleObject returned 0x102transform.c:1181: created L"C:\\Users\\winetest\\AppData\\Local\\Temp\\nv12frame-grabber.bmp"
Nikolay Sivov (@nsivov) commented about dlls/mf/session.c:
- if (sample_entry->sample) - { - if ((hr = IMFTransform_ProcessInput(topo_node->object.transform, stream_id, - sample_entry->sample, 0)) == MF_E_NOTACCEPTING) - break; - if (FAILED(hr)) - WARN("Failed to process input for stream %u/%lu, hr %#lx.\n", i, stream_id, hr); - transform_release_sample(sample_entry); - } - else - { - transform_stream_drop_samples(stream); - drain = TRUE; - } - } - } What does this have to go? Are samples supposed to be lost if downstream transform does not accept them?
-- https://gitlab.winehq.org/wine/wine/-/merge_requests/3245#note_38043
On Wed Jul 5 20:03:27 2023 +0000, Nikolay Sivov wrote:
Why does this have to go? Are samples supposed to be lost if downstream transform does not accept them? Extending the tests to check the samples that were refused it looks like they are submitted again.
I misinterpreted the fact that refusing the sample didn't change the request pattern, and thought that we could make the code simpler by assuming that after MF_E_TRANSFORM_NEED_MORE_INPUT the transform would accept the samples. I'll restore the input sample queue. -- https://gitlab.winehq.org/wine/wine/-/merge_requests/3245#note_38047
participants (3)
-
Marvin -
Nikolay Sivov (＠nsivov) -
Rémi Bernon