[PATCH 0/11] MR791: mf: Test AAC encoder / decoder presence, begin factoring some transform tests.

[PATCH 01/11] mf/tests: Test AAC encoder MFT presence and media types.

[Rémi Bernon]

From: R��mi Bernon

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

diff --git a/dlls/mf/tests/mf.c b/dlls/mf/tests/mf.c
index 35ccde2f9cb..88b0e0c319a 100644
--- a/dlls/mf/tests/mf.c
+++ b/dlls/mf/tests/mf.c
@@ -7059,6 +7059,148 @@ static void check_sample_pcm16_(int line, IMFSample *sample, const BYTE *expect_
     ok_(__FILE__, line)(ret == 1, "Release returned %lu\n", ret);
 }

+static const BYTE aac_codec_data[14] = {0x00,0x00,0x29,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x12,0x08};
+
+static void test_aac_encoder(void)
+{
+    const GUID transform_inputs[] =
+    {
+        MFAudioFormat_PCM,
+    };
+    const GUID transform_outputs[] =
+    {
+        MFAudioFormat_AAC,
+    };
+
+    static const struct attribute_desc input_type_desc[] =
+    {
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio),
+        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_PCM),
+        ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 16),
+        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 1),
+        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 44100),
+        {0},
+    };
+    const struct attribute_desc output_type_desc[] =
+    {
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio),
+        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_AAC),
+        ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 16),
+        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 1),
+        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 44100),
+        ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 12000),
+        {0},
+    };
+
+    static const struct attribute_desc expect_input_type_desc[] =
+    {
+        ATTR_GUID(MF_MT_AM_FORMAT_TYPE, FORMAT_WaveFormatEx),
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio),
+        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_PCM),
+        ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 16),
+        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 1),
+        ATTR_UINT32(MF_MT_AUDIO_BLOCK_ALIGNMENT, 2),
+        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 44100),
+        ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 44100 * 2),
+        ATTR_UINT32(MF_MT_AVG_BITRATE, 44100 * 2 * 8),
+        ATTR_UINT32(MF_MT_COMPRESSED, 0),
+        ATTR_UINT32(MF_MT_FIXED_SIZE_SAMPLES, 1),
+        ATTR_UINT32(MF_MT_ALL_SAMPLES_INDEPENDENT, 1),
+        ATTR_UINT32(MF_MT_AUDIO_PREFER_WAVEFORMATEX, 1),
+        {0},
+    };
+    const struct attribute_desc expect_output_type_desc[] =
+    {
+        ATTR_GUID(MF_MT_AM_FORMAT_TYPE, FORMAT_WaveFormatEx),
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio),
+        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_AAC),
+        ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 16),
+        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 1),
+        ATTR_UINT32(MF_MT_AUDIO_BLOCK_ALIGNMENT, 1),
+        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 44100),
+        ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 12000),
+        ATTR_UINT32(MF_MT_AVG_BITRATE, 96000),
+        ATTR_UINT32(MF_MT_COMPRESSED, 1),
+        ATTR_UINT32(MF_MT_FIXED_SIZE_SAMPLES, 0),
+        ATTR_UINT32(MF_MT_AUDIO_PREFER_WAVEFORMATEX, 1),
+        ATTR_UINT32(MF_MT_AAC_AUDIO_PROFILE_LEVEL_INDICATION, 41),
+        ATTR_UINT32(MF_MT_AAC_PAYLOAD_TYPE, 0),
+        ATTR_BLOB(MF_MT_USER_DATA, aac_codec_data, sizeof(aac_codec_data)),
+        {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;
+    GUID class_id;
+    HRESULT hr;
+    ULONG ret;
+
+    hr = CoInitialize(NULL);
+    ok(hr == S_OK, "Failed to initialize, hr %#lx.\n", hr);
+
+    if (!create_transform(MFT_CATEGORY_AUDIO_ENCODER, &input_type, &output_type, L"Microsoft AAC Audio Encoder MFT", &MFMediaType_Audio,
+            transform_inputs, ARRAY_SIZE(transform_inputs), transform_outputs, ARRAY_SIZE(transform_outputs),
+            &transform, &CLSID_AACMFTEncoder, &class_id))
+        goto failed;
+
+    check_interface(transform, &IID_IMFTransform, TRUE);
+    check_interface(transform, &IID_IMediaObject, FALSE);
+
+    hr = MFCreateMediaType(&media_type);
+    ok(hr == S_OK, "MFCreateMediaType returned %#lx\n", hr);
+    init_media_type(media_type, input_type_desc, -1);
+    hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
+    ok(hr == S_OK, "SetInputType returned %#lx.\n", hr);
+    ret = IMFMediaType_Release(media_type);
+    ok(ret == 1, "Release returned %lu\n", ret);
+
+    hr = MFCreateMediaType(&media_type);
+    ok(hr == S_OK, "MFCreateMediaType returned %#lx\n", hr);
+    init_media_type(media_type, output_type_desc, -1);
+    hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
+    ok(hr == S_OK, "SetOutputType returned %#lx.\n", hr);
+    ret = IMFMediaType_Release(media_type);
+    ok(ret == 1, "Release returned %lu\n", ret);
+
+    hr = IMFTransform_GetInputCurrentType(transform, 0, &media_type);
+    ok(hr == S_OK, "GetInputCurrentType returned %#lx.\n", hr);
+    check_media_type(media_type, expect_input_type_desc, -1);
+    ret = IMFMediaType_Release(media_type);
+    ok(ret <= 1, "Release returned %lu\n", ret);
+
+    hr = IMFTransform_GetOutputCurrentType(transform, 0, &media_type);
+    ok(hr == S_OK, "GetOutputCurrentType returned %#lx.\n", hr);
+    check_media_type(media_type, expect_output_type_desc, -1);
+    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);
+
+    ret = IMFTransform_Release(transform);
+    ok(ret == 0, "Release returned %lu\n", ret);
+
+failed:
+    CoUninitialize();
+}
+
 static const BYTE wma_codec_data[10] = {0, 0x44, 0, 0, 0x17, 0, 0, 0, 0, 0};
 static const ULONG wmaenc_block_size = 1487;
 static const ULONG wmadec_block_size = 0x2000;
@@ -10514,6 +10656,7 @@ START_TEST(mf)
     test_sample_copier_output_processing();
     test_MFGetTopoNodeCurrentType();
     test_MFRequireProtectedEnvironment();
+    test_aac_encoder();
     test_wma_encoder();
     test_wma_decoder();
     test_h264_decoder();

[PATCH 02/11] mf/tests: Test AAC decoder MFT presence and media types.

[Rémi Bernon]

From: R��mi Bernon

---
 dlls/mf/tests/mf.c | 264 ++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 263 insertions(+), 1 deletion(-)

diff --git a/dlls/mf/tests/mf.c b/dlls/mf/tests/mf.c
index 88b0e0c319a..b6be9428682 100644
--- a/dlls/mf/tests/mf.c
+++ b/dlls/mf/tests/mf.c
@@ -26,9 +26,11 @@

#include "windef.h"
 #include "winbase.h"
+#include "wingdi.h"
 #include "d3d9types.h"

#include "initguid.h"
+#include "mmreg.h"
 #include "control.h"
 #include "dmo.h"
 #include "mediaobj.h"
@@ -48,6 +50,8 @@ DEFINE_GUID(DMOVideoFormat_RGB565, D3DFMT_R5G6B5, 0x524f, 0x11ce, 0x9f, 0x53, 0x
 DEFINE_GUID(DMOVideoFormat_RGB555, D3DFMT_X1R5G5B5, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70);
 DEFINE_GUID(DMOVideoFormat_RGB8, D3DFMT_P8, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70);

+DEFINE_GUID(MFAudioFormat_RAW_AAC1, WAVE_FORMAT_RAW_AAC1, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
+
 #undef INITGUID
 #include <guiddef.h>
 #include "mfapi.h"
@@ -268,7 +272,9 @@ static BOOL create_transform(GUID category, MFT_REGISTER_TYPE_INFO *input_type,
     {
         ok(hr == S_OK, "MFTEnum returned %lx\n", hr);
         ok(!wcscmp(name, expect_name), "got name %s\n", debugstr_w(name));
-        ok(input_count == expect_input_count, "got input_count %u\n", input_count);
+        ok(input_count == expect_input_count
+                || broken(IsEqualGUID(class_id, &CLSID_MSAACDecMFT) && input_count == expect_input_count - 1), /* w8 */
+                "got input_count %u\n", input_count);
         for (i = 0; i < input_count; ++i)
         {
             ok(IsEqualGUID(&input_types[i].guidMajorType, expect_major_type),
@@ -7201,6 +7207,261 @@ failed:
     CoUninitialize();
 }

+static void test_aac_decoder(void)
+{
+    const GUID transform_inputs[] =
+    {
+        MFAudioFormat_AAC,
+        MFAudioFormat_RAW_AAC1,
+        MFAudioFormat_ADTS,
+    };
+    const GUID transform_outputs[] =
+    {
+        MFAudioFormat_Float,
+        MFAudioFormat_PCM,
+    };
+
+    static const struct attribute_desc expect_input_attributes[] =
+    {
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio),
+        ATTR_UINT32(MF_MT_AUDIO_PREFER_WAVEFORMATEX, 1),
+        ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 32),
+        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 6),
+        ATTR_UINT32(MF_MT_AUDIO_BLOCK_ALIGNMENT, 24),
+        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 48000),
+        ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 1152000),
+        {0},
+    };
+    static const media_type_desc expect_available_inputs[] =
+    {
+        {
+            ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_AAC),
+            ATTR_UINT32(MF_MT_AAC_AUDIO_PROFILE_LEVEL_INDICATION, 0),
+            ATTR_UINT32(MF_MT_AAC_PAYLOAD_TYPE, 0),
+            /* MF_MT_USER_DATA with some AAC codec data */
+        },
+        {
+            ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_RAW_AAC1),
+        },
+        {
+            ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_AAC),
+            ATTR_UINT32(MF_MT_AAC_AUDIO_PROFILE_LEVEL_INDICATION, 0),
+            ATTR_UINT32(MF_MT_AAC_PAYLOAD_TYPE, 1),
+            /* MF_MT_USER_DATA with some AAC codec data */
+        },
+        {
+            ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_AAC),
+            ATTR_UINT32(MF_MT_AAC_AUDIO_PROFILE_LEVEL_INDICATION, 0),
+            ATTR_UINT32(MF_MT_AAC_PAYLOAD_TYPE, 3),
+            /* MF_MT_USER_DATA with some AAC codec data */
+        },
+        {
+            ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_ADTS),
+        },
+    };
+    static const struct attribute_desc expect_output_attributes[] =
+    {
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio),
+        ATTR_UINT32(MF_MT_AUDIO_PREFER_WAVEFORMATEX, 1),
+        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 1),
+        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 44100),
+        ATTR_UINT32(MF_MT_ALL_SAMPLES_INDEPENDENT, 1),
+        {0},
+    };
+    static const media_type_desc expect_available_outputs[] =
+    {
+        {
+            ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio),
+            ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_Float),
+            ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 32),
+            ATTR_UINT32(MF_MT_AUDIO_BLOCK_ALIGNMENT, 4),
+            ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 4 * 44100),
+        },
+        {
+            ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio),
+            ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_PCM),
+            ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 16),
+            ATTR_UINT32(MF_MT_AUDIO_BLOCK_ALIGNMENT, 2),
+            ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 2 * 44100),
+        },
+    };
+
+    const struct attribute_desc input_type_desc[] =
+    {
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio),
+        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_AAC),
+        ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 16),
+        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 1),
+        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 44100),
+        ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 12000),
+        ATTR_UINT32(MF_MT_AAC_AUDIO_PROFILE_LEVEL_INDICATION, 41),
+        ATTR_UINT32(MF_MT_AAC_PAYLOAD_TYPE, 0),
+        ATTR_BLOB(MF_MT_USER_DATA, aac_codec_data, sizeof(aac_codec_data)),
+        {0},
+    };
+    static const struct attribute_desc output_type_desc[] =
+    {
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio),
+        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_PCM),
+        ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 16),
+        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 1),
+        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 44100),
+        {0},
+    };
+
+    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;
+    GUID class_id;
+    ULONG i, ret;
+    DWORD flags;
+    HRESULT hr;
+
+    hr = CoInitialize(NULL);
+    ok(hr == S_OK, "Failed to initialize, hr %#lx.\n", hr);
+
+    if (!create_transform(MFT_CATEGORY_AUDIO_DECODER, &input_type, &output_type, L"Microsoft AAC Audio Decoder MFT", &MFMediaType_Audio,
+            transform_inputs, ARRAY_SIZE(transform_inputs), transform_outputs, ARRAY_SIZE(transform_outputs),
+            &transform, &CLSID_MSAACDecMFT, &class_id))
+        goto failed;
+
+    check_interface(transform, &IID_IMFTransform, TRUE);
+    check_interface(transform, &IID_IMediaObject, 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);
+
+    hr = IMFTransform_GetOutputAvailableType(transform, 0, 0, &media_type);
+    ok(hr == MF_E_TRANSFORM_TYPE_NOT_SET, "GetOutputAvailableType returned %#lx\n", hr);
+
+    i = -1;
+    while (SUCCEEDED(hr = IMFTransform_GetInputAvailableType(transform, 0, ++i, &media_type)))
+    {
+        winetest_push_context("in %lu", i);
+        ok(hr == S_OK, "GetInputAvailableType returned %#lx\n", hr);
+        check_media_type(media_type, expect_input_attributes, -1);
+        check_media_type(media_type, expect_available_inputs[i], -1);
+        hr = IMFTransform_SetInputType(transform, 0, media_type, MFT_SET_TYPE_TEST_ONLY);
+        if (i != 1) ok(hr == S_OK, "SetInputType returned %#lx.\n", hr);
+        else ok(hr == MF_E_INVALIDMEDIATYPE, "SetInputType returned %#lx.\n", hr);
+        ret = IMFMediaType_Release(media_type);
+        ok(ret <= 1, "Release returned %lu\n", ret);
+        winetest_pop_context();
+    }
+    ok(hr == MF_E_NO_MORE_TYPES, "GetInputAvailableType returned %#lx\n", hr);
+    ok(i == ARRAY_SIZE(expect_available_inputs)
+            || broken(i == 2) /* w7 */ || broken(i == 4) /* w8 */,
+            "%lu input media types\n", i);
+
+    /* setting output media type first doesn't work */
+
+    hr = MFCreateMediaType(&media_type);
+    ok(hr == S_OK, "MFCreateMediaType returned %#lx\n", hr);
+    init_media_type(media_type, output_type_desc, -1);
+    hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
+    ok(hr == MF_E_TRANSFORM_TYPE_NOT_SET, "SetOutputType returned %#lx.\n", hr);
+    ret = IMFMediaType_Release(media_type);
+    ok(ret == 0, "Release returned %lu\n", ret);
+
+    /* check required input media type attributes */
+
+    hr = MFCreateMediaType(&media_type);
+    ok(hr == S_OK, "MFCreateMediaType returned %#lx\n", hr);
+    hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
+    ok(hr == E_INVALIDARG, "SetInputType returned %#lx.\n", hr);
+    init_media_type(media_type, input_type_desc, 1);
+    for (i = 1; i < ARRAY_SIZE(input_type_desc) - 1; ++i)
+    {
+        hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
+        ok(hr == MF_E_INVALIDMEDIATYPE, "SetInputType returned %#lx.\n", hr);
+        init_media_type(media_type, input_type_desc, i + 1);
+    }
+    hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
+    ok(hr == S_OK, "SetInputType returned %#lx.\n", hr);
+    ret = IMFMediaType_Release(media_type);
+    ok(ret == 1, "Release returned %lu\n", ret);
+
+    /* check new output media types */
+
+    i = -1;
+    while (SUCCEEDED(hr = IMFTransform_GetOutputAvailableType(transform, 0, ++i, &media_type)))
+    {
+        winetest_push_context("out %lu", i);
+        ok(hr == S_OK, "GetOutputAvailableType returned %#lx\n", hr);
+        check_media_type(media_type, expect_output_attributes, -1);
+        check_media_type(media_type, expect_available_outputs[i], -1);
+        hr = IMFTransform_SetOutputType(transform, 0, media_type, MFT_SET_TYPE_TEST_ONLY);
+        ok(hr == S_OK, "SetInputType returned %#lx.\n", hr);
+        ret = IMFMediaType_Release(media_type);
+        ok(ret <= 1, "Release returned %lu\n", ret);
+        winetest_pop_context();
+    }
+    ok(hr == MF_E_NO_MORE_TYPES, "GetOutputAvailableType returned %#lx\n", hr);
+    ok(i == ARRAY_SIZE(expect_available_outputs), "%lu input media types\n", i);
+
+    /* check required output media type attributes */
+
+    hr = MFCreateMediaType(&media_type);
+    ok(hr == S_OK, "MFCreateMediaType returned %#lx\n", hr);
+    hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
+    ok(hr == E_INVALIDARG, "SetOutputType returned %#lx.\n", hr);
+    init_media_type(media_type, output_type_desc, 1);
+    for (i = 1; i < ARRAY_SIZE(output_type_desc) - 1; ++i)
+    {
+        hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
+        ok(hr == MF_E_INVALIDMEDIATYPE, "SetOutputType returned %#lx.\n", hr);
+        init_media_type(media_type, output_type_desc, i + 1);
+    }
+    hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
+    ok(hr == S_OK, "SetOutputType returned %#lx.\n", hr);
+    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);
+
+    ret = IMFTransform_Release(transform);
+    ok(ret == 0, "Release returned %lu\n", ret);
+
+failed:
+    CoUninitialize();
+}
+
 static const BYTE wma_codec_data[10] = {0, 0x44, 0, 0, 0x17, 0, 0, 0, 0, 0};
 static const ULONG wmaenc_block_size = 1487;
 static const ULONG wmadec_block_size = 0x2000;
@@ -10657,6 +10918,7 @@ START_TEST(mf)
     test_MFGetTopoNodeCurrentType();
     test_MFRequireProtectedEnvironment();
     test_aac_encoder();
+    test_aac_decoder();
     test_wma_encoder();
     test_wma_decoder();
     test_h264_decoder();

[PATCH 03/11] mf/tests: Remove unused CLSID_WINEAudioConverter declaration.

[Rémi Bernon]

From: R��mi Bernon

---
 dlls/mf/tests/mf.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/dlls/mf/tests/mf.c b/dlls/mf/tests/mf.c
index b6be9428682..c95e6a0882c 100644
--- a/dlls/mf/tests/mf.c
+++ b/dlls/mf/tests/mf.c
@@ -42,7 +42,6 @@
 DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0);
 DEFINE_GUID(MFVideoFormat_P208, 0x38303250, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
 DEFINE_GUID(MFVideoFormat_ABGR32, 0x00000020, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
-DEFINE_GUID(CLSID_WINEAudioConverter, 0x6a170414, 0xaad9, 0x4693, 0xb8, 0x06, 0x3a, 0x0c, 0x47, 0xc5, 0x70, 0xd6);

DEFINE_GUID(DMOVideoFormat_RGB32, D3DFMT_X8R8G8B8, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70);
 DEFINE_GUID(DMOVideoFormat_RGB24, D3DFMT_R8G8B8, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70);

[PATCH 04/11] mf/tests: Add some winetest context to MFT tests.

[Rémi Bernon]

From: R��mi Bernon

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

diff --git a/dlls/mf/tests/mf.c b/dlls/mf/tests/mf.c
index c95e6a0882c..aac4ba8c52e 100644
--- a/dlls/mf/tests/mf.c
+++ b/dlls/mf/tests/mf.c
@@ -6227,6 +6227,8 @@ static void test_sample_copier(void)
         return;
     }

+    winetest_push_context("copier");
+
     hr = pMFCreateSampleCopierMFT(&copier);
     ok(hr == S_OK, "Failed to create sample copier, hr %#lx.\n", hr);

@@ -6478,6 +6480,8 @@ static void test_sample_copier(void)
     ok(ref == 0, "Release returned %ld\n", ref);
     ref = IMFMediaType_Release(mediatype);
     ok(ref == 0, "Release returned %ld\n", ref);
+
+    winetest_pop_context();
 }

struct sample_metadata
@@ -7147,6 +7151,8 @@ static void test_aac_encoder(void)
     hr = CoInitialize(NULL);
     ok(hr == S_OK, "Failed to initialize, hr %#lx.\n", hr);

+    winetest_push_context("aacenc");
+
     if (!create_transform(MFT_CATEGORY_AUDIO_ENCODER, &input_type, &output_type, L"Microsoft AAC Audio Encoder MFT", &MFMediaType_Audio,
             transform_inputs, ARRAY_SIZE(transform_inputs), transform_outputs, ARRAY_SIZE(transform_outputs),
             &transform, &CLSID_AACMFTEncoder, &class_id))
@@ -7203,6 +7209,7 @@ static void test_aac_encoder(void)
     ok(ret == 0, "Release returned %lu\n", ret);

failed:
+    winetest_pop_context();
     CoUninitialize();
 }

@@ -7322,6 +7329,8 @@ static void test_aac_decoder(void)
     hr = CoInitialize(NULL);
     ok(hr == S_OK, "Failed to initialize, hr %#lx.\n", hr);

+    winetest_push_context("aacdec");
+
     if (!create_transform(MFT_CATEGORY_AUDIO_DECODER, &input_type, &output_type, L"Microsoft AAC Audio Decoder MFT", &MFMediaType_Audio,
             transform_inputs, ARRAY_SIZE(transform_inputs), transform_outputs, ARRAY_SIZE(transform_outputs),
             &transform, &CLSID_MSAACDecMFT, &class_id))
@@ -7458,6 +7467,7 @@ static void test_aac_decoder(void)
     ok(ret == 0, "Release returned %lu\n", ret);

failed:
+    winetest_pop_context();
     CoUninitialize();
 }

@@ -7534,6 +7544,8 @@ static void test_wma_encoder(void)
     hr = CoInitialize(NULL);
     ok(hr == S_OK, "Failed to initialize, hr %#lx.\n", hr);

+    winetest_push_context("wmaenc");
+
     if (!create_transform(MFT_CATEGORY_AUDIO_ENCODER, &input_type, &output_type, L"WMAudio Encoder MFT", &MFMediaType_Audio,
             transform_inputs, ARRAY_SIZE(transform_inputs), transform_outputs, ARRAY_SIZE(transform_outputs),
             &transform, &CLSID_CWMAEncMediaObject, &class_id))
@@ -7656,6 +7668,7 @@ static void test_wma_encoder(void)
     ok(ret == 0, "Release returned %lu\n", ret);

failed:
+    winetest_pop_context();
     CoUninitialize();
 }

@@ -7786,6 +7799,8 @@ static void test_wma_decoder(void)
     hr = CoInitialize(NULL);
     ok(hr == S_OK, "Failed to initialize, hr %#lx.\n", hr);

+    winetest_push_context("wmadec");
+
     if (!create_transform(MFT_CATEGORY_AUDIO_DECODER, &input_type, &output_type, L"WMAudio Decoder MFT", &MFMediaType_Audio,
             transform_inputs, ARRAY_SIZE(transform_inputs), transform_outputs, ARRAY_SIZE(transform_outputs),
             &transform, &CLSID_CWMADecMediaObject, &class_id))
@@ -8168,6 +8183,7 @@ static void test_wma_decoder(void)
     ok( ref == 0, "Release returned %lu\n", ref );

failed:
+    winetest_pop_context();
     CoUninitialize();
 }

@@ -8425,6 +8441,8 @@ static void test_h264_decoder(void)
     hr = CoInitialize(NULL);
     ok(hr == S_OK, "Failed to initialize, hr %#lx.\n", hr);

+    winetest_push_context("h264dec");
+
     if (!create_transform(MFT_CATEGORY_VIDEO_DECODER, &input_type, &output_type, L"Microsoft H264 Video Decoder MFT", &MFMediaType_Video,
             transform_inputs, ARRAY_SIZE(transform_inputs), transform_outputs, ARRAY_SIZE(transform_outputs),
             &transform, &CLSID_MSH264DecoderMFT, &class_id))
@@ -8929,6 +8947,7 @@ static void test_h264_decoder(void)
     ok(ret == 0, "Release returned %lu\n", ret);

failed:
+    winetest_pop_context();
     CoUninitialize();
 }

@@ -9040,6 +9059,8 @@ static void test_audio_convert(void)
     hr = CoInitialize(NULL);
     ok(hr == S_OK, "Failed to initialize, hr %#lx.\n", hr);

+    winetest_push_context("resampler");
+
     if (!create_transform(MFT_CATEGORY_AUDIO_EFFECT, &input_type, &output_type, L"Resampler MFT", &MFMediaType_Audio,
             transform_inputs, ARRAY_SIZE(transform_inputs), transform_outputs, ARRAY_SIZE(transform_outputs),
             &transform, &CLSID_CResamplerMediaObject, &class_id))
@@ -9318,6 +9339,7 @@ static void test_audio_convert(void)
     ok(ret == 0, "Release returned %lu\n", ret);

failed:
+    winetest_pop_context();
     CoUninitialize();
 }

@@ -9497,6 +9519,8 @@ static void test_color_convert(void)
     hr = CoInitialize(NULL);
     ok(hr == S_OK, "Failed to initialize, hr %#lx.\n", hr);

+    winetest_push_context("colorconv");
+
     if (!create_transform(MFT_CATEGORY_VIDEO_EFFECT, &input_type, &output_type, L"Color Converter MFT", &MFMediaType_Video,
             transform_inputs, ARRAY_SIZE(transform_inputs), transform_outputs, ARRAY_SIZE(transform_outputs),
             &transform, &CLSID_CColorConvertDMO, &class_id))
@@ -9693,6 +9717,7 @@ static void test_color_convert(void)
     ok(ret == 0, "Release returned %ld\n", ret);

failed:
+    winetest_pop_context();
     CoUninitialize();
 }

@@ -9885,6 +9910,8 @@ static void test_video_processor(void)
     hr = CoInitialize(NULL);
     ok(hr == S_OK, "Failed to initialize, hr %#lx.\n", hr);

+    winetest_push_context("videoproc");
+
     if (!create_transform(MFT_CATEGORY_VIDEO_PROCESSOR, &input_type, &output_type, L"Microsoft Video Processor MFT", &MFMediaType_Video,
             transform_inputs, ARRAY_SIZE(transform_inputs), transform_outputs, ARRAY_SIZE(transform_outputs),
             &transform, &CLSID_VideoProcessorMFT, &class_id))
@@ -10444,6 +10471,7 @@ skip_output:
     ok(ret == 0, "Release returned %ld\n", ret);

failed:
+    winetest_pop_context();
     CoUninitialize();
 }

@@ -10581,6 +10609,8 @@ static void test_mp3_decoder(void)
     hr = CoInitialize(NULL);
     ok(hr == S_OK, "Failed to initialize, hr %#lx.\n", hr);

+    winetest_push_context("mp3dec");
+
     if (!create_transform(MFT_CATEGORY_AUDIO_DECODER, &input_type, &output_type, L"MP3 Decoder MFT", &MFMediaType_Audio,
             transform_inputs, ARRAY_SIZE(transform_inputs), transform_outputs, ARRAY_SIZE(transform_outputs),
             &transform, &CLSID_CMP3DecMediaObject, &class_id))
@@ -10879,6 +10909,7 @@ static void test_mp3_decoder(void)
     ok(ret == 0, "Release returned %lu\n", ret);

failed:
+    winetest_pop_context();
     CoUninitialize();
 }

[PATCH 05/11] mf/tests: Factor transform required attributes checks together.

[Rémi Bernon]

From: R��mi Bernon

---
 dlls/mf/tests/mf.c | 570 +++++++++++++++++++--------------------------
 1 file changed, 235 insertions(+), 335 deletions(-)

diff --git a/dlls/mf/tests/mf.c b/dlls/mf/tests/mf.c
index aac4ba8c52e..f4577c0d397 100644
--- a/dlls/mf/tests/mf.c
+++ b/dlls/mf/tests/mf.c
@@ -165,6 +165,7 @@ struct attribute_desc
     const char *name;
     PROPVARIANT value;
     BOOL ratio;
+    BOOL required;
     BOOL todo;
     BOOL todo_value;
 };
@@ -320,6 +321,97 @@ static void init_media_type(IMFMediaType *mediatype, const struct attribute_desc
     }
 }

+#define check_set_input_type_required_attributes(a, b) check_set_input_type_required_attributes_(__LINE__, a, b)
+static void check_set_input_type_required_attributes_(int line, IMFTransform *transform, const struct attribute_desc *attributes)
+{
+    const struct attribute_desc *attr;
+    IMFMediaType *media_type;
+    HRESULT hr;
+    ULONG ref;
+
+    hr = MFCreateMediaType(&media_type);
+    ok_(__FILE__, line)(hr == S_OK, "MFCreateMediaType returned hr %#lx.\n", hr);
+    init_media_type(media_type, attributes, -1);
+
+    for (attr = attributes; attr && attr->key; attr++)
+    {
+        winetest_push_context("%s", debugstr_a(attr->name));
+        hr = IMFMediaType_DeleteItem(media_type, attr->key);
+        ok_(__FILE__, line)(hr == S_OK, "DeleteItem returned %#lx\n", hr);
+        hr = IMFTransform_SetInputType(transform, 0, media_type, MFT_SET_TYPE_TEST_ONLY);
+        ok_(__FILE__, line)(FAILED(hr) == attr->required, "SetInputType returned %#lx.\n", hr);
+        hr = IMFMediaType_SetItem(media_type, attr->key, &attr->value);
+        ok_(__FILE__, line)(hr == S_OK, "SetItem returned %#lx\n", hr);
+        winetest_pop_context();
+    }
+
+    hr = IMFTransform_SetInputType(transform, 0, media_type, MFT_SET_TYPE_TEST_ONLY);
+    ok_(__FILE__, line)(hr == S_OK, "SetInputType returned %#lx.\n", hr);
+    ref = IMFMediaType_Release(media_type);
+    ok_(__FILE__, line)(!ref, "Release returned %lu\n", ref);
+}
+
+#define check_set_output_type_required_attributes(a, b) check_set_output_type_required_attributes_(__LINE__, a, b)
+static void check_set_output_type_required_attributes_(int line, IMFTransform *transform, const struct attribute_desc *attributes)
+{
+    const struct attribute_desc *attr;
+    IMFMediaType *media_type;
+    HRESULT hr;
+    ULONG ref;
+
+    hr = MFCreateMediaType(&media_type);
+    ok_(__FILE__, line)(hr == S_OK, "MFCreateMediaType returned hr %#lx.\n", hr);
+    init_media_type(media_type, attributes, -1);
+
+    for (attr = attributes; attr && attr->key; attr++)
+    {
+        winetest_push_context("%s", debugstr_a(attr->name));
+        hr = IMFMediaType_DeleteItem(media_type, attr->key);
+        ok_(__FILE__, line)(hr == S_OK, "DeleteItem returned %#lx\n", hr);
+        hr = IMFTransform_SetOutputType(transform, 0, media_type, MFT_SET_TYPE_TEST_ONLY);
+        ok_(__FILE__, line)(FAILED(hr) == attr->required, "SetOutputType returned %#lx.\n", hr);
+        hr = IMFMediaType_SetItem(media_type, attr->key, &attr->value);
+        ok_(__FILE__, line)(hr == S_OK, "SetItem returned %#lx\n", hr);
+        winetest_pop_context();
+    }
+
+    hr = IMFTransform_SetOutputType(transform, 0, media_type, MFT_SET_TYPE_TEST_ONLY);
+    ok_(__FILE__, line)(hr == S_OK, "SetOutputType returned %#lx.\n", hr);
+    ref = IMFMediaType_Release(media_type);
+    ok_(__FILE__, line)(!ref, "Release returned %lu\n", ref);
+}
+
+#define check_handler_required_attributes(a, b) check_handler_required_attributes_(__LINE__, a, b)
+static void check_handler_required_attributes_(int line, IMFMediaTypeHandler *handler, const struct attribute_desc *attributes)
+{
+    const struct attribute_desc *attr;
+    IMFMediaType *media_type;
+    HRESULT hr;
+    ULONG ref;
+
+    hr = MFCreateMediaType(&media_type);
+    ok_(__FILE__, line)(hr == S_OK, "MFCreateMediaType returned hr %#lx.\n", hr);
+    init_media_type(media_type, attributes, -1);
+
+    for (attr = attributes; attr && attr->key; attr++)
+    {
+        winetest_push_context("%s", debugstr_a(attr->name));
+        hr = IMFMediaType_DeleteItem(media_type, attr->key);
+        ok_(__FILE__, line)(hr == S_OK, "DeleteItem returned %#lx\n", hr);
+        hr = IMFMediaTypeHandler_IsMediaTypeSupported(handler, media_type, NULL);
+        todo_wine_if(attr->todo)
+        ok_(__FILE__, line)(FAILED(hr) == attr->required, "IsMediaTypeSupported returned %#lx.\n", hr);
+        hr = IMFMediaType_SetItem(media_type, attr->key, &attr->value);
+        ok_(__FILE__, line)(hr == S_OK, "SetItem returned %#lx\n", hr);
+        winetest_pop_context();
+    }
+
+    hr = IMFMediaTypeHandler_IsMediaTypeSupported(handler, media_type, NULL);
+    ok_(__FILE__, line)(hr == S_OK, "IsMediaTypeSupported returned %#lx.\n", hr);
+    ref = IMFMediaType_Release(media_type);
+    ok_(__FILE__, line)(!ref, "Release returned %lu\n", ref);
+}
+
 static void create_descriptors(UINT enum_types_count, IMFMediaType **enum_types, const media_type_desc *current_desc,
         IMFPresentationDescriptor **pd, IMFStreamDescriptor **sd)
 {
@@ -5030,24 +5122,24 @@ static void test_sar(void)
 {
     static const struct attribute_desc input_type_desc_48000[] =
     {
-        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio),
-        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_Float),
-        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 48000),
-        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 2),
-        ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 32),
-        ATTR_UINT32(MF_MT_AUDIO_BLOCK_ALIGNMENT, 8),
-        ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 8 * 48000),
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio, .required = TRUE),
+        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_Float, .required = TRUE, .todo = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 2, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 32, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 48000, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_BLOCK_ALIGNMENT, 2 * (32 / 8), .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 2 * (32 / 8) * 48000, .required = TRUE),
         {0},
     };
     static const struct attribute_desc input_type_desc_44100[] =
     {
-        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio),
-        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_Float),
-        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 44100),
-        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 2),
-        ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 32),
-        ATTR_UINT32(MF_MT_AUDIO_BLOCK_ALIGNMENT, 8),
-        ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 8 * 44100),
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio, .required = TRUE),
+        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_Float, .required = TRUE, .todo = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 2, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 32, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 44100, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_BLOCK_ALIGNMENT, 2 * (32 / 8), .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 2 * (32 / 8) * 44100, .required = TRUE),
         {0},
     };

@@ -5242,27 +5334,7 @@ if (SUCCEEDED(hr))
     ok(rate == 48000 || rate == 44100, "got rate %u.\n", rate);
     IMFMediaType_Release(mediatype);

-
-    /* check required output media type attributes */
-
-    hr = MFCreateMediaType(&mediatype);
-    ok(hr == S_OK, "MFCreateMediaType returned %#lx\n", hr);
-    hr = IMFMediaTypeHandler_IsMediaTypeSupported(handler, mediatype, NULL);
-    ok(hr == MF_E_ATTRIBUTENOTFOUND, "Unexpected hr %#lx.\n", hr);
-    init_media_type(mediatype, rate == 44100 ? input_type_desc_44100 : input_type_desc_48000, 2);
-    for (int i = 1; i < (rate == 44100 ? ARRAY_SIZE(input_type_desc_44100) : ARRAY_SIZE(input_type_desc_48000)) - 1; ++i)
-    {
-        hr = IMFMediaTypeHandler_IsMediaTypeSupported(handler, mediatype, NULL);
-        ok(hr == MF_E_INVALIDMEDIATYPE, "Unexpected hr %#lx.\n", hr);
-        init_media_type(mediatype, rate == 44100 ? input_type_desc_44100 : input_type_desc_48000, i + 1);
-    }
-    hr = IMFMediaTypeHandler_IsMediaTypeSupported(handler, mediatype, NULL);
-    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
-    init_media_type(mediatype, rate == 44100 ? input_type_desc_44100 : input_type_desc_48000, -1);
-    hr = IMFMediaTypeHandler_IsMediaTypeSupported(handler, mediatype, NULL);
-    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
-    IMFMediaType_Release(mediatype);
-
+    check_handler_required_attributes(handler, rate == 44100 ? input_type_desc_44100 : input_type_desc_48000);

hr = IMFMediaTypeHandler_GetCurrentMediaType(handler, &mediatype);
     ok(hr == MF_E_NOT_INITIALIZED, "Unexpected hr %#lx.\n", hr);
@@ -7083,21 +7155,21 @@ static void test_aac_encoder(void)

static const struct attribute_desc input_type_desc[] =
     {
-        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio),
-        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_PCM),
-        ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 16),
-        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 1),
-        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 44100),
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio, .required = TRUE),
+        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_PCM, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 1, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 16, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 44100, .required = TRUE),
         {0},
     };
     const struct attribute_desc output_type_desc[] =
     {
-        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio),
-        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_AAC),
-        ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 16),
-        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 1),
-        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 44100),
-        ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 12000),
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio, .required = TRUE),
+        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_AAC, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 1, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 16, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 44100, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 12000, .required = TRUE),
         {0},
     };

@@ -7161,6 +7233,8 @@ static void test_aac_encoder(void)
     check_interface(transform, &IID_IMFTransform, TRUE);
     check_interface(transform, &IID_IMediaObject, FALSE);

+    check_set_input_type_required_attributes(transform, input_type_desc);
+
     hr = MFCreateMediaType(&media_type);
     ok(hr == S_OK, "MFCreateMediaType returned %#lx\n", hr);
     init_media_type(media_type, input_type_desc, -1);
@@ -7169,6 +7243,8 @@ static void test_aac_encoder(void)
     ret = IMFMediaType_Release(media_type);
     ok(ret == 1, "Release returned %lu\n", ret);

+    check_set_output_type_required_attributes(transform, output_type_desc);
+
     hr = MFCreateMediaType(&media_type);
     ok(hr == S_OK, "MFCreateMediaType returned %#lx\n", hr);
     init_media_type(media_type, output_type_desc, -1);
@@ -7294,24 +7370,24 @@ static void test_aac_decoder(void)

const struct attribute_desc input_type_desc[] =
     {
-        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio),
-        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_AAC),
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio, .required = TRUE),
+        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_AAC, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 44100, .required = TRUE),
+        ATTR_BLOB(MF_MT_USER_DATA, aac_codec_data, sizeof(aac_codec_data), .required = TRUE),
         ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 16),
         ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 1),
-        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 44100),
         ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 12000),
         ATTR_UINT32(MF_MT_AAC_AUDIO_PROFILE_LEVEL_INDICATION, 41),
         ATTR_UINT32(MF_MT_AAC_PAYLOAD_TYPE, 0),
-        ATTR_BLOB(MF_MT_USER_DATA, aac_codec_data, sizeof(aac_codec_data)),
         {0},
     };
     static const struct attribute_desc output_type_desc[] =
     {
-        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio),
-        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_PCM),
-        ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 16),
-        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 1),
-        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 44100),
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio, .required = TRUE),
+        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_PCM, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 1, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 16, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 44100, .required = TRUE),
         {0},
     };

@@ -7391,19 +7467,11 @@ static void test_aac_decoder(void)
     ret = IMFMediaType_Release(media_type);
     ok(ret == 0, "Release returned %lu\n", ret);

-    /* check required input media type attributes */
+    check_set_input_type_required_attributes(transform, input_type_desc);

hr = MFCreateMediaType(&media_type);
     ok(hr == S_OK, "MFCreateMediaType returned %#lx\n", hr);
-    hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
-    ok(hr == E_INVALIDARG, "SetInputType returned %#lx.\n", hr);
-    init_media_type(media_type, input_type_desc, 1);
-    for (i = 1; i < ARRAY_SIZE(input_type_desc) - 1; ++i)
-    {
-        hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
-        ok(hr == MF_E_INVALIDMEDIATYPE, "SetInputType returned %#lx.\n", hr);
-        init_media_type(media_type, input_type_desc, i + 1);
-    }
+    init_media_type(media_type, input_type_desc, -1);
     hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
     ok(hr == S_OK, "SetInputType returned %#lx.\n", hr);
     ret = IMFMediaType_Release(media_type);
@@ -7427,19 +7495,11 @@ static void test_aac_decoder(void)
     ok(hr == MF_E_NO_MORE_TYPES, "GetOutputAvailableType returned %#lx\n", hr);
     ok(i == ARRAY_SIZE(expect_available_outputs), "%lu input media types\n", i);

-    /* check required output media type attributes */
+    check_set_output_type_required_attributes(transform, output_type_desc);

hr = MFCreateMediaType(&media_type);
     ok(hr == S_OK, "MFCreateMediaType returned %#lx\n", hr);
-    hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
-    ok(hr == E_INVALIDARG, "SetOutputType returned %#lx.\n", hr);
-    init_media_type(media_type, output_type_desc, 1);
-    for (i = 1; i < ARRAY_SIZE(output_type_desc) - 1; ++i)
-    {
-        hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
-        ok(hr == MF_E_INVALIDMEDIATYPE, "SetOutputType returned %#lx.\n", hr);
-        init_media_type(media_type, output_type_desc, i + 1);
-    }
+    init_media_type(media_type, output_type_desc, -1);
     hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
     ok(hr == S_OK, "SetOutputType returned %#lx.\n", hr);
     ret = IMFMediaType_Release(media_type);
@@ -7501,24 +7561,24 @@ static void test_wma_encoder(void)

static const struct attribute_desc input_type_desc[] =
     {
-        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio),
-        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_Float),
-        ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 32),
-        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 2),
-        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 22050),
-        ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 176400),
-        ATTR_UINT32(MF_MT_AUDIO_BLOCK_ALIGNMENT, 8),
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio, .required = TRUE),
+        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_Float, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 2, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 32, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 22050, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_BLOCK_ALIGNMENT, 2 * (32 / 8), .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 2 * (32 / 8) * 22050, .required = TRUE),
         {0},
     };
     const struct attribute_desc output_type_desc[] =
     {
-        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio),
-        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_WMAudioV8),
-        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 2),
-        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 22050),
-        ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 4003),
-        ATTR_UINT32(MF_MT_AUDIO_BLOCK_ALIGNMENT, wmaenc_block_size),
-        ATTR_BLOB(MF_MT_USER_DATA, wma_codec_data, sizeof(wma_codec_data)),
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio, .required = TRUE),
+        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_WMAudioV8, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 2, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 22050, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 4003, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_BLOCK_ALIGNMENT, wmaenc_block_size, .required = TRUE),
+        ATTR_BLOB(MF_MT_USER_DATA, wma_codec_data, sizeof(wma_codec_data), .required = TRUE),
         {0},
     };

@@ -7559,11 +7619,20 @@ static void test_wma_encoder(void)
     check_interface(transform, &IID_IPropertyStore, TRUE);
     check_interface(transform, &IID_IPropertyBag, TRUE);

+    check_set_input_type_required_attributes(transform, input_type_desc);
+
     hr = MFCreateMediaType(&media_type);
     ok(hr == S_OK, "MFCreateMediaType returned %#lx\n", hr);
     init_media_type(media_type, input_type_desc, -1);
     hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
     ok(hr == S_OK, "SetInputType returned %#lx.\n", hr);
+    ret = IMFMediaType_Release(media_type);
+    ok(ret == 0, "Release returned %lu\n", ret);
+
+    check_set_output_type_required_attributes(transform, output_type_desc);
+
+    hr = MFCreateMediaType(&media_type);
+    ok(hr == S_OK, "MFCreateMediaType returned %#lx\n", hr);
     init_media_type(media_type, output_type_desc, -1);
     hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
     ok(hr == S_OK, "SetOutputType returned %#lx.\n", hr);
@@ -7752,23 +7821,24 @@ static void test_wma_decoder(void)

const struct attribute_desc input_type_desc[] =
     {
-        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio),
-        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_WMAudioV8),
-        ATTR_BLOB(MF_MT_USER_DATA, wma_codec_data, sizeof(wma_codec_data)),
-        ATTR_UINT32(MF_MT_AUDIO_BLOCK_ALIGNMENT, wmaenc_block_size),
-        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 22050),
-        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 2),
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio, .required = TRUE),
+        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_WMAudioV8, .required = TRUE),
+        ATTR_BLOB(MF_MT_USER_DATA, wma_codec_data, sizeof(wma_codec_data), .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_BLOCK_ALIGNMENT, wmaenc_block_size, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 22050, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 2, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 4003), /* not required by SetInputType, but needed for the transform to work */
         {0},
     };
     static const struct attribute_desc output_type_desc[] =
     {
-        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio),
-        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_PCM),
-        ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 88200),
-        ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 16),
-        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 2),
-        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 22050),
-        ATTR_UINT32(MF_MT_AUDIO_BLOCK_ALIGNMENT, 4),
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio, .required = TRUE),
+        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_PCM, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 2, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 16, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 22050, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_BLOCK_ALIGNMENT, 2 * (16 / 8), .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 2 * (16 / 8) * 22050, .required = TRUE),
         {0},
     };

@@ -7851,22 +7921,11 @@ static void test_wma_decoder(void)
     ret = IMFMediaType_Release(media_type);
     ok(ret == 0, "Release returned %lu\n", ret);

-    /* check required input media type attributes */
+    check_set_input_type_required_attributes(transform, input_type_desc);

hr = MFCreateMediaType(&media_type);
     ok(hr == S_OK, "MFCreateMediaType returned %#lx\n", hr);
-    hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
-    ok(hr == MF_E_ATTRIBUTENOTFOUND, "SetInputType returned %#lx.\n", hr);
-    init_media_type(media_type, input_type_desc, 1);
-    hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
-    ok(hr == MF_E_ATTRIBUTENOTFOUND, "SetInputType returned %#lx.\n", hr);
-    init_media_type(media_type, input_type_desc, 2);
-    for (i = 2; i < ARRAY_SIZE(input_type_desc) - 1; ++i)
-    {
-        hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
-        ok(hr == MF_E_INVALIDMEDIATYPE, "SetInputType returned %#lx.\n", hr);
-        init_media_type(media_type, input_type_desc, i + 1);
-    }
+    init_media_type(media_type, input_type_desc, -1);
     hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
     ok(hr == S_OK, "SetInputType returned %#lx.\n", hr);
     ret = IMFMediaType_Release(media_type);
@@ -7892,22 +7951,11 @@ static void test_wma_decoder(void)
     ok(hr == MF_E_NO_MORE_TYPES, "GetOutputAvailableType returned %#lx\n", hr);
     ok(i == 2, "%lu output media types\n", i);

-    /* check required output media type attributes */
+    check_set_output_type_required_attributes(transform, output_type_desc);

hr = MFCreateMediaType(&media_type);
     ok(hr == S_OK, "MFCreateMediaType returned %#lx\n", hr);
-    hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
-    ok(hr == MF_E_ATTRIBUTENOTFOUND, "SetOutputType returned %#lx.\n", hr);
-    init_media_type(media_type, output_type_desc, 1);
-    hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
-    ok(hr == MF_E_ATTRIBUTENOTFOUND, "SetOutputType returned %#lx.\n", hr);
-    init_media_type(media_type, output_type_desc, 2);
-    for (i = 2; i < ARRAY_SIZE(output_type_desc) - 1; ++i)
-    {
-        hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
-        ok(hr == MF_E_INVALIDMEDIATYPE, "SetOutputType returned %#lx.\n", hr);
-        init_media_type(media_type, output_type_desc, i + 1);
-    }
+    init_media_type(media_type, output_type_desc, -1);
     hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
     ok(hr == S_OK, "SetOutputType returned %#lx.\n", hr);
     ret = IMFMediaType_Release(media_type);
@@ -7922,33 +7970,6 @@ static void test_wma_decoder(void)
     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 == 0, "got cbSize %#lx\n", output_info.cbSize);
-    ok(output_info.cbAlignment == 1, "got cbAlignment %#lx\n", output_info.cbAlignment);
-
-    /* MF_MT_AUDIO_AVG_BYTES_PER_SECOND isn't required by SetInputType, but is needed for the transform to work */
-
-    hr = MFCreateMediaType(&media_type);
-    ok(hr == S_OK, "MFCreateMediaType returned %#lx\n", hr);
-    init_media_type(media_type, input_type_desc, -1);
-    hr = IMFMediaType_SetUINT32(media_type, &MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 4003);
-    ok(hr == S_OK, "SetUINT32 returned %#lx\n", hr);
-    hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
-    ok(hr == S_OK, "SetInputType returned %#lx.\n", hr);
-
-    hr = IMFTransform_GetOutputStreamInfo(transform, 0, &output_info);
-    ok(hr == MF_E_TRANSFORM_TYPE_NOT_SET, "GetOutputStreamInfo returned %#lx\n", hr);
-
-    init_media_type(media_type, output_type_desc, -1);
-    hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
-    ok(hr == S_OK, "SetInputType returned %#lx.\n", hr);
-    ret = IMFMediaType_Release(media_type);
-    ok(ret == 0, "Release returned %lu\n", ret);
-
     memset(&output_info, 0xcd, sizeof(output_info));
     hr = IMFTransform_GetOutputStreamInfo(transform, 0, &output_info);
     ok(hr == S_OK, "GetOutputStreamInfo returned %#lx\n", hr);
@@ -8305,23 +8326,16 @@ static void test_h264_decoder(void)
     };
     const struct attribute_desc input_type_desc[] =
     {
-        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video),
-        ATTR_GUID(MF_MT_SUBTYPE, MFVideoFormat_H264),
-        ATTR_RATIO(MF_MT_FRAME_SIZE, input_width, input_height),
-        {0},
-    };
-    const struct attribute_desc minimal_output_type_desc[] =
-    {
-        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video),
-        ATTR_GUID(MF_MT_SUBTYPE, MFVideoFormat_NV12),
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video, .required = TRUE),
+        ATTR_GUID(MF_MT_SUBTYPE, MFVideoFormat_H264, .required = TRUE),
         ATTR_RATIO(MF_MT_FRAME_SIZE, input_width, input_height),
         {0},
     };
     const struct attribute_desc output_type_desc[] =
     {
-        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video),
-        ATTR_GUID(MF_MT_SUBTYPE, MFVideoFormat_NV12),
-        ATTR_RATIO(MF_MT_FRAME_SIZE, input_width, input_height),
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video, .required = TRUE),
+        ATTR_GUID(MF_MT_SUBTYPE, MFVideoFormat_NV12, .required = TRUE),
+        ATTR_RATIO(MF_MT_FRAME_SIZE, input_width, input_height, .required = TRUE),
         ATTR_RATIO(MF_MT_FRAME_RATE, 60000, 1000),
         ATTR_RATIO(MF_MT_PIXEL_ASPECT_RATIO, 2, 1),
         ATTR_UINT32(MF_MT_DEFAULT_STRIDE, 3840),
@@ -8512,19 +8526,10 @@ static void test_h264_decoder(void)
     ok(hr == MF_E_NO_MORE_TYPES, "GetInputAvailableType returned %#lx\n", hr);
     ok(i == 2 || broken(i == 1) /* Win7 */, "%lu input media types\n", i);

-    /* check required input media type attributes */
+    check_set_input_type_required_attributes(transform, input_type_desc);

hr = MFCreateMediaType(&media_type);
     ok(hr == S_OK, "MFCreateMediaType returned %#lx\n", hr);
-    hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
-    ok(hr == E_INVALIDARG, "SetInputType returned %#lx.\n", hr);
-    init_media_type(media_type, input_type_desc, 1);
-    hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
-    todo_wine
-    ok(hr == MF_E_INVALIDMEDIATYPE, "SetInputType returned %#lx.\n", hr);
-    init_media_type(media_type, input_type_desc, 2);
-    hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
-    ok(hr == S_OK, "SetInputType returned %#lx.\n", hr);
     init_media_type(media_type, input_type_desc, -1);
     hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
     ok(hr == S_OK, "SetInputType returned %#lx.\n", hr);
@@ -8555,27 +8560,10 @@ 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);

-    /* check required output media type attributes */
+    check_set_output_type_required_attributes(transform, output_type_desc);

hr = MFCreateMediaType(&media_type);
     ok(hr == S_OK, "MFCreateMediaType returned %#lx\n", hr);
-    hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
-    todo_wine
-    ok(hr == E_INVALIDARG, "SetOutputType returned %#lx.\n", hr);
-    init_media_type(media_type, minimal_output_type_desc, 1);
-    hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
-    todo_wine
-    ok(hr == MF_E_INVALIDMEDIATYPE, "SetOutputType returned %#lx.\n", hr);
-    init_media_type(media_type, minimal_output_type_desc, 2);
-    for (i = 2; i < ARRAY_SIZE(minimal_output_type_desc) - 1; ++i)
-    {
-        hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
-        todo_wine
-        ok(hr == MF_E_ATTRIBUTENOTFOUND, "SetOutputType returned %#lx.\n", hr);
-        init_media_type(media_type, minimal_output_type_desc, i + 1);
-    }
-    hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
-    ok(hr == S_OK, "SetOutputType returned %#lx.\n", hr);
     init_media_type(media_type, output_type_desc, -1);
     hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
     ok(hr == S_OK, "SetOutputType returned %#lx.\n", hr);
@@ -9015,24 +9003,24 @@ static void test_audio_convert(void)

static const struct attribute_desc input_type_desc[] =
     {
-        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio),
-        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_Float),
-        ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 32),
-        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 2),
-        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 22050),
-        ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 176400),
-        ATTR_UINT32(MF_MT_AUDIO_BLOCK_ALIGNMENT, 8),
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio, .required = TRUE),
+        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_Float, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 2, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 32, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 22050, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_BLOCK_ALIGNMENT, 2 * (32 / 8), .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 2 * (32 / 8) * 22050, .required = TRUE),
         {0},
     };
     const struct attribute_desc output_type_desc[] =
     {
-        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio),
-        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_PCM),
-        ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 16),
-        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 2),
-        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 44100),
-        ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 176400),
-        ATTR_UINT32(MF_MT_AUDIO_BLOCK_ALIGNMENT, 4),
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio, .required = TRUE),
+        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_PCM, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 2, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 16, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 44100, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_BLOCK_ALIGNMENT, 2 * (16 / 8), .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 2 * (16 / 8) * 44100, .required = TRUE),
         {0},
     };

@@ -9120,22 +9108,11 @@ static void test_audio_convert(void)
     ret = IMFMediaType_Release(media_type);
     ok(ret == 0, "Release returned %lu\n", ret);

-    /* check required input media type attributes */
+    check_set_input_type_required_attributes(transform, input_type_desc);

hr = MFCreateMediaType(&media_type);
     ok(hr == S_OK, "MFCreateMediaType returned %#lx\n", hr);
-    hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
-    ok(hr == MF_E_ATTRIBUTENOTFOUND, "SetInputType returned %#lx.\n", hr);
-    init_media_type(media_type, input_type_desc, 1);
-    hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
-    ok(hr == MF_E_ATTRIBUTENOTFOUND, "SetInputType returned %#lx.\n", hr);
-    init_media_type(media_type, input_type_desc, 2);
-    for (i = 2; i < ARRAY_SIZE(input_type_desc) - 1; ++i)
-    {
-        hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
-        ok(hr == MF_E_INVALIDMEDIATYPE, "SetInputType returned %#lx.\n", hr);
-        init_media_type(media_type, input_type_desc, i + 1);
-    }
+    init_media_type(media_type, input_type_desc, -1);
     hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
     ok(hr == S_OK, "SetInputType returned %#lx.\n", hr);
     ret = IMFMediaType_Release(media_type);
@@ -9161,22 +9138,11 @@ static void test_audio_convert(void)
     ok(hr == MF_E_NO_MORE_TYPES, "GetOutputAvailableType returned %#lx\n", hr);
     ok(i == 4, "%lu output media types\n", i);

-    /* check required output media type attributes */
+    check_set_output_type_required_attributes(transform, output_type_desc);

hr = MFCreateMediaType(&media_type);
     ok(hr == S_OK, "MFCreateMediaType returned %#lx\n", hr);
-    hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
-    ok(hr == MF_E_ATTRIBUTENOTFOUND, "SetOutputType returned %#lx.\n", hr);
-    init_media_type(media_type, output_type_desc, 1);
-    hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
-    ok(hr == MF_E_ATTRIBUTENOTFOUND, "SetOutputType returned %#lx.\n", hr);
-    init_media_type(media_type, output_type_desc, 2);
-    for (i = 2; i < ARRAY_SIZE(output_type_desc) - 1; ++i)
-    {
-        hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
-        ok(hr == MF_E_INVALIDMEDIATYPE, "SetOutputType returned %#lx.\n", hr);
-        init_media_type(media_type, output_type_desc, i + 1);
-    }
+    init_media_type(media_type, output_type_desc, -1);
     hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
     ok(hr == S_OK, "SetOutputType returned %#lx.\n", hr);
     ret = IMFMediaType_Release(media_type);
@@ -9483,17 +9449,17 @@ static void test_color_convert(void)
     static const DWORD actual_width = 96, actual_height = 96;
     const struct attribute_desc input_type_desc[] =
     {
-        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video),
-        ATTR_GUID(MF_MT_SUBTYPE, MFVideoFormat_NV12),
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video, .required = TRUE),
+        ATTR_GUID(MF_MT_SUBTYPE, MFVideoFormat_NV12, .required = TRUE),
+        ATTR_RATIO(MF_MT_FRAME_SIZE, actual_width, actual_height, .required = TRUE),
         ATTR_BLOB(MF_MT_MINIMUM_DISPLAY_APERTURE, &actual_aperture, 16),
-        ATTR_RATIO(MF_MT_FRAME_SIZE, actual_width, actual_height),
         {0},
     };
     const struct attribute_desc output_type_desc[] =
     {
-        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video),
-        ATTR_GUID(MF_MT_SUBTYPE, MFVideoFormat_RGB32),
-        ATTR_RATIO(MF_MT_FRAME_SIZE, actual_width, actual_height),
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video, .required = TRUE),
+        ATTR_GUID(MF_MT_SUBTYPE, MFVideoFormat_RGB32, .required = TRUE),
+        ATTR_RATIO(MF_MT_FRAME_SIZE, actual_width, actual_height, .required = TRUE),
         {0},
     };

@@ -9579,43 +9545,21 @@ static void test_color_convert(void)
     ok(hr == MF_E_NO_MORE_TYPES, "GetInputAvailableType returned %#lx\n", hr);
     ok(i == 20, "%lu input media types\n", i);

-    /* check required output media type attributes */
+    check_set_output_type_required_attributes(transform, output_type_desc);

hr = MFCreateMediaType(&media_type);
     ok(hr == S_OK, "MFCreateMediaType returned %#lx\n", hr);
-    hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
-    ok(hr == MF_E_ATTRIBUTENOTFOUND, "SetOutputType returned %#lx.\n", hr);
-    init_media_type(media_type, output_type_desc, 1);
-    hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
-    ok(hr == MF_E_ATTRIBUTENOTFOUND, "SetOutputType returned %#lx.\n", hr);
-    init_media_type(media_type, output_type_desc, 2);
-    for (i = 2; i < ARRAY_SIZE(output_type_desc) - 1; ++i)
-    {
-        hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
-        ok(hr == E_INVALIDARG, "SetOutputType returned %#lx.\n", hr);
-        init_media_type(media_type, output_type_desc, i + 1);
-    }
+    init_media_type(media_type, output_type_desc, -1);
     hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
     ok(hr == S_OK, "SetOutputType returned %#lx.\n", hr);
     ret = IMFMediaType_Release(media_type);
     ok(ret == 0, "Release returned %lu\n", ret);

-    /* check required input media type attributes */
+    check_set_input_type_required_attributes(transform, input_type_desc);

hr = MFCreateMediaType(&media_type);
     ok(hr == S_OK, "MFCreateMediaType returned %#lx\n", hr);
-    hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
-    ok(hr == MF_E_ATTRIBUTENOTFOUND, "SetInputType returned %#lx.\n", hr);
-    init_media_type(media_type, input_type_desc, 1);
-    hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
-    ok(hr == MF_E_ATTRIBUTENOTFOUND, "SetInputType returned %#lx.\n", hr);
-    init_media_type(media_type, input_type_desc, 2);
-    for (i = 2; i < ARRAY_SIZE(input_type_desc) - 1; ++i)
-    {
-        hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
-        ok(hr == E_INVALIDARG, "SetInputType returned %#lx.\n", hr);
-        init_media_type(media_type, input_type_desc, i + 1);
-    }
+    init_media_type(media_type, input_type_desc, -1);
     hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
     ok(hr == S_OK, "SetInputType returned %#lx.\n", hr);
     ret = IMFMediaType_Release(media_type);
@@ -9861,18 +9805,18 @@ static void test_video_processor(void)
     static const DWORD actual_width = 96, actual_height = 96;
     const struct attribute_desc input_type_desc[] =
     {
-        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video),
-        ATTR_GUID(MF_MT_SUBTYPE, MFVideoFormat_NV12),
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video, .required = TRUE),
+        ATTR_GUID(MF_MT_SUBTYPE, MFVideoFormat_NV12, .required = TRUE),
+        ATTR_RATIO(MF_MT_FRAME_SIZE, actual_width, actual_height, .required = TRUE),
         ATTR_BLOB(MF_MT_MINIMUM_DISPLAY_APERTURE, &actual_aperture, 16),
-        ATTR_RATIO(MF_MT_FRAME_SIZE, actual_width, actual_height),
         {0},
     };
     const struct attribute_desc output_type_desc[] =
     {
-        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video),
-        ATTR_GUID(MF_MT_SUBTYPE, MFVideoFormat_RGB32),
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video, .required = TRUE),
+        ATTR_GUID(MF_MT_SUBTYPE, MFVideoFormat_RGB32, .required = TRUE),
+        ATTR_RATIO(MF_MT_FRAME_SIZE, actual_width, actual_height, .required = TRUE),
         ATTR_BLOB(MF_MT_MINIMUM_DISPLAY_APERTURE, &actual_aperture, 16),
-        ATTR_RATIO(MF_MT_FRAME_SIZE, actual_width, actual_height),
         {0},
     };

@@ -10309,43 +10253,21 @@ todo_wine {
     ok(hr == MF_E_NO_MORE_TYPES, "GetInputAvailableType returned %#lx\n", hr);
     ok(i == 22 || i == 30 || broken(i == 26) /* w1064v1507 */, "%lu input media types\n", i);

-    /* check required input media type attributes */
+    check_set_input_type_required_attributes(transform, input_type_desc);

hr = MFCreateMediaType(&media_type);
     ok(hr == S_OK, "MFCreateMediaType returned %#lx\n", hr);
-    hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
-    ok(hr == E_INVALIDARG, "SetInputType returned %#lx.\n", hr);
-    init_media_type(media_type, input_type_desc, 1);
-    hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
-    ok(hr == MF_E_INVALIDMEDIATYPE, "SetInputType returned %#lx.\n", hr);
-    init_media_type(media_type, input_type_desc, 2);
-    for (i = 2; i < ARRAY_SIZE(input_type_desc) - 1; ++i)
-    {
-        hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
-        ok(hr == MF_E_ATTRIBUTENOTFOUND, "SetInputType returned %#lx.\n", hr);
-        init_media_type(media_type, input_type_desc, i + 1);
-    }
+    init_media_type(media_type, input_type_desc, -1);
     hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
     ok(hr == S_OK, "SetInputType returned %#lx.\n", hr);
     ret = IMFMediaType_Release(media_type);
     ok(ret == 1, "Release returned %lu\n", ret);

-    /* check required output media type attributes */
+    check_set_output_type_required_attributes(transform, output_type_desc);

hr = MFCreateMediaType(&media_type);
     ok(hr == S_OK, "MFCreateMediaType returned %#lx\n", hr);
-    hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
-    ok(hr == E_INVALIDARG, "SetOutputType returned %#lx.\n", hr);
-    init_media_type(media_type, output_type_desc, 1);
-    hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
-    ok(hr == MF_E_INVALIDMEDIATYPE, "SetOutputType returned %#lx.\n", hr);
-    init_media_type(media_type, output_type_desc, 2);
-    for (i = 2; i < ARRAY_SIZE(output_type_desc) - 1; ++i)
-    {
-        hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
-        ok(hr == MF_E_ATTRIBUTENOTFOUND, "SetOutputType returned %#lx.\n", hr);
-        init_media_type(media_type, output_type_desc, i + 1);
-    }
+    init_media_type(media_type, output_type_desc, -1);
     hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
     ok(hr == S_OK, "SetOutputType returned %#lx.\n", hr);
     ret = IMFMediaType_Release(media_type);
@@ -10568,21 +10490,21 @@ static void test_mp3_decoder(void)

const struct attribute_desc input_type_desc[] =
     {
-        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio),
-        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_MP3),
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio, .required = TRUE),
+        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_MP3, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 2, .required = TRUE),
         ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 22050),
-        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 2),
         {0},
     };
     static const struct attribute_desc output_type_desc[] =
     {
-        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio),
-        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_PCM),
-        ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 88200),
-        ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 16),
-        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 2),
-        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 22050),
-        ATTR_UINT32(MF_MT_AUDIO_BLOCK_ALIGNMENT, 4),
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio, .required = TRUE),
+        ATTR_GUID(MF_MT_SUBTYPE, MFAudioFormat_PCM, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_NUM_CHANNELS, 2, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 16, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, 22050, .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_BLOCK_ALIGNMENT, 2 * (16 / 8), .required = TRUE),
+        ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 2 * (16 / 8) * 22050, .required = TRUE),
         {0},
     };

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

-    /* check required input media type attributes */
+    check_set_input_type_required_attributes(transform, input_type_desc);

hr = MFCreateMediaType(&media_type);
     ok(hr == S_OK, "MFCreateMediaType returned %#lx\n", hr);
-    hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
-    ok(hr == MF_E_ATTRIBUTENOTFOUND, "SetInputType returned %#lx.\n", hr);
-    init_media_type(media_type, input_type_desc, 1);
-    hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
-    ok(hr == MF_E_ATTRIBUTENOTFOUND, "SetInputType returned %#lx.\n", hr);
-    init_media_type(media_type, input_type_desc, 2);
-    for (i = 2; i < ARRAY_SIZE(input_type_desc) - 1; ++i)
-    {
-        hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
-        ok(hr == MF_E_INVALIDMEDIATYPE, "SetInputType returned %#lx.\n", hr);
-        init_media_type(media_type, input_type_desc, i + 1);
-    }
+    init_media_type(media_type, input_type_desc, -1);
     hr = IMFTransform_SetInputType(transform, 0, media_type, 0);
     ok(hr == S_OK, "SetInputType returned %#lx.\n", hr);
     ret = IMFMediaType_Release(media_type);
@@ -10702,22 +10613,11 @@ static void test_mp3_decoder(void)
     ok(hr == MF_E_NO_MORE_TYPES, "GetOutputAvailableType returned %#lx\n", hr);
     ok(i == ARRAY_SIZE(expect_available_outputs), "%lu output media types\n", i);

-    /* check required output media type attributes */
+    check_set_output_type_required_attributes(transform, output_type_desc);

hr = MFCreateMediaType(&media_type);
     ok(hr == S_OK, "MFCreateMediaType returned %#lx\n", hr);
-    hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
-    ok(hr == MF_E_ATTRIBUTENOTFOUND, "SetOutputType returned %#lx.\n", hr);
-    init_media_type(media_type, output_type_desc, 1);
-    hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
-    ok(hr == MF_E_ATTRIBUTENOTFOUND, "SetOutputType returned %#lx.\n", hr);
-    init_media_type(media_type, output_type_desc, 2);
-    for (i = 2; i < ARRAY_SIZE(output_type_desc) - 1; ++i)
-    {
-        hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
-        ok(hr == E_INVALIDARG, "SetOutputType returned %#lx.\n", hr);
-        init_media_type(media_type, output_type_desc, i + 1);
-    }
+    init_media_type(media_type, output_type_desc, -1);
     hr = IMFTransform_SetOutputType(transform, 0, media_type, 0);
     ok(hr == S_OK, "SetOutputType returned %#lx.\n", hr);
     ret = IMFMediaType_Release(media_type);

[PATCH 05/11] mf/tests: Factor transform required attributes checks together.

[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=122724

Your paranoid android.

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

mf:
mf.c:10256: Test failed: videoproc: Release returned 1
mf.c:10266: Test failed: videoproc: Release returned 1
mf.c:8529: Test failed: h264dec: Release returned 1
mf.c:8563: Test failed: h264dec: Release returned 1

=== debian11 (32 bit Arabic:Morocco report) ===

mf:
mf.c:10256: Test failed: videoproc: Release returned 1
mf.c:10266: Test failed: videoproc: Release returned 1
mf.c:8529: Test failed: h264dec: Release returned 1
mf.c:8563: Test failed: h264dec: Release returned 1

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

mf:
mf.c:10256: Test failed: videoproc: Release returned 1
mf.c:10266: Test failed: videoproc: Release returned 1
mf.c:8529: Test failed: h264dec: Release returned 1
mf.c:8563: Test failed: h264dec: Release returned 1

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

mf:
mf.c:10256: Test failed: videoproc: Release returned 1
mf.c:10266: Test failed: videoproc: Release returned 1
mf.c:8529: Test failed: h264dec: Release returned 1
mf.c:8563: Test failed: h264dec: Release returned 1

=== debian11 (32 bit Hebrew:Israel report) ===

mf:
mf.c:10256: Test failed: videoproc: Release returned 1
mf.c:10266: Test failed: videoproc: Release returned 1
mf.c:8529: Test failed: h264dec: Release returned 1
mf.c:8563: Test failed: h264dec: Release returned 1

=== debian11 (32 bit Hindi:India report) ===

mf:
mf.c:10256: Test failed: videoproc: Release returned 1
mf.c:10266: Test failed: videoproc: Release returned 1
mf.c:8529: Test failed: h264dec: Release returned 1
mf.c:8563: Test failed: h264dec: Release returned 1

=== debian11 (32 bit Japanese:Japan report) ===

mf:
mf.c:10256: Test failed: videoproc: Release returned 1
mf.c:10266: Test failed: videoproc: Release returned 1
mf.c:8529: Test failed: h264dec: Release returned 1
mf.c:8563: Test failed: h264dec: Release returned 1

=== debian11 (32 bit Chinese:China report) ===

mf:
mf.c:10256: Test failed: videoproc: Release returned 1
mf.c:10266: Test failed: videoproc: Release returned 1
mf.c:8529: Test failed: h264dec: Release returned 1
mf.c:8563: Test failed: h264dec: Release returned 1

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

mf:
mf.c:10256: Test failed: videoproc: Release returned 1
mf.c:10266: Test failed: videoproc: Release returned 1
mf.c:8529: Test failed: h264dec: Release returned 1
mf.c:8563: Test failed: h264dec: Release returned 1

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

mf:
mf.c:10256: Test failed: videoproc: Release returned 1
mf.c:10266: Test failed: videoproc: Release returned 1
mf.c:8529: Test failed: h264dec: Release returned 1
mf.c:8563: Test failed: h264dec: Release returned 1

[PATCH 06/11] winegstreamer: Avoid leaking attributes on video processor creation failure.

[Rémi Bernon]

From: R��mi Bernon

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

diff --git a/dlls/winegstreamer/video_processor.c b/dlls/winegstreamer/video_processor.c
index a271ca9231f..6f227bc4033 100644
--- a/dlls/winegstreamer/video_processor.c
+++ b/dlls/winegstreamer/video_processor.c
@@ -663,6 +663,10 @@ HRESULT video_processor_create(REFIID riid, void **ret)
     return S_OK;

failed:
+    if (impl->output_attributes)
+        IMFAttributes_Release(impl->output_attributes);
+    if (impl->attributes)
+        IMFAttributes_Release(impl->attributes);
     free(impl);
     return hr;
 }

[PATCH 07/11] winegstreamer: Better implement H264 MFT GetAttributes and GetOutputStreamAttributes.

[Rémi Bernon]

From: R��mi Bernon

---
 dlls/mf/tests/mf.c                |  1 -
 dlls/winegstreamer/h264_decoder.c | 53 +++++++++++++++++++++++++------
 2 files changed, 43 insertions(+), 11 deletions(-)

diff --git a/dlls/mf/tests/mf.c b/dlls/mf/tests/mf.c
index f4577c0d397..ebbb7e3f058 100644
--- a/dlls/mf/tests/mf.c
+++ b/dlls/mf/tests/mf.c
@@ -8467,7 +8467,6 @@ static void test_h264_decoder(void)
     hr = IMFAttributes_SetUINT32(attributes, &MF_LOW_LATENCY, 1);
     ok(hr == S_OK, "SetUINT32 returned %#lx\n", hr);
     ret = IMFAttributes_Release(attributes);
-    todo_wine
     ok(ret == 1, "Release returned %ld\n", ret);

/* no output type is available before an input type is set */
diff --git a/dlls/winegstreamer/h264_decoder.c b/dlls/winegstreamer/h264_decoder.c
index 43b8f83a20c..f5b54b8bf51 100644
--- a/dlls/winegstreamer/h264_decoder.c
+++ b/dlls/winegstreamer/h264_decoder.c
@@ -47,6 +47,9 @@ struct h264_decoder
 {
     IMFTransform IMFTransform_iface;
     LONG refcount;
+
+    IMFAttributes *attributes;
+    IMFAttributes *output_attributes;
     IMFMediaType *input_type;
     IMFMediaType *output_type;

@@ -238,6 +241,10 @@ static ULONG WINAPI transform_Release(IMFTransform *iface)
             IMFMediaType_Release(decoder->input_type);
         if (decoder->output_type)
             IMFMediaType_Release(decoder->output_type);
+        if (decoder->output_attributes)
+            IMFAttributes_Release(decoder->output_attributes);
+        if (decoder->attributes)
+            IMFAttributes_Release(decoder->attributes);

wg_sample_queue_destroy(decoder->wg_sample_queue);
         free(decoder);
@@ -305,8 +312,15 @@ 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);
-    return MFCreateAttributes(attributes, 0);
+    struct h264_decoder *decoder = impl_from_IMFTransform(iface);
+
+    FIXME("iface %p, attributes %p semi-stub!\n", iface, attributes);
+
+    if (!attributes)
+        return E_POINTER;
+
+    IMFAttributes_AddRef((*attributes = decoder->attributes));
+    return S_OK;
 }

static HRESULT WINAPI transform_GetInputStreamAttributes(IMFTransform *iface, DWORD id, IMFAttributes **attributes)
@@ -315,11 +329,19 @@ static HRESULT WINAPI transform_GetInputStreamAttributes(IMFTransform *iface, DW
     return E_NOTIMPL;
 }

-static HRESULT WINAPI transform_GetOutputStreamAttributes(IMFTransform *iface, DWORD id,
-        IMFAttributes **attributes)
+static HRESULT WINAPI transform_GetOutputStreamAttributes(IMFTransform *iface, DWORD id, IMFAttributes **attributes)
 {
-    FIXME("iface %p, id %#lx, attributes %p stub!\n", iface, id, attributes);
-    return E_NOTIMPL;
+    struct h264_decoder *decoder = impl_from_IMFTransform(iface);
+
+    FIXME("iface %p, id %#lx, attributes %p semi-stub!\n", iface, id, attributes);
+
+    if (!attributes)
+        return E_POINTER;
+    if (id)
+        return MF_E_INVALIDSTREAMNUMBER;
+
+    IMFAttributes_AddRef((*attributes = decoder->output_attributes));
+    return S_OK;
 }

static HRESULT WINAPI transform_DeleteInputStream(IMFTransform *iface, DWORD id)
@@ -704,13 +726,24 @@ HRESULT h264_decoder_create(REFIID riid, void **ret)
     decoder->wg_format.u.video.fps_n = 30000;
     decoder->wg_format.u.video.fps_d = 1001;

+    if (FAILED(hr = MFCreateAttributes(&decoder->attributes, 16)))
+        goto failed;
+    if (FAILED(hr = IMFAttributes_SetUINT32(decoder->attributes, &MF_LOW_LATENCY, 0)))
+        goto failed;
+    if (FAILED(hr = MFCreateAttributes(&decoder->output_attributes, 0)))
+        goto failed;
     if (FAILED(hr = wg_sample_queue_create(&decoder->wg_sample_queue)))
-    {
-        free(decoder);
-        return hr;
-    }
+        goto failed;

*ret = &decoder->IMFTransform_iface;
     TRACE("Created decoder %p\n", *ret);
     return S_OK;
+
+failed:
+    if (decoder->output_attributes)
+        IMFAttributes_Release(decoder->output_attributes);
+    if (decoder->attributes)
+        IMFAttributes_Release(decoder->attributes);
+    free(decoder);
+    return hr;
 }

[PATCH 07/11] winegstreamer: Better implement H264 MFT GetAttributes and GetOutputStreamAttributes.

[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=122726

Your paranoid android.

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

mf:
mf.c:10255: Test failed: videoproc: Release returned 1
mf.c:10265: Test failed: videoproc: Release returned 1
mf.c:8528: Test failed: h264dec: Release returned 1
mf.c:8562: Test failed: h264dec: Release returned 1

=== debian11 (32 bit Arabic:Morocco report) ===

mf:
mf.c:10255: Test failed: videoproc: Release returned 1
mf.c:10265: Test failed: videoproc: Release returned 1
mf.c:8528: Test failed: h264dec: Release returned 1
mf.c:8562: Test failed: h264dec: Release returned 1

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

mf:
mf.c:10255: Test failed: videoproc: Release returned 1
mf.c:10265: Test failed: videoproc: Release returned 1
mf.c:8528: Test failed: h264dec: Release returned 1
mf.c:8562: Test failed: h264dec: Release returned 1

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

mf:
mf.c:10255: Test failed: videoproc: Release returned 1
mf.c:10265: Test failed: videoproc: Release returned 1
mf.c:8528: Test failed: h264dec: Release returned 1
mf.c:8562: Test failed: h264dec: Release returned 1

=== debian11 (32 bit Hebrew:Israel report) ===

mf:
mf.c:10255: Test failed: videoproc: Release returned 1
mf.c:10265: Test failed: videoproc: Release returned 1
mf.c:8528: Test failed: h264dec: Release returned 1
mf.c:8562: Test failed: h264dec: Release returned 1

=== debian11 (32 bit Hindi:India report) ===

mf:
mf.c:10255: Test failed: videoproc: Release returned 1
mf.c:10265: Test failed: videoproc: Release returned 1
mf.c:8528: Test failed: h264dec: Release returned 1
mf.c:8562: Test failed: h264dec: Release returned 1

=== debian11 (32 bit Japanese:Japan report) ===

mf:
mf.c:10255: Test failed: videoproc: Release returned 1
mf.c:10265: Test failed: videoproc: Release returned 1
mf.c:8528: Test failed: h264dec: Release returned 1
mf.c:8562: Test failed: h264dec: Release returned 1

=== debian11 (32 bit Chinese:China report) ===

mf:
mf.c:10255: Test failed: videoproc: Release returned 1
mf.c:10265: Test failed: videoproc: Release returned 1
mf.c:8528: Test failed: h264dec: Release returned 1
mf.c:8562: Test failed: h264dec: Release returned 1

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

mf:
mf.c:10255: Test failed: videoproc: Release returned 1
mf.c:10265: Test failed: videoproc: Release returned 1
mf.c:8528: Test failed: h264dec: Release returned 1
mf.c:8562: Test failed: h264dec: Release returned 1

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

mf:
mf.c:10255: Test failed: videoproc: Release returned 1
mf.c:10265: Test failed: videoproc: Release returned 1
mf.c:8528: Test failed: h264dec: Release returned 1
mf.c:8562: Test failed: h264dec: Release returned 1

[PATCH 08/11] mf: Check output pointers in sample copier GetStreamLimits / GetStreamCount / GetAttributes.

[Rémi Bernon]

From: R��mi Bernon

---
 dlls/mf/copier.c | 18 +++++++++++++++---
 1 file changed, 15 insertions(+), 3 deletions(-)

diff --git a/dlls/mf/copier.c b/dlls/mf/copier.c
index ab995fb98db..14cb391e17e 100644
--- a/dlls/mf/copier.c
+++ b/dlls/mf/copier.c
@@ -102,7 +102,14 @@ static HRESULT WINAPI sample_copier_transform_GetStreamLimits(IMFTransform *ifac
 {
     TRACE("%p, %p, %p, %p, %p.\n", iface, input_minimum, input_maximum, output_minimum, output_maximum);

-    *input_minimum = *input_maximum = *output_minimum = *output_maximum = 1;
+    if (input_minimum)
+        *input_minimum = 1;
+    if (input_maximum)
+        *input_maximum = 1;
+    if (output_minimum)
+        *output_minimum = 1;
+    if (output_maximum)
+        *output_maximum = 1;

return S_OK;
 }
@@ -111,8 +118,10 @@ static HRESULT WINAPI sample_copier_transform_GetStreamCount(IMFTransform *iface
 {
     TRACE("%p, %p, %p.\n", iface, inputs, outputs);

-    *inputs = 1;
-    *outputs = 1;
+    if (inputs)
+        *inputs = 1;
+    if (outputs)
+        *outputs = 1;

return S_OK;
 }
@@ -162,6 +171,9 @@ static HRESULT WINAPI sample_copier_transform_GetAttributes(IMFTransform *iface,

TRACE("%p, %p.\n", iface, attributes);

+    if (!attributes)
+        return E_POINTER;
+
     *attributes = transform->attributes;
     IMFAttributes_AddRef(*attributes);

[PATCH 08/11] mf: Check output pointers in sample copier GetStreamLimits / GetStreamCount / GetAttributes.

[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=122727

Your paranoid android.

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

mf:
mf.c:10255: Test failed: videoproc: Release returned 1
mf.c:10265: Test failed: videoproc: Release returned 1
mf.c:8528: Test failed: h264dec: Release returned 1
mf.c:8562: Test failed: h264dec: Release returned 1

=== debian11 (32 bit Chinese:China report) ===

mf:
mf.c:10255: Test failed: videoproc: Release returned 1
mf.c:10265: Test failed: videoproc: Release returned 1
mf.c:8528: Test failed: h264dec: Release returned 1
mf.c:8562: Test failed: h264dec: Release returned 1

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

mf:
mf.c:10255: Test failed: videoproc: Release returned 1
mf.c:10265: Test failed: videoproc: Release returned 1
mf.c:8528: Test failed: h264dec: Release returned 1
mf.c:8562: Test failed: h264dec: Release returned 1

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

mf:
mf.c:10255: Test failed: videoproc: Release returned 1
mf.c:10265: Test failed: videoproc: Release returned 1
mf.c:8528: Test failed: h264dec: Release returned 1
mf.c:8562: Test failed: h264dec: Release returned 1

[PATCH 09/11] winegstreamer: Check output pointers in MFT GetStreamLimits / GetStreamCount / GetAttributes.

[Rémi Bernon]

From: R��mi Bernon

---
 dlls/mf/tests/mf.c                   |  3 ---
 dlls/winegstreamer/color_convert.c   | 18 ++++++++++++++++--
 dlls/winegstreamer/h264_decoder.c    | 24 ++++++++++++++++++++----
 dlls/winegstreamer/resampler.c       | 18 ++++++++++++++++--
 dlls/winegstreamer/video_processor.c | 26 ++++++++++++++++++++++++--
 dlls/winegstreamer/wma_decoder.c     | 24 ++++++++++++++++++++----
 6 files changed, 96 insertions(+), 17 deletions(-)

diff --git a/dlls/mf/tests/mf.c b/dlls/mf/tests/mf.c
index ebbb7e3f058..c748374fabc 100644
--- a/dlls/mf/tests/mf.c
+++ b/dlls/mf/tests/mf.c
@@ -8611,11 +8611,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/color_convert.c b/dlls/winegstreamer/color_convert.c
index b47832b2c30..5884e1db355 100644
--- a/dlls/winegstreamer/color_convert.c
+++ b/dlls/winegstreamer/color_convert.c
@@ -206,14 +206,28 @@ static HRESULT WINAPI transform_GetStreamLimits(IMFTransform *iface, DWORD *inpu
 {
     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);
-    *input_minimum = *input_maximum = *output_minimum = *output_maximum = 1;
+
+    if (input_minimum)
+        *input_minimum = 1;
+    if (input_maximum)
+        *input_maximum = 1;
+    if (output_minimum)
+        *output_minimum = 1;
+    if (output_maximum)
+        *output_maximum = 1;
+
     return S_OK;
 }

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

diff --git a/dlls/winegstreamer/h264_decoder.c b/dlls/winegstreamer/h264_decoder.c
index f5b54b8bf51..e9adbaf5a6f 100644
--- a/dlls/winegstreamer/h264_decoder.c
+++ b/dlls/winegstreamer/h264_decoder.c
@@ -256,15 +256,31 @@ 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;
+
+    if (input_minimum)
+        *input_minimum = 1;
+    if (input_maximum)
+        *input_maximum = 1;
+    if (output_minimum)
+        *output_minimum = 1;
+    if (output_maximum)
+        *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);
+
+    if (inputs)
+        *inputs = 1;
+    if (outputs)
+        *outputs = 1;
+
+    return S_OK;
 }

static HRESULT WINAPI transform_GetStreamIDs(IMFTransform *iface, DWORD input_size,
diff --git a/dlls/winegstreamer/resampler.c b/dlls/winegstreamer/resampler.c
index 65a29d96794..32bcb69b86d 100644
--- a/dlls/winegstreamer/resampler.c
+++ b/dlls/winegstreamer/resampler.c
@@ -169,14 +169,28 @@ static HRESULT WINAPI transform_GetStreamLimits(IMFTransform *iface, DWORD *inpu
 {
     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);
-    *input_minimum = *input_maximum = *output_minimum = *output_maximum = 1;
+
+    if (input_minimum)
+        *input_minimum = 1;
+    if (input_maximum)
+        *input_maximum = 1;
+    if (output_minimum)
+        *output_minimum = 1;
+    if (output_maximum)
+        *output_maximum = 1;
+
     return S_OK;
 }

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

diff --git a/dlls/winegstreamer/video_processor.c b/dlls/winegstreamer/video_processor.c
index 6f227bc4033..91999c6aaf2 100644
--- a/dlls/winegstreamer/video_processor.c
+++ b/dlls/winegstreamer/video_processor.c
@@ -170,14 +170,28 @@ static HRESULT WINAPI video_processor_GetStreamLimits(IMFTransform *iface, DWORD
 {
     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);
-    *input_minimum = *input_maximum = *output_minimum = *output_maximum = 1;
+
+    if (input_minimum)
+        *input_minimum = 1;
+    if (input_maximum)
+        *input_maximum = 1;
+    if (output_minimum)
+        *output_minimum = 1;
+    if (output_maximum)
+        *output_maximum = 1;
+
     return S_OK;
 }

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

@@ -249,6 +263,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 +282,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;
 }
diff --git a/dlls/winegstreamer/wma_decoder.c b/dlls/winegstreamer/wma_decoder.c
index e2a7a770826..f490aef3e61 100644
--- a/dlls/winegstreamer/wma_decoder.c
+++ b/dlls/winegstreamer/wma_decoder.c
@@ -177,15 +177,31 @@ 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;
+
+    if (input_minimum)
+        *input_minimum = 1;
+    if (input_maximum)
+        *input_maximum = 1;
+    if (output_minimum)
+        *output_minimum = 1;
+    if (output_maximum)
+        *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);
+
+    if (inputs)
+        *inputs = 1;
+    if (outputs)
+        *outputs = 1;
+
+    return S_OK;
 }

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

[PATCH 09/11] winegstreamer: Check output pointers in MFT GetStreamLimits / GetStreamCount / GetAttributes.

[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=122728

Your paranoid android.

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

mf:
mf.c:10252: Test failed: videoproc: Release returned 1
mf.c:10262: Test failed: videoproc: Release returned 1
mf.c:8528: Test failed: h264dec: Release returned 1
mf.c:8562: Test failed: h264dec: Release returned 1

=== debian11 (32 bit Arabic:Morocco report) ===

mf:
mf.c:10252: Test failed: videoproc: Release returned 1
mf.c:10262: Test failed: videoproc: Release returned 1
mf.c:8528: Test failed: h264dec: Release returned 1
mf.c:8562: Test failed: h264dec: Release returned 1

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

mf:
mf.c:10252: Test failed: videoproc: Release returned 1
mf.c:10262: Test failed: videoproc: Release returned 1
mf.c:8528: Test failed: h264dec: Release returned 1
mf.c:8562: Test failed: h264dec: Release returned 1

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

mf:
mf.c:10252: Test failed: videoproc: Release returned 1
mf.c:10262: Test failed: videoproc: Release returned 1
mf.c:8528: Test failed: h264dec: Release returned 1
mf.c:8562: Test failed: h264dec: Release returned 1

=== debian11 (32 bit Hebrew:Israel report) ===

mf:
mf.c:10252: Test failed: videoproc: Release returned 1
mf.c:10262: Test failed: videoproc: Release returned 1
mf.c:8528: Test failed: h264dec: Release returned 1
mf.c:8562: Test failed: h264dec: Release returned 1

=== debian11 (32 bit Hindi:India report) ===

mf:
mf.c:10252: Test failed: videoproc: Release returned 1
mf.c:10262: Test failed: videoproc: Release returned 1
mf.c:8528: Test failed: h264dec: Release returned 1
mf.c:8562: Test failed: h264dec: Release returned 1

=== debian11 (32 bit Japanese:Japan report) ===

mf:
mf.c:10252: Test failed: videoproc: Release returned 1
mf.c:10262: Test failed: videoproc: Release returned 1
mf.c:8528: Test failed: h264dec: Release returned 1
mf.c:8562: Test failed: h264dec: Release returned 1

=== debian11 (32 bit Chinese:China report) ===

mf:
mf.c:10252: Test failed: videoproc: Release returned 1
mf.c:10262: Test failed: videoproc: Release returned 1
mf.c:8528: Test failed: h264dec: Release returned 1
mf.c:8562: Test failed: h264dec: Release returned 1

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

mf:
mf.c:10252: Test failed: videoproc: Release returned 1
mf.c:10262: Test failed: videoproc: Release returned 1
mf.c:8528: Test failed: h264dec: Release returned 1
mf.c:8562: Test failed: h264dec: Release returned 1

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

mf:
mf.c:10252: Test failed: videoproc: Release returned 1
mf.c:10262: Test failed: videoproc: Release returned 1
mf.c:8528: Test failed: h264dec: Release returned 1
mf.c:8562: Test failed: h264dec: Release returned 1

[PATCH 10/11] 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 5884e1db355..a9332d6e21e 100644
--- a/dlls/winegstreamer/color_convert.c
+++ b/dlls/winegstreamer/color_convert.c
@@ -234,7 +234,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;
 }
@@ -295,31 +295,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;
 }

@@ -535,7 +535,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 e9adbaf5a6f..c4ee3c814ac 100644
--- a/dlls/winegstreamer/h264_decoder.c
+++ b/dlls/winegstreamer/h264_decoder.c
@@ -283,10 +283,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;
 }
@@ -341,7 +341,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;
 }

@@ -362,13 +362,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;
 }

@@ -578,7 +578,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 32bcb69b86d..1c17590b44c 100644
--- a/dlls/winegstreamer/resampler.c
+++ b/dlls/winegstreamer/resampler.c
@@ -197,7 +197,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;
 }
@@ -248,31 +248,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;
 }

@@ -504,7 +504,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 91999c6aaf2..a20221c4807 100644
--- a/dlls/winegstreamer/video_processor.c
+++ b/dlls/winegstreamer/video_processor.c
@@ -198,7 +198,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;
 }
@@ -261,7 +261,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;
@@ -272,7 +272,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;
 }

@@ -280,7 +280,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;
@@ -293,13 +293,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;
 }

@@ -520,7 +520,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 f490aef3e61..b72187f2c1c 100644
--- a/dlls/winegstreamer/wma_decoder.c
+++ b/dlls/winegstreamer/wma_decoder.c
@@ -207,7 +207,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;
 }
@@ -260,31 +260,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;
 }

@@ -521,8 +521,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 11/11] mf/tests: Test miscellaneous and optional IMFTransform methods.

[Rémi Bernon]

From: R��mi Bernon

---
 dlls/mf/tests/mf.c | 307 +++++++++++++++++++++++++--------------------
 1 file changed, 173 insertions(+), 134 deletions(-)

diff --git a/dlls/mf/tests/mf.c b/dlls/mf/tests/mf.c
index c748374fabc..dd6b64b7616 100644
--- a/dlls/mf/tests/mf.c
+++ b/dlls/mf/tests/mf.c
@@ -306,6 +306,112 @@ static BOOL create_transform(GUID category, MFT_REGISTER_TYPE_INFO *input_type,
     return TRUE;
 }

+static void check_transform_info(IMFTransform *transform, const struct attribute_desc *attributes_desc, BOOL output_attributes)
+{
+    DWORD in_id, out_id, in_count, out_count, in_min, in_max, out_min, out_max;
+    IMFAttributes *attributes, *tmp_attributes;
+    PROPVARIANT propvar = {.vt = VT_EMPTY};
+    IMFMediaEvent *event;
+    UINT32 count;
+    HRESULT hr;
+    ULONG ref;
+
+    in_min = in_max = out_min = out_max = 0xdeadbeef;
+    hr = IMFTransform_GetStreamLimits(transform, &in_min, NULL, NULL, NULL);
+    ok(hr == S_OK, "GetStreamLimits returned %#lx\n", hr);
+    ok(in_min == 1, "got input_min %lu\n", in_min);
+    hr = IMFTransform_GetStreamLimits(transform, NULL, &in_max, &out_min, &out_max);
+    ok(hr == S_OK, "GetStreamLimits returned %#lx\n", hr);
+    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, NULL);
+    ok(hr == S_OK || hr == E_POINTER, "GetStreamCount returned %#lx\n", hr);
+    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);
+
+    hr = IMFTransform_GetAttributes(transform, &attributes);
+    if (!attributes_desc)
+        ok(hr == E_NOTIMPL, "GetAttributes returned %#lx\n", hr);
+    else
+    {
+        ok(hr == S_OK, "GetAttributes returned %#lx\n", hr);
+        check_attributes(attributes, attributes_desc, -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);
+    if (!output_attributes)
+        ok(hr == E_NOTIMPL || broken(hr == MF_E_UNSUPPORTED_REPRESENTATION) /* w7 */,
+                "GetOutputStreamAttributes returned %#lx\n", hr);
+    else
+    {
+        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) /* w7 */,
+            "GetInputStreamAttributes returned %#lx\n", hr);
+}
+
 static void init_media_type(IMFMediaType *mediatype, const struct attribute_desc *desc, ULONG limit)
 {
     HRESULT hr;
@@ -6278,18 +6384,19 @@ static BOOL is_sample_copier_available_type(IMFMediaType *type)

static void test_sample_copier(void)
 {
-    IMFAttributes *attributes, *attributes2;
-    DWORD in_min, in_max, out_min, out_max;
+    static const struct attribute_desc expect_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;
-    DWORD input_count, output_count;
     MFT_OUTPUT_DATA_BUFFER buffer;
     IMFMediaBuffer *media_buffer;
     IMFTransform *copier;
     DWORD flags, status;
-    UINT32 value, count;
     HRESULT hr;
     LONG ref;

@@ -6304,51 +6411,12 @@ 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);
+    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_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);
-
-    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_transform_info(copier, expect_attributes, FALSE);

/* Available types. */
     hr = IMFTransform_GetInputAvailableType(copier, 0, 0, &mediatype);
@@ -7232,6 +7300,10 @@ 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_transform_info(transform, NULL, FALSE);

check_set_input_type_required_attributes(transform, input_type_desc);

@@ -7367,7 +7439,12 @@ static void test_aac_decoder(void)
             ATTR_UINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 2 * 44100),
         },
     };
-
+    const struct attribute_desc expect_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),
@@ -7414,6 +7491,10 @@ 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_transform_info(transform, expect_attributes, FALSE);

/* check default media types */

@@ -7619,6 +7700,8 @@ static void test_wma_encoder(void)
     check_interface(transform, &IID_IPropertyStore, TRUE);
     check_interface(transform, &IID_IPropertyBag, TRUE);

+    check_transform_info(transform, NULL, FALSE);
+
     check_set_input_type_required_attributes(transform, input_type_desc);

hr = MFCreateMediaType(&media_type);
@@ -7885,6 +7968,8 @@ static void test_wma_decoder(void)
     check_interface(transform, &IID_IPropertyStore, TRUE);
     check_interface(transform, &IID_IPropertyBag, TRUE);

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

hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
@@ -8255,6 +8340,15 @@ static void test_h264_decoder(void)
             ATTR_GUID(MF_MT_SUBTYPE, MFVideoFormat_H264_ES),
         },
     };
+    static const struct attribute_desc expect_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[] =
     {
@@ -8432,7 +8526,6 @@ static void test_h264_decoder(void)
     MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Video, MFVideoFormat_NV12};
     const BYTE *h264_encoded_data, *nv12_frame_data, *i420_frame_data;
     ULONG h264_encoded_data_len, nv12_frame_len, i420_frame_len;
-    DWORD input_id, output_id, input_count, output_count;
     MFT_OUTPUT_STREAM_INFO output_info;
     MFT_INPUT_STREAM_INFO input_info;
     MFT_OUTPUT_DATA_BUFFER output;
@@ -8462,12 +8555,18 @@ static void test_h264_decoder(void)
             &transform, &CLSID_MSH264DecoderMFT, &class_id))
         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_transform_info(transform, expect_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 */

@@ -8609,14 +8708,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);
-
     resource = FindResourceW(NULL, L"h264data.bin", (const WCHAR *)RT_RCDATA);
     ok(resource != 0, "FindResourceW failed, error %lu\n", GetLastError());
     h264_encoded_data = LockResource(LoadResource(GetModuleHandleW(NULL), resource));
@@ -9059,6 +9150,8 @@ static void test_audio_convert(void)
     check_interface(transform, &IID_IPropertyBag, TRUE);
     /* check_interface(transform, &IID_IWMResamplerProps, TRUE); */

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

hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
@@ -9495,9 +9588,13 @@ 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_transform_info(transform, NULL, FALSE);
+
     /* check default media types */

hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info);
@@ -9796,6 +9893,12 @@ static void test_video_processor(void)
     {
         ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video),
     };
+    static const struct attribute_desc expect_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;
@@ -9818,12 +9921,9 @@ static void test_video_processor(void)

MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Video, MFVideoFormat_NV12};
     MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Video, MFVideoFormat_I420};
-    DWORD input_count, output_count, input_id, output_id, flags;
-    DWORD input_min, input_max, output_min, output_max, i, j, k;
     ULONG nv12frame_data_len, rgb32_data_len;
-    IMFMediaType *media_type, *media_type2;
-    IMFAttributes *attributes, *attributes2;
     const BYTE *nv12frame_data, *rgb32_data;
+    IMFMediaType *media_type, *media_type2;
     MFT_OUTPUT_DATA_BUFFER output_buffer;
     const GUID *expect_available_inputs;
     MFT_OUTPUT_STREAM_INFO output_info;
@@ -9834,9 +9934,8 @@ static void test_video_processor(void)
     LONGLONG time, duration;
     IMFTransform *transform;
     IMFMediaBuffer *buffer;
-    IMFMediaEvent *event;
     DWORD length, status;
-    unsigned int value;
+    DWORD flags, i, j, k;
     HANDLE output_file;
     HRSRC resource;
     BYTE *ptr, tmp;
@@ -9865,63 +9964,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);

@@ -9940,22 +9988,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)
     {
@@ -10146,7 +10178,12 @@ 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_transform_info(transform, expect_attributes, TRUE);

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

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

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

[PATCH 11/11] 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=122730

Your paranoid android.

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

mf:
mf.c:10289: Test failed: videoproc: Release returned 1
mf.c:10299: Test failed: videoproc: Release returned 1
mf.c:8627: Test failed: h264dec: Release returned 1
mf.c:8661: Test failed: h264dec: Release returned 1

=== debian11 (32 bit Arabic:Morocco report) ===

mf:
mf.c:10289: Test failed: videoproc: Release returned 1
mf.c:10299: Test failed: videoproc: Release returned 1
mf.c:8627: Test failed: h264dec: Release returned 1
mf.c:8661: Test failed: h264dec: Release returned 1

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

mf:
mf.c:10289: Test failed: videoproc: Release returned 1
mf.c:10299: Test failed: videoproc: Release returned 1
mf.c:8627: Test failed: h264dec: Release returned 1
mf.c:8661: Test failed: h264dec: Release returned 1

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

mf:
mf.c:10289: Test failed: videoproc: Release returned 1
mf.c:10299: Test failed: videoproc: Release returned 1
mf.c:8627: Test failed: h264dec: Release returned 1
mf.c:8661: Test failed: h264dec: Release returned 1

=== debian11 (32 bit Hebrew:Israel report) ===

mf:
mf.c:10289: Test failed: videoproc: Release returned 1
mf.c:10299: Test failed: videoproc: Release returned 1
mf.c:8627: Test failed: h264dec: Release returned 1
mf.c:8661: Test failed: h264dec: Release returned 1

=== debian11 (32 bit Hindi:India report) ===

mf:
mf.c:10289: Test failed: videoproc: Release returned 1
mf.c:10299: Test failed: videoproc: Release returned 1
mf.c:8627: Test failed: h264dec: Release returned 1
mf.c:8661: Test failed: h264dec: Release returned 1

=== debian11 (32 bit Japanese:Japan report) ===

mf:
mf.c:10289: Test failed: videoproc: Release returned 1
mf.c:10299: Test failed: videoproc: Release returned 1
mf.c:8627: Test failed: h264dec: Release returned 1
mf.c:8661: Test failed: h264dec: Release returned 1

=== debian11 (32 bit Chinese:China report) ===

mf:
mf.c:10289: Test failed: videoproc: Release returned 1
mf.c:10299: Test failed: videoproc: Release returned 1
mf.c:8627: Test failed: h264dec: Release returned 1
mf.c:8661: Test failed: h264dec: Release returned 1

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

mf:
mf.c:10289: Test failed: videoproc: Release returned 1
mf.c:10299: Test failed: videoproc: Release returned 1
mf.c:8627: Test failed: h264dec: Release returned 1
mf.c:8661: Test failed: h264dec: Release returned 1

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

mf:
mf.c:10289: Test failed: videoproc: Release returned 1
mf.c:10299: Test failed: videoproc: Release returned 1
mf.c:8627: Test failed: h264dec: Release returned 1
mf.c:8661: Test failed: h264dec: Release returned 1

[Rémi Bernon (＠rbernon)]

Ah sorry, this needs the MFT_SET_TYPE_TEST_ONLY flag support from https://gitlab.winehq.org/wine/wine/-/merge_requests/789. So it'll need to go after.