[KSPROXY]

- Implement IEnumMediaTypes interface
- Implement IKsObject, IKsPropertySet, IKsControl interface for CInputPin
- Verify connection format for CInputPin
- Delegate interface requests to ksproxy plugins
- Implement CKsProxy::FindPin
[MSDVBNP]
- Use FORMAT_None as format specifier

svn path=/trunk/; revision=45776

reactos/dll/directx/ksproxy/enum_mediatypes.cpp

@@ -0,0 +1,188 @@
+/*
+ * COPYRIGHT:       See COPYING in the top level directory
+ * PROJECT:         ReactOS Network Provider for MPEG2 based networks
+ * FILE:            dll/directx/msdvbnp/enum_mediatypes.cpp
+ * PURPOSE:         IEnumMediaTypes interface
+ *
+ * PROGRAMMERS:     Johannes Anderwald (janderwald@reactos.org)
+ */
+#include "precomp.h"
+
+class CEnumMediaTypes : public IEnumMediaTypes
+{
+public:
+    STDMETHODIMP QueryInterface( REFIID InterfaceId, PVOID* Interface);
+
+    STDMETHODIMP_(ULONG) AddRef()
+    {
+        InterlockedIncrement(&m_Ref);
+        return m_Ref;
+    }
+    STDMETHODIMP_(ULONG) Release()
+    {
+        InterlockedDecrement(&m_Ref);
+        if (!m_Ref)
+        {
+            delete this;
+            return 0;
+        }
+        return m_Ref;
+    }
+
+    HRESULT STDMETHODCALLTYPE Next(ULONG cMediaTypes, AM_MEDIA_TYPE **ppMediaTypes, ULONG *pcFetched);
+    HRESULT STDMETHODCALLTYPE Skip(ULONG cMediaTypes);
+    HRESULT STDMETHODCALLTYPE Reset();
+    HRESULT STDMETHODCALLTYPE Clone(IEnumMediaTypes **ppEnum);
+
+
+    CEnumMediaTypes(ULONG MediaTypeCount, AM_MEDIA_TYPE * MediaTypes) : m_Ref(0), m_MediaTypeCount(MediaTypeCount), m_MediaTypes(MediaTypes), m_Index(0){};
+    virtual ~CEnumMediaTypes(){};
+
+protected:
+    LONG m_Ref;
+    ULONG m_MediaTypeCount;
+    AM_MEDIA_TYPE * m_MediaTypes;
+    ULONG m_Index;
+};
+
+HRESULT
+STDMETHODCALLTYPE
+CEnumMediaTypes::QueryInterface(
+    IN  REFIID refiid,
+    OUT PVOID* Output)
+{
+    if (IsEqualGUID(refiid, IID_IUnknown))
+    {
+        *Output = PVOID(this);
+        reinterpret_cast<IUnknown*>(*Output)->AddRef();
+        return NOERROR;
+    }
+    if (IsEqualGUID(refiid, IID_IEnumMediaTypes))
+    {
+        *Output = (IEnumMediaTypes*)(this);
+        reinterpret_cast<IEnumMediaTypes*>(*Output)->AddRef();
+        return NOERROR;
+    }
+
+    WCHAR Buffer[MAX_PATH];
+    LPOLESTR lpstr;
+    StringFromCLSID(refiid, &lpstr);
+    swprintf(Buffer, L"CEnumMediaTypes::QueryInterface: NoInterface for %s\n", lpstr);
+    OutputDebugStringW(Buffer);
+    CoTaskMemFree(lpstr);
+
+    return E_NOINTERFACE;
+}
+
+//-------------------------------------------------------------------
+// IEnumMediaTypes
+//
+
+HRESULT
+STDMETHODCALLTYPE
+CEnumMediaTypes::Next(
+    ULONG cMediaTypes,
+    AM_MEDIA_TYPE **ppMediaTypes,
+    ULONG *pcFetched)
+{
+    ULONG i = 0;
+    AM_MEDIA_TYPE * MediaType;
+
+    if (!ppMediaTypes)
+        return E_POINTER;
+
+    if (cMediaTypes > 1 && !pcFetched)
+        return E_INVALIDARG;
+
+    while(i < cMediaTypes)
+    {
+        if (m_Index + i >= m_MediaTypeCount)
+            break;
+
+        MediaType = (AM_MEDIA_TYPE*)CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE));
+        if (!MediaType)
+            break;
+
+        CopyMemory(MediaType, &m_MediaTypes[m_Index + i], sizeof(AM_MEDIA_TYPE));
+        ppMediaTypes[i] = MediaType;
+        i++;
+    }
+
+    if (pcFetched)
+    {
+        *pcFetched = i;
+    }
+
+    m_Index += i;
+
+    if (i < cMediaTypes)
+        return S_FALSE;
+    else
+        return S_OK;
+}
+
+HRESULT
+STDMETHODCALLTYPE
+CEnumMediaTypes::Skip(
+    ULONG cMediaTypes)
+{
+    if (cMediaTypes + m_Index >= m_MediaTypeCount)
+    {
+        return S_FALSE;
+    }
+
+    m_Index += cMediaTypes;
+    return S_OK;
+}
+
+HRESULT
+STDMETHODCALLTYPE
+CEnumMediaTypes::Reset()
+{
+    m_Index = 0;
+    return S_OK;
+}
+
+HRESULT
+STDMETHODCALLTYPE
+CEnumMediaTypes::Clone(
+    IEnumMediaTypes **ppEnum)
+{
+    OutputDebugStringW(L"CEnumMediaTypes::Clone : NotImplemented\n");
+    return E_NOTIMPL;
+}
+
+HRESULT
+WINAPI
+CEnumMediaTypes_fnConstructor(
+    ULONG MediaTypeCount,
+    AM_MEDIA_TYPE * MediaTypes,
+    REFIID riid,
+    LPVOID * ppv)
+{
+    CEnumMediaTypes * handler = new CEnumMediaTypes(MediaTypeCount, MediaTypes);
+
+#ifdef KSPROXY_TRACE
+    WCHAR Buffer[MAX_PATH];
+    LPOLESTR lpstr;
+    StringFromCLSID(riid, &lpstr);
+    swprintf(Buffer, L"CEnumMediaTypes_fnConstructor riid %s pUnknown %p\n", lpstr, pUnknown);
+    OutputDebugStringW(Buffer);
+#endif
+
+    if (!handler)
+    {
+        CoTaskMemFree(MediaTypes);
+        return E_OUTOFMEMORY;
+    }
+
+    if (FAILED(handler->QueryInterface(riid, ppv)))
+    {
+        /* not supported */
+        delete handler;
+        return E_NOINTERFACE;
+    }
+
+    return NOERROR;
+}
+

reactos/dll/directx/ksproxy/input_pin.cpp

@@ -8,17 +8,17 @@
  */
 #include "precomp.h"
 
-class CInputPin : public IPin
+class CInputPin : public IPin,
+                  public IKsPropertySet,
+                  public IKsControl,
+                  public IKsObject
 /*
                   public IQualityControl,
-                  public IKsObject,
                   public IKsPinEx,
                   public IKsPinPipe,
                   public ISpecifyPropertyPages,
                   public IStreamBuilder,
-                  public IKsPropertySet,
                   public IKsPinFactory,
-                  public IKsControl,
                   public IKsAggregateControl
 */
 {
@@ -58,13 +58,30 @@ public:
     HRESULT STDMETHODCALLTYPE EndFlush();
     HRESULT STDMETHODCALLTYPE NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate);
 
-    CInputPin(IBaseFilter * ParentFilter, LPCWSTR PinName) : m_Ref(0), m_ParentFilter(ParentFilter), m_PinName(PinName){};
+    //IKsObject methods
+    HANDLE STDMETHODCALLTYPE KsGetObjectHandle();
+
+    //IKsPropertySet
+    HRESULT STDMETHODCALLTYPE Set(REFGUID guidPropSet, DWORD dwPropID, LPVOID pInstanceData, DWORD cbInstanceData, LPVOID pPropData, DWORD cbPropData);
+    HRESULT STDMETHODCALLTYPE Get(REFGUID guidPropSet, DWORD dwPropID, LPVOID pInstanceData, DWORD cbInstanceData, LPVOID pPropData, DWORD cbPropData, DWORD *pcbReturned);
+    HRESULT STDMETHODCALLTYPE QuerySupported(REFGUID guidPropSet, DWORD dwPropID, DWORD *pTypeSupport);
+
+    //IKsControl
+    HRESULT STDMETHODCALLTYPE KsProperty(PKSPROPERTY Property, ULONG PropertyLength, LPVOID PropertyData, ULONG DataLength, ULONG* BytesReturned);
+    HRESULT STDMETHODCALLTYPE KsMethod(PKSMETHOD Method, ULONG MethodLength, LPVOID MethodData, ULONG DataLength, ULONG* BytesReturned);
+    HRESULT STDMETHODCALLTYPE KsEvent(PKSEVENT Event, ULONG EventLength, LPVOID EventData, ULONG DataLength, ULONG* BytesReturned);
+
+    HRESULT STDMETHODCALLTYPE CheckFormat(const AM_MEDIA_TYPE *pmt);
+    CInputPin(IBaseFilter * ParentFilter, LPCWSTR PinName, HANDLE hFilter, ULONG PinId) : m_Ref(0), m_ParentFilter(ParentFilter), m_PinName(PinName), m_hFilter(hFilter), m_hPin(0), m_PinId(PinId){};
     virtual ~CInputPin(){};
 
 protected:
     LONG m_Ref;
     IBaseFilter * m_ParentFilter;
     LPCWSTR m_PinName;
+    HANDLE m_hFilter;
+    HANDLE m_hPin;
+    ULONG m_PinId;
 };
 
 HRESULT
@@ -74,6 +91,7 @@ CInputPin::QueryInterface(
     OUT PVOID* Output)
 {
     *Output = NULL;
+
     if (IsEqualGUID(refiid, IID_IUnknown) ||
         IsEqualGUID(refiid, IID_IPin))
     {
@@ -81,6 +99,42 @@ CInputPin::QueryInterface(
         reinterpret_cast<IUnknown*>(*Output)->AddRef();
         return NOERROR;
     }
+    else if (IsEqualGUID(refiid, IID_IKsObject))
+    {
+        if (!m_hPin)
+        {
+            OutputDebugStringW(L"CInputPin::QueryInterface IID_IKsObject Create PIN!!!\n");
+            DebugBreak();
+        }
+
+        *Output = (IKsObject*)(this);
+        reinterpret_cast<IKsObject*>(*Output)->AddRef();
+        return NOERROR;
+    }
+    else if (IsEqualGUID(refiid, IID_IKsPropertySet))
+    {
+        if (!m_hPin)
+        {
+            OutputDebugStringW(L"CInputPin::QueryInterface IID_IKsPropertySet Create PIN!!!\n");
+            DebugBreak();
+        }
+
+        *Output = (IKsPropertySet*)(this);
+        reinterpret_cast<IKsPropertySet*>(*Output)->AddRef();
+        return NOERROR;
+    }
+    else if (IsEqualGUID(refiid, IID_IKsControl))
+    {
+        if (!m_hPin)
+        {
+            OutputDebugStringW(L"CInputPin::QueryInterface IID_IKsControl Create PIN!!!\n");
+            DebugBreak();
+        }
+
+        *Output = (IKsControl*)(this);
+        reinterpret_cast<IKsControl*>(*Output)->AddRef();
+        return NOERROR;
+    }
 
     WCHAR Buffer[MAX_PATH];
     LPOLESTR lpstr;
@@ -92,6 +146,167 @@ CInputPin::QueryInterface(
     return E_NOINTERFACE;
 }
 
+//-------------------------------------------------------------------
+// IKsPropertySet
+//
+HRESULT
+STDMETHODCALLTYPE
+CInputPin::KsProperty(
+    PKSPROPERTY Property,
+    ULONG PropertyLength,
+    LPVOID PropertyData,
+    ULONG DataLength,
+    ULONG* BytesReturned)
+{
+    return KsSynchronousDeviceControl(m_hPin, IOCTL_KS_PROPERTY, (PVOID)Property, PropertyLength, (PVOID)PropertyData, DataLength, BytesReturned);
+}
+
+HRESULT
+STDMETHODCALLTYPE
+CInputPin::KsMethod(
+    PKSMETHOD Method,
+    ULONG MethodLength,
+    LPVOID MethodData,
+    ULONG DataLength,
+    ULONG* BytesReturned)
+{
+    return KsSynchronousDeviceControl(m_hPin, IOCTL_KS_METHOD, (PVOID)Method, MethodLength, (PVOID)MethodData, DataLength, BytesReturned);
+}
+
+HRESULT
+STDMETHODCALLTYPE
+CInputPin::KsEvent(
+    PKSEVENT Event,
+    ULONG EventLength,
+    LPVOID EventData,
+    ULONG DataLength,
+    ULONG* BytesReturned)
+{
+    if (EventLength)
+        return KsSynchronousDeviceControl(m_hPin, IOCTL_KS_ENABLE_EVENT, (PVOID)Event, EventLength, (PVOID)EventData, DataLength, BytesReturned);
+    else
+        return KsSynchronousDeviceControl(m_hPin, IOCTL_KS_DISABLE_EVENT, (PVOID)Event, EventLength, NULL, 0, BytesReturned);
+}
+
+
+//-------------------------------------------------------------------
+// IKsPropertySet
+//
+HRESULT
+STDMETHODCALLTYPE
+CInputPin::Set(
+    REFGUID guidPropSet,
+    DWORD dwPropID,
+    LPVOID pInstanceData,
+    DWORD cbInstanceData,
+    LPVOID pPropData,
+    DWORD cbPropData)
+{
+    ULONG BytesReturned;
+
+    if (cbInstanceData)
+    {
+        PKSPROPERTY Property = (PKSPROPERTY)CoTaskMemAlloc(sizeof(KSPROPERTY) + cbInstanceData);
+        if (!Property)
+            return E_OUTOFMEMORY;
+
+        Property->Set = guidPropSet;
+        Property->Id = dwPropID;
+        Property->Flags = KSPROPERTY_TYPE_SET;
+
+        CopyMemory((Property+1), pInstanceData, cbInstanceData);
+
+        HRESULT hr = KsProperty(Property, sizeof(KSPROPERTY) + cbInstanceData, pPropData, cbPropData, &BytesReturned);
+        CoTaskMemFree(Property);
+        return hr;
+    }
+    else
+    {
+        KSPROPERTY Property;
+
+        Property.Set = guidPropSet;
+        Property.Id = dwPropID;
+        Property.Flags = KSPROPERTY_TYPE_SET;
+
+        HRESULT hr = KsProperty(&Property, sizeof(KSPROPERTY), pPropData, cbPropData, &BytesReturned);
+        return hr;
+    }
+}
+
+HRESULT
+STDMETHODCALLTYPE
+CInputPin::Get(
+    REFGUID guidPropSet,
+    DWORD dwPropID,
+    LPVOID pInstanceData,
+    DWORD cbInstanceData,
+    LPVOID pPropData,
+    DWORD cbPropData,
+    DWORD *pcbReturned)
+{
+    ULONG BytesReturned;
+
+    if (cbInstanceData)
+    {
+        PKSPROPERTY Property = (PKSPROPERTY)CoTaskMemAlloc(sizeof(KSPROPERTY) + cbInstanceData);
+        if (!Property)
+            return E_OUTOFMEMORY;
+
+        Property->Set = guidPropSet;
+        Property->Id = dwPropID;
+        Property->Flags = KSPROPERTY_TYPE_GET;
+
+        CopyMemory((Property+1), pInstanceData, cbInstanceData);
+
+        HRESULT hr = KsProperty(Property, sizeof(KSPROPERTY) + cbInstanceData, pPropData, cbPropData, &BytesReturned);
+        CoTaskMemFree(Property);
+        return hr;
+    }
+    else
+    {
+        KSPROPERTY Property;
+
+        Property.Set = guidPropSet;
+        Property.Id = dwPropID;
+        Property.Flags = KSPROPERTY_TYPE_GET;
+
+        HRESULT hr = KsProperty(&Property, sizeof(KSPROPERTY), pPropData, cbPropData, &BytesReturned);
+        return hr;
+    }
+}
+
+HRESULT
+STDMETHODCALLTYPE
+CInputPin::QuerySupported(
+    REFGUID guidPropSet,
+    DWORD dwPropID,
+    DWORD *pTypeSupport)
+{
+    KSPROPERTY Property;
+    ULONG BytesReturned;
+
+    Property.Set = guidPropSet;
+    Property.Id = dwPropID;
+    Property.Flags = KSPROPERTY_TYPE_SETSUPPORT;
+
+    return KsProperty(&Property, sizeof(KSPROPERTY), pTypeSupport, sizeof(DWORD), &BytesReturned);
+}
+
+
+//-------------------------------------------------------------------
+// IKsObject
+//
+HANDLE
+STDMETHODCALLTYPE
+CInputPin::KsGetObjectHandle()
+{
+    OutputDebugStringW(L"CInputPin::KsGetObjectHandle CALLED\n");
+
+    //FIXME
+    // return pin handle
+    return m_hPin;
+}
+
 //-------------------------------------------------------------------
 // IPin interface
 //
@@ -99,7 +314,16 @@ HRESULT
 STDMETHODCALLTYPE
 CInputPin::Connect(IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
 {
-    OutputDebugStringW(L"CInputPin::Connect called\n");
+    //MajorFormat: KSDATAFORMAT_TYPE_BDA_ANTENNA
+    //SubType: MEDIASUBTYPE_None
+    //FormatType: FORMAT_None
+    //bFixedSizeSamples 1 bTemporalCompression 0 lSampleSize 1 pUnk 00000000 cbFormat 0 pbFormat 00000000
+
+    //KSPROPSETID_Connection KSPROPERTY_CONNECTION_PROPOSEDATAFORMAT
+    //PriorityClass = KSPRIORITY_NORMAL PrioritySubClass = KSPRIORITY_NORMAL
+
+
+    OutputDebugStringW(L"CInputPin::Connect NotImplemented\n");
     return E_NOTIMPL;
 }
 
@@ -107,28 +331,29 @@ HRESULT
 STDMETHODCALLTYPE
 CInputPin::ReceiveConnection(IPin *pConnector, const AM_MEDIA_TYPE *pmt)
 {
-    OutputDebugStringW(L"CInputPin::ReceiveConnection called\n");
+    OutputDebugStringW(L"CInputPin::ReceiveConnection NotImplemented\n");
     return E_NOTIMPL;
 }
 HRESULT
 STDMETHODCALLTYPE
 CInputPin::Disconnect( void)
 {
-    OutputDebugStringW(L"CInputPin::Disconnect called\n");
+    OutputDebugStringW(L"CInputPin::Disconnect NotImplemented\n");
     return E_NOTIMPL;
 }
 HRESULT
 STDMETHODCALLTYPE
 CInputPin::ConnectedTo(IPin **pPin)
 {
-    OutputDebugStringW(L"CInputPin::ConnectedTo called\n");
+    *pPin = NULL;
+    OutputDebugStringW(L"CInputPin::ConnectedTo NotImplemented\n");
     return VFW_E_NOT_CONNECTED;
 }
 HRESULT
 STDMETHODCALLTYPE
 CInputPin::ConnectionMediaType(AM_MEDIA_TYPE *pmt)
 {
-    OutputDebugStringW(L"CInputPin::ConnectionMediaType called\n");
+    OutputDebugStringW(L"CInputPin::ConnectionMediaType NotImplemented\n");
     return E_NOTIMPL;
 }
 HRESULT
@@ -165,53 +390,112 @@ CInputPin::QueryId(LPWSTR *Id)
     wcscpy(*Id, m_PinName);
     return S_OK;
 }
+
 HRESULT
 STDMETHODCALLTYPE
-CInputPin::QueryAccept(const AM_MEDIA_TYPE *pmt)
+CInputPin::CheckFormat(
+    const AM_MEDIA_TYPE *pmt)
 {
-    OutputDebugStringW(L"CInputPin::QueryAccept called\n");
+    KSP_PIN Property;
-    return E_NOTIMPL;
+    PKSMULTIPLE_ITEM MultipleItem;
+    PKSDATAFORMAT DataFormat;
+    ULONG BytesReturned;
+    HRESULT hr;
+
+    // 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;
+
+    // query for size of dataranges
+    hr = KsSynchronousDeviceControl(m_hFilter, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSP_PIN), NULL, 0, &BytesReturned);
+
+    if (hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_MORE_DATA))
+    {
+        // allocate dataranges buffer
+        MultipleItem = (PKSMULTIPLE_ITEM)CoTaskMemAlloc(BytesReturned);
+
+        if (!MultipleItem)
+            return E_OUTOFMEMORY;
+
+        // query dataranges
+        hr = KsSynchronousDeviceControl(m_hFilter, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSP_PIN), (PVOID)MultipleItem, BytesReturned, &BytesReturned);
+
+        if (FAILED(hr))
+        {
+            // failed to query data ranges
+            CoTaskMemFree(MultipleItem);
+            return hr;
+        }
+
+        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))
+            {
+                // format is supported
+                CoTaskMemFree(MultipleItem);
+                OutputDebugStringW(L"CInputPin::CheckFormat format OK\n");
+                return S_OK;
+            }
+            DataFormat = (PKSDATAFORMAT)((ULONG_PTR)DataFormat + DataFormat->FormatSize);
+        }
+        //format is not supported
+        CoTaskMemFree(MultipleItem);
+    }
+    return S_FALSE;
+}
+
+HRESULT
+STDMETHODCALLTYPE
+CInputPin::QueryAccept(
+    const AM_MEDIA_TYPE *pmt)
+{
+    return CheckFormat(pmt);
 }
 HRESULT
 STDMETHODCALLTYPE
 CInputPin::EnumMediaTypes(IEnumMediaTypes **ppEnum)
 {
-    OutputDebugStringW(L"CInputPin::EnumMediaTypes called\n");
+    return CEnumMediaTypes_fnConstructor(0, NULL, IID_IEnumMediaTypes, (void**)ppEnum);
-    return E_NOTIMPL;
 }
 HRESULT
 STDMETHODCALLTYPE
 CInputPin::QueryInternalConnections(IPin **apPin, ULONG *nPin)
 {
-    OutputDebugStringW(L"CInputPin::QueryInternalConnections called\n");
+    OutputDebugStringW(L"CInputPin::QueryInternalConnections NotImplemented\n");
     return E_NOTIMPL;
 }
 HRESULT
 STDMETHODCALLTYPE
 CInputPin::EndOfStream( void)
 {
-    OutputDebugStringW(L"CInputPin::EndOfStream called\n");
+    OutputDebugStringW(L"CInputPin::EndOfStream NotImplemented\n");
     return E_NOTIMPL;
 }
 HRESULT
 STDMETHODCALLTYPE
 CInputPin::BeginFlush( void)
 {
-    OutputDebugStringW(L"CInputPin::BeginFlush called\n");
+    OutputDebugStringW(L"CInputPin::BeginFlush NotImplemented\n");
     return E_NOTIMPL;
 }
 HRESULT
 STDMETHODCALLTYPE
 CInputPin::EndFlush( void)
 {
-    OutputDebugStringW(L"CInputPin::EndFlush called\n");
+    OutputDebugStringW(L"CInputPin::EndFlush NotImplemented\n");
     return E_NOTIMPL;
 }
 HRESULT
 STDMETHODCALLTYPE
 CInputPin::NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
 {
-    OutputDebugStringW(L"CInputPin::NewSegment called\n");
+    OutputDebugStringW(L"CInputPin::NewSegment NotImplemented\n");
     return E_NOTIMPL;
 }
 
@@ -220,10 +504,12 @@ WINAPI
 CInputPin_Constructor(
     IBaseFilter * ParentFilter,
     LPCWSTR PinName,
+    HANDLE hFilter,
+    ULONG PinId,
     REFIID riid,
     LPVOID * ppv)
 {
-    CInputPin * handler = new CInputPin(ParentFilter, PinName);
+    CInputPin * handler = new CInputPin(ParentFilter, PinName, hFilter, PinId);
 
     if (!handler)
         return E_OUTOFMEMORY;

reactos/dll/directx/ksproxy/ksproxy.rbuild

@@ -26,6 +26,7 @@
 	<file>cvpconfig.cpp</file>
 	<file>cvpvbiconfig.cpp</file>
 	<file>datatype.cpp</file>
+	<file>enum_mediatypes.cpp</file>
 	<file>enumpins.cpp</file>
 	<file>input_pin.cpp</file>
 	<file>interface.cpp</file>

reactos/dll/directx/ksproxy/precomp.h

@@ -16,6 +16,7 @@
 #include <vptype.h>
 #include <vpconfig.h>
 #include <setupapi.h>
+#include <stdio.h>
 #include <vector>
 //#include <debug.h>
 
@@ -104,6 +105,8 @@ WINAPI
 CInputPin_Constructor(
     IBaseFilter * ParentFilter,
     LPCWSTR PinName,
+    HANDLE hFilter,
+    ULONG PinId,
     REFIID riid,
     LPVOID * ppv);
 
@@ -122,5 +125,15 @@ WINAPI
 CEnumPins_fnConstructor(
     std::vector<IPin*> Pins,
     REFIID riid,
-    LPVOID * ppv)
+    LPVOID * ppv);
-;
+
+/* enum_mediatypes.cpp */
+HRESULT
+WINAPI
+CEnumMediaTypes_fnConstructor(
+    ULONG MediaTypeCount,
+    AM_MEDIA_TYPE * MediaTypes,
+    REFIID riid,
+    LPVOID * ppv);
+
+

reactos/dll/directx/ksproxy/proxy.cpp

@@ -10,7 +10,7 @@
 
 const GUID IID_IPersistPropertyBag = {0x37D84F60, 0x42CB, 0x11CE, {0x81, 0x35, 0x00, 0xAA, 0x00, 0x4B, 0xB8, 0x51}};
 const GUID GUID_NULL                     = {0x00000000L, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}};
-
+const GUID IID_IBDA_DeviceControl = {0xFD0A5AF3, 0xB41D, 0x11d2, {0x9C, 0x95, 0x00, 0xC0, 0x4F, 0x79, 0x71, 0xE0}};
 /*
     Needs IKsClock, IKsNotifyEvent
 */
@@ -134,6 +134,24 @@ CKsProxy::QueryInterface(
         return NOERROR;
     }
 
+    for(ULONG Index = 0; Index < m_Plugins.size(); Index++)
+    {
+        if (m_Pins[Index])
+        {
+            HRESULT hr = m_Plugins[Index]->QueryInterface(refiid, Output);
+            if (SUCCEEDED(hr))
+            {
+                WCHAR Buffer[100];
+                LPOLESTR lpstr;
+                StringFromCLSID(refiid, &lpstr);
+                swprintf(Buffer, L"CKsProxy::QueryInterface plugin %lu supports interface %s\n", Index, lpstr);
+                OutputDebugStringW(Buffer);
+                CoTaskMemFree(lpstr);
+                return hr;
+            }
+        }
+    }
+
     WCHAR Buffer[MAX_PATH];
     LPOLESTR lpstr;
     StringFromCLSID(refiid, &lpstr);
@@ -469,7 +487,7 @@ CKsProxy::CreatePins()
         // construct the pins
         if (DataFlow == KSPIN_DATAFLOW_IN)
         {
-            hr = CInputPin_Constructor((IBaseFilter*)this, PinName, IID_IPin, (void**)&pPin);
+            hr = CInputPin_Constructor((IBaseFilter*)this, PinName, m_hDevice, Index, IID_IPin, (void**)&pPin);
             if (FAILED(hr))
             {
                 CoTaskMemFree(PinName);
@@ -555,11 +573,6 @@ CKsProxy::Load(IPropertyBag *pPropBag, IErrorLog *pErrorLog)
     // now create the input / output pins
     hr = CreatePins();
 
-
-    CloseHandle(m_hDevice);
-    m_hDevice = NULL;
-
-
     return hr;
 }
 
@@ -657,7 +670,6 @@ STDMETHODCALLTYPE
 CKsProxy::EnumPins(
     IEnumPins **ppEnum)
 {
-    OutputDebugStringW(L"CKsProxy::EnumPins\n");
     return CEnumPins_fnConstructor(m_Pins, IID_IEnumPins, (void**)ppEnum);
 }
 
@@ -666,8 +678,31 @@ STDMETHODCALLTYPE
 CKsProxy::FindPin(
     LPCWSTR Id, IPin **ppPin)
 {
-    OutputDebugStringW(L"CKsProxy::FindPin : NotImplemented\n");
+    ULONG PinId;
-    return E_NOTIMPL;
+
+    if (!ppPin)
+        return E_POINTER;
+
+    // convert to pin
+    int ret = swscanf(Id, L"%u", &PinId);
+
+    if (!ret || ret == EOF)
+    {
+        // invalid id
+        return VFW_E_NOT_FOUND;
+    }
+
+    if (PinId >= m_Pins.size() || m_Pins[PinId] == NULL)
+    {
+        // invalid id
+        return VFW_E_NOT_FOUND;
+    }
+
+    // found pin
+    *ppPin = m_Pins[PinId];
+    m_Pins[PinId]->AddRef();
+
+    return S_OK;
 }
 
 
@@ -702,7 +737,6 @@ CKsProxy::JoinFilterGraph(
         m_pGraph = 0;
     }
 
-    OutputDebugStringW(L"CKsProxy::JoinFilterGraph\n");
     return S_OK;
 }
 

reactos/dll/directx/msdvbnp/pin.cpp

@@ -184,7 +184,7 @@ CPin::EnumMediaTypes(IEnumMediaTypes **ppEnum)
 
     MediaType->majortype = KSDATAFORMAT_TYPE_BDA_ANTENNA;
     MediaType->subtype = MEDIASUBTYPE_None;
-    MediaType->formattype = GUID_NULL;
+    MediaType->formattype = FORMAT_None;
     MediaType->bFixedSizeSamples = true;
     MediaType->bTemporalCompression = false;
     MediaType->lSampleSize = sizeof(CHAR);