CKsProxy Class Reference

Inheritance diagram for CKsProxy:

Collaboration diagram for CKsProxy:

Public Types
typedef std::vector< IUnknown * >	ProxyPluginVector
typedef std::vector< IPin * >	PinVector
Public Types inherited from IBaseFilter
typedef struct IBaseFilter::_FilterInfo	FILTER_INFO
Public Types inherited from IMediaFilter
enum	_FilterState { State_Stopped, State_Paused, State_Running }
typedef enum IMediaFilter::_FilterState	FILTER_STATE
Public Types inherited from IPersist
typedef IPersist *	LPPERSIST
Public Types inherited from IUnknown
typedef IUnknown *	LPUNKNOWN
Public Types inherited from IPersistPropertyBag
typedef IPersistPropertyBag *	LPPERSISTPROPERTYBAG
Public Types inherited from IPersistStream
typedef IPersistStream *	LPPERSISTSTREAM
Public Types inherited from ISpecifyPropertyPages
typedef ISpecifyPropertyPages *	LPSPECIFYPROPERTYPAGES
typedef struct ISpecifyPropertyPages::tagCAUUID	CAUUID
typedef struct ISpecifyPropertyPages::tagCAUUID *	LPCAUUID

Public Member Functions
STDMETHODIMP	QueryInterface (REFIID InterfaceId, PVOID *Interface)
	STDMETHODIMP_ (ULONG) AddRef()
	STDMETHODIMP_ (ULONG) Release()
HRESULT STDMETHODCALLTYPE	GetClassID (CLSID *pClassID)
HRESULT STDMETHODCALLTYPE	Stop (void)
HRESULT STDMETHODCALLTYPE	Pause (void)
HRESULT STDMETHODCALLTYPE	Run (REFERENCE_TIME tStart)
HRESULT STDMETHODCALLTYPE	GetState (DWORD dwMilliSecsTimeout, FILTER_STATE *State)
HRESULT STDMETHODCALLTYPE	SetSyncSource (IReferenceClock *pClock)
HRESULT STDMETHODCALLTYPE	GetSyncSource (IReferenceClock **pClock)
HRESULT STDMETHODCALLTYPE	EnumPins (IEnumPins **ppEnum)
HRESULT STDMETHODCALLTYPE	FindPin (LPCWSTR Id, IPin **ppPin)
HRESULT STDMETHODCALLTYPE	QueryFilterInfo (FILTER_INFO *pInfo)
HRESULT STDMETHODCALLTYPE	JoinFilterGraph (IFilterGraph *pGraph, LPCWSTR pName)
HRESULT STDMETHODCALLTYPE	QueryVendorInfo (LPWSTR *pVendorInfo)
HRESULT STDMETHODCALLTYPE	GetTime (REFERENCE_TIME *pTime)
HRESULT STDMETHODCALLTYPE	AdviseTime (REFERENCE_TIME baseTime, REFERENCE_TIME streamTime, HEVENT hEvent, DWORD_PTR *pdwAdviseCookie)
HRESULT STDMETHODCALLTYPE	AdvisePeriodic (REFERENCE_TIME startTime, REFERENCE_TIME periodTime, HSEMAPHORE hSemaphore, DWORD_PTR *pdwAdviseCookie)
HRESULT STDMETHODCALLTYPE	Unadvise (DWORD_PTR dwAdviseCookie)
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)
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)
ULONG STDMETHODCALLTYPE	GetMiscFlags (void)
HRESULT STDMETHODCALLTYPE	KsProperty (PKSPROPERTY Property, ULONG PropertyLength, LPVOID PropertyData, ULONG DataLength, ULONG *BytesReturned)
HRESULT STDMETHODCALLTYPE	KsMethod (PKSMETHOD Method, ULONG MethodLength, LPVOID MethodData, ULONG DataLength, ULONG *BytesReturned)
HRESULT STDMETHODCALLTYPE	KsEvent (PKSEVENT Event, ULONG EventLength, LPVOID EventData, ULONG DataLength, ULONG *BytesReturned)
HRESULT STDMETHODCALLTYPE	CreateNodeInstance (ULONG NodeId, ULONG Flags, ACCESS_MASK DesiredAccess, IUnknown *UnkOuter, REFGUID InterfaceId, LPVOID *Interface)
HRESULT STDMETHODCALLTYPE	KsAddAggregate (IN REFGUID AggregateClass)
HRESULT STDMETHODCALLTYPE	KsRemoveAggregate (REFGUID AggregateClass)
HRESULT STDMETHODCALLTYPE	KsGetTime (LONGLONG *Time)
HRESULT STDMETHODCALLTYPE	KsSetTime (LONGLONG Time)
HRESULT STDMETHODCALLTYPE	KsGetPhysicalTime (LONGLONG *Time)
HRESULT STDMETHODCALLTYPE	KsSetPhysicalTime (LONGLONG Time)
HRESULT STDMETHODCALLTYPE	KsGetCorrelatedTime (KSCORRELATED_TIME *CorrelatedTime)
HRESULT STDMETHODCALLTYPE	KsSetCorrelatedTime (KSCORRELATED_TIME *CorrelatedTime)
HRESULT STDMETHODCALLTYPE	KsGetCorrelatedPhysicalTime (KSCORRELATED_TIME *CorrelatedTime)
HRESULT STDMETHODCALLTYPE	KsSetCorrelatedPhysicalTime (KSCORRELATED_TIME *CorrelatedTime)
HRESULT STDMETHODCALLTYPE	KsGetResolution (KSRESOLUTION *Resolution)
HRESULT STDMETHODCALLTYPE	KsGetState (KSSTATE *State)
HRESULT STDMETHODCALLTYPE	Register (void)
HRESULT STDMETHODCALLTYPE	Unregister (void)
HRESULT STDMETHODCALLTYPE	InitNew (void)
HRESULT STDMETHODCALLTYPE	Load (IPropertyBag *pPropBag, IErrorLog *pErrorLog)
HRESULT STDMETHODCALLTYPE	Save (IPropertyBag *pPropBag, BOOL fClearDirty, BOOL fSaveAllProperties)
HANDLE STDMETHODCALLTYPE	KsGetObjectHandle ()
HANDLE STDMETHODCALLTYPE	KsGetClockHandle ()
HRESULT STDMETHODCALLTYPE	DeviceInfo (CLSID *pclsidInterfaceClass, LPWSTR *pwszSymbolicLink)
HRESULT STDMETHODCALLTYPE	Reassociate (void)
HRESULT STDMETHODCALLTYPE	Disassociate (void)
HRESULT STDMETHODCALLTYPE	IsDirty (void)
HRESULT STDMETHODCALLTYPE	Load (IStream *pStm)
HRESULT STDMETHODCALLTYPE	Save (IStream *pStm, BOOL fClearDirty)
HRESULT STDMETHODCALLTYPE	GetSizeMax (ULARGE_INTEGER *pcbSize)
HRESULT STDMETHODCALLTYPE	GetPages (CAUUID *pPages)
	CKsProxy ()
	~CKsProxy ()
HRESULT STDMETHODCALLTYPE	GetSupportedSets (LPGUID *pOutGuid, PULONG NumGuids)
HRESULT STDMETHODCALLTYPE	LoadProxyPlugins (LPGUID pGuids, ULONG NumGuids)
HRESULT STDMETHODCALLTYPE	GetNumberOfPins (PULONG NumPins)
HRESULT STDMETHODCALLTYPE	GetPinInstanceCount (ULONG PinId, PKSPIN_CINSTANCES Instances)
HRESULT STDMETHODCALLTYPE	GetPinDataflow (ULONG PinId, KSPIN_DATAFLOW *DataFlow)
HRESULT STDMETHODCALLTYPE	GetPinName (ULONG PinId, KSPIN_DATAFLOW DataFlow, ULONG PinCount, LPWSTR *OutPinName)
HRESULT STDMETHODCALLTYPE	GetPinCommunication (ULONG PinId, KSPIN_COMMUNICATION *Communication)
HRESULT STDMETHODCALLTYPE	CreatePins ()
HRESULT STDMETHODCALLTYPE	GetMediaSeekingFormats (PKSMULTIPLE_ITEM *FormatList)
HRESULT STDMETHODCALLTYPE	CreateClockInstance ()
HRESULT STDMETHODCALLTYPE	PerformClockProperty (ULONG PropertyId, ULONG PropertyFlags, PVOID OutputBuffer, ULONG OutputBufferSize)
HRESULT STDMETHODCALLTYPE	SetPinState (KSSTATE State)
Public Member Functions inherited from IUnknown
HRESULT	QueryInterface ([in] REFIID riid, [out, iid_is(riid)] void **ppvObject)
ULONG	AddRef ()
ULONG	Release ()
Public Member Functions inherited from IKsControl
HRESULT	KsProperty ([in] PKSPROPERTY Property, [in] ULONG PropertyLength, [in, out] void *PropertyData, [in] ULONG DataLength, [out] ULONG *BytesReturned)
HRESULT	KsMethod ([in] PKSMETHOD Method, [in] ULONG MethodLength, [in, out] void *MethodData, [in] ULONG DataLength, [out] ULONG *BytesReturned)
HRESULT	KsEvent ([in] PKSEVENT Event, [in] ULONG EventLength, [in, out] void *EventData, [in] ULONG DataLength, [out] ULONG *BytesReturned)

Protected Attributes
LONG	m_Ref
IFilterGraph *	m_pGraph
IReferenceClock *	m_ReferenceClock
FILTER_STATE	m_FilterState
HANDLE	m_hDevice
ProxyPluginVector	m_Plugins
PinVector	m_Pins
LPWSTR	m_DevicePath
CLSID	m_DeviceInterfaceGUID
HANDLE	m_hClock
CRITICAL_SECTION	m_Lock

Detailed Description

Definition at line 24 of file proxy.cpp.

Member Typedef Documentation

PinVector

typedef std::vector<IPin *> CKsProxy::PinVector

Definition at line 44 of file proxy.cpp.

ProxyPluginVector

typedef std::vector<IUnknown *> CKsProxy::ProxyPluginVector

Definition at line 43 of file proxy.cpp.

Constructor & Destructor Documentation

CKsProxy()

CKsProxy::CKsProxy

(

)

Definition at line 201 of file proxy.cpp.

                   : m_Ref(0),
                       m_pGraph(0),
                       m_FilterState(State_Stopped),
                       m_hDevice(0),
                       m_Plugins(),
                       m_Pins(),
                       m_DevicePath(0),
                       m_hClock(0)
{
    m_ReferenceClock = this;
    InitializeCriticalSection(&m_Lock);
}

~CKsProxy()

CKsProxy::~CKsProxy ( )

inline

Definition at line 167 of file proxy.cpp.

    {
        if (m_hDevice)
            CloseHandle(m_hDevice);
    };

Member Function Documentation

AdvisePeriodic()

HRESULT STDMETHODCALLTYPE CKsProxy::AdvisePeriodic	(	REFERENCE_TIME	startTime,
		REFERENCE_TIME	periodTime,
		HSEMAPHORE	hSemaphore,
		DWORD_PTR *	pdwAdviseCookie
	)

Implements IReferenceClock.

Definition at line 719 of file proxy.cpp.

{
    HRESULT hr;
    KSEVENT Property;
    ULONG BytesReturned;
    PKSEVENT_TIME_INTERVAL Event;

#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::AdvisePeriodic\n");
#endif

    //
    //FIXME locks
    //

    if (!pdwAdviseCookie)
        return E_POINTER;

    if (!m_hClock)
    {
        // create clock
        hr = CreateClockInstance();
        if (FAILED(hr))
            return hr;
    }

    // allocate event entry
    Event = (PKSEVENT_TIME_INTERVAL)CoTaskMemAlloc(sizeof(KSEVENT_TIME_INTERVAL));
    if (Event)
    {
        // setup request
        Property.Set = KSEVENTSETID_Clock;
        Property.Id = KSEVENT_CLOCK_INTERVAL_MARK;
        Property.Flags = KSEVENT_TYPE_ENABLE;

        Event->EventData.NotificationType = KSEVENTF_SEMAPHORE_HANDLE;
        Event->EventData.SemaphoreHandle.Semaphore = (HANDLE)hSemaphore;
        Event->EventData.SemaphoreHandle.Reserved = 0;
        Event->EventData.SemaphoreHandle.Adjustment = 1;
        Event->TimeBase = startTime;
        Event->Interval = periodTime;

        // perform request
        hr = KsSynchronousDeviceControl(m_hClock, IOCTL_KS_ENABLE_EVENT, (PVOID)&Property, sizeof(KSEVENT), (PVOID)Event, sizeof(KSEVENT_TIME_INTERVAL), &BytesReturned);
        if (SUCCEEDED(hr))
        {
            // store event handle
            *pdwAdviseCookie = (DWORD_PTR)Event;
        }
        else
        {
            // failed to enable event
            CoTaskMemFree(Event);
        }
    }
    else
    {
         hr = E_OUTOFMEMORY;
    }

    return hr;
}

AdviseTime()

HRESULT STDMETHODCALLTYPE CKsProxy::AdviseTime	(	REFERENCE_TIME	baseTime,
		REFERENCE_TIME	streamTime,
		HEVENT	hEvent,
		DWORD_PTR *	pdwAdviseCookie
	)

Implements IReferenceClock.

Definition at line 651 of file proxy.cpp.

{
    HRESULT hr;
    KSEVENT Property;
    ULONG BytesReturned;
    PKSEVENT_TIME_MARK Event;

#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::AdviseTime\n");
#endif

    //
    //FIXME locks
    //

    if (!pdwAdviseCookie)
        return E_POINTER;

    if (!m_hClock)
    {
        // create clock
        hr = CreateClockInstance();
        if (FAILED(hr))
            return hr;
    }

    // allocate event entry
    Event = (PKSEVENT_TIME_MARK)CoTaskMemAlloc(sizeof(KSEVENT_TIME_MARK));
    if (Event)
    {
        // setup request
        Property.Set = KSEVENTSETID_Clock;
        Property.Id = KSEVENT_CLOCK_POSITION_MARK;
        Property.Flags = KSEVENT_TYPE_ENABLE;

        Event->EventData.NotificationType = KSEVENTF_EVENT_HANDLE;
        Event->EventData.EventHandle.Event = (HANDLE)hEvent;
        Event->EventData.Alignment.Alignment[0] = 0;
        Event->EventData.Alignment.Alignment[1] = 0;
        Event->MarkTime = baseTime + streamTime;

        // perform request
        hr = KsSynchronousDeviceControl(m_hClock, IOCTL_KS_ENABLE_EVENT, (PVOID)&Property, sizeof(KSEVENT), (PVOID)Event, sizeof(KSEVENT_TIME_MARK), &BytesReturned);
        if (SUCCEEDED(hr))
        {
            // store event handle
            *pdwAdviseCookie = (DWORD_PTR)Event;
        }
        else
        {
            // failed to enable event
            CoTaskMemFree(Event);
        }
    }
    else
    {
         hr = E_OUTOFMEMORY;
    }

    return hr;
}

CheckCapabilities()

HRESULT STDMETHODCALLTYPE CKsProxy::CheckCapabilities

(

DWORD *

pCapabilities

)

Implements IMediaSeeking.

Definition at line 881 of file proxy.cpp.

{
    DWORD Capabilities;
    HRESULT hr;

#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::CheckCapabilities\n");
#endif

    if (!pCapabilities)
        return E_POINTER;

    if (!*pCapabilities)
        return E_FAIL;

    hr = GetCapabilities(&Capabilities);
    if (SUCCEEDED(hr))
    {
        if ((Capabilities | *pCapabilities) == Capabilities)
        {
            // all present
            return S_OK;
        }

        Capabilities = (Capabilities & *pCapabilities);
        if (Capabilities)
        {
            // not all present
            *pCapabilities = Capabilities;
            return S_FALSE;
        }
        // no capabilities are present
        return E_FAIL;
    }

    return hr;
}

ConvertTimeFormat()

HRESULT STDMETHODCALLTYPE CKsProxy::ConvertTimeFormat	(	LONGLONG *	pTarget,
		const GUID *	pTargetFormat,
		LONGLONG	Source,
		const GUID *	pSourceFormat
	)

Implements IMediaSeeking.

Definition at line 1358 of file proxy.cpp.

{
    KSP_TIMEFORMAT Property;
    ULONG BytesReturned, Index;
    GUID SourceFormat, TargetFormat;
    HRESULT hr;

    Property.Property.Set = KSPROPSETID_MediaSeeking;
    Property.Property.Id = KSPROPERTY_MEDIASEEKING_CONVERTTIMEFORMAT;
    Property.Property.Flags = KSPROPERTY_TYPE_GET;

#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::ConvertTimeFormat\n");
#endif

    if (!pTargetFormat)
    {
        // get current format
        hr = GetTimeFormat(&TargetFormat);
        if (FAILED(hr))
            return hr;

        pTargetFormat = &TargetFormat;
    }

    if (!pSourceFormat)
    {
        // get current format
        hr = GetTimeFormat(&SourceFormat);
        if (FAILED(hr))
            return hr;

        pSourceFormat = &SourceFormat;
    }

    Property.SourceFormat = *pSourceFormat;
    Property.TargetFormat = *pTargetFormat;
    Property.Time = Source;


    hr = KsSynchronousDeviceControl(m_hDevice, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSP_TIMEFORMAT), (PVOID)pTarget, sizeof(LONGLONG), &BytesReturned);
    if (hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_NOT_FOUND) || hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_SET_NOT_FOUND))
    {
        //default error
        hr = E_NOTIMPL;

        // check if plugins support it
        for(Index = 0; Index < m_Plugins.size(); Index++)
        {
            // get plugin
            IUnknown * Plugin = m_Plugins[Index];

            if (!Plugin)
               continue;

            // query for IMediaSeeking interface
            IMediaSeeking *pSeek = NULL;
            hr = Plugin->QueryInterface(IID_IMediaSeeking, (void**)&pSeek);
            if (SUCCEEDED(hr))
            {
                // convert time format
                hr = pSeek->ConvertTimeFormat(pTarget, pTargetFormat, Source, pSourceFormat);
                // release IMediaSeeking interface
                pSeek->Release();

                if (hr != S_FALSE) // plugin implements it
                     break;
            }
        }
    }

    return hr;
}

CreateClockInstance()

HRESULT STDMETHODCALLTYPE CKsProxy::CreateClockInstance

(

)

Definition at line 393 of file proxy.cpp.

{
    HRESULT hr;
    HANDLE hPin = INVALID_HANDLE_VALUE;
    ULONG Index;
    PIN_DIRECTION PinDir;
    IKsObject *pObject;
    KSCLOCK_CREATE ClockCreate;

    // find output pin and handle
    for(Index = 0; Index < m_Pins.size(); Index++)
    {
        //get pin
        IPin * pin = m_Pins[Index];
        if (!pin)
            continue;

        // get direction
        hr = pin->QueryDirection(&PinDir);
        if (FAILED(hr))
            continue;

        // query IKsObject interface
        hr = pin->QueryInterface(IID_IKsObject, (void**)&pObject);
        if (FAILED(hr))
            continue;


        // get pin handle
        hPin = pObject->KsGetObjectHandle();

        //release IKsObject
        pObject->Release();

        if (hPin != INVALID_HANDLE_VALUE)
            break;
    }

    if (hPin == INVALID_HANDLE_VALUE)
    {
        // clock can only be instantiated on a pin handle
        return E_NOTIMPL;
    }

    if (m_hClock)
    {
        // release clock handle
        CloseHandle(m_hClock);
    }

    //setup clock create request
    ClockCreate.CreateFlags = 0;

    // setup clock create request
    hr = KsCreateClock(hPin, &ClockCreate, &m_hClock); // FIXME KsCreateClock returns NTSTATUS
    if (SUCCEEDED(hr))
    {
        // failed to create clock
        return MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, GetLastError());
    }

    return S_OK;
}

Referenced by AdvisePeriodic(), AdviseTime(), GetTime(), PerformClockProperty(), and QueryInterface().

CreateNodeInstance()

HRESULT STDMETHODCALLTYPE CKsProxy::CreateNodeInstance	(	ULONG	NodeId,
		ULONG	Flags,
		ACCESS_MASK	DesiredAccess,
		IUnknown *	UnkOuter,
		REFGUID	InterfaceId,
		LPVOID *	Interface
	)

Definition at line 1883 of file proxy.cpp.

{
    HRESULT hr;

#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::CreateNodeInstance\n");
#endif

    *Interface = NULL;

    if (IsEqualIID(IID_IUnknown, InterfaceId) || !UnkOuter)
    {
        hr = CKsNode_Constructor(UnkOuter, m_hDevice, NodeId, DesiredAccess, InterfaceId, Interface);
    }
    else
    {
        // interface not supported
        hr = E_NOINTERFACE;
    }

    return hr;
}

CreatePins()

HRESULT STDMETHODCALLTYPE CKsProxy::CreatePins

(

)

Definition at line 2450 of file proxy.cpp.

{
    ULONG NumPins, Index;
    KSPIN_CINSTANCES Instances;
    KSPIN_DATAFLOW DataFlow;
    KSPIN_COMMUNICATION Communication;
    HRESULT hr;
    LPWSTR PinName;
    IPin * pPin;
    ULONG InputPin = 0;
    ULONG OutputPin = 0;

    // get number of pins
    hr = GetNumberOfPins(&NumPins);
    if (FAILED(hr))
        return hr;

    for(Index = 0; Index < NumPins; Index++)
    {
        // query current instance count
        hr = GetPinInstanceCount(Index, &Instances);
        if (FAILED(hr))
        {
#ifdef KSPROXY_TRACE
            WCHAR Buffer[100];
            swprintf(Buffer, L"CKsProxy::CreatePins GetPinInstanceCount failed with %lx\n", hr);
            OutputDebugStringW(Buffer);
#endif
            continue;
        }


        // query pin communication;
        hr = GetPinCommunication(Index, &Communication);
        if (FAILED(hr))
        {
#ifdef KSPROXY_TRACE
            WCHAR Buffer[100];
            swprintf(Buffer, L"CKsProxy::CreatePins GetPinCommunication failed with %lx\n", hr);
            OutputDebugStringW(Buffer);
#endif
            continue;
        }

        if (Instances.CurrentCount == Instances.PossibleCount)
        {
            // already maximum reached for this pin
#ifdef KSPROXY_TRACE
            WCHAR Buffer[100];
            swprintf(Buffer, L"CKsProxy::CreatePins Instances.CurrentCount == Instances.PossibleCount\n");
            OutputDebugStringW(Buffer);
#endif
            continue;
        }

        // get direction of pin
        hr = GetPinDataflow(Index, &DataFlow);
        if (FAILED(hr))
        {
#ifdef KSPROXY_TRACE
            WCHAR Buffer[100];
            swprintf(Buffer, L"CKsProxy::CreatePins GetPinDataflow failed with %lx\n", hr);
            OutputDebugStringW(Buffer);
#endif
            continue;
        }

        if (DataFlow == KSPIN_DATAFLOW_IN)
            hr = GetPinName(Index, DataFlow, InputPin, &PinName);
        else
            hr = GetPinName(Index, DataFlow, OutputPin, &PinName);

        if (FAILED(hr))
        {
#ifdef KSPROXY_TRACE
            WCHAR Buffer[100];
            swprintf(Buffer, L"CKsProxy::CreatePins GetPinName failed with %lx\n", hr);
            OutputDebugStringW(Buffer);
#endif
            continue;
        }

        // construct the pins
        if (DataFlow == KSPIN_DATAFLOW_IN)
        {
            hr = CInputPin_Constructor((IBaseFilter*)this, PinName, m_hDevice, Index, Communication, IID_IPin, (void**)&pPin);
            if (FAILED(hr))
            {
#ifdef KSPROXY_TRACE
                WCHAR Buffer[100];
                swprintf(Buffer, L"CKsProxy::CreatePins CInputPin_Constructor failed with %lx\n", hr);
                OutputDebugStringW(Buffer);
#endif
                CoTaskMemFree(PinName);
                continue;
            }
            InputPin++;
        }
        else
        {
            hr = COutputPin_Constructor((IBaseFilter*)this, PinName, Index, Communication, IID_IPin, (void**)&pPin);
            if (FAILED(hr))
            {
#ifdef KSPROXY_TRACE
                WCHAR Buffer[100];
                swprintf(Buffer, L"CKsProxy::CreatePins COutputPin_Constructor failed with %lx\n", hr);
                OutputDebugStringW(Buffer);
#endif
                CoTaskMemFree(PinName);
                continue;
            }
            OutputPin++;
        }

        // store pins
        m_Pins.push_back(pPin);

#ifdef KSPROXY_TRACE
        WCHAR Buffer[100];
        swprintf(Buffer, L"Index %lu DataFlow %lu Name %s\n", Index, DataFlow, PinName);
        OutputDebugStringW(Buffer);
#endif

    }

    return S_OK;
}

Referenced by Load().

DeviceInfo()

HRESULT STDMETHODCALLTYPE CKsProxy::DeviceInfo	(	CLSID *	pclsidInterfaceClass,
		LPWSTR *	pwszSymbolicLink
	)

Definition at line 2063 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::DeviceInfo\n");
#endif

    if (!m_DevicePath)
    {
        // object not initialized
        return MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_FILE_NOT_FOUND);
    }

    // copy device interface guid
    CopyMemory(pclsidInterfaceClass, &m_DeviceInterfaceGUID, sizeof(GUID));

    if (pwszSymbolicLink)
    {
        *pwszSymbolicLink = (LPWSTR)CoTaskMemAlloc((wcslen(m_DevicePath)+1) * sizeof(WCHAR));
        if (!*pwszSymbolicLink)
            return E_OUTOFMEMORY;

        wcscpy(*pwszSymbolicLink, m_DevicePath);
    }
    return S_OK;
}

Disassociate()

HRESULT STDMETHODCALLTYPE CKsProxy::Disassociate

(

void

)

Definition at line 2115 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::Disassociate\n");
#endif

    if (!m_hDevice)
        return E_HANDLE;

    CloseHandle(m_hDevice);
    m_hDevice = NULL;
    return NOERROR;
}

EnumPins()

HRESULT STDMETHODCALLTYPE CKsProxy::EnumPins

(

IEnumPins **

ppEnum

)

Implements IBaseFilter.

Definition at line 3030 of file proxy.cpp.

{
    return CEnumPins_fnConstructor(m_Pins, IID_IEnumPins, (void**)ppEnum);
}

FindPin()

HRESULT STDMETHODCALLTYPE CKsProxy::FindPin	(	LPCWSTR	Id,
		IPin **	ppPin
	)

Implements IBaseFilter.

Definition at line 3038 of file proxy.cpp.

{
    ULONG PinId;

#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::FindPin\n");
#endif

    if (!ppPin)
        return E_POINTER;

    // convert to pin
    int ret = swscanf(Id, L"%u", &PinId);

    if (!ret || ret == EOF)
    {
        // invalid id
        return VFW_E_NOT_FOUND;
    }

    if (PinId >= m_Pins.size() || m_Pins[PinId] == NULL)
    {
        // invalid id
        return VFW_E_NOT_FOUND;
    }

    // found pin
    *ppPin = m_Pins[PinId];
    m_Pins[PinId]->AddRef();

    return S_OK;
}

Get()

HRESULT STDMETHODCALLTYPE CKsProxy::Get	(	REFGUID	guidPropSet,
		DWORD	dwPropID,
		LPVOID	pInstanceData,
		DWORD	cbInstanceData,
		LPVOID	pPropData,
		DWORD	cbPropData,
		DWORD *	pcbReturned
	)

Implements IKsPropertySet.

Definition at line 1812 of file proxy.cpp.

{
    ULONG BytesReturned;

#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::Get\n");
#endif

    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;
    }
}

GetAvailable()

HRESULT STDMETHODCALLTYPE CKsProxy::GetAvailable	(	LONGLONG *	pEarliest,
		LONGLONG *	pLatest
	)

Implements IMediaSeeking.

Definition at line 1534 of file proxy.cpp.

{
    KSPROPERTY Property;
    KSPROPERTY_MEDIAAVAILABLE Media;
    ULONG BytesReturned, Index;
    HRESULT hr;

    Property.Set = KSPROPSETID_MediaSeeking;
    Property.Id = KSPROPERTY_MEDIASEEKING_AVAILABLE;
    Property.Flags = KSPROPERTY_TYPE_GET;

#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::GetAvailable\n");
#endif

    hr = KsSynchronousDeviceControl(m_hDevice, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), (PVOID)&Media, sizeof(KSPROPERTY_MEDIAAVAILABLE), &BytesReturned);
    if (hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_NOT_FOUND) || hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_SET_NOT_FOUND))
    {
        // check if plugins support it
        for(Index = 0; Index < m_Plugins.size(); Index++)
        {
            hr = E_NOTIMPL;
            // get plugin
            IUnknown * Plugin = m_Plugins[Index];

            if (!Plugin)
               continue;

            // query for IMediaSeeking interface
            IMediaSeeking *pSeek = NULL;
            hr = Plugin->QueryInterface(IID_IMediaSeeking, (void**)&pSeek);
            if (SUCCEEDED(hr))
            {
                // delegate call
                hr = pSeek->GetAvailable(pEarliest, pLatest);
                // release IMediaSeeking interface
                pSeek->Release();

                if (hr != S_FALSE) // plugin implements it
                     break;
            }
        }
    }
    else if (SUCCEEDED(hr))
    {
        *pEarliest = Media.Earliest;
        *pLatest = Media.Latest;
    }

    return hr;
}

GetCapabilities()

HRESULT STDMETHODCALLTYPE CKsProxy::GetCapabilities

(

DWORD *

pCapabilities

)

Implements IMediaSeeking.

Definition at line 822 of file proxy.cpp.

{
    KSPROPERTY Property;
    ULONG BytesReturned, Index;
    HRESULT hr = S_OK;
    DWORD TempCaps;

    Property.Set = KSPROPSETID_MediaSeeking;
    Property.Id = KSPROPERTY_MEDIASEEKING_CAPABILITIES;
    Property.Flags = KSPROPERTY_TYPE_GET;

#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::GetCapabilities\n");
#endif


    if (!pCapabilities)
        return E_POINTER;


    *pCapabilities = (KS_SEEKING_CanSeekAbsolute | KS_SEEKING_CanSeekForwards | KS_SEEKING_CanSeekBackwards | KS_SEEKING_CanGetCurrentPos |
                      KS_SEEKING_CanGetStopPos | KS_SEEKING_CanGetDuration | KS_SEEKING_CanPlayBackwards);

    KsSynchronousDeviceControl(m_hDevice, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), (PVOID)&pCapabilities, sizeof(KS_SEEKING_CAPABILITIES), &BytesReturned);
    // check if plugins support it
    for(Index = 0; Index < m_Plugins.size(); Index++)
    {
        // get plugin
        IUnknown * Plugin = m_Plugins[Index];

        if (!Plugin)
           continue;

        // query for IMediaSeeking interface
        IMediaSeeking *pSeek = NULL;
        hr = Plugin->QueryInterface(IID_IMediaSeeking, (void**)&pSeek);
        if (FAILED(hr))
        {
            *pCapabilities = 0;
            return hr;
        }

        TempCaps = 0;
        // set time format
        hr = pSeek->GetCapabilities(&TempCaps);
        if (SUCCEEDED(hr))
        {
            // and with supported flags
            *pCapabilities = (*pCapabilities & TempCaps);
        }
        // release IMediaSeeking interface
        pSeek->Release();
    }
    return hr;
}

Referenced by CheckCapabilities().

GetClassID()

HRESULT STDMETHODCALLTYPE CKsProxy::GetClassID

(

CLSID *

pClassID

)

Implements IPersist.

Definition at line 2704 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::GetClassID\n");
#endif
    CopyMemory(pClassID, &CLSID_Proxy, sizeof(GUID));

    return S_OK;
}

GetCurrentPosition()

HRESULT STDMETHODCALLTYPE CKsProxy::GetCurrentPosition

(

LONGLONG *

pCurrent

)

Implements IMediaSeeking.

Definition at line 1310 of file proxy.cpp.

{
    KSPROPERTY Property;
    ULONG BytesReturned, Index;
    HRESULT hr;

    Property.Set = KSPROPSETID_MediaSeeking;
    Property.Id = KSPROPERTY_MEDIASEEKING_POSITION;
    Property.Flags = KSPROPERTY_TYPE_GET;

#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::GetCurrentPosition\n");
#endif

    hr = KsSynchronousDeviceControl(m_hDevice, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), (PVOID)pCurrent, sizeof(LONGLONG), &BytesReturned);
    if (hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_NOT_FOUND) || hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_SET_NOT_FOUND))
    {
        // check if plugins support it
        for(Index = 0; Index < m_Plugins.size(); Index++)
        {
            hr = E_NOTIMPL;
            // get plugin
            IUnknown * Plugin = m_Plugins[Index];

            if (!Plugin)
               continue;

            // query for IMediaSeeking interface
            IMediaSeeking *pSeek = NULL;
            hr = Plugin->QueryInterface(IID_IMediaSeeking, (void**)&pSeek);
            if (SUCCEEDED(hr))
            {
                // get current position
                hr = pSeek->GetCurrentPosition(pCurrent);
                // release IMediaSeeking interface
                pSeek->Release();

                if (hr != S_FALSE) // plugin implements it
                     break;
            }
        }
    }
    return hr;
}

Referenced by GetPositions(), and SetPositions().

GetDuration()

HRESULT STDMETHODCALLTYPE CKsProxy::GetDuration

(

LONGLONG *

pDuration

)

Implements IMediaSeeking.

Definition at line 1214 of file proxy.cpp.

{
    KSPROPERTY Property;
    ULONG BytesReturned, Index;
    HRESULT hr;

    Property.Set = KSPROPSETID_MediaSeeking;
    Property.Id = KSPROPERTY_MEDIASEEKING_DURATION;
    Property.Flags = KSPROPERTY_TYPE_GET;

#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::GetDuration\n");
#endif

    hr = KsSynchronousDeviceControl(m_hDevice, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), (PVOID)pDuration, sizeof(LONGLONG), &BytesReturned);
    if (hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_NOT_FOUND) || hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_SET_NOT_FOUND))
    {
        // check if plugins support it
        for(Index = 0; Index < m_Plugins.size(); Index++)
        {
            hr = E_NOTIMPL;
            // get plugin
            IUnknown * Plugin = m_Plugins[Index];

            if (!Plugin)
               continue;

            // query for IMediaSeeking interface
            IMediaSeeking *pSeek = NULL;
            hr = Plugin->QueryInterface(IID_IMediaSeeking, (void**)&pSeek);
            if (SUCCEEDED(hr))
            {
                // get duration
                hr = pSeek->GetStopPosition(pDuration);
                // release IMediaSeeking interface
                pSeek->Release();

                if (hr != S_FALSE) // plugin implements it
                     break;
            }
        }
    }
    return hr;
}

GetMediaSeekingFormats()

HRESULT STDMETHODCALLTYPE CKsProxy::GetMediaSeekingFormats

(

PKSMULTIPLE_ITEM *

FormatList

)

Definition at line 922 of file proxy.cpp.

{
    KSPROPERTY Property;
    HRESULT hr;
    ULONG BytesReturned;

    Property.Set = KSPROPSETID_MediaSeeking;
    Property.Id = KSPROPERTY_MEDIASEEKING_FORMATS;
    Property.Flags = KSPROPERTY_TYPE_GET;

    // query for format size list
    hr = KsSynchronousDeviceControl(m_hDevice, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), NULL, 0, &BytesReturned);

    if (hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_MORE_DATA))
    {
        // allocate format list
        *FormatList = (PKSMULTIPLE_ITEM)CoTaskMemAlloc(BytesReturned);
        if (!*FormatList)
        {
            // not enough memory
            return E_OUTOFMEMORY;
        }

        // get format list
        hr = KsSynchronousDeviceControl(m_hDevice, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), (PVOID)*FormatList, BytesReturned, &BytesReturned);
        if (FAILED(hr))
        {
            // failed to query format list
            CoTaskMemFree(FormatList);
        }
    }
    return hr;
}

Referenced by IsFormatSupported(), and QueryPreferredFormat().

GetMiscFlags()

ULONG STDMETHODCALLTYPE CKsProxy::GetMiscFlags

(

void

)

Implements IAMFilterMiscFlags.

Definition at line 1664 of file proxy.cpp.

{
    ULONG Index;
    ULONG Flags = 0;
    HRESULT hr;
    PIN_DIRECTION PinDirection;
    KSPIN_COMMUNICATION Communication;


    for(Index = 0; Index < m_Pins.size(); Index++)
    {
        // get current pin
        IPin * pin = m_Pins[Index];
        // query direction
        hr = pin->QueryDirection(&PinDirection);
        if (SUCCEEDED(hr))
        {
            if (PinDirection == PINDIR_INPUT)
            {
                if (SUCCEEDED(GetPinCommunication(Index, //FIXME verify PinId
                                        &Communication)))
                {
                    if (Communication != KSPIN_COMMUNICATION_NONE && Communication != KSPIN_COMMUNICATION_BRIDGE)
                    {
                        Flags |= AM_FILTER_MISC_FLAGS_IS_SOURCE;
                    }
                }
            }
        }
    }

#ifdef KSPROXY_TRACE
    WCHAR Buffer[100];
    swprintf(Buffer, L"CKsProxy::GetMiscFlags stub Flags %x\n", Flags);
    OutputDebugStringW(Buffer);
#endif

    return Flags;
}

GetNumberOfPins()

HRESULT STDMETHODCALLTYPE CKsProxy::GetNumberOfPins

(

PULONG

NumPins

)

Definition at line 2307 of file proxy.cpp.

{
    KSPROPERTY Property;
    ULONG BytesReturned;

    // setup request
    Property.Set = KSPROPSETID_Pin;
    Property.Id = KSPROPERTY_PIN_CTYPES;
    Property.Flags = KSPROPERTY_TYPE_GET;

    return KsSynchronousDeviceControl(m_hDevice, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), (PVOID)NumPins, sizeof(ULONG), &BytesReturned);
}

Referenced by CreatePins().

GetPages()

HRESULT STDMETHODCALLTYPE CKsProxy::GetPages

(

CAUUID *

pPages

)

Implements ISpecifyPropertyPages.

Definition at line 372 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::GetPages NotImplemented\n");
#endif

    if (!pPages)
        return E_POINTER;

    pPages->cElems = 0;
    pPages->pElems = NULL;

    return S_OK;
}

GetPinCommunication()

HRESULT STDMETHODCALLTYPE CKsProxy::GetPinCommunication	(	ULONG	PinId,
		KSPIN_COMMUNICATION *	Communication
	)

Definition at line 2342 of file proxy.cpp.

{
    KSP_PIN Property;
    ULONG BytesReturned;

    // setup request
    Property.Property.Set = KSPROPSETID_Pin;
    Property.Property.Id = KSPROPERTY_PIN_COMMUNICATION;
    Property.Property.Flags = KSPROPERTY_TYPE_GET;
    Property.PinId = PinId;
    Property.Reserved = 0;

    return KsSynchronousDeviceControl(m_hDevice, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSP_PIN), (PVOID)Communication, sizeof(KSPIN_COMMUNICATION), &BytesReturned);
}

Referenced by CreatePins(), and GetMiscFlags().

GetPinDataflow()

HRESULT STDMETHODCALLTYPE CKsProxy::GetPinDataflow	(	ULONG	PinId,
		KSPIN_DATAFLOW *	DataFlow
	)

Definition at line 2361 of file proxy.cpp.

{
    KSP_PIN Property;
    ULONG BytesReturned;

    // setup request
    Property.Property.Set = KSPROPSETID_Pin;
    Property.Property.Id = KSPROPERTY_PIN_DATAFLOW;
    Property.Property.Flags = KSPROPERTY_TYPE_GET;
    Property.PinId = PinId;
    Property.Reserved = 0;

    return KsSynchronousDeviceControl(m_hDevice, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSP_PIN), (PVOID)DataFlow, sizeof(KSPIN_DATAFLOW), &BytesReturned);
}

Referenced by CreatePins().

GetPinInstanceCount()

HRESULT STDMETHODCALLTYPE CKsProxy::GetPinInstanceCount	(	ULONG	PinId,
		PKSPIN_CINSTANCES	Instances
	)

Definition at line 2323 of file proxy.cpp.

{
    KSP_PIN Property;
    ULONG BytesReturned;

    // setup request
    Property.Property.Set = KSPROPSETID_Pin;
    Property.Property.Id = KSPROPERTY_PIN_CINSTANCES;
    Property.Property.Flags = KSPROPERTY_TYPE_GET;
    Property.PinId = PinId;
    Property.Reserved = 0;

    return KsSynchronousDeviceControl(m_hDevice, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSP_PIN), (PVOID)Instances, sizeof(KSPIN_CINSTANCES), &BytesReturned);
}

Referenced by CreatePins().

GetPinName()

HRESULT STDMETHODCALLTYPE CKsProxy::GetPinName	(	ULONG	PinId,
		KSPIN_DATAFLOW	DataFlow,
		ULONG	PinCount,
		LPWSTR *	OutPinName
	)

Definition at line 2380 of file proxy.cpp.

{
    KSP_PIN Property;
    LPWSTR PinName;
    ULONG BytesReturned;
    HRESULT hr;
    WCHAR Buffer[100];

    // setup request
    Property.Property.Set = KSPROPSETID_Pin;
    Property.Property.Id = KSPROPERTY_PIN_NAME;
    Property.Property.Flags = KSPROPERTY_TYPE_GET;
    Property.PinId = PinId;
    Property.Reserved = 0;

    // #1 try get it from pin directly
    hr = KsSynchronousDeviceControl(m_hDevice, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSP_PIN), NULL, 0, &BytesReturned);

    if (hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_MORE_DATA))
    {
        // allocate pin name
        PinName = (LPWSTR)CoTaskMemAlloc(BytesReturned);
        if (!PinName)
            return E_OUTOFMEMORY;

        // retry with allocated buffer
        hr = KsSynchronousDeviceControl(m_hDevice, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSP_PIN), PinName, BytesReturned, &BytesReturned);
        if (SUCCEEDED(hr))
        {
            *OutPinName = PinName;
            return hr;
        }

        //free buffer
        CoTaskMemFree(PinName);
    }

    //
    // TODO: retrieve pin name from topology node
    //

    if (DataFlow == KSPIN_DATAFLOW_IN)
    {
        swprintf(Buffer, L"Input%lu", PinCount);
    }
    else
    {
        swprintf(Buffer, L"Output%lu", PinCount);
    }

    // allocate pin name 
    PinName = (LPWSTR)CoTaskMemAlloc((wcslen(Buffer)+1) * sizeof(WCHAR));
    if (!PinName)
        return E_OUTOFMEMORY;

    // copy pin name
    wcscpy(PinName, Buffer);

    // store result
    *OutPinName = PinName;
    // done
    return S_OK;
}

Referenced by CreatePins().

GetPositions()

HRESULT STDMETHODCALLTYPE CKsProxy::GetPositions	(	LONGLONG *	pCurrent,
		LONGLONG *	pStop
	)

Implements IMediaSeeking.

Definition at line 1515 of file proxy.cpp.

{
    HRESULT hr;

#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::GetPositions\n");
#endif

    hr = GetCurrentPosition(pCurrent);
    if (SUCCEEDED(hr))
        hr = GetStopPosition(pStop);

    return hr;
}

GetPreroll()

HRESULT STDMETHODCALLTYPE CKsProxy::GetPreroll

(

LONGLONG *

pllPreroll

)

Implements IMediaSeeking.

Definition at line 1612 of file proxy.cpp.

{
    KSPROPERTY Property;
    ULONG BytesReturned, Index;
    HRESULT hr;

    Property.Set = KSPROPSETID_MediaSeeking;
    Property.Id = KSPROPERTY_MEDIASEEKING_PREROLL;
    Property.Flags = KSPROPERTY_TYPE_GET;

#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::GetPreroll\n");
#endif

    hr = KsSynchronousDeviceControl(m_hDevice, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), (PVOID)pllPreroll, sizeof(LONGLONG), &BytesReturned);
    if (hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_NOT_FOUND) || hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_SET_NOT_FOUND))
    {
        // check if all plugins support it
        for(Index = 0; Index < m_Plugins.size(); Index++)
        {
            // get plugin
            IUnknown * Plugin = m_Plugins[Index];

            if (!Plugin)
               continue;

            // query for IMediaSeeking interface
            IMediaSeeking *pSeek = NULL;
            hr = Plugin->QueryInterface(IID_IMediaSeeking, (void**)&pSeek);
            if (SUCCEEDED(hr))
            {
                // get preroll
                hr = pSeek->GetPreroll(pllPreroll);
                // release IMediaSeeking interface
                pSeek->Release();

                if (hr != S_FALSE) // plugin implements it
                     break;
            }
        }
        hr = E_NOTIMPL;
    }
    return hr;
}

GetRate()

HRESULT STDMETHODCALLTYPE CKsProxy::GetRate

(

double *

pdRate

)

Implements IMediaSeeking.

Definition at line 1601 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::GetRate\n");
#endif
    return E_NOTIMPL;
}

GetSizeMax()

HRESULT STDMETHODCALLTYPE CKsProxy::GetSizeMax

(

ULARGE_INTEGER *

pcbSize

)

Implements IPersistStream.

Definition at line 2047 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::GetSizeMax Notimplemented\n");
#endif

    return E_NOTIMPL;
}

GetState()

HRESULT STDMETHODCALLTYPE CKsProxy::GetState	(	DWORD	dwMilliSecsTimeout,
		FILTER_STATE *	State
	)

Implements IMediaFilter.

Definition at line 2881 of file proxy.cpp.

{
    if (!State)
        return E_POINTER;

    *State = m_FilterState;
    return S_OK;
}

GetStopPosition()

HRESULT STDMETHODCALLTYPE CKsProxy::GetStopPosition

(

LONGLONG *

pStop

)

Implements IMediaSeeking.

Definition at line 1262 of file proxy.cpp.

{
    KSPROPERTY Property;
    ULONG BytesReturned, Index;
    HRESULT hr;

    Property.Set = KSPROPSETID_MediaSeeking;
    Property.Id = KSPROPERTY_MEDIASEEKING_STOPPOSITION;
    Property.Flags = KSPROPERTY_TYPE_GET;

#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::GetStopPosition\n");
#endif

    hr = KsSynchronousDeviceControl(m_hDevice, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), (PVOID)pStop, sizeof(LONGLONG), &BytesReturned);
    if (hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_NOT_FOUND) || hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_SET_NOT_FOUND))
    {
        // check if plugins support it
        for(Index = 0; Index < m_Plugins.size(); Index++)
        {
            hr = E_NOTIMPL;
            // get plugin
            IUnknown * Plugin = m_Plugins[Index];

            if (!Plugin)
               continue;

            // query for IMediaSeeking interface
            IMediaSeeking *pSeek = NULL;
            hr = Plugin->QueryInterface(IID_IMediaSeeking, (void**)&pSeek);
            if (SUCCEEDED(hr))
            {
                // get stop position
                hr = pSeek->GetStopPosition(pStop);
                // release IMediaSeeking interface
                pSeek->Release();

                if (hr != S_FALSE) // plugin implements it
                     break;
            }
        }
    }
    return hr;
}

Referenced by GetPositions(), and SetPositions().

GetSupportedSets()

HRESULT STDMETHODCALLTYPE CKsProxy::GetSupportedSets	(	LPGUID *	pOutGuid,
		PULONG	NumGuids
	)

Definition at line 2176 of file proxy.cpp.

{
    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_hDevice, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), NULL, 0, &NumProperty);
    KsSynchronousDeviceControl(m_hDevice, IOCTL_KS_METHOD, (PVOID)&Property, sizeof(KSPROPERTY), NULL, 0, &NumMethods);
    KsSynchronousDeviceControl(m_hDevice, IOCTL_KS_ENABLE_EVENT, (PVOID)&Property, sizeof(KSPROPERTY), NULL, 0, &NumEvents);

    Length = NumProperty + NumMethods + NumEvents;

    // 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_hDevice, 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)
    {
        hr = KsSynchronousDeviceControl(m_hDevice, 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)
    {
        hr = KsSynchronousDeviceControl(m_hDevice, 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;
}

Referenced by Load().

GetSyncSource()

HRESULT STDMETHODCALLTYPE CKsProxy::GetSyncSource

(

IReferenceClock **

pClock

)

Implements IMediaFilter.

Definition at line 3011 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::GetSyncSource\n");
#endif

    if (!pClock)
        return E_POINTER;

    if (m_ReferenceClock)
        m_ReferenceClock->AddRef();

    *pClock = m_ReferenceClock;
    return S_OK;
}

GetTime()

HRESULT STDMETHODCALLTYPE CKsProxy::GetTime

(

REFERENCE_TIME *

pTime

)

Implements IReferenceClock.

Definition at line 608 of file proxy.cpp.

{
    HRESULT hr;
    KSPROPERTY Property;
    ULONG BytesReturned;

#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::GetTime\n");
#endif

    if (!pTime)
        return E_POINTER;

    //
    //FIXME locks
    //

    if (!m_hClock)
    {
        // create clock
        hr = CreateClockInstance();
        if (FAILED(hr))
            return hr;
    }

    // setup request
    Property.Set = KSPROPSETID_Clock;
    Property.Id = KSPROPERTY_CLOCK_TIME;
    Property.Flags = KSPROPERTY_TYPE_GET;

    // perform request
    hr = KsSynchronousDeviceControl(m_hClock, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), (PVOID)pTime, sizeof(REFERENCE_TIME), &BytesReturned);

    // TODO
    // increment value
    //

    return hr;
}

GetTimeFormat()

HRESULT STDMETHODCALLTYPE CKsProxy::GetTimeFormat

(

GUID *

pFormat

)

Implements IMediaSeeking.

Definition at line 1096 of file proxy.cpp.

{
    KSPROPERTY Property;
    ULONG BytesReturned, Index;
    HRESULT hr;

    Property.Set = KSPROPSETID_MediaSeeking;
    Property.Id = KSPROPERTY_MEDIASEEKING_TIMEFORMAT;
    Property.Flags = KSPROPERTY_TYPE_GET;

#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::GetTimeFormat\n");
#endif

    hr = KsSynchronousDeviceControl(m_hDevice, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), (PVOID)pFormat, sizeof(GUID), &BytesReturned);
    if (hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_NOT_FOUND) || hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_SET_NOT_FOUND))
    {
        // check if plugins support it
        for(Index = 0; Index < m_Plugins.size(); Index++)
        {
            hr = E_NOTIMPL;
            // get plugin
            IUnknown * Plugin = m_Plugins[Index];

            if (!Plugin)
               continue;

            // query for IMediaSeeking interface
            IMediaSeeking *pSeek = NULL;
            hr = Plugin->QueryInterface(IID_IMediaSeeking, (void**)&pSeek);
            if (SUCCEEDED(hr))
            {
                // set time format
                hr = pSeek->GetTimeFormat(pFormat);
                // release IMediaSeeking interface
                pSeek->Release();

                if (hr != S_FALSE)
                    break;
            }
        }
    }
    return hr;
}

Referenced by ConvertTimeFormat().

InitNew()

HRESULT STDMETHODCALLTYPE CKsProxy::InitNew

(

void

)

Implements IPersistPropertyBag.

Definition at line 2165 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::InitNew\n");
#endif

    return S_OK;
}

IsDirty()

HRESULT STDMETHODCALLTYPE CKsProxy::IsDirty

(

void

)

Implements IPersistStream.

Definition at line 1945 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::IsDirty Notimplemented\n");
#endif
    return E_NOTIMPL;
}

IsFormatSupported()

HRESULT STDMETHODCALLTYPE CKsProxy::IsFormatSupported

(

const GUID *

pFormat

)

Implements IMediaSeeking.

Definition at line 959 of file proxy.cpp.

{
    PKSMULTIPLE_ITEM FormatList;
    LPGUID pGuid;
    ULONG Index;
    HRESULT hr = S_FALSE;

#ifdef KSPROXY_TRACE
    WCHAR Buffer[100];
    LPOLESTR pstr;
    StringFromCLSID(*pFormat, &pstr);
    swprintf(Buffer, L"CKsProxy::IsFormatSupported %s\n",pstr);
    OutputDebugStringW(Buffer);
#endif

    if (!pFormat)
        return E_POINTER;

    // get media formats
    hr = GetMediaSeekingFormats(&FormatList);
    if (SUCCEEDED(hr))
    {
#ifdef KSPROXY_TRACE
        swprintf(Buffer, L"CKsProxy::IsFormatSupported NumFormat %lu\n",FormatList->Count);
        OutputDebugStringW(Buffer);
#endif

        //iterate through format list
        pGuid = (LPGUID)(FormatList + 1);
        for(Index = 0; Index < FormatList->Count; Index++)
        {
            if (IsEqualGUID(*pGuid, *pFormat))
            {
                CoTaskMemFree(FormatList);
                return S_OK;
            }
            pGuid++;
        }
        // free format list
        CoTaskMemFree(FormatList);
    }

    // check if all plugins support it
    for(Index = 0; Index < m_Plugins.size(); Index++)
    {
        // get plugin
        IUnknown * Plugin = m_Plugins[Index];

        if (!Plugin)
            continue;

        // query for IMediaSeeking interface
        IMediaSeeking *pSeek = NULL;
        hr = Plugin->QueryInterface(IID_IMediaSeeking, (void**)&pSeek);
        if (FAILED(hr))
        {
            // plugin does not support interface
            hr = S_FALSE;
#ifdef KSPROXY_TRACE
            OutputDebugStringW(L"CKsProxy::IsFormatSupported plugin does not support IMediaSeeking interface\n");
#endif
            break;
        }

        // query if it is supported
        hr = pSeek->IsFormatSupported(pFormat);
        // release interface
        pSeek->Release();

        if (FAILED(hr) || hr == S_FALSE)
            break;
    }

    return hr;
}

IsUsingTimeFormat()

HRESULT STDMETHODCALLTYPE CKsProxy::IsUsingTimeFormat

(

const GUID *

pFormat

)

Implements IMediaSeeking.

Definition at line 1144 of file proxy.cpp.

{
    GUID Format;

#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::IsUsingTimeFormat\n");
#endif

    if (FAILED(QueryPreferredFormat(&Format)))
        return S_FALSE;

    if (IsEqualGUID(Format, *pFormat))
        return S_OK;
    else
        return S_FALSE;
}

JoinFilterGraph()

HRESULT STDMETHODCALLTYPE CKsProxy::JoinFilterGraph	(	IFilterGraph *	pGraph,
		LPCWSTR	pName
	)

Implements IBaseFilter.

Definition at line 3096 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    WCHAR Buffer[100];
    swprintf(Buffer, L"CKsProxy::JoinFilterGraph pName %s pGraph %p m_Ref %u\n", pName, pGraph, m_Ref);
    OutputDebugStringW(Buffer);
#endif

    if (pGraph)
    {
        // joining filter graph
        m_pGraph = pGraph;
    }
    else
    {
        // leaving graph
        m_pGraph = 0;
    }

    return S_OK;
}

KsAddAggregate()

HRESULT STDMETHODCALLTYPE CKsProxy::KsAddAggregate

(

IN REFGUID

AggregateClass

)

Definition at line 1917 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::KsAddAggregate NotImplemented\n");
#endif
    return E_NOTIMPL;
}

KsEvent()

HRESULT STDMETHODCALLTYPE CKsProxy::KsEvent	(	PKSEVENT	Event,
		ULONG	EventLength,
		LPVOID	EventData,
		ULONG	DataLength,
		ULONG *	BytesReturned
	)

Definition at line 1743 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::KsEvent\n");
#endif

    assert(m_hDevice != 0);
    if (EventLength)
        return KsSynchronousDeviceControl(m_hDevice, IOCTL_KS_ENABLE_EVENT, (PVOID)Event, EventLength, (PVOID)EventData, DataLength, BytesReturned);
    else
        return KsSynchronousDeviceControl(m_hDevice, IOCTL_KS_DISABLE_EVENT, (PVOID)Event, EventLength, NULL, 0, BytesReturned);
}

KsGetClockHandle()

HANDLE STDMETHODCALLTYPE CKsProxy::KsGetClockHandle

(

)

Definition at line 2135 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::KsGetClockHandle\n");
#endif

    return m_hClock;
}

KsGetCorrelatedPhysicalTime()

HRESULT STDMETHODCALLTYPE CKsProxy::KsGetCorrelatedPhysicalTime

(

KSCORRELATED_TIME *

CorrelatedTime

)

Definition at line 560 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::KsGetCorrelatedPhysicalTime\n");
#endif
    return PerformClockProperty(KSPROPERTY_CLOCK_CORRELATEDPHYSICALTIME, KSPROPERTY_TYPE_GET, (PVOID)CorrelatedTime, sizeof(KSCORRELATED_TIME));
}

KsGetCorrelatedTime()

HRESULT STDMETHODCALLTYPE CKsProxy::KsGetCorrelatedTime

(

KSCORRELATED_TIME *

CorrelatedTime

)

Definition at line 537 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::KsGetCorrelatedTime\n");
#endif

    return PerformClockProperty(KSPROPERTY_CLOCK_CORRELATEDTIME, KSPROPERTY_TYPE_GET, (PVOID)CorrelatedTime, sizeof(KSCORRELATED_TIME));
}

KsGetObjectHandle()

HANDLE STDMETHODCALLTYPE CKsProxy::KsGetObjectHandle

(

)

Definition at line 2151 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::KsGetObjectHandle\n");
#endif

    return m_hDevice;
}

KsGetPhysicalTime()

HRESULT STDMETHODCALLTYPE CKsProxy::KsGetPhysicalTime

(

LONGLONG *

Time

)

Definition at line 513 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::KsGetPhysicalTime\n");
#endif

    return PerformClockProperty(KSPROPERTY_CLOCK_PHYSICALTIME, KSPROPERTY_TYPE_GET, (PVOID)Time, sizeof(LONGLONG));
}

KsGetResolution()

HRESULT STDMETHODCALLTYPE CKsProxy::KsGetResolution

(

KSRESOLUTION *

Resolution

)

Definition at line 583 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::KsGetResolution\n");
#endif
    return PerformClockProperty(KSPROPERTY_CLOCK_RESOLUTION, KSPROPERTY_TYPE_GET, (PVOID)Resolution, sizeof(KSRESOLUTION));
}

KsGetState()

HRESULT STDMETHODCALLTYPE CKsProxy::KsGetState

(

KSSTATE *

State

)

Definition at line 594 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::KsGetState\n");
#endif
    return PerformClockProperty(KSPROPERTY_CLOCK_STATE, KSPROPERTY_TYPE_GET, (PVOID)State, sizeof(KSSTATE));
}

KsGetTime()

HRESULT STDMETHODCALLTYPE CKsProxy::KsGetTime

(

LONGLONG *

Time

)

Definition at line 489 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::KsGetTime\n");
#endif

    return PerformClockProperty(KSPROPERTY_CLOCK_TIME, KSPROPERTY_TYPE_GET, (PVOID)Time, sizeof(LONGLONG));
}

KsMethod()

HRESULT STDMETHODCALLTYPE CKsProxy::KsMethod	(	PKSMETHOD	Method,
		ULONG	MethodLength,
		LPVOID	MethodData,
		ULONG	DataLength,
		ULONG *	BytesReturned
	)

Definition at line 1726 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::KsMethod\n");
#endif

    assert(m_hDevice != 0);
    return KsSynchronousDeviceControl(m_hDevice, IOCTL_KS_METHOD, (PVOID)Method, MethodLength, (PVOID)MethodData, DataLength, BytesReturned);
}

KsProperty()

HRESULT STDMETHODCALLTYPE CKsProxy::KsProperty	(	PKSPROPERTY	Property,
		ULONG	PropertyLength,
		LPVOID	PropertyData,
		ULONG	DataLength,
		ULONG *	BytesReturned
	)

Definition at line 1709 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::KsProperty\n");
#endif

    assert(m_hDevice != 0);
    return KsSynchronousDeviceControl(m_hDevice, IOCTL_KS_PROPERTY, (PVOID)Property, PropertyLength, (PVOID)PropertyData, DataLength, BytesReturned);
}

Referenced by Get(), QuerySupported(), and Set().

KsRemoveAggregate()

HRESULT STDMETHODCALLTYPE CKsProxy::KsRemoveAggregate

(

REFGUID

AggregateClass

)

Definition at line 1928 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::KsRemoveAggregate NotImplemented\n");
#endif

    return E_NOTIMPL;
}

KsSetCorrelatedPhysicalTime()

HRESULT STDMETHODCALLTYPE CKsProxy::KsSetCorrelatedPhysicalTime

(

KSCORRELATED_TIME *

CorrelatedTime

)

Definition at line 571 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::KsSetCorrelatedPhysicalTime\n");
#endif

    return PerformClockProperty(KSPROPERTY_CLOCK_CORRELATEDPHYSICALTIME, KSPROPERTY_TYPE_SET, (PVOID)CorrelatedTime, sizeof(KSCORRELATED_TIME));
}

KsSetCorrelatedTime()

HRESULT STDMETHODCALLTYPE CKsProxy::KsSetCorrelatedTime

(

KSCORRELATED_TIME *

CorrelatedTime

)

Definition at line 549 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::KsSetCorrelatedTime\n");
#endif
    return PerformClockProperty(KSPROPERTY_CLOCK_CORRELATEDTIME, KSPROPERTY_TYPE_SET, (PVOID)CorrelatedTime, sizeof(KSCORRELATED_TIME));
}

KsSetPhysicalTime()

HRESULT STDMETHODCALLTYPE CKsProxy::KsSetPhysicalTime

(

LONGLONG

Time

)

Definition at line 525 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::KsSetPhysicalTime\n");
#endif

    return PerformClockProperty(KSPROPERTY_CLOCK_PHYSICALTIME, KSPROPERTY_TYPE_SET, (PVOID)&Time, sizeof(LONGLONG));
}

KsSetTime()

HRESULT STDMETHODCALLTYPE CKsProxy::KsSetTime

(

LONGLONG

Time

)

Definition at line 501 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::KsSetTime\n");
#endif

    return PerformClockProperty(KSPROPERTY_CLOCK_TIME, KSPROPERTY_TYPE_SET, (PVOID)&Time, sizeof(LONGLONG));
}

Load() [1/2]

HRESULT STDMETHODCALLTYPE CKsProxy::Load	(	IPropertyBag *	pPropBag,
		IErrorLog *	pErrorLog
	)

Implements IPersistPropertyBag.

Definition at line 2580 of file proxy.cpp.

{
    HRESULT hr;
    VARIANT varName;
    LPGUID pGuid;
    ULONG NumGuids = 0;
    HDEVINFO hList;
    SP_DEVICE_INTERFACE_DATA DeviceInterfaceData;

#ifdef KSPROXY_TRACE
    WCHAR Buffer[100];
    OutputDebugStringW(L"CKsProxy::Load\n");
#endif

    // read device path
    varName.vt = VT_BSTR;
    hr = pPropBag->Read(L"DevicePath", &varName, pErrorLog);

    if (FAILED(hr))
    {
#ifdef KSPROXY_TRACE
        swprintf(Buffer, L"CKsProxy::Load Read %lx\n", hr);
        OutputDebugStringW(Buffer);
#endif
        return MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, GetLastError());
    }

#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"DevicePath: ");
    OutputDebugStringW(varName.bstrVal);
    OutputDebugStringW(L"\n");
#endif

    // create device list
    hList = SetupDiCreateDeviceInfoListExW(NULL, NULL, NULL, NULL);
    if (hList == INVALID_HANDLE_VALUE)
    {
        // failed to create device list
        return MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, GetLastError());
    }

    DeviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
    if (!SetupDiOpenDeviceInterfaceW(hList, (PCWSTR)varName.bstrVal, 0, &DeviceInterfaceData))
    {
        // failed to open device interface
        SetupDiDestroyDeviceInfoList(hList);
    }

    // FIXME handle device interface links(aliases)
    CopyMemory(&m_DeviceInterfaceGUID, &DeviceInterfaceData.InterfaceClassGuid, sizeof(GUID));

    // close device info list
   SetupDiDestroyDeviceInfoList(hList);

    // open device
    m_hDevice = CreateFileW(varName.bstrVal, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);

    if (m_hDevice == INVALID_HANDLE_VALUE)
    {
        // failed to open device
#ifdef KSPROXY_TRACE
        swprintf(Buffer, L"CKsProxy:: failed to open device with %lx\n", GetLastError());
        OutputDebugStringW(Buffer);
#endif
        return MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, GetLastError());
    }

    // store device path
    m_DevicePath = varName.bstrVal;

    // get all supported sets
    hr = GetSupportedSets(&pGuid, &NumGuids);
    if (FAILED(hr))
    {
        CloseHandle(m_hDevice);
        m_hDevice = NULL;
        return hr;
    }

    // load all proxy plugins
    hr = LoadProxyPlugins(pGuid, NumGuids);
    if (FAILED(hr))
    {
#if 0 //HACK
        CloseHandle(m_hDevice);
        m_hDevice = NULL;
        return hr;
#endif
        OutputDebugStringW(L"CKsProxy::LoadProxyPlugins failed!\n");
    }

    // free sets
    CoTaskMemFree(pGuid);

    // now create the input / output pins
    hr = CreatePins();

#ifdef KSPROXY_TRACE
    swprintf(Buffer, L"CKsProxy::Load CreatePins %lx\n", hr);
    OutputDebugStringW(Buffer);
#endif

    //HACK
    hr = S_OK;

    return hr;
}

Load() [2/2]

HRESULT STDMETHODCALLTYPE CKsProxy::Load

(

IStream *

pStm

)

Implements IPersistStream.

Definition at line 1955 of file proxy.cpp.

{
    HRESULT hr;
    WCHAR Buffer[1000];
    AM_MEDIA_TYPE MediaType;
    ULONG BytesReturned;
    LONG Length;

    ULONG PinId;
    LPOLESTR pMajor, pSub, pFormat;

#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::Load\n");
#endif

#if 0
    ULONG Version = ReadInt(pStm, hr);
    if (Version != 1)
        return E_FAIL;
#endif

    hr = pStm->Read(&Length, sizeof(ULONG), &BytesReturned);
    swprintf(Buffer, L"Length hr %x hr length %lu\n", hr, Length);
    OutputDebugStringW(Buffer);

    do
    {
        hr = pStm->Read(&PinId, sizeof(ULONG), &BytesReturned);
        swprintf(Buffer, L"Read: hr %08x PinId %lx BytesReturned %lu\n", hr, PinId, BytesReturned);
        OutputDebugStringW(Buffer);

        if (FAILED(hr) || !BytesReturned)
            break;

        Length -= BytesReturned;

        hr = pStm->Read(&MediaType, sizeof(AM_MEDIA_TYPE), &BytesReturned);
        if (FAILED(hr) || BytesReturned != sizeof(AM_MEDIA_TYPE))
        {
            swprintf(Buffer, L"Read failed with %lx\n", hr);
            OutputDebugStringW(Buffer);
            break;
        }


        StringFromIID(MediaType.majortype, &pMajor);
        StringFromIID(MediaType.subtype , &pSub);
        StringFromIID(MediaType.formattype, &pFormat);

        swprintf(Buffer, L"BytesReturned %lu majortype %s subtype %s bFixedSizeSamples %u bTemporalCompression %u lSampleSize %u formattype %s, pUnk %p cbFormat %u pbFormat %p\n", BytesReturned, pMajor, pSub, MediaType.bFixedSizeSamples, MediaType.bTemporalCompression, MediaType.lSampleSize, pFormat, MediaType.pUnk, MediaType.cbFormat, MediaType.pbFormat);
        OutputDebugStringW(Buffer);

        Length -= BytesReturned;


        if (MediaType.cbFormat)
        {
            MediaType.pbFormat = (BYTE*)CoTaskMemAlloc(MediaType.cbFormat);
            if (!MediaType.pbFormat)
                return E_OUTOFMEMORY;

            hr = pStm->Read(&MediaType.pbFormat, sizeof(MediaType.cbFormat), &BytesReturned);
            if (FAILED(hr))
            {
                swprintf(Buffer, L"ReadFormat failed with %lx\n", hr);
                OutputDebugStringW(Buffer);
                break;
            }
            Length -= BytesReturned;
        }

    }while(Length > 0);

    return S_OK;
}

LoadProxyPlugins()

HRESULT STDMETHODCALLTYPE CKsProxy::LoadProxyPlugins	(	LPGUID	pGuids,
		ULONG	NumGuids
	)

Definition at line 2257 of file proxy.cpp.

{
    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;
}

Referenced by Load().

Pause()

HRESULT STDMETHODCALLTYPE CKsProxy::Pause

(

void

)

Implements IMediaFilter.

Definition at line 2738 of file proxy.cpp.

{
    HRESULT hr = S_OK;

#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::Pause\n");
#endif

    EnterCriticalSection(&m_Lock);

    if (m_FilterState == State_Running)
    {
        hr = SetPinState(KSSTATE_STOP);
    }
    if (SUCCEEDED(hr))
    {
        if (m_FilterState == State_Stopped)
        {
            hr = SetPinState(KSSTATE_PAUSE);
        }
    }

    if (SUCCEEDED(hr))
        m_FilterState = State_Paused;

    LeaveCriticalSection(&m_Lock);
    return hr;

}

Referenced by Run().

PerformClockProperty()

HRESULT STDMETHODCALLTYPE CKsProxy::PerformClockProperty	(	ULONG	PropertyId,
		ULONG	PropertyFlags,
		PVOID	OutputBuffer,
		ULONG	OutputBufferSize
	)

Definition at line 459 of file proxy.cpp.

{
    KSPROPERTY Property;
    HRESULT hr;
    ULONG BytesReturned;

    if (!m_hClock)
    {
        // create clock
        hr = CreateClockInstance();
        if (FAILED(hr))
            return hr;
    }

    // setup request
    Property.Set = KSPROPSETID_Clock;
    Property.Id = PropertyId;
    Property.Flags = PropertyFlags;

    hr = KsSynchronousDeviceControl(m_hClock, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), (PVOID)OutputBuffer, OutputBufferSize, &BytesReturned);

    return hr;
}

Referenced by KsGetCorrelatedPhysicalTime(), KsGetCorrelatedTime(), KsGetPhysicalTime(), KsGetResolution(), KsGetState(), KsGetTime(), KsSetCorrelatedPhysicalTime(), KsSetCorrelatedTime(), KsSetPhysicalTime(), and KsSetTime().

QueryFilterInfo()

HRESULT STDMETHODCALLTYPE CKsProxy::QueryFilterInfo

(

FILTER_INFO *

pInfo

)

Implements IBaseFilter.

Definition at line 3075 of file proxy.cpp.

{
    if (!pInfo)
        return E_POINTER;

#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::QueryFilterInfo\n");
#endif

    pInfo->achName[0] = L'\0';
    pInfo->pGraph = m_pGraph;

    if (m_pGraph)
        m_pGraph->AddRef();

    return S_OK;
}

QueryInterface()

HRESULT STDMETHODCALLTYPE CKsProxy::QueryInterface	(	REFIID	InterfaceId,
		PVOID *	Interface
	)

Definition at line 217 of file proxy.cpp.

{
    *Output = NULL;

    if (IsEqualGUID(refiid, IID_IUnknown) ||
        IsEqualGUID(refiid, IID_IBaseFilter))
    {
        *Output = PVOID(this);
        reinterpret_cast<IUnknown*>(*Output)->AddRef();
        return NOERROR;
    }
    else if (IsEqualGUID(refiid, IID_IPersistPropertyBag))
    {
        *Output = (IPersistPropertyBag*)(this);
        reinterpret_cast<IPersistPropertyBag*>(*Output)->AddRef();
        return NOERROR;
    }
    else if (IsEqualGUID(refiid, IID_IAMDeviceRemoval))
    {
        *Output = (IAMDeviceRemoval*)(this);
        reinterpret_cast<IAMDeviceRemoval*>(*Output)->AddRef();
        return NOERROR;
    }
    else if (IsEqualGUID(refiid, IID_IPersistStream))
    {
        *Output = (IPersistStream*)(this);
        reinterpret_cast<IPersistStream*>(*Output)->AddRef();
        return NOERROR;
    }
    else if (IsEqualGUID(refiid, IID_IPersist))
    {
        *Output = (IPersistStream*)(this);
        reinterpret_cast<IPersist*>(*Output)->AddRef();
        return NOERROR;
    }
    else if (IsEqualGUID(refiid, IID_IKsObject))
    {
        *Output = (IKsObject*)(this);
        reinterpret_cast<IKsObject*>(*Output)->AddRef();
        return NOERROR;
    }
    else if (IsEqualGUID(refiid, IID_IKsClock))
    {
        *Output = (IKsClock*)(this);
        reinterpret_cast<IKsClock*>(*Output)->AddRef();
        return NOERROR;
    }
    else if (IsEqualGUID(refiid, IID_IReferenceClock))
    {
        if (!m_hClock)
        {
            HRESULT hr = CreateClockInstance();
            if (FAILED(hr))
                return hr;
        }

        *Output = (IReferenceClock*)(this);
        reinterpret_cast<IReferenceClock*>(*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_IAMFilterMiscFlags))
    {
        *Output = (IAMFilterMiscFlags*)(this);
        reinterpret_cast<IAMFilterMiscFlags*>(*Output)->AddRef();
        return NOERROR;
    }
    else if (IsEqualGUID(refiid, IID_IKsControl))
    {
        *Output = (IKsControl*)(this);
        reinterpret_cast<IKsControl*>(*Output)->AddRef();
        return NOERROR;
    }
    else if (IsEqualGUID(refiid, IID_IKsPropertySet))
    {
        *Output = (IKsPropertySet*)(this);
        reinterpret_cast<IKsPropertySet*>(*Output)->AddRef();
        return NOERROR;
    }
    else if (IsEqualGUID(refiid, IID_IKsTopology))
    {
        *Output = (IKsTopology*)(this);
        reinterpret_cast<IKsTopology*>(*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_IKsClockPropertySet))
    {
        if (!m_hClock)
        {
            HRESULT hr = CreateClockInstance();
            if (FAILED(hr))
                return hr;
        }

        *Output = (IKsClockPropertySet*)(this);
        reinterpret_cast<IKsClockPropertySet*>(*Output)->AddRef();
        return NOERROR;
    }
    else if (IsEqualGUID(refiid, IID_ISpecifyPropertyPages))
    {
        *Output = (ISpecifyPropertyPages*)(this);
        reinterpret_cast<ISpecifyPropertyPages*>(*Output)->AddRef();
        return NOERROR;
    }

    for(ULONG Index = 0; Index < m_Plugins.size(); Index++)
    {
        if (m_Pins[Index])
        {
            HRESULT hr = m_Plugins[Index]->QueryInterface(refiid, Output);
            if (SUCCEEDED(hr))
            {
#ifdef KSPROXY_TRACE
                WCHAR Buffer[100];
                LPOLESTR lpstr;
                StringFromCLSID(refiid, &lpstr);
                swprintf(Buffer, L"CKsProxy::QueryInterface plugin %lu supports interface %s\n", Index, lpstr);
                OutputDebugStringW(Buffer);
                CoTaskMemFree(lpstr);
#endif
                return hr;
            }
        }
    }
#ifdef KSPROXY_TRACE
    WCHAR Buffer[MAX_PATH];
    LPOLESTR lpstr;
    StringFromCLSID(refiid, &lpstr);
    swprintf(Buffer, L"CKsProxy::QueryInterface: NoInterface for %s !!!\n", lpstr);
    OutputDebugStringW(Buffer);
    CoTaskMemFree(lpstr);
#endif

    return E_NOINTERFACE;
}

QueryPreferredFormat()

HRESULT STDMETHODCALLTYPE CKsProxy::QueryPreferredFormat

(

GUID *

pFormat

)

Implements IMediaSeeking.

Definition at line 1038 of file proxy.cpp.

{
    PKSMULTIPLE_ITEM FormatList;
    HRESULT hr;
    ULONG Index;

#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::QueryPreferredFormat\n");
#endif

    if (!pFormat)
        return E_POINTER;

    hr = GetMediaSeekingFormats(&FormatList);
    if (SUCCEEDED(hr))
    {
        if (FormatList->Count)
        {
            CopyMemory(pFormat, (FormatList + 1), sizeof(GUID));
            CoTaskMemFree(FormatList);
            return S_OK;
        }
        CoTaskMemFree(FormatList);
    }
    if (hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_NOT_FOUND) || hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_SET_NOT_FOUND))
    {
        // check if plugins support it
        for(Index = 0; Index < m_Plugins.size(); Index++)
        {
            // get plugin
            IUnknown * Plugin = m_Plugins[Index];

            if (!Plugin)
               continue;

            // query for IMediaSeeking interface
            IMediaSeeking *pSeek = NULL;
            hr = Plugin->QueryInterface(IID_IMediaSeeking, (void**)&pSeek);
            if (SUCCEEDED(hr))
            {
                // get preferred time format
                hr = pSeek->QueryPreferredFormat(pFormat);
                // release IMediaSeeking interface
                pSeek->Release();

                if (hr != S_FALSE)
                    return hr;
            }
        }
        hr = S_FALSE;
    }

    return hr;
}

Referenced by IsUsingTimeFormat().

QuerySupported()

HRESULT STDMETHODCALLTYPE CKsProxy::QuerySupported	(	REFGUID	guidPropSet,
		DWORD	dwPropID,
		DWORD *	pTypeSupport
	)

Implements IKsPropertySet.

Definition at line 1858 of file proxy.cpp.

{
    KSPROPERTY Property;
    ULONG BytesReturned;

#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::QuerySupported\n");
#endif

    Property.Set = guidPropSet;
    Property.Id = dwPropID;
    Property.Flags = KSPROPERTY_TYPE_SETSUPPORT;

    return KsProperty(&Property, sizeof(KSPROPERTY), pTypeSupport, sizeof(DWORD), &BytesReturned);
}

QueryVendorInfo()

HRESULT STDMETHODCALLTYPE CKsProxy::QueryVendorInfo

(

LPWSTR *

pVendorInfo

)

Implements IBaseFilter.

Definition at line 3123 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::QueryVendorInfo\n");
#endif
    return StringFromCLSID(CLSID_Proxy, pVendorInfo);
}

Reassociate()

HRESULT STDMETHODCALLTYPE CKsProxy::Reassociate

(

void

)

Definition at line 2090 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::Reassociate\n");
#endif

    if (!m_DevicePath || m_hDevice)
    {
        // file path not available
        return MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_FILE_NOT_FOUND);
    }

    m_hDevice = CreateFileW(m_DevicePath, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);
    if (!m_hDevice)
    {
        // failed to open device
        return MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, GetLastError());
    }

    // success
    return NOERROR;
}

Register()

HRESULT STDMETHODCALLTYPE CKsProxy::Register

(

void

)

Implements IAMovieSetup.

Definition at line 3138 of file proxy.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugStringW(L"CKsProxy::Register : NotImplemented\n");
#endif

    return E_NOTIMP