Add amstream dll (MultiMedia Streams), part of Direct Show.

configure.ac

@@ -1492,6 +1492,7 @@ Makefile
 dlls/Makefile
 dlls/advapi32/Makefile
 dlls/advapi32/tests/Makefile
+dlls/amstream/Makefile
 dlls/avicap32/Makefile
 dlls/avifil32/Makefile
 dlls/cabinet/Makefile

dlls/Makefile.in

@@ -17,6 +17,7 @@ EXTRADIRS = @GLU32FILES@ @GLUT32FILES@ @OPENGLFILES@ @XFILES@
 
 BASEDIRS = \
 	advapi32 \
+	amstream \
 	avicap32 \
 	avifil32 \
 	cabinet \
@@ -225,6 +226,7 @@ SYMLINKS = \
 	$(EXTRADIRS:%=%.dll$(DLLEXT)) \
 	@WIN16_FILES@ \
 	advapi32.dll$(DLLEXT) \
+	amstream.dll$(DLLEXT) \
 	avicap32.dll$(DLLEXT) \
 	avifil32.dll$(DLLEXT) \
 	cabinet.dll$(DLLEXT) \
@@ -368,6 +370,9 @@ all: $(SYMLINKS)
 advapi32.dll$(DLLEXT): advapi32/advapi32.dll$(DLLEXT)
 	$(RM) $@ && $(LN_S) advapi32/advapi32.dll$(DLLEXT) $@
 
+amstream.dll$(DLLEXT): amstream/amstream.dll$(DLLEXT)
+	$(RM) $@ && $(LN_S) amstream/amstream.dll$(DLLEXT) $@
+
 avicap32.dll$(DLLEXT): avicap32/avicap32.dll$(DLLEXT)
 	$(RM) $@ && $(LN_S) avicap32/avicap32.dll$(DLLEXT) $@
 
@@ -882,6 +887,7 @@ libuuid.a: uuid/libuuid.a
 
 IMPORT_LIBS = \
 	libadvapi32 \
+	libamstream \
 	libavicap32 \
 	libavifil32 \
 	libcabinet \
@@ -1005,6 +1011,11 @@ libadvapi32.def: advapi32/advapi32.spec.def
 libadvapi32.a: advapi32/advapi32.spec.def
 	$(DLLTOOL) -k -l $@ -d advapi32/advapi32.spec.def
 
+libamstream.def: amstream/amstream.spec.def
+	$(RM) $@ && $(LN_S) amstream/amstream.spec.def $@
+libamstream.a: amstream/amstream.spec.def
+	$(DLLTOOL) -k -l $@ -d amstream/amstream.spec.def
+
 libavicap32.def: avicap32/avicap32.spec.def
 	$(RM) $@ && $(LN_S) avicap32/avicap32.spec.def $@
 libavicap32.a: avicap32/avicap32.spec.def
@@ -1566,6 +1577,7 @@ libx11drv.a: x11drv/x11drv.spec.def
 	$(DLLTOOL) -k -l $@ -d x11drv/x11drv.spec.def
 
 advapi32/advapi32.spec.def: $(WINEBUILD)
+amstream/amstream.spec.def: $(WINEBUILD)
 avicap32/avicap32.spec.def: $(WINEBUILD)
 avifil32/avifil32.spec.def: $(WINEBUILD)
 cabinet/cabinet.spec.def: $(WINEBUILD)
@@ -1685,6 +1697,7 @@ $(INSTALLSUBDIRS:%=%/__install__): $(ALL_IMPORT_LIBS)
 # Map library name to the corresponding directory
 
 advapi32/advapi32.dll$(DLLEXT): advapi32
+amstream/amstream.dll$(DLLEXT): amstream
 avicap32/avicap32.dll$(DLLEXT): avicap32
 avifil32/avifil32.dll$(DLLEXT): avifil32
 cabinet/cabinet.dll$(DLLEXT): cabinet

dlls/amstream/.cvsignore

+Makefile
+amstream.dll.dbg.c
+amstream.spec.c
+amstream.spec.def
+version.res

dlls/amstream/Makefile.in

+TOPSRCDIR = @top_srcdir@
+TOPOBJDIR = ../..
+SRCDIR    = @srcdir@
+VPATH     = @srcdir@
+MODULE    = amstream.dll
+IMPORTS   = ole32 user32 advapi32 kernel32
+EXTRALIBS = -luuid
+
+C_SRCS = \
+	amstream.c \
+	main.c \
+	regsvr.c
+
+RC_SRCS = version.rc
+
+@MAKE_DLL_RULES@
+
+### Dependencies:

dlls/amstream/amstream.c

+/*
+ * Implementation of IAMMultiMediaStream Interface
+ *
+ * Copyright 2004 Christian Costa
+ *
+ * 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 "winbase.h"
+#include "wingdi.h"
+
+#include "amstream_private.h"
+#include "amstream.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(amstream);
+
+typedef struct {
+    IAMMultiMediaStream lpVtbl;
+    int ref;
+} IAMMultiMediaStreamImpl;
+
+static struct ICOM_VTABLE(IAMMultiMediaStream) AM_Vtbl;
+
+HRESULT AM_create(IUnknown *pUnkOuter, LPVOID *ppObj)
+{
+    IAMMultiMediaStreamImpl* object; 
+
+    FIXME("(%p,%p)\n", pUnkOuter, ppObj);
+      
+    object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IAMMultiMediaStreamImpl));
+    
+    object->lpVtbl.lpVtbl = &AM_Vtbl;
+    object->ref = 1;
+
+    *ppObj = object;
+    
+    return S_OK;
+}
+
+/*** IUnknown methods ***/
+static HRESULT WINAPI IAMMultiMediaStreamImpl_QueryInterface(IAMMultiMediaStream* iface, REFIID riid, void** ppvObject)
+{
+  ICOM_THIS(IAMMultiMediaStreamImpl, iface);
+
+  FIXME("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
+
+  if (IsEqualGUID(riid, &IID_IUnknown)
+      || IsEqualGUID(riid, &IID_IAMMultiMediaStream))
+  {
+    IClassFactory_AddRef(iface);
+    *ppvObject = This;
+    return S_OK;
+  }
+
+  ERR("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
+  return E_NOINTERFACE;
+}
+
+static ULONG WINAPI IAMMultiMediaStreamImpl_AddRef(IAMMultiMediaStream* iface)
+{
+  ICOM_THIS(IAMMultiMediaStreamImpl, iface);
+
+  FIXME("(%p/%p)\n", iface, This); 
+
+  This->ref++;
+  return S_OK;
+}
+
+static ULONG WINAPI IAMMultiMediaStreamImpl_Release(IAMMultiMediaStream* iface)
+{
+  ICOM_THIS(IAMMultiMediaStreamImpl, iface);
+
+  FIXME("(%p/%p)\n", iface, This); 
+
+  if (!--This->ref)
+    HeapFree(GetProcessHeap(), 0, This);
+
+  return S_OK;
+}
+
+/*** IMultiMediaStream methods ***/
+static HRESULT WINAPI IAMMultiMediaStreamImpl_GetInformation(IAMMultiMediaStream* iface, char* pdwFlags, STREAM_TYPE* pStreamType)
+{
+  ICOM_THIS(IAMMultiMediaStreamImpl, iface);
+
+  FIXME("(%p/%p)->(%p,%p) stub!\n", This, iface, pdwFlags, pStreamType); 
+
+  return S_FALSE;
+}
+
+static HRESULT WINAPI IAMMultiMediaStreamImpl_GetMediaStream(IAMMultiMediaStream* iface, REFMSPID idPurpose, IMediaStream** ppMediaStream)
+{
+  ICOM_THIS(IAMMultiMediaStreamImpl, iface);
+
+  FIXME("(%p/%p)->(%p,%p) stub!\n", This, iface, idPurpose, ppMediaStream); 
+
+  return S_FALSE;
+}
+
+static HRESULT WINAPI IAMMultiMediaStreamImpl_EnumMediaStreams(IAMMultiMediaStream* iface, long Index, IMediaStream** ppMediaStream)
+{
+  ICOM_THIS(IAMMultiMediaStreamImpl, iface);
+
+  FIXME("(%p/%p)->(%ld,%p) stub!\n", This, iface, Index, ppMediaStream); 
+
+  return S_FALSE;
+}
+
+static HRESULT WINAPI IAMMultiMediaStreamImpl_GetState(IAMMultiMediaStream* iface, STREAM_STATE* pCurrentState)
+{
+  ICOM_THIS(IAMMultiMediaStreamImpl, iface);
+
+  FIXME("(%p/%p)->(%p) stub!\n", This, iface, pCurrentState); 
+
+  return S_FALSE;
+}
+
+static HRESULT WINAPI IAMMultiMediaStreamImpl_SetState(IAMMultiMediaStream* iface, STREAM_STATE NewState)
+{
+  ICOM_THIS(IAMMultiMediaStreamImpl, iface);
+  
+  FIXME("(%p/%p)->() stub!\n", This, iface); 
+
+  return S_FALSE;
+}
+
+static HRESULT WINAPI IAMMultiMediaStreamImpl_GetTime(IAMMultiMediaStream* iface, STREAM_TIME* pCurrentTime)
+{
+  ICOM_THIS(IAMMultiMediaStreamImpl, iface);
+
+  FIXME("(%p/%p)->(%p) stub!\n", This, iface, pCurrentTime); 
+
+  return S_FALSE;
+}
+
+static HRESULT WINAPI IAMMultiMediaStreamImpl_GetDuration(IAMMultiMediaStream* iface, STREAM_TIME* pDuration)
+{
+  ICOM_THIS(IAMMultiMediaStreamImpl, iface);
+
+  FIXME("(%p/%p)->(%p) stub!\n", This, iface, pDuration); 
+
+  return S_FALSE;
+}
+
+static HRESULT WINAPI IAMMultiMediaStreamImpl_Seek(IAMMultiMediaStream* iface, STREAM_TIME SeekTime)
+{
+  ICOM_THIS(IAMMultiMediaStreamImpl, iface);
+
+  FIXME("(%p/%p)->() stub!\n", This, iface); 
+
+  return S_FALSE;
+}
+
+static HRESULT WINAPI IAMMultiMediaStreamImpl_GetEndOfStream(IAMMultiMediaStream* iface, HANDLE* phEOS)
+{
+  ICOM_THIS(IAMMultiMediaStreamImpl, iface);
+
+  FIXME("(%p/%p)->(%p) stub!\n", This, iface, phEOS); 
+
+  return S_FALSE;
+}
+
+/*** IAMMultiMediaStream methods ***/
+static HRESULT WINAPI IAMMultiMediaStreamImpl_Initialize(IAMMultiMediaStream* iface, STREAM_TYPE StreamType, DWORD dwFlags, IGraphBuilder* pFilterGraph)
+{
+  ICOM_THIS(IAMMultiMediaStreamImpl, iface);
+
+  FIXME("(%p/%p)->(%lx,%lx,%p) stub!\n", This, iface, (DWORD)StreamType, dwFlags, pFilterGraph); 
+
+  return S_FALSE;
+}
+
+static HRESULT WINAPI IAMMultiMediaStreamImpl_GetFilterGraph(IAMMultiMediaStream* iface, IGraphBuilder** ppGraphBuilder)
+{
+  ICOM_THIS(IAMMultiMediaStreamImpl, iface);
+
+  FIXME("(%p/%p)->(%p) stub!\n", This, iface, ppGraphBuilder); 
+
+  return S_FALSE;
+}
+
+static HRESULT WINAPI IAMMultiMediaStreamImpl_GetFilter(IAMMultiMediaStream* iface, IMediaStreamFilter** ppFilter)
+{
+  ICOM_THIS(IAMMultiMediaStreamImpl, iface);
+
+  FIXME("(%p/%p)->(%p) stub!\n", This, iface, ppFilter); 
+
+  return S_FALSE;
+}
+
+static HRESULT WINAPI IAMMultiMediaStreamImpl_AddMediaStream(IAMMultiMediaStream* iface, IUnknown* pStreamObject, const MSPID* PurposeId,
+                                          DWORD dwFlags, IMediaStream** ppNewStream)
+{
+  ICOM_THIS(IAMMultiMediaStreamImpl, iface);
+
+  FIXME("(%p/%p)->(%p,%p,%lx,%p) stub!\n", This, iface, pStreamObject, PurposeId, dwFlags, ppNewStream); 
+
+  return S_FALSE;
+}
+
+static HRESULT WINAPI IAMMultiMediaStreamImpl_OpenFile(IAMMultiMediaStream* iface, LPCWSTR pszFileName, DWORD dwFlags)
+{
+  ICOM_THIS(IAMMultiMediaStreamImpl, iface);
+
+  FIXME("(%p/%p)->(%p,%lx) stub!\n", This, iface, pszFileName, dwFlags); 
+
+  return S_FALSE;
+}
+
+static HRESULT WINAPI IAMMultiMediaStreamImpl_OpenMoniker(IAMMultiMediaStream* iface, IBindCtx* pCtx, IMoniker* pMoniker, DWORD dwFlags)
+{
+  ICOM_THIS(IAMMultiMediaStreamImpl, iface);
+
+  FIXME("(%p/%p)->(%p,%p,%lx) stub!\n", This, iface, pCtx, pMoniker, dwFlags); 
+
+  return S_FALSE;
+}
+
+static HRESULT WINAPI IAMMultiMediaStreamImpl_Render(IAMMultiMediaStream* iface, DWORD dwFlags)
+{
+  ICOM_THIS(IAMMultiMediaStreamImpl, iface);
+
+  FIXME("(%p/%p)->(%lx) stub!\n", This, iface, dwFlags); 
+
+  return S_FALSE;
+}
+
+static ICOM_VTABLE(IAMMultiMediaStream) AM_Vtbl =
+{
+    ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
+    IAMMultiMediaStreamImpl_QueryInterface,
+    IAMMultiMediaStreamImpl_AddRef,
+    IAMMultiMediaStreamImpl_Release,
+    IAMMultiMediaStreamImpl_GetInformation,
+    IAMMultiMediaStreamImpl_GetMediaStream,
+    IAMMultiMediaStreamImpl_EnumMediaStreams,
+    IAMMultiMediaStreamImpl_GetState,
+    IAMMultiMediaStreamImpl_SetState,
+    IAMMultiMediaStreamImpl_GetTime,
+    IAMMultiMediaStreamImpl_GetDuration,
+    IAMMultiMediaStreamImpl_Seek,
+    IAMMultiMediaStreamImpl_GetEndOfStream,
+    IAMMultiMediaStreamImpl_Initialize,
+    IAMMultiMediaStreamImpl_GetFilterGraph,
+    IAMMultiMediaStreamImpl_GetFilter,
+    IAMMultiMediaStreamImpl_AddMediaStream,
+    IAMMultiMediaStreamImpl_OpenFile,
+    IAMMultiMediaStreamImpl_OpenMoniker,
+    IAMMultiMediaStreamImpl_Render
+};

dlls/amstream/amstream.spec

+@ stdcall -private DllCanUnloadNow() AMSTREAM_DllCanUnloadNow
+@ stdcall -private DllGetClassObject(ptr ptr ptr) AMSTREAM_DllGetClassObject
+@ stdcall -private DllRegisterServer() AMSTREAM_DllRegisterServer
+@ stdcall -private DllUnregisterServer() AMSTREAM_DllUnregisterServer

dlls/amstream/amstream_private.h

+/*
+ *      MultiMedia Streams private interfaces (AMSTREAM.DLL)
+ *
+ * Copyright 2004 Christian Costa
+ *
+ * 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 __AMSTREAM_PRIVATE_INCLUDED__
+#define __AMSTREAM_PRIVATE_INCLUDED__
+
+#include <stdarg.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "wtypes.h"
+#include "wingdi.h"
+#include "winuser.h"
+#include "dshow.h"
+
+HRESULT AM_create(IUnknown *pUnkOuter, LPVOID *ppObj);
+
+#endif /* __AMSTREAM_PRIVATE_INCLUDED__ */

dlls/amstream/main.c

+/*
+ *     MultiMedia Streams Base Functions (AMSTREAM.DLL)
+ *
+ * Copyright 2004 Christian Costa
+ *
+ * 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
+ */
+
+#define COM_NO_WINDOWS_H
+
+#include <stdarg.h>
+#include <string.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "winuser.h"
+#include "winreg.h"
+#include "winerror.h"
+
+#include "ole2.h"
+#include "uuids.h"
+
+#include "amstream_private.h"
+#include "amstream.h"
+
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(amstream);
+
+static DWORD dll_ref = 0;
+
+/* For the moment, do nothing here. */
+BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv)
+{
+    switch(fdwReason) {
+        case DLL_PROCESS_ATTACH:
+            DisableThreadLibraryCalls(hInstDLL);
+	    break;
+	case DLL_PROCESS_DETACH:
+	    break;
+    }
+    return TRUE;
+}
+
+/******************************************************************************
+ * Multimedia Streams ClassFactory
+ */
+typedef struct {
+    IClassFactory ITF_IClassFactory;
+
+    DWORD ref;
+    HRESULT (*pfnCreateInstance)(IUnknown *pUnkOuter, LPVOID *ppObj);
+} IClassFactoryImpl;
+
+struct object_creation_info
+{
+    const CLSID *clsid;
+    HRESULT (*pfnCreateInstance)(IUnknown *pUnkOuter, LPVOID *ppObj);
+};
+
+static const struct object_creation_info object_creation[] =
+{
+    { &CLSID_AMMultiMediaStream, AM_create },
+};
+
+static HRESULT WINAPI
+AMCF_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;
+}
+
+static ULONG WINAPI AMCF_AddRef(LPCLASSFACTORY iface) {
+    ICOM_THIS(IClassFactoryImpl,iface);
+    return ++(This->ref);
+}
+
+static ULONG WINAPI AMCF_Release(LPCLASSFACTORY iface) {
+    ICOM_THIS(IClassFactoryImpl,iface);
+
+    ULONG ref = --This->ref;
+
+    if (ref == 0)
+	HeapFree(GetProcessHeap(), 0, This);
+
+    return ref;
+}
+
+
+static HRESULT WINAPI AMCF_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 AMCF_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
+    AMCF_QueryInterface,
+    AMCF_AddRef,
+    AMCF_Release,
+    AMCF_CreateInstance,
+    AMCF_LockServer
+};
+
+/*******************************************************************************
+ * DllGetClassObject [AMSTREAM.@]
+ * Retrieves class object from a DLL object
+ *
+ * NOTES
+ *    Docs say returns STDAPI
+ *
+ * PARAMS
+ *    rclsid [I] CLSID for the class object
+ *    riid   [I] Reference to identifier of interface for class object
+ *    ppv    [O] Address of variable to receive interface pointer for riid
+ *
+ * RETURNS
+ *    Success: S_OK
+ *    Failure: CLASS_E_CLASSNOTAVAILABLE, E_OUTOFMEMORY, E_INVALIDARG,
+ *             E_UNEXPECTED
+ */
+DWORD WINAPI AMSTREAM_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
+{
+    int i;
+    IClassFactoryImpl *factory;
+    
+    TRACE("(%s,%s,%p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
+    
+    if ( !IsEqualGUID( &IID_IClassFactory, riid )
+	 && ! IsEqualGUID( &IID_IUnknown, riid) )
+	return E_NOINTERFACE;
+
+    for (i=0; i < sizeof(object_creation)/sizeof(object_creation[0]); i++)
+    {
+	if (IsEqualGUID(object_creation[i].clsid, rclsid))
+	    break;
+    }
+
+    if (i == sizeof(object_creation)/sizeof(object_creation[0]))
+    {
+	FIXME("%s: no class found.\n", debugstr_guid(rclsid));
+	return CLASS_E_CLASSNOTAVAILABLE;
+    }
+
+    factory = HeapAlloc(GetProcessHeap(), 0, sizeof(*factory));
+    if (factory == NULL) return E_OUTOFMEMORY;
+
+    factory->ITF_IClassFactory.lpVtbl = &DSCF_Vtbl;
+    factory->ref = 1;
+
+    factory->pfnCreateInstance = object_creation[i].pfnCreateInstance;
+
+    *ppv = &(factory->ITF_IClassFactory);
+    return S_OK;
+}
+
+/***********************************************************************
+ *              DllCanUnloadNow (AMSTREAM.@)
+ */
+HRESULT WINAPI AMSTREAM_DllCanUnloadNow()
+{
+    return dll_ref != 0 ? S_FALSE : S_OK;
+}

dlls/amstream/version.rc

+/*
+ * Copyright (c) 2004 Christian Costa
+ *
+ * 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
+ */
+
+#define WINE_FILEDESCRIPTION_STR "Wine AMStream dll"
+#define WINE_FILENAME_STR "amstream.dll"
+#define WINE_FILEVERSION 6,3,1,881
+#define WINE_FILEVERSION_STR "6.3.1.881"
+#define WINE_PRODUCTVERSION 6,3,1,881
+#define WINE_PRODUCTVERSION_STR "6.3"
+#define WINE_PRODUCTNAME_STR "DirectShow"
+
+#include "wine/wine_common_ver.rc"

dlls/uuid/uuid.c

@@ -64,6 +64,8 @@ DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0);
 #define __IKsPropertySet_INTERFACE_DEFINED__
 #include "strmif.h"
 #include "control.h"
+#define __DDRAW_GUID_DEFINED__
+#include "amstream.h"
 
 /* GUIDs not declared in an exported header file */
 DEFINE_GUID(IID_IDirectPlaySP,0xc9f6360,0xcc61,0x11cf,0xac,0xec,0x00,0xaa,0x00,0x68,0x86,0xe3);

include/Makefile.in

@@ -5,10 +5,14 @@ VPATH	  = @srcdir@
 MODULE	  = none
 
 IDL_SRCS = \
+	amstream.idl \
 	amvideo.idl \
+	austream.idl \
 	comcat.idl \
+	ddstream.idl \
 	docobj.idl \
 	exdisp.idl \
+	mmstream.idl \
 	oaidl.idl \
 	objidl.idl \
 	ocidl.idl \

include/amstream.idl

+/*
+ * Copyright 2004 Christian Costa
+ *
+ * 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
+ */
+
+import "unknwn.idl";
+import "mmstream.idl";
+import "strmif.idl";
+
+cpp_quote("#include <ddraw.h>")
+cpp_quote("#include <mmsystem.h>")
+cpp_quote("#include <mmstream.h>")
+cpp_quote("#include <ddstream.h>")
+cpp_quote("#include <austream.h>")
+
+cpp_quote("#if 0")
+interface IDirectDraw;
+interface IDirectDrawSurface;
+cpp_quote("#endif")
+
+interface IAMMultiMediaStream;
+interface IAMMediaStream;
+interface IMediaStreamFilter;
+interface IAMMediaTypeStream;
+interface IAMMediaTypeSample;
+
+enum {
+	AMMSF_NOGRAPHTHREAD      = 0x00000001
+};
+
+enum {
+	AMMSF_ADDDEFAULTRENDERER = 0x00000001,
+	AMMSF_CREATEPEER         = 0x00000002
+};
+
+enum {
+	AMMSF_RENDERTYPEMASK     = 0x00000003,
+	AMMSF_RENDERTOEXISTING   = 0x00000000,
+	AMMSF_RENDERALLSTREAMS   = 0x00000001,
+	AMMSF_NORENDER           = 0x00000002,
+	AMMSF_NOCLOCK            = 0x00000004,
+	AMMSF_RUN                = 0x00000008
+};
+
+
+typedef [v1_enum] enum {
+	Disabled = 0,
+	ReadData = 1,
+	RenderData = 2
+} OUTPUT_STATE;
+
+/*
+[
+object,
+uuid(7DB01C96-C0C3-11d0-8FF1-00C04FD9189D),
+dual,
+helpstring("IDirectShowStream Interface"),
+pointer_default(unique)
+]
+interface IDirectShowStream : IDispatch
+{
+	[propget, id(1), helpstring("property FileName")] HRESULT FileName([out, retval] BSTR *pVal);
+	[propput, id(1), helpstring("property FileName")] HRESULT FileName([in] BSTR newVal);
+	[propget, id(2), helpstring("property Video")] HRESULT Video([out, retval] OUTPUT_STATE *pVal);
+	[propput, id(2), helpstring("propetry Video")] HRESULT Video([in] OUTPUT_STATE newVal);
+	[propget, id(3), helpstring("property Audio")] HRESULT Audio([out, retval] OUTPUT_STATE *pVal);
+	[propput, id(3), helpstring("propetry Audio")] HRESULT Audio([in] OUTPUT_STATE newVal);
+};
+*/
+
+[
+object,
+uuid(BEBE595C-9A6F-11d0-8FDE-00C04FD9189D),
+pointer_default(unique)
+]
+interface IAMMultiMediaStream : IMultiMediaStream
+{
+	HRESULT Initialize(
+		[in] STREAM_TYPE StreamType,
+		[in] DWORD dwFlags,
+		[in] /*[optional]*/ IGraphBuilder *pFilterGraph);
+
+	HRESULT GetFilterGraph(
+		[out] IGraphBuilder **ppGraphBuilder);
+
+	HRESULT GetFilter(
+		[out] IMediaStreamFilter **ppFilter);
+
+	HRESULT AddMediaStream(
+		[in] /*[optional]*/ IUnknown *pStreamObject,
+		[in] /*[optional]*/ const MSPID *PurposeId,
+		[in] DWORD dwFlags,
+		[out] /*[optional]*/ IMediaStream **ppNewStream);
+
+	HRESULT OpenFile(
+		[in] LPCWSTR pszFileName,
+		[in] DWORD dwFlags);
+
+	HRESULT OpenMoniker(
+		[in] IBindCtx *pCtx,
+		[in] IMoniker *pMoniker,
+		[in] DWORD dwFlags);
+
+	HRESULT Render(
+		[in] DWORD dwFlags);
+}
+
+
+[
+object,
+uuid(BEBE595D-9A6F-11d0-8FDE-00C04FD9189D),
+pointer_default(unique)
+]
+interface IAMMediaStream : IMediaStream
+{
+	HRESULT Initialize(
+		[in] /*[optional]*/ IUnknown *pSourceObject,
+		[in] DWORD dwFlags,
+		[in] REFMSPID PurposeId,
+		[in] const STREAM_TYPE StreamType);
+
+	HRESULT SetState(
+		[in] FILTER_STATE State);
+
+	HRESULT JoinAMMultiMediaStream(
+		[in] IAMMultiMediaStream *pAMMultiMediaStream);
+
+	HRESULT JoinFilter(
+		[in] IMediaStreamFilter *pMediaStreamFilter);
+
+	HRESULT JoinFilterGraph(
+		[in] IFilterGraph *pFilterGraph);
+};
+
+
+[
+object,
+local,
+uuid(BEBE595E-9A6F-11d0-8FDE-00C04FD9189D),
+pointer_default(unique)
+]
+interface IMediaStreamFilter : IBaseFilter
+{
+	HRESULT AddMediaStream(
+		[in] IAMMediaStream *pAMMediaStream);
+
+	HRESULT GetMediaStream(
+		[in] REFMSPID idPurpose,
+		[out] IMediaStream **ppMediaStream);
+
+	HRESULT EnumMediaStreams(
+		[in] long Index,
+		[out] IMediaStream **ppMediaStream);
+
+	HRESULT SupportSeeking(
+		[in] BOOL bRenderer);
+
+	HRESULT ReferenceTimeToStreamTime(
+		[in] [out] REFERENCE_TIME *pTime);
+
+	HRESULT GetCurrentStreamTime(
+		[out] REFERENCE_TIME *pCurrentStreamTime);
+
+	HRESULT WaitUntil(
+		[in]  REFERENCE_TIME WaitStreamTime);
+
+	HRESULT Flush(
+		[in] BOOL bCancelEOS);
+
+	HRESULT EndOfStream();
+};
+
+
+[
+object,
+local,
+uuid(AB6B4AFC-F6E4-11d0-900D-00C04FD9189D),
+pointer_default(unique)
+]
+interface IDirectDrawMediaSampleAllocator : IUnknown
+{
+	HRESULT GetDirectDraw(IDirectDraw **ppDirectDraw);
+};
+
+
+[
+object,
+local,
+uuid(AB6B4AFE-F6E4-11d0-900D-00C04FD9189D),
+pointer_default(unique)
+]
+interface IDirectDrawMediaSample : IUnknown
+{
+	HRESULT GetSurfaceAndReleaseLock(
+		[out] IDirectDrawSurface **ppDirectDrawSurface,
+		[out] RECT * pRect);
+
+	HRESULT LockMediaSamplePointer(void);
+};
+
+
+[
+object,
+local,
+uuid(AB6B4AFA-F6E4-11d0-900D-00C04FD9189D),
+pointer_default(unique)
+]
+
+interface IAMMediaTypeStream : IMediaStream
+{
+	HRESULT GetFormat(
+		[out] AM_MEDIA_TYPE * pMediaType,
+		[in] DWORD dwFlags);
+
+	HRESULT SetFormat(
+		[in] AM_MEDIA_TYPE * pMediaType,
+		[in] DWORD dwFlags);
+
+	HRESULT CreateSample(
+		[in] long lSampleSize,
+		[in] /*[optional]*/ BYTE * pbBuffer,
+		[in] DWORD dwFlags,
+		[in] /*[optional]*/ IUnknown *pUnkOuter,
+		[out] IAMMediaTypeSample ** ppAMMediaTypeSample);
+
+	HRESULT GetStreamAllocatorRequirements(
+		[out] ALLOCATOR_PROPERTIES *pProps);
+
+	HRESULT SetStreamAllocatorRequirements(
+		[in] ALLOCATOR_PROPERTIES *pProps);
+};
+
+
+[
+object,
+local,
+uuid(AB6B4AFB-F6E4-11d0-900D-00C04FD9189D),
+pointer_default(unique)
+]
+interface IAMMediaTypeSample : IStreamSample
+{
+	HRESULT SetPointer(
+		[in] BYTE *pBuffer,
+		[in] long lSize);
+
+	HRESULT GetPointer(
+		[out] BYTE ** ppBuffer);
+
+	long GetSize(void);
+
+	HRESULT GetTime(
+		[out] REFERENCE_TIME * pTimeStart,
+		[out] REFERENCE_TIME * pTimeEnd);
+
+	HRESULT SetTime(
+		[in] REFERENCE_TIME * pTimeStart,
+		[in] REFERENCE_TIME * pTimeEnd);
+
+	HRESULT IsSyncPoint(void);
+
+	HRESULT SetSyncPoint(
+		BOOL bIsSyncPoint);
+
+	HRESULT IsPreroll(void);
+
+	HRESULT SetPreroll(
+		BOOL bIsPreroll);
+
+	long GetActualDataLength(void);
+
+	HRESULT SetActualDataLength(long Len);
+
+	HRESULT GetMediaType(
+		AM_MEDIA_TYPE **ppMediaType);
+
+	HRESULT SetMediaType(
+		AM_MEDIA_TYPE *pMediaType);
+
+	HRESULT IsDiscontinuity(void);
+
+	HRESULT SetDiscontinuity(
+		BOOL bDiscontinuity);
+
+	HRESULT GetMediaTime(
+		[out] LONGLONG * pTimeStart,
+		[out] LONGLONG * pTimeEnd);
+
+	HRESULT SetMediaTime(
+		[in] LONGLONG * pTimeStart,
+		[in] LONGLONG * pTimeEnd);
+};
+
+cpp_quote("DEFINE_GUID(CLSID_AMMultiMediaStream,  0x49c47ce5, 0x9ba4, 0x11d0, 0x82, 0x12, 0x00, 0xc0, 0x4f, 0xc3, 0x2c, 0x45);")
+cpp_quote("DEFINE_GUID(CLSID_AMDirectDrawStream,  0x49c47ce4, 0x9ba4, 0x11d0, 0x82, 0x12, 0x00, 0xc0, 0x4f, 0xc3, 0x2c, 0x45);")
+cpp_quote("DEFINE_GUID(CLSID_AMAudioStream,       0x8496e040, 0xaf4c, 0x11d0, 0x82, 0x12, 0x00, 0xc0, 0x4f, 0xc3, 0x2c, 0x45);")
+cpp_quote("DEFINE_GUID(CLSID_AMAudioData,         0xf2468580, 0xaf8a, 0x11d0, 0x82, 0x12, 0x00, 0xc0, 0x4f, 0xc3, 0x2c, 0x45);")
+cpp_quote("DEFINE_GUID(CLSID_AMMediaTypeStream,   0xcf0f2f7c, 0xf7bf, 0x11d0, 0x90, 0x0d, 0x00, 0xc0, 0x4f, 0xd9, 0x18, 0x9d);")

include/austream.idl

+/*
+ * Copyright 2004 Christian Costa
+ *
+ * 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
+ */
+
+import "unknwn.idl";
+import "mmstream.idl";
+
+cpp_quote("#if 0")
+typedef struct tWAVEFORMATEX WAVEFORMATEX;
+cpp_quote ("#endif")
+
+interface IAudioMediaStream;
+interface IAudioStreamSample;
+interface IMemoryData;
+interface IAudioData;
+
+[
+object,
+local,
+uuid(f7537560-a3be-11d0-8212-00c04fc32c45),
+pointer_default(unique)
+]
+interface IAudioMediaStream : IMediaStream
+{
+	HRESULT GetFormat(
+		[out] /*[optional]*/ WAVEFORMATEX *pWaveFormatCurrent
+	);
+
+	HRESULT SetFormat(
+		[in] const WAVEFORMATEX *lpWaveFormat);
+
+	HRESULT CreateSample(
+		[in] IAudioData *pAudioData,
+		[in] DWORD dwFlags,
+		[out] IAudioStreamSample **ppSample
+	);
+}
+
+
+[
+object,
+local,
+uuid(345fee00-aba5-11d0-8212-00c04fc32c45),
+pointer_default(unique)
+]
+interface IAudioStreamSample : IStreamSample
+{
+	HRESULT GetAudioData(
+		[out] IAudioData **ppAudio
+	);
+}
+
+
+[
+object,
+local,
+uuid(327fc560-af60-11d0-8212-00c04fc32c45),
+pointer_default(unique)
+]
+interface IMemoryData : IUnknown
+{
+	HRESULT SetBuffer(
+		[in] DWORD cbSize,
+		[in] BYTE *pbData,
+		[in] DWORD dwFlags
+	);
+
+	HRESULT GetInfo(
+		[out] DWORD *pdwLength,
+		[out] BYTE **ppbData,
+		[out] DWORD *pcbActualData
+	);
+	HRESULT SetActual(
+		[in] DWORD cbDataValid
+	);
+}
+
+
+[
+object,
+local,
+uuid(54c719c0-af60-11d0-8212-00c04fc32c45),
+pointer_default(unique)
+]
+interface IAudioData : IMemoryData
+{
+	HRESULT GetFormat(
+		[out] /*[optional]*/ WAVEFORMATEX *pWaveFormatCurrent
+	);
+
+	HRESULT SetFormat(
+		[in] const WAVEFORMATEX *lpWaveFormat
+	);
+}

include/ddraw.h

@@ -32,6 +32,7 @@ extern "C" {
 /*****************************************************************************
  * Predeclare the interfaces
  */
+#ifndef __DDRAW_GUID_DEFINED__
 DEFINE_GUID( CLSID_DirectDraw,		0xD7B70EE0,0x4340,0x11CF,0xB0,0x63,0x00,0x20,0xAF,0xC2,0xCD,0x35 );
 DEFINE_GUID( CLSID_DirectDraw7,         0x3C305196,0x50DB,0x11D3,0x9C,0xFE,0x00,0xC0,0x4F,0xD9,0x30,0xC5 );
 DEFINE_GUID( CLSID_DirectDrawClipper,	0x593817A0,0x7DB3,0x11CF,0xA2,0xDE,0x00,0xAA,0x00,0xb9,0x33,0x56 );
@@ -48,6 +49,7 @@ DEFINE_GUID( IID_IDirectDrawPalette,	0x6C14DB84,0xA733,0x11CE,0xA5,0x21,0x00,0x2
 DEFINE_GUID( IID_IDirectDrawClipper,	0x6C14DB85,0xA733,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60 );
 DEFINE_GUID( IID_IDirectDrawColorControl,0x4B9F0EE0,0x0D7E,0x11D0,0x9B,0x06,0x00,0xA0,0xC9,0x03,0xA3,0xB8 );
 DEFINE_GUID( IID_IDirectDrawGammaControl,0x69C11C3E,0xB46B,0x11D1,0xAD,0x7A,0x00,0xC0,0x4F,0xC2,0x9B,0x4E );
+#endif
 
 typedef struct IDirectDraw IDirectDraw,*LPDIRECTDRAW;
 typedef struct IDirectDraw2 IDirectDraw2,*LPDIRECTDRAW2;

include/ddstream.idl

+/*
+ * Copyright 2004 Christian Costa
+ *
+ * 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
+ */
+
+import "unknwn.idl";
+import "mmstream.idl";
+
+cpp_quote("#ifndef __WINE_DDRAW_H")
+typedef void * LPDDSURFACEDESC;
+typedef struct tDDSURFACEDESC DDSURFACEDESC;
+interface IDirectDraw;
+interface IDirectDrawSurface;
+interface IDirectDrawPalette;
+cpp_quote("#endif")
+cpp_quote("#include <ddraw.h>")
+
+enum {
+	DDSFF_PROGRESSIVERENDER = 0x00000001
+};
+
+interface IDirectDrawMediaStream;
+interface IDirectDrawStreamSample;
+
+[
+object,
+local,
+uuid(F4104FCE-9A70-11d0-8FDE-00C04FD9189D),
+pointer_default(unique)
+]
+interface IDirectDrawMediaStream : IMediaStream
+{
+	HRESULT GetFormat(
+		[out] /*[optional]*/ DDSURFACEDESC *pDDSDCurrent,
+		[out] /*[optional]*/ IDirectDrawPalette **ppDirectDrawPalette,
+		[out] /*[optional]*/ DDSURFACEDESC *pDDSDDesired,
+		[out] /*[optional]*/ DWORD *pdwFlags);
+
+	HRESULT SetFormat(
+		[in] const DDSURFACEDESC *pDDSurfaceDesc,
+		[in] /*[optional]*/ IDirectDrawPalette *pDirectDrawPalette);
+
+	HRESULT GetDirectDraw(
+		[out] IDirectDraw **ppDirectDraw);
+
+	HRESULT SetDirectDraw(
+		[in] IDirectDraw *pDirectDraw);
+
+	HRESULT CreateSample(
+		[in] /*[optional]*/ IDirectDrawSurface *pSurface,
+		[in] /*[optional]*/ const RECT *pRect,
+		[in] DWORD dwFlags,
+		[out] IDirectDrawStreamSample **ppSample);
+
+	HRESULT GetTimePerFrame(
+		[out] STREAM_TIME *pFrameTime);
+};
+
+
+[
+object,
+local,
+uuid(F4104FCF-9A70-11d0-8FDE-00C04FD9189D),
+pointer_default(unique)
+]
+interface IDirectDrawStreamSample : IStreamSample
+{
+	HRESULT GetSurface(
+		[out] /*[optional]*/ IDirectDrawSurface ** ppDirectDrawSurface,
+		[out] /*[optional]*/ RECT * pRect);
+
+	HRESULT SetRect(
+		[in] const RECT * pRect);
+
+};

include/mmstream.idl

+/*
+ * Copyright 2004 Christian Costa
+ *
+ * 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
+ */
+
+import "unknwn.idl";
+
+cpp_quote("#define MS_ERROR_CODE(x)                  MAKE_HRESULT(1, FACILITY_ITF, (x) + 0x400)")
+cpp_quote("#define MS_SUCCESS_CODE(x)                MAKE_HRESULT(0, FACILITY_ITF, x)")
+cpp_quote("#define MS_S_PENDING                      MS_SUCCESS_CODE(1)")
+cpp_quote("#define MS_S_NOUPDATE                     MS_SUCCESS_CODE(2)")
+cpp_quote("#define MS_S_ENDOFSTREAM                  MS_SUCCESS_CODE(3)")
+
+cpp_quote("#define MS_E_SAMPLEALLOC                  MS_ERROR_CODE(1)")
+cpp_quote("#define MS_E_PURPOSEID                    MS_ERROR_CODE(2)")
+cpp_quote("#define MS_E_NOSTREAM                     MS_ERROR_CODE(3)")
+cpp_quote("#define MS_E_NOSEEKING                    MS_ERROR_CODE(4)")
+cpp_quote("#define MS_E_INCOMPATIBLE                 MS_ERROR_CODE(5)")
+cpp_quote("#define MS_E_BUSY                         MS_ERROR_CODE(6)")
+cpp_quote("#define MS_E_NOTINIT                      MS_ERROR_CODE(7)")
+cpp_quote("#define MS_E_SOURCEALREADYDEFINED         MS_ERROR_CODE(8)")
+cpp_quote("#define MS_E_INVALIDSTREAMTYPE            MS_ERROR_CODE(9)")
+cpp_quote("#define MS_E_NOTRUNNING                   MS_ERROR_CODE(10)")
+
+cpp_quote("DEFINE_GUID(MSPID_PrimaryVideo,  0xa35ff56a, 0x9fda, 0x11d0, 0x8f, 0xdf, 0x0, 0xc0, 0x4f, 0xd9, 0x18, 0x9d);")
+cpp_quote("DEFINE_GUID(MSPID_PrimaryAudio,  0xa35ff56b, 0x9fda, 0x11d0, 0x8f, 0xdf, 0x0, 0xc0, 0x4f, 0xd9, 0x18, 0x9d);")
+
+cpp_quote("#if 0")
+typedef void* PAPCFUNC;
+cpp_quote("#endif")
+
+typedef LONGLONG STREAM_TIME;
+
+typedef GUID MSPID;
+typedef REFGUID REFMSPID;
+
+typedef enum {
+	STREAMTYPE_READ         = 0,
+	STREAMTYPE_WRITE        = 1,
+	STREAMTYPE_TRANSFORM    = 2
+} STREAM_TYPE;
+
+typedef enum {
+	STREAMSTATE_STOP        = 0,
+	STREAMSTATE_RUN         = 1
+} STREAM_STATE;
+
+
+typedef enum {
+	COMPSTAT_NOUPDATEOK                             = 0x00000001,
+	COMPSTAT_WAIT                                   = 0x00000002,
+	COMPSTAT_ABORT                                  = 0x00000004
+} COMPLETION_STATUS_FLAGS;
+
+enum {
+	MMSSF_HASCLOCK                                  = 0x00000001,
+	MMSSF_SUPPORTSEEK                               = 0x00000002,
+	MMSSF_ASYNCHRONOUS                              = 0x00000004
+};
+
+enum {
+	SSUPDATE_ASYNC                                  = 0x00000001,
+	SSUPDATE_CONTINUOUS                             = 0x00000002
+};
+
+interface IMultiMediaStream;
+interface IMediaStream;
+interface IStreamSample;
+
+
+[
+object,
+local,
+uuid(B502D1BC-9A57-11d0-8FDE-00C04FD9189D),
+pointer_default(unique)
+]
+interface IMultiMediaStream : IUnknown {
+
+	HRESULT GetInformation(
+		[out] /*[optional]*/ char *pdwFlags,
+		[out] /*[optional]*/ STREAM_TYPE *pStreamType);
+
+	HRESULT GetMediaStream(
+		[in] REFMSPID idPurpose,
+		[out] IMediaStream **ppMediaStream);
+
+	HRESULT EnumMediaStreams(
+		[in] long Index,
+		[out] IMediaStream **ppMediaStream);
+
+	HRESULT GetState(
+		[out] STREAM_STATE *pCurrentState);
+
+	HRESULT SetState(
+		[in] STREAM_STATE NewState);
+
+	HRESULT GetTime(
+		[out] STREAM_TIME *pCurrentTime);
+
+	HRESULT GetDuration(
+		[out] STREAM_TIME *pDuration);
+
+	HRESULT Seek(
+		[in] STREAM_TIME SeekTime);
+
+	HRESULT GetEndOfStreamEventHandle(
+		[out] HANDLE *phEOS);
+};
+
+
+[
+object,
+uuid(B502D1BD-9A57-11d0-8FDE-00C04FD9189D),
+pointer_default(unique)
+]
+interface IMediaStream : IUnknown {
+	
+	HRESULT GetMultiMediaStream(
+		[out] IMultiMediaStream **ppMultiMediaStream);
+
+	HRESULT GetInformation(
+		[out] /*[optional]*/ MSPID *pPurposeId,
+		[out] /*[optional]*/ STREAM_TYPE *pType);
+
+	HRESULT SetSameFormat(
+		[in] IMediaStream *pStreamThatHasDesiredFormat,
+		[in] DWORD dwFlags);
+
+	HRESULT AllocateSample(
+		[in]  DWORD dwFlags,
+		[out] IStreamSample **ppSample);
+
+	HRESULT CreateSharedSample(
+		[in]  IStreamSample *pExistingSample,
+		[in]  DWORD dwFlags,
+		[out] IStreamSample **ppNewSample);
+
+	HRESULT SendEndOfStream(DWORD dwFlags);
+};
+
+
+[
+object,
+local,
+uuid(B502D1BE-9A57-11d0-8FDE-00C04FD9189D),
+pointer_default(unique)
+]
+interface IStreamSample : IUnknown {
+	
+	HRESULT GetMediaStream(
+		[in] IMediaStream **ppMediaStream);
+
+	HRESULT GetSampleTimes(
+		[out] /*[optional]*/ STREAM_TIME * pStartTime,
+		[out] /*[optional]*/ STREAM_TIME * pEndTime,
+		[out] /*[optional]*/ STREAM_TIME * pCurrentTime);
+
+	HRESULT SetSampleTimes(
+		[in] /*[optional]*/ const STREAM_TIME *pStartTime,
+		[in] /*[optional]*/ const STREAM_TIME *pEndTime);
+
+	HRESULT Update(
+		[in] DWORD dwFlags,
+		[in] /*[optional]*/ HANDLE hEvent,
+		[in] /*[optional]*/ PAPCFUNC pfnAPC,
+		[in] /*[optional]*/ DWORD dwAPCData);
+
+	HRESULT CompletionStatus(
+		[in] DWORD dwFlags,
+		[in] /*[optional]*/ DWORD dwMilliseconds);
+};

tools/wine.inf

@@ -1969,6 +1969,7 @@ HKLM,%CurrentVersion%\Telephony\Country List\998,"SameAreaRule",,"G"
 
 [RegisterDllsSection]
 11,,avifil32.dll,1
+11,,amstream.dll,1
 11,,comcat.dll,1
 11,,ddraw.dll,1
 11,,devenum.dll,1