[PATCH 0/12] MR929: mf/tests: More MF transform test factorization and small fixes.

[PATCH 01/12] winegstreamer: Implement H264 decoder GetStreamLimits / GetStreamCount.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/mf/tests/transform.c         |  3 ---
 dlls/winegstreamer/h264_decoder.c | 10 ++++++----
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/dlls/mf/tests/transform.c b/dlls/mf/tests/transform.c
index 9b30b9cafda..23d1c5b9a3a 100644
--- a/dlls/mf/tests/transform.c
+++ b/dlls/mf/tests/transform.c
@@ -2830,11 +2830,8 @@ static void test_h264_decoder(void)

input_count = output_count = 0xdeadbeef;
     hr = IMFTransform_GetStreamCount(transform, &input_count, &output_count);
-    todo_wine
     ok(hr == S_OK, "GetStreamCount returned %#lx\n", hr);
-    todo_wine
     ok(input_count == 1, "got input_count %lu\n", input_count);
-    todo_wine
     ok(output_count == 1, "got output_count %lu\n", output_count);
     hr = IMFTransform_GetStreamIDs(transform, 1, &input_id, 1, &output_id);
     ok(hr == E_NOTIMPL, "GetStreamIDs returned %#lx\n", hr);
diff --git a/dlls/winegstreamer/h264_decoder.c b/dlls/winegstreamer/h264_decoder.c
index 44c6d992b55..161497b0cba 100644
--- a/dlls/winegstreamer/h264_decoder.c
+++ b/dlls/winegstreamer/h264_decoder.c
@@ -256,15 +256,17 @@ static ULONG WINAPI transform_Release(IMFTransform *iface)
 static HRESULT WINAPI transform_GetStreamLimits(IMFTransform *iface, DWORD *input_minimum,
         DWORD *input_maximum, DWORD *output_minimum, DWORD *output_maximum)
 {
-    FIXME("iface %p, input_minimum %p, input_maximum %p, output_minimum %p, output_maximum %p stub!\n",
+    TRACE("iface %p, input_minimum %p, input_maximum %p, output_minimum %p, output_maximum %p.\n",
             iface, input_minimum, input_maximum, output_minimum, output_maximum);
-    return E_NOTIMPL;
+    *input_minimum = *input_maximum = *output_minimum = *output_maximum = 1;
+    return S_OK;
 }

static HRESULT WINAPI transform_GetStreamCount(IMFTransform *iface, DWORD *inputs, DWORD *outputs)
 {
-    FIXME("iface %p, inputs %p, outputs %p stub!\n", iface, inputs, outputs);
-    return E_NOTIMPL;
+    TRACE("iface %p, inputs %p, outputs %p.\n", iface, inputs, outputs);
+    *inputs = *outputs = 1;
+    return S_OK;
 }

static HRESULT WINAPI transform_GetStreamIDs(IMFTransform *iface, DWORD input_size,

[PATCH 02/12] winegstreamer: Implement WMA decoder GetStreamLimits / GetStreamCount.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/winegstreamer/wma_decoder.c | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/dlls/winegstreamer/wma_decoder.c b/dlls/winegstreamer/wma_decoder.c
index 6d8917c9c07..9ddeeb01e90 100644
--- a/dlls/winegstreamer/wma_decoder.c
+++ b/dlls/winegstreamer/wma_decoder.c
@@ -177,15 +177,17 @@ static ULONG WINAPI transform_Release(IMFTransform *iface)
 static HRESULT WINAPI transform_GetStreamLimits(IMFTransform *iface, DWORD *input_minimum,
         DWORD *input_maximum, DWORD *output_minimum, DWORD *output_maximum)
 {
-    FIXME("iface %p, input_minimum %p, input_maximum %p, output_minimum %p, output_maximum %p stub!\n",
+    TRACE("iface %p, input_minimum %p, input_maximum %p, output_minimum %p, output_maximum %p.\n",
             iface, input_minimum, input_maximum, output_minimum, output_maximum);
-    return E_NOTIMPL;
+    *input_minimum = *input_maximum = *output_minimum = *output_maximum = 1;
+    return S_OK;
 }

static HRESULT WINAPI transform_GetStreamCount(IMFTransform *iface, DWORD *inputs, DWORD *outputs)
 {
-    FIXME("iface %p, inputs %p, outputs %p stub!\n", iface, inputs, outputs);
-    return E_NOTIMPL;
+    TRACE("iface %p, inputs %p, outputs %p.\n", iface, inputs, outputs);
+    *inputs = *outputs = 1;
+    return S_OK;
 }

static HRESULT WINAPI transform_GetStreamIDs(IMFTransform *iface, DWORD input_size, DWORD *inputs,

[PATCH 03/12] winegstreamer: Check Video Processor Get(OutputStream)Attributes pointers.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/winegstreamer/video_processor.c | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/dlls/winegstreamer/video_processor.c b/dlls/winegstreamer/video_processor.c
index fcbccb3c3ef..74065103c87 100644
--- a/dlls/winegstreamer/video_processor.c
+++ b/dlls/winegstreamer/video_processor.c
@@ -249,6 +249,9 @@ static HRESULT WINAPI video_processor_GetAttributes(IMFTransform *iface, IMFAttr

FIXME("iface %p, attributes %p stub!\n", iface, attributes);

+    if (!attributes)
+        return E_POINTER;
+
     IMFAttributes_AddRef((*attributes = impl->attributes));
     return S_OK;
 }
@@ -265,6 +268,11 @@ static HRESULT WINAPI video_processor_GetOutputStreamAttributes(IMFTransform *if

FIXME("iface %p, id %#lx, attributes %p stub!\n", iface, id, attributes);

+    if (!attributes)
+        return E_POINTER;
+    if (id)
+        return MF_E_INVALIDSTREAMNUMBER;
+
     IMFAttributes_AddRef((*attributes = impl->output_attributes));
     return S_OK;
 }

[PATCH 04/12] mf/tests: Test miscellaneous and optional IMFTransform methods.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/mf/tests/transform.c | 318 ++++++++++++++++++++++----------------
 1 file changed, 184 insertions(+), 134 deletions(-)

diff --git a/dlls/mf/tests/transform.c b/dlls/mf/tests/transform.c
index 23d1c5b9a3a..8845df2eb12 100644
--- a/dlls/mf/tests/transform.c
+++ b/dlls/mf/tests/transform.c
@@ -261,6 +261,113 @@ void init_media_type(IMFMediaType *mediatype, const struct attribute_desc *desc,
     }
 }

+static void check_mft_optional_methods(IMFTransform *transform)
+{
+    DWORD in_id, out_id, in_count, out_count, in_min, in_max, out_min, out_max;
+    PROPVARIANT propvar = {.vt = VT_EMPTY};
+    IMFMediaEvent *event;
+    HRESULT hr;
+
+    in_min = in_max = out_min = out_max = 0xdeadbeef;
+    hr = IMFTransform_GetStreamLimits(transform, &in_min, &in_max, &out_min, &out_max);
+    ok(hr == S_OK, "GetStreamLimits returned %#lx\n", hr);
+    ok(in_min == 1, "got input_min %lu\n", in_min);
+    ok(in_max == 1, "got input_max %lu\n", in_max);
+    ok(out_min == 1, "got output_min %lu\n", out_min);
+    ok(out_max == 1, "got output_max %lu\n", out_max);
+
+    in_count = out_count = 0xdeadbeef;
+    hr = IMFTransform_GetStreamCount(transform, &in_count, &out_count);
+    ok(hr == S_OK, "GetStreamCount returned %#lx\n", hr);
+    ok(in_count == 1, "got input_count %lu\n", in_count);
+    ok(out_count == 1, "got output_count %lu\n", out_count);
+
+    in_count = out_count = 1;
+    in_id = out_id = 0xdeadbeef;
+    hr = IMFTransform_GetStreamIDs(transform, in_count, &in_id, out_count, &out_id);
+    ok(hr == E_NOTIMPL, "GetStreamIDs returned %#lx\n", hr);
+
+    hr = IMFTransform_DeleteInputStream(transform, 0);
+    ok(hr == E_NOTIMPL, "DeleteInputStream returned %#lx\n", hr);
+    hr = IMFTransform_DeleteInputStream(transform, 1);
+    ok(hr == E_NOTIMPL, "DeleteInputStream returned %#lx\n", hr);
+
+    hr = IMFTransform_AddInputStreams(transform, 0, NULL);
+    ok(hr == E_NOTIMPL, "AddInputStreams returned %#lx\n", hr);
+    in_id = 0xdeadbeef;
+    hr = IMFTransform_AddInputStreams(transform, 1, &in_id);
+    ok(hr == E_NOTIMPL, "AddInputStreams returned %#lx\n", hr);
+
+    hr = IMFTransform_SetOutputBounds(transform, 0, 0);
+    ok(hr == E_NOTIMPL || hr == S_OK, "SetOutputBounds returned %#lx\n", hr);
+
+    hr = MFCreateMediaEvent(MEEndOfStream, &GUID_NULL, S_OK, &propvar, &event);
+    ok(hr == S_OK, "MFCreateMediaEvent returned %#lx\n", hr);
+    hr = IMFTransform_ProcessEvent(transform, 0, NULL);
+    ok(hr == E_NOTIMPL || hr == E_POINTER || hr == E_INVALIDARG, "ProcessEvent returned %#lx\n", hr);
+    hr = IMFTransform_ProcessEvent(transform, 1, event);
+    ok(hr == E_NOTIMPL, "ProcessEvent returned %#lx\n", hr);
+    hr = IMFTransform_ProcessEvent(transform, 0, event);
+    ok(hr == E_NOTIMPL, "ProcessEvent returned %#lx\n", hr);
+    IMFMediaEvent_Release(event);
+}
+
+static void check_mft_get_attributes(IMFTransform *transform, const struct attribute_desc *expect_transform_attributes,
+        BOOL expect_output_attributes)
+{
+    IMFAttributes *attributes, *tmp_attributes;
+    UINT32 count;
+    HRESULT hr;
+    ULONG ref;
+
+    hr = IMFTransform_GetAttributes(transform, &attributes);
+    ok(hr == (expect_transform_attributes ? S_OK : E_NOTIMPL), "GetAttributes returned %#lx\n", hr);
+    if (hr == S_OK)
+    {
+        ok(hr == S_OK, "GetAttributes returned %#lx\n", hr);
+        check_attributes(attributes, expect_transform_attributes, -1);
+
+        hr = IMFTransform_GetAttributes(transform, &tmp_attributes);
+        ok(hr == S_OK, "GetAttributes returned %#lx\n", hr);
+        ok(attributes == tmp_attributes, "got attributes %p\n", tmp_attributes);
+        IMFAttributes_Release(tmp_attributes);
+
+        ref = IMFAttributes_Release(attributes);
+        ok(ref == 1, "Release returned %lu\n", ref);
+    }
+
+    hr = IMFTransform_GetOutputStreamAttributes(transform, 0, &attributes);
+    ok(hr == (expect_output_attributes ? S_OK : E_NOTIMPL)
+            || broken(hr == MF_E_UNSUPPORTED_REPRESENTATION) /* Win7 */,
+            "GetOutputStreamAttributes returned %#lx\n", hr);
+    if (hr == S_OK)
+    {
+        ok(hr == S_OK, "GetOutputStreamAttributes returned %#lx\n", hr);
+
+        count = 0xdeadbeef;
+        hr = IMFAttributes_GetCount(attributes, &count);
+        ok(hr == S_OK, "GetCount returned %#lx\n", hr);
+        ok(!count, "got %u attributes\n", count);
+
+        hr = IMFTransform_GetOutputStreamAttributes(transform, 0, &tmp_attributes);
+        ok(hr == S_OK, "GetAttributes returned %#lx\n", hr);
+        ok(attributes == tmp_attributes, "got attributes %p\n", tmp_attributes);
+        IMFAttributes_Release(tmp_attributes);
+
+        ref = IMFAttributes_Release(attributes);
+        ok(ref == 1, "Release returned %lu\n", ref);
+
+        hr = IMFTransform_GetOutputStreamAttributes(transform, 0, NULL);
+        ok(hr == E_NOTIMPL || hr == E_POINTER, "GetOutputStreamAttributes returned %#lx\n", hr);
+        hr = IMFTransform_GetOutputStreamAttributes(transform, 1, &attributes);
+        ok(hr == MF_E_INVALIDSTREAMNUMBER, "GetOutputStreamAttributes returned %#lx\n", hr);
+    }
+
+    hr = IMFTransform_GetInputStreamAttributes(transform, 0, &attributes);
+    ok(hr == E_NOTIMPL || broken(hr == MF_E_UNSUPPORTED_REPRESENTATION) /* Win7 */,
+            "GetInputStreamAttributes returned %#lx\n", hr);
+}
+
 #define check_mft_set_input_type_required(a, b) check_mft_set_input_type_required_(__LINE__, a, b)
 static void check_mft_set_input_type_required_(int line, IMFTransform *transform, const struct attribute_desc *attributes)
 {
@@ -891,17 +998,18 @@ static BOOL is_sample_copier_available_type(IMFMediaType *type)

static void test_sample_copier(void)
 {
-    DWORD input_count, output_count, output_status;
-    IMFAttributes *attributes, *attributes2;
-    DWORD in_min, in_max, out_min, out_max;
+    static const struct attribute_desc expect_transform_attributes[] =
+    {
+        ATTR_UINT32(MFT_SUPPORT_DYNAMIC_FORMAT_CHANGE, 1),
+        {0},
+    };
     IMFMediaType *mediatype, *mediatype2;
     MFT_OUTPUT_STREAM_INFO output_info;
     IMFSample *sample, *client_sample;
     MFT_INPUT_STREAM_INFO input_info;
     IMFMediaBuffer *media_buffer;
+    DWORD flags, output_status;
     IMFTransform *copier;
-    UINT32 value, count;
-    DWORD flags;
     HRESULT hr;
     LONG ref;

@@ -916,51 +1024,13 @@ static void test_sample_copier(void)
     hr = pMFCreateSampleCopierMFT(&copier);
     ok(hr == S_OK, "Failed to create sample copier, hr %#lx.\n", hr);

-    hr = IMFTransform_GetAttributes(copier, &attributes);
-    ok(hr == S_OK, "Failed to get transform attributes, hr %#lx.\n", hr);
-    hr = IMFTransform_GetAttributes(copier, &attributes2);
-    ok(hr == S_OK, "Failed to get transform attributes, hr %#lx.\n", hr);
-    ok(attributes == attributes2, "Unexpected instance.\n");
-    IMFAttributes_Release(attributes2);
-    hr = IMFAttributes_GetCount(attributes, &count);
-    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
-    ok(count == 1, "Unexpected attribute count %u.\n", count);
-    hr = IMFAttributes_GetUINT32(attributes, &MFT_SUPPORT_DYNAMIC_FORMAT_CHANGE, &value);
-    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
-    ok(!!value, "Unexpected value %u.\n", value);
-    ref = IMFAttributes_Release(attributes);
-    ok(ref == 1, "Release returned %ld\n", ref);
-
-    hr = IMFTransform_GetInputStreamAttributes(copier, 0, &attributes);
-    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
-
-    hr = IMFTransform_GetInputStreamAttributes(copier, 1, &attributes);
-    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
+    check_interface(copier, &IID_IMFTransform, TRUE);
+    check_interface(copier, &IID_IMediaObject, FALSE);
+    check_interface(copier, &IID_IPropertyStore, FALSE);
+    check_interface(copier, &IID_IPropertyBag, FALSE);

-    hr = IMFTransform_GetOutputStreamAttributes(copier, 0, &attributes);
-    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
-
-    hr = IMFTransform_GetOutputStreamAttributes(copier, 1, &attributes);
-    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
-
-    hr = IMFTransform_SetOutputBounds(copier, 0, 0);
-    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
-
-    /* No dynamic streams. */
-    input_count = output_count = 0;
-    hr = IMFTransform_GetStreamCount(copier, &input_count, &output_count);
-    ok(hr == S_OK, "Failed to get stream count, hr %#lx.\n", hr);
-    ok(input_count == 1 && output_count == 1, "Unexpected streams count.\n");
-
-    hr = IMFTransform_GetStreamLimits(copier, &in_min, &in_max, &out_min, &out_max);
-    ok(hr == S_OK, "Failed to get stream limits, hr %#lx.\n", hr);
-    ok(in_min == in_max && in_min == 1 && out_min == out_max && out_min == 1, "Unexpected stream limits.\n");
-
-    hr = IMFTransform_GetStreamIDs(copier, 1, &input_count, 1, &output_count);
-    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
-
-    hr = IMFTransform_DeleteInputStream(copier, 0);
-    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
+    check_mft_optional_methods(copier);
+    check_mft_get_attributes(copier, expect_transform_attributes, FALSE);

/* Available types. */
     hr = IMFTransform_GetInputAvailableType(copier, 0, 0, &mediatype);
@@ -1458,6 +1528,11 @@ static void test_aac_encoder(void)

check_interface(transform, &IID_IMFTransform, TRUE);
     check_interface(transform, &IID_IMediaObject, FALSE);
+    check_interface(transform, &IID_IPropertyStore, FALSE);
+    check_interface(transform, &IID_IPropertyBag, FALSE);
+
+    check_mft_optional_methods(transform);
+    check_mft_get_attributes(transform, NULL, FALSE);

check_mft_set_input_type_required(transform, input_type_desc);

@@ -1599,7 +1674,12 @@ static void test_aac_decoder(void)
             ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 2 * 44100),
         },
     };
-
+    const struct attribute_desc expect_transform_attributes[] =
+    {
+        ATTR_UINT32(MFT_SUPPORT_DYNAMIC_FORMAT_CHANGE, !has_video_processor /* 1 on W7 */, .todo = TRUE),
+        /* more AAC decoder specific attributes from CODECAPI */
+        {0},
+    };
     const struct attribute_desc input_type_desc[] =
     {
         ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio, .required = TRUE),
@@ -1648,6 +1728,11 @@ static void test_aac_decoder(void)

check_interface(transform, &IID_IMFTransform, TRUE);
     check_interface(transform, &IID_IMediaObject, FALSE);
+    check_interface(transform, &IID_IPropertyStore, FALSE);
+    check_interface(transform, &IID_IPropertyBag, FALSE);
+
+    check_mft_optional_methods(transform);
+    check_mft_get_attributes(transform, expect_transform_attributes, FALSE);

/* check default media types */

@@ -1890,6 +1975,9 @@ static void test_wma_encoder(void)
     check_interface(transform, &IID_IPropertyStore, TRUE);
     check_interface(transform, &IID_IPropertyBag, TRUE);

+    check_mft_optional_methods(transform);
+    check_mft_get_attributes(transform, NULL, FALSE);
+
     check_mft_set_input_type_required(transform, input_type_desc);

hr = MFCreateMediaType(&media_type);
@@ -2173,6 +2261,9 @@ static void test_wma_decoder(void)
     check_interface(transform, &IID_IPropertyStore, TRUE);
     check_interface(transform, &IID_IPropertyBag, TRUE);

+    check_mft_optional_methods(transform);
+    check_mft_get_attributes(transform, NULL, FALSE);
+
     /* check default media types */

hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
@@ -2451,6 +2542,15 @@ static void test_h264_decoder(void)
             ATTR_GUID(MF_MT_SUBTYPE, MFVideoFormat_H264_ES),
         },
     };
+    static const struct attribute_desc expect_transform_attributes[] =
+    {
+        ATTR_UINT32(MF_LOW_LATENCY, 0),
+        ATTR_UINT32(MF_SA_D3D_AWARE, 1, .todo = TRUE),
+        ATTR_UINT32(MF_SA_D3D11_AWARE, 1, .todo = TRUE),
+        ATTR_UINT32(MFT_DECODER_EXPOSE_OUTPUT_TYPES_IN_NATIVE_ORDER, 0, .todo = TRUE),
+        /* more H264 decoder specific attributes from CODECAPI */
+        {0},
+    };
     static const DWORD input_width = 120, input_height = 248;
     const media_type_desc default_outputs[] =
     {
@@ -2654,7 +2754,6 @@ static void test_h264_decoder(void)

MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Video, MFVideoFormat_H264};
     MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Video, MFVideoFormat_NV12};
-    DWORD input_id, output_id, input_count, output_count;
     IMFSample *input_sample, *output_sample;
     MFT_OUTPUT_STREAM_INFO output_info;
     MFT_INPUT_STREAM_INFO input_info;
@@ -2681,12 +2780,19 @@ static void test_h264_decoder(void)
             &IID_IMFTransform, (void **)&transform)))
         goto failed;

+    check_interface(transform, &IID_IMFTransform, TRUE);
+    check_interface(transform, &IID_IMediaObject, FALSE);
+    check_interface(transform, &IID_IPropertyStore, FALSE);
+    check_interface(transform, &IID_IPropertyBag, FALSE);
+
+    check_mft_optional_methods(transform);
+    check_mft_get_attributes(transform, expect_transform_attributes, TRUE);
+
     hr = IMFTransform_GetAttributes(transform, &attributes);
     ok(hr == S_OK, "GetAttributes returned %#lx\n", hr);
     hr = IMFAttributes_SetUINT32(attributes, &MF_LOW_LATENCY, 1);
     ok(hr == S_OK, "SetUINT32 returned %#lx\n", hr);
-    ret = IMFAttributes_Release(attributes);
-    ok(ret == 1, "Release returned %ld\n", ret);
+    IMFAttributes_Release(attributes);

/* no output type is available before an input type is set */

@@ -2828,14 +2934,6 @@ static void test_h264_decoder(void)
     ok(output_info.cbSize == input_width * input_height * 2, "got cbSize %#lx\n", output_info.cbSize);
     ok(output_info.cbAlignment == 0, "got cbAlignment %#lx\n", output_info.cbAlignment);

-    input_count = output_count = 0xdeadbeef;
-    hr = IMFTransform_GetStreamCount(transform, &input_count, &output_count);
-    ok(hr == S_OK, "GetStreamCount returned %#lx\n", hr);
-    ok(input_count == 1, "got input_count %lu\n", input_count);
-    ok(output_count == 1, "got output_count %lu\n", output_count);
-    hr = IMFTransform_GetStreamIDs(transform, 1, &input_id, 1, &output_id);
-    ok(hr == E_NOTIMPL, "GetStreamIDs returned %#lx\n", hr);
-
     load_resource(L"h264data.bin", &h264_encoded_data, &h264_encoded_data_len);

/* As output_info.dwFlags doesn't have MFT_OUTPUT_STREAM_CAN_PROVIDE_SAMPLES
@@ -3188,6 +3286,9 @@ static void test_audio_convert(void)
     check_interface(transform, &IID_IPropertyBag, TRUE);
     /* check_interface(transform, &IID_IWMResamplerProps, TRUE); */

+    check_mft_optional_methods(transform);
+    check_mft_get_attributes(transform, NULL, FALSE);
+
     /* check default media types */

hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
@@ -3565,9 +3666,14 @@ static void test_color_convert(void)
     check_interface(transform, &IID_IMediaObject, TRUE);
     check_interface(transform, &IID_IPropertyStore, TRUE);
     todo_wine
+    check_interface(transform, &IID_IPropertyBag, FALSE);
+    todo_wine
     check_interface(transform, &IID_IMFRealTimeClient, TRUE);
     /* check_interface(transform, &IID_IWMColorConvProps, TRUE); */

+    check_mft_optional_methods(transform);
+    check_mft_get_attributes(transform, NULL, FALSE);
+
     /* check default media types */

hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
@@ -3843,6 +3949,12 @@ static void test_video_processor(void)
     {
         ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video),
     };
+    static const struct attribute_desc expect_transform_attributes[] =
+    {
+        ATTR_UINT32(MFT_SUPPORT_3DVIDEO, 1, .todo = TRUE),
+        /* ATTR_UINT32(MF_SA_D3D_AWARE, 1), only on W7 */
+        {0},
+    };

static const MFVideoArea actual_aperture = {.Area={82,84}};
     static const DWORD actual_width = 96, actual_height = 96;
@@ -3880,11 +3992,9 @@ static void test_video_processor(void)
         .buffer_count = 1, .buffers = &output_buffer_desc,
     };

-    DWORD input_count, output_count, input_id, output_id, flags, length, output_status;
     MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Video, MFVideoFormat_NV12};
     MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Video, MFVideoFormat_I420};
-    DWORD input_min, input_max, output_min, output_max, i, j, k;
-    IMFAttributes *attributes, *attributes2;
+    DWORD i, j, k, flags, length, output_status;
     IMFSample *input_sample, *output_sample;
     IMFMediaType *media_type, *media_type2;
     const GUID *expect_available_inputs;
@@ -3895,8 +4005,6 @@ static void test_video_processor(void)
     ULONG nv12frame_data_len;
     IMFTransform *transform;
     IMFMediaBuffer *buffer;
-    IMFMediaEvent *event;
-    unsigned int value;
     UINT32 count;
     HRESULT hr;
     ULONG ret;
@@ -3923,63 +4031,12 @@ static void test_video_processor(void)
     check_interface(transform, &IID_IMFMediaEventGenerator, FALSE);
     check_interface(transform, &IID_IMFShutdown, FALSE);

-    /* Transform global attributes. */
-    hr = IMFTransform_GetAttributes(transform, &attributes);
-    ok(hr == S_OK, "Failed to get attributes, hr %#lx.\n", hr);
-
-    hr = IMFAttributes_GetCount(attributes, &count);
-    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
-    todo_wine
-    ok(!!count, "Unexpected attribute count %u.\n", count);
-
-    value = 0;
-    hr = IMFAttributes_GetUINT32(attributes, &MF_SA_D3D11_AWARE, &value);
-todo_wine {
-    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
-    ok(value == 1, "Unexpected attribute value %u.\n", value);
-}
-    hr = IMFTransform_GetAttributes(transform, &attributes2);
-    ok(hr == S_OK, "Failed to get attributes, hr %#lx.\n", hr);
-    ok(attributes == attributes2, "Unexpected instance.\n");
-    IMFAttributes_Release(attributes);
-    IMFAttributes_Release(attributes2);
-
-    hr = IMFTransform_GetStreamLimits(transform, &input_min, &input_max, &output_min, &output_max);
-    ok(hr == S_OK, "Failed to get stream limits, hr %#lx.\n", hr);
-    ok(input_min == input_max && input_min == 1 && output_min == output_max && output_min == 1,
-            "Unexpected stream limits.\n");
-
-    hr = IMFTransform_GetStreamCount(transform, &input_count, &output_count);
-    ok(hr == S_OK, "Failed to get stream count, hr %#lx.\n", hr);
-    ok(input_count == 1 && output_count == 1, "Unexpected stream count %lu, %lu.\n", input_count, output_count);
-
-    hr = IMFTransform_GetStreamIDs(transform, 1, &input_id, 1, &output_id);
-    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
-
-    input_id = 100;
-    hr = IMFTransform_AddInputStreams(transform, 1, &input_id);
-    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
-
-    hr = IMFTransform_DeleteInputStream(transform, 0);
-    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
-
     hr = IMFTransform_GetInputStatus(transform, 0, &flags);
     ok(hr == MF_E_TRANSFORM_TYPE_NOT_SET, "Unexpected hr %#lx.\n", hr);

-    hr = IMFTransform_GetInputStreamAttributes(transform, 0, &attributes);
-    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
-
     hr = IMFTransform_GetOutputStatus(transform, &flags);
     ok(hr == MF_E_TRANSFORM_TYPE_NOT_SET, "Unexpected hr %#lx.\n", hr);

-    hr = IMFTransform_GetOutputStreamAttributes(transform, 0, &attributes);
-    ok(hr == S_OK, "Failed to get output attributes, hr %#lx.\n", hr);
-    hr = IMFTransform_GetOutputStreamAttributes(transform, 0, &attributes2);
-    ok(hr == S_OK, "Failed to get output attributes, hr %#lx.\n", hr);
-    ok(attributes == attributes2, "Unexpected instance.\n");
-    IMFAttributes_Release(attributes);
-    IMFAttributes_Release(attributes2);
-
     hr = IMFTransform_GetOutputAvailableType(transform, 0, 0, &media_type);
     ok(hr == MF_E_NO_MORE_TYPES, "Unexpected hr %#lx.\n", hr);

@@ -3998,22 +4055,6 @@ todo_wine {
     hr = IMFTransform_GetInputStreamInfo(transform, 1, &input_info);
     ok(hr == MF_E_INVALIDSTREAMNUMBER, "Unexpected hr %#lx.\n", hr);

-    memset(&input_info, 0xcc, sizeof(input_info));
-    hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
-    ok(hr == S_OK, "Failed to get stream info, hr %#lx.\n", hr);
-    ok(input_info.dwFlags == 0, "Unexpected flag %#lx.\n", input_info.dwFlags);
-    ok(input_info.cbSize == 0, "Unexpected size %lu.\n", input_info.cbSize);
-    ok(input_info.cbMaxLookahead == 0, "Unexpected lookahead length %lu.\n", input_info.cbMaxLookahead);
-    ok(input_info.cbAlignment == 0, "Unexpected alignment %lu.\n", input_info.cbAlignment);
-    hr = MFCreateMediaEvent(MEUnknown, &GUID_NULL, S_OK, NULL, &event);
-    ok(hr == S_OK, "Failed to create event object, hr %#lx.\n", hr);
-    hr = IMFTransform_ProcessEvent(transform, 0, event);
-    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
-    hr = IMFTransform_ProcessEvent(transform, 1, event);
-    ok(hr == E_NOTIMPL, "Unexpected hr %#lx.\n", hr);
-    ref = IMFMediaEvent_Release(event);
-    ok(ref == 0, "Release returned %ld\n", ref);
-
     /* Configure stream types. */
     for (i = 0;;++i)
     {
@@ -4179,7 +4220,13 @@ todo_wine {
     hr = CoCreateInstance(class_id, NULL, CLSCTX_INPROC_SERVER, &IID_IMFTransform, (void **)&transform);
     ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);

-    /* check default media types */
+    check_interface(transform, &IID_IMFTransform, TRUE);
+    check_interface(transform, &IID_IMediaObject, FALSE);
+    check_interface(transform, &IID_IPropertyStore, FALSE);
+    check_interface(transform, &IID_IPropertyBag, FALSE);
+
+    check_mft_optional_methods(transform);
+    check_mft_get_attributes(transform, expect_transform_attributes, TRUE);

memset(&input_info, 0xcd, sizeof(input_info));
     hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
@@ -4569,6 +4616,9 @@ static void test_mp3_decoder(void)
     check_interface(transform, &IID_IPropertyStore, TRUE);
     check_interface(transform, &IID_IPropertyBag, FALSE);

+    check_mft_optional_methods(transform);
+    check_mft_get_attributes(transform, NULL, FALSE);
+
     /* check default media types */

hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);

[PATCH 04/12] mf/tests: Test miscellaneous and optional IMFTransform methods.

[Marvin]

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 full results can be found at:
https://testbot.winehq.org/JobDetails.pl?Key=124199

Your paranoid android.

=== debian11 (32 bit report) ===

mf:
transform.c:367: Test failed: colorconv: GetInputStreamAttributes returned 0

=== debian11 (32 bit ar:MA report) ===

mf:
transform.c:367: Test failed: colorconv: GetInputStreamAttributes returned 0

=== debian11 (32 bit de report) ===

mf:
transform.c:367: Test failed: colorconv: GetInputStreamAttributes returned 0

=== debian11 (32 bit fr report) ===

mf:
transform.c:367: Test failed: colorconv: GetInputStreamAttributes returned 0

=== debian11 (32 bit he:IL report) ===

mf:
transform.c:367: Test failed: colorconv: GetInputStreamAttributes returned 0

=== debian11 (32 bit hi:IN report) ===

mf:
transform.c:367: Test failed: colorconv: GetInputStreamAttributes returned 0

=== debian11 (32 bit ja:JP report) ===

mf:
transform.c:367: Test failed: colorconv: GetInputStreamAttributes returned 0

=== debian11 (32 bit zh:CN report) ===

mf:
transform.c:367: Test failed: colorconv: GetInputStreamAttributes returned 0

=== debian11 (32 bit WoW report) ===

mf:
transform.c:367: Test failed: colorconv: GetInputStreamAttributes returned 0

=== debian11 (64 bit WoW report) ===

mf:
transform.c:367: Test failed: colorconv: GetInputStreamAttributes returned 0

[PATCH 05/12] winegstreamer: Remove FIXME / stub! from optional transform methods.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/winegstreamer/color_convert.c   | 16 ++++++++--------
 dlls/winegstreamer/h264_decoder.c    | 14 +++++++-------
 dlls/winegstreamer/resampler.c       | 14 +++++++-------
 dlls/winegstreamer/video_processor.c | 14 +++++++-------
 dlls/winegstreamer/wma_decoder.c     | 15 +++++++--------
 5 files changed, 36 insertions(+), 37 deletions(-)

diff --git a/dlls/winegstreamer/color_convert.c b/dlls/winegstreamer/color_convert.c
index e4fb78752b0..f7e72e0e514 100644
--- a/dlls/winegstreamer/color_convert.c
+++ b/dlls/winegstreamer/color_convert.c
@@ -220,7 +220,7 @@ static HRESULT WINAPI transform_GetStreamCount(IMFTransform *iface, DWORD *input
 static HRESULT WINAPI transform_GetStreamIDs(IMFTransform *iface, DWORD input_size, DWORD *inputs,
         DWORD output_size, DWORD *outputs)
 {
-    FIXME("iface %p, input_size %lu, inputs %p, output_size %lu, outputs %p stub!\n", iface,
+    TRACE("iface %p, input_size %lu, inputs %p, output_size %lu, outputs %p.\n", iface,
             input_size, inputs, output_size, outputs);
     return E_NOTIMPL;
 }
@@ -281,31 +281,31 @@ static HRESULT WINAPI transform_GetOutputStreamInfo(IMFTransform *iface, DWORD i

static HRESULT WINAPI transform_GetAttributes(IMFTransform *iface, IMFAttributes **attributes)
 {
-    FIXME("iface %p, attributes %p stub!\n", iface, attributes);
+    TRACE("iface %p, attributes %p.\n", iface, attributes);
     return E_NOTIMPL;
 }

static HRESULT WINAPI transform_GetInputStreamAttributes(IMFTransform *iface, DWORD id, IMFAttributes **attributes)
 {
-    FIXME("iface %p, id %#lx, attributes %p stub!\n", iface, id, attributes);
-    return MFCreateAttributes(attributes, 0);
+    TRACE("iface %p, id %#lx, attributes %p.\n", iface, id, attributes);
+    return E_NOTIMPL;
 }

static HRESULT WINAPI transform_GetOutputStreamAttributes(IMFTransform *iface, DWORD id, IMFAttributes **attributes)
 {
-    FIXME("iface %p, id %#lx, attributes %p stub!\n", iface, id, attributes);
+    TRACE("iface %p, id %#lx, attributes %p.\n", iface, id, attributes);
     return E_NOTIMPL;
 }

static HRESULT WINAPI transform_DeleteInputStream(IMFTransform *iface, DWORD id)
 {
-    FIXME("iface %p, id %#lx stub!\n", iface, id);
+    TRACE("iface %p, id %#lx.\n", iface, id);
     return E_NOTIMPL;
 }

static HRESULT WINAPI transform_AddInputStreams(IMFTransform *iface, DWORD streams, DWORD *ids)
 {
-    FIXME("iface %p, streams %lu, ids %p stub!\n", iface, streams, ids);
+    TRACE("iface %p, streams %lu, ids %p.\n", iface, streams, ids);
     return E_NOTIMPL;
 }

@@ -525,7 +525,7 @@ static HRESULT WINAPI transform_GetOutputStatus(IMFTransform *iface, DWORD *flag

static HRESULT WINAPI transform_SetOutputBounds(IMFTransform *iface, LONGLONG lower, LONGLONG upper)
 {
-    FIXME("iface %p, lower %I64d, upper %I64d stub!\n", iface, lower, upper);
+    TRACE("iface %p, lower %I64d, upper %I64d.\n", iface, lower, upper);
     return E_NOTIMPL;
 }

diff --git a/dlls/winegstreamer/h264_decoder.c b/dlls/winegstreamer/h264_decoder.c
index 161497b0cba..12031588365 100644
--- a/dlls/winegstreamer/h264_decoder.c
+++ b/dlls/winegstreamer/h264_decoder.c
@@ -269,10 +269,10 @@ static HRESULT WINAPI transform_GetStreamCount(IMFTransform *iface, DWORD *input
     return S_OK;
 }

-static HRESULT WINAPI transform_GetStreamIDs(IMFTransform *iface, DWORD input_size,
-        DWORD *inputs, DWORD output_size, DWORD *outputs)
+static HRESULT WINAPI transform_GetStreamIDs(IMFTransform *iface, DWORD input_size, DWORD *inputs,
+        DWORD output_size, DWORD *outputs)
 {
-    FIXME("iface %p, input_size %lu, inputs %p, output_size %lu, outputs %p stub!\n", iface,
+    TRACE("iface %p, input_size %lu, inputs %p, output_size %lu, outputs %p.\n", iface,
             input_size, inputs, output_size, outputs);
     return E_NOTIMPL;
 }
@@ -327,7 +327,7 @@ static HRESULT WINAPI transform_GetAttributes(IMFTransform *iface, IMFAttributes

static HRESULT WINAPI transform_GetInputStreamAttributes(IMFTransform *iface, DWORD id, IMFAttributes **attributes)
 {
-    FIXME("iface %p, id %#lx, attributes %p stub!\n", iface, id, attributes);
+    TRACE("iface %p, id %#lx, attributes %p.\n", iface, id, attributes);
     return E_NOTIMPL;
 }

@@ -348,13 +348,13 @@ static HRESULT WINAPI transform_GetOutputStreamAttributes(IMFTransform *iface, D

static HRESULT WINAPI transform_DeleteInputStream(IMFTransform *iface, DWORD id)
 {
-    FIXME("iface %p, id %#lx stub!\n", iface, id);
+    TRACE("iface %p, id %#lx.\n", iface, id);
     return E_NOTIMPL;
 }

static HRESULT WINAPI transform_AddInputStreams(IMFTransform *iface, DWORD streams, DWORD *ids)
 {
-    FIXME("iface %p, streams %lu, ids %p stub!\n", iface, streams, ids);
+    TRACE("iface %p, streams %lu, ids %p.\n", iface, streams, ids);
     return E_NOTIMPL;
 }

@@ -568,7 +568,7 @@ static HRESULT WINAPI transform_GetOutputStatus(IMFTransform *iface, DWORD *flag

static HRESULT WINAPI transform_SetOutputBounds(IMFTransform *iface, LONGLONG lower, LONGLONG upper)
 {
-    FIXME("iface %p, lower %I64d, upper %I64d stub!\n", iface, lower, upper);
+    TRACE("iface %p, lower %I64d, upper %I64d.\n", iface, lower, upper);
     return E_NOTIMPL;
 }

diff --git a/dlls/winegstreamer/resampler.c b/dlls/winegstreamer/resampler.c
index a9c9ae32e8a..d7227aab2b3 100644
--- a/dlls/winegstreamer/resampler.c
+++ b/dlls/winegstreamer/resampler.c
@@ -183,7 +183,7 @@ static HRESULT WINAPI transform_GetStreamCount(IMFTransform *iface, DWORD *input
 static HRESULT WINAPI transform_GetStreamIDs(IMFTransform *iface, DWORD input_size, DWORD *inputs,
         DWORD output_size, DWORD *outputs)
 {
-    FIXME("iface %p, input_size %lu, inputs %p, output_size %lu, outputs %p stub!\n", iface,
+    TRACE("iface %p, input_size %lu, inputs %p, output_size %lu, outputs %p.\n", iface,
             input_size, inputs, output_size, outputs);
     return E_NOTIMPL;
 }
@@ -234,31 +234,31 @@ static HRESULT WINAPI transform_GetOutputStreamInfo(IMFTransform *iface, DWORD i

static HRESULT WINAPI transform_GetAttributes(IMFTransform *iface, IMFAttributes **attributes)
 {
-    FIXME("iface %p, attributes %p stub!\n", iface, attributes);
+    TRACE("iface %p, attributes %p.\n", iface, attributes);
     return E_NOTIMPL;
 }

static HRESULT WINAPI transform_GetInputStreamAttributes(IMFTransform *iface, DWORD id, IMFAttributes **attributes)
 {
-    FIXME("iface %p, id %#lx, attributes %p stub!\n", iface, id, attributes);
+    TRACE("iface %p, id %#lx, attributes %p.\n", iface, id, attributes);
     return E_NOTIMPL;
 }

static HRESULT WINAPI transform_GetOutputStreamAttributes(IMFTransform *iface, DWORD id, IMFAttributes **attributes)
 {
-    FIXME("iface %p, id %#lx, attributes %p stub!\n", iface, id, attributes);
+    TRACE("iface %p, id %#lx, attributes %p.\n", iface, id, attributes);
     return E_NOTIMPL;
 }

static HRESULT WINAPI transform_DeleteInputStream(IMFTransform *iface, DWORD id)
 {
-    FIXME("iface %p, id %#lx stub!\n", iface, id);
+    TRACE("iface %p, id %#lx.\n", iface, id);
     return E_NOTIMPL;
 }

static HRESULT WINAPI transform_AddInputStreams(IMFTransform *iface, DWORD streams, DWORD *ids)
 {
-    FIXME("iface %p, streams %lu, ids %p stub!\n", iface, streams, ids);
+    TRACE("iface %p, streams %lu, ids %p.\n", iface, streams, ids);
     return E_NOTIMPL;
 }

@@ -494,7 +494,7 @@ static HRESULT WINAPI transform_GetOutputStatus(IMFTransform *iface, DWORD *flag

static HRESULT WINAPI transform_SetOutputBounds(IMFTransform *iface, LONGLONG lower, LONGLONG upper)
 {
-    FIXME("iface %p, lower %I64d, upper %I64d stub!\n", iface, lower, upper);
+    TRACE("iface %p, lower %I64d, upper %I64d.\n", iface, lower, upper);
     return E_NOTIMPL;
 }

diff --git a/dlls/winegstreamer/video_processor.c b/dlls/winegstreamer/video_processor.c
index 74065103c87..a67ed8d6efd 100644
--- a/dlls/winegstreamer/video_processor.c
+++ b/dlls/winegstreamer/video_processor.c
@@ -184,7 +184,7 @@ static HRESULT WINAPI video_processor_GetStreamCount(IMFTransform *iface, DWORD
 static HRESULT WINAPI video_processor_GetStreamIDs(IMFTransform *iface, DWORD input_size, DWORD *inputs,
         DWORD output_size, DWORD *outputs)
 {
-    FIXME("iface %p, input_size %lu, inputs %p, output_size %lu, outputs %p stub!\n", iface,
+    TRACE("iface %p, input_size %lu, inputs %p, output_size %lu, outputs %p.\n", iface,
             input_size, inputs, output_size, outputs);
     return E_NOTIMPL;
 }
@@ -247,7 +247,7 @@ static HRESULT WINAPI video_processor_GetAttributes(IMFTransform *iface, IMFAttr
 {
     struct video_processor *impl = impl_from_IMFTransform(iface);

-    FIXME("iface %p, attributes %p stub!\n", iface, attributes);
+    FIXME("iface %p, attributes %p semi-stub!\n", iface, attributes);

if (!attributes)
         return E_POINTER;
@@ -258,7 +258,7 @@ static HRESULT WINAPI video_processor_GetAttributes(IMFTransform *iface, IMFAttr

static HRESULT WINAPI video_processor_GetInputStreamAttributes(IMFTransform *iface, DWORD id, IMFAttributes **attributes)
 {
-    FIXME("iface %p, id %#lx, attributes %p stub!\n", iface, id, attributes);
+    TRACE("iface %p, id %#lx, attributes %p.\n", iface, id, attributes);
     return E_NOTIMPL;
 }

@@ -266,7 +266,7 @@ static HRESULT WINAPI video_processor_GetOutputStreamAttributes(IMFTransform *if
 {
     struct video_processor *impl = impl_from_IMFTransform(iface);

-    FIXME("iface %p, id %#lx, attributes %p stub!\n", iface, id, attributes);
+    FIXME("iface %p, id %#lx, attributes %p semi-stub!\n", iface, id, attributes);

if (!attributes)
         return E_POINTER;
@@ -279,13 +279,13 @@ static HRESULT WINAPI video_processor_GetOutputStreamAttributes(IMFTransform *if

static HRESULT WINAPI video_processor_DeleteInputStream(IMFTransform *iface, DWORD id)
 {
-    FIXME("iface %p, id %#lx stub!\n", iface, id);
+    TRACE("iface %p, id %#lx.\n", iface, id);
     return E_NOTIMPL;
 }

static HRESULT WINAPI video_processor_AddInputStreams(IMFTransform *iface, DWORD streams, DWORD *ids)
 {
-    FIXME("iface %p, streams %lu, ids %p stub!\n", iface, streams, ids);
+    TRACE("iface %p, streams %lu, ids %p.\n", iface, streams, ids);
     return E_NOTIMPL;
 }

@@ -510,7 +510,7 @@ static HRESULT WINAPI video_processor_GetOutputStatus(IMFTransform *iface, DWORD

static HRESULT WINAPI video_processor_SetOutputBounds(IMFTransform *iface, LONGLONG lower, LONGLONG upper)
 {
-    FIXME("iface %p, lower %I64d, upper %I64d stub!\n", iface, lower, upper);
+    TRACE("iface %p, lower %I64d, upper %I64d.\n", iface, lower, upper);
     return E_NOTIMPL;
 }

diff --git a/dlls/winegstreamer/wma_decoder.c b/dlls/winegstreamer/wma_decoder.c
index 9ddeeb01e90..99328103bad 100644
--- a/dlls/winegstreamer/wma_decoder.c
+++ b/dlls/winegstreamer/wma_decoder.c
@@ -193,7 +193,7 @@ static HRESULT WINAPI transform_GetStreamCount(IMFTransform *iface, DWORD *input
 static HRESULT WINAPI transform_GetStreamIDs(IMFTransform *iface, DWORD input_size, DWORD *inputs,
         DWORD output_size, DWORD *outputs)
 {
-    FIXME("iface %p, input_size %lu, inputs %p, output_size %lu, outputs %p stub!\n", iface,
+    TRACE("iface %p, input_size %lu, inputs %p, output_size %lu, outputs %p.\n", iface,
             input_size, inputs, output_size, outputs);
     return E_NOTIMPL;
 }
@@ -246,31 +246,31 @@ static HRESULT WINAPI transform_GetOutputStreamInfo(IMFTransform *iface, DWORD i

static HRESULT WINAPI transform_GetAttributes(IMFTransform *iface, IMFAttributes **attributes)
 {
-    FIXME("iface %p, attributes %p stub!\n", iface, attributes);
+    TRACE("iface %p, attributes %p.\n", iface, attributes);
     return E_NOTIMPL;
 }

static HRESULT WINAPI transform_GetInputStreamAttributes(IMFTransform *iface, DWORD id, IMFAttributes **attributes)
 {
-    FIXME("iface %p, id %lu, attributes %p stub!\n", iface, id, attributes);
+    TRACE("iface %p, id %#lx, attributes %p.\n", iface, id, attributes);
     return E_NOTIMPL;
 }

static HRESULT WINAPI transform_GetOutputStreamAttributes(IMFTransform *iface, DWORD id, IMFAttributes **attributes)
 {
-    FIXME("iface %p, id %lu, attributes %p stub!\n", iface, id, attributes);
+    TRACE("iface %p, id %#lx, attributes %p.\n", iface, id, attributes);
     return E_NOTIMPL;
 }

static HRESULT WINAPI transform_DeleteInputStream(IMFTransform *iface, DWORD id)
 {
-    FIXME("iface %p, id %lu stub!\n", iface, id);
+    TRACE("iface %p, id %#lx.\n", iface, id);
     return E_NOTIMPL;
 }

static HRESULT WINAPI transform_AddInputStreams(IMFTransform *iface, DWORD streams, DWORD *ids)
 {
-    FIXME("iface %p, streams %lu, ids %p stub!\n", iface, streams, ids);
+    TRACE("iface %p, streams %lu, ids %p.\n", iface, streams, ids);
     return E_NOTIMPL;
 }

@@ -511,8 +511,7 @@ static HRESULT WINAPI transform_GetOutputStatus(IMFTransform *iface, DWORD *flag

static HRESULT WINAPI transform_SetOutputBounds(IMFTransform *iface, LONGLONG lower, LONGLONG upper)
 {
-    FIXME("iface %p, lower %s, upper %s stub!\n", iface, wine_dbgstr_longlong(lower),
-            wine_dbgstr_longlong(upper));
+    TRACE("iface %p, lower %I64d, upper %I64d.\n", iface, lower, upper);
     return E_NOTIMPL;
 }

[PATCH 06/12] winegstreamer: Keep input / output stream info in struct color_convert.

[Rémi Bernon]

From: Rémi Bernon

And calculate the sizes when media type is successfully changed.
---
 dlls/winegstreamer/color_convert.c | 62 +++++++++++++-----------------
 1 file changed, 26 insertions(+), 36 deletions(-)

diff --git a/dlls/winegstreamer/color_convert.c b/dlls/winegstreamer/color_convert.c
index f7e72e0e514..7ffe29de907 100644
--- a/dlls/winegstreamer/color_convert.c
+++ b/dlls/winegstreamer/color_convert.c
@@ -80,8 +80,11 @@ struct color_convert
     IPropertyStore IPropertyStore_iface;
     IUnknown *outer;
     LONG refcount;
+
     IMFMediaType *input_type;
+    MFT_INPUT_STREAM_INFO input_info;
     IMFMediaType *output_type;
+    MFT_OUTPUT_STREAM_INFO output_info;

struct wg_transform *wg_transform;
     struct wg_sample_queue *wg_sample_queue;
@@ -228,54 +231,32 @@ static HRESULT WINAPI transform_GetStreamIDs(IMFTransform *iface, DWORD input_si
 static HRESULT WINAPI transform_GetInputStreamInfo(IMFTransform *iface, DWORD id, MFT_INPUT_STREAM_INFO *info)
 {
     struct color_convert *impl = impl_from_IMFTransform(iface);
-    UINT32 sample_size;
-    UINT64 framesize;
-    GUID subtype;
-    HRESULT hr;

TRACE("iface %p, id %#lx, info %p.\n", iface, id, info);

if (!impl->input_type || !impl->output_type)
+    {
+        memset(info, 0, sizeof(*info));
         return MF_E_TRANSFORM_TYPE_NOT_SET;
+    }

-    if (SUCCEEDED(hr = IMFMediaType_GetGUID(impl->input_type, &MF_MT_SUBTYPE, &subtype)) &&
-        SUCCEEDED(hr = IMFMediaType_GetUINT64(impl->input_type, &MF_MT_FRAME_SIZE, &framesize)))
-        MFCalculateImageSize(&subtype, framesize >> 32, (UINT32)framesize, &sample_size);
-    else
-        sample_size = 0;
-
-    info->dwFlags = 0;
-    info->cbSize = sample_size;
-    info->cbAlignment = 1;
-    info->hnsMaxLatency = 0;
-    info->cbMaxLookahead = 0;
-
+    *info = impl->input_info;
     return S_OK;
 }

static HRESULT WINAPI transform_GetOutputStreamInfo(IMFTransform *iface, DWORD id, MFT_OUTPUT_STREAM_INFO *info)
 {
     struct color_convert *impl = impl_from_IMFTransform(iface);
-    UINT32 sample_size;
-    UINT64 framesize;
-    GUID subtype;
-    HRESULT hr;

TRACE("iface %p, id %#lx, info %p.\n", iface, id, info);

if (!impl->input_type || !impl->output_type)
+    {
+        memset(info, 0, sizeof(*info));
         return MF_E_TRANSFORM_TYPE_NOT_SET;
+    }

-    if (SUCCEEDED(hr = IMFMediaType_GetGUID(impl->output_type, &MF_MT_SUBTYPE, &subtype)) &&
-        SUCCEEDED(hr = IMFMediaType_GetUINT64(impl->output_type, &MF_MT_FRAME_SIZE, &framesize)))
-        MFCalculateImageSize(&subtype, framesize >> 32, (UINT32)framesize, &sample_size);
-    else
-        sample_size = 0;
-
-    info->dwFlags = 0;
-    info->cbSize = sample_size;
-    info->cbAlignment = 1;
-
+    *info = impl->output_info;
     return S_OK;
 }

@@ -380,8 +361,8 @@ done:
 static HRESULT WINAPI transform_SetInputType(IMFTransform *iface, DWORD id, IMFMediaType *type, DWORD flags)
 {
     struct color_convert *impl = impl_from_IMFTransform(iface);
-    MF_ATTRIBUTE_TYPE item_type;
     GUID major, subtype;
+    UINT64 frame_size;
     HRESULT hr;
     ULONG i;

@@ -392,8 +373,7 @@ static HRESULT WINAPI transform_SetInputType(IMFTransform *iface, DWORD id, IMFM
         return MF_E_ATTRIBUTENOTFOUND;

if (!IsEqualGUID(&major, &MFMediaType_Video)
-            || FAILED(IMFMediaType_GetItemType(type, &MF_MT_FRAME_SIZE, &item_type))
-            || item_type != MF_ATTRIBUTE_UINT64)
+            || IMFMediaType_GetUINT64(type, &MF_MT_FRAME_SIZE, &frame_size))
         return E_INVALIDARG;

for (i = 0; i < ARRAY_SIZE(input_types); ++i)
@@ -419,14 +399,18 @@ static HRESULT WINAPI transform_SetInputType(IMFTransform *iface, DWORD id, IMFM
         impl->input_type = NULL;
     }

+    if (FAILED(hr) || FAILED(MFCalculateImageSize(&subtype, frame_size >> 32, (UINT32)frame_size,
+            (UINT32 *)&impl->input_info.cbSize)))
+        impl->input_info.cbSize = 0;
+
     return hr;
 }

static HRESULT WINAPI transform_SetOutputType(IMFTransform *iface, DWORD id, IMFMediaType *type, DWORD flags)
 {
     struct color_convert *impl = impl_from_IMFTransform(iface);
-    MF_ATTRIBUTE_TYPE item_type;
     GUID major, subtype;
+    UINT64 frame_size;
     HRESULT hr;
     ULONG i;

@@ -437,8 +421,7 @@ static HRESULT WINAPI transform_SetOutputType(IMFTransform *iface, DWORD id, IMF
         return MF_E_ATTRIBUTENOTFOUND;

if (!IsEqualGUID(&major, &MFMediaType_Video)
-            || FAILED(IMFMediaType_GetItemType(type, &MF_MT_FRAME_SIZE, &item_type))
-            || item_type != MF_ATTRIBUTE_UINT64)
+            || IMFMediaType_GetUINT64(type, &MF_MT_FRAME_SIZE, &frame_size))
         return E_INVALIDARG;

for (i = 0; i < ARRAY_SIZE(output_types); ++i)
@@ -464,6 +447,10 @@ static HRESULT WINAPI transform_SetOutputType(IMFTransform *iface, DWORD id, IMF
         impl->output_type = NULL;
     }

+    if (FAILED(hr) || FAILED(MFCalculateImageSize(&subtype, frame_size >> 32, (UINT32)frame_size,
+            (UINT32 *)&impl->output_info.cbSize)))
+        impl->output_info.cbSize = 0;
+
     return hr;
 }

@@ -963,6 +950,9 @@ HRESULT color_convert_create(IUnknown *outer, IUnknown **out)
     impl->refcount = 1;
     impl->outer = outer ? outer : &impl->IUnknown_inner;

+    impl->input_info.cbAlignment = 1;
+    impl->output_info.cbAlignment = 1;
+
     *out = &impl->IUnknown_inner;
     TRACE("Created %p\n", *out);
     return S_OK;

[PATCH 07/12] winegstreamer: Keep input / output stream info in struct resampler.

[Rémi Bernon]

From: Rémi Bernon

And calculate the sizes when media type is successfully changed.
---
 dlls/winegstreamer/resampler.c | 50 ++++++++++++++++++----------------
 1 file changed, 26 insertions(+), 24 deletions(-)

diff --git a/dlls/winegstreamer/resampler.c b/dlls/winegstreamer/resampler.c
index d7227aab2b3..85724b0dea2 100644
--- a/dlls/winegstreamer/resampler.c
+++ b/dlls/winegstreamer/resampler.c
@@ -43,8 +43,11 @@ struct resampler
     IPropertyStore IPropertyStore_iface;
     IUnknown *outer;
     LONG refcount;
+
     IMFMediaType *input_type;
+    MFT_INPUT_STREAM_INFO input_info;
     IMFMediaType *output_type;
+    MFT_OUTPUT_STREAM_INFO output_info;

struct wg_transform *wg_transform;
     struct wg_sample_queue *wg_sample_queue;
@@ -191,44 +194,32 @@ static HRESULT WINAPI transform_GetStreamIDs(IMFTransform *iface, DWORD input_si
 static HRESULT WINAPI transform_GetInputStreamInfo(IMFTransform *iface, DWORD id, MFT_INPUT_STREAM_INFO *info)
 {
     struct resampler *impl = impl_from_IMFTransform(iface);
-    UINT32 block_alignment;
-    HRESULT hr;

TRACE("iface %p, id %#lx, info %p.\n", iface, id, info);

if (!impl->input_type || !impl->output_type)
+    {
+        memset(info, 0, sizeof(*info));
         return MF_E_TRANSFORM_TYPE_NOT_SET;
+    }

-    if (FAILED(hr = IMFMediaType_GetUINT32(impl->input_type, &MF_MT_AUDIO_BLOCK_ALIGNMENT, &block_alignment)))
-        return hr;
-
-    info->dwFlags = 0;
-    info->cbSize = block_alignment;
-    info->cbAlignment = 1;
-    info->hnsMaxLatency = 0;
-    info->cbMaxLookahead = 0;
-
+    *info = impl->input_info;
     return S_OK;
 }

static HRESULT WINAPI transform_GetOutputStreamInfo(IMFTransform *iface, DWORD id, MFT_OUTPUT_STREAM_INFO *info)
 {
     struct resampler *impl = impl_from_IMFTransform(iface);
-    UINT32 block_alignment;
-    HRESULT hr;

TRACE("iface %p, id %#lx, info %p.\n", iface, id, info);

if (!impl->input_type || !impl->output_type)
+    {
+        memset(info, 0, sizeof(*info));
         return MF_E_TRANSFORM_TYPE_NOT_SET;
+    }

-    if (FAILED(hr = IMFMediaType_GetUINT32(impl->output_type, &MF_MT_AUDIO_BLOCK_ALIGNMENT, &block_alignment)))
-        return hr;
-
-    info->dwFlags = 0;
-    info->cbSize = block_alignment;
-    info->cbAlignment = 1;
-
+    *info = impl->output_info;
     return S_OK;
 }

@@ -367,9 +358,6 @@ static HRESULT check_media_type(IMFMediaType *type)
     if (FAILED(IMFMediaType_GetItemType(type, &MF_MT_AUDIO_SAMPLES_PER_SECOND, &item_type)) ||
         item_type != MF_ATTRIBUTE_UINT32)
         return MF_E_INVALIDMEDIATYPE;
-    if (FAILED(IMFMediaType_GetItemType(type, &MF_MT_AUDIO_BLOCK_ALIGNMENT, &item_type)) ||
-        item_type != MF_ATTRIBUTE_UINT32)
-        return MF_E_INVALIDMEDIATYPE;

return S_OK;
 }
@@ -377,12 +365,15 @@ static HRESULT check_media_type(IMFMediaType *type)
 static HRESULT WINAPI transform_SetInputType(IMFTransform *iface, DWORD id, IMFMediaType *type, DWORD flags)
 {
     struct resampler *impl = impl_from_IMFTransform(iface);
+    UINT32 block_alignment;
     HRESULT hr;

TRACE("iface %p, id %#lx, type %p, flags %#lx.\n", iface, id, type, flags);

if (FAILED(hr = check_media_type(type)))
         return hr;
+    if (FAILED(hr = IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_BLOCK_ALIGNMENT, &block_alignment)))
+        return MF_E_INVALIDMEDIATYPE;
     if (flags & MFT_SET_TYPE_TEST_ONLY)
         return S_OK;

@@ -395,9 +386,12 @@ static HRESULT WINAPI transform_SetInputType(IMFTransform *iface, DWORD id, IMFM
         impl->output_type = NULL;
     }

-    if (FAILED(hr = IMFMediaType_CopyAllItems(type, (IMFAttributes *)impl->input_type)))
+    if (SUCCEEDED(hr = IMFMediaType_CopyAllItems(type, (IMFAttributes *)impl->input_type)))
+        impl->input_info.cbSize = block_alignment;
+    else
     {
         IMFMediaType_Release(impl->input_type);
+        impl->input_info.cbSize = 0;
         impl->input_type = NULL;
     }

@@ -407,6 +401,7 @@ static HRESULT WINAPI transform_SetInputType(IMFTransform *iface, DWORD id, IMFM
 static HRESULT WINAPI transform_SetOutputType(IMFTransform *iface, DWORD id, IMFMediaType *type, DWORD flags)
 {
     struct resampler *impl = impl_from_IMFTransform(iface);
+    UINT32 block_alignment;
     HRESULT hr;

TRACE("iface %p, id %#lx, type %p, flags %#lx.\n", iface, id, type, flags);
@@ -416,6 +411,8 @@ static HRESULT WINAPI transform_SetOutputType(IMFTransform *iface, DWORD id, IMF

if (FAILED(hr = check_media_type(type)))
         return hr;
+    if (FAILED(hr = IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_BLOCK_ALIGNMENT, &block_alignment)))
+        return MF_E_INVALIDMEDIATYPE;
     if (flags & MFT_SET_TYPE_TEST_ONLY)
         return S_OK;

@@ -428,10 +425,12 @@ static HRESULT WINAPI transform_SetOutputType(IMFTransform *iface, DWORD id, IMF
     if (FAILED(hr = try_create_wg_transform(impl)))
         goto failed;

+    impl->output_info.cbSize = block_alignment;
     return hr;

failed:
     IMFMediaType_Release(impl->output_type);
+    impl->output_info.cbSize = 0;
     impl->output_type = NULL;
     return hr;
 }
@@ -940,6 +939,9 @@ HRESULT resampler_create(IUnknown *outer, IUnknown **out)
     impl->refcount = 1;
     impl->outer = outer ? outer : &impl->IUnknown_inner;

+    impl->input_info.cbAlignment = 1;
+    impl->output_info.cbAlignment = 1;
+
     *out = &impl->IUnknown_inner;
     TRACE("Created %p\n", *out);
     return S_OK;

[PATCH 08/12] winegstreamer: Keep input / output stream info in struct video_processor.

[Rémi Bernon]

From: Rémi Bernon

And calculate the sizes when media type is successfully changed.
---
 dlls/winegstreamer/video_processor.c | 47 +++++++++-------------------
 1 file changed, 15 insertions(+), 32 deletions(-)

diff --git a/dlls/winegstreamer/video_processor.c b/dlls/winegstreamer/video_processor.c
index a67ed8d6efd..a0f1c52f356 100644
--- a/dlls/winegstreamer/video_processor.c
+++ b/dlls/winegstreamer/video_processor.c
@@ -73,11 +73,14 @@ struct video_processor
     IMFTransform IMFTransform_iface;
     LONG refcount;

-    IMFMediaType *input_type;
-    IMFMediaType *output_type;
     IMFAttributes *attributes;
     IMFAttributes *output_attributes;

+    IMFMediaType *input_type;
+    MFT_INPUT_STREAM_INFO input_info;
+    IMFMediaType *output_type;
+    MFT_OUTPUT_STREAM_INFO output_info;
+
     struct wg_transform *wg_transform;
     struct wg_sample_queue *wg_sample_queue;
 };
@@ -192,54 +195,26 @@ static HRESULT WINAPI video_processor_GetStreamIDs(IMFTransform *iface, DWORD in
 static HRESULT WINAPI video_processor_GetInputStreamInfo(IMFTransform *iface, DWORD id, MFT_INPUT_STREAM_INFO *info)
 {
     struct video_processor *impl = impl_from_IMFTransform(iface);
-    UINT32 sample_size;
-    UINT64 framesize;
-    GUID subtype;
-    HRESULT hr;

TRACE("iface %p, id %#lx, info %p.\n", iface, id, info);

if (id)
         return MF_E_INVALIDSTREAMNUMBER;

-    if (impl->input_type && SUCCEEDED(hr = IMFMediaType_GetGUID(impl->input_type, &MF_MT_SUBTYPE, &subtype))
-            && SUCCEEDED(hr = IMFMediaType_GetUINT64(impl->input_type, &MF_MT_FRAME_SIZE, &framesize)))
-        MFCalculateImageSize(&subtype, framesize >> 32, (UINT32)framesize, &sample_size);
-    else
-        sample_size = 0;
-
-    info->dwFlags = 0;
-    info->cbSize = sample_size;
-    info->cbAlignment = 0;
-    info->hnsMaxLatency = 0;
-    info->cbMaxLookahead = 0;
-
+    *info = impl->input_info;
     return S_OK;
 }

static HRESULT WINAPI video_processor_GetOutputStreamInfo(IMFTransform *iface, DWORD id, MFT_OUTPUT_STREAM_INFO *info)
 {
     struct video_processor *impl = impl_from_IMFTransform(iface);
-    UINT32 sample_size;
-    UINT64 framesize;
-    GUID subtype;
-    HRESULT hr;

TRACE("iface %p, id %#lx, info %p.\n", iface, id, info);

if (id)
         return MF_E_INVALIDSTREAMNUMBER;

-    if (impl->output_type && SUCCEEDED(hr = IMFMediaType_GetGUID(impl->output_type, &MF_MT_SUBTYPE, &subtype))
-            && SUCCEEDED(hr = IMFMediaType_GetUINT64(impl->output_type, &MF_MT_FRAME_SIZE, &framesize)))
-        MFCalculateImageSize(&subtype, framesize >> 32, (UINT32)framesize, &sample_size);
-    else
-        sample_size = 0;
-
-    info->dwFlags = 0;
-    info->cbSize = sample_size;
-    info->cbAlignment = 0;
-
+    *info = impl->output_info;
     return S_OK;
 }

@@ -397,6 +372,10 @@ static HRESULT WINAPI video_processor_SetInputType(IMFTransform *iface, DWORD id
         impl->input_type = NULL;
     }

+    if (FAILED(hr) || FAILED(MFCalculateImageSize(&subtype, frame_size >> 32, (UINT32)frame_size,
+            (UINT32 *)&impl->input_info.cbSize)))
+        impl->input_info.cbSize = 0;
+
     return hr;
 }

@@ -436,6 +415,10 @@ static HRESULT WINAPI video_processor_SetOutputType(IMFTransform *iface, DWORD i
         impl->output_type = NULL;
     }

+    if (FAILED(hr) || FAILED(MFCalculateImageSize(&subtype, frame_size >> 32, (UINT32)frame_size,
+            (UINT32 *)&impl->output_info.cbSize)))
+        impl->output_info.cbSize = 0;
+
     return hr;
 }

[PATCH 09/12] winegstreamer: Keep input / output stream info in struct wma_decoder.

[Rémi Bernon]

From: Rémi Bernon

And calculate the sizes when media type is successfully changed.
---
 dlls/winegstreamer/wma_decoder.c | 54 +++++++++++++++-----------------
 1 file changed, 25 insertions(+), 29 deletions(-)

diff --git a/dlls/winegstreamer/wma_decoder.c b/dlls/winegstreamer/wma_decoder.c
index 99328103bad..a5271572b7c 100644
--- a/dlls/winegstreamer/wma_decoder.c
+++ b/dlls/winegstreamer/wma_decoder.c
@@ -52,8 +52,11 @@ struct wma_decoder
     IPropertyBag IPropertyBag_iface;
     IUnknown *outer;
     LONG refcount;
+
     IMFMediaType *input_type;
+    MFT_INPUT_STREAM_INFO input_info;
     IMFMediaType *output_type;
+    MFT_OUTPUT_STREAM_INFO output_info;

struct wg_transform *wg_transform;
     struct wg_sample_queue *wg_sample_queue;
@@ -201,46 +204,32 @@ static HRESULT WINAPI transform_GetStreamIDs(IMFTransform *iface, DWORD input_si
 static HRESULT WINAPI transform_GetInputStreamInfo(IMFTransform *iface, DWORD id, MFT_INPUT_STREAM_INFO *info)
 {
     struct wma_decoder *decoder = impl_from_IMFTransform(iface);
-    UINT32 block_alignment;
-    HRESULT hr;

TRACE("iface %p, id %lu, info %p.\n", iface, id, info);

if (!decoder->input_type || !decoder->output_type)
+    {
+        memset(info, 0, sizeof(*info));
         return MF_E_TRANSFORM_TYPE_NOT_SET;
+    }

-    if (FAILED(hr = IMFMediaType_GetUINT32(decoder->input_type, &MF_MT_AUDIO_BLOCK_ALIGNMENT, &block_alignment)))
-        return hr;
-
-    info->hnsMaxLatency = 0;
-    info->dwFlags = 0;
-    info->cbSize = block_alignment;
-    info->cbMaxLookahead = 0;
-    info->cbAlignment = 1;
-
+    *info = decoder->input_info;
     return S_OK;
 }

static HRESULT WINAPI transform_GetOutputStreamInfo(IMFTransform *iface, DWORD id, MFT_OUTPUT_STREAM_INFO *info)
 {
     struct wma_decoder *decoder = impl_from_IMFTransform(iface);
-    UINT32 channel_count, block_alignment;
-    HRESULT hr;

TRACE("iface %p, id %lu, info %p.\n", iface, id, info);

if (!decoder->input_type || !decoder->output_type)
+    {
+        memset(info, 0, sizeof(*info));
         return MF_E_TRANSFORM_TYPE_NOT_SET;
+    }

-    if (FAILED(hr = IMFMediaType_GetUINT32(decoder->output_type, &MF_MT_AUDIO_NUM_CHANNELS, &channel_count)))
-        return hr;
-    if (FAILED(hr = IMFMediaType_GetUINT32(decoder->output_type, &MF_MT_AUDIO_BLOCK_ALIGNMENT, &block_alignment)))
-        return hr;
-
-    info->dwFlags = 0;
-    info->cbSize = 1024 * block_alignment * channel_count;
-    info->cbAlignment = 1;
-
+    *info = decoder->output_info;
     return S_OK;
 }

@@ -358,6 +347,7 @@ static HRESULT WINAPI transform_SetInputType(IMFTransform *iface, DWORD id, IMFM
 {
     struct wma_decoder *decoder = impl_from_IMFTransform(iface);
     MF_ATTRIBUTE_TYPE item_type;
+    UINT32 block_alignment;
     GUID major, subtype;
     HRESULT hr;
     ULONG i;
@@ -380,8 +370,7 @@ static HRESULT WINAPI transform_SetInputType(IMFTransform *iface, DWORD id, IMFM
     if (FAILED(IMFMediaType_GetItemType(type, &MF_MT_USER_DATA, &item_type)) ||
         item_type != MF_ATTRIBUTE_BLOB)
         return MF_E_INVALIDMEDIATYPE;
-    if (FAILED(IMFMediaType_GetItemType(type, &MF_MT_AUDIO_BLOCK_ALIGNMENT, &item_type)) ||
-        item_type != MF_ATTRIBUTE_UINT32)
+    if (FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_BLOCK_ALIGNMENT, &block_alignment)))
         return MF_E_INVALIDMEDIATYPE;
     if (FAILED(IMFMediaType_GetItemType(type, &MF_MT_AUDIO_SAMPLES_PER_SECOND, &item_type)) ||
         item_type != MF_ATTRIBUTE_UINT32)
@@ -401,9 +390,12 @@ static HRESULT WINAPI transform_SetInputType(IMFTransform *iface, DWORD id, IMFM
         decoder->output_type = NULL;
     }

-    if (FAILED(hr = IMFMediaType_CopyAllItems(type, (IMFAttributes *)decoder->input_type)))
+    if (SUCCEEDED(hr = IMFMediaType_CopyAllItems(type, (IMFAttributes *)decoder->input_type)))
+        decoder->input_info.cbSize = block_alignment;
+    else
     {
         IMFMediaType_Release(decoder->input_type);
+        decoder->input_info.cbSize = 0;
         decoder->input_type = NULL;
     }

@@ -413,6 +405,7 @@ static HRESULT WINAPI transform_SetInputType(IMFTransform *iface, DWORD id, IMFM
 static HRESULT WINAPI transform_SetOutputType(IMFTransform *iface, DWORD id, IMFMediaType *type, DWORD flags)
 {
     struct wma_decoder *decoder = impl_from_IMFTransform(iface);
+    UINT32 channel_count, block_alignment;
     MF_ATTRIBUTE_TYPE item_type;
     ULONG i, sample_size;
     GUID major, subtype;
@@ -453,14 +446,12 @@ static HRESULT WINAPI transform_SetOutputType(IMFTransform *iface, DWORD id, IMF
     if (FAILED(IMFMediaType_GetItemType(type, &MF_MT_AUDIO_BITS_PER_SAMPLE, &item_type)) ||
         item_type != MF_ATTRIBUTE_UINT32)
         return MF_E_INVALIDMEDIATYPE;
-    if (FAILED(IMFMediaType_GetItemType(type, &MF_MT_AUDIO_NUM_CHANNELS, &item_type)) ||
-        item_type != MF_ATTRIBUTE_UINT32)
+    if (FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_NUM_CHANNELS, &channel_count)))
         return MF_E_INVALIDMEDIATYPE;
     if (FAILED(IMFMediaType_GetItemType(type, &MF_MT_AUDIO_SAMPLES_PER_SECOND, &item_type)) ||
         item_type != MF_ATTRIBUTE_UINT32)
         return MF_E_INVALIDMEDIATYPE;
-    if (FAILED(IMFMediaType_GetItemType(type, &MF_MT_AUDIO_BLOCK_ALIGNMENT, &item_type)) ||
-        item_type != MF_ATTRIBUTE_UINT32)
+    if (FAILED(IMFMediaType_GetUINT32(type, &MF_MT_AUDIO_BLOCK_ALIGNMENT, &block_alignment)))
         return MF_E_INVALIDMEDIATYPE;
     if (flags & MFT_SET_TYPE_TEST_ONLY)
         return S_OK;
@@ -477,10 +468,12 @@ static HRESULT WINAPI transform_SetOutputType(IMFTransform *iface, DWORD id, IMF
     if (FAILED(hr = try_create_wg_transform(decoder)))
         goto failed;

+    decoder->output_info.cbSize = 1024 * block_alignment * channel_count;
     return S_OK;

failed:
     IMFMediaType_Release(decoder->output_type);
+    decoder->output_info.cbSize = 0;
     decoder->output_type = NULL;
     return hr;
 }
@@ -901,6 +894,9 @@ HRESULT wma_decoder_create(IUnknown *outer, IUnknown **out)
     decoder->refcount = 1;
     decoder->outer = outer ? outer : &decoder->IUnknown_inner;

+    decoder->input_info.cbAlignment = 1;
+    decoder->output_info.cbAlignment = 1;
+
     *out = &decoder->IUnknown_inner;
     TRACE("Created decoder %p\n", *out);
     return S_OK;

[PATCH 10/12] winegstreamer: Keep input / output stream info in struct h264_decoder.

[Rémi Bernon]

From: Rémi Bernon

And calculate the sizes when media type is successfully changed.
---
 dlls/mf/tests/transform.c         |  5 -----
 dlls/winegstreamer/h264_decoder.c | 35 ++++++++++++++++++-------------
 2 files changed, 21 insertions(+), 19 deletions(-)

diff --git a/dlls/mf/tests/transform.c b/dlls/mf/tests/transform.c
index 8845df2eb12..21f7b44cdde 100644
--- a/dlls/mf/tests/transform.c
+++ b/dlls/mf/tests/transform.c
@@ -2818,15 +2818,12 @@ static void test_h264_decoder(void)
     hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
     todo_wine
     ok(hr == S_OK, "GetInputStreamInfo returned %#lx\n", hr);
-    todo_wine
     ok(input_info.hnsMaxLatency == 0, "got hnsMaxLatency %s\n", wine_dbgstr_longlong(input_info.hnsMaxLatency));
     todo_wine
     ok(input_info.dwFlags == flags, "got dwFlags %#lx\n", input_info.dwFlags);
     todo_wine
     ok(input_info.cbSize == 0x1000, "got cbSize %lu\n", input_info.cbSize);
-    todo_wine
     ok(input_info.cbMaxLookahead == 0, "got cbMaxLookahead %#lx\n", input_info.cbMaxLookahead);
-    todo_wine
     ok(input_info.cbAlignment == 0, "got cbAlignment %#lx\n", input_info.cbAlignment);

flags = MFT_OUTPUT_STREAM_WHOLE_SAMPLES | MFT_OUTPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER | MFT_OUTPUT_STREAM_FIXED_SAMPLE_SIZE;
@@ -2865,7 +2862,6 @@ static void test_h264_decoder(void)
     hr = IMFTransform_GetOutputStreamInfo(transform, 0, &output_info);
     ok(hr == S_OK, "GetOutputStreamInfo returned %#lx\n", hr);
     ok(output_info.dwFlags == flags, "got dwFlags %#lx\n", output_info.dwFlags);
-    todo_wine
     ok(output_info.cbSize == input_width * input_height * 2, "got cbSize %#lx\n", output_info.cbSize);
     ok(output_info.cbAlignment == 0, "got cbAlignment %#lx\n", output_info.cbAlignment);

@@ -2930,7 +2926,6 @@ static void test_h264_decoder(void)
     hr = IMFTransform_GetOutputStreamInfo(transform, 0, &output_info);
     ok(hr == S_OK, "GetOutputStreamInfo returned %#lx\n", hr);
     ok(output_info.dwFlags == flags, "got dwFlags %#lx\n", output_info.dwFlags);
-    todo_wine
     ok(output_info.cbSize == input_width * input_height * 2, "got cbSize %#lx\n", output_info.cbSize);
     ok(output_info.cbAlignment == 0, "got cbAlignment %#lx\n", output_info.cbAlignment);

diff --git a/dlls/winegstreamer/h264_decoder.c b/dlls/winegstreamer/h264_decoder.c
index 12031588365..aaed3213633 100644
--- a/dlls/winegstreamer/h264_decoder.c
+++ b/dlls/winegstreamer/h264_decoder.c
@@ -29,6 +29,8 @@
 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
 WINE_DECLARE_DEBUG_CHANNEL(winediag);

+#define ALIGN_SIZE(size, alignment) (((size) + (alignment)) & ~((alignment)))
+
 static const GUID *const h264_decoder_input_types[] =
 {
     &MFVideoFormat_H264,
@@ -50,8 +52,11 @@ struct h264_decoder

IMFAttributes *attributes;
     IMFAttributes *output_attributes;
+
     IMFMediaType *input_type;
+    MFT_INPUT_STREAM_INFO input_info;
     IMFMediaType *output_type;
+    MFT_OUTPUT_STREAM_INFO output_info;

struct wg_format wg_format;
     struct wg_transform *wg_transform;
@@ -284,31 +289,22 @@ static HRESULT WINAPI transform_GetInputStreamInfo(IMFTransform *iface, DWORD id
     TRACE("iface %p, id %#lx, info %p.\n", iface, id, info);

if (!decoder->input_type)
+    {
+        memset(info, 0, sizeof(*info));
         return MF_E_TRANSFORM_TYPE_NOT_SET;
+    }

-    info->hnsMaxLatency = 0;
-    info->dwFlags = MFT_INPUT_STREAM_WHOLE_SAMPLES | MFT_INPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER | MFT_INPUT_STREAM_FIXED_SAMPLE_SIZE;
-    info->cbSize = 0x1000;
-    info->cbMaxLookahead = 0;
-    info->cbAlignment = 0;
-
+    *info = decoder->input_info;
     return S_OK;
 }

static HRESULT WINAPI transform_GetOutputStreamInfo(IMFTransform *iface, DWORD id, MFT_OUTPUT_STREAM_INFO *info)
 {
     struct h264_decoder *decoder = impl_from_IMFTransform(iface);
-    UINT32 actual_width, actual_height;

TRACE("iface %p, id %#lx, info %p.\n", iface, id, info);

-    actual_width = (decoder->wg_format.u.video.width + 15) & ~15;
-    actual_height = (decoder->wg_format.u.video.height + 15) & ~15;
-
-    info->dwFlags = MFT_OUTPUT_STREAM_WHOLE_SAMPLES | MFT_OUTPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER | MFT_OUTPUT_STREAM_FIXED_SAMPLE_SIZE;
-    info->cbSize = actual_width * actual_height * 2;
-    info->cbAlignment = 0;
-
+    *info = decoder->output_info;
     return S_OK;
 }

@@ -460,6 +456,8 @@ static HRESULT WINAPI transform_SetInputType(IMFTransform *iface, DWORD id, IMFM
     {
         decoder->wg_format.u.video.width = frame_size >> 32;
         decoder->wg_format.u.video.height = (UINT32)frame_size;
+        decoder->output_info.cbSize = decoder->wg_format.u.video.width
+                * decoder->wg_format.u.video.height * 2;
     }

return S_OK;
@@ -643,6 +641,8 @@ static HRESULT WINAPI transform_ProcessOutput(IMFTransform *iface, DWORD flags,
     if (hr == MF_E_TRANSFORM_STREAM_CHANGE)
     {
         decoder->wg_format = wg_format;
+        decoder->output_info.cbSize = ALIGN_SIZE(decoder->wg_format.u.video.width, 0xf)
+                * ALIGN_SIZE(decoder->wg_format.u.video.height, 0xf) * 2;

/* keep the frame rate that was requested, GStreamer doesn't provide any */
         if (SUCCEEDED(IMFMediaType_GetUINT64(decoder->output_type, &MF_MT_FRAME_RATE, &frame_rate)))
@@ -725,6 +725,13 @@ HRESULT h264_decoder_create(REFIID riid, void **ret)
     decoder->wg_format.u.video.fps_n = 30000;
     decoder->wg_format.u.video.fps_d = 1001;

+    decoder->input_info.dwFlags = MFT_INPUT_STREAM_WHOLE_SAMPLES | MFT_INPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER
+            | MFT_INPUT_STREAM_FIXED_SAMPLE_SIZE;
+    decoder->input_info.cbSize = 0x1000;
+    decoder->output_info.dwFlags = MFT_OUTPUT_STREAM_WHOLE_SAMPLES | MFT_OUTPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER
+            | MFT_OUTPUT_STREAM_FIXED_SAMPLE_SIZE;
+    decoder->output_info.cbSize = 1920 * 1088 * 2;
+
     if (FAILED(hr = MFCreateAttributes(&decoder->attributes, 16)))
         goto failed;
     if (FAILED(hr = IMFAttributes_SetUINT32(decoder->attributes, &MF_LOW_LATENCY, 0)))

[PATCH 11/12] winegstreamer: Stop requiring input type in H264 decoder GetInputStreamInfo.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/mf/tests/transform.c         | 3 ---
 dlls/winegstreamer/h264_decoder.c | 6 ------
 2 files changed, 9 deletions(-)

diff --git a/dlls/mf/tests/transform.c b/dlls/mf/tests/transform.c
index 21f7b44cdde..488f8227fd4 100644
--- a/dlls/mf/tests/transform.c
+++ b/dlls/mf/tests/transform.c
@@ -2816,12 +2816,9 @@ static void test_h264_decoder(void)
     flags = MFT_INPUT_STREAM_WHOLE_SAMPLES | MFT_INPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER | MFT_INPUT_STREAM_FIXED_SAMPLE_SIZE;
     memset(&input_info, 0xcd, sizeof(input_info));
     hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
-    todo_wine
     ok(hr == S_OK, "GetInputStreamInfo returned %#lx\n", hr);
     ok(input_info.hnsMaxLatency == 0, "got hnsMaxLatency %s\n", wine_dbgstr_longlong(input_info.hnsMaxLatency));
-    todo_wine
     ok(input_info.dwFlags == flags, "got dwFlags %#lx\n", input_info.dwFlags);
-    todo_wine
     ok(input_info.cbSize == 0x1000, "got cbSize %lu\n", input_info.cbSize);
     ok(input_info.cbMaxLookahead == 0, "got cbMaxLookahead %#lx\n", input_info.cbMaxLookahead);
     ok(input_info.cbAlignment == 0, "got cbAlignment %#lx\n", input_info.cbAlignment);
diff --git a/dlls/winegstreamer/h264_decoder.c b/dlls/winegstreamer/h264_decoder.c
index aaed3213633..7e722de4c88 100644
--- a/dlls/winegstreamer/h264_decoder.c
+++ b/dlls/winegstreamer/h264_decoder.c
@@ -288,12 +288,6 @@ static HRESULT WINAPI transform_GetInputStreamInfo(IMFTransform *iface, DWORD id

TRACE("iface %p, id %#lx, info %p.\n", iface, id, info);

-    if (!decoder->input_type)
-    {
-        memset(info, 0, sizeof(*info));
-        return MF_E_TRANSFORM_TYPE_NOT_SET;
-    }
-
     *info = decoder->input_info;
     return S_OK;
 }

[PATCH 12/12] mf/tests: Factor IMFTransform_Get(Input|Output)StreamInfo checks together.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/mf/tests/transform.c | 538 ++++++++++++++++----------------------
 1 file changed, 226 insertions(+), 312 deletions(-)

diff --git a/dlls/mf/tests/transform.c b/dlls/mf/tests/transform.c
index 488f8227fd4..4c650b33297 100644
--- a/dlls/mf/tests/transform.c
+++ b/dlls/mf/tests/transform.c
@@ -84,6 +84,10 @@ static void check_interface_(unsigned int line, void *iface_ptr, REFIID iid, BOO
         IUnknown_Release(unk);
 }

+#define check_member_(file, line, val, exp, fmt, member)                                           \
+    ok_ (file, line)((val).member == (exp).member, "got " #member " " fmt "\n", (val).member)
+#define check_member(val, exp, fmt, member) check_member_(__FILE__, __LINE__, val, exp, fmt, member)
+
 void check_attributes_(int line, IMFAttributes *attributes, const struct attribute_desc *desc, ULONG limit)
 {
     char buffer[256], *buf = buffer;
@@ -368,6 +372,48 @@ static void check_mft_get_attributes(IMFTransform *transform, const struct attri
             "GetInputStreamAttributes returned %#lx\n", hr);
 }

+#define check_mft_input_stream_info(a, b) check_mft_input_stream_info_(__LINE__, a, b)
+static void check_mft_input_stream_info_(int line, MFT_INPUT_STREAM_INFO *value, const MFT_INPUT_STREAM_INFO *expect)
+{
+    check_member_(__FILE__, line, *value, *expect, "%I64d", hnsMaxLatency);
+    check_member_(__FILE__, line, *value, *expect, "%#lx", dwFlags);
+    check_member_(__FILE__, line, *value, *expect, "%#lx", cbSize);
+    check_member_(__FILE__, line, *value, *expect, "%#lx", cbMaxLookahead);
+    check_member_(__FILE__, line, *value, *expect, "%#lx", cbAlignment);
+}
+
+#define check_mft_get_input_stream_info(a, b) check_mft_get_input_stream_info_(__LINE__, a, b)
+static void check_mft_get_input_stream_info_(int line, IMFTransform *transform, const MFT_INPUT_STREAM_INFO *expect)
+{
+    MFT_INPUT_STREAM_INFO info, empty = {0};
+    HRESULT hr;
+
+    memset(&info, 0xcd, sizeof(info));
+    hr = IMFTransform_GetInputStreamInfo(transform, 0, &info);
+    ok_(__FILE__, line)(hr == (expect ? S_OK : MF_E_TRANSFORM_TYPE_NOT_SET), "GetInputStreamInfo returned %#lx\n", hr);
+    check_mft_input_stream_info_(line, &info, expect ? expect : &empty);
+}
+
+#define check_mft_output_stream_info(a, b) check_mft_output_stream_info_(__LINE__, a, b)
+static void check_mft_output_stream_info_(int line, MFT_OUTPUT_STREAM_INFO *value, const MFT_OUTPUT_STREAM_INFO *expect)
+{
+    check_member_(__FILE__, line, *value, *expect, "%#lx", dwFlags);
+    check_member_(__FILE__, line, *value, *expect, "%#lx", cbSize);
+    check_member_(__FILE__, line, *value, *expect, "%#lx", cbAlignment);
+}
+
+#define check_mft_get_output_stream_info(a, b) check_mft_get_output_stream_info_(__LINE__, a, b)
+static void check_mft_get_output_stream_info_(int line, IMFTransform *transform, const MFT_OUTPUT_STREAM_INFO *expect)
+{
+    MFT_OUTPUT_STREAM_INFO info, empty = {0};
+    HRESULT hr;
+
+    memset(&info, 0xcd, sizeof(info));
+    hr = IMFTransform_GetOutputStreamInfo(transform, 0, &info);
+    ok_(__FILE__, line)(hr == (expect ? S_OK : MF_E_TRANSFORM_TYPE_NOT_SET), "GetInputStreamInfo returned %#lx\n", hr);
+    check_mft_output_stream_info_(line, &info, expect ? expect : &empty);
+}
+
 #define check_mft_set_input_type_required(a, b) check_mft_set_input_type_required_(__LINE__, a, b)
 static void check_mft_set_input_type_required_(int line, IMFTransform *transform, const struct attribute_desc *attributes)
 {
@@ -1003,11 +1049,12 @@ static void test_sample_copier(void)
         ATTR_UINT32(MFT_SUPPORT_DYNAMIC_FORMAT_CHANGE, 1),
         {0},
     };
+    const MFT_OUTPUT_STREAM_INFO initial_output_info = {0}, output_info = {.cbSize = 16 * 16};
+    const MFT_INPUT_STREAM_INFO initial_input_info = {0}, input_info = {.cbSize = 16 * 16};
     IMFMediaType *mediatype, *mediatype2;
-    MFT_OUTPUT_STREAM_INFO output_info;
     IMFSample *sample, *client_sample;
-    MFT_INPUT_STREAM_INFO input_info;
     IMFMediaBuffer *media_buffer;
+    MFT_INPUT_STREAM_INFO info;
     DWORD flags, output_status;
     IMFTransform *copier;
     HRESULT hr;
@@ -1088,29 +1135,22 @@ static void test_sample_copier(void)
     hr = IMFMediaType_SetUINT64(mediatype, &MF_MT_FRAME_SIZE, ((UINT64)16) << 32 | 16);
     ok(hr == S_OK, "Failed to set attribute, hr %#lx.\n", hr);

-    hr = IMFTransform_GetOutputStreamInfo(copier, 0, &output_info);
-    ok(hr == S_OK, "Failed to get stream info, hr %#lx.\n", hr);
-    ok(!output_info.dwFlags, "Unexpected flags %#lx.\n", output_info.dwFlags);
-    ok(!output_info.cbSize, "Unexpected size %lu.\n", output_info.cbSize);
-    ok(!output_info.cbAlignment, "Unexpected alignment %lu.\n", output_info.cbAlignment);
-
-    hr = IMFTransform_GetInputStreamInfo(copier, 0, &input_info);
-    ok(hr == S_OK, "Failed to get stream info, hr %#lx.\n", hr);
-
-    ok(!input_info.hnsMaxLatency, "Unexpected latency %s.\n", wine_dbgstr_longlong(input_info.hnsMaxLatency));
-    ok(!input_info.dwFlags, "Unexpected flags %#lx.\n", input_info.dwFlags);
-    ok(!input_info.cbSize, "Unexpected size %lu.\n", input_info.cbSize);
-    ok(!input_info.cbMaxLookahead, "Unexpected lookahead size %lu.\n", input_info.cbMaxLookahead);
-    ok(!input_info.cbAlignment, "Unexpected alignment %lu.\n", input_info.cbAlignment);
+    check_mft_get_input_stream_info(copier, &initial_input_info);
+    check_mft_get_output_stream_info(copier, &initial_output_info);

hr = IMFTransform_SetOutputType(copier, 0, mediatype, 0);
     ok(hr == S_OK, "Failed to set input type, hr %#lx.\n", hr);

-    hr = IMFTransform_GetOutputStreamInfo(copier, 0, &output_info);
-    ok(hr == S_OK, "Failed to get stream info, hr %#lx.\n", hr);
-    ok(!output_info.dwFlags, "Unexpected flags %#lx.\n", output_info.dwFlags);
-    ok(output_info.cbSize == 16 * 16, "Unexpected size %lu.\n", output_info.cbSize);
-    ok(!output_info.cbAlignment, "Unexpected alignment %lu.\n", output_info.cbAlignment);
+    memset(&info, 0xcd, sizeof(info));
+    hr = IMFTransform_GetInputStreamInfo(copier, 0, &info);
+    ok(hr == S_OK, "GetInputStreamInfo returned %#lx\n", hr);
+    check_member(info, initial_input_info, "%I64d", hnsMaxLatency);
+    check_member(info, initial_input_info, "%#lx", dwFlags);
+    todo_wine
+    check_member(info, initial_input_info, "%#lx", cbSize);
+    check_member(info, initial_input_info, "%#lx", cbMaxLookahead);
+    check_member(info, initial_input_info, "%#lx", cbAlignment);
+    check_mft_get_output_stream_info(copier, &output_info);

hr = IMFTransform_GetOutputCurrentType(copier, 0, &mediatype2);
     ok(hr == S_OK, "Failed to get current type, hr %#lx.\n", hr);
@@ -1138,13 +1178,8 @@ static void test_sample_copier(void)
     ok(is_sample_copier_available_type(mediatype2), "Unexpected type.\n");
     IMFMediaType_Release(mediatype2);

-    hr = IMFTransform_GetInputStreamInfo(copier, 0, &input_info);
-    ok(hr == S_OK, "Failed to get stream info, hr %#lx.\n", hr);
-    ok(!input_info.hnsMaxLatency, "Unexpected latency %s.\n", wine_dbgstr_longlong(input_info.hnsMaxLatency));
-    ok(!input_info.dwFlags, "Unexpected flags %#lx.\n", input_info.dwFlags);
-    ok(input_info.cbSize == 16 * 16, "Unexpected size %lu.\n", input_info.cbSize);
-    ok(!input_info.cbMaxLookahead, "Unexpected lookahead size %lu.\n", input_info.cbMaxLookahead);
-    ok(!input_info.cbAlignment, "Unexpected alignment %lu.\n", input_info.cbAlignment);
+    check_mft_get_input_stream_info(copier, &input_info);
+    check_mft_get_output_stream_info(copier, &output_info);

hr = IMFTransform_GetOutputAvailableType(copier, 0, 0, &mediatype2);
     ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
@@ -1194,8 +1229,8 @@ static void test_sample_copier(void)
     hr = IMFTransform_ProcessInput(copier, 0, sample, 0);
     ok(hr == MF_E_NOTACCEPTING, "Unexpected hr %#lx.\n", hr);

-    hr = IMFTransform_GetOutputStreamInfo(copier, 0, &output_info);
-    ok(hr == S_OK, "Failed to get output info, hr %#lx.\n", hr);
+    check_mft_get_input_stream_info(copier, &input_info);
+    check_mft_get_output_stream_info(copier, &output_info);

hr = MFCreateAlignedMemoryBuffer(output_info.cbSize, output_info.cbAlignment, &media_buffer);
     ok(hr == S_OK, "Failed to create media buffer, hr %#lx.\n", hr);
@@ -1503,11 +1538,11 @@ static void test_aac_encoder(void)
         ATTR_BLOB(MF_MT_USER_DATA, aac_codec_data, sizeof(aac_codec_data)),
         {0},
     };
+    const MFT_OUTPUT_STREAM_INFO initial_output_info = {0}, output_info = {.cbSize = 0x600};
+    const MFT_INPUT_STREAM_INFO input_info = {0};

MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Audio, MFAudioFormat_AAC};
     MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Audio, MFAudioFormat_PCM};
-    MFT_OUTPUT_STREAM_INFO output_info;
-    MFT_INPUT_STREAM_INFO input_info;
     IMFMediaType *media_type;
     IMFTransform *transform;
     HRESULT hr;
@@ -1533,6 +1568,8 @@ static void test_aac_encoder(void)

check_mft_optional_methods(transform);
     check_mft_get_attributes(transform, NULL, FALSE);
+    check_mft_get_input_stream_info(transform, &input_info);
+    check_mft_get_output_stream_info(transform, &initial_output_info);

check_mft_set_input_type_required(transform, input_type_desc);

@@ -1566,21 +1603,8 @@ static void test_aac_encoder(void)
     ret = IMFMediaType_Release(media_type);
     ok(ret <= 1, "Release returned %lu\n", ret);

-    memset(&input_info, 0xcd, sizeof(input_info));
-    hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
-    ok(hr == S_OK, "GetInputStreamInfo returned %#lx\n", hr);
-    ok(input_info.hnsMaxLatency == 0, "got hnsMaxLatency %I64d\n", input_info.hnsMaxLatency);
-    ok(input_info.dwFlags == 0, "got dwFlags %#lx\n", input_info.dwFlags);
-    ok(input_info.cbSize == 0, "got cbSize %lu\n", input_info.cbSize);
-    ok(input_info.cbMaxLookahead == 0, "got cbMaxLookahead %#lx\n", input_info.cbMaxLookahead);
-    ok(input_info.cbAlignment == 0, "got cbAlignment %#lx\n", input_info.cbAlignment);
-
-    memset(&output_info, 0xcd, sizeof(output_info));
-    hr = IMFTransform_GetOutputStreamInfo(transform, 0, &output_info);
-    ok(hr == S_OK, "GetOutputStreamInfo returned %#lx\n", hr);
-    ok(output_info.dwFlags == 0, "got dwFlags %#lx\n", output_info.dwFlags);
-    ok(output_info.cbSize == 0x600, "got cbSize %#lx\n", output_info.cbSize);
-    ok(output_info.cbAlignment == 0, "got cbAlignment %#lx\n", output_info.cbAlignment);
+    check_mft_get_input_stream_info(transform, &input_info);
+    check_mft_get_output_stream_info(transform, &output_info);

ret = IMFTransform_Release(transform);
     ok(ret == 0, "Release returned %lu\n", ret);
@@ -1702,15 +1726,22 @@ static void test_aac_decoder(void)
         ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 44100, .required = TRUE),
         {0},
     };
+    const MFT_OUTPUT_STREAM_INFO output_info =
+    {
+        .dwFlags = MFT_INPUT_STREAM_WHOLE_SAMPLES,
+        .cbSize = 0xc000,
+    };
+    const MFT_INPUT_STREAM_INFO input_info =
+    {
+        .dwFlags = MFT_INPUT_STREAM_WHOLE_SAMPLES | MFT_INPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER |
+                MFT_INPUT_STREAM_FIXED_SAMPLE_SIZE | MFT_INPUT_STREAM_HOLDS_BUFFERS,
+    };

MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Audio, MFAudioFormat_Float};
     MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Audio, MFAudioFormat_AAC};
-    MFT_OUTPUT_STREAM_INFO output_info;
-    MFT_INPUT_STREAM_INFO input_info;
     IMFMediaType *media_type;
     IMFTransform *transform;
     ULONG i, ret;
-    DWORD flags;
     HRESULT hr;

hr = CoInitialize(NULL);
@@ -1733,26 +1764,8 @@ static void test_aac_decoder(void)

check_mft_optional_methods(transform);
     check_mft_get_attributes(transform, expect_transform_attributes, FALSE);
-
-    /* check default media types */
-
-    flags = MFT_INPUT_STREAM_WHOLE_SAMPLES | MFT_INPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER | MFT_INPUT_STREAM_FIXED_SAMPLE_SIZE | MFT_INPUT_STREAM_HOLDS_BUFFERS;
-    memset(&input_info, 0xcd, sizeof(input_info));
-    hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
-    ok(hr == S_OK, "GetInputStreamInfo returned %#lx\n", hr);
-    ok(input_info.hnsMaxLatency == 0, "got hnsMaxLatency %s\n", wine_dbgstr_longlong(input_info.hnsMaxLatency));
-    ok(input_info.dwFlags == flags, "got dwFlags %#lx\n", input_info.dwFlags);
-    ok(input_info.cbSize == 0, "got cbSize %lu\n", input_info.cbSize);
-    ok(input_info.cbMaxLookahead == 0, "got cbMaxLookahead %#lx\n", input_info.cbMaxLookahead);
-    ok(input_info.cbAlignment == 0, "got cbAlignment %#lx\n", input_info.cbAlignment);
-
-    flags = MFT_INPUT_STREAM_WHOLE_SAMPLES;
-    memset(&output_info, 0xcd, sizeof(output_info));
-    hr = IMFTransform_GetOutputStreamInfo(transform, 0, &output_info);
-    ok(hr == S_OK, "GetOutputStreamInfo returned %#lx\n", hr);
-    ok(output_info.dwFlags == flags, "got dwFlags %#lx\n", output_info.dwFlags);
-    ok(output_info.cbSize == 0xc000, "got cbSize %#lx\n", output_info.cbSize);
-    ok(output_info.cbAlignment == 0, "got cbAlignment %#lx\n", output_info.cbAlignment);
+    check_mft_get_input_stream_info(transform, &input_info);
+    check_mft_get_output_stream_info(transform, &output_info);

hr = IMFTransform_GetOutputAvailableType(transform, 0, 0, &media_type);
     ok(hr == MF_E_TRANSFORM_TYPE_NOT_SET, "GetOutputAvailableType returned %#lx\n", hr);
@@ -1824,23 +1837,8 @@ static void test_aac_decoder(void)
     ret = IMFMediaType_Release(media_type);
     ok(ret == 1, "Release returned %lu\n", ret);

-    flags = MFT_INPUT_STREAM_WHOLE_SAMPLES | MFT_INPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER | MFT_INPUT_STREAM_FIXED_SAMPLE_SIZE | MFT_INPUT_STREAM_HOLDS_BUFFERS;
-    memset(&input_info, 0xcd, sizeof(input_info));
-    hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
-    ok(hr == S_OK, "GetInputStreamInfo returned %#lx\n", hr);
-    ok(input_info.hnsMaxLatency == 0, "got hnsMaxLatency %s\n", wine_dbgstr_longlong(input_info.hnsMaxLatency));
-    ok(input_info.dwFlags == flags, "got dwFlags %#lx\n", input_info.dwFlags);
-    ok(input_info.cbSize == 0, "got cbSize %lu\n", input_info.cbSize);
-    ok(input_info.cbMaxLookahead == 0, "got cbMaxLookahead %#lx\n", input_info.cbMaxLookahead);
-    ok(input_info.cbAlignment == 0, "got cbAlignment %#lx\n", input_info.cbAlignment);
-
-    flags = MFT_INPUT_STREAM_WHOLE_SAMPLES;
-    memset(&output_info, 0xcd, sizeof(output_info));
-    hr = IMFTransform_GetOutputStreamInfo(transform, 0, &output_info);
-    ok(hr == S_OK, "GetOutputStreamInfo returned %#lx\n", hr);
-    ok(output_info.dwFlags == flags, "got dwFlags %#lx\n", output_info.dwFlags);
-    ok(output_info.cbSize == 0xc000, "got cbSize %#lx\n", output_info.cbSize);
-    ok(output_info.cbAlignment == 0, "got cbAlignment %#lx\n", output_info.cbAlignment);
+    check_mft_get_input_stream_info(transform, &input_info);
+    check_mft_get_output_stream_info(transform, &output_info);

ret = IMFTransform_Release(transform);
     ok(ret == 0, "Release returned %lu\n", ret);
@@ -1911,6 +1909,17 @@ static void test_wma_encoder(void)
         ATTR_BLOB(MF_MT_USER_DATA, wma_codec_data, sizeof(wma_codec_data), .required = TRUE),
         {0},
     };
+    const MFT_OUTPUT_STREAM_INFO output_info =
+    {
+        .cbSize = wmaenc_block_size,
+        .cbAlignment = 1,
+    };
+    const MFT_INPUT_STREAM_INFO input_info =
+    {
+        .hnsMaxLatency = 19969161,
+        .cbSize = 8,
+        .cbAlignment = 1,
+    };

const struct buffer_desc output_buffer_desc[] =
     {
@@ -1944,8 +1953,6 @@ static void test_wma_encoder(void)
     MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Audio, MFAudioFormat_WMAudioV8};
     MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Audio, MFAudioFormat_Float};
     IMFSample *input_sample, *output_sample;
-    MFT_OUTPUT_STREAM_INFO output_info;
-    MFT_INPUT_STREAM_INFO input_info;
     IMFCollection *output_samples;
     DWORD length, output_status;
     IMFMediaType *media_type;
@@ -1977,6 +1984,8 @@ static void test_wma_encoder(void)

check_mft_optional_methods(transform);
     check_mft_get_attributes(transform, NULL, FALSE);
+    check_mft_get_input_stream_info(transform, NULL);
+    check_mft_get_output_stream_info(transform, NULL);

check_mft_set_input_type_required(transform, input_type_desc);

@@ -1998,22 +2007,8 @@ static void test_wma_encoder(void)
     ret = IMFMediaType_Release(media_type);
     ok(ret == 0, "Release returned %lu\n", ret);

-    memset(&input_info, 0xcd, sizeof(input_info));
-    hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
-    ok(hr == S_OK, "GetInputStreamInfo returned %#lx\n", hr);
-    ok(input_info.hnsMaxLatency == 19969161, "got hnsMaxLatency %s\n",
-            wine_dbgstr_longlong(input_info.hnsMaxLatency));
-    ok(input_info.dwFlags == 0, "got dwFlags %#lx\n", input_info.dwFlags);
-    ok(input_info.cbSize == 8, "got cbSize %lu\n", input_info.cbSize);
-    ok(input_info.cbMaxLookahead == 0, "got cbMaxLookahead %#lx\n", input_info.cbMaxLookahead);
-    ok(input_info.cbAlignment == 1, "got cbAlignment %#lx\n", input_info.cbAlignment);
-
-    memset(&output_info, 0xcd, sizeof(output_info));
-    hr = IMFTransform_GetOutputStreamInfo(transform, 0, &output_info);
-    ok(hr == S_OK, "GetOutputStreamInfo returned %#lx\n", hr);
-    ok(output_info.dwFlags == 0, "got dwFlags %#lx\n", output_info.dwFlags);
-    ok(output_info.cbSize == wmaenc_block_size, "got cbSize %#lx\n", output_info.cbSize);
-    ok(output_info.cbAlignment == 1, "got cbAlignment %#lx\n", output_info.cbAlignment);
+    check_mft_get_input_stream_info(transform, &input_info);
+    check_mft_get_output_stream_info(transform, &output_info);

load_resource(L"audiodata.bin", &audio_data, &audio_data_len);
     ok(audio_data_len == 179928, "got length %lu\n", audio_data_len);
@@ -2187,6 +2182,16 @@ static void test_wma_decoder(void)
         ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 2 * (16 / 8) * 22050, .required = TRUE),
         {0},
     };
+    const MFT_INPUT_STREAM_INFO input_info =
+    {
+        .cbSize = wmaenc_block_size,
+        .cbAlignment = 1,
+    };
+    const MFT_OUTPUT_STREAM_INFO output_info =
+    {
+        .cbSize = wmadec_block_size,
+        .cbAlignment = 1,
+    };

const struct buffer_desc output_buffer_desc[] =
     {
@@ -2228,8 +2233,6 @@ static void test_wma_decoder(void)
     MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Audio, MFAudioFormat_Float};
     IUnknown *unknown, *tmp_unknown, outer = {&test_unk_vtbl};
     IMFSample *input_sample, *output_sample;
-    MFT_OUTPUT_STREAM_INFO output_info;
-    MFT_INPUT_STREAM_INFO input_info;
     IMFCollection *output_samples;
     DWORD length, output_status;
     IMediaObject *media_object;
@@ -2263,13 +2266,9 @@ static void test_wma_decoder(void)

check_mft_optional_methods(transform);
     check_mft_get_attributes(transform, NULL, FALSE);
+    check_mft_get_input_stream_info(transform, NULL);
+    check_mft_get_output_stream_info(transform, NULL);

-    /* check default media types */
-
-    hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
-    ok(hr == MF_E_TRANSFORM_TYPE_NOT_SET, "GetInputStreamInfo returned %#lx\n", hr);
-    hr = IMFTransform_GetOutputStreamInfo(transform, 0, &output_info);
-    ok(hr == MF_E_TRANSFORM_TYPE_NOT_SET, "GetOutputStreamInfo returned %#lx\n", hr);
     hr = IMFTransform_GetOutputAvailableType(transform, 0, 0, &media_type);
     ok(hr == MF_E_TRANSFORM_TYPE_NOT_SET, "GetOutputAvailableType returned %#lx\n", hr);

@@ -2310,10 +2309,8 @@ static void test_wma_decoder(void)
     ret = IMFMediaType_Release(media_type);
     ok(ret == 0, "Release returned %lu\n", ret);

-    hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
-    ok(hr == MF_E_TRANSFORM_TYPE_NOT_SET, "GetInputStreamInfo returned %#lx\n", hr);
-    hr = IMFTransform_GetOutputStreamInfo(transform, 0, &output_info);
-    ok(hr == MF_E_TRANSFORM_TYPE_NOT_SET, "GetOutputStreamInfo returned %#lx\n", hr);
+    check_mft_get_input_stream_info(transform, NULL);
+    check_mft_get_output_stream_info(transform, NULL);

/* check new output media types */

@@ -2340,21 +2337,8 @@ static void test_wma_decoder(void)
     ret = IMFMediaType_Release(media_type);
     ok(ret == 0, "Release returned %lu\n", ret);

-    memset(&input_info, 0xcd, sizeof(input_info));
-    hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
-    ok(hr == S_OK, "GetInputStreamInfo returned %#lx\n", hr);
-    ok(input_info.hnsMaxLatency == 0, "got hnsMaxLatency %s\n", wine_dbgstr_longlong(input_info.hnsMaxLatency));
-    ok(input_info.dwFlags == 0, "got dwFlags %#lx\n", input_info.dwFlags);
-    ok(input_info.cbSize == wmaenc_block_size, "got cbSize %lu\n", input_info.cbSize);
-    ok(input_info.cbMaxLookahead == 0, "got cbMaxLookahead %#lx\n", input_info.cbMaxLookahead);
-    ok(input_info.cbAlignment == 1, "got cbAlignment %#lx\n", input_info.cbAlignment);
-
-    memset(&output_info, 0xcd, sizeof(output_info));
-    hr = IMFTransform_GetOutputStreamInfo(transform, 0, &output_info);
-    ok(hr == S_OK, "GetOutputStreamInfo returned %#lx\n", hr);
-    ok(output_info.dwFlags == 0, "got dwFlags %#lx\n", output_info.dwFlags);
-    ok(output_info.cbSize == wmadec_block_size, "got cbSize %#lx\n", output_info.cbSize);
-    ok(output_info.cbAlignment == 1, "got cbAlignment %#lx\n", output_info.cbAlignment);
+    check_mft_get_input_stream_info(transform, &input_info);
+    check_mft_get_output_stream_info(transform, &output_info);

load_resource(L"wmaencdata.bin", &wmaenc_data, &wmaenc_data_len);
     ok(wmaenc_data_len % wmaenc_block_size == 0, "got length %lu\n", wmaenc_data_len);
@@ -2723,6 +2707,30 @@ static void test_h264_decoder(void)
             ATTR_BLOB(MF_MT_MINIMUM_DISPLAY_APERTURE, &actual_aperture, 16),
         },
     };
+    const MFT_OUTPUT_STREAM_INFO initial_output_info =
+    {
+        .dwFlags = MFT_OUTPUT_STREAM_WHOLE_SAMPLES | MFT_OUTPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER |
+                MFT_OUTPUT_STREAM_FIXED_SAMPLE_SIZE,
+        .cbSize = 1920 * 1088 * 2,
+    };
+    const MFT_OUTPUT_STREAM_INFO output_info =
+    {
+        .dwFlags = MFT_OUTPUT_STREAM_WHOLE_SAMPLES | MFT_OUTPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER |
+                MFT_OUTPUT_STREAM_FIXED_SAMPLE_SIZE,
+        .cbSize = input_width * input_height * 2,
+    };
+    const MFT_OUTPUT_STREAM_INFO actual_output_info =
+    {
+        .dwFlags = MFT_OUTPUT_STREAM_WHOLE_SAMPLES | MFT_OUTPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER |
+                MFT_OUTPUT_STREAM_FIXED_SAMPLE_SIZE,
+        .cbSize = actual_width * actual_height * 2,
+    };
+    const MFT_INPUT_STREAM_INFO input_info =
+    {
+        .dwFlags = MFT_INPUT_STREAM_WHOLE_SAMPLES | MFT_INPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER |
+                MFT_INPUT_STREAM_FIXED_SAMPLE_SIZE,
+        .cbSize = 0x1000,
+    };

const struct attribute_desc output_sample_attributes[] =
     {
@@ -2755,16 +2763,14 @@ static void test_h264_decoder(void)
     MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Video, MFVideoFormat_H264};
     MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Video, MFVideoFormat_NV12};
     IMFSample *input_sample, *output_sample;
-    MFT_OUTPUT_STREAM_INFO output_info;
-    MFT_INPUT_STREAM_INFO input_info;
-    IMFCollection *output_samples;
     const BYTE *h264_encoded_data;
+    IMFCollection *output_samples;
     ULONG h264_encoded_data_len;
     DWORD length, output_status;
     IMFAttributes *attributes;
-    ULONG i, ret, ref, flags;
     IMFMediaType *media_type;
     IMFTransform *transform;
+    ULONG i, ret, ref;
     HRESULT hr;

hr = CoInitialize(NULL);
@@ -2787,6 +2793,8 @@ static void test_h264_decoder(void)

check_mft_optional_methods(transform);
     check_mft_get_attributes(transform, expect_transform_attributes, TRUE);
+    check_mft_get_input_stream_info(transform, &input_info);
+    check_mft_get_output_stream_info(transform, &initial_output_info);

hr = IMFTransform_GetAttributes(transform, &attributes);
     ok(hr == S_OK, "GetAttributes returned %#lx\n", hr);
@@ -2813,24 +2821,6 @@ static void test_h264_decoder(void)

/* check available input types */

-    flags = MFT_INPUT_STREAM_WHOLE_SAMPLES | MFT_INPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER | MFT_INPUT_STREAM_FIXED_SAMPLE_SIZE;
-    memset(&input_info, 0xcd, sizeof(input_info));
-    hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
-    ok(hr == S_OK, "GetInputStreamInfo returned %#lx\n", hr);
-    ok(input_info.hnsMaxLatency == 0, "got hnsMaxLatency %s\n", wine_dbgstr_longlong(input_info.hnsMaxLatency));
-    ok(input_info.dwFlags == flags, "got dwFlags %#lx\n", input_info.dwFlags);
-    ok(input_info.cbSize == 0x1000, "got cbSize %lu\n", input_info.cbSize);
-    ok(input_info.cbMaxLookahead == 0, "got cbMaxLookahead %#lx\n", input_info.cbMaxLookahead);
-    ok(input_info.cbAlignment == 0, "got cbAlignment %#lx\n", input_info.cbAlignment);
-
-    flags = MFT_OUTPUT_STREAM_WHOLE_SAMPLES | MFT_OUTPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER | MFT_OUTPUT_STREAM_FIXED_SAMPLE_SIZE;
-    memset(&output_info, 0xcd, sizeof(output_info));
-    hr = IMFTransform_GetOutputStreamInfo(transform, 0, &output_info);
-    ok(hr == S_OK, "GetOutputStreamInfo returned %#lx\n", hr);
-    ok(output_info.dwFlags == flags, "got dwFlags %#lx\n", output_info.dwFlags);
-    ok(output_info.cbSize == 1920 * 1088 * 2, "got cbSize %#lx\n", output_info.cbSize);
-    ok(output_info.cbAlignment == 0, "got cbAlignment %#lx\n", output_info.cbAlignment);
-
     i = -1;
     while (SUCCEEDED(hr = IMFTransform_GetInputAvailableType(transform, 0, ++i, &media_type)))
     {
@@ -2854,13 +2844,8 @@ static void test_h264_decoder(void)
     ret = IMFMediaType_Release(media_type);
     ok(ret == 1, "Release returned %lu\n", ret);

-    flags = MFT_OUTPUT_STREAM_WHOLE_SAMPLES | MFT_OUTPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER | MFT_OUTPUT_STREAM_FIXED_SAMPLE_SIZE;
-    memset(&output_info, 0xcd, sizeof(output_info));
-    hr = IMFTransform_GetOutputStreamInfo(transform, 0, &output_info);
-    ok(hr == S_OK, "GetOutputStreamInfo returned %#lx\n", hr);
-    ok(output_info.dwFlags == flags, "got dwFlags %#lx\n", output_info.dwFlags);
-    ok(output_info.cbSize == input_width * input_height * 2, "got cbSize %#lx\n", output_info.cbSize);
-    ok(output_info.cbAlignment == 0, "got cbAlignment %#lx\n", output_info.cbAlignment);
+    check_mft_get_input_stream_info(transform, &input_info);
+    check_mft_get_output_stream_info(transform, &output_info);

/* output types can now be enumerated (though they are actually the same for all input types) */

@@ -2908,23 +2893,8 @@ static void test_h264_decoder(void)
     ok(hr == MF_E_NO_MORE_TYPES, "GetOutputAvailableType returned %#lx\n", hr);
     ok(i == 5, "%lu output media types\n", i);

-    flags = MFT_INPUT_STREAM_WHOLE_SAMPLES | MFT_INPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER | MFT_INPUT_STREAM_FIXED_SAMPLE_SIZE;
-    memset(&input_info, 0xcd, sizeof(input_info));
-    hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
-    ok(hr == S_OK, "GetInputStreamInfo returned %#lx\n", hr);
-    ok(input_info.hnsMaxLatency == 0, "got hnsMaxLatency %s\n", wine_dbgstr_longlong(input_info.hnsMaxLatency));
-    ok(input_info.dwFlags == flags, "got dwFlags %#lx\n", input_info.dwFlags);
-    ok(input_info.cbSize == 0x1000, "got cbSize %lu\n", input_info.cbSize);
-    ok(input_info.cbMaxLookahead == 0, "got cbMaxLookahead %#lx\n", input_info.cbMaxLookahead);
-    ok(input_info.cbAlignment == 0, "got cbAlignment %#lx\n", input_info.cbAlignment);
-
-    flags = MFT_OUTPUT_STREAM_WHOLE_SAMPLES | MFT_OUTPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER | MFT_OUTPUT_STREAM_FIXED_SAMPLE_SIZE;
-    memset(&output_info, 0xcd, sizeof(output_info));
-    hr = IMFTransform_GetOutputStreamInfo(transform, 0, &output_info);
-    ok(hr == S_OK, "GetOutputStreamInfo returned %#lx\n", hr);
-    ok(output_info.dwFlags == flags, "got dwFlags %#lx\n", output_info.dwFlags);
-    ok(output_info.cbSize == input_width * input_height * 2, "got cbSize %#lx\n", output_info.cbSize);
-    ok(output_info.cbAlignment == 0, "got cbAlignment %#lx\n", output_info.cbAlignment);
+    check_mft_get_input_stream_info(transform, &input_info);
+    check_mft_get_output_stream_info(transform, &output_info);

load_resource(L"h264data.bin", &h264_encoded_data, &h264_encoded_data_len);

@@ -2979,13 +2949,8 @@ static void test_h264_decoder(void)
     ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

-    flags = MFT_OUTPUT_STREAM_WHOLE_SAMPLES | MFT_OUTPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER | MFT_OUTPUT_STREAM_FIXED_SAMPLE_SIZE;
-    memset(&output_info, 0xcd, sizeof(output_info));
-    hr = IMFTransform_GetOutputStreamInfo(transform, 0, &output_info);
-    ok(hr == S_OK, "GetOutputStreamInfo returned %#lx\n", hr);
-    ok(output_info.dwFlags == flags, "got dwFlags %#lx\n", output_info.dwFlags);
-    ok(output_info.cbSize == actual_width * actual_height * 2, "got cbSize %#lx\n", output_info.cbSize);
-    ok(output_info.cbAlignment == 0, "got cbAlignment %#lx\n", output_info.cbAlignment);
+    check_mft_get_input_stream_info(transform, &input_info);
+    check_mft_get_output_stream_info(transform, &actual_output_info);

i = -1;
     while (SUCCEEDED(hr = IMFTransform_GetOutputAvailableType(transform, 0, ++i, &media_type)))
@@ -3211,6 +3176,16 @@ static void test_audio_convert(void)
         ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 2 * (16 / 8) * 44100, .required = TRUE),
         {0},
     };
+    const MFT_OUTPUT_STREAM_INFO output_info =
+    {
+        .cbSize = 4,
+        .cbAlignment = 1,
+    };
+    const MFT_INPUT_STREAM_INFO input_info =
+    {
+        .cbSize = 8,
+        .cbAlignment = 1,
+    };

static const ULONG audioconv_block_size = 0x4000;
     const struct buffer_desc output_buffer_desc[] =
@@ -3247,8 +3222,6 @@ static void test_audio_convert(void)
     MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Audio, MFAudioFormat_PCM};
     MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Audio, MFAudioFormat_Float};
     IMFSample *input_sample, *output_sample;
-    MFT_OUTPUT_STREAM_INFO output_info;
-    MFT_INPUT_STREAM_INFO input_info;
     IMFCollection *output_samples;
     DWORD length, output_status;
     IMFMediaType *media_type;
@@ -3280,13 +3253,8 @@ static void test_audio_convert(void)

check_mft_optional_methods(transform);
     check_mft_get_attributes(transform, NULL, FALSE);
-
-    /* check default media types */
-
-    hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
-    ok(hr == MF_E_TRANSFORM_TYPE_NOT_SET, "GetInputStreamInfo returned %#lx\n", hr);
-    hr = IMFTransform_GetOutputStreamInfo(transform, 0, &output_info);
-    ok(hr == MF_E_TRANSFORM_TYPE_NOT_SET, "GetOutputStreamInfo returned %#lx\n", hr);
+    check_mft_get_input_stream_info(transform, NULL);
+    check_mft_get_output_stream_info(transform, NULL);

i = -1;
     while (SUCCEEDED(hr = IMFTransform_GetOutputAvailableType(transform, 0, ++i, &media_type)))
@@ -3336,10 +3304,8 @@ static void test_audio_convert(void)
     ret = IMFMediaType_Release(media_type);
     ok(ret == 0, "Release returned %lu\n", ret);

-    hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
-    ok(hr == MF_E_TRANSFORM_TYPE_NOT_SET, "GetInputStreamInfo returned %#lx\n", hr);
-    hr = IMFTransform_GetOutputStreamInfo(transform, 0, &output_info);
-    ok(hr == MF_E_TRANSFORM_TYPE_NOT_SET, "GetOutputStreamInfo returned %#lx\n", hr);
+    check_mft_get_input_stream_info(transform, NULL);
+    check_mft_get_output_stream_info(transform, NULL);

/* check new output media types */

@@ -3366,21 +3332,8 @@ static void test_audio_convert(void)
     ret = IMFMediaType_Release(media_type);
     ok(ret == 0, "Release returned %lu\n", ret);

-    memset(&input_info, 0xcd, sizeof(input_info));
-    hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
-    ok(hr == S_OK, "GetInputStreamInfo returned %#lx\n", hr);
-    ok(input_info.hnsMaxLatency == 0, "got hnsMaxLatency %s\n", wine_dbgstr_longlong(input_info.hnsMaxLatency));
-    ok(input_info.dwFlags == 0, "got dwFlags %#lx\n", input_info.dwFlags);
-    ok(input_info.cbSize == 8, "got cbSize %lu\n", input_info.cbSize);
-    ok(input_info.cbMaxLookahead == 0, "got cbMaxLookahead %#lx\n", input_info.cbMaxLookahead);
-    ok(input_info.cbAlignment == 1, "got cbAlignment %#lx\n", input_info.cbAlignment);
-
-    memset(&output_info, 0xcd, sizeof(output_info));
-    hr = IMFTransform_GetOutputStreamInfo(transform, 0, &output_info);
-    ok(hr == S_OK, "GetOutputStreamInfo returned %#lx\n", hr);
-    ok(output_info.dwFlags == 0, "got dwFlags %#lx\n", output_info.dwFlags);
-    ok(output_info.cbSize == 4, "got cbSize %#lx\n", output_info.cbSize);
-    ok(output_info.cbAlignment == 1, "got cbAlignment %#lx\n", output_info.cbAlignment);
+    check_mft_get_input_stream_info(transform, &input_info);
+    check_mft_get_output_stream_info(transform, &output_info);

load_resource(L"audiodata.bin", &audio_data, &audio_data_len);
     ok(audio_data_len == 179928, "got length %lu\n", audio_data_len);
@@ -3608,6 +3561,16 @@ static void test_color_convert(void)
         ATTR_RATIO(MF_MT_FRAME_SIZE, actual_width, actual_height, .required = TRUE),
         {0},
     };
+    const MFT_OUTPUT_STREAM_INFO output_info =
+    {
+        .cbSize = actual_width * actual_height * 4,
+        .cbAlignment = 1,
+    };
+    const MFT_INPUT_STREAM_INFO input_info =
+    {
+        .cbSize = actual_width * actual_height * 3 / 2,
+        .cbAlignment = 1,
+    };

const struct buffer_desc output_buffer_desc =
     {
@@ -3629,8 +3592,6 @@ static void test_color_convert(void)
     MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Video, MFVideoFormat_NV12};
     MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Video, MFVideoFormat_I420};
     IMFSample *input_sample, *output_sample;
-    MFT_OUTPUT_STREAM_INFO output_info;
-    MFT_INPUT_STREAM_INFO input_info;
     IMFCollection *output_samples;
     DWORD length, output_status;
     const BYTE *nv12frame_data;
@@ -3665,13 +3626,8 @@ static void test_color_convert(void)

check_mft_optional_methods(transform);
     check_mft_get_attributes(transform, NULL, FALSE);
-
-    /* check default media types */
-
-    hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
-    ok(hr == MF_E_TRANSFORM_TYPE_NOT_SET, "GetInputStreamInfo returned %#lx\n", hr);
-    hr = IMFTransform_GetOutputStreamInfo(transform, 0, &output_info);
-    ok(hr == MF_E_TRANSFORM_TYPE_NOT_SET, "GetOutputStreamInfo returned %#lx\n", hr);
+    check_mft_get_input_stream_info(transform, NULL);
+    check_mft_get_output_stream_info(transform, NULL);

i = -1;
     while (SUCCEEDED(hr = IMFTransform_GetOutputAvailableType(transform, 0, ++i, &media_type)))
@@ -3729,21 +3685,8 @@ static void test_color_convert(void)
     ret = IMFMediaType_Release(media_type);
     ok(ret == 0, "Release returned %lu\n", ret);

-    memset(&input_info, 0xcd, sizeof(input_info));
-    hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
-    ok(hr == S_OK, "GetInputStreamInfo returned %#lx\n", hr);
-    ok(input_info.hnsMaxLatency == 0, "got hnsMaxLatency %s\n", wine_dbgstr_longlong(input_info.hnsMaxLatency));
-    ok(input_info.dwFlags == 0, "got dwFlags %#lx\n", input_info.dwFlags);
-    ok(input_info.cbSize == actual_width * actual_height * 3 / 2, "got cbSize %#lx\n", input_info.cbSize);
-    ok(input_info.cbMaxLookahead == 0, "got cbMaxLookahead %#lx\n", input_info.cbMaxLookahead);
-    ok(input_info.cbAlignment == 1, "got cbAlignment %#lx\n", input_info.cbAlignment);
-
-    memset(&output_info, 0xcd, sizeof(output_info));
-    hr = IMFTransform_GetOutputStreamInfo(transform, 0, &output_info);
-    ok(hr == S_OK, "GetOutputStreamInfo returned %#lx\n", hr);
-    ok(output_info.dwFlags == 0, "got dwFlags %#lx\n", output_info.dwFlags);
-    ok(output_info.cbSize == actual_width * actual_height * 4, "got cbSize %#lx\n", output_info.cbSize);
-    ok(output_info.cbAlignment == 1, "got cbAlignment %#lx\n", output_info.cbAlignment);
+    check_mft_get_input_stream_info(transform, &input_info);
+    check_mft_get_output_stream_info(transform, &output_info);

load_resource(L"nv12frame.bmp", &nv12frame_data, &nv12frame_data_len);
     /* skip BMP header and RGB data from the dump */
@@ -3966,6 +3909,10 @@ static void test_video_processor(void)
         ATTR_BLOB(MF_MT_MINIMUM_DISPLAY_APERTURE, &actual_aperture, 16),
         {0},
     };
+    const MFT_OUTPUT_STREAM_INFO initial_output_info = {0};
+    const MFT_INPUT_STREAM_INFO initial_input_info = {0};
+    MFT_OUTPUT_STREAM_INFO output_info = {0};
+    MFT_INPUT_STREAM_INFO input_info = {0};

const struct buffer_desc output_buffer_desc =
     {
@@ -3990,8 +3937,6 @@ static void test_video_processor(void)
     IMFSample *input_sample, *output_sample;
     IMFMediaType *media_type, *media_type2;
     const GUID *expect_available_inputs;
-    MFT_OUTPUT_STREAM_INFO output_info;
-    MFT_INPUT_STREAM_INFO input_info;
     IMFCollection *output_samples;
     const BYTE *nv12frame_data;
     ULONG nv12frame_data_len;
@@ -4044,8 +3989,8 @@ static void test_video_processor(void)
     hr = IMFTransform_GetOutputCurrentType(transform, 1, &media_type);
     ok(hr == MF_E_INVALIDSTREAMNUMBER, "Unexpected hr %#lx.\n", hr);

-    hr = IMFTransform_GetInputStreamInfo(transform, 1, &input_info);
-    ok(hr == MF_E_INVALIDSTREAMNUMBER, "Unexpected hr %#lx.\n", hr);
+    check_mft_get_input_stream_info(transform, &initial_input_info);
+    check_mft_get_output_stream_info(transform, &initial_output_info);

/* Configure stream types. */
     for (i = 0;;++i)
@@ -4111,11 +4056,18 @@ static void test_video_processor(void)
         ok(hr == S_OK, "Failed to get input status, hr %#lx.\n", hr);
         ok(flags == MFT_INPUT_STATUS_ACCEPT_DATA, "Unexpected input status %#lx.\n", flags);

-        hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
-        ok(hr == S_OK, "Failed to get stream info, hr %#lx.\n", hr);
-        ok(input_info.dwFlags == 0, "Unexpected flags %#lx.\n", input_info.dwFlags);
-        ok(input_info.cbMaxLookahead == 0, "Unexpected lookahead length %lu.\n", input_info.cbMaxLookahead);
-        ok(input_info.cbAlignment == 0, "Unexpected alignment %lu.\n", input_info.cbAlignment);
+        input_info.cbSize = 0;
+        if (!IsEqualGUID(&guid, &MFVideoFormat_P208) && !IsEqualGUID(&guid, &MEDIASUBTYPE_Y41T)
+                && !IsEqualGUID(&guid, &MEDIASUBTYPE_Y42T))
+        {
+            hr = MFCalculateImageSize(&guid, 16, 16, (UINT32 *)&input_info.cbSize);
+            todo_wine_if(IsEqualGUID(&guid, &MFVideoFormat_NV11) || IsEqualGUID(&guid, &MFVideoFormat_YVYU)
+                    || IsEqualGUID(&guid, &MFVideoFormat_Y216) || IsEqualGUID(&guid, &MFVideoFormat_v410)
+                    || IsEqualGUID(&guid, &MFVideoFormat_Y41P))
+            ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+        }
+        check_mft_get_input_stream_info(transform, &input_info);
+        check_mft_get_output_stream_info(transform, &initial_output_info);

IMFMediaType_Release(media_type);
     }
@@ -4142,12 +4094,12 @@ static void test_video_processor(void)
     hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
     ok(hr == S_OK, "Failed to set output type, hr %#lx.\n", hr);

-    memset(&output_info, 0, sizeof(output_info));
-    hr = IMFTransform_GetOutputStreamInfo(transform, 0, &output_info);
-    ok(hr == S_OK, "Failed to get stream info, hr %#lx.\n", hr);
-    ok(output_info.dwFlags == 0, "Unexpected flags %#lx.\n", output_info.dwFlags);
-    ok(output_info.cbSize > 0, "Unexpected size %lu.\n", output_info.cbSize);
-    ok(output_info.cbAlignment == 0, "Unexpected alignment %lu.\n", output_info.cbAlignment);
+    hr = MFCalculateImageSize(&MFVideoFormat_IYUV, 16, 16, (UINT32 *)&input_info.cbSize);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    hr = MFCalculateImageSize(&MFVideoFormat_RGB32, 16, 16, (UINT32 *)&output_info.cbSize);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    check_mft_get_input_stream_info(transform, &input_info);
+    check_mft_get_output_stream_info(transform, &output_info);

hr = MFCreateSample(&input_sample);
     ok(hr == S_OK, "Failed to create a sample, hr %#lx.\n", hr);
@@ -4219,22 +4171,8 @@ static void test_video_processor(void)

check_mft_optional_methods(transform);
     check_mft_get_attributes(transform, expect_transform_attributes, TRUE);
-
-    memset(&input_info, 0xcd, sizeof(input_info));
-    hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
-    ok(hr == S_OK, "GetInputStreamInfo returned %#lx\n", hr);
-    ok(input_info.hnsMaxLatency == 0, "got hnsMaxLatency %s\n", wine_dbgstr_longlong(input_info.hnsMaxLatency));
-    ok(input_info.dwFlags == 0, "got dwFlags %#lx\n", input_info.dwFlags);
-    ok(input_info.cbSize == 0, "got cbSize %#lx\n", input_info.cbSize);
-    ok(input_info.cbMaxLookahead == 0, "got cbMaxLookahead %#lx\n", input_info.cbMaxLookahead);
-    ok(input_info.cbAlignment == 0, "got cbAlignment %#lx\n", input_info.cbAlignment);
-
-    memset(&output_info, 0xcd, sizeof(output_info));
-    hr = IMFTransform_GetOutputStreamInfo(transform, 0, &output_info);
-    ok(hr == S_OK, "GetOutputStreamInfo returned %#lx\n", hr);
-    ok(output_info.dwFlags == 0, "got dwFlags %#lx\n", output_info.dwFlags);
-    ok(output_info.cbSize == 0, "got cbSize %#lx\n", output_info.cbSize);
-    ok(output_info.cbAlignment == 0, "got cbAlignment %#lx\n", output_info.cbAlignment);
+    check_mft_get_input_stream_info(transform, &initial_input_info);
+    check_mft_get_output_stream_info(transform, &initial_output_info);

hr = IMFTransform_GetOutputAvailableType(transform, 0, 0, &media_type);
     ok(hr == MF_E_NO_MORE_TYPES, "GetOutputAvailableType returned %#lx\n", hr);
@@ -4341,21 +4279,10 @@ static void test_video_processor(void)
     ret = IMFMediaType_Release(media_type);
     ok(ret == 1, "Release returned %lu\n", ret);

-    memset(&input_info, 0xcd, sizeof(input_info));
-    hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
-    ok(hr == S_OK, "GetInputStreamInfo returned %#lx\n", hr);
-    ok(input_info.hnsMaxLatency == 0, "got hnsMaxLatency %s\n", wine_dbgstr_longlong(input_info.hnsMaxLatency));
-    ok(input_info.dwFlags == 0, "got dwFlags %#lx\n", input_info.dwFlags);
-    ok(input_info.cbSize == actual_width * actual_height * 3 / 2, "got cbSize %#lx\n", input_info.cbSize);
-    ok(input_info.cbMaxLookahead == 0, "got cbMaxLookahead %#lx\n", input_info.cbMaxLookahead);
-    ok(input_info.cbAlignment == 0, "got cbAlignment %#lx\n", input_info.cbAlignment);
-
-    memset(&output_info, 0xcd, sizeof(output_info));
-    hr = IMFTransform_GetOutputStreamInfo(transform, 0, &output_info);
-    ok(hr == S_OK, "GetOutputStreamInfo returned %#lx\n", hr);
-    ok(output_info.dwFlags == 0, "got dwFlags %#lx\n", output_info.dwFlags);
-    ok(output_info.cbSize == actual_width * actual_height * 4, "got cbSize %#lx\n", output_info.cbSize);
-    ok(output_info.cbAlignment == 0, "got cbAlignment %#lx\n", output_info.cbAlignment);
+    input_info.cbSize = actual_width * actual_height * 3 / 2;
+    output_info.cbSize = actual_width * actual_height * 4;
+    check_mft_get_input_stream_info(transform, &input_info);
+    check_mft_get_output_stream_info(transform, &output_info);

load_resource(L"nv12frame.bmp", &nv12frame_data, &nv12frame_data_len);
     /* skip BMP header and RGB data from the dump */
@@ -4451,6 +4378,7 @@ static void test_mp3_decoder(void)
         },
     };

+    static const ULONG mp3dec_block_size = 0x1200;
     static const media_type_desc expect_available_inputs[] =
     {
         {
@@ -4542,8 +4470,16 @@ static void test_mp3_decoder(void)
         ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 2 * (16 / 8) * 22050, .required = TRUE),
         {0},
     };
+    const MFT_OUTPUT_STREAM_INFO output_info =
+    {
+        .cbSize = mp3dec_block_size,
+        .cbAlignment = 1,
+    };
+    const MFT_INPUT_STREAM_INFO input_info =
+    {
+        .cbAlignment = 1,
+    };

-    static const ULONG mp3dec_block_size = 0x1200;
     const struct buffer_desc output_buffer_desc[] =
     {
         {.length = 0x9c0, .compare = compare_pcm16},
@@ -4577,8 +4513,6 @@ static void test_mp3_decoder(void)
     MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Audio, MFAudioFormat_PCM};
     MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Audio, MFAudioFormat_MP3};
     IMFSample *input_sample, *output_sample;
-    MFT_OUTPUT_STREAM_INFO output_info;
-    MFT_INPUT_STREAM_INFO input_info;
     IMFCollection *output_samples;
     DWORD length, output_status;
     IMFMediaType *media_type;
@@ -4610,13 +4544,9 @@ static void test_mp3_decoder(void)

check_mft_optional_methods(transform);
     check_mft_get_attributes(transform, NULL, FALSE);
+    check_mft_get_input_stream_info(transform, NULL);
+    check_mft_get_output_stream_info(transform, NULL);

-    /* check default media types */
-
-    hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
-    ok(hr == MF_E_TRANSFORM_TYPE_NOT_SET, "GetInputStreamInfo returned %#lx\n", hr);
-    hr = IMFTransform_GetOutputStreamInfo(transform, 0, &output_info);
-    ok(hr == MF_E_TRANSFORM_TYPE_NOT_SET, "GetOutputStreamInfo returned %#lx\n", hr);
     hr = IMFTransform_GetOutputAvailableType(transform, 0, 0, &media_type);
     ok(hr == MF_E_TRANSFORM_TYPE_NOT_SET, "GetOutputAvailableType returned %#lx\n", hr);

@@ -4657,10 +4587,8 @@ static void test_mp3_decoder(void)
     ret = IMFMediaType_Release(media_type);
     ok(ret == 0, "Release returned %lu\n", ret);

-    hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
-    ok(hr == MF_E_TRANSFORM_TYPE_NOT_SET, "GetInputStreamInfo returned %#lx\n", hr);
-    hr = IMFTransform_GetOutputStreamInfo(transform, 0, &output_info);
-    ok(hr == MF_E_TRANSFORM_TYPE_NOT_SET, "GetOutputStreamInfo returned %#lx\n", hr);
+    check_mft_get_input_stream_info(transform, NULL);
+    check_mft_get_output_stream_info(transform, NULL);

/* check new output media types */

@@ -4687,22 +4615,8 @@ static void test_mp3_decoder(void)
     ret = IMFMediaType_Release(media_type);
     ok(ret == 0, "Release returned %lu\n", ret);

-    memset(&input_info, 0xcd, sizeof(input_info));
-    hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
-    ok(hr == S_OK, "GetInputStreamInfo returned %#lx\n", hr);
-    ok(input_info.hnsMaxLatency == 0, "got hnsMaxLatency %s\n", wine_dbgstr_longlong(input_info.hnsMaxLatency));
-    ok(input_info.dwFlags == 0, "got dwFlags %#lx\n", input_info.dwFlags);
-    ok(input_info.cbSize == 0, "got cbSize %lu\n", input_info.cbSize);
-    ok(input_info.cbMaxLookahead == 0, "got cbMaxLookahead %#lx\n", input_info.cbMaxLookahead);
-    ok(input_info.cbAlignment == 1, "got cbAlignment %#lx\n", input_info.cbAlignment);
-
-    memset(&output_info, 0xcd, sizeof(output_info));
-    hr = IMFTransform_GetOutputStreamInfo(transform, 0, &output_info);
-    ok(hr == S_OK, "GetOutputStreamInfo returned %#lx\n", hr);
-    ok(output_info.dwFlags == 0, "got dwFlags %#lx\n", output_info.dwFlags);
-    todo_wine
-    ok(output_info.cbSize == mp3dec_block_size, "got cbSize %#lx\n", output_info.cbSize);
-    ok(output_info.cbAlignment == 1, "got cbAlignment %#lx\n", output_info.cbAlignment);
+    check_mft_get_input_stream_info(transform, &input_info);
+    check_mft_get_output_stream_info(transform, &output_info);

load_resource(L"mp3encdata.bin", &mp3enc_data, &mp3enc_data_len);
     ok(mp3enc_data_len == 6295, "got length %lu\n", mp3enc_data_len);