[PATCH v4 0/6] MR6220: mfplat: Implement MFCreateMediaBufferFromMediaType for video formats and test video processor with 2D buffers.

[Rémi Bernon (＠rbernon)]

Superseding https://gitlab.winehq.org/wine/wine/-/merge_requests/6188

--
  v4: mf/tests: Test 2D buffers can override stride.
      mf/tests: Test 1D/2D output on 2D buffers.
      mf/tests: Test video processor with 2D buffers.
      mf/tests: Cleanup the video processor test list.
      mfplat: Implement MFCreateMediaBufferFromMediaType for video formats.
      mfplat/tests: Add more tests for MFCreateMediaBufferFromMediaType.

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

[PATCH v4 1/6] mfplat/tests: Add more tests for MFCreateMediaBufferFromMediaType.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/mfplat/tests/mfplat.c | 244 ++++++++++++++++++++++++++++++++++++-
 1 file changed, 242 insertions(+), 2 deletions(-)

diff --git a/dlls/mfplat/tests/mfplat.c b/dlls/mfplat/tests/mfplat.c
index 786aba44c04..258c03957aa 100644
--- a/dlls/mfplat/tests/mfplat.c
+++ b/dlls/mfplat/tests/mfplat.c
@@ -7080,9 +7080,12 @@ static void test_MFCreateMediaBufferFromMediaType(void)
     };
     IMFMediaType *media_type, *media_type2;
     unsigned int i, alignment;
+    IMF2DBuffer2 *buffer_2d2;
     IMFMediaBuffer *buffer;
+    IMF2DBuffer *buffer_2d;
+    BYTE *data, *scanline0;
     DWORD length, max;
-    BYTE *data;
+    LONG pitch;
     HRESULT hr;

if (!pMFCreateMediaBufferFromMediaType)
@@ -7097,6 +7100,22 @@ static void test_MFCreateMediaBufferFromMediaType(void)
     hr = MFCreateMediaType(&media_type);
     ok(hr == S_OK, "Failed to create media type, hr %#lx.\n", hr);

+    hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 0, 0, &buffer);
+    ok(hr == MF_E_ATTRIBUTENOTFOUND, "Unexpected hr %#lx.\n", hr);
+    hr = IMFMediaType_SetGUID(media_type, &MF_MT_MAJOR_TYPE, &GUID_NULL);
+    ok(hr == S_OK, "Failed to set attribute, hr %#lx.\n", hr);
+    hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 0, 0, &buffer);
+    todo_wine ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
+    hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 16, 0, &buffer);
+    todo_wine ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    if (hr == S_OK)
+    {
+    hr = IMFMediaBuffer_GetMaxLength(buffer, &length);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    ok(length == 16, "Got length %#lx.\n", length);
+    IMFMediaBuffer_Release(buffer);
+    }
+
     hr = MFCreateMediaType(&media_type2);
     ok(hr == S_OK, "Failed to create media type, hr %#lx.\n", hr);

@@ -7157,8 +7176,229 @@ static void test_MFCreateMediaBufferFromMediaType(void)
         IMFMediaBuffer_Release(buffer);
     }

-    IMFMediaType_Release(media_type);
     IMFMediaType_Release(media_type2);
+
+
+    hr = IMFMediaType_DeleteAllItems(media_type);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+
+    /* MF_MT_SUBTYPE is required unless min length is provided */
+    hr = IMFMediaType_SetGUID(media_type, &MF_MT_MAJOR_TYPE, &MFMediaType_Video);
+    ok(hr == S_OK, "Failed to set attribute, hr %#lx.\n", hr);
+    hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 0, 0, &buffer);
+    todo_wine ok(hr == MF_E_ATTRIBUTENOTFOUND, "Unexpected hr %#lx.\n", hr);
+    hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 16, 0, &buffer);
+    todo_wine ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    if (hr == S_OK)
+    {
+    hr = IMFMediaBuffer_Lock(buffer, &data, &max, &length);
+    ok(hr == S_OK, "Failed to lock, hr %#lx.\n", hr);
+    ok(max == 16, "Unexpected max length.\n");
+    ok(length == 0, "Unexpected length.\n");
+    ok(!((uintptr_t)data & 0xf), "%u: data at %p is misaligned.\n", i, data);
+    hr = IMFMediaBuffer_Unlock(buffer);
+    ok(hr == S_OK, "Failed to unlock, hr %#lx.\n", hr);
+    IMFMediaBuffer_Release(buffer);
+    }
+
+    /* MF_MT_FRAME_SIZE is required  unless min length is provided */
+    hr = IMFMediaType_SetGUID(media_type, &MF_MT_SUBTYPE, &MFVideoFormat_RGB32);
+    ok(hr == S_OK, "Failed to set attribute, hr %#lx.\n", hr);
+    hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 0, 0, &buffer);
+    todo_wine ok(hr == MF_E_ATTRIBUTENOTFOUND, "Unexpected hr %#lx.\n", hr);
+    hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 16, 0, &buffer);
+    todo_wine ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    if (hr == S_OK)
+    {
+    hr = IMFMediaBuffer_Lock(buffer, &data, &max, &length);
+    ok(hr == S_OK, "Failed to lock, hr %#lx.\n", hr);
+    ok(max == 16, "Unexpected max length.\n");
+    ok(length == 0, "Unexpected length.\n");
+    ok(!((uintptr_t)data & 0xf), "%u: data at %p is misaligned.\n", i, data);
+    hr = IMFMediaBuffer_Unlock(buffer);
+    ok(hr == S_OK, "Failed to unlock, hr %#lx.\n", hr);
+    IMFMediaBuffer_Release(buffer);
+    }
+
+    /* MF_MT_SAMPLE_SIZE / MF_MT_FIXED_SIZE_SAMPLES / MF_MT_COMPRESSED don't have any effect */
+    hr = IMFMediaType_SetUINT32(media_type, &MF_MT_SAMPLE_SIZE, 1024);
+    ok(hr == S_OK, "Failed to set attribute, hr %#lx.\n", hr);
+    hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 0, 0, &buffer);
+    todo_wine ok(hr == MF_E_ATTRIBUTENOTFOUND, "Unexpected hr %#lx.\n", hr);
+    hr = IMFMediaType_SetUINT32(media_type, &MF_MT_FIXED_SIZE_SAMPLES, 1);
+    ok(hr == S_OK, "Failed to set attribute, hr %#lx.\n", hr);
+    hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 0, 0, &buffer);
+    todo_wine ok(hr == MF_E_ATTRIBUTENOTFOUND, "Unexpected hr %#lx.\n", hr);
+    hr = IMFMediaType_SetUINT32(media_type, &MF_MT_COMPRESSED, 0);
+    ok(hr == S_OK, "Failed to set attribute, hr %#lx.\n", hr);
+    hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 0, 0, &buffer);
+    todo_wine ok(hr == MF_E_ATTRIBUTENOTFOUND, "Unexpected hr %#lx.\n", hr);
+
+    /* MF_MT_FRAME_SIZE forces the buffer size, regardless of min length */
+    hr = IMFMediaType_SetUINT64(media_type, &MF_MT_FRAME_SIZE, (UINT64)7 << 32 | 8);
+    ok(hr == S_OK, "Failed to set attribute, hr %#lx.\n", hr);
+    hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 0, 0, &buffer);
+    todo_wine ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    if (hr == S_OK)
+    {
+    hr = IMFMediaBuffer_Lock(buffer, &data, &max, &length);
+    ok(hr == S_OK, "Failed to lock, hr %#lx.\n", hr);
+    ok(max == 224, "Unexpected max length.\n");
+    ok(length == 224, "Unexpected length.\n");
+    hr = IMFMediaBuffer_Unlock(buffer);
+    ok(hr == S_OK, "Failed to unlock, hr %#lx.\n", hr);
+
+    /* Video media type buffers implement IMF2DBuffer */
+    hr = IMFMediaBuffer_QueryInterface(buffer, &IID_IMF2DBuffer, (void **)&buffer_2d);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    hr = IMF2DBuffer_Lock2D(buffer_2d, &data, &pitch);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    ok(pitch == 64, "got pitch %ld.\n", pitch);
+    hr = IMF2DBuffer_Unlock2D(buffer_2d);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    IMF2DBuffer_Release(buffer_2d);
+
+    /* IMF2DBuffer2 is also implemented */
+    hr = IMFMediaBuffer_QueryInterface(buffer, &IID_IMF2DBuffer2, (void **)&buffer_2d2);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    hr = IMF2DBuffer2_Lock2DSize(buffer_2d2, MF2DBuffer_LockFlags_Read, &scanline0, &pitch, &data, &length);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    ok(pitch == 64, "got pitch %ld.\n", pitch);
+    ok(length == 512, "Unexpected length.\n");
+    ok(scanline0 == data, "Unexpected scanline0.\n");
+    hr = IMF2DBuffer2_Unlock2D(buffer_2d2);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    IMF2DBuffer_Release(buffer_2d);
+
+    IMFMediaBuffer_Release(buffer);
+    }
+
+    /* minimum buffer size value is ignored */
+    hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 4096, 0, &buffer);
+    todo_wine ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    if (hr == S_OK)
+    {
+    hr = IMFMediaBuffer_Lock(buffer, &data, &max, &length);
+    ok(hr == S_OK, "Failed to lock, hr %#lx.\n", hr);
+    ok(max == 224, "got max %lu.\n", max);
+    ok(length == 224, "got length %lu.\n", length);
+    hr = IMFMediaBuffer_Unlock(buffer);
+    ok(hr == S_OK, "Failed to unlock, hr %#lx.\n", hr);
+
+    hr = IMFMediaBuffer_QueryInterface(buffer, &IID_IMF2DBuffer, (void **)&buffer_2d);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    hr = IMF2DBuffer_Lock2D(buffer_2d, &data, &pitch);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    ok(pitch == 64, "got pitch %ld.\n", pitch);
+    hr = IMF2DBuffer_Unlock2D(buffer_2d);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    IMF2DBuffer_Release(buffer_2d);
+
+    IMFMediaBuffer_Release(buffer);
+    }
+
+    /* minimum alignment value is ignored */
+    hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 0, 0x1fff, &buffer);
+    todo_wine ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    if (hr == S_OK)
+    {
+    hr = IMFMediaBuffer_Lock(buffer, &data, &max, &length);
+    ok(hr == S_OK, "Failed to lock, hr %#lx.\n", hr);
+    ok(max == 224, "got max %lu.\n", max);
+    ok(length == 224, "got length %lu.\n", length);
+    hr = IMFMediaBuffer_Unlock(buffer);
+    ok(hr == S_OK, "Failed to unlock, hr %#lx.\n", hr);
+
+    hr = IMFMediaBuffer_QueryInterface(buffer, &IID_IMF2DBuffer, (void **)&buffer_2d);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    hr = IMF2DBuffer_Lock2D(buffer_2d, &data, &pitch);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    ok(pitch == 64, "got pitch %ld.\n", pitch);
+    hr = IMF2DBuffer_Unlock2D(buffer_2d);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    IMF2DBuffer_Release(buffer_2d);
+
+    IMFMediaBuffer_Release(buffer);
+    }
+
+    /* MF_MT_DEFAULT_STRIDE value is ignored */
+    hr = IMFMediaType_SetUINT32(media_type, &MF_MT_DEFAULT_STRIDE, -123456);
+    ok(hr == S_OK, "Failed to set attribute, hr %#lx.\n", hr);
+    hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 0, 0, &buffer);
+    todo_wine ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    if (hr == S_OK)
+    {
+    hr = IMFMediaBuffer_Lock(buffer, &data, &max, &length);
+    ok(hr == S_OK, "Failed to lock, hr %#lx.\n", hr);
+    ok(max == 224, "got max %lu.\n", max);
+    ok(length == 224, "got length %lu.\n", length);
+    hr = IMFMediaBuffer_Unlock(buffer);
+    ok(hr == S_OK, "Failed to unlock, hr %#lx.\n", hr);
+
+    hr = IMFMediaBuffer_QueryInterface(buffer, &IID_IMF2DBuffer, (void **)&buffer_2d);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    hr = IMF2DBuffer_Lock2D(buffer_2d, &data, &pitch);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    ok(pitch == -64, "got pitch %ld.\n", pitch);
+    hr = IMF2DBuffer_Unlock2D(buffer_2d);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    IMF2DBuffer_Release(buffer_2d);
+
+    IMFMediaBuffer_Release(buffer);
+    }
+
+    /* MF_MT_DEFAULT_STRIDE sign controls bottom-up */
+    hr = IMFMediaType_SetUINT32(media_type, &MF_MT_DEFAULT_STRIDE, 123456);
+    ok(hr == S_OK, "Failed to set attribute, hr %#lx.\n", hr);
+    hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 0, 0, &buffer);
+    todo_wine ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    if (hr == S_OK)
+    {
+    hr = IMFMediaBuffer_QueryInterface(buffer, &IID_IMF2DBuffer2, (void **)&buffer_2d2);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    hr = IMF2DBuffer2_Lock2DSize(buffer_2d2, MF2DBuffer_LockFlags_Read, &scanline0, &pitch, &data, &length);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    ok(pitch == 64, "got pitch %ld.\n", pitch);
+    ok(length == 64 * 8, "Unexpected length.\n");
+    ok(scanline0 == data, "Unexpected scanline0.\n");
+    hr = IMF2DBuffer2_Unlock2D(buffer_2d2);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    IMF2DBuffer_Release(buffer_2d);
+
+    IMFMediaBuffer_Release(buffer);
+    }
+
+    hr = IMFMediaType_SetUINT32(media_type, &MF_MT_DEFAULT_STRIDE, -123456);
+    ok(hr == S_OK, "Failed to set attribute, hr %#lx.\n", hr);
+    hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 0, 0, &buffer);
+    todo_wine ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    if (hr == S_OK)
+    {
+    hr = IMFMediaBuffer_QueryInterface(buffer, &IID_IMF2DBuffer2, (void **)&buffer_2d2);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    hr = IMF2DBuffer2_Lock2DSize(buffer_2d2, MF2DBuffer_LockFlags_Read, &scanline0, &pitch, &data, &length);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    ok(pitch == -64, "got pitch %ld.\n", pitch);
+    ok(length == 64 * 8, "Unexpected length.\n");
+    ok(scanline0 == data - pitch * 7, "Unexpected scanline0.\n");
+    hr = IMF2DBuffer2_Unlock2D(buffer_2d2);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    IMF2DBuffer_Release(buffer_2d);
+
+    IMFMediaBuffer_Release(buffer);
+    }
+
+    /* MF_MT_FRAME_SIZE doesn't work with compressed formats */
+    hr = IMFMediaType_DeleteItem(media_type, &MF_MT_FRAME_SIZE);
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
+    hr = IMFMediaType_SetGUID(media_type, &MF_MT_SUBTYPE, &MFVideoFormat_H264);
+    ok(hr == S_OK, "Failed to set attribute, hr %#lx.\n", hr);
+    hr = IMFMediaType_SetUINT64(media_type, &MF_MT_FRAME_SIZE, (UINT64)16 << 32 | 32);
+    ok(hr == S_OK, "Failed to set attribute, hr %#lx.\n", hr);
+    hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 0, 0, &buffer);
+    todo_wine ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
+
+    IMFMediaType_Release(media_type);
 }

static void validate_media_type(IMFMediaType *mediatype, const WAVEFORMATEX *format)

[PATCH v4 2/6] mfplat: Implement MFCreateMediaBufferFromMediaType for video formats.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/mfplat/buffer.c       | 30 +++++++++++++++++--
 dlls/mfplat/tests/mfplat.c | 59 +++++++++++---------------------------
 2 files changed, 43 insertions(+), 46 deletions(-)

diff --git a/dlls/mfplat/buffer.c b/dlls/mfplat/buffer.c
index b7f32f12cdc..fb3b2f305ee 100644
--- a/dlls/mfplat/buffer.c
+++ b/dlls/mfplat/buffer.c
@@ -1688,8 +1688,10 @@ HRESULT WINAPI MFCreateMediaBufferFromMediaType(IMFMediaType *media_type, LONGLO
 {
     UINT32 length = 0, block_alignment;
     LONGLONG avg_length;
+    GUID major, subtype;
+    UINT64 frame_size;
+    BOOL is_yuv;
     HRESULT hr;
-    GUID major;

TRACE("%p, %s, %lu, %lu, %p.\n", media_type, debugstr_time(duration), min_length, alignment, buffer);

@@ -1731,8 +1733,30 @@ HRESULT WINAPI MFCreateMediaBufferFromMediaType(IMFMediaType *media_type, LONGLO

return create_1d_buffer(length, alignment - 1, buffer);
     }
-    else
-        FIXME("Major type %s is not supported.\n", debugstr_guid(&major));

+    if (IsEqualGUID(&major, &MFMediaType_Video))
+    {
+        if (SUCCEEDED(hr = IMFMediaType_GetGUID(media_type, &MF_MT_SUBTYPE, &subtype))
+                && SUCCEEDED(hr = IMFMediaType_GetUINT64(media_type, &MF_MT_FRAME_SIZE, &frame_size))
+                && mf_format_get_stride(&subtype, frame_size >> 32, &is_yuv))
+        {
+            BOOL bottom_up = FALSE;
+            UINT32 stride;
+
+            if (!is_yuv && SUCCEEDED(IMFMediaType_GetUINT32(media_type, &MF_MT_DEFAULT_STRIDE, &stride)))
+                bottom_up = (int)stride < 0;
+
+            if (SUCCEEDED(hr = create_2d_buffer(frame_size >> 32, (UINT32)frame_size, subtype.Data1, bottom_up, buffer)))
+                return hr;
+        }
+
+        if (!min_length)
+            return FAILED(hr) ? hr : E_INVALIDARG;
+
+        alignment = max(16, alignment);
+        return create_1d_buffer(min_length, alignment - 1, buffer);
+    }
+
+    FIXME("Major type %s is not supported.\n", debugstr_guid(&major));
     return E_NOTIMPL;
 }
diff --git a/dlls/mfplat/tests/mfplat.c b/dlls/mfplat/tests/mfplat.c
index 258c03957aa..b9e6a715e93 100644
--- a/dlls/mfplat/tests/mfplat.c
+++ b/dlls/mfplat/tests/mfplat.c
@@ -7105,16 +7105,13 @@ static void test_MFCreateMediaBufferFromMediaType(void)
     hr = IMFMediaType_SetGUID(media_type, &MF_MT_MAJOR_TYPE, &GUID_NULL);
     ok(hr == S_OK, "Failed to set attribute, hr %#lx.\n", hr);
     hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 0, 0, &buffer);
-    todo_wine ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
+    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
     hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 16, 0, &buffer);
-    todo_wine ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
-    if (hr == S_OK)
-    {
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
     hr = IMFMediaBuffer_GetMaxLength(buffer, &length);
     ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
     ok(length == 16, "Got length %#lx.\n", length);
     IMFMediaBuffer_Release(buffer);
-    }

hr = MFCreateMediaType(&media_type2);
     ok(hr == S_OK, "Failed to create media type, hr %#lx.\n", hr);
@@ -7186,11 +7183,9 @@ static void test_MFCreateMediaBufferFromMediaType(void)
     hr = IMFMediaType_SetGUID(media_type, &MF_MT_MAJOR_TYPE, &MFMediaType_Video);
     ok(hr == S_OK, "Failed to set attribute, hr %#lx.\n", hr);
     hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 0, 0, &buffer);
-    todo_wine ok(hr == MF_E_ATTRIBUTENOTFOUND, "Unexpected hr %#lx.\n", hr);
+    ok(hr == MF_E_ATTRIBUTENOTFOUND, "Unexpected hr %#lx.\n", hr);
     hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 16, 0, &buffer);
-    todo_wine ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
-    if (hr == S_OK)
-    {
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
     hr = IMFMediaBuffer_Lock(buffer, &data, &max, &length);
     ok(hr == S_OK, "Failed to lock, hr %#lx.\n", hr);
     ok(max == 16, "Unexpected max length.\n");
@@ -7199,17 +7194,14 @@ static void test_MFCreateMediaBufferFromMediaType(void)
     hr = IMFMediaBuffer_Unlock(buffer);
     ok(hr == S_OK, "Failed to unlock, hr %#lx.\n", hr);
     IMFMediaBuffer_Release(buffer);
-    }

/* MF_MT_FRAME_SIZE is required  unless min length is provided */
     hr = IMFMediaType_SetGUID(media_type, &MF_MT_SUBTYPE, &MFVideoFormat_RGB32);
     ok(hr == S_OK, "Failed to set attribute, hr %#lx.\n", hr);
     hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 0, 0, &buffer);
-    todo_wine ok(hr == MF_E_ATTRIBUTENOTFOUND, "Unexpected hr %#lx.\n", hr);
+    ok(hr == MF_E_ATTRIBUTENOTFOUND, "Unexpected hr %#lx.\n", hr);
     hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 16, 0, &buffer);
-    todo_wine ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
-    if (hr == S_OK)
-    {
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
     hr = IMFMediaBuffer_Lock(buffer, &data, &max, &length);
     ok(hr == S_OK, "Failed to lock, hr %#lx.\n", hr);
     ok(max == 16, "Unexpected max length.\n");
@@ -7218,29 +7210,26 @@ static void test_MFCreateMediaBufferFromMediaType(void)
     hr = IMFMediaBuffer_Unlock(buffer);
     ok(hr == S_OK, "Failed to unlock, hr %#lx.\n", hr);
     IMFMediaBuffer_Release(buffer);
-    }

/* MF_MT_SAMPLE_SIZE / MF_MT_FIXED_SIZE_SAMPLES / MF_MT_COMPRESSED don't have any effect */
     hr = IMFMediaType_SetUINT32(media_type, &MF_MT_SAMPLE_SIZE, 1024);
     ok(hr == S_OK, "Failed to set attribute, hr %#lx.\n", hr);
     hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 0, 0, &buffer);
-    todo_wine ok(hr == MF_E_ATTRIBUTENOTFOUND, "Unexpected hr %#lx.\n", hr);
+    ok(hr == MF_E_ATTRIBUTENOTFOUND, "Unexpected hr %#lx.\n", hr);
     hr = IMFMediaType_SetUINT32(media_type, &MF_MT_FIXED_SIZE_SAMPLES, 1);
     ok(hr == S_OK, "Failed to set attribute, hr %#lx.\n", hr);
     hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 0, 0, &buffer);
-    todo_wine ok(hr == MF_E_ATTRIBUTENOTFOUND, "Unexpected hr %#lx.\n", hr);
+    ok(hr == MF_E_ATTRIBUTENOTFOUND, "Unexpected hr %#lx.\n", hr);
     hr = IMFMediaType_SetUINT32(media_type, &MF_MT_COMPRESSED, 0);
     ok(hr == S_OK, "Failed to set attribute, hr %#lx.\n", hr);
     hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 0, 0, &buffer);
-    todo_wine ok(hr == MF_E_ATTRIBUTENOTFOUND, "Unexpected hr %#lx.\n", hr);
+    ok(hr == MF_E_ATTRIBUTENOTFOUND, "Unexpected hr %#lx.\n", hr);

/* MF_MT_FRAME_SIZE forces the buffer size, regardless of min length */
     hr = IMFMediaType_SetUINT64(media_type, &MF_MT_FRAME_SIZE, (UINT64)7 << 32 | 8);
     ok(hr == S_OK, "Failed to set attribute, hr %#lx.\n", hr);
     hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 0, 0, &buffer);
-    todo_wine ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
-    if (hr == S_OK)
-    {
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
     hr = IMFMediaBuffer_Lock(buffer, &data, &max, &length);
     ok(hr == S_OK, "Failed to lock, hr %#lx.\n", hr);
     ok(max == 224, "Unexpected max length.\n");
@@ -7271,13 +7260,10 @@ static void test_MFCreateMediaBufferFromMediaType(void)
     IMF2DBuffer_Release(buffer_2d);

IMFMediaBuffer_Release(buffer);
-    }

/* minimum buffer size value is ignored */
     hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 4096, 0, &buffer);
-    todo_wine ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
-    if (hr == S_OK)
-    {
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
     hr = IMFMediaBuffer_Lock(buffer, &data, &max, &length);
     ok(hr == S_OK, "Failed to lock, hr %#lx.\n", hr);
     ok(max == 224, "got max %lu.\n", max);
@@ -7295,13 +7281,10 @@ static void test_MFCreateMediaBufferFromMediaType(void)
     IMF2DBuffer_Release(buffer_2d);

IMFMediaBuffer_Release(buffer);
-    }

/* minimum alignment value is ignored */
     hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 0, 0x1fff, &buffer);
-    todo_wine ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
-    if (hr == S_OK)
-    {
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
     hr = IMFMediaBuffer_Lock(buffer, &data, &max, &length);
     ok(hr == S_OK, "Failed to lock, hr %#lx.\n", hr);
     ok(max == 224, "got max %lu.\n", max);
@@ -7319,15 +7302,12 @@ static void test_MFCreateMediaBufferFromMediaType(void)
     IMF2DBuffer_Release(buffer_2d);

IMFMediaBuffer_Release(buffer);
-    }

/* MF_MT_DEFAULT_STRIDE value is ignored */
     hr = IMFMediaType_SetUINT32(media_type, &MF_MT_DEFAULT_STRIDE, -123456);
     ok(hr == S_OK, "Failed to set attribute, hr %#lx.\n", hr);
     hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 0, 0, &buffer);
-    todo_wine ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
-    if (hr == S_OK)
-    {
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
     hr = IMFMediaBuffer_Lock(buffer, &data, &max, &length);
     ok(hr == S_OK, "Failed to lock, hr %#lx.\n", hr);
     ok(max == 224, "got max %lu.\n", max);
@@ -7345,15 +7325,12 @@ static void test_MFCreateMediaBufferFromMediaType(void)
     IMF2DBuffer_Release(buffer_2d);

IMFMediaBuffer_Release(buffer);
-    }

/* MF_MT_DEFAULT_STRIDE sign controls bottom-up */
     hr = IMFMediaType_SetUINT32(media_type, &MF_MT_DEFAULT_STRIDE, 123456);
     ok(hr == S_OK, "Failed to set attribute, hr %#lx.\n", hr);
     hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 0, 0, &buffer);
-    todo_wine ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
-    if (hr == S_OK)
-    {
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
     hr = IMFMediaBuffer_QueryInterface(buffer, &IID_IMF2DBuffer2, (void **)&buffer_2d2);
     ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
     hr = IMF2DBuffer2_Lock2DSize(buffer_2d2, MF2DBuffer_LockFlags_Read, &scanline0, &pitch, &data, &length);
@@ -7366,14 +7343,11 @@ static void test_MFCreateMediaBufferFromMediaType(void)
     IMF2DBuffer_Release(buffer_2d);

IMFMediaBuffer_Release(buffer);
-    }

hr = IMFMediaType_SetUINT32(media_type, &MF_MT_DEFAULT_STRIDE, -123456);
     ok(hr == S_OK, "Failed to set attribute, hr %#lx.\n", hr);
     hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 0, 0, &buffer);
-    todo_wine ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
-    if (hr == S_OK)
-    {
+    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
     hr = IMFMediaBuffer_QueryInterface(buffer, &IID_IMF2DBuffer2, (void **)&buffer_2d2);
     ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
     hr = IMF2DBuffer2_Lock2DSize(buffer_2d2, MF2DBuffer_LockFlags_Read, &scanline0, &pitch, &data, &length);
@@ -7386,7 +7360,6 @@ static void test_MFCreateMediaBufferFromMediaType(void)
     IMF2DBuffer_Release(buffer_2d);

IMFMediaBuffer_Release(buffer);
-    }

/* MF_MT_FRAME_SIZE doesn't work with compressed formats */
     hr = IMFMediaType_DeleteItem(media_type, &MF_MT_FRAME_SIZE);
@@ -7396,7 +7369,7 @@ static void test_MFCreateMediaBufferFromMediaType(void)
     hr = IMFMediaType_SetUINT64(media_type, &MF_MT_FRAME_SIZE, (UINT64)16 << 32 | 32);
     ok(hr == S_OK, "Failed to set attribute, hr %#lx.\n", hr);
     hr = pMFCreateMediaBufferFromMediaType(media_type, 0, 0, 0, &buffer);
-    todo_wine ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);
+    ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr);

IMFMediaType_Release(media_type);
 }

[PATCH v4 3/6] mf/tests: Cleanup the video processor test list.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/mf/tests/nv12frame-flip.bmp       | Bin 50742 -> 50742 bytes
 dlls/mf/tests/rgb32frame-crop-flip.bmp | Bin 27606 -> 27606 bytes
 dlls/mf/tests/rgb32frame.bmp           | Bin 36918 -> 36918 bytes
 dlls/mf/tests/rgb555frame-flip.bmp     | Bin 18486 -> 18486 bytes
 dlls/mf/tests/rgb555frame.bmp          | Bin 18486 -> 18486 bytes
 dlls/mf/tests/transform.c              |  82 +++++++++++++++----------
 6 files changed, 49 insertions(+), 33 deletions(-)

diff --git a/dlls/mf/tests/nv12frame-flip.bmp b/dlls/mf/tests/nv12frame-flip.bmp
index 72310512d44ec8b88e4186e2e7bd3ee61dc66fda..c9261ed5caa1d94680dbdeae62bbe28ef19d4ecf 100644
GIT binary patch
literal 50742
zcmeI0u}UjJ6o&N;_7N_rZeGA(>9tOg!X_Zx+CWO{?ZoaTjZff8u<$K}SOzPLG-8z^
zd4qBGYBS9#_8jI6?l;2`W#FIj<D0X~{u!VAJNiFP;?Li){(jf-(XaSh9N+6-e|-IX
zynhN53~&GkZ~zBz00(dY2XFufZ~zBz00(g3=Q=Pv%mbxh@Lq@0SY7W3>=o==cj51Q
zf8h`RK0ib7AOG>6_a83@=s)xyFZW8=7yt3U1P{H=p!9z--3Lm+;QAw6#OnI}2lfi~
zt-J8|y}$5>f1jTr_>cei&-;&;1N0yIkC%HT?2G^SUxJ5TXHfb-TW<rUVDR!5u3~ll
z{sVgj`_^6f``%yp!@tkZ5d6n~{OA40%K`ci{m09_686P^{4c>nuQMq9UyKHUQZTq2
zhefQe-+y4QVBfk6f8YBHfB5(L8G`@#kN>>?csW4-q5pWfSHiydkN+ij=ye9A|Es17
zl!C#-S!iN){r&@c1^d=r`1{^p_`|=?&k+2_fBfhD$IAiw5B<l>y%P4tfBY}OL$5O^
z{oho}Kq(lU--YK`UBCapUctU~7yiEY7yj_?^D_kh@gM(r|M7Bw{zL!qa<7Da@gM(7
z@X+fFO8<9t9Vi8Zo7?ajtLyh4*elq#?!w>q{=y&reSU`EKmOxC?>}A+(0}MZUhb8!
zFaG0y2_AZ#LFxY^0|F3$fD?hC^*Bxc5$pIN`7%=Yz(*z^uV(gVVm&U>{$m|KAzwxc
zANa@w<kign%&f;%+JCI$XXMLB;R7F;fV`U7pN08I`;U42f_#}NeBdJ!kXQ5iv$7sd
zdVcHp75Oq!_`pXdAg^ZjXJb8{)Ba-}zad{n3Lp5$1mxAs{_L#BYubOT<9FoCNZ|t?
znSi{S*`NC-CIq?@ILvM5d!3%eHvKRsUnZKH&vb7)uRl_MY}2QE@@1mA`K-6L^W`n|
z$2NVvC0{0*o6l%qJ1@tnKep+k0r@h~+<cnKc0Qb?{@A8B75OsJ+<dB~?L5Cr{jp82
ZmgLJsbMvW<$IWf(k8ylWzDzVXpHCQBhC2WN

literal 50742
zcmeI4y-H(I6h@sl(9UwS8X<xR25hIFA_x{%(}@-~f~~1VLB$8KFiNzDosS?XBw#Oy
zm0cd;%<-piTO4qIo6!^3-h3h9az5@|S)>ww|7q@zJx?>g{>u6Lnjd37^SeB+*Iz!o
zyk2yAiRcV&Zf=q%u-Dl?G4!y1Is<?BkAegEALFst1^C0?>&_^g!+-oA1&_VYfd6&+
ze|6kVL}%dj|1$F@Is-5N*@t!_Is-5Nh0LGm47~hjh8v0K4B)RbR6K+~{1ty{Ka2nP
zU%SJ~{o_CWEB@4e*6aWL^-dx>126wZ=1+76UjD7^K_WT>`0ET658eD%hN(ql2Jrt}
zkKhmg@BBN4|M-vpAO9Ql@60Un+4=pc^Y>?Y^Dz;ff!F_~%%A8Cy!_XC_lf8Xy!=-)
zf1)$+@?Y=YC89Hczs^wc5dQF2{Hgsc{^Nh`4lDPM|M;)?Q~O!`$N$<LR_@>H|9*2i
z5uE}2b%u(E@Q1(RPwi*%AOCB2Sh;`v$A872+Rx%Y{@3oXa{pfck6KfS=nTC44>NzF
zGw||1+nr2AXW-?3lKB&zftP>xbUYEA0sM7_iihxrzv55rXYn8ZYj;?=fBeUP#h=>G
zdi_6d&n2QWfWOXA@zBeEu(*|o&cMsRpZOD=ftUa7#6coD1NiF<6%XMLf5o5L&*DG+
z*Y2=#|M-vpia)iVb^G7gOSeR30RPYR$jhH|AOD|uFoPKm-~bNb01n^)4&VR|-~bNb
z01n_lO%7ayPk#D06JCGuraZr;|2+ZtyeDEmj~1V+@UeU@!^if|hL7!E2p`)&6F&5p
zk;3OI@tF@F`~5b;$M(0vhyF5B_`s)3pnTQ(vm8FQe<^%y|62Ii{?+iY{p;aFe;Fx!
z;8P}0zH0s14<Gu=NZ|vYGJ*0{>(5d6*#5)tvHfS^WBX6S$M$!_hyF5B_<SWk=iy_&
z-|+f#+dl{&+usi#+kYEA^p}ys2R>y2<*U{oK0yEi5cn(tonG|XCy8$F^yn`$wS11d
z(QEr3+R<zKha1sLf0?M|bG;M2wtssNy|#a47`^nDiCR9JkI`%Ud-u_6`}=p%OMjW@
z|K-!1j$V8J(e2G?`pZl$pVn0L+Wy_i=(YW)<IzihnW*K{o{L`Fzql2>wtwOvdg(6{
QwR{?T(QEtp1ObJ>KcaD^#sB~S

diff --git a/dlls/mf/tests/rgb32frame-crop-flip.bmp b/dlls/mf/tests/rgb32frame-crop-flip.bmp
index 34a28ad44732f38d4165bdc00de313db7c2f390a..53cbb9e023b9a5c5e9ce9b1e8e33805f010cf7ee 100644
GIT binary patch
literal 27606
zcmeI(u}K6`5P;#i#5xSG0t+zKM6L@%tFQtQ49qP;u!Bo3GO`03xaY9kR4{)q!hi7g
zA+p2c_gi5FZ|_f!v3+jxy3h5H>yT>~*LjV2zkGlD;&NFL%hhY}9d|Ya9NDqwu%2T(
z+OaH5*!8H#2@dNFdemcCn6T?nj}si$8T80`j5udjSEs>K{MZmMWJl&Xw4)t6zt8A<
z^{7YMRA-(Z_1N)4->XMG(xy7|^vHQU=c~G_*I-@!+7NJL$DYG_j_qj2vM^!SqaG(X
ztTX6Qk7Z%Pu17sia9C&1Bj<6qV!3(^Uf-T=2spB1&tW~scC=$zn6T?nj}si$8T6>f
zvM^!SqaG(XtTX75^O*lQyj;x&A1^i}9NCd^WJfy^&m%QMk9wpm5p(pYN5T;`Lyvl-
zED>|`h<R+jSrR|Ze?Q~%%fC<%j_k-dvZEb|=aHJBM?F%Oh&g)HBjJdep+`MZmWVle
z<UHn!x}R==V|Re}Zw2hgK(M17nF7odJ=&2ez)aDj9hm~m6g}FJDZot8Bi8W`gV)&s

literal 27606
zcmeI&!3}~y5J1tP6OUG40p7hByRa#%vK-cdFbyys_V7q%2_Yn#pLc<9e|+DuAGchu
zInSI|&JvegBR<Fd{o+_g#4s8#zyJdbFu(u<3^2d|0}L?GGZ3+6LUX=BeV)+pe8a7s
zj=g^6Pe&cg!VG5~d7Qyv?SV%g%fbw29(kO>VeNs(e|lW=y~b$300Rs#zyJdbFu(u<
z3^2ez&%iQb7!4R;fB^;=V1NMz7+`<_1{mlW$iD%G(SQL47+`<_1{h#~0R|XgfPtQY
v-qY&q#{dHiFu(u<3^2d|0}L?0z-GXqfC36Apnw7jD4>7>3Mim}0{sF%iRi;|

diff --git a/dlls/mf/tests/rgb32frame.bmp b/dlls/mf/tests/rgb32frame.bmp
index 9f2ea1e5d1b2b808f3671b09c19ed6fcd090de85..5d275ae88d0315e324e6af0ac7a24763ef06e3eb 100644
GIT binary patch
literal 36918
zcmeI)u}woU7==-%VGc?r$N<!^13NH4YC1ZE#0Ct3#0K<KY`_8uek2q4Ml%27L~;Z|
z&U3z;SdkTReY<^Zzqf6_zv|=eG&b$B|I}}%zaM`&-XGlZ0w4V$c7r3ox<}A|t^xh^
zpIcz=)%n+dZh^U1=U@N11?FCzfBokcn0s~p%l2=5<wn-v?Y&3bjScOy_Detg^M;8-
z{q;}$RG-T~|J4mA>*t^U#836P{PSPkaI${>>-wL&@<iPqn)~`ReEy^V8D2;I`zhEN
zI*vYu{`!yFS;IX3`Co(M(dWQF|D$%+Fpq!!*Wh^cIq+ZB|E9m@M%Li@<ze{zNBgY(
z(og@qVd7AK{S!ac=km{gb;HT}`R70JQ++P~{8u-ete^k7{`dWB14h>1aPd8S{-b@?
ze(9%w-Y{{fzy67z>T~($zq;XM{rvNv_^CdZfBvf*PS($VUH`4^4@TDDzI_d!|7f4J
zU;62vH%uJruYcmF`dt3`uWmS5KmYtEeyY#qpa1HHllAjo*MC3!>Hj*!NE&>$o8j}H
z<hte_-ReL0{j0zJ|9LOspMU=Q_i%Ru!)MR<^SAxS{$u|c*n5`!%Kj5Ku>Ta^f0p-v
bp#cL7Fu(u<3^2d|0}L?000Rs#uv!B@G3kk=

literal 36918
zcmeI*u}Yg^9EI^Cp-Y{_DXoJ;g<gTswR>Gccke(i!PP-=^b)K~Zl@ik*$ag_DEVIB
zs5js_AC!Oc1db^3!j~V9MuH??za3ub`F7Ype(pPd-In(IXZ`m2{g*FZJ`TemmK(IQ
zCTG~^_A5ijesu<a{MVrY`X8rbw*~z1ciUNqbM#OD>(H@#ALzek|36w2%MINA@47$B
z4P5_^j}KzGf$Kl}_g5@8aQ)SmVz~kSxna^F{`e>TR6k4q^k2Q<<ofBK{*!*HpLP2`
zZF8~Q!1X_93$fh5_5bxa70V4=|I0r|V!46q-=BUK8^OT*|2OPMuwONd|Ns3t#vlJp
zek`GX`ltW5KMrrQ*_ij;{QYy=w#9M-_wUc&Z6cN%xc+<nX>*nvxc=YoC6*hw{_2lG
zEH}VEH%vOjAOEDE>SyVn{;M~fTtEHOf6`C&v-D5@)f-N(-|c^?K`b}GKQ~M|#2^2p
zpXz7npZ=>ioLoQs(|^)W^|SO(|J55#uHWtd=6w^(4P5`bNq_Ad78|(!AM_xW8@T>6
z_1C^(v4QKa{_H2q4e-wmlMeC6Kk29XS^B5{>J2B?Pyh6v^i%z;+yBYVTr4+m{Xe~1
zh~);Z|4&WDas$`@LPuh`f$KkPNh~+OKQ~M|#2^2ppXz7npZ=>ioLoQs(|^)W^|NmO
z3w;sG4P5_w?TY0Fu75l4?_17tgEQ~_-`jOR$8rPLpL1`2%|gsDqX8PA0UDqI8lV9h
MpaB}7fpQHz0TpqG-v9sr

diff --git a/dlls/mf/tests/rgb555frame-flip.bmp b/dlls/mf/tests/rgb555frame-flip.bmp
index e3a641a9a04d3e09b8ad12c3f437cece1dab2f30..43cb317ce03cb2f1dd6fe1f8023273d97bb12eba 100644
GIT binary patch
literal 18486
zcmeI!F^U2~5Jusa$rm#NgGn~<1RlUZMA$Q|M-VpIV5E=cRput`pvIlNpo{iR;h;zr
zKVMhShoAi^J)iyZ-YuWY`?E^x<=gVS|9|~>z01u~Kmi35P(T3%K1*Os(QEr%JCW$=
z$7KGtXQaRWM8N$adc0SEZb&Bd?VqOT^>wY?f1;;Pllj}8k^cG<0r!XK@m~G8A(_y(
z|2T!O|Jwa0eEMlLf7>0?Uw<Ot{t!Lht3Nj+6T0@Fhv@ZptlfX2r=JJ&w>=~M^(O-E
z57Fbj`g21vp>O{(M6dg~cK?Z<z6|DXdq(=}PXyc_qQ`sn=Z0iL-~MxsUYlII|3pte
zXY;o`BmMO!0`3pd<GuQGLo%Un|B|EEZ}t8YJ$=dMZ+k}i>rVvSAEL*5_2-6ULf`%m
D4Bcc|

literal 18486
zcmeH_u}Z^G7)B#kP()B?i&+GH0lNxLF5LuIA3<;t4CyoZ8il??q0Vkj3L0$ZZ}|xK
z6VE*)w1hu7oO^F()7$2EO^5sCa6N3Vo#uG>HLUIP&7aM^?ekfRm2cnnLVt<>_yy=c
zeq;3o`l~wQKcoNnjnx-a|9PK}^1tr$QT}K9`6&O%A6Ux2ZSujt?jF&f{!RhTk5kW|
zRsB!S^HKh%hxsV~-N$^C|LiUw<==Gq;9qx-=udyA0O!Z4=g+GC2haH^|I+27{3l&L
z%Kxg%NBOs1KKR$&Bl^?dDZu%0>iM(u_ZvEIQ2kdWAN=d?5&h}!6yW?g_54}-`wg8p
zsQ!zRkMduae3buJ$w&Er?B%2Uze_&&*WDxf)88q;`Ely`v#S5=MLx>^^C%zX|MrxR
z@_)b2NBOVj`QTr7kLXW-rvT^2sprqC{)?A<l>d63kMidk1t>rP3Q&Lo6!>oiegF~`
BPFnx~

diff --git a/dlls/mf/tests/rgb555frame.bmp b/dlls/mf/tests/rgb555frame.bmp
index 7feb1e4254cc61b1a82f4563b4db942c363e13a5..17949ce032478c44a8857256d1b703ed51a85b0f 100644
GIT binary patch
literal 18486
zcmeI$F^a-a5P;#gq?hfsut;OEC-49kB7$dFk097sL~^vfN^X)3ntGa_<qeNNLxK`!
z7``{c;Nh}AmDjajp5M!TUGI<bxqMo#_5J(H`#F!<<7b?oLD>I43+P|>7oxxZM8NqW
zdOTNuZb&M`{?nK}zQX+{d-v05|8>tufBlJo^F#D_uKwJRRA}3O?y|@4Ir#VInZ5hD
zv;Vqhq`&?|!1*D1JXe2iNGi1LKXuvTevI~??A=eD{ntGs{q-jT&JWS!x%zWMQlV}C
zen=mWX#Yvy{m|Qg-5Jwge<I-g5Ivr&KQ|;5n)WY4_SoE_{U>|(Ww8IcXQaRWM8NqW
zdOTNuZb&M$?cbN|vE4=cPxkKnV*ho|NPqo_fb&E2c&`53kW^^fKiVyPr+@+qD4>7>
I3bZKj2W=B%SpWb4

literal 18486
zcmeH_F-ikb6h%kApon0s4Neo#4VX4yWs^>@bqRuv;4rf$w-Im;fmqvFDd=EQ-{uzo
zisv6PB!o8{&imKP`AzeC=Hv5n{M_$8d(CA0HlE%8+aKHKD~AFUpa2CZKmiK;vjUqT
zAGMOzb3V#{J>-Lb-5t@N{!Rhzk5kW|RsG-Z@=^Y8kNGJ7&y#$V|I0-_%Ky9MgMZx}
z(VzZK0q&1e&!1KOKMwLy{$C{@<-aNUDF0Q-NBOTyKKR$&5&h}!6yW|i_54}-`wg8p
zsQzu25B_y`M1T4_1-L&>J%5(|enaOCs{d7&kMf^(`6&O=<)i$Mp7K%tO_vY;b$3L6
z`a1=<KTbV=R`p-r=A-=gAM#QDXUF*{|I=AM%D-*$!N2Z~=udyA0QbkK=g+GC(?4*O
r|M_7)%74-4qx^?HALZZn`QTr7NA#z^Q-J&9)bnTQ?>BVbp!)v+To6uM

diff --git a/dlls/mf/tests/transform.c b/dlls/mf/tests/transform.c
index 7e2ccb6ea6e..0c6c7b6055f 100644
--- a/dlls/mf/tests/transform.c
+++ b/dlls/mf/tests/transform.c
@@ -7680,100 +7680,116 @@ static void test_video_processor(void)
     }
     video_processor_tests[] =
     {
-        {
+        { /* Test 0 */
             .input_type_desc = nv12_default_stride, .input_bitmap = L"nv12frame.bmp",
             .output_type_desc = rgb32_default_stride, .output_bitmap = L"rgb32frame-flip.bmp",
-            .output_sample_desc = &rgb32_sample_desc, .delta = 2, /* Windows returns 0, Wine needs 2 */
+            .output_sample_desc = &rgb32_sample_desc,
+            .delta = 2, /* Windows returns 0, Wine needs 2 */
         },
-        {
+        { /* Test 1 */
             .input_type_desc = nv12_default_stride, .input_bitmap = L"nv12frame.bmp",
             .output_type_desc = rgb32_negative_stride, .output_bitmap = L"rgb32frame-flip.bmp",
-            .output_sample_desc = &rgb32_sample_desc, .delta = 2, /* Windows returns 0, Wine needs 2 */
+            .output_sample_desc = &rgb32_sample_desc,
+            .delta = 2, /* Windows returns 0, Wine needs 2 */
         },
-        {
+        { /* Test 2 */
             .input_type_desc = nv12_default_stride, .input_bitmap = L"nv12frame.bmp",
             .output_type_desc = rgb32_positive_stride, .output_bitmap = L"rgb32frame.bmp",
-            .output_sample_desc = &rgb32_sample_desc, .delta = 6,
+            .output_sample_desc = &rgb32_sample_desc,
+            .delta = 6,
         },
-        {
+        { /* Test 3 */
             .input_type_desc = rgb32_default_stride, .input_bitmap = L"rgb32frame.bmp",
             .output_type_desc = nv12_default_stride, .output_bitmap = L"nv12frame-flip.bmp",
-            .output_sample_desc = &nv12_sample_desc, .delta = 2, /* Windows returns 0, Wine needs 2 */
+            .output_sample_desc = &nv12_sample_desc,
+            .delta = 2, /* Windows returns 0, Wine needs 2 */
         },
-        {
+        { /* Test 4 */
             .input_type_desc = rgb32_negative_stride, .input_bitmap = L"rgb32frame.bmp",
             .output_type_desc = nv12_default_stride, .output_bitmap = L"nv12frame-flip.bmp",
-            .output_sample_desc = &nv12_sample_desc, .delta = 2, /* Windows returns 0, Wine needs 2 */
+            .output_sample_desc = &nv12_sample_desc,
+            .delta = 2, /* Windows returns 0, Wine needs 2 */
         },
-        {
+        { /* Test 5 */
             .input_type_desc = rgb32_positive_stride, .input_bitmap = L"rgb32frame.bmp",
             .output_type_desc = nv12_default_stride, .output_bitmap = L"nv12frame.bmp",
-            .output_sample_desc = &nv12_sample_desc, .delta = 2, /* Windows returns 1, Wine needs 2 */
+            .output_sample_desc = &nv12_sample_desc,
+            .delta = 2, /* Windows returns 1, Wine needs 2 */
         },
-        {
+        { /* Test 6 */
             .input_type_desc = rgb32_negative_stride, .input_bitmap = L"rgb32frame.bmp",
             .output_type_desc = rgb32_negative_stride, .output_bitmap = L"rgb32frame.bmp",
             .output_sample_desc = &rgb32_sample_desc,
         },
-        {
+        { /* Test 7 */
             .input_type_desc = rgb32_negative_stride, .input_bitmap = L"rgb32frame.bmp",
             .output_type_desc = rgb32_positive_stride, .output_bitmap = L"rgb32frame-flip.bmp",
-            .output_sample_desc = &rgb32_sample_desc, .delta = 3, /* Windows returns 3 */
+            .output_sample_desc = &rgb32_sample_desc,
+            .delta = 3, /* Windows returns 3 */
         },
-        {
+        { /* Test 8 */
             .input_type_desc = rgb32_positive_stride, .input_bitmap = L"rgb32frame.bmp",
             .output_type_desc = rgb32_negative_stride, .output_bitmap = L"rgb32frame-flip.bmp",
-            .output_sample_desc = &rgb32_sample_desc, .delta = 3, /* Windows returns 3 */
+            .output_sample_desc = &rgb32_sample_desc,
+            .delta = 3, /* Windows returns 3 */
         },
-        {
+        { /* Test 9 */
             .input_type_desc = rgb32_positive_stride, .input_bitmap = L"rgb32frame.bmp",
             .output_type_desc = rgb32_positive_stride, .output_bitmap = L"rgb32frame.bmp",
             .output_sample_desc = &rgb32_sample_desc,
         },
-        {
+        { /* Test 10 */
             .input_type_desc = rgb32_with_aperture, .input_bitmap = L"rgb32frame.bmp",
             .output_type_desc = rgb32_with_aperture, .output_bitmap = L"rgb32frame.bmp",
-            .output_sample_desc = &rgb32_sample_desc, .broken = TRUE /* old Windows version incorrectly rescale */
+            .output_sample_desc = &rgb32_sample_desc,
+            .broken = TRUE, /* old Windows version incorrectly rescale */
         },
-        {
+        { /* Test 11 */
             .input_type_desc = rgb32_default_stride, .input_bitmap = L"rgb32frame.bmp",
             .output_type_desc = rgb555_default_stride, .output_bitmap = L"rgb555frame.bmp",
             .output_sample_desc = &rgb555_sample_desc,
+            .delta = 5, /* Windows returns 0, Wine needs 5 */
         },
-        {
+        { /* Test 12 */
             .input_type_desc = rgb32_default_stride, .input_bitmap = L"rgb32frame.bmp",
             .output_type_desc = rgb555_negative_stride, .output_bitmap = L"rgb555frame.bmp",
             .output_sample_desc = &rgb555_sample_desc,
+            .delta = 5, /* Windows returns 0, Wine needs 5 */
         },
-        {
+        { /* Test 13 */
             .input_type_desc = rgb32_default_stride, .input_bitmap = L"rgb32frame.bmp",
             .output_type_desc = rgb555_positive_stride, .output_bitmap = L"rgb555frame-flip.bmp",
-            .output_sample_desc = &rgb555_sample_desc, .delta = 3, /* Windows returns 0, Wine needs 3 */
+            .output_sample_desc = &rgb555_sample_desc,
+            .delta = 3, /* Windows returns 0, Wine needs 3 */
         },
-        {
+        { /* Test 14 */
             .input_type_desc = rgb555_default_stride, .input_bitmap = L"rgb555frame.bmp",
             .output_type_desc = rgb555_positive_stride, .output_bitmap = L"rgb555frame-flip.bmp",
-            .output_sample_desc = &rgb555_sample_desc, .delta = 4, /* Windows returns 0, Wine needs 4 */
+            .output_sample_desc = &rgb555_sample_desc,
+            .delta = 4, /* Windows returns 0, Wine needs 4 */
         },
-        {
+        { /* Test 15 */
             .input_type_desc = nv12_with_aperture, .input_bitmap = L"nv12frame.bmp",
             .output_type_desc = rgb32_no_aperture, .output_bitmap = L"rgb32frame-crop-flip.bmp",
-            .output_sample_desc = &rgb32_crop_sample_desc, .delta = 2, /* Windows returns 0, Wine needs 2 */
+            .output_sample_desc = &rgb32_crop_sample_desc,
+            .delta = 2, /* Windows returns 0, Wine needs 2 */
         },
-        {
+        { /* Test 16 */
             .input_type_desc = rgb32_no_aperture, .input_bitmap = L"rgb32frame-crop-flip.bmp",
             .output_type_desc = rgb32_with_aperture, .output_bitmap = L"rgb32frame-flip.bmp",
-            .output_sample_desc = &rgb32_sample_desc, .broken = TRUE /* old Windows version incorrectly rescale */
+            .output_sample_desc = &rgb32_sample_desc,
+            .broken = TRUE, /* old Windows version incorrectly rescale */
         },
-        {
+        { /* Test 17 */
             .input_type_desc = rgb32_with_aperture, .input_bitmap = L"rgb32frame-flip.bmp",
             .output_type_desc = rgb32_no_aperture, .output_bitmap = L"rgb32frame-crop-flip.bmp",
             .output_sample_desc = &rgb32_crop_sample_desc,
         },
-        {
+        { /* Test 18 */
             .input_type_desc = rgb32_with_aperture_positive_stride, .input_bitmap = L"rgb32frame.bmp",
             .output_type_desc = rgb32_no_aperture, .output_bitmap = L"rgb32frame-crop-flip.bmp",
-            .output_sample_desc = &rgb32_crop_sample_desc, .delta = 3, /* Windows returns 3 */
+            .output_sample_desc = &rgb32_crop_sample_desc,
+            .delta = 3, /* Windows returns 3 */
         },
     };

[PATCH v4 4/6] mf/tests: Test video processor with 2D buffers.

[Brendan McGrath]

From: Brendan McGrath

---
 dlls/mf/tests/transform.c | 110 ++++++++++++++++++++++++++++++++++----
 1 file changed, 99 insertions(+), 11 deletions(-)

diff --git a/dlls/mf/tests/transform.c b/dlls/mf/tests/transform.c
index 0c6c7b6055f..7603d56f6ee 100644
--- a/dlls/mf/tests/transform.c
+++ b/dlls/mf/tests/transform.c
@@ -2017,26 +2017,56 @@ static void test_sample_copier_output_processing(void)
     ok(ref == 0, "Release returned %ld\n", ref);
 }

-static IMFSample *create_sample(const BYTE *data, ULONG size)
+#define create_sample(a, b) create_sample_(a, b, NULL)
+static IMFSample *create_sample_(const BYTE *data, ULONG size, const struct attribute_desc *desc)
 {
     IMFMediaBuffer *media_buffer;
+    IMFMediaType *media_type;
+    IMF2DBuffer2 *buffer2d2;
+    BYTE *buffer, *scanline;
     IMFSample *sample;
     DWORD length;
-    BYTE *buffer;
+    LONG stride;
     HRESULT hr;
     ULONG ret;

hr = MFCreateSample(&sample);
     ok(hr == S_OK, "MFCreateSample returned %#lx\n", hr);
-    hr = MFCreateMemoryBuffer(size, &media_buffer);
-    ok(hr == S_OK, "MFCreateMemoryBuffer returned %#lx\n", hr);
+
+    if (!desc)
+    {
+        hr = MFCreateMemoryBuffer(size, &media_buffer);
+        ok(hr == S_OK, "MFCreateMemoryBuffer returned %#lx\n", hr);
+    }
+    else
+    {
+        hr = MFCreateMediaType(&media_type);
+        ok(hr == S_OK, "Failed to create media type, hr %#lx.\n", hr);
+        init_media_type(media_type, desc, -1);
+        hr = MFCreateMediaBufferFromMediaType(media_type, 0, 0, 0, &media_buffer);
+        ok(hr == S_OK, "MFCreateMediaBufferFromMediaType returned %#lx\n", hr);
+        IMFMediaType_Release(media_type);
+    }
+
     hr = IMFMediaBuffer_Lock(media_buffer, &buffer, NULL, &length);
     ok(hr == S_OK, "Lock returned %#lx\n", hr);
-    ok(length == 0, "got length %lu\n", length);
+    if (!desc) ok(length == 0, "got length %lu\n", length);
     if (!data) memset(buffer, 0xcd, size);
     else memcpy(buffer, data, size);
     hr = IMFMediaBuffer_Unlock(media_buffer);
     ok(hr == S_OK, "Unlock returned %#lx\n", hr);
+
+    if (SUCCEEDED(hr = IMFMediaBuffer_QueryInterface(media_buffer, &IID_IMF2DBuffer2, (void**)&buffer2d2)))
+    {
+        ok(hr == S_OK, "QueryInterface IMF2DBuffer2 returned %#lx\n", hr);
+        hr = IMF2DBuffer2_Lock2DSize(buffer2d2, MF2DBuffer_LockFlags_Write, &scanline, &stride, &buffer, &length);
+        ok(hr == S_OK, "Lock2D returned %#lx\n", hr);
+        if (!data) memset(buffer, 0xcd, length);
+        hr = IMF2DBuffer2_Unlock2D(buffer2d2);
+        ok(hr == S_OK, "Unlock2D returned %#lx\n", hr);
+        IMF2DBuffer2_Release(buffer2d2);
+    }
+
     hr = IMFMediaBuffer_SetCurrentLength(media_buffer, data ? size : 0);
     ok(hr == S_OK, "SetCurrentLength returned %#lx\n", hr);
     hr = IMFSample_AddBuffer(sample, media_buffer);
@@ -7379,7 +7409,7 @@ failed:
     CoUninitialize();
 }

-static void test_video_processor(void)
+static void test_video_processor(BOOL use_2d_buffer)
 {
     const GUID *const class_id = &CLSID_VideoProcessorMFT;
     const struct transform_info expect_mft_info =
@@ -7520,6 +7550,15 @@ static void test_video_processor(void)
         ATTR_BLOB(MF_MT_MINIMUM_DISPLAY_APERTURE, &actual_aperture, 16),
         {0},
     };
+    const struct attribute_desc rgb32_with_aperture_negative_stride[] =
+    {
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video, .required = TRUE),
+        ATTR_GUID(MF_MT_SUBTYPE, MFVideoFormat_RGB32, .required = TRUE),
+        ATTR_RATIO(MF_MT_FRAME_SIZE, actual_width, actual_height, .required = TRUE),
+        ATTR_BLOB(MF_MT_MINIMUM_DISPLAY_APERTURE, &actual_aperture, 16),
+        ATTR_UINT32(MF_MT_DEFAULT_STRIDE, -actual_width * 4),
+        {0},
+    };
     const struct attribute_desc rgb32_with_aperture_positive_stride[] =
     {
         ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video, .required = TRUE),
@@ -7606,6 +7645,14 @@ static void test_video_processor(void)
         ATTR_RATIO(MF_MT_FRAME_SIZE, 82, 84, .required = TRUE),
         {0},
     };
+    const struct attribute_desc rgb32_no_aperture_negative_stride[] =
+    {
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video, .required = TRUE),
+        ATTR_GUID(MF_MT_SUBTYPE, MFVideoFormat_RGB32, .required = TRUE),
+        ATTR_RATIO(MF_MT_FRAME_SIZE, 82, 84, .required = TRUE),
+        ATTR_UINT32(MF_MT_DEFAULT_STRIDE, -82 * 4),
+        {0},
+    };
     const MFT_OUTPUT_STREAM_INFO initial_output_info = {0};
     const MFT_INPUT_STREAM_INFO initial_input_info = {0};
     MFT_OUTPUT_STREAM_INFO output_info = {0};
@@ -7671,8 +7718,10 @@ static void test_video_processor(void)
     const struct transform_desc
     {
         const struct attribute_desc *input_type_desc;
+        const struct attribute_desc *input_buffer_desc;
         const WCHAR *input_bitmap;
         const struct attribute_desc *output_type_desc;
+        const struct attribute_desc *output_buffer_desc;
         const struct sample_desc *output_sample_desc;
         const WCHAR *output_bitmap;
         ULONG delta;
@@ -7682,112 +7731,150 @@ static void test_video_processor(void)
     {
         { /* Test 0 */
             .input_type_desc = nv12_default_stride, .input_bitmap = L"nv12frame.bmp",
+            .input_buffer_desc = use_2d_buffer ? nv12_default_stride : NULL,
             .output_type_desc = rgb32_default_stride, .output_bitmap = L"rgb32frame-flip.bmp",
+            .output_buffer_desc = use_2d_buffer ? rgb32_negative_stride : NULL,
             .output_sample_desc = &rgb32_sample_desc,
             .delta = 2, /* Windows returns 0, Wine needs 2 */
         },
         { /* Test 1 */
             .input_type_desc = nv12_default_stride, .input_bitmap = L"nv12frame.bmp",
+            .input_buffer_desc = use_2d_buffer ? nv12_default_stride : NULL,
             .output_type_desc = rgb32_negative_stride, .output_bitmap = L"rgb32frame-flip.bmp",
+            .output_buffer_desc = use_2d_buffer ? rgb32_negative_stride : NULL,
             .output_sample_desc = &rgb32_sample_desc,
             .delta = 2, /* Windows returns 0, Wine needs 2 */
         },
         { /* Test 2 */
             .input_type_desc = nv12_default_stride, .input_bitmap = L"nv12frame.bmp",
+            .input_buffer_desc = use_2d_buffer ? nv12_default_stride : NULL,
             .output_type_desc = rgb32_positive_stride, .output_bitmap = L"rgb32frame.bmp",
+            .output_buffer_desc = use_2d_buffer ? rgb32_positive_stride : NULL,
             .output_sample_desc = &rgb32_sample_desc,
             .delta = 6,
         },
         { /* Test 3 */
             .input_type_desc = rgb32_default_stride, .input_bitmap = L"rgb32frame.bmp",
+            .input_buffer_desc = use_2d_buffer ? rgb32_negative_stride : NULL,
             .output_type_desc = nv12_default_stride, .output_bitmap = L"nv12frame-flip.bmp",
+            .output_buffer_desc = use_2d_buffer ? nv12_default_stride : NULL,
             .output_sample_desc = &nv12_sample_desc,
             .delta = 2, /* Windows returns 0, Wine needs 2 */
         },
         { /* Test 4 */
             .input_type_desc = rgb32_negative_stride, .input_bitmap = L"rgb32frame.bmp",
+            .input_buffer_desc = use_2d_buffer ? rgb32_negative_stride : NULL,
             .output_type_desc = nv12_default_stride, .output_bitmap = L"nv12frame-flip.bmp",
+            .output_buffer_desc = use_2d_buffer ? nv12_default_stride : NULL,
             .output_sample_desc = &nv12_sample_desc,
             .delta = 2, /* Windows returns 0, Wine needs 2 */
         },
         { /* Test 5 */
             .input_type_desc = rgb32_positive_stride, .input_bitmap = L"rgb32frame.bmp",
+            .input_buffer_desc = use_2d_buffer ? rgb32_positive_stride : NULL,
             .output_type_desc = nv12_default_stride, .output_bitmap = L"nv12frame.bmp",
+            .output_buffer_desc = use_2d_buffer ? nv12_default_stride : NULL,
             .output_sample_desc = &nv12_sample_desc,
             .delta = 2, /* Windows returns 1, Wine needs 2 */
         },
         { /* Test 6 */
             .input_type_desc = rgb32_negative_stride, .input_bitmap = L"rgb32frame.bmp",
+            .input_buffer_desc = use_2d_buffer ? rgb32_negative_stride : NULL,
             .output_type_desc = rgb32_negative_stride, .output_bitmap = L"rgb32frame.bmp",
+            .output_buffer_desc = use_2d_buffer ? rgb32_negative_stride : NULL,
             .output_sample_desc = &rgb32_sample_desc,
         },
         { /* Test 7 */
             .input_type_desc = rgb32_negative_stride, .input_bitmap = L"rgb32frame.bmp",
+            .input_buffer_desc = use_2d_buffer ? rgb32_negative_stride : NULL,
             .output_type_desc = rgb32_positive_stride, .output_bitmap = L"rgb32frame-flip.bmp",
+            .output_buffer_desc = use_2d_buffer ? rgb32_positive_stride : NULL,
             .output_sample_desc = &rgb32_sample_desc,
             .delta = 3, /* Windows returns 3 */
         },
         { /* Test 8 */
             .input_type_desc = rgb32_positive_stride, .input_bitmap = L"rgb32frame.bmp",
+            .input_buffer_desc = use_2d_buffer ? rgb32_positive_stride : NULL,
             .output_type_desc = rgb32_negative_stride, .output_bitmap = L"rgb32frame-flip.bmp",
+            .output_buffer_desc = use_2d_buffer ? rgb32_negative_stride : NULL,
             .output_sample_desc = &rgb32_sample_desc,
             .delta = 3, /* Windows returns 3 */
         },
         { /* Test 9 */
             .input_type_desc = rgb32_positive_stride, .input_bitmap = L"rgb32frame.bmp",
+            .input_buffer_desc = use_2d_buffer ? rgb32_positive_stride : NULL,
             .output_type_desc = rgb32_positive_stride, .output_bitmap = L"rgb32frame.bmp",
+            .output_buffer_desc = use_2d_buffer ? rgb32_positive_stride : NULL,
             .output_sample_desc = &rgb32_sample_desc,
         },
         { /* Test 10 */
             .input_type_desc = rgb32_with_aperture, .input_bitmap = L"rgb32frame.bmp",
+            .input_buffer_desc = use_2d_buffer ? rgb32_with_aperture : NULL,
             .output_type_desc = rgb32_with_aperture, .output_bitmap = L"rgb32frame.bmp",
+            .output_buffer_desc = use_2d_buffer ? rgb32_with_aperture : NULL,
             .output_sample_desc = &rgb32_sample_desc,
             .broken = TRUE, /* old Windows version incorrectly rescale */
         },
         { /* Test 11 */
             .input_type_desc = rgb32_default_stride, .input_bitmap = L"rgb32frame.bmp",
+            .input_buffer_desc = use_2d_buffer ? rgb32_negative_stride : NULL,
             .output_type_desc = rgb555_default_stride, .output_bitmap = L"rgb555frame.bmp",
+            .output_buffer_desc = use_2d_buffer ? rgb555_negative_stride : NULL,
             .output_sample_desc = &rgb555_sample_desc,
             .delta = 5, /* Windows returns 0, Wine needs 5 */
         },
         { /* Test 12 */
             .input_type_desc = rgb32_default_stride, .input_bitmap = L"rgb32frame.bmp",
+            .input_buffer_desc = use_2d_buffer ? rgb32_negative_stride : NULL,
             .output_type_desc = rgb555_negative_stride, .output_bitmap = L"rgb555frame.bmp",
+            .output_buffer_desc = use_2d_buffer ? rgb555_negative_stride : NULL,
             .output_sample_desc = &rgb555_sample_desc,
             .delta = 5, /* Windows returns 0, Wine needs 5 */
         },
         { /* Test 13 */
             .input_type_desc = rgb32_default_stride, .input_bitmap = L"rgb32frame.bmp",
+            .input_buffer_desc = use_2d_buffer ? rgb32_negative_stride : NULL,
             .output_type_desc = rgb555_positive_stride, .output_bitmap = L"rgb555frame-flip.bmp",
+            .output_buffer_desc = use_2d_buffer ? rgb555_positive_stride : NULL,
             .output_sample_desc = &rgb555_sample_desc,
             .delta = 3, /* Windows returns 0, Wine needs 3 */
         },
         { /* Test 14 */
             .input_type_desc = rgb555_default_stride, .input_bitmap = L"rgb555frame.bmp",
+            .input_buffer_desc = use_2d_buffer ? rgb555_negative_stride : NULL,
             .output_type_desc = rgb555_positive_stride, .output_bitmap = L"rgb555frame-flip.bmp",
+            .output_buffer_desc = use_2d_buffer ? rgb555_positive_stride : NULL,
             .output_sample_desc = &rgb555_sample_desc,
             .delta = 4, /* Windows returns 0, Wine needs 4 */
         },
         { /* Test 15 */
             .input_type_desc = nv12_with_aperture, .input_bitmap = L"nv12frame.bmp",
+            .input_buffer_desc = use_2d_buffer ? nv12_with_aperture : NULL,
             .output_type_desc = rgb32_no_aperture, .output_bitmap = L"rgb32frame-crop-flip.bmp",
+            .output_buffer_desc = use_2d_buffer ? rgb32_no_aperture_negative_stride : NULL,
             .output_sample_desc = &rgb32_crop_sample_desc,
             .delta = 2, /* Windows returns 0, Wine needs 2 */
         },
         { /* Test 16 */
             .input_type_desc = rgb32_no_aperture, .input_bitmap = L"rgb32frame-crop-flip.bmp",
+            .input_buffer_desc = use_2d_buffer ? rgb32_no_aperture : NULL,
             .output_type_desc = rgb32_with_aperture, .output_bitmap = L"rgb32frame-flip.bmp",
+            .output_buffer_desc = use_2d_buffer ? rgb32_with_aperture : NULL,
             .output_sample_desc = &rgb32_sample_desc,
             .broken = TRUE, /* old Windows version incorrectly rescale */
         },
         { /* Test 17 */
             .input_type_desc = rgb32_with_aperture, .input_bitmap = L"rgb32frame-flip.bmp",
+            .input_buffer_desc = use_2d_buffer ? rgb32_with_aperture_negative_stride : NULL,
             .output_type_desc = rgb32_no_aperture, .output_bitmap = L"rgb32frame-crop-flip.bmp",
+            .output_buffer_desc = use_2d_buffer ? rgb32_no_aperture_negative_stride : NULL,
             .output_sample_desc = &rgb32_crop_sample_desc,
         },
         { /* Test 18 */
             .input_type_desc = rgb32_with_aperture_positive_stride, .input_bitmap = L"rgb32frame.bmp",
+            .input_buffer_desc = use_2d_buffer ? rgb32_with_aperture_positive_stride : NULL,
             .output_type_desc = rgb32_no_aperture, .output_bitmap = L"rgb32frame-crop-flip.bmp",
+            .output_buffer_desc = use_2d_buffer ? rgb32_no_aperture_negative_stride : NULL,
             .output_sample_desc = &rgb32_crop_sample_desc,
             .delta = 3, /* Windows returns 3 */
         },
@@ -7813,7 +7900,7 @@ static void test_video_processor(void)
     hr = CoInitialize(NULL);
     ok(hr == S_OK, "Failed to initialize, hr %#lx.\n", hr);

-    winetest_push_context("videoproc");
+    winetest_push_context("videoproc %s", use_2d_buffer ? "2d" : "1d");

if (!check_mft_enum(MFT_CATEGORY_VIDEO_PROCESSOR, &input_type, &output_type, class_id))
         goto failed;
@@ -8192,7 +8279,7 @@ static void test_video_processor(void)
         ok(input_data_len == input_info.cbSize, "got length %lu\n", input_data_len);
         input_data += length;

-        input_sample = create_sample(input_data, input_data_len);
+        input_sample = create_sample_(input_data, input_data_len, test->input_buffer_desc);
         hr = IMFSample_SetSampleTime(input_sample, 0);
         ok(hr == S_OK, "SetSampleTime returned %#lx\n", hr);
         hr = IMFSample_SetSampleDuration(input_sample, 10000000);
@@ -8209,7 +8296,7 @@ static void test_video_processor(void)
         hr = MFCreateCollection(&output_samples);
         ok(hr == S_OK, "MFCreateCollection returned %#lx\n", hr);

-        output_sample = create_sample(NULL, output_info.cbSize);
+        output_sample = create_sample_(NULL, output_info.cbSize, test->output_buffer_desc);
         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);
@@ -8230,7 +8317,7 @@ static void test_video_processor(void)
             ok(ret <= test->delta || broken(test->broken), "got %lu%% diff\n", ret);
             IMFCollection_Release(output_samples);

-            output_sample = create_sample(NULL, output_info.cbSize);
+            output_sample = create_sample_(NULL, output_info.cbSize, test->output_buffer_desc);
             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_status == 0, "got output[0].dwStatus %#lx\n", output_status);
@@ -9763,7 +9850,8 @@ START_TEST(transform)
     test_wmv_decoder_media_object();
     test_audio_convert();
     test_color_convert();
-    test_video_processor();
+    test_video_processor(FALSE);
+    test_video_processor(TRUE);
     test_mp3_decoder();
     test_iv50_encoder();
     test_iv50_decoder();

[PATCH v4 5/6] mf/tests: Test 1D/2D output on 2D buffers.

[Brendan McGrath]

From: Brendan McGrath

---
 dlls/mf/tests/mf_test.h                   |   4 +-
 dlls/mf/tests/nv12frame-2d.bmp            | Bin 0 -> 67638 bytes
 dlls/mf/tests/nv12frame-flip-2d.bmp       | Bin 0 -> 67638 bytes
 dlls/mf/tests/resource.rc                 |  16 ++
 dlls/mf/tests/rgb32frame-crop-flip-2d.bmp | Bin 0 -> 32310 bytes
 dlls/mf/tests/rgb32frame-flip-2d.bmp      | Bin 0 -> 36918 bytes
 dlls/mf/tests/transform.c                 | 237 ++++++++++++++++++----
 7 files changed, 210 insertions(+), 47 deletions(-)
 create mode 100644 dlls/mf/tests/nv12frame-2d.bmp
 create mode 100644 dlls/mf/tests/nv12frame-flip-2d.bmp
 create mode 100644 dlls/mf/tests/rgb32frame-crop-flip-2d.bmp
 create mode 100644 dlls/mf/tests/rgb32frame-flip-2d.bmp

diff --git a/dlls/mf/tests/mf_test.h b/dlls/mf/tests/mf_test.h
index 9fa5d4fef41..f118e921b11 100644
--- a/dlls/mf/tests/mf_test.h
+++ b/dlls/mf/tests/mf_test.h
@@ -114,6 +114,6 @@ struct sample_desc
     BOOL todo_time;
 };

-#define check_mf_sample_collection(a, b, c) check_mf_sample_collection_(__FILE__, __LINE__, a, b, c)
+#define check_mf_sample_collection(a, b, c) check_mf_sample_collection_(__FILE__, __LINE__, a, b, c, FALSE)
 extern DWORD check_mf_sample_collection_(const char *file, int line, IMFCollection *samples,
-        const struct sample_desc *expect_samples, const WCHAR *expect_data_filename);
+        const struct sample_desc *expect_samples, const WCHAR *expect_data_filename, BOOL use_2d_buffer);
diff --git a/dlls/mf/tests/nv12frame-2d.bmp b/dlls/mf/tests/nv12frame-2d.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..3f3670aa7e2ce632cfc4ceeec506d049eaf30fa4
GIT binary patch
literal 67638
zcmeI0u}<Sa5Qe!o@FSd3U0#5QlB1@epoxTZHApF`-66`*@B{=!De?+bNI}{LQBkBp
zR4L#M_SRJ6W>?9M<=FGBHIb#`@@N0=pYh6nPY<6Ce%4|5{1d7S^)J+~gWusZtf!yP
z+Q+6WJ(c0X&8>e6wRl+WRL(iyX2Cv#ebqbgw>>}L4}a#r-3-wGcG>g%x6K~@@Mr$p
z&H()3&-veO2Izmg?0azjdoAufmEpn3y?+kX)%X9f&tPBm4*YG;5BS5M`ENG^^uJy9
zJpXO8hd=z8|F$y#fB19$x0?a_-!A(eod4#t!c!R@JRbX5sII>MhkXY7s(0XTdw#$l
z{>*>78KD2|vgi44n?3yD&-}NY0r<n8^S|8;(EoPX_u%|D9SuB{;lahJpN8t{`+wMH
zu&;Ut{<h}_{Nd01x0?a_-!6Ne|F+q~AO6gL+ZljA{5k*I%>eyxmwgY;e^;xur!qWv
zdH0v0y88Yf_8IJ}-hsdE`2m0UGym;ofd043p69=9_V9;4^WSy`;17S!|8_G#|J!BX
zgY)0n_{&on9$bI=^H5!V{}1~N_Eqn|-}d}~Km3{hb~8Z#+hx!5-!^;r!=L$YI|J~C
zKj(kD8KD2|vhTt9Z}>g&RE7s1r9TSQ)%X9f&tPBm4*YG;5BS5M`ENG^^uJy9JpXO8
zhd=z8|F$y#fB19$x0?a_-!A(eod0%xZ_WQ(?)=VQdgq+;ZI=8k-0Lvi#>Y0<SK8bB
zR{mB$AMn@rv`aaKKm6OwK$m)@kH57|_LX)YJ?+w-;LrSTGXq`fl|KH~HrX@(+n+t~
zZ=XS%a|QnJZ!-fM?e(^(t+2P~(w5(#kN?7fX!ycEl0Rh!=s%IZ#bV#{_o}^~Yuium
zUt9ha{ThH&{_tPf0rE%wgaiBDe{=0M6PpjWsr_rq&(W^|!2h@d<WJcF`ma;{H&tJ?
z?I-8Iy8IM<=|Ft?Ifwt+4oLUY=O1nLDfzDfApda(uC&)>&Hm*4*OtFRzXl*q-#PqO
zc7XhmKjFZ>_urZJIv1M{x2gSW%b%fN1AzZ=2gskY1N2{~`fsScj%wRa&VOzBA^J4{
z@#*Ir{wq5`{>YzjVBh;s{M1HnQ~Pg3RD3D=aR-D|joil7oohr?d@1^I2ZU9P+{V@6
z--zkrOH=-r%IoI#VJR>4;|?g>U*f+^-@`KQzH`N$?samHzH|Wp;|}PiuejSbf3rgO
zdOVi&)BUHbJ}c12f9XKH`<xpMbgzq3sh-ZiuKH+zKK@GwQu$x4b+4Cqsh-ZiuKH??
zKK@GwQu!Z$>0Z~LQazo2UG?!7`uHy$Nag=~qI-RmQazo2UG?t?`uHy$NabJtZ4>wC
W#~o<GbNQWdb?4;YHgUi2`u_ny&%5*h

literal 0
HcmV?d00001

diff --git a/dlls/mf/tests/nv12frame-flip-2d.bmp b/dlls/mf/tests/nv12frame-flip-2d.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..4fffacd51030977b35846210a4a2a0ca04a943fb
GIT binary patch
literal 67638
zcmeI0u}&i~6h+xT$S15)Ek6LFWT{h7&>$gEgG5O^9imJczJQ=81;0Rr1d<y>ML~n8
zQotX0Jydoxmew!wOzyGuM(J*R&wX#K`8(Np*!o#J;rS<26Y4b7udUzV8P>zkGkGj;
z?>$w|1LvHtS+K9izV*H)`&JwN@FxTHGC=>=^S%$chd=ylW}pu}p!^?dvTwDOz3;=>
z;m`c9nSnm^fbxH+$)5RNfA+w?K7*R`r#AoX?+Z^Ac<|Bqy-@#~A@~<~--qnNUweMQ
zAO6gL-3-wGy6oHg2mImB{MXF@{jbZO`LE3${_to1YiD5K{11=6JXPSq<)=RiHPr9_
zurFZW_742D=Lh`Z&-~ZT0R6Aap7*~td-%hj`LCS;_`{$3zitNTe_i$)aQ{1hdiPX;
z2hVT*EYwiH|HHn3ecL<m*Pb8nhd=XQHv{y)E_>ep+U(&Ef9Ah-2H+2W?*F<Op#OE*
zZ@~R;x;yq%fd?lOKMgh1@BgqbVBhu*{I%x?{Nd01*UbR^ugjkIzczdL!=L%DodNj6
zpZmXV2IzlX_8V~jTg*qED)8WL-_Ju0_4_~U3)r{41Ap!L0e|>2|8+A!|Ld~n{jbd)
z{_to1Yi9ud@aO)on*sV?m;DCZ|6WEjPZfA@aN{3C4fXp!><iepy#s&k`2m0UGyion
zK>zEq=l!qE9{%uW{%dCd{_yAiubTn-Uzhy`-2YZh<Ea7<uCD!SsG)xUhkXJ2ws+vK
zJwM<Nf9Ah#2IzlX_PqbK*~1_H%zy0+z#snH|8+A!|Ld~ffcxKa&C6xhn&p=nd58Xb
z9l-x?2iEKUlKgkuFW>*$)@v_KbjE&XEx(O^0s#NJ9Uy<k4$yyt>c2zlb(9=Gd;hSO
zKSVzP&^`T}!+&E3$RGKO9O!%hom;Q7=<wlZ?)=vB=jbN@@W0yu@@MP-{Wqxoo0_lW
z_}TeyE<Z&-cA$IuIfwt&4#e)~??2Y+Q}UkxAphMCEUec&u|GTit>qW!Cjh$XJBR<q
z4v;_c7dg=P{(G@rkI~`7&)oT~<zLWG0N{VO1LV)x0s3!H{kO7SugUSV^WR#2g?<8{
zd-^$t|HclGKk^qj(D(kky<hLnoqxURxA*9GJD~3W_l52LXi`VJ-FMDb{rdua{Er>T
z<?r~*c3*zR>iPL=tA6~2KK{oJ<nsUYZo8k~V)cCfZPlON(Z~PTfn5G~$F}=q607I)
zZ>zpLMj!uU2XgtJk8JndeypC)zpeUwgg*Yq4&?Gbn%VAyn^--ce_Qp@41N5M9mwUs
WF<w{Kv3frL#_|pN_#Zov%l|*U>bvv+

literal 0
HcmV?d00001

diff --git a/dlls/mf/tests/resource.rc b/dlls/mf/tests/resource.rc
index 6c9a6601c24..8eb147c90e6 100644
--- a/dlls/mf/tests/resource.rc
+++ b/dlls/mf/tests/resource.rc
@@ -85,6 +85,10 @@ h264data-2.bin RCDATA h264data-2.bin
 /* @makedep: nv12frame.bmp */
 nv12frame.bmp RCDATA nv12frame.bmp

+/* Generated from running the tests on Windows */
+/* @makedep: nv12frame-2d.bmp */
+nv12frame-2d.bmp RCDATA nv12frame-2d.bmp
+
 /* Generated from running the tests on Windows */
 /* @makedep: nv12frame-grabber.bmp */
 nv12frame-grabber.bmp RCDATA nv12frame-grabber.bmp
@@ -93,6 +97,10 @@ nv12frame-grabber.bmp RCDATA nv12frame-grabber.bmp
 /* @makedep: nv12frame-flip.bmp */
 nv12frame-flip.bmp RCDATA nv12frame-flip.bmp

+/* Generated from running the tests on Windows */
+/* @makedep: nv12frame-flip-2d.bmp */
+nv12frame-flip-2d.bmp RCDATA nv12frame-flip-2d.bmp
+
 /* Generated from running the tests on Windows */
 /* @makedep: i420frame.bmp */
 i420frame.bmp RCDATA i420frame.bmp
@@ -105,6 +113,10 @@ rgb32frame.bmp RCDATA rgb32frame.bmp
 /* @makedep: rgb32frame-flip.bmp */
 rgb32frame-flip.bmp RCDATA rgb32frame-flip.bmp

+/* Generated from running the tests on Windows */
+/* @makedep: rgb32frame-flip-2d.bmp */
+rgb32frame-flip-2d.bmp RCDATA rgb32frame-flip-2d.bmp
+
 /* Generated from running the tests on Windows */
 /* @makedep: rgb32frame-crop.bmp */
 rgb32frame-crop.bmp RCDATA rgb32frame-crop.bmp
@@ -113,6 +125,10 @@ rgb32frame-crop.bmp RCDATA rgb32frame-crop.bmp
 /* @makedep: rgb32frame-crop-flip.bmp */
 rgb32frame-crop-flip.bmp RCDATA rgb32frame-crop-flip.bmp

+/* Generated from running the tests on Windows */
+/* @makedep: rgb32frame-crop-flip-2d.bmp */
+rgb32frame-crop-flip-2d.bmp RCDATA rgb32frame-crop-flip-2d.bmp
+
 /* Generated from running the tests on Windows */
 /* @makedep: abgr32frame-crop.bmp */
 abgr32frame-crop.bmp RCDATA abgr32frame-crop.bmp
diff --git a/dlls/mf/tests/rgb32frame-crop-flip-2d.bmp b/dlls/mf/tests/rgb32frame-crop-flip-2d.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..53592995484a8ae67426dacdecfb612a89527adf
GIT binary patch
literal 32310
zcmeI4y-fo_5Jtxdbr8A&7eEXd1-J)taw<SbbU+bE<OJl7+yM=End7KnzLkbg_g31I
zENeXDchBR~_~+*C@EE`AkjH)QWA6LhySUC{uD|=&8|!gI47SGL6u0BExL~ibU--da
zXQ+4xfA}l@xX0o@{<}M@)Q|u8ulVC0i~soV?yyon{`>kLamiE9Rv0|Qxjg?-@)Emx
z3;*8NFZ|)Z<z9sU_>cd!55Ts}ZPs(A|ImMCx#ajb_>cdN-p;C7@&A&eE4Id9Tz!}4
zKd{%>FZ|%IGgLf;Kl~Mc++*<{|J@x{>c@ZlSNw60#ee*FcUY+(|9$=6jTmf=!OQDY
zdHw@?js3z8{yIa&L-@mA@y9(D|MB15VWocj$A85i_gMVLe|LwK`tje_|NQfx`~n4A
zV(|7{p8rUBId7}G@b7&M!yo=z?nU^I|M*|}0T|am6Ry4KKlC5^5B;ah0s4<^|C#Xa
z(`DVi$@~5>%JU!i>sNsA*BL4v!XN&MKkl*kkN@rtEA`_){ww~t$KpT!yF0AZkN>{@
z=irK^68Ngmf7H~(Cjt2PY5;%u_Y&yMj{orQCD5B4|KZ<Dpf@}I!@rk6Z+85*<^Kcu
COpmqz

literal 0
HcmV?d00001

diff --git a/dlls/mf/tests/rgb32frame-flip-2d.bmp b/dlls/mf/tests/rgb32frame-flip-2d.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..8b5235b2ff12b40de19ef56fc8b88ec643af6eb6
GIT binary patch
literal 36918
zcmeI&(M`iJ6oyfE6CRm>0eEKzMq;t9)Zma#@Y|B>%ZcO)gf6bX9931-&##Z4_IG{s
z$M?RzpX=7%`cM6O{{8ypdOTV?tnmi-@X~&~{n;?gf7f6C3I_O}<2bdTzy7J63UmDP
zU%_#D2LAa^?NpfKe^39dJvu)tZ*YBlmio{4b<eJL`mZ&lzyAOEwTOTI`S<>3l>x6m
zUVm2Edxd@Z=l>NPu6hn*{vZ8gD{H(#`u<1z@%Cp!{pWN{J?gK2YNx^+|NK{QoSuPy
z{!=>@=J@Bog5&fI{O{@icC^D9Z;<-ee!TtJQ2#j{Q;+)VpW3M~$3OoS9H(dCpa0ZO
zg*pEDui!X61OI#a@82Fetnmh^f9=QHpAGe&(=qj^zy7J63UmDPU%_#D2LAa^?NpfK
zpZ^Mu(=+hDr~kFjI@R`ibE$v*=iE#E=X6Xx>aTxlr@|cn{8w<Co`HY<Q#%#r_~*ZZ
z<Ma&t@9DpP`NuV(K<a<O*8W8=p#NG1`s=^8z}nsU*MDt+wY&4L|Jnj;cjsUKwFTDh
i&i|hM)B9#l0R<FLKmi35P(T3%6i`3`1r$(Vj{?7uQspQB

literal 0
HcmV?d00001

diff --git a/dlls/mf/tests/transform.c b/dlls/mf/tests/transform.c
index 7603d56f6ee..ffb3de92e2c 100644
--- a/dlls/mf/tests/transform.c
+++ b/dlls/mf/tests/transform.c
@@ -1196,18 +1196,13 @@ static void enum_mf_samples(IMFCollection *samples, const struct sample_desc *co
     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)
+static void dump_buffer_data(const struct buffer_desc *buffer_desc, void *data, DWORD length, 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);
+    SIZE size = buffer_desc->size;
+    DWORD ret, written;

if (buffer_desc->dump)
-        buffer_desc->dump(data, length, &buffer_desc->size, output);
+        buffer_desc->dump(data, length, &size, output);
     else
     {
         if (buffer_desc->length == -1)
@@ -1221,7 +1216,36 @@ static void dump_mf_media_buffer(IMFMediaBuffer *buffer, const struct buffer_des
         ok(ret, "WriteFile failed, error %lu\n", GetLastError());
         ok(written == length, "written %lu bytes\n", written);
     }
+}
+
+static void dump_mf_2d_buffer(IMFMediaBuffer *buffer, const struct buffer_desc *buffer_desc, HANDLE output)
+{
+    IMF2DBuffer2 *buffer2d;
+    DWORD length;
+    LONG stride;
+    BYTE *scanline;
+    HRESULT hr;
+    BYTE *data;
+
+    hr = IMFMediaBuffer_QueryInterface(buffer, &IID_IMF2DBuffer2, (void **)&buffer2d);
+    ok(hr == S_OK, "QueryInterface IMF2DBuffer2 returned %#lx\n", hr);
+    hr = IMF2DBuffer2_Lock2DSize(buffer2d, MF2DBuffer_LockFlags_Read, &scanline, &stride, &data, &length);
+    ok(hr == S_OK, "Lock2DSize returned %#lx\n", hr);
+    dump_buffer_data(buffer_desc, data, length, output);
+    hr = IMF2DBuffer2_Unlock2D(buffer2d);
+    ok(hr == S_OK, "Unlock2D returned %#lx\n", hr);
+    IMF2DBuffer2_Release(buffer2d);
+}
+
+static void dump_mf_media_buffer(IMFMediaBuffer *buffer, const struct buffer_desc *buffer_desc, HANDLE output)
+{
+    DWORD length;
+    HRESULT hr;
+    BYTE *data;

+    hr = IMFMediaBuffer_Lock(buffer, &data, NULL, &length);
+    ok(hr == S_OK, "Lock returned %#lx\n", hr);
+    dump_buffer_data(buffer_desc, data, length, output);
     hr = IMFMediaBuffer_Unlock(buffer);
     ok(hr == S_OK, "Unlock returned %#lx\n", hr);
 }
@@ -1231,8 +1255,13 @@ 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_2d(IMFSample *sample, const struct sample_desc *sample_desc, HANDLE output)
+{
+    enum_mf_media_buffers(sample, sample_desc, dump_mf_2d_buffer, output);
+}
+
 static void dump_mf_sample_collection(IMFCollection *samples, const struct sample_desc *collection_desc,
-        const WCHAR *output_filename)
+        const WCHAR *output_filename, BOOL use_2d_buffer)
 {
     WCHAR path[MAX_PATH];
     HANDLE output;
@@ -1243,12 +1272,47 @@ static void dump_mf_sample_collection(IMFCollection *samples, const struct sampl
     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);
+    enum_mf_samples(samples, collection_desc, use_2d_buffer ? dump_mf_sample_2d : dump_mf_sample, output);

trace("created %s\n", debugstr_w(path));
     CloseHandle(output);
 }

+#define check_mf_2d_buffer(a, b, c) check_mf_2d_buffer_(__FILE__, __LINE__, a, b, c)
+static DWORD check_mf_2d_buffer_(const char *file, int line, IMF2DBuffer2 *buffer, const struct buffer_desc *expect,
+        const BYTE **expect_data, DWORD *expect_data_len)
+{
+    DWORD length, diff = 0, expect_length = expect->length;
+    BYTE *scanline;
+    LONG stride;
+    HRESULT hr;
+    BYTE *data;
+
+    hr = IMF2DBuffer2_Lock2DSize(buffer, MF2DBuffer_LockFlags_Read, &scanline, &stride, &data, &length);
+    ok_(file, line)(hr == S_OK, "Lock2DSize returned %#lx\n", hr);
+    todo_wine_if(expect->todo_length)
+    ok_(file, line)(length == expect_length, "got length %ld, expected %ld\n", length, expect_length);
+
+    if (*expect_data)
+    {
+        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, NULL, *expect_data);
+        else
+            diff = expect->compare(data, &length, &expect->size, &expect->compare_rect, *expect_data);
+    }
+
+    hr = IMF2DBuffer2_Unlock2D(buffer);
+    ok_(file, line)(hr == S_OK, "Unlock2D 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;
+}
+
 #define check_mf_media_buffer(a, b, c) check_mf_media_buffer_(__FILE__, __LINE__, a, b, c)
 static DWORD check_mf_media_buffer_(const char *file, int line, IMFMediaBuffer *buffer, const struct buffer_desc *expect,
         const BYTE **expect_data, DWORD *expect_data_len)
@@ -1267,7 +1331,7 @@ static DWORD check_mf_media_buffer_(const char *file, int line, IMFMediaBuffer *
     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);
+    ok_(file, line)(length == expect_length, "got length %ld, expected %ld\n", length, expect_length);

if (*expect_data)
     {
@@ -1368,17 +1432,58 @@ static void check_mf_sample_collection_enum(IMFSample *sample, const struct samp
     ctx->diff += check_mf_sample_(ctx->file, ctx->line, sample, expect, &ctx->data, &ctx->data_len);
 }

+static void check_mf_sample_2d_buffer(IMFMediaBuffer *buffer, const struct buffer_desc *expect, void *context)
+{
+    struct check_mf_sample_context *ctx = context;
+    IMF2DBuffer2 *buffer2d;
+    HRESULT hr;
+
+    hr = IMFMediaBuffer_QueryInterface(buffer, &IID_IMF2DBuffer2, (void **)&buffer2d);
+    ok(hr == S_OK, "QueryInterface IMF2DBuffer2 returned %#lx\n", hr);
+    ctx->diff += check_mf_2d_buffer_(ctx->file, ctx->line, buffer2d, expect, &ctx->data, &ctx->data_len);
+    IMF2DBuffer2_Release(buffer2d);
+}
+
+#define check_mf_sample_2d(a, b, c, d) check_mf_sample_2d_(__FILE__, __LINE__, a, b, c, d)
+static DWORD check_mf_sample_2d_(const char *file, 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, .file = file, .line = line};
+    DWORD buffer_count;
+    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_2d_buffer, &ctx);
+
+    *expect_data = ctx.data;
+    *expect_data_len = ctx.data_len;
+
+    return ctx.diff / buffer_count;
+}
+
+static void check_mf_sample_collection_2d_enum(IMFSample *sample, const struct sample_desc *expect, void *context)
+{
+    struct check_mf_sample_context *ctx = context;
+    ctx->diff += check_mf_sample_2d_(ctx->file, ctx->line, sample, expect, &ctx->data, &ctx->data_len);
+}
+
+#define check_2d_mf_sample_collection(a, b, c) check_mf_sample_collection_(__FILE__, __LINE__, a, b, c, TRUE)
 DWORD check_mf_sample_collection_(const char *file, int line, IMFCollection *samples,
-        const struct sample_desc *expect_samples, const WCHAR *expect_data_filename)
+        const struct sample_desc *expect_samples, const WCHAR *expect_data_filename, BOOL use_2d_buffer)
 {
     struct check_mf_sample_context ctx = {.file = file, .line = line};
     DWORD count;
     HRESULT hr;

if (expect_data_filename) load_resource(expect_data_filename, &ctx.data, &ctx.data_len);
-    enum_mf_samples(samples, expect_samples, check_mf_sample_collection_enum, &ctx);
+    enum_mf_samples(samples, expect_samples, use_2d_buffer ? check_mf_sample_collection_2d_enum : check_mf_sample_collection_enum, &ctx);

-    if (expect_data_filename) dump_mf_sample_collection(samples, expect_samples, expect_data_filename);
+    if (expect_data_filename) dump_mf_sample_collection(samples, expect_samples, expect_data_filename, use_2d_buffer);

hr = IMFCollection_GetElementCount(samples, &count);
     ok_(file, line)(hr == S_OK, "GetElementCount returned %#lx\n", hr);
@@ -7541,7 +7646,7 @@ static void test_video_processor(BOOL use_2d_buffer)
     };

static const MFVideoArea actual_aperture = {.Area={82,84}};
-    static const DWORD actual_width = 96, actual_height = 96;
+    static const DWORD actual_width = 96, actual_height = 96, nv12_aligned_width = 128;
     const struct attribute_desc rgb32_with_aperture[] =
     {
         ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video, .required = TRUE),
@@ -7688,6 +7793,18 @@ static void test_video_processor(BOOL use_2d_buffer)
         .sample_time = 0, .sample_duration = 10000000,
         .buffer_count = 1, .buffers = &rgb32_crop_buffer_desc,
     };
+    const struct buffer_desc rgb32_crop_buffer_2d_desc =
+    {
+        .length = actual_width * actual_aperture.Area.cy * 4,
+        .compare = compare_rgb32, .compare_rect = {.right = actual_aperture.Area.cx, .bottom = actual_aperture.Area.cy},
+        .dump = dump_rgb32, .size = {.cx = actual_width, .cy = actual_aperture.Area.cy},
+    };
+    const struct sample_desc rgb32_crop_sample_2d_desc =
+    {
+        .attributes = output_sample_attributes,
+        .sample_time = 0, .sample_duration = 10000000,
+        .buffer_count = 1, .buffers = &rgb32_crop_buffer_2d_desc,
+    };

const struct buffer_desc rgb555_buffer_desc =
     {
@@ -7714,6 +7831,18 @@ static void test_video_processor(BOOL use_2d_buffer)
         .sample_time = 0, .sample_duration = 10000000,
         .buffer_count = 1, .buffers = &nv12_buffer_desc,
     };
+    const struct buffer_desc nv12_buffer_2d_desc =
+    {
+        .length = nv12_aligned_width * actual_height * 3 / 2,
+        .compare = compare_nv12, .compare_rect = {.top = 12, .right = 82, .bottom = 96},
+        .dump = dump_nv12, .size = {.cx = nv12_aligned_width, .cy = actual_height},
+    };
+    const struct sample_desc nv12_sample_2d_desc =
+    {
+        .attributes = output_sample_attributes,
+        .sample_time = 0, .sample_duration = 10000000,
+        .buffer_count = 1, .buffers = &nv12_buffer_2d_desc,
+    };

const struct transform_desc
     {
@@ -7723,9 +7852,13 @@ static void test_video_processor(BOOL use_2d_buffer)
         const struct attribute_desc *output_type_desc;
         const struct attribute_desc *output_buffer_desc;
         const struct sample_desc *output_sample_desc;
+        const struct sample_desc *output_sample_2d_desc;
         const WCHAR *output_bitmap;
+        const WCHAR *output_bitmap_1d;
+        const WCHAR *output_bitmap_2d;
         ULONG delta;
         BOOL broken;
+        BOOL todo;
     }
     video_processor_tests[] =
     {
@@ -7734,7 +7867,7 @@ static void test_video_processor(BOOL use_2d_buffer)
             .input_buffer_desc = use_2d_buffer ? nv12_default_stride : NULL,
             .output_type_desc = rgb32_default_stride, .output_bitmap = L"rgb32frame-flip.bmp",
             .output_buffer_desc = use_2d_buffer ? rgb32_negative_stride : NULL,
-            .output_sample_desc = &rgb32_sample_desc,
+            .output_sample_desc = &rgb32_sample_desc, .output_sample_2d_desc = &rgb32_sample_desc,
             .delta = 2, /* Windows returns 0, Wine needs 2 */
         },
         { /* Test 1 */
@@ -7742,7 +7875,7 @@ static void test_video_processor(BOOL use_2d_buffer)
             .input_buffer_desc = use_2d_buffer ? nv12_default_stride : NULL,
             .output_type_desc = rgb32_negative_stride, .output_bitmap = L"rgb32frame-flip.bmp",
             .output_buffer_desc = use_2d_buffer ? rgb32_negative_stride : NULL,
-            .output_sample_desc = &rgb32_sample_desc,
+            .output_sample_desc = &rgb32_sample_desc, .output_sample_2d_desc = &rgb32_sample_desc,
             .delta = 2, /* Windows returns 0, Wine needs 2 */
         },
         { /* Test 2 */
@@ -7750,31 +7883,31 @@ static void test_video_processor(BOOL use_2d_buffer)
             .input_buffer_desc = use_2d_buffer ? nv12_default_stride : NULL,
             .output_type_desc = rgb32_positive_stride, .output_bitmap = L"rgb32frame.bmp",
             .output_buffer_desc = use_2d_buffer ? rgb32_positive_stride : NULL,
-            .output_sample_desc = &rgb32_sample_desc,
+            .output_sample_desc = &rgb32_sample_desc, .output_sample_2d_desc = &rgb32_sample_desc,
             .delta = 6,
         },
         { /* Test 3 */
             .input_type_desc = rgb32_default_stride, .input_bitmap = L"rgb32frame.bmp",
             .input_buffer_desc = use_2d_buffer ? rgb32_negative_stride : NULL,
-            .output_type_desc = nv12_default_stride, .output_bitmap = L"nv12frame-flip.bmp",
+            .output_type_desc = nv12_default_stride, .output_bitmap = L"nv12frame-flip.bmp", .output_bitmap_2d = L"nv12frame-flip-2d.bmp",
             .output_buffer_desc = use_2d_buffer ? nv12_default_stride : NULL,
-            .output_sample_desc = &nv12_sample_desc,
+            .output_sample_desc = &nv12_sample_desc, .output_sample_2d_desc = &nv12_sample_2d_desc,
             .delta = 2, /* Windows returns 0, Wine needs 2 */
         },
         { /* Test 4 */
             .input_type_desc = rgb32_negative_stride, .input_bitmap = L"rgb32frame.bmp",
             .input_buffer_desc = use_2d_buffer ? rgb32_negative_stride : NULL,
-            .output_type_desc = nv12_default_stride, .output_bitmap = L"nv12frame-flip.bmp",
+            .output_type_desc = nv12_default_stride, .output_bitmap = L"nv12frame-flip.bmp", .output_bitmap_2d = L"nv12frame-flip-2d.bmp",
             .output_buffer_desc = use_2d_buffer ? nv12_default_stride : NULL,
-            .output_sample_desc = &nv12_sample_desc,
+            .output_sample_desc = &nv12_sample_desc, .output_sample_2d_desc = &nv12_sample_2d_desc,
             .delta = 2, /* Windows returns 0, Wine needs 2 */
         },
         { /* Test 5 */
             .input_type_desc = rgb32_positive_stride, .input_bitmap = L"rgb32frame.bmp",
             .input_buffer_desc = use_2d_buffer ? rgb32_positive_stride : NULL,
-            .output_type_desc = nv12_default_stride, .output_bitmap = L"nv12frame.bmp",
+            .output_type_desc = nv12_default_stride, .output_bitmap = L"nv12frame.bmp", .output_bitmap_2d = L"nv12frame-2d.bmp",
             .output_buffer_desc = use_2d_buffer ? nv12_default_stride : NULL,
-            .output_sample_desc = &nv12_sample_desc,
+            .output_sample_desc = &nv12_sample_desc, .output_sample_2d_desc = &nv12_sample_2d_desc,
             .delta = 2, /* Windows returns 1, Wine needs 2 */
         },
         { /* Test 6 */
@@ -7782,14 +7915,14 @@ static void test_video_processor(BOOL use_2d_buffer)
             .input_buffer_desc = use_2d_buffer ? rgb32_negative_stride : NULL,
             .output_type_desc = rgb32_negative_stride, .output_bitmap = L"rgb32frame.bmp",
             .output_buffer_desc = use_2d_buffer ? rgb32_negative_stride : NULL,
-            .output_sample_desc = &rgb32_sample_desc,
+            .output_sample_desc = &rgb32_sample_desc, .output_sample_2d_desc = &rgb32_sample_desc,
         },
         { /* Test 7 */
             .input_type_desc = rgb32_negative_stride, .input_bitmap = L"rgb32frame.bmp",
             .input_buffer_desc = use_2d_buffer ? rgb32_negative_stride : NULL,
             .output_type_desc = rgb32_positive_stride, .output_bitmap = L"rgb32frame-flip.bmp",
             .output_buffer_desc = use_2d_buffer ? rgb32_positive_stride : NULL,
-            .output_sample_desc = &rgb32_sample_desc,
+            .output_sample_desc = &rgb32_sample_desc, .output_sample_2d_desc = &rgb32_sample_desc,
             .delta = 3, /* Windows returns 3 */
         },
         { /* Test 8 */
@@ -7797,7 +7930,7 @@ static void test_video_processor(BOOL use_2d_buffer)
             .input_buffer_desc = use_2d_buffer ? rgb32_positive_stride : NULL,
             .output_type_desc = rgb32_negative_stride, .output_bitmap = L"rgb32frame-flip.bmp",
             .output_buffer_desc = use_2d_buffer ? rgb32_negative_stride : NULL,
-            .output_sample_desc = &rgb32_sample_desc,
+            .output_sample_desc = &rgb32_sample_desc, .output_sample_2d_desc = &rgb32_sample_desc,
             .delta = 3, /* Windows returns 3 */
         },
         { /* Test 9 */
@@ -7805,14 +7938,14 @@ static void test_video_processor(BOOL use_2d_buffer)
             .input_buffer_desc = use_2d_buffer ? rgb32_positive_stride : NULL,
             .output_type_desc = rgb32_positive_stride, .output_bitmap = L"rgb32frame.bmp",
             .output_buffer_desc = use_2d_buffer ? rgb32_positive_stride : NULL,
-            .output_sample_desc = &rgb32_sample_desc,
+            .output_sample_desc = &rgb32_sample_desc, .output_sample_2d_desc = &rgb32_sample_desc,
         },
         { /* Test 10 */
             .input_type_desc = rgb32_with_aperture, .input_bitmap = L"rgb32frame.bmp",
             .input_buffer_desc = use_2d_buffer ? rgb32_with_aperture : NULL,
             .output_type_desc = rgb32_with_aperture, .output_bitmap = L"rgb32frame.bmp",
             .output_buffer_desc = use_2d_buffer ? rgb32_with_aperture : NULL,
-            .output_sample_desc = &rgb32_sample_desc,
+            .output_sample_desc = &rgb32_sample_desc, .output_sample_2d_desc = &rgb32_sample_desc,
             .broken = TRUE, /* old Windows version incorrectly rescale */
         },
         { /* Test 11 */
@@ -7820,7 +7953,7 @@ static void test_video_processor(BOOL use_2d_buffer)
             .input_buffer_desc = use_2d_buffer ? rgb32_negative_stride : NULL,
             .output_type_desc = rgb555_default_stride, .output_bitmap = L"rgb555frame.bmp",
             .output_buffer_desc = use_2d_buffer ? rgb555_negative_stride : NULL,
-            .output_sample_desc = &rgb555_sample_desc,
+            .output_sample_desc = &rgb555_sample_desc, .output_sample_2d_desc = &rgb555_sample_desc,
             .delta = 5, /* Windows returns 0, Wine needs 5 */
         },
         { /* Test 12 */
@@ -7828,7 +7961,7 @@ static void test_video_processor(BOOL use_2d_buffer)
             .input_buffer_desc = use_2d_buffer ? rgb32_negative_stride : NULL,
             .output_type_desc = rgb555_negative_stride, .output_bitmap = L"rgb555frame.bmp",
             .output_buffer_desc = use_2d_buffer ? rgb555_negative_stride : NULL,
-            .output_sample_desc = &rgb555_sample_desc,
+            .output_sample_desc = &rgb555_sample_desc, .output_sample_2d_desc = &rgb555_sample_desc,
             .delta = 5, /* Windows returns 0, Wine needs 5 */
         },
         { /* Test 13 */
@@ -7836,7 +7969,7 @@ static void test_video_processor(BOOL use_2d_buffer)
             .input_buffer_desc = use_2d_buffer ? rgb32_negative_stride : NULL,
             .output_type_desc = rgb555_positive_stride, .output_bitmap = L"rgb555frame-flip.bmp",
             .output_buffer_desc = use_2d_buffer ? rgb555_positive_stride : NULL,
-            .output_sample_desc = &rgb555_sample_desc,
+            .output_sample_desc = &rgb555_sample_desc, .output_sample_2d_desc = &rgb555_sample_desc,
             .delta = 3, /* Windows returns 0, Wine needs 3 */
         },
         { /* Test 14 */
@@ -7844,38 +7977,40 @@ static void test_video_processor(BOOL use_2d_buffer)
             .input_buffer_desc = use_2d_buffer ? rgb555_negative_stride : NULL,
             .output_type_desc = rgb555_positive_stride, .output_bitmap = L"rgb555frame-flip.bmp",
             .output_buffer_desc = use_2d_buffer ? rgb555_positive_stride : NULL,
-            .output_sample_desc = &rgb555_sample_desc,
+            .output_sample_desc = &rgb555_sample_desc, .output_sample_2d_desc = &rgb555_sample_desc,
             .delta = 4, /* Windows returns 0, Wine needs 4 */
         },
         { /* Test 15 */
             .input_type_desc = nv12_with_aperture, .input_bitmap = L"nv12frame.bmp",
             .input_buffer_desc = use_2d_buffer ? nv12_with_aperture : NULL,
-            .output_type_desc = rgb32_no_aperture, .output_bitmap = L"rgb32frame-crop-flip.bmp",
+            .output_type_desc = rgb32_no_aperture, .output_bitmap = L"rgb32frame-crop-flip.bmp", .output_bitmap_2d = L"rgb32frame-crop-flip-2d.bmp",
             .output_buffer_desc = use_2d_buffer ? rgb32_no_aperture_negative_stride : NULL,
-            .output_sample_desc = &rgb32_crop_sample_desc,
-            .delta = 2, /* Windows returns 0, Wine needs 2 */
+            .output_sample_desc = &rgb32_crop_sample_desc, .output_sample_2d_desc = &rgb32_crop_sample_2d_desc,
+            .delta = 3, /* Windows returns 3 with 2D buffer */
         },
         { /* Test 16 */
             .input_type_desc = rgb32_no_aperture, .input_bitmap = L"rgb32frame-crop-flip.bmp",
             .input_buffer_desc = use_2d_buffer ? rgb32_no_aperture : NULL,
-            .output_type_desc = rgb32_with_aperture, .output_bitmap = L"rgb32frame-flip.bmp",
+            .output_type_desc = rgb32_with_aperture, .output_bitmap = L"rgb32frame-flip.bmp", .output_bitmap_1d = L"rgb32frame-flip-2d.bmp", .output_bitmap_2d = L"rgb32frame-flip-2d.bmp",
             .output_buffer_desc = use_2d_buffer ? rgb32_with_aperture : NULL,
-            .output_sample_desc = &rgb32_sample_desc,
+            .output_sample_desc = &rgb32_sample_desc, .output_sample_2d_desc = &rgb32_sample_desc,
             .broken = TRUE, /* old Windows version incorrectly rescale */
+            .todo = use_2d_buffer,
         },
         { /* Test 17 */
             .input_type_desc = rgb32_with_aperture, .input_bitmap = L"rgb32frame-flip.bmp",
             .input_buffer_desc = use_2d_buffer ? rgb32_with_aperture_negative_stride : NULL,
-            .output_type_desc = rgb32_no_aperture, .output_bitmap = L"rgb32frame-crop-flip.bmp",
+            .output_type_desc = rgb32_no_aperture, .output_bitmap = L"rgb32frame-crop-flip.bmp", .output_bitmap_2d = L"rgb32frame-crop-flip-2d.bmp",
             .output_buffer_desc = use_2d_buffer ? rgb32_no_aperture_negative_stride : NULL,
-            .output_sample_desc = &rgb32_crop_sample_desc,
+            .output_sample_desc = &rgb32_crop_sample_desc, .output_sample_2d_desc = &rgb32_crop_sample_2d_desc,
+            .delta = 3, /* Windows returns 3 with 2D buffer */
         },
         { /* Test 18 */
             .input_type_desc = rgb32_with_aperture_positive_stride, .input_bitmap = L"rgb32frame.bmp",
             .input_buffer_desc = use_2d_buffer ? rgb32_with_aperture_positive_stride : NULL,
-            .output_type_desc = rgb32_no_aperture, .output_bitmap = L"rgb32frame-crop-flip.bmp",
+            .output_type_desc = rgb32_no_aperture, .output_bitmap = L"rgb32frame-crop-flip.bmp", .output_bitmap_2d = L"rgb32frame-crop-flip-2d.bmp",
             .output_buffer_desc = use_2d_buffer ? rgb32_no_aperture_negative_stride : NULL,
-            .output_sample_desc = &rgb32_crop_sample_desc,
+            .output_sample_desc = &rgb32_crop_sample_desc, .output_sample_2d_desc = &rgb32_crop_sample_2d_desc,
             .delta = 3, /* Windows returns 3 */
         },
     };
@@ -7887,6 +8022,7 @@ static void test_video_processor(BOOL use_2d_buffer)
     IMFSample *input_sample, *output_sample;
     IMFMediaType *media_type, *media_type2;
     IMFCollection *output_samples;
+    const WCHAR *output_bitmap;
     IMFTransform *transform;
     IMFMediaBuffer *buffer;
     const BYTE *input_data;
@@ -8313,8 +8449,19 @@ static void test_video_processor(BOOL use_2d_buffer)
             ref = IMFSample_Release(output_sample);
             ok(ref == 1, "Release returned %ld\n", ref);

-            ret = check_mf_sample_collection(output_samples, test->output_sample_desc, test->output_bitmap);
-            ok(ret <= test->delta || broken(test->broken), "got %lu%% diff\n", ret);
+            output_bitmap = use_2d_buffer && test->output_bitmap_1d ? test->output_bitmap_1d : test->output_bitmap;
+            ret = check_mf_sample_collection(output_samples, test->output_sample_desc, output_bitmap);
+            todo_wine_if(test->todo)
+            ok(ret <= test->delta || broken(test->broken), "1d got %lu%% diff\n", ret);
+
+            if (use_2d_buffer)
+            {
+                output_bitmap = test->output_bitmap_2d ? test->output_bitmap_2d : test->output_bitmap;
+                ret = check_2d_mf_sample_collection(output_samples, test->output_sample_2d_desc, output_bitmap);
+                todo_wine_if(test->todo)
+                ok(ret <= test->delta || broken(test->broken), "2d got %lu%% diff\n", ret);
+            }
+
             IMFCollection_Release(output_samples);

output_sample = create_sample_(NULL, output_info.cbSize, test->output_buffer_desc);

[PATCH v4 6/6] mf/tests: Test 2D buffers can override stride.

[Brendan McGrath]

From: Brendan McGrath

These tests ensure that a 2D buffer can override the stride settings
of the input/output media attributes of a transform.

This tests the 2D 'width' of the buffer, and if the image is stored
'bottom-up' (determined by a positive or negative stride).
---
 dlls/mf/tests/mf_test.h                    |   1 +
 dlls/mf/tests/nv12frame-extra-width-2d.bmp | Bin 0 -> 101430 bytes
 dlls/mf/tests/nv12frame-extra-width.bmp    | Bin 0 -> 76086 bytes
 dlls/mf/tests/resource.rc                  |  12 ++
 dlls/mf/tests/rgb32frame-extra-width.bmp   | Bin 0 -> 55350 bytes
 dlls/mf/tests/transform.c                  | 129 ++++++++++++++++++++-
 6 files changed, 136 insertions(+), 6 deletions(-)
 create mode 100644 dlls/mf/tests/nv12frame-extra-width-2d.bmp
 create mode 100644 dlls/mf/tests/nv12frame-extra-width.bmp
 create mode 100644 dlls/mf/tests/rgb32frame-extra-width.bmp

diff --git a/dlls/mf/tests/mf_test.h b/dlls/mf/tests/mf_test.h
index f118e921b11..bc3deaf3264 100644
--- a/dlls/mf/tests/mf_test.h
+++ b/dlls/mf/tests/mf_test.h
@@ -107,6 +107,7 @@ struct sample_desc
     LONGLONG sample_time;
     LONGLONG sample_duration;
     DWORD buffer_count;
+    DWORD total_length;
     const struct buffer_desc *buffers;
     DWORD repeat_count;
     BOOL todo_length;
diff --git a/dlls/mf/tests/nv12frame-extra-width-2d.bmp b/dlls/mf/tests/nv12frame-extra-width-2d.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..463dc9adeeb26f12cf15f05c8095bf54483a964a
GIT binary patch
literal 101430
zcmeI&u})N57{zgYgLwo)b$J1arCL)^*pQgqS`td@>5L^bJ^>g)!7JR#1QQx!WkF-C
zDBul_XY_`!PiWR&pEI+<|4cUF=>BGw-~OG$!R%Mt&!0VgvN)cP<DYT-H;#YD@$|{F
z@#}c}|M!1R{(QZj&j*IlgAX5vZ{s*UI_nx27Z(F#bv?koVSjP&z<>1hi+}t-=AS?K
z$3Ol}1CRN42%dj<{=t9O@4k!QnIH4LcOCxiJpY(K`?&u{U&Hvv|2o`<SCs+(_+OR1
zb@*KT+rew$NxGwTvdk4+2O!2dhq(w@MRqA|5@E09_QM@zF~iH
z@4$cb|9|2i|IYn0y%zuYPdDu3$3OlZKk2pj$A7wECqMr2@Ayft#XtVj4LkYqkAKHc
zdM*C(pKjR6kAM6-e$s34kN<STPX3eQ*}yP*@cHF%JP!8%WbXgLzF~iH@4$cb{vZ6~
z-+6vWuf;$9(+xZM@sEGUPkJr>@t<zk$&Y{hJATq@@sIy>!%lwu<KOX<UW<SHryF+i
z;~)QypY&S%<3HW7lmB3AV_+CPc)L9ujD!6@nfrgRZ`fblJMbU9{|Ep0cb*^8Yw?f&
zbi+=5{Nvy8lU|E|{HGgs^5Y->j-T{e{Nq2}u#+GE_;>uI*Ww@l>4u&B_{YEFC%qQ`
z_)j<N<lj5L8W=_ozJ4Fxjf4F^nfrgRZ`fblJMbU9{|Ep0cb*^8Yw?f&bi+=5{Nvy8
zlU|E|{HGgs^5Y->j-T{e{Nq2}u#+GE_;>uI*Ww@l>4u&B_{YEFC%qQ`_)j<N<lou7
z85l+n-v1oljD!6@nfrgRZ`fblJMbU9{|Ep0cb*^8Yw?f&bi+=5{Nvy8lU|E|{HGgs
z^5Y->j-T{e{Nq2}u#+GE_;>uI*Ww@l>4u&B_{YEFC%qQ`_)j<N<lnsA9~edte$0m#
z<6!?!=Kde-8}=9X4*W;&|G_{0o#%)2TKwZb-LR7%|M++Oq}Spf|LKOE{P@Se<0riq
z|M*Wg?BvHk{vAK*wfM(>x?v|j{_*elNw38}{?iRR`Fr=RP<Ph7=jVR!oVBCY-*a?-
zE%?61w9-cm`-Yt!Dr?2u`s>44J8J!F2h;VYm7ZeQH|+FKSu5t&Un|bqQR`njn65Xi
z^c2IsVW)@6S~0i&T5;BnTL0R?biHY%rx^APJ3Um^in;aIinDgq`qvJo>rE>?#jtPK
z>7lY#%&osxoVBCYzjiQPZ(8XohJC|M53j3_Z>P;MX8Ws0b^L4cOY24dCmp~KekLTO
zQ~cmZ0yCM6AIZ;U_3@>7{5h4vbWE;}e@T9673lw@1NgzugoJd8AN)vQCX?|a`8laR
zj+guVQyu?={P=ND;RiqXx%(j?Vd$9bwEDqXu3u>t9_*p>hfD7NLHTh<|MxdiGdm`i
z$3GyyvJCWp+5!CFXKF$@#}9rKFVngBQT*&xAMcji|LXXA<X8Ay(EmvX@PnTT3F#C+
z_>sU&CgVr)vr~P%S?=>sb^IOj<HtdTAN=6w?uUScp<}Ys>IZANex+4-u!qhcF1i1k
z)yIoF`oF)Cn%ObAI{qg4rB$H+lMdhqKNAwtDSq%HftgIkkL0I)TB$#i!gNfoPu#v^
zM<l7F{j~ZsDNM)Y`o!%!c0`g&+E1%LlfraNu20;)V@D*Zr2Vw|Gbv2R<od+zJ9b2p
zO4?7WKa;|AOs-GdzGFuusigh1`ZFm^$K?9N?K^fvl1k>q$A^zcXZK%Hn2yQC@#o~%
z7J>e^9l(#~XLeZodj0AC-RI~`OQX-OO+Py%zqSVSzwH2iG(X3)+Slio%f0{9razvM
zA3u&M{Ahl*HfmpQx0ieWsZGDNL4N!=rtqWrIlroXef_@N`%i89^DFY>$1#N;&Cl*l
z?d$!|<=%g4)9>DpA3u&M{Ahk|_iJB2=F7eR)TY1PCqI51Q~1&Rw0Dd8GcAoiyFPLI
pj(Q@kqW!e`GcAoiyFPLIj(Q@kqW!e`GcAoiyFPLIj(Q@k;umL%C3gS-

literal 0
HcmV?d00001

diff --git a/dlls/mf/tests/nv12frame-extra-width.bmp b/dlls/mf/tests/nv12frame-extra-width.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..0fbb616d07919774ac0074e7d94b2caf7a82e5f3
GIT binary patch
literal 76086
zcmeI2u}&L75QfPc_z@yk;RQgHgxZA*8YHCDSaM124$;MKcmf+)F8mfqAkkP95rrE>
zMFDTH*$XMWSB$jx&q<f;x2Lr@?G2jy{p~-KEZ+wQzxMu&gZTL^&YyAqi1W+d*Z3L7
z-}TR%&(F8XBrpXHuCBvVoU8e|(R_S-4FB?k9f6%{@4*lLqj)g<zz_U1uA$T~>X*`g
z!4LevkH`S^i~6N7pv2NY(?7!x{-ZFU#Nt2r5B%Ui3Ij@P;r_Gf%>q-<;N&LU#aZh4
z7wib^RC^D8@E^s4;Rk-;r*Z#G{i1#;=NIq;Kky?mK>ebADGVsF^w0Fq@Pq#-3@EYq
z5B>u`_>aPX5?i?cEEm1N6g0R!4vRQTJ^z9oft_ma!4LkUcrg6H5BxOlpQ&HeFXj9K
ze&7dwL<Xo|)GvhrC6@k~{uzGoAB6!W7XQJ2;0OOv7*Jvh_n+xuKQILi&Ie%{XQ}63
zup_Wj?LGLxe-safANYZv#{Dz(i~6OUU%(Iiz>mlP^^5wYFrdWJKhr<M5B{Stpv2-o
z_z(QxKMDg%Y~lVhy59z-puxj)xQMgV^Do#D*s1m&{NO)|2g48iz)$1;nfgWjQqC{n
z2Y%p3WPtib{ZbfEV(FjhpWz4pQ5aBS@gMvLe()cK0VTF@{~4aW2d1FG<!d;Nv()o1
z*b&&N_8$D;KZ*y#5B$JS<NlfYMg3CFFW?7$;74SD`bGUx7*JyApXs0B2metRP-5{P
z{0DyUAB6!Wws8O1{}>0Rpux)|9K~7c`4{X6>{NRXe()c~gW(5$;HPo_O#PyMDd!jP
z13&O1GC=*JeklwnvGmXM&+vo)C=4jE_z(UAKlqQrfD&7{|1>?fA#UCH%xhOW<=@U-
zh~0e`e)eG^N5?KOpyZJAt~~3{m-5|pAr>b5naI(!3k)bZ<h(1-`m?5dcU_2u34bPX
zH0=TdN)9>i%Cr8gDc@ZeVqwCci5yM4z<`oN&b#ugKWoZ&*M(S^@Mj`N(=ITe<dE~O
zJnPSz^4)bI7AE|e$kDV53@ACgd5@=6GGcC7!#kZf^06gFAM~*muvg&+eQX8nRgs^K
z_qa>S*D9-c#fQDq*^rMdDf*y~t$@7>Kj>pCV6Te&EWO7<t6$#fEXl`~6n)UgR={3`
zAM~*muvbNXrtU+lU+(El$;Z|debC2Nz+QzP^syDNS2cb{-s6INOi9tllxKuK=wmBj
zufk7J`V76tsaC(d(;1SFEh+k-kF9{c3P0#$D`2mR{Oo&=BdvaUr?XE!wxsBTKDGk(
zD*T|2t$@8M@{?8@|GV73KlINa{f*?4>QTQ#pSmLHJ^G}2)bG%zu1I>1KB*q{yIg%H
z&g1HOzTUmaClwfdQa$Q-|C>I&neTOSv%9<I>)ie2n@w*<KDMIh)2=>?p6_*gtnDw~
zY!*H8u@yz1cJ(>z`(Eb*ZGZV@bJ!;zTT%3BSD*W>@AdGk?JwVK?ziM)D~dkt>T~w)
zdtJV2`^z_*vv=~b6-A$R_4ye4UM~}EfB9zfF(w~dQS@n7pL93)-{t=Qp??PHZzP{o
PkNO?@)D=nZbM^TRqP14o

literal 0
HcmV?d00001

diff --git a/dlls/mf/tests/resource.rc b/dlls/mf/tests/resource.rc
index 8eb147c90e6..949977ab8b2 100644
--- a/dlls/mf/tests/resource.rc
+++ b/dlls/mf/tests/resource.rc
@@ -137,6 +137,18 @@ abgr32frame-crop.bmp RCDATA abgr32frame-crop.bmp
 /* @makedep: rgb32frame-grabber.bmp */
 rgb32frame-grabber.bmp RCDATA rgb32frame-grabber.bmp

+/* Generated from running the tests on Windows */
+/* @makedep: rgb32frame-extra-width.bmp */
+rgb32frame-extra-width.bmp RCDATA rgb32frame-extra-width.bmp
+
+/* Generated from running the tests on Windows */
+/* @makedep: nv12frame-extra-width.bmp */
+nv12frame-extra-width.bmp RCDATA nv12frame-extra-width.bmp
+
+/* Generated from running the tests on Windows */
+/* @makedep: nv12frame-extra-width-2d.bmp */
+nv12frame-extra-width-2d.bmp RCDATA nv12frame-extra-width-2d.bmp
+
 /* Generated from running the tests on Windows */
 /* @makedep: rgb555frame.bmp */
 rgb555frame.bmp RCDATA rgb555frame.bmp
diff --git a/dlls/mf/tests/rgb32frame-extra-width.bmp b/dlls/mf/tests/rgb32frame-extra-width.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..509ed6acaeb54d46fd6e2221b47124ec92dfbfcf
GIT binary patch
literal 55350
zcmeI)v27GV7>40>LLG!u-~x!D2YR3Y$7Ey(i4G_NiTnaG0wOw~0UvW-S1_-o+tWNJ
z%}JK^*?a#!^X*xC^4s_KzqhBy{dj&e*5|Q4jCHrY9?#?P{Qdol{rT+CC-7_hh=;j#
zy75OJo}X~$2ZAyIe#-P@`C*_;fS)owS$-HO6X2&zPnI7B$^`f+)05?gfieMp%JgIx
z_Op$%Z?zfx_&J97Ft={}_ScD>X6G_Le)<eocE}Gu#Xmp%@H6*LtjtYz-*@^)|CGJJ
z4?q04eiZ{HtAF$lKl-N_C|UiZfB2c}A99ME=j`_{%ijOuho8CT*;D-R!_NyCD4$|+
z{TiP_xbiu;<=@W_KgBOU{O~jNHpq4B1+LrrNB`&_{ZkB-tp3qI{OF%zpkx>BpSv+P
ztIgo+w@=I7|6-@vxy+BBKEstA^21N@&ksNRO#S(FDsz+F_nrRHKV>iQ!w)~MU&TPl
z>L2~XkNznJN>=~qAAaWg=W%>|%4#z>zxucA{V#T!oy+|A=`&o}AwT>S|NQX7kN3~T
zK*{PK{lky`DF#Yb|L7ln^iMHRvie8=@S}f<fs$Rhf41%MY_%DD-2N_m|BIbw=Q2Nj
z`V3cg$PYioKR^8NGxzsbnVams@AQxUDSLq*e)w_yDh5hc|L7ln^iMHRvie8=@H5vx
z<L1}+7vff#!JqBjviHBr++_EC$B+Igdx0N*`0@Uy7${l&qks6(KgB@F>L2~XkNznJ
zN>=~qAAa;tF;KGlNB{6M**_2C|F2nBo59>!J5Gw7>+YZ9NSHeke)yS_v#0psho9>j
zD0{G+yCY=FYnSbAk6@r20|VVanPEA1N641fF5B%L!9Y0%2D*VV!*cG9kS(uWw%a>`
bfpQECbOU9E<=h=1TVA_tw|4{s<rw}0eNi>b

literal 0
HcmV?d00001

diff --git a/dlls/mf/tests/transform.c b/dlls/mf/tests/transform.c
index ffb3de92e2c..258974cd8ad 100644
--- a/dlls/mf/tests/transform.c
+++ b/dlls/mf/tests/transform.c
@@ -1376,7 +1376,7 @@ static DWORD check_mf_sample_(const char *file, int line, IMFSample *sample, con
         const BYTE **expect_data, DWORD *expect_data_len)
 {
     struct check_mf_sample_context ctx = {.data = *expect_data, .data_len = *expect_data_len, .file = file, .line = line};
-    DWORD buffer_count, total_length, sample_flags;
+    DWORD buffer_count, total_length, sample_flags, expect_length;
     LONGLONG timestamp;
     HRESULT hr;

@@ -1410,15 +1410,19 @@ static DWORD check_mf_sample_(const char *file, int line, IMFSample *sample, con
             "got sample duration %I64d\n", timestamp);

enum_mf_media_buffers(sample, expect, check_mf_sample_buffer, &ctx);
+    if (expect->total_length)
+        expect_length = expect->total_length;
+    else
+        expect_length = ctx.total_length;

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,
+    ok_(file, line)(total_length == expect_length,
             "got total length %#lx\n", total_length);
-    ok_(file, line)(!*expect_data || *expect_data_len >= ctx.total_length,
-            "missing %#lx data\n", ctx.total_length - *expect_data_len);
+    ok_(file, line)(!*expect_data || *expect_data_len >= expect_length,
+            "missing %#lx data\n", expect_length - *expect_data_len);

*expect_data = ctx.data;
     *expect_data_len = ctx.data_len;
@@ -7647,6 +7651,8 @@ static void test_video_processor(BOOL use_2d_buffer)

static const MFVideoArea actual_aperture = {.Area={82,84}};
     static const DWORD actual_width = 96, actual_height = 96, nv12_aligned_width = 128;
+    static const DWORD extra_width = actual_width + 0x30;
+    static const DWORD nv12_aligned_extra_width = 192;
     const struct attribute_desc rgb32_with_aperture[] =
     {
         ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video, .required = TRUE),
@@ -7680,6 +7686,13 @@ static void test_video_processor(BOOL use_2d_buffer)
         ATTR_RATIO(MF_MT_FRAME_SIZE, actual_width, actual_height, .required = TRUE),
         {0},
     };
+    const struct attribute_desc nv12_extra_width[] =
+    {
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video, .required = TRUE),
+        ATTR_GUID(MF_MT_SUBTYPE, MFVideoFormat_NV12, .required = TRUE),
+        ATTR_RATIO(MF_MT_FRAME_SIZE, extra_width, actual_height, .required = TRUE),
+        {0},
+    };
     const struct attribute_desc rgb32_default_stride[] =
     {
         ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video, .required = TRUE),
@@ -7687,6 +7700,14 @@ static void test_video_processor(BOOL use_2d_buffer)
         ATTR_RATIO(MF_MT_FRAME_SIZE, actual_width, actual_height, .required = TRUE),
         {0},
     };
+    const struct attribute_desc rgb32_extra_width[] =
+    {
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video, .required = TRUE),
+        ATTR_GUID(MF_MT_SUBTYPE, MFVideoFormat_RGB32, .required = TRUE),
+        ATTR_RATIO(MF_MT_FRAME_SIZE, extra_width, actual_height, .required = TRUE),
+        ATTR_UINT32(MF_MT_DEFAULT_STRIDE, extra_width * 4),
+        {0},
+    };
     const struct attribute_desc rgb32_negative_stride[] =
     {
         ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video, .required = TRUE),
@@ -7758,6 +7779,7 @@ static void test_video_processor(BOOL use_2d_buffer)
         ATTR_UINT32(MF_MT_DEFAULT_STRIDE, -82 * 4),
         {0},
     };
+
     const MFT_OUTPUT_STREAM_INFO initial_output_info = {0};
     const MFT_INPUT_STREAM_INFO initial_input_info = {0};
     MFT_OUTPUT_STREAM_INFO output_info = {0};
@@ -7805,6 +7827,19 @@ static void test_video_processor(BOOL use_2d_buffer)
         .sample_time = 0, .sample_duration = 10000000,
         .buffer_count = 1, .buffers = &rgb32_crop_buffer_2d_desc,
     };
+    const struct buffer_desc rgb32_extra_width_buffer_desc =
+    {
+        .length = extra_width * actual_height * 4,
+        .compare = compare_rgb32, .compare_rect = {.top = 12, .right = 82, .bottom = 96},
+        .dump = dump_rgb32, .size = {.cx = extra_width, .cy = actual_height},
+    };
+    const struct sample_desc rgb32_extra_width_sample_desc =
+    {
+        .attributes = output_sample_attributes,
+        .sample_time = 0, .sample_duration = 10000000,
+        .total_length = actual_width * actual_height * 4,
+        .buffer_count = 1, .buffers = &rgb32_extra_width_buffer_desc,
+    };

const struct buffer_desc rgb555_buffer_desc =
     {
@@ -7844,6 +7879,32 @@ static void test_video_processor(BOOL use_2d_buffer)
         .buffer_count = 1, .buffers = &nv12_buffer_2d_desc,
     };

+    const struct buffer_desc nv12_extra_width_buffer_desc =
+    {
+        .length = extra_width * actual_height * 3 / 2,
+        .compare = compare_nv12, .compare_rect = {.top = 12, .right = 82, .bottom = 96},
+        .dump = dump_nv12, .size = {.cx = extra_width, .cy = actual_height},
+    };
+    const struct sample_desc nv12_extra_width_sample_desc =
+    {
+        .attributes = output_sample_attributes,
+        .sample_time = 0, .sample_duration = 10000000,
+        .total_length = actual_width * actual_height * 3 / 2,
+        .buffer_count = 1, .buffers = &nv12_extra_width_buffer_desc,
+    };
+    const struct buffer_desc nv12_extra_width_buffer_2d_desc =
+    {
+        .length = nv12_aligned_extra_width * actual_height * 3 / 2,
+        .compare = compare_nv12, .compare_rect = {.top = 12, .right = 82, .bottom = 96},
+        .dump = dump_nv12, .size = {.cx = nv12_aligned_extra_width, .cy = actual_height},
+    };
+    const struct sample_desc nv12_extra_width_sample_2d_desc =
+    {
+        .attributes = output_sample_attributes,
+        .sample_time = 0, .sample_duration = 10000000,
+        .buffer_count = 1, .buffers = &nv12_extra_width_buffer_2d_desc,
+    };
+
     const struct transform_desc
     {
         const struct attribute_desc *input_type_desc;
@@ -8013,6 +8074,57 @@ static void test_video_processor(BOOL use_2d_buffer)
             .output_sample_desc = &rgb32_crop_sample_desc, .output_sample_2d_desc = &rgb32_crop_sample_2d_desc,
             .delta = 3, /* Windows returns 3 */
         },
+        { /* Test 19 */
+            .input_type_desc = nv12_default_stride, .input_bitmap = L"nv12frame.bmp",
+            .input_buffer_desc = use_2d_buffer ? nv12_default_stride : NULL,
+            .output_type_desc = rgb32_default_stride, .output_bitmap = L"rgb32frame-flip.bmp", .output_bitmap_2d = L"rgb32frame.bmp", .output_bitmap_1d = L"rgb32frame.bmp",
+            .output_buffer_desc = use_2d_buffer ? rgb32_default_stride : NULL,
+            .output_sample_desc = &rgb32_sample_desc, .output_sample_2d_desc = &rgb32_sample_desc,
+            .delta = 3, /* Windows returns 3 with 2D buffer */
+            .todo = use_2d_buffer,
+        },
+        { /* Test 20 */
+            .input_type_desc = nv12_default_stride, .input_bitmap = L"nv12frame.bmp",
+            .input_buffer_desc = use_2d_buffer ? nv12_default_stride : NULL,
+            .output_type_desc = rgb32_default_stride, .output_bitmap = L"rgb32frame-flip.bmp", .output_bitmap_2d = L"rgb32frame.bmp", .output_bitmap_1d = L"rgb32frame.bmp",
+            .output_buffer_desc = use_2d_buffer ? rgb32_positive_stride : NULL,
+            .output_sample_desc = &rgb32_sample_desc, .output_sample_2d_desc = &rgb32_sample_desc,
+            .delta = 3, /* Windows returns 3 with 2D buffer */
+            .todo = use_2d_buffer,
+        },
+
+        { /* Test 21, 2D only */
+            .input_type_desc = nv12_default_stride, .input_bitmap = L"nv12frame.bmp",
+            .input_buffer_desc = nv12_default_stride,
+            .output_type_desc = rgb32_default_stride, .output_bitmap = L"rgb32frame-extra-width.bmp",
+            .output_buffer_desc = rgb32_extra_width,
+            .output_sample_desc = &rgb32_extra_width_sample_desc, .output_sample_2d_desc = &rgb32_extra_width_sample_desc,
+            .todo = TRUE,
+        },
+        { /* Test 22, 2D only */
+            .input_type_desc = rgb32_default_stride, .input_bitmap = L"rgb32frame-extra-width.bmp",
+            .input_buffer_desc = rgb32_extra_width,
+            .output_type_desc = nv12_default_stride, .output_bitmap_1d = L"nv12frame.bmp", .output_bitmap_2d = L"nv12frame-2d.bmp",
+            .output_buffer_desc = nv12_default_stride,
+            .output_sample_desc = &nv12_sample_desc, .output_sample_2d_desc = &nv12_sample_2d_desc,
+            .delta = 2, /* Windows returns 2 with 1D buffer */ .todo = TRUE,
+        },
+        { /* Test 23, 2D only */
+            .input_type_desc = rgb32_default_stride, .input_bitmap = L"rgb32frame-extra-width.bmp",
+            .input_buffer_desc = rgb32_extra_width,
+            .output_type_desc = nv12_default_stride, .output_bitmap_1d = L"nv12frame-extra-width.bmp", .output_bitmap_2d = L"nv12frame-extra-width-2d.bmp",
+            .output_buffer_desc = nv12_extra_width,
+            .output_sample_desc = &nv12_extra_width_sample_desc, .output_sample_2d_desc = &nv12_extra_width_sample_2d_desc,
+            .todo = TRUE,
+        },
+        { /* Test 24, 2D only */
+            .input_type_desc = nv12_default_stride, .input_bitmap = L"nv12frame-extra-width.bmp",
+            .input_buffer_desc = nv12_extra_width,
+            .output_type_desc = rgb32_default_stride, .output_bitmap_1d = L"rgb32frame.bmp", .output_bitmap_2d = L"rgb32frame.bmp",
+            .output_buffer_desc = rgb32_default_stride,
+            .output_sample_desc = &rgb32_sample_desc, .output_sample_2d_desc = &rgb32_sample_desc,
+            .todo = TRUE,
+        },
     };

MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Video, MFVideoFormat_NV12};
@@ -8347,6 +8459,10 @@ static void test_video_processor(BOOL use_2d_buffer)
     {
         const struct transform_desc *test = video_processor_tests + i;

+        /* skip tests which require 2D buffers when not testing them */
+        if (!use_2d_buffer && test->input_buffer_desc)
+            continue;
+
         winetest_push_context("transform #%lu", i);

check_mft_set_input_type_required(transform, test->input_type_desc);
@@ -8357,7 +8473,8 @@ static void test_video_processor(BOOL use_2d_buffer)
         check_mft_set_output_type(transform, test->output_type_desc, S_OK);
         check_mft_get_output_current_type(transform, test->output_type_desc);

-        if (test->output_sample_desc == &nv12_sample_desc)
+        if (test->output_sample_desc == &nv12_sample_desc
+                || test->output_sample_desc == &nv12_extra_width_sample_desc)
         {
             output_info.cbSize = actual_width * actual_height * 3 / 2;
             check_mft_get_output_stream_info(transform, S_OK, &output_info);
@@ -8412,7 +8529,7 @@ static void test_video_processor(BOOL use_2d_buffer)
             length = *(DWORD *)(input_data + 2 + 2 * sizeof(DWORD));
             input_data_len -= length;
         }
-        ok(input_data_len == input_info.cbSize, "got length %lu\n", input_data_len);
+        if (!test->input_buffer_desc) ok(input_data_len == input_info.cbSize, "got length %lu\n", input_data_len);
         input_data += length;

input_sample = create_sample_(input_data, input_data_len, test->input_buffer_desc);

[PATCH v4 6/6] mf/tests: Test 2D buffers can override stride.

[Marvin]

Hi,

It looks like your patch introduced the new failures shown below.
Please investigate and fix them before resubmitting your patch.
If they are not new, fixing them anyway would help a lot. Otherwise
please ask for the known failures list to be updated.

The full results can be found at:
https://testbot.winehq.org/JobDetails.pl?Key=147681

Your paranoid android.

=== build (build log) ===

Task: Patch failed to apply

=== debian11 (build log) ===

Task: Patch failed to apply

=== debian11b (build log) ===

Task: Patch failed to apply

[PATCH v4 6/6] mf/tests: Test 2D buffers can override stride.

[Marvin]

Hi,

It looks like your patch introduced the new failures shown below.
Please investigate and fix them before resubmitting your patch.
If they are not new, fixing them anyway would help a lot. Otherwise
please ask for the known failures list to be updated.

The full results can be found at:
https://testbot.winehq.org/JobDetails.pl?Key=147681

Your paranoid android.

=== build (build log) ===

Task: Patch failed to apply

=== debian11 (build log) ===

Task: Patch failed to apply

=== debian11b (build log) ===

Task: Patch failed to apply

[Brendan McGrath (＠redmcg)]

This looks good, thanks @rbernon

[PATCH v4 0/6] MR6220: mfplat: Implement MFCreateMediaBufferFromMediaType for video formats and test video processor with 2D buffers. - approved

[Brendan McGrath (＠redmcg)]

This merge request was approved by Brendan McGrath.

[PATCH v4 0/6] MR6220: mfplat: Implement MFCreateMediaBufferFromMediaType for video formats and test video processor with 2D buffers. - approved

[Nikolay Sivov (＠nsivov)]

This merge request was approved by Nikolay Sivov.