[PATCH v2 0/7] 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

--
  v2: mf/tests: Test 2D buffers can override stride.
      mf/tests: Test differing height attributes.
      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 v2 1/7] 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 v2 2/7] mfplat: Implement MFCreateMediaBufferFromMediaType for video formats.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/mfplat/buffer.c       | 26 ++++++++++++++---
 dlls/mfplat/tests/mfplat.c | 59 +++++++++++---------------------------
 2 files changed, 38 insertions(+), 47 deletions(-)

diff --git a/dlls/mfplat/buffer.c b/dlls/mfplat/buffer.c
index b7f32f12cdc..acea6482ab9 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,24 @@ 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));
+    else if (IsEqualGUID(&major, &MFMediaType_Video)
+            && 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;

-    return E_NOTIMPL;
+        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);
 }
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 v2 3/7] 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 v2 4/7] 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 v2 5/7] 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 v2 6/7] mf/tests: Test differing height attributes.

[Brendan McGrath]

From: Brendan McGrath

These tests ensure that the transform will work with input and
output buffers that have differing height values.
---
 dlls/mf/tests/nv12frame-extra-height-2d.bmp | Bin 0 -> 78902 bytes
 dlls/mf/tests/nv12frame-extra-height.bmp    | Bin 0 -> 59190 bytes
 dlls/mf/tests/resource.rc                   |  12 +++
 dlls/mf/tests/rgb32frame-extra-height.bmp   | Bin 0 -> 43062 bytes
 dlls/mf/tests/transform.c                   |  92 +++++++++++++++++++-
 5 files changed, 103 insertions(+), 1 deletion(-)
 create mode 100644 dlls/mf/tests/nv12frame-extra-height-2d.bmp
 create mode 100644 dlls/mf/tests/nv12frame-extra-height.bmp
 create mode 100644 dlls/mf/tests/rgb32frame-extra-height.bmp

diff --git a/dlls/mf/tests/nv12frame-extra-height-2d.bmp b/dlls/mf/tests/nv12frame-extra-height-2d.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..42c90555126aa84f3f743aa36f1dd7a73c14c433
GIT binary patch
literal 78902
zcmeI3F;3k;5QfPOe1wQ9TmY1kP*YIQAmsu<La9=_LzIt(6YvnCc(;f|q-_ut1&V}H
zQNRs0YpOBDt{$G%*q(2#eKO+3zxV(C8E-7{ZGZdk#@pCVpI_2!)BKs{r;X3)GmXD*
zpS_Q!Z6njpgAhWroUpfJ-+6DzzSD+3{K<e_2B?2K@5hjP_`}~a17oNG&-Y--zSH*X
z{TSA6&Hp+5AA~u;gVVEkpXSZw>O&L$1H2zYcH!^4f50F9^nbq@p#J@`@Ae<?hd=$_
zZw9D;zwGJ%zS+Yc{`7y}8JIZ#yXHJH2Y9e|5r3yS)%X9fAHcq=9r*k1AMl4i{oii}
zsDHogdH(xm4}bX6|9xiw{_to2?>7U~zhCw<*#BKGo5&pC!PRbDra9I3|F9pxzN;Ph
z`|cm`hd=$_Zw9D;zwCMb`(_V+_|yM=X8`{2XaDav1Ju7?_A}W3Ep|2|bASim_v0eX
zslNY*{Q&k|?ZDr6|A0UI>HmH+K>hn=&-33md-%hj{_i^j@P|M9f4>=^{{6C_!T#^~
z_AxRCc<|>T{z!AG@Bd*xfPGgx@b}$6;17TLzuyc{|9;u?{P)cs{_v;&`_2IT;m`ix
zZw9D;zwBqQ|2sH(iOc~W{Q4IU)12!2f7lOT-_;KMefJOe!=L`|Hv`naU-mrzeY1x@
z{OSL`GXQ`1v;X&-0qWl``x)&2wq8#nbASg=ZTy<%RNw!@egONfcHr;3f50F9^nbq@
zp#J@`=lSoOJ^bNM|M#5%_`{$5zuyc{|9;ueVE^~g_tyNo)ra5tOYcGm(Q?Xr;arF5
zIzC#m@3hysSH7#C5BTeQI;EV#AO4mZm{P6G@m?+2ciMCGbV_T2KmFe_15>J%Io_)!
zd-}h9?}5KP1IxYwfB0KwplRF4wDZ7{eWwk3JNBLT@VE8fI{)y8zhwrj^Y2~Xl6|M`
z-GA%#!=L_dnE~tkd)K#Q|JMJTx+7_1M_u)%$%?06qF>hm{Led3*Zp$-pS8#RO>g8^
zAA+|0Gy3>193X#r2dF<~2PW2k?zG2mQGDq%pS}>Z<?qn%0l@#f1LRNH0qSp3^>?j3
zmc8W{`@gpQHTpdO`R*42{wq5`{>YzjVC?m`P#<FP>9n+db@>JQ(gFO>J3#)l9gyjx
z{`2VzLEHVsn*Hxsd;D0Bzqb4_`aJ-p{NcZ{1LTkV2?xere+Sy*P%J*3me#K=e}H}u
z0RHD4Ab-jZP=AxEzb)<YwYU6Y|JRn^Lca$f-~B?se`N>AANdmwjJ^KEtyVcLt-p$>
zxG4I02ZU8sPV?#^R1p;yML+L=u&T;wULF2bOcxg|`EULA2k6&z0RDLg>bhV4`x|Th
zw(`ikA3|mM7X7>f+Ww!OU9RMjSJ&r{zI6X`h5va6nseP_?_xdwb=8}5^zmOhkWYUI
z%SQLO+Lh|%{-dkDY|zJl=|Cy}JDa-4_kF2e&cCku&L;Z!FC8f5|MpS$`12su%lX$;
zzkNg>|D^+^{2#sO9>4xc^>Y4o)sJ4#$A9TSDgUo0y2n#1)yw(URewD}AOEETrTok9
o);LE$??4UD<u&u_A;|C6I3K&d_WS?$*DJ06{r9zhMnCVse}%m&tN;K2

literal 0
HcmV?d00001

diff --git a/dlls/mf/tests/nv12frame-extra-height.bmp b/dlls/mf/tests/nv12frame-extra-height.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..082d0dc15a5c858bd61f13af721eed0c7c95cb22
GIT binary patch
literal 59190
zcmeI5v1(f}6hPBIc%M)_)jtrEG0p73Ll#4za}1_a=C_56_L48~ON|HrMZg(NrVL&}
zCJ*)>sCrF@Xt_}7R#)vi64ziv?vqcBu7oi7>+tl)$**?mU%&YH=Ht7MPbZ)Kt8c%@
z-`~8yR(0(N7~lX7-~bNb01n^)4&XpH9N7EwKas%T_Rc-~SS{930s92@t-J8IUBB>$
zf0y?V{KtR%k2?FbXC}@+oPYjl2dMwHYZ(6UXa9}ff49}#5eW<~?%ku0*!v&YC$Mkb
zg}?3kg+KheyocaF{^LLAA1eo_Khz&9_eyv!{^NfM9$L*I(f?&rIU<3<!?|mG#NPkF
zK7oDfF8poRFZ|)(<vj%d@gM&=|5!Od{h|I?xmUt-@gM(7@X%@wiT=+9Jx3%kxEi{d
zkJ$Sk*e9@W-G#sH`h`FIyS#_sKmOxC=N~Hvs6W&nEB8uxF8<?x2_9O_A<_TIX6J|m
z22U^U+DGjD59|}zx9-B<cKyO1{$1Wf@E`y2pYxBE1JobtkCl5RJQx4*zXT7h=8)+B
zXnb%)0)v}3cj+Vc{s;C6>|1x?Z@Yfs5C1OjA^4B~_|N&r$^q&R^~cJ+5}u3y_+NsD
zR&z-7zki%MB7wnc?aq9}-v7Wpfqm;P{B74S{Ndl_Jp}*pAOAW3SUEubq5fF8SHg4g
zAOB16&}t5e{>R>1@ON>)_YOC>;Q$Wc01n^)4&VR|-~bNb01n^)4&-*As%uBU00(dY
z2XFufZ~zBz00%naKt+Q<cM0sZ+w&@D+UfV?myyB;J~9D$G_yZj?e-XypOtp{E%{}n
z@PUs^KpxHP&r-WJVg1ogza+nm6h82g3CN?F{h6t^u>Pp0pOIf?3Lp5$1mw}Y{!Fyn
zbvS?R^b_*SNZ|t?nSeZ+*`JYiyA11(cKQ+dWu)+dk4!)w&FoKKyPbvgM>~C={4!Gb
zz(*z^k7o8KtQNe300bbAk3e_7`NSuOK;^&YOZ%S)+}<tLAG`KvBfm^EH=k;*+b`}v
z+Ot^eX0PVtmx<=)(^R_s;XL$5H+xf&UnZKH&!DH<uZE#Ny4eRk^2<bX^V#fl`_oJ4
zk8bwOj{Gvw+<e9d-G1{H`lFkDd?3F}G&i5)RJXs@p+CCWk5lr?M04{A|J%HSz@HJ2
LZxa~(+XQ|B;m5&E

literal 0
HcmV?d00001

diff --git a/dlls/mf/tests/resource.rc b/dlls/mf/tests/resource.rc
index 8eb147c90e6..4d986626cc0 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-height.bmp */
+rgb32frame-extra-height.bmp RCDATA rgb32frame-extra-height.bmp
+
+/* Generated from running the tests on Windows */
+/* @makedep: nv12frame-extra-height.bmp */
+nv12frame-extra-height.bmp RCDATA nv12frame-extra-height.bmp
+
+/* Generated from running the tests on Windows */
+/* @makedep: nv12frame-extra-height-2d.bmp */
+nv12frame-extra-height-2d.bmp RCDATA nv12frame-extra-height-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-height.bmp b/dlls/mf/tests/rgb32frame-extra-height.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..eec9635493dc3ccdf9abe3094644ebba2b2537e2
GIT binary patch
literal 43062
zcmeI)!D$;o7>421#dYME3RHm4Ne?L@kOFje1;&s93@##&4sy>a9i#y%zbxas=3AKj
zt4A<G#?0>M)uTo13f+I+KQFJhecgYo@ukMs8oT8~-Pi5y|Cc}B?@#r}(0~C37+`<_
z1{h#~fg3Pza?1<+s!bdQN4|Gk(0{H0{q>()VD8@e*MDw-xqIhd|G5R`?wx=A=N6c|
zcmCV<Uuxw>*5Jp_ig*|s+Gp+0{q)ZpCJy!2Kk?IjF8};@H=L}WfBq9c-RJVpe|N*l
z`uXqcf9}c?b^p=am&f7rKl-omI_h6%!B*%vx()sHAGNcEdHnOg1;?Y$fq(u-?QCHl
z|NL*k@#u5lzpejWz2-*N;OYCr@cAF@v-anH`sWQ3hx+TE_~|~EfBw50PS(#q|B0XO
zbNT1LyWwR0{P*>Ltgj6iS%cHv-{JE=+Gp+0{q)ZpCJy!2Kk?IjF8};@H=L}WfBq9c
z-RJVpe|N*l`uXqce_4+8JKsjq;M?+N`20_@Uvn>R^`HCx)nETxJ{IxMKmT<d=5YPE
z<!);|cgG*cpS3J?+z$WzcXYefniKzZ@~3_}#7G+aUOo+d_Idrhq<!p9|GDp9{q;|d
zpWWy3&wqEr$@=-{Kk?IjF8};@H=L}W|Hl3YuGx%S=P~E{Yh#*e#sC8hFu(u<3^2d|
g0}L?000V0nSnB&Hh6W5UzyJdbFu(u<4BUo+e~HF~KL7v#

literal 0
HcmV?d00001

diff --git a/dlls/mf/tests/transform.c b/dlls/mf/tests/transform.c
index ffb3de92e2c..575d884e195 100644
--- a/dlls/mf/tests/transform.c
+++ b/dlls/mf/tests/transform.c
@@ -7647,6 +7647,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, nv12_aligned_width = 128;
+    static const DWORD extra_height = actual_height + 0x10;
     const struct attribute_desc rgb32_with_aperture[] =
     {
         ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video, .required = TRUE),
@@ -7680,6 +7681,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_height[] =
+    {
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video, .required = TRUE),
+        ATTR_GUID(MF_MT_SUBTYPE, MFVideoFormat_NV12, .required = TRUE),
+        ATTR_RATIO(MF_MT_FRAME_SIZE, actual_width, extra_height, .required = TRUE),
+        {0},
+    };
     const struct attribute_desc rgb32_default_stride[] =
     {
         ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video, .required = TRUE),
@@ -7687,6 +7695,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_height[] =
+    {
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video, .required = TRUE),
+        ATTR_GUID(MF_MT_SUBTYPE, MFVideoFormat_RGB32, .required = TRUE),
+        ATTR_RATIO(MF_MT_FRAME_SIZE, actual_width, extra_height, .required = TRUE),
+        ATTR_UINT32(MF_MT_DEFAULT_STRIDE, actual_width * 4),
+        {0},
+    };
     const struct attribute_desc rgb32_negative_stride[] =
     {
         ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video, .required = TRUE),
@@ -7805,6 +7821,18 @@ 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_height_buffer_desc =
+    {
+        .length = actual_width * extra_height * 4,
+        .compare = compare_rgb32, .compare_rect = {.top = 12, .right = 82, .bottom = 96},
+        .dump = dump_rgb32, .size = {.cx = actual_width, .cy = extra_height},
+    };
+    const struct sample_desc rgb32_extra_height_sample_desc =
+    {
+        .attributes = output_sample_attributes,
+        .sample_time = 0, .sample_duration = 10000000,
+        .buffer_count = 1, .buffers = &rgb32_extra_height_buffer_desc,
+    };

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

+    const struct buffer_desc nv12_extra_height_buffer_desc =
+    {
+        .length = actual_width * extra_height * 3 / 2,
+        .compare = compare_nv12, .compare_rect = {.top = 12, .right = 82, .bottom = 96},
+        .dump = dump_nv12, .size = {.cx = actual_width, .cy = extra_height},
+    };
+    const struct sample_desc nv12_extra_height_sample_desc =
+    {
+        .attributes = output_sample_attributes,
+        .sample_time = 0, .sample_duration = 10000000,
+        .buffer_count = 1, .buffers = &nv12_extra_height_buffer_desc,
+    };
+    const struct buffer_desc nv12_extra_height_buffer_2d_desc =
+    {
+        .length = nv12_aligned_width * extra_height * 3 / 2,
+        .compare = compare_nv12, .compare_rect = {.top = 12, .right = 82, .bottom = 96},
+        .dump = dump_nv12, .size = {.cx = nv12_aligned_width, .cy = extra_height},
+    };
+    const struct sample_desc nv12_extra_height_sample_2d_desc =
+    {
+        .attributes = output_sample_attributes,
+        .sample_time = 0, .sample_duration = 10000000,
+        .buffer_count = 1, .buffers = &nv12_extra_height_buffer_2d_desc,
+    };
+
     const struct transform_desc
     {
         const struct attribute_desc *input_type_desc;
@@ -8013,6 +8066,22 @@ 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_extra_height, .output_bitmap = L"rgb32frame-extra-height.bmp",
+            .output_buffer_desc = use_2d_buffer ? rgb32_extra_height : NULL,
+            .output_sample_desc = &rgb32_extra_height_sample_desc, .output_sample_2d_desc = &rgb32_extra_height_sample_desc,
+            .todo = TRUE,
+        },
+        { /* Test 20 */
+            .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_extra_height, .output_bitmap = L"nv12frame-extra-height.bmp", .output_bitmap_2d = L"nv12frame-extra-height-2d.bmp",
+            .output_buffer_desc = use_2d_buffer ? nv12_extra_height : NULL,
+            .output_sample_desc = &nv12_extra_height_sample_desc, .output_sample_2d_desc = &nv12_extra_height_sample_2d_desc,
+            .todo = TRUE,
+        },
     };

MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Video, MFVideoFormat_NV12};
@@ -8372,6 +8441,16 @@ static void test_video_processor(BOOL use_2d_buffer)
             output_info.cbSize = actual_aperture.Area.cx * actual_aperture.Area.cy * 4;
             check_mft_get_output_stream_info(transform, S_OK, &output_info);
         }
+        else if (test->output_sample_desc == &nv12_extra_height_sample_desc)
+        {
+            output_info.cbSize = actual_width * extra_height * 3 / 2;
+            check_mft_get_output_stream_info(transform, S_OK, &output_info);
+        }
+        else if (test->output_sample_desc == &rgb32_extra_height_sample_desc)
+        {
+            output_info.cbSize = actual_width * extra_height * 4;
+            check_mft_get_output_stream_info(transform, S_OK, &output_info);
+        }
         else
         {
             output_info.cbSize = actual_width * actual_height * 4;
@@ -8393,6 +8472,16 @@ static void test_video_processor(BOOL use_2d_buffer)
             input_info.cbSize = 82 * 84 * 4;
             check_mft_get_input_stream_info(transform, S_OK, &input_info);
         }
+        else if (test->input_type_desc == nv12_extra_height)
+        {
+            input_info.cbSize = actual_width * extra_height * 3 / 2;
+            check_mft_get_input_stream_info(transform, S_OK, &input_info);
+        }
+        else if (test->input_type_desc == rgb32_extra_height)
+        {
+            input_info.cbSize = actual_width * extra_height * 4;
+            check_mft_get_input_stream_info(transform, S_OK, &input_info);
+        }
         else
         {
             input_info.cbSize = actual_width * actual_height * 4;
@@ -8400,7 +8489,8 @@ static void test_video_processor(BOOL use_2d_buffer)
         }

load_resource(test->input_bitmap, &input_data, &input_data_len);
-        if (test->input_type_desc == nv12_default_stride || test->input_type_desc == nv12_with_aperture)
+        if (test->input_type_desc == nv12_default_stride || test->input_type_desc == nv12_with_aperture
+                || test->input_type_desc == nv12_extra_height)
         {
             /* skip BMP header and RGB data from the dump */
             length = *(DWORD *)(input_data + 2);

[PATCH v2 7/7] 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
 .../tests/nv12frame-extra-width-height-2d.bmp | Bin 0 -> 118326 bytes
 .../mf/tests/nv12frame-extra-width-height.bmp | Bin 0 -> 88758 bytes
 dlls/mf/tests/nv12frame-extra-width.bmp       | Bin 0 -> 76086 bytes
 dlls/mf/tests/resource.rc                     |  24 ++
 .../tests/rgb32frame-extra-width-height.bmp   | Bin 0 -> 64566 bytes
 dlls/mf/tests/rgb32frame-extra-width.bmp      | Bin 0 -> 55350 bytes
 dlls/mf/tests/transform.c                     | 207 +++++++++++++++++-
 9 files changed, 223 insertions(+), 9 deletions(-)
 create mode 100644 dlls/mf/tests/nv12frame-extra-width-2d.bmp
 create mode 100644 dlls/mf/tests/nv12frame-extra-width-height-2d.bmp
 create mode 100644 dlls/mf/tests/nv12frame-extra-width-height.bmp
 create mode 100644 dlls/mf/tests/nv12frame-extra-width.bmp
 create mode 100644 dlls/mf/tests/rgb32frame-extra-width-height.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-height-2d.bmp b/dlls/mf/tests/nv12frame-extra-width-height-2d.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..3f5de553aab76e8baf12dee730ac9632ecc5ae70
GIT binary patch
literal 118326
zcmeI)v2N5@6vlCQgL#Bis?7@!QL@yLHU&*2UVuo^R@BoW%B0~55)`G#D{O@nq%;u~
zMH)nvB6$O^4XY@&qAPvhJu|k?{5>*?@jdo;kAF6!UBh3yFaCc1tXp2R>!0oVZ@d1}
zuFs$S(f-;l|L_03@%z`sa@nws*MqC8tA=&F9$<ew`(5v`Kc4-r_xQ*ECf|ej$3OnZ
zHL%I|;3nIf!rV96-W29O1p}L$VG0H|Im0H~o5I{T+1?c9J_Q4toZ+_pZ*Z&?J^1jk
z`PQ!ICl}Vb$@Zo&ckEZ#@17m_pY{L4z(4+{@Ejg11OD+pmc1#Q7ytO5g2S;g;2-~E
z*_*<7@sIy0I2<bj{_#JSy(yd*|M;JR!?7~pAOB<7o5FeVkN+t+94iC<@jsTmDV+Cu
zaon(0^x*ZU=1aTs{?E97kI}uCuwP-ndv@S|*6;t|AOG&NGeaHz@t?u5I|uyZ-?fvW
z4*&Si;Mko5{_*eH$xw%X{AY0N&H?}UckN`T!$1BrICkfNfBd_4GSuN8{}~*+b2vL)
zG^`ap`24ClZCBp^ndkdI*srkPJv;C}>-T@~kAL^OLxwv1<3EFAcMkZ+ziTH$9scp3
z!Ld6B{NvxXlc5g(_|M?jodf>y@7l>whkyKMaO}<j|M++9WT?YG{xdjs=Ww*M)v#9d
z;O%a6)ULe$Gtc*buwP-ndv@S|*6;t|AOG%mhYWT2$A1RL?i}!sf7eciI{f25gJX9N
z_{YC%Cqo_n@t?u5I|uyZ-?fvW4*&Si;Mko5{_*eH$xw%X{AY0N&f(zlreUq<!PoE2
zyLRRMpLxFjgZ&Eo-LnJ#vwr^v|M+*mJ7lQCKmIc~cISY9{JVBC)Zrih863NFz(4+7
zI~nTmkN*sg-8tYN|E`@3b@<1B2FLCk@Q;7jPKG-C<3EFAcMf~|cMWSr58nT5-n1+4
z|IG9KAM97y@17m_pY{7c_{YEd-62CA{_&r|u{#I+<KMNDp$`A}&*0dd1OD;v+R0Fd
zfBa`~?9KuI_;>AOsKY=0GdOnVfPehEb~4oAAO9H~yK~sSKWtbldhlb}ylhwA|C#6e
zKiIFZ-#t6<KkN5@@Q;7@yF-RL{Nq1^V|Nbt$G>YQLmmF{pTV&^2mIsTwUeO^|M<_~
z*qsCZ@$cHnP=|l~XK?J!0sr`S?PRFKKmIc~cIV)}w?f^8{m#$h-nrL}x|sKk9$yQ7
zjxnwD5yvr(-99SUim~zchkM<qi@9$w9dBCcDUM?tyM0uy6=UP?75BPP7jxfWI^ML>
zQyj-QcKfJYE5^p(EADlpF6O?$bi8S$r#Oyr?DkQ)R*a3mSKRAHUCe!h>3GvhPjMXM
z*zKcotr#1BuejHZx|sV0)A6R2p5i#hvD?SRa@nws*8}&uQ5SRHV1GROUGH%m<Jj#Z
z{_*eH$xw%X{AY0N&H?}UckN`T!$1BrICkfNfBd_4GSuN8{}~*+b6Bi+X>+Y~S#kWu
zO2fAYCx5vE^uOGJa`)=@md{?lw?1L{2=xieM<}1YesB5g^?Prlmv862r9NT#2+{Fx
z$zN{xU@!e2bO1jCA?3|M_v$z4f4Sj<z4Z+r9D)81I$YiybgzDs{+Am**n1tleCd7t
zIUk%Zd^0-!HTk7$ME?gJzz==~B&1FJ;70;87>pmu&sp?xy58?U(ecm7kDnS;_`wf;
z9{v!JFc^btTK!}#_pfvnp6p@GZ?3ujN8!r@{a-&w%`^sw$3G&!avA9VumkwP&(MUj
zjUW6dUWQ}wqxd<9Uf!*@|IzUe$gl9ZqW^;q;0Heg64EAq@FRg4491V-XD@nrv)=DN
z(ed}lkDnS;_`wf;9{v!JFc^btTK!}#_pfvnp6p@GZ?3uj+tJI*2l~H$keX=>j*h=g
ze(5UE|3L@vgP#EjX%j#Ak-!WF<45w-|F#mpC515t$0zO|(TF6K^v@Q*C515t$0zO|
z(TF6K^v@Q*C515t$0zO|(TF6K^v@Q*C515t$0zO|(TF6K^v@Q*C515t$0zO|(TF6K
z^v@Q*C515t$0zO|(TF6K)c*@b<s(R8jKSrz*Y7nVNhS3O%SVvH7=z1auitA#l1l0m
zmX9EXF$R~<Ucc9fB$d=BEFVD%V+<~zy?(C|Nh(>cc#*;wgI64XX+)Ar$Y1V&)J$V=
z`Rw}M4<Ao19)FBTQi-0hTtR-R{a58~>U-(`X7zt@9Q%3w>G9L&<U;GFJ~}r2;+Xu}
zHK70f4&X=gbGnHAe15gw=TB_<(*^nQQ)3E0nxCDm*w5SD^*(=M)9-ANA3rsw@T2*;
zyovpM{l4DkPi*?j8}j3)#uR=uKl^vFpZ7o4`}~Pbzkf%5{M4AjkLKt8F!u9fx!&hb
zZ2J2{^5dt*6n->6{ij9zmX<~z9iO;=L_LvK(LY=KmX<~z9iO;=L_LvK(LY=KmX<~z
s9iO;=L_LvKp}(P_RcLAS(OMdPw4O+-&=YADS{i+{mPQ|~C(<hZ1Han)P5=M^

literal 0
HcmV?d00001

diff --git a/dlls/mf/tests/nv12frame-extra-width-height.bmp b/dlls/mf/tests/nv12frame-extra-width-height.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..432958d9c59ce960498aa508c6c6d158ad035e71
GIT binary patch
literal 88758
zcmeI3F>cjb5Qcd>@DflevH>DW9(9ToG?CZ<k)l^o-wx4{G^`*uic(}3NI^;yQBkBp
zR4I}LJjvKV;ggYmVgF;@6Zx}sqU$qvJmcS=XHH`HclY`KPkwFByPwax@v$5Kb>p8W
zPrIMp_Q(GF;P=mFwQ3og)8Ojrs(s7@b~eXOul-|Yr_UXJ;KyMYe&7dwHp_tX3_AC&
z24Cme@%6c_fdMB681NZzG<5D=4ZhB`<Lk3m0|QPDx83iM3`2wWAKI_oI6t|VG@N@^
zgD>nD?DWqb{7`?K8Vo=113#1h4o?4~e>v+Y_<<kzF&UtL(Z3u99ADPYte@eB`r|O*
z_)>qUKk!5SaTsuX7hZp^o8y*YXz=P&`?(uSeg6eJ20Q(;2S3ywrv}3h{J_uT^)vm8
z{^h*CfFJmQACm$47yZj&!0~1M%=#IAs6P$^jxY6x`U5}IABO?Qcj5KtY~8dBLxa<o
z?YbLFeg6eJ20Q(;2S3ywrv}3h{J_uT^)vm8{^h*CfFJmQACm$47yZj&!0~1M%=#IA
zs6P$^jxY6x`U5}IABO?Qcj5KtXlJWs7#h6UZI8OK)c0SoW3badd+<a3acVI9zz_UP
zUO&^n=wHtJ3;2N__%Ruvf6>1j1{`13&#a%}hx+3%;P_I1s6X&S{c#v@d>3AS4lZw6
zhM~ciZ|&P|EcN{t>=^9y&mR0xf1DZ&Kkx%Tlh@DmFZ!4B{sMmB2YyTj=wI|NhXKcz
z^)u^d_@Vwd3^=~jAL<YMP=6c-9N&f4pS}INmSJe{?nnE&8%urv1v>^i{j&!@)E}n?
z!w>wx&*b$p{fqwPyuW}S_<<jj0s0sH%VEIrW&O<h8Gfig4g-!a^@sWcKhz(G0mpaY
z^=JG3uw@t;d|$OMy0O&vU$A4a(?5IgL;Z1TF#Ny|{7hay)4%9n&if1afgkuW8K8gB
zzZ?b}U)Im8pW%o4<1pa(Qh%sF@I(D^7;t<SUVo;(x54jX@;k4gcFyn4HTVv%h0i%m
zjM1?M2AmwmTr1zr=gYZwHTc3rJ`-a!t$_h2hcVa6ck@|u?p+POFp<y17)@(nz{z3E
zwesD3)|`7+gD*_vGciWf8W?bL7;~+BH=i}<-qqj>6ZuSx(X<8zoE*knE8op$&AE3q
z_`*a!6Js>3fdMCnX0>V=o72F#cQyFJ&gR(ZwXcBzCkOa}ANbiU1I{z(+`AfloomO}
z=e7n0oE%`lXTZ_Wxpy`AI@gY`&t44-I61(8&w!($bMI>KZD!uOYaF%BoK7<;neNNv
zqZLCR^cgas)ri*H?CtA$vBijbCOe&5^3jr_5Bg{Yv=x5PM=PMMCO_BN+vlQvo$GED
zt=Z{ZlaH1Zeb7fMpsnzOK3V~7HTgNq-qv3K%1-Bue6*zKgFadTZG|87(F$m*$<I;x
z=Jl`ibdJbJYl=STqZQCr_(317fVO)49As~A$wx|xK2n|o^g$o3fVRTVqV(Cz-d=nC
zD?6P%^3jr_5Bg{Yv=x5PM=PMMCO_NR+Y7IMWv8=EK3Y=rK_9Jvw!#nkXa%&@<frU5
z`A6|z80wk)49YX==+Rnw=O4w0dL}=E@{Brqw3goaM=_$F$<LrXqmCY}rFZ^OjHqYw
zGbqofqepA$oqrS~>Y4lu$}{Td(OP=vAH|4zCO?Dnj5>O>4*&1i9G_!EJu^oR!*lBB
z(K_^<<8zFtXXeOZcupNXT8F-Ke2x+I%p5rk&#9wF>(F<O&oQE&nInhcId$}CUCq43
zh<aw`bXGcgw31KMWH^(p&-)K27sGuR>u)}jk5&nN9+y7Naqj-=)9~p!xzK7vYi>5p
zG5Kgk(Pv(L)=lny`qF#8a<f@C<f9cupLzA!*~;DD?0U~vZZ<nx<f9cupLzAUyvg0a
zeDj{K+-xpy$VV%RKJ)6cf0w(z`{6xbx!LUBk&jjsedg8Y{xEm{zVe>0+-&X-$ww=S
zKJ)5RJ`MRt@h^mWCO?Dnj5>O>mfrbCF`}Ny&!9Y`jvlS0cm7d~sAuvsD9@;)M{D-`
il!xbw5%tVN|LkKOJzBHlKRjQIsAnGfXCLe6(fSkd?O#*?

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 4d986626cc0..0bd8c68d0ff 100644
--- a/dlls/mf/tests/resource.rc
+++ b/dlls/mf/tests/resource.rc
@@ -137,10 +137,26 @@ 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: rgb32frame-extra-height.bmp */
 rgb32frame-extra-height.bmp RCDATA rgb32frame-extra-height.bmp

+/* Generated from running the tests on Windows */
+/* @makedep: rgb32frame-extra-width-height.bmp */
+rgb32frame-extra-width-height.bmp RCDATA rgb32frame-extra-width-height.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: nv12frame-extra-height.bmp */
 nv12frame-extra-height.bmp RCDATA nv12frame-extra-height.bmp
@@ -149,6 +165,14 @@ nv12frame-extra-height.bmp RCDATA nv12frame-extra-height.bmp
 /* @makedep: nv12frame-extra-height-2d.bmp */
 nv12frame-extra-height-2d.bmp RCDATA nv12frame-extra-height-2d.bmp

+/* Generated from running the tests on Windows */
+/* @makedep: nv12frame-extra-width-height.bmp */
+nv12frame-extra-width-height.bmp RCDATA nv12frame-extra-width-height.bmp
+
+/* Generated from running the tests on Windows */
+/* @makedep: nv12frame-extra-width-height-2d.bmp */
+nv12frame-extra-width-height-2d.bmp RCDATA nv12frame-extra-width-height-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-height.bmp b/dlls/mf/tests/rgb32frame-extra-width-height.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..e4484622f19ac9240ec3f1a4bd5f3de760231118
GIT binary patch
literal 64566
zcmeI)v27GV7>40>LLG!u-~x!D7bFUBOh$%~=zt=S$Q_Uq(E&N~F~?dIFt4Q@YoC+m
z1VW#^`_HrAowbKwzrFpl{d?Sw=T~EW9P8a!H`~kcJRXn#zW?R_^JV<WI%o#>&-}s8
zvDeNs=X1{wKgBRV{P1(EfpQI&y;~t$&Rw><UBN&(1_ru;GQ+ZWD`d;L%XWJ!7%0bZ
z@#quyF}}pz+$wvwLbeajSGe#4L74zQWqPvwFi<AIPnn)9KMa%!@KdHI%MSx(0{oQe
z$@0TMnE*d!da@_>vyI)i+6=yZA49yGTPxhdD#yT1vvZvvKYfO0cE}Gu#Xmp%@H6)=
zsLV}vzwY#p{wdc2Km73H^{W^tS^cAb_|ZSbK*{PK{lm{(|BzGUJZ8UsI_>>0e)ySd
zo;}46Km0s_f$}L9uV3R+2nX-MbN>GP@KgNq!w)}GZ-cyUJ;Cd?{?R}BNB<N9C98k*
z4?p^+7%15j_s`9ko7HCU`OAmX-v45!*}2Y-pFYDgJLHF-;-4RW_?i0g>%PoQcE9fQ
zkNzpw0zdrl<Mpc;C|UiZfB4Zq#X!mGAN|A6T>m_bk55@`2A3DVPkaB1oo44cKYscQ
z&+L#Neu{s7_~FO<=VG8_^^gAHNB<N9C98k*4?p^+7${l&qks6(KgB@Fp1FUv?crjz
z8NA<qo%a40JI&5@e*E+qp4lNk{1pHE@WapC&tGM3vio(XfAmke7Wm<ZAFp4<K*{PK
z{lky`DF#Yb|L7ln=K5#c{2ISP+$uBpxxG2<{jV}N+5NiXNB@*-fggVO@&2b6C|UiZ
zfB4Zq#X!mGAN|9R{wW4ZR{!W9e)LZ<P_p_*|L`-}KX>EzuUUu9U~bpeNwIV6^|OwI
zxg+6+pE)^uiXVRXIo3eA2Fu>9kS*sf+ug2Upd14O-9VXP*}E08<=kbvy%h|UV_={g
zC^Ia3w?ej@yKJ|&f`M`j40Ho!hGp+o$d+@L?e<nMP>x|6|M$x}ZU$xVR>-n*oSp0J
zS1?eHfggVOIo3eA2Fu>9kS*sf+ug2Upd14O-9VXP*}E08<=kbvy%h|UV_={gC^Ia3
Hw?g(WEVa!9

literal 0
HcmV?d00001

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 575d884e195..6de257475ba 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,7 +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_height = actual_height + 0x10;
+    static const DWORD extra_width = actual_width + 0x30, extra_height = actual_height + 0x10;
+    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),
@@ -7681,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 nv12_extra_height[] =
     {
         ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video, .required = TRUE),
@@ -7688,6 +7700,13 @@ static void test_video_processor(BOOL use_2d_buffer)
         ATTR_RATIO(MF_MT_FRAME_SIZE, actual_width, extra_height, .required = TRUE),
         {0},
     };
+    const struct attribute_desc nv12_extra_width_height[] =
+    {
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video, .required = TRUE),
+        ATTR_GUID(MF_MT_SUBTYPE, MFVideoFormat_NV12, .required = TRUE),
+        ATTR_RATIO(MF_MT_FRAME_SIZE, extra_width, extra_height, .required = TRUE),
+        {0},
+    };
     const struct attribute_desc rgb32_default_stride[] =
     {
         ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video, .required = TRUE),
@@ -7695,6 +7714,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_extra_height[] =
     {
         ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video, .required = TRUE),
@@ -7703,6 +7730,14 @@ static void test_video_processor(BOOL use_2d_buffer)
         ATTR_UINT32(MF_MT_DEFAULT_STRIDE, actual_width * 4),
         {0},
     };
+    const struct attribute_desc rgb32_extra_width_height[] =
+    {
+        ATTR_GUID(MF_MT_MAJOR_TYPE, MFMediaType_Video, .required = TRUE),
+        ATTR_GUID(MF_MT_SUBTYPE, MFVideoFormat_RGB32, .required = TRUE),
+        ATTR_RATIO(MF_MT_FRAME_SIZE, extra_width, extra_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),
@@ -7774,6 +7809,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};
@@ -7821,6 +7857,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 rgb32_extra_height_buffer_desc =
     {
         .length = actual_width * extra_height * 4,
@@ -7831,8 +7880,22 @@ static void test_video_processor(BOOL use_2d_buffer)
     {
         .attributes = output_sample_attributes,
         .sample_time = 0, .sample_duration = 10000000,
+        .total_length = actual_width * extra_height * 4,
         .buffer_count = 1, .buffers = &rgb32_extra_height_buffer_desc,
     };
+    const struct buffer_desc rgb32_extra_width_height_buffer_desc =
+    {
+        .length = extra_width * extra_height * 4,
+        .compare = compare_rgb32, .compare_rect = {.top = 12, .right = 82, .bottom = 96},
+        .dump = dump_rgb32, .size = {.cx = extra_width, .cy = extra_height},
+    };
+    const struct sample_desc rgb32_extra_width_height_sample_desc =
+    {
+        .attributes = output_sample_attributes,
+        .sample_time = 0, .sample_duration = 10000000,
+        .total_length = actual_width * extra_height * 4,
+        .buffer_count = 1, .buffers = &rgb32_extra_width_height_buffer_desc,
+    };

const struct buffer_desc rgb555_buffer_desc =
     {
@@ -7872,6 +7935,31 @@ 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 buffer_desc nv12_extra_height_buffer_desc =
     {
         .length = actual_width * extra_height * 3 / 2,
@@ -7882,6 +7970,7 @@ static void test_video_processor(BOOL use_2d_buffer)
     {
         .attributes = output_sample_attributes,
         .sample_time = 0, .sample_duration = 10000000,
+        .total_length = actual_width * extra_height * 3 / 2,
         .buffer_count = 1, .buffers = &nv12_extra_height_buffer_desc,
     };
     const struct buffer_desc nv12_extra_height_buffer_2d_desc =
@@ -7894,8 +7983,34 @@ static void test_video_processor(BOOL use_2d_buffer)
     {
         .attributes = output_sample_attributes,
         .sample_time = 0, .sample_duration = 10000000,
+        .total_length = actual_width * extra_height * 3 / 2,
         .buffer_count = 1, .buffers = &nv12_extra_height_buffer_2d_desc,
     };
+    const struct buffer_desc nv12_extra_width_height_buffer_desc =
+    {
+        .length = extra_width * extra_height * 3 / 2,
+        .compare = compare_nv12, .compare_rect = {.top = 12, .right = 82, .bottom = 96},
+        .dump = dump_nv12, .size = {.cx = extra_width, .cy = extra_height},
+    };
+    const struct sample_desc nv12_extra_width_height_sample_desc =
+    {
+        .attributes = output_sample_attributes,
+        .sample_time = 0, .sample_duration = 10000000,
+        .total_length = actual_width * extra_height * 3 / 2,
+        .buffer_count = 1, .buffers = &nv12_extra_width_height_buffer_desc,
+    };
+    const struct buffer_desc nv12_extra_width_height_buffer_2d_desc =
+    {
+        .length = nv12_aligned_extra_width * extra_height * 3 / 2,
+        .compare = compare_nv12, .compare_rect = {.top = 12, .right = 82, .bottom = 96},
+        .dump = dump_nv12, .size = {.cx = nv12_aligned_extra_width, .cy = extra_height},
+    };
+    const struct sample_desc nv12_extra_width_height_sample_2d_desc =
+    {
+        .attributes = output_sample_attributes,
+        .sample_time = 0, .sample_duration = 10000000,
+        .buffer_count = 1, .buffers = &nv12_extra_width_height_buffer_2d_desc,
+    };

const struct transform_desc
     {
@@ -8082,6 +8197,73 @@ static void test_video_processor(BOOL use_2d_buffer)
             .output_sample_desc = &nv12_extra_height_sample_desc, .output_sample_2d_desc = &nv12_extra_height_sample_2d_desc,
             .todo = TRUE,
         },
+        { /* Test 21 */
+            .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 22 */
+            .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 23, 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 24, 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 25, 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 26, 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,
+        },
+        { /* Test 27, 2D only */
+            .input_type_desc = nv12_default_stride, .input_bitmap = L"nv12frame.bmp",
+            .input_buffer_desc = nv12_default_stride,
+            .output_type_desc = rgb32_extra_height, .output_bitmap = L"rgb32frame-extra-width-height.bmp",
+            .output_buffer_desc = rgb32_extra_width_height,
+            .output_sample_desc = &rgb32_extra_width_height_sample_desc, .output_sample_2d_desc = &rgb32_extra_width_height_sample_desc,
+            .todo = TRUE,
+        },
+        { /* Test 28, 2D only */
+            .input_type_desc = rgb32_default_stride, .input_bitmap = L"rgb32frame.bmp",
+            .input_buffer_desc = rgb32_default_stride,
+            .output_type_desc = nv12_extra_height, .output_bitmap_1d = L"nv12frame-extra-width-height.bmp", .output_bitmap_2d = L"nv12frame-extra-width-height-2d.bmp",
+            .output_buffer_desc = nv12_extra_width_height,
+            .output_sample_desc = &nv12_extra_width_height_sample_desc, .output_sample_2d_desc = &nv12_extra_width_height_sample_2d_desc,
+            .todo = TRUE,
+        },
     };

MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Video, MFVideoFormat_NV12};
@@ -8416,6 +8598,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);
@@ -8426,7 +8612,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);
@@ -8441,12 +8628,14 @@ static void test_video_processor(BOOL use_2d_buffer)
             output_info.cbSize = actual_aperture.Area.cx * actual_aperture.Area.cy * 4;
             check_mft_get_output_stream_info(transform, S_OK, &output_info);
         }
-        else if (test->output_sample_desc == &nv12_extra_height_sample_desc)
+        else if (test->output_sample_desc == &nv12_extra_height_sample_desc
+                    || test->output_sample_desc == &nv12_extra_width_height_sample_desc)
         {
             output_info.cbSize = actual_width * extra_height * 3 / 2;
             check_mft_get_output_stream_info(transform, S_OK, &output_info);
         }
-        else if (test->output_sample_desc == &rgb32_extra_height_sample_desc)
+        else if (test->output_sample_desc == &rgb32_extra_height_sample_desc
+                    || test->output_sample_desc == &rgb32_extra_width_height_sample_desc)
         {
             output_info.cbSize = actual_width * extra_height * 4;
             check_mft_get_output_stream_info(transform, S_OK, &output_info);
@@ -8502,7 +8691,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 v2 7/7] 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=147588

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

[Nikolay Sivov (＠nsivov)]

Nikolay Sivov (@nsivov) commented about dlls/mfplat/buffer.c:
> -
>    FIXME("Major type %s is not supported.\n", debugstr_guid(&major));
> - else if (IsEqualGUID(&major, &MFMediaType_Video)
> -
>        && 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;
>
> - return E_NOTIMPL;
> -
>    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;
> - }

I think we should keep E_NOTIMPL for other major types, so that fixme is visible.