From 1fa96246825ac763333cb5c01f3b8b8d25649619 Mon Sep 17 00:00:00 2001 From: Lionel Ulmer <lionel.ulmer@free.fr> Date: Fri, 13 Jun 2003 18:06:44 +0000 Subject: [PATCH] Stubbed some interfaces for the FilterGraph CLSID. --- dlls/quartz/Makefile.in | 3 + dlls/quartz/filtergraph.c | 1939 ++++++++++++++++++++++++++++++++++ dlls/quartz/main.c | 195 +++- dlls/quartz/quartz_private.h | 45 + include/Makefile.in | 2 + include/control.h | 345 ++++++ include/dshow.h | 10 +- include/strmif.h | 388 +++++++ include/uuids.h | 8 + winedefault.reg | 11 + 10 files changed, 2929 insertions(+), 17 deletions(-) create mode 100644 dlls/quartz/filtergraph.c create mode 100644 dlls/quartz/quartz_private.h create mode 100644 include/control.h create mode 100644 include/strmif.h diff --git a/dlls/quartz/Makefile.in b/dlls/quartz/Makefile.in index 3e51f7103c8..c4ad36bc3f8 100644 --- a/dlls/quartz/Makefile.in +++ b/dlls/quartz/Makefile.in @@ -3,11 +3,14 @@ TOPOBJDIR = ../.. SRCDIR = @srcdir@ VPATH = @srcdir@ MODULE = quartz.dll +IMPORTS = kernel32 +EXTRALIBS = $(LIBUUID) LDDLLFLAGS = @LDDLLFLAGS@ SYMBOLFILE = $(MODULE).tmp.o C_SRCS = \ + filtergraph.c \ main.c @MAKE_DLL_RULES@ diff --git a/dlls/quartz/filtergraph.c b/dlls/quartz/filtergraph.c new file mode 100644 index 00000000000..78719f55e3b --- /dev/null +++ b/dlls/quartz/filtergraph.c @@ -0,0 +1,1939 @@ +/* DirectShow FilterGraph object (QUARTZ.DLL) + * + * Copyright 2002 Lionel Ulmer + * + * This file contains the (internal) driver registration functions, + * driver enumeration APIs and DirectDraw creation functions. + * + * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "config.h" +#include "dshow.h" +#include "wine/debug.h" + +#include "quartz_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(quartz); + +static HRESULT Filtergraph_QueryInterface(IFilterGraphImpl *This, + REFIID riid, + LPVOID *ppvObj) { + TRACE("(%p)->(%s (%p), %p)\n", This, debugstr_guid(riid), riid, ppvObj); + + if (IsEqualGUID(&IID_IUnknown, riid) || + IsEqualGUID(&IID_IGraphBuilder, riid)) { + *ppvObj = &(This->IGraphBuilder_vtbl); + TRACE(" returning IGraphBuilder interface (%p)\n", *ppvObj); + } else if (IsEqualGUID(&IID_IMediaControl, riid)) { + *ppvObj = &(This->IMediaControl_vtbl); + TRACE(" returning IMediaControl interface (%p)\n", *ppvObj); + } else if (IsEqualGUID(&IID_IMediaSeeking, riid)) { + *ppvObj = &(This->IMediaSeeking_vtbl); + TRACE(" returning IMediaSeeking interface (%p)\n", *ppvObj); + } else if (IsEqualGUID(&IID_IBasicAudio, riid)) { + *ppvObj = &(This->IBasicAudio_vtbl); + TRACE(" returning IBasicAudio interface (%p)\n", *ppvObj); + } else if (IsEqualGUID(&IID_IBasicVideo, riid)) { + *ppvObj = &(This->IBasicVideo_vtbl); + TRACE(" returning IBasicVideo interface (%p)\n", *ppvObj); + } else if (IsEqualGUID(&IID_IVideoWindow, riid)) { + *ppvObj = &(This->IVideoWindow_vtbl); + TRACE(" returning IVideoWindow interface (%p)\n", *ppvObj); + } else if (IsEqualGUID(&IID_IMediaEvent, riid) || + IsEqualGUID(&IID_IMediaEventEx, riid)) { + *ppvObj = &(This->IMediaEventEx_vtbl); + TRACE(" returning IMediaEvent(Ex) interface (%p)\n", *ppvObj); + } else { + *ppvObj = NULL; + FIXME(" unknown interface !\n"); + return E_NOINTERFACE; + } + + This->ref++; + return S_OK; +} + +static ULONG Filtergraph_AddRef(IFilterGraphImpl *This) { + TRACE("(%p)->(): new ref = %ld\n", This, This->ref + 1); + + return ++This->ref; +} + +static ULONG Filtergraph_Release(IFilterGraphImpl *This) { + static ULONG ref; + + TRACE("(%p)->(): new ref = %ld\n", This, This->ref - 1); + + ref = --This->ref; + if (ref == 0) { + HeapFree(GetProcessHeap(), 0, This); + } + return ref; +} + + +/*** IUnknown methods ***/ +static HRESULT WINAPI Graphbuilder_QueryInterface(IGraphBuilder *iface, + REFIID riid, + LPVOID*ppvObj) { + ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface); + + TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj); + return Filtergraph_QueryInterface(This, riid, ppvObj); +} + +static ULONG WINAPI Graphbuilder_AddRef(IGraphBuilder *iface) { + ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface); + + TRACE("(%p/%p)->() calling FilterGraph AddRef\n", This, iface); + + return Filtergraph_AddRef(This); +} + +static ULONG WINAPI Graphbuilder_Release(IGraphBuilder *iface) { + ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface); + + TRACE("(%p/%p)->() calling FilterGraph Release\n", This, iface); + + return Filtergraph_Release(This); +} + +/*** IFilterGraph methods ***/ +static HRESULT WINAPI Graphbuilder_AddFilter(IGraphBuilder *iface, + IBaseFilter *pFilter, + LPCWSTR pName) { + ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface); + + TRACE("(%p/%p)->(%p, %s (%p)): stub !!!\n", This, iface, pFilter, debugstr_w(pName), pName); + + return S_OK; +} + +static HRESULT WINAPI Graphbuilder_RemoveFilter(IGraphBuilder *iface, + IBaseFilter *pFilter) { + ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pFilter); + + return S_OK; +} + +static HRESULT WINAPI Graphbuilder_EnumFilter(IGraphBuilder *iface, + IEnumFilters **ppEnum) { + ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, ppEnum); + + return S_OK; +} + +static HRESULT WINAPI Graphbuilder_FindFilterByName(IGraphBuilder *iface, + LPCWSTR pName, + IBaseFilter **ppFilter) { + ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface); + + TRACE("(%p/%p)->(%s (%p), %p): stub !!!\n", This, iface, debugstr_w(pName), pName, ppFilter); + + return S_OK; +} + +static HRESULT WINAPI Graphbuilder_ConnectDirect(IGraphBuilder *iface, + IPin *ppinIn, + IPin *ppinOut, + const AM_MEDIA_TYPE *pmt) { + ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface); + + TRACE("(%p/%p)->(%p, %p, %p): stub !!!\n", This, iface, ppinIn, ppinOut, pmt); + + return S_OK; +} + +static HRESULT WINAPI Graphbuilder_Reconnect(IGraphBuilder *iface, + IPin *ppin) { + ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, ppin); + + return S_OK; +} + +static HRESULT WINAPI Graphbuilder_Disconnect(IGraphBuilder *iface, + IPin *ppin) { + ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, ppin); + + return S_OK; +} + +static HRESULT WINAPI Graphbuilder_SetDefaultSyncSource(IGraphBuilder *iface) { + ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface); + + TRACE("(%p/%p)->(): stub !!!\n", iface, This); + + return S_OK; +} + +/*** IGraphBuilder methods ***/ +static HRESULT WINAPI Graphbuilder_Connect(IGraphBuilder *iface, + IPin *ppinOut, + IPin *ppinIn) { + ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface); + + TRACE("(%p/%p)->(%p, %p): stub !!!\n", This, iface, ppinOut, ppinIn); + + return S_OK; +} + +static HRESULT WINAPI Graphbuilder_Render(IGraphBuilder *iface, + IPin *ppinOut) { + ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, ppinOut); + + return S_OK; +} + +static HRESULT WINAPI Graphbuilder_RenderFile(IGraphBuilder *iface, + LPCWSTR lpcwstrFile, + LPCWSTR lpcwstrPlayList) { + ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface); + + TRACE("(%p/%p)->(%s (%p), %s (%p)): stub !!!\n", This, iface, debugstr_w(lpcwstrFile), lpcwstrFile, debugstr_w(lpcwstrPlayList), lpcwstrPlayList); + + return S_OK; +} + +static HRESULT WINAPI Graphbuilder_AddSourceFilter(IGraphBuilder *iface, + LPCWSTR lpcwstrFileName, + LPCWSTR lpcwstrFilterName, + IBaseFilter **ppFilter) { + ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface); + + TRACE("(%p/%p)->(%s (%p), %s (%p), %p): stub !!!\n", This, iface, debugstr_w(lpcwstrFileName), lpcwstrFileName, debugstr_w(lpcwstrFilterName), lpcwstrFilterName, ppFilter); + + return S_OK; +} + +static HRESULT WINAPI Graphbuilder_SetLogFile(IGraphBuilder *iface, + DWORD_PTR hFile) { + ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface); + + TRACE("(%p/%p)->(%08lx): stub !!!\n", This, iface, (DWORD) hFile); + + return S_OK; +} + +static HRESULT WINAPI Graphbuilder_Abort(IGraphBuilder *iface) { + ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface); + + TRACE("(%p/%p)->(): stub !!!\n", This, iface); + + return S_OK; +} + +static HRESULT WINAPI Graphbuilder_ShouldOperationContinue(IGraphBuilder *iface) { + ICOM_THIS_MULTI(IFilterGraphImpl, IGraphBuilder_vtbl, iface); + + TRACE("(%p/%p)->(): stub !!!\n", This, iface); + + return S_OK; +} + + +static ICOM_VTABLE(IGraphBuilder) IGraphBuilder_VTable = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + Graphbuilder_QueryInterface, + Graphbuilder_AddRef, + Graphbuilder_Release, + Graphbuilder_AddFilter, + Graphbuilder_RemoveFilter, + Graphbuilder_EnumFilter, + Graphbuilder_FindFilterByName, + Graphbuilder_ConnectDirect, + Graphbuilder_Reconnect, + Graphbuilder_Disconnect, + Graphbuilder_SetDefaultSyncSource, + Graphbuilder_Connect, + Graphbuilder_Render, + Graphbuilder_RenderFile, + Graphbuilder_AddSourceFilter, + Graphbuilder_SetLogFile, + Graphbuilder_Abort, + Graphbuilder_ShouldOperationContinue +}; + +/*** IUnknown methods ***/ +static HRESULT WINAPI Mediacontrol_QueryInterface(IMediaControl *iface, + REFIID riid, + LPVOID*ppvObj) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface); + + TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj); + + return Filtergraph_QueryInterface(This, riid, ppvObj); +} + +static ULONG WINAPI Mediacontrol_AddRef(IMediaControl *iface) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface); + + TRACE("(%p/%p)->()\n", This, iface); + + return Filtergraph_AddRef(This); +} + +static ULONG WINAPI Mediacontrol_Release(IMediaControl *iface) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface); + + TRACE("(%p/%p)->()\n", This, iface); + + return Filtergraph_Release(This); + +} + +/*** IDispatch methods ***/ +static HRESULT WINAPI Mediacontrol_GetTypeInfoCount(IMediaControl *iface, + UINT*pctinfo) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo); + + return S_OK; +} + +static HRESULT WINAPI Mediacontrol_GetTypeInfo(IMediaControl *iface, + UINT iTInfo, + LCID lcid, + ITypeInfo**ppTInfo) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface); + + TRACE("(%p/%p)->(%d, %ld, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo); + + return S_OK; +} + +static HRESULT WINAPI Mediacontrol_GetIDsOfNames(IMediaControl *iface, + REFIID riid, + LPOLESTR*rgszNames, + UINT cNames, + LCID lcid, + DISPID*rgDispId) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface); + + TRACE("(%p/%p)->(%s (%p), %p, %d, %ld, %p): stub !!!\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId); + + return S_OK; +} + +static HRESULT WINAPI Mediacontrol_Invoke(IMediaControl *iface, + DISPID dispIdMember, + REFIID riid, + LCID lcid, + WORD wFlags, + DISPPARAMS*pDispParams, + VARIANT*pVarResult, + EXCEPINFO*pExepInfo, + UINT*puArgErr) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface); + + TRACE("(%p/%p)->(%ld, %s (%p), %ld, %04x, %p, %p, %p, %p): stub !!!\n", This, iface, dispIdMember, debugstr_guid(riid), riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr); + + return S_OK; +} + +/*** IMediaControl methods ***/ +static HRESULT WINAPI Mediacontrol_Run(IMediaControl *iface) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface); + + TRACE("(%p/%p)->(): stub !!!\n", This, iface); + + return S_OK; +} + +static HRESULT WINAPI Mediacontrol_Pause(IMediaControl *iface) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface); + + TRACE("(%p/%p)->(): stub !!!\n", This, iface); + + return S_OK; +} + +static HRESULT WINAPI Mediacontrol_Stop(IMediaControl *iface) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface); + + TRACE("(%p/%p)->(): stub !!!\n", This, iface); + + return S_OK; +} + +static HRESULT WINAPI Mediacontrol_GetState(IMediaControl *iface, + LONG msTimeout, + OAFilterState *pfs) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface); + + TRACE("(%p/%p)->(%ld, %p): stub !!!\n", This, iface, msTimeout, pfs); + + return S_OK; +} + +static HRESULT WINAPI Mediacontrol_RenderFile(IMediaControl *iface, + BSTR strFilename) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface); + + TRACE("(%p/%p)->(%s (%p)): stub !!!\n", This, iface, debugstr_w(strFilename), strFilename); + + return S_OK; +} + +static HRESULT WINAPI Mediacontrol_AddSourceFilter(IMediaControl *iface, + BSTR strFilename, + IDispatch **ppUnk) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface); + + TRACE("(%p/%p)->(%s (%p), %p): stub !!!\n", This, iface, debugstr_w(strFilename), strFilename, ppUnk); + + return S_OK; +} + +static HRESULT WINAPI Mediacontrol_get_FilterCollection(IMediaControl *iface, + IDispatch **ppUnk) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, ppUnk); + + return S_OK; +} + +static HRESULT WINAPI Mediacontrol_get_RegFilterCollection(IMediaControl *iface, + IDispatch **ppUnk) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, ppUnk); + + return S_OK; +} + +static HRESULT WINAPI Mediacontrol_StopWhenReady(IMediaControl *iface) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface); + + TRACE("(%p/%p)->(): stub !!!\n", This, iface); + + return S_OK; +} + + +static ICOM_VTABLE(IMediaControl) IMediaControl_VTable = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + Mediacontrol_QueryInterface, + Mediacontrol_AddRef, + Mediacontrol_Release, + Mediacontrol_GetTypeInfoCount, + Mediacontrol_GetTypeInfo, + Mediacontrol_GetIDsOfNames, + Mediacontrol_Invoke, + Mediacontrol_Run, + Mediacontrol_Pause, + Mediacontrol_Stop, + Mediacontrol_GetState, + Mediacontrol_RenderFile, + Mediacontrol_AddSourceFilter, + Mediacontrol_get_FilterCollection, + Mediacontrol_get_RegFilterCollection, + Mediacontrol_StopWhenReady +}; + + +/*** IUnknown methods ***/ +static HRESULT WINAPI Mediaseeking_QueryInterface(IMediaSeeking *iface, + REFIID riid, + LPVOID*ppvObj) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface); + + TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj); + + return Filtergraph_QueryInterface(This, riid, ppvObj); +} + +static ULONG WINAPI Mediaseeking_AddRef(IMediaSeeking *iface) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface); + + TRACE("(%p/%p)->()\n", This, iface); + + return Filtergraph_AddRef(This); +} + +static ULONG WINAPI Mediaseeking_Release(IMediaSeeking *iface) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface); + + TRACE("(%p/%p)->()\n", This, iface); + + return Filtergraph_Release(This); +} + +/*** IMediaSeeking methods ***/ +static HRESULT WINAPI Mediaseeking_GetCapabilities(IMediaSeeking *iface, + DWORD *pCapabilities) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pCapabilities); + + return S_OK; +} + +static HRESULT WINAPI Mediaseeking_CheckCapabilities(IMediaSeeking *iface, + DWORD *pCapabilities) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pCapabilities); + + return S_OK; +} + +static HRESULT WINAPI Mediaseeking_IsFormatSupported(IMediaSeeking *iface, + GUID *pFormat) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pFormat); + + return S_OK; +} + +static HRESULT WINAPI Mediaseeking_QueryPreferredFormat(IMediaSeeking *iface, + GUID *pFormat) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pFormat); + + return S_OK; +} + +static HRESULT WINAPI Mediaseeking_GetTimeFormat(IMediaSeeking *iface, + GUID *pFormat) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pFormat); + + return S_OK; +} + +static HRESULT WINAPI Mediaseeking_IsUsingTimeFormat(IMediaSeeking *iface, + GUID *pFormat) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pFormat); + + return S_OK; +} + +static HRESULT WINAPI Mediaseeking_SetTimeFormat(IMediaSeeking *iface, + GUID *pFormat) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pFormat); + + return S_OK; +} + +static HRESULT WINAPI Mediaseeking_GetDuration(IMediaSeeking *iface, + LONGLONG *pDuration) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pDuration); + + return S_OK; +} + +static HRESULT WINAPI Mediaseeking_GetStopPosition(IMediaSeeking *iface, + LONGLONG *pStop) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pStop); + + return S_OK; +} + +static HRESULT WINAPI Mediaseeking_GetCurrentPosition(IMediaSeeking *iface, + LONGLONG *pCurrent) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pCurrent); + + return S_OK; +} + +static HRESULT WINAPI Mediaseeking_ConvertTimeFormat(IMediaSeeking *iface, + LONGLONG *pTarget, + GUID *pTargetFormat, + LONGLONG Source, + GUID *pSourceFormat) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface); + + TRACE("(%p/%p)->(%p, %p, %lld, %p): stub !!!\n", This, iface, pTarget, pTargetFormat, Source, pSourceFormat); + + return S_OK; +} + +static HRESULT WINAPI Mediaseeking_SetPositions(IMediaSeeking *iface, + LONGLONG *pCurrent, + DWORD dwCurrentFlags, + LONGLONG *pStop, + DWORD dwStopFlags) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface); + + TRACE("(%p/%p)->(%p, %08lx, %p, %08lx): stub !!!\n", This, iface, pCurrent, dwCurrentFlags, pStop, dwStopFlags); + + return S_OK; +} + +static HRESULT WINAPI Mediaseeking_GetPositions(IMediaSeeking *iface, + LONGLONG *pCurrent, + LONGLONG *pStop) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface); + + TRACE("(%p/%p)->(%p, %p): stub !!!\n", This, iface, pCurrent, pStop); + + return S_OK; +} + +static HRESULT WINAPI Mediaseeking_GetAvailable(IMediaSeeking *iface, + LONGLONG *pEarliest, + LONGLONG *pLatest) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface); + + TRACE("(%p/%p)->(%p, %p): stub !!!\n", This, iface, pEarliest, pLatest); + + return S_OK; +} + +static HRESULT WINAPI Mediaseeking_SetRate(IMediaSeeking *iface, + double dRate) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface); + + TRACE("(%p/%p)->(%f): stub !!!\n", This, iface, dRate); + + return S_OK; +} + +static HRESULT WINAPI Mediaseeking_GetRate(IMediaSeeking *iface, + double *pdRate) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pdRate); + + return S_OK; +} + +static HRESULT WINAPI Mediaseeking_GetPreroll(IMediaSeeking *iface, + LONGLONG *pllPreroll) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaSeeking_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pllPreroll); + + return S_OK; +} + + +static ICOM_VTABLE(IMediaSeeking) IMediaSeeking_VTable = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + Mediaseeking_QueryInterface, + Mediaseeking_AddRef, + Mediaseeking_Release, + Mediaseeking_GetCapabilities, + Mediaseeking_CheckCapabilities, + Mediaseeking_IsFormatSupported, + Mediaseeking_QueryPreferredFormat, + Mediaseeking_GetTimeFormat, + Mediaseeking_IsUsingTimeFormat, + Mediaseeking_SetTimeFormat, + Mediaseeking_GetDuration, + Mediaseeking_GetStopPosition, + Mediaseeking_GetCurrentPosition, + Mediaseeking_ConvertTimeFormat, + Mediaseeking_SetPositions, + Mediaseeking_GetPositions, + Mediaseeking_GetAvailable, + Mediaseeking_SetRate, + Mediaseeking_GetRate, + Mediaseeking_GetPreroll +}; + +/*** IUnknown methods ***/ +static HRESULT WINAPI Basicaudio_QueryInterface(IBasicAudio *iface, + REFIID riid, + LPVOID*ppvObj) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface); + + TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj); + + return Filtergraph_QueryInterface(This, riid, ppvObj); +} + +static ULONG WINAPI Basicaudio_AddRef(IBasicAudio *iface) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface); + + TRACE("(%p/%p)->()\n", This, iface); + + return Filtergraph_AddRef(This); +} + +static ULONG WINAPI Basicaudio_Release(IBasicAudio *iface) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface); + + TRACE("(%p/%p)->()\n", This, iface); + + return Filtergraph_Release(This); +} + +/*** IDispatch methods ***/ +static HRESULT WINAPI Basicaudio_GetTypeInfoCount(IBasicAudio *iface, + UINT*pctinfo) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo); + + return S_OK; +} + +static HRESULT WINAPI Basicaudio_GetTypeInfo(IBasicAudio *iface, + UINT iTInfo, + LCID lcid, + ITypeInfo**ppTInfo) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface); + + TRACE("(%p/%p)->(%d, %ld, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo); + + return S_OK; +} + +static HRESULT WINAPI Basicaudio_GetIDsOfNames(IBasicAudio *iface, + REFIID riid, + LPOLESTR*rgszNames, + UINT cNames, + LCID lcid, + DISPID*rgDispId) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface); + + TRACE("(%p/%p)->(%s (%p), %p, %d, %ld, %p): stub !!!\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId); + + return S_OK; +} + +static HRESULT WINAPI Basicaudio_Invoke(IBasicAudio *iface, + DISPID dispIdMember, + REFIID riid, + LCID lcid, + WORD wFlags, + DISPPARAMS*pDispParams, + VARIANT*pVarResult, + EXCEPINFO*pExepInfo, + UINT*puArgErr) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface); + + TRACE("(%p/%p)->(%ld, %s (%p), %ld, %04x, %p, %p, %p, %p): stub !!!\n", This, iface, dispIdMember, debugstr_guid(riid), riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr); + + return S_OK; +} + +/*** IBasicAudio methods ***/ +static HRESULT WINAPI Basicaudio_put_Volume(IBasicAudio *iface, + long lVolume) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface); + + TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, lVolume); + + return S_OK; +} + +static HRESULT WINAPI Basicaudio_get_Volume(IBasicAudio *iface, + long *plVolume) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, plVolume); + + return S_OK; +} + +static HRESULT WINAPI Basicaudio_put_Balance(IBasicAudio *iface, + long lBalance) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface); + + TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, lBalance); + + return S_OK; +} + +static HRESULT WINAPI Basicaudio_get_Balance(IBasicAudio *iface, + long *plBalance) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicAudio_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, plBalance); + + return S_OK; +} + +static ICOM_VTABLE(IBasicAudio) IBasicAudio_VTable = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + Basicaudio_QueryInterface, + Basicaudio_AddRef, + Basicaudio_Release, + Basicaudio_GetTypeInfoCount, + Basicaudio_GetTypeInfo, + Basicaudio_GetIDsOfNames, + Basicaudio_Invoke, + Basicaudio_put_Volume, + Basicaudio_get_Volume, + Basicaudio_put_Balance, + Basicaudio_get_Balance +}; + +/*** IUnknown methods ***/ +static HRESULT WINAPI Basicvideo_QueryInterface(IBasicVideo *iface, + REFIID riid, + LPVOID*ppvObj) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj); + + return Filtergraph_QueryInterface(This, riid, ppvObj); +} + +static ULONG WINAPI Basicvideo_AddRef(IBasicVideo *iface) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->()\n", This, iface); + + return Filtergraph_AddRef(This); +} + +static ULONG WINAPI Basicvideo_Release(IBasicVideo *iface) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->()\n", This, iface); + + return Filtergraph_Release(This); +} + +/*** IDispatch methods ***/ +static HRESULT WINAPI Basicvideo_GetTypeInfoCount(IBasicVideo *iface, + UINT*pctinfo) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_GetTypeInfo(IBasicVideo *iface, + UINT iTInfo, + LCID lcid, + ITypeInfo**ppTInfo) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%d, %ld, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_GetIDsOfNames(IBasicVideo *iface, + REFIID riid, + LPOLESTR*rgszNames, + UINT cNames, + LCID lcid, + DISPID*rgDispId) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%s (%p), %p, %d, %ld, %p): stub !!!\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_Invoke(IBasicVideo *iface, + DISPID dispIdMember, + REFIID riid, + LCID lcid, + WORD wFlags, + DISPPARAMS*pDispParams, + VARIANT*pVarResult, + EXCEPINFO*pExepInfo, + UINT*puArgErr) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%ld, %s (%p), %ld, %04x, %p, %p, %p, %p): stub !!!\n", This, iface, dispIdMember, debugstr_guid(riid), riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr); + + return S_OK; +} + +/*** IBasicVideo methods ***/ +static HRESULT WINAPI Basicvideo_get_AvgTimePerFrame(IBasicVideo *iface, + REFTIME *pAvgTimePerFrame) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pAvgTimePerFrame); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_get_BitRate(IBasicVideo *iface, + long *pBitRate) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pBitRate); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_get_BitErrorRate(IBasicVideo *iface, + long *pBitErrorRate) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pBitErrorRate); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_get_VideoWidth(IBasicVideo *iface, + long *pVideoWidth) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pVideoWidth); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_get_VideoHeight(IBasicVideo *iface, + long *pVideoHeight) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pVideoHeight); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_put_SourceLeft(IBasicVideo *iface, + long SourceLeft) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, SourceLeft); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_get_SourceLeft(IBasicVideo *iface, + long *pSourceLeft) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pSourceLeft); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_put_SourceWidth(IBasicVideo *iface, + long SourceWidth) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, SourceWidth); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_get_SourceWidth(IBasicVideo *iface, + long *pSourceWidth) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pSourceWidth); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_put_SourceTop(IBasicVideo *iface, + long SourceTop) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, SourceTop); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_get_SourceTop(IBasicVideo *iface, + long *pSourceTop) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pSourceTop); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_put_SourceHeight(IBasicVideo *iface, + long SourceHeight) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, SourceHeight); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_get_SourceHeight(IBasicVideo *iface, + long *pSourceHeight) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pSourceHeight); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_put_DestinationLeft(IBasicVideo *iface, + long DestinationLeft) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, DestinationLeft); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_get_DestinationLeft(IBasicVideo *iface, + long *pDestinationLeft) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pDestinationLeft); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_put_DestinationWidth(IBasicVideo *iface, + long DestinationWidth) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, DestinationWidth); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_get_DestinationWidth(IBasicVideo *iface, + long *pDestinationWidth) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pDestinationWidth); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_put_DestinationTop(IBasicVideo *iface, + long DestinationTop) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, DestinationTop); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_get_DestinationTop(IBasicVideo *iface, + long *pDestinationTop) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pDestinationTop); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_put_DestinationHeight(IBasicVideo *iface, + long DestinationHeight) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, DestinationHeight); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_get_DestinationHeight(IBasicVideo *iface, + long *pDestinationHeight) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pDestinationHeight); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_SetSourcePosition(IBasicVideo *iface, + long Left, + long Top, + long Width, + long Height) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%ld, %ld, %ld, %ld): stub !!!\n", This, iface, Left, Top, Width, Height); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_GetSourcePosition(IBasicVideo *iface, + long *pLeft, + long *pTop, + long *pWidth, + long *pHeight) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%p, %p, %p, %p): stub !!!\n", This, iface, pLeft, pTop, pWidth, pHeight); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_SetDefaultSourcePosition(IBasicVideo *iface) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(): stub !!!\n", This, iface); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_SetDestinationPosition(IBasicVideo *iface, + long Left, + long Top, + long Width, + long Height) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%ld, %ld, %ld, %ld): stub !!!\n", This, iface, Left, Top, Width, Height); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_GetDestinationPosition(IBasicVideo *iface, + long *pLeft, + long *pTop, + long *pWidth, + long *pHeight) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%p, %p, %p, %p): stub !!!\n", This, iface, pLeft, pTop, pWidth, pHeight); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_SetDefaultDestinationPosition(IBasicVideo *iface) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(): stub !!!\n", This, iface); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_GetVideoSize(IBasicVideo *iface, + long *pWidth, + long *pHeight) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%p, %p): stub !!!\n", This, iface, pWidth, pHeight); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_GetVideoPaletteEntries(IBasicVideo *iface, + long StartIndex, + long Entries, + long *pRetrieved, + long *pPalette) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%ld, %ld, %p, %p): stub !!!\n", This, iface, StartIndex, Entries, pRetrieved, pPalette); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_GetCurrentImage(IBasicVideo *iface, + long *pBufferSize, + long *pDIBImage) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(%p, %p): stub !!!\n", This, iface, pBufferSize, pDIBImage); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_IsUsingDefaultSource(IBasicVideo *iface) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(): stub !!!\n", This, iface); + + return S_OK; +} + +static HRESULT WINAPI Basicvideo_IsUsingDefaultDestination(IBasicVideo *iface) { + ICOM_THIS_MULTI(IFilterGraphImpl, IBasicVideo_vtbl, iface); + + TRACE("(%p/%p)->(): stub !!!\n", This, iface); + + return S_OK; +} + + +static ICOM_VTABLE(IBasicVideo) IBasicVideo_VTable = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + Basicvideo_QueryInterface, + Basicvideo_AddRef, + Basicvideo_Release, + Basicvideo_GetTypeInfoCount, + Basicvideo_GetTypeInfo, + Basicvideo_GetIDsOfNames, + Basicvideo_Invoke, + Basicvideo_get_AvgTimePerFrame, + Basicvideo_get_BitRate, + Basicvideo_get_BitErrorRate, + Basicvideo_get_VideoWidth, + Basicvideo_get_VideoHeight, + Basicvideo_put_SourceLeft, + Basicvideo_get_SourceLeft, + Basicvideo_put_SourceWidth, + Basicvideo_get_SourceWidth, + Basicvideo_put_SourceTop, + Basicvideo_get_SourceTop, + Basicvideo_put_SourceHeight, + Basicvideo_get_SourceHeight, + Basicvideo_put_DestinationLeft, + Basicvideo_get_DestinationLeft, + Basicvideo_put_DestinationWidth, + Basicvideo_get_DestinationWidth, + Basicvideo_put_DestinationTop, + Basicvideo_get_DestinationTop, + Basicvideo_put_DestinationHeight, + Basicvideo_get_DestinationHeight, + Basicvideo_SetSourcePosition, + Basicvideo_GetSourcePosition, + Basicvideo_SetDefaultSourcePosition, + Basicvideo_SetDestinationPosition, + Basicvideo_GetDestinationPosition, + Basicvideo_SetDefaultDestinationPosition, + Basicvideo_GetVideoSize, + Basicvideo_GetVideoPaletteEntries, + Basicvideo_GetCurrentImage, + Basicvideo_IsUsingDefaultSource, + Basicvideo_IsUsingDefaultDestination +}; + + +/*** IUnknown methods ***/ +static HRESULT WINAPI Videowindow_QueryInterface(IVideoWindow *iface, + REFIID riid, + LPVOID*ppvObj) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj); + + return Filtergraph_QueryInterface(This, riid, ppvObj); +} + +static ULONG WINAPI Videowindow_AddRef(IVideoWindow *iface) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->()\n", This, iface); + + return Filtergraph_AddRef(This); +} + +static ULONG WINAPI Videowindow_Release(IVideoWindow *iface) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->()\n", This, iface); + + return Filtergraph_Release(This); +} + +/*** IDispatch methods ***/ +static HRESULT WINAPI Videowindow_GetTypeInfoCount(IVideoWindow *iface, + UINT*pctinfo) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_GetTypeInfo(IVideoWindow *iface, + UINT iTInfo, + LCID lcid, + ITypeInfo**ppTInfo) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%d, %ld, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_GetIDsOfNames(IVideoWindow *iface, + REFIID riid, + LPOLESTR*rgszNames, + UINT cNames, + LCID lcid, + DISPID*rgDispId) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%s (%p), %p, %d, %ld, %p): stub !!!\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_Invoke(IVideoWindow *iface, + DISPID dispIdMember, + REFIID riid, + LCID lcid, + WORD wFlags, + DISPPARAMS*pDispParams, + VARIANT*pVarResult, + EXCEPINFO*pExepInfo, + UINT*puArgErr) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%ld, %s (%p), %ld, %04x, %p, %p, %p, %p): stub !!!\n", This, iface, dispIdMember, debugstr_guid(riid), riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr); + + return S_OK; +} + +/*** IVideoWindow methods ***/ +static HRESULT WINAPI Videowindow_put_Caption(IVideoWindow *iface, + BSTR strCaption) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%s (%p)): stub !!!\n", This, iface, debugstr_w(strCaption), strCaption); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_get_Caption(IVideoWindow *iface, + BSTR *strCaption) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, strCaption); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_put_WindowStyle(IVideoWindow *iface, + long WindowStyle) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, WindowStyle); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_get_WindowStyle(IVideoWindow *iface, + long *WindowStyle) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, WindowStyle); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_put_WindowStyleEx(IVideoWindow *iface, + long WindowStyleEx) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, WindowStyleEx); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_get_WindowStyleEx(IVideoWindow *iface, + long *WindowStyleEx) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, WindowStyleEx); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_put_AutoShow(IVideoWindow *iface, + long AutoShow) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, AutoShow); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_get_AutoShow(IVideoWindow *iface, + long *AutoShow) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, AutoShow); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_put_WindowState(IVideoWindow *iface, + long WindowState) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, WindowState); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_get_WindowState(IVideoWindow *iface, + long *WindowState) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, WindowState); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_put_BackgroundPalette(IVideoWindow *iface, + long BackgroundPalette) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, BackgroundPalette); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_get_BackgroundPalette(IVideoWindow *iface, + long *pBackgroundPalette) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pBackgroundPalette); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_put_Visible(IVideoWindow *iface, + long Visible) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, Visible); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_get_Visible(IVideoWindow *iface, + long *pVisible) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pVisible); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_put_Left(IVideoWindow *iface, + long Left) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, Left); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_get_Left(IVideoWindow *iface, + long *pLeft) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pLeft); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_put_Width(IVideoWindow *iface, + long Width) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, Width); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_get_Width(IVideoWindow *iface, + long *pWidth) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pWidth); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_put_Top(IVideoWindow *iface, + long Top) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, Top); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_get_Top(IVideoWindow *iface, + long *pTop) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pTop); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_put_Height(IVideoWindow *iface, + long Height) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, Height); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_get_Height(IVideoWindow *iface, + long *pHeight) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pHeight); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_put_Owner(IVideoWindow *iface, + OAHWND Owner) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%08lx): stub !!!\n", This, iface, (DWORD) Owner); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_get_Owner(IVideoWindow *iface, + OAHWND *Owner) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%08lx): stub !!!\n", This, iface, (DWORD) Owner); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_put_MessageDrain(IVideoWindow *iface, + OAHWND Drain) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%08lx): stub !!!\n", This, iface, (DWORD) Drain); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_get_MessageDrain(IVideoWindow *iface, + OAHWND *Drain) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, Drain); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_get_BorderColor(IVideoWindow *iface, + long *Color) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, Color); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_put_BorderColor(IVideoWindow *iface, + long Color) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, Color); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_get_FullScreenMode(IVideoWindow *iface, + long *FullScreenMode) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, FullScreenMode); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_put_FullScreenMode(IVideoWindow *iface, + long FullScreenMode) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, FullScreenMode); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_SetWindowForeground(IVideoWindow *iface, + long Focus) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, Focus); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_NotifyOwnerMessage(IVideoWindow *iface, + OAHWND hwnd, + long uMsg, + LONG_PTR wParam, + LONG_PTR lParam) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%08lx, %ld, %08lx, %08lx): stub !!!\n", This, iface, (DWORD) hwnd, uMsg, wParam, lParam); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_SetWindowPosition(IVideoWindow *iface, + long Left, + long Top, + long Width, + long Height) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%ld, %ld, %ld, %ld): stub !!!\n", This, iface, Left, Top, Width, Height); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_GetWindowPosition(IVideoWindow *iface, + long *pLeft, + long *pTop, + long *pWidth, + long *pHeight) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%p, %p, %p, %p): stub !!!\n", This, iface, pLeft, pTop, pWidth, pHeight); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_GetMinIdealImageSize(IVideoWindow *iface, + long *pWidth, + long *pHeight) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%p, %p): stub !!!\n", This, iface, pWidth, pHeight); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_GetMaxIdealImageSize(IVideoWindow *iface, + long *pWidth, + long *pHeight) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%p, %p): stub !!!\n", This, iface, pWidth, pHeight); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_GetRestorePosition(IVideoWindow *iface, + long *pLeft, + long *pTop, + long *pWidth, + long *pHeight) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%p, %p, %p, %p): stub !!!\n", This, iface, pLeft, pTop, pWidth, pHeight); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_HideCursor(IVideoWindow *iface, + long HideCursor) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, HideCursor); + + return S_OK; +} + +static HRESULT WINAPI Videowindow_IsCursorHidden(IVideoWindow *iface, + long *CursorHidden) { + ICOM_THIS_MULTI(IFilterGraphImpl, IVideoWindow_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, CursorHidden); + + return S_OK; +} + + +static ICOM_VTABLE(IVideoWindow) IVideoWindow_VTable = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + Videowindow_QueryInterface, + Videowindow_AddRef, + Videowindow_Release, + Videowindow_GetTypeInfoCount, + Videowindow_GetTypeInfo, + Videowindow_GetIDsOfNames, + Videowindow_Invoke, + Videowindow_put_Caption, + Videowindow_get_Caption, + Videowindow_put_WindowStyle, + Videowindow_get_WindowStyle, + Videowindow_put_WindowStyleEx, + Videowindow_get_WindowStyleEx, + Videowindow_put_AutoShow, + Videowindow_get_AutoShow, + Videowindow_put_WindowState, + Videowindow_get_WindowState, + Videowindow_put_BackgroundPalette, + Videowindow_get_BackgroundPalette, + Videowindow_put_Visible, + Videowindow_get_Visible, + Videowindow_put_Left, + Videowindow_get_Left, + Videowindow_put_Width, + Videowindow_get_Width, + Videowindow_put_Top, + Videowindow_get_Top, + Videowindow_put_Height, + Videowindow_get_Height, + Videowindow_put_Owner, + Videowindow_get_Owner, + Videowindow_put_MessageDrain, + Videowindow_get_MessageDrain, + Videowindow_get_BorderColor, + Videowindow_put_BorderColor, + Videowindow_get_FullScreenMode, + Videowindow_put_FullScreenMode, + Videowindow_SetWindowForeground, + Videowindow_NotifyOwnerMessage, + Videowindow_SetWindowPosition, + Videowindow_GetWindowPosition, + Videowindow_GetMinIdealImageSize, + Videowindow_GetMaxIdealImageSize, + Videowindow_GetRestorePosition, + Videowindow_HideCursor, + Videowindow_IsCursorHidden +}; + + +/*** IUnknown methods ***/ +static HRESULT WINAPI Mediaevent_QueryInterface(IMediaEventEx *iface, + REFIID riid, + LPVOID*ppvObj) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface); + + TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_guid(riid), riid, ppvObj); + + return Filtergraph_QueryInterface(This, riid, ppvObj); +} + +static ULONG WINAPI Mediaevent_AddRef(IMediaEventEx *iface) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface); + + TRACE("(%p/%p)->()\n", This, iface); + + return Filtergraph_AddRef(This); +} + +static ULONG WINAPI Mediaevent_Release(IMediaEventEx *iface) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface); + + TRACE("(%p/%p)->()\n", This, iface); + + return Filtergraph_Release(This); +} + +/*** IDispatch methods ***/ +static HRESULT WINAPI Mediaevent_GetTypeInfoCount(IMediaEventEx *iface, + UINT*pctinfo) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, pctinfo); + + return S_OK; +} + +static HRESULT WINAPI Mediaevent_GetTypeInfo(IMediaEventEx *iface, + UINT iTInfo, + LCID lcid, + ITypeInfo**ppTInfo) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface); + + TRACE("(%p/%p)->(%d, %ld, %p): stub !!!\n", This, iface, iTInfo, lcid, ppTInfo); + + return S_OK; +} + +static HRESULT WINAPI Mediaevent_GetIDsOfNames(IMediaEventEx *iface, + REFIID riid, + LPOLESTR*rgszNames, + UINT cNames, + LCID lcid, + DISPID*rgDispId) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface); + + TRACE("(%p/%p)->(%s (%p), %p, %d, %ld, %p): stub !!!\n", This, iface, debugstr_guid(riid), riid, rgszNames, cNames, lcid, rgDispId); + + return S_OK; +} + +static HRESULT WINAPI Mediaevent_Invoke(IMediaEventEx *iface, + DISPID dispIdMember, + REFIID riid, + LCID lcid, + WORD wFlags, + DISPPARAMS*pDispParams, + VARIANT*pVarResult, + EXCEPINFO*pExepInfo, + UINT*puArgErr) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface); + + TRACE("(%p/%p)->(%ld, %s (%p), %ld, %04x, %p, %p, %p, %p): stub !!!\n", This, iface, dispIdMember, debugstr_guid(riid), riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr); + + return S_OK; +} + +/*** IMediaEvent methods ***/ +static HRESULT WINAPI Mediaevent_GetEventHandle(IMediaEventEx *iface, + OAEVENT *hEvent) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, hEvent); + + return S_OK; +} + +static HRESULT WINAPI Mediaevent_GetEvent(IMediaEventEx *iface, + long *lEventCode, + LONG_PTR *lParam1, + LONG_PTR *lParam2, + long msTimeout) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface); + + TRACE("(%p/%p)->(%p, %p, %p, %ld): stub !!!\n", This, iface, lEventCode, lParam1, lParam2, msTimeout); + + return S_OK; +} + +static HRESULT WINAPI Mediaevent_WaitForCompletion(IMediaEventEx *iface, + long msTimeout, + long *pEvCode) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface); + + TRACE("(%p/%p)->(%ld, %p): stub !!!\n", This, iface, msTimeout, pEvCode); + + return S_OK; +} + +static HRESULT WINAPI Mediaevent_CancelDefaultHandling(IMediaEventEx *iface, + long lEvCode) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface); + + TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, lEvCode); + + return S_OK; +} + +static HRESULT WINAPI Mediaevent_RestoreDefaultHandling(IMediaEventEx *iface, + long lEvCode) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface); + + TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, lEvCode); + + return S_OK; +} + +static HRESULT WINAPI Mediaevent_FreeEventParams(IMediaEventEx *iface, + long lEvCode, + LONG_PTR lParam1, + LONG_PTR lParam2) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface); + + TRACE("(%p/%p)->(%ld, %08lx, %08lx): stub !!!\n", This, iface, lEvCode, lParam1, lParam2); + + return S_OK; +} + +/*** IMediaEventEx methods ***/ +static HRESULT WINAPI Mediaevent_SetNotifyWindow(IMediaEventEx *iface, + OAHWND hwnd, + long lMsg, + LONG_PTR lInstanceData) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface); + + TRACE("(%p/%p)->(%08lx, %ld, %08lx): stub !!!\n", This, iface, (DWORD) hwnd, lMsg, lInstanceData); + + return S_OK; +} + +static HRESULT WINAPI Mediaevent_SetNotifyFlags(IMediaEventEx *iface, + long lNoNotifyFlags) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface); + + TRACE("(%p/%p)->(%ld): stub !!!\n", This, iface, lNoNotifyFlags); + + return S_OK; +} + +static HRESULT WINAPI Mediaevent_GetNotifyFlags(IMediaEventEx *iface, + long *lplNoNotifyFlags) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaEventEx_vtbl, iface); + + TRACE("(%p/%p)->(%p): stub !!!\n", This, iface, lplNoNotifyFlags); + + return S_OK; +} + + +static ICOM_VTABLE(IMediaEventEx) IMediaEventEx_VTable = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + Mediaevent_QueryInterface, + Mediaevent_AddRef, + Mediaevent_Release, + Mediaevent_GetTypeInfoCount, + Mediaevent_GetTypeInfo, + Mediaevent_GetIDsOfNames, + Mediaevent_Invoke, + Mediaevent_GetEventHandle, + Mediaevent_GetEvent, + Mediaevent_WaitForCompletion, + Mediaevent_CancelDefaultHandling, + Mediaevent_RestoreDefaultHandling, + Mediaevent_FreeEventParams, + Mediaevent_SetNotifyWindow, + Mediaevent_SetNotifyFlags, + Mediaevent_GetNotifyFlags +}; + + + + + +/* This is the only function that actually creates a FilterGraph class... */ +HRESULT FILTERGRAPH_create(IUnknown *pUnkOuter, LPVOID *ppObj) { + IFilterGraphImpl *fimpl; + + TRACE("(%p,%p)\n", pUnkOuter, ppObj); + + fimpl = (IFilterGraphImpl *) HeapAlloc(GetProcessHeap(), 0, sizeof(*fimpl)); + fimpl->IGraphBuilder_vtbl = &IGraphBuilder_VTable; + fimpl->IMediaControl_vtbl = &IMediaControl_VTable; + fimpl->IMediaSeeking_vtbl = &IMediaSeeking_VTable; + fimpl->IBasicAudio_vtbl = &IBasicAudio_VTable; + fimpl->IBasicVideo_vtbl = &IBasicVideo_VTable; + fimpl->IVideoWindow_vtbl = &IVideoWindow_VTable; + fimpl->IMediaEventEx_vtbl = &IMediaEventEx_VTable; + fimpl->ref = 1; + + *ppObj = fimpl; + return S_OK; +} diff --git a/dlls/quartz/main.c b/dlls/quartz/main.c index 80da205b57a..b1151e92b57 100644 --- a/dlls/quartz/main.c +++ b/dlls/quartz/main.c @@ -1,31 +1,202 @@ +/* DirectShow Base Functions (QUARTZ.DLL) + * + * Copyright 2002 Lionel Ulmer + * + * This file contains the (internal) driver registration functions, + * driver enumeration APIs and DirectDraw creation functions. + * + * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "config.h" #include "wine/debug.h" -#include "winerror.h" +#include "quartz_private.h" WINE_DEFAULT_DEBUG_CHANNEL(quartz); -DWORD dll_ref = 0; +static DWORD dll_ref = 0; -/*********************************************************************** - * DllRegisterServer (QUARTZ.@) +/* For the moment, do nothing here. */ +BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv) +{ + switch(fdwReason) { + case DLL_PROCESS_ATTACH: + break; + case DLL_PROCESS_DETACH: + break; + } + return TRUE; +} + +/****************************************************************************** + * DirectShow ClassFactory */ -HRESULT WINAPI QUARTZ_DllRegisterServer() +typedef struct { + IClassFactory ITF_IClassFactory; + + DWORD ref; + HRESULT (*pfnCreateInstance)(IUnknown *pUnkOuter, LPVOID *ppObj); +} IClassFactoryImpl; + +struct object_creation_info +{ + const CLSID *clsid; + HRESULT (*pfnCreateInstance)(IUnknown *pUnkOuter, LPVOID *ppObj); +}; + +static const struct object_creation_info object_creation[] = +{ + { &CLSID_FilterGraph, FILTERGRAPH_create }, +}; + +static HRESULT WINAPI +DSCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) { - FIXME("(): stub\n"); - return 0; + ICOM_THIS(IClassFactoryImpl,iface); + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IClassFactory)) + { + IClassFactory_AddRef(iface); + *ppobj = This; + return S_OK; + } + + WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj); + return E_NOINTERFACE; +} + +static ULONG WINAPI DSCF_AddRef(LPCLASSFACTORY iface) { + ICOM_THIS(IClassFactoryImpl,iface); + return ++(This->ref); +} + +static ULONG WINAPI DSCF_Release(LPCLASSFACTORY iface) { + ICOM_THIS(IClassFactoryImpl,iface); + + ULONG ref = --This->ref; + + if (ref == 0) + HeapFree(GetProcessHeap(), 0, This); + + return ref; +} + + +static HRESULT WINAPI DSCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, + REFIID riid, LPVOID *ppobj) { + ICOM_THIS(IClassFactoryImpl,iface); + HRESULT hres; + LPUNKNOWN punk; + + TRACE("(%p)->(%p,%s,%p)\n",This,pOuter,debugstr_guid(riid),ppobj); + + hres = This->pfnCreateInstance(pOuter, (LPVOID *) &punk); + if (FAILED(hres)) { + *ppobj = NULL; + return hres; + } + hres = IUnknown_QueryInterface(punk, riid, ppobj); + if (FAILED(hres)) { + *ppobj = NULL; + return hres; + } + IUnknown_Release(punk); + return hres; +} + +static HRESULT WINAPI DSCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) { + ICOM_THIS(IClassFactoryImpl,iface); + FIXME("(%p)->(%d),stub!\n",This,dolock); + return S_OK; +} + +static ICOM_VTABLE(IClassFactory) DSCF_Vtbl = +{ + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + DSCF_QueryInterface, + DSCF_AddRef, + DSCF_Release, + DSCF_CreateInstance, + DSCF_LockServer +}; + +/******************************************************************************* + * DllGetClassObject [QUARTZ.@] + * Retrieves class object from a DLL object + * + * NOTES + * Docs say returns STDAPI + * + * PARAMS + * rclsid [I] CLSID for the class object + * riid [I] Reference to identifier of interface for class object + * ppv [O] Address of variable to receive interface pointer for riid + * + * RETURNS + * Success: S_OK + * Failure: CLASS_E_CLASSNOTAVAILABLE, E_OUTOFMEMORY, E_INVALIDARG, + * E_UNEXPECTED + */ +DWORD WINAPI QUARTZ_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv) +{ + int i; + IClassFactoryImpl *factory; + + TRACE("(%s,%s,%p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv); + + if ( !IsEqualGUID( &IID_IClassFactory, riid ) + && ! IsEqualGUID( &IID_IUnknown, riid) ) + return E_NOINTERFACE; + + for (i=0; i < sizeof(object_creation)/sizeof(object_creation[0]); i++) + { + if (IsEqualGUID(object_creation[i].clsid, rclsid)) + break; + } + + if (i == sizeof(object_creation)/sizeof(object_creation[0])) + { + FIXME("%s: no class found.\n", debugstr_guid(rclsid)); + return CLASS_E_CLASSNOTAVAILABLE; + } + + factory = HeapAlloc(GetProcessHeap(), 0, sizeof(*factory)); + if (factory == NULL) return E_OUTOFMEMORY; + + factory->ITF_IClassFactory.lpVtbl = &DSCF_Vtbl; + factory->ref = 1; + + factory->pfnCreateInstance = object_creation[i].pfnCreateInstance; + + *ppv = &(factory->ITF_IClassFactory); + return S_OK; } /*********************************************************************** - * DllGetClassObject (QUARTZ.@) + * DllRegisterServer (QUARTZ.@) */ -HRESULT WINAPI QUARTZ_DllGetClassObject(REFCLSID rclsid, REFIID iid, LPVOID *ppv) +HRESULT WINAPI QUARTZ_DllRegisterServer() { - FIXME("\n\tCLSID:\t%s,\n\tIID:\t%s\n",debugstr_guid(rclsid),debugstr_guid(iid)); - return CLASS_E_CLASSNOTAVAILABLE; + FIXME("(): stub\n"); + return 0; } /*********************************************************************** - * DllCanUnloadNow (QUARTZ.@) + * DllCanUnloadNow (QUARTZ.@) */ HRESULT WINAPI QUARTZ_DllCanUnloadNow() { diff --git a/dlls/quartz/quartz_private.h b/dlls/quartz/quartz_private.h new file mode 100644 index 00000000000..eaf88d94e03 --- /dev/null +++ b/dlls/quartz/quartz_private.h @@ -0,0 +1,45 @@ +/* DirectShow private interfaces (QUARTZ.DLL) + * + * Copyright 2002 Lionel Ulmer + * + * This file contains the (internal) driver registration functions, + * driver enumeration APIs and DirectDraw creation functions. + * + * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef __QUARTZ_PRIVATE_INCLUDED__ +#define __QUARTZ_PRIVATE_INCLUDED__ + +#include "winbase.h" +#include "wtypes.h" +#include "wingdi.h" +#include "winuser.h" +#include "dshow.h" + +typedef struct _IFilterGraphImpl { + ICOM_VTABLE(IGraphBuilder) *IGraphBuilder_vtbl; + ICOM_VTABLE(IMediaControl) *IMediaControl_vtbl; + ICOM_VTABLE(IMediaSeeking) *IMediaSeeking_vtbl; + ICOM_VTABLE(IBasicAudio) *IBasicAudio_vtbl; + ICOM_VTABLE(IBasicVideo) *IBasicVideo_vtbl; + ICOM_VTABLE(IVideoWindow) *IVideoWindow_vtbl; + ICOM_VTABLE(IMediaEventEx) *IMediaEventEx_vtbl; + ULONG ref; +} IFilterGraphImpl; + +HRESULT FILTERGRAPH_create(IUnknown *pUnkOuter, LPVOID *ppObj) ; + +#endif /* __QUARTZ_PRIVATE_INCLUDED__ */ diff --git a/include/Makefile.in b/include/Makefile.in index a2f64dd6192..6da35cf5ad1 100644 --- a/include/Makefile.in +++ b/include/Makefile.in @@ -20,6 +20,7 @@ WINDOWS_INCLUDES = \ commctrl.h \ commdlg.h \ compobj.h \ + control.h \ cpl.h \ custcntl.h \ d3d.h \ @@ -140,6 +141,7 @@ WINDOWS_INCLUDES = \ sqlext.h \ sqltypes.h \ storage.h \ + strmif.h \ tapi.h \ tchar.h \ tlhelp32.h \ diff --git a/include/control.h b/include/control.h new file mode 100644 index 00000000000..369c261475a --- /dev/null +++ b/include/control.h @@ -0,0 +1,345 @@ +/* + * Copyright (C) 2002 Lionel Ulmer + * + * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef __CONTROL_INCLUDED__ +#define __CONTROL_INCLUDED__ + +#include "windef.h" +#include "wingdi.h" +#include "objbase.h" +#include "oleauto.h" + +typedef struct IMediaControl IMediaControl; +typedef struct IBasicAudio IBasicAudio; +typedef struct IBasicVideo IBasicVideo; +typedef struct IVideoWindow IVideoWindow; +typedef struct IMediaEvent IMediaEvent; +typedef struct IMediaEventEx IMediaEventEx; + +typedef long OAFilterState; +typedef LONG_PTR OAHWND; +typedef LONG_PTR OAEVENT; + +#define INTERFACE IMediaControl +#define IMediaControl_METHODS \ + IDispatch_METHODS \ + STDMETHOD(Run)(THIS) PURE; \ + STDMETHOD(Pause)(THIS) PURE; \ + STDMETHOD(Stop)(THIS) PURE; \ + STDMETHOD(GetState)(THIS_ LONG msTimeout, OAFilterState * pfs) PURE; \ + STDMETHOD(RenderFile)(THIS_ BSTR strFilename) PURE; \ + STDMETHOD(AddSourceFilter)(THIS_ BSTR strFilename, IDispatch ** ppUnk) PURE; \ + STDMETHOD(get_FilterCollection)(THIS_ IDispatch ** ppUnk) PURE; \ + STDMETHOD(get_RegFilterCollection)(THIS_ IDispatch ** ppUnk) PURE; \ + STDMETHOD(StopWhenReady)(THIS) PURE; +ICOM_DEFINE(IMediaControl,IDispatch) +#undef INTERFACE + +#ifdef ICOM_CINTERFACE +/*** IUnknown methods ***/ +#define IMediaControl_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IMediaControl_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IMediaControl_Release(p) (p)->lpVtbl->Release(p) +/*** IDispatch methods ***/ +#define IMediaControl_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a) +#define IMediaControl_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c) +#define IMediaControl_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e) +#define IMediaControl_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h) +/*** IMediaControl methods ***/ +#define IMediaControl_Run(p) (p)->lpVtbl->Run(p) +#define IMediaControl_Pause(p) (p)->lpVtbl->Pause(p) +#define IMediaControl_Stop(p) (p)->lpVtbl->Stop(p) +#define IMediaControl_GetState(p,a,b) (p)->lpVtbl->GetState(p,a,b) +#define IMediaControl_RenderFile(p,a) (p)->lpVtbl->RenderFile(p,a) +#define IMediaControl_AddSourceFilter(p,a,b) (p)->lpVtbl->AddSourceFilter(p,a,b) +#define IMediaControl_get_FilterCollection(p,a) (p)->lpVtbl->get_FilterCollection(p,a) +#define IMediaControl_get_RegFilterCollection(p,a) (p)->lpVtbl->get_RegFilterCollection(p,a) +#define IMediaControl_StopWhenReady(p) (p)->lpVtbl->StopWhenReady(p) +#endif + +#define INTERFACE IBasicAudio +#define IBasicAudio_METHODS \ + IDispatch_METHODS \ + STDMETHOD(put_Volume)(THIS_ long lVolume) PURE; \ + STDMETHOD(get_Volume)(THIS_ long * plVolume) PURE; \ + STDMETHOD(put_Balance)(THIS_ long lBalance) PURE; \ + STDMETHOD(get_Balance)(THIS_ long * plBalance) PURE; +ICOM_DEFINE(IBasicAudio,IDispatch) +#undef INTERFACE + +#ifdef ICOM_CINTERFACE +/*** IUnknown methods ***/ +#define IBasicAudio_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IBasicAudio_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IBasicAudio_Release(p) (p)->lpVtbl->Release(p) +/*** IDispatch methods ***/ +#define IBasicAudio_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a) +#define IBasicAudio_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c) +#define IBasicAudio_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e) +#define IBasicAudio_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h) +/*** IBasicAudio methods ***/ +#define IBasicAudio_get_Volume(p,a) (p)->lpVtbl->get_Volume(p,a) +#define IBasicAudio_put_Volume(p,a) (p)->lpVtbl->put_Volume(p,a) +#define IBasicAudio_get_Balance(p,a) (p)->lpVtbl->get_Balance(p,a) +#define IBasicAudio_put_Balance(p,a) (p)->lpVtbl->put_Balance(p,a) +#endif + +#define INTERFACE IBasicVideo +#define IBasicVideo_METHODS \ + IDispatch_METHODS \ + STDMETHOD(get_AvgTimePerFrame)(THIS_ REFTIME * pAvgTimePerFrame) PURE; \ + STDMETHOD(get_BitRate)(THIS_ long * pBitRate) PURE; \ + STDMETHOD(get_BitErrorRate)(THIS_ long * pBitErrorRate) PURE; \ + STDMETHOD(get_VideoWidth)(THIS_ long * pVideoWidth) PURE; \ + STDMETHOD(get_VideoHeight)(THIS_ long * pVideoHeight) PURE; \ + STDMETHOD(put_SourceLeft)(THIS_ long SourceLeft) PURE; \ + STDMETHOD(get_SourceLeft)(THIS_ long * pSourceLeft) PURE; \ + STDMETHOD(put_SourceWidth)(THIS_ long SourceWidth) PURE; \ + STDMETHOD(get_SourceWidth)(THIS_ long * pSourceWidth) PURE; \ + STDMETHOD(put_SourceTop)(THIS_ long SourceTop) PURE; \ + STDMETHOD(get_SourceTop)(THIS_ long * pSourceTop) PURE; \ + STDMETHOD(put_SourceHeight)(THIS_ long SourceHeight) PURE; \ + STDMETHOD(get_SourceHeight)(THIS_ long * pSourceHeight) PURE; \ + STDMETHOD(put_DestinationLeft)(THIS_ long DestinationLeft) PURE; \ + STDMETHOD(get_DestinationLeft)(THIS_ long * pDestinationLeft) PURE; \ + STDMETHOD(put_DestinationWidth)(THIS_ long DestinationWidth) PURE; \ + STDMETHOD(get_DestinationWidth)(THIS_ long * pDestinationWidth) PURE; \ + STDMETHOD(put_DestinationTop)(THIS_ long DestinationTop) PURE; \ + STDMETHOD(get_DestinationTop)(THIS_ long * pDestinationTop) PURE; \ + STDMETHOD(put_DestinationHeight)(THIS_ long DestinationHeight) PURE; \ + STDMETHOD(get_DestinationHeight)(THIS_ long * pDestinationHeight) PURE; \ + STDMETHOD(SetSourcePosition)(THIS_ long Left, long Top, long Width, long Height) PURE; \ + STDMETHOD(GetSourcePosition)(THIS_ long * pLeft, long * pTop, long * pWidth, long * pHeight) PURE; \ + STDMETHOD(SetDefaultSourcePosition)(THIS) PURE; \ + STDMETHOD(SetDestinationPosition)(THIS_ long Left, long Top, long Width, long Height) PURE; \ + STDMETHOD(GetDestinationPosition)(THIS_ long * pLeft, long * pTop, long * pWidth, long * pHeight) PURE; \ + STDMETHOD(SetDefaultDestinationPosition)(THIS) PURE; \ + STDMETHOD(GetVideoSize)(THIS_ long * pWidth, long * pHeight) PURE; \ + STDMETHOD(GetVideoPaletteEntries)(THIS_ long StartIndex, long Entries, long * pRetrieved, long * pPalette) PURE; \ + STDMETHOD(GetCurrentImage)(THIS_ long * pBufferSize, long * pDIBImage) PURE; \ + STDMETHOD(IsUsingDefaultSource)(THIS) PURE; \ + STDMETHOD(IsUsingDefaultDestination)(THIS) PURE; +ICOM_DEFINE(IBasicVideo,IDispatch) +#undef INTERFACE + +#ifdef ICOM_CINTERFACE +/*** IUnknown methods ***/ +#define IBasicVideo_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IBasicVideo_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IBasicVideo_Release(p) (p)->lpVtbl->Release(p) +/*** IDispatch methods ***/ +#define IBasicVideo_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a) +#define IBasicVideo_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c) +#define IBasicVideo_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e) +#define IBasicVideo_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h) +/*** IBasicVideo methods ***/ +#define IBasicVideo_get_AvgTimePerFrame(p,a) (p)->lpVtbl->get_AvgTimePerFrame(p,a) +#define IBasicVideo_get_BitRate(p,a) (p)->lpVtbl->get_BitRate(p,a) +#define IBasicVideo_get_BitErrorRate(p,a) (p)->lpVtbl->get_BitErrorRate(p,a) +#define IBasicVideo_get_VideoWidth(p,a) (p)->lpVtbl->get_VideoWidth(p,a) +#define IBasicVideo_get_VideoHeight(p,a) (p)->lpVtbl->get_VideoHeight(p,a) +#define IBasicVideo_put_SourceLeft(p,a) (p)->lpVtbl->put_SourceLeft(p,a) +#define IBasicVideo_get_SourceLeft(p,a) (p)->lpVtbl->get_SourceLeft(p,a) +#define IBasicVideo_put_SourceWidth(p,a) (p)->lpVtbl->put_SourceWidth(p,a) +#define IBasicVideo_get_SourceWidth(p,a) (p)->lpVtbl->get_SourceWidth(p,a) +#define IBasicVideo_put_SourceTop(p,a) (p)->lpVtbl->put_SourceTop(p,a) +#define IBasicVideo_get_SourceTop(p,a) (p)->lpVtbl->get_SourceTop(p,a) +#define IBasicVideo_put_SourceHeight(p,a) (p)->lpVtbl->put_SourceHeight(p,a) +#define IBasicVideo_get_SourceHeight(p,a) (p)->lpVtbl->get_SourceHeight(p,a) +#define IBasicVideo_put_DestinationLeft(p,a) (p)->lpVtbl->put_DestinationLeft(p,a) +#define IBasicVideo_get_DestinationLeft(p,a) (p)->lpVtbl->get_DestinationLeft(p,a) +#define IBasicVideo_put_DestinationWidth(p,a) (p)->lpVtbl->put_DestinationWidth(p,a) +#define IBasicVideo_get_DestinationWidth(p,a) (p)->lpVtbl->get_DestinationWidth(p,a) +#define IBasicVideo_put_DestinationTop(p,a) (p)->lpVtbl->put_DestinationTop(p,a) +#define IBasicVideo_get_DestinationTop(p,a) (p)->lpVtbl->get_DestinationTop(p,a) +#define IBasicVideo_put_DestinationHeight(p,a) (p)->lpVtbl->put_DestinationHeight(p,a) +#define IBasicVideo_get_DestinationHeight(p,a) (p)->lpVtbl->get_DestinationHeight(p,a) +#define IBasicVideo_SetSourcePosition(p,a,b,c,d) (p)->lpVtbl->SetSourcePosition(p,a,b,c,d) +#define IBasicVideo_GetSourcePosition(p,a,b,c,d) (p)->lpVtbl->GetSourcePosition(p,a,b,c,d) +#define IBasicVideo_SetDefaultSourcePosition(p) (p)->lpVtbl->SetDefaultSourcePosition(p) +#define IBasicVideo_SetDestinationPosition(p,a,b,c,d) (p)->lpVtbl->SetDestinationPosition(p,a,b,c,d) +#define IBasicVideo_GetDestinationPosition(p,a,b,c,d) (p)->lpVtbl->GetDestinationPosition(p,a,b,c,d) +#define IBasicVideo_SetDefaultDestinationPosition(p) (p)->lpVtbl->SetDefaultDestinationPosition(p) +#define IBasicVideo_GetVideoSize(p,a,b) (p)->lpVtbl->GetVideoSize(p,a,b) +#define IBasicVideo_GetVideoPaletteEntries(p,a,b,c,d) (p)->lpVtbl->GetVideoPaletteEntries(p,a,b,c,d) +#define IBasicVideo_GetCurrentImage(p,a,b) (p)->lpVtbl->GetCurrentImage(p,a,b) +#define IBasicVideo_IsUsingDefaultSource(p) (p)->lpVtbl->IsUsingDefaultSource(p) +#define IBasicVideo_IsUsingDefaultDestination(p) (p)->lpVtbl->IsUsingDefaultDestination(p) +#endif + +#define INTERFACE IVideoWindow +#define IVideoWindow_METHODS \ + IDispatch_METHODS \ + STDMETHOD(put_Caption)(THIS_ BSTR strCaption) PURE; \ + STDMETHOD(get_Caption)(THIS_ BSTR * strCaption) PURE; \ + STDMETHOD(put_WindowStyle)(THIS_ long WindowStyle) PURE; \ + STDMETHOD(get_WindowStyle)(THIS_ long * WindowStyle) PURE; \ + STDMETHOD(put_WindowStyleEx)(THIS_ long WindowStyleEx) PURE; \ + STDMETHOD(get_WindowStyleEx)(THIS_ long * WindowStyleEx) PURE; \ + STDMETHOD(put_AutoShow)(THIS_ long AutoShow) PURE; \ + STDMETHOD(get_AutoShow)(THIS_ long * AutoShow) PURE; \ + STDMETHOD(put_WindowState)(THIS_ long WindowState) PURE; \ + STDMETHOD(get_WindowState)(THIS_ long * WindowState) PURE; \ + STDMETHOD(put_BackgroundPalette)(THIS_ long BackgroundPalette) PURE; \ + STDMETHOD(get_BackgroundPalette)(THIS_ long * pBackgroundPalette) PURE; \ + STDMETHOD(put_Visible)(THIS_ long Visible) PURE; \ + STDMETHOD(get_Visible)(THIS_ long * pVisible) PURE; \ + STDMETHOD(put_Left)(THIS_ long Left) PURE; \ + STDMETHOD(get_Left)(THIS_ long * pLeft) PURE; \ + STDMETHOD(put_Width)(THIS_ long Width) PURE; \ + STDMETHOD(get_Width)(THIS_ long * pWidth) PURE; \ + STDMETHOD(put_Top)(THIS_ long Top) PURE; \ + STDMETHOD(get_Top)(THIS_ long * pTop) PURE; \ + STDMETHOD(put_Height)(THIS_ long Height) PURE; \ + STDMETHOD(get_Height)(THIS_ long * pHeight) PURE; \ + STDMETHOD(put_Owner)(THIS_ OAHWND Owner) PURE; \ + STDMETHOD(get_Owner)(THIS_ OAHWND * Owner) PURE; \ + STDMETHOD(put_MessageDrain)(THIS_ OAHWND Drain) PURE; \ + STDMETHOD(get_MessageDrain)(THIS_ OAHWND * Drain) PURE; \ + STDMETHOD(get_BorderColor)(THIS_ long * Color) PURE; \ + STDMETHOD(put_BorderColor)(THIS_ long Color) PURE; \ + STDMETHOD(get_FullScreenMode)(THIS_ long * FullScreenMode) PURE; \ + STDMETHOD(put_FullScreenMode)(THIS_ long FullScreenMode) PURE; \ + STDMETHOD(SetWindowForeground)(THIS_ long Focus) PURE; \ + STDMETHOD(NotifyOwnerMessage)(THIS_ OAHWND hwnd, long uMsg, LONG_PTR wParam, LONG_PTR lParam) PURE; \ + STDMETHOD(SetWindowPosition)(THIS_ long Left, long Top, long Width, long Height) PURE; \ + STDMETHOD(GetWindowPosition)(THIS_ long * pLeft, long * pTop, long * pWidth, long * pHeight) PURE; \ + STDMETHOD(GetMinIdealImageSize)(THIS_ long * pWidth, long * pHeight) PURE; \ + STDMETHOD(GetMaxIdealImageSize)(THIS_ long * pWidth, long * pHeight) PURE; \ + STDMETHOD(GetRestorePosition)(THIS_ long * pLeft, long * pTop, long * pWidth, long * pHeight) PURE; \ + STDMETHOD(HideCursor)(THIS_ long HideCursor) PURE; \ + STDMETHOD(IsCursorHidden)(THIS_ long * CursorHidden) PURE; +ICOM_DEFINE(IVideoWindow,IDispatch) +#undef INTERFACE + +#ifdef ICOM_CINTERFACE +/*** IUnknown methods ***/ +#define IVideoWindow_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IVideoWindow_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IVideoWindow_Release(p) (p)->lpVtbl->Release(p) +/*** IDispatch methods ***/ +#define IVideoWindow_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a) +#define IVideoWindow_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c) +#define IVideoWindow_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e) +#define IVideoWindow_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h) +/*** IVideoWindow methods ***/ +#define IVideoWindow_put_Caption(p,a) (p)->lpVtbl->put_Caption(p,a) +#define IVideoWindow_get_Caption(p,a) (p)->lpVtbl->get_Caption(p,a) +#define IVideoWindow_put_WindowStyle(p,a) (p)->lpVtbl->put_WindowStyle(p,a) +#define IVideoWindow_get_WindowStyle(p,a) (p)->lpVtbl->get_WindowStyle(p,a) +#define IVideoWindow_put_WindowStyleEx(p,a) (p)->lpVtbl->put_WindowStyleEx(p,a) +#define IVideoWindow_get_WindowStyleEx(p,a) (p)->lpVtbl->get_WindowStyleEx(p,a) +#define IVideoWindow_put_AutoShow(p,a) (p)->lpVtbl->put_AutoShow(p,a) +#define IVideoWindow_get_AutoShow(p,a) (p)->lpVtbl->get_AutoShow(p,a) +#define IVideoWindow_put_WindowState(p,a) (p)->lpVtbl->put_WindowState(p,a) +#define IVideoWindow_get_WindowState(p,a) (p)->lpVtbl->get_WindowState(p,a) +#define IVideoWindow_put_BackgroundPalette(p,a) (p)->lpVtbl->put_BackgroundPalette(p,a) +#define IVideoWindow_get_BackgroundPalette(p,a) (p)->lpVtbl->get_BackgroundPalette(p,a) +#define IVideoWindow_put_Visible(p,a) (p)->lpVtbl->put_Visible(p,a) +#define IVideoWindow_get_Visible(p,a) (p)->lpVtbl->get_Visible(p,a) +#define IVideoWindow_put_Left(p,a) (p)->lpVtbl->put_Left(p,a) +#define IVideoWindow_get_Left(p,a) (p)->lpVtbl->get_Left(p,a) +#define IVideoWindow_put_Width(p,a) (p)->lpVtbl->put_Width(p,a) +#define IVideoWindow_get_Width(p,a) (p)->lpVtbl->get_Width(p,a) +#define IVideoWindow_put_Top(p,a) (p)->lpVtbl->put_Top(p,a) +#define IVideoWindow_get_Top(p,a) (p)->lpVtbl->get_Top(p,a) +#define IVideoWindow_put_Height(p,a) (p)->lpVtbl->put_Height(p,a) +#define IVideoWindow_get_Height(p,a) (p)->lpVtbl->get_Height(p,a) +#define IVideoWindow_put_Owner(p,a) (p)->lpVtbl->put_Owner(p,a) +#define IVideoWindow_get_Owner(p,a) (p)->lpVtbl->get_Owner(p,a) +#define IVideoWindow_put_MessageDrain(p,a) (p)->lpVtbl->put_MessageDrain(p,a) +#define IVideoWindow_get_MessageDrain(p,a) (p)->lpVtbl->get_MessageDrain(p,a) +#define IVideoWindow_get_BorderColor(p,a) (p)->lpVtbl->get_BorderColor(p,a) +#define IVideoWindow_put_BorderColor(p,a) (p)->lpVtbl->put_BorderColor(p,a) +#define IVideoWindow_get_FullScreenMode(p,a) (p)->lpVtbl->get_FullScreenMode(p,a) +#define IVideoWindow_put_FullScreenMode(p,a) (p)->lpVtbl->put_FullScreenMode(p,a) +#define IVideoWindow_SetWindowForeground(p,a) (p)->lpVtbl->SetWindowForeground(p,a) +#define IVideoWindow_NotifyOwnerMessage(p,a,b,c,d) (p)->lpVtbl->NotifyOwnerMessage(p,a,b,c,d) +#define IVideoWindow_SetWindowPosition(p,a,b,c,d) (p)->lpVtbl->SetWindowPosition(p,a,b,c,d) +#define IVideoWindow_GetWindowPosition(p,a,b,c,d) (p)->lpVtbl->GetWindowPosition(p,a,b,c,d) +#define IVideoWindow_GetMinIdealImageSize(p,a,b) (p)->lpVtbl->GetMinIdealImageSize(p,a,b) +#define IVideoWindow_GetMaxIdealImageSize(p,a,b) (p)->lpVtbl->GetMaxIdealImageSize(p,a,b) +#define IVideoWindow_GetRestorePosition(p,a,b,c,d) (p)->lpVtbl->GetRestorePosition(p,a,b,c,d) +#define IVideoWindow_HideCursor(p,a) (p)->lpVtbl->HideCursor(p,a) +#define IVideoWindow_IsCursorHidden(p,a) (p)->lpVtbl->IsCursorHidden(p,a) +#endif + +#define INTERFACE IMediaEvent +#define IMediaEvent_METHODS \ + IDispatch_METHODS \ + STDMETHOD(GetEventHandle)(THIS_ OAEVENT * hEvent) PURE; \ + STDMETHOD(GetEvent)(THIS_ long * lEventCode, LONG_PTR * lParam1, LONG_PTR * lParam2, long msTimeout) PURE; \ + STDMETHOD(WaitForCompletion)(THIS_ long msTimeout, long * pEvCode) PURE; \ + STDMETHOD(CancelDefaultHandling)(THIS_ long lEvCode) PURE; \ + STDMETHOD(RestoreDefaultHandling)(THIS_ long lEvCode) PURE; \ + STDMETHOD(FreeEventParams)(THIS_ long lEvCode, LONG_PTR lParam1, LONG_PTR lParam2) PURE; +ICOM_DEFINE(IMediaEvent,IDispatch) +#undef INTERFACE + +#ifdef ICOM_CINTERFACE +/*** IUnknown methods ***/ +#define IMediaEvent_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IMediaEvent_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IMediaEvent_Release(p) (p)->lpVtbl->Release(p) +/*** IDispatch methods ***/ +#define IMediaEvent_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a) +#define IMediaEvent_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c) +#define IMediaEvent_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e) +#define IMediaEvent_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h) +/*** IMediaEvent methods ***/ +#define IMediaEvent_GetEventHandle(p,a) (p)->lpVtbl->GetEventHandle(p,a) +#define IMediaEvent_GetEvent(p,a,b,c,d) (p)->lpVtbl->GetEvent(p,a,b,c,d) +#define IMediaEvent_WaitForCompletion(p,a,b) (p)->lpVtbl->WaitForCompletion(p,a,b) +#define IMediaEvent_CancelDefaultHandling(p,a) (p)->lpVtbl->CancelDefaultHandling(p,a) +#define IMediaEvent_RestoreDefaultHandling(p,a) (p)->lpVtbl->RestoreDefaultHandling(p,a) +#define IMediaEvent_FreeEventParams(p,a,b,c) (p)->lpVtbl->FreeEventParams(p,a,b,c) +#endif + +#define INTERFACE IMediaEventEx +#define IMediaEventEx_METHODS \ + IMediaEvent_METHODS \ + STDMETHOD(SetNotifyWindow)(THIS_ OAHWND hwnd, long lMsg, LONG_PTR lInstanceData) PURE; \ + STDMETHOD(SetNotifyFlags)(THIS_ long lNoNotifyFlags) PURE; \ + STDMETHOD(GetNotifyFlags)(THIS_ long * lplNoNotifyFlags) PURE; +ICOM_DEFINE(IMediaEventEx,IMediaEvent) +#undef INTERFACE + +#ifdef ICOM_CINTERFACE +/*** IUnknown methods ***/ +#define IMediaEventEx_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IMediaEventEx_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IMediaEventEx_Release(p) (p)->lpVtbl->Release(p) +/*** IDispatch methods ***/ +#define IMediaEventEx_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a) +#define IMediaEventEx_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c) +#define IMediaEventEx_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e) +#define IMediaEventEx_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h) +/*** IMediaEvent methods ***/ +#define IMediaEventEx_GetEventHandle(p,a) (p)->lpVtbl->GetEventHandle(p,a) +#define IMediaEventEx_GetEvent(p,a,b,c,d) (p)->lpVtbl->GetEvent(p,a,b,c,d) +#define IMediaEventEx_WaitForCompletion(p,a,b) (p)->lpVtbl->WaitForCompletion(p,a,b) +#define IMediaEventEx_CancelDefaultHandling(p,a) (p)->lpVtbl->CancelDefaultHandling(p,a) +#define IMediaEventEx_RestoreDefaultHandling(p,a) (p)->lpVtbl->RestoreDefaultHandling(p,a) +#define IMediaEventEx_FreeEventParams(p,a,b,c) (p)->lpVtbl->FreeEventParams(p,a,b,c) +/*** IMediaEventEx methods ***/ +#define IMediaEventEx_SetNotifyWindow(p,a,b,c) (p)->lpVtbl->SetNotifyWindow(p,a,b,c) +#define IMediaEventEx_SetNotifyFlags(p,a) (p)->lpVtbl->SetNotifyFlags(p,a) +#define IMediaEventEx_GetNotifyFlags(p,a) (p)->lpVtbl->GetNotifyFlags(p,a) +#endif + +#endif /* __CONTROL_INCLUDED__ */ diff --git a/include/dshow.h b/include/dshow.h index c4c952a5456..fcbd823693b 100644 --- a/include/dshow.h +++ b/include/dshow.h @@ -21,9 +21,9 @@ #define AM_NOVTABLE -#include "windows.h" -#include "windowsx.h" -#include "olectl.h" +#include "windef.h" +#include "wingdi.h" +#include "objbase.h" #include "ddraw.h" #include "mmsystem.h" @@ -31,10 +31,10 @@ #define NUMELMS(array) (sizeof(array)/sizeof((array)[0])) #endif -/*#include "strmif.h"*/ +#include "strmif.h" /*#include "amvideo.h"*/ /*#include "amaudio.h"*/ -/*#include "control.h"*/ +#include "control.h" /*#include "evcode.h"*/ #include "uuids.h" /*#include "errors.h"*/ diff --git a/include/strmif.h b/include/strmif.h new file mode 100644 index 00000000000..6817260fc65 --- /dev/null +++ b/include/strmif.h @@ -0,0 +1,388 @@ +/* + * Copyright (C) 2002 Lionel Ulmer + * + * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef __STRMIF_INCLUDED__ +#define __STRMIF_INCLUDED__ + +#include "windef.h" +#include "wingdi.h" +#include "objbase.h" + +/* FilterGraph object / interface */ +typedef struct IFilterGraph IFilterGraph; +typedef struct IBaseFilter IBaseFilter; +typedef struct IEnumFilters IEnumFilters; +typedef struct IPin IPin; +typedef struct IEnumPins IEnumPins; +typedef struct IEnumMediaTypes IEnumMediaTypes; +typedef struct IMediaFilter IMediaFilter; +typedef struct IReferenceClock IReferenceClock; +typedef struct IGraphBuilder IGraphBuilder; +typedef struct IMediaSeeking IMediaSeeking; + +typedef LONGLONG REFERENCE_TIME; +typedef double REFTIME; + +typedef struct _MediaType { + GUID majortype; + GUID subtype; + BOOL bFixedSizeSamples; + BOOL bTemporalCompression; + ULONG lSampleSize; + GUID formattype; + IUnknown *pUnk; + ULONG cbFormat; + /* [size_is] */ BYTE *pbFormat; +} AM_MEDIA_TYPE; + +#define MAX_FILTER_NAME 128 +typedef struct _FilterInfo { + WCHAR achName[MAX_FILTER_NAME]; + IFilterGraph *pGraph; +} FILTER_INFO; + +typedef enum _FilterState { + State_Stopped = 0, + State_Paused = 1, + State_Running = 2 +} FILTER_STATE; + +typedef enum _PinDirection { + PINDIR_INPUT = 0, + PINDIR_OUTPUT = 1 +} PIN_DIRECTION; + +#define MAX_PIN_NAME 128 +typedef struct _PinInfo { + IBaseFilter *pFilter; + PIN_DIRECTION dir; + WCHAR achName[MAX_PIN_NAME]; +} PIN_INFO; + +typedef DWORD_PTR HSEMAPHORE; +typedef DWORD_PTR HEVENT; + +#define INTERFACE IPin +#define IPin_METHODS \ + IUnknown_METHODS \ + STDMETHOD(Connect)(THIS_ IPin * pReceivePin, AM_MEDIA_TYPE * pmt) PURE; \ + STDMETHOD(ReceiveConnection)(THIS_ IPin * pConnector, AM_MEDIA_TYPE * pmt) PURE; \ + STDMETHOD(Disconnect)(THIS) PURE; \ + STDMETHOD(ConnectedTo)(THIS_ IPin ** pPin) PURE; \ + STDMETHOD(ConnectionMediaType)(THIS_ AM_MEDIA_TYPE * pmt) PURE; \ + STDMETHOD(QueryPinInfo)(THIS_ PIN_INFO * pInfo) PURE; \ + STDMETHOD(QueryDirection)(THIS_ PIN_DIRECTION * pPinDir) PURE; \ + STDMETHOD(QueryId)(THIS_ LPWSTR * Id) PURE; \ + STDMETHOD(QueryAccept)(THIS_ AM_MEDIA_TYPE * pmt) PURE; \ + STDMETHOD(EnumMediaTypes)(THIS_ IEnumMediaTypes ** ppEnum) PURE; \ + STDMETHOD(QueryInternalConnections)(THIS_ IPin ** apPin, ULONG * nPin) PURE; \ + STDMETHOD(EndOfStream)(THIS) PURE; \ + STDMETHOD(BeginFlush)(THIS) PURE; \ + STDMETHOD(EndFlush)(THIS) PURE; \ + STDMETHOD(NewSegment)(THIS_ REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate) PURE; +ICOM_DEFINE(IPin,IUnknown) +#undef INTERFACE + +#ifdef ICOM_CINTERFACE +/*** IUnknown methods ***/ +#define IPin_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IPin_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IPin_Release(p) (p)->lpVtbl->Release(p) +/*** IPin methods ***/ +#define IPin_Connect(p,a,b) (p)->lpVtbl->Connect(p,a,b) +#define IPin_ReceiveConnection(p,a,b) (p)->lpVtbl->ReceiveConnection(p,a,b) +#define IPin_Disconnect(p) (p)->lpVtbl->Disconnect(p) +#define IPin_ConnectedTo(p,a) (p)->lpVtbl->ConnectedTo(p,a) +#define IPin_ConnectionMediaType(p,a) (p)->lpVtbl->ConnectionMediaType(p,a) +#define IPin_QueryPinInfo(p,a) (p)->lpVtbl->QueryPinInfo(p,a) +#define IPin_QueryDirection(p,a) (p)->lpVtbl->QueryDirection(p,a) +#define IPin_QueryId(p,a) (p)->lpVtbl->QueryId(p,a) +#define IPin_QueryAccept(p,a) (p)->lpVtbl->QueryAccept(p,a) +#define IPin_EnumMediaTypes(p,a) (p)->lpVtbl->EnumMediaTypes(p,a) +#define IPin_QueryInternalConnections(p,a,b) (p)->lpVtbl->QueryInternalConnections(p,a,b) +#define IPin_EndOfStream(p) (p)->lpVtbl->EndOfStream(p) +#define IPin_BeginFlush(p) (p)->lpVtbl->BeginFlush(p) +#define IPin_EndFlush(p) (p)->lpVtbl->EndFlush(p) +#define IPin_NewSegment(p,a,b,c) (p)->lpVtbl->NewSegment(p,a,b,c) +#endif + +#define INTERFACE IEnumPins +#define IEnumPins_METHODS \ + IUnknown_METHODS \ + STDMETHOD(Next)(THIS_ ULONG cPins, IPin ** ppPins, ULONG * pcFetched) PURE; \ + STDMETHOD(Skip)(THIS_ ULONG cPins) PURE; \ + STDMETHOD(Reset)(THIS) PURE; \ + STDMETHOD(Clone)(THIS_ IEnumPins ** ppEnum) PURE; +ICOM_DEFINE(IEnumPins,IUnknown) +#undef INTERFACE + +#ifdef ICOM_CINTERFACE +/*** IUnknown methods ***/ +#define IEnumPins_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IEnumPins_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IEnumPins_Release(p) (p)->lpVtbl->Release(p) +/*** IEnumPins methods ***/ +#define IEnumPins_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c) +#define IEnumPins_Skip(p,a) (p)->lpVtbl->Skip(p,a) +#define IEnumPins_Reset(p) (p)->lpVtbl->Reset(p) +#define IEnumPins_Clone(p,a) (p)->lpVtbl->Clone(p,a) +#endif + +#define INTERFACE IMediaFilter +#define IMediaFilter_METHODS \ + IPersist_METHODS \ + STDMETHOD(Stop)(THIS) PURE; \ + STDMETHOD(Pause)(THIS) PURE; \ + STDMETHOD(Run)(THIS_ REFERENCE_TIME tStart) PURE; \ + STDMETHOD(GetState)(THIS_ DWORD dwMilliSecsTimeout, FILTER_STATE * State) PURE; \ + STDMETHOD(SetSyncSource)(THIS_ IReferenceClock * pClock) PURE; \ + STDMETHOD(GetSyncSource)(THIS_ IReferenceClock ** pClock) PURE; +ICOM_DEFINE(IMediaFilter,IPersist) +#undef INTERFACE + +#ifdef ICOM_CINTERFACE +/*** IUnknown methods ***/ +#define IMediaFilter_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IMediaFilter_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IMediaFilter_Release(p) (p)->lpVtbl->Release(p) +/*** IPersist methods ***/ +#define IMediaFilter_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a) +/*** IMediaFilter methods ***/ +#define IMediaFilter_Stop(p) (p)->lpVtbl->Stop(p) +#define IMediaFilter_Pause(p) (p)->lpVtbl->Pause(p) +#define IMediaFilter_Run(p,a) (p)->lpVtbl->Run(p,a) +#define IMediaFilter_GetState(p,a,b) (p)->lpVtbl->GetState(p,a,b) +#define IMediaFilter_SetSyncSource(p,a) (p)->lpVtbl->SetSyncSource(p,a) +#define IMediaFilter_GetSyncSource(p,a) (p)->lpVtbl->GetSyncSource(p,a) +#endif + +#define INTERFACE IBaseFilter +#define IBaseFilter_METHODS \ + IMediaFilter_METHODS \ + STDMETHOD(EnumPins)(THIS_ IEnumPins ** ppEnum) PURE; \ + STDMETHOD(FindPin)(THIS_ LPCWSTR Id, IPin ** ppPin) PURE; \ + STDMETHOD(QueryFilterInfo)(THIS_ FILTER_INFO * pInfo) PURE; \ + STDMETHOD(JoinFilterGraph)(THIS_ IFilterGraph * pGraph, LPCWSTR pName) PURE; \ + STDMETHOD(QueryVendorInfo)(THIS_ LPWSTR * pVendorInfo) PURE; +ICOM_DEFINE(IBaseFilter,IMediaFilter) +#undef INTERFACE + +#ifdef ICOM_CINTERFACE +/*** IUnknown methods ***/ +#define IBaseFilter_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IBaseFilter_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IBaseFilter_Release(p) (p)->lpVtbl->Release(p) +/*** IPersist methods ***/ +#define IBaseFilter_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a) +/*** IMediaFilter methods ***/ +#define IBaseFilter_Stop(p) (p)->lpVtbl->Stop(p) +#define IBaseFilter_Pause(p) (p)->lpVtbl->Pause(p) +#define IBaseFilter_Run(p,a) (p)->lpVtbl->Run(p,a) +#define IBaseFilter_GetState(p,a,b) (p)->lpVtbl->GetState(p,a,b) +#define IBaseFilter_SetSyncSource(p,a) (p)->lpVtbl->SetSyncSource(p,a) +#define IBaseFilter_GetSyncSource(p,a) (p)->lpVtbl->GetSyncSource(p,a) +/*** IBaseFilter methods ***/ +#define IBaseFilter_EnumPins(p,a) (p)->lpVtbl->EnumPins(p,a) +#define IBaseFilter_FindPin(p,a,b) (p)->lpVtbl->FindPin(p,a,b) +#define IBaseFilter_QueryFilterInfo(p,a) (p)->lpVtbl->QueryFilterInfo(p,a) +#define IBaseFilter_JoinFilterGraph(p,a,b) (p)->lpVtbl->JoinFilterGraph(p,a,b) +#define IBaseFilter_QueryVendorInfo(p,a) (p)->lpVtbl->QueryVendorInfo(p,a) +#endif + +#define INTERFACE IFilterGraph +#define IFilterGraph_METHODS \ + IUnknown_METHODS \ + STDMETHOD(AddFilter)(THIS_ IBaseFilter * pFilter, LPCWSTR pName) PURE; \ + STDMETHOD(RemoveFilter)(THIS_ IBaseFilter * pFilter) PURE; \ + STDMETHOD(EnumFilter)(THIS_ IEnumFilters ** ppEnum) PURE; \ + STDMETHOD(FindFilterByName)(THIS_ LPCWSTR pName, IBaseFilter ** ppFilter) PURE; \ + STDMETHOD(ConnectDirect)(THIS_ IPin * ppinIn, IPin * ppinOut, const AM_MEDIA_TYPE * pmt) PURE; \ + STDMETHOD(Reconnect)(THIS_ IPin * ppin) PURE; \ + STDMETHOD(Disconnect)(THIS_ IPin * ppin) PURE; \ + STDMETHOD(SetDefaultSyncSource)(THIS) PURE; +ICOM_DEFINE(IFilterGraph,IUnknown) +#undef INTERFACE + +#ifdef ICOM_CINTERFACE +/*** IUnknown methods ***/ +#define IFilterGraph_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IFilterGraph_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IFilterGraph_Release(p) (p)->lpVtbl->Release(p) +/*** IFilterGraph methods ***/ +#define IFilterGraph_AddFilter(p,a,b) (p)->lpVtbl->AddFilter(p,a,b) +#define IFilterGraph_RemoveFilter(p,a) (p)->lpVtbl->RemoveFilter(p,a) +#define IFilterGraph_EnumFilter(p,a) (p)->lpVtbl->EnumFilter(p,a) +#define IFilterGraph_FindFilterByName(p,a,b) (p)->lpVtbl->FindFilterByName(p,a,b) +#define IFilterGraph_ConnectDirect(p,a,b,c) (p)->lpVtbl->ConnectDirect(p,a,b,c) +#define IFilterGraph_Reconnect(p,a) (p)->lpVtbl->Reconnect(p,a) +#define IFilterGraph_Disconnect(p,a) (p)->lpVtbl->Disconnect(p,a) +#define IFilterGraph_SetDefaultSyncSource(p) (p)->lpVtbl->SetDefaultSyncSource(p) +#endif + +#define INTERFACE IEnumFilters +#define IEnumFilters_METHODS \ + IUnknown_METHODS \ + STDMETHOD(Next)(THIS_ ULONG cFilters, IBaseFilter ** ppFilter, ULONG * pcFetched) PURE; \ + STDMETHOD(Skip)(THIS_ ULONG cFilters) PURE; \ + STDMETHOD(Reset)(THIS) PURE; \ + STDMETHOD(Clone)(THIS_ IEnumFilters ** ppEnum) PURE; +ICOM_DEFINE(IEnumFilters,IUnknown) +#undef INTERFACE + +#ifdef ICOM_CINTERFACE +/*** IUnknown methods ***/ +#define IEnumFilters_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IEnumFilters_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IEnumFilters_Release(p) (p)->lpVtbl->Release(p) +/*** IEnumFilters methods ***/ +#define IEnumFilters_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c) +#define IEnumFilters_Skip(p,a) (p)->lpVtbl->Skip(p,a) +#define IEnumFilters_Reset(p) (p)->lpVtbl->Reset(p) +#define IEnumFilters_Clone(p,a) (p)->lpVtbl->Clone(p,a) +#endif + +#define INTERFACE IEnumMediaTypes +#define IEnumMediaTypes_METHODS \ + IUnknown_METHODS \ + STDMETHOD(Next)(THIS_ ULONG cMediaTypes, AM_MEDIA_TYPE ** ppMediaTypes, ULONG * pcFetched) PURE; \ + STDMETHOD(Skip)(THIS_ ULONG cMediaTypes) PURE; \ + STDMETHOD(Reset)(THIS) PURE; \ + STDMETHOD(Clone)(THIS_ IEnumMediaTypes ** ppEnum) PURE; +ICOM_DEFINE(IEnumMediaTypes,IUnknown) +#undef INTERFACE + +#ifdef ICOM_CINTERFACE +/*** IUnknown methods ***/ +#define IEnumMediaTypes_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IEnumMediaTypes_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IEnumMediaTypes_Release(p) (p)->lpVtbl->Release(p) +/*** IEnumMediaTypes methods ***/ +#define IEnumMediaTypes_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c) +#define IEnumMediaTypes_Skip(p,a) (p)->lpVtbl->Skip(p,a) +#define IEnumMediaTypes_Reset(p) (p)->lpVtbl->Reset(p) +#define IEnumMediaTypes_Clone(p,a) (p)->lpVtbl->Clone(p,a) +#endif + +#define INTERFACE IReferenceClock +#define IReferenceClock_METHODS \ + IUnknown_METHODS \ + STDMETHOD(GetTime)(THIS_ REFERENCE_TIME * pTime) PURE; \ + STDMETHOD(AdviseTime)(THIS_ REFERENCE_TIME baseTime, REFERENCE_TIME streamTime, HEVENT hEvent, DWORD_PTR * pdwAdviseCookie) PURE; \ + STDMETHOD(AdvisePeriodic)(THIS_ REFERENCE_TIME startTime, REFERENCE_TIME periodTime, HSEMAPHORE hSemaphore, DWORD_PTR * pdwAdviseCookie) PURE; \ + STDMETHOD(Unadvise)(THIS_ DWORD_PTR dwAdviseCookie) PURE; +ICOM_DEFINE(IReferenceClock,IUnknown) +#undef INTERFACE + +#ifdef ICOM_CINTERFACE +/*** IUnknown methods ***/ +#define IReferenceClock_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IReferenceClock_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IReferenceClock_Release(p) (p)->lpVtbl->Release(p) +/*** IReferenceClock methods ***/ +#define IReferenceClock_GetTime(p,a) (p)->lpVtbl->GetTime(p,a) +#define IReferenceClock_AdviseTime(p,a,b,c,d) (p)->lpVtbl->AdviseTime(p,a,b,c,d) +#define IReferenceClock_AdvisePeriodic(p,a,b,c,d) (p)->lpVtbl->AdvisePeriodic(p,a,b,c,d) +#define IReferenceClock_Unadvise(p,a) (p)->lpVtbl->Unadvise(p,a) +#endif + +#define INTERFACE IGraphBuilder +#define IGraphBuilder_METHODS \ + IFilterGraph_METHODS \ + STDMETHOD(Connect)(THIS_ IPin * ppinOut, IPin * ppinIn) PURE; \ + STDMETHOD(Render)(THIS_ IPin * ppinOut) PURE; \ + STDMETHOD(RenderFile)(THIS_ LPCWSTR lpcwstrFile, LPCWSTR lpcwstrPlayList) PURE; \ + STDMETHOD(AddSourceFilter)(THIS_ LPCWSTR lpcwstrFileName, LPCWSTR lpcwstrFilterName, IBaseFilter ** ppFilter) PURE; \ + STDMETHOD(SetLogFile)(THIS_ DWORD_PTR hFile) PURE; \ + STDMETHOD(Abort)(THIS) PURE; \ + STDMETHOD(ShouldOperationContinue)(THIS) PURE; +ICOM_DEFINE(IGraphBuilder,IFilterGraph) +#undef INTERFACE + +#ifdef ICOM_CINTERFACE +/*** IUnknown methods ***/ +#define IGraphBuilder_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IGraphBuilder_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IGraphBuilder_Release(p) (p)->lpVtbl->Release(p) +/*** IFilterGraph methods ***/ +#define IGraphBuilder_AddFilter(p,a,b) (p)->lpVtbl->AddFilter(p,a,b) +#define IGraphBuilder_RemoveFilter(p,a) (p)->lpVtbl->RemoveFilter(p,a) +#define IGraphBuilder_EnumFilter(p,a) (p)->lpVtbl->EnumFilter(p,a) +#define IGraphBuilder_FindFilterByName(p,a,b) (p)->lpVtbl->FindFilterByName(p,a,b) +#define IGraphBuilder_ConnectDirect(p,a,b,c) (p)->lpVtbl->ConnectDirect(p,a,b,c) +#define IGraphBuilder_Reconnect(p,a) (p)->lpVtbl->Reconnect(p,a) +#define IGraphBuilder_Disconnect(p,a) (p)->lpVtbl->Disconnect(p,a) +#define IGraphBuilder_SetDefaultSyncSource(p) (p)->lpVtbl->SetDefaultSyncSource(p) +/*** IGraphBuilder methods ***/ +#define IGraphBuilder_Connect(p,a,b) (p)->lpVtbl->Connect(p,a,b) +#define IGraphBuilder_Render(p,a) (p)->lpVtbl->Render(p,a) +#define IGraphBuilder_RenderFile(p,a,b) (p)->lpVtbl->RenderFile(p,a,b) +#define IGraphBuilder_AddSourceFilter(p,a,b,c) (p)->lpVtbl->AddSourceFilter(p,a,b,c) +#define IGraphBuilder_SetLogFile(p,a) (p)->lpVtbl->SetLogFile(p,a) +#define IGraphBuilder_Abort(p) (p)->lpVtbl->Abort(p) +#define IGraphBuilder_ShouldOperationContinue(p) (p)->lpVtbl->ShouldOperationContinue(p) +#endif + +#define INTERFACE IMediaSeeking +#define IMediaSeeking_METHODS \ + IUnknown_METHODS \ + STDMETHOD(GetCapabilities)(THIS_ DWORD * pCapabilities) PURE; \ + STDMETHOD(CheckCapabilities)(THIS_ DWORD * pCapabilities) PURE; \ + STDMETHOD(IsFormatSupported)(THIS_ GUID * pFormat) PURE; \ + STDMETHOD(QueryPreferredFormat)(THIS_ GUID * pFormat) PURE; \ + STDMETHOD(GetTimeFormat)(THIS_ GUID * pFormat) PURE; \ + STDMETHOD(IsUsingTimeFormat)(THIS_ GUID * pFormat) PURE; \ + STDMETHOD(SetTimeFormat)(THIS_ GUID * pFormat) PURE; \ + STDMETHOD(GetDuration)(THIS_ LONGLONG * pDuration) PURE; \ + STDMETHOD(GetStopPosition)(THIS_ LONGLONG * pStop) PURE; \ + STDMETHOD(GetCurrentPosition)(THIS_ LONGLONG * pCurrent) PURE; \ + STDMETHOD(ConvertTimeFormat)(THIS_ LONGLONG * pTarget, GUID * pTargetFormat, LONGLONG Source, GUID * pSourceFormat) PURE; \ + STDMETHOD(SetPositions)(THIS_ LONGLONG * pCurrent, DWORD dwCurrentFlags, LONGLONG * pStop, DWORD dwStopFlags) PURE; \ + STDMETHOD(GetPositions)(THIS_ LONGLONG * pCurrent, LONGLONG * pStop) PURE; \ + STDMETHOD(GetAvailable)(THIS_ LONGLONG * pEarliest, LONGLONG * pLatest) PURE; \ + STDMETHOD(SetRate)(THIS_ double dRate) PURE; \ + STDMETHOD(GetRate)(THIS_ double * pdRate) PURE; \ + STDMETHOD(GetPreroll)(THIS_ LONGLONG * pllPreroll) PURE; +ICOM_DEFINE(IMediaSeeking,IUnknown) +#undef INTERFACE + +#ifdef ICOM_CINTERFACE +/*** IUnknown methods ***/ +#define IMediaSeeking_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IMediaSeeking_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IMediaSeeking_Release(p) (p)->lpVtbl->Release(p) +/*** IMediaSeeking methods ***/ +#define IMediaSeeking_GetCapabilities(p,a) (p)->lpVtbl->GetCapabilities(p,a) +#define IMediaSeeking_CheckCapabilities(p,a) (p)->lpVtbl->CheckCapabilities(p,a) +#define IMediaSeeking_IsFormatSupported(p,a) (p)->lpVtbl->IsFormatSupported(p,a) +#define IMediaSeeking_QueryPreferredFormat(p,a) (p)->lpVtbl->QueryPreferredFormat(p,a) +#define IMediaSeeking_GetTimeFormat(p,a) (p)->lpVtbl->GetTimeFormat(p,a) +#define IMediaSeeking_IsUsingTimeFormat(p,a) (p)->lpVtbl->IsUsingTimeFormat(p,a) +#define IMediaSeeking_SetTimeFormat(p,a) (p)->lpVtbl->SetTimeFormat(p,a) +#define IMediaSeeking_GetDuration(p,a) (p)->lpVtbl->GetDuration(p,a) +#define IMediaSeeking_GetStopPosition(p,a) (p)->lpVtbl->GetStopPosition(p,a) +#define IMediaSeeking_GetCurrentPosition(p,a) (p)->lpVtbl->GetCurrentPosition(p,a) +#define IMediaSeeking_ConvertTimeFormat(p,a,b,c,d) (p)->lpVtbl->ConvertTimeFormat(p,a,b,c,d) +#define IMediaSeeking_SetPositions(p,a,b,c,d) (p)->lpVtbl->SetPositions(p,a,b,c,d) +#define IMediaSeeking_GetPositions(p,a,b) (p)->lpVtbl->GetPositions(p,a,b) +#define IMediaSeeking_GetAvailable(p,a,b) (p)->lpVtbl->GetAvailable(p,a,b) +#define IMediaSeeking_SetRate(p,a) (p)->lpVtbl->SetRate(p,a) +#define IMediaSeeking_GetRate(p,a) (p)->lpVtbl->GetRate(p,a) +#define IMediaSeeking_GetPreroll(p,a) (p)->lpVtbl->GetPreroll(p,a) +#endif + +#endif /* __STRMIF_INCLUDED__ */ diff --git a/include/uuids.h b/include/uuids.h index 62349b5ad2b..07442f7e8c0 100644 --- a/include/uuids.h +++ b/include/uuids.h @@ -270,5 +270,13 @@ OUR_GUID_ENTRY(CLSID_VideoProcAmpPropertyPage, 0x71f96464, 0x78f3, 0x11d0, OUR_GUID_ENTRY(CLSID_CameraControlPropertyPage, 0x71f96465, 0x78f3, 0x11d0, 0xa1, 0x8c, 0x00, 0xa0, 0xc9, 0x11, 0x89, 0x56) OUR_GUID_ENTRY(CLSID_AnalogVideoDecoderPropertyPage, 0x71f96466, 0x78f3, 0x11d0, 0xa1, 0x8c, 0x00, 0xa0, 0xc9, 0x11, 0x89, 0x56) OUR_GUID_ENTRY(CLSID_VideoStreamConfigPropertyPage, 0x71f96467, 0x78f3, 0x11d0, 0xa1, 0x8c, 0x00, 0xa0, 0xc9, 0x11, 0x89, 0x56) +OUR_GUID_ENTRY(IID_IGraphBuilder, 0x56a868a9, 0x0ad4, 0x11ce, 0xb0, 0x3a, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(IID_IMediaControl, 0x56a868b1, 0x0ad4, 0x11ce, 0xb0, 0x3a, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(IID_IMediaSeeking, 0x36b73880, 0xc2c8, 0x11cf, 0x8b, 0x46, 0x00, 0x80, 0x5f, 0x6c, 0xef, 0x60) +OUR_GUID_ENTRY(IID_IBasicVideo, 0x56a868b5, 0x0ad4, 0x11ce, 0xb0, 0x3a, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(IID_IVideoWindow, 0x56a868b4, 0x0ad4, 0x11ce, 0xb0, 0x3a, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(IID_IMediaEvent, 0x56a868b6, 0x0ad4, 0x11ce, 0xb0, 0x3a, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(IID_IMediaEventEx, 0x56a868c0, 0x0ad4, 0x11ce, 0xb0, 0x3a, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(IID_IBasicAudio, 0x56a868b3, 0x0ad4, 0x11ce, 0xb0, 0x3a, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) #undef OUR_GUID_ENTRY diff --git a/winedefault.reg b/winedefault.reg index f7ad3e7c905..acf75ff144a 100644 --- a/winedefault.reg +++ b/winedefault.reg @@ -4004,3 +4004,14 @@ [HKEY_CLASSES_ROOT\txtfile\shell\print\command] @="C:\\WINDOWS\\NOTEPAD.EXE /p %1" + + +# +# Entries for DirectShow +# +[Software\\CLASSES\\CLSID\\{E436EBB3-524F-11CE-9F53-0020AF0BA770}] 1032641842 +@="Filter Graph" + +[Software\\CLASSES\\CLSID\\{E436EBB3-524F-11CE-9F53-0020AF0BA770}\\InprocServer32] 1032641842 +@="C:\\windows\\system\\quartz.dll" +"ThreadingModel"="Both" -- GitLab