[KSPROXY]
[reactos.git] / reactos / dll / directx / ksproxy / input_pin.cpp
index 2b08b16..a530b8d 100644 (file)
@@ -1,14 +1,19 @@
 /*
  * COPYRIGHT:       See COPYING in the top level directory
  * PROJECT:         ReactOS WDM Streaming ActiveMovie Proxy
- * FILE:            dll/directx/ksproxy/input_cpp.cpp
+ * FILE:            dll/directx/ksproxy/input_pin.cpp
  * PURPOSE:         InputPin of Proxy Filter
  *
  * PROGRAMMERS:     Johannes Anderwald (janderwald@reactos.org)
  */
 #include "precomp.h"
 
-const GUID IID_IKsPinEx = {0x7bb38260L, 0xd19c, 0x11d2, {0xb3, 0x8a, 0x00, 0xa0, 0xc9, 0x5e, 0xc2, 0x2e}};
+const GUID IID_IKsPinPipe = {0xe539cd90, 0xa8b4, 0x11d1, {0x81, 0x89, 0x00, 0xa0, 0xc9, 0x06, 0x28, 0x02}};
+const GUID IID_IKsPinEx   = {0x7bb38260L, 0xd19c, 0x11d2, {0xb3, 0x8a, 0x00, 0xa0, 0xc9, 0x5e, 0xc2, 0x2e}};
+
+
+#ifndef _MSC_VER
+
 const GUID KSPROPSETID_Connection = {0x1D58C920L, 0xAC9B, 0x11CF, {0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00}};
 
 KSPIN_INTERFACE StandardPinInterface = 
@@ -25,21 +30,36 @@ KSPIN_MEDIUM StandardPinMedium =
     0
 };
 
+#else
+
+KSPIN_INTERFACE StandardPinInterface = 
+{
+    STATIC_KSINTERFACESETID_Standard,
+    KSINTERFACE_STANDARD_STREAMING,
+    0
+};
+
+KSPIN_MEDIUM StandardPinMedium =
+{
+    STATIC_KSMEDIUMSETID_Standard,
+    KSMEDIUM_TYPE_ANYINSTANCE,
+    0
+};
+
+#endif
 
 class CInputPin : public IPin,
                   public IKsPropertySet,
                   public IKsControl,
                   public IKsObject,
                   public IKsPinEx,
-                  public IMemInputPin
-/*
-                  public IQualityControl,
+                  public IMemInputPin,
                   public IKsPinPipe,
-                  public ISpecifyPropertyPages,
-                  public IStreamBuilder,
                   public IKsPinFactory,
-                  public IKsAggregateControl
-*/
+                  public IStreamBuilder,
+                  public IKsAggregateControl,
+                  public IQualityControl,
+                  public ISpecifyPropertyPages
 {
 public:
     STDMETHODIMP QueryInterface( REFIID InterfaceId, PVOID* Interface);
@@ -60,6 +80,19 @@ public:
         return m_Ref;
     }
 
+    //IKsPinPipe
+    HRESULT STDMETHODCALLTYPE KsGetPinFramingCache(PKSALLOCATOR_FRAMING_EX *FramingEx, PFRAMING_PROP FramingProp, FRAMING_CACHE_OPS Option);
+    HRESULT STDMETHODCALLTYPE KsSetPinFramingCache(PKSALLOCATOR_FRAMING_EX FramingEx, PFRAMING_PROP FramingProp, FRAMING_CACHE_OPS Option);
+    IPin* STDMETHODCALLTYPE KsGetConnectedPin();
+    IKsAllocatorEx* STDMETHODCALLTYPE KsGetPipe(KSPEEKOPERATION Operation);
+    HRESULT STDMETHODCALLTYPE KsSetPipe(IKsAllocatorEx *KsAllocator);
+    ULONG STDMETHODCALLTYPE KsGetPipeAllocatorFlag();
+    HRESULT STDMETHODCALLTYPE KsSetPipeAllocatorFlag(ULONG Flag);
+    GUID STDMETHODCALLTYPE KsGetPinBusCache();
+    HRESULT STDMETHODCALLTYPE KsSetPinBusCache(GUID Bus);
+    PWCHAR STDMETHODCALLTYPE KsGetPinName();
+    PWCHAR STDMETHODCALLTYPE KsGetFilterName();
+
     //IPin methods
     HRESULT STDMETHODCALLTYPE Connect(IPin *pReceivePin, const AM_MEDIA_TYPE *pmt);
     HRESULT STDMETHODCALLTYPE ReceiveConnection(IPin *pConnector, const AM_MEDIA_TYPE *pmt);
@@ -77,6 +110,9 @@ public:
     HRESULT STDMETHODCALLTYPE EndFlush();
     HRESULT STDMETHODCALLTYPE NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate);
 
+    // ISpecifyPropertyPages
+    HRESULT STDMETHODCALLTYPE GetPages(CAUUID *pPages);
+
     //IKsObject methods
     HANDLE STDMETHODCALLTYPE KsGetObjectHandle();
 
@@ -115,18 +151,32 @@ public:
     HRESULT STDMETHODCALLTYPE ReceiveMultiple(IMediaSample **pSamples, long nSamples, long *nSamplesProcessed);
     HRESULT STDMETHODCALLTYPE ReceiveCanBlock( void);
 
+    //IKsPinFactory
+    HRESULT STDMETHODCALLTYPE KsPinFactory(ULONG* PinFactory);
+
+    //IStreamBuilder
+    HRESULT STDMETHODCALLTYPE Render(IPin *ppinOut, IGraphBuilder *pGraph);
+    HRESULT STDMETHODCALLTYPE Backout(IPin *ppinOut, IGraphBuilder *pGraph);
+
+    //IKsAggregateControl
+    HRESULT STDMETHODCALLTYPE KsAddAggregate(IN REFGUID AggregateClass);
+    HRESULT STDMETHODCALLTYPE KsRemoveAggregate(REFGUID AggregateClass);
+
+    //IQualityControl
+    HRESULT STDMETHODCALLTYPE Notify(IBaseFilter *pSelf, Quality q);
+    HRESULT STDMETHODCALLTYPE SetSink(IQualityControl *piqc);
+
     //---------------------------------------------------------------
     HRESULT STDMETHODCALLTYPE CheckFormat(const AM_MEDIA_TYPE *pmt);
-    HRESULT STDMETHODCALLTYPE CreatePin();
-    HRESULT STDMETHODCALLTYPE CreatePinHandle(PKSPIN_MEDIUM Medium, PKSPIN_INTERFACE Interface, PKSDATAFORMAT DataFormat);
-    CInputPin(IBaseFilter * ParentFilter, LPCWSTR PinName, HANDLE hFilter, ULONG PinId, KSPIN_COMMUNICATION Communication) : m_Ref(0), m_ParentFilter(ParentFilter), m_PinName(PinName), m_hFilter(hFilter), m_hPin(0), m_PinId(PinId), m_MemAllocator(0), m_IoCount(0), m_Communication(Communication), m_Pin(0){};
+    HRESULT STDMETHODCALLTYPE CreatePin(const AM_MEDIA_TYPE *pmt);
+    HRESULT STDMETHODCALLTYPE CreatePinHandle(PKSPIN_MEDIUM Medium, PKSPIN_INTERFACE Interface, const AM_MEDIA_TYPE *pmt);
+    CInputPin(IBaseFilter * ParentFilter, LPCWSTR PinName, ULONG PinId, KSPIN_COMMUNICATION Communication);
     virtual ~CInputPin(){};
 
 protected:
     LONG m_Ref;
     IBaseFilter * m_ParentFilter;
     LPCWSTR m_PinName;
-    HANDLE m_hFilter;
     HANDLE m_hPin;
     ULONG m_PinId;
     IMemAllocator * m_MemAllocator;
@@ -134,15 +184,68 @@ protected:
     KSPIN_COMMUNICATION m_Communication;
     KSPIN_INTERFACE m_Interface;
     KSPIN_MEDIUM m_Medium;
+    AM_MEDIA_TYPE m_MediaFormat;
     IPin * m_Pin;
+    BOOL m_ReadOnly;
+    IKsInterfaceHandler * m_InterfaceHandler;
+    IKsAllocatorEx * m_KsAllocatorEx;
+    ULONG m_PipeAllocatorFlag;
+    BOOL m_bPinBusCacheInitialized;
+    GUID m_PinBusCache;
+    LPWSTR m_FilterName;
+    FRAMING_PROP m_FramingProp[4];
+    PKSALLOCATOR_FRAMING_EX m_FramingEx[4];
 };
 
+CInputPin::CInputPin(
+    IBaseFilter * ParentFilter,
+    LPCWSTR PinName,
+    ULONG PinId,
+    KSPIN_COMMUNICATION Communication) : m_Ref(0),
+                                         m_ParentFilter(ParentFilter),
+                                         m_PinName(PinName),
+                                         m_hPin(INVALID_HANDLE_VALUE),
+                                         m_PinId(PinId),
+                                         m_MemAllocator(0),
+                                         m_IoCount(0),
+                                         m_Communication(Communication),
+                                         m_Pin(0),
+                                         m_ReadOnly(0),
+                                         m_InterfaceHandler(0),
+                                         m_KsAllocatorEx(0),
+                                         m_PipeAllocatorFlag(0),
+                                         m_bPinBusCacheInitialized(0),
+                                         m_FilterName(0)
+{
+    ZeroMemory(m_FramingProp, sizeof(m_FramingProp));
+    ZeroMemory(m_FramingEx, sizeof(m_FramingEx));
+
+    HRESULT hr;
+    IKsObject * KsObjectParent;
+    HANDLE hFilter;
+
+    hr = m_ParentFilter->QueryInterface(IID_IKsObject, (LPVOID*)&KsObjectParent);
+    assert(hr == S_OK);
+
+    hFilter = KsObjectParent->KsGetObjectHandle();
+    assert(hFilter);
+
+    KsObjectParent->Release();
+
+
+    ZeroMemory(&m_MediaFormat, sizeof(AM_MEDIA_TYPE));
+    hr = KsGetMediaType(0, &m_MediaFormat, hFilter, m_PinId);
+    assert(hr == S_OK);
+}
+
 HRESULT
 STDMETHODCALLTYPE
 CInputPin::QueryInterface(
     IN  REFIID refiid,
     OUT PVOID* Output)
 {
+    WCHAR Buffer[100];
+
     *Output = NULL;
 
     if (IsEqualGUID(refiid, IID_IUnknown) ||
@@ -154,28 +257,28 @@ CInputPin::QueryInterface(
     }
     else if (IsEqualGUID(refiid, IID_IMemInputPin))
     {
+        if (m_hPin == INVALID_HANDLE_VALUE)
+        {
+            HRESULT hr = CreatePin(&m_MediaFormat);
+            if (FAILED(hr))
+                return hr;
+        }
+
         *Output = (IMemInputPin*)(this);
         reinterpret_cast<IMemInputPin*>(*Output)->AddRef();
         return NOERROR;
     }
     else if (IsEqualGUID(refiid, IID_IKsObject))
     {
-        if (!m_hPin)
-        {
-            HRESULT hr = CreatePin();
-            if (FAILED(hr))
-                return hr;
-        }
-
         *Output = (IKsObject*)(this);
         reinterpret_cast<IKsObject*>(*Output)->AddRef();
         return NOERROR;
     }
     else if (IsEqualGUID(refiid, IID_IKsPropertySet))
     {
-        if (!m_hPin)
+        if (m_hPin == INVALID_HANDLE_VALUE)
         {
-            HRESULT hr = CreatePin();
+            HRESULT hr = CreatePin(&m_MediaFormat);
             if (FAILED(hr))
                 return hr;
         }
@@ -186,13 +289,6 @@ CInputPin::QueryInterface(
     }
     else if (IsEqualGUID(refiid, IID_IKsControl))
     {
-        if (!m_hPin)
-        {
-            HRESULT hr = CreatePin();
-            if (FAILED(hr))
-                return hr;
-        }
-
         *Output = (IKsControl*)(this);
         reinterpret_cast<IKsControl*>(*Output)->AddRef();
         return NOERROR;
@@ -200,20 +296,49 @@ CInputPin::QueryInterface(
     else if (IsEqualGUID(refiid, IID_IKsPin) ||
              IsEqualGUID(refiid, IID_IKsPinEx))
     {
-        if (!m_hPin)
-        {
-            HRESULT hr = CreatePin();
-            if (FAILED(hr))
-                return hr;
-        }
-
         *Output = (IKsPinEx*)(this);
         reinterpret_cast<IKsPinEx*>(*Output)->AddRef();
         return NOERROR;
     }
+    else if (IsEqualGUID(refiid, IID_IKsPinPipe))
+    {
+        *Output = (IKsPinPipe*)(this);
+        reinterpret_cast<IKsPinPipe*>(*Output)->AddRef();
+        return NOERROR;
+    }
+    else if (IsEqualGUID(refiid, IID_IKsPinFactory))
+    {
+        *Output = (IKsPinFactory*)(this);
+        reinterpret_cast<IKsPinFactory*>(*Output)->AddRef();
+        return NOERROR;
+    }
+#if 0
+    else if (IsEqualGUID(refiid, IID_IStreamBuilder))
+    {
+        *Output = (IStreamBuilder*)(this);
+        reinterpret_cast<IStreamBuilder*>(*Output)->AddRef();
+        return NOERROR;
+    }
+#endif
+    else if (IsEqualGUID(refiid, IID_IKsAggregateControl))
+    {
+        *Output = (IKsAggregateControl*)(this);
+        reinterpret_cast<IKsAggregateControl*>(*Output)->AddRef();
+        return NOERROR;
+    }
+    else if (IsEqualGUID(refiid, IID_IQualityControl))
+    {
+        *Output = (IQualityControl*)(this);
+        reinterpret_cast<IQualityControl*>(*Output)->AddRef();
+        return NOERROR;
+    }
+    else if (IsEqualGUID(refiid, IID_ISpecifyPropertyPages))
+    {
+        *Output = (ISpecifyPropertyPages*)(this);
+        reinterpret_cast<ISpecifyPropertyPages*>(*Output)->AddRef();
+        return NOERROR;
+    }
 
-
-    WCHAR Buffer[MAX_PATH];
     LPOLESTR lpstr;
     StringFromCLSID(refiid, &lpstr);
     swprintf(Buffer, L"CInputPin::QueryInterface: NoInterface for %s\n", lpstr);
@@ -222,17 +347,281 @@ CInputPin::QueryInterface(
 
     return E_NOINTERFACE;
 }
+//-------------------------------------------------------------------
+// IQualityControl interface
+//
+HRESULT
+STDMETHODCALLTYPE
+CInputPin::Notify(
+    IBaseFilter *pSelf,
+    Quality q)
+{
+#ifdef KSPROXY_TRACE
+    OutputDebugStringW(L"CInputPin::Notify NotImplemented\n");
+#endif
+
+    return E_NOTIMPL;
+}
+
+HRESULT
+STDMETHODCALLTYPE
+CInputPin::SetSink(
+    IQualityControl *piqc)
+{
+#ifdef KSPROXY_TRACE
+    OutputDebugStringW(L"CInputPin::SetSink NotImplemented\n");
+#endif
+
+    return E_NOTIMPL;
+}
+
+
+//-------------------------------------------------------------------
+// IKsAggregateControl interface
+//
+HRESULT
+STDMETHODCALLTYPE
+CInputPin::KsAddAggregate(
+    IN REFGUID AggregateClass)
+{
+#ifdef KSPROXY_TRACE
+    OutputDebugStringW(L"CInputPin::KsAddAggregate NotImplemented\n");
+#endif
+
+    return E_NOTIMPL;
+}
+
+HRESULT
+STDMETHODCALLTYPE
+CInputPin::KsRemoveAggregate(
+    REFGUID AggregateClass)
+{
+#ifdef KSPROXY_TRACE
+    OutputDebugStringW(L"CInputPin::KsRemoveAggregate NotImplemented\n");
+#endif
+
+    return E_NOTIMPL;
+}
+
+//-------------------------------------------------------------------
+// IStreamBuilder
+//
+
+HRESULT
+STDMETHODCALLTYPE
+CInputPin::Render(
+    IPin *ppinOut,
+    IGraphBuilder *pGraph)
+{
+    OutputDebugStringW(L"CInputPin::Render\n");
+    return S_OK;
+}
+
+HRESULT
+STDMETHODCALLTYPE
+CInputPin::Backout(
+    IPin *ppinOut, 
+    IGraphBuilder *pGraph)
+{
+#ifdef KSPROXY_TRACE
+    OutputDebugStringW(L"CInputPin::Backout\n");
+#endif
+
+    return S_OK;
+}
+
+//-------------------------------------------------------------------
+// IKsPinFactory
+//
+
+HRESULT
+STDMETHODCALLTYPE
+CInputPin::KsPinFactory(
+    ULONG* PinFactory)
+{
+#ifdef KSPROXY_TRACE
+    OutputDebugStringW(L"CInputPin::KsPinFactory\n");
+#endif
+
+    *PinFactory = m_PinId;
+    return S_OK;
+}
+
+//-------------------------------------------------------------------
+// IKsPinPipe
+//
+
+HRESULT
+STDMETHODCALLTYPE
+CInputPin::KsGetPinFramingCache(
+    PKSALLOCATOR_FRAMING_EX *FramingEx,
+    PFRAMING_PROP FramingProp,
+    FRAMING_CACHE_OPS Option)
+{
+    if (Option > Framing_Cache_Write || Option < Framing_Cache_ReadLast)
+    {
+        // invalid argument
+        return E_INVALIDARG;
+    }
+
+    // get framing properties
+    *FramingProp = m_FramingProp[Option];
+    *FramingEx = m_FramingEx[Option];
+
+    return NOERROR;
+}
+
+HRESULT
+STDMETHODCALLTYPE
+CInputPin::KsSetPinFramingCache(
+    PKSALLOCATOR_FRAMING_EX FramingEx,
+    PFRAMING_PROP FramingProp,
+    FRAMING_CACHE_OPS Option)
+{
+    ULONG Index;
+    ULONG RefCount = 0;
+
+    if (m_FramingEx[Option])
+    {
+        for(Index = 1; Index < 4; Index++)
+        {
+            if (m_FramingEx[Index] == m_FramingEx[Option])
+                RefCount++;
+        }
+
+        if (RefCount == 1)
+        {
+            // existing framing is only used once
+            CoTaskMemFree(m_FramingEx[Option]);
+        }
+    }
+
+    // store framing
+    m_FramingEx[Option] = FramingEx;
+    m_FramingProp[Option] = *FramingProp;
+
+    return S_OK;
+}
+
+IPin*
+STDMETHODCALLTYPE
+CInputPin::KsGetConnectedPin()
+{
+    return m_Pin;
+}
+
+IKsAllocatorEx*
+STDMETHODCALLTYPE
+CInputPin::KsGetPipe(
+    KSPEEKOPERATION Operation)
+{
+    if (Operation == KsPeekOperation_AddRef)
+    {
+        if (m_KsAllocatorEx)
+            m_KsAllocatorEx->AddRef();
+    }
+    return m_KsAllocatorEx;
+}
+
+HRESULT
+STDMETHODCALLTYPE
+CInputPin::KsSetPipe(
+    IKsAllocatorEx *KsAllocator)
+{
+    if (KsAllocator)
+        KsAllocator->AddRef();
+
+    if (m_KsAllocatorEx)
+        m_KsAllocatorEx->Release();
+
+    m_KsAllocatorEx = KsAllocator;
+    return NOERROR;
+}
+
+ULONG
+STDMETHODCALLTYPE
+CInputPin::KsGetPipeAllocatorFlag()
+{
+    return m_PipeAllocatorFlag;
+}
+
+
+HRESULT
+STDMETHODCALLTYPE
+CInputPin::KsSetPipeAllocatorFlag(
+    ULONG Flag)
+{
+    m_PipeAllocatorFlag = Flag;
+    return NOERROR;
+}
+
+GUID
+STDMETHODCALLTYPE
+CInputPin::KsGetPinBusCache()
+{
+    if (!m_bPinBusCacheInitialized)
+    {
+        CopyMemory(&m_PinBusCache, &m_Medium.Set, sizeof(GUID));
+        m_bPinBusCacheInitialized = TRUE;
+    }
+
+    return m_PinBusCache;
+}
+
+HRESULT
+STDMETHODCALLTYPE
+CInputPin::KsSetPinBusCache(
+    GUID Bus)
+{
+    CopyMemory(&m_PinBusCache, &Bus, sizeof(GUID));
+    return NOERROR;
+}
+
+PWCHAR
+STDMETHODCALLTYPE
+CInputPin::KsGetPinName()
+{
+    return (PWCHAR)m_PinName;
+}
+
+
+PWCHAR
+STDMETHODCALLTYPE
+CInputPin::KsGetFilterName()
+{
+    return m_FilterName;
+}
+
+//-------------------------------------------------------------------
+// ISpecifyPropertyPages
+//
+
+HRESULT
+STDMETHODCALLTYPE
+CInputPin::GetPages(CAUUID *pPages)
+{
+    if (!pPages)
+        return E_POINTER;
+
+    pPages->cElems = 0;
+    pPages->pElems = NULL;
+
+    return S_OK;
+}
 
 //-------------------------------------------------------------------
 // IMemInputPin
 //
 
-    //
+
 HRESULT
 STDMETHODCALLTYPE
 CInputPin::GetAllocator(IMemAllocator **ppAllocator)
 {
+#ifdef KSPROXY_TRACE
     OutputDebugStringW(L"CInputPin::GetAllocator\n");
+#endif
+
     return VFW_E_NO_ALLOCATOR;
 }
 
@@ -240,6 +629,17 @@ HRESULT
 STDMETHODCALLTYPE
 CInputPin::NotifyAllocator(IMemAllocator *pAllocator, BOOL bReadOnly)
 {
+    HRESULT hr;
+    ALLOCATOR_PROPERTIES Properties;
+
+    hr = pAllocator->GetProperties(&Properties);
+
+#ifdef KSPROXY_TRACE
+    WCHAR Buffer[100];
+    swprintf(Buffer, L"CInputPin::NotifyAllocator hr %lx bReadOnly, %u cbAlign %u cbBuffer %u cbPrefix %u cBuffers %u\n", hr, bReadOnly, Properties.cbAlign, Properties.cbBuffer, Properties.cbPrefix, Properties.cBuffers);
+    OutputDebugStringW(Buffer);
+#endif
+
     if (pAllocator)
     {
         pAllocator->AddRef();
@@ -251,6 +651,7 @@ CInputPin::NotifyAllocator(IMemAllocator *pAllocator, BOOL bReadOnly)
     }
 
     m_MemAllocator = pAllocator;
+    m_ReadOnly = bReadOnly;
     return NOERROR;
 }
 
@@ -274,17 +675,28 @@ CInputPin::GetAllocatorRequirements(ALLOCATOR_PROPERTIES *pProps)
         pProps->cbBuffer = Framing.FrameSize;
         pProps->cbAlign = Framing.FileAlignment;
         pProps->cbPrefix = 0;
-        return hr;
     }
     else
-        return E_NOTIMPL;
+        hr = E_NOTIMPL;
+
+#ifdef KSPROXY_TRACE
+    WCHAR Buffer[100];
+    swprintf(Buffer, L"CInputPin::GetAllocatorRequirements hr %lx m_hPin %p cBuffers %u cbBuffer %u cbAlign %u cbPrefix %u\n", hr, m_hPin, pProps->cBuffers, pProps->cbBuffer, pProps->cbAlign, pProps->cbPrefix);
+    OutputDebugStringW(Buffer);
+#endif
+
+    return hr;
 }
 
 HRESULT
 STDMETHODCALLTYPE
 CInputPin::Receive(IMediaSample *pSample)
 {
+#ifdef KSPROXY_TRACE
     OutputDebugStringW(L"CInputPin::Receive NotImplemented\n");
+    DebugBreak();
+#endif
+
     return E_NOTIMPL;
 }
 
@@ -292,7 +704,11 @@ HRESULT
 STDMETHODCALLTYPE
 CInputPin::ReceiveMultiple(IMediaSample **pSamples, long nSamples, long *nSamplesProcessed)
 {
+#ifdef KSPROXY_TRACE
     OutputDebugStringW(L"CInputPin::ReceiveMultiple NotImplemented\n");
+    DebugBreak();
+#endif
+
     return E_NOTIMPL;
 }
 
@@ -300,11 +716,14 @@ HRESULT
 STDMETHODCALLTYPE
 CInputPin::ReceiveCanBlock( void)
 {
+#ifdef KSPROXY_TRACE
     OutputDebugStringW(L"CInputPin::ReceiveCanBlock NotImplemented\n");
+    DebugBreak();
+#endif
+
     return S_FALSE;
 }
 
-
 //-------------------------------------------------------------------
 // IKsPin
 //
@@ -314,7 +733,22 @@ STDMETHODCALLTYPE
 CInputPin::KsQueryMediums(
     PKSMULTIPLE_ITEM* MediumList)
 {
-    return KsGetMultiplePinFactoryItems(m_hFilter, m_PinId, KSPROPERTY_PIN_MEDIUMS, (PVOID*)MediumList);
+    HRESULT hr;
+    IKsObject * KsObjectParent;
+    HANDLE hFilter;
+
+    hr = m_ParentFilter->QueryInterface(IID_IKsObject, (LPVOID*)&KsObjectParent);
+    if (FAILED(hr))
+        return hr;
+
+    hFilter = KsObjectParent->KsGetObjectHandle();
+
+    KsObjectParent->Release();
+
+    if (!hFilter)
+        return E_HANDLE;
+
+    return KsGetMultiplePinFactoryItems(hFilter, m_PinId, KSPROPERTY_PIN_MEDIUMS, (PVOID*)MediumList);
 }
 
 HRESULT
@@ -322,7 +756,22 @@ STDMETHODCALLTYPE
 CInputPin::KsQueryInterfaces(
     PKSMULTIPLE_ITEM* InterfaceList)
 {
-    return KsGetMultiplePinFactoryItems(m_hFilter, m_PinId, KSPROPERTY_PIN_INTERFACES, (PVOID*)InterfaceList);
+    HRESULT hr;
+    IKsObject * KsObjectParent;
+    HANDLE hFilter;
+
+    hr = m_ParentFilter->QueryInterface(IID_IKsObject, (LPVOID*)&KsObjectParent);
+    if (FAILED(hr))
+        return hr;
+
+    hFilter = KsObjectParent->KsGetObjectHandle();
+
+    KsObjectParent->Release();
+
+    if (!hFilter)
+        return E_HANDLE;
+
+    return KsGetMultiplePinFactoryItems(hFilter, m_PinId, KSPROPERTY_PIN_INTERFACES, (PVOID*)InterfaceList);
 }
 
 HRESULT
@@ -331,8 +780,7 @@ CInputPin::KsCreateSinkPinHandle(
     KSPIN_INTERFACE& Interface,
     KSPIN_MEDIUM& Medium)
 {
-    OutputDebugStringW(L"CInputPin::KsCreateSinkPinHandle NotImplemented\n");
-    return E_NOTIMPL;
+    return CreatePin(&m_MediaFormat);
 }
 
 HRESULT
@@ -369,8 +817,25 @@ HRESULT
 STDMETHODCALLTYPE
 CInputPin::KsPropagateAcquire()
 {
-    OutputDebugStringW(L"CInputPin::KsPropagateAcquire NotImplemented\n");
-    return E_NOTIMPL;
+    KSPROPERTY Property;
+    KSSTATE State;
+    ULONG BytesReturned;
+    HRESULT hr;
+
+    assert(m_hPin != INVALID_HANDLE_VALUE);
+
+    Property.Set = KSPROPSETID_Connection;
+    Property.Id = KSPROPERTY_CONNECTION_STATE;
+    Property.Flags = KSPROPERTY_TYPE_SET;
+
+    State = KSSTATE_ACQUIRE;
+
+    hr = KsProperty(&Property, sizeof(KSPROPERTY), (LPVOID)&State, sizeof(KSSTATE), &BytesReturned);
+
+    //TODO
+    //propagate to connected pin on the pipe
+
+    return hr;
 }
 
 HRESULT
@@ -406,6 +871,7 @@ HRESULT
 STDMETHODCALLTYPE
 CInputPin::KsReceiveAllocator(IMemAllocator *MemAllocator)
 {
+
     if (MemAllocator)
     {
         MemAllocator->AddRef();
@@ -447,7 +913,11 @@ CInputPin::KsQualityNotify(
     ULONG Proportion,
     REFERENCE_TIME TimeDelta)
 {
+#ifdef KSPROXY_TRACE
     OutputDebugStringW(L"CInputPin::KsQualityNotify NotImplemented\n");
+#endif
+
+    DebugBreak();
     return E_NOTIMPL;
 }
 
@@ -461,12 +931,14 @@ CInputPin::KsNotifyError(
     IMediaSample* Sample,
     HRESULT hr)
 {
+#ifdef KSPROXY_TRACE
     OutputDebugStringW(L"CInputPin::KsNotifyError NotImplemented\n");
+#endif
 }
 
 
 //-------------------------------------------------------------------
-// IKsPropertySet
+// IKsControl
 //
 HRESULT
 STDMETHODCALLTYPE
@@ -477,6 +949,7 @@ CInputPin::KsProperty(
     ULONG DataLength,
     ULONG* BytesReturned)
 {
+    assert(m_hPin != INVALID_HANDLE_VALUE);
     return KsSynchronousDeviceControl(m_hPin, IOCTL_KS_PROPERTY, (PVOID)Property, PropertyLength, (PVOID)PropertyData, DataLength, BytesReturned);
 }
 
@@ -489,6 +962,7 @@ CInputPin::KsMethod(
     ULONG DataLength,
     ULONG* BytesReturned)
 {
+    assert(m_hPin != INVALID_HANDLE_VALUE);
     return KsSynchronousDeviceControl(m_hPin, IOCTL_KS_METHOD, (PVOID)Method, MethodLength, (PVOID)MethodData, DataLength, BytesReturned);
 }
 
@@ -501,6 +975,8 @@ CInputPin::KsEvent(
     ULONG DataLength,
     ULONG* BytesReturned)
 {
+    assert(m_hPin != INVALID_HANDLE_VALUE);
+
     if (EventLength)
         return KsSynchronousDeviceControl(m_hPin, IOCTL_KS_ENABLE_EVENT, (PVOID)Event, EventLength, (PVOID)EventData, DataLength, BytesReturned);
     else
@@ -619,10 +1095,7 @@ HANDLE
 STDMETHODCALLTYPE
 CInputPin::KsGetObjectHandle()
 {
-    OutputDebugStringW(L"CInputPin::KsGetObjectHandle CALLED\n");
-
-    //FIXME
-    // return pin handle
+    assert(m_hPin);
     return m_hPin;
 }
 
@@ -633,7 +1106,10 @@ HRESULT
 STDMETHODCALLTYPE
 CInputPin::Connect(IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
 {
+#ifdef KSPROXY_TRACE
     OutputDebugStringW(L"CInputPin::Connect NotImplemented\n");
+    DebugBreak();
+#endif
     return NOERROR;
 }
 
@@ -645,31 +1121,50 @@ CInputPin::ReceiveConnection(IPin *pConnector, const AM_MEDIA_TYPE *pmt)
 
     if (m_Pin)
     {
-        OutputDebugStringW(L"CInputPin::ReceiveConnection already connected\n");
+        // already connected
         return VFW_E_ALREADY_CONNECTED;
     }
 
     // first check format
     hr = CheckFormat(pmt);
     if (FAILED(hr))
+    {
+        // format is not supported
         return hr;
+    }
 
-    if (FAILED(CheckFormat(pmt)))
+    hr = CreatePin(pmt);
+    if (FAILED(hr))
+    {
         return hr;
+    }
 
-    //FIXME create pin
-   m_Pin = pConnector;
-   m_Pin->AddRef();
+    m_Pin = pConnector;
+    m_Pin->AddRef();
 
-    OutputDebugStringW(L"CInputPin::ReceiveConnection NotImplemented\n");
     return S_OK;
 }
 HRESULT
 STDMETHODCALLTYPE
 CInputPin::Disconnect( void)
 {
-    OutputDebugStringW(L"CInputPin::Disconnect NotImplemented\n");
-    return E_NOTIMPL;
+    if (!m_Pin)
+    {
+        // pin was not connected
+        return S_FALSE;
+    }
+
+    //FIXME
+    //check if filter is active
+
+    m_Pin->Release();
+    m_Pin = NULL;
+
+#ifdef KSPROXY_TRACE
+    OutputDebugStringW(L"CInputPin::Disconnect\n");
+#endif
+
+    return S_OK;
 }
 HRESULT
 STDMETHODCALLTYPE
@@ -693,7 +1188,14 @@ HRESULT
 STDMETHODCALLTYPE
 CInputPin::ConnectionMediaType(AM_MEDIA_TYPE *pmt)
 {
+    if (!m_Pin)
+        return VFW_E_NOT_CONNECTED;
+
+#ifdef KSPROXY_TRACE
     OutputDebugStringW(L"CInputPin::ConnectionMediaType NotImplemented\n");
+    DebugBreak();
+#endif
+
     return E_NOTIMPL;
 }
 HRESULT
@@ -742,114 +1244,164 @@ HRESULT
 STDMETHODCALLTYPE
 CInputPin::EnumMediaTypes(IEnumMediaTypes **ppEnum)
 {
-    return CEnumMediaTypes_fnConstructor(0, NULL, IID_IEnumMediaTypes, (void**)ppEnum);
+    HRESULT hr;
+    ULONG MediaTypeCount = 0, Index;
+    AM_MEDIA_TYPE * MediaTypes;
+    IKsObject * KsObjectParent;
+    HANDLE hFilter;
+
+    hr = m_ParentFilter->QueryInterface(IID_IKsObject, (LPVOID*)&KsObjectParent);
+    if (FAILED(hr))
+        return hr;
+
+    hFilter = KsObjectParent->KsGetObjectHandle();
+
+    KsObjectParent->Release();
+
+    if (!hFilter)
+        return E_HANDLE;
+
+
+    // query media type count
+    hr = KsGetMediaTypeCount(hFilter, m_PinId, &MediaTypeCount);
+    if (FAILED(hr) || !MediaTypeCount)
+        return hr;
+
+    // allocate media types
+    MediaTypes = (AM_MEDIA_TYPE*)CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE) * MediaTypeCount);
+    if (!MediaTypes)
+    {
+        // not enough memory
+        return E_OUTOFMEMORY;
+    }
+
+    // zero media types
+    ZeroMemory(MediaTypes, sizeof(AM_MEDIA_TYPE) * MediaTypeCount);
+
+    for(Index = 0; Index < MediaTypeCount; Index++)
+    {
+        // get media type
+        hr = KsGetMediaType(Index, &MediaTypes[Index], hFilter, m_PinId);
+        if (FAILED(hr))
+        {
+            // failed
+            CoTaskMemFree(MediaTypes);
+            return hr;
+        }
+    }
+
+    return CEnumMediaTypes_fnConstructor(MediaTypeCount, MediaTypes, IID_IEnumMediaTypes, (void**)ppEnum);
 }
+
 HRESULT
 STDMETHODCALLTYPE
 CInputPin::QueryInternalConnections(IPin **apPin, ULONG *nPin)
 {
+#ifdef KSPROXY_TRACE
     OutputDebugStringW(L"CInputPin::QueryInternalConnections NotImplemented\n");
+#endif
     return E_NOTIMPL;
 }
 HRESULT
 STDMETHODCALLTYPE
 CInputPin::EndOfStream( void)
 {
+#ifdef KSPROXY_TRACE
     OutputDebugStringW(L"CInputPin::EndOfStream NotImplemented\n");
+#endif
     return E_NOTIMPL;
 }
 HRESULT
 STDMETHODCALLTYPE
 CInputPin::BeginFlush( void)
 {
+#ifdef KSPROXY_TRACE
     OutputDebugStringW(L"CInputPin::BeginFlush NotImplemented\n");
+#endif
     return E_NOTIMPL;
 }
 HRESULT
 STDMETHODCALLTYPE
 CInputPin::EndFlush( void)
 {
+#ifdef KSPROXY_TRACE
     OutputDebugStringW(L"CInputPin::EndFlush NotImplemented\n");
+#endif
     return E_NOTIMPL;
 }
 HRESULT
 STDMETHODCALLTYPE
 CInputPin::NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
 {
+#ifdef KSPROXY_TRACE
     OutputDebugStringW(L"CInputPin::NewSegment NotImplemented\n");
+#endif
     return E_NOTIMPL;
 }
 
+
 //-------------------------------------------------------------------
 HRESULT
 STDMETHODCALLTYPE
 CInputPin::CheckFormat(
     const AM_MEDIA_TYPE *pmt)
 {
-    KSP_PIN Property;
     PKSMULTIPLE_ITEM MultipleItem;
     PKSDATAFORMAT DataFormat;
-    ULONG BytesReturned;
     HRESULT hr;
+    IKsObject * KsObjectParent;
+    HANDLE hFilter;
 
-    // prepare request
-    Property.Property.Set = KSPROPSETID_Pin;
-    Property.Property.Id = KSPROPERTY_PIN_DATARANGES;
-    Property.Property.Flags = KSPROPERTY_TYPE_GET;
-    Property.PinId = m_PinId;
-    Property.Reserved = 0;
+    if (!pmt)
+        return E_POINTER;
 
-    // query for size of dataranges
-    hr = KsSynchronousDeviceControl(m_hFilter, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSP_PIN), NULL, 0, &BytesReturned);
+    hr = m_ParentFilter->QueryInterface(IID_IKsObject, (LPVOID*)&KsObjectParent);
+    if (FAILED(hr))
+        return hr;
 
-    if (hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_MORE_DATA))
-    {
-        // allocate dataranges buffer
-        MultipleItem = (PKSMULTIPLE_ITEM)CoTaskMemAlloc(BytesReturned);
+    hFilter = KsObjectParent->KsGetObjectHandle();
 
-        if (!MultipleItem)
-            return E_OUTOFMEMORY;
+    KsObjectParent->Release();
 
-        // query dataranges
-        hr = KsSynchronousDeviceControl(m_hFilter, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSP_PIN), (PVOID)MultipleItem, BytesReturned, &BytesReturned);
+    if (!hFilter)
+        return E_HANDLE;
 
-        if (FAILED(hr))
-        {
-            // failed to query data ranges
-            CoTaskMemFree(MultipleItem);
-            return hr;
-        }
 
-        DataFormat = (PKSDATAFORMAT)(MultipleItem + 1);
-        for(ULONG Index = 0; Index < MultipleItem->Count; Index++)
+    hr = KsGetMultiplePinFactoryItems(hFilter, m_PinId, KSPROPERTY_PIN_DATARANGES, (PVOID*)&MultipleItem);
+    if (FAILED(hr))
+        return S_FALSE;
+
+    DataFormat = (PKSDATAFORMAT)(MultipleItem + 1);
+    for(ULONG Index = 0; Index < MultipleItem->Count; Index++)
+    {
+        if (IsEqualGUID(pmt->majortype, DataFormat->MajorFormat) &&
+            IsEqualGUID(pmt->subtype, DataFormat->SubFormat) &&
+            IsEqualGUID(pmt->formattype, DataFormat->Specifier))
         {
-            if (IsEqualGUID(pmt->majortype, DataFormat->MajorFormat) &&
-                IsEqualGUID(pmt->subtype, DataFormat->SubFormat) &&
-                IsEqualGUID(pmt->formattype, DataFormat->Specifier))
-            {
-                // format is supported
-                CoTaskMemFree(MultipleItem);
-                OutputDebugStringW(L"CInputPin::CheckFormat format OK\n");
-                return S_OK;
-            }
-            DataFormat = (PKSDATAFORMAT)((ULONG_PTR)DataFormat + DataFormat->FormatSize);
+            // format is supported
+            CoTaskMemFree(MultipleItem);
+#ifdef KSPROXY_TRACE
+            OutputDebugStringW(L"CInputPin::CheckFormat format OK\n");
+#endif
+            return S_OK;
         }
-        //format is not supported
-        CoTaskMemFree(MultipleItem);
+        DataFormat = (PKSDATAFORMAT)((ULONG_PTR)DataFormat + DataFormat->FormatSize);
     }
+    //format is not supported
+    CoTaskMemFree(MultipleItem);
     return S_FALSE;
 }
 
 HRESULT
 STDMETHODCALLTYPE
-CInputPin::CreatePin()
+CInputPin::CreatePin(
+    const AM_MEDIA_TYPE *pmt)
 {
     PKSMULTIPLE_ITEM MediumList;
     PKSMULTIPLE_ITEM InterfaceList;
-    PKSMULTIPLE_ITEM DataFormatList = NULL;
     PKSPIN_MEDIUM Medium;
-    PKSDATAFORMAT DataFormat;
     PKSPIN_INTERFACE Interface;
+    IKsInterfaceHandler * InterfaceHandler;
     HRESULT hr;
 
     // query for pin medium
@@ -866,19 +1418,6 @@ CInputPin::CreatePin()
         return hr;
     }
 
-    // get data ranges
-    hr = KsGetMultiplePinFactoryItems(m_hFilter, m_PinId, KSPROPERTY_PIN_DATARANGES, (PVOID*)&DataFormatList);
-    if (FAILED(hr) || DataFormatList->Count == 0)
-    {
-        // failed
-        CoTaskMemFree(MediumList);
-        CoTaskMemFree(InterfaceList);
-        if (DataFormatList)
-            CoTaskMemFree(DataFormatList);
-
-        return hr;
-    }
-
     if (MediumList->Count)
     {
         //use first available medium
@@ -901,15 +1440,62 @@ CInputPin::CreatePin()
         Interface = &StandardPinInterface;
     }
 
-    //FIXME determine format
-    // use first available format
-    DataFormat = (PKSDATAFORMAT) (DataFormatList + 1);
+    if (m_Communication != KSPIN_COMMUNICATION_BRIDGE && m_Communication != KSPIN_COMMUNICATION_NONE)
+    {
+        if (!m_InterfaceHandler)
+        {
+            // now load the IKsInterfaceHandler plugin
+            hr = CoCreateInstance(Interface->Set, NULL, CLSCTX_INPROC_SERVER, IID_IKsInterfaceHandler, (void**)&InterfaceHandler);
+            if (FAILED(hr))
+            {
+                // failed to load interface handler plugin
+#ifdef KSPROXY_TRACE
+                OutputDebugStringW(L"CInputPin::CreatePin failed to load InterfaceHandlerPlugin\n");
+#endif
+                CoTaskMemFree(MediumList);
+                CoTaskMemFree(InterfaceList);
 
-    // now create pin
-    hr = CreatePinHandle(Medium, Interface, DataFormat);
+                return hr;
+            }
+
+            // now set the pin
+            hr = InterfaceHandler->KsSetPin((IKsPin*)this);
+            if (FAILED(hr))
+            {
+                // failed to load interface handler plugin
+#ifdef KSPROXY_TRACE
+                OutputDebugStringW(L"CInputPin::CreatePin failed to initialize InterfaceHandlerPlugin\n");
+#endif
+                InterfaceHandler->Release();
+                CoTaskMemFree(MediumList);
+                CoTaskMemFree(InterfaceList);
+                return hr;
+            }
+
+            // store interface handler
+            m_InterfaceHandler = InterfaceHandler;
+        }
+
+        // now create pin
+        hr = CreatePinHandle(Medium, Interface, pmt);
+        if (FAILED(hr))
+        {
+            m_InterfaceHandler->Release();
+            m_InterfaceHandler = InterfaceHandler;
+        }
+    }
+    else
+    {
+#ifdef KSPROXY_TRACE
+        WCHAR Buffer[100];
+        swprintf(Buffer, L"CInputPin::CreatePin unexpected communication %u %s\n", m_Communication, m_PinName);
+        OutputDebugStringW(Buffer);
+        DebugBreak();
+#endif
+        hr = E_FAIL;
+    }
 
     // free medium / interface / dataformat
-    CoTaskMemFree(DataFormatList);
     CoTaskMemFree(MediumList);
     CoTaskMemFree(InterfaceList);
 
@@ -921,14 +1507,41 @@ STDMETHODCALLTYPE
 CInputPin::CreatePinHandle(
     PKSPIN_MEDIUM Medium,
     PKSPIN_INTERFACE Interface,
-    PKSDATAFORMAT DataFormat)
+    const AM_MEDIA_TYPE *pmt)
 {
     PKSPIN_CONNECT PinConnect;
+    PKSDATAFORMAT DataFormat;
     ULONG Length;
     HRESULT hr;
+    IKsObject * KsObjectParent;
+    HANDLE hFilter;
+
+    if (!pmt)
+        return E_POINTER;
+
+    hr = m_ParentFilter->QueryInterface(IID_IKsObject, (LPVOID*)&KsObjectParent);
+    if (FAILED(hr))
+        return hr;
+
+    hFilter = KsObjectParent->KsGetObjectHandle();
+
+    KsObjectParent->Release();
+
+    if (!hFilter)
+        return E_HANDLE;
+
+
+    if (m_hPin != INVALID_HANDLE_VALUE)
+    {
+        // pin already exists
+        //CloseHandle(m_hPin);
+        //m_hPin = INVALID_HANDLE_VALUE;
+        return S_OK;
+    }
+
 
     // calc format size
-    Length = sizeof(KSPIN_CONNECT) + DataFormat->FormatSize;
+    Length = sizeof(KSPIN_CONNECT) + sizeof(KSDATAFORMAT) + pmt->cbFormat;
 
     // allocate pin connect
     PinConnect = (PKSPIN_CONNECT)CoTaskMemAlloc(Length);
@@ -945,10 +1558,66 @@ CInputPin::CreatePinHandle(
     PinConnect->PinToHandle = NULL;
     PinConnect->Priority.PriorityClass = KSPRIORITY_NORMAL;
     PinConnect->Priority.PrioritySubClass = KSPRIORITY_NORMAL;
-    CopyMemory((PinConnect + 1), DataFormat, DataFormat->FormatSize);
+
+    // get dataformat offset
+    DataFormat = (PKSDATAFORMAT)(PinConnect + 1);
+
+    // copy data format
+    DataFormat->FormatSize = sizeof(KSDATAFORMAT) + pmt->cbFormat;
+    DataFormat->Flags = 0;
+    DataFormat->SampleSize = pmt->lSampleSize;
+    DataFormat->Reserved = 0;
+    CopyMemory(&DataFormat->MajorFormat, &pmt->majortype, sizeof(GUID));
+    CopyMemory(&DataFormat->SubFormat,  &pmt->subtype, sizeof(GUID));
+    CopyMemory(&DataFormat->Specifier, &pmt->formattype, sizeof(GUID));
+
+    if (pmt->cbFormat)
+    {
+        // copy extended format
+        CopyMemory((DataFormat + 1), pmt->pbFormat, pmt->cbFormat);
+    }
 
     // create pin
-    hr = KsCreatePin(m_hFilter, PinConnect, GENERIC_WRITE, &m_hPin);
+    hr = KsCreatePin(hFilter, PinConnect, GENERIC_WRITE, &m_hPin);
+
+    if (SUCCEEDED(hr))
+    {
+        // store current interface / medium
+        CopyMemory(&m_Medium, Medium, sizeof(KSPIN_MEDIUM));
+        CopyMemory(&m_Interface, Interface, sizeof(KSPIN_INTERFACE));
+        CopyMemory(&m_MediaFormat, pmt, sizeof(AM_MEDIA_TYPE));
+
+#ifdef KSPROXY_TRACE
+        LPOLESTR pMajor, pSub, pFormat;
+        StringFromIID(m_MediaFormat.majortype, &pMajor);
+        StringFromIID(m_MediaFormat.subtype , &pSub);
+        StringFromIID(m_MediaFormat.formattype, &pFormat);
+
+        WCHAR Buffer[200];
+        swprintf(Buffer, L"CInputPin::CreatePinHandle Major %s SubType %s Format %s pbFormat %p cbFormat %u\n", pMajor, pSub, pFormat, pmt->pbFormat, pmt->cbFormat);
+        CoTaskMemFree(pMajor);
+        CoTaskMemFree(pSub);
+        CoTaskMemFree(pFormat);
+        OutputDebugStringW(Buffer);
+#endif
+
+        if (pmt->cbFormat)
+        {
+            m_MediaFormat.pbFormat = (BYTE*)CoTaskMemAlloc(pmt->cbFormat);
+            if (!m_MediaFormat.pbFormat)
+            {
+                CoTaskMemFree(PinConnect);
+                m_MediaFormat.pbFormat = NULL;
+                m_MediaFormat.cbFormat = 0;
+                return E_OUTOFMEMORY;
+            }
+            CopyMemory(m_MediaFormat.pbFormat, pmt->pbFormat, pmt->cbFormat);
+        }
+
+        //TODO
+        // connect pin pipes
+
+    }
 
     // free pin connect
      CoTaskMemFree(PinConnect);
@@ -967,7 +1636,7 @@ CInputPin_Constructor(
     REFIID riid,
     LPVOID * ppv)
 {
-    CInputPin * handler = new CInputPin(ParentFilter, PinName, hFilter, PinId, Communication);
+    CInputPin * handler = new CInputPin(ParentFilter, PinName, PinId, Communication);
 
     if (!handler)
         return E_OUTOFMEMORY;