[PATCH 0/3] MR6337: mfplat: Test and implement MFCreateLegacyMediaBufferOnMFMediaBuffer.
From: Rémi Bernon <rbernon(a)codeweavers.com> --- dlls/mfplat/buffer.c | 6 ++++++ dlls/mfplat/mfplat.spec | 2 +- include/mfapi.h | 1 + 3 files changed, 8 insertions(+), 1 deletion(-) diff --git a/dlls/mfplat/buffer.c b/dlls/mfplat/buffer.c index fb3b2f305ee..26b1d5f982c 100644 --- a/dlls/mfplat/buffer.c +++ b/dlls/mfplat/buffer.c @@ -1760,3 +1760,9 @@ HRESULT WINAPI MFCreateMediaBufferFromMediaType(IMFMediaType *media_type, LONGLO FIXME("Major type %s is not supported.\n", debugstr_guid(&major)); return E_NOTIMPL; } + +HRESULT WINAPI MFCreateLegacyMediaBufferOnMFMediaBuffer(IMFSample *sample, IMFMediaBuffer *media_buffer, DWORD offset, IMediaBuffer **obj) +{ + FIXME("stub!\n"); + return E_NOTIMPL; +} diff --git a/dlls/mfplat/mfplat.spec b/dlls/mfplat/mfplat.spec index d61e18491d3..7b356f9f457 100644 --- a/dlls/mfplat/mfplat.spec +++ b/dlls/mfplat/mfplat.spec @@ -50,7 +50,7 @@ @ stdcall MFCreateDXSurfaceBuffer(ptr ptr long ptr) @ stdcall MFCreateEventQueue(ptr) @ stdcall MFCreateFile(long long long wstr ptr) -@ stub MFCreateLegacyMediaBufferOnMFMediaBuffer +@ stdcall MFCreateLegacyMediaBufferOnMFMediaBuffer(ptr ptr long ptr) @ stdcall MFCreateMFByteStreamOnStream(ptr ptr) @ stdcall MFCreateMFByteStreamOnStreamEx(ptr ptr) @ stdcall MFCreateMFByteStreamWrapper(ptr ptr) diff --git a/include/mfapi.h b/include/mfapi.h index acf76d84ffd..afa3655aa2b 100644 --- a/include/mfapi.h +++ b/include/mfapi.h @@ -558,6 +558,7 @@ HRESULT WINAPI MFCreateTempFile(MF_FILE_ACCESSMODE accessmode, MF_FILE_OPENMODE IMFByteStream **bytestream); HRESULT WINAPI MFCreateVideoMediaType(const MFVIDEOFORMAT *format, IMFVideoMediaType **media_type); HRESULT WINAPI MFCreateVideoMediaTypeFromSubtype(const GUID *subtype, IMFVideoMediaType **media_type); +HRESULT WINAPI MFCreateLegacyMediaBufferOnMFMediaBuffer(IMFSample *sample, IMFMediaBuffer *media_buffer, DWORD offset, IMediaBuffer **obj); #ifdef _KSMEDIA_ HRESULT WINAPI MFCreateVideoMediaTypeFromVideoInfoHeader(const KS_VIDEOINFOHEADER *vih, DWORD size, DWORD pixel_aspect_ratio_x, -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/6337
From: Rémi Bernon <rbernon(a)codeweavers.com> --- dlls/mfplat/tests/mfplat.c | 174 +++++++++++++++++++++++++++++++++++++ 1 file changed, 174 insertions(+) diff --git a/dlls/mfplat/tests/mfplat.c b/dlls/mfplat/tests/mfplat.c index 4c1a5707f50..b05c2a7299d 100644 --- a/dlls/mfplat/tests/mfplat.c +++ b/dlls/mfplat/tests/mfplat.c @@ -493,6 +493,8 @@ static HRESULT (WINAPI *pMFCreate2DMediaBuffer)(DWORD width, DWORD height, DWORD IMFMediaBuffer **buffer); static HRESULT (WINAPI *pMFCreateMediaBufferFromMediaType)(IMFMediaType *media_type, LONGLONG duration, DWORD min_length, DWORD min_alignment, IMFMediaBuffer **buffer); +static HRESULT (WINAPI *pMFCreateLegacyMediaBufferOnMFMediaBuffer)(IMFSample *sample, IMFMediaBuffer *media_buffer, DWORD offset, + IMediaBuffer **obj); static HRESULT (WINAPI *pMFCreatePathFromURL)(const WCHAR *url, WCHAR **path); static HRESULT (WINAPI *pMFCreateDXSurfaceBuffer)(REFIID riid, IUnknown *surface, BOOL bottom_up, IMFMediaBuffer **buffer); static HRESULT (WINAPI *pMFCreateTrackedSample)(IMFTrackedSample **sample); @@ -1610,6 +1612,7 @@ static void init_functions(void) X(MFAllocateWorkQueueEx); X(MFCopyImage); X(MFCreate2DMediaBuffer); + X(MFCreateLegacyMediaBufferOnMFMediaBuffer); X(MFCreateDXGIDeviceManager); X(MFCreateDXGISurfaceBuffer); X(MFCreateDXSurfaceBuffer); @@ -3137,6 +3140,176 @@ static void test_system_memory_aligned_buffer(void) IMFMediaBuffer_Release(buffer); } +static UINT expect_locks; +static UINT expect_unlocks; + +static HRESULT WINAPI test_buffer_QueryInterface(IMFMediaBuffer *iface, REFIID riid, void **obj) +{ + if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IMFMediaBuffer)) + { + IMFMediaBuffer_AddRef(iface); + *obj = iface; + return S_OK; + } + + ok(IsEqualIID(riid, &IID_IMF2DBuffer) || IsEqualIID(riid, &IID_IMF2DBuffer2), + "Unexpected riid %s\n", debugstr_guid(riid)); + *obj = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI test_buffer_AddRef(IMFMediaBuffer *iface) +{ + return 2; +} + +static ULONG WINAPI test_buffer_Release(IMFMediaBuffer *iface) +{ + return 1; +} + +static HRESULT WINAPI test_buffer_Lock(IMFMediaBuffer *iface, BYTE **data, DWORD *maxlength, DWORD *length) +{ + ok(expect_locks--, "Unexpected call\n"); + ok(!maxlength, "got maxlength\n"); + ok(!length, "got length\n"); + *data = (BYTE *)0xdeadbeef; + return S_OK; +} + +static HRESULT WINAPI test_buffer_Unlock(IMFMediaBuffer *iface) +{ + ok(expect_unlocks--, "Unexpected call\n"); + return S_OK; +} + +static HRESULT WINAPI test_buffer_GetCurrentLength(IMFMediaBuffer *iface, DWORD *length) +{ + *length = 0; + return S_OK; +} + +static HRESULT WINAPI test_buffer_SetCurrentLength(IMFMediaBuffer *iface, DWORD length) +{ + ok(0, "Unexpected call\n"); + return E_NOTIMPL; +} + +static HRESULT WINAPI test_buffer_GetMaxLength(IMFMediaBuffer *iface, DWORD *length) +{ + *length = 0; + return S_OK; +} + +static const IMFMediaBufferVtbl test_buffer_vtbl = +{ + test_buffer_QueryInterface, + test_buffer_AddRef, + test_buffer_Release, + test_buffer_Lock, + test_buffer_Unlock, + test_buffer_GetCurrentLength, + test_buffer_SetCurrentLength, + test_buffer_GetMaxLength, +}; + +static IMFMediaBuffer test_buffer = {.lpVtbl = &test_buffer_vtbl}; + +static void test_MFCreateLegacyMediaBufferOnMFMediaBuffer(void) +{ + IMediaBuffer *media_buffer; + IMFMediaBuffer *buffer; + IMFSample *sample; + ULONG length; + BYTE *data; + HRESULT hr; + + if (!pMFCreateLegacyMediaBufferOnMFMediaBuffer) + { + win_skip("MFCreateLegacyMediaBufferOnMFMediaBuffer() is not available.\n"); + return; + } + + hr = pMFCreateLegacyMediaBufferOnMFMediaBuffer(NULL, NULL, 0, NULL); + todo_wine ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr); + + if (0) /* crashes */ + { + hr = MFCreateSample(&sample); + ok(hr == S_OK, "Unexpected hr %#lx.\n", hr); + hr = pMFCreateLegacyMediaBufferOnMFMediaBuffer(sample, NULL, 0, &media_buffer); + ok(hr == S_OK, "Unexpected hr %#lx.\n", hr); + IMFSample_Release(sample); + } + + hr = pMFCreateLegacyMediaBufferOnMFMediaBuffer(NULL, &test_buffer, 0, &media_buffer); + todo_wine ok(hr == S_OK, "Unexpected hr %#lx.\n", hr); + if (hr == S_OK) + { + expect_locks = 1; + hr = IMediaBuffer_GetBufferAndLength(media_buffer, &data, &length); + ok(hr == S_OK, "Unexpected hr %#lx.\n", hr); + ok(expect_locks == 0, "Unexpected Lock calls\n"); + + expect_locks = 1; + hr = IMediaBuffer_GetBufferAndLength(media_buffer, &data, &length); + ok(hr == S_OK, "Unexpected hr %#lx.\n", hr); + ok(expect_locks == 1, "Unexpected Lock calls\n"); + + expect_unlocks = 1; + IMediaBuffer_Release(media_buffer); + ok(expect_unlocks == 0, "Unexpected Unlock calls\n"); + } + + hr = MFCreateMemoryBuffer(0, &buffer); + ok(hr == S_OK, "Unexpected hr %#lx.\n", hr); + hr = pMFCreateLegacyMediaBufferOnMFMediaBuffer(NULL, buffer, 0, &media_buffer); + todo_wine ok(hr == S_OK, "Unexpected hr %#lx.\n", hr); + IMFMediaBuffer_Release(buffer); + if (hr == S_OK) + { + check_interface(media_buffer, &IID_IMFMediaBuffer, FALSE); + check_interface(media_buffer, &IID_IMFGetService, FALSE); + check_interface(media_buffer, &IID_IMF2DBuffer, FALSE); + check_interface(media_buffer, &IID_IMFSample, FALSE); + IMediaBuffer_Release(media_buffer); + } + + hr = MFCreateSample(&sample); + ok(hr == S_OK, "Unexpected hr %#lx.\n", hr); + hr = MFCreateMemoryBuffer(0, &buffer); + ok(hr == S_OK, "Unexpected hr %#lx.\n", hr); + hr = pMFCreateLegacyMediaBufferOnMFMediaBuffer(sample, buffer, 0, &media_buffer); + todo_wine ok(hr == S_OK, "Unexpected hr %#lx.\n", hr); + IMFMediaBuffer_Release(buffer); + IMFSample_Release(sample); + if (hr == S_OK) + { + check_interface(media_buffer, &IID_IMFSample, TRUE); + IMediaBuffer_Release(media_buffer); + } + + if (pMFCreate2DMediaBuffer) + { + hr = MFCreateSample(&sample); + ok(hr == S_OK, "Unexpected hr %#lx.\n", hr); + hr = pMFCreate2DMediaBuffer(1, 1, MAKEFOURCC('N','V','1','2'), FALSE, &buffer); + ok(hr == S_OK, "Unexpected hr %#lx.\n", hr); + hr = pMFCreateLegacyMediaBufferOnMFMediaBuffer(sample, buffer, 0, &media_buffer); + todo_wine ok(hr == S_OK, "Unexpected hr %#lx.\n", hr); + IMFMediaBuffer_Release(buffer); + IMFSample_Release(sample); + if (hr == S_OK) + { + check_interface(media_buffer, &IID_IMFMediaBuffer, FALSE); + check_interface(media_buffer, &IID_IMF2DBuffer, TRUE); + check_interface(media_buffer, &IID_IMF2DBuffer2, TRUE); + check_interface(media_buffer, &IID_IMFSample, TRUE); + IMediaBuffer_Release(media_buffer); + } + } +} + static void test_sample(void) { static const DWORD test_pattern = 0x22222222; @@ -12812,6 +12985,7 @@ START_TEST(mfplat) test_MFCreateMFByteStreamOnStream(); test_system_memory_buffer(); test_system_memory_aligned_buffer(); + test_MFCreateLegacyMediaBufferOnMFMediaBuffer(); test_source_resolver(); test_MFCreateAsyncResult(); test_allocate_queue(); -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/6337
From: Rémi Bernon <rbernon(a)codeweavers.com> --- dlls/mfplat/Makefile.in | 2 +- dlls/mfplat/buffer.c | 587 ++++++++++++++++++++++++++++++++++++- dlls/mfplat/tests/mfplat.c | 24 +- 3 files changed, 592 insertions(+), 21 deletions(-) diff --git a/dlls/mfplat/Makefile.in b/dlls/mfplat/Makefile.in index b41110e9f6f..1e98aaa6f9d 100644 --- a/dlls/mfplat/Makefile.in +++ b/dlls/mfplat/Makefile.in @@ -1,6 +1,6 @@ MODULE = mfplat.dll IMPORTLIB = mfplat -IMPORTS = advapi32 ole32 mfuuid propsys rtworkq kernelbase +IMPORTS = advapi32 ole32 dmoguids mfuuid propsys rtworkq kernelbase DELAYIMPORTS = bcrypt EXTRADLLFLAGS = -Wb,--prefer-native diff --git a/dlls/mfplat/buffer.c b/dlls/mfplat/buffer.c index 26b1d5f982c..b34b4de66b2 100644 --- a/dlls/mfplat/buffer.c +++ b/dlls/mfplat/buffer.c @@ -1761,8 +1761,591 @@ HRESULT WINAPI MFCreateMediaBufferFromMediaType(IMFMediaType *media_type, LONGLO return E_NOTIMPL; } +struct legacy_buffer +{ + IMediaBuffer IMediaBuffer_iface; + IMF2DBuffer2 IMF2DBuffer2_iface; + IMFSample IMFSample_iface; + LONG refcount; + + IMFMediaBuffer *media_buffer; + void *locked_data; + + IMFSample *sample; + IMF2DBuffer2 *buffer_2d; +}; + +static struct legacy_buffer *legacy_buffer_from_IMediaBuffer(IMediaBuffer *iface) +{ + return CONTAINING_RECORD(iface, struct legacy_buffer, IMediaBuffer_iface); +} + +static HRESULT WINAPI legacy_buffer_QueryInterface(IMediaBuffer *iface, REFIID iid, void **obj) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMediaBuffer(iface); + + TRACE("iface %p, iid %s, obj %p.\n", iface, debugstr_guid(iid), obj); + + if (IsEqualGUID(iid, &IID_IUnknown) + || IsEqualGUID(iid, &IID_IMediaBuffer)) + { + IMediaBuffer_AddRef(&buffer->IMediaBuffer_iface); + *obj = &buffer->IMediaBuffer_iface; + return S_OK; + } + + if (buffer->sample && + IsEqualGUID(iid, &IID_IMFSample)) + { + IMFSample_AddRef(&buffer->IMFSample_iface); + *obj = &buffer->IMFSample_iface; + return S_OK; + } + + if (buffer->buffer_2d && + (IsEqualGUID(iid, &IID_IMF2DBuffer) + || IsEqualGUID(iid, &IID_IMF2DBuffer2))) + { + IMF2DBuffer2_AddRef(&buffer->IMF2DBuffer2_iface); + *obj = &buffer->IMF2DBuffer2_iface; + return S_OK; + } + + WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); + *obj = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI legacy_buffer_AddRef(IMediaBuffer *iface) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMediaBuffer(iface); + ULONG refcount = InterlockedIncrement(&buffer->refcount); + TRACE("%p, refcount %lu.\n", buffer, refcount); + return refcount; +} + +static ULONG WINAPI legacy_buffer_Release(IMediaBuffer *iface) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMediaBuffer(iface); + ULONG refcount = InterlockedDecrement(&buffer->refcount); + TRACE("%p, refcount %lu.\n", buffer, refcount); + + if (!refcount) + { + if (buffer->locked_data) + IMFMediaBuffer_Unlock(buffer->media_buffer); + if (buffer->sample) + IMFSample_Release(buffer->sample); + if (buffer->buffer_2d) + IMF2DBuffer2_Release(buffer->buffer_2d); + IMFMediaBuffer_Release(buffer->media_buffer); + free(buffer); + } + + return refcount; +} + +static HRESULT WINAPI legacy_buffer_SetLength(IMediaBuffer *iface, DWORD len) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMediaBuffer(iface); + TRACE("%p, len %lu.\n", buffer, len); + return IMFMediaBuffer_SetCurrentLength(buffer->media_buffer, len); +} + +static HRESULT WINAPI legacy_buffer_GetMaxLength(IMediaBuffer *iface, DWORD *len) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMediaBuffer(iface); + TRACE("%p, len %p.\n", buffer, len); + return IMFMediaBuffer_GetMaxLength(buffer->media_buffer, len); +} + +static HRESULT WINAPI legacy_buffer_GetBufferAndLength(IMediaBuffer *iface, BYTE **data, DWORD *len) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMediaBuffer(iface); + HRESULT hr; + + TRACE("%p, data %p, len %p.\n", buffer, data, len); + + if ((*data = InterlockedCompareExchangePointer(&buffer->locked_data, NULL, NULL))) + return IMFMediaBuffer_GetCurrentLength(buffer->media_buffer, len); + + if (SUCCEEDED(hr = IMFMediaBuffer_Lock(buffer->media_buffer, data, NULL, len))) + InterlockedExchangePointer(&buffer->locked_data, data); + + return hr; +} + +static const IMediaBufferVtbl legacy_buffer_vtbl = +{ + legacy_buffer_QueryInterface, + legacy_buffer_AddRef, + legacy_buffer_Release, + legacy_buffer_SetLength, + legacy_buffer_GetMaxLength, + legacy_buffer_GetBufferAndLength, +}; + +static struct legacy_buffer *legacy_buffer_from_IMF2DBuffer2(IMF2DBuffer2 *iface) +{ + return CONTAINING_RECORD(iface, struct legacy_buffer, IMF2DBuffer2_iface); +} + +static HRESULT WINAPI legacy_buffer_IMF2DBuffer2_QueryInterface(IMF2DBuffer2 *iface, REFIID riid, void **obj) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMF2DBuffer2(iface); + return IMediaBuffer_QueryInterface(&buffer->IMediaBuffer_iface, riid, obj); +} + +static ULONG WINAPI legacy_buffer_IMF2DBuffer2_AddRef(IMF2DBuffer2 *iface) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMF2DBuffer2(iface); + return IMediaBuffer_AddRef(&buffer->IMediaBuffer_iface); +} + +static ULONG WINAPI legacy_buffer_IMF2DBuffer2_Release(IMF2DBuffer2 *iface) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMF2DBuffer2(iface); + return IMediaBuffer_Release(&buffer->IMediaBuffer_iface); +} + +static HRESULT WINAPI legacy_buffer_IMF2DBuffer2_Lock2D(IMF2DBuffer2 *iface, BYTE **scanline0, LONG *pitch) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMF2DBuffer2(iface); + return IMF2DBuffer2_Lock2D(buffer->buffer_2d, scanline0, pitch); +} + +static HRESULT WINAPI legacy_buffer_IMF2DBuffer2_Unlock2D(IMF2DBuffer2 *iface) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMF2DBuffer2(iface); + return IMF2DBuffer2_Unlock2D(buffer->buffer_2d); +} + +static HRESULT WINAPI legacy_buffer_IMF2DBuffer2_GetScanline0AndPitch(IMF2DBuffer2 *iface, BYTE **scanline0, LONG *pitch) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMF2DBuffer2(iface); + return IMF2DBuffer2_GetScanline0AndPitch(buffer->buffer_2d, scanline0, pitch); +} + +static HRESULT WINAPI legacy_buffer_IMF2DBuffer2_IsContiguousFormat(IMF2DBuffer2 *iface, BOOL *is_contiguous) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMF2DBuffer2(iface); + return IMF2DBuffer2_IsContiguousFormat(buffer->buffer_2d, is_contiguous); +} + +static HRESULT WINAPI legacy_buffer_IMF2DBuffer2_GetContiguousLength(IMF2DBuffer2 *iface, DWORD *length) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMF2DBuffer2(iface); + return IMF2DBuffer2_GetContiguousLength(buffer->buffer_2d, length); +} + +static HRESULT WINAPI legacy_buffer_IMF2DBuffer2_ContiguousCopyTo(IMF2DBuffer2 *iface, BYTE *dest_buffer, DWORD dest_length) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMF2DBuffer2(iface); + return IMF2DBuffer2_ContiguousCopyTo(buffer->buffer_2d, dest_buffer, dest_length); +} + +static HRESULT WINAPI legacy_buffer_IMF2DBuffer2_ContiguousCopyFrom(IMF2DBuffer2 *iface, const BYTE *src_buffer, DWORD src_length) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMF2DBuffer2(iface); + return IMF2DBuffer2_ContiguousCopyFrom(buffer->buffer_2d, src_buffer, src_length); +} + +static HRESULT WINAPI legacy_buffer_IMF2DBuffer2_Lock2DSize(IMF2DBuffer2 *iface, MF2DBuffer_LockFlags flags, BYTE **scanline0, + LONG *pitch, BYTE **buffer_start, DWORD *buffer_length) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMF2DBuffer2(iface); + return IMF2DBuffer2_Lock2DSize(buffer->buffer_2d, flags, scanline0, pitch, buffer_start, buffer_length); +} + +static HRESULT WINAPI legacy_buffer_IMF2DBuffer2_Copy2DTo(IMF2DBuffer2 *iface, IMF2DBuffer2 *dest_buffer) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMF2DBuffer2(iface); + return IMF2DBuffer2_Copy2DTo(buffer->buffer_2d, dest_buffer); +} + +static const IMF2DBuffer2Vtbl legacy_buffer_IMF2DBuffer2_vtbl = +{ + legacy_buffer_IMF2DBuffer2_QueryInterface, + legacy_buffer_IMF2DBuffer2_AddRef, + legacy_buffer_IMF2DBuffer2_Release, + legacy_buffer_IMF2DBuffer2_Lock2D, + legacy_buffer_IMF2DBuffer2_Unlock2D, + legacy_buffer_IMF2DBuffer2_GetScanline0AndPitch, + legacy_buffer_IMF2DBuffer2_IsContiguousFormat, + legacy_buffer_IMF2DBuffer2_GetContiguousLength, + legacy_buffer_IMF2DBuffer2_ContiguousCopyTo, + legacy_buffer_IMF2DBuffer2_ContiguousCopyFrom, + legacy_buffer_IMF2DBuffer2_Lock2DSize, + legacy_buffer_IMF2DBuffer2_Copy2DTo, +}; + +static struct legacy_buffer *legacy_buffer_from_IMFSample(IMFSample *iface) +{ + return CONTAINING_RECORD(iface, struct legacy_buffer, IMFSample_iface); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_QueryInterface(IMFSample *iface, REFIID riid, void **obj) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMediaBuffer_QueryInterface(&buffer->IMediaBuffer_iface, riid, obj); +} + +static ULONG WINAPI legacy_buffer_IMFSample_AddRef(IMFSample *iface) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMediaBuffer_AddRef(&buffer->IMediaBuffer_iface); +} + +static ULONG WINAPI legacy_buffer_IMFSample_Release(IMFSample *iface) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMediaBuffer_Release(&buffer->IMediaBuffer_iface); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_GetItem(IMFSample *iface, REFGUID key, PROPVARIANT *value) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_GetItem(buffer->sample, key, value); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_GetItemType(IMFSample *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_GetItemType(buffer->sample, key, type); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_CompareItem(IMFSample *iface, REFGUID key, REFPROPVARIANT value, BOOL *result) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_CompareItem(buffer->sample, key, value, result); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_Compare(IMFSample *iface, IMFAttributes *theirs, MF_ATTRIBUTES_MATCH_TYPE type, + BOOL *result) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_Compare(buffer->sample, theirs, type, result); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_GetUINT32(IMFSample *iface, REFGUID key, UINT32 *value) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_GetUINT32(buffer->sample, key, value); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_GetUINT64(IMFSample *iface, REFGUID key, UINT64 *value) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_GetUINT64(buffer->sample, key, value); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_GetDouble(IMFSample *iface, REFGUID key, double *value) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_GetDouble(buffer->sample, key, value); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_GetGUID(IMFSample *iface, REFGUID key, GUID *value) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_GetGUID(buffer->sample, key, value); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_GetStringLength(IMFSample *iface, REFGUID key, UINT32 *length) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_GetStringLength(buffer->sample, key, length); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_GetString(IMFSample *iface, REFGUID key, WCHAR *value, UINT32 size, UINT32 *length) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_GetString(buffer->sample, key, value, size, length); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_GetAllocatedString(IMFSample *iface, REFGUID key, WCHAR **value, UINT32 *length) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_GetAllocatedString(buffer->sample, key, value, length); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_GetBlobSize(IMFSample *iface, REFGUID key, UINT32 *size) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_GetBlobSize(buffer->sample, key, size); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_GetBlob(IMFSample *iface, REFGUID key, UINT8 *buf, UINT32 bufsize, UINT32 *blobsize) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_GetBlob(buffer->sample, key, buf, bufsize, blobsize); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_GetAllocatedBlob(IMFSample *iface, REFGUID key, UINT8 **buf, UINT32 *size) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_GetAllocatedBlob(buffer->sample, key, buf, size); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_GetUnknown(IMFSample *iface, REFGUID key, REFIID riid, void **out) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_GetUnknown(buffer->sample, key, riid, out); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_SetItem(IMFSample *iface, REFGUID key, REFPROPVARIANT value) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_SetItem(buffer->sample, key, value); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_DeleteItem(IMFSample *iface, REFGUID key) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_DeleteItem(buffer->sample, key); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_DeleteAllItems(IMFSample *iface) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_DeleteAllItems(buffer->sample); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_SetUINT32(IMFSample *iface, REFGUID key, UINT32 value) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_SetUINT32(buffer->sample, key, value); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_SetUINT64(IMFSample *iface, REFGUID key, UINT64 value) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_SetUINT64(buffer->sample, key, value); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_SetDouble(IMFSample *iface, REFGUID key, double value) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_SetDouble(buffer->sample, key, value); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_SetGUID(IMFSample *iface, REFGUID key, REFGUID value) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_SetGUID(buffer->sample, key, value); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_SetString(IMFSample *iface, REFGUID key, const WCHAR *value) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_SetString(buffer->sample, key, value); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_SetBlob(IMFSample *iface, REFGUID key, const UINT8 *buf, UINT32 size) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_SetBlob(buffer->sample, key, buf, size); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_SetUnknown(IMFSample *iface, REFGUID key, IUnknown *unknown) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_SetUnknown(buffer->sample, key, unknown); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_LockStore(IMFSample *iface) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_LockStore(buffer->sample); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_UnlockStore(IMFSample *iface) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_UnlockStore(buffer->sample); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_GetCount(IMFSample *iface, UINT32 *count) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_GetCount(buffer->sample, count); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_GetItemByIndex(IMFSample *iface, UINT32 index, GUID *key, PROPVARIANT *value) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_GetItemByIndex(buffer->sample, index, key, value); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_CopyAllItems(IMFSample *iface, IMFAttributes *dest) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_CopyAllItems(buffer->sample, dest); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_GetSampleFlags(IMFSample *iface, DWORD *flags) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_GetSampleFlags(buffer->sample, flags); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_SetSampleFlags(IMFSample *iface, DWORD flags) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_SetSampleFlags(buffer->sample, flags); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_GetSampleTime(IMFSample *iface, LONGLONG *timestamp) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_GetSampleTime(buffer->sample, timestamp); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_SetSampleTime(IMFSample *iface, LONGLONG timestamp) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_SetSampleTime(buffer->sample, timestamp); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_GetSampleDuration(IMFSample *iface, LONGLONG *duration) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_GetSampleDuration(buffer->sample, duration); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_SetSampleDuration(IMFSample *iface, LONGLONG duration) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_SetSampleDuration(buffer->sample, duration); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_GetBufferCount(IMFSample *iface, DWORD *count) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_GetBufferCount(buffer->sample, count); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_GetBufferByIndex(IMFSample *iface, DWORD index, IMFMediaBuffer **out) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_GetBufferByIndex(buffer->sample, index, out); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_ConvertToContiguousBuffer(IMFSample *iface, IMFMediaBuffer **out) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_ConvertToContiguousBuffer(buffer->sample, out); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_AddBuffer(IMFSample *iface, IMFMediaBuffer *media_buffer) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_AddBuffer(buffer->sample, media_buffer); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_RemoveBufferByIndex(IMFSample *iface, DWORD index) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_RemoveBufferByIndex(buffer->sample, index); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_RemoveAllBuffers(IMFSample *iface) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_RemoveAllBuffers(buffer->sample); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_GetTotalLength(IMFSample *iface, DWORD *total_length) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_GetTotalLength(buffer->sample, total_length); +} + +static HRESULT WINAPI legacy_buffer_IMFSample_CopyToBuffer(IMFSample *iface, IMFMediaBuffer *dest) +{ + struct legacy_buffer *buffer = legacy_buffer_from_IMFSample(iface); + return IMFSample_CopyToBuffer(buffer->sample, dest); +} + +static const IMFSampleVtbl legacy_buffer_IMFSample_vtbl = +{ + legacy_buffer_IMFSample_QueryInterface, + legacy_buffer_IMFSample_AddRef, + legacy_buffer_IMFSample_Release, + legacy_buffer_IMFSample_GetItem, + legacy_buffer_IMFSample_GetItemType, + legacy_buffer_IMFSample_CompareItem, + legacy_buffer_IMFSample_Compare, + legacy_buffer_IMFSample_GetUINT32, + legacy_buffer_IMFSample_GetUINT64, + legacy_buffer_IMFSample_GetDouble, + legacy_buffer_IMFSample_GetGUID, + legacy_buffer_IMFSample_GetStringLength, + legacy_buffer_IMFSample_GetString, + legacy_buffer_IMFSample_GetAllocatedString, + legacy_buffer_IMFSample_GetBlobSize, + legacy_buffer_IMFSample_GetBlob, + legacy_buffer_IMFSample_GetAllocatedBlob, + legacy_buffer_IMFSample_GetUnknown, + legacy_buffer_IMFSample_SetItem, + legacy_buffer_IMFSample_DeleteItem, + legacy_buffer_IMFSample_DeleteAllItems, + legacy_buffer_IMFSample_SetUINT32, + legacy_buffer_IMFSample_SetUINT64, + legacy_buffer_IMFSample_SetDouble, + legacy_buffer_IMFSample_SetGUID, + legacy_buffer_IMFSample_SetString, + legacy_buffer_IMFSample_SetBlob, + legacy_buffer_IMFSample_SetUnknown, + legacy_buffer_IMFSample_LockStore, + legacy_buffer_IMFSample_UnlockStore, + legacy_buffer_IMFSample_GetCount, + legacy_buffer_IMFSample_GetItemByIndex, + legacy_buffer_IMFSample_CopyAllItems, + legacy_buffer_IMFSample_GetSampleFlags, + legacy_buffer_IMFSample_SetSampleFlags, + legacy_buffer_IMFSample_GetSampleTime, + legacy_buffer_IMFSample_SetSampleTime, + legacy_buffer_IMFSample_GetSampleDuration, + legacy_buffer_IMFSample_SetSampleDuration, + legacy_buffer_IMFSample_GetBufferCount, + legacy_buffer_IMFSample_GetBufferByIndex, + legacy_buffer_IMFSample_ConvertToContiguousBuffer, + legacy_buffer_IMFSample_AddBuffer, + legacy_buffer_IMFSample_RemoveBufferByIndex, + legacy_buffer_IMFSample_RemoveAllBuffers, + legacy_buffer_IMFSample_GetTotalLength, + legacy_buffer_IMFSample_CopyToBuffer, +}; + HRESULT WINAPI MFCreateLegacyMediaBufferOnMFMediaBuffer(IMFSample *sample, IMFMediaBuffer *media_buffer, DWORD offset, IMediaBuffer **obj) { - FIXME("stub!\n"); - return E_NOTIMPL; + struct legacy_buffer *buffer; + + TRACE("sample %p, media_buffer %p, offset %lu, out %p\n", sample, media_buffer, offset, obj); + + if (!obj) + return E_INVALIDARG; + if (offset) + { + FIXME("Not implemented\n"); + return E_NOTIMPL; + } + + if (!(buffer = calloc(1, sizeof(*buffer)))) + return E_OUTOFMEMORY; + buffer->IMediaBuffer_iface.lpVtbl = &legacy_buffer_vtbl; + buffer->IMFSample_iface.lpVtbl = &legacy_buffer_IMFSample_vtbl; + buffer->IMF2DBuffer2_iface.lpVtbl = &legacy_buffer_IMF2DBuffer2_vtbl; + buffer->refcount = 1; + + IMFMediaBuffer_AddRef((buffer->media_buffer = media_buffer)); + if ((buffer->sample = sample)) + IMFSample_AddRef(buffer->sample); + if (FAILED(IMFMediaBuffer_QueryInterface(media_buffer, &IID_IMF2DBuffer2, (void **)&buffer->buffer_2d))) + buffer->buffer_2d = NULL; + + TRACE("created %p\n", buffer); + *obj = &buffer->IMediaBuffer_iface; + return S_OK; } diff --git a/dlls/mfplat/tests/mfplat.c b/dlls/mfplat/tests/mfplat.c index b05c2a7299d..6a2761e6613 100644 --- a/dlls/mfplat/tests/mfplat.c +++ b/dlls/mfplat/tests/mfplat.c @@ -3172,7 +3172,7 @@ static HRESULT WINAPI test_buffer_Lock(IMFMediaBuffer *iface, BYTE **data, DWORD { ok(expect_locks--, "Unexpected call\n"); ok(!maxlength, "got maxlength\n"); - ok(!length, "got length\n"); + todo_wine ok(!length, "got length\n"); *data = (BYTE *)0xdeadbeef; return S_OK; } @@ -3231,7 +3231,7 @@ static void test_MFCreateLegacyMediaBufferOnMFMediaBuffer(void) } hr = pMFCreateLegacyMediaBufferOnMFMediaBuffer(NULL, NULL, 0, NULL); - todo_wine ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr); + ok(hr == E_INVALIDARG, "Unexpected hr %#lx.\n", hr); if (0) /* crashes */ { @@ -3243,9 +3243,7 @@ static void test_MFCreateLegacyMediaBufferOnMFMediaBuffer(void) } hr = pMFCreateLegacyMediaBufferOnMFMediaBuffer(NULL, &test_buffer, 0, &media_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); expect_locks = 1; hr = IMediaBuffer_GetBufferAndLength(media_buffer, &data, &length); ok(hr == S_OK, "Unexpected hr %#lx.\n", hr); @@ -3259,35 +3257,28 @@ static void test_MFCreateLegacyMediaBufferOnMFMediaBuffer(void) expect_unlocks = 1; IMediaBuffer_Release(media_buffer); ok(expect_unlocks == 0, "Unexpected Unlock calls\n"); - } hr = MFCreateMemoryBuffer(0, &buffer); ok(hr == S_OK, "Unexpected hr %#lx.\n", hr); hr = pMFCreateLegacyMediaBufferOnMFMediaBuffer(NULL, buffer, 0, &media_buffer); - todo_wine ok(hr == S_OK, "Unexpected hr %#lx.\n", hr); + ok(hr == S_OK, "Unexpected hr %#lx.\n", hr); IMFMediaBuffer_Release(buffer); - if (hr == S_OK) - { check_interface(media_buffer, &IID_IMFMediaBuffer, FALSE); check_interface(media_buffer, &IID_IMFGetService, FALSE); check_interface(media_buffer, &IID_IMF2DBuffer, FALSE); check_interface(media_buffer, &IID_IMFSample, FALSE); IMediaBuffer_Release(media_buffer); - } hr = MFCreateSample(&sample); ok(hr == S_OK, "Unexpected hr %#lx.\n", hr); hr = MFCreateMemoryBuffer(0, &buffer); ok(hr == S_OK, "Unexpected hr %#lx.\n", hr); hr = pMFCreateLegacyMediaBufferOnMFMediaBuffer(sample, buffer, 0, &media_buffer); - todo_wine ok(hr == S_OK, "Unexpected hr %#lx.\n", hr); + ok(hr == S_OK, "Unexpected hr %#lx.\n", hr); IMFMediaBuffer_Release(buffer); IMFSample_Release(sample); - if (hr == S_OK) - { check_interface(media_buffer, &IID_IMFSample, TRUE); IMediaBuffer_Release(media_buffer); - } if (pMFCreate2DMediaBuffer) { @@ -3296,17 +3287,14 @@ static void test_MFCreateLegacyMediaBufferOnMFMediaBuffer(void) hr = pMFCreate2DMediaBuffer(1, 1, MAKEFOURCC('N','V','1','2'), FALSE, &buffer); ok(hr == S_OK, "Unexpected hr %#lx.\n", hr); hr = pMFCreateLegacyMediaBufferOnMFMediaBuffer(sample, buffer, 0, &media_buffer); - todo_wine ok(hr == S_OK, "Unexpected hr %#lx.\n", hr); + ok(hr == S_OK, "Unexpected hr %#lx.\n", hr); IMFMediaBuffer_Release(buffer); IMFSample_Release(sample); - if (hr == S_OK) - { check_interface(media_buffer, &IID_IMFMediaBuffer, FALSE); check_interface(media_buffer, &IID_IMF2DBuffer, TRUE); check_interface(media_buffer, &IID_IMF2DBuffer2, TRUE); check_interface(media_buffer, &IID_IMFSample, TRUE); IMediaBuffer_Release(media_buffer); - } } } -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/6337
This merge request was approved by Nikolay Sivov. -- https://gitlab.winehq.org/wine/wine/-/merge_requests/6337
participants (2)
-
Nikolay Sivov (＠nsivov) -
Rémi Bernon