[PATCH v2 0/10] MR887: mf/tests: Improve MF transform output checks and dumps.

[Rémi Bernon (＠rbernon)]

--
  v2: mf/tests: Dump image samples with a BMP header and RGB data.
      mf/tests: Rename transform frame dumps to BMP.
      mf/tests: Check all produced output IMFSample at the same time.
      mf/tests: Factor IMFSample attributes checks in check_mf_sample.
      mf/tests: Factor IMFSample checks in a check_mf_sample helper.
      mf/tests: Introduce a new dump_mf_sample helper.
      mf/tests: Introduce a new load_resource helper.
      mf/tests: Factor IMFTransform_ProcessOutput checks together.
      mf/tests: Use separate variables for input / output samples.
      mf: Validate sample copier ProcessOutput count parameter.

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

[PATCH v2 01/10] mf: Validate sample copier ProcessOutput count parameter.

[Rémi Bernon]

From: Rémi Bernon

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

diff --git a/dlls/mf/copier.c b/dlls/mf/copier.c
index ab995fb98db..816bed6388e 100644
--- a/dlls/mf/copier.c
+++ b/dlls/mf/copier.c
@@ -494,6 +494,9 @@ static HRESULT WINAPI sample_copier_transform_ProcessOutput(IMFTransform *iface,

TRACE("%p, %#lx, %lu, %p, %p.\n", iface, flags, count, buffers, status);

+    if (count != 1)
+        return E_INVALIDARG;
+
     EnterCriticalSection(&transform->cs);
     if (!(transform->flags & SAMPLE_COPIER_OUTPUT_TYPE_SET))
         hr = MF_E_TRANSFORM_TYPE_NOT_SET;

[PATCH v2 02/10] mf/tests: Use separate variables for input / output samples.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/mf/tests/transform.c | 469 +++++++++++++++++++-------------------
 1 file changed, 230 insertions(+), 239 deletions(-)

diff --git a/dlls/mf/tests/transform.c b/dlls/mf/tests/transform.c
index c5dbea290bc..5c9e3a24f79 100644
--- a/dlls/mf/tests/transform.c
+++ b/dlls/mf/tests/transform.c
@@ -1424,6 +1424,7 @@ static void test_wma_encoder(void)

MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Audio, MFAudioFormat_WMAudioV8};
     MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Audio, MFAudioFormat_Float};
+    IMFSample *input_sample, *output_sample;
     ULONG audio_data_len, wmaenc_data_len;
     const BYTE *audio_data, *wmaenc_data;
     MFT_OUTPUT_STREAM_INFO output_info;
@@ -1434,7 +1435,6 @@ static void test_wma_encoder(void)
     IMFTransform *transform;
     DWORD status, length;
     HANDLE output_file;
-    IMFSample *sample;
     HRSRC resource;
     ULONG i, ret;
     HRESULT hr;
@@ -1502,24 +1502,23 @@ static void test_wma_encoder(void)
     audio_data_len = SizeofResource(GetModuleHandleW(NULL), resource);
     ok(audio_data_len == 179928, "got length %lu\n", audio_data_len);

-    sample = create_sample(audio_data, audio_data_len);
-    hr = IMFSample_SetSampleTime(sample, 0);
+    input_sample = create_sample(audio_data, audio_data_len);
+    hr = IMFSample_SetSampleTime(input_sample, 0);
     ok(hr == S_OK, "SetSampleTime returned %#lx\n", hr);
-    hr = IMFSample_SetSampleDuration(sample, 10000000);
+    hr = IMFSample_SetSampleDuration(input_sample, 10000000);
     ok(hr == S_OK, "SetSampleDuration returned %#lx\n", hr);
-    hr = IMFTransform_ProcessInput(transform, 0, sample, 0);
+    hr = IMFTransform_ProcessInput(transform, 0, input_sample, 0);
     ok(hr == S_OK, "ProcessInput returned %#lx\n", hr);
     hr = IMFTransform_ProcessMessage(transform, MFT_MESSAGE_COMMAND_DRAIN, 0);
     ok(hr == S_OK, "ProcessMessage returned %#lx\n", hr);
-    hr = IMFTransform_ProcessInput(transform, 0, sample, 0);
+    hr = IMFTransform_ProcessInput(transform, 0, input_sample, 0);
     ok(hr == MF_E_NOTACCEPTING, "ProcessInput returned %#lx\n", hr);
-    ref = IMFSample_Release(sample);
+    ref = IMFSample_Release(input_sample);
     ok(ref <= 1, "Release returned %ld\n", ref);

status = 0xdeadbeef;
-    sample = create_sample(NULL, output_info.cbSize);
     memset(&output, 0, sizeof(output));
-    output.pSample = sample;
+    output.pSample = output_sample = create_sample(NULL, output_info.cbSize);

resource = FindResourceW(NULL, L"wmaencdata.bin", (const WCHAR *)RT_RCDATA);
     ok(resource != 0, "FindResourceW failed, error %lu\n", GetLastError());
@@ -1538,16 +1537,16 @@ static void test_wma_encoder(void)
     {
         winetest_push_context("%lu", i);
         ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
-        ok(output.pSample == sample, "got pSample %p\n", output.pSample);
+        ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
         ok(output.dwStatus == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE ||
                 broken(output.dwStatus == (MFT_OUTPUT_DATA_BUFFER_INCOMPLETE|7)) /* win7 */,
                 "got dwStatus %#lx\n", output.dwStatus);
         ok(status == 0, "got status %#lx\n", status);
-        hr = IMFSample_GetTotalLength(sample, &length);
+        hr = IMFSample_GetTotalLength(output_sample, &length);
         ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
         ok(length == wmaenc_block_size, "got length %lu\n", length);
         ok(wmaenc_data_len > i * wmaenc_block_size, "got %lu blocks\n", i);
-        check_sample(sample, wmaenc_data + i * wmaenc_block_size, output_file);
+        check_sample(output_sample, wmaenc_data + i * wmaenc_block_size, output_file);
         winetest_pop_context();
         i++;
     }
@@ -1555,22 +1554,21 @@ static void test_wma_encoder(void)
     trace("created %s\n", debugstr_w(output_path));
     CloseHandle(output_file);

-    ret = IMFSample_Release(sample);
+    ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

status = 0xdeadbeef;
-    sample = create_sample(NULL, output_info.cbSize);
     memset(&output, 0, sizeof(output));
-    output.pSample = sample;
+    output.pSample = output_sample = create_sample(NULL, output_info.cbSize);
     hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
     ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#lx\n", hr);
-    ok(output.pSample == sample, "got pSample %p\n", output.pSample);
+    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
     ok(output.dwStatus == 0, "got dwStatus %#lx\n", output.dwStatus);
     ok(status == 0, "got status %#lx\n", status);
-    hr = IMFSample_GetTotalLength(sample, &length);
+    hr = IMFSample_GetTotalLength(output_sample, &length);
     ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
     ok(length == 0, "got length %lu\n", length);
-    ret = IMFSample_Release(sample);
+    ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

ret = IMFTransform_Release(transform);
@@ -1696,6 +1694,7 @@ static void test_wma_decoder(void)
     MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Audio, MFAudioFormat_WMAudioV8};
     MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Audio, MFAudioFormat_Float};
     IUnknown *unknown, *tmp_unknown, outer = {&test_unk_vtbl};
+    IMFSample *input_sample, *output_sample;
     ULONG wmadec_data_len, wmaenc_data_len;
     const BYTE *wmadec_data, *wmaenc_data;
     MFT_OUTPUT_STREAM_INFO output_info;
@@ -1710,7 +1709,6 @@ static void test_wma_decoder(void)
     IMFTransform *transform;
     LONGLONG time, duration;
     HANDLE output_file;
-    IMFSample *sample;
     ULONG i, ret, ref;
     HRSRC resource;
     UINT32 value;
@@ -1834,22 +1832,22 @@ static void test_wma_decoder(void)
     wmaenc_data_len = SizeofResource(GetModuleHandleW(NULL), resource);
     ok(wmaenc_data_len % wmaenc_block_size == 0, "got length %lu\n", wmaenc_data_len);

-    sample = create_sample(wmaenc_data, wmaenc_block_size / 2);
-    hr = IMFTransform_ProcessInput(transform, 0, sample, 0);
+    input_sample = create_sample(wmaenc_data, wmaenc_block_size / 2);
+    hr = IMFTransform_ProcessInput(transform, 0, input_sample, 0);
     ok(hr == S_OK, "ProcessInput returned %#lx\n", hr);
-    ret = IMFSample_Release(sample);
+    ret = IMFSample_Release(input_sample);
     ok(ret == 0, "Release returned %lu\n", ret);
-    sample = create_sample(wmaenc_data, wmaenc_block_size + 1);
-    hr = IMFTransform_ProcessInput(transform, 0, sample, 0);
+    input_sample = create_sample(wmaenc_data, wmaenc_block_size + 1);
+    hr = IMFTransform_ProcessInput(transform, 0, input_sample, 0);
     ok(hr == S_OK, "ProcessInput returned %#lx\n", hr);
-    ret = IMFSample_Release(sample);
+    ret = IMFSample_Release(input_sample);
     ok(ret == 0, "Release returned %lu\n", ret);
-    sample = create_sample(wmaenc_data, wmaenc_block_size);
-    hr = IMFTransform_ProcessInput(transform, 0, sample, 0);
+    input_sample = create_sample(wmaenc_data, wmaenc_block_size);
+    hr = IMFTransform_ProcessInput(transform, 0, input_sample, 0);
     ok(hr == S_OK, "ProcessInput returned %#lx\n", hr);
-    hr = IMFTransform_ProcessInput(transform, 0, sample, 0);
+    hr = IMFTransform_ProcessInput(transform, 0, input_sample, 0);
     ok(hr == MF_E_NOTACCEPTING, "ProcessInput returned %#lx\n", hr);
-    ret = IMFSample_Release(sample);
+    ret = IMFSample_Release(input_sample);
     ok(ret == 1, "Release returned %lu\n", ret);

/* As output_info.dwFlags doesn't have MFT_OUTPUT_STREAM_CAN_PROVIDE_SAMPLES
@@ -1867,10 +1865,10 @@ static void test_wma_decoder(void)
     ok(!output.pEvents, "got pEvents %p\n", output.pEvents);
     ok(status == 0, "got status %#lx\n", status);

-    sample = create_sample(wmaenc_data, wmaenc_block_size);
-    hr = IMFTransform_ProcessInput(transform, 0, sample, 0);
+    input_sample = create_sample(wmaenc_data, wmaenc_block_size);
+    hr = IMFTransform_ProcessInput(transform, 0, input_sample, 0);
     ok(hr == MF_E_NOTACCEPTING, "ProcessInput returned %#lx\n", hr);
-    ret = IMFSample_Release(sample);
+    ret = IMFSample_Release(input_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

status = 0xdeadbeef;
@@ -1886,10 +1884,8 @@ static void test_wma_decoder(void)
     status = 0xdeadbeef;
     memset(&output, 0, sizeof(output));
     output_info.cbSize = wmadec_block_size;
-    sample = create_sample(NULL, output_info.cbSize);
-    outputs[0].pSample = sample;
-    sample = create_sample(NULL, output_info.cbSize);
-    outputs[1].pSample = sample;
+    outputs[0].pSample = create_sample(NULL, output_info.cbSize);
+    outputs[1].pSample = create_sample(NULL, output_info.cbSize);
     hr = IMFTransform_ProcessOutput(transform, 0, 2, outputs, &status);
     ok(hr == E_INVALIDARG, "ProcessOutput returned %#lx\n", hr);
     ref = IMFSample_Release(outputs[0].pSample);
@@ -1911,9 +1907,8 @@ static void test_wma_decoder(void)

status = 0xdeadbeef;
     output_info.cbSize = wmadec_block_size;
-    sample = create_sample(NULL, output_info.cbSize);
     memset(&output, 0, sizeof(output));
-    output.pSample = sample;
+    output.pSample = output_sample = create_sample(NULL, output_info.cbSize);
     hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);

for (i = 0; i < 4; ++i)
@@ -1921,34 +1916,34 @@ static void test_wma_decoder(void)
         winetest_push_context("%lu", i);

ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
-        ok(output.pSample == sample, "got pSample %p\n", output.pSample);
+        ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
         ok(output.dwStatus == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE || output.dwStatus == 0 ||
                 broken(output.dwStatus == (MFT_OUTPUT_DATA_BUFFER_INCOMPLETE|7) || output.dwStatus == 7) /* Win7 */,
                 "got dwStatus %#lx\n", output.dwStatus);
         ok(status == 0, "got status %#lx\n", status);
         value = 0xdeadbeef;
-        hr = IMFSample_GetUINT32(sample, &MFSampleExtension_CleanPoint, &value);
+        hr = IMFSample_GetUINT32(output_sample, &MFSampleExtension_CleanPoint, &value);
         ok(hr == S_OK, "GetUINT32 MFSampleExtension_CleanPoint returned %#lx\n", hr);
         ok(value == 1, "got MFSampleExtension_CleanPoint %u\n", value);
-        hr = IMFSample_GetTotalLength(sample, &length);
+        hr = IMFSample_GetTotalLength(output_sample, &length);
         ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
         flags = 0xdeadbeef;
-        hr = IMFSample_GetSampleFlags(sample, &flags);
+        hr = IMFSample_GetSampleFlags(output_sample, &flags);
         ok(hr == S_OK, "GetSampleFlags returned %#lx\n", hr);
         ok(flags == 0, "got flags %#lx\n", flags);
         time = 0xdeadbeef;
-        hr = IMFSample_GetSampleTime(sample, &time);
+        hr = IMFSample_GetSampleTime(output_sample, &time);
         ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
         ok(time == i * 928798, "got time %I64d\n", time);
         duration = 0xdeadbeef;
-        hr = IMFSample_GetSampleDuration(sample, &duration);
+        hr = IMFSample_GetSampleDuration(output_sample, &duration);
         ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
         if (output.dwStatus == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE ||
                 broken(output.dwStatus == (MFT_OUTPUT_DATA_BUFFER_INCOMPLETE|7)))
         {
             ok(length == wmadec_block_size, "got length %lu\n", length);
             ok(duration == 928798, "got duration %I64d\n", duration);
-            check_sample_pcm16(sample, wmadec_data, output_file, TRUE);
+            check_sample_pcm16(output_sample, wmadec_data, output_file, TRUE);
             wmadec_data += wmadec_block_size;
             wmadec_data_len -= wmadec_block_size;
         }
@@ -1961,17 +1956,16 @@ static void test_wma_decoder(void)
             ok(duration == 464399, "got duration %I64d\n", duration);

if (length == wmadec_block_size / 2)
-                check_sample_pcm16(sample, wmadec_data, output_file, FALSE);
+                check_sample_pcm16(output_sample, wmadec_data, output_file, FALSE);
             wmadec_data += length;
             wmadec_data_len -= length;
         }
-        ret = IMFSample_Release(sample);
+        ret = IMFSample_Release(output_sample);
         ok(ret == 0, "Release returned %lu\n", ret);

status = 0xdeadbeef;
-        sample = create_sample(NULL, output_info.cbSize);
         memset(&output, 0, sizeof(output));
-        output.pSample = sample;
+        output.pSample = output_sample = create_sample(NULL, output_info.cbSize);
         hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);

winetest_pop_context();
@@ -1986,36 +1980,35 @@ static void test_wma_decoder(void)
     CloseHandle(output_file);

ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#lx\n", hr);
-    ok(output.pSample == sample, "got pSample %p\n", output.pSample);
+    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
     ok(output.dwStatus == 0, "got dwStatus %#lx\n", output.dwStatus);
     ok(status == 0, "got status %#lx\n", status);
-    ret = IMFSample_Release(sample);
+    ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

status = 0xdeadbeef;
-    sample = create_sample(NULL, output_info.cbSize);
     memset(&output, 0, sizeof(output));
-    output.pSample = sample;
+    output.pSample = output_sample = create_sample(NULL, output_info.cbSize);
     hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
     ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#lx\n", hr);
-    ok(output.pSample == sample, "got pSample %p\n", output.pSample);
+    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
     ok(output.dwStatus == 0 ||
             broken(output.dwStatus == (MFT_OUTPUT_DATA_BUFFER_INCOMPLETE|7)) /* Win7 */,
             "got dwStatus %#lx\n", output.dwStatus);
     ok(status == 0, "got status %#lx\n", status);
-    hr = IMFSample_GetTotalLength(sample, &length);
+    hr = IMFSample_GetTotalLength(output_sample, &length);
     ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
     ok(length == 0, "got length %lu\n", length);
-    ret = IMFSample_Release(sample);
+    ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

-    sample = create_sample(wmaenc_data, wmaenc_block_size);
-    hr = IMFTransform_ProcessInput(transform, 0, sample, 0);
+    input_sample = create_sample(wmaenc_data, wmaenc_block_size);
+    hr = IMFTransform_ProcessInput(transform, 0, input_sample, 0);
     ok(hr == S_OK, "ProcessInput returned %#lx\n", hr);

ret = IMFTransform_Release(transform);
     ok(ret == 0, "Release returned %lu\n", ret);
-    ret = IMFSample_Release(sample);
+    ret = IMFSample_Release(input_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

hr = CoCreateInstance( &CLSID_CWMADecMediaObject, &outer, CLSCTX_INPROC_SERVER, &IID_IUnknown,
@@ -2290,6 +2283,7 @@ static void test_h264_decoder(void)
     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;
+    IMFSample *input_sample, *output_sample;
     MFT_OUTPUT_STREAM_INFO output_info;
     MFT_INPUT_STREAM_INFO input_info;
     MFT_OUTPUT_DATA_BUFFER output;
@@ -2302,7 +2296,6 @@ static void test_h264_decoder(void)
     IMFTransform *transform;
     ULONG i, ret, flags;
     HANDLE output_file;
-    IMFSample *sample;
     HRSRC resource;
     UINT32 value;
     BYTE *data;
@@ -2498,37 +2491,37 @@ static void test_h264_decoder(void)
     ok(status == 0, "got status %#lx\n", status);

i = 0;
-    sample = next_h264_sample(&h264_encoded_data, &h264_encoded_data_len);
+    input_sample = next_h264_sample(&h264_encoded_data, &h264_encoded_data_len);
     while (1)
     {
         status = 0;
         memset(&output, 0, sizeof(output));
-        output.pSample = create_sample(NULL, output_info.cbSize);
+        output.pSample = output_sample = create_sample(NULL, output_info.cbSize);
         hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
         if (hr != MF_E_TRANSFORM_NEED_MORE_INPUT) break;
         ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#lx\n", hr);
         ok(output.dwStreamID == 0, "got dwStreamID %lu\n", output.dwStreamID);
-        ok(!!output.pSample, "got pSample %p\n", output.pSample);
+        ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
         ok(output.dwStatus == 0, "got dwStatus %#lx\n", output.dwStatus);
         ok(!output.pEvents, "got pEvents %p\n", output.pEvents);
         ok(status == 0, "got status %#lx\n", status);
-        hr = IMFSample_GetTotalLength(output.pSample, &length);
+        hr = IMFSample_GetTotalLength(output_sample, &length);
         ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
         ok(length == 0, "got length %lu\n", length);
-        ret = IMFSample_Release(output.pSample);
+        ret = IMFSample_Release(output_sample);
         ok(ret == 0, "Release returned %lu\n", ret);

-        hr = IMFTransform_ProcessInput(transform, 0, sample, 0);
+        hr = IMFTransform_ProcessInput(transform, 0, input_sample, 0);
         ok(hr == S_OK, "ProcessInput returned %#lx\n", hr);
-        ret = IMFSample_Release(sample);
+        ret = IMFSample_Release(input_sample);
         ok(ret <= 1, "Release returned %lu\n", ret);
-        sample = next_h264_sample(&h264_encoded_data, &h264_encoded_data_len);
+        input_sample = next_h264_sample(&h264_encoded_data, &h264_encoded_data_len);

-        hr = IMFTransform_ProcessInput(transform, 0, sample, 0);
+        hr = IMFTransform_ProcessInput(transform, 0, input_sample, 0);
         ok(hr == S_OK, "ProcessInput returned %#lx\n", hr);
-        ret = IMFSample_Release(sample);
+        ret = IMFSample_Release(input_sample);
         ok(ret <= 1, "Release returned %lu\n", ret);
-        sample = next_h264_sample(&h264_encoded_data, &h264_encoded_data_len);
+        input_sample = next_h264_sample(&h264_encoded_data, &h264_encoded_data_len);
         i++;

hr = IMFTransform_ProcessMessage(transform, MFT_MESSAGE_COMMAND_DRAIN, 0);
@@ -2540,16 +2533,16 @@ static void test_h264_decoder(void)
     ok(h264_encoded_data_len == 1180, "got h264_encoded_data_len %lu\n", h264_encoded_data_len);
     ok(hr == MF_E_TRANSFORM_STREAM_CHANGE, "ProcessOutput returned %#lx\n", hr);
     ok(output.dwStreamID == 0, "got dwStreamID %lu\n", output.dwStreamID);
-    ok(!!output.pSample, "got pSample %p\n", output.pSample);
+    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
     ok(output.dwStatus == MFT_OUTPUT_DATA_BUFFER_FORMAT_CHANGE,
             "got dwStatus %#lx\n", output.dwStatus);
     ok(!output.pEvents, "got pEvents %p\n", output.pEvents);
     ok(status == MFT_PROCESS_OUTPUT_STATUS_NEW_STREAMS,
             "got status %#lx\n", status);
-    hr = IMFSample_GetTotalLength(output.pSample, &length);
+    hr = IMFSample_GetTotalLength(output_sample, &length);
     ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
     ok(length == 0, "got length %lu\n", length);
-    ret = IMFSample_Release(output.pSample);
+    ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

flags = MFT_OUTPUT_STREAM_WHOLE_SAMPLES | MFT_OUTPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER | MFT_OUTPUT_STREAM_FIXED_SAMPLE_SIZE;
@@ -2596,42 +2589,43 @@ static void test_h264_decoder(void)

status = 0;
     memset(&output, 0, sizeof(output));
-    output.pSample = create_sample(NULL, nv12_frame_len);
+    output.pSample = output_sample = create_sample(NULL, nv12_frame_len);
     hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
     ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
     ok(output.dwStreamID == 0, "got dwStreamID %lu\n", output.dwStreamID);
-    ok(!!output.pSample, "got pSample %p\n", output.pSample);
+    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
     ok(output.dwStatus == 0, "got dwStatus %#lx\n", output.dwStatus);
     ok(!output.pEvents, "got pEvents %p\n", output.pEvents);
     ok(status == 0, "got status %#lx\n", status);

-    hr = IMFSample_GetUINT32(sample, &MFSampleExtension_CleanPoint, &value);
-    ok(hr == MF_E_ATTRIBUTENOTFOUND, "GetUINT32 MFSampleExtension_CleanPoint returned %#lx\n", hr);
+    hr = IMFSample_GetUINT32(output_sample, &MFSampleExtension_CleanPoint, &value);
+    ok(hr == S_OK, "GetUINT32 MFSampleExtension_CleanPoint returned %#lx\n", hr);
+    ok(value == 1, "got MFSampleExtension_CleanPoint %u\n", value);

count = 0xdeadbeef;
-    hr = IMFSample_GetBufferCount(output.pSample, &count);
+    hr = IMFSample_GetBufferCount(output_sample, &count);
     ok(hr == S_OK, "GetBufferCount returned %#lx\n", hr);
     ok(count == 1, "got count %#lx\n", count);

flags = 0xdeadbeef;
-    hr = IMFSample_GetSampleFlags(output.pSample, &flags);
+    hr = IMFSample_GetSampleFlags(output_sample, &flags);
     ok(hr == S_OK, "GetSampleFlags returned %#lx\n", hr);
     ok(flags == 0, "got flags %#lx\n", flags);

time = 0xdeadbeef;
-    hr = IMFSample_GetSampleTime(output.pSample, &time);
+    hr = IMFSample_GetSampleTime(output_sample, &time);
     ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
     ok(time == 0, "got time %I64d\n", time);

/* doesn't matter what frame rate we've selected, duration is defined by the stream */
     duration = 0xdeadbeef;
-    hr = IMFSample_GetSampleDuration(output.pSample, &duration);
+    hr = IMFSample_GetSampleDuration(output_sample, &duration);
     ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
     ok(duration - 333666 <= 2, "got duration %I64d\n", duration);

/* Win8 and before pad the data with garbage instead of original
      * buffer data, make sure it's consistent.  */
-    hr = IMFSample_ConvertToContiguousBuffer(output.pSample, &media_buffer);
+    hr = IMFSample_ConvertToContiguousBuffer(output_sample, &media_buffer);
     ok(hr == S_OK, "ConvertToContiguousBuffer returned %#lx\n", hr);
     hr = IMFMediaBuffer_Lock(media_buffer, &data, NULL, &length);
     ok(hr == S_OK, "Lock returned %#lx\n", hr);
@@ -2649,9 +2643,9 @@ static void test_h264_decoder(void)
     ok(hr == S_OK, "Unlock returned %#lx\n", hr);
     IMFMediaBuffer_Release(media_buffer);

-    check_sample(output.pSample, nv12_frame_data, output_file);
+    check_sample(output_sample, nv12_frame_data, output_file);

-    ret = IMFSample_Release(output.pSample);
+    ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

trace("created %s\n", debugstr_w(output_path));
@@ -2679,32 +2673,32 @@ static void test_h264_decoder(void)

status = 0;
     memset(&output, 0, sizeof(output));
-    output.pSample = create_sample(NULL, actual_width * actual_height * 2);
+    output.pSample = output_sample = create_sample(NULL, actual_width * actual_height * 2);
     hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
     todo_wine
     ok(hr == MF_E_TRANSFORM_STREAM_CHANGE, "ProcessOutput returned %#lx\n", hr);

while (hr == MF_E_TRANSFORM_NEED_MORE_INPUT)
     {
-        hr = IMFTransform_ProcessInput(transform, 0, sample, 0);
+        hr = IMFTransform_ProcessInput(transform, 0, input_sample, 0);
         ok(hr == S_OK, "ProcessInput returned %#lx\n", hr);
-        ret = IMFSample_Release(sample);
+        ret = IMFSample_Release(input_sample);
         ok(ret <= 1, "Release returned %lu\n", ret);
-        sample = next_h264_sample(&h264_encoded_data, &h264_encoded_data_len);
+        input_sample = next_h264_sample(&h264_encoded_data, &h264_encoded_data_len);
         hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
         todo_wine_if(hr == MF_E_TRANSFORM_NEED_MORE_INPUT)
         ok(hr == MF_E_TRANSFORM_STREAM_CHANGE, "ProcessOutput returned %#lx\n", hr);
     }

ok(output.dwStreamID == 0, "got dwStreamID %lu\n", output.dwStreamID);
-    ok(!!output.pSample, "got pSample %p\n", output.pSample);
+    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
     ok(output.dwStatus == MFT_OUTPUT_DATA_BUFFER_FORMAT_CHANGE, "got dwStatus %#lx\n", output.dwStatus);
     ok(!output.pEvents, "got pEvents %p\n", output.pEvents);
     ok(status == MFT_PROCESS_OUTPUT_STATUS_NEW_STREAMS, "got status %#lx\n", status);
-    hr = IMFSample_GetTotalLength(output.pSample, &length);
+    hr = IMFSample_GetTotalLength(output_sample, &length);
     ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
     ok(length == 0, "got length %lu\n", length);
-    ret = IMFSample_Release(output.pSample);
+    ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

GetTempPathW(ARRAY_SIZE(output_path), output_path);
@@ -2720,28 +2714,28 @@ static void test_h264_decoder(void)

status = 0;
     memset(&output, 0, sizeof(output));
-    output.pSample = create_sample(NULL, actual_width * actual_height * 2);
+    output.pSample = output_sample = create_sample(NULL, actual_width * actual_height * 2);
     hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
     ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
     ok(output.dwStreamID == 0, "got dwStreamID %lu\n", output.dwStreamID);
-    ok(!!output.pSample, "got pSample %p\n", output.pSample);
+    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
     ok(output.dwStatus == 0, "got dwStatus %#lx\n", output.dwStatus);
     ok(!output.pEvents, "got pEvents %p\n", output.pEvents);
     ok(status == 0, "got status %#lx\n", status);

-    hr = IMFSample_GetSampleTime(output.pSample, &time);
+    hr = IMFSample_GetSampleTime(output_sample, &time);
     ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
     todo_wine_if(time == 1334666)  /* when VA-API plugin is used */
     ok(time - 333666 <= 2, "got time %I64d\n", time);

duration = 0xdeadbeef;
-    hr = IMFSample_GetSampleDuration(output.pSample, &duration);
+    hr = IMFSample_GetSampleDuration(output_sample, &duration);
     ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
     ok(duration - 333666 <= 2, "got duration %I64d\n", duration);

/* Win8 and before pad the data with garbage instead of original
      * buffer data, make sure it's consistent.  */
-    hr = IMFSample_ConvertToContiguousBuffer(output.pSample, &media_buffer);
+    hr = IMFSample_ConvertToContiguousBuffer(output_sample, &media_buffer);
     ok(hr == S_OK, "ConvertToContiguousBuffer returned %#lx\n", hr);
     hr = IMFMediaBuffer_Lock(media_buffer, &data, NULL, &length);
     ok(hr == S_OK, "Lock returned %#lx\n", hr);
@@ -2765,9 +2759,9 @@ static void test_h264_decoder(void)
     ok(hr == S_OK, "Unlock returned %#lx\n", hr);
     IMFMediaBuffer_Release(media_buffer);

-    check_sample(output.pSample, i420_frame_data, output_file);
+    check_sample(output_sample, i420_frame_data, output_file);

-    ret = IMFSample_Release(output.pSample);
+    ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

trace("created %s\n", debugstr_w(output_path));
@@ -2775,21 +2769,21 @@ static void test_h264_decoder(void)

status = 0;
     memset(&output, 0, sizeof(output));
-    output.pSample = create_sample(NULL, actual_width * actual_height * 2);
+    output.pSample = output_sample = create_sample(NULL, actual_width * actual_height * 2);
     hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
     todo_wine_if(hr == S_OK)  /* when VA-API plugin is used */
     ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#lx\n", hr);
     ok(output.dwStreamID == 0, "got dwStreamID %lu\n", output.dwStreamID);
-    ok(!!output.pSample, "got pSample %p\n", output.pSample);
+    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
     ok(output.dwStatus == 0, "got dwStatus %#lx\n", output.dwStatus);
     ok(!output.pEvents, "got pEvents %p\n", output.pEvents);
     ok(status == 0, "got status %#lx\n", status);
-    ret = IMFSample_Release(output.pSample);
+    ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

ret = IMFTransform_Release(transform);
     ok(ret == 0, "Release returned %lu\n", ret);
-    ret = IMFSample_Release(sample);
+    ret = IMFSample_Release(input_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

failed:
@@ -2907,6 +2901,7 @@ static void test_audio_convert(void)
     MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Audio, MFAudioFormat_Float};
     static const ULONG audioconv_block_size = 0x4000;
     ULONG audio_data_len, audioconv_data_len;
+    IMFSample *input_sample, *output_sample;
     const BYTE *audio_data, *audioconv_data;
     MFT_OUTPUT_STREAM_INFO output_info;
     MFT_INPUT_STREAM_INFO input_info;
@@ -2917,7 +2912,6 @@ static void test_audio_convert(void)
     IMFTransform *transform;
     DWORD length, status;
     HANDLE output_file;
-    IMFSample *sample;
     HRSRC resource;
     ULONG i, ret;
     HRESULT hr;
@@ -3049,24 +3043,23 @@ static void test_audio_convert(void)
     audio_data_len = SizeofResource(GetModuleHandleW(NULL), resource);
     ok(audio_data_len == 179928, "got length %lu\n", audio_data_len);

-    sample = create_sample(audio_data, audio_data_len);
-    hr = IMFSample_SetSampleTime(sample, 0);
+    input_sample = create_sample(audio_data, audio_data_len);
+    hr = IMFSample_SetSampleTime(input_sample, 0);
     ok(hr == S_OK, "SetSampleTime returned %#lx\n", hr);
-    hr = IMFSample_SetSampleDuration(sample, 10000000);
+    hr = IMFSample_SetSampleDuration(input_sample, 10000000);
     ok(hr == S_OK, "SetSampleDuration returned %#lx\n", hr);
-    hr = IMFTransform_ProcessInput(transform, 0, sample, 0);
+    hr = IMFTransform_ProcessInput(transform, 0, input_sample, 0);
     ok(hr == S_OK, "ProcessInput returned %#lx\n", hr);
     hr = IMFTransform_ProcessMessage(transform, MFT_MESSAGE_COMMAND_DRAIN, 0);
     ok(hr == S_OK, "ProcessMessage returned %#lx\n", hr);
-    hr = IMFTransform_ProcessInput(transform, 0, sample, 0);
+    hr = IMFTransform_ProcessInput(transform, 0, input_sample, 0);
     ok(hr == MF_E_NOTACCEPTING, "ProcessInput returned %#lx\n", hr);
-    ret = IMFSample_Release(sample);
+    ret = IMFSample_Release(input_sample);
     ok(ret <= 1, "Release returned %ld\n", ret);

status = 0xdeadbeef;
-    sample = create_sample(NULL, audioconv_block_size);
     memset(&output, 0, sizeof(output));
-    output.pSample = sample;
+    output.pSample = output_sample = create_sample(NULL, audioconv_block_size);

resource = FindResourceW(NULL, L"audioconvdata.bin", (const WCHAR *)RT_RCDATA);
     ok(resource != 0, "FindResourceW failed, error %lu\n", GetLastError());
@@ -3085,7 +3078,7 @@ static void test_audio_convert(void)
     {
         winetest_push_context("%lu", i);
         ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
-        ok(output.pSample == sample, "got pSample %p\n", output.pSample);
+        ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
         ok(output.dwStatus == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE || output.dwStatus == 0 ||
                 broken(output.dwStatus == (MFT_OUTPUT_DATA_BUFFER_INCOMPLETE|6) || output.dwStatus == 6) /* win7 */,
                 "got dwStatus %#lx\n", output.dwStatus);
@@ -3096,17 +3089,17 @@ static void test_audio_convert(void)
             break;
         }

-        hr = IMFSample_GetSampleTime(sample, &time);
+        hr = IMFSample_GetSampleTime(output_sample, &time);
         ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
         ok(time == i * 928798, "got time %I64d\n", time);
-        hr = IMFSample_GetSampleDuration(sample, &duration);
+        hr = IMFSample_GetSampleDuration(output_sample, &duration);
         ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
         ok(duration == 928798, "got duration %I64d\n", duration);
-        hr = IMFSample_GetTotalLength(sample, &length);
+        hr = IMFSample_GetTotalLength(output_sample, &length);
         ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
         ok(length == audioconv_block_size, "got length %lu\n", length);
         ok(audioconv_data_len > audioconv_block_size, "got remaining length %lu\n", audioconv_data_len);
-        check_sample_pcm16(sample, audioconv_data, output_file, FALSE);
+        check_sample_pcm16(output_sample, audioconv_data, output_file, FALSE);
         audioconv_data_len -= audioconv_block_size;
         audioconv_data += audioconv_block_size;

@@ -3114,28 +3107,32 @@ static void test_audio_convert(void)
         i++;
     }

-    hr = IMFSample_GetSampleTime(sample, &time);
+    hr = IMFSample_GetSampleTime(output_sample, &time);
     ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
     ok(time == i * 928798, "got time %I64d\n", time);
-    hr = IMFSample_GetSampleDuration(sample, &duration);
+    hr = IMFSample_GetSampleDuration(output_sample, &duration);
     ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
     todo_wine
     ok(duration == 897506, "got duration %I64d\n", duration);
-    hr = IMFSample_GetTotalLength(sample, &length);
+    hr = IMFSample_GetTotalLength(output_sample, &length);
     ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
     todo_wine
     ok(length == 15832, "got length %lu\n", length);
     ok(audioconv_data_len == 16084, "got remaining length %lu\n", audioconv_data_len);
-    check_sample_pcm16(sample, audioconv_data, output_file, FALSE);
+    check_sample_pcm16(output_sample, audioconv_data, output_file, FALSE);
     audioconv_data_len -= length;
     audioconv_data += length;

+    ret = IMFSample_Release(output_sample);
+    ok(ret == 0, "Release returned %lu\n", ret);
+
+    status = 0xdeadbeef;
     memset(&output, 0, sizeof(output));
-    output.pSample = sample;
+    output.pSample = output_sample = create_sample(NULL, audioconv_block_size);
     hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
     todo_wine
     ok(hr == S_OK || broken(hr == MF_E_TRANSFORM_NEED_MORE_INPUT) /* win7 */, "ProcessOutput returned %#lx\n", hr);
-    ok(output.pSample == sample, "got pSample %p\n", output.pSample);
+    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
     todo_wine
     ok(output.dwStatus == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE || broken(output.dwStatus == 0) /* win7 */,
             "got dwStatus %#lx\n", output.dwStatus);
@@ -3143,41 +3140,40 @@ static void test_audio_convert(void)

if (hr == S_OK)
     {
-        hr = IMFSample_GetSampleTime(sample, &time);
+        hr = IMFSample_GetSampleTime(output_sample, &time);
         ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
         todo_wine
         ok(time == 10185486, "got time %I64d\n", time);
-        hr = IMFSample_GetSampleDuration(sample, &duration);
+        hr = IMFSample_GetSampleDuration(output_sample, &duration);
         ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
         todo_wine
         ok(duration == 14286, "got duration %I64d\n", duration);
-        hr = IMFSample_GetTotalLength(sample, &length);
+        hr = IMFSample_GetTotalLength(output_sample, &length);
         ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
         todo_wine
         ok(length == audioconv_data_len, "got length %lu\n", length);
         if (length == audioconv_data_len)
-            check_sample_pcm16(sample, audioconv_data, output_file, FALSE);
+            check_sample_pcm16(output_sample, audioconv_data, output_file, FALSE);
     }

trace("created %s\n", debugstr_w(output_path));
     CloseHandle(output_file);

-    ret = IMFSample_Release(sample);
+    ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

status = 0xdeadbeef;
-    sample = create_sample(NULL, audioconv_block_size);
     memset(&output, 0, sizeof(output));
-    output.pSample = sample;
+    output.pSample = output_sample = create_sample(NULL, audioconv_block_size);
     hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
     ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#lx\n", hr);
-    ok(output.pSample == sample, "got pSample %p\n", output.pSample);
+    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
     ok(output.dwStatus == 0, "got dwStatus %#lx\n", output.dwStatus);
     ok(status == 0, "got status %#lx\n", status);
-    hr = IMFSample_GetTotalLength(sample, &length);
+    hr = IMFSample_GetTotalLength(output_sample, &length);
     ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
     ok(length == 0, "got length %lu\n", length);
-    ret = IMFSample_Release(sample);
+    ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

ret = IMFTransform_Release(transform);
@@ -3357,6 +3353,7 @@ static void test_color_convert(void)
     MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Video, MFVideoFormat_I420};
     ULONG nv12frame_data_len, rgb32_data_len;
     const BYTE *nv12frame_data, *rgb32_data;
+    IMFSample *input_sample, *output_sample;
     MFT_OUTPUT_STREAM_INFO output_info;
     MFT_INPUT_STREAM_INFO input_info;
     MFT_OUTPUT_DATA_BUFFER output;
@@ -3366,7 +3363,6 @@ static void test_color_convert(void)
     IMFTransform *transform;
     DWORD length, status;
     HANDLE output_file;
-    IMFSample *sample;
     HRSRC resource;
     ULONG i, ret;
     HRESULT hr;
@@ -3477,18 +3473,18 @@ static void test_color_convert(void)
     nv12frame_data_len = SizeofResource(GetModuleHandleW(NULL), resource);
     ok(nv12frame_data_len == 13824, "got length %lu\n", nv12frame_data_len);

-    sample = create_sample(nv12frame_data, nv12frame_data_len);
-    hr = IMFSample_SetSampleTime(sample, 0);
+    input_sample = create_sample(nv12frame_data, nv12frame_data_len);
+    hr = IMFSample_SetSampleTime(input_sample, 0);
     ok(hr == S_OK, "SetSampleTime returned %#lx\n", hr);
-    hr = IMFSample_SetSampleDuration(sample, 10000000);
+    hr = IMFSample_SetSampleDuration(input_sample, 10000000);
     ok(hr == S_OK, "SetSampleDuration returned %#lx\n", hr);
-    hr = IMFTransform_ProcessInput(transform, 0, sample, 0);
+    hr = IMFTransform_ProcessInput(transform, 0, input_sample, 0);
     ok(hr == S_OK, "ProcessInput returned %#lx\n", hr);
-    hr = IMFTransform_ProcessInput(transform, 0, sample, 0);
+    hr = IMFTransform_ProcessInput(transform, 0, input_sample, 0);
     ok(hr == MF_E_NOTACCEPTING, "ProcessInput returned %#lx\n", hr);
     hr = IMFTransform_ProcessMessage(transform, MFT_MESSAGE_COMMAND_DRAIN, 0);
     ok(hr == S_OK, "ProcessMessage returned %#lx\n", hr);
-    ret = IMFSample_Release(sample);
+    ret = IMFSample_Release(input_sample);
     ok(ret <= 1, "Release returned %ld\n", ret);

resource = FindResourceW(NULL, L"rgb32frame.bin", (const WCHAR *)RT_RCDATA);
@@ -3504,47 +3500,45 @@ static void test_color_convert(void)
     ok(output_file != INVALID_HANDLE_VALUE, "CreateFileW failed, error %lu\n", GetLastError());

status = 0xdeadbeef;
-    sample = create_sample(NULL, output_info.cbSize);
     memset(&output, 0, sizeof(output));
-    output.pSample = sample;
+    output.pSample = output_sample = create_sample(NULL, output_info.cbSize);
     hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
     ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
-    ok(output.pSample == sample, "got pSample %p\n", output.pSample);
+    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
     ok(output.dwStatus == 0 || broken(output.dwStatus == 6) /* win7 */, "got dwStatus %#lx\n", output.dwStatus);
     ok(status == 0, "got status %#lx\n", status);

-    hr = IMFSample_GetSampleTime(sample, &time);
+    hr = IMFSample_GetSampleTime(output_sample, &time);
     ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
     ok(time == 0, "got time %I64d\n", time);
-    hr = IMFSample_GetSampleDuration(sample, &duration);
+    hr = IMFSample_GetSampleDuration(output_sample, &duration);
     ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
     ok(duration == 10000000, "got duration %I64d\n", duration);
-    hr = IMFSample_GetTotalLength(sample, &length);
+    hr = IMFSample_GetTotalLength(output_sample, &length);
     ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
     ok(length == output_info.cbSize, "got length %lu\n", length);
-    check_sample_rgb32(sample, rgb32_data, output_file);
+    check_sample_rgb32(output_sample, rgb32_data, output_file);
     rgb32_data_len -= output_info.cbSize;
     rgb32_data += output_info.cbSize;

trace("created %s\n", debugstr_w(output_path));
     CloseHandle(output_file);

-    ret = IMFSample_Release(sample);
+    ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

status = 0xdeadbeef;
-    sample = create_sample(NULL, output_info.cbSize);
     memset(&output, 0, sizeof(output));
-    output.pSample = sample;
+    output.pSample = output_sample = create_sample(NULL, output_info.cbSize);
     hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
     ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#lx\n", hr);
-    ok(output.pSample == sample, "got pSample %p\n", output.pSample);
+    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
     ok(output.dwStatus == 0, "got dwStatus %#lx\n", output.dwStatus);
     ok(status == 0, "got status %#lx\n", status);
-    hr = IMFSample_GetTotalLength(sample, &length);
+    hr = IMFSample_GetTotalLength(output_sample, &length);
     ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
     ok(length == 0, "got length %lu\n", length);
-    ret = IMFSample_Release(sample);
+    ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

ret = IMFTransform_Release(transform);
@@ -3721,15 +3715,14 @@ static void test_video_processor(void)
     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;
+    IMFSample *input_sample, *output_sample;
     IMFMediaType *media_type, *media_type2;
     IMFAttributes *attributes, *attributes2;
     const BYTE *nv12frame_data, *rgb32_data;
-    MFT_OUTPUT_DATA_BUFFER output_buffer;
     const GUID *expect_available_inputs;
     MFT_OUTPUT_STREAM_INFO output_info;
     MFT_INPUT_STREAM_INFO input_info;
     MFT_OUTPUT_DATA_BUFFER output;
-    IMFSample *sample, *sample2;
     WCHAR output_path[MAX_PATH];
     LONGLONG time, duration;
     IMFTransform *transform;
@@ -3959,75 +3952,75 @@ todo_wine {
     ok(output_info.cbSize > 0, "Unexpected size %lu.\n", output_info.cbSize);
     ok(output_info.cbAlignment == 0, "Unexpected alignment %lu.\n", output_info.cbAlignment);

-    hr = MFCreateSample(&sample);
+    hr = MFCreateSample(&input_sample);
     ok(hr == S_OK, "Failed to create a sample, hr %#lx.\n", hr);

-    hr = MFCreateSample(&sample2);
+    hr = MFCreateSample(&output_sample);
     ok(hr == S_OK, "Failed to create a sample, hr %#lx.\n", hr);

-    memset(&output_buffer, 0, sizeof(output_buffer));
-    output_buffer.pSample = sample;
+    memset(&output, 0, sizeof(output));
+    output.pSample = output_sample;
     flags = 0;
-    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output_buffer, &flags);
+    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &flags);
     todo_wine
     ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "Unexpected hr %#lx.\n", hr);
-    ok(output_buffer.dwStatus == 0, "Unexpected buffer status, %#lx.\n", output_buffer.dwStatus);
+    ok(output.dwStatus == 0, "Unexpected buffer status, %#lx.\n", output.dwStatus);
     ok(flags == 0, "Unexpected status %#lx.\n", flags);

-    hr = IMFTransform_ProcessInput(transform, 0, sample2, 0);
+    hr = IMFTransform_ProcessInput(transform, 0, input_sample, 0);
     todo_wine
     ok(hr == S_OK, "Failed to push a sample, hr %#lx.\n", hr);

-    hr = IMFTransform_ProcessInput(transform, 0, sample2, 0);
+    hr = IMFTransform_ProcessInput(transform, 0, input_sample, 0);
     todo_wine
     ok(hr == MF_E_NOTACCEPTING, "Unexpected hr %#lx.\n", hr);

-    memset(&output_buffer, 0, sizeof(output_buffer));
-    output_buffer.pSample = sample;
+    memset(&output, 0, sizeof(output));
+    output.pSample = output_sample;
     flags = 0;
-    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output_buffer, &flags);
+    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &flags);
     todo_wine
     ok(hr == MF_E_NO_SAMPLE_TIMESTAMP, "Unexpected hr %#lx.\n", hr);
-    ok(output_buffer.dwStatus == 0, "Unexpected buffer status, %#lx.\n", output_buffer.dwStatus);
+    ok(output.dwStatus == 0, "Unexpected buffer status, %#lx.\n", output.dwStatus);
     ok(flags == 0, "Unexpected status %#lx.\n", flags);

-    hr = IMFSample_SetSampleTime(sample2, 0);
+    hr = IMFSample_SetSampleTime(input_sample, 0);
     ok(hr == S_OK, "Failed to set sample time, hr %#lx.\n", hr);
-    memset(&output_buffer, 0, sizeof(output_buffer));
-    output_buffer.pSample = sample;
+    memset(&output, 0, sizeof(output));
+    output.pSample = output_sample;
     flags = 0;
-    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output_buffer, &flags);
+    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &flags);
     todo_wine
     ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
-    ok(output_buffer.dwStatus == 0, "Unexpected buffer status, %#lx.\n", output_buffer.dwStatus);
+    ok(output.dwStatus == 0, "Unexpected buffer status, %#lx.\n", output.dwStatus);
     ok(flags == 0, "Unexpected status %#lx.\n", flags);

hr = MFCreateMemoryBuffer(1024 * 1024, &buffer);
     ok(hr == S_OK, "Failed to create a buffer, hr %#lx.\n", hr);

-    hr = IMFSample_AddBuffer(sample2, buffer);
+    hr = IMFSample_AddBuffer(input_sample, buffer);
     ok(hr == S_OK, "Failed to add a buffer, hr %#lx.\n", hr);

-    hr = IMFSample_AddBuffer(sample, buffer);
+    hr = IMFSample_AddBuffer(output_sample, buffer);
     ok(hr == S_OK, "Failed to add a buffer, hr %#lx.\n", hr);

-    memset(&output_buffer, 0, sizeof(output_buffer));
-    output_buffer.pSample = sample;
+    memset(&output, 0, sizeof(output));
+    output.pSample = output_sample;
     flags = 0;
-    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output_buffer, &flags);
+    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &flags);
     todo_wine
     ok(hr == S_OK || broken(FAILED(hr)) /* Win8 */, "Failed to get output buffer, hr %#lx.\n", hr);
-    ok(output_buffer.dwStatus == 0, "Unexpected buffer status, %#lx.\n", output_buffer.dwStatus);
+    ok(output.dwStatus == 0, "Unexpected buffer status, %#lx.\n", output.dwStatus);
     ok(flags == 0, "Unexpected status %#lx.\n", flags);

if (SUCCEEDED(hr))
     {
-        memset(&output_buffer, 0, sizeof(output_buffer));
-        output_buffer.pSample = sample;
+        memset(&output, 0, sizeof(output));
+        output.pSample = output_sample;
         flags = 0;
-        hr = IMFTransform_ProcessOutput(transform, 0, 1, &output_buffer, &flags);
+        hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &flags);
         ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "Unexpected hr %#lx.\n", hr);
-        ok(output_buffer.dwStatus == 0, "Unexpected buffer status, %#lx.\n", output_buffer.dwStatus);
+        ok(output.dwStatus == 0, "Unexpected buffer status, %#lx.\n", output.dwStatus);
         ok(flags == 0, "Unexpected status %#lx.\n", flags);
     }

@@ -4036,9 +4029,9 @@ todo_wine {

ref = IMFMediaType_Release(media_type);
     ok(ref == 0, "Release returned %ld\n", ref);
-    ref = IMFSample_Release(sample2);
+    ref = IMFSample_Release(input_sample);
     ok(ref == 0, "Release returned %ld\n", ref);
-    ref = IMFSample_Release(sample);
+    ref = IMFSample_Release(output_sample);
     ok(ref == 0, "Release returned %ld\n", ref);
     ref = IMFMediaBuffer_Release(buffer);
     ok(ref == 0, "Release returned %ld\n", ref);
@@ -4192,18 +4185,18 @@ todo_wine {
     nv12frame_data_len = SizeofResource(GetModuleHandleW(NULL), resource);
     ok(nv12frame_data_len == 13824, "got length %lu\n", nv12frame_data_len);

-    sample = create_sample(nv12frame_data, nv12frame_data_len);
-    hr = IMFSample_SetSampleTime(sample, 0);
+    input_sample = create_sample(nv12frame_data, nv12frame_data_len);
+    hr = IMFSample_SetSampleTime(input_sample, 0);
     ok(hr == S_OK, "SetSampleTime returned %#lx\n", hr);
-    hr = IMFSample_SetSampleDuration(sample, 10000000);
+    hr = IMFSample_SetSampleDuration(input_sample, 10000000);
     ok(hr == S_OK, "SetSampleDuration returned %#lx\n", hr);
-    hr = IMFTransform_ProcessInput(transform, 0, sample, 0);
+    hr = IMFTransform_ProcessInput(transform, 0, input_sample, 0);
     ok(hr == S_OK, "ProcessInput returned %#lx\n", hr);
-    hr = IMFTransform_ProcessInput(transform, 0, sample, 0);
+    hr = IMFTransform_ProcessInput(transform, 0, input_sample, 0);
     ok(hr == MF_E_NOTACCEPTING, "ProcessInput returned %#lx\n", hr);
     hr = IMFTransform_ProcessMessage(transform, MFT_MESSAGE_COMMAND_DRAIN, 0);
     ok(hr == S_OK, "ProcessMessage returned %#lx\n", hr);
-    ret = IMFSample_Release(sample);
+    ret = IMFSample_Release(input_sample);
     ok(ret <= 1, "Release returned %ld\n", ret);

resource = FindResourceW(NULL, L"rgb32frame-vp.bin", (const WCHAR *)RT_RCDATA);
@@ -4219,9 +4212,8 @@ todo_wine {
     ok(output_file != INVALID_HANDLE_VALUE, "CreateFileW failed, error %lu\n", GetLastError());

status = 0xdeadbeef;
-    sample = create_sample(NULL, rgb32_data_len);
     memset(&output, 0, sizeof(output));
-    output.pSample = sample;
+    output.pSample = output_sample = create_sample(NULL, rgb32_data_len);
     hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
     ok(hr == S_OK || broken(hr == MF_E_SHUTDOWN) /* w8 */, "ProcessOutput returned %#lx\n", hr);
     if (hr != S_OK)
@@ -4230,21 +4222,21 @@ todo_wine {
         CloseHandle(output_file);
         goto skip_output;
     }
-    ok(output.pSample == sample, "got pSample %p\n", output.pSample);
+    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
     ok(output.dwStatus == 0 || broken(output.dwStatus == 6) /* win7 */, "got dwStatus %#lx\n", output.dwStatus);
     ok(status == 0xdeadbeef, "got status %#lx\n", status);

-    hr = IMFSample_GetSampleTime(sample, &time);
+    hr = IMFSample_GetSampleTime(output_sample, &time);
     ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
     ok(time == 0, "got time %I64d\n", time);
-    hr = IMFSample_GetSampleDuration(sample, &duration);
+    hr = IMFSample_GetSampleDuration(output_sample, &duration);
     ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
     ok(duration == 10000000, "got duration %I64d\n", duration);
-    hr = IMFSample_GetTotalLength(sample, &length);
+    hr = IMFSample_GetTotalLength(output_sample, &length);
     ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
     ok(length == output_info.cbSize, "got length %lu\n", length);

-    hr = IMFSample_ConvertToContiguousBuffer(sample, &buffer);
+    hr = IMFSample_ConvertToContiguousBuffer(output_sample, &buffer);
     ok(hr == S_OK, "ConvertToContiguousBuffer returned %#lx\n", hr);
     hr = IMFMediaBuffer_Lock(buffer, &ptr, NULL, &length);
     ok(hr == S_OK, "Lock returned %#lx\n", hr);
@@ -4259,31 +4251,30 @@ todo_wine {
     if (tmp == 0x00)
         win_skip("Frame got resized, skipping output comparison\n");
     else if (tmp == 0xcd) /* Wine doesn't flip the frame, yet */
-        check_sample_rgb32(sample, rgb32_data, output_file);
+        check_sample_rgb32(output_sample, rgb32_data, output_file);
     rgb32_data_len -= output_info.cbSize;
     rgb32_data += output_info.cbSize;

trace("created %s\n", debugstr_w(output_path));
     CloseHandle(output_file);

-    ret = IMFSample_Release(sample);
+    ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

status = 0xdeadbeef;
-    sample = create_sample(NULL, output_info.cbSize);
     memset(&output, 0, sizeof(output));
-    output.pSample = sample;
+    output.pSample = output_sample = create_sample(NULL, output_info.cbSize);
     hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
     ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#lx\n", hr);
-    ok(output.pSample == sample, "got pSample %p\n", output.pSample);
+    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
     ok(output.dwStatus == 0, "got dwStatus %#lx\n", output.dwStatus);
     ok(status == 0xdeadbeef, "got status %#lx\n", status);
-    hr = IMFSample_GetTotalLength(sample, &length);
+    hr = IMFSample_GetTotalLength(output_sample, &length);
     ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
     ok(length == 0, "got length %lu\n", length);

skip_output:
-    ret = IMFSample_Release(sample);
+    ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

ret = IMFTransform_Release(transform);
@@ -4419,6 +4410,7 @@ static void test_mp3_decoder(void)
     MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Audio, MFAudioFormat_PCM};
     MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Audio, MFAudioFormat_MP3};
     static const ULONG mp3dec_block_size = 0x1200;
+    IMFSample *input_sample, *output_sample;
     ULONG mp3dec_data_len, mp3enc_data_len;
     const BYTE *mp3dec_data, *mp3enc_data;
     MFT_OUTPUT_STREAM_INFO output_info;
@@ -4430,7 +4422,6 @@ static void test_mp3_decoder(void)
     LONGLONG time, duration;
     DWORD status, length;
     HANDLE output_file;
-    IMFSample *sample;
     HRSRC resource;
     ULONG i, ret;
     HRESULT hr;
@@ -4554,22 +4545,21 @@ static void test_mp3_decoder(void)
     mp3enc_data_len = SizeofResource(GetModuleHandleW(NULL), resource);
     ok(mp3enc_data_len == 6295, "got length %lu\n", mp3enc_data_len);

-    sample = create_sample(mp3enc_data, mp3enc_data_len);
-    hr = IMFTransform_ProcessInput(transform, 0, sample, 0);
+    input_sample = create_sample(mp3enc_data, mp3enc_data_len);
+    hr = IMFTransform_ProcessInput(transform, 0, input_sample, 0);
     ok(hr == S_OK, "ProcessInput returned %#lx\n", hr);
-    ret = IMFSample_Release(sample);
+    ret = IMFSample_Release(input_sample);
     ok(ret == 1, "Release returned %lu\n", ret);

-    sample = create_sample(mp3enc_data, mp3enc_data_len);
-    hr = IMFTransform_ProcessInput(transform, 0, sample, 0);
+    input_sample = create_sample(mp3enc_data, mp3enc_data_len);
+    hr = IMFTransform_ProcessInput(transform, 0, input_sample, 0);
     ok(hr == MF_E_NOTACCEPTING, "ProcessInput returned %#lx\n", hr);
-    ret = IMFSample_Release(sample);
+    ret = IMFSample_Release(input_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

status = 0xdeadbeef;
-    sample = create_sample(NULL, mp3dec_block_size);
     memset(&output, 0, sizeof(output));
-    output.pSample = sample;
+    output.pSample = output_sample = create_sample(NULL, mp3dec_block_size);

resource = FindResourceW(NULL, L"mp3decdata.bin", (const WCHAR *)RT_RCDATA);
     ok(resource != 0, "FindResourceW failed, error %lu\n", GetLastError());
@@ -4588,25 +4578,25 @@ static void test_mp3_decoder(void)

hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
     ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
-    ok(output.pSample == sample, "got pSample %p\n", output.pSample);
+    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
     ok(output.dwStatus == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE || output.dwStatus == 0 ||
             broken(output.dwStatus == (MFT_OUTPUT_DATA_BUFFER_INCOMPLETE|7) || output.dwStatus == 7) /* win7 */,
             "got dwStatus %#lx\n", output.dwStatus);
     ok(status == 0, "got status %#lx\n", status);

-    hr = IMFSample_GetSampleTime(sample, &time);
+    hr = IMFSample_GetSampleTime(output_sample, &time);
     ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
     ok(time == 0, "got time %I64d\n", time);
-    hr = IMFSample_GetSampleDuration(sample, &duration);
+    hr = IMFSample_GetSampleDuration(output_sample, &duration);
     ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
     ok(duration == 282993 || broken(duration == 522449) /* win8 */ || broken(duration == 261224) /* win7 */,
             "got duration %I64d\n", duration);
-    hr = IMFSample_GetTotalLength(sample, &length);
+    hr = IMFSample_GetTotalLength(output_sample, &length);
     ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
     ok(length == 0x9c0 || broken(length == mp3dec_block_size) /* win8 */ || broken(length == 0x900) /* win7 */,
             "got length %lu\n", length);
     ok(mp3dec_data_len > length, "got remaining length %lu\n", mp3dec_data_len);
-    if (length == 0x9c0) check_sample_pcm16(sample, mp3dec_data, output_file, FALSE);
+    if (length == 0x9c0) check_sample_pcm16(output_sample, mp3dec_data, output_file, FALSE);
     mp3dec_data_len -= 0x9c0;
     mp3dec_data += 0x9c0;

@@ -4615,7 +4605,7 @@ static void test_mp3_decoder(void)
     {
         winetest_push_context("%lu", i);
         ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
-        ok(output.pSample == sample, "got pSample %p\n", output.pSample);
+        ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
         ok(output.dwStatus == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE || output.dwStatus == 0 ||
                 broken(output.dwStatus == (MFT_OUTPUT_DATA_BUFFER_INCOMPLETE|7) || output.dwStatus == 7) /* win7 */,
                 "got dwStatus %#lx\n", output.dwStatus);
@@ -4626,20 +4616,20 @@ static void test_mp3_decoder(void)
             break;
         }

-        hr = IMFSample_GetSampleTime(sample, &time);
+        hr = IMFSample_GetSampleTime(output_sample, &time);
         ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
         ok(time == i, "got time %I64d\n", time);
-        hr = IMFSample_GetSampleDuration(sample, &duration);
+        hr = IMFSample_GetSampleDuration(output_sample, &duration);
         ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
         ok(duration == 522449 || broken(261225 - duration <= 1) /* win7 */,
                 "got duration %I64d\n", duration);
-        hr = IMFSample_GetTotalLength(sample, &length);
+        hr = IMFSample_GetTotalLength(output_sample, &length);
         ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
         ok(length == mp3dec_block_size || broken(length == 0x900) /* win7 */,
                 "got length %lu\n", length);
         ok(mp3dec_data_len > length || broken(mp3dec_data_len == 2304 || mp3dec_data_len == 0) /* win7 */,
                 "got remaining length %lu\n", mp3dec_data_len);
-        if (length == mp3dec_block_size) check_sample_pcm16(sample, mp3dec_data, output_file, FALSE);
+        if (length == mp3dec_block_size) check_sample_pcm16(output_sample, mp3dec_data, output_file, FALSE);
         mp3dec_data += min(mp3dec_data_len, length);
         mp3dec_data_len -= min(mp3dec_data_len, length);

@@ -4647,28 +4637,30 @@ static void test_mp3_decoder(void)
         i += duration;
     }

-    hr = IMFSample_GetSampleTime(sample, &time);
+    hr = IMFSample_GetSampleTime(output_sample, &time);
     ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
     ok(time == i || broken(time == i - duration) /* win7 */, "got time %I64d\n", time);
-    hr = IMFSample_GetSampleDuration(sample, &duration);
+    hr = IMFSample_GetSampleDuration(output_sample, &duration);
     ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
     todo_wine
     ok(duration == 522449 || broken(261225 - duration <= 1) /* win7 */, "got duration %I64d\n", duration);
-    hr = IMFSample_GetTotalLength(sample, &length);
+    hr = IMFSample_GetTotalLength(output_sample, &length);
     ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
     todo_wine
     ok(length == mp3dec_block_size || broken(length == 0) /* win7 */, "got length %lu\n", length);
     ok(mp3dec_data_len == mp3dec_block_size || broken(mp3dec_data_len == 0) /* win7 */, "got remaining length %lu\n", mp3dec_data_len);
-    check_sample_pcm16(sample, mp3dec_data, output_file, FALSE);
+    check_sample_pcm16(output_sample, mp3dec_data, output_file, FALSE);
     mp3dec_data_len -= length;
     mp3dec_data += length;

+    IMFSample_Release(output_sample);
+
     memset(&output, 0, sizeof(output));
-    output.pSample = sample;
+    output.pSample = output_sample = create_sample(NULL, mp3dec_block_size);
     hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
     todo_wine
     ok(hr == S_OK || broken(hr == MF_E_TRANSFORM_NEED_MORE_INPUT) /* win7 */, "ProcessOutput returned %#lx\n", hr);
-    ok(output.pSample == sample, "got pSample %p\n", output.pSample);
+    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
     todo_wine
     ok(output.dwStatus == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE || broken(output.dwStatus == 0) /* win7 */,
             "got dwStatus %#lx\n", output.dwStatus);
@@ -4676,41 +4668,40 @@ static void test_mp3_decoder(void)

if (hr == S_OK)
     {
-        hr = IMFSample_GetSampleTime(sample, &time);
+        hr = IMFSample_GetSampleTime(output_sample, &time);
         ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
         todo_wine
         ok(time == 10185486, "got time %I64d\n", time);
-        hr = IMFSample_GetSampleDuration(sample, &duration);
+        hr = IMFSample_GetSampleDuration(output_sample, &duration);
         ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
         todo_wine
         ok(duration == 14286, "got duration %I64d\n", duration);
-        hr = IMFSample_GetTotalLength(sample, &length);
+        hr = IMFSample_GetTotalLength(output_sample, &length);
         ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
         todo_wine
         ok(length == mp3dec_data_len, "got length %lu\n", length);
         if (length == mp3dec_data_len)
-            check_sample_pcm16(sample, mp3dec_data, output_file, FALSE);
+            check_sample_pcm16(output_sample, mp3dec_data, output_file, FALSE);
     }

trace("created %s\n", debugstr_w(output_path));
     CloseHandle(output_file);

-    ret = IMFSample_Release(sample);
+    ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

status = 0xdeadbeef;
-    sample = create_sample(NULL, mp3dec_block_size);
     memset(&output, 0, sizeof(output));
-    output.pSample = sample;
+    output.pSample = output_sample = create_sample(NULL, mp3dec_block_size);
     hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
     ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#lx\n", hr);
-    ok(output.pSample == sample, "got pSample %p\n", output.pSample);
+    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
     ok(output.dwStatus == 0, "got dwStatus %#lx\n", output.dwStatus);
     ok(status == 0, "got status %#lx\n", status);
-    hr = IMFSample_GetTotalLength(sample, &length);
+    hr = IMFSample_GetTotalLength(output_sample, &length);
     ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
     ok(length == 0, "got length %lu\n", length);
-    ret = IMFSample_Release(sample);
+    ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

ret = IMFTransform_Release(transform);

[PATCH v2 03/10] mf/tests: Factor IMFTransform_ProcessOutput checks together.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/mf/tests/transform.c | 436 +++++++++++++-------------------------
 1 file changed, 153 insertions(+), 283 deletions(-)

diff --git a/dlls/mf/tests/transform.c b/dlls/mf/tests/transform.c
index 5c9e3a24f79..9c7f0928fb2 100644
--- a/dlls/mf/tests/transform.c
+++ b/dlls/mf/tests/transform.c
@@ -311,6 +311,48 @@ static void check_mft_set_output_type_required_(int line, IMFTransform *transfor
     ok_(__FILE__, line)(!ref, "Release returned %lu\n", ref);
 }

+#define check_mft_process_output(a, b, c) check_mft_process_output_(__LINE__, a, b, c)
+static HRESULT check_mft_process_output_(int line, IMFTransform *transform, IMFSample *output_sample, DWORD *output_status)
+{
+    static const DWORD expect_flags = MFT_OUTPUT_DATA_BUFFER_INCOMPLETE | MFT_OUTPUT_DATA_BUFFER_FORMAT_CHANGE
+            | MFT_OUTPUT_DATA_BUFFER_STREAM_END | MFT_OUTPUT_DATA_BUFFER_NO_SAMPLE;
+    MFT_OUTPUT_DATA_BUFFER output[2];
+    HRESULT hr, ret;
+    DWORD status;
+
+    status = 0xdeadbeef;
+    memset(&output, 0xcd, sizeof(output));
+    output[0].pSample = output_sample;
+    output[1].pSample = output_sample;
+    hr = IMFTransform_ProcessOutput(transform, 0, 2, output, &status);
+    ok_(__FILE__, line)(hr == E_INVALIDARG, "ProcessOutput returned %#lx\n", hr);
+    ok_(__FILE__, line)(status == 0 || status == 0xdeadbeef, "got status %#lx\n", status);
+
+    status = 0;
+    memset(&output, 0, sizeof(output));
+    output[0].pSample = output_sample;
+    output[0].dwStreamID = 0;
+    ret = IMFTransform_ProcessOutput(transform, 0, 1, output, &status);
+    ok_(__FILE__, line)(output[0].dwStreamID == 0, "got dwStreamID %#lx\n", output[0].dwStreamID);
+    ok_(__FILE__, line)(output[0].pEvents == NULL, "got pEvents %p\n", output[0].pEvents);
+    ok_(__FILE__, line)(output[0].pSample == output_sample, "got pSample %p\n", output[0].pSample);
+    ok_(__FILE__, line)((output[0].dwStatus & ~expect_flags) == 0
+            || broken((output[0].dwStatus & ~expect_flags) == 6) /* Win7 */
+            || broken((output[0].dwStatus & ~expect_flags) == 7) /* Win7 */,
+            "got dwStatus %#lx\n", output[0].dwStatus);
+    *output_status = output[0].dwStatus & expect_flags;
+
+    if (!output_sample)
+        ok_(__FILE__, line)(status == 0, "got status %#lx\n", status);
+    else if (ret == MF_E_TRANSFORM_STREAM_CHANGE)
+        ok_(__FILE__, line)(status == MFT_PROCESS_OUTPUT_STATUS_NEW_STREAMS,
+                "got status %#lx\n", status);
+    else
+        ok_(__FILE__, line)(status == 0, "got status %#lx\n", status);
+
+    return ret;
+}
+
 static HRESULT WINAPI test_unk_QueryInterface(IUnknown *iface, REFIID riid, void **obj)
 {
     if (IsEqualIID(riid, &IID_IUnknown))
@@ -394,18 +436,17 @@ static BOOL is_sample_copier_available_type(IMFMediaType *type)

static void test_sample_copier(void)
 {
+    DWORD input_count, output_count, output_status;
     IMFAttributes *attributes, *attributes2;
     DWORD in_min, in_max, out_min, out_max;
     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;
+    DWORD flags;
     HRESULT hr;
     LONG ref;

@@ -641,15 +682,14 @@ static void test_sample_copier(void)
     ok(hr == S_OK, "Failed to add a buffer, hr %#lx.\n", hr);
     IMFMediaBuffer_Release(media_buffer);

-    status = 0;
-    memset(&buffer, 0, sizeof(buffer));
-    buffer.pSample = client_sample;
-    hr = IMFTransform_ProcessOutput(copier, 0, 1, &buffer, &status);
+    hr = check_mft_process_output(copier, client_sample, &output_status);
     ok(hr == S_OK, "Failed to get output, hr %#lx.\n", hr);
+    ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);
     EXPECT_REF(sample, 1);

-    hr = IMFTransform_ProcessOutput(copier, 0, 1, &buffer, &status);
+    hr = check_mft_process_output(copier, client_sample, &output_status);
     ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "Failed to get output, hr %#lx.\n", hr);
+    ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);

/* Flushing. */
     hr = IMFTransform_ProcessInput(copier, 0, sample, 0);
@@ -684,8 +724,7 @@ static void sample_copier_process(IMFTransform *copier, IMFMediaBuffer *input_bu
 {
     static const struct sample_metadata zero_md = { 0, ~0u, ~0u };
     IMFSample *input_sample, *output_sample;
-    MFT_OUTPUT_DATA_BUFFER buffer;
-    DWORD flags, status;
+    DWORD flags, output_status;
     LONGLONG time;
     HRESULT hr;
     LONG ref;
@@ -726,11 +765,9 @@ static void sample_copier_process(IMFTransform *copier, IMFMediaBuffer *input_bu
     hr = IMFTransform_ProcessInput(copier, 0, input_sample, 0);
     ok(hr == S_OK, "Failed to process input, hr %#lx.\n", hr);

-    status = 0;
-    memset(&buffer, 0, sizeof(buffer));
-    buffer.pSample = output_sample;
-    hr = IMFTransform_ProcessOutput(copier, 0, 1, &buffer, &status);
+    hr = check_mft_process_output(copier, output_sample, &output_status);
     ok(hr == S_OK, "Failed to get output, hr %#lx.\n", hr);
+    ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);

if (!md) md = &zero_md;

@@ -1429,11 +1466,10 @@ static void test_wma_encoder(void)
     const BYTE *audio_data, *wmaenc_data;
     MFT_OUTPUT_STREAM_INFO output_info;
     MFT_INPUT_STREAM_INFO input_info;
-    MFT_OUTPUT_DATA_BUFFER output;
     WCHAR output_path[MAX_PATH];
+    DWORD length, output_status;
     IMFMediaType *media_type;
     IMFTransform *transform;
-    DWORD status, length;
     HANDLE output_file;
     HRSRC resource;
     ULONG i, ret;
@@ -1516,9 +1552,7 @@ static void test_wma_encoder(void)
     ref = IMFSample_Release(input_sample);
     ok(ref <= 1, "Release returned %ld\n", ref);

-    status = 0xdeadbeef;
-    memset(&output, 0, sizeof(output));
-    output.pSample = output_sample = create_sample(NULL, output_info.cbSize);
+    output_sample = create_sample(NULL, output_info.cbSize);

resource = FindResourceW(NULL, L"wmaencdata.bin", (const WCHAR *)RT_RCDATA);
     ok(resource != 0, "FindResourceW failed, error %lu\n", GetLastError());
@@ -1532,39 +1566,30 @@ static void test_wma_encoder(void)
     output_file = CreateFileW(output_path, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
     ok(output_file != INVALID_HANDLE_VALUE, "CreateFileW failed, error %lu\n", GetLastError());

-    i = 0;
-    while (SUCCEEDED(hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status)))
+    for (i = 0; SUCCEEDED(hr = check_mft_process_output(transform, output_sample, &output_status)); i++)
     {
         winetest_push_context("%lu", i);
         ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
-        ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
-        ok(output.dwStatus == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE ||
-                broken(output.dwStatus == (MFT_OUTPUT_DATA_BUFFER_INCOMPLETE|7)) /* win7 */,
-                "got dwStatus %#lx\n", output.dwStatus);
-        ok(status == 0, "got status %#lx\n", status);
+        ok(output_status == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE, "got output[0].dwStatus %#lx\n", output_status);
         hr = IMFSample_GetTotalLength(output_sample, &length);
         ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
         ok(length == wmaenc_block_size, "got length %lu\n", length);
         ok(wmaenc_data_len > i * wmaenc_block_size, "got %lu blocks\n", i);
         check_sample(output_sample, wmaenc_data + i * wmaenc_block_size, output_file);
         winetest_pop_context();
-        i++;
     }
+    ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#lx\n", hr);
+    ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);
+    ret = IMFSample_Release(output_sample);
+    ok(ret == 0, "Release returned %lu\n", ret);

trace("created %s\n", debugstr_w(output_path));
     CloseHandle(output_file);

-    ret = IMFSample_Release(output_sample);
-    ok(ret == 0, "Release returned %lu\n", ret);
-
-    status = 0xdeadbeef;
-    memset(&output, 0, sizeof(output));
-    output.pSample = output_sample = create_sample(NULL, output_info.cbSize);
-    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
+    output_sample = create_sample(NULL, output_info.cbSize);
+    hr = check_mft_process_output(transform, output_sample, &output_status);
     ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#lx\n", hr);
-    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
-    ok(output.dwStatus == 0, "got dwStatus %#lx\n", output.dwStatus);
-    ok(status == 0, "got status %#lx\n", status);
+    ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);
     hr = IMFSample_GetTotalLength(output_sample, &length);
     ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
     ok(length == 0, "got length %lu\n", length);
@@ -1698,10 +1723,8 @@ static void test_wma_decoder(void)
     ULONG wmadec_data_len, wmaenc_data_len;
     const BYTE *wmadec_data, *wmaenc_data;
     MFT_OUTPUT_STREAM_INFO output_info;
-    MFT_OUTPUT_DATA_BUFFER outputs[2];
+    DWORD flags, length, output_status;
     MFT_INPUT_STREAM_INFO input_info;
-    MFT_OUTPUT_DATA_BUFFER output;
-    DWORD status, flags, length;
     WCHAR output_path[MAX_PATH];
     IMediaObject *media_object;
     IPropertyBag *property_bag;
@@ -1853,17 +1876,11 @@ static void test_wma_decoder(void)
     /* As output_info.dwFlags doesn't have MFT_OUTPUT_STREAM_CAN_PROVIDE_SAMPLES
      * IMFTransform_ProcessOutput needs a sample or returns MF_E_TRANSFORM_NEED_MORE_INPUT */

-    status = 0xdeadbeef;
-    memset(&output, 0, sizeof(output));
-    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
+    hr = check_mft_process_output(transform, NULL, &output_status);
     ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#lx\n", hr);
-    ok(output.dwStreamID == 0, "got dwStreamID %lu\n", output.dwStreamID);
-    ok(!output.pSample, "got pSample %p\n", output.pSample);
-    ok(output.dwStatus == MFT_OUTPUT_DATA_BUFFER_NO_SAMPLE ||
-            broken(output.dwStatus == (MFT_OUTPUT_DATA_BUFFER_INCOMPLETE|MFT_OUTPUT_DATA_BUFFER_NO_SAMPLE)) /* Win7 */,
-            "got dwStatus %#lx\n", output.dwStatus);
-    ok(!output.pEvents, "got pEvents %p\n", output.pEvents);
-    ok(status == 0, "got status %#lx\n", status);
+    ok(output_status == MFT_OUTPUT_DATA_BUFFER_NO_SAMPLE
+            || broken(output_status == (MFT_OUTPUT_DATA_BUFFER_INCOMPLETE|MFT_OUTPUT_DATA_BUFFER_NO_SAMPLE)) /* Win7 */,
+            "got output[0].dwStatus %#lx\n", output_status);

input_sample = create_sample(wmaenc_data, wmaenc_block_size);
     hr = IMFTransform_ProcessInput(transform, 0, input_sample, 0);
@@ -1871,27 +1888,11 @@ static void test_wma_decoder(void)
     ret = IMFSample_Release(input_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

-    status = 0xdeadbeef;
-    memset(&output, 0, sizeof(output));
-    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
+    hr = check_mft_process_output(transform, NULL, &output_status);
     ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#lx\n", hr);
-    ok(!output.pSample, "got pSample %p\n", output.pSample);
-    ok(output.dwStatus == MFT_OUTPUT_DATA_BUFFER_NO_SAMPLE ||
-            broken(output.dwStatus == (MFT_OUTPUT_DATA_BUFFER_INCOMPLETE|MFT_OUTPUT_DATA_BUFFER_NO_SAMPLE)) /* Win7 */,
-            "got dwStatus %#lx\n", output.dwStatus);
-    ok(status == 0, "got status %#lx\n", status);
-
-    status = 0xdeadbeef;
-    memset(&output, 0, sizeof(output));
-    output_info.cbSize = wmadec_block_size;
-    outputs[0].pSample = create_sample(NULL, output_info.cbSize);
-    outputs[1].pSample = create_sample(NULL, output_info.cbSize);
-    hr = IMFTransform_ProcessOutput(transform, 0, 2, outputs, &status);
-    ok(hr == E_INVALIDARG, "ProcessOutput returned %#lx\n", hr);
-    ref = IMFSample_Release(outputs[0].pSample);
-    ok(ref == 0, "Release returned %ld\n", ref);
-    ref = IMFSample_Release(outputs[1].pSample);
-    ok(ref == 0, "Release returned %ld\n", ref);
+    ok(output_status == MFT_OUTPUT_DATA_BUFFER_NO_SAMPLE
+            || broken(output_status == (MFT_OUTPUT_DATA_BUFFER_INCOMPLETE|MFT_OUTPUT_DATA_BUFFER_NO_SAMPLE)) /* Win7 */,
+            "got output[0].dwStatus %#lx\n", output_status);

resource = FindResourceW(NULL, L"wmadecdata.bin", (const WCHAR *)RT_RCDATA);
     ok(resource != 0, "FindResourceW failed, error %lu\n", GetLastError());
@@ -1905,22 +1906,15 @@ static void test_wma_decoder(void)
     output_file = CreateFileW(output_path, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
     ok(output_file != INVALID_HANDLE_VALUE, "CreateFileW failed, error %lu\n", GetLastError());

-    status = 0xdeadbeef;
     output_info.cbSize = wmadec_block_size;
-    memset(&output, 0, sizeof(output));
-    output.pSample = output_sample = create_sample(NULL, output_info.cbSize);
-    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
+    output_sample = create_sample(NULL, output_info.cbSize);
+    hr = check_mft_process_output(transform, output_sample, &output_status);

for (i = 0; i < 4; ++i)
     {
         winetest_push_context("%lu", i);

ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
-        ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
-        ok(output.dwStatus == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE || output.dwStatus == 0 ||
-                broken(output.dwStatus == (MFT_OUTPUT_DATA_BUFFER_INCOMPLETE|7) || output.dwStatus == 7) /* Win7 */,
-                "got dwStatus %#lx\n", output.dwStatus);
-        ok(status == 0, "got status %#lx\n", status);
         value = 0xdeadbeef;
         hr = IMFSample_GetUINT32(output_sample, &MFSampleExtension_CleanPoint, &value);
         ok(hr == S_OK, "GetUINT32 MFSampleExtension_CleanPoint returned %#lx\n", hr);
@@ -1938,9 +1932,10 @@ static void test_wma_decoder(void)
         duration = 0xdeadbeef;
         hr = IMFSample_GetSampleDuration(output_sample, &duration);
         ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
-        if (output.dwStatus == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE ||
-                broken(output.dwStatus == (MFT_OUTPUT_DATA_BUFFER_INCOMPLETE|7)))
+
+        if (output_status & MFT_OUTPUT_DATA_BUFFER_INCOMPLETE)
         {
+            ok(output_status == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE, "got output[0].dwStatus %#lx\n", output_status);
             ok(length == wmadec_block_size, "got length %lu\n", length);
             ok(duration == 928798, "got duration %I64d\n", duration);
             check_sample_pcm16(output_sample, wmadec_data, output_file, TRUE);
@@ -1949,6 +1944,7 @@ static void test_wma_decoder(void)
         }
         else
         {
+            ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);
             /* FFmpeg doesn't seem to decode WMA buffers in the same way as native */
             todo_wine
             ok(length == wmadec_block_size / 2, "got length %lu\n", length);
@@ -1963,10 +1959,8 @@ static void test_wma_decoder(void)
         ret = IMFSample_Release(output_sample);
         ok(ret == 0, "Release returned %lu\n", ret);

-        status = 0xdeadbeef;
-        memset(&output, 0, sizeof(output));
-        output.pSample = output_sample = create_sample(NULL, output_info.cbSize);
-        hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
+        output_sample = create_sample(NULL, output_info.cbSize);
+        hr = check_mft_process_output(transform, output_sample, &output_status);

winetest_pop_context();

@@ -1980,22 +1974,14 @@ static void test_wma_decoder(void)
     CloseHandle(output_file);

ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#lx\n", hr);
-    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
-    ok(output.dwStatus == 0, "got dwStatus %#lx\n", output.dwStatus);
-    ok(status == 0, "got status %#lx\n", status);
+    ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);
     ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

-    status = 0xdeadbeef;
-    memset(&output, 0, sizeof(output));
-    output.pSample = output_sample = create_sample(NULL, output_info.cbSize);
-    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
+    output_sample = create_sample(NULL, output_info.cbSize);
+    hr = check_mft_process_output(transform, output_sample, &output_status);
     ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#lx\n", hr);
-    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
-    ok(output.dwStatus == 0 ||
-            broken(output.dwStatus == (MFT_OUTPUT_DATA_BUFFER_INCOMPLETE|7)) /* Win7 */,
-            "got dwStatus %#lx\n", output.dwStatus);
-    ok(status == 0, "got status %#lx\n", status);
+    ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);
     hr = IMFSample_GetTotalLength(output_sample, &length);
     ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
     ok(length == 0, "got length %lu\n", length);
@@ -2285,10 +2271,9 @@ static void test_h264_decoder(void)
     DWORD input_id, output_id, input_count, output_count;
     IMFSample *input_sample, *output_sample;
     MFT_OUTPUT_STREAM_INFO output_info;
+    DWORD length, count, output_status;
     MFT_INPUT_STREAM_INFO input_info;
-    MFT_OUTPUT_DATA_BUFFER output;
     IMFMediaBuffer *media_buffer;
-    DWORD status, length, count;
     WCHAR output_path[MAX_PATH];
     IMFAttributes *attributes;
     IMFMediaType *media_type;
@@ -2480,31 +2465,19 @@ static void test_h264_decoder(void)
     /* As output_info.dwFlags doesn't have MFT_OUTPUT_STREAM_CAN_PROVIDE_SAMPLES
      * IMFTransform_ProcessOutput needs a sample or returns an error */

-    status = 0;
-    memset(&output, 0, sizeof(output));
-    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
+    hr = check_mft_process_output(transform, NULL, &output_status);
     ok(hr == E_INVALIDARG || hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#lx\n", hr);
-    ok(output.dwStreamID == 0, "got dwStreamID %lu\n", output.dwStreamID);
-    ok(!output.pSample, "got pSample %p\n", output.pSample);
-    ok(output.dwStatus == 0, "got dwStatus %#lx\n", output.dwStatus);
-    ok(!output.pEvents, "got pEvents %p\n", output.pEvents);
-    ok(status == 0, "got status %#lx\n", status);
+    ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);

i = 0;
     input_sample = next_h264_sample(&h264_encoded_data, &h264_encoded_data_len);
     while (1)
     {
-        status = 0;
-        memset(&output, 0, sizeof(output));
-        output.pSample = output_sample = create_sample(NULL, output_info.cbSize);
-        hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
+        output_sample = create_sample(NULL, output_info.cbSize);
+        hr = check_mft_process_output(transform, output_sample, &output_status);
         if (hr != MF_E_TRANSFORM_NEED_MORE_INPUT) break;
         ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#lx\n", hr);
-        ok(output.dwStreamID == 0, "got dwStreamID %lu\n", output.dwStreamID);
-        ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
-        ok(output.dwStatus == 0, "got dwStatus %#lx\n", output.dwStatus);
-        ok(!output.pEvents, "got pEvents %p\n", output.pEvents);
-        ok(status == 0, "got status %#lx\n", status);
+        ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);
         hr = IMFSample_GetTotalLength(output_sample, &length);
         ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
         ok(length == 0, "got length %lu\n", length);
@@ -2532,13 +2505,7 @@ static void test_h264_decoder(void)
     todo_wine
     ok(h264_encoded_data_len == 1180, "got h264_encoded_data_len %lu\n", h264_encoded_data_len);
     ok(hr == MF_E_TRANSFORM_STREAM_CHANGE, "ProcessOutput returned %#lx\n", hr);
-    ok(output.dwStreamID == 0, "got dwStreamID %lu\n", output.dwStreamID);
-    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
-    ok(output.dwStatus == MFT_OUTPUT_DATA_BUFFER_FORMAT_CHANGE,
-            "got dwStatus %#lx\n", output.dwStatus);
-    ok(!output.pEvents, "got pEvents %p\n", output.pEvents);
-    ok(status == MFT_PROCESS_OUTPUT_STATUS_NEW_STREAMS,
-            "got status %#lx\n", status);
+    ok(output_status == MFT_OUTPUT_DATA_BUFFER_FORMAT_CHANGE, "got output[0].dwStatus %#lx\n", output_status);
     hr = IMFSample_GetTotalLength(output_sample, &length);
     ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
     ok(length == 0, "got length %lu\n", length);
@@ -2587,16 +2554,10 @@ static void test_h264_decoder(void)
     nv12_frame_len = SizeofResource(GetModuleHandleW(NULL), resource);
     ok(nv12_frame_len == actual_width * actual_height * 3 / 2, "got frame length %lu\n", nv12_frame_len);

-    status = 0;
-    memset(&output, 0, sizeof(output));
-    output.pSample = output_sample = create_sample(NULL, nv12_frame_len);
-    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
+    output_sample = create_sample(NULL, nv12_frame_len);
+    hr = check_mft_process_output(transform, output_sample, &output_status);
     ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
-    ok(output.dwStreamID == 0, "got dwStreamID %lu\n", output.dwStreamID);
-    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
-    ok(output.dwStatus == 0, "got dwStatus %#lx\n", output.dwStatus);
-    ok(!output.pEvents, "got pEvents %p\n", output.pEvents);
-    ok(status == 0, "got status %#lx\n", status);
+    ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);

hr = IMFSample_GetUINT32(output_sample, &MFSampleExtension_CleanPoint, &value);
     ok(hr == S_OK, "GetUINT32 MFSampleExtension_CleanPoint returned %#lx\n", hr);
@@ -2671,12 +2632,12 @@ static void test_h264_decoder(void)
     ret = IMFMediaType_Release(media_type);
     ok(ret == 0, "Release returned %lu\n", ret);

-    status = 0;
-    memset(&output, 0, sizeof(output));
-    output.pSample = output_sample = create_sample(NULL, actual_width * actual_height * 2);
-    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
+    output_sample = create_sample(NULL, actual_width * actual_height * 2);
+    hr = check_mft_process_output(transform, output_sample, &output_status);
     todo_wine
     ok(hr == MF_E_TRANSFORM_STREAM_CHANGE, "ProcessOutput returned %#lx\n", hr);
+    todo_wine
+    ok(output_status == MFT_OUTPUT_DATA_BUFFER_FORMAT_CHANGE, "got output[0].dwStatus %#lx\n", output_status);

while (hr == MF_E_TRANSFORM_NEED_MORE_INPUT)
     {
@@ -2685,16 +2646,12 @@ static void test_h264_decoder(void)
         ret = IMFSample_Release(input_sample);
         ok(ret <= 1, "Release returned %lu\n", ret);
         input_sample = next_h264_sample(&h264_encoded_data, &h264_encoded_data_len);
-        hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
+        hr = check_mft_process_output(transform, output_sample, &output_status);
         todo_wine_if(hr == MF_E_TRANSFORM_NEED_MORE_INPUT)
         ok(hr == MF_E_TRANSFORM_STREAM_CHANGE, "ProcessOutput returned %#lx\n", hr);
+        ok(output_status == MFT_OUTPUT_DATA_BUFFER_FORMAT_CHANGE, "got output[0].dwStatus %#lx\n", output_status);
     }

-    ok(output.dwStreamID == 0, "got dwStreamID %lu\n", output.dwStreamID);
-    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
-    ok(output.dwStatus == MFT_OUTPUT_DATA_BUFFER_FORMAT_CHANGE, "got dwStatus %#lx\n", output.dwStatus);
-    ok(!output.pEvents, "got pEvents %p\n", output.pEvents);
-    ok(status == MFT_PROCESS_OUTPUT_STATUS_NEW_STREAMS, "got status %#lx\n", status);
     hr = IMFSample_GetTotalLength(output_sample, &length);
     ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
     ok(length == 0, "got length %lu\n", length);
@@ -2712,16 +2669,10 @@ static void test_h264_decoder(void)
     i420_frame_len = SizeofResource(GetModuleHandleW(NULL), resource);
     ok(i420_frame_len == actual_width * actual_height * 3 / 2, "got frame length %lu\n", i420_frame_len);

-    status = 0;
-    memset(&output, 0, sizeof(output));
-    output.pSample = output_sample = create_sample(NULL, actual_width * actual_height * 2);
-    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
+    output_sample = create_sample(NULL, actual_width * actual_height * 2);
+    hr = check_mft_process_output(transform, output_sample, &output_status);
     ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
-    ok(output.dwStreamID == 0, "got dwStreamID %lu\n", output.dwStreamID);
-    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
-    ok(output.dwStatus == 0, "got dwStatus %#lx\n", output.dwStatus);
-    ok(!output.pEvents, "got pEvents %p\n", output.pEvents);
-    ok(status == 0, "got status %#lx\n", status);
+    ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);

hr = IMFSample_GetSampleTime(output_sample, &time);
     ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
@@ -2767,17 +2718,11 @@ static void test_h264_decoder(void)
     trace("created %s\n", debugstr_w(output_path));
     CloseHandle(output_file);

-    status = 0;
-    memset(&output, 0, sizeof(output));
-    output.pSample = output_sample = create_sample(NULL, actual_width * actual_height * 2);
-    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
+    output_sample = create_sample(NULL, actual_width * actual_height * 2);
+    hr = check_mft_process_output(transform, output_sample, &output_status);
     todo_wine_if(hr == S_OK)  /* when VA-API plugin is used */
     ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#lx\n", hr);
-    ok(output.dwStreamID == 0, "got dwStreamID %lu\n", output.dwStreamID);
-    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
-    ok(output.dwStatus == 0, "got dwStatus %#lx\n", output.dwStatus);
-    ok(!output.pEvents, "got pEvents %p\n", output.pEvents);
-    ok(status == 0, "got status %#lx\n", status);
+    ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);
     ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

@@ -2905,12 +2850,11 @@ static void test_audio_convert(void)
     const BYTE *audio_data, *audioconv_data;
     MFT_OUTPUT_STREAM_INFO output_info;
     MFT_INPUT_STREAM_INFO input_info;
-    MFT_OUTPUT_DATA_BUFFER output;
     WCHAR output_path[MAX_PATH];
+    DWORD length, output_status;
     IMFMediaType *media_type;
     LONGLONG time, duration;
     IMFTransform *transform;
-    DWORD length, status;
     HANDLE output_file;
     HRSRC resource;
     ULONG i, ret;
@@ -3057,9 +3001,7 @@ static void test_audio_convert(void)
     ret = IMFSample_Release(input_sample);
     ok(ret <= 1, "Release returned %ld\n", ret);

-    status = 0xdeadbeef;
-    memset(&output, 0, sizeof(output));
-    output.pSample = output_sample = create_sample(NULL, audioconv_block_size);
+    output_sample = create_sample(NULL, audioconv_block_size);

resource = FindResourceW(NULL, L"audioconvdata.bin", (const WCHAR *)RT_RCDATA);
     ok(resource != 0, "FindResourceW failed, error %lu\n", GetLastError());
@@ -3074,21 +3016,18 @@ static void test_audio_convert(void)
     ok(output_file != INVALID_HANDLE_VALUE, "CreateFileW failed, error %lu\n", GetLastError());

i = 0;
-    while (SUCCEEDED(hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status)))
+    while (SUCCEEDED(hr = check_mft_process_output(transform, output_sample, &output_status)))
     {
         winetest_push_context("%lu", i);
         ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
-        ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
-        ok(output.dwStatus == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE || output.dwStatus == 0 ||
-                broken(output.dwStatus == (MFT_OUTPUT_DATA_BUFFER_INCOMPLETE|6) || output.dwStatus == 6) /* win7 */,
-                "got dwStatus %#lx\n", output.dwStatus);
-        ok(status == 0, "got status %#lx\n", status);
-        if (!(output.dwStatus & MFT_OUTPUT_DATA_BUFFER_INCOMPLETE))
+        if (!(output_status & MFT_OUTPUT_DATA_BUFFER_INCOMPLETE))
         {
+            ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);
             winetest_pop_context();
             break;
         }

+        ok(output_status == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE, "got output[0].dwStatus %#lx\n", output_status);
         hr = IMFSample_GetSampleTime(output_sample, &time);
         ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
         ok(time == i * 928798, "got time %I64d\n", time);
@@ -3126,17 +3065,14 @@ static void test_audio_convert(void)
     ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

-    status = 0xdeadbeef;
-    memset(&output, 0, sizeof(output));
-    output.pSample = output_sample = create_sample(NULL, audioconv_block_size);
-    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
+    output_sample = create_sample(NULL, audioconv_block_size);
+    hr = check_mft_process_output(transform, output_sample, &output_status);
     todo_wine
-    ok(hr == S_OK || broken(hr == MF_E_TRANSFORM_NEED_MORE_INPUT) /* win7 */, "ProcessOutput returned %#lx\n", hr);
-    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
+    ok(hr == S_OK || broken(hr == MF_E_TRANSFORM_NEED_MORE_INPUT) /* Win7 */,
+            "ProcessOutput returned %#lx\n", hr);
     todo_wine
-    ok(output.dwStatus == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE || broken(output.dwStatus == 0) /* win7 */,
-            "got dwStatus %#lx\n", output.dwStatus);
-    ok(status == 0, "got status %#lx\n", status);
+    ok(output_status == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE || broken(output_status == 0) /* Win7 */,
+            "got output[0].dwStatus %#lx\n", output_status);

if (hr == S_OK)
     {
@@ -3162,14 +3098,10 @@ static void test_audio_convert(void)
     ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

-    status = 0xdeadbeef;
-    memset(&output, 0, sizeof(output));
-    output.pSample = output_sample = create_sample(NULL, audioconv_block_size);
-    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
+    output_sample = create_sample(NULL, audioconv_block_size);
+    hr = check_mft_process_output(transform, output_sample, &output_status);
     ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#lx\n", hr);
-    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
-    ok(output.dwStatus == 0, "got dwStatus %#lx\n", output.dwStatus);
-    ok(status == 0, "got status %#lx\n", status);
+    ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);
     hr = IMFSample_GetTotalLength(output_sample, &length);
     ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
     ok(length == 0, "got length %lu\n", length);
@@ -3356,12 +3288,11 @@ static void test_color_convert(void)
     IMFSample *input_sample, *output_sample;
     MFT_OUTPUT_STREAM_INFO output_info;
     MFT_INPUT_STREAM_INFO input_info;
-    MFT_OUTPUT_DATA_BUFFER output;
     WCHAR output_path[MAX_PATH];
+    DWORD length, output_status;
     IMFMediaType *media_type;
     LONGLONG time, duration;
     IMFTransform *transform;
-    DWORD length, status;
     HANDLE output_file;
     HRSRC resource;
     ULONG i, ret;
@@ -3499,14 +3430,10 @@ static void test_color_convert(void)
     output_file = CreateFileW(output_path, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
     ok(output_file != INVALID_HANDLE_VALUE, "CreateFileW failed, error %lu\n", GetLastError());

-    status = 0xdeadbeef;
-    memset(&output, 0, sizeof(output));
-    output.pSample = output_sample = create_sample(NULL, output_info.cbSize);
-    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
+    output_sample = create_sample(NULL, output_info.cbSize);
+    hr = check_mft_process_output(transform, output_sample, &output_status);
     ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
-    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
-    ok(output.dwStatus == 0 || broken(output.dwStatus == 6) /* win7 */, "got dwStatus %#lx\n", output.dwStatus);
-    ok(status == 0, "got status %#lx\n", status);
+    ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);

hr = IMFSample_GetSampleTime(output_sample, &time);
     ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
@@ -3527,14 +3454,10 @@ static void test_color_convert(void)
     ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

-    status = 0xdeadbeef;
-    memset(&output, 0, sizeof(output));
-    output.pSample = output_sample = create_sample(NULL, output_info.cbSize);
-    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
+    output_sample = create_sample(NULL, output_info.cbSize);
+    hr = check_mft_process_output(transform, output_sample, &output_status);
     ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#lx\n", hr);
-    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
-    ok(output.dwStatus == 0, "got dwStatus %#lx\n", output.dwStatus);
-    ok(status == 0, "got status %#lx\n", status);
+    ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);
     hr = IMFSample_GetTotalLength(output_sample, &length);
     ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
     ok(length == 0, "got length %lu\n", length);
@@ -3722,13 +3645,12 @@ static void test_video_processor(void)
     const GUID *expect_available_inputs;
     MFT_OUTPUT_STREAM_INFO output_info;
     MFT_INPUT_STREAM_INFO input_info;
-    MFT_OUTPUT_DATA_BUFFER output;
+    DWORD length, output_status;
     WCHAR output_path[MAX_PATH];
     LONGLONG time, duration;
     IMFTransform *transform;
     IMFMediaBuffer *buffer;
     IMFMediaEvent *event;
-    DWORD length, status;
     unsigned int value;
     HANDLE output_file;
     HRSRC resource;
@@ -3958,14 +3880,9 @@ todo_wine {
     hr = MFCreateSample(&output_sample);
     ok(hr == S_OK, "Failed to create a sample, hr %#lx.\n", hr);

-    memset(&output, 0, sizeof(output));
-    output.pSample = output_sample;
-    flags = 0;
-    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &flags);
+    hr = check_mft_process_output(transform, output_sample, &output_status);
     todo_wine
     ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "Unexpected hr %#lx.\n", hr);
-    ok(output.dwStatus == 0, "Unexpected buffer status, %#lx.\n", output.dwStatus);
-    ok(flags == 0, "Unexpected status %#lx.\n", flags);

hr = IMFTransform_ProcessInput(transform, 0, input_sample, 0);
     todo_wine
@@ -3975,25 +3892,15 @@ todo_wine {
     todo_wine
     ok(hr == MF_E_NOTACCEPTING, "Unexpected hr %#lx.\n", hr);

-    memset(&output, 0, sizeof(output));
-    output.pSample = output_sample;
-    flags = 0;
-    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &flags);
+    hr = check_mft_process_output(transform, output_sample, &output_status);
     todo_wine
     ok(hr == MF_E_NO_SAMPLE_TIMESTAMP, "Unexpected hr %#lx.\n", hr);
-    ok(output.dwStatus == 0, "Unexpected buffer status, %#lx.\n", output.dwStatus);
-    ok(flags == 0, "Unexpected status %#lx.\n", flags);

hr = IMFSample_SetSampleTime(input_sample, 0);
     ok(hr == S_OK, "Failed to set sample time, hr %#lx.\n", hr);
-    memset(&output, 0, sizeof(output));
-    output.pSample = output_sample;
-    flags = 0;
-    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &flags);
+    hr = check_mft_process_output(transform, output_sample, &output_status);
     todo_wine
     ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
-    ok(output.dwStatus == 0, "Unexpected buffer status, %#lx.\n", output.dwStatus);
-    ok(flags == 0, "Unexpected status %#lx.\n", flags);

hr = MFCreateMemoryBuffer(1024 * 1024, &buffer);
     ok(hr == S_OK, "Failed to create a buffer, hr %#lx.\n", hr);
@@ -4004,24 +3911,14 @@ todo_wine {
     hr = IMFSample_AddBuffer(output_sample, buffer);
     ok(hr == S_OK, "Failed to add a buffer, hr %#lx.\n", hr);

-    memset(&output, 0, sizeof(output));
-    output.pSample = output_sample;
-    flags = 0;
-    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &flags);
+    hr = check_mft_process_output(transform, output_sample, &output_status);
     todo_wine
     ok(hr == S_OK || broken(FAILED(hr)) /* Win8 */, "Failed to get output buffer, hr %#lx.\n", hr);
-    ok(output.dwStatus == 0, "Unexpected buffer status, %#lx.\n", output.dwStatus);
-    ok(flags == 0, "Unexpected status %#lx.\n", flags);

if (SUCCEEDED(hr))
     {
-        memset(&output, 0, sizeof(output));
-        output.pSample = output_sample;
-        flags = 0;
-        hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &flags);
+        hr = check_mft_process_output(transform, output_sample, &output_status);
         ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "Unexpected hr %#lx.\n", hr);
-        ok(output.dwStatus == 0, "Unexpected buffer status, %#lx.\n", output.dwStatus);
-        ok(flags == 0, "Unexpected status %#lx.\n", flags);
     }

ref = IMFTransform_Release(transform);
@@ -4211,10 +4108,8 @@ todo_wine {
     output_file = CreateFileW(output_path, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
     ok(output_file != INVALID_HANDLE_VALUE, "CreateFileW failed, error %lu\n", GetLastError());

-    status = 0xdeadbeef;
-    memset(&output, 0, sizeof(output));
-    output.pSample = output_sample = create_sample(NULL, rgb32_data_len);
-    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
+    output_sample = create_sample(NULL, rgb32_data_len);
+    hr = check_mft_process_output(transform, output_sample, &output_status);
     ok(hr == S_OK || broken(hr == MF_E_SHUTDOWN) /* w8 */, "ProcessOutput returned %#lx\n", hr);
     if (hr != S_OK)
     {
@@ -4222,9 +4117,7 @@ todo_wine {
         CloseHandle(output_file);
         goto skip_output;
     }
-    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
-    ok(output.dwStatus == 0 || broken(output.dwStatus == 6) /* win7 */, "got dwStatus %#lx\n", output.dwStatus);
-    ok(status == 0xdeadbeef, "got status %#lx\n", status);
+    ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);

hr = IMFSample_GetSampleTime(output_sample, &time);
     ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
@@ -4261,14 +4154,10 @@ todo_wine {
     ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

-    status = 0xdeadbeef;
-    memset(&output, 0, sizeof(output));
-    output.pSample = output_sample = create_sample(NULL, output_info.cbSize);
-    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
+    output_sample = create_sample(NULL, output_info.cbSize);
+    hr = check_mft_process_output(transform, output_sample, &output_status);
     ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#lx\n", hr);
-    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
-    ok(output.dwStatus == 0, "got dwStatus %#lx\n", output.dwStatus);
-    ok(status == 0xdeadbeef, "got status %#lx\n", status);
+    ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);
     hr = IMFSample_GetTotalLength(output_sample, &length);
     ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
     ok(length == 0, "got length %lu\n", length);
@@ -4415,12 +4304,11 @@ static void test_mp3_decoder(void)
     const BYTE *mp3dec_data, *mp3enc_data;
     MFT_OUTPUT_STREAM_INFO output_info;
     MFT_INPUT_STREAM_INFO input_info;
-    MFT_OUTPUT_DATA_BUFFER output;
     WCHAR output_path[MAX_PATH];
+    DWORD length, output_status;
     IMFMediaType *media_type;
     IMFTransform *transform;
     LONGLONG time, duration;
-    DWORD status, length;
     HANDLE output_file;
     HRSRC resource;
     ULONG i, ret;
@@ -4557,9 +4445,7 @@ static void test_mp3_decoder(void)
     ret = IMFSample_Release(input_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

-    status = 0xdeadbeef;
-    memset(&output, 0, sizeof(output));
-    output.pSample = output_sample = create_sample(NULL, mp3dec_block_size);
+    output_sample = create_sample(NULL, mp3dec_block_size);

resource = FindResourceW(NULL, L"mp3decdata.bin", (const WCHAR *)RT_RCDATA);
     ok(resource != 0, "FindResourceW failed, error %lu\n", GetLastError());
@@ -4576,13 +4462,9 @@ static void test_mp3_decoder(void)
     hr = IMFTransform_ProcessMessage(transform, MFT_MESSAGE_COMMAND_DRAIN, 0);
     ok(hr == S_OK, "ProcessMessage returned %#lx\n", hr);

-    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
+    hr = check_mft_process_output(transform, output_sample, &output_status);
     ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
-    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
-    ok(output.dwStatus == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE || output.dwStatus == 0 ||
-            broken(output.dwStatus == (MFT_OUTPUT_DATA_BUFFER_INCOMPLETE|7) || output.dwStatus == 7) /* win7 */,
-            "got dwStatus %#lx\n", output.dwStatus);
-    ok(status == 0, "got status %#lx\n", status);
+    ok(output_status == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE, "got output[0].dwStatus %#lx\n", output_status);

hr = IMFSample_GetSampleTime(output_sample, &time);
     ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
@@ -4601,21 +4483,18 @@ static void test_mp3_decoder(void)
     mp3dec_data += 0x9c0;

i = duration;
-    while (SUCCEEDED(hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status)))
+    while (SUCCEEDED(hr = check_mft_process_output(transform, output_sample, &output_status)))
     {
         winetest_push_context("%lu", i);
         ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
-        ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
-        ok(output.dwStatus == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE || output.dwStatus == 0 ||
-                broken(output.dwStatus == (MFT_OUTPUT_DATA_BUFFER_INCOMPLETE|7) || output.dwStatus == 7) /* win7 */,
-                "got dwStatus %#lx\n", output.dwStatus);
-        ok(status == 0, "got status %#lx\n", status);
-        if (!(output.dwStatus & MFT_OUTPUT_DATA_BUFFER_INCOMPLETE))
+        if (!(output_status & MFT_OUTPUT_DATA_BUFFER_INCOMPLETE))
         {
+            ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);
             winetest_pop_context();
             break;
         }

+        ok(output_status == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE, "got output[0].dwStatus %#lx\n", output_status);
         hr = IMFSample_GetSampleTime(output_sample, &time);
         ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
         ok(time == i, "got time %I64d\n", time);
@@ -4655,16 +4534,11 @@ static void test_mp3_decoder(void)

IMFSample_Release(output_sample);

-    memset(&output, 0, sizeof(output));
-    output.pSample = output_sample = create_sample(NULL, mp3dec_block_size);
-    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
+    output_sample = create_sample(NULL, mp3dec_block_size);
+    hr = check_mft_process_output(transform, output_sample, &output_status);
     todo_wine
     ok(hr == S_OK || broken(hr == MF_E_TRANSFORM_NEED_MORE_INPUT) /* win7 */, "ProcessOutput returned %#lx\n", hr);
-    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
-    todo_wine
-    ok(output.dwStatus == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE || broken(output.dwStatus == 0) /* win7 */,
-            "got dwStatus %#lx\n", output.dwStatus);
-    ok(status == 0, "got status %#lx\n", status);
+    ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);

if (hr == S_OK)
     {
@@ -4690,14 +4564,10 @@ static void test_mp3_decoder(void)
     ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

-    status = 0xdeadbeef;
-    memset(&output, 0, sizeof(output));
-    output.pSample = output_sample = create_sample(NULL, mp3dec_block_size);
-    hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status);
+    output_sample = create_sample(NULL, mp3dec_block_size);
+    hr = check_mft_process_output(transform, output_sample, &output_status);
     ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#lx\n", hr);
-    ok(output.pSample == output_sample, "got pSample %p\n", output.pSample);
-    ok(output.dwStatus == 0, "got dwStatus %#lx\n", output.dwStatus);
-    ok(status == 0, "got status %#lx\n", status);
+    ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);
     hr = IMFSample_GetTotalLength(output_sample, &length);
     ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
     ok(length == 0, "got length %lu\n", length);

[PATCH v2 04/10] mf/tests: Introduce a new load_resource helper.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/mf/tests/transform.c | 90 ++++++++++-----------------------------
 1 file changed, 23 insertions(+), 67 deletions(-)

diff --git a/dlls/mf/tests/transform.c b/dlls/mf/tests/transform.c
index 9c7f0928fb2..37f664e0489 100644
--- a/dlls/mf/tests/transform.c
+++ b/dlls/mf/tests/transform.c
@@ -49,6 +49,14 @@ DEFINE_GUID(MFAudioFormat_RAW_AAC1,WAVE_FORMAT_RAW_AAC1,0x0000,0x0010,0x80,0x00,
 DEFINE_GUID(MFVideoFormat_ABGR32,0x00000020,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71);
 DEFINE_GUID(MFVideoFormat_P208,0x38303250,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71);

+static void load_resource(const WCHAR *filename, const BYTE **data, DWORD *length)
+{
+    HRSRC resource = FindResourceW(NULL, filename, (const WCHAR *)RT_RCDATA);
+    ok(resource != 0, "FindResourceW failed, error %lu\n", GetLastError());
+    *data = LockResource(LoadResource(GetModuleHandleW(NULL), resource));
+    *length = SizeofResource(GetModuleHandleW(NULL), resource);
+}
+
 #define EXPECT_REF(obj,ref) _expect_ref((IUnknown*)obj, ref, __LINE__)
 static void _expect_ref(IUnknown* obj, ULONG expected_refcount, int line)
 {
@@ -1471,7 +1479,6 @@ static void test_wma_encoder(void)
     IMFMediaType *media_type;
     IMFTransform *transform;
     HANDLE output_file;
-    HRSRC resource;
     ULONG i, ret;
     HRESULT hr;
     LONG ref;
@@ -1532,10 +1539,7 @@ static void test_wma_encoder(void)
     ok(output_info.cbSize == wmaenc_block_size, "got cbSize %#lx\n", output_info.cbSize);
     ok(output_info.cbAlignment == 1, "got cbAlignment %#lx\n", output_info.cbAlignment);

-    resource = FindResourceW(NULL, L"audiodata.bin", (const WCHAR *)RT_RCDATA);
-    ok(resource != 0, "FindResourceW failed, error %lu\n", GetLastError());
-    audio_data = LockResource(LoadResource(GetModuleHandleW(NULL), resource));
-    audio_data_len = SizeofResource(GetModuleHandleW(NULL), resource);
+    load_resource(L"audiodata.bin", &audio_data, &audio_data_len);
     ok(audio_data_len == 179928, "got length %lu\n", audio_data_len);

input_sample = create_sample(audio_data, audio_data_len);
@@ -1554,10 +1558,7 @@ static void test_wma_encoder(void)

output_sample = create_sample(NULL, output_info.cbSize);

-    resource = FindResourceW(NULL, L"wmaencdata.bin", (const WCHAR *)RT_RCDATA);
-    ok(resource != 0, "FindResourceW failed, error %lu\n", GetLastError());
-    wmaenc_data = LockResource(LoadResource(GetModuleHandleW(NULL), resource));
-    wmaenc_data_len = SizeofResource(GetModuleHandleW(NULL), resource);
+    load_resource(L"wmaencdata.bin", &wmaenc_data, &wmaenc_data_len);
     ok(wmaenc_data_len % wmaenc_block_size == 0, "got length %lu\n", wmaenc_data_len);

/* and generate a new one as well in a temporary directory */
@@ -1733,7 +1734,6 @@ static void test_wma_decoder(void)
     LONGLONG time, duration;
     HANDLE output_file;
     ULONG i, ret, ref;
-    HRSRC resource;
     UINT32 value;
     HRESULT hr;

@@ -1849,10 +1849,7 @@ static void test_wma_decoder(void)
     ok(output_info.cbSize == wmadec_block_size, "got cbSize %#lx\n", output_info.cbSize);
     ok(output_info.cbAlignment == 1, "got cbAlignment %#lx\n", output_info.cbAlignment);

-    resource = FindResourceW(NULL, L"wmaencdata.bin", (const WCHAR *)RT_RCDATA);
-    ok(resource != 0, "FindResourceW failed, error %lu\n", GetLastError());
-    wmaenc_data = LockResource(LoadResource(GetModuleHandleW(NULL), resource));
-    wmaenc_data_len = SizeofResource(GetModuleHandleW(NULL), resource);
+    load_resource(L"wmaencdata.bin", &wmaenc_data, &wmaenc_data_len);
     ok(wmaenc_data_len % wmaenc_block_size == 0, "got length %lu\n", wmaenc_data_len);

input_sample = create_sample(wmaenc_data, wmaenc_block_size / 2);
@@ -1894,10 +1891,7 @@ static void test_wma_decoder(void)
             || broken(output_status == (MFT_OUTPUT_DATA_BUFFER_INCOMPLETE|MFT_OUTPUT_DATA_BUFFER_NO_SAMPLE)) /* Win7 */,
             "got output[0].dwStatus %#lx\n", output_status);

-    resource = FindResourceW(NULL, L"wmadecdata.bin", (const WCHAR *)RT_RCDATA);
-    ok(resource != 0, "FindResourceW failed, error %lu\n", GetLastError());
-    wmadec_data = LockResource(LoadResource(GetModuleHandleW(NULL), resource));
-    wmadec_data_len = SizeofResource(GetModuleHandleW(NULL), resource);
+    load_resource(L"wmadecdata.bin", &wmadec_data, &wmadec_data_len);
     ok(wmadec_data_len == wmadec_block_size * 7 / 2, "got length %lu\n", wmadec_data_len);

/* and generate a new one as well in a temporary directory */
@@ -2281,7 +2275,6 @@ static void test_h264_decoder(void)
     IMFTransform *transform;
     ULONG i, ret, flags;
     HANDLE output_file;
-    HRSRC resource;
     UINT32 value;
     BYTE *data;
     HRESULT hr;
@@ -2457,10 +2450,7 @@ static void test_h264_decoder(void)
     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));
-    h264_encoded_data_len = SizeofResource(GetModuleHandleW(NULL), resource);
+    load_resource(L"h264data.bin", &h264_encoded_data, &h264_encoded_data_len);

/* As output_info.dwFlags doesn't have MFT_OUTPUT_STREAM_CAN_PROVIDE_SAMPLES
      * IMFTransform_ProcessOutput needs a sample or returns an error */
@@ -2548,10 +2538,7 @@ static void test_h264_decoder(void)
     output_file = CreateFileW(output_path, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
     ok(output_file != INVALID_HANDLE_VALUE, "CreateFileW failed, error %lu\n", GetLastError());

-    resource = FindResourceW(NULL, L"nv12frame.bin", (const WCHAR *)RT_RCDATA);
-    ok(resource != 0, "FindResourceW failed, error %lu\n", GetLastError());
-    nv12_frame_data = LockResource(LoadResource(GetModuleHandleW(NULL), resource));
-    nv12_frame_len = SizeofResource(GetModuleHandleW(NULL), resource);
+    load_resource(L"nv12frame.bin", &nv12_frame_data, &nv12_frame_len);
     ok(nv12_frame_len == actual_width * actual_height * 3 / 2, "got frame length %lu\n", nv12_frame_len);

output_sample = create_sample(NULL, nv12_frame_len);
@@ -2663,10 +2650,7 @@ static void test_h264_decoder(void)
     output_file = CreateFileW(output_path, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
     ok(output_file != INVALID_HANDLE_VALUE, "CreateFileW failed, error %lu\n", GetLastError());

-    resource = FindResourceW(NULL, L"i420frame.bin", (const WCHAR *)RT_RCDATA);
-    ok(resource != 0, "FindResourceW failed, error %lu\n", GetLastError());
-    i420_frame_data = LockResource(LoadResource(GetModuleHandleW(NULL), resource));
-    i420_frame_len = SizeofResource(GetModuleHandleW(NULL), resource);
+    load_resource(L"i420frame.bin", &i420_frame_data, &i420_frame_len);
     ok(i420_frame_len == actual_width * actual_height * 3 / 2, "got frame length %lu\n", i420_frame_len);

output_sample = create_sample(NULL, actual_width * actual_height * 2);
@@ -2856,7 +2840,6 @@ static void test_audio_convert(void)
     LONGLONG time, duration;
     IMFTransform *transform;
     HANDLE output_file;
-    HRSRC resource;
     ULONG i, ret;
     HRESULT hr;

@@ -2981,10 +2964,7 @@ static void test_audio_convert(void)
     ok(output_info.cbSize == 4, "got cbSize %#lx\n", output_info.cbSize);
     ok(output_info.cbAlignment == 1, "got cbAlignment %#lx\n", output_info.cbAlignment);

-    resource = FindResourceW(NULL, L"audiodata.bin", (const WCHAR *)RT_RCDATA);
-    ok(resource != 0, "FindResourceW failed, error %lu\n", GetLastError());
-    audio_data = LockResource(LoadResource(GetModuleHandleW(NULL), resource));
-    audio_data_len = SizeofResource(GetModuleHandleW(NULL), resource);
+    load_resource(L"audiodata.bin", &audio_data, &audio_data_len);
     ok(audio_data_len == 179928, "got length %lu\n", audio_data_len);

input_sample = create_sample(audio_data, audio_data_len);
@@ -3003,10 +2983,7 @@ static void test_audio_convert(void)

output_sample = create_sample(NULL, audioconv_block_size);

-    resource = FindResourceW(NULL, L"audioconvdata.bin", (const WCHAR *)RT_RCDATA);
-    ok(resource != 0, "FindResourceW failed, error %lu\n", GetLastError());
-    audioconv_data = LockResource(LoadResource(GetModuleHandleW(NULL), resource));
-    audioconv_data_len = SizeofResource(GetModuleHandleW(NULL), resource);
+    load_resource(L"audioconvdata.bin", &audioconv_data, &audioconv_data_len);
     ok(audioconv_data_len == 179924, "got length %lu\n", audioconv_data_len);

/* and generate a new one as well in a temporary directory */
@@ -3294,7 +3271,6 @@ static void test_color_convert(void)
     LONGLONG time, duration;
     IMFTransform *transform;
     HANDLE output_file;
-    HRSRC resource;
     ULONG i, ret;
     HRESULT hr;

@@ -3398,10 +3374,7 @@ static void test_color_convert(void)
     ok(output_info.cbSize == actual_width * actual_height * 4, "got cbSize %#lx\n", output_info.cbSize);
     ok(output_info.cbAlignment == 1, "got cbAlignment %#lx\n", output_info.cbAlignment);

-    resource = FindResourceW(NULL, L"nv12frame.bin", (const WCHAR *)RT_RCDATA);
-    ok(resource != 0, "FindResourceW failed, error %lu\n", GetLastError());
-    nv12frame_data = LockResource(LoadResource(GetModuleHandleW(NULL), resource));
-    nv12frame_data_len = SizeofResource(GetModuleHandleW(NULL), resource);
+    load_resource(L"nv12frame.bin", &nv12frame_data, &nv12frame_data_len);
     ok(nv12frame_data_len == 13824, "got length %lu\n", nv12frame_data_len);

input_sample = create_sample(nv12frame_data, nv12frame_data_len);
@@ -3418,10 +3391,7 @@ static void test_color_convert(void)
     ret = IMFSample_Release(input_sample);
     ok(ret <= 1, "Release returned %ld\n", ret);

-    resource = FindResourceW(NULL, L"rgb32frame.bin", (const WCHAR *)RT_RCDATA);
-    ok(resource != 0, "FindResourceW failed, error %lu\n", GetLastError());
-    rgb32_data = LockResource(LoadResource(GetModuleHandleW(NULL), resource));
-    rgb32_data_len = SizeofResource(GetModuleHandleW(NULL), resource);
+    load_resource(L"rgb32frame.bin", &rgb32_data, &rgb32_data_len);
     ok(rgb32_data_len == output_info.cbSize, "got length %lu\n", rgb32_data_len);

/* and generate a new one as well in a temporary directory */
@@ -3653,7 +3623,6 @@ static void test_video_processor(void)
     IMFMediaEvent *event;
     unsigned int value;
     HANDLE output_file;
-    HRSRC resource;
     BYTE *ptr, tmp;
     UINT32 count;
     HRESULT hr;
@@ -4076,10 +4045,7 @@ todo_wine {
     ok(output_info.cbSize == actual_width * actual_height * 4, "got cbSize %#lx\n", output_info.cbSize);
     ok(output_info.cbAlignment == 0, "got cbAlignment %#lx\n", output_info.cbAlignment);

-    resource = FindResourceW(NULL, L"nv12frame.bin", (const WCHAR *)RT_RCDATA);
-    ok(resource != 0, "FindResourceW failed, error %lu\n", GetLastError());
-    nv12frame_data = LockResource(LoadResource(GetModuleHandleW(NULL), resource));
-    nv12frame_data_len = SizeofResource(GetModuleHandleW(NULL), resource);
+    load_resource(L"nv12frame.bin", &nv12frame_data, &nv12frame_data_len);
     ok(nv12frame_data_len == 13824, "got length %lu\n", nv12frame_data_len);

input_sample = create_sample(nv12frame_data, nv12frame_data_len);
@@ -4096,10 +4062,7 @@ todo_wine {
     ret = IMFSample_Release(input_sample);
     ok(ret <= 1, "Release returned %ld\n", ret);

-    resource = FindResourceW(NULL, L"rgb32frame-vp.bin", (const WCHAR *)RT_RCDATA);
-    ok(resource != 0, "FindResourceW failed, error %lu\n", GetLastError());
-    rgb32_data = LockResource(LoadResource(GetModuleHandleW(NULL), resource));
-    rgb32_data_len = SizeofResource(GetModuleHandleW(NULL), resource);
+    load_resource(L"rgb32frame-vp.bin", &rgb32_data, &rgb32_data_len);
     ok(rgb32_data_len == output_info.cbSize, "got length %lu\n", rgb32_data_len);

/* and generate a new one as well in a temporary directory */
@@ -4310,7 +4273,6 @@ static void test_mp3_decoder(void)
     IMFTransform *transform;
     LONGLONG time, duration;
     HANDLE output_file;
-    HRSRC resource;
     ULONG i, ret;
     HRESULT hr;

@@ -4427,10 +4389,7 @@ static void test_mp3_decoder(void)
     ok(output_info.cbSize == mp3dec_block_size, "got cbSize %#lx\n", output_info.cbSize);
     ok(output_info.cbAlignment == 1, "got cbAlignment %#lx\n", output_info.cbAlignment);

-    resource = FindResourceW(NULL, L"mp3encdata.bin", (const WCHAR *)RT_RCDATA);
-    ok(resource != 0, "FindResourceW failed, error %lu\n", GetLastError());
-    mp3enc_data = LockResource(LoadResource(GetModuleHandleW(NULL), resource));
-    mp3enc_data_len = SizeofResource(GetModuleHandleW(NULL), resource);
+    load_resource(L"mp3encdata.bin", &mp3enc_data, &mp3enc_data_len);
     ok(mp3enc_data_len == 6295, "got length %lu\n", mp3enc_data_len);

input_sample = create_sample(mp3enc_data, mp3enc_data_len);
@@ -4447,10 +4406,7 @@ static void test_mp3_decoder(void)

output_sample = create_sample(NULL, mp3dec_block_size);

-    resource = FindResourceW(NULL, L"mp3decdata.bin", (const WCHAR *)RT_RCDATA);
-    ok(resource != 0, "FindResourceW failed, error %lu\n", GetLastError());
-    mp3dec_data = LockResource(LoadResource(GetModuleHandleW(NULL), resource));
-    mp3dec_data_len = SizeofResource(GetModuleHandleW(NULL), resource);
+    load_resource(L"mp3decdata.bin", &mp3dec_data, &mp3dec_data_len);
     ok(mp3dec_data_len == 94656, "got length %lu\n", mp3dec_data_len);

/* and generate a new one as well in a temporary directory */

[PATCH v2 05/10] mf/tests: Introduce a new dump_mf_sample helper.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/mf/tests/transform.c | 229 +++++++++++++++++++++++++++++++++-----
 1 file changed, 202 insertions(+), 27 deletions(-)

diff --git a/dlls/mf/tests/transform.c b/dlls/mf/tests/transform.c
index 37f664e0489..99e088bf081 100644
--- a/dlls/mf/tests/transform.c
+++ b/dlls/mf/tests/transform.c
@@ -361,6 +361,62 @@ static HRESULT check_mft_process_output_(int line, IMFTransform *transform, IMFS
     return ret;
 }

+struct buffer_desc
+{
+    DWORD length;
+};
+
+struct sample_desc
+{
+    DWORD buffer_count;
+    const struct buffer_desc *buffers;
+};
+
+typedef void (*enum_mf_media_buffers_cb)(IMFMediaBuffer *buffer, const struct buffer_desc *desc, void *context);
+static void enum_mf_media_buffers(IMFSample *sample, const struct sample_desc *sample_desc,
+        enum_mf_media_buffers_cb callback, void *context)
+{
+    IMFMediaBuffer *buffer;
+    HRESULT hr;
+    DWORD i;
+
+    for (i = 0; SUCCEEDED(hr = IMFSample_GetBufferByIndex(sample, i, &buffer)); i++)
+    {
+        winetest_push_context("buffer %lu", i);
+        ok(hr == S_OK, "GetBufferByIndex returned %#lx\n", hr);
+        ok(i < sample_desc->buffer_count, "got unexpected buffer\n");
+
+        callback(buffer, sample_desc->buffers + i, context);
+
+        IMFMediaBuffer_Release(buffer);
+        winetest_pop_context();
+    }
+    ok(hr == E_INVALIDARG, "GetBufferByIndex returned %#lx\n", hr);
+}
+
+static void dump_mf_media_buffer(IMFMediaBuffer *buffer, const struct buffer_desc *buffer_desc, HANDLE output)
+{
+    DWORD length, written;
+    HRESULT hr;
+    BYTE *data;
+    BOOL ret;
+
+    hr = IMFMediaBuffer_Lock(buffer, &data, NULL, &length);
+    ok(hr == S_OK, "Lock returned %#lx\n", hr);
+
+    ret = WriteFile(output, data, length, &written, NULL);
+    ok(ret, "WriteFile failed, error %lu\n", GetLastError());
+    ok(written == length, "written %lu bytes\n", written);
+
+    hr = IMFMediaBuffer_Unlock(buffer);
+    ok(hr == S_OK, "Unlock returned %#lx\n", hr);
+}
+
+static void dump_mf_sample(IMFSample *sample, const struct sample_desc *sample_desc, HANDLE output)
+{
+    enum_mf_media_buffers(sample, sample_desc, dump_mf_media_buffer, output);
+}
+
 static HRESULT WINAPI test_unk_QueryInterface(IUnknown *iface, REFIID riid, void **obj)
 {
     if (IsEqualIID(riid, &IID_IUnknown))
@@ -911,8 +967,8 @@ static IMFSample *create_sample(const BYTE *data, ULONG size)
     return sample;
 }

-#define check_sample(a, b, c) check_sample_(__LINE__, a, b, c)
-static void check_sample_(int line, IMFSample *sample, const BYTE *expect_buf, HANDLE output_file)
+#define check_sample(a, b) check_sample_(__LINE__, a, b)
+static void check_sample_(int line, IMFSample *sample, const BYTE *expect_buf)
 {
     IMFMediaBuffer *media_buffer;
     DWORD length;
@@ -925,15 +981,14 @@ static void check_sample_(int line, IMFSample *sample, const BYTE *expect_buf, H
     hr = IMFMediaBuffer_Lock(media_buffer, &buffer, NULL, &length);
     ok_(__FILE__, line)(hr == S_OK, "Lock returned %#lx\n", hr);
     ok_(__FILE__, line)(!memcmp(expect_buf, buffer, length), "unexpected buffer data\n");
-    if (output_file) WriteFile(output_file, buffer, length, &length, NULL);
     hr = IMFMediaBuffer_Unlock(media_buffer);
     ok_(__FILE__, line)(hr == S_OK, "Unlock returned %#lx\n", hr);
     ret = IMFMediaBuffer_Release(media_buffer);
     ok_(__FILE__, line)(ret == 1, "Release returned %lu\n", ret);
 }

-#define check_sample_rgb32(a, b, c) check_sample_rgb32_(__LINE__, a, b, c)
-static void check_sample_rgb32_(int line, IMFSample *sample, const BYTE *expect_buf, HANDLE output_file)
+#define check_sample_rgb32(a, b) check_sample_rgb32_(__LINE__, a, b)
+static void check_sample_rgb32_(int line, IMFSample *sample, const BYTE *expect_buf)
 {
     DWORD i, length, diff = 0, max_diff;
     IMFMediaBuffer *media_buffer;
@@ -958,15 +1013,14 @@ static void check_sample_rgb32_(int line, IMFSample *sample, const BYTE *expect_
     max_diff = length * 3 * 256;
     ok_(__FILE__, line)(diff * 100 / max_diff == 0, "unexpected buffer data\n");

-    if (output_file) WriteFile(output_file, buffer, length, &length, NULL);
     hr = IMFMediaBuffer_Unlock(media_buffer);
     ok_(__FILE__, line)(hr == S_OK, "Unlock returned %#lx\n", hr);
     ret = IMFMediaBuffer_Release(media_buffer);
     ok_(__FILE__, line)(ret == 1, "Release returned %lu\n", ret);
 }

-#define check_sample_pcm16(a, b, c, d) check_sample_pcm16_(__LINE__, a, b, c, d)
-static void check_sample_pcm16_(int line, IMFSample *sample, const BYTE *expect_buf, HANDLE output_file, BOOL todo)
+#define check_sample_pcm16(a, b, c) check_sample_pcm16_(__LINE__, a, b, c)
+static void check_sample_pcm16_(int line, IMFSample *sample, const BYTE *expect_buf, BOOL todo)
 {
     IMFMediaBuffer *media_buffer;
     DWORD i, length;
@@ -991,7 +1045,6 @@ static void check_sample_pcm16_(int line, IMFSample *sample, const BYTE *expect_
     todo_wine_if(todo && i < length / 2)
     ok_(__FILE__, line)(i == length, "unexpected buffer data\n");

-    if (output_file) WriteFile(output_file, buffer, length, &length, NULL);
     hr = IMFMediaBuffer_Unlock(media_buffer);
     ok_(__FILE__, line)(hr == S_OK, "Unlock returned %#lx\n", hr);
     ret = IMFMediaBuffer_Release(media_buffer);
@@ -1467,6 +1520,17 @@ static void test_wma_encoder(void)
         {0},
     };

+    const struct buffer_desc output_buffer_desc[] =
+    {
+        {.length = wmaenc_block_size},
+    };
+    const struct sample_desc output_sample_desc[] =
+    {
+        {
+            .buffer_count = 1, .buffers = output_buffer_desc,
+        },
+    };
+
     MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Audio, MFAudioFormat_WMAudioV8};
     MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Audio, MFAudioFormat_Float};
     IMFSample *input_sample, *output_sample;
@@ -1576,7 +1640,8 @@ static void test_wma_encoder(void)
         ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
         ok(length == wmaenc_block_size, "got length %lu\n", length);
         ok(wmaenc_data_len > i * wmaenc_block_size, "got %lu blocks\n", i);
-        check_sample(output_sample, wmaenc_data + i * wmaenc_block_size, output_file);
+        check_sample(output_sample, wmaenc_data + i * wmaenc_block_size);
+        dump_mf_sample(output_sample, output_sample_desc, output_file);
         winetest_pop_context();
     }
     ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#lx\n", hr);
@@ -1717,6 +1782,21 @@ static void test_wma_decoder(void)
         {0},
     };

+    const struct buffer_desc output_buffer_desc[] =
+    {
+        {.length = wmadec_block_size},
+        {.length = wmadec_block_size / 2},
+    };
+    const struct sample_desc output_sample_desc[] =
+    {
+        {
+            .buffer_count = 1, .buffers = output_buffer_desc + 0,
+        },
+        {
+            .buffer_count = 1, .buffers = output_buffer_desc + 1,
+        },
+    };
+
     MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Audio, MFAudioFormat_WMAudioV8};
     MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Audio, MFAudioFormat_Float};
     IUnknown *unknown, *tmp_unknown, outer = {&test_unk_vtbl};
@@ -1932,7 +2012,8 @@ static void test_wma_decoder(void)
             ok(output_status == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE, "got output[0].dwStatus %#lx\n", output_status);
             ok(length == wmadec_block_size, "got length %lu\n", length);
             ok(duration == 928798, "got duration %I64d\n", duration);
-            check_sample_pcm16(output_sample, wmadec_data, output_file, TRUE);
+            check_sample_pcm16(output_sample, wmadec_data, TRUE);
+            dump_mf_sample(output_sample, output_sample_desc + 0, output_file);
             wmadec_data += wmadec_block_size;
             wmadec_data_len -= wmadec_block_size;
         }
@@ -1946,7 +2027,10 @@ static void test_wma_decoder(void)
             ok(duration == 464399, "got duration %I64d\n", duration);

if (length == wmadec_block_size / 2)
-                check_sample_pcm16(output_sample, wmadec_data, output_file, FALSE);
+            {
+                check_sample_pcm16(output_sample, wmadec_data, FALSE);
+                dump_mf_sample(output_sample, output_sample_desc + 1, output_file);
+            }
             wmadec_data += length;
             wmadec_data_len -= length;
         }
@@ -2258,6 +2342,23 @@ static void test_h264_decoder(void)
         },
     };

+    const struct buffer_desc output_buffer_desc_nv12 =
+    {
+        .length = actual_width * actual_height * 3 / 2,
+    };
+    const struct sample_desc output_sample_desc_nv12 =
+    {
+        .buffer_count = 1, .buffers = &output_buffer_desc_nv12,
+    };
+    const struct buffer_desc output_buffer_desc_i420 =
+    {
+        .length = actual_width * actual_height * 3 / 2,
+    };
+    const struct sample_desc output_sample_desc_i420 =
+    {
+        .buffer_count = 1, .buffers = &output_buffer_desc_i420,
+    };
+
     MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Video, MFVideoFormat_H264};
     MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Video, MFVideoFormat_NV12};
     const BYTE *h264_encoded_data, *nv12_frame_data, *i420_frame_data;
@@ -2591,7 +2692,8 @@ static void test_h264_decoder(void)
     ok(hr == S_OK, "Unlock returned %#lx\n", hr);
     IMFMediaBuffer_Release(media_buffer);

-    check_sample(output_sample, nv12_frame_data, output_file);
+    check_sample(output_sample, nv12_frame_data);
+    dump_mf_sample(output_sample, &output_sample_desc_nv12, output_file);

ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);
@@ -2694,7 +2796,8 @@ static void test_h264_decoder(void)
     ok(hr == S_OK, "Unlock returned %#lx\n", hr);
     IMFMediaBuffer_Release(media_buffer);

-    check_sample(output_sample, i420_frame_data, output_file);
+    check_sample(output_sample, i420_frame_data);
+    dump_mf_sample(output_sample, &output_sample_desc_i420, output_file);

ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);
@@ -2826,9 +2929,28 @@ static void test_audio_convert(void)
         {0},
     };

+    static const ULONG audioconv_block_size = 0x4000;
+    const struct buffer_desc output_buffer_desc[] =
+    {
+        {.length = audioconv_block_size},
+        {.length = 0x3dd8},
+        {.length = 0xfc},
+    };
+    const struct sample_desc output_sample_desc[] =
+    {
+        {
+            .buffer_count = 1, .buffers = output_buffer_desc + 0,
+        },
+        {
+            .buffer_count = 1, .buffers = output_buffer_desc + 1,
+        },
+        {
+            .buffer_count = 1, .buffers = output_buffer_desc + 2,
+        },
+    };
+
     MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Audio, MFAudioFormat_PCM};
     MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Audio, MFAudioFormat_Float};
-    static const ULONG audioconv_block_size = 0x4000;
     ULONG audio_data_len, audioconv_data_len;
     IMFSample *input_sample, *output_sample;
     const BYTE *audio_data, *audioconv_data;
@@ -3015,7 +3137,8 @@ static void test_audio_convert(void)
         ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
         ok(length == audioconv_block_size, "got length %lu\n", length);
         ok(audioconv_data_len > audioconv_block_size, "got remaining length %lu\n", audioconv_data_len);
-        check_sample_pcm16(output_sample, audioconv_data, output_file, FALSE);
+        check_sample_pcm16(output_sample, audioconv_data, FALSE);
+        dump_mf_sample(output_sample, output_sample_desc + 0, output_file);
         audioconv_data_len -= audioconv_block_size;
         audioconv_data += audioconv_block_size;

@@ -3035,7 +3158,8 @@ static void test_audio_convert(void)
     todo_wine
     ok(length == 15832, "got length %lu\n", length);
     ok(audioconv_data_len == 16084, "got remaining length %lu\n", audioconv_data_len);
-    check_sample_pcm16(output_sample, audioconv_data, output_file, FALSE);
+    check_sample_pcm16(output_sample, audioconv_data, FALSE);
+    dump_mf_sample(output_sample, output_sample_desc + 1, output_file);
     audioconv_data_len -= length;
     audioconv_data += length;

@@ -3066,7 +3190,10 @@ static void test_audio_convert(void)
         todo_wine
         ok(length == audioconv_data_len, "got length %lu\n", length);
         if (length == audioconv_data_len)
-            check_sample_pcm16(output_sample, audioconv_data, output_file, FALSE);
+        {
+            check_sample_pcm16(output_sample, audioconv_data, FALSE);
+            dump_mf_sample(output_sample, output_sample_desc + 2, output_file);
+        }
     }

trace("created %s\n", debugstr_w(output_path));
@@ -3258,6 +3385,15 @@ static void test_color_convert(void)
         {0},
     };

+    const struct buffer_desc output_buffer_desc =
+    {
+        .length = actual_width * actual_height * 4,
+    };
+    const struct sample_desc output_sample_desc =
+    {
+        .buffer_count = 1, .buffers = &output_buffer_desc,
+    };
+
     MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Video, MFVideoFormat_NV12};
     MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Video, MFVideoFormat_I420};
     ULONG nv12frame_data_len, rgb32_data_len;
@@ -3414,7 +3550,8 @@ static void test_color_convert(void)
     hr = IMFSample_GetTotalLength(output_sample, &length);
     ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
     ok(length == output_info.cbSize, "got length %lu\n", length);
-    check_sample_rgb32(output_sample, rgb32_data, output_file);
+    check_sample_rgb32(output_sample, rgb32_data);
+    dump_mf_sample(output_sample, &output_sample_desc, output_file);
     rgb32_data_len -= output_info.cbSize;
     rgb32_data += output_info.cbSize;

@@ -3603,9 +3740,18 @@ static void test_video_processor(void)
         {0},
     };

+    const struct buffer_desc output_buffer_desc =
+    {
+        .length = actual_width * actual_height * 4,
+    };
+    const struct sample_desc output_sample_desc =
+    {
+        .buffer_count = 1, .buffers = &output_buffer_desc,
+    };
+
+    DWORD input_count, output_count, input_id, output_id, flags, length, output_status;
     MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Video, MFVideoFormat_NV12};
     MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Video, MFVideoFormat_I420};
-    DWORD input_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;
     IMFSample *input_sample, *output_sample;
@@ -3615,7 +3761,6 @@ static void test_video_processor(void)
     const GUID *expect_available_inputs;
     MFT_OUTPUT_STREAM_INFO output_info;
     MFT_INPUT_STREAM_INFO input_info;
-    DWORD length, output_status;
     WCHAR output_path[MAX_PATH];
     LONGLONG time, duration;
     IMFTransform *transform;
@@ -4107,7 +4252,10 @@ todo_wine {
     if (tmp == 0x00)
         win_skip("Frame got resized, skipping output comparison\n");
     else if (tmp == 0xcd) /* Wine doesn't flip the frame, yet */
-        check_sample_rgb32(output_sample, rgb32_data, output_file);
+    {
+        check_sample_rgb32(output_sample, rgb32_data);
+        dump_mf_sample(output_sample, &output_sample_desc, output_file);
+    }
     rgb32_data_len -= output_info.cbSize;
     rgb32_data += output_info.cbSize;

@@ -4259,9 +4407,24 @@ static void test_mp3_decoder(void)
         {0},
     };

+    static const ULONG mp3dec_block_size = 0x1200;
+    const struct buffer_desc output_buffer_desc[] =
+    {
+        {.length = 0x9c0},
+        {.length = mp3dec_block_size},
+    };
+    const struct sample_desc output_sample_desc[] =
+    {
+        {
+            .buffer_count = 1, .buffers = output_buffer_desc + 0,
+        },
+        {
+            .buffer_count = 1, .buffers = output_buffer_desc + 1,
+        },
+    };
+
     MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Audio, MFAudioFormat_PCM};
     MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Audio, MFAudioFormat_MP3};
-    static const ULONG mp3dec_block_size = 0x1200;
     IMFSample *input_sample, *output_sample;
     ULONG mp3dec_data_len, mp3enc_data_len;
     const BYTE *mp3dec_data, *mp3enc_data;
@@ -4434,7 +4597,11 @@ static void test_mp3_decoder(void)
     ok(length == 0x9c0 || broken(length == mp3dec_block_size) /* win8 */ || broken(length == 0x900) /* win7 */,
             "got length %lu\n", length);
     ok(mp3dec_data_len > length, "got remaining length %lu\n", mp3dec_data_len);
-    if (length == 0x9c0) check_sample_pcm16(output_sample, mp3dec_data, output_file, FALSE);
+    if (length == 0x9c0)
+    {
+        check_sample_pcm16(output_sample, mp3dec_data, FALSE);
+        dump_mf_sample(output_sample, output_sample_desc + 0, output_file);
+    }
     mp3dec_data_len -= 0x9c0;
     mp3dec_data += 0x9c0;

@@ -4464,7 +4631,11 @@ static void test_mp3_decoder(void)
                 "got length %lu\n", length);
         ok(mp3dec_data_len > length || broken(mp3dec_data_len == 2304 || mp3dec_data_len == 0) /* win7 */,
                 "got remaining length %lu\n", mp3dec_data_len);
-        if (length == mp3dec_block_size) check_sample_pcm16(output_sample, mp3dec_data, output_file, FALSE);
+        if (length == mp3dec_block_size)
+        {
+            check_sample_pcm16(output_sample, mp3dec_data, FALSE);
+            dump_mf_sample(output_sample, output_sample_desc + 1, output_file);
+        }
         mp3dec_data += min(mp3dec_data_len, length);
         mp3dec_data_len -= min(mp3dec_data_len, length);

@@ -4484,7 +4655,8 @@ static void test_mp3_decoder(void)
     todo_wine
     ok(length == mp3dec_block_size || broken(length == 0) /* win7 */, "got length %lu\n", length);
     ok(mp3dec_data_len == mp3dec_block_size || broken(mp3dec_data_len == 0) /* win7 */, "got remaining length %lu\n", mp3dec_data_len);
-    check_sample_pcm16(output_sample, mp3dec_data, output_file, FALSE);
+    check_sample_pcm16(output_sample, mp3dec_data, FALSE);
+    dump_mf_sample(output_sample, output_sample_desc + 1, output_file);
     mp3dec_data_len -= length;
     mp3dec_data += length;

@@ -4511,7 +4683,10 @@ static void test_mp3_decoder(void)
         todo_wine
         ok(length == mp3dec_data_len, "got length %lu\n", length);
         if (length == mp3dec_data_len)
-            check_sample_pcm16(output_sample, mp3dec_data, output_file, FALSE);
+        {
+            check_sample_pcm16(output_sample, mp3dec_data, FALSE);
+            dump_mf_sample(output_sample, output_sample_desc + 1, output_file);
+        }
     }

trace("created %s\n", debugstr_w(output_path));

[PATCH v2 06/10] mf/tests: Factor IMFSample checks in a check_mf_sample helper.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/mf/tests/transform.c | 512 +++++++++++++++++++-------------------
 1 file changed, 251 insertions(+), 261 deletions(-)

diff --git a/dlls/mf/tests/transform.c b/dlls/mf/tests/transform.c
index 99e088bf081..9e88ee21f1a 100644
--- a/dlls/mf/tests/transform.c
+++ b/dlls/mf/tests/transform.c
@@ -361,15 +361,119 @@ static HRESULT check_mft_process_output_(int line, IMFTransform *transform, IMFS
     return ret;
 }

+typedef DWORD (*compare_cb)(const BYTE *data, DWORD length, const RECT *rect, const BYTE *expect);
+
+static DWORD compare_nv12(const BYTE *data, DWORD length, const RECT *rect, const BYTE *expect)
+{
+    DWORD x, y, size, diff = 0, width = (rect->right + 0xf) & ~0xf, height = (rect->bottom + 0xf) & ~0xf;
+
+    for (y = 0; y < height; y++, data += width, expect += width)
+    {
+        if (y < rect->top || y >= rect->bottom) continue;
+        for (x = 0; x < width; x++)
+        {
+            if (x < rect->left || x >= rect->right) continue;
+            diff += abs((int)expect[x] - (int)data[x]);
+        }
+    }
+
+    for (y = 0; y < height; y += 2, data += width, expect += width)
+    {
+        if (y < rect->top || y >= rect->bottom) continue;
+        for (x = 0; x < width; x += 2)
+        {
+            if (x < rect->left || x >= rect->right) continue;
+            diff += abs((int)expect[x + 0] - (int)data[x + 0]);
+            diff += abs((int)expect[x + 1] - (int)data[x + 1]);
+        }
+    }
+
+    size = (rect->right - rect->left) * (rect->bottom - rect->top) * 3 / 2;
+    return diff * 100 / 256 / size;
+}
+
+static DWORD compare_i420(const BYTE *data, DWORD length, const RECT *rect, const BYTE *expect)
+{
+    DWORD i, x, y, size, diff = 0, width = (rect->right + 0xf) & ~0xf, height = (rect->bottom + 0xf) & ~0xf;
+
+    for (y = 0; y < height; y++, data += width, expect += width)
+    {
+        if (y < rect->top || y >= rect->bottom) continue;
+        for (x = 0; x < width; x++)
+        {
+            if (x < rect->left || x >= rect->right) continue;
+            diff += abs((int)expect[x] - (int)data[x]);
+        }
+    }
+
+    for (i = 0; i < 2; ++i) for (y = 0; y < height; y += 2, data += width / 2, expect += width / 2)
+    {
+        if (y < rect->top || y >= rect->bottom) continue;
+        for (x = 0; x < width; x += 2)
+        {
+            if (x < rect->left || x >= rect->right) continue;
+            diff += abs((int)expect[x / 2] - (int)data[x / 2]);
+        }
+    }
+
+    size = (rect->right - rect->left) * (rect->bottom - rect->top) * 3 / 2;
+    return diff * 100 / 256 / size;
+}
+
+static DWORD compare_rgb32(const BYTE *data, DWORD length, const RECT *rect, const BYTE *expect)
+{
+    DWORD x, y, size, diff = 0, width = (rect->right + 0xf) & ~0xf, height = (rect->bottom + 0xf) & ~0xf;
+
+    for (y = 0; y < height; y++, data += width * 4, expect += width * 4)
+    {
+        if (y < rect->top || y >= rect->bottom) continue;
+        for (x = 0; x < width; x++)
+        {
+            if (x < rect->left || x >= rect->right) continue;
+            diff += abs((int)expect[4 * x + 0] - (int)data[4 * x + 0]);
+            diff += abs((int)expect[4 * x + 1] - (int)data[4 * x + 1]);
+            diff += abs((int)expect[4 * x + 2] - (int)data[4 * x + 2]);
+        }
+    }
+
+    size = (rect->right - rect->left) * (rect->bottom - rect->top) * 3;
+    return diff * 100 / 256 / size;
+}
+
+static DWORD compare_pcm16(const BYTE *data, DWORD length, const RECT *rect, const BYTE *expect)
+{
+    const INT16 *data_pcm = (INT16 *)data, *expect_pcm = (INT16 *)expect;
+    DWORD i, size = length / 2, diff = 0;
+
+    for (i = 0; i < size; i++)
+        diff += abs((int)*expect_pcm++ - (int)*data_pcm++);
+
+    return diff * 100 / 65536 / size;
+}
+
+static DWORD compare_bytes(const BYTE *data, DWORD length, const RECT *rect, const BYTE *expect)
+{
+    DWORD i, diff = 0;
+
+    for (i = 0; i < length; i++)
+        diff += abs((int)*expect++ - (int)*data++);
+
+    return diff * 100 / 256 / length;
+}
+
 struct buffer_desc
 {
     DWORD length;
+    BOOL todo_length;
+    compare_cb compare;
+    RECT rect;
 };

struct sample_desc
 {
     DWORD buffer_count;
     const struct buffer_desc *buffers;
+    BOOL todo_length;
 };

typedef void (*enum_mf_media_buffers_cb)(IMFMediaBuffer *buffer, const struct buffer_desc *desc, void *context);
@@ -417,6 +521,83 @@ static void dump_mf_sample(IMFSample *sample, const struct sample_desc *sample_d
     enum_mf_media_buffers(sample, sample_desc, dump_mf_media_buffer, output);
 }

+#define check_mf_media_buffer(a, b, c) check_mf_media_buffer_(__LINE__, a, b, c)
+static DWORD check_mf_media_buffer_(int line, IMFMediaBuffer *buffer, const struct buffer_desc *expect,
+        const BYTE **expect_data, DWORD *expect_data_len)
+{
+    DWORD length, diff = 0;
+    HRESULT hr;
+    BYTE *data;
+
+    hr = IMFMediaBuffer_Lock(buffer, &data, NULL, &length);
+    ok_(__FILE__, line)(hr == S_OK, "Lock returned %#lx\n", hr);
+    todo_wine_if(expect->todo_length)
+    ok_(__FILE__, line)(length == expect->length, "got length %#lx\n", length);
+
+    if (*expect_data_len < length)
+        todo_wine_if(expect->todo_length)
+        ok_(__FILE__, line)(0, "missing %#lx bytes\n", length - *expect_data_len);
+    else if (!expect->compare)
+        diff = compare_bytes(data, length, NULL, *expect_data);
+    else
+        diff = expect->compare(data, length, &expect->rect, *expect_data);
+
+    hr = IMFMediaBuffer_Unlock(buffer);
+    ok_(__FILE__, line)(hr == S_OK, "Unlock returned %#lx\n", hr);
+
+    *expect_data = *expect_data + min(length, *expect_data_len);
+    *expect_data_len = *expect_data_len - min(length, *expect_data_len);
+
+    return diff;
+}
+
+struct check_mf_sample_context
+{
+    DWORD total_length;
+    const BYTE *data;
+    DWORD data_len;
+    DWORD diff;
+    int line;
+};
+
+static void check_mf_sample_buffer(IMFMediaBuffer *buffer, const struct buffer_desc *expect, void *context)
+{
+    struct check_mf_sample_context *ctx = context;
+    ctx->diff += check_mf_media_buffer_(ctx->line, buffer, expect, &ctx->data, &ctx->data_len);
+    ctx->total_length += expect->length;
+}
+
+#define check_mf_sample(a, b, c, d) check_mf_sample_(__LINE__, a, b, c, d)
+static DWORD check_mf_sample_(int line, IMFSample *sample, const struct sample_desc *expect,
+        const BYTE **expect_data, DWORD *expect_data_len)
+{
+    struct check_mf_sample_context ctx = {.data = *expect_data, .data_len = *expect_data_len, .line = line};
+    DWORD buffer_count, total_length;
+    HRESULT hr;
+
+    buffer_count = 0xdeadbeef;
+    hr = IMFSample_GetBufferCount(sample, &buffer_count);
+    ok_(__FILE__, line)(hr == S_OK, "GetBufferCount returned %#lx\n", hr);
+    ok_(__FILE__, line)(buffer_count == expect->buffer_count,
+            "got %lu buffers\n", buffer_count);
+
+    enum_mf_media_buffers(sample, expect, check_mf_sample_buffer, &ctx);
+
+    total_length = 0xdeadbeef;
+    hr = IMFSample_GetTotalLength(sample, &total_length);
+    ok_(__FILE__, line)(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
+    todo_wine_if(expect->todo_length)
+    ok_(__FILE__, line)(total_length == ctx.total_length,
+            "got total length %#lx\n", total_length);
+    ok_(__FILE__, line)(*expect_data_len >= ctx.total_length,
+            "missing %#lx data\n", ctx.total_length - *expect_data_len);
+
+    *expect_data = *expect_data + min(total_length, *expect_data_len);
+    *expect_data_len = *expect_data_len - min(total_length, *expect_data_len);
+
+    return ctx.diff / buffer_count;
+}
+
 static HRESULT WINAPI test_unk_QueryInterface(IUnknown *iface, REFIID riid, void **obj)
 {
     if (IsEqualIID(riid, &IID_IUnknown))
@@ -967,90 +1148,6 @@ static IMFSample *create_sample(const BYTE *data, ULONG size)
     return sample;
 }

-#define check_sample(a, b) check_sample_(__LINE__, a, b)
-static void check_sample_(int line, IMFSample *sample, const BYTE *expect_buf)
-{
-    IMFMediaBuffer *media_buffer;
-    DWORD length;
-    BYTE *buffer;
-    HRESULT hr;
-    ULONG ret;
-
-    hr = IMFSample_ConvertToContiguousBuffer(sample, &media_buffer);
-    ok_(__FILE__, line)(hr == S_OK, "ConvertToContiguousBuffer returned %#lx\n", hr);
-    hr = IMFMediaBuffer_Lock(media_buffer, &buffer, NULL, &length);
-    ok_(__FILE__, line)(hr == S_OK, "Lock returned %#lx\n", hr);
-    ok_(__FILE__, line)(!memcmp(expect_buf, buffer, length), "unexpected buffer data\n");
-    hr = IMFMediaBuffer_Unlock(media_buffer);
-    ok_(__FILE__, line)(hr == S_OK, "Unlock returned %#lx\n", hr);
-    ret = IMFMediaBuffer_Release(media_buffer);
-    ok_(__FILE__, line)(ret == 1, "Release returned %lu\n", ret);
-}
-
-#define check_sample_rgb32(a, b) check_sample_rgb32_(__LINE__, a, b)
-static void check_sample_rgb32_(int line, IMFSample *sample, const BYTE *expect_buf)
-{
-    DWORD i, length, diff = 0, max_diff;
-    IMFMediaBuffer *media_buffer;
-    BYTE *buffer;
-    HRESULT hr;
-    ULONG ret;
-
-    hr = IMFSample_ConvertToContiguousBuffer(sample, &media_buffer);
-    ok_(__FILE__, line)(hr == S_OK, "ConvertToContiguousBuffer returned %#lx\n", hr);
-    hr = IMFMediaBuffer_Lock(media_buffer, &buffer, NULL, &length);
-    ok_(__FILE__, line)(hr == S_OK, "Lock returned %#lx\n", hr);
-
-    /* check that buffer values are "close" enough, there's some pretty big
-     * differences with the color converter between ffmpeg and native.
-     */
-    for (i = 0; i < length; i++)
-    {
-        if (i % 4 == 3) continue; /* ignore alpha diff */
-        if (!expect_buf[(i & ~3) + 3]) continue; /* ignore transparent pixels */
-        diff += abs((int)expect_buf[i] - (int)buffer[i]);
-    }
-    max_diff = length * 3 * 256;
-    ok_(__FILE__, line)(diff * 100 / max_diff == 0, "unexpected buffer data\n");
-
-    hr = IMFMediaBuffer_Unlock(media_buffer);
-    ok_(__FILE__, line)(hr == S_OK, "Unlock returned %#lx\n", hr);
-    ret = IMFMediaBuffer_Release(media_buffer);
-    ok_(__FILE__, line)(ret == 1, "Release returned %lu\n", ret);
-}
-
-#define check_sample_pcm16(a, b, c) check_sample_pcm16_(__LINE__, a, b, c)
-static void check_sample_pcm16_(int line, IMFSample *sample, const BYTE *expect_buf, BOOL todo)
-{
-    IMFMediaBuffer *media_buffer;
-    DWORD i, length;
-    BYTE *buffer;
-    HRESULT hr;
-    ULONG ret;
-
-    hr = IMFSample_ConvertToContiguousBuffer(sample, &media_buffer);
-    ok_(__FILE__, line)(hr == S_OK, "ConvertToContiguousBuffer returned %#lx\n", hr);
-    hr = IMFMediaBuffer_Lock(media_buffer, &buffer, NULL, &length);
-    ok_(__FILE__, line)(hr == S_OK, "Lock returned %#lx\n", hr);
-
-    /* check that buffer values are close enough, there's some differences in
-     * the output of audio DSP between 32bit and 64bit implementation
-     */
-    for (i = 0; i < length; i += 2)
-    {
-        DWORD expect = *(INT16 *)(expect_buf + i), value = *(INT16 *)(buffer + i);
-        if (expect - value + 512 > 1024) break;
-    }
-
-    todo_wine_if(todo && i < length / 2)
-    ok_(__FILE__, line)(i == length, "unexpected buffer data\n");
-
-    hr = IMFMediaBuffer_Unlock(media_buffer);
-    ok_(__FILE__, line)(hr == S_OK, "Unlock returned %#lx\n", hr);
-    ret = IMFMediaBuffer_Release(media_buffer);
-    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)
@@ -1636,14 +1733,12 @@ static void test_wma_encoder(void)
         winetest_push_context("%lu", i);
         ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
         ok(output_status == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE, "got output[0].dwStatus %#lx\n", output_status);
-        hr = IMFSample_GetTotalLength(output_sample, &length);
-        ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
-        ok(length == wmaenc_block_size, "got length %lu\n", length);
-        ok(wmaenc_data_len > i * wmaenc_block_size, "got %lu blocks\n", i);
-        check_sample(output_sample, wmaenc_data + i * wmaenc_block_size);
+        ret = check_mf_sample(output_sample, output_sample_desc, &wmaenc_data, &wmaenc_data_len);
+        ok(ret == 0, "Unexpected %lu%% diff\n", ret);
         dump_mf_sample(output_sample, output_sample_desc, output_file);
         winetest_pop_context();
     }
+    ok(wmaenc_data_len == 0, "missing %#lx bytes\n", wmaenc_data_len);
     ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#lx\n", hr);
     ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);
     ret = IMFSample_Release(output_sample);
@@ -1784,8 +1879,8 @@ static void test_wma_decoder(void)

const struct buffer_desc output_buffer_desc[] =
     {
-        {.length = wmadec_block_size},
-        {.length = wmadec_block_size / 2},
+        {.length = wmadec_block_size, .compare = compare_pcm16},
+        {.length = wmadec_block_size / 2, .compare = compare_pcm16, .todo_length = TRUE},
     };
     const struct sample_desc output_sample_desc[] =
     {
@@ -1793,7 +1888,7 @@ static void test_wma_decoder(void)
             .buffer_count = 1, .buffers = output_buffer_desc + 0,
         },
         {
-            .buffer_count = 1, .buffers = output_buffer_desc + 1,
+            .buffer_count = 1, .buffers = output_buffer_desc + 1, .todo_length = TRUE
         },
     };

@@ -1993,8 +2088,6 @@ static void test_wma_decoder(void)
         hr = IMFSample_GetUINT32(output_sample, &MFSampleExtension_CleanPoint, &value);
         ok(hr == S_OK, "GetUINT32 MFSampleExtension_CleanPoint returned %#lx\n", hr);
         ok(value == 1, "got MFSampleExtension_CleanPoint %u\n", value);
-        hr = IMFSample_GetTotalLength(output_sample, &length);
-        ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
         flags = 0xdeadbeef;
         hr = IMFSample_GetSampleFlags(output_sample, &flags);
         ok(hr == S_OK, "GetSampleFlags returned %#lx\n", hr);
@@ -2010,29 +2103,23 @@ static void test_wma_decoder(void)
         if (output_status & MFT_OUTPUT_DATA_BUFFER_INCOMPLETE)
         {
             ok(output_status == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE, "got output[0].dwStatus %#lx\n", output_status);
-            ok(length == wmadec_block_size, "got length %lu\n", length);
             ok(duration == 928798, "got duration %I64d\n", duration);
-            check_sample_pcm16(output_sample, wmadec_data, TRUE);
+            ret = check_mf_sample(output_sample, output_sample_desc + 0, &wmadec_data, &wmadec_data_len);
+            todo_wine_if(ret > 0 && ret <= 10)  /* ffmpeg sometimes offsets the decoded data */
+            ok(ret == 0, "Unexpected %lu%% diff\n", ret);
             dump_mf_sample(output_sample, output_sample_desc + 0, output_file);
-            wmadec_data += wmadec_block_size;
-            wmadec_data_len -= wmadec_block_size;
         }
         else
         {
             ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);
             /* FFmpeg doesn't seem to decode WMA buffers in the same way as native */
             todo_wine
-            ok(length == wmadec_block_size / 2, "got length %lu\n", length);
-            todo_wine
             ok(duration == 464399, "got duration %I64d\n", duration);

-            if (length == wmadec_block_size / 2)
-            {
-                check_sample_pcm16(output_sample, wmadec_data, FALSE);
-                dump_mf_sample(output_sample, output_sample_desc + 1, output_file);
-            }
-            wmadec_data += length;
-            wmadec_data_len -= length;
+            ret = check_mf_sample(output_sample, output_sample_desc + 1, &wmadec_data, &wmadec_data_len);
+            todo_wine_if(ret > 0 && ret <= 10)  /* ffmpeg sometimes offsets the decoded data */
+            ok(ret == 0, "Unexpected %lu%% diff\n", ret);
+            dump_mf_sample(output_sample, output_sample_desc + 1, output_file);
         }
         ret = IMFSample_Release(output_sample);
         ok(ret == 0, "Release returned %lu\n", ret);
@@ -2045,7 +2132,7 @@ static void test_wma_decoder(void)
         /* some FFmpeg version request more input to complete decoding */
         if (hr == MF_E_TRANSFORM_NEED_MORE_INPUT && i == 2) break;
     }
-    todo_wine
+    todo_wine_if(wmadec_data_len == 0x1000)
     ok(wmadec_data_len == 0, "missing %#lx bytes\n", wmadec_data_len);

trace("created %s\n", debugstr_w(output_path));
@@ -2345,6 +2432,7 @@ static void test_h264_decoder(void)
     const struct buffer_desc output_buffer_desc_nv12 =
     {
         .length = actual_width * actual_height * 3 / 2,
+        .compare = compare_nv12, .rect = {.right = 82, .bottom = 84},
     };
     const struct sample_desc output_sample_desc_nv12 =
     {
@@ -2353,6 +2441,7 @@ static void test_h264_decoder(void)
     const struct buffer_desc output_buffer_desc_i420 =
     {
         .length = actual_width * actual_height * 3 / 2,
+        .compare = compare_i420, .rect = {.right = 82, .bottom = 84},
     };
     const struct sample_desc output_sample_desc_i420 =
     {
@@ -2366,9 +2455,8 @@ static void test_h264_decoder(void)
     DWORD input_id, output_id, input_count, output_count;
     IMFSample *input_sample, *output_sample;
     MFT_OUTPUT_STREAM_INFO output_info;
-    DWORD length, count, output_status;
     MFT_INPUT_STREAM_INFO input_info;
-    IMFMediaBuffer *media_buffer;
+    DWORD length, output_status;
     WCHAR output_path[MAX_PATH];
     IMFAttributes *attributes;
     IMFMediaType *media_type;
@@ -2377,7 +2465,6 @@ static void test_h264_decoder(void)
     ULONG i, ret, flags;
     HANDLE output_file;
     UINT32 value;
-    BYTE *data;
     HRESULT hr;

hr = CoInitialize(NULL);
@@ -2651,11 +2738,6 @@ static void test_h264_decoder(void)
     ok(hr == S_OK, "GetUINT32 MFSampleExtension_CleanPoint returned %#lx\n", hr);
     ok(value == 1, "got MFSampleExtension_CleanPoint %u\n", value);

-    count = 0xdeadbeef;
-    hr = IMFSample_GetBufferCount(output_sample, &count);
-    ok(hr == S_OK, "GetBufferCount returned %#lx\n", hr);
-    ok(count == 1, "got count %#lx\n", count);
-
     flags = 0xdeadbeef;
     hr = IMFSample_GetSampleFlags(output_sample, &flags);
     ok(hr == S_OK, "GetSampleFlags returned %#lx\n", hr);
@@ -2672,27 +2754,8 @@ static void test_h264_decoder(void)
     ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
     ok(duration - 333666 <= 2, "got duration %I64d\n", duration);

-    /* Win8 and before pad the data with garbage instead of original
-     * buffer data, make sure it's consistent.  */
-    hr = IMFSample_ConvertToContiguousBuffer(output_sample, &media_buffer);
-    ok(hr == S_OK, "ConvertToContiguousBuffer returned %#lx\n", hr);
-    hr = IMFMediaBuffer_Lock(media_buffer, &data, NULL, &length);
-    ok(hr == S_OK, "Lock returned %#lx\n", hr);
-    ok(length == nv12_frame_len, "got length %lu\n", length);
-
-    for (i = 0; i < actual_aperture.Area.cy; ++i)
-    {
-        memset(data + actual_width * i + actual_aperture.Area.cx, 0xcd, actual_width - actual_aperture.Area.cx);
-        memset(data + actual_width * (actual_height + i / 2) + actual_aperture.Area.cx, 0xcd, actual_width - actual_aperture.Area.cx);
-    }
-    memset(data + actual_width * actual_aperture.Area.cy, 0xcd, (actual_height - actual_aperture.Area.cy) * actual_width);
-    memset(data + actual_width * (actual_height + actual_aperture.Area.cy / 2), 0xcd, (actual_height - actual_aperture.Area.cy) / 2 * actual_width);
-
-    hr = IMFMediaBuffer_Unlock(media_buffer);
-    ok(hr == S_OK, "Unlock returned %#lx\n", hr);
-    IMFMediaBuffer_Release(media_buffer);
-
-    check_sample(output_sample, nv12_frame_data);
+    ret = check_mf_sample(output_sample, &output_sample_desc_nv12, &nv12_frame_data, &nv12_frame_len);
+    ok(ret == 0, "Unexpected %lu%% diff\n", ret);
     dump_mf_sample(output_sample, &output_sample_desc_nv12, output_file);

ret = IMFSample_Release(output_sample);
@@ -2770,33 +2833,8 @@ static void test_h264_decoder(void)
     ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
     ok(duration - 333666 <= 2, "got duration %I64d\n", duration);

-    /* Win8 and before pad the data with garbage instead of original
-     * buffer data, make sure it's consistent.  */
-    hr = IMFSample_ConvertToContiguousBuffer(output_sample, &media_buffer);
-    ok(hr == S_OK, "ConvertToContiguousBuffer returned %#lx\n", hr);
-    hr = IMFMediaBuffer_Lock(media_buffer, &data, NULL, &length);
-    ok(hr == S_OK, "Lock returned %#lx\n", hr);
-    ok(length == i420_frame_len, "got length %lu\n", length);
-
-    for (i = 0; i < actual_aperture.Area.cy; ++i)
-    {
-        memset(data + actual_width * i + actual_aperture.Area.cx, 0xcd, actual_width - actual_aperture.Area.cx);
-        memset(data + actual_width * actual_height + actual_width / 2 * i + actual_aperture.Area.cx / 2, 0xcd,
-                actual_width / 2 - actual_aperture.Area.cx / 2);
-        memset(data + actual_width * actual_height + actual_width / 2 * (actual_height / 2 + i) + actual_aperture.Area.cx / 2, 0xcd,
-                actual_width / 2 - actual_aperture.Area.cx / 2);
-    }
-    memset(data + actual_width * actual_aperture.Area.cy, 0xcd, (actual_height - actual_aperture.Area.cy) * actual_width);
-    memset(data + actual_width * actual_height + actual_width / 2 * actual_aperture.Area.cy / 2, 0xcd,
-            (actual_height - actual_aperture.Area.cy) / 2 * actual_width / 2);
-    memset(data + actual_width * actual_height + actual_width / 2 * (actual_height / 2 + actual_aperture.Area.cy / 2), 0xcd,
-            (actual_height - actual_aperture.Area.cy) / 2 * actual_width / 2);
-
-    hr = IMFMediaBuffer_Unlock(media_buffer);
-    ok(hr == S_OK, "Unlock returned %#lx\n", hr);
-    IMFMediaBuffer_Release(media_buffer);
-
-    check_sample(output_sample, i420_frame_data);
+    ret = check_mf_sample(output_sample, &output_sample_desc_i420, &i420_frame_data, &i420_frame_len);
+    ok(ret == 0, "Unexpected %lu%% diff\n", ret);
     dump_mf_sample(output_sample, &output_sample_desc_i420, output_file);

ret = IMFSample_Release(output_sample);
@@ -2932,9 +2970,9 @@ static void test_audio_convert(void)
     static const ULONG audioconv_block_size = 0x4000;
     const struct buffer_desc output_buffer_desc[] =
     {
-        {.length = audioconv_block_size},
-        {.length = 0x3dd8},
-        {.length = 0xfc},
+        {.length = audioconv_block_size, .compare = compare_pcm16},
+        {.length = 0x3dd8, .compare = compare_pcm16, .todo_length = TRUE},
+        {.length = 0xfc, .compare = compare_pcm16},
     };
     const struct sample_desc output_sample_desc[] =
     {
@@ -2942,7 +2980,7 @@ static void test_audio_convert(void)
             .buffer_count = 1, .buffers = output_buffer_desc + 0,
         },
         {
-            .buffer_count = 1, .buffers = output_buffer_desc + 1,
+            .buffer_count = 1, .buffers = output_buffer_desc + 1, .todo_length = TRUE,
         },
         {
             .buffer_count = 1, .buffers = output_buffer_desc + 2,
@@ -3133,14 +3171,10 @@ static void test_audio_convert(void)
         hr = IMFSample_GetSampleDuration(output_sample, &duration);
         ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
         ok(duration == 928798, "got duration %I64d\n", duration);
-        hr = IMFSample_GetTotalLength(output_sample, &length);
-        ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
-        ok(length == audioconv_block_size, "got length %lu\n", length);
-        ok(audioconv_data_len > audioconv_block_size, "got remaining length %lu\n", audioconv_data_len);
-        check_sample_pcm16(output_sample, audioconv_data, FALSE);
+
+        ret = check_mf_sample(output_sample, output_sample_desc + 0, &audioconv_data, &audioconv_data_len);
+        ok(ret == 0, "Unexpected %lu%% diff\n", ret);
         dump_mf_sample(output_sample, output_sample_desc + 0, output_file);
-        audioconv_data_len -= audioconv_block_size;
-        audioconv_data += audioconv_block_size;

winetest_pop_context();
         i++;
@@ -3153,15 +3187,10 @@ static void test_audio_convert(void)
     ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
     todo_wine
     ok(duration == 897506, "got duration %I64d\n", duration);
-    hr = IMFSample_GetTotalLength(output_sample, &length);
-    ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
-    todo_wine
-    ok(length == 15832, "got length %lu\n", length);
-    ok(audioconv_data_len == 16084, "got remaining length %lu\n", audioconv_data_len);
-    check_sample_pcm16(output_sample, audioconv_data, FALSE);
+
+    ret = check_mf_sample(output_sample, output_sample_desc + 1, &audioconv_data, &audioconv_data_len);
+    ok(ret == 0, "Unexpected %lu%% diff\n", ret);
     dump_mf_sample(output_sample, output_sample_desc + 1, output_file);
-    audioconv_data_len -= length;
-    audioconv_data += length;

ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);
@@ -3185,16 +3214,15 @@ static void test_audio_convert(void)
         ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
         todo_wine
         ok(duration == 14286, "got duration %I64d\n", duration);
-        hr = IMFSample_GetTotalLength(output_sample, &length);
-        ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
-        todo_wine
-        ok(length == audioconv_data_len, "got length %lu\n", length);
-        if (length == audioconv_data_len)
-        {
-            check_sample_pcm16(output_sample, audioconv_data, FALSE);
-            dump_mf_sample(output_sample, output_sample_desc + 2, output_file);
-        }
+
+        ret = check_mf_sample(output_sample, output_sample_desc + 2, &audioconv_data, &audioconv_data_len);
+        ok(ret == 0, "Unexpected %lu%% diff\n", ret);
+        dump_mf_sample(output_sample, output_sample_desc + 2, output_file);
     }
+    todo_wine
+    ok(audioconv_data_len == 0
+            || broken(audioconv_data_len == 0xfc) /* Win7 */,
+            "missing %#lx bytes\n", audioconv_data_len);

trace("created %s\n", debugstr_w(output_path));
     CloseHandle(output_file);
@@ -3388,6 +3416,7 @@ static void test_color_convert(void)
     const struct buffer_desc output_buffer_desc =
     {
         .length = actual_width * actual_height * 4,
+        .compare = compare_rgb32, .rect = {.right = 82, .bottom = 84},
     };
     const struct sample_desc output_sample_desc =
     {
@@ -3547,13 +3576,10 @@ static void test_color_convert(void)
     hr = IMFSample_GetSampleDuration(output_sample, &duration);
     ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
     ok(duration == 10000000, "got duration %I64d\n", duration);
-    hr = IMFSample_GetTotalLength(output_sample, &length);
-    ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
-    ok(length == output_info.cbSize, "got length %lu\n", length);
-    check_sample_rgb32(output_sample, rgb32_data);
+
+    ret = check_mf_sample(output_sample, &output_sample_desc, &rgb32_data, &rgb32_data_len);
+    ok(ret <= 4 /* small and harmless differences in Wine vs Windows */, "Unexpected %lu%% diff\n", ret);
     dump_mf_sample(output_sample, &output_sample_desc, output_file);
-    rgb32_data_len -= output_info.cbSize;
-    rgb32_data += output_info.cbSize;

trace("created %s\n", debugstr_w(output_path));
     CloseHandle(output_file);
@@ -3743,6 +3769,7 @@ static void test_video_processor(void)
     const struct buffer_desc output_buffer_desc =
     {
         .length = actual_width * actual_height * 4,
+        .compare = compare_rgb32, .rect = {.top = 12, .right = 82, .bottom = 96},
     };
     const struct sample_desc output_sample_desc =
     {
@@ -3768,7 +3795,6 @@ static void test_video_processor(void)
     IMFMediaEvent *event;
     unsigned int value;
     HANDLE output_file;
-    BYTE *ptr, tmp;
     UINT32 count;
     HRESULT hr;
     ULONG ret;
@@ -4233,31 +4259,11 @@ todo_wine {
     hr = IMFSample_GetSampleDuration(output_sample, &duration);
     ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
     ok(duration == 10000000, "got duration %I64d\n", duration);
-    hr = IMFSample_GetTotalLength(output_sample, &length);
-    ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
-    ok(length == output_info.cbSize, "got length %lu\n", length);

-    hr = IMFSample_ConvertToContiguousBuffer(output_sample, &buffer);
-    ok(hr == S_OK, "ConvertToContiguousBuffer returned %#lx\n", hr);
-    hr = IMFMediaBuffer_Lock(buffer, &ptr, NULL, &length);
-    ok(hr == S_OK, "Lock returned %#lx\n", hr);
-    tmp = *ptr;
-    hr = IMFMediaBuffer_Unlock(buffer);
-    ok(hr == S_OK, "Lock returned %#lx\n", hr);
-    IMFMediaBuffer_Release(buffer);
-
-    /* w1064v1809 ignores MF_MT_MINIMUM_DISPLAY_APERTURE and resizes the frame */
-    todo_wine
-    ok(tmp == 0xcd || broken(tmp == 0x00), "got %#x\n", tmp);
-    if (tmp == 0x00)
-        win_skip("Frame got resized, skipping output comparison\n");
-    else if (tmp == 0xcd) /* Wine doesn't flip the frame, yet */
-    {
-        check_sample_rgb32(output_sample, rgb32_data);
-        dump_mf_sample(output_sample, &output_sample_desc, output_file);
-    }
-    rgb32_data_len -= output_info.cbSize;
-    rgb32_data += output_info.cbSize;
+    ret = check_mf_sample(output_sample, &output_sample_desc, &rgb32_data, &rgb32_data_len);
+    todo_wine /* Wine doesn't flip the frame, yet */
+    ok(ret == 0 || broken(ret == 25) /* w1064v1507 / w1064v1809 incorrectly rescale */, "got %lu%% diff\n", ret);
+    dump_mf_sample(output_sample, &output_sample_desc, output_file);

trace("created %s\n", debugstr_w(output_path));
     CloseHandle(output_file);
@@ -4410,8 +4416,8 @@ static void test_mp3_decoder(void)
     static const ULONG mp3dec_block_size = 0x1200;
     const struct buffer_desc output_buffer_desc[] =
     {
-        {.length = 0x9c0},
-        {.length = mp3dec_block_size},
+        {.length = 0x9c0, .compare = compare_pcm16},
+        {.length = mp3dec_block_size, .compare = compare_pcm16},
     };
     const struct sample_desc output_sample_desc[] =
     {
@@ -4596,14 +4602,15 @@ static void test_mp3_decoder(void)
     ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
     ok(length == 0x9c0 || broken(length == mp3dec_block_size) /* win8 */ || broken(length == 0x900) /* win7 */,
             "got length %lu\n", length);
-    ok(mp3dec_data_len > length, "got remaining length %lu\n", mp3dec_data_len);
-    if (length == 0x9c0)
+    if (broken(length != 0x9c0))
     {
-        check_sample_pcm16(output_sample, mp3dec_data, FALSE);
-        dump_mf_sample(output_sample, output_sample_desc + 0, output_file);
+        win_skip("Skipping MP3 decoder output sample checks on Win7 / Win8\n");
+        goto skip_mp3dec_output;
     }
-    mp3dec_data_len -= 0x9c0;
-    mp3dec_data += 0x9c0;
+
+    ret = check_mf_sample(output_sample, output_sample_desc + 0, &mp3dec_data, &mp3dec_data_len);
+    ok(ret == 0, "Unexpected %lu%% diff\n", ret);
+    dump_mf_sample(output_sample, output_sample_desc + 0, output_file);

i = duration;
     while (SUCCEEDED(hr = check_mft_process_output(transform, output_sample, &output_status)))
@@ -4625,19 +4632,10 @@ static void test_mp3_decoder(void)
         ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
         ok(duration == 522449 || broken(261225 - duration <= 1) /* win7 */,
                 "got duration %I64d\n", duration);
-        hr = IMFSample_GetTotalLength(output_sample, &length);
-        ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
-        ok(length == mp3dec_block_size || broken(length == 0x900) /* win7 */,
-                "got length %lu\n", length);
-        ok(mp3dec_data_len > length || broken(mp3dec_data_len == 2304 || mp3dec_data_len == 0) /* win7 */,
-                "got remaining length %lu\n", mp3dec_data_len);
-        if (length == mp3dec_block_size)
-        {
-            check_sample_pcm16(output_sample, mp3dec_data, FALSE);
-            dump_mf_sample(output_sample, output_sample_desc + 1, output_file);
-        }
-        mp3dec_data += min(mp3dec_data_len, length);
-        mp3dec_data_len -= min(mp3dec_data_len, length);
+
+        ret = check_mf_sample(output_sample, output_sample_desc + 1, &mp3dec_data, &mp3dec_data_len);
+        ok(ret == 0, "Unexpected %lu%% diff\n", ret);
+        dump_mf_sample(output_sample, output_sample_desc + 1, output_file);

winetest_pop_context();
         i += duration;
@@ -4650,15 +4648,10 @@ static void test_mp3_decoder(void)
     ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
     todo_wine
     ok(duration == 522449 || broken(261225 - duration <= 1) /* win7 */, "got duration %I64d\n", duration);
-    hr = IMFSample_GetTotalLength(output_sample, &length);
-    ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
-    todo_wine
-    ok(length == mp3dec_block_size || broken(length == 0) /* win7 */, "got length %lu\n", length);
-    ok(mp3dec_data_len == mp3dec_block_size || broken(mp3dec_data_len == 0) /* win7 */, "got remaining length %lu\n", mp3dec_data_len);
-    check_sample_pcm16(output_sample, mp3dec_data, FALSE);
+
+    ret = check_mf_sample(output_sample, output_sample_desc + 1, &mp3dec_data, &mp3dec_data_len);
+    ok(ret == 0, "Unexpected %lu%% diff\n", ret);
     dump_mf_sample(output_sample, output_sample_desc + 1, output_file);
-    mp3dec_data_len -= length;
-    mp3dec_data += length;

IMFSample_Release(output_sample);

@@ -4678,16 +4671,12 @@ static void test_mp3_decoder(void)
         ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
         todo_wine
         ok(duration == 14286, "got duration %I64d\n", duration);
-        hr = IMFSample_GetTotalLength(output_sample, &length);
-        ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
-        todo_wine
-        ok(length == mp3dec_data_len, "got length %lu\n", length);
-        if (length == mp3dec_data_len)
-        {
-            check_sample_pcm16(output_sample, mp3dec_data, FALSE);
-            dump_mf_sample(output_sample, output_sample_desc + 1, output_file);
-        }
+
+        ret = check_mf_sample(output_sample, output_sample_desc + 1, &mp3dec_data, &mp3dec_data_len);
+        ok(ret == 0, "Unexpected %lu%% diff\n", ret);
+        dump_mf_sample(output_sample, output_sample_desc + 1, output_file);
     }
+    ok(mp3dec_data_len == 0, "missing %#lx bytes\n", mp3dec_data_len);

trace("created %s\n", debugstr_w(output_path));
     CloseHandle(output_file);
@@ -4702,6 +4691,7 @@ static void test_mp3_decoder(void)
     hr = IMFSample_GetTotalLength(output_sample, &length);
     ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
     ok(length == 0, "got length %lu\n", length);
+skip_mp3dec_output:
     ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

[PATCH v2 07/10] mf/tests: Factor IMFSample attributes checks in check_mf_sample.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/mf/tests/transform.c | 307 ++++++++++++++++++++------------------
 1 file changed, 158 insertions(+), 149 deletions(-)

diff --git a/dlls/mf/tests/transform.c b/dlls/mf/tests/transform.c
index 9e88ee21f1a..12be38f1650 100644
--- a/dlls/mf/tests/transform.c
+++ b/dlls/mf/tests/transform.c
@@ -49,6 +49,8 @@ DEFINE_GUID(MFAudioFormat_RAW_AAC1,WAVE_FORMAT_RAW_AAC1,0x0000,0x0010,0x80,0x00,
 DEFINE_GUID(MFVideoFormat_ABGR32,0x00000020,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71);
 DEFINE_GUID(MFVideoFormat_P208,0x38303250,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71);

+DEFINE_GUID(mft_output_sample_incomplete,0xffffff,0xffff,0xffff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
+
 static void load_resource(const WCHAR *filename, const BYTE **data, DWORD *length)
 {
     HRSRC resource = FindResourceW(NULL, filename, (const WCHAR *)RT_RCDATA);
@@ -356,7 +358,19 @@ static HRESULT check_mft_process_output_(int line, IMFTransform *transform, IMFS
         ok_(__FILE__, line)(status == MFT_PROCESS_OUTPUT_STATUS_NEW_STREAMS,
                 "got status %#lx\n", status);
     else
+    {
+        if (*output_status & MFT_OUTPUT_DATA_BUFFER_INCOMPLETE)
+        {
+            hr = IMFSample_SetUINT32(output_sample, &mft_output_sample_incomplete, 1);
+            ok_(__FILE__, line)(hr == S_OK, "SetUINT32 returned %#lx\n", hr);
+        }
+        else
+        {
+            hr = IMFSample_DeleteItem(output_sample, &mft_output_sample_incomplete);
+            ok_(__FILE__, line)(hr == S_OK, "DeleteItem returned %#lx\n", hr);
+        }
         ok_(__FILE__, line)(status == 0, "got status %#lx\n", status);
+    }

return ret;
 }
@@ -471,6 +485,9 @@ struct buffer_desc

struct sample_desc
 {
+    const struct attribute_desc *attributes;
+    LONGLONG sample_time;
+    LONGLONG sample_duration;
     DWORD buffer_count;
     const struct buffer_desc *buffers;
     BOOL todo_length;
@@ -572,15 +589,38 @@ static DWORD check_mf_sample_(int line, IMFSample *sample, const struct sample_d
         const BYTE **expect_data, DWORD *expect_data_len)
 {
     struct check_mf_sample_context ctx = {.data = *expect_data, .data_len = *expect_data_len, .line = line};
-    DWORD buffer_count, total_length;
+    DWORD buffer_count, total_length, sample_flags;
+    LONGLONG timestamp;
     HRESULT hr;

+    if (expect->attributes)
+        check_attributes_(line, (IMFAttributes *)sample, expect->attributes, -1);
+
     buffer_count = 0xdeadbeef;
     hr = IMFSample_GetBufferCount(sample, &buffer_count);
     ok_(__FILE__, line)(hr == S_OK, "GetBufferCount returned %#lx\n", hr);
     ok_(__FILE__, line)(buffer_count == expect->buffer_count,
             "got %lu buffers\n", buffer_count);

+    sample_flags = 0xdeadbeef;
+    hr = IMFSample_GetSampleFlags(sample, &sample_flags);
+    ok_(__FILE__, line)(hr == S_OK, "GetSampleFlags returned %#lx\n", hr);
+    ok_(__FILE__, line)(sample_flags == 0,
+            "got sample flags %#lx\n", sample_flags);
+
+    timestamp = 0xdeadbeef;
+    hr = IMFSample_GetSampleTime(sample, &timestamp);
+    ok_(__FILE__, line)(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
+    ok_(__FILE__, line)(llabs(timestamp - expect->sample_time) <= 50,
+            "got sample time %I64d\n", timestamp);
+
+    timestamp = 0xdeadbeef;
+    hr = IMFSample_GetSampleDuration(sample, &timestamp);
+    ok_(__FILE__, line)(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
+    todo_wine_if(expect->todo_length)
+    ok_(__FILE__, line)(llabs(timestamp - expect->sample_duration) <= 1,
+            "got sample duration %I64d\n", timestamp);
+
     enum_mf_media_buffers(sample, expect, check_mf_sample_buffer, &ctx);

total_length = 0xdeadbeef;
@@ -1621,9 +1661,27 @@ static void test_wma_encoder(void)
     {
         {.length = wmaenc_block_size},
     };
+    const struct attribute_desc output_sample_attributes[] =
+    {
+        ATTR_UINT32(mft_output_sample_incomplete, 1),
+        ATTR_UINT32(MFSampleExtension_CleanPoint, 1),
+        {0},
+    };
     const struct sample_desc output_sample_desc[] =
     {
         {
+            .attributes = output_sample_attributes,
+            .sample_time = 0, .sample_duration = 3250794,
+            .buffer_count = 1, .buffers = output_buffer_desc,
+        },
+        {
+            .attributes = output_sample_attributes,
+            .sample_time = 3250794, .sample_duration = 3715193,
+            .buffer_count = 1, .buffers = output_buffer_desc,
+        },
+        {
+            .attributes = output_sample_attributes,
+            .sample_time = 6965986, .sample_duration = 3366893,
             .buffer_count = 1, .buffers = output_buffer_desc,
         },
     };
@@ -1733,9 +1791,9 @@ static void test_wma_encoder(void)
         winetest_push_context("%lu", i);
         ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
         ok(output_status == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE, "got output[0].dwStatus %#lx\n", output_status);
-        ret = check_mf_sample(output_sample, output_sample_desc, &wmaenc_data, &wmaenc_data_len);
+        ret = check_mf_sample(output_sample, output_sample_desc + i, &wmaenc_data, &wmaenc_data_len);
         ok(ret == 0, "Unexpected %lu%% diff\n", ret);
-        dump_mf_sample(output_sample, output_sample_desc, output_file);
+        dump_mf_sample(output_sample, output_sample_desc + i, output_file);
         winetest_pop_context();
     }
     ok(wmaenc_data_len == 0, "missing %#lx bytes\n", wmaenc_data_len);
@@ -1882,13 +1940,39 @@ static void test_wma_decoder(void)
         {.length = wmadec_block_size, .compare = compare_pcm16},
         {.length = wmadec_block_size / 2, .compare = compare_pcm16, .todo_length = TRUE},
     };
+    const struct attribute_desc output_sample_attributes[] =
+    {
+        ATTR_UINT32(mft_output_sample_incomplete, 1),
+        ATTR_UINT32(MFSampleExtension_CleanPoint, 1),
+        {0},
+    };
+    const struct attribute_desc output_sample_attributes_todo[] =
+    {
+        ATTR_UINT32(mft_output_sample_incomplete, 1, .todo = TRUE),
+        ATTR_UINT32(MFSampleExtension_CleanPoint, 1),
+        {0},
+    };
     const struct sample_desc output_sample_desc[] =
     {
         {
+            .attributes = output_sample_attributes + 0,
+            .sample_time = 0, .sample_duration = 928798,
             .buffer_count = 1, .buffers = output_buffer_desc + 0,
         },
         {
-            .buffer_count = 1, .buffers = output_buffer_desc + 1, .todo_length = TRUE
+            .attributes = output_sample_attributes + 0,
+            .sample_time = 928798, .sample_duration = 928798,
+            .buffer_count = 1, .buffers = output_buffer_desc + 0,
+        },
+        {
+            .attributes = output_sample_attributes_todo + 0,
+            .sample_time = 1857596, .sample_duration = 928798,
+            .buffer_count = 1, .buffers = output_buffer_desc + 0,
+        },
+        {
+            .attributes = output_sample_attributes + 1, /* not MFT_OUTPUT_DATA_BUFFER_INCOMPLETE */
+            .sample_time = 2786394, .sample_duration = 464399,
+            .buffer_count = 1, .buffers = output_buffer_desc + 1, .todo_length = TRUE,
         },
     };

@@ -1899,17 +1983,15 @@ static void test_wma_decoder(void)
     ULONG wmadec_data_len, wmaenc_data_len;
     const BYTE *wmadec_data, *wmaenc_data;
     MFT_OUTPUT_STREAM_INFO output_info;
-    DWORD flags, length, output_status;
     MFT_INPUT_STREAM_INFO input_info;
+    DWORD length, output_status;
     WCHAR output_path[MAX_PATH];
     IMediaObject *media_object;
     IPropertyBag *property_bag;
     IMFMediaType *media_type;
     IMFTransform *transform;
-    LONGLONG time, duration;
     HANDLE output_file;
     ULONG i, ret, ref;
-    UINT32 value;
     HRESULT hr;

hr = CoInitialize(NULL);
@@ -2082,44 +2164,24 @@ static void test_wma_decoder(void)
     for (i = 0; i < 4; ++i)
     {
         winetest_push_context("%lu", i);
-
         ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
-        value = 0xdeadbeef;
-        hr = IMFSample_GetUINT32(output_sample, &MFSampleExtension_CleanPoint, &value);
-        ok(hr == S_OK, "GetUINT32 MFSampleExtension_CleanPoint returned %#lx\n", hr);
-        ok(value == 1, "got MFSampleExtension_CleanPoint %u\n", value);
-        flags = 0xdeadbeef;
-        hr = IMFSample_GetSampleFlags(output_sample, &flags);
-        ok(hr == S_OK, "GetSampleFlags returned %#lx\n", hr);
-        ok(flags == 0, "got flags %#lx\n", flags);
-        time = 0xdeadbeef;
-        hr = IMFSample_GetSampleTime(output_sample, &time);
-        ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
-        ok(time == i * 928798, "got time %I64d\n", time);
-        duration = 0xdeadbeef;
-        hr = IMFSample_GetSampleDuration(output_sample, &duration);
-        ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
-
-        if (output_status & MFT_OUTPUT_DATA_BUFFER_INCOMPLETE)
+        if (!strcmp(winetest_platform, "wine") && i == 2 && (output_status & MFT_OUTPUT_DATA_BUFFER_INCOMPLETE))
+            todo_wine ok(0, "skipping bogus sample check\n");
+        else if (output_status & MFT_OUTPUT_DATA_BUFFER_INCOMPLETE)
         {
             ok(output_status == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE, "got output[0].dwStatus %#lx\n", output_status);
-            ok(duration == 928798, "got duration %I64d\n", duration);
-            ret = check_mf_sample(output_sample, output_sample_desc + 0, &wmadec_data, &wmadec_data_len);
+            ret = check_mf_sample(output_sample, output_sample_desc + i, &wmadec_data, &wmadec_data_len);
             todo_wine_if(ret > 0 && ret <= 10)  /* ffmpeg sometimes offsets the decoded data */
             ok(ret == 0, "Unexpected %lu%% diff\n", ret);
-            dump_mf_sample(output_sample, output_sample_desc + 0, output_file);
+            dump_mf_sample(output_sample, output_sample_desc + i, output_file);
         }
         else
         {
             ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);
-            /* FFmpeg doesn't seem to decode WMA buffers in the same way as native */
-            todo_wine
-            ok(duration == 464399, "got duration %I64d\n", duration);
-
-            ret = check_mf_sample(output_sample, output_sample_desc + 1, &wmadec_data, &wmadec_data_len);
+            ret = check_mf_sample(output_sample, output_sample_desc + i, &wmadec_data, &wmadec_data_len);
             todo_wine_if(ret > 0 && ret <= 10)  /* ffmpeg sometimes offsets the decoded data */
             ok(ret == 0, "Unexpected %lu%% diff\n", ret);
-            dump_mf_sample(output_sample, output_sample_desc + 1, output_file);
+            dump_mf_sample(output_sample, output_sample_desc + i, output_file);
         }
         ret = IMFSample_Release(output_sample);
         ok(ret == 0, "Release returned %lu\n", ret);
@@ -2429,6 +2491,11 @@ static void test_h264_decoder(void)
         },
     };

+    const struct attribute_desc output_sample_attributes[] =
+    {
+        ATTR_UINT32(MFSampleExtension_CleanPoint, 1),
+        {0},
+    };
     const struct buffer_desc output_buffer_desc_nv12 =
     {
         .length = actual_width * actual_height * 3 / 2,
@@ -2436,6 +2503,8 @@ static void test_h264_decoder(void)
     };
     const struct sample_desc output_sample_desc_nv12 =
     {
+        .attributes = output_sample_attributes,
+        .sample_time = 0, .sample_duration = 333667,
         .buffer_count = 1, .buffers = &output_buffer_desc_nv12,
     };
     const struct buffer_desc output_buffer_desc_i420 =
@@ -2445,6 +2514,8 @@ static void test_h264_decoder(void)
     };
     const struct sample_desc output_sample_desc_i420 =
     {
+        .attributes = output_sample_attributes,
+        .sample_time = 333667, .sample_duration = 333667,
         .buffer_count = 1, .buffers = &output_buffer_desc_i420,
     };

@@ -2460,11 +2531,9 @@ static void test_h264_decoder(void)
     WCHAR output_path[MAX_PATH];
     IMFAttributes *attributes;
     IMFMediaType *media_type;
-    LONGLONG time, duration;
     IMFTransform *transform;
     ULONG i, ret, flags;
     HANDLE output_file;
-    UINT32 value;
     HRESULT hr;

hr = CoInitialize(NULL);
@@ -2734,26 +2803,6 @@ static void test_h264_decoder(void)
     ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
     ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);

-    hr = IMFSample_GetUINT32(output_sample, &MFSampleExtension_CleanPoint, &value);
-    ok(hr == S_OK, "GetUINT32 MFSampleExtension_CleanPoint returned %#lx\n", hr);
-    ok(value == 1, "got MFSampleExtension_CleanPoint %u\n", value);
-
-    flags = 0xdeadbeef;
-    hr = IMFSample_GetSampleFlags(output_sample, &flags);
-    ok(hr == S_OK, "GetSampleFlags returned %#lx\n", hr);
-    ok(flags == 0, "got flags %#lx\n", flags);
-
-    time = 0xdeadbeef;
-    hr = IMFSample_GetSampleTime(output_sample, &time);
-    ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
-    ok(time == 0, "got time %I64d\n", time);
-
-    /* doesn't matter what frame rate we've selected, duration is defined by the stream */
-    duration = 0xdeadbeef;
-    hr = IMFSample_GetSampleDuration(output_sample, &duration);
-    ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
-    ok(duration - 333666 <= 2, "got duration %I64d\n", duration);
-
     ret = check_mf_sample(output_sample, &output_sample_desc_nv12, &nv12_frame_data, &nv12_frame_len);
     ok(ret == 0, "Unexpected %lu%% diff\n", ret);
     dump_mf_sample(output_sample, &output_sample_desc_nv12, output_file);
@@ -2823,16 +2872,6 @@ static void test_h264_decoder(void)
     ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
     ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);

-    hr = IMFSample_GetSampleTime(output_sample, &time);
-    ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
-    todo_wine_if(time == 1334666)  /* when VA-API plugin is used */
-    ok(time - 333666 <= 2, "got time %I64d\n", time);
-
-    duration = 0xdeadbeef;
-    hr = IMFSample_GetSampleDuration(output_sample, &duration);
-    ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
-    ok(duration - 333666 <= 2, "got duration %I64d\n", duration);
-
     ret = check_mf_sample(output_sample, &output_sample_desc_i420, &i420_frame_data, &i420_frame_len);
     ok(ret == 0, "Unexpected %lu%% diff\n", ret);
     dump_mf_sample(output_sample, &output_sample_desc_i420, output_file);
@@ -2974,21 +3013,34 @@ static void test_audio_convert(void)
         {.length = 0x3dd8, .compare = compare_pcm16, .todo_length = TRUE},
         {.length = 0xfc, .compare = compare_pcm16},
     };
+    const struct attribute_desc output_sample_attributes[] =
+    {
+        ATTR_UINT32(mft_output_sample_incomplete, 1),
+        ATTR_UINT32(MFSampleExtension_CleanPoint, has_video_processor /* 0 on Win7 */, .todo = TRUE),
+        {0},
+    };
     const struct sample_desc output_sample_desc[] =
     {
         {
+            .attributes = output_sample_attributes + 0,
+            .sample_time = 0, .sample_duration = 928798,
             .buffer_count = 1, .buffers = output_buffer_desc + 0,
         },
         {
+            .attributes = output_sample_attributes + 1, /* not MFT_OUTPUT_DATA_BUFFER_INCOMPLETE */
+            .sample_time = 9287980, .sample_duration = 897506,
             .buffer_count = 1, .buffers = output_buffer_desc + 1, .todo_length = TRUE,
         },
         {
+            .attributes = output_sample_attributes + 0,
+            .sample_time = 10185486, .sample_duration = 14286,
             .buffer_count = 1, .buffers = output_buffer_desc + 2,
         },
     };

MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Audio, MFAudioFormat_PCM};
     MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Audio, MFAudioFormat_Float};
+    struct sample_desc tmp_sample_desc = output_sample_desc[0];
     ULONG audio_data_len, audioconv_data_len;
     IMFSample *input_sample, *output_sample;
     const BYTE *audio_data, *audioconv_data;
@@ -2997,7 +3049,6 @@ static void test_audio_convert(void)
     WCHAR output_path[MAX_PATH];
     DWORD length, output_status;
     IMFMediaType *media_type;
-    LONGLONG time, duration;
     IMFTransform *transform;
     HANDLE output_file;
     ULONG i, ret;
@@ -3163,31 +3214,17 @@ static void test_audio_convert(void)
             winetest_pop_context();
             break;
         }
-
         ok(output_status == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE, "got output[0].dwStatus %#lx\n", output_status);
-        hr = IMFSample_GetSampleTime(output_sample, &time);
-        ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
-        ok(time == i * 928798, "got time %I64d\n", time);
-        hr = IMFSample_GetSampleDuration(output_sample, &duration);
-        ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
-        ok(duration == 928798, "got duration %I64d\n", duration);
-
-        ret = check_mf_sample(output_sample, output_sample_desc + 0, &audioconv_data, &audioconv_data_len);
+
+        ret = check_mf_sample(output_sample, &tmp_sample_desc, &audioconv_data, &audioconv_data_len);
         ok(ret == 0, "Unexpected %lu%% diff\n", ret);
-        dump_mf_sample(output_sample, output_sample_desc + 0, output_file);
+        dump_mf_sample(output_sample, &tmp_sample_desc, output_file);
+        tmp_sample_desc.sample_time += tmp_sample_desc.sample_duration;

winetest_pop_context();
         i++;
     }

-    hr = IMFSample_GetSampleTime(output_sample, &time);
-    ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
-    ok(time == i * 928798, "got time %I64d\n", time);
-    hr = IMFSample_GetSampleDuration(output_sample, &duration);
-    ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
-    todo_wine
-    ok(duration == 897506, "got duration %I64d\n", duration);
-
     ret = check_mf_sample(output_sample, output_sample_desc + 1, &audioconv_data, &audioconv_data_len);
     ok(ret == 0, "Unexpected %lu%% diff\n", ret);
     dump_mf_sample(output_sample, output_sample_desc + 1, output_file);
@@ -3206,15 +3243,6 @@ static void test_audio_convert(void)

if (hr == S_OK)
     {
-        hr = IMFSample_GetSampleTime(output_sample, &time);
-        ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
-        todo_wine
-        ok(time == 10185486, "got time %I64d\n", time);
-        hr = IMFSample_GetSampleDuration(output_sample, &duration);
-        ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
-        todo_wine
-        ok(duration == 14286, "got duration %I64d\n", duration);
-
         ret = check_mf_sample(output_sample, output_sample_desc + 2, &audioconv_data, &audioconv_data_len);
         ok(ret == 0, "Unexpected %lu%% diff\n", ret);
         dump_mf_sample(output_sample, output_sample_desc + 2, output_file);
@@ -3418,8 +3446,15 @@ static void test_color_convert(void)
         .length = actual_width * actual_height * 4,
         .compare = compare_rgb32, .rect = {.right = 82, .bottom = 84},
     };
+    const struct attribute_desc output_sample_attributes[] =
+    {
+        ATTR_UINT32(MFSampleExtension_CleanPoint, 0, .todo = TRUE),
+        {0},
+    };
     const struct sample_desc output_sample_desc =
     {
+        .attributes = output_sample_attributes,
+        .sample_time = 0, .sample_duration = 10000000,
         .buffer_count = 1, .buffers = &output_buffer_desc,
     };

@@ -3433,7 +3468,6 @@ static void test_color_convert(void)
     WCHAR output_path[MAX_PATH];
     DWORD length, output_status;
     IMFMediaType *media_type;
-    LONGLONG time, duration;
     IMFTransform *transform;
     HANDLE output_file;
     ULONG i, ret;
@@ -3570,13 +3604,6 @@ static void test_color_convert(void)
     ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
     ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);

-    hr = IMFSample_GetSampleTime(output_sample, &time);
-    ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
-    ok(time == 0, "got time %I64d\n", time);
-    hr = IMFSample_GetSampleDuration(output_sample, &duration);
-    ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
-    ok(duration == 10000000, "got duration %I64d\n", duration);
-
     ret = check_mf_sample(output_sample, &output_sample_desc, &rgb32_data, &rgb32_data_len);
     ok(ret <= 4 /* small and harmless differences in Wine vs Windows */, "Unexpected %lu%% diff\n", ret);
     dump_mf_sample(output_sample, &output_sample_desc, output_file);
@@ -3771,8 +3798,15 @@ static void test_video_processor(void)
         .length = actual_width * actual_height * 4,
         .compare = compare_rgb32, .rect = {.top = 12, .right = 82, .bottom = 96},
     };
+    const struct attribute_desc output_sample_attributes[] =
+    {
+        ATTR_UINT32(MFSampleExtension_CleanPoint, 1, .todo = TRUE),
+        {0},
+    };
     const struct sample_desc output_sample_desc =
     {
+        .attributes = output_sample_attributes,
+        .sample_time = 0, .sample_duration = 10000000,
         .buffer_count = 1, .buffers = &output_buffer_desc,
     };

@@ -3789,7 +3823,6 @@ static void test_video_processor(void)
     MFT_OUTPUT_STREAM_INFO output_info;
     MFT_INPUT_STREAM_INFO input_info;
     WCHAR output_path[MAX_PATH];
-    LONGLONG time, duration;
     IMFTransform *transform;
     IMFMediaBuffer *buffer;
     IMFMediaEvent *event;
@@ -4253,13 +4286,6 @@ todo_wine {
     }
     ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);

-    hr = IMFSample_GetSampleTime(output_sample, &time);
-    ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
-    ok(time == 0, "got time %I64d\n", time);
-    hr = IMFSample_GetSampleDuration(output_sample, &duration);
-    ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
-    ok(duration == 10000000, "got duration %I64d\n", duration);
-
     ret = check_mf_sample(output_sample, &output_sample_desc, &rgb32_data, &rgb32_data_len);
     todo_wine /* Wine doesn't flip the frame, yet */
     ok(ret == 0 || broken(ret == 25) /* w1064v1507 / w1064v1809 incorrectly rescale */, "got %lu%% diff\n", ret);
@@ -4419,18 +4445,34 @@ static void test_mp3_decoder(void)
         {.length = 0x9c0, .compare = compare_pcm16},
         {.length = mp3dec_block_size, .compare = compare_pcm16},
     };
+    const struct attribute_desc output_sample_attributes[] =
+    {
+        ATTR_UINT32(mft_output_sample_incomplete, 1),
+        ATTR_UINT32(MFSampleExtension_CleanPoint, 1),
+        {0},
+    };
     const struct sample_desc output_sample_desc[] =
     {
         {
+            .attributes = output_sample_attributes + 0,
+            .sample_time = 0, .sample_duration = 282993,
             .buffer_count = 1, .buffers = output_buffer_desc + 0,
         },
         {
+            .attributes = output_sample_attributes + 0,
+            .sample_time = 282993, .sample_duration = 522449,
+            .buffer_count = 1, .buffers = output_buffer_desc + 1,
+        },
+        {
+            .attributes = output_sample_attributes + 1, /* not MFT_OUTPUT_DATA_BUFFER_INCOMPLETE */
+            .sample_time = 10209524, .sample_duration = 522449,
             .buffer_count = 1, .buffers = output_buffer_desc + 1,
         },
     };

MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Audio, MFAudioFormat_PCM};
     MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Audio, MFAudioFormat_MP3};
+    struct sample_desc tmp_sample_desc = output_sample_desc[1];
     IMFSample *input_sample, *output_sample;
     ULONG mp3dec_data_len, mp3enc_data_len;
     const BYTE *mp3dec_data, *mp3enc_data;
@@ -4440,7 +4482,6 @@ static void test_mp3_decoder(void)
     DWORD length, output_status;
     IMFMediaType *media_type;
     IMFTransform *transform;
-    LONGLONG time, duration;
     HANDLE output_file;
     ULONG i, ret;
     HRESULT hr;
@@ -4591,13 +4632,6 @@ static void test_mp3_decoder(void)
     ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
     ok(output_status == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE, "got output[0].dwStatus %#lx\n", output_status);

-    hr = IMFSample_GetSampleTime(output_sample, &time);
-    ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
-    ok(time == 0, "got time %I64d\n", time);
-    hr = IMFSample_GetSampleDuration(output_sample, &duration);
-    ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
-    ok(duration == 282993 || broken(duration == 522449) /* win8 */ || broken(duration == 261224) /* win7 */,
-            "got duration %I64d\n", duration);
     hr = IMFSample_GetTotalLength(output_sample, &length);
     ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
     ok(length == 0x9c0 || broken(length == mp3dec_block_size) /* win8 */ || broken(length == 0x900) /* win7 */,
@@ -4612,7 +4646,6 @@ static void test_mp3_decoder(void)
     ok(ret == 0, "Unexpected %lu%% diff\n", ret);
     dump_mf_sample(output_sample, output_sample_desc + 0, output_file);

-    i = duration;
     while (SUCCEEDED(hr = check_mft_process_output(transform, output_sample, &output_status)))
     {
         winetest_push_context("%lu", i);
@@ -4623,35 +4656,20 @@ static void test_mp3_decoder(void)
             winetest_pop_context();
             break;
         }
-
         ok(output_status == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE, "got output[0].dwStatus %#lx\n", output_status);
-        hr = IMFSample_GetSampleTime(output_sample, &time);
-        ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
-        ok(time == i, "got time %I64d\n", time);
-        hr = IMFSample_GetSampleDuration(output_sample, &duration);
-        ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
-        ok(duration == 522449 || broken(261225 - duration <= 1) /* win7 */,
-                "got duration %I64d\n", duration);

-        ret = check_mf_sample(output_sample, output_sample_desc + 1, &mp3dec_data, &mp3dec_data_len);
+        ret = check_mf_sample(output_sample, &tmp_sample_desc, &mp3dec_data, &mp3dec_data_len);
         ok(ret == 0, "Unexpected %lu%% diff\n", ret);
-        dump_mf_sample(output_sample, output_sample_desc + 1, output_file);
+        dump_mf_sample(output_sample, &tmp_sample_desc, output_file);
+        tmp_sample_desc.sample_time += tmp_sample_desc.sample_duration;

winetest_pop_context();
-        i += duration;
     }

-    hr = IMFSample_GetSampleTime(output_sample, &time);
-    ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
-    ok(time == i || broken(time == i - duration) /* win7 */, "got time %I64d\n", time);
-    hr = IMFSample_GetSampleDuration(output_sample, &duration);
-    ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
-    todo_wine
-    ok(duration == 522449 || broken(261225 - duration <= 1) /* win7 */, "got duration %I64d\n", duration);
-
-    ret = check_mf_sample(output_sample, output_sample_desc + 1, &mp3dec_data, &mp3dec_data_len);
+    ok(mp3dec_data_len == mp3dec_block_size || broken(mp3dec_data_len == 0) /* win7 */, "got remaining length %lu\n", mp3dec_data_len);
+    ret = check_mf_sample(output_sample, output_sample_desc + 2, &mp3dec_data, &mp3dec_data_len);
     ok(ret == 0, "Unexpected %lu%% diff\n", ret);
-    dump_mf_sample(output_sample, output_sample_desc + 1, output_file);
+    dump_mf_sample(output_sample, output_sample_desc + 2, output_file);

IMFSample_Release(output_sample);

@@ -4663,15 +4681,6 @@ static void test_mp3_decoder(void)

if (hr == S_OK)
     {
-        hr = IMFSample_GetSampleTime(output_sample, &time);
-        ok(hr == S_OK, "GetSampleTime returned %#lx\n", hr);
-        todo_wine
-        ok(time == 10185486, "got time %I64d\n", time);
-        hr = IMFSample_GetSampleDuration(output_sample, &duration);
-        ok(hr == S_OK, "GetSampleDuration returned %#lx\n", hr);
-        todo_wine
-        ok(duration == 14286, "got duration %I64d\n", duration);
-
         ret = check_mf_sample(output_sample, output_sample_desc + 1, &mp3dec_data, &mp3dec_data_len);
         ok(ret == 0, "Unexpected %lu%% diff\n", ret);
         dump_mf_sample(output_sample, output_sample_desc + 1, output_file);

[PATCH v2 08/10] mf/tests: Check all produced output IMFSample at the same time.

[Rémi Bernon]

From: Rémi Bernon

Keeping them in a IMFCollection.
---
 dlls/mf/tests/transform.c | 511 +++++++++++++++++---------------------
 1 file changed, 221 insertions(+), 290 deletions(-)

diff --git a/dlls/mf/tests/transform.c b/dlls/mf/tests/transform.c
index 12be38f1650..9eafa1c4971 100644
--- a/dlls/mf/tests/transform.c
+++ b/dlls/mf/tests/transform.c
@@ -490,6 +490,7 @@ struct sample_desc
     LONGLONG sample_duration;
     DWORD buffer_count;
     const struct buffer_desc *buffers;
+    DWORD repeat_count;
     BOOL todo_length;
 };

@@ -515,6 +516,38 @@ static void enum_mf_media_buffers(IMFSample *sample, const struct sample_desc *s
     ok(hr == E_INVALIDARG, "GetBufferByIndex returned %#lx\n", hr);
 }

+struct enum_mf_sample_state
+{
+    const struct sample_desc *next_sample;
+    struct sample_desc sample;
+};
+
+typedef void (*enum_mf_sample_cb)(IMFSample *sample, const struct sample_desc *sample_desc, void *context);
+static void enum_mf_samples(IMFCollection *samples, const struct sample_desc *collection_desc,
+        enum_mf_sample_cb callback, void *context)
+{
+    struct enum_mf_sample_state state = {.next_sample = collection_desc};
+    IMFSample *sample;
+    HRESULT hr;
+    DWORD i;
+
+    for (i = 0; SUCCEEDED(hr = IMFCollection_GetElement(samples, i, (IUnknown **)&sample)); i++)
+    {
+        winetest_push_context("sample %lu", i);
+        ok(hr == S_OK, "GetElement returned %#lx\n", hr);
+
+        state.sample.sample_time += state.sample.sample_duration;
+        if (!state.sample.repeat_count--)
+            state.sample = *state.next_sample++;
+
+        callback(sample, &state.sample, context);
+
+        IMFSample_Release(sample);
+        winetest_pop_context();
+    }
+    ok(hr == E_INVALIDARG, "GetElement returned %#lx\n", hr);
+}
+
 static void dump_mf_media_buffer(IMFMediaBuffer *buffer, const struct buffer_desc *buffer_desc, HANDLE output)
 {
     DWORD length, written;
@@ -538,6 +571,24 @@ static void dump_mf_sample(IMFSample *sample, const struct sample_desc *sample_d
     enum_mf_media_buffers(sample, sample_desc, dump_mf_media_buffer, output);
 }

+static void dump_mf_sample_collection(IMFCollection *samples, const struct sample_desc *collection_desc,
+        const WCHAR *output_filename)
+{
+    WCHAR path[MAX_PATH];
+    HANDLE output;
+
+    GetTempPathW(ARRAY_SIZE(path), path);
+    lstrcatW(path, output_filename);
+
+    output = CreateFileW(path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
+    ok(output != INVALID_HANDLE_VALUE, "CreateFileW failed, error %lu\n", GetLastError());
+
+    enum_mf_samples(samples, collection_desc, dump_mf_sample, output);
+
+    trace("created %s\n", debugstr_w(path));
+    CloseHandle(output);
+}
+
 #define check_mf_media_buffer(a, b, c) check_mf_media_buffer_(__LINE__, a, b, c)
 static DWORD check_mf_media_buffer_(int line, IMFMediaBuffer *buffer, const struct buffer_desc *expect,
         const BYTE **expect_data, DWORD *expect_data_len)
@@ -638,6 +689,31 @@ static DWORD check_mf_sample_(int line, IMFSample *sample, const struct sample_d
     return ctx.diff / buffer_count;
 }

+static void check_mf_sample_collection_enum(IMFSample *sample, const struct sample_desc *expect, void *context)
+{
+    struct check_mf_sample_context *ctx = context;
+    ctx->diff += check_mf_sample_(ctx->line, sample, expect, &ctx->data, &ctx->data_len);
+}
+
+#define check_mf_sample_collection(a, b, c) check_mf_sample_collection_(__LINE__, a, b, c)
+static DWORD check_mf_sample_collection_(int line, IMFCollection *samples,
+        const struct sample_desc *expect_samples, const WCHAR *expect_data_filename)
+{
+    struct check_mf_sample_context ctx = {.line = line};
+    DWORD count;
+    HRESULT hr;
+
+    load_resource(expect_data_filename, &ctx.data, &ctx.data_len);
+    enum_mf_samples(samples, expect_samples, check_mf_sample_collection_enum, &ctx);
+
+    dump_mf_sample_collection(samples, expect_samples, expect_data_filename);
+
+    hr = IMFCollection_GetElementCount(samples, &count);
+    ok_(__FILE__, line)(hr == S_OK, "GetElementCount returned %#lx\n", hr);
+
+    return ctx.diff / count;
+}
+
 static HRESULT WINAPI test_unk_QueryInterface(IUnknown *iface, REFIID riid, void **obj)
 {
     if (IsEqualIID(riid, &IID_IUnknown))
@@ -1689,15 +1765,14 @@ static void test_wma_encoder(void)
     MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Audio, MFAudioFormat_WMAudioV8};
     MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Audio, MFAudioFormat_Float};
     IMFSample *input_sample, *output_sample;
-    ULONG audio_data_len, wmaenc_data_len;
-    const BYTE *audio_data, *wmaenc_data;
     MFT_OUTPUT_STREAM_INFO output_info;
     MFT_INPUT_STREAM_INFO input_info;
-    WCHAR output_path[MAX_PATH];
+    IMFCollection *output_samples;
     DWORD length, output_status;
     IMFMediaType *media_type;
     IMFTransform *transform;
-    HANDLE output_file;
+    const BYTE *audio_data;
+    ULONG audio_data_len;
     ULONG i, ret;
     HRESULT hr;
     LONG ref;
@@ -1775,35 +1850,31 @@ static void test_wma_encoder(void)
     ref = IMFSample_Release(input_sample);
     ok(ref <= 1, "Release returned %ld\n", ref);

-    output_sample = create_sample(NULL, output_info.cbSize);
-
-    load_resource(L"wmaencdata.bin", &wmaenc_data, &wmaenc_data_len);
-    ok(wmaenc_data_len % wmaenc_block_size == 0, "got length %lu\n", wmaenc_data_len);
-
-    /* and generate a new one as well in a temporary directory */
-    GetTempPathW(ARRAY_SIZE(output_path), output_path);
-    lstrcatW(output_path, L"wmaencdata.bin");
-    output_file = CreateFileW(output_path, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
-    ok(output_file != INVALID_HANDLE_VALUE, "CreateFileW failed, error %lu\n", GetLastError());
+    hr = MFCreateCollection(&output_samples);
+    ok(hr == S_OK, "MFCreateCollection returned %#lx\n", hr);

+    output_sample = create_sample(NULL, output_info.cbSize);
     for (i = 0; SUCCEEDED(hr = check_mft_process_output(transform, output_sample, &output_status)); i++)
     {
         winetest_push_context("%lu", i);
         ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
         ok(output_status == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE, "got output[0].dwStatus %#lx\n", output_status);
-        ret = check_mf_sample(output_sample, output_sample_desc + i, &wmaenc_data, &wmaenc_data_len);
-        ok(ret == 0, "Unexpected %lu%% diff\n", ret);
-        dump_mf_sample(output_sample, output_sample_desc + i, output_file);
+        hr = IMFCollection_AddElement(output_samples, (IUnknown *)output_sample);
+        ok(hr == S_OK, "AddElement returned %#lx\n", hr);
+        ref = IMFSample_Release(output_sample);
+        ok(ref == 1, "Release returned %ld\n", ref);
+        output_sample = create_sample(NULL, output_info.cbSize);
         winetest_pop_context();
     }
-    ok(wmaenc_data_len == 0, "missing %#lx bytes\n", wmaenc_data_len);
     ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#lx\n", hr);
     ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);
     ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);
+    ok(i == 3, "got %lu output samples\n", i);

-    trace("created %s\n", debugstr_w(output_path));
-    CloseHandle(output_file);
+    ret = check_mf_sample_collection(output_samples, output_sample_desc, L"wmaencdata.bin");
+    ok(ret == 0, "got %lu%% diff\n", ret);
+    IMFCollection_Release(output_samples);

output_sample = create_sample(NULL, output_info.cbSize);
     hr = check_mft_process_output(transform, output_sample, &output_status);
@@ -1952,20 +2023,15 @@ static void test_wma_decoder(void)
         ATTR_UINT32(MFSampleExtension_CleanPoint, 1),
         {0},
     };
-    const struct sample_desc output_sample_desc[] =
+    struct sample_desc output_sample_desc[] =
     {
         {
             .attributes = output_sample_attributes + 0,
             .sample_time = 0, .sample_duration = 928798,
-            .buffer_count = 1, .buffers = output_buffer_desc + 0,
+            .buffer_count = 1, .buffers = output_buffer_desc + 0, .repeat_count = 1,
         },
         {
             .attributes = output_sample_attributes + 0,
-            .sample_time = 928798, .sample_duration = 928798,
-            .buffer_count = 1, .buffers = output_buffer_desc + 0,
-        },
-        {
-            .attributes = output_sample_attributes_todo + 0,
             .sample_time = 1857596, .sample_duration = 928798,
             .buffer_count = 1, .buffers = output_buffer_desc + 0,
         },
@@ -1980,17 +2046,16 @@ static void test_wma_decoder(void)
     MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Audio, MFAudioFormat_Float};
     IUnknown *unknown, *tmp_unknown, outer = {&test_unk_vtbl};
     IMFSample *input_sample, *output_sample;
-    ULONG wmadec_data_len, wmaenc_data_len;
-    const BYTE *wmadec_data, *wmaenc_data;
     MFT_OUTPUT_STREAM_INFO output_info;
     MFT_INPUT_STREAM_INFO input_info;
+    IMFCollection *output_samples;
     DWORD length, output_status;
-    WCHAR output_path[MAX_PATH];
     IMediaObject *media_object;
     IPropertyBag *property_bag;
     IMFMediaType *media_type;
     IMFTransform *transform;
-    HANDLE output_file;
+    const BYTE *wmaenc_data;
+    ULONG wmaenc_data_len;
     ULONG i, ret, ref;
     HRESULT hr;

@@ -2148,62 +2213,36 @@ static void test_wma_decoder(void)
             || broken(output_status == (MFT_OUTPUT_DATA_BUFFER_INCOMPLETE|MFT_OUTPUT_DATA_BUFFER_NO_SAMPLE)) /* Win7 */,
             "got output[0].dwStatus %#lx\n", output_status);

-    load_resource(L"wmadecdata.bin", &wmadec_data, &wmadec_data_len);
-    ok(wmadec_data_len == wmadec_block_size * 7 / 2, "got length %lu\n", wmadec_data_len);
-
-    /* and generate a new one as well in a temporary directory */
-    GetTempPathW(ARRAY_SIZE(output_path), output_path);
-    lstrcatW(output_path, L"wmadecdata.bin");
-    output_file = CreateFileW(output_path, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
-    ok(output_file != INVALID_HANDLE_VALUE, "CreateFileW failed, error %lu\n", GetLastError());
+    hr = MFCreateCollection(&output_samples);
+    ok(hr == S_OK, "MFCreateCollection returned %#lx\n", hr);

-    output_info.cbSize = wmadec_block_size;
     output_sample = create_sample(NULL, output_info.cbSize);
-    hr = check_mft_process_output(transform, output_sample, &output_status);
-
-    for (i = 0; i < 4; ++i)
+    for (i = 0; SUCCEEDED(hr = check_mft_process_output(transform, output_sample, &output_status)); i++)
     {
         winetest_push_context("%lu", i);
+        ok(!(output_status & ~MFT_OUTPUT_DATA_BUFFER_INCOMPLETE), "got output[0].dwStatus %#lx\n", output_status);
         ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
-        if (!strcmp(winetest_platform, "wine") && i == 2 && (output_status & MFT_OUTPUT_DATA_BUFFER_INCOMPLETE))
-            todo_wine ok(0, "skipping bogus sample check\n");
-        else if (output_status & MFT_OUTPUT_DATA_BUFFER_INCOMPLETE)
-        {
-            ok(output_status == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE, "got output[0].dwStatus %#lx\n", output_status);
-            ret = check_mf_sample(output_sample, output_sample_desc + i, &wmadec_data, &wmadec_data_len);
-            todo_wine_if(ret > 0 && ret <= 10)  /* ffmpeg sometimes offsets the decoded data */
-            ok(ret == 0, "Unexpected %lu%% diff\n", ret);
-            dump_mf_sample(output_sample, output_sample_desc + i, output_file);
-        }
-        else
-        {
-            ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);
-            ret = check_mf_sample(output_sample, output_sample_desc + i, &wmadec_data, &wmadec_data_len);
-            todo_wine_if(ret > 0 && ret <= 10)  /* ffmpeg sometimes offsets the decoded data */
-            ok(ret == 0, "Unexpected %lu%% diff\n", ret);
-            dump_mf_sample(output_sample, output_sample_desc + i, output_file);
-        }
-        ret = IMFSample_Release(output_sample);
-        ok(ret == 0, "Release returned %lu\n", ret);
-
+        hr = IMFCollection_AddElement(output_samples, (IUnknown *)output_sample);
+        ok(hr == S_OK, "AddElement returned %#lx\n", hr);
+        ref = IMFSample_Release(output_sample);
+        ok(ref == 1, "Release returned %ld\n", ref);
         output_sample = create_sample(NULL, output_info.cbSize);
-        hr = check_mft_process_output(transform, output_sample, &output_status);
-
         winetest_pop_context();
-
-        /* some FFmpeg version request more input to complete decoding */
-        if (hr == MF_E_TRANSFORM_NEED_MORE_INPUT && i == 2) break;
     }
-    todo_wine_if(wmadec_data_len == 0x1000)
-    ok(wmadec_data_len == 0, "missing %#lx bytes\n", wmadec_data_len);
-
-    trace("created %s\n", debugstr_w(output_path));
-    CloseHandle(output_file);
-
     ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#lx\n", hr);
     ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);
     ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);
+    todo_wine_if(i == 3) /* wmadec output depends on ffmpeg version used */
+    ok(i == 4, "got %lu output samples\n", i);
+
+    if (!strcmp(winetest_platform, "wine") && i == 3)
+        output_sample_desc[1].attributes = output_sample_attributes_todo;
+
+    ret = check_mf_sample_collection(output_samples, output_sample_desc, L"wmadecdata.bin");
+    todo_wine_if(ret > 0 && ret <= 10)  /* ffmpeg sometimes offsets the decoded data */
+    ok(ret == 0, "got %lu%% diff\n", ret);
+    IMFCollection_Release(output_samples);

output_sample = create_sample(NULL, output_info.cbSize);
     hr = check_mft_process_output(transform, output_sample, &output_status);
@@ -2512,7 +2551,7 @@ static void test_h264_decoder(void)
         .length = actual_width * actual_height * 3 / 2,
         .compare = compare_i420, .rect = {.right = 82, .bottom = 84},
     };
-    const struct sample_desc output_sample_desc_i420 =
+    const struct sample_desc expect_output_sample_i420 =
     {
         .attributes = output_sample_attributes,
         .sample_time = 333667, .sample_duration = 333667,
@@ -2521,19 +2560,18 @@ static void test_h264_decoder(void)

MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Video, MFVideoFormat_H264};
     MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Video, MFVideoFormat_NV12};
-    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;
     IMFSample *input_sample, *output_sample;
     MFT_OUTPUT_STREAM_INFO output_info;
     MFT_INPUT_STREAM_INFO input_info;
+    IMFCollection *output_samples;
+    const BYTE *h264_encoded_data;
+    ULONG h264_encoded_data_len;
     DWORD length, output_status;
-    WCHAR output_path[MAX_PATH];
     IMFAttributes *attributes;
+    ULONG i, ret, ref, flags;
     IMFMediaType *media_type;
     IMFTransform *transform;
-    ULONG i, ret, flags;
-    HANDLE output_file;
     HRESULT hr;

hr = CoInitialize(NULL);
@@ -2723,6 +2761,7 @@ static void test_h264_decoder(void)
         output_sample = create_sample(NULL, output_info.cbSize);
         hr = check_mft_process_output(transform, output_sample, &output_status);
         if (hr != MF_E_TRANSFORM_NEED_MORE_INPUT) break;
+
         ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#lx\n", hr);
         ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);
         hr = IMFSample_GetTotalLength(output_sample, &length);
@@ -2789,29 +2828,21 @@ static void test_h264_decoder(void)
     ret = IMFMediaType_Release(media_type);
     ok(ret == 0, "Release returned %lu\n", ret);

-    /* and generate a new one as well in a temporary directory */
-    GetTempPathW(ARRAY_SIZE(output_path), output_path);
-    lstrcatW(output_path, L"nv12frame.bin");
-    output_file = CreateFileW(output_path, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
-    ok(output_file != INVALID_HANDLE_VALUE, "CreateFileW failed, error %lu\n", GetLastError());
-
-    load_resource(L"nv12frame.bin", &nv12_frame_data, &nv12_frame_len);
-    ok(nv12_frame_len == actual_width * actual_height * 3 / 2, "got frame length %lu\n", nv12_frame_len);
+    hr = MFCreateCollection(&output_samples);
+    ok(hr == S_OK, "MFCreateCollection returned %#lx\n", hr);

-    output_sample = create_sample(NULL, nv12_frame_len);
+    output_sample = create_sample(NULL, output_info.cbSize);
     hr = check_mft_process_output(transform, output_sample, &output_status);
     ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
     ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);
+    hr = IMFCollection_AddElement(output_samples, (IUnknown *)output_sample);
+    ok(hr == S_OK, "AddElement returned %#lx\n", hr);
+    ref = IMFSample_Release(output_sample);
+    ok(ref == 1, "Release returned %ld\n", ref);

-    ret = check_mf_sample(output_sample, &output_sample_desc_nv12, &nv12_frame_data, &nv12_frame_len);
-    ok(ret == 0, "Unexpected %lu%% diff\n", ret);
-    dump_mf_sample(output_sample, &output_sample_desc_nv12, output_file);
-
-    ret = IMFSample_Release(output_sample);
-    ok(ret == 0, "Release returned %lu\n", ret);
-
-    trace("created %s\n", debugstr_w(output_path));
-    CloseHandle(output_file);
+    ret = check_mf_sample_collection(output_samples, &output_sample_desc_nv12, L"nv12frame.bin");
+    ok(ret == 0, "got %lu%% diff\n", ret);
+    IMFCollection_Release(output_samples);

/* we can change it, but only with the correct frame size */
     hr = MFCreateMediaType(&media_type);
@@ -2859,28 +2890,21 @@ static void test_h264_decoder(void)
     ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

-    GetTempPathW(ARRAY_SIZE(output_path), output_path);
-    lstrcatW(output_path, L"i420frame.bin");
-    output_file = CreateFileW(output_path, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
-    ok(output_file != INVALID_HANDLE_VALUE, "CreateFileW failed, error %lu\n", GetLastError());
-
-    load_resource(L"i420frame.bin", &i420_frame_data, &i420_frame_len);
-    ok(i420_frame_len == actual_width * actual_height * 3 / 2, "got frame length %lu\n", i420_frame_len);
+    hr = MFCreateCollection(&output_samples);
+    ok(hr == S_OK, "MFCreateCollection returned %#lx\n", hr);

output_sample = create_sample(NULL, actual_width * actual_height * 2);
     hr = check_mft_process_output(transform, output_sample, &output_status);
     ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
     ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);
+    hr = IMFCollection_AddElement(output_samples, (IUnknown *)output_sample);
+    ok(hr == S_OK, "AddElement returned %#lx\n", hr);
+    ref = IMFSample_Release(output_sample);
+    ok(ref == 1, "Release returned %ld\n", ref);

-    ret = check_mf_sample(output_sample, &output_sample_desc_i420, &i420_frame_data, &i420_frame_len);
-    ok(ret == 0, "Unexpected %lu%% diff\n", ret);
-    dump_mf_sample(output_sample, &output_sample_desc_i420, output_file);
-
-    ret = IMFSample_Release(output_sample);
-    ok(ret == 0, "Release returned %lu\n", ret);
-
-    trace("created %s\n", debugstr_w(output_path));
-    CloseHandle(output_file);
+    ret = check_mf_sample_collection(output_samples, &expect_output_sample_i420, L"i420frame.bin");
+    ok(ret == 0, "got %lu%% diff\n", ret);
+    IMFCollection_Release(output_samples);

output_sample = create_sample(NULL, actual_width * actual_height * 2);
     hr = check_mft_process_output(transform, output_sample, &output_status);
@@ -3024,7 +3048,7 @@ static void test_audio_convert(void)
         {
             .attributes = output_sample_attributes + 0,
             .sample_time = 0, .sample_duration = 928798,
-            .buffer_count = 1, .buffers = output_buffer_desc + 0,
+            .buffer_count = 1, .buffers = output_buffer_desc + 0, .repeat_count = 9,
         },
         {
             .attributes = output_sample_attributes + 1, /* not MFT_OUTPUT_DATA_BUFFER_INCOMPLETE */
@@ -3040,18 +3064,16 @@ static void test_audio_convert(void)

MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Audio, MFAudioFormat_PCM};
     MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Audio, MFAudioFormat_Float};
-    struct sample_desc tmp_sample_desc = output_sample_desc[0];
-    ULONG audio_data_len, audioconv_data_len;
     IMFSample *input_sample, *output_sample;
-    const BYTE *audio_data, *audioconv_data;
     MFT_OUTPUT_STREAM_INFO output_info;
     MFT_INPUT_STREAM_INFO input_info;
-    WCHAR output_path[MAX_PATH];
+    IMFCollection *output_samples;
     DWORD length, output_status;
     IMFMediaType *media_type;
     IMFTransform *transform;
-    HANDLE output_file;
-    ULONG i, ret;
+    const BYTE *audio_data;
+    ULONG audio_data_len;
+    ULONG i, ret, ref;
     HRESULT hr;

hr = CoInitialize(NULL);
@@ -3192,71 +3214,32 @@ static void test_audio_convert(void)
     ret = IMFSample_Release(input_sample);
     ok(ret <= 1, "Release returned %ld\n", ret);

-    output_sample = create_sample(NULL, audioconv_block_size);
-
-    load_resource(L"audioconvdata.bin", &audioconv_data, &audioconv_data_len);
-    ok(audioconv_data_len == 179924, "got length %lu\n", audioconv_data_len);
-
-    /* and generate a new one as well in a temporary directory */
-    GetTempPathW(ARRAY_SIZE(output_path), output_path);
-    lstrcatW(output_path, L"audioconvdata.bin");
-    output_file = CreateFileW(output_path, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
-    ok(output_file != INVALID_HANDLE_VALUE, "CreateFileW failed, error %lu\n", GetLastError());
+    hr = MFCreateCollection(&output_samples);
+    ok(hr == S_OK, "MFCreateCollection returned %#lx\n", hr);

-    i = 0;
-    while (SUCCEEDED(hr = check_mft_process_output(transform, output_sample, &output_status)))
+    output_sample = create_sample(NULL, audioconv_block_size);
+    for (i = 0; SUCCEEDED(hr = check_mft_process_output(transform, output_sample, &output_status)); i++)
     {
         winetest_push_context("%lu", i);
         ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
-        if (!(output_status & MFT_OUTPUT_DATA_BUFFER_INCOMPLETE))
-        {
-            ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);
-            winetest_pop_context();
-            break;
-        }
-        ok(output_status == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE, "got output[0].dwStatus %#lx\n", output_status);
-
-        ret = check_mf_sample(output_sample, &tmp_sample_desc, &audioconv_data, &audioconv_data_len);
-        ok(ret == 0, "Unexpected %lu%% diff\n", ret);
-        dump_mf_sample(output_sample, &tmp_sample_desc, output_file);
-        tmp_sample_desc.sample_time += tmp_sample_desc.sample_duration;
-
+        ok(!(output_status & ~MFT_OUTPUT_DATA_BUFFER_INCOMPLETE), "got output[0].dwStatus %#lx\n", output_status);
+        hr = IMFCollection_AddElement(output_samples, (IUnknown *)output_sample);
+        ok(hr == S_OK, "AddElement returned %#lx\n", hr);
+        ref = IMFSample_Release(output_sample);
+        ok(ref == 1, "Release returned %ld\n", ref);
+        output_sample = create_sample(NULL, audioconv_block_size);
         winetest_pop_context();
-        i++;
     }
-
-    ret = check_mf_sample(output_sample, output_sample_desc + 1, &audioconv_data, &audioconv_data_len);
-    ok(ret == 0, "Unexpected %lu%% diff\n", ret);
-    dump_mf_sample(output_sample, output_sample_desc + 1, output_file);
-
+    ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#lx\n", hr);
+    ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);
     ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);
-
-    output_sample = create_sample(NULL, audioconv_block_size);
-    hr = check_mft_process_output(transform, output_sample, &output_status);
-    todo_wine
-    ok(hr == S_OK || broken(hr == MF_E_TRANSFORM_NEED_MORE_INPUT) /* Win7 */,
-            "ProcessOutput returned %#lx\n", hr);
     todo_wine
-    ok(output_status == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE || broken(output_status == 0) /* Win7 */,
-            "got output[0].dwStatus %#lx\n", output_status);
+    ok(i == 12 || broken(i == 11) /* Win7 */, "got %lu output samples\n", i);

-    if (hr == S_OK)
-    {
-        ret = check_mf_sample(output_sample, output_sample_desc + 2, &audioconv_data, &audioconv_data_len);
-        ok(ret == 0, "Unexpected %lu%% diff\n", ret);
-        dump_mf_sample(output_sample, output_sample_desc + 2, output_file);
-    }
-    todo_wine
-    ok(audioconv_data_len == 0
-            || broken(audioconv_data_len == 0xfc) /* Win7 */,
-            "missing %#lx bytes\n", audioconv_data_len);
-
-    trace("created %s\n", debugstr_w(output_path));
-    CloseHandle(output_file);
-
-    ret = IMFSample_Release(output_sample);
-    ok(ret == 0, "Release returned %lu\n", ret);
+    ret = check_mf_sample_collection(output_samples, output_sample_desc, L"audioconvdata.bin");
+    ok(ret == 0, "got %lu%% diff\n", ret);
+    IMFCollection_Release(output_samples);

output_sample = create_sample(NULL, audioconv_block_size);
     hr = check_mft_process_output(transform, output_sample, &output_status);
@@ -3460,17 +3443,16 @@ static void test_color_convert(void)

MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Video, MFVideoFormat_NV12};
     MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Video, MFVideoFormat_I420};
-    ULONG nv12frame_data_len, rgb32_data_len;
-    const BYTE *nv12frame_data, *rgb32_data;
     IMFSample *input_sample, *output_sample;
     MFT_OUTPUT_STREAM_INFO output_info;
     MFT_INPUT_STREAM_INFO input_info;
-    WCHAR output_path[MAX_PATH];
+    IMFCollection *output_samples;
     DWORD length, output_status;
+    const BYTE *nv12frame_data;
+    ULONG nv12frame_data_len;
     IMFMediaType *media_type;
     IMFTransform *transform;
-    HANDLE output_file;
-    ULONG i, ret;
+    ULONG i, ret, ref;
     HRESULT hr;

hr = CoInitialize(NULL);
@@ -3590,29 +3572,21 @@ static void test_color_convert(void)
     ret = IMFSample_Release(input_sample);
     ok(ret <= 1, "Release returned %ld\n", ret);

-    load_resource(L"rgb32frame.bin", &rgb32_data, &rgb32_data_len);
-    ok(rgb32_data_len == output_info.cbSize, "got length %lu\n", rgb32_data_len);
-
-    /* and generate a new one as well in a temporary directory */
-    GetTempPathW(ARRAY_SIZE(output_path), output_path);
-    lstrcatW(output_path, L"rgb32frame.bin");
-    output_file = CreateFileW(output_path, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
-    ok(output_file != INVALID_HANDLE_VALUE, "CreateFileW failed, error %lu\n", GetLastError());
+    hr = MFCreateCollection(&output_samples);
+    ok(hr == S_OK, "MFCreateCollection returned %#lx\n", hr);

output_sample = create_sample(NULL, output_info.cbSize);
     hr = check_mft_process_output(transform, output_sample, &output_status);
     ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
     ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);
+    hr = IMFCollection_AddElement(output_samples, (IUnknown *)output_sample);
+    ok(hr == S_OK, "AddElement returned %#lx\n", hr);
+    ref = IMFSample_Release(output_sample);
+    ok(ref == 1, "Release returned %ld\n", ref);

-    ret = check_mf_sample(output_sample, &output_sample_desc, &rgb32_data, &rgb32_data_len);
-    ok(ret <= 4 /* small and harmless differences in Wine vs Windows */, "Unexpected %lu%% diff\n", ret);
-    dump_mf_sample(output_sample, &output_sample_desc, output_file);
-
-    trace("created %s\n", debugstr_w(output_path));
-    CloseHandle(output_file);
-
-    ret = IMFSample_Release(output_sample);
-    ok(ret == 0, "Release returned %lu\n", ret);
+    ret = check_mf_sample_collection(output_samples, &output_sample_desc, L"rgb32frame.bin");
+    ok(ret <= 4 /* small and harmless diff in Wine vs Windows */, "got %lu%% diff\n", ret);
+    IMFCollection_Release(output_samples);

output_sample = create_sample(NULL, output_info.cbSize);
     hr = check_mft_process_output(transform, output_sample, &output_status);
@@ -3814,20 +3788,19 @@ 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_min, input_max, output_min, output_max, i, j, k;
-    ULONG nv12frame_data_len, rgb32_data_len;
+    IMFAttributes *attributes, *attributes2;
     IMFSample *input_sample, *output_sample;
     IMFMediaType *media_type, *media_type2;
-    IMFAttributes *attributes, *attributes2;
-    const BYTE *nv12frame_data, *rgb32_data;
     const GUID *expect_available_inputs;
     MFT_OUTPUT_STREAM_INFO output_info;
     MFT_INPUT_STREAM_INFO input_info;
-    WCHAR output_path[MAX_PATH];
+    IMFCollection *output_samples;
+    const BYTE *nv12frame_data;
+    ULONG nv12frame_data_len;
     IMFTransform *transform;
     IMFMediaBuffer *buffer;
     IMFMediaEvent *event;
     unsigned int value;
-    HANDLE output_file;
     UINT32 count;
     HRESULT hr;
     ULONG ret;
@@ -4266,36 +4239,28 @@ todo_wine {
     ret = IMFSample_Release(input_sample);
     ok(ret <= 1, "Release returned %ld\n", ret);

-    load_resource(L"rgb32frame-vp.bin", &rgb32_data, &rgb32_data_len);
-    ok(rgb32_data_len == output_info.cbSize, "got length %lu\n", rgb32_data_len);
-
-    /* and generate a new one as well in a temporary directory */
-    GetTempPathW(ARRAY_SIZE(output_path), output_path);
-    lstrcatW(output_path, L"rgb32frame-vp.bin");
-    output_file = CreateFileW(output_path, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
-    ok(output_file != INVALID_HANDLE_VALUE, "CreateFileW failed, error %lu\n", GetLastError());
+    hr = MFCreateCollection(&output_samples);
+    ok(hr == S_OK, "MFCreateCollection returned %#lx\n", hr);

-    output_sample = create_sample(NULL, rgb32_data_len);
+    output_sample = create_sample(NULL, output_info.cbSize);
     hr = check_mft_process_output(transform, output_sample, &output_status);
     ok(hr == S_OK || broken(hr == MF_E_SHUTDOWN) /* w8 */, "ProcessOutput returned %#lx\n", hr);
     if (hr != S_OK)
     {
         win_skip("ProcessOutput returned MF_E_SHUTDOWN, skipping tests.\n");
-        CloseHandle(output_file);
         goto skip_output;
     }
     ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);

-    ret = check_mf_sample(output_sample, &output_sample_desc, &rgb32_data, &rgb32_data_len);
-    todo_wine /* Wine doesn't flip the frame, yet */
-    ok(ret == 0 || broken(ret == 25) /* w1064v1507 / w1064v1809 incorrectly rescale */, "got %lu%% diff\n", ret);
-    dump_mf_sample(output_sample, &output_sample_desc, output_file);
-
-    trace("created %s\n", debugstr_w(output_path));
-    CloseHandle(output_file);
+    hr = IMFCollection_AddElement(output_samples, (IUnknown *)output_sample);
+    ok(hr == S_OK, "AddElement returned %#lx\n", hr);
+    ref = IMFSample_Release(output_sample);
+    ok(ref == 1, "Release returned %ld\n", ref);

-    ret = IMFSample_Release(output_sample);
-    ok(ret == 0, "Release returned %lu\n", ret);
+    ret = check_mf_sample_collection(output_samples, &output_sample_desc, L"rgb32frame-vp.bin");
+    todo_wine
+    ok(ret == 0 || broken(ret == 25) /* w1064v1507 / w1064v1809 incorrectly rescale */, "got %lu%% diff\n", ret);
+    IMFCollection_Release(output_samples);

output_sample = create_sample(NULL, output_info.cbSize);
     hr = check_mft_process_output(transform, output_sample, &output_status);
@@ -4461,7 +4426,7 @@ static void test_mp3_decoder(void)
         {
             .attributes = output_sample_attributes + 0,
             .sample_time = 282993, .sample_duration = 522449,
-            .buffer_count = 1, .buffers = output_buffer_desc + 1,
+            .buffer_count = 1, .buffers = output_buffer_desc + 1, .repeat_count = 18,
         },
         {
             .attributes = output_sample_attributes + 1, /* not MFT_OUTPUT_DATA_BUFFER_INCOMPLETE */
@@ -4472,18 +4437,16 @@ static void test_mp3_decoder(void)

MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Audio, MFAudioFormat_PCM};
     MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Audio, MFAudioFormat_MP3};
-    struct sample_desc tmp_sample_desc = output_sample_desc[1];
     IMFSample *input_sample, *output_sample;
-    ULONG mp3dec_data_len, mp3enc_data_len;
-    const BYTE *mp3dec_data, *mp3enc_data;
     MFT_OUTPUT_STREAM_INFO output_info;
     MFT_INPUT_STREAM_INFO input_info;
-    WCHAR output_path[MAX_PATH];
+    IMFCollection *output_samples;
     DWORD length, output_status;
     IMFMediaType *media_type;
     IMFTransform *transform;
-    HANDLE output_file;
-    ULONG i, ret;
+    const BYTE *mp3enc_data;
+    ULONG mp3enc_data_len;
+    ULONG i, ret, ref;
     HRESULT hr;

hr = CoInitialize(NULL);
@@ -4614,84 +4577,53 @@ static void test_mp3_decoder(void)
     ret = IMFSample_Release(input_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

-    output_sample = create_sample(NULL, mp3dec_block_size);
-
-    load_resource(L"mp3decdata.bin", &mp3dec_data, &mp3dec_data_len);
-    ok(mp3dec_data_len == 94656, "got length %lu\n", mp3dec_data_len);
-
-    /* and generate a new one as well in a temporary directory */
-    GetTempPathW(ARRAY_SIZE(output_path), output_path);
-    lstrcatW(output_path, L"mp3decdata.bin");
-    output_file = CreateFileW(output_path, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
-    ok(output_file != INVALID_HANDLE_VALUE, "CreateFileW failed, error %lu\n", GetLastError());
-
     hr = IMFTransform_ProcessMessage(transform, MFT_MESSAGE_COMMAND_DRAIN, 0);
     ok(hr == S_OK, "ProcessMessage returned %#lx\n", hr);

+    hr = MFCreateCollection(&output_samples);
+    ok(hr == S_OK, "MFCreateCollection returned %#lx\n", hr);
+
+    /* first sample is broken */
+    output_sample = create_sample(NULL, output_info.cbSize);
     hr = check_mft_process_output(transform, output_sample, &output_status);
     ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
     ok(output_status == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE, "got output[0].dwStatus %#lx\n", output_status);
-
     hr = IMFSample_GetTotalLength(output_sample, &length);
     ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
-    ok(length == 0x9c0 || broken(length == mp3dec_block_size) /* win8 */ || broken(length == 0x900) /* win7 */,
+    ok(length == mp3dec_block_size /* Win8 */ || length == 0x9c0 /* Win10 */ || length == 0x900 /* Win7 */,
             "got length %lu\n", length);
-    if (broken(length != 0x9c0))
-    {
-        win_skip("Skipping MP3 decoder output sample checks on Win7 / Win8\n");
-        goto skip_mp3dec_output;
-    }
-
-    ret = check_mf_sample(output_sample, output_sample_desc + 0, &mp3dec_data, &mp3dec_data_len);
-    ok(ret == 0, "Unexpected %lu%% diff\n", ret);
-    dump_mf_sample(output_sample, output_sample_desc + 0, output_file);
+    hr = IMFCollection_AddElement(output_samples, (IUnknown *)output_sample);
+    ok(hr == S_OK, "AddElement returned %#lx\n", hr);
+    ref = IMFSample_Release(output_sample);
+    ok(ref == 1, "Release returned %ld\n", ref);

-    while (SUCCEEDED(hr = check_mft_process_output(transform, output_sample, &output_status)))
+    output_sample = create_sample(NULL, output_info.cbSize);
+    for (i = 0; SUCCEEDED(hr = check_mft_process_output(transform, output_sample, &output_status)); i++)
     {
         winetest_push_context("%lu", i);
         ok(hr == S_OK, "ProcessOutput returned %#lx\n", hr);
-        if (!(output_status & MFT_OUTPUT_DATA_BUFFER_INCOMPLETE))
-        {
-            ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);
-            winetest_pop_context();
-            break;
-        }
-        ok(output_status == MFT_OUTPUT_DATA_BUFFER_INCOMPLETE, "got output[0].dwStatus %#lx\n", output_status);
-
-        ret = check_mf_sample(output_sample, &tmp_sample_desc, &mp3dec_data, &mp3dec_data_len);
-        ok(ret == 0, "Unexpected %lu%% diff\n", ret);
-        dump_mf_sample(output_sample, &tmp_sample_desc, output_file);
-        tmp_sample_desc.sample_time += tmp_sample_desc.sample_duration;
-
+        ok(!(output_status & ~MFT_OUTPUT_DATA_BUFFER_INCOMPLETE), "got output[0].dwStatus %#lx\n", output_status);
+        hr = IMFCollection_AddElement(output_samples, (IUnknown *)output_sample);
+        ok(hr == S_OK, "AddElement returned %#lx\n", hr);
+        ref = IMFSample_Release(output_sample);
+        ok(ref == 1, "Release returned %ld\n", ref);
+        output_sample = create_sample(NULL, output_info.cbSize);
         winetest_pop_context();
     }
-
-    ok(mp3dec_data_len == mp3dec_block_size || broken(mp3dec_data_len == 0) /* win7 */, "got remaining length %lu\n", mp3dec_data_len);
-    ret = check_mf_sample(output_sample, output_sample_desc + 2, &mp3dec_data, &mp3dec_data_len);
-    ok(ret == 0, "Unexpected %lu%% diff\n", ret);
-    dump_mf_sample(output_sample, output_sample_desc + 2, output_file);
-
-    IMFSample_Release(output_sample);
-
-    output_sample = create_sample(NULL, mp3dec_block_size);
-    hr = check_mft_process_output(transform, output_sample, &output_status);
-    todo_wine
-    ok(hr == S_OK || broken(hr == MF_E_TRANSFORM_NEED_MORE_INPUT) /* win7 */, "ProcessOutput returned %#lx\n", hr);
+    ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#lx\n", hr);
     ok(output_status == 0, "got output[0].dwStatus %#lx\n", output_status);
+    ret = IMFSample_Release(output_sample);
+    ok(ret == 0, "Release returned %lu\n", ret);
+    ok(i == 20 || broken(i == 41) /* Win7 */, "got %lu output samples\n", i);

-    if (hr == S_OK)
+    if (broken(length != 0x9c0))
+        win_skip("Skipping MP3 decoder output sample checks on Win7 / Win8\n");
+    else
     {
-        ret = check_mf_sample(output_sample, output_sample_desc + 1, &mp3dec_data, &mp3dec_data_len);
-        ok(ret == 0, "Unexpected %lu%% diff\n", ret);
-        dump_mf_sample(output_sample, output_sample_desc + 1, output_file);
+        ret = check_mf_sample_collection(output_samples, output_sample_desc, L"mp3decdata.bin");
+        ok(ret == 0, "got %lu%% diff\n", ret);
     }
-    ok(mp3dec_data_len == 0, "missing %#lx bytes\n", mp3dec_data_len);
-
-    trace("created %s\n", debugstr_w(output_path));
-    CloseHandle(output_file);
-
-    ret = IMFSample_Release(output_sample);
-    ok(ret == 0, "Release returned %lu\n", ret);
+    IMFCollection_Release(output_samples);

output_sample = create_sample(NULL, mp3dec_block_size);
     hr = check_mft_process_output(transform, output_sample, &output_status);
@@ -4700,7 +4632,6 @@ static void test_mp3_decoder(void)
     hr = IMFSample_GetTotalLength(output_sample, &length);
     ok(hr == S_OK, "GetTotalLength returned %#lx\n", hr);
     ok(length == 0, "got length %lu\n", length);
-skip_mp3dec_output:
     ret = IMFSample_Release(output_sample);
     ok(ret == 0, "Release returned %lu\n", ret);

[PATCH v2 09/10] mf/tests: Rename transform frame dumps to BMP.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/mf/tests/{i420frame.bin => i420frame.bmp}  |   0
 dlls/mf/tests/{nv12frame.bin => nv12frame.bmp}  |   0
 dlls/mf/tests/resource.rc                       |  16 ++++++++--------
 .../{rgb32frame-vp.bin => rgb32frame-vp.bmp}    | Bin
 .../mf/tests/{rgb32frame.bin => rgb32frame.bmp} | Bin
 dlls/mf/tests/transform.c                       |  12 ++++++------
 6 files changed, 14 insertions(+), 14 deletions(-)
 rename dlls/mf/tests/{i420frame.bin => i420frame.bmp} (100%)
 rename dlls/mf/tests/{nv12frame.bin => nv12frame.bmp} (100%)
 rename dlls/mf/tests/{rgb32frame-vp.bin => rgb32frame-vp.bmp} (100%)
 rename dlls/mf/tests/{rgb32frame.bin => rgb32frame.bmp} (100%)

diff --git a/dlls/mf/tests/i420frame.bin b/dlls/mf/tests/i420frame.bmp
similarity index 100%
rename from dlls/mf/tests/i420frame.bin
rename to dlls/mf/tests/i420frame.bmp
diff --git a/dlls/mf/tests/nv12frame.bin b/dlls/mf/tests/nv12frame.bmp
similarity index 100%
rename from dlls/mf/tests/nv12frame.bin
rename to dlls/mf/tests/nv12frame.bmp
diff --git a/dlls/mf/tests/resource.rc b/dlls/mf/tests/resource.rc
index 3cc0f875452..43493319046 100644
--- a/dlls/mf/tests/resource.rc
+++ b/dlls/mf/tests/resource.rc
@@ -55,17 +55,17 @@ mp3decdata.bin RCDATA mp3decdata.bin
 h264data.bin RCDATA h264data.bin

/* Generated from running the tests on Windows */
-/* @makedep: nv12frame.bin */
-nv12frame.bin RCDATA nv12frame.bin
+/* @makedep: nv12frame.bmp */
+nv12frame.bmp RCDATA nv12frame.bmp

/* Generated from running the tests on Windows */
-/* @makedep: i420frame.bin */
-i420frame.bin RCDATA i420frame.bin
+/* @makedep: i420frame.bmp */
+i420frame.bmp RCDATA i420frame.bmp

/* Generated from running the tests on Windows */
-/* @makedep: rgb32frame.bin */
-rgb32frame.bin RCDATA rgb32frame.bin
+/* @makedep: rgb32frame.bmp */
+rgb32frame.bmp RCDATA rgb32frame.bmp

/* Generated from running the tests on Windows */
-/* @makedep: rgb32frame-vp.bin */
-rgb32frame-vp.bin RCDATA rgb32frame-vp.bin
+/* @makedep: rgb32frame-vp.bmp */
+rgb32frame-vp.bmp RCDATA rgb32frame-vp.bmp
diff --git a/dlls/mf/tests/rgb32frame-vp.bin b/dlls/mf/tests/rgb32frame-vp.bmp
similarity index 100%
rename from dlls/mf/tests/rgb32frame-vp.bin
rename to dlls/mf/tests/rgb32frame-vp.bmp
diff --git a/dlls/mf/tests/rgb32frame.bin b/dlls/mf/tests/rgb32frame.bmp
similarity index 100%
rename from dlls/mf/tests/rgb32frame.bin
rename to dlls/mf/tests/rgb32frame.bmp
diff --git a/dlls/mf/tests/transform.c b/dlls/mf/tests/transform.c
index 9eafa1c4971..30a39c6667f 100644
--- a/dlls/mf/tests/transform.c
+++ b/dlls/mf/tests/transform.c
@@ -2840,7 +2840,7 @@ static void test_h264_decoder(void)
     ref = IMFSample_Release(output_sample);
     ok(ref == 1, "Release returned %ld\n", ref);

-    ret = check_mf_sample_collection(output_samples, &output_sample_desc_nv12, L"nv12frame.bin");
+    ret = check_mf_sample_collection(output_samples, &output_sample_desc_nv12, L"nv12frame.bmp");
     ok(ret == 0, "got %lu%% diff\n", ret);
     IMFCollection_Release(output_samples);

@@ -2902,7 +2902,7 @@ static void test_h264_decoder(void)
     ref = IMFSample_Release(output_sample);
     ok(ref == 1, "Release returned %ld\n", ref);

-    ret = check_mf_sample_collection(output_samples, &expect_output_sample_i420, L"i420frame.bin");
+    ret = check_mf_sample_collection(output_samples, &expect_output_sample_i420, L"i420frame.bmp");
     ok(ret == 0, "got %lu%% diff\n", ret);
     IMFCollection_Release(output_samples);

@@ -3555,7 +3555,7 @@ static void test_color_convert(void)
     ok(output_info.cbSize == actual_width * actual_height * 4, "got cbSize %#lx\n", output_info.cbSize);
     ok(output_info.cbAlignment == 1, "got cbAlignment %#lx\n", output_info.cbAlignment);

-    load_resource(L"nv12frame.bin", &nv12frame_data, &nv12frame_data_len);
+    load_resource(L"nv12frame.bmp", &nv12frame_data, &nv12frame_data_len);
     ok(nv12frame_data_len == 13824, "got length %lu\n", nv12frame_data_len);

input_sample = create_sample(nv12frame_data, nv12frame_data_len);
@@ -3584,7 +3584,7 @@ static void test_color_convert(void)
     ref = IMFSample_Release(output_sample);
     ok(ref == 1, "Release returned %ld\n", ref);

-    ret = check_mf_sample_collection(output_samples, &output_sample_desc, L"rgb32frame.bin");
+    ret = check_mf_sample_collection(output_samples, &output_sample_desc, L"rgb32frame.bmp");
     ok(ret <= 4 /* small and harmless diff in Wine vs Windows */, "got %lu%% diff\n", ret);
     IMFCollection_Release(output_samples);

@@ -4222,7 +4222,7 @@ todo_wine {
     ok(output_info.cbSize == actual_width * actual_height * 4, "got cbSize %#lx\n", output_info.cbSize);
     ok(output_info.cbAlignment == 0, "got cbAlignment %#lx\n", output_info.cbAlignment);

-    load_resource(L"nv12frame.bin", &nv12frame_data, &nv12frame_data_len);
+    load_resource(L"nv12frame.bmp", &nv12frame_data, &nv12frame_data_len);
     ok(nv12frame_data_len == 13824, "got length %lu\n", nv12frame_data_len);

input_sample = create_sample(nv12frame_data, nv12frame_data_len);
@@ -4257,7 +4257,7 @@ todo_wine {
     ref = IMFSample_Release(output_sample);
     ok(ref == 1, "Release returned %ld\n", ref);

-    ret = check_mf_sample_collection(output_samples, &output_sample_desc, L"rgb32frame-vp.bin");
+    ret = check_mf_sample_collection(output_samples, &output_sample_desc, L"rgb32frame-vp.bmp");
     todo_wine
     ok(ret == 0 || broken(ret == 25) /* w1064v1507 / w1064v1809 incorrectly rescale */, "got %lu%% diff\n", ret);
     IMFCollection_Release(output_samples);

[PATCH v2 10/10] mf/tests: Dump image samples with a BMP header and RGB data.

[Rémi Bernon]

From: Rémi Bernon

Allowing easier preview of NV12 / I420 images as well.
---
 dlls/mf/tests/i420frame.bmp          | Bin 13824 -> 50742 bytes
 dlls/mf/tests/nv12frame-grabber.bmp  | Bin 0 -> 22582 bytes
 dlls/mf/tests/nv12frame.bmp          | Bin 13824 -> 50742 bytes
 dlls/mf/tests/rgb32frame-grabber.bmp | Bin 0 -> 16438 bytes
 dlls/mf/tests/rgb32frame-vp.bmp      | Bin 36864 -> 36918 bytes
 dlls/mf/tests/rgb32frame.bmp         | Bin 36864 -> 36918 bytes
 dlls/mf/tests/transform.c            | 141 +++++++++++++++++++++++----
 7 files changed, 122 insertions(+), 19 deletions(-)
 create mode 100644 dlls/mf/tests/nv12frame-grabber.bmp
 create mode 100644 dlls/mf/tests/rgb32frame-grabber.bmp

diff --git a/dlls/mf/tests/i420frame.bmp b/dlls/mf/tests/i420frame.bmp
index 58cefb87913d03728d293154aaa5fc82ce0fb64c..d56f2c502b5cbbcc8e683947b8dc75ebf9b7072c 100644
GIT binary patch
literal 50742
zcmeI!p{>GD7>41F&=Cj<7U%$Y1hxu|V1|wW41wq<l?>1YFx}wL0Qxr-CmfzH`5SJU
zYu-HJ-rc^rRPQzOb2H!ZdsVfXKh68T|NQWIKD#bC4H#g60R|XgfB^;=V1NMz7+`>b
zat%D{TXGsOzyJdbFu(u<3^2d|0}L?000ZS3=<juM8Zf{B0}L?000Rs#zyJdbFu(u<
z<r=s)>*O?GfB^;=V1NMz7+`<_1{h#~0S3x7a2m$sG+=-M1{h#~0R|XgfB^;=V1NMz
z$~ACkr{pwXfB^;=V1NMz7+`<_1{h#~0S3x7u$|7yX}|yj3^2d|0}L?000Rs#zyJdb
zFu(u<3^2d|0}L?000Rs#zyJdbFu=fX8hDxl3Mi1Nz{3<!K!HpJdQ(6F1u_-5ngR+a
zkg34Q6i`5cOa%_6fC36+DzG&L6i`3`1r$)=&kA%F7N{*OaJR5PV_|{8!UC;@1twEq
lL4oj(zn9(3!UEwxM_$%z3k!@E7Fh7r{ujS`HU$<GcmWa@Bi#T1

literal 13824
zcmeH}u?>Sz3`AF82D&W39<+>*f*Du=hM-^+q%;{I3;c!=(zr1ar$e%SVeT4)e7g9a
zEQL~{^>K<$FU7@wlz%25K4&8SU3@%`^IKg$-*EZ;!{fio$4tdXd@un#t$ROPxcvU%
z@tg87Q}GcWOaM>o-p?E^zkhiAtbEK=e8dM6z|*?-^A4BaKRo`ee9TmQ#0L|=)4KQ5
zhs*CD9^We;GZi24!36NM?)|*N<@XPde<>d`6(8}z1n{)({rF$gn+S-22-G7mv9gs|
z`;^4ru(H0ay-DI<Sy^A!z9#W^tgJ6<?~?d;R@Rrb?@9avE9=YJha~=kmGx!qM-so)
z(Bp!@)4pf!_FY&RU)H`P@jvZ*?{43gmE8ktZ<F|ctgJ6<|0VH1?f?32-;tHw18X0X
K_^pN>7X<!9H+|Ir

diff --git a/dlls/mf/tests/nv12frame-grabber.bmp b/dlls/mf/tests/nv12frame-grabber.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..2acd5d9992330c5b71afd7ffb5d34a3770eb1dee
GIT binary patch
literal 22582
zcmeIwp%H^n5QJe$z~VBf(7@A76ea>o2?%PyBB2Nbr64H)i@?yq<qZ=PeIjE2z1cTd
zcD~m;l*yeC-)C(3ZIV3VS4?@oKhN3sM%e%Z7{CAqFd$~28tfGA7XMwk>0}#a0}NmQ
z0~o-7l!0YVjj{m-Fn|FJU_i`3m)RoRG5))BLvABw0}NmQ0~o-7l!12Ljj{m-Fn|FJ
zU_i{kbXY6gI{v$Ko6Bm-1{lBq1~7mDDFemT8D#?uU;qOczyJm?pkv@9EZ|sRBP`%p
zU?D8vSYRY9;8>s~EZ|t6CM@7spdc*p#|3)vRD<u*N&Dth`?}0`A=kcj*S_iSU2|#Q
I)p4E$KCEGdKL7v#

literal 0
HcmV?d00001

diff --git a/dlls/mf/tests/nv12frame.bmp b/dlls/mf/tests/nv12frame.bmp
index d6640023fb9f7382de5251b39eb54cf693a1dad8..dadece8b145379a2a6fbdd990809524c357d9f00 100644
GIT binary patch
literal 50742
zcmeI5v5g`@5Jd@LLO5X^2}}UzpMi^YHU=>e!a@)jgo1=a03?7j8O+VxuCa|#(*6Ew
zX-cnKjcB#%Q}y=w`|EfAvHG|A>GS7w{(PO)>c{kLT3_#<m(S1F@i=no8QkypQ8}=$
zXFoGk*v~cahkphK@ZaOH>H_@Xuey_=4*&5#gU9L&_>cdpI~nTmf0_P2y7S1XXQ28I
z`+D{>L->0*sy@OW{;E3}>hK@`GkC1dfdBZfx|5*}|M5SA$Lb9DzfAwHmu}?LGf@49
zeLee`A^bfYRUhFGf7P7~b@-3}89Y{Jz<>N#-N{gg|M;K5V|51nU#9=3em!#P8L0ll
zzMlQe5dI#Hs*mu8zv@ngI{e4~3?8d9;6MJW?qsOLfBetju{s0(FVp}1?KyJl8L0ll
zzMlQe5dI#Hs*mu8zv@ngI{e4~3?8d9;6MJW?qsOLfBetju{s0(FVp|+ZWuZB3{?MN
zU(bGK2!9Vp)kpZlUv(!#9sc8g29MPl@E`wGcQVxBKmKR%Se*g?m+AjzIE<Wn2CDzC
zuV+6qgujQQ>LdK&uey_=4*&5#gU9L&_>cdpI~nTmAOACWtj>V{%k*FUyHTh8zjwI7
z4F_-l2XFufZ~zBz00(dY2XFufaG<pVFZ-G%__plvuW#YgSMuKpz~`Mvd52HQ<Nel_
z&%?gT{_XJ(@?)m(flo{zer@Z|)xOI9?eSOgW2W$dPfQ?wZR^j;zRLdX@h9?QrtpDJ
zOdx)3>(Ac4%Kq)~d-7wZ@PSWEAbxG@&(^-m{_XKw@?)m(flo{zer@Z|#=gq_?eQD(
zW2W$dPfQ?wZR=0@Yuq3J0SL4saI~+ocYFMi{FrH5KHb^9%l_Tz-I@HDX<I&*&b`b2
z-RYN({FrH5KK<Ig%l_Tz{hIukX<I(Gr+b(EyVGw^@?)lL`RoSwF8g<<?*{T?rfvBQ
Z2lp=fcc%{r@?)lL`INuL4Fdm1;4i8^`3(R7

delta 18
acmdni!`zTF*<pgm<bVlWn>!|~GX(%k@CXP1

diff --git a/dlls/mf/tests/rgb32frame-grabber.bmp b/dlls/mf/tests/rgb32frame-grabber.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..b5a5960b96481bd01a5cc1a1fe9358127ca370bb
GIT binary patch
literal 16438
zcmeI&JxW7C6o%n9h=OPq5K*x35A0LNprtlhf-6X$CL72CbO&~pqN~s*DT8qVYDCc7
zJ03zB*YKW!XSnS-=NlL<)4gnWSgv;LC!w<f`|%a4v)un}bzPIP2bqD)KxV*~ftOM+
zn@0U+w^6@Y@9P7zi|;vRlnS$Ey}-;o`>eg<u*}r#8F(rK%(|~b%;Nfs+2pr{nR)hE
zJG_^Mnmq##WfQZzvW408Cz$QV?+>%nA21{CzbSi=8E|Hxf8WRK`0WU@@y-OZ(bWjE
zikg%?$P73$@Vrqlo36$CAF-Qe!K_ET{}DT9ju~<LG23Q=nR)hEd&R-}OwFEw$Grh&
dXACi`8(=o3g_(KwS-bn}=lpa2nE`hO{s5dR2pIqX

literal 0
HcmV?d00001

diff --git a/dlls/mf/tests/rgb32frame-vp.bmp b/dlls/mf/tests/rgb32frame-vp.bmp
index 46d93a9c40b5d875c821580dd1db984d3b97217a..3361ed3f4a0a6d5df0d345b02afc327e2ca1ba49 100644
GIT binary patch
delta 70
xcmZozz_e`vlbMsR*#rhKFawerK%4-@3=9fD77#$?Ash&~k@3Ia=Kq3>bpT{%3D^Jt

delta 17
ZcmdnCfT>{t(?*AHf)fL{7Mlsx0RTdu2FCyZ

diff --git a/dlls/mf/tests/rgb32frame.bmp b/dlls/mf/tests/rgb32frame.bmp
index 3ad7556ef7886011bce680f90127f150b081502d..0e50c30b8d02f3b6f226b21a1b51423c7115c980 100644
GIT binary patch
delta 63
qcmZozz_e`vlbMsR*#rhKFawerK%4-@3=9fD77#$?Ash&~U;+Rqod*N}

delta 18
acmdnCfT>{t(?&Z7#)*C$o9h^N^Z@`v$p;Dm

diff --git a/dlls/mf/tests/transform.c b/dlls/mf/tests/transform.c
index 30a39c6667f..2f1e7c60cc6 100644
--- a/dlls/mf/tests/transform.c
+++ b/dlls/mf/tests/transform.c
@@ -375,12 +375,16 @@ static HRESULT check_mft_process_output_(int line, IMFTransform *transform, IMFS
     return ret;
 }

-typedef DWORD (*compare_cb)(const BYTE *data, DWORD length, const RECT *rect, const BYTE *expect);
+typedef DWORD (*compare_cb)(const BYTE *data, DWORD *length, const RECT *rect, const BYTE *expect);

-static DWORD compare_nv12(const BYTE *data, DWORD length, const RECT *rect, const BYTE *expect)
+static DWORD compare_nv12(const BYTE *data, DWORD *length, const RECT *rect, const BYTE *expect)
 {
     DWORD x, y, size, diff = 0, width = (rect->right + 0xf) & ~0xf, height = (rect->bottom + 0xf) & ~0xf;

+    /* skip BMP header and RGB data from the dump */
+    expect = expect + *(DWORD *)(expect + 2);
+    *length = *length + *(DWORD *)(expect + 2);
+
     for (y = 0; y < height; y++, data += width, expect += width)
     {
         if (y < rect->top || y >= rect->bottom) continue;
@@ -406,10 +410,14 @@ static DWORD compare_nv12(const BYTE *data, DWORD length, const RECT *rect, cons
     return diff * 100 / 256 / size;
 }

-static DWORD compare_i420(const BYTE *data, DWORD length, const RECT *rect, const BYTE *expect)
+static DWORD compare_i420(const BYTE *data, DWORD *length, const RECT *rect, const BYTE *expect)
 {
     DWORD i, x, y, size, diff = 0, width = (rect->right + 0xf) & ~0xf, height = (rect->bottom + 0xf) & ~0xf;

+    /* skip BMP header and RGB data from the dump */
+    expect = expect + *(DWORD *)(expect + 2);
+    *length = *length + *(DWORD *)(expect + 2);
+
     for (y = 0; y < height; y++, data += width, expect += width)
     {
         if (y < rect->top || y >= rect->bottom) continue;
@@ -434,10 +442,14 @@ static DWORD compare_i420(const BYTE *data, DWORD length, const RECT *rect, cons
     return diff * 100 / 256 / size;
 }

-static DWORD compare_rgb32(const BYTE *data, DWORD length, const RECT *rect, const BYTE *expect)
+static DWORD compare_rgb32(const BYTE *data, DWORD *length, const RECT *rect, const BYTE *expect)
 {
     DWORD x, y, size, diff = 0, width = (rect->right + 0xf) & ~0xf, height = (rect->bottom + 0xf) & ~0xf;

+    /* skip BMP header from the dump */
+    expect = expect + *(DWORD *)(expect + 2 + 2 * sizeof(DWORD));
+    *length = *length + *(DWORD *)(expect + 2 + 2 * sizeof(DWORD));
+
     for (y = 0; y < height; y++, data += width * 4, expect += width * 4)
     {
         if (y < rect->top || y >= rect->bottom) continue;
@@ -454,10 +466,10 @@ static DWORD compare_rgb32(const BYTE *data, DWORD length, const RECT *rect, con
     return diff * 100 / 256 / size;
 }

-static DWORD compare_pcm16(const BYTE *data, DWORD length, const RECT *rect, const BYTE *expect)
+static DWORD compare_pcm16(const BYTE *data, DWORD *length, const RECT *rect, const BYTE *expect)
 {
     const INT16 *data_pcm = (INT16 *)data, *expect_pcm = (INT16 *)expect;
-    DWORD i, size = length / 2, diff = 0;
+    DWORD i, size = *length / 2, diff = 0;

for (i = 0; i < size; i++)
         diff += abs((int)*expect_pcm++ - (int)*data_pcm++);
@@ -465,14 +477,93 @@ static DWORD compare_pcm16(const BYTE *data, DWORD length, const RECT *rect, con
     return diff * 100 / 65536 / size;
 }

-static DWORD compare_bytes(const BYTE *data, DWORD length, const RECT *rect, const BYTE *expect)
+static DWORD compare_bytes(const BYTE *data, DWORD *length, const RECT *rect, const BYTE *expect)
 {
-    DWORD i, diff = 0;
+    DWORD i, size = *length, diff = 0;

-    for (i = 0; i < length; i++)
+    for (i = 0; i < size; i++)
         diff += abs((int)*expect++ - (int)*data++);

-    return diff * 100 / 256 / length;
+    return diff * 100 / 256 / size;
+}
+
+typedef void (*dump_cb)(const BYTE *data, DWORD length, const RECT *rect, HANDLE output);
+
+static void dump_rgb32(const BYTE *data, DWORD length, const RECT *rect, HANDLE output)
+{
+    DWORD width = (rect->right + 0xf) & ~0xf, height = (rect->bottom + 0xf) & ~0xf;
+    static const char magic[2] = "BM";
+    struct
+    {
+        DWORD length;
+        DWORD reserved;
+        DWORD offset;
+        BITMAPINFOHEADER biHeader;
+    } header =
+    {
+        .length = length + sizeof(header) + 2, .offset = sizeof(header) + 2,
+        .biHeader =
+        {
+            .biSize = sizeof(BITMAPINFOHEADER), .biWidth = width, .biHeight = height,
+            .biBitCount = 32, .biCompression = BI_RGB, .biSizeImage = width * height * 4,
+        },
+    };
+    DWORD written;
+    BOOL ret;
+
+    ret = WriteFile(output, magic, sizeof(magic), &written, NULL);
+    ok(ret, "WriteFile failed, error %lu\n", GetLastError());
+    ok(written == sizeof(magic), "written %lu bytes\n", written);
+    ret = WriteFile(output, &header, sizeof(header), &written, NULL);
+    ok(ret, "WriteFile failed, error %lu\n", GetLastError());
+    ok(written == sizeof(header), "written %lu bytes\n", written);
+    ret = WriteFile(output, data, length, &written, NULL);
+    ok(ret, "WriteFile failed, error %lu\n", GetLastError());
+    ok(written == length, "written %lu bytes\n", written);
+}
+
+static void dump_nv12(const BYTE *data, DWORD length, const RECT *rect, HANDLE output)
+{
+    DWORD written, x, y, width = (rect->right + 0xf) & ~0xf, height = (rect->bottom + 0xf) & ~0xf;
+    BYTE *rgb32_data = malloc(width * height * 4), *rgb32 = rgb32_data;
+    BOOL ret;
+
+    for (y = 0; y < height; y++) for (x = 0; x < width; x++)
+    {
+        *rgb32++ = data[width * y + x];
+        *rgb32++ = data[width * height + width * (y / 2) + (x & ~1) + 0];
+        *rgb32++ = data[width * height + width * (y / 2) + (x & ~1) + 1];
+        *rgb32++ = 0xff;
+    }
+
+    dump_rgb32(rgb32_data, width * height * 4, rect, output);
+    free(rgb32_data);
+
+    ret = WriteFile(output, data, length, &written, NULL);
+    ok(ret, "WriteFile failed, error %lu\n", GetLastError());
+    ok(written == length, "written %lu bytes\n", written);
+}
+
+static void dump_i420(const BYTE *data, DWORD length, const RECT *rect, HANDLE output)
+{
+    DWORD written, x, y, width = (rect->right + 0xf) & ~0xf, height = (rect->bottom + 0xf) & ~0xf;
+    BYTE *rgb32_data = malloc(width * height * 4), *rgb32 = rgb32_data;
+    BOOL ret;
+
+    for (y = 0; y < height; y++) for (x = 0; x < width; x++)
+    {
+        *rgb32++ = data[width * y + x];
+        *rgb32++ = data[width * height + (width / 2) * (y / 2) + x / 2];
+        *rgb32++ = data[width * height + (width / 2) * (y / 2) + (width / 2) * (height / 2) + x / 2];
+        *rgb32++ = 0xff;
+    }
+
+    dump_rgb32(rgb32_data, width * height * 4, rect, output);
+    free(rgb32_data);
+
+    ret = WriteFile(output, data, length, &written, NULL);
+    ok(ret, "WriteFile failed, error %lu\n", GetLastError());
+    ok(written == length, "written %lu bytes\n", written);
 }

struct buffer_desc
@@ -480,6 +571,7 @@ struct buffer_desc
     DWORD length;
     BOOL todo_length;
     compare_cb compare;
+    dump_cb dump;
     RECT rect;
 };

@@ -558,9 +650,14 @@ static void dump_mf_media_buffer(IMFMediaBuffer *buffer, const struct buffer_des
     hr = IMFMediaBuffer_Lock(buffer, &data, NULL, &length);
     ok(hr == S_OK, "Lock returned %#lx\n", hr);

-    ret = WriteFile(output, data, length, &written, NULL);
-    ok(ret, "WriteFile failed, error %lu\n", GetLastError());
-    ok(written == length, "written %lu bytes\n", written);
+    if (buffer_desc->dump)
+        buffer_desc->dump(data, length, &buffer_desc->rect, output);
+    else
+    {
+        ret = WriteFile(output, data, length, &written, NULL);
+        ok(ret, "WriteFile failed, error %lu\n", GetLastError());
+        ok(written == length, "written %lu bytes\n", written);
+    }

hr = IMFMediaBuffer_Unlock(buffer);
     ok(hr == S_OK, "Unlock returned %#lx\n", hr);
@@ -606,9 +703,9 @@ static DWORD check_mf_media_buffer_(int line, IMFMediaBuffer *buffer, const stru
         todo_wine_if(expect->todo_length)
         ok_(__FILE__, line)(0, "missing %#lx bytes\n", length - *expect_data_len);
     else if (!expect->compare)
-        diff = compare_bytes(data, length, NULL, *expect_data);
+        diff = compare_bytes(data, &length, NULL, *expect_data);
     else
-        diff = expect->compare(data, length, &expect->rect, *expect_data);
+        diff = expect->compare(data, &length, &expect->rect, *expect_data);

hr = IMFMediaBuffer_Unlock(buffer);
     ok_(__FILE__, line)(hr == S_OK, "Unlock returned %#lx\n", hr);
@@ -2538,7 +2635,7 @@ static void test_h264_decoder(void)
     const struct buffer_desc output_buffer_desc_nv12 =
     {
         .length = actual_width * actual_height * 3 / 2,
-        .compare = compare_nv12, .rect = {.right = 82, .bottom = 84},
+        .compare = compare_nv12, .dump = dump_nv12, .rect = {.right = 82, .bottom = 84},
     };
     const struct sample_desc output_sample_desc_nv12 =
     {
@@ -2549,7 +2646,7 @@ static void test_h264_decoder(void)
     const struct buffer_desc output_buffer_desc_i420 =
     {
         .length = actual_width * actual_height * 3 / 2,
-        .compare = compare_i420, .rect = {.right = 82, .bottom = 84},
+        .compare = compare_i420, .dump = dump_i420, .rect = {.right = 82, .bottom = 84},
     };
     const struct sample_desc expect_output_sample_i420 =
     {
@@ -3427,7 +3524,7 @@ static void test_color_convert(void)
     const struct buffer_desc output_buffer_desc =
     {
         .length = actual_width * actual_height * 4,
-        .compare = compare_rgb32, .rect = {.right = 82, .bottom = 84},
+        .compare = compare_rgb32, .dump = dump_rgb32, .rect = {.right = 82, .bottom = 84},
     };
     const struct attribute_desc output_sample_attributes[] =
     {
@@ -3556,6 +3653,9 @@ static void test_color_convert(void)
     ok(output_info.cbAlignment == 1, "got cbAlignment %#lx\n", output_info.cbAlignment);

load_resource(L"nv12frame.bmp", &nv12frame_data, &nv12frame_data_len);
+    /* skip BMP header and RGB data from the dump */
+    nv12frame_data_len = nv12frame_data_len - *(DWORD *)(nv12frame_data + 2);
+    nv12frame_data = nv12frame_data + *(DWORD *)(nv12frame_data + 2);
     ok(nv12frame_data_len == 13824, "got length %lu\n", nv12frame_data_len);

input_sample = create_sample(nv12frame_data, nv12frame_data_len);
@@ -3770,7 +3870,7 @@ static void test_video_processor(void)
     const struct buffer_desc output_buffer_desc =
     {
         .length = actual_width * actual_height * 4,
-        .compare = compare_rgb32, .rect = {.top = 12, .right = 82, .bottom = 96},
+        .compare = compare_rgb32, .dump = dump_rgb32, .rect = {.top = 12, .right = 82, .bottom = 96},
     };
     const struct attribute_desc output_sample_attributes[] =
     {
@@ -4223,6 +4323,9 @@ todo_wine {
     ok(output_info.cbAlignment == 0, "got cbAlignment %#lx\n", output_info.cbAlignment);

load_resource(L"nv12frame.bmp", &nv12frame_data, &nv12frame_data_len);
+    /* skip BMP header and RGB data from the dump */
+    nv12frame_data_len = nv12frame_data_len - *(DWORD *)(nv12frame_data + 2);
+    nv12frame_data = nv12frame_data + *(DWORD *)(nv12frame_data + 2);
     ok(nv12frame_data_len == 13824, "got length %lu\n", nv12frame_data_len);

input_sample = create_sample(nv12frame_data, nv12frame_data_len);

[Rémi Bernon (＠rbernon)]

v2: Fix intermediate test failures, rename the dumps in a separate commit to help the testbot apply the patch.