/*
* 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}};
-#endif
-#ifndef _MSC_VER
KSPIN_INTERFACE StandardPinInterface =
{
{STATIC_KSINTERFACESETID_Standard},
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);
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);
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();
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(const AM_MEDIA_TYPE *pmt);
HRESULT STDMETHODCALLTYPE CreatePinHandle(PKSPIN_MEDIUM Medium, PKSPIN_INTERFACE Interface, const AM_MEDIA_TYPE *pmt);
- 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(INVALID_HANDLE_VALUE), m_PinId(PinId), m_MemAllocator(0), m_IoCount(0), m_Communication(Communication), m_Pin(0), m_ReadOnly(0){};
+ 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;
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) ||
}
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_IKsPropertySet))
{
+ if (m_hPin == INVALID_HANDLE_VALUE)
+ {
+ HRESULT hr = CreatePin(&m_MediaFormat);
+ if (FAILED(hr))
+ return hr;
+ }
+
*Output = (IKsPropertySet*)(this);
reinterpret_cast<IKsPropertySet*>(*Output)->AddRef();
return NOERROR;
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);
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
STDMETHODCALLTYPE
CInputPin::GetAllocator(IMemAllocator **ppAllocator)
{
+#ifdef KSPROXY_TRACE
OutputDebugStringW(L"CInputPin::GetAllocator\n");
+#endif
+
return VFW_E_NO_ALLOCATOR;
}
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();
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;
}
STDMETHODCALLTYPE
CInputPin::ReceiveMultiple(IMediaSample **pSamples, long nSamples, long *nSamplesProcessed)
{
+#ifdef KSPROXY_TRACE
OutputDebugStringW(L"CInputPin::ReceiveMultiple NotImplemented\n");
+ DebugBreak();
+#endif
+
return E_NOTIMPL;
}
STDMETHODCALLTYPE
CInputPin::ReceiveCanBlock( void)
{
+#ifdef KSPROXY_TRACE
OutputDebugStringW(L"CInputPin::ReceiveCanBlock NotImplemented\n");
+ DebugBreak();
+#endif
+
return S_FALSE;
}
-
//-------------------------------------------------------------------
// IKsPin
//
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
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
KSPIN_INTERFACE& Interface,
KSPIN_MEDIUM& Medium)
{
- OutputDebugStringW(L"CInputPin::KsCreateSinkPinHandle NotImplemented\n");
- return E_NOTIMPL;
+ return CreatePin(&m_MediaFormat);
}
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
STDMETHODCALLTYPE
CInputPin::KsReceiveAllocator(IMemAllocator *MemAllocator)
{
+
if (MemAllocator)
{
MemAllocator->AddRef();
ULONG Proportion,
REFERENCE_TIME TimeDelta)
{
+#ifdef KSPROXY_TRACE
OutputDebugStringW(L"CInputPin::KsQualityNotify NotImplemented\n");
+#endif
+
+ DebugBreak();
return E_NOTIMPL;
}
IMediaSample* Sample,
HRESULT hr)
{
+#ifdef KSPROXY_TRACE
OutputDebugStringW(L"CInputPin::KsNotifyError NotImplemented\n");
+#endif
}
ULONG DataLength,
ULONG* BytesReturned)
{
- assert(m_hPin != 0);
+ assert(m_hPin != INVALID_HANDLE_VALUE);
return KsSynchronousDeviceControl(m_hPin, IOCTL_KS_PROPERTY, (PVOID)Property, PropertyLength, (PVOID)PropertyData, DataLength, BytesReturned);
}
ULONG DataLength,
ULONG* BytesReturned)
{
- assert(m_hPin != 0);
+ assert(m_hPin != INVALID_HANDLE_VALUE);
return KsSynchronousDeviceControl(m_hPin, IOCTL_KS_METHOD, (PVOID)Method, MethodLength, (PVOID)MethodData, DataLength, BytesReturned);
}
ULONG DataLength,
ULONG* BytesReturned)
{
- assert(m_hPin != 0);
+ assert(m_hPin != INVALID_HANDLE_VALUE);
if (EventLength)
return KsSynchronousDeviceControl(m_hPin, IOCTL_KS_ENABLE_EVENT, (PVOID)Event, EventLength, (PVOID)EventData, DataLength, BytesReturned);
STDMETHODCALLTYPE
CInputPin::Connect(IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
{
+#ifdef KSPROXY_TRACE
OutputDebugStringW(L"CInputPin::Connect NotImplemented\n");
+ DebugBreak();
+#endif
return NOERROR;
}
if (m_Pin)
{
+ // 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)))
- return hr;
+ }
hr = CreatePin(pmt);
if (FAILED(hr))
return hr;
}
- //FIXME create pin
- m_Pin = pConnector;
- m_Pin->AddRef();
+ m_Pin = pConnector;
+ m_Pin->AddRef();
return S_OK;
}
m_Pin->Release();
m_Pin = NULL;
+#ifdef KSPROXY_TRACE
OutputDebugStringW(L"CInputPin::Disconnect\n");
+#endif
+
return S_OK;
}
HRESULT
if (!m_Pin)
return VFW_E_NOT_CONNECTED;
+#ifdef KSPROXY_TRACE
OutputDebugStringW(L"CInputPin::ConnectionMediaType NotImplemented\n");
+ DebugBreak();
+#endif
+
return E_NOTIMPL;
}
HRESULT
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(m_hFilter, m_PinId, &MediaTypeCount);
+ hr = KsGetMediaTypeCount(hFilter, m_PinId, &MediaTypeCount);
if (FAILED(hr) || !MediaTypeCount)
return hr;
for(Index = 0; Index < MediaTypeCount; Index++)
{
// get media type
- hr = KsGetMediaType(Index, &MediaTypes[Index], m_hFilter, m_PinId);
+ hr = KsGetMediaType(Index, &MediaTypes[Index], hFilter, m_PinId);
if (FAILED(hr))
{
// failed
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;
-
- // 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;
+ IKsObject * KsObjectParent;
+ HANDLE hFilter;
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;
}
PKSMULTIPLE_ITEM InterfaceList;
PKSPIN_MEDIUM Medium;
PKSPIN_INTERFACE Interface;
+ IKsInterfaceHandler * InterfaceHandler;
HRESULT hr;
// query for pin medium
Interface = &StandardPinInterface;
}
- // now create pin
- hr = CreatePinHandle(Medium, Interface, pmt);
+ 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);
+
+ 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(MediumList);
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) + sizeof(KSDATAFORMAT) + 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);
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;
projects / reactos.git / blobdiff