Stubbed some interfaces for the FilterGraph CLSID.

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@

dlls/quartz/filtergraph.c

+/*              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;
+}

dlls/quartz/main.c

+/*              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
 {
-	FIXME("(): stub\n");
-	return 0;
+    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)
+{
+    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;
 }
 
-/***********************************************************************
- *		DllGetClassObject (QUARTZ.@)
+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
  */
-HRESULT WINAPI QUARTZ_DllGetClassObject(REFCLSID rclsid, REFIID iid, LPVOID *ppv)
+DWORD WINAPI QUARTZ_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
 {
-    FIXME("\n\tCLSID:\t%s,\n\tIID:\t%s\n",debugstr_guid(rclsid),debugstr_guid(iid));
+    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;
+}
+
+/***********************************************************************
+ *      DllRegisterServer (QUARTZ.@)
+ */
+HRESULT WINAPI QUARTZ_DllRegisterServer()
+{
+        FIXME("(): stub\n");
+        return 0;
 }
 
 /***********************************************************************

dlls/quartz/quartz_private.h

+/*              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__ */

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 \

include/control.h

+/*
+ * 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__ */

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"*/

include/strmif.h

+/*
+ * 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__ */

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

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"