reactos/dll/directx/bdaplgin/pincontrol.cpp

403 lines
10 KiB
C++
Raw Normal View History

/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS BDA Proxy
* FILE: dll/directx/bdaplgin/pincontrol.cpp
* PURPOSE: ClassFactory interface
*
* PROGRAMMERS: Johannes Anderwald (johannes.anderwald@reactos.org)
*/
#include "precomp.h"
#ifndef _MSC_VER
const GUID KSPROPSETID_BdaPinControl = {0x0ded49d5, 0xa8b7, 0x4d5d, {0x97, 0xa1, 0x12, 0xb0, 0xc1, 0x95, 0x87, 0x4d}};
const GUID IID_IBDA_PinControl = {0x0DED49D5, 0xA8B7, 0x4d5d, {0x97, 0xA1, 0x12, 0xB0, 0xC1, 0x95, 0x87, 0x4D}};
const GUID IID_IPin = {0x56a86891, 0x0ad4, 0x11ce, {0xb0, 0x3a, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70}};
#endif
class CBDAPinControl : public IBDA_PinControl
{
public:
STDMETHODIMP QueryInterface( REFIID InterfaceId, PVOID* Interface);
STDMETHODIMP_(ULONG) AddRef()
{
InterlockedIncrement(&m_Ref);
return m_Ref;
}
STDMETHODIMP_(ULONG) Release()
{
InterlockedDecrement(&m_Ref);
if (!m_Ref)
{
delete this;
return 0;
}
return m_Ref;
}
// IBDA_PinControl methods
HRESULT STDMETHODCALLTYPE GetPinID(ULONG *pulPinID);
HRESULT STDMETHODCALLTYPE GetPinType(ULONG *pulPinType);
HRESULT STDMETHODCALLTYPE RegistrationContext(ULONG *pulRegistrationCtx);
CBDAPinControl(HANDLE hFile, IBDA_NetworkProvider * pProvider, IPin * pConnectedPin, ULONG RegistrationCtx) : m_Ref(0), m_Handle(hFile), m_pProvider(pProvider), m_pConnectedPin(pConnectedPin), m_RegistrationCtx(RegistrationCtx){};
virtual ~CBDAPinControl()
{
//m_pConnectedPin->Release();
//m_pProvider->Release();
};
protected:
LONG m_Ref;
HANDLE m_Handle;
IBDA_NetworkProvider * m_pProvider;
IPin * m_pConnectedPin;
ULONG m_RegistrationCtx;
};
HRESULT
STDMETHODCALLTYPE
CBDAPinControl::QueryInterface(
IN REFIID refiid,
OUT PVOID* Output)
{
*Output = NULL;
if (IsEqualGUID(refiid, IID_IUnknown))
{
*Output = PVOID(this);
reinterpret_cast<IUnknown*>(*Output)->AddRef();
return NOERROR;
}
if (IsEqualGUID(refiid, IID_IBDA_PinControl))
{
*Output = (IBDA_PinControl*)(this);
reinterpret_cast<IBDA_PinControl*>(*Output)->AddRef();
return NOERROR;
}
DebugBreak();
return E_NOINTERFACE;
}
//-------------------------------------------------------------------
// IBDA_PinControl methods
//
HRESULT
STDMETHODCALLTYPE
CBDAPinControl::GetPinID(ULONG *pulPinID)
{
KSPROPERTY Property;
ULONG BytesReturned;
HRESULT hr;
// setup request
Property.Set = KSPROPSETID_BdaPinControl;
Property.Id = KSPROPERTY_BDA_PIN_ID;
Property.Flags = KSPROPERTY_TYPE_GET;
// perform request
hr = KsSynchronousDeviceControl(m_Handle, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), pulPinID, sizeof(ULONG), &BytesReturned);
2010-02-26 01:53:48 +00:00
#ifdef BDAPLGIN_TRACE
WCHAR Buffer[100];
swprintf(Buffer, L"CBDAPinControl::GetPinID: hr %lx pulPinID %lu BytesReturned %lx\n", hr, *pulPinID, BytesReturned);
OutputDebugStringW(Buffer);
2010-02-26 01:53:48 +00:00
#endif
return hr;
}
HRESULT
STDMETHODCALLTYPE
CBDAPinControl::GetPinType(ULONG *pulPinType)
{
KSPROPERTY Property;
ULONG BytesReturned;
HRESULT hr;
// setup request
Property.Set = KSPROPSETID_BdaPinControl;
Property.Id = KSPROPERTY_BDA_PIN_TYPE;
Property.Flags = KSPROPERTY_TYPE_GET;
// perform request
hr = KsSynchronousDeviceControl(m_Handle, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), pulPinType, sizeof(ULONG), &BytesReturned);
2010-02-26 01:53:48 +00:00
#ifdef BDAPLGIN_TRACE
WCHAR Buffer[100];
swprintf(Buffer, L"CBDAPinControl::GetPinType: hr %lx pulPinType %lu BytesReturned %lx\n", hr, *pulPinType, BytesReturned);
OutputDebugStringW(Buffer);
2010-02-26 01:53:48 +00:00
#endif
return hr;
}
HRESULT
STDMETHODCALLTYPE
CBDAPinControl::RegistrationContext(ULONG *pulRegistrationCtx)
{
2010-02-26 01:53:48 +00:00
#ifdef BDAPLGIN_TRACE
OutputDebugStringW(L"CBDAPinControl::RegistrationContext\n");
2010-02-26 01:53:48 +00:00
#endif
if (!pulRegistrationCtx)
{
// invalid argument
return E_POINTER;
}
if (m_RegistrationCtx)
{
// is registered
*pulRegistrationCtx = m_RegistrationCtx;
return NOERROR;
}
//pin not registered
return E_FAIL;
}
//-------------------------------------------------------------------
HRESULT
GetNetworkProviderFromGraph(
IFilterGraph * pGraph,
IBDA_NetworkProvider ** pOutNetworkProvider)
{
IEnumFilters *pEnumFilters = NULL;
IBaseFilter * ppFilter[1];
IBDA_NetworkProvider * pNetworkProvider = NULL;
HRESULT hr;
// get IEnumFilters interface
hr = pGraph->EnumFilters(&pEnumFilters);
if (FAILED(hr))
{
//clean up
*pOutNetworkProvider = NULL;
return hr;
}
while(pEnumFilters->Next(1, ppFilter, NULL) == S_OK)
{
// check if that filter supports the IBDA_NetworkProvider interface
hr = ppFilter[0]->QueryInterface(IID_IBDA_NetworkProvider, (void**)&pNetworkProvider);
// release IBaseFilter
ppFilter[0]->Release();
if (SUCCEEDED(hr))
break;
}
// release IEnumFilters interface
pEnumFilters->Release();
//store result
*pOutNetworkProvider = pNetworkProvider;
if (pNetworkProvider)
return S_OK;
else
return E_FAIL;
}
HRESULT
CBDAPinControl_RealConstructor(
HANDLE hPin,
IBDA_NetworkProvider *pNetworkProvider,
IPin * pConnectedPin,
ULONG RegistrationCtx,
IUnknown * pUnkOuter,
REFIID riid,
LPVOID * ppv)
{
CBDAPinControl * handler = new CBDAPinControl(hPin, pNetworkProvider, pConnectedPin, RegistrationCtx);
#ifdef BDAPLGIN_TRACE
OutputDebugStringW(L"CBDAPinControl_fnConstructor\n");
#endif
if (!handler)
return E_OUTOFMEMORY;
if (FAILED(handler->QueryInterface(riid, ppv)))
{
/* not supported */
delete handler;
return E_NOINTERFACE;
}
return NOERROR;
}
HRESULT
WINAPI
CBDAPinControl_fnConstructor(
IUnknown * pUnkOuter,
REFIID riid,
LPVOID * ppv)
{
IPin * pConnectedPin = NULL;
IBDA_NetworkProvider * pNetworkProvider = NULL;
HANDLE hFile = INVALID_HANDLE_VALUE;
HRESULT hr;
IKsObject * pObject = NULL;
IPin * pPin = NULL;
IUnknown * pUnknown = NULL;
PIN_INFO PinInfo;
FILTER_INFO FilterInfo;
ULONG RegistrationCtx = 0;
if (!pUnkOuter)
return E_POINTER;
OutputDebugStringW(L"CBDAPinControl_fnConstructor\n");
//DebugBreak();
// query for IKsObject interface
hr = pUnkOuter->QueryInterface(IID_IKsObject, (void**)&pObject);
if (FAILED(hr))
return hr;
// query for IPin interface
hr = pObject->QueryInterface(IID_IPin, (void**)&pPin);
if (FAILED(hr))
{
//clean up
pObject->Release();
return hr;
}
// get pin info
hr = pPin->QueryPinInfo(&PinInfo);
if (FAILED(hr))
{
//clean up
pObject->Release();
pPin->Release();
return hr;
}
if (!PinInfo.pFilter)
{
//clean up
pObject->Release();
pPin->Release();
return hr;
}
// sanity checks
assert(PinInfo.pFilter != NULL);
// query filter info
hr = PinInfo.pFilter->QueryFilterInfo(&FilterInfo);
// sanity check
assert(FilterInfo.pGraph != NULL);
// get network provider interface
hr = GetNetworkProviderFromGraph(FilterInfo.pGraph, &pNetworkProvider);
if (SUCCEEDED(hr))
{
if (PinInfo.dir == PINDIR_OUTPUT)
{
// get connected pin handle
hr = pPin->ConnectedTo(&pConnectedPin);
if (SUCCEEDED(hr))
{
// get file handle
hFile = pObject->KsGetObjectHandle();
if (hFile)
{
hr = CBDAPinControl_RealConstructor(hFile, pNetworkProvider, pConnectedPin, 0, pUnkOuter, riid, ppv);
if (SUCCEEDED(hr))
{
// set to null to prevent releasing
pNetworkProvider = NULL;
pConnectedPin = NULL;
}
}
else
{
// expected file handle
hr = E_UNEXPECTED;
}
}
}
else
{
// get IUnknown from base filter
hr = PinInfo.pFilter->QueryInterface(IID_IUnknown, (void**)&pUnknown);
if (SUCCEEDED(hr))
{
// register device filter
OutputDebugStringW(L"CBDAPinControl_fnConstructor registering device filter with network provider\n");
hr = pNetworkProvider->RegisterDeviceFilter(pUnknown, &RegistrationCtx);
if (SUCCEEDED(hr))
{
// get file handle
hFile = pObject->KsGetObjectHandle();
if (hFile)
{
hr = CBDAPinControl_RealConstructor(hFile, pNetworkProvider, NULL, RegistrationCtx, pUnkOuter, riid, ppv);
if (SUCCEEDED(hr))
{
// set to null to prevent releasing
pNetworkProvider = NULL;
}
}
else
{
// expected file handle
hr = E_UNEXPECTED;
}
}
else
{
WCHAR Buffer[100];
swprintf(Buffer, L"CBDAPinControl_fnConstructor failed to register filter with %lx\n", hr);
OutputDebugStringW(Buffer);
}
}
}
}
// release IFilterGraph interface
FilterInfo.pGraph->Release();
// release IBaseFilter interface
PinInfo.pFilter->Release();
// release IPin
pPin->Release();
// release IKsObject
pObject->Release();
if (pNetworkProvider)
{
// release network provider
pNetworkProvider->Release();
}
if (pConnectedPin)
{
// release connected pin
pConnectedPin->Release();
}
if (pUnknown)
{
// release filter
pUnknown->Release();
}
return hr;
}