CKsClockForwarder Class Reference

Inheritance diagram for CKsClockForwarder:

Collaboration diagram for CKsClockForwarder:

Public Member Functions
STDMETHODIMP	QueryInterface (REFIID InterfaceId, PVOID *Interface)
	STDMETHODIMP_ (ULONG) AddRef()
	STDMETHODIMP_ (ULONG) Release()
HRESULT STDMETHODCALLTYPE	Stop ()
HRESULT STDMETHODCALLTYPE	Pause ()
HRESULT STDMETHODCALLTYPE	Run (REFERENCE_TIME tStart)
HRESULT STDMETHODCALLTYPE	SetSyncSource (IReferenceClock *pClock)
HRESULT STDMETHODCALLTYPE	NotifyGraphChange ()
HANDLE STDMETHODCALLTYPE	KsGetObjectHandle ()
	CKsClockForwarder (HANDLE handle)
virtual	~CKsClockForwarder ()
HRESULT STDMETHODCALLTYPE	SetClockState (KSSTATE State)
HRESULT	Stop (void)
HRESULT	Pause (void)
HRESULT	Run (REFERENCE_TIME tStart)
HRESULT	SetSyncSource ([in] IReferenceClock *pClock)
HRESULT	NotifyGraphChange (void)
Public Member Functions inherited from IUnknown
HRESULT	QueryInterface ([in] REFIID riid, [out, iid_is(riid)] void **ppvObject)
ULONG	AddRef ()
ULONG	Release ()

Protected Attributes
LONG	m_Ref
HANDLE	m_Handle
IReferenceClock *	m_Clock
HANDLE	m_hEvent
HANDLE	m_hThread
BOOL	m_ThreadStarted
BOOL	m_PendingStop
BOOL	m_ForceStart
KSSTATE	m_State
REFERENCE_TIME	m_Time

Friends
DWORD WINAPI	CKsClockForwarder_ThreadStartup (LPVOID lpParameter)

Additional Inherited Members
Public Types inherited from IUnknown
typedef IUnknown *	LPUNKNOWN

Detailed Description

Definition at line 15 of file clockforward.cpp.

Constructor & Destructor Documentation

CKsClockForwarder()

CKsClockForwarder::CKsClockForwarder

(

HANDLE

handle

)

Definition at line 66 of file clockforward.cpp.

                   : m_Ref(0),
                     m_Handle(handle),
                     m_Clock(0),
                     m_hEvent(NULL),
                     m_hThread(NULL),
                     m_ThreadStarted(FALSE),
                     m_PendingStop(FALSE),
                     m_ForceStart(FALSE),
                     m_State(KSSTATE_STOP),
                     m_Time(0)
{
}

~CKsClockForwarder()

virtual CKsClockForwarder::~CKsClockForwarder ( )

inlinevirtual

Definition at line 49 of file clockforward.cpp.

{};

Member Function Documentation

KsGetObjectHandle()

HANDLE STDMETHODCALLTYPE CKsClockForwarder::KsGetObjectHandle

(

)

Definition at line 267 of file clockforward.cpp.

{
    return m_Handle;
}

NotifyGraphChange()

HRESULT STDMETHODCALLTYPE CKsClockForwarder::NotifyGraphChange

(

void

)

Implements IDistributorNotify.

Definition at line 252 of file clockforward.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugString("CKsClockForwarder::NotifyGraphChange\n");
#endif
 
    return NOERROR;
}

Pause()

HRESULT STDMETHODCALLTYPE CKsClockForwarder::Pause

(

void

)

Implements IDistributorNotify.

Definition at line 162 of file clockforward.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugString("CKsClockForwarder::Pause\n");
#endif
 
    if (!m_hEvent)
    {
        m_hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
        if (!m_hEvent)
            return MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, GetLastError());
    }
 
    if (m_State <= KSSTATE_PAUSE)
    {
        if (m_State == KSSTATE_STOP)
            SetClockState(KSSTATE_ACQUIRE);
 
        if (m_State == KSSTATE_ACQUIRE)
            SetClockState(KSSTATE_PAUSE);
    }
    else
    {
        if (!m_ForceStart)
        {
            SetClockState(KSSTATE_PAUSE);
        }
    }
 
    if (!m_hThread)
    {
        m_hThread = CreateThread(NULL, 0, CKsClockForwarder_ThreadStartup, (LPVOID)this, 0, NULL);
        if (!m_hThread)
            return MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, GetLastError());
    }
 
    return NOERROR;
}

Referenced by Run().

QueryInterface()

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

Definition at line 82 of file clockforward.cpp.

{
    if (IsEqualGUID(refiid, IID_IUnknown))
    {
        *Output = PVOID(this);
        reinterpret_cast<IUnknown*>(*Output)->AddRef();
        return NOERROR;
    }
    if (IsEqualGUID(refiid, IID_IKsObject) ||
        IsEqualGUID(refiid, IID_IKsClockForwarder))
    {
        *Output = (IKsObject*)(this);
        reinterpret_cast<IKsObject*>(*Output)->AddRef();
        return NOERROR;
    }
 
    if (IsEqualGUID(refiid, IID_IDistributorNotify))
    {
        *Output = (IDistributorNotify*)(this);
        reinterpret_cast<IDistributorNotify*>(*Output)->AddRef();
        return NOERROR;
    }
 
    return E_NOINTERFACE;
}

Run()

HRESULT STDMETHODCALLTYPE CKsClockForwarder::Run

(

REFERENCE_TIME

tStart

)

Implements IDistributorNotify.

Definition at line 203 of file clockforward.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugString("CKsClockForwarder::Run\n");
#endif
 
    m_Time = tStart;
 
    if (!m_hEvent || !m_hThread)
    {
        m_ForceStart = TRUE;
        HRESULT hr = Pause();
        m_ForceStart = FALSE;
 
        if (FAILED(hr))
            return hr;
    }
 
    assert(m_hThread);
 
    SetClockState(KSSTATE_RUN);
    SetEvent(m_hEvent);
 
    return NOERROR;
}

SetClockState()

HRESULT STDMETHODCALLTYPE CKsClockForwarder::SetClockState

(

KSSTATE

State

)

Definition at line 275 of file clockforward.cpp.

{
    KSPROPERTY Property;
    ULONG BytesReturned;
 
    Property.Set = KSPROPSETID_Clock;
    Property.Id = KSPROPERTY_CLOCK_STATE;
    Property.Flags = KSPROPERTY_TYPE_SET;
 
    HRESULT hr = KsSynchronousDeviceControl(m_Handle, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), &State, sizeof(KSSTATE), &BytesReturned);
    if (SUCCEEDED(hr))
        m_State = State;
 
#ifdef KSPROXY_TRACE
    WCHAR Buffer[100];
    swprintf(Buffer, L"CKsClockForwarder::SetClockState m_State %u State %u hr %lx\n", m_State, State, hr);
    OutputDebugStringW(Buffer);
#endif
 
    return hr;
}

Referenced by Pause(), Run(), and Stop().

SetSyncSource()

HRESULT STDMETHODCALLTYPE CKsClockForwarder::SetSyncSource

(

IReferenceClock *

pClock

)

Implements IDistributorNotify.

Definition at line 232 of file clockforward.cpp.

{
#ifdef KSPROXY_TRACE
    OutputDebugString("CKsClockForwarder::SetSyncSource\n");
#endif
 
    if (pClock)
        pClock->AddRef();
 
    if (m_Clock)
        m_Clock->Release();
 
 
    m_Clock = pClock;
    return NOERROR;
}

STDMETHODIMP_() [1/2]

CKsClockForwarder::STDMETHODIMP_ ( ULONG  )

inline

Definition at line 21 of file clockforward.cpp.

    {
        InterlockedIncrement(&m_Ref);
        return m_Ref;
    }

STDMETHODIMP_() [2/2]

CKsClockForwarder::STDMETHODIMP_ ( ULONG  )

inline

Definition at line 26 of file clockforward.cpp.

    {
        InterlockedDecrement(&m_Ref);
 
        if (!m_Ref)
        {
            delete this;
            return 0;
        }
        return m_Ref;
    }

Stop()

HRESULT STDMETHODCALLTYPE CKsClockForwarder::Stop

(

void

)

Implements IDistributorNotify.

Definition at line 117 of file clockforward.cpp.

{
#ifdef KSPROXY_TRACE
    WCHAR Buffer[200];
    swprintf(Buffer, L"CKsClockForwarder::Stop m_ThreadStarted %u m_PendingStop %u m_hThread %p m_hEvent %p m_Handle %p\n", m_ThreadStarted, m_PendingStop, m_hThread, m_hEvent, m_Handle);
    OutputDebugStringW(Buffer);
#endif
 
    m_Time = 0;
    if (m_ThreadStarted)
    {
        // signal pending stop
        m_PendingStop = true;
 
        assert(m_hThread);
        assert(m_hEvent);
 
        // set stop event
        SetEvent(m_hEvent);
 
        // wait untill the thread has finished
        WaitForSingleObject(m_hThread, INFINITE);
 
        // close thread handle
        CloseHandle(m_hThread);
 
        // zero handle
        m_hThread = NULL;
    }
 
    if (m_hEvent)
    {
        // close stop event
        CloseHandle(m_hEvent);
        m_hEvent = NULL;
    }
 
    m_PendingStop = false;
 
    SetClockState(KSSTATE_STOP);
    return NOERROR;
}

Friends And Related Function Documentation

CKsClockForwarder_ThreadStartup

DWORD WINAPI CKsClockForwarder_ThreadStartup ( LPVOID  lpParameter )

friend

Definition at line 299 of file clockforward.cpp.

{
    REFERENCE_TIME Time;
    ULONG BytesReturned;
 
    CKsClockForwarder * Fwd = (CKsClockForwarder*)lpParameter;
 
    Fwd->m_ThreadStarted = TRUE;
 
    do
    {
        if (Fwd->m_PendingStop)
            break;
 
        if (Fwd->m_State != KSSTATE_RUN)
            WaitForSingleObject(Fwd->m_hEvent, INFINITE);
 
        KSPROPERTY Property;
        Property.Set = KSPROPSETID_Clock;
        Property.Id = KSPROPERTY_CLOCK_TIME;
        Property.Flags = KSPROPERTY_TYPE_SET;
 
        Fwd->m_Clock->GetTime(&Time);
        Time -= Fwd->m_Time;
 
        KsSynchronousDeviceControl(Fwd->m_Handle, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), &Time, sizeof(REFERENCE_TIME), &BytesReturned);
    }
    while(TRUE);
 
    Fwd->m_ThreadStarted = FALSE;
    return NOERROR;
}

Referenced by Pause().

Member Data Documentation

m_Clock

IReferenceClock* CKsClockForwarder::m_Clock

protected

Definition at line 54 of file clockforward.cpp.

Referenced by SetSyncSource().

m_ForceStart

BOOL CKsClockForwarder::m_ForceStart

protected

Definition at line 59 of file clockforward.cpp.

Referenced by Pause(), and Run().

m_Handle

HANDLE CKsClockForwarder::m_Handle

protected

Definition at line 53 of file clockforward.cpp.

Referenced by KsGetObjectHandle(), SetClockState(), and Stop().

m_hEvent

HANDLE CKsClockForwarder::m_hEvent

protected

Definition at line 55 of file clockforward.cpp.

Referenced by Pause(), Run(), and Stop().

m_hThread

HANDLE CKsClockForwarder::m_hThread

protected

Definition at line 56 of file clockforward.cpp.

Referenced by Pause(), Run(), and Stop().

m_PendingStop

BOOL CKsClockForwarder::m_PendingStop

protected

Definition at line 58 of file clockforward.cpp.

Referenced by Stop().

m_Ref

LONG CKsClockForwarder::m_Ref

protected

Definition at line 52 of file clockforward.cpp.

Referenced by STDMETHODIMP_().

m_State

KSSTATE CKsClockForwarder::m_State

protected

Definition at line 60 of file clockforward.cpp.

Referenced by Pause(), and SetClockState().

m_ThreadStarted

BOOL CKsClockForwarder::m_ThreadStarted

protected

Definition at line 57 of file clockforward.cpp.

Referenced by Stop().

m_Time

REFERENCE_TIME CKsClockForwarder::m_Time

protected

Definition at line 61 of file clockforward.cpp.

Referenced by Run(), and Stop().

---

The documentation for this class was generated from the following file:

• dll/directx/ksproxy/clockforward.cpp