mirror of
https://github.com/reactos/reactos.git
synced 2024-10-31 03:48:17 +00:00
2823 lines
72 KiB
C++
2823 lines
72 KiB
C++
/*
|
|
* COPYRIGHT: See COPYING in the top level directory
|
|
* PROJECT: ReactOS WDM Streaming ActiveMovie Proxy
|
|
* FILE: dll/directx/ksproxy/output_pin.cpp
|
|
* PURPOSE: OutputPin of Proxy Filter
|
|
*
|
|
* PROGRAMMERS: Johannes Anderwald (johannes.anderwald@reactos.org)
|
|
*/
|
|
#include "precomp.h"
|
|
|
|
class COutputPin : public IPin,
|
|
public IKsObject,
|
|
public IKsPropertySet,
|
|
public IStreamBuilder,
|
|
public IKsPinFactory,
|
|
public ISpecifyPropertyPages,
|
|
public IKsPinEx,
|
|
public IKsPinPipe,
|
|
public IKsControl,
|
|
public IKsAggregateControl,
|
|
public IQualityControl,
|
|
public IMediaSeeking,
|
|
public IAMBufferNegotiation,
|
|
public IAMStreamConfig,
|
|
public IMemAllocatorNotifyCallbackTemp
|
|
|
|
{
|
|
public:
|
|
typedef std::vector<IUnknown *>ProxyPluginVector;
|
|
|
|
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;
|
|
}
|
|
|
|
//IKsPin
|
|
HRESULT STDMETHODCALLTYPE KsQueryMediums(PKSMULTIPLE_ITEM* MediumList);
|
|
HRESULT STDMETHODCALLTYPE KsQueryInterfaces(PKSMULTIPLE_ITEM* InterfaceList);
|
|
HRESULT STDMETHODCALLTYPE KsCreateSinkPinHandle(KSPIN_INTERFACE& Interface, KSPIN_MEDIUM& Medium);
|
|
HRESULT STDMETHODCALLTYPE KsGetCurrentCommunication(KSPIN_COMMUNICATION *Communication, KSPIN_INTERFACE *Interface, KSPIN_MEDIUM *Medium);
|
|
HRESULT STDMETHODCALLTYPE KsPropagateAcquire();
|
|
HRESULT STDMETHODCALLTYPE KsDeliver(IMediaSample* Sample, ULONG Flags);
|
|
HRESULT STDMETHODCALLTYPE KsMediaSamplesCompleted(PKSSTREAM_SEGMENT StreamSegment);
|
|
IMemAllocator * STDMETHODCALLTYPE KsPeekAllocator(KSPEEKOPERATION Operation);
|
|
HRESULT STDMETHODCALLTYPE KsReceiveAllocator(IMemAllocator *MemAllocator);
|
|
HRESULT STDMETHODCALLTYPE KsRenegotiateAllocator();
|
|
LONG STDMETHODCALLTYPE KsIncrementPendingIoCount();
|
|
LONG STDMETHODCALLTYPE KsDecrementPendingIoCount();
|
|
HRESULT STDMETHODCALLTYPE KsQualityNotify(ULONG Proportion, REFERENCE_TIME TimeDelta);
|
|
// IKsPinEx
|
|
VOID STDMETHODCALLTYPE KsNotifyError(IMediaSample* Sample, HRESULT hr);
|
|
|
|
//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 Disconnect();
|
|
HRESULT STDMETHODCALLTYPE ConnectedTo(IPin **pPin);
|
|
HRESULT STDMETHODCALLTYPE ConnectionMediaType(AM_MEDIA_TYPE *pmt);
|
|
HRESULT STDMETHODCALLTYPE QueryPinInfo(PIN_INFO *pInfo);
|
|
HRESULT STDMETHODCALLTYPE QueryDirection(PIN_DIRECTION *pPinDir);
|
|
HRESULT STDMETHODCALLTYPE QueryId(LPWSTR *Id);
|
|
HRESULT STDMETHODCALLTYPE QueryAccept(const AM_MEDIA_TYPE *pmt);
|
|
HRESULT STDMETHODCALLTYPE EnumMediaTypes(IEnumMediaTypes **ppEnum);
|
|
HRESULT STDMETHODCALLTYPE QueryInternalConnections(IPin **apPin, ULONG *nPin);
|
|
HRESULT STDMETHODCALLTYPE EndOfStream();
|
|
HRESULT STDMETHODCALLTYPE BeginFlush();
|
|
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();
|
|
|
|
//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);
|
|
|
|
//IStreamBuilder
|
|
HRESULT STDMETHODCALLTYPE Render(IPin *ppinOut, IGraphBuilder *pGraph);
|
|
HRESULT STDMETHODCALLTYPE Backout(IPin *ppinOut, IGraphBuilder *pGraph);
|
|
|
|
//IKsPinFactory
|
|
HRESULT STDMETHODCALLTYPE KsPinFactory(ULONG* PinFactory);
|
|
|
|
//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);
|
|
|
|
//IMediaSeeking
|
|
HRESULT STDMETHODCALLTYPE GetCapabilities(DWORD *pCapabilities);
|
|
HRESULT STDMETHODCALLTYPE CheckCapabilities(DWORD *pCapabilities);
|
|
HRESULT STDMETHODCALLTYPE IsFormatSupported(const GUID *pFormat);
|
|
HRESULT STDMETHODCALLTYPE QueryPreferredFormat(GUID *pFormat);
|
|
HRESULT STDMETHODCALLTYPE GetTimeFormat(GUID *pFormat);
|
|
HRESULT STDMETHODCALLTYPE IsUsingTimeFormat(const GUID *pFormat);
|
|
HRESULT STDMETHODCALLTYPE SetTimeFormat(const GUID *pFormat);
|
|
HRESULT STDMETHODCALLTYPE GetDuration(LONGLONG *pDuration);
|
|
HRESULT STDMETHODCALLTYPE GetStopPosition(LONGLONG *pStop);
|
|
HRESULT STDMETHODCALLTYPE GetCurrentPosition(LONGLONG *pCurrent);
|
|
HRESULT STDMETHODCALLTYPE ConvertTimeFormat(LONGLONG *pTarget, const GUID *pTargetFormat, LONGLONG Source, const GUID *pSourceFormat);
|
|
HRESULT STDMETHODCALLTYPE SetPositions(LONGLONG *pCurrent, DWORD dwCurrentFlags, LONGLONG *pStop, DWORD dwStopFlags);
|
|
HRESULT STDMETHODCALLTYPE GetPositions(LONGLONG *pCurrent, LONGLONG *pStop);
|
|
HRESULT STDMETHODCALLTYPE GetAvailable(LONGLONG *pEarliest, LONGLONG *pLatest);
|
|
HRESULT STDMETHODCALLTYPE SetRate(double dRate);
|
|
HRESULT STDMETHODCALLTYPE GetRate(double *pdRate);
|
|
HRESULT STDMETHODCALLTYPE GetPreroll(LONGLONG *pllPreroll);
|
|
|
|
//IAMBufferNegotiation
|
|
HRESULT STDMETHODCALLTYPE SuggestAllocatorProperties(const ALLOCATOR_PROPERTIES *pprop);
|
|
HRESULT STDMETHODCALLTYPE GetAllocatorProperties(ALLOCATOR_PROPERTIES *pprop);
|
|
|
|
//IAMStreamConfig
|
|
HRESULT STDMETHODCALLTYPE SetFormat(AM_MEDIA_TYPE *pmt);
|
|
HRESULT STDMETHODCALLTYPE GetFormat(AM_MEDIA_TYPE **ppmt);
|
|
HRESULT STDMETHODCALLTYPE GetNumberOfCapabilities(int *piCount, int *piSize);
|
|
HRESULT STDMETHODCALLTYPE GetStreamCaps(int iIndex, AM_MEDIA_TYPE **ppmt, BYTE *pSCC);
|
|
|
|
//IMemAllocatorNotifyCallbackTemp
|
|
HRESULT STDMETHODCALLTYPE NotifyRelease();
|
|
|
|
//---------------------------------------------------------------
|
|
COutputPin(IBaseFilter * ParentFilter, LPCWSTR PinName, ULONG PinId, KSPIN_COMMUNICATION Communication);
|
|
virtual ~COutputPin();
|
|
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);
|
|
HRESULT WINAPI IoProcessRoutine();
|
|
HRESULT WINAPI InitializeIOThread();
|
|
HRESULT STDMETHODCALLTYPE GetSupportedSets(LPGUID * pOutGuid, PULONG NumGuids);
|
|
HRESULT STDMETHODCALLTYPE LoadProxyPlugins(LPGUID pGuids, ULONG NumGuids);
|
|
|
|
friend DWORD WINAPI COutputPin_IoThreadStartup(LPVOID lpParameter);
|
|
friend HRESULT STDMETHODCALLTYPE COutputPin_SetState(IPin * Pin, KSSTATE State);
|
|
|
|
protected:
|
|
LONG m_Ref;
|
|
IBaseFilter * m_ParentFilter;
|
|
LPCWSTR m_PinName;
|
|
HANDLE m_hPin;
|
|
ULONG m_PinId;
|
|
IPin * m_Pin;
|
|
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];
|
|
|
|
IMemAllocator * m_MemAllocator;
|
|
IMemInputPin * m_MemInputPin;
|
|
LONG m_IoCount;
|
|
KSPIN_COMMUNICATION m_Communication;
|
|
KSPIN_INTERFACE m_Interface;
|
|
KSPIN_MEDIUM m_Medium;
|
|
AM_MEDIA_TYPE m_MediaFormat;
|
|
ALLOCATOR_PROPERTIES m_Properties;
|
|
IKsInterfaceHandler * m_InterfaceHandler;
|
|
|
|
HANDLE m_hStartEvent;
|
|
HANDLE m_hBufferAvailable;
|
|
HANDLE m_hStopEvent;
|
|
BOOL m_StopInProgress;
|
|
BOOL m_IoThreadStarted;
|
|
|
|
KSSTATE m_State;
|
|
CRITICAL_SECTION m_Lock;
|
|
|
|
ProxyPluginVector m_Plugins;
|
|
};
|
|
|
|
COutputPin::~COutputPin()
|
|
{
|
|
}
|
|
|
|
COutputPin::COutputPin(
|
|
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_Pin(0),
|
|
m_KsAllocatorEx(0),
|
|
m_PipeAllocatorFlag(0),
|
|
m_bPinBusCacheInitialized(0),
|
|
m_FilterName(0),
|
|
m_MemAllocator(0),
|
|
m_MemInputPin(0),
|
|
m_IoCount(0),
|
|
m_Communication(Communication),
|
|
m_InterfaceHandler(0),
|
|
m_hStartEvent(0),
|
|
m_hBufferAvailable(0),
|
|
m_hStopEvent(0),
|
|
m_StopInProgress(0),
|
|
m_IoThreadStarted(0),
|
|
m_State(KSSTATE_STOP),
|
|
m_Plugins()
|
|
{
|
|
HRESULT hr;
|
|
IKsObject * KsObjectParent;
|
|
|
|
hr = m_ParentFilter->QueryInterface(IID_IKsObject, (LPVOID*)&KsObjectParent);
|
|
assert(hr == S_OK);
|
|
|
|
ZeroMemory(m_FramingProp, sizeof(m_FramingProp));
|
|
ZeroMemory(m_FramingEx, sizeof(m_FramingEx));
|
|
ZeroMemory(&m_MediaFormat, sizeof(AM_MEDIA_TYPE));
|
|
|
|
hr = KsGetMediaType(0, &m_MediaFormat, KsObjectParent->KsGetObjectHandle(), m_PinId);
|
|
|
|
#ifdef KSPROXY_TRACE
|
|
WCHAR Buffer[100];
|
|
swprintf(Buffer, L"COutputPin::COutputPin Format %p pbFormat %lu\n", &m_MediaFormat, m_MediaFormat.cbFormat);
|
|
OutputDebugStringW(Buffer);
|
|
#endif
|
|
|
|
assert(hr == S_OK);
|
|
|
|
InitializeCriticalSection(&m_Lock);
|
|
|
|
KsObjectParent->Release();
|
|
};
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::QueryInterface(
|
|
IN REFIID refiid,
|
|
OUT PVOID* Output)
|
|
{
|
|
*Output = NULL;
|
|
if (IsEqualGUID(refiid, IID_IUnknown) ||
|
|
IsEqualGUID(refiid, IID_IPin))
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::QueryInterface IID_IPin\n");
|
|
#endif
|
|
*Output = PVOID(this);
|
|
reinterpret_cast<IUnknown*>(*Output)->AddRef();
|
|
return NOERROR;
|
|
}
|
|
else if (IsEqualGUID(refiid, IID_IKsObject))
|
|
{
|
|
if (m_hPin == INVALID_HANDLE_VALUE)
|
|
{
|
|
HRESULT hr = CreatePin(&m_MediaFormat);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
}
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::QueryInterface IID_IKsObject\n");
|
|
#endif
|
|
*Output = (IKsObject*)(this);
|
|
reinterpret_cast<IKsObject*>(*Output)->AddRef();
|
|
return NOERROR;
|
|
}
|
|
else if (IsEqualGUID(refiid, IID_IKsPin) || IsEqualGUID(refiid, IID_IKsPinEx))
|
|
{
|
|
*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_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_IKsPropertySet))
|
|
{
|
|
if (m_hPin == INVALID_HANDLE_VALUE)
|
|
{
|
|
HRESULT hr = CreatePin(&m_MediaFormat);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
}
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::QueryInterface IID_IKsPropertySet\n");
|
|
#endif
|
|
*Output = (IKsPropertySet*)(this);
|
|
reinterpret_cast<IKsPropertySet*>(*Output)->AddRef();
|
|
return NOERROR;
|
|
}
|
|
else if (IsEqualGUID(refiid, IID_IKsControl))
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::QueryInterface IID_IKsControl\n");
|
|
#endif
|
|
*Output = (IKsControl*)(this);
|
|
reinterpret_cast<IKsControl*>(*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_IKsPinFactory))
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::QueryInterface IID_IKsPinFactory\n");
|
|
#endif
|
|
*Output = (IKsPinFactory*)(this);
|
|
reinterpret_cast<IKsPinFactory*>(*Output)->AddRef();
|
|
return NOERROR;
|
|
}
|
|
else if (IsEqualGUID(refiid, IID_ISpecifyPropertyPages))
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::QueryInterface IID_ISpecifyPropertyPages\n");
|
|
#endif
|
|
*Output = (ISpecifyPropertyPages*)(this);
|
|
reinterpret_cast<ISpecifyPropertyPages*>(*Output)->AddRef();
|
|
return NOERROR;
|
|
}
|
|
else if (IsEqualGUID(refiid, IID_IMediaSeeking))
|
|
{
|
|
*Output = (IMediaSeeking*)(this);
|
|
reinterpret_cast<IMediaSeeking*>(*Output)->AddRef();
|
|
return NOERROR;
|
|
}
|
|
else if (IsEqualGUID(refiid, IID_IAMBufferNegotiation))
|
|
{
|
|
*Output = (IAMBufferNegotiation*)(this);
|
|
reinterpret_cast<IAMBufferNegotiation*>(*Output)->AddRef();
|
|
return NOERROR;
|
|
}
|
|
else if (IsEqualGUID(refiid, IID_IAMStreamConfig))
|
|
{
|
|
*Output = (IAMStreamConfig*)(this);
|
|
reinterpret_cast<IAMStreamConfig*>(*Output)->AddRef();
|
|
return NOERROR;
|
|
}
|
|
else if (IsEqualGUID(refiid, IID_IMemAllocatorNotifyCallbackTemp))
|
|
{
|
|
*Output = (IMemAllocatorNotifyCallbackTemp*)(this);
|
|
reinterpret_cast<IMemAllocatorNotifyCallbackTemp*>(*Output)->AddRef();
|
|
return NOERROR;
|
|
}
|
|
|
|
#ifdef KSPROXY_TRACE
|
|
WCHAR Buffer[MAX_PATH];
|
|
LPOLESTR lpstr;
|
|
StringFromCLSID(refiid, &lpstr);
|
|
swprintf(Buffer, L"COutputPin::QueryInterface: NoInterface for %s PinId %u PinName %s\n", lpstr, m_PinId, m_PinName);
|
|
OutputDebugStringW(Buffer);
|
|
CoTaskMemFree(lpstr);
|
|
#endif
|
|
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// IAMBufferNegotiation interface
|
|
//
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::SuggestAllocatorProperties(
|
|
const ALLOCATOR_PROPERTIES *pprop)
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::SuggestAllocatorProperties\n");
|
|
#endif
|
|
|
|
if (m_Pin)
|
|
{
|
|
// pin is already connected
|
|
return VFW_E_ALREADY_CONNECTED;
|
|
}
|
|
|
|
CopyMemory(&m_Properties, pprop, sizeof(ALLOCATOR_PROPERTIES));
|
|
return NOERROR;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::GetAllocatorProperties(
|
|
ALLOCATOR_PROPERTIES *pprop)
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::GetAllocatorProperties\n");
|
|
#endif
|
|
|
|
if (!m_Pin)
|
|
{
|
|
// you should call this method AFTER you connected
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
if (!m_KsAllocatorEx)
|
|
{
|
|
// something went wrong while creating the allocator
|
|
return E_FAIL;
|
|
}
|
|
|
|
CopyMemory(pprop, &m_Properties, sizeof(ALLOCATOR_PROPERTIES));
|
|
return NOERROR;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// IAMStreamConfig interface
|
|
//
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::SetFormat(
|
|
AM_MEDIA_TYPE *pmt)
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::SetFormat NotImplemented\n");
|
|
#endif
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::GetFormat(AM_MEDIA_TYPE **ppmt)
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::GetFormat NotImplemented\n");
|
|
#endif
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::GetNumberOfCapabilities(
|
|
int *piCount,
|
|
int *piSize)
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::GetNumberOfCapabilities NotImplemented\n");
|
|
#endif
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::GetStreamCaps(
|
|
int iIndex,
|
|
AM_MEDIA_TYPE **ppmt,
|
|
BYTE *pSCC)
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::GetStreamCaps NotImplemented\n");
|
|
#endif
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// IMemAllocatorNotifyCallbackTemp interface
|
|
//
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::NotifyRelease()
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::NotifyRelease\n");
|
|
#endif
|
|
|
|
// notify thread of new available sample
|
|
SetEvent(m_hBufferAvailable);
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// IMediaSeeking interface
|
|
//
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::GetCapabilities(
|
|
DWORD *pCapabilities)
|
|
{
|
|
IMediaSeeking * FilterMediaSeeking;
|
|
HRESULT hr;
|
|
|
|
hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = FilterMediaSeeking->GetCapabilities(pCapabilities);
|
|
|
|
FilterMediaSeeking->Release();
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::CheckCapabilities(
|
|
DWORD *pCapabilities)
|
|
{
|
|
IMediaSeeking * FilterMediaSeeking;
|
|
HRESULT hr;
|
|
|
|
hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = FilterMediaSeeking->CheckCapabilities(pCapabilities);
|
|
|
|
FilterMediaSeeking->Release();
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::IsFormatSupported(
|
|
const GUID *pFormat)
|
|
{
|
|
IMediaSeeking * FilterMediaSeeking;
|
|
HRESULT hr;
|
|
|
|
hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = FilterMediaSeeking->IsFormatSupported(pFormat);
|
|
|
|
FilterMediaSeeking->Release();
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::QueryPreferredFormat(
|
|
GUID *pFormat)
|
|
{
|
|
IMediaSeeking * FilterMediaSeeking;
|
|
HRESULT hr;
|
|
|
|
hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = FilterMediaSeeking->QueryPreferredFormat(pFormat);
|
|
|
|
FilterMediaSeeking->Release();
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::GetTimeFormat(
|
|
GUID *pFormat)
|
|
{
|
|
IMediaSeeking * FilterMediaSeeking;
|
|
HRESULT hr;
|
|
|
|
hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = FilterMediaSeeking->GetTimeFormat(pFormat);
|
|
|
|
FilterMediaSeeking->Release();
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::IsUsingTimeFormat(
|
|
const GUID *pFormat)
|
|
{
|
|
IMediaSeeking * FilterMediaSeeking;
|
|
HRESULT hr;
|
|
|
|
hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = FilterMediaSeeking->IsUsingTimeFormat(pFormat);
|
|
|
|
FilterMediaSeeking->Release();
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::SetTimeFormat(
|
|
const GUID *pFormat)
|
|
{
|
|
IMediaSeeking * FilterMediaSeeking;
|
|
HRESULT hr;
|
|
|
|
hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = FilterMediaSeeking->SetTimeFormat(pFormat);
|
|
|
|
FilterMediaSeeking->Release();
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::GetDuration(
|
|
LONGLONG *pDuration)
|
|
{
|
|
IMediaSeeking * FilterMediaSeeking;
|
|
HRESULT hr;
|
|
|
|
hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = FilterMediaSeeking->GetDuration(pDuration);
|
|
|
|
FilterMediaSeeking->Release();
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::GetStopPosition(
|
|
LONGLONG *pStop)
|
|
{
|
|
IMediaSeeking * FilterMediaSeeking;
|
|
HRESULT hr;
|
|
|
|
hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = FilterMediaSeeking->GetStopPosition(pStop);
|
|
|
|
FilterMediaSeeking->Release();
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::GetCurrentPosition(
|
|
LONGLONG *pCurrent)
|
|
{
|
|
IMediaSeeking * FilterMediaSeeking;
|
|
HRESULT hr;
|
|
|
|
hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = FilterMediaSeeking->GetCurrentPosition(pCurrent);
|
|
|
|
FilterMediaSeeking->Release();
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::ConvertTimeFormat(
|
|
LONGLONG *pTarget,
|
|
const GUID *pTargetFormat,
|
|
LONGLONG Source,
|
|
const GUID *pSourceFormat)
|
|
{
|
|
IMediaSeeking * FilterMediaSeeking;
|
|
HRESULT hr;
|
|
|
|
hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = FilterMediaSeeking->ConvertTimeFormat(pTarget, pTargetFormat, Source, pSourceFormat);
|
|
|
|
FilterMediaSeeking->Release();
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::SetPositions(
|
|
LONGLONG *pCurrent,
|
|
DWORD dwCurrentFlags,
|
|
LONGLONG *pStop,
|
|
DWORD dwStopFlags)
|
|
{
|
|
IMediaSeeking * FilterMediaSeeking;
|
|
HRESULT hr;
|
|
|
|
hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = FilterMediaSeeking->SetPositions(pCurrent, dwCurrentFlags, pStop, dwStopFlags);
|
|
|
|
FilterMediaSeeking->Release();
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::GetPositions(
|
|
LONGLONG *pCurrent,
|
|
LONGLONG *pStop)
|
|
{
|
|
IMediaSeeking * FilterMediaSeeking;
|
|
HRESULT hr;
|
|
|
|
hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = FilterMediaSeeking->GetPositions(pCurrent, pStop);
|
|
|
|
FilterMediaSeeking->Release();
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::GetAvailable(
|
|
LONGLONG *pEarliest,
|
|
LONGLONG *pLatest)
|
|
{
|
|
IMediaSeeking * FilterMediaSeeking;
|
|
HRESULT hr;
|
|
|
|
hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = FilterMediaSeeking->GetAvailable(pEarliest, pLatest);
|
|
|
|
FilterMediaSeeking->Release();
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::SetRate(
|
|
double dRate)
|
|
{
|
|
IMediaSeeking * FilterMediaSeeking;
|
|
HRESULT hr;
|
|
|
|
hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = FilterMediaSeeking->SetRate(dRate);
|
|
|
|
FilterMediaSeeking->Release();
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::GetRate(
|
|
double *pdRate)
|
|
{
|
|
IMediaSeeking * FilterMediaSeeking;
|
|
HRESULT hr;
|
|
|
|
hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = FilterMediaSeeking->GetRate(pdRate);
|
|
|
|
FilterMediaSeeking->Release();
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::GetPreroll(
|
|
LONGLONG *pllPreroll)
|
|
{
|
|
IMediaSeeking * FilterMediaSeeking;
|
|
HRESULT hr;
|
|
|
|
hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = FilterMediaSeeking->GetPreroll(pllPreroll);
|
|
|
|
FilterMediaSeeking->Release();
|
|
return hr;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// IQualityControl interface
|
|
//
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::Notify(
|
|
IBaseFilter *pSelf,
|
|
Quality q)
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::Notify NotImplemented\n");
|
|
#endif
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::SetSink(
|
|
IQualityControl *piqc)
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::SetSink NotImplemented\n");
|
|
#endif
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------
|
|
// IKsAggregateControl interface
|
|
//
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::KsAddAggregate(
|
|
IN REFGUID AggregateClass)
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::KsAddAggregate NotImplemented\n");
|
|
#endif
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::KsRemoveAggregate(
|
|
REFGUID AggregateClass)
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::KsRemoveAggregate NotImplemented\n");
|
|
#endif
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------
|
|
// IKsPin
|
|
//
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::KsQueryMediums(
|
|
PKSMULTIPLE_ITEM* MediumList)
|
|
{
|
|
HRESULT hr;
|
|
HANDLE hFilter;
|
|
IKsObject * KsObjectParent;
|
|
|
|
hr = m_ParentFilter->QueryInterface(IID_IKsObject, (LPVOID*)&KsObjectParent);
|
|
if (FAILED(hr))
|
|
return E_NOINTERFACE;
|
|
|
|
hFilter = KsObjectParent->KsGetObjectHandle();
|
|
|
|
if (hFilter)
|
|
hr = KsGetMultiplePinFactoryItems(hFilter, m_PinId, KSPROPERTY_PIN_MEDIUMS, (PVOID*)MediumList);
|
|
else
|
|
hr = E_HANDLE;
|
|
|
|
KsObjectParent->Release();
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::KsQueryInterfaces(
|
|
PKSMULTIPLE_ITEM* InterfaceList)
|
|
{
|
|
HRESULT hr;
|
|
HANDLE hFilter;
|
|
IKsObject * KsObjectParent;
|
|
|
|
hr = m_ParentFilter->QueryInterface(IID_IKsObject, (LPVOID*)&KsObjectParent);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hFilter = KsObjectParent->KsGetObjectHandle();
|
|
|
|
if (hFilter)
|
|
hr = KsGetMultiplePinFactoryItems(hFilter, m_PinId, KSPROPERTY_PIN_INTERFACES, (PVOID*)InterfaceList);
|
|
else
|
|
hr = E_HANDLE;
|
|
|
|
KsObjectParent->Release();
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::KsCreateSinkPinHandle(
|
|
KSPIN_INTERFACE& Interface,
|
|
KSPIN_MEDIUM& Medium)
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::KsCreateSinkPinHandle NotImplemented\n");
|
|
#endif
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::KsGetCurrentCommunication(
|
|
KSPIN_COMMUNICATION *Communication,
|
|
KSPIN_INTERFACE *Interface,
|
|
KSPIN_MEDIUM *Medium)
|
|
{
|
|
if (Communication)
|
|
{
|
|
*Communication = m_Communication;
|
|
}
|
|
|
|
if (Interface)
|
|
{
|
|
if (!m_hPin)
|
|
return VFW_E_NOT_CONNECTED;
|
|
|
|
CopyMemory(Interface, &m_Interface, sizeof(KSPIN_INTERFACE));
|
|
}
|
|
|
|
if (Medium)
|
|
{
|
|
if (!m_hPin)
|
|
return VFW_E_NOT_CONNECTED;
|
|
|
|
CopyMemory(Medium, &m_Medium, sizeof(KSPIN_MEDIUM));
|
|
}
|
|
return NOERROR;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::KsPropagateAcquire()
|
|
{
|
|
KSPROPERTY Property;
|
|
KSSTATE State;
|
|
ULONG BytesReturned;
|
|
HRESULT hr;
|
|
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::KsPropagateAcquire\n");
|
|
#endif
|
|
|
|
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);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
m_State = State;
|
|
}
|
|
|
|
//TODO
|
|
//propagate to connected pin on the pipe
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::KsDeliver(
|
|
IMediaSample* Sample,
|
|
ULONG Flags)
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::KsMediaSamplesCompleted(PKSSTREAM_SEGMENT StreamSegment)
|
|
{
|
|
return NOERROR;
|
|
}
|
|
|
|
IMemAllocator *
|
|
STDMETHODCALLTYPE
|
|
COutputPin::KsPeekAllocator(KSPEEKOPERATION Operation)
|
|
{
|
|
if (Operation == KsPeekOperation_AddRef)
|
|
{
|
|
// add reference on allocator
|
|
m_MemAllocator->AddRef();
|
|
}
|
|
|
|
return m_MemAllocator;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::KsReceiveAllocator(IMemAllocator *MemAllocator)
|
|
{
|
|
if (MemAllocator)
|
|
{
|
|
MemAllocator->AddRef();
|
|
}
|
|
|
|
if (m_MemAllocator)
|
|
{
|
|
m_MemAllocator->Release();
|
|
}
|
|
|
|
m_MemAllocator = MemAllocator;
|
|
return NOERROR;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::KsRenegotiateAllocator()
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
LONG
|
|
STDMETHODCALLTYPE
|
|
COutputPin::KsIncrementPendingIoCount()
|
|
{
|
|
return InterlockedIncrement((volatile LONG*)&m_IoCount);
|
|
}
|
|
|
|
LONG
|
|
STDMETHODCALLTYPE
|
|
COutputPin::KsDecrementPendingIoCount()
|
|
{
|
|
return InterlockedDecrement((volatile LONG*)&m_IoCount);
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::KsQualityNotify(
|
|
ULONG Proportion,
|
|
REFERENCE_TIME TimeDelta)
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::KsQualityNotify NotImplemented\n");
|
|
#endif
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// IKsPinEx
|
|
//
|
|
|
|
VOID
|
|
STDMETHODCALLTYPE
|
|
COutputPin::KsNotifyError(
|
|
IMediaSample* Sample,
|
|
HRESULT hr)
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::KsNotifyError NotImplemented\n");
|
|
#endif
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------
|
|
// IKsPinPipe
|
|
//
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::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
|
|
COutputPin::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
|
|
COutputPin::KsGetConnectedPin()
|
|
{
|
|
return m_Pin;
|
|
}
|
|
|
|
IKsAllocatorEx*
|
|
STDMETHODCALLTYPE
|
|
COutputPin::KsGetPipe(
|
|
KSPEEKOPERATION Operation)
|
|
{
|
|
if (Operation == KsPeekOperation_AddRef)
|
|
{
|
|
if (m_KsAllocatorEx)
|
|
m_KsAllocatorEx->AddRef();
|
|
}
|
|
return m_KsAllocatorEx;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::KsSetPipe(
|
|
IKsAllocatorEx *KsAllocator)
|
|
{
|
|
if (KsAllocator)
|
|
KsAllocator->AddRef();
|
|
|
|
if (m_KsAllocatorEx)
|
|
m_KsAllocatorEx->Release();
|
|
|
|
m_KsAllocatorEx = KsAllocator;
|
|
return NOERROR;
|
|
}
|
|
|
|
ULONG
|
|
STDMETHODCALLTYPE
|
|
COutputPin::KsGetPipeAllocatorFlag()
|
|
{
|
|
return m_PipeAllocatorFlag;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::KsSetPipeAllocatorFlag(
|
|
ULONG Flag)
|
|
{
|
|
m_PipeAllocatorFlag = Flag;
|
|
return NOERROR;
|
|
}
|
|
|
|
GUID
|
|
STDMETHODCALLTYPE
|
|
COutputPin::KsGetPinBusCache()
|
|
{
|
|
if (!m_bPinBusCacheInitialized)
|
|
{
|
|
CopyMemory(&m_PinBusCache, &m_Medium.Set, sizeof(GUID));
|
|
m_bPinBusCacheInitialized = TRUE;
|
|
}
|
|
|
|
return m_PinBusCache;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::KsSetPinBusCache(
|
|
GUID Bus)
|
|
{
|
|
CopyMemory(&m_PinBusCache, &Bus, sizeof(GUID));
|
|
return NOERROR;
|
|
}
|
|
|
|
PWCHAR
|
|
STDMETHODCALLTYPE
|
|
COutputPin::KsGetPinName()
|
|
{
|
|
return (PWCHAR)m_PinName;
|
|
}
|
|
|
|
|
|
PWCHAR
|
|
STDMETHODCALLTYPE
|
|
COutputPin::KsGetFilterName()
|
|
{
|
|
return m_FilterName;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// ISpecifyPropertyPages
|
|
//
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::GetPages(CAUUID *pPages)
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::GetPages NotImplemented\n");
|
|
#endif
|
|
|
|
if (!pPages)
|
|
return E_POINTER;
|
|
|
|
pPages->cElems = 0;
|
|
pPages->pElems = NULL;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// IKsPinFactory
|
|
//
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::KsPinFactory(
|
|
ULONG* PinFactory)
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::KsPinFactory\n");
|
|
#endif
|
|
|
|
*PinFactory = m_PinId;
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------
|
|
// IStreamBuilder
|
|
//
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::Render(
|
|
IPin *ppinOut,
|
|
IGraphBuilder *pGraph)
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::Render\n");
|
|
#endif
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::Backout(
|
|
IPin *ppinOut,
|
|
IGraphBuilder *pGraph)
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::Backout\n");
|
|
#endif
|
|
|
|
return S_OK;
|
|
}
|
|
//-------------------------------------------------------------------
|
|
// IKsObject
|
|
//
|
|
HANDLE
|
|
STDMETHODCALLTYPE
|
|
COutputPin::KsGetObjectHandle()
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::KsGetObjectHandle\n");
|
|
#endif
|
|
|
|
assert(m_hPin != INVALID_HANDLE_VALUE);
|
|
return m_hPin;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// IKsControl
|
|
//
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::KsProperty(
|
|
PKSPROPERTY Property,
|
|
ULONG PropertyLength,
|
|
LPVOID PropertyData,
|
|
ULONG DataLength,
|
|
ULONG* BytesReturned)
|
|
{
|
|
HRESULT hr;
|
|
|
|
assert(m_hPin != INVALID_HANDLE_VALUE);
|
|
|
|
hr = KsSynchronousDeviceControl(m_hPin, IOCTL_KS_PROPERTY, (PVOID)Property, PropertyLength, (PVOID)PropertyData, DataLength, BytesReturned);
|
|
#ifdef KSPROXY_TRACE
|
|
WCHAR Buffer[100];
|
|
LPOLESTR pstr;
|
|
StringFromCLSID(Property->Set, &pstr);
|
|
swprintf(Buffer, L"COutputPin::KsProperty Set %s Id %lu Flags %x hr %x\n", pstr, Property->Id, Property->Flags, hr);
|
|
OutputDebugStringW(Buffer);
|
|
#endif
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::KsMethod(
|
|
PKSMETHOD Method,
|
|
ULONG MethodLength,
|
|
LPVOID MethodData,
|
|
ULONG DataLength,
|
|
ULONG* BytesReturned)
|
|
{
|
|
assert(m_hPin != INVALID_HANDLE_VALUE);
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::KsMethod\n");
|
|
#endif
|
|
return KsSynchronousDeviceControl(m_hPin, IOCTL_KS_METHOD, (PVOID)Method, MethodLength, (PVOID)MethodData, DataLength, BytesReturned);
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::KsEvent(
|
|
PKSEVENT Event,
|
|
ULONG EventLength,
|
|
LPVOID EventData,
|
|
ULONG DataLength,
|
|
ULONG* BytesReturned)
|
|
{
|
|
assert(m_hPin != INVALID_HANDLE_VALUE);
|
|
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::KsEvent\n");
|
|
#endif
|
|
|
|
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
|
|
COutputPin::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
|
|
COutputPin::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
|
|
COutputPin::QuerySupported(
|
|
REFGUID guidPropSet,
|
|
DWORD dwPropID,
|
|
DWORD *pTypeSupport)
|
|
{
|
|
KSPROPERTY Property;
|
|
ULONG BytesReturned;
|
|
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::QuerySupported\n");
|
|
#endif
|
|
|
|
Property.Set = guidPropSet;
|
|
Property.Id = dwPropID;
|
|
Property.Flags = KSPROPERTY_TYPE_SETSUPPORT;
|
|
|
|
return KsProperty(&Property, sizeof(KSPROPERTY), pTypeSupport, sizeof(DWORD), &BytesReturned);
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------
|
|
// IPin interface
|
|
//
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::Connect(IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
|
|
{
|
|
HRESULT hr;
|
|
ALLOCATOR_PROPERTIES Properties;
|
|
IMemAllocatorCallbackTemp *pMemCallback;
|
|
LPGUID pGuid;
|
|
ULONG NumGuids = 0;
|
|
|
|
#ifdef KSPROXY_TRACE
|
|
WCHAR Buffer[200];
|
|
OutputDebugStringW(L"COutputPin::Connect called\n");
|
|
#endif
|
|
|
|
if (pmt)
|
|
{
|
|
hr = pReceivePin->QueryAccept(pmt);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
}
|
|
else
|
|
{
|
|
// query accept
|
|
hr = pReceivePin->QueryAccept(&m_MediaFormat);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
pmt = &m_MediaFormat;
|
|
}
|
|
|
|
if (m_hPin == INVALID_HANDLE_VALUE)
|
|
{
|
|
hr = CreatePin(pmt);
|
|
if (FAILED(hr))
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
swprintf(Buffer, L"COutputPin::Connect CreatePin handle failed with %lx\n", hr);
|
|
OutputDebugStringW(Buffer);
|
|
#endif
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
|
|
// query for IMemInput interface
|
|
hr = pReceivePin->QueryInterface(IID_IMemInputPin, (void**)&m_MemInputPin);
|
|
if (FAILED(hr))
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::Connect no IMemInputPin interface\n");
|
|
#endif
|
|
|
|
return hr;
|
|
}
|
|
|
|
// get input pin allocator properties
|
|
ZeroMemory(&Properties, sizeof(ALLOCATOR_PROPERTIES));
|
|
m_MemInputPin->GetAllocatorRequirements(&Properties);
|
|
|
|
//FIXME determine allocator properties
|
|
Properties.cBuffers = 32;
|
|
Properties.cbBuffer = 2048 * 188; //2048 frames * MPEG2 TS Payload size
|
|
Properties.cbAlign = 4;
|
|
|
|
// get input pin allocator
|
|
#if 0
|
|
hr = m_MemInputPin->GetAllocator(&m_MemAllocator);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// set allocator properties
|
|
hr = m_MemAllocator->SetProperties(&Properties, &m_Properties);
|
|
if (FAILED(hr))
|
|
m_MemAllocator->Release();
|
|
}
|
|
#endif
|
|
|
|
if (1)
|
|
{
|
|
hr = CKsAllocator_Constructor(NULL, IID_IMemAllocator, (void**)&m_MemAllocator);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
// set allocator properties
|
|
hr = m_MemAllocator->SetProperties(&Properties, &m_Properties);
|
|
if (FAILED(hr))
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
swprintf(Buffer, L"COutputPin::Connect IMemAllocator::SetProperties failed with hr %lx\n", hr);
|
|
OutputDebugStringW(Buffer);
|
|
#endif
|
|
m_MemAllocator->Release();
|
|
m_MemInputPin->Release();
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
// commit property changes
|
|
hr = m_MemAllocator->Commit();
|
|
if (FAILED(hr))
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
swprintf(Buffer, L"COutputPin::Connect IMemAllocator::Commit failed with hr %lx\n", hr);
|
|
OutputDebugStringW(Buffer);
|
|
#endif
|
|
m_MemAllocator->Release();
|
|
m_MemInputPin->Release();
|
|
return hr;
|
|
}
|
|
|
|
// get callback interface
|
|
hr = m_MemAllocator->QueryInterface(IID_IMemAllocatorCallbackTemp, (void**)&pMemCallback);
|
|
if (FAILED(hr))
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
swprintf(Buffer, L"COutputPin::Connect No IMemAllocatorCallbackTemp interface hr %lx\n", hr);
|
|
OutputDebugStringW(Buffer);
|
|
#endif
|
|
m_MemAllocator->Release();
|
|
m_MemInputPin->Release();
|
|
return hr;
|
|
}
|
|
|
|
// set notification routine
|
|
hr = pMemCallback->SetNotify((IMemAllocatorNotifyCallbackTemp*)this);
|
|
|
|
// release IMemAllocatorNotifyCallbackTemp interface
|
|
pMemCallback->Release();
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
swprintf(Buffer, L"COutputPin::Connect IMemAllocatorNotifyCallbackTemp::SetNotify failed hr %lx\n", hr);
|
|
OutputDebugStringW(Buffer);
|
|
#endif
|
|
m_MemAllocator->Release();
|
|
m_MemInputPin->Release();
|
|
return hr;
|
|
}
|
|
|
|
// now set allocator
|
|
hr = m_MemInputPin->NotifyAllocator(m_MemAllocator, TRUE);
|
|
if (FAILED(hr))
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
swprintf(Buffer, L"COutputPin::Connect IMemInputPin::NotifyAllocator failed with hr %lx\n", hr);
|
|
OutputDebugStringW(Buffer);
|
|
#endif
|
|
m_MemAllocator->Release();
|
|
m_MemInputPin->Release();
|
|
return hr;
|
|
}
|
|
|
|
|
|
assert(m_hPin != INVALID_HANDLE_VALUE);
|
|
|
|
// get all supported sets
|
|
if (m_Plugins.empty())
|
|
{
|
|
if (GetSupportedSets(&pGuid, &NumGuids))
|
|
{
|
|
// load all proxy plugins
|
|
if (FAILED(LoadProxyPlugins(pGuid, NumGuids)))
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::Connect LoadProxyPlugins failed\n");
|
|
#endif
|
|
}
|
|
// free sets
|
|
CoTaskMemFree(pGuid);
|
|
}
|
|
}
|
|
|
|
// receive connection;
|
|
hr = pReceivePin->ReceiveConnection((IPin*)this, pmt);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// increment reference count
|
|
pReceivePin->AddRef();
|
|
m_Pin = pReceivePin;
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::Connect success\n");
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
m_MemInputPin->Release();
|
|
m_MemAllocator->Release();
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::ReceiveConnection(IPin *pConnector, const AM_MEDIA_TYPE *pmt)
|
|
{
|
|
return E_UNEXPECTED;
|
|
}
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::Disconnect( void)
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::Disconnect\n");
|
|
#endif
|
|
|
|
if (!m_Pin)
|
|
{
|
|
// pin was not connected
|
|
return S_FALSE;
|
|
}
|
|
|
|
//FIXME
|
|
//check if filter is active
|
|
|
|
m_Pin->Release();
|
|
m_Pin = NULL;
|
|
m_MemInputPin->Release();
|
|
m_MemAllocator->Release();
|
|
|
|
CloseHandle(m_hPin);
|
|
m_hPin = INVALID_HANDLE_VALUE;
|
|
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::Disconnect\n");
|
|
#endif
|
|
return S_OK;
|
|
}
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::ConnectedTo(IPin **pPin)
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::ConnectedTo\n");
|
|
#endif
|
|
|
|
if (!pPin)
|
|
return E_POINTER;
|
|
|
|
if (m_Pin)
|
|
{
|
|
// increment reference count
|
|
m_Pin->AddRef();
|
|
*pPin = m_Pin;
|
|
return S_OK;
|
|
}
|
|
|
|
*pPin = NULL;
|
|
return VFW_E_NOT_CONNECTED;
|
|
}
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::ConnectionMediaType(AM_MEDIA_TYPE *pmt)
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::ConnectionMediaType called\n");
|
|
#endif
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::QueryPinInfo(PIN_INFO *pInfo)
|
|
{
|
|
wcscpy(pInfo->achName, m_PinName);
|
|
pInfo->dir = PINDIR_OUTPUT;
|
|
pInfo->pFilter = m_ParentFilter;
|
|
m_ParentFilter->AddRef();
|
|
|
|
return S_OK;
|
|
}
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::QueryDirection(PIN_DIRECTION *pPinDir)
|
|
{
|
|
if (pPinDir)
|
|
{
|
|
*pPinDir = PINDIR_OUTPUT;
|
|
return S_OK;
|
|
}
|
|
|
|
return E_POINTER;
|
|
}
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::QueryId(LPWSTR *Id)
|
|
{
|
|
*Id = (LPWSTR)CoTaskMemAlloc((wcslen(m_PinName)+1)*sizeof(WCHAR));
|
|
if (!*Id)
|
|
return E_OUTOFMEMORY;
|
|
|
|
wcscpy(*Id, m_PinName);
|
|
return S_OK;
|
|
}
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::QueryAccept(const AM_MEDIA_TYPE *pmt)
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"COutputPin::QueryAccept called\n");
|
|
#endif
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::EnumMediaTypes(IEnumMediaTypes **ppEnum)
|
|
{
|
|
HRESULT hr;
|
|
ULONG MediaTypeCount = 0, Index;
|
|
AM_MEDIA_TYPE * MediaTypes;
|
|
HANDLE hFilter;
|
|
IKsObject * KsObjectParent;
|
|
|
|
hr = m_ParentFilter->QueryInterface(IID_IKsObject, (LPVOID*)&KsObjectParent);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
// get parent filter handle
|
|
hFilter = KsObjectParent->KsGetObjectHandle();
|
|
|
|
// release IKsObject
|
|
KsObjectParent->Release();
|
|
|
|
// 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
|
|
COutputPin::QueryInternalConnections(IPin **apPin, ULONG *nPin)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::EndOfStream( void)
|
|
{
|
|
/* should be called only on input pins */
|
|
return E_UNEXPECTED;
|
|
}
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::BeginFlush( void)
|
|
{
|
|
/* should be called only on input pins */
|
|
return E_UNEXPECTED;
|
|
}
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::EndFlush( void)
|
|
{
|
|
/* should be called only on input pins */
|
|
return E_UNEXPECTED;
|
|
}
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
|
|
{
|
|
if (!m_Pin)
|
|
{
|
|
// we are not connected
|
|
return VFW_E_NOT_CONNECTED;
|
|
}
|
|
|
|
return m_Pin->NewSegment(tStart, tStop, dRate);
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::CheckFormat(
|
|
const AM_MEDIA_TYPE *pmt)
|
|
{
|
|
PKSMULTIPLE_ITEM MultipleItem;
|
|
PKSDATAFORMAT DataFormat;
|
|
HRESULT hr;
|
|
IKsObject * KsObjectParent;
|
|
HANDLE hFilter;
|
|
|
|
if (!pmt)
|
|
return E_POINTER;
|
|
|
|
// get IKsObject interface
|
|
hr = m_ParentFilter->QueryInterface(IID_IKsObject, (LPVOID*)&KsObjectParent);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
// get parent filter handle
|
|
hFilter = KsObjectParent->KsGetObjectHandle();
|
|
|
|
// release IKsObject
|
|
KsObjectParent->Release();
|
|
|
|
if (!hFilter)
|
|
return E_HANDLE;
|
|
|
|
|
|
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))
|
|
{
|
|
// format is supported
|
|
CoTaskMemFree(MultipleItem);
|
|
return S_OK;
|
|
}
|
|
DataFormat = (PKSDATAFORMAT)((ULONG_PTR)DataFormat + DataFormat->FormatSize);
|
|
}
|
|
//format is not supported
|
|
CoTaskMemFree(MultipleItem);
|
|
return S_FALSE;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::CreatePin(
|
|
const AM_MEDIA_TYPE *pmt)
|
|
{
|
|
PKSMULTIPLE_ITEM MediumList;
|
|
PKSMULTIPLE_ITEM InterfaceList;
|
|
PKSPIN_MEDIUM Medium;
|
|
PKSPIN_INTERFACE Interface;
|
|
IKsInterfaceHandler * InterfaceHandler;
|
|
HRESULT hr;
|
|
|
|
// query for pin medium
|
|
hr = KsQueryMediums(&MediumList);
|
|
if (FAILED(hr))
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
WCHAR Buffer[100];
|
|
swprintf(Buffer, L"COutputPin::CreatePin KsQueryMediums failed %lx\n", hr);
|
|
OutputDebugStringW(Buffer);
|
|
#endif
|
|
return hr;
|
|
}
|
|
|
|
// query for pin interface
|
|
hr = KsQueryInterfaces(&InterfaceList);
|
|
if (FAILED(hr))
|
|
{
|
|
// failed
|
|
#ifdef KSPROXY_TRACE
|
|
WCHAR Buffer[100];
|
|
swprintf(Buffer, L"COutputPin::CreatePin KsQueryInterfaces failed %lx\n", hr);
|
|
OutputDebugStringW(Buffer);
|
|
#endif
|
|
|
|
CoTaskMemFree(MediumList);
|
|
return hr;
|
|
}
|
|
|
|
if (MediumList->Count)
|
|
{
|
|
//use first available medium
|
|
Medium = (PKSPIN_MEDIUM)(MediumList + 1);
|
|
}
|
|
else
|
|
{
|
|
// default to standard medium
|
|
Medium = &StandardPinMedium;
|
|
}
|
|
|
|
if (InterfaceList->Count)
|
|
{
|
|
//use first available interface
|
|
Interface = (PKSPIN_INTERFACE)(InterfaceList + 1);
|
|
}
|
|
else
|
|
{
|
|
// default to standard interface
|
|
Interface = &StandardPinInterface;
|
|
}
|
|
|
|
if (m_Communication != KSPIN_COMMUNICATION_BRIDGE && m_Communication != KSPIN_COMMUNICATION_NONE)
|
|
{
|
|
// now create pin
|
|
hr = CreatePinHandle(Medium, Interface, pmt);
|
|
if (FAILED(hr))
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
WCHAR Buffer[100];
|
|
swprintf(Buffer, L"COutputPin::CreatePinHandle failed with %lx\n", hr);
|
|
OutputDebugStringW(Buffer);
|
|
#endif
|
|
return hr;
|
|
}
|
|
|
|
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
|
|
CoTaskMemFree(MediumList);
|
|
CoTaskMemFree(InterfaceList);
|
|
|
|
#ifdef KSPROXY_TRACE
|
|
WCHAR Buffer[100];
|
|
swprintf(Buffer, L"COutputPin::CreatePin failed to create interface handler %lx\n", hr);
|
|
OutputDebugStringW(Buffer);
|
|
#endif
|
|
|
|
return hr;
|
|
}
|
|
|
|
// now set the pin
|
|
hr = InterfaceHandler->KsSetPin((IKsPin*)this);
|
|
if (FAILED(hr))
|
|
{
|
|
// failed to initialize interface handler plugin
|
|
#ifdef KSPROXY_TRACE
|
|
WCHAR Buffer[100];
|
|
swprintf(Buffer, L"COutputPin::CreatePin failed to initialize interface handler %lx\n", hr);
|
|
OutputDebugStringW(Buffer);
|
|
#endif
|
|
InterfaceHandler->Release();
|
|
CoTaskMemFree(MediumList);
|
|
CoTaskMemFree(InterfaceList);
|
|
return hr;
|
|
}
|
|
|
|
// store interface handler
|
|
m_InterfaceHandler = InterfaceHandler;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
WCHAR Buffer[100];
|
|
swprintf(Buffer, L"COutputPin::CreatePin unexpected communication %u %s\n", m_Communication, m_PinName);
|
|
OutputDebugStringW(Buffer);
|
|
#endif
|
|
|
|
hr = E_FAIL;
|
|
}
|
|
|
|
// free medium / interface / dataformat
|
|
CoTaskMemFree(MediumList);
|
|
CoTaskMemFree(InterfaceList);
|
|
|
|
#ifdef KSPROXY_TRACE
|
|
WCHAR Buffer[100];
|
|
swprintf(Buffer, L"COutputPin::CreatePin Result %lx\n", hr);
|
|
OutputDebugStringW(Buffer);
|
|
#endif
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::CreatePinHandle(
|
|
PKSPIN_MEDIUM Medium,
|
|
PKSPIN_INTERFACE Interface,
|
|
const AM_MEDIA_TYPE *pmt)
|
|
{
|
|
PKSPIN_CONNECT PinConnect;
|
|
PKSDATAFORMAT DataFormat;
|
|
ULONG Length;
|
|
HRESULT hr;
|
|
HANDLE hFilter;
|
|
IKsObject * KsObjectParent;
|
|
|
|
//KSALLOCATOR_FRAMING Framing;
|
|
//KSPROPERTY Property;
|
|
//ULONG BytesReturned;
|
|
|
|
OutputDebugStringW(L"COutputPin::CreatePinHandle\n");
|
|
|
|
if (m_hPin != INVALID_HANDLE_VALUE)
|
|
{
|
|
// pin already exists
|
|
//CloseHandle(m_hPin);
|
|
//m_hPin = INVALID_HANDLE_VALUE;
|
|
OutputDebugStringW(L"COutputPin::CreatePinHandle pin already exists\n");
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
// calc format size
|
|
Length = sizeof(KSPIN_CONNECT) + sizeof(KSDATAFORMAT) + pmt->cbFormat;
|
|
|
|
// allocate pin connect
|
|
PinConnect = (PKSPIN_CONNECT)CoTaskMemAlloc(Length);
|
|
if (!PinConnect)
|
|
{
|
|
// failed
|
|
OutputDebugStringW(L"COutputPin::CreatePinHandle out of memory\n");
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
OutputDebugStringW(L"COutputPin::CreatePinHandle copy pinconnect\n");
|
|
// setup request
|
|
CopyMemory(&PinConnect->Interface, Interface, sizeof(KSPIN_INTERFACE));
|
|
CopyMemory(&PinConnect->Medium, Medium, sizeof(KSPIN_MEDIUM));
|
|
PinConnect->PinId = m_PinId;
|
|
PinConnect->PinToHandle = NULL;
|
|
PinConnect->Priority.PriorityClass = KSPRIORITY_NORMAL;
|
|
PinConnect->Priority.PrioritySubClass = KSPRIORITY_NORMAL;
|
|
|
|
// get dataformat offset
|
|
DataFormat = (PKSDATAFORMAT)(PinConnect + 1);
|
|
OutputDebugStringW(L"COutputPin::CreatePinHandle copy format\n");
|
|
// 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
|
|
WCHAR Buffer[100];
|
|
swprintf(Buffer, L"COutputPin::CreatePinHandle copy format %p pbFormat %lu\n", pmt, pmt->cbFormat);
|
|
OutputDebugStringW(Buffer);
|
|
CopyMemory((DataFormat + 1), pmt->pbFormat, pmt->cbFormat);
|
|
}
|
|
|
|
// get IKsObject interface
|
|
hr = m_ParentFilter->QueryInterface(IID_IKsObject, (LPVOID*)&KsObjectParent);
|
|
if (FAILED(hr))
|
|
{
|
|
OutputDebugStringW(L"COutputPin::CreatePinHandle no IID_IKsObject interface\n");
|
|
return hr;
|
|
}
|
|
|
|
// get parent filter handle
|
|
hFilter = KsObjectParent->KsGetObjectHandle();
|
|
|
|
// release IKsObject
|
|
KsObjectParent->Release();
|
|
|
|
if (!hFilter)
|
|
{
|
|
OutputDebugStringW(L"COutputPin::CreatePinHandle no filter handle\n");
|
|
return E_HANDLE;
|
|
}
|
|
|
|
OutputDebugStringW(L"COutputPin::CreatePinHandle before creating pin\n");
|
|
// create pin
|
|
DWORD dwError = KsCreatePin(hFilter, PinConnect, GENERIC_READ, &m_hPin);
|
|
|
|
if (dwError == ERROR_SUCCESS)
|
|
{
|
|
OutputDebugStringW(L"COutputPin::CreatePinHandle created pin\n");
|
|
|
|
// 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"COutputPin::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);
|
|
}
|
|
#if 0
|
|
Property.Set = KSPROPSETID_Connection;
|
|
Property.Id = KSPROPERTY_CONNECTION_ALLOCATORFRAMING;
|
|
Property.Flags = KSPROPERTY_TYPE_GET;
|
|
|
|
ZeroMemory(&Framing, sizeof(KSALLOCATOR_FRAMING));
|
|
hr = KsProperty(&Property, sizeof(KSPROPERTY), (PVOID)&Framing, sizeof(KSALLOCATOR_FRAMING), &BytesReturned);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
m_Properties.cbAlign = (Framing.FileAlignment + 1);
|
|
m_Properties.cbBuffer = Framing.FrameSize;
|
|
m_Properties.cbPrefix = 0; //FIXME
|
|
m_Properties.cBuffers = Framing.Frames;
|
|
}
|
|
hr = S_OK;
|
|
#endif
|
|
|
|
if (FAILED(InitializeIOThread()))
|
|
{
|
|
OutputDebugStringW(L"COutputPin::CreatePinHandle failed to initialize i/o thread\n");
|
|
}
|
|
|
|
//TODO
|
|
// connect pin pipes
|
|
|
|
}
|
|
else
|
|
OutputDebugStringW(L"COutputPin::CreatePinHandle failed to create pin\n");
|
|
// free pin connect
|
|
CoTaskMemFree(PinConnect);
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::GetSupportedSets(
|
|
LPGUID * pOutGuid,
|
|
PULONG NumGuids)
|
|
{
|
|
KSPROPERTY Property;
|
|
LPGUID pGuid;
|
|
ULONG NumProperty = 0;
|
|
ULONG NumMethods = 0;
|
|
ULONG NumEvents = 0;
|
|
ULONG Length;
|
|
ULONG BytesReturned;
|
|
HRESULT hr;
|
|
|
|
Property.Set = GUID_NULL;
|
|
Property.Id = 0;
|
|
Property.Flags = KSPROPERTY_TYPE_SETSUPPORT;
|
|
|
|
KsSynchronousDeviceControl(m_hPin, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), NULL, 0, &NumProperty);
|
|
KsSynchronousDeviceControl(m_hPin, IOCTL_KS_METHOD, (PVOID)&Property, sizeof(KSPROPERTY), NULL, 0, &NumMethods);
|
|
KsSynchronousDeviceControl(m_hPin, IOCTL_KS_ENABLE_EVENT, (PVOID)&Property, sizeof(KSPROPERTY), NULL, 0, &NumEvents);
|
|
|
|
Length = NumProperty + NumMethods + NumEvents;
|
|
|
|
assert(Length);
|
|
|
|
// allocate guid buffer
|
|
pGuid = (LPGUID)CoTaskMemAlloc(Length);
|
|
if (!pGuid)
|
|
{
|
|
// failed
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
NumProperty /= sizeof(GUID);
|
|
NumMethods /= sizeof(GUID);
|
|
NumEvents /= sizeof(GUID);
|
|
|
|
// get all properties
|
|
hr = KsSynchronousDeviceControl(m_hPin, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), (PVOID)pGuid, Length, &BytesReturned);
|
|
if (FAILED(hr))
|
|
{
|
|
CoTaskMemFree(pGuid);
|
|
return E_FAIL;
|
|
}
|
|
Length -= BytesReturned;
|
|
|
|
// get all methods
|
|
if (Length && NumMethods)
|
|
{
|
|
hr = KsSynchronousDeviceControl(m_hPin, IOCTL_KS_METHOD, (PVOID)&Property, sizeof(KSPROPERTY), (PVOID)&pGuid[NumProperty], Length, &BytesReturned);
|
|
if (FAILED(hr))
|
|
{
|
|
CoTaskMemFree(pGuid);
|
|
return E_FAIL;
|
|
}
|
|
Length -= BytesReturned;
|
|
}
|
|
|
|
// get all events
|
|
if (Length && NumEvents)
|
|
{
|
|
hr = KsSynchronousDeviceControl(m_hPin, IOCTL_KS_ENABLE_EVENT, (PVOID)&Property, sizeof(KSPROPERTY), (PVOID)&pGuid[NumProperty+NumMethods], Length, &BytesReturned);
|
|
if (FAILED(hr))
|
|
{
|
|
CoTaskMemFree(pGuid);
|
|
return E_FAIL;
|
|
}
|
|
Length -= BytesReturned;
|
|
}
|
|
|
|
#ifdef KSPROXY_TRACE
|
|
WCHAR Buffer[200];
|
|
swprintf(Buffer, L"NumProperty %lu NumMethods %lu NumEvents %lu\n", NumProperty, NumMethods, NumEvents);
|
|
OutputDebugStringW(Buffer);
|
|
#endif
|
|
|
|
*pOutGuid = pGuid;
|
|
*NumGuids = NumProperty+NumEvents+NumMethods;
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin::LoadProxyPlugins(
|
|
LPGUID pGuids,
|
|
ULONG NumGuids)
|
|
{
|
|
ULONG Index;
|
|
LPOLESTR pStr;
|
|
HKEY hKey, hSubKey;
|
|
HRESULT hr;
|
|
IUnknown * pUnknown;
|
|
|
|
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SYSTEM\\CurrentControlSet\\Control\\MediaInterfaces", 0, KEY_READ, &hKey) != ERROR_SUCCESS)
|
|
{
|
|
OutputDebugStringW(L"CKsProxy::LoadProxyPlugins failed to open MediaInterfaces key\n");
|
|
return E_FAIL;
|
|
}
|
|
|
|
// enumerate all sets
|
|
for(Index = 0; Index < NumGuids; Index++)
|
|
{
|
|
// convert to string
|
|
hr = StringFromCLSID(pGuids[Index], &pStr);
|
|
if (FAILED(hr))
|
|
return E_FAIL;
|
|
|
|
// now try open class key
|
|
if (RegOpenKeyExW(hKey, pStr, 0, KEY_READ, &hSubKey) != ERROR_SUCCESS)
|
|
{
|
|
// no plugin for that set exists
|
|
CoTaskMemFree(pStr);
|
|
continue;
|
|
}
|
|
|
|
// try load plugin
|
|
hr = CoCreateInstance(pGuids[Index], (IBaseFilter*)this, CLSCTX_INPROC_SERVER, IID_IUnknown, (void**)&pUnknown);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// store plugin
|
|
m_Plugins.push_back(pUnknown);
|
|
}
|
|
// close key
|
|
RegCloseKey(hSubKey);
|
|
}
|
|
|
|
// close media interfaces key
|
|
RegCloseKey(hKey);
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WINAPI
|
|
COutputPin::IoProcessRoutine()
|
|
{
|
|
IMediaSample *Sample;
|
|
LONG SampleCount;
|
|
HRESULT hr;
|
|
PKSSTREAM_SEGMENT * StreamSegment;
|
|
HANDLE hEvent;
|
|
IMediaSample ** Samples;
|
|
LONG NumHandles;
|
|
DWORD dwStatus;
|
|
|
|
#ifdef KSPROXY_TRACE
|
|
WCHAR Buffer[200];
|
|
#endif
|
|
|
|
NumHandles = m_Properties.cBuffers / 2;
|
|
|
|
if (!NumHandles)
|
|
NumHandles = 8;
|
|
|
|
assert(NumHandles);
|
|
|
|
//allocate stream segment array
|
|
StreamSegment = (PKSSTREAM_SEGMENT*)CoTaskMemAlloc(sizeof(PVOID) * NumHandles);
|
|
if (!StreamSegment)
|
|
{
|
|
OutputDebugStringW(L"COutputPin::IoProcessRoutine out of memory\n");
|
|
return E_FAIL;
|
|
}
|
|
|
|
// allocate handle array
|
|
Samples = (IMediaSample**)CoTaskMemAlloc(sizeof(IMediaSample*) * NumHandles);
|
|
if (!Samples)
|
|
{
|
|
OutputDebugStringW(L"COutputPin::IoProcessRoutine out of memory\n");
|
|
return E_FAIL;
|
|
}
|
|
|
|
// zero handles array
|
|
ZeroMemory(StreamSegment, sizeof(PVOID) * NumHandles);
|
|
ZeroMemory(Samples, sizeof(IMediaSample*) * NumHandles);
|
|
|
|
// first wait for the start event to signal
|
|
WaitForSingleObject(m_hStartEvent, INFINITE);
|
|
|
|
m_IoCount = 0;
|
|
|
|
assert(m_InterfaceHandler);
|
|
do
|
|
{
|
|
if (m_StopInProgress)
|
|
{
|
|
// stop io thread
|
|
break;
|
|
}
|
|
|
|
assert(m_State == KSSTATE_RUN);
|
|
assert(m_MemAllocator);
|
|
|
|
// get buffer
|
|
hr = m_MemAllocator->GetBuffer(&Sample, NULL, NULL, AM_GBF_NOWAIT);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
WaitForSingleObject(m_hBufferAvailable, INFINITE);
|
|
// now retry again
|
|
continue;
|
|
}
|
|
|
|
// fill buffer
|
|
SampleCount = 1;
|
|
Samples[m_IoCount] = Sample;
|
|
|
|
Sample->SetTime(NULL, NULL);
|
|
hr = m_InterfaceHandler->KsProcessMediaSamples(NULL, /* FIXME */
|
|
&Samples[m_IoCount],
|
|
&SampleCount,
|
|
KsIoOperation_Read,
|
|
&StreamSegment[m_IoCount]);
|
|
if (FAILED(hr) || !StreamSegment)
|
|
{
|
|
#ifdef KSPROXY_TRACE
|
|
swprintf(Buffer, L"COutputPin::IoProcessRoutine KsProcessMediaSamples FAILED PinName %s hr %lx\n", m_PinName, hr);
|
|
OutputDebugStringW(Buffer);
|
|
#endif
|
|
break;
|
|
}
|
|
|
|
// interface handle should increment pending i/o count
|
|
assert(m_IoCount >= 1);
|
|
|
|
swprintf(Buffer, L"COutputPin::IoProcessRoutine m_IoCount %lu NumHandles %lu\n", m_IoCount, NumHandles);
|
|
OutputDebugStringW(Buffer);
|
|
|
|
if (m_IoCount != NumHandles)
|
|
continue;
|
|
|
|
// get completion handle
|
|
hEvent = StreamSegment[0]->CompletionEvent;
|
|
|
|
// wait for i/o completion
|
|
dwStatus = WaitForSingleObject(hEvent, INFINITE);
|
|
|
|
swprintf(Buffer, L"COutputPin::IoProcessRoutine dwStatus %lx Error %lx NumHandles %lu\n", dwStatus, GetLastError(), NumHandles);
|
|
OutputDebugStringW(Buffer);
|
|
|
|
// perform completion
|
|
m_InterfaceHandler->KsCompleteIo(StreamSegment[0]);
|
|
|
|
// close completion event
|
|
CloseHandle(hEvent);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
assert(m_MemInputPin);
|
|
|
|
// now deliver the sample
|
|
hr = m_MemInputPin->Receive(Samples[0]);
|
|
|
|
#ifdef KSPROXY_TRACE
|
|
swprintf(Buffer, L"COutputPin::IoProcessRoutine PinName %s IMemInputPin::Receive hr %lx Sample %p m_MemAllocator %p\n", m_PinName, hr, Sample, m_MemAllocator);
|
|
OutputDebugStringW(Buffer);
|
|
#endif
|
|
|
|
if (FAILED(hr))
|
|
break;
|
|
|
|
Sample = NULL;
|
|
}
|
|
|
|
//circular stream segment array
|
|
RtlMoveMemory(StreamSegment, &StreamSegment[1], sizeof(PVOID) * (NumHandles - 1));
|
|
RtlMoveMemory(Samples, &Samples[1], sizeof(IMediaSample*) * (NumHandles - 1));
|
|
|
|
}while(TRUE);
|
|
|
|
// signal end of i/o thread
|
|
SetEvent(m_hStopEvent);
|
|
|
|
m_IoThreadStarted = false;
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
DWORD
|
|
WINAPI
|
|
COutputPin_IoThreadStartup(
|
|
LPVOID lpParameter)
|
|
{
|
|
COutputPin * Pin = (COutputPin*)lpParameter;
|
|
assert(Pin);
|
|
|
|
return Pin->IoProcessRoutine();
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WINAPI
|
|
COutputPin::InitializeIOThread()
|
|
{
|
|
HANDLE hThread;
|
|
|
|
if (m_IoThreadStarted)
|
|
return NOERROR;
|
|
|
|
if (!m_hStartEvent)
|
|
m_hStartEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
|
|
|
|
if (!m_hStartEvent)
|
|
return E_OUTOFMEMORY;
|
|
|
|
if (!m_hStopEvent)
|
|
m_hStopEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
|
|
|
|
if (!m_hStopEvent)
|
|
return E_OUTOFMEMORY;
|
|
|
|
if (!m_hBufferAvailable)
|
|
m_hBufferAvailable = CreateEventW(NULL, FALSE, FALSE, NULL);
|
|
|
|
if (!m_hBufferAvailable)
|
|
return E_OUTOFMEMORY;
|
|
|
|
m_StopInProgress = false;
|
|
m_IoThreadStarted = true;
|
|
|
|
// now create the startup thread
|
|
hThread = CreateThread(NULL, 0, COutputPin_IoThreadStartup, (LPVOID)this, 0, NULL);
|
|
if (!hThread)
|
|
return E_OUTOFMEMORY;
|
|
|
|
|
|
// close thread handle
|
|
CloseHandle(hThread);
|
|
return NOERROR;
|
|
}
|
|
|
|
HRESULT
|
|
STDMETHODCALLTYPE
|
|
COutputPin_SetState(
|
|
IPin * Pin,
|
|
KSSTATE State)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
KSPROPERTY Property;
|
|
KSSTATE CurState;
|
|
ULONG BytesReturned;
|
|
COutputPin * pPin = (COutputPin*)Pin;
|
|
|
|
#ifdef KSPROXY_TRACE
|
|
WCHAR Buffer[200];
|
|
#endif
|
|
|
|
Property.Set = KSPROPSETID_Connection;
|
|
Property.Id = KSPROPERTY_CONNECTION_STATE;
|
|
Property.Flags = KSPROPERTY_TYPE_SET;
|
|
|
|
EnterCriticalSection(&pPin->m_Lock);
|
|
|
|
if (pPin->m_State <= State)
|
|
{
|
|
if (pPin->m_State == KSSTATE_STOP)
|
|
{
|
|
hr = pPin->InitializeIOThread();
|
|
if (FAILED(hr))
|
|
{
|
|
// failed to initialize I/O thread
|
|
#ifdef KSPROXY_TRACE
|
|
OutputDebugStringW(L"Failed to initialize I/O Thread\n");
|
|
#endif
|
|
LeaveCriticalSection(&pPin->m_Lock);
|
|
return hr;
|
|
}
|
|
CurState = KSSTATE_ACQUIRE;
|
|
hr = pPin->KsProperty(&Property, sizeof(KSPROPERTY), &CurState, sizeof(KSSTATE), &BytesReturned);
|
|
|
|
#ifdef KSPROXY_TRACE
|
|
swprintf(Buffer, L"COutputPin_SetState Setting State CurState: KSSTATE_STOP KSSTATE_ACQUIRE PinName %s hr %lx\n", pPin->m_PinName, hr);
|
|
OutputDebugStringW(Buffer);
|
|
#endif
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
LeaveCriticalSection(&pPin->m_Lock);
|
|
return hr;
|
|
}
|
|
|
|
pPin->m_State = CurState;
|
|
|
|
if (pPin->m_State == State)
|
|
{
|
|
LeaveCriticalSection(&pPin->m_Lock);
|
|
return hr;
|
|
}
|
|
}
|
|
if (pPin->m_State == KSSTATE_ACQUIRE)
|
|
{
|
|
CurState = KSSTATE_PAUSE;
|
|
hr = pPin->KsProperty(&Property, sizeof(KSPROPERTY), &CurState, sizeof(KSSTATE), &BytesReturned);
|
|
|
|
#ifdef KSPROXY_TRACE
|
|
swprintf(Buffer, L"COutputPin_SetState Setting State CurState KSSTATE_ACQUIRE KSSTATE_PAUSE PinName %s hr %lx\n", pPin->m_PinName, hr);
|
|
OutputDebugStringW(Buffer);
|
|
#endif
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
LeaveCriticalSection(&pPin->m_Lock);
|
|
return hr;
|
|
}
|
|
|
|
pPin->m_State = CurState;
|
|
|
|
if (pPin->m_State == State)
|
|
{
|
|
LeaveCriticalSection(&pPin->m_Lock);
|
|
return hr;
|
|
}
|
|
}
|
|
if (State == KSSTATE_RUN && pPin->m_State == KSSTATE_PAUSE)
|
|
{
|
|
CurState = KSSTATE_RUN;
|
|
hr = pPin->KsProperty(&Property, sizeof(KSPROPERTY), &CurState, sizeof(KSSTATE), &BytesReturned);
|
|
|
|
#ifdef KSPROXY_TRACE
|
|
swprintf(Buffer, L"COutputPin_SetState Setting State CurState: KSSTATE_PAUSE KSSTATE_RUN PinName %s hr %lx\n", pPin->m_PinName, hr);
|
|
OutputDebugStringW(Buffer);
|
|
#endif
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
pPin->m_State = CurState;
|
|
// signal start event
|
|
SetEvent(pPin->m_hStartEvent);
|
|
}
|
|
}
|
|
|
|
LeaveCriticalSection(&pPin->m_Lock);
|
|
return hr;
|
|
}
|
|
else
|
|
{
|
|
if (pPin->m_State == KSSTATE_RUN)
|
|
{
|
|
// setting pending stop flag
|
|
pPin->m_StopInProgress = true;
|
|
|
|
// release any waiting threads
|
|
SetEvent(pPin->m_hBufferAvailable);
|
|
|
|
// wait until i/o thread is done
|
|
WaitForSingleObject(pPin->m_hStopEvent, INFINITE);
|
|
|
|
CurState = KSSTATE_PAUSE;
|
|
hr = pPin->KsProperty(&Property, sizeof(KSPROPERTY), &CurState, sizeof(KSSTATE), &BytesReturned);
|
|
|
|
#ifdef KSPROXY_TRACE
|
|
swprintf(Buffer, L"COutputPin_SetState Setting State CurState: KSSTATE_RUN KSSTATE_PAUSE PinName %s hr %lx\n", pPin->m_PinName, hr);
|
|
OutputDebugStringW(Buffer);
|
|
#endif
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
LeaveCriticalSection(&pPin->m_Lock);
|
|
return hr;
|
|
}
|
|
|
|
pPin->m_State = CurState;
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
LeaveCriticalSection(&pPin->m_Lock);
|
|
return hr;
|
|
}
|
|
}
|
|
if (pPin->m_State == KSSTATE_PAUSE)
|
|
{
|
|
CurState = KSSTATE_ACQUIRE;
|
|
hr = pPin->KsProperty(&Property, sizeof(KSPROPERTY), &CurState, sizeof(KSSTATE), &BytesReturned);
|
|
|
|
#ifdef KSPROXY_TRACE
|
|
swprintf(Buffer, L"COutputPin_SetState Setting State CurState: KSSTATE_PAUSE KSSTATE_ACQUIRE PinName %s hr %lx\n", pPin->m_PinName, hr);
|
|
OutputDebugStringW(Buffer);
|
|
#endif
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
LeaveCriticalSection(&pPin->m_Lock);
|
|
return hr;
|
|
}
|
|
|
|
pPin->m_State = CurState;
|
|
|
|
if (pPin->m_State == State)
|
|
{
|
|
LeaveCriticalSection(&pPin->m_Lock);
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
CloseHandle(pPin->m_hStopEvent);
|
|
CloseHandle(pPin->m_hStartEvent);
|
|
CloseHandle(pPin->m_hBufferAvailable);
|
|
|
|
/* close event handles */
|
|
pPin->m_hStopEvent = NULL;
|
|
pPin->m_hStartEvent = NULL;
|
|
pPin->m_hBufferAvailable = NULL;
|
|
|
|
CurState = KSSTATE_STOP;
|
|
hr = pPin->KsProperty(&Property, sizeof(KSPROPERTY), &CurState, sizeof(KSSTATE), &BytesReturned);
|
|
|
|
#ifdef KSPROXY_TRACE
|
|
swprintf(Buffer, L"COutputPin_SetState Setting State CurState: KSSTATE_ACQUIRE KSSTATE_STOP PinName %s hr %lx\n", pPin->m_PinName, hr);
|
|
OutputDebugStringW(Buffer);
|
|
#endif
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// store state
|
|
pPin->m_State = CurState;
|
|
}
|
|
|
|
// unset pending stop flag
|
|
pPin->m_StopInProgress = false;
|
|
|
|
LeaveCriticalSection(&pPin->m_Lock);
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
HRESULT
|
|
WINAPI
|
|
COutputPin_Constructor(
|
|
IBaseFilter * ParentFilter,
|
|
LPCWSTR PinName,
|
|
ULONG PinId,
|
|
KSPIN_COMMUNICATION Communication,
|
|
REFIID riid,
|
|
LPVOID * ppv)
|
|
{
|
|
COutputPin * handler = new COutputPin(ParentFilter, PinName, PinId, Communication);
|
|
|
|
if (!handler)
|
|
return E_OUTOFMEMORY;
|
|
|
|
if (FAILED(handler->QueryInterface(riid, ppv)))
|
|
{
|
|
/* not supported */
|
|
delete handler;
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|