diff loader/dshow/inputpin.c @ 3056:213b35f84cf3

C++ -> C (import from avifile cvs)

--- a/loader/dshow/inputpin.c	Wed Nov 21 18:40:59 2001 +0000
+++ b/loader/dshow/inputpin.c	Wed Nov 21 19:12:39 2001 +0000
@@ -4,98 +4,46 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-GUID CInputPin::interfaces[]=
-{
-    IID_IUnknown,
-};
-IMPLEMENT_IUNKNOWN(CInputPin)
-
-GUID CRemotePin::interfaces[]=
+static int unimplemented(const char* s, void* p)
 {
-    IID_IUnknown,
-};
-IMPLEMENT_IUNKNOWN(CRemotePin)
-
-GUID CRemotePin2::interfaces[]=
-{
-    IID_IUnknown,
-};
-IMPLEMENT_IUNKNOWN(CRemotePin2)
+    Debug printf("%s(%p) called (UNIMPLEMENTED)", s, p);
+    return E_NOTIMPL;
+}
 
-GUID CBaseFilter::interfaces[]=
-{
-    IID_IUnknown,
-    IID_IBaseFilter,
-};
-IMPLEMENT_IUNKNOWN(CBaseFilter)
+/***********
+ * EnumPins
+ ***********/
 
-GUID CBaseFilter2::interfaces[]=
+typedef struct
 {
-    IID_IUnknown,
-    IID_IBaseFilter,
-    {0x76c61a30, 0xebe1, 0x11cf, {0x89, 0xf9, 0x00, 0xa0, 0xc9, 0x03, 0x49, 0xcb}},
-    {0xaae7e4e2, 0x6388, 0x11d1, {0x8d, 0x93, 0x00, 0x60, 0x97, 0xc9, 0xa2, 0xb2}},
-    {0x02ef04dd, 0x7580, 0x11d1, {0xbe, 0xce, 0x00, 0xc0, 0x4f, 0xb6, 0xe9, 0x37}},
-};
-IMPLEMENT_IUNKNOWN(CBaseFilter2)
-
-class CEnumPins: public IEnumPins
-{
+    IEnumPins_vt* vt;
     IPin* pin1;
     IPin* pin2;
     int counter;
-    static GUID interfaces[];
-    DECLARE_IUNKNOWN(CEnumPins)
-public:
-    CEnumPins(IPin*, IPin* =0);
-    ~CEnumPins(){delete vt;}
-    static long STDCALL Next (IEnumPins * This,
-			      /* [in] */ unsigned long cMediaTypes,
-			      /* [size_is][out] */ IPin **ppMediaTypes,
-			      /* [out] */ unsigned long *pcFetched);
-    static long STDCALL Skip (IEnumPins * This,
-			      /* [in] */ unsigned long cMediaTypes);
-    static long STDCALL Reset (IEnumPins * This);
-    static long STDCALL Clone (IEnumPins * This,
-			       /* [out] */ IEnumPins **ppEnum);
-};
+    GUID interfaces[2];
+    DECLARE_IUNKNOWN();
+} CEnumPins;
 
-GUID CEnumPins::interfaces[]=
+static long STDCALL CEnumPins_Next(IEnumPins* This,
+				   /* [in] */ unsigned long cMediaTypes,
+				   /* [size_is][out] */ IPin **ppMediaTypes,
+				   /* [out] */ unsigned long *pcFetched)
 {
-    IID_IUnknown,
-    IID_IEnumPins,
-};
-IMPLEMENT_IUNKNOWN(CEnumPins)
+    CEnumPins* pin = (CEnumPins*)This;
 
-CEnumPins::CEnumPins(IPin* p, IPin* pp): pin1(p), pin2(pp), counter(0), refcount(1)
-{
-    vt=new IEnumPins_vt;
-    vt->QueryInterface = QueryInterface;
-    vt->AddRef = AddRef;
-    vt->Release = Release;
-    vt->Next = Next;
-    vt->Skip = Skip;
-    vt->Reset = Reset;
-    vt->Clone = Clone;
-}
-
-long STDCALL CEnumPins::Next(IEnumPins * This,
-			     /* [in] */ unsigned long cMediaTypes,
-			     /* [size_is][out] */ IPin **ppMediaTypes,
-			     /* [out] */ unsigned long *pcFetched)
-{
-    Debug printf("CEnumPins::Next() called\n");
+    Debug printf("CEnumPins_Next(%p) called\n", This);
     if (!ppMediaTypes)
 	return E_INVALIDARG;
     if (!pcFetched && (cMediaTypes!=1))
 	return E_INVALIDARG;
     if (cMediaTypes<=0)
 	return 0;
-    int& lcounter=((CEnumPins*)This)->counter;
 
-    IPin* lpin1=((CEnumPins*)This)->pin1;
-    IPin* lpin2=((CEnumPins*)This)->pin2;
-    if (((lcounter == 2) && lpin2) || ((lcounter == 1) && !lpin2))
+    //lcounter = ((CEnumPins*)This)->counter;
+    //lpin1 = ((CEnumPins*)This)->pin1;
+    //lpin2 = ((CEnumPins*)This)->pin2;
+    if (((pin->counter == 2) && pin->pin2)
+	|| ((pin->counter == 1) && !pin->pin2))
     {
 	if (pcFetched)
 	    *pcFetched=0;
@@ -104,105 +52,118 @@
 
     if (pcFetched)
 	*pcFetched=1;
-    if (lcounter==0)
+    if (pin->counter==0)
     {
-	*ppMediaTypes = lpin1;
-	lpin1->vt->AddRef((IUnknown*)lpin1);
+	*ppMediaTypes = pin->pin1;
+	pin->pin1->vt->AddRef((IUnknown*)pin->pin1);
     }
     else
     {
-	*ppMediaTypes = lpin2;
-	lpin2->vt->AddRef((IUnknown*)lpin2);
+	*ppMediaTypes = pin->pin2;
+	pin->pin2->vt->AddRef((IUnknown*)pin->pin2);
     }
-    lcounter++;
+    pin->counter++;
     if (cMediaTypes == 1)
 	return 0;
     return 1;
 }
 
-long STDCALL CEnumPins::Skip(IEnumPins * This,
-			     /* [in] */ unsigned long cMediaTypes)
+static long STDCALL CEnumPins_Skip(IEnumPins* This,
+				   /* [in] */ unsigned long cMediaTypes)
 {
-    Debug printf("CEnumPins::Skip() called\n");
+    Debug unimplemented("CEnumPins_Skip", This);
     return E_NOTIMPL;
 }
 
-long STDCALL CEnumPins::Reset(IEnumPins * This)
+static long STDCALL CEnumPins_Reset(IEnumPins* This)
 {
-    Debug printf("CEnumPins::Reset() called\n");
-    ((CEnumPins*)This)->counter=0;
+    Debug printf("CEnumPins_Reset(%p) called\n", This);
+    ((CEnumPins*)This)->counter = 0;
     return 0;
 }
 
-long STDCALL CEnumPins::Clone(IEnumPins * This,
-			      /* [out] */ IEnumPins **ppEnum)
+static long STDCALL CEnumPins_Clone(IEnumPins* This,
+				    /* [out] */ IEnumPins** ppEnum)
 {
-    Debug printf("CEnumPins::Clone() called\n");
+    Debug unimplemented("CEnumPins_Clone", This);
     return E_NOTIMPL;
 }
 
-CInputPin::CInputPin(CBaseFilter* p, const AM_MEDIA_TYPE& vh)
-     : type(vh)
+static void CEnumPins_Destroy(CEnumPins* This)
 {
-    refcount = 1;
-    parent = p;
-    vt=new IPin_vt;
-    vt->QueryInterface = QueryInterface;
-    vt->AddRef = AddRef;
-    vt->Release = Release;
-    vt->Connect = Connect;
-    vt->ReceiveConnection = ReceiveConnection;
-    vt->Disconnect=Disconnect;
-    vt->ConnectedTo = ConnectedTo;
-    vt->ConnectionMediaType = ConnectionMediaType;
-    vt->QueryPinInfo = QueryPinInfo;
-    vt->QueryDirection = QueryDirection;
-    vt->QueryId = QueryId;
-    vt->QueryAccept = QueryAccept;
-    vt->EnumMediaTypes = EnumMediaTypes;
-    vt->QueryInternalConnections = QueryInternalConnections;
-    vt->EndOfStream = EndOfStream;
-    vt->BeginFlush = BeginFlush;
-    vt->EndFlush = EndFlush;
-    vt->NewSegment = NewSegment;
+    free(This->vt);
+    free(This);
 }
 
-long STDCALL CInputPin::Connect (
-    IPin * This,
-    /* [in] */ IPin *pReceivePin,
-    /* [in] */ AM_MEDIA_TYPE *pmt)
+IMPLEMENT_IUNKNOWN(CEnumPins)
+
+static CEnumPins* CEnumPinsCreate(IPin* p, IPin* pp)
 {
-    Debug printf("CInputPin::Connect() called\n");
+    CEnumPins* This = (CEnumPins*) malloc(sizeof(CEnumPins));
+
+    This->pin1 = p;
+    This->pin2 = pp;
+    This->counter = 0;
+    This->refcount = 1;
+
+    This->vt = (IEnumPins_vt*) malloc(sizeof(IEnumPins_vt));
+    This->vt->QueryInterface = CEnumPins_QueryInterface;
+    This->vt->AddRef = CEnumPins_AddRef;
+    This->vt->Release = CEnumPins_Release;
+    This->vt->Next = CEnumPins_Next;
+    This->vt->Skip = CEnumPins_Skip;
+    This->vt->Reset = CEnumPins_Reset;
+    This->vt->Clone = CEnumPins_Clone;
+
+    This->interfaces[0] = IID_IUnknown;
+    This->interfaces[1] = IID_IEnumPins;
+
+    return This;
+}
+
+
+
+/***********
+ * InputPin
+ ***********/
+
+static long STDCALL CInputPin_Connect(IPin * This,
+				      /* [in] */ IPin *pReceivePin,
+				      /* [in] */ AM_MEDIA_TYPE *pmt)
+{
+    Debug unimplemented("CInputPin_Connect", This);
     return E_NOTIMPL;
 }
 
-long STDCALL CInputPin::ReceiveConnection(IPin * This,
-					  /* [in] */ IPin *pConnector,
-					  /* [in] */ const AM_MEDIA_TYPE *pmt)
+static long STDCALL CInputPin_ReceiveConnection(IPin* This,
+						/* [in] */ IPin* pConnector,
+						/* [in] */ const AM_MEDIA_TYPE *pmt)
 {
-    Debug printf("CInputPin::ReceiveConnection() called\n");
+    Debug unimplemented("CInputPin_ReceiveConnection", This);
     return E_NOTIMPL;
 }
 
-long STDCALL CInputPin::Disconnect(IPin * This)
+static long STDCALL CInputPin_Disconnect(IPin* This)
 {
-    Debug printf("CInputPin::Disconnect() called\n");
+    Debug unimplemented("CInputPin_Disconnect", This);
     return E_NOTIMPL;
 }
 
-long STDCALL CInputPin::ConnectedTo(IPin * This, /* [out] */ IPin **pPin)
+static long STDCALL CInputPin_ConnectedTo(IPin* This,
+					  /* [out] */ IPin** pPin)
 {
-    Debug printf("CInputPin::ConnectedTo() called\n");
+    Debug unimplemented("CInputPin_ConnectedTo", This);
     return E_NOTIMPL;
 }
 
-long STDCALL CInputPin::ConnectionMediaType(IPin * This,
-					    /* [out] */ AM_MEDIA_TYPE *pmt)
+static long STDCALL CInputPin_ConnectionMediaType(IPin* This,
+						  /* [out] */ AM_MEDIA_TYPE *pmt)
 {
-    Debug printf("CInputPin::ConnectionMediaType() called\n");
-    if(!pmt)return E_INVALIDARG;
+    Debug printf("CInputPin_ConnectionMediaType(%p) called\n", This);
+    if (!pmt)
+	return E_INVALIDARG;
     *pmt=((CInputPin*)This)->type;
-    if(pmt->cbFormat>0)
+    if (pmt->cbFormat > 0)
     {
 	pmt->pbFormat=(char *)CoTaskMemAlloc(pmt->cbFormat);
 	memcpy(pmt->pbFormat, ((CInputPin*)This)->type.pbFormat, pmt->cbFormat);
@@ -210,352 +171,445 @@
     return 0;
 }
 
-long STDCALL CInputPin::QueryPinInfo(IPin * This, /* [out] */ PIN_INFO *pInfo)
+static long STDCALL CInputPin_QueryPinInfo(IPin* This,
+					   /* [out] */ PIN_INFO *pInfo)
 {
-    Debug printf("CInputPin::QueryPinInfo() called\n");
-    pInfo->dir=PINDIR_OUTPUT;
     CBaseFilter* lparent=((CInputPin*)This)->parent;
-    pInfo->pFilter = lparent;
+    Debug printf("CInputPin_QueryPinInfo(%p) called\n", This);
+    pInfo->dir = PINDIR_OUTPUT;
+    pInfo->pFilter = (IBaseFilter*) lparent;
     lparent->vt->AddRef((IUnknown*)lparent);
-    pInfo->achName[0]=0;
+    pInfo->achName[0] = 0;
+    return 0;
+}
+
+static long STDCALL CInputPin_QueryDirection(IPin* This,
+					      /* [out] */ PIN_DIRECTION *pPinDir)
+{
+    *pPinDir = PINDIR_OUTPUT;
+    Debug printf("CInputPin_QueryDirection(%p) called\n", This);
     return 0;
 }
 
-long STDCALL CInputPin::QueryDirection(IPin * This,
-				       /* [out] */ PIN_DIRECTION *pPinDir)
+static long STDCALL CInputPin_QueryId(IPin* This,
+				       /* [out] */ unsigned short* *Id)
 {
-    *pPinDir=PINDIR_OUTPUT;
-    Debug printf("CInputPin::QueryDirection() called\n");
-    return 0;
+    Debug unimplemented("CInputPin_QueryId", This);
+    return E_NOTIMPL;
 }
 
-long STDCALL CInputPin::QueryId(IPin * This, /* [out] */ unsigned short* *Id)
+static long STDCALL CInputPin_QueryAccept(IPin* This,
+					  /* [in] */ const AM_MEDIA_TYPE *pmt)
 {
-    Debug printf("CInputPin::QueryId() called\n");
+    Debug unimplemented("CInputPin_QueryAccept", This);
     return E_NOTIMPL;
 }
 
-long STDCALL CInputPin::QueryAccept(IPin * This,
-				    /* [in] */ const AM_MEDIA_TYPE *pmt)
+static long STDCALL CInputPin_EnumMediaTypes(IPin* This,
+					     /* [out] */ IEnumMediaTypes **ppEnum)
 {
-    Debug printf("CInputPin::QueryAccept() called\n");
+    Debug unimplemented("CInputPin_EnumMediaTypes", This);
+    return E_NOTIMPL;
+}
+
+static long STDCALL CInputPin_QueryInternalConnections(IPin* This,
+						       /* [out] */ IPin **apPin,
+						       /* [out][in] */ unsigned long *nPin)
+{
+    Debug unimplemented("CInputPin_QueryInternalConnections", This);
+    return E_NOTIMPL;
+}
+
+static long STDCALL CInputPin_EndOfStream(IPin * This)
+{
+    Debug unimplemented("CInputPin_EndOfStream", This);
     return E_NOTIMPL;
 }
 
 
-long STDCALL CInputPin::EnumMediaTypes (
-    IPin * This,
-    /* [out] */ IEnumMediaTypes **ppEnum)
-{
-    Debug printf("CInputPin::EnumMediaTypes() called\n");
-    return E_NOTIMPL;
-}
-
-
-long STDCALL CInputPin::QueryInternalConnections(IPin * This,
-						 /* [out] */ IPin **apPin,
-						 /* [out][in] */ unsigned long *nPin)
+static long STDCALL CInputPin_BeginFlush(IPin * This)
 {
-    Debug printf("CInputPin::QueryInternalConnections() called\n");
-    return E_NOTIMPL;
-}
-
-long STDCALL CInputPin::EndOfStream (IPin * This)
-{
-    Debug printf("CInputPin::EndOfStream() called\n");
-    return E_NOTIMPL;
-}
-
-
-long STDCALL CInputPin::BeginFlush(IPin * This)
-{
-    Debug printf("CInputPin::BeginFlush() called\n");
+    Debug unimplemented("CInputPin_BeginFlush", This);
     return E_NOTIMPL;
 }
 
 
-long STDCALL CInputPin::EndFlush(IPin * This)
+static long STDCALL CInputPin_EndFlush(IPin * This)
 {
-    Debug printf("CInputPin::EndFlush() called\n");
-    return E_NOTIMPL;
-}
-
-long STDCALL CInputPin::NewSegment(IPin * This,
-				   /* [in] */ REFERENCE_TIME tStart,
-				   /* [in] */ REFERENCE_TIME tStop,
-				   /* [in] */ double dRate)
-{
-    Debug printf("CInputPin::NewSegment() called\n");
+    Debug unimplemented("CInputPin_EndFlush", This);
     return E_NOTIMPL;
 }
 
-CBaseFilter::CBaseFilter(const AM_MEDIA_TYPE& type, CBaseFilter2* parent)
+static long STDCALL CInputPin_NewSegment(IPin * This,
+					  /* [in] */ REFERENCE_TIME tStart,
+					  /* [in] */ REFERENCE_TIME tStop,
+					  /* [in] */ double dRate)
 {
-    refcount = 1;
-    pin=new CInputPin(this, type);
-    unused_pin=new CRemotePin(this, parent->GetPin());
-    vt=new IBaseFilter_vt;
-    vt->QueryInterface = QueryInterface;
-    vt->AddRef = AddRef;
-    vt->Release = Release;
-    vt->GetClassID = GetClassID;
-    vt->Stop = Stop;
-    vt->Pause = Pause;
-    vt->Run = Run;
-    vt->GetState = GetState;
-    vt->SetSyncSource = SetSyncSource;
-    vt->GetSyncSource = GetSyncSource;
-    vt->EnumPins = EnumPins;
-    vt->FindPin = FindPin;
-    vt->QueryFilterInfo = QueryFilterInfo;
-    vt->JoinFilterGraph = JoinFilterGraph;
-    vt->QueryVendorInfo = QueryVendorInfo;
-}
-
-long STDCALL CBaseFilter::GetClassID(IBaseFilter * This,
-				      /* [out] */ CLSID *pClassID)
-{
-    Debug printf("CBaseFilter::GetClassID() called\n");
-    return E_NOTIMPL;
-}
-
-long STDCALL CBaseFilter::Stop(IBaseFilter * This)
-{
-    Debug printf("CBaseFilter::Stop() called\n");
+    Debug unimplemented("CInputPin_NewSegment", This);
     return E_NOTIMPL;
 }
 
-long STDCALL CBaseFilter::Pause(IBaseFilter * This)
+static void CInputPin_Destroy(CInputPin* This)
 {
-    Debug printf("CBaseFilter::Pause() called\n");
-    return E_NOTIMPL;
+    free(This->vt);
+    free(This);
 }
 
-long STDCALL CBaseFilter::Run(IBaseFilter * This,
-			      REFERENCE_TIME tStart)
+IMPLEMENT_IUNKNOWN(CInputPin)
+
+CInputPin* CInputPinCreate(CBaseFilter* p, const AM_MEDIA_TYPE* amt)
 {
-    Debug printf("CBaseFilter::Run() called\n");
-    return E_NOTIMPL;
+    CInputPin* This = (CInputPin*) malloc(sizeof(CInputPin));
+
+    This->parent = p;
+    This->refcount = 1;
+    This->type = *amt;
+
+    This->vt= (IPin_vt*) malloc(sizeof(IPin_vt));
+    This->vt->QueryInterface = CInputPin_QueryInterface;
+    This->vt->AddRef = CInputPin_AddRef;
+    This->vt->Release = CInputPin_Release;
+    This->vt->Connect = CInputPin_Connect;
+    This->vt->ReceiveConnection = CInputPin_ReceiveConnection;
+    This->vt->Disconnect = CInputPin_Disconnect;
+    This->vt->ConnectedTo = CInputPin_ConnectedTo;
+    This->vt->ConnectionMediaType = CInputPin_ConnectionMediaType;
+    This->vt->QueryPinInfo = CInputPin_QueryPinInfo;
+    This->vt->QueryDirection = CInputPin_QueryDirection;
+    This->vt->QueryId = CInputPin_QueryId;
+    This->vt->QueryAccept = CInputPin_QueryAccept;
+    This->vt->EnumMediaTypes = CInputPin_EnumMediaTypes;
+    This->vt->QueryInternalConnections = CInputPin_QueryInternalConnections;
+    This->vt->EndOfStream = CInputPin_EndOfStream;
+    This->vt->BeginFlush = CInputPin_BeginFlush;
+    This->vt->EndFlush = CInputPin_EndFlush;
+    This->vt->NewSegment = CInputPin_NewSegment;
+
+    This->interfaces[0]=IID_IUnknown;
+
+    return This;
 }
 
-long STDCALL CBaseFilter::GetState(IBaseFilter * This,
-				   /* [in] */ unsigned long dwMilliSecsTimeout,
-				   // /* [out] */ FILTER_STATE *State)
-				   void* State)
+
+/*************
+ * BaseFilter
+ *************/
+
+static long STDCALL CBaseFilter_GetClassID(IBaseFilter * This,
+					   /* [out] */ CLSID *pClassID)
 {
-    Debug printf("CBaseFilter::GetState() called\n");
+    Debug unimplemented("CBaseFilter_GetClassID", This);
     return E_NOTIMPL;
 }
 
-long STDCALL CBaseFilter::SetSyncSource(IBaseFilter * This,
-					/* [in] */ IReferenceClock *pClock)
+static long STDCALL CBaseFilter_Stop(IBaseFilter* This)
 {
-    Debug printf("CBaseFilter::SetSyncSource() called\n");
+    Debug unimplemented("CBaseFilter_Stop", This);
     return E_NOTIMPL;
 }
 
-long STDCALL CBaseFilter::GetSyncSource (
-        IBaseFilter * This,
-        /* [out] */ IReferenceClock **pClock)
+static long STDCALL CBaseFilter_Pause(IBaseFilter* This)
 {
-    Debug printf("CBaseFilter::GetSyncSource() called\n");
+    Debug unimplemented("CBaseFilter_Pause", This);
+    return E_NOTIMPL;
+}
+
+static long STDCALL CBaseFilter_Run(IBaseFilter* This, REFERENCE_TIME tStart)
+{
+    Debug unimplemented("CBaseFilter_Run", This);
     return E_NOTIMPL;
 }
 
-
-long STDCALL CBaseFilter::EnumPins (
-        IBaseFilter * This,
-        /* [out] */ IEnumPins **ppEnum)
+static long STDCALL CBaseFilter_GetState(IBaseFilter* This,
+					 /* [in] */ unsigned long dwMilliSecsTimeout,
+					 // /* [out] */ FILTER_STATE *State)
+					 void* State)
 {
-    Debug printf("CBaseFilter::EnumPins() called\n");
-    *ppEnum=new CEnumPins(((CBaseFilter*)This)->pin, ((CBaseFilter*)This)->unused_pin);
-    return 0;
+    Debug unimplemented("CBaseFilter_GetState", This);
+    return E_NOTIMPL;
 }
 
+static long STDCALL CBaseFilter_SetSyncSource(IBaseFilter* This,
+					      /* [in] */ IReferenceClock *pClock)
+{
+    Debug unimplemented("CBaseFilter_SetSyncSource", This);
+    return E_NOTIMPL;
+}
 
-long STDCALL CBaseFilter::FindPin (
-        IBaseFilter * This,
-        /* [string][in] */ const unsigned short* Id,
-        /* [out] */ IPin **ppPin)
+static long STDCALL CBaseFilter_GetSyncSource(IBaseFilter* This,
+					      /* [out] */ IReferenceClock **pClock)
 {
-    Debug printf("CBaseFilter::FindPin() called\n");
+    Debug unimplemented("CBaseFilter_GetSyncSource", This);
     return E_NOTIMPL;
 }
 
 
-long STDCALL CBaseFilter::QueryFilterInfo (
-        IBaseFilter * This,
-//        /* [out] */ FILTER_INFO *pInfo)
-	void* pInfo)
+static long STDCALL CBaseFilter_EnumPins(IBaseFilter* This,
+					 /* [out] */ IEnumPins **ppEnum)
+{
+    Debug printf("CBaseFilter_EnumPins(%p) called\n", This);
+    *ppEnum = (IEnumPins*) CEnumPinsCreate(((CBaseFilter*)This)->pin, ((CBaseFilter*)This)->unused_pin);
+    return 0;
+}
+
+static long STDCALL CBaseFilter_FindPin(IBaseFilter* This,
+					/* [string][in] */ const unsigned short* Id,
+					/* [out] */ IPin **ppPin)
 {
-    Debug printf("CBaseFilter::QueryFilterInfo() called\n");
+    Debug unimplemented("CBaseFilter_FindPin\n", This);
+    return E_NOTIMPL;
+}
+
+static long STDCALL CBaseFilter_QueryFilterInfo(IBaseFilter * This,
+						// /* [out] */ FILTER_INFO *pInfo)
+						void* pInfo)
+{
+    Debug unimplemented("CBaseFilter_QueryFilterInfo", This);
+    return E_NOTIMPL;
+}
+
+static long STDCALL CBaseFilter_JoinFilterGraph(IBaseFilter * This,
+						/* [in] */ IFilterGraph *pGraph,
+						/* [string][in] */ const unsigned short* pName)
+{
+    Debug unimplemented("CBaseFilter_JoinFilterGraph", This);
+    return E_NOTIMPL;
+}
+
+static long STDCALL CBaseFilter_QueryVendorInfo(IBaseFilter * This,
+						/* [string][out] */ unsigned short* *pVendorInfo)
+{
+    Debug unimplemented("CBaseFilter_QueryVendorInfo", This);
     return E_NOTIMPL;
 }
 
+static IPin* CBaseFilter_GetPin(CBaseFilter* This)
+{
+    return This->pin;
+}
 
-long STDCALL CBaseFilter::JoinFilterGraph (
-        IBaseFilter * This,
-        /* [in] */ IFilterGraph *pGraph,
-        /* [string][in] */ const unsigned short* pName)
+static IPin* CBaseFilter_GetUnusedPin(CBaseFilter* This)
 {
-    Debug printf("CBaseFilter::JoinFilterGraph() called\n");
-    return E_NOTIMPL;
+    return This->unused_pin;
+}
+
+static void CBaseFilter_Destroy(CBaseFilter* This)
+{
+    free(This->vt);
+    This->pin->vt->Release((IUnknown*)This->pin);
+    This->unused_pin->vt->Release((IUnknown*)This->unused_pin);
+    free(This);
 }
 
+IMPLEMENT_IUNKNOWN(CBaseFilter)
 
-long STDCALL CBaseFilter::QueryVendorInfo (
-        IBaseFilter * This,
-        /* [string][out] */ unsigned short* *pVendorInfo)
+CBaseFilter* CBaseFilterCreate(const AM_MEDIA_TYPE* type, CBaseFilter2* parent)
 {
-    Debug printf("CBaseFilter::QueryVendorInfo() called\n");
-    return E_NOTIMPL;
+    CBaseFilter* This = (CBaseFilter*) malloc(sizeof(CBaseFilter));
+    This->refcount = 1;
+
+    This->pin = (IPin*) CInputPinCreate(This, type);
+    This->unused_pin = (IPin*) CRemotePinCreate(This, parent->GetPin(parent));
+
+    This->vt = (IBaseFilter_vt*) malloc(sizeof(IBaseFilter_vt));
+    This->vt->QueryInterface = CBaseFilter_QueryInterface;
+    This->vt->AddRef = CBaseFilter_AddRef;
+    This->vt->Release = CBaseFilter_Release;
+    This->vt->GetClassID = CBaseFilter_GetClassID;
+    This->vt->Stop = CBaseFilter_Stop;
+    This->vt->Pause = CBaseFilter_Pause;
+    This->vt->Run = CBaseFilter_Run;
+    This->vt->GetState = CBaseFilter_GetState;
+    This->vt->SetSyncSource = CBaseFilter_SetSyncSource;
+    This->vt->GetSyncSource = CBaseFilter_GetSyncSource;
+    This->vt->EnumPins = CBaseFilter_EnumPins;
+    This->vt->FindPin = CBaseFilter_FindPin;
+    This->vt->QueryFilterInfo = CBaseFilter_QueryFilterInfo;
+    This->vt->JoinFilterGraph = CBaseFilter_JoinFilterGraph;
+    This->vt->QueryVendorInfo = CBaseFilter_QueryVendorInfo;
+
+    This->interfaces[0] = IID_IUnknown;
+    This->interfaces[1] = IID_IBaseFilter;
+
+    This->GetPin = CBaseFilter_GetPin;
+    This->GetUnusedPin = CBaseFilter_GetUnusedPin;
+
+    return This;
 }
 
 
-CBaseFilter2::CBaseFilter2() : refcount(1)
-{
-    pin=new CRemotePin2(this);
-    vt=new IBaseFilter_vt;
-    memset(vt, 0, sizeof (IBaseFilter_vt));
-    vt->QueryInterface = QueryInterface;
-    vt->AddRef = AddRef;
-    vt->Release = Release;
-    vt->GetClassID = GetClassID;
-    vt->Stop = Stop;
-    vt->Pause = Pause;
-    vt->Run = Run;
-    vt->GetState = GetState;
-    vt->SetSyncSource = SetSyncSource;
-    vt->GetSyncSource = GetSyncSource;
-    vt->EnumPins = EnumPins;
-    vt->FindPin = FindPin;
-    vt->QueryFilterInfo = QueryFilterInfo;
-    vt->JoinFilterGraph = JoinFilterGraph;
-    vt->QueryVendorInfo = QueryVendorInfo;
-}
+/**************
+ * BaseFilter2
+ **************/
 
 
-
-
-long STDCALL CBaseFilter2::GetClassID (
-        IBaseFilter * This,
-        /* [out] */ CLSID *pClassID)
+static long STDCALL CBaseFilter2_GetClassID(IBaseFilter * This,
+					     /* [out] */ CLSID *pClassID)
 {
-    Debug printf("CBaseFilter2::GetClassID() called\n");
+    Debug unimplemented("CBaseFilter2_GetClassID", This);
     return E_NOTIMPL;
 }
 
-long STDCALL CBaseFilter2::Stop (
-        IBaseFilter * This)
+static long STDCALL CBaseFilter2_Stop(IBaseFilter * This)
 {
-    Debug printf("CBaseFilter2::Stop() called\n");
+    Debug unimplemented("CBaseFilter2_Stop", This);
     return E_NOTIMPL;
 }
 
-
-long STDCALL CBaseFilter2::Pause (IBaseFilter * This)
+static long STDCALL CBaseFilter2_Pause(IBaseFilter * This)
 {
-    Debug printf("CBaseFilter2::Pause() called\n");
+    Debug unimplemented("CBaseFilter2_Pause", This);
     return E_NOTIMPL;
 }
 
-long STDCALL CBaseFilter2::Run (IBaseFilter * This, REFERENCE_TIME tStart)
+static long STDCALL CBaseFilter2_Run(IBaseFilter * This, REFERENCE_TIME tStart)
 {
-    Debug printf("CBaseFilter2::Run() called\n");
+    Debug unimplemented("CBaseFilter2_Run", This);
     return E_NOTIMPL;
 }
 
 
-long STDCALL CBaseFilter2::GetState (
-        IBaseFilter * This,
-        /* [in] */ unsigned long dwMilliSecsTimeout,
-//        /* [out] */ FILTER_STATE *State)
-    	void* State)
+static long STDCALL CBaseFilter2_GetState(IBaseFilter* This,
+					  /* [in] */ unsigned long dwMilliSecsTimeout,
+					  // /* [out] */ FILTER_STATE *State)
+					  void* State)
+{
+    Debug unimplemented("CBaseFilter2_GetState", This);
+    return E_NOTIMPL;
+}
+
+static long STDCALL CBaseFilter2_SetSyncSource(IBaseFilter* This,
+					       /* [in] */ IReferenceClock* pClock)
+{
+    Debug unimplemented("CBaseFilter2_SetSyncSource", This);
+    return E_NOTIMPL;
+}
+
+static long STDCALL CBaseFilter2_GetSyncSource(IBaseFilter* This,
+					       /* [out] */ IReferenceClock** pClock)
+{
+    Debug unimplemented("CBaseFilter2_GetSyncSource", This);
+    return E_NOTIMPL;
+}
+
+static long STDCALL CBaseFilter2_EnumPins(IBaseFilter* This,
+					  /* [out] */ IEnumPins** ppEnum)
 {
-    Debug printf("CBaseFilter2::GetState() called\n");
+    Debug printf("CBaseFilter2_EnumPins(%p) called\n", This);
+    *ppEnum = (IEnumPins*) CEnumPinsCreate(((CBaseFilter2*)This)->pin, 0);
+    return 0;
+}
+
+static long STDCALL CBaseFilter2_FindPin(IBaseFilter* This,
+					 /* [string][in] */ const unsigned short* Id,
+					 /* [out] */ IPin** ppPin)
+{
+    Debug unimplemented("CBaseFilter2_FindPin", This);
+    return E_NOTIMPL;
+}
+
+static long STDCALL CBaseFilter2_QueryFilterInfo(IBaseFilter* This,
+						 // /* [out] */ FILTER_INFO *pInfo)
+						 void* pInfo)
+{
+    Debug unimplemented("CBaseFilter2_QueryFilterInfo", This);
+    return E_NOTIMPL;
+}
+
+static long STDCALL CBaseFilter2_JoinFilterGraph(IBaseFilter* This,
+						 /* [in] */ IFilterGraph* pGraph,
+						 /* [string][in] */
+						  const unsigned short* pName)
+{
+    Debug unimplemented("CBaseFilter2_JoinFilterGraph", This);
     return E_NOTIMPL;
 }
 
-
-long STDCALL CBaseFilter2::SetSyncSource (
-        IBaseFilter * This,
-        /* [in] */ IReferenceClock *pClock)
+static long STDCALL CBaseFilter2_QueryVendorInfo(IBaseFilter* This,
+						 /* [string][out] */
+						 unsigned short** pVendorInfo)
 {
-    Debug printf("CBaseFilter2::SetSyncSource() called\n");
+    Debug unimplemented("CBaseFilter2_QueryVendorInfo", This);
     return E_NOTIMPL;
 }
 
+static IPin* CBaseFilter2_GetPin(CBaseFilter2* This)
+{
+    return This->pin;
+}
 
-long STDCALL CBaseFilter2::GetSyncSource (
-        IBaseFilter * This,
-        /* [out] */ IReferenceClock **pClock)
+static void CBaseFilter2_Destroy(CBaseFilter2* This)
 {
-    Debug printf("CBaseFilter2::GetSyncSource() called\n");
-    return E_NOTIMPL;
+    This->pin->vt->Release((IUnknown*) This->pin);
+    free(This->vt);
+    free(This);
 }
 
+IMPLEMENT_IUNKNOWN(CBaseFilter2)
 
-long STDCALL CBaseFilter2::EnumPins (
-        IBaseFilter * This,
-        /* [out] */ IEnumPins **ppEnum)
+static GUID CBaseFilter2_interf1 =
+{0x76c61a30, 0xebe1, 0x11cf, {0x89, 0xf9, 0x00, 0xa0, 0xc9, 0x03, 0x49, 0xcb}};
+static GUID CBaseFilter2_interf2 =
+{0xaae7e4e2, 0x6388, 0x11d1, {0x8d, 0x93, 0x00, 0x60, 0x97, 0xc9, 0xa2, 0xb2}};
+static GUID CBaseFilter2_interf3 =
+{0x02ef04dd, 0x7580, 0x11d1, {0xbe, 0xce, 0x00, 0xc0, 0x4f, 0xb6, 0xe9, 0x37}};
+
+CBaseFilter2* CBaseFilter2Create()
 {
-    Debug printf("CBaseFilter2::EnumPins() called\n");
-    *ppEnum=new CEnumPins(((CBaseFilter2*)This)->pin);
-    return 0;
+    CBaseFilter2* This = (CBaseFilter2*) malloc(sizeof(CBaseFilter2));
+
+    This->refcount = 1;
+    This->pin = (IPin*) CRemotePin2Create(This);
+
+    This->vt = (IBaseFilter_vt*) malloc(sizeof(IBaseFilter_vt));
+    memset(This->vt, 0, sizeof(IBaseFilter_vt));
+    This->vt->QueryInterface = CBaseFilter2_QueryInterface;
+    This->vt->AddRef = CBaseFilter2_AddRef;
+    This->vt->Release = CBaseFilter2_Release;
+    This->vt->GetClassID = CBaseFilter2_GetClassID;
+    This->vt->Stop = CBaseFilter2_Stop;
+    This->vt->Pause = CBaseFilter2_Pause;
+    This->vt->Run = CBaseFilter2_Run;
+    This->vt->GetState = CBaseFilter2_GetState;
+    This->vt->SetSyncSource = CBaseFilter2_SetSyncSource;
+    This->vt->GetSyncSource = CBaseFilter2_GetSyncSource;
+    This->vt->EnumPins = CBaseFilter2_EnumPins;
+    This->vt->FindPin = CBaseFilter2_FindPin;
+    This->vt->QueryFilterInfo = CBaseFilter2_QueryFilterInfo;
+    This->vt->JoinFilterGraph = CBaseFilter2_JoinFilterGraph;
+    This->vt->QueryVendorInfo = CBaseFilter2_QueryVendorInfo;
+
+    This->GetPin = CBaseFilter2_GetPin;
+
+    This->interfaces[0] = IID_IUnknown;
+    This->interfaces[1] = IID_IBaseFilter;
+    This->interfaces[2] = CBaseFilter2_interf1;
+    This->interfaces[3] = CBaseFilter2_interf2;
+    This->interfaces[4] = CBaseFilter2_interf3;
+
+    return This;
 }
 
 
-long STDCALL CBaseFilter2::FindPin (
-        IBaseFilter * This,
-        /* [string][in] */ const unsigned short* Id,
-        /* [out] */ IPin **ppPin)
-{
-    Debug printf("CBaseFilter2::FindPin() called\n");
-    return E_NOTIMPL;
-}
-
-
-long STDCALL CBaseFilter2::QueryFilterInfo (
-        IBaseFilter * This,
-//        /* [out] */ FILTER_INFO *pInfo)
-	void* pInfo)
-{
-    Debug printf("CBaseFilter2::QueryFilterInfo() called\n");
-    return E_NOTIMPL;
-}
+/*************
+ * CRemotePin
+ *************/
 
 
-long STDCALL CBaseFilter2::JoinFilterGraph(IBaseFilter * This,
-					   /* [in] */ IFilterGraph *pGraph,
-					   /* [string][in] */
-					   const unsigned short* pName)
+static long STDCALL CRemotePin_ConnectedTo(IPin* This, /* [out] */ IPin** pPin)
 {
-    Debug printf("CBaseFilter2::JoinFilterGraph() called\n");
-    return E_NOTIMPL;
-}
-
-long STDCALL CBaseFilter2::QueryVendorInfo(IBaseFilter * This,
-					   /* [string][out] */
-					   unsigned short* *pVendorInfo)
-{
-    Debug printf("CBaseFilter2::QueryVendorInfo() called\n");
-    return E_NOTIMPL;
-}
-
-static long STDCALL CRemotePin_ConnectedTo(IPin * This, /* [out] */ IPin **pPin)
-{
-    Debug printf("CRemotePin::ConnectedTo called\n");
+    Debug printf("CRemotePin_ConnectedTo(%p) called\n", This);
     if (!pPin)
 	return E_INVALIDARG;
-    *pPin=((CRemotePin*)This)->remote_pin;
+    *pPin = ((CRemotePin*)This)->remote_pin;
     (*pPin)->vt->AddRef((IUnknown*)(*pPin));
     return 0;
 }
 
-static long STDCALL CRemotePin_QueryDirection(IPin * This,
+static long STDCALL CRemotePin_QueryDirection(IPin* This,
 					      /* [out] */ PIN_DIRECTION *pPinDir)
 {
-    Debug printf("CRemotePin::QueryDirection called\n");
+    Debug printf("CRemotePin_QueryDirection(%p) called\n", This);
     if (!pPinDir)
 	return E_INVALIDARG;
     *pPinDir=PINDIR_INPUT;
@@ -564,27 +618,65 @@
 
 static long STDCALL CRemotePin_ConnectionMediaType(IPin* This, /* [out] */ AM_MEDIA_TYPE* pmt)
 {
-    Debug printf("CRemotePin::ConnectionMediaType() called\n");
+    Debug unimplemented("CRemotePin_ConnectionMediaType", This);
     return E_NOTIMPL;
 }
 
 static long STDCALL CRemotePin_QueryPinInfo(IPin* This, /* [out] */ PIN_INFO* pInfo)
 {
-    Debug printf("CRemotePin::QueryPinInfo() called\n");
-    pInfo->dir=PINDIR_INPUT;
     CBaseFilter* lparent = ((CRemotePin*)This)->parent;
-    pInfo->pFilter = lparent;
+    Debug printf("CRemotePin_QueryPinInfo(%p) called\n", This);
+    pInfo->dir= PINDIR_INPUT;
+    pInfo->pFilter = (IBaseFilter*) lparent;
     lparent->vt->AddRef((IUnknown*)lparent);
     pInfo->achName[0]=0;
     return 0;
 }
 
+static void CRemotePin_Destroy(CRemotePin* This)
+{
+    Debug printf("CRemotePin_Destroy(%p) called\n", This);
+    free(This->vt);
+    free(This);
+}
+
+IMPLEMENT_IUNKNOWN(CRemotePin)
+
+CRemotePin* CRemotePinCreate(CBaseFilter* pt, IPin* rpin)
+{
+    CRemotePin* This = (CRemotePin*) malloc(sizeof(CRemotePin));
+    Debug printf("CRemotePinCreate() called -> %p\n", This);
+
+    This->parent = pt;
+    This->remote_pin = rpin;
+    This->refcount = 1;
+
+    This->vt = (IPin_vt*) malloc(sizeof(IPin_vt));
+    memset(This->vt, 0, sizeof(IPin_vt));
+    This->vt->QueryInterface = CRemotePin_QueryInterface;
+    This->vt->AddRef = CRemotePin_AddRef;
+    This->vt->Release = CRemotePin_Release;
+    This->vt->QueryDirection = CRemotePin_QueryDirection;
+    This->vt->ConnectedTo = CRemotePin_ConnectedTo;
+    This->vt->ConnectionMediaType = CRemotePin_ConnectionMediaType;
+    This->vt->QueryPinInfo = CRemotePin_QueryPinInfo;
+
+    This->interfaces[0] = IID_IUnknown;
+
+    return This;
+}
+
+
+/*************
+ * CRemotePin
+ *************/
+
 
 static long STDCALL CRemotePin2_QueryPinInfo(IPin * This,
 				       /* [out] */ PIN_INFO *pInfo)
 {
-    Debug printf("CRemotePin2::QueryPinInfo called\n");
     CBaseFilter2* lparent=((CRemotePin2*)This)->parent;
+    Debug printf("CRemotePin2_QueryPinInfo(%p) called\n", This);
     pInfo->pFilter=(IBaseFilter*)lparent;
     lparent->vt->AddRef((IUnknown*)lparent);
     pInfo->dir=PINDIR_OUTPUT;
@@ -592,27 +684,31 @@
     return 0;
 }
 
-CRemotePin::CRemotePin(CBaseFilter* pt, IPin* rpin): parent(pt), remote_pin(rpin),
-    refcount(1)
+static void CRemotePin2_Destroy(CRemotePin2* This)
 {
-    vt = new IPin_vt;
-    memset(vt, 0, sizeof(IPin_vt));
-    vt->QueryInterface = QueryInterface;
-    vt->AddRef = AddRef;
-    vt->Release = Release;
-    vt->QueryDirection = CRemotePin_QueryDirection;
-    vt->ConnectedTo = CRemotePin_ConnectedTo;
-    vt->ConnectionMediaType = CRemotePin_ConnectionMediaType;
-    vt->QueryPinInfo = CRemotePin_QueryPinInfo;
+    Debug printf("CRemotePin2_Destroy(%p) called\n", This);
+    free(This->vt);
+    free(This);
 }
 
-CRemotePin2::CRemotePin2(CBaseFilter2* p):parent(p),
-    refcount(1)
+IMPLEMENT_IUNKNOWN(CRemotePin2)
+
+CRemotePin2* CRemotePin2Create(CBaseFilter2* p)
 {
-    vt = new IPin_vt;
-    memset(vt, 0, sizeof(IPin_vt));
-    vt->QueryInterface = QueryInterface;
-    vt->AddRef = AddRef;
-    vt->Release = Release;
-    vt->QueryPinInfo = CRemotePin2_QueryPinInfo;
+    CRemotePin2* This = (CRemotePin2*) malloc(sizeof(CRemotePin2));
+    Debug printf("CRemotePin2Create() called -> %p\n", This);
+
+    This->parent = p;
+    This->refcount = 1;
+
+    This->vt = (IPin_vt*) malloc(sizeof(IPin_vt));
+    memset(This->vt, 0, sizeof(IPin_vt));
+    This->vt->QueryInterface = CRemotePin2_QueryInterface;
+    This->vt->AddRef = CRemotePin2_AddRef;
+    This->vt->Release = CRemotePin2_Release;
+    This->vt->QueryPinInfo = CRemotePin2_QueryPinInfo;
+
+    This->interfaces[0] = IID_IUnknown;
+
+    return This;
 }