Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com>
---
dlls/mf/Makefile.in | 1 +
dlls/mf/main.c | 436 ++++++++++++++++++++++++++++++++++++++++
dlls/mf/mf.spec | 2 +-
dlls/mf/mf_private.h | 27 +++
dlls/mf/samplegrabber.c | 83 ++++++++
dlls/mf/tests/mf.c | 110 ++++++++++
include/mfidl.idl | 26 ++-
7 files changed, 683 insertions(+), 2 deletions(-)
create mode 100644 dlls/mf/mf_private.h
create mode 100644 dlls/mf/samplegrabber.c
diff --git a/dlls/mf/Makefile.in b/dlls/mf/Makefile.in
index 221ef42ec9..2eb9b346d9 100644
--- a/dlls/mf/Makefile.in
+++ b/dlls/mf/Makefile.in
@@ -4,6 +4,7 @@ IMPORTS = mfplat mfuuid
C_SRCS = \
main.c \
+ samplegrabber.c \
session.c \
topology.c
diff --git a/dlls/mf/main.c b/dlls/mf/main.c
index 77081e2a57..c2e5eb45d2 100644
--- a/dlls/mf/main.c
+++ b/dlls/mf/main.c
@@ -35,6 +35,8 @@
#include "mfapi.h"
#include "mferror.h"
+#include "mf_private.h"
+
#include "wine/debug.h"
#include "wine/heap.h"
#include "wine/unicode.h"
@@ -44,6 +46,440 @@ WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
static HINSTANCE mf_instance;
+struct activate_object
+{
+ IMFActivate IMFActivate_iface;
+ LONG refcount;
+ IMFAttributes *attributes;
+ IUnknown *object;
+ const struct activate_funcs *funcs;
+ void *context;
+};
+
+static struct activate_object *impl_from_IMFActivate(IMFActivate *iface)
+{
+ return CONTAINING_RECORD(iface, struct activate_object, IMFActivate_iface);
+}
+
+static HRESULT WINAPI activate_object_QueryInterface(IMFActivate *iface, REFIID riid, void **obj)
+{
+ TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
+
+ if (IsEqualIID(riid, &IID_IMFActivate) ||
+ IsEqualIID(riid, &IID_IMFAttributes) ||
+ IsEqualIID(riid, &IID_IUnknown))
+ {
+ *obj = iface;
+ IMFActivate_AddRef(iface);
+ return S_OK;
+ }
+
+ WARN("Unsupported %s.\n", debugstr_guid(riid));
+ *obj = NULL;
+ return E_NOINTERFACE;
+}
+
+static ULONG WINAPI activate_object_AddRef(IMFActivate *iface)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+ ULONG refcount = InterlockedIncrement(&activate->refcount);
+
+ TRACE("%p, refcount %u.\n", iface, refcount);
+
+ return refcount;
+}
+
+static ULONG WINAPI activate_object_Release(IMFActivate *iface)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+ ULONG refcount = InterlockedDecrement(&activate->refcount);
+
+ TRACE("%p, refcount %u.\n", iface, refcount);
+
+ if (!refcount)
+ {
+ activate->funcs->free_private(activate->context);
+ if (activate->object)
+ IUnknown_Release(activate->object);
+ IMFAttributes_Release(activate->attributes);
+ heap_free(activate);
+ }
+
+ return refcount;
+}
+
+static HRESULT WINAPI activate_object_GetItem(IMFActivate *iface, REFGUID key, PROPVARIANT *value)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
+
+ return IMFAttributes_GetItem(activate->attributes, key, value);
+}
+
+static HRESULT WINAPI activate_object_GetItemType(IMFActivate *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), type);
+
+ return IMFAttributes_GetItemType(activate->attributes, key, type);
+}
+
+static HRESULT WINAPI activate_object_CompareItem(IMFActivate *iface, REFGUID key, REFPROPVARIANT value, BOOL *result)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), value, result);
+
+ return IMFAttributes_CompareItem(activate->attributes, key, value, result);
+}
+
+static HRESULT WINAPI activate_object_Compare(IMFActivate *iface, IMFAttributes *theirs, MF_ATTRIBUTES_MATCH_TYPE type,
+ BOOL *result)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("%p, %p, %d, %p.\n", iface, theirs, type, result);
+
+ return IMFAttributes_Compare(activate->attributes, theirs, type, result);
+}
+
+static HRESULT WINAPI activate_object_GetUINT32(IMFActivate *iface, REFGUID key, UINT32 *value)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
+
+ return IMFAttributes_GetUINT32(activate->attributes, key, value);
+}
+
+static HRESULT WINAPI activate_object_GetUINT64(IMFActivate *iface, REFGUID key, UINT64 *value)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
+
+ return IMFAttributes_GetUINT64(activate->attributes, key, value);
+}
+
+static HRESULT WINAPI activate_object_GetDouble(IMFActivate *iface, REFGUID key, double *value)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
+
+ return IMFAttributes_GetDouble(activate->attributes, key, value);
+}
+
+static HRESULT WINAPI activate_object_GetGUID(IMFActivate *iface, REFGUID key, GUID *value)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
+
+ return IMFAttributes_GetGUID(activate->attributes, key, value);
+}
+
+static HRESULT WINAPI activate_object_GetStringLength(IMFActivate *iface, REFGUID key, UINT32 *length)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), length);
+
+ return IMFAttributes_GetStringLength(activate->attributes, key, length);
+}
+
+static HRESULT WINAPI activate_object_GetString(IMFActivate *iface, REFGUID key, WCHAR *value,
+ UINT32 size, UINT32 *length)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("%p, %s, %p, %d, %p.\n", iface, debugstr_guid(key), value, size, length);
+
+ return IMFAttributes_GetString(activate->attributes, key, value, size, length);
+}
+
+static HRESULT WINAPI activate_object_GetAllocatedString(IMFActivate *iface, REFGUID key,
+ WCHAR **value, UINT32 *length)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), value, length);
+
+ return IMFAttributes_GetAllocatedString(activate->attributes, key, value, length);
+}
+
+static HRESULT WINAPI activate_object_GetBlobSize(IMFActivate *iface, REFGUID key, UINT32 *size)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), size);
+
+ return IMFAttributes_GetBlobSize(activate->attributes, key, size);
+}
+
+static HRESULT WINAPI activate_object_GetBlob(IMFActivate *iface, REFGUID key, UINT8 *buf,
+ UINT32 bufsize, UINT32 *blobsize)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("%p, %s, %p, %d, %p.\n", iface, debugstr_guid(key), buf, bufsize, blobsize);
+
+ return IMFAttributes_GetBlob(activate->attributes, key, buf, bufsize, blobsize);
+}
+
+static HRESULT WINAPI activate_object_GetAllocatedBlob(IMFActivate *iface, REFGUID key, UINT8 **buf, UINT32 *size)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), buf, size);
+
+ return IMFAttributes_GetAllocatedBlob(activate->attributes, key, buf, size);
+}
+
+static HRESULT WINAPI activate_object_GetUnknown(IMFActivate *iface, REFGUID key, REFIID riid, void **ppv)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(key), debugstr_guid(riid), ppv);
+
+ return IMFAttributes_GetUnknown(activate->attributes, key, riid, ppv);
+}
+
+static HRESULT WINAPI activate_object_SetItem(IMFActivate *iface, REFGUID key, REFPROPVARIANT value)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
+
+ return IMFAttributes_SetItem(activate->attributes, key, value);
+}
+
+static HRESULT WINAPI activate_object_DeleteItem(IMFActivate *iface, REFGUID key)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("%p, %s.\n", iface, debugstr_guid(key));
+
+ return IMFAttributes_DeleteItem(activate->attributes, key);
+}
+
+static HRESULT WINAPI activate_object_DeleteAllItems(IMFActivate *iface)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("%p.\n", iface);
+
+ return IMFAttributes_DeleteAllItems(activate->attributes);
+}
+
+static HRESULT WINAPI activate_object_SetUINT32(IMFActivate *iface, REFGUID key, UINT32 value)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("%p, %s, %d.\n", iface, debugstr_guid(key), value);
+
+ return IMFAttributes_SetUINT32(activate->attributes, key, value);
+}
+
+static HRESULT WINAPI activate_object_SetUINT64(IMFActivate *iface, REFGUID key, UINT64 value)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), wine_dbgstr_longlong(value));
+
+ return IMFAttributes_SetUINT64(activate->attributes, key, value);
+}
+
+static HRESULT WINAPI activate_object_SetDouble(IMFActivate *iface, REFGUID key, double value)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("%p, %s, %f.\n", iface, debugstr_guid(key), value);
+
+ return IMFAttributes_SetDouble(activate->attributes, key, value);
+}
+
+static HRESULT WINAPI activate_object_SetGUID(IMFActivate *iface, REFGUID key, REFGUID value)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), debugstr_guid(value));
+
+ return IMFAttributes_SetGUID(activate->attributes, key, value);
+}
+
+static HRESULT WINAPI activate_object_SetString(IMFActivate *iface, REFGUID key, const WCHAR *value)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), debugstr_w(value));
+
+ return IMFAttributes_SetString(activate->attributes, key, value);
+}
+
+static HRESULT WINAPI activate_object_SetBlob(IMFActivate *iface, REFGUID key, const UINT8 *buf, UINT32 size)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("%p, %s, %p, %d.\n", iface, debugstr_guid(key), buf, size);
+
+ return IMFAttributes_SetBlob(activate->attributes, key, buf, size);
+}
+
+static HRESULT WINAPI activate_object_SetUnknown(IMFActivate *iface, REFGUID key, IUnknown *unknown)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(key), unknown);
+
+ return IMFAttributes_SetUnknown(activate->attributes, key, unknown);
+}
+
+static HRESULT WINAPI activate_object_LockStore(IMFActivate *iface)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("%p.\n", iface);
+
+ return IMFAttributes_LockStore(activate->attributes);
+}
+
+static HRESULT WINAPI activate_object_UnlockStore(IMFActivate *iface)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("%p.\n", iface);
+
+ return IMFAttributes_UnlockStore(activate->attributes);
+}
+
+static HRESULT WINAPI activate_object_GetCount(IMFActivate *iface, UINT32 *count)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("%p, %p.\n", iface, count);
+
+ return IMFAttributes_GetCount(activate->attributes, count);
+}
+
+static HRESULT WINAPI activate_object_GetItemByIndex(IMFActivate *iface, UINT32 index, GUID *key, PROPVARIANT *value)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("%p, %u, %p, %p.\n", iface, index, key, value);
+
+ return IMFAttributes_GetItemByIndex(activate->attributes, index, key, value);
+}
+
+static HRESULT WINAPI activate_object_CopyAllItems(IMFActivate *iface, IMFAttributes *dest)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+
+ TRACE("%p, %p.\n", iface, dest);
+
+ return IMFAttributes_CopyAllItems(activate->attributes, dest);
+}
+
+static HRESULT WINAPI activate_object_ActivateObject(IMFActivate *iface, REFIID riid, void **obj)
+{
+ struct activate_object *activate = impl_from_IMFActivate(iface);
+ IUnknown *object;
+ HRESULT hr;
+
+ TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
+
+ if (!activate->object)
+ {
+ if (FAILED(hr = activate->funcs->create_object(activate->context, &object)))
+ return hr;
+
+ if (!InterlockedCompareExchangePointer((void **)&activate->object, object, NULL))
+ IUnknown_Release(object);
+ }
+
+ return IUnknown_QueryInterface(activate->object, riid, obj);
+}
+
+static HRESULT WINAPI activate_object_ShutdownObject(IMFActivate *iface)
+{
+ FIXME("%p.\n", iface);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI activate_object_DetachObject(IMFActivate *iface)
+{
+ FIXME("%p.\n", iface);
+
+ return E_NOTIMPL;
+}
+
+static const IMFActivateVtbl activate_object_vtbl =
+{
+ activate_object_QueryInterface,
+ activate_object_AddRef,
+ activate_object_Release,
+ activate_object_GetItem,
+ activate_object_GetItemType,
+ activate_object_CompareItem,
+ activate_object_Compare,
+ activate_object_GetUINT32,
+ activate_object_GetUINT64,
+ activate_object_GetDouble,
+ activate_object_GetGUID,
+ activate_object_GetStringLength,
+ activate_object_GetString,
+ activate_object_GetAllocatedString,
+ activate_object_GetBlobSize,
+ activate_object_GetBlob,
+ activate_object_GetAllocatedBlob,
+ activate_object_GetUnknown,
+ activate_object_SetItem,
+ activate_object_DeleteItem,
+ activate_object_DeleteAllItems,
+ activate_object_SetUINT32,
+ activate_object_SetUINT64,
+ activate_object_SetDouble,
+ activate_object_SetGUID,
+ activate_object_SetString,
+ activate_object_SetBlob,
+ activate_object_SetUnknown,
+ activate_object_LockStore,
+ activate_object_UnlockStore,
+ activate_object_GetCount,
+ activate_object_GetItemByIndex,
+ activate_object_CopyAllItems,
+ activate_object_ActivateObject,
+ activate_object_ShutdownObject,
+ activate_object_DetachObject,
+};
+
+HRESULT create_activation_object(void *context, const struct activate_funcs *funcs, IMFActivate **ret)
+{
+ struct activate_object *object;
+ HRESULT hr;
+
+ object = heap_alloc_zero(sizeof(*object));
+ if (!object)
+ return E_OUTOFMEMORY;
+
+ object->IMFActivate_iface.lpVtbl = &activate_object_vtbl;
+ object->refcount = 1;
+ if (FAILED(hr = MFCreateAttributes(&object->attributes, 0)))
+ {
+ heap_free(object);
+ return hr;
+ }
+ object->funcs = funcs;
+ object->context = context;
+
+ *ret = &object->IMFActivate_iface;
+
+ return S_OK;
+}
+
struct class_factory
{
IClassFactory IClassFactory_iface;
diff --git a/dlls/mf/mf.spec b/dlls/mf/mf.spec
index 9e3f6caef8..6131495225 100644
--- a/dlls/mf/mf.spec
+++ b/dlls/mf/mf.spec
@@ -51,7 +51,7 @@
@ stub MFCreateRemoteDesktopPlugin
@ stub MFCreateSAMIByteStreamPlugin
@ stub MFCreateSampleCopierMFT
-@ stub MFCreateSampleGrabberSinkActivate
+@ stdcall MFCreateSampleGrabberSinkActivate(ptr ptr ptr)
@ stub MFCreateSecureHttpSchemePlugin
@ stub MFCreateSequencerSegmentOffset
@ stdcall MFCreateSequencerSource(ptr ptr)
diff --git a/dlls/mf/mf_private.h b/dlls/mf/mf_private.h
new file mode 100644
index 0000000000..b5b4e84bba
--- /dev/null
+++ b/dlls/mf/mf_private.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2019 Nikolay Sivov for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "mfidl.h"
+
+struct activate_funcs
+{
+ HRESULT (*create_object)(void *context, IUnknown **object);
+ void (*free_private)(void *context);
+};
+
+HRESULT create_activation_object(void *context, const struct activate_funcs *funcs, IMFActivate **ret) DECLSPEC_HIDDEN;
diff --git a/dlls/mf/samplegrabber.c b/dlls/mf/samplegrabber.c
new file mode 100644
index 0000000000..1ffa3ba0b0
--- /dev/null
+++ b/dlls/mf/samplegrabber.c
@@ -0,0 +1,83 @@
+/*
+ * Copyright 2019 Nikolay Sivov for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#define COBJMACROS
+
+#include "mfidl.h"
+#include "mf_private.h"
+
+#include "wine/debug.h"
+#include "wine/heap.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
+
+struct sample_grabber_activate_context
+{
+ IMFMediaType *media_type;
+ IMFSampleGrabberSinkCallback *callback;
+};
+
+static void sample_grabber_free_private(void *user_context)
+{
+ struct sample_grabber_activate_context *context = user_context;
+ IMFMediaType_Release(context->media_type);
+ IMFSampleGrabberSinkCallback_Release(context->callback);
+ heap_free(context);
+}
+
+static HRESULT sample_grabber_create_object(void *user_context, IUnknown **obj)
+{
+ FIXME("%p, %p.\n", user_context, obj);
+
+ return E_NOTIMPL;
+}
+
+static const struct activate_funcs sample_grabber_activate_funcs =
+{
+ sample_grabber_create_object,
+ sample_grabber_free_private,
+};
+
+/***********************************************************************
+ * MFCreateSampleGrabberSinkActivate (mf.@)
+ */
+HRESULT WINAPI MFCreateSampleGrabberSinkActivate(IMFMediaType *media_type, IMFSampleGrabberSinkCallback *callback,
+ IMFActivate **activate)
+{
+ struct sample_grabber_activate_context *context;
+ HRESULT hr;
+
+ TRACE("%p, %p, %p.\n", media_type, callback, activate);
+
+ if (!media_type || !callback || !activate)
+ return E_POINTER;
+
+ context = heap_alloc_zero(sizeof(*context));
+ if (!context)
+ return E_OUTOFMEMORY;
+
+ context->media_type = media_type;
+ IMFMediaType_AddRef(context->media_type);
+ context->callback = callback;
+ IMFSampleGrabberSinkCallback_AddRef(context->callback);
+
+ if (FAILED(hr = create_activation_object(context, &sample_grabber_activate_funcs, activate)))
+ sample_grabber_free_private(context);
+
+ return hr;
+}
diff --git a/dlls/mf/tests/mf.c b/dlls/mf/tests/mf.c
index 80dc990254..059062f698 100644
--- a/dlls/mf/tests/mf.c
+++ b/dlls/mf/tests/mf.c
@@ -940,6 +940,115 @@ todo_wine
ok(hr == S_OK, "Failed to shut down, hr %#x.\n", hr);
}
+static HRESULT WINAPI grabber_callback_QueryInterface(IMFSampleGrabberSinkCallback *iface, REFIID riid, void **obj)
+{
+ if (IsEqualIID(riid, &IID_IMFSampleGrabberSinkCallback) ||
+ IsEqualIID(riid, &IID_IMFClockStateSink) ||
+ IsEqualIID(riid, &IID_IUnknown))
+ {
+ *obj = iface;
+ IMFSampleGrabberSinkCallback_AddRef(iface);
+ return S_OK;
+ }
+
+ *obj = NULL;
+ return E_NOINTERFACE;
+}
+
+static ULONG WINAPI grabber_callback_AddRef(IMFSampleGrabberSinkCallback *iface)
+{
+ return 2;
+}
+
+static ULONG WINAPI grabber_callback_Release(IMFSampleGrabberSinkCallback *iface)
+{
+ return 1;
+}
+
+static HRESULT WINAPI grabber_callback_OnClockStart(IMFSampleGrabberSinkCallback *iface, MFTIME time, LONGLONG offset)
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI grabber_callback_OnClockStop(IMFSampleGrabberSinkCallback *iface, MFTIME time)
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI grabber_callback_OnClockPause(IMFSampleGrabberSinkCallback *iface, MFTIME time)
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI grabber_callback_OnClockRestart(IMFSampleGrabberSinkCallback *iface, MFTIME time)
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI grabber_callback_OnClockSetRate(IMFSampleGrabberSinkCallback *iface, MFTIME time, float rate)
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI grabber_callback_OnSetPresentationClock(IMFSampleGrabberSinkCallback *iface,
+ IMFPresentationClock *clock)
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI grabber_callback_OnProcessSample(IMFSampleGrabberSinkCallback *iface, REFGUID major_type,
+ DWORD sample_flags, LONGLONG sample_time, LONGLONG sample_duration, const BYTE *buffer, DWORD sample_size)
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI grabber_callback_OnShutdown(IMFSampleGrabberSinkCallback *iface)
+{
+ return E_NOTIMPL;
+}
+
+static const IMFSampleGrabberSinkCallbackVtbl grabber_callback_vtbl =
+{
+ grabber_callback_QueryInterface,
+ grabber_callback_AddRef,
+ grabber_callback_Release,
+ grabber_callback_OnClockStart,
+ grabber_callback_OnClockStop,
+ grabber_callback_OnClockPause,
+ grabber_callback_OnClockRestart,
+ grabber_callback_OnClockSetRate,
+ grabber_callback_OnSetPresentationClock,
+ grabber_callback_OnProcessSample,
+ grabber_callback_OnShutdown,
+};
+
+static IMFSampleGrabberSinkCallback grabber_callback = { &grabber_callback_vtbl };
+
+static void test_sample_grabber(void)
+{
+ IMFMediaType *media_type;
+ IMFActivate *activate;
+ ULONG refcount;
+ HRESULT hr;
+
+ hr = MFCreateMediaType(&media_type);
+ ok(hr == S_OK, "Failed to create media type, hr %#x.\n", hr);
+
+ hr = MFCreateSampleGrabberSinkActivate(NULL, NULL, &activate);
+ ok(hr == E_POINTER, "Unexpected hr %#x.\n", hr);
+
+ hr = MFCreateSampleGrabberSinkActivate(NULL, &grabber_callback, &activate);
+ ok(hr == E_POINTER, "Unexpected hr %#x.\n", hr);
+
+ hr = MFCreateSampleGrabberSinkActivate(media_type, &grabber_callback, &activate);
+ ok(hr == S_OK, "Failed to create grabber activate, hr %#x.\n", hr);
+
+ refcount = IMFMediaType_Release(media_type);
+ ok(refcount == 1, "Unexpected refcount %u.\n", refcount);
+
+ IMFActivate_Release(activate);
+}
+
START_TEST(mf)
{
test_topology();
@@ -949,4 +1058,5 @@ START_TEST(mf)
test_media_session();
test_MFShutdownObject();
test_presentation_clock();
+ test_sample_grabber();
}
diff --git a/include/mfidl.idl b/include/mfidl.idl
index 64d39db77e..2f2f17c04a 100644
--- a/include/mfidl.idl
+++ b/include/mfidl.idl
@@ -463,8 +463,30 @@ interface IMFSequencerSource : IUnknown
HRESULT UpdateTopologyFlags(
[in] MFSequencerElementId id,
[in] DWORD flags );
+}
+
+interface IMFPresentationClock;
+
+[
+ object,
+ uuid(8c7b80bf-ee42-4b59-b1df-55668e1bdca8),
+ local
+]
+interface IMFSampleGrabberSinkCallback : IMFClockStateSink
+{
+ HRESULT OnSetPresentationClock(
+ [in] IMFPresentationClock *clock);
-};
+ HRESULT OnProcessSample(
+ [in] REFGUID major_type,
+ [in] DWORD sample_flags,
+ [in] LONGLONG sample_time,
+ [in] LONGLONG sample_duration,
+ [in] const BYTE *buffer,
+ [in] DWORD sample_size);
+
+ HRESULT OnShutdown();
+}
cpp_quote("HRESULT WINAPI MFCreateMediaSession(IMFAttributes *config, IMFMediaSession **session);")
cpp_quote("HRESULT WINAPI MFCreateMFByteStreamOnStream(IStream *stream, IMFByteStream **bytestream);" )
@@ -472,6 +494,8 @@ cpp_quote("HRESULT WINAPI MFCreateMFByteStreamOnStreamEx(IUnknown *stream, IMFBy
cpp_quote("HRESULT WINAPI MFCreatePresentationClock(IMFPresentationClock **clock);")
cpp_quote("HRESULT WINAPI MFCreatePresentationDescriptor(DWORD count, IMFStreamDescriptor **descriptors,")
cpp_quote(" IMFPresentationDescriptor **presentation_desc);")
+cpp_quote("HRESULT WINAPI MFCreateSampleGrabberSinkActivate(IMFMediaType *media_type,")
+cpp_quote(" IMFSampleGrabberSinkCallback *callback, IMFActivate **activate);")
cpp_quote("HRESULT WINAPI MFCreateSequencerSource(IUnknown *reserved, IMFSequencerSource **seq_source);" )
cpp_quote("HRESULT WINAPI MFCreateSourceResolver(IMFSourceResolver **resolver);")
cpp_quote("HRESULT WINAPI MFCreateStreamDescriptor(DWORD identifier, DWORD cMediaTypes,")
--
2.20.1
