2863 lines
97 KiB
C++
2863 lines
97 KiB
C++
//------------------------------------------------------------------------------
|
|
// File: RenBase.cpp
|
|
//
|
|
// Desc: DirectShow base classes.
|
|
//
|
|
// Copyright (c) 1992-2001 Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------------------------
|
|
|
|
#include <pjmedia-videodev/config.h>
|
|
|
|
#if defined(PJMEDIA_VIDEO_DEV_HAS_DSHOW) && PJMEDIA_VIDEO_DEV_HAS_DSHOW != 0
|
|
|
|
#include <streams.h> // DirectShow base class definitions
|
|
#include <mmsystem.h> // Needed for definition of timeGetTime
|
|
#include <limits.h> // Standard data type limit definitions
|
|
#include <measure.h> // Used for time critical log functions
|
|
|
|
#pragma warning(disable:4355)
|
|
|
|
// Helper function for clamping time differences
|
|
int inline TimeDiff(REFERENCE_TIME rt)
|
|
{
|
|
if (rt < - (50 * UNITS)) {
|
|
return -(50 * UNITS);
|
|
} else
|
|
if (rt > 50 * UNITS) {
|
|
return 50 * UNITS;
|
|
} else return (int)rt;
|
|
}
|
|
|
|
// Implements the CBaseRenderer class
|
|
|
|
CBaseRenderer::CBaseRenderer(REFCLSID RenderClass, // CLSID for this renderer
|
|
__in_opt LPCTSTR pName, // Debug ONLY description
|
|
__inout_opt LPUNKNOWN pUnk, // Aggregated owner object
|
|
__inout HRESULT *phr) : // General OLE return code
|
|
|
|
CBaseFilter(pName,pUnk,&m_InterfaceLock,RenderClass),
|
|
m_evComplete(TRUE, phr),
|
|
m_RenderEvent(FALSE, phr),
|
|
m_bAbort(FALSE),
|
|
m_pPosition(NULL),
|
|
m_ThreadSignal(TRUE, phr),
|
|
m_bStreaming(FALSE),
|
|
m_bEOS(FALSE),
|
|
m_bEOSDelivered(FALSE),
|
|
m_pMediaSample(NULL),
|
|
m_dwAdvise(0),
|
|
m_pQSink(NULL),
|
|
m_pInputPin(NULL),
|
|
m_bRepaintStatus(TRUE),
|
|
m_SignalTime(0),
|
|
m_bInReceive(FALSE),
|
|
m_EndOfStreamTimer(0)
|
|
{
|
|
if (SUCCEEDED(*phr)) {
|
|
Ready();
|
|
#ifdef PERF
|
|
m_idBaseStamp = MSR_REGISTER(TEXT("BaseRenderer: sample time stamp"));
|
|
m_idBaseRenderTime = MSR_REGISTER(TEXT("BaseRenderer: draw time (msec)"));
|
|
m_idBaseAccuracy = MSR_REGISTER(TEXT("BaseRenderer: Accuracy (msec)"));
|
|
#endif
|
|
}
|
|
}
|
|
|
|
|
|
// Delete the dynamically allocated IMediaPosition and IMediaSeeking helper
|
|
// object. The object is created when somebody queries us. These are standard
|
|
// control interfaces for seeking and setting start/stop positions and rates.
|
|
// We will probably also have made an input pin based on CRendererInputPin
|
|
// that has to be deleted, it's created when an enumerator calls our GetPin
|
|
|
|
CBaseRenderer::~CBaseRenderer()
|
|
{
|
|
ASSERT(m_bStreaming == FALSE);
|
|
ASSERT(m_EndOfStreamTimer == 0);
|
|
StopStreaming();
|
|
ClearPendingSample();
|
|
|
|
// Delete any IMediaPosition implementation
|
|
|
|
if (m_pPosition) {
|
|
delete m_pPosition;
|
|
m_pPosition = NULL;
|
|
}
|
|
|
|
// Delete any input pin created
|
|
|
|
if (m_pInputPin) {
|
|
delete m_pInputPin;
|
|
m_pInputPin = NULL;
|
|
}
|
|
|
|
// Release any Quality sink
|
|
|
|
ASSERT(m_pQSink == NULL);
|
|
}
|
|
|
|
|
|
// This returns the IMediaPosition and IMediaSeeking interfaces
|
|
|
|
HRESULT CBaseRenderer::GetMediaPositionInterface(REFIID riid, __deref_out void **ppv)
|
|
{
|
|
CAutoLock cObjectCreationLock(&m_ObjectCreationLock);
|
|
if (m_pPosition) {
|
|
return m_pPosition->NonDelegatingQueryInterface(riid,ppv);
|
|
}
|
|
|
|
CBasePin *pPin = GetPin(0);
|
|
if (NULL == pPin) {
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
HRESULT hr = NOERROR;
|
|
|
|
// Create implementation of this dynamically since sometimes we may
|
|
// never try and do a seek. The helper object implements a position
|
|
// control interface (IMediaPosition) which in fact simply takes the
|
|
// calls normally from the filter graph and passes them upstream
|
|
|
|
m_pPosition = new CRendererPosPassThru(NAME("Renderer CPosPassThru"),
|
|
CBaseFilter::GetOwner(),
|
|
(HRESULT *) &hr,
|
|
pPin);
|
|
if (m_pPosition == NULL) {
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
if (FAILED(hr)) {
|
|
delete m_pPosition;
|
|
m_pPosition = NULL;
|
|
return E_NOINTERFACE;
|
|
}
|
|
return GetMediaPositionInterface(riid,ppv);
|
|
}
|
|
|
|
|
|
// Overriden to say what interfaces we support and where
|
|
|
|
STDMETHODIMP CBaseRenderer::NonDelegatingQueryInterface(REFIID riid, __deref_out void **ppv)
|
|
{
|
|
// Do we have this interface
|
|
|
|
if (riid == IID_IMediaPosition || riid == IID_IMediaSeeking) {
|
|
return GetMediaPositionInterface(riid,ppv);
|
|
} else {
|
|
return CBaseFilter::NonDelegatingQueryInterface(riid,ppv);
|
|
}
|
|
}
|
|
|
|
|
|
// This is called whenever we change states, we have a manual reset event that
|
|
// is signalled whenever we don't won't the source filter thread to wait in us
|
|
// (such as in a stopped state) and likewise is not signalled whenever it can
|
|
// wait (during paused and running) this function sets or resets the thread
|
|
// event. The event is used to stop source filter threads waiting in Receive
|
|
|
|
HRESULT CBaseRenderer::SourceThreadCanWait(BOOL bCanWait)
|
|
{
|
|
if (bCanWait == TRUE) {
|
|
m_ThreadSignal.Reset();
|
|
} else {
|
|
m_ThreadSignal.Set();
|
|
}
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
#ifdef DEBUG
|
|
// Dump the current renderer state to the debug terminal. The hardest part of
|
|
// the renderer is the window where we unlock everything to wait for a clock
|
|
// to signal it is time to draw or for the application to cancel everything
|
|
// by stopping the filter. If we get things wrong we can leave the thread in
|
|
// WaitForRenderTime with no way for it to ever get out and we will deadlock
|
|
|
|
void CBaseRenderer::DisplayRendererState()
|
|
{
|
|
DbgLog((LOG_TIMING, 1, TEXT("\nTimed out in WaitForRenderTime")));
|
|
|
|
// No way should this be signalled at this point
|
|
|
|
BOOL bSignalled = m_ThreadSignal.Check();
|
|
DbgLog((LOG_TIMING, 1, TEXT("Signal sanity check %d"),bSignalled));
|
|
|
|
// Now output the current renderer state variables
|
|
|
|
DbgLog((LOG_TIMING, 1, TEXT("Filter state %d"),m_State));
|
|
|
|
DbgLog((LOG_TIMING, 1, TEXT("Abort flag %d"),m_bAbort));
|
|
|
|
DbgLog((LOG_TIMING, 1, TEXT("Streaming flag %d"),m_bStreaming));
|
|
|
|
DbgLog((LOG_TIMING, 1, TEXT("Clock advise link %d"),m_dwAdvise));
|
|
|
|
DbgLog((LOG_TIMING, 1, TEXT("Current media sample %x"),m_pMediaSample));
|
|
|
|
DbgLog((LOG_TIMING, 1, TEXT("EOS signalled %d"),m_bEOS));
|
|
|
|
DbgLog((LOG_TIMING, 1, TEXT("EOS delivered %d"),m_bEOSDelivered));
|
|
|
|
DbgLog((LOG_TIMING, 1, TEXT("Repaint status %d"),m_bRepaintStatus));
|
|
|
|
|
|
// Output the delayed end of stream timer information
|
|
|
|
DbgLog((LOG_TIMING, 1, TEXT("End of stream timer %x"),m_EndOfStreamTimer));
|
|
|
|
DbgLog((LOG_TIMING, 1, TEXT("Deliver time %s"),CDisp((LONGLONG)m_SignalTime)));
|
|
|
|
|
|
// Should never timeout during a flushing state
|
|
|
|
BOOL bFlushing = m_pInputPin->IsFlushing();
|
|
DbgLog((LOG_TIMING, 1, TEXT("Flushing sanity check %d"),bFlushing));
|
|
|
|
// Display the time we were told to start at
|
|
DbgLog((LOG_TIMING, 1, TEXT("Last run time %s"),CDisp((LONGLONG)m_tStart.m_time)));
|
|
|
|
// Have we got a reference clock
|
|
if (m_pClock == NULL) return;
|
|
|
|
// Get the current time from the wall clock
|
|
|
|
CRefTime CurrentTime,StartTime,EndTime;
|
|
m_pClock->GetTime((REFERENCE_TIME*) &CurrentTime);
|
|
CRefTime Offset = CurrentTime - m_tStart;
|
|
|
|
// Display the current time from the clock
|
|
|
|
DbgLog((LOG_TIMING, 1, TEXT("Clock time %s"),CDisp((LONGLONG)CurrentTime.m_time)));
|
|
|
|
DbgLog((LOG_TIMING, 1, TEXT("Time difference %dms"),Offset.Millisecs()));
|
|
|
|
|
|
// Do we have a sample ready to render
|
|
if (m_pMediaSample == NULL) return;
|
|
|
|
m_pMediaSample->GetTime((REFERENCE_TIME*)&StartTime, (REFERENCE_TIME*)&EndTime);
|
|
DbgLog((LOG_TIMING, 1, TEXT("Next sample stream times (Start %d End %d ms)"),
|
|
StartTime.Millisecs(),EndTime.Millisecs()));
|
|
|
|
// Calculate how long it is until it is due for rendering
|
|
CRefTime Wait = (m_tStart + StartTime) - CurrentTime;
|
|
DbgLog((LOG_TIMING, 1, TEXT("Wait required %d ms"),Wait.Millisecs()));
|
|
}
|
|
#endif
|
|
|
|
|
|
// Wait until the clock sets the timer event or we're otherwise signalled. We
|
|
// set an arbitrary timeout for this wait and if it fires then we display the
|
|
// current renderer state on the debugger. It will often fire if the filter's
|
|
// left paused in an application however it may also fire during stress tests
|
|
// if the synchronisation with application seeks and state changes is faulty
|
|
|
|
#define RENDER_TIMEOUT 10000
|
|
|
|
HRESULT CBaseRenderer::WaitForRenderTime()
|
|
{
|
|
HANDLE WaitObjects[] = { m_ThreadSignal, m_RenderEvent };
|
|
DWORD Result = WAIT_TIMEOUT;
|
|
|
|
// Wait for either the time to arrive or for us to be stopped
|
|
|
|
OnWaitStart();
|
|
while (Result == WAIT_TIMEOUT) {
|
|
Result = WaitForMultipleObjects(2,WaitObjects,FALSE,RENDER_TIMEOUT);
|
|
|
|
#ifdef DEBUG
|
|
if (Result == WAIT_TIMEOUT) DisplayRendererState();
|
|
#endif
|
|
|
|
}
|
|
OnWaitEnd();
|
|
|
|
// We may have been awoken without the timer firing
|
|
|
|
if (Result == WAIT_OBJECT_0) {
|
|
return VFW_E_STATE_CHANGED;
|
|
}
|
|
|
|
SignalTimerFired();
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
// Poll waiting for Receive to complete. This really matters when
|
|
// Receive may set the palette and cause window messages
|
|
// The problem is that if we don't really wait for a renderer to
|
|
// stop processing we can deadlock waiting for a transform which
|
|
// is calling the renderer's Receive() method because the transform's
|
|
// Stop method doesn't know to process window messages to unblock
|
|
// the renderer's Receive processing
|
|
void CBaseRenderer::WaitForReceiveToComplete()
|
|
{
|
|
for (;;) {
|
|
if (!m_bInReceive) {
|
|
break;
|
|
}
|
|
|
|
MSG msg;
|
|
// Receive all interthread snedmessages
|
|
PeekMessage(&msg, NULL, WM_NULL, WM_NULL, PM_NOREMOVE);
|
|
|
|
Sleep(1);
|
|
}
|
|
|
|
// If the wakebit for QS_POSTMESSAGE is set, the PeekMessage call
|
|
// above just cleared the changebit which will cause some messaging
|
|
// calls to block (waitMessage, MsgWaitFor...) now.
|
|
// Post a dummy message to set the QS_POSTMESSAGE bit again
|
|
if (HIWORD(GetQueueStatus(QS_POSTMESSAGE)) & QS_POSTMESSAGE) {
|
|
// Send dummy message
|
|
PostThreadMessage(GetCurrentThreadId(), WM_NULL, 0, 0);
|
|
}
|
|
}
|
|
|
|
// A filter can have four discrete states, namely Stopped, Running, Paused,
|
|
// Intermediate. We are in an intermediate state if we are currently trying
|
|
// to pause but haven't yet got the first sample (or if we have been flushed
|
|
// in paused state and therefore still have to wait for a sample to arrive)
|
|
|
|
// This class contains an event called m_evComplete which is signalled when
|
|
// the current state is completed and is not signalled when we are waiting to
|
|
// complete the last state transition. As mentioned above the only time we
|
|
// use this at the moment is when we wait for a media sample in paused state
|
|
// If while we are waiting we receive an end of stream notification from the
|
|
// source filter then we know no data is imminent so we can reset the event
|
|
// This means that when we transition to paused the source filter must call
|
|
// end of stream on us or send us an image otherwise we'll hang indefinately
|
|
|
|
|
|
// Simple internal way of getting the real state
|
|
|
|
FILTER_STATE CBaseRenderer::GetRealState() {
|
|
return m_State;
|
|
}
|
|
|
|
|
|
// The renderer doesn't complete the full transition to paused states until
|
|
// it has got one media sample to render. If you ask it for its state while
|
|
// it's waiting it will return the state along with VFW_S_STATE_INTERMEDIATE
|
|
|
|
STDMETHODIMP CBaseRenderer::GetState(DWORD dwMSecs,FILTER_STATE *State)
|
|
{
|
|
CheckPointer(State,E_POINTER);
|
|
|
|
if (WaitDispatchingMessages(m_evComplete, dwMSecs) == WAIT_TIMEOUT) {
|
|
*State = m_State;
|
|
return VFW_S_STATE_INTERMEDIATE;
|
|
}
|
|
*State = m_State;
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
// If we're pausing and we have no samples we don't complete the transition
|
|
// to State_Paused and we return S_FALSE. However if the m_bAbort flag has
|
|
// been set then all samples are rejected so there is no point waiting for
|
|
// one. If we do have a sample then return NOERROR. We will only ever return
|
|
// VFW_S_STATE_INTERMEDIATE from GetState after being paused with no sample
|
|
// (calling GetState after either being stopped or Run will NOT return this)
|
|
|
|
HRESULT CBaseRenderer::CompleteStateChange(FILTER_STATE OldState)
|
|
{
|
|
// Allow us to be paused when disconnected
|
|
|
|
if (m_pInputPin->IsConnected() == FALSE) {
|
|
Ready();
|
|
return S_OK;
|
|
}
|
|
|
|
// Have we run off the end of stream
|
|
|
|
if (IsEndOfStream() == TRUE) {
|
|
Ready();
|
|
return S_OK;
|
|
}
|
|
|
|
// Make sure we get fresh data after being stopped
|
|
|
|
if (HaveCurrentSample() == TRUE) {
|
|
if (OldState != State_Stopped) {
|
|
Ready();
|
|
return S_OK;
|
|
}
|
|
}
|
|
NotReady();
|
|
return S_FALSE;
|
|
}
|
|
|
|
|
|
// When we stop the filter the things we do are:-
|
|
|
|
// Decommit the allocator being used in the connection
|
|
// Release the source filter if it's waiting in Receive
|
|
// Cancel any advise link we set up with the clock
|
|
// Any end of stream signalled is now obsolete so reset
|
|
// Allow us to be stopped when we are not connected
|
|
|
|
STDMETHODIMP CBaseRenderer::Stop()
|
|
{
|
|
CAutoLock cRendererLock(&m_InterfaceLock);
|
|
|
|
// Make sure there really is a state change
|
|
|
|
if (m_State == State_Stopped) {
|
|
return NOERROR;
|
|
}
|
|
|
|
// Is our input pin connected
|
|
|
|
if (m_pInputPin->IsConnected() == FALSE) {
|
|
NOTE("Input pin is not connected");
|
|
m_State = State_Stopped;
|
|
return NOERROR;
|
|
}
|
|
|
|
CBaseFilter::Stop();
|
|
|
|
// If we are going into a stopped state then we must decommit whatever
|
|
// allocator we are using it so that any source filter waiting in the
|
|
// GetBuffer can be released and unlock themselves for a state change
|
|
|
|
if (m_pInputPin->Allocator()) {
|
|
m_pInputPin->Allocator()->Decommit();
|
|
}
|
|
|
|
// Cancel any scheduled rendering
|
|
|
|
SetRepaintStatus(TRUE);
|
|
StopStreaming();
|
|
SourceThreadCanWait(FALSE);
|
|
ResetEndOfStream();
|
|
CancelNotification();
|
|
|
|
// There should be no outstanding clock advise
|
|
ASSERT(CancelNotification() == S_FALSE);
|
|
ASSERT(WAIT_TIMEOUT == WaitForSingleObject((HANDLE)m_RenderEvent,0));
|
|
ASSERT(m_EndOfStreamTimer == 0);
|
|
|
|
Ready();
|
|
WaitForReceiveToComplete();
|
|
m_bAbort = FALSE;
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
// When we pause the filter the things we do are:-
|
|
|
|
// Commit the allocator being used in the connection
|
|
// Allow a source filter thread to wait in Receive
|
|
// Cancel any clock advise link (we may be running)
|
|
// Possibly complete the state change if we have data
|
|
// Allow us to be paused when we are not connected
|
|
|
|
STDMETHODIMP CBaseRenderer::Pause()
|
|
{
|
|
CAutoLock cRendererLock(&m_InterfaceLock);
|
|
FILTER_STATE OldState = m_State;
|
|
ASSERT(m_pInputPin->IsFlushing() == FALSE);
|
|
|
|
// Make sure there really is a state change
|
|
|
|
if (m_State == State_Paused) {
|
|
return CompleteStateChange(State_Paused);
|
|
}
|
|
|
|
// Has our input pin been connected
|
|
|
|
if (m_pInputPin->IsConnected() == FALSE) {
|
|
NOTE("Input pin is not connected");
|
|
m_State = State_Paused;
|
|
return CompleteStateChange(State_Paused);
|
|
}
|
|
|
|
// Pause the base filter class
|
|
|
|
HRESULT hr = CBaseFilter::Pause();
|
|
if (FAILED(hr)) {
|
|
NOTE("Pause failed");
|
|
return hr;
|
|
}
|
|
|
|
// Enable EC_REPAINT events again
|
|
|
|
SetRepaintStatus(TRUE);
|
|
StopStreaming();
|
|
SourceThreadCanWait(TRUE);
|
|
CancelNotification();
|
|
ResetEndOfStreamTimer();
|
|
|
|
// If we are going into a paused state then we must commit whatever
|
|
// allocator we are using it so that any source filter can call the
|
|
// GetBuffer and expect to get a buffer without returning an error
|
|
|
|
if (m_pInputPin->Allocator()) {
|
|
m_pInputPin->Allocator()->Commit();
|
|
}
|
|
|
|
// There should be no outstanding advise
|
|
ASSERT(CancelNotification() == S_FALSE);
|
|
ASSERT(WAIT_TIMEOUT == WaitForSingleObject((HANDLE)m_RenderEvent,0));
|
|
ASSERT(m_EndOfStreamTimer == 0);
|
|
ASSERT(m_pInputPin->IsFlushing() == FALSE);
|
|
|
|
// When we come out of a stopped state we must clear any image we were
|
|
// holding onto for frame refreshing. Since renderers see state changes
|
|
// first we can reset ourselves ready to accept the source thread data
|
|
// Paused or running after being stopped causes the current position to
|
|
// be reset so we're not interested in passing end of stream signals
|
|
|
|
if (OldState == State_Stopped) {
|
|
m_bAbort = FALSE;
|
|
ClearPendingSample();
|
|
}
|
|
return CompleteStateChange(OldState);
|
|
}
|
|
|
|
|
|
// When we run the filter the things we do are:-
|
|
|
|
// Commit the allocator being used in the connection
|
|
// Allow a source filter thread to wait in Receive
|
|
// Signal the render event just to get us going
|
|
// Start the base class by calling StartStreaming
|
|
// Allow us to be run when we are not connected
|
|
// Signal EC_COMPLETE if we are not connected
|
|
|
|
STDMETHODIMP CBaseRenderer::Run(REFERENCE_TIME StartTime)
|
|
{
|
|
CAutoLock cRendererLock(&m_InterfaceLock);
|
|
FILTER_STATE OldState = m_State;
|
|
|
|
// Make sure there really is a state change
|
|
|
|
if (m_State == State_Running) {
|
|
return NOERROR;
|
|
}
|
|
|
|
// Send EC_COMPLETE if we're not connected
|
|
|
|
if (m_pInputPin->IsConnected() == FALSE) {
|
|
NotifyEvent(EC_COMPLETE,S_OK,(LONG_PTR)(IBaseFilter *)this);
|
|
m_State = State_Running;
|
|
return NOERROR;
|
|
}
|
|
|
|
Ready();
|
|
|
|
// Pause the base filter class
|
|
|
|
HRESULT hr = CBaseFilter::Run(StartTime);
|
|
if (FAILED(hr)) {
|
|
NOTE("Run failed");
|
|
return hr;
|
|
}
|
|
|
|
// Allow the source thread to wait
|
|
ASSERT(m_pInputPin->IsFlushing() == FALSE);
|
|
SourceThreadCanWait(TRUE);
|
|
SetRepaintStatus(FALSE);
|
|
|
|
// There should be no outstanding advise
|
|
ASSERT(CancelNotification() == S_FALSE);
|
|
ASSERT(WAIT_TIMEOUT == WaitForSingleObject((HANDLE)m_RenderEvent,0));
|
|
ASSERT(m_EndOfStreamTimer == 0);
|
|
ASSERT(m_pInputPin->IsFlushing() == FALSE);
|
|
|
|
// If we are going into a running state then we must commit whatever
|
|
// allocator we are using it so that any source filter can call the
|
|
// GetBuffer and expect to get a buffer without returning an error
|
|
|
|
if (m_pInputPin->Allocator()) {
|
|
m_pInputPin->Allocator()->Commit();
|
|
}
|
|
|
|
// When we come out of a stopped state we must clear any image we were
|
|
// holding onto for frame refreshing. Since renderers see state changes
|
|
// first we can reset ourselves ready to accept the source thread data
|
|
// Paused or running after being stopped causes the current position to
|
|
// be reset so we're not interested in passing end of stream signals
|
|
|
|
if (OldState == State_Stopped) {
|
|
m_bAbort = FALSE;
|
|
ClearPendingSample();
|
|
}
|
|
return StartStreaming();
|
|
}
|
|
|
|
|
|
// Return the number of input pins we support
|
|
|
|
int CBaseRenderer::GetPinCount()
|
|
{
|
|
if (m_pInputPin == NULL) {
|
|
// Try to create it
|
|
(void)GetPin(0);
|
|
}
|
|
return m_pInputPin != NULL ? 1 : 0;
|
|
}
|
|
|
|
|
|
// We only support one input pin and it is numbered zero
|
|
|
|
CBasePin *CBaseRenderer::GetPin(int n)
|
|
{
|
|
CAutoLock cObjectCreationLock(&m_ObjectCreationLock);
|
|
|
|
// Should only ever be called with zero
|
|
ASSERT(n == 0);
|
|
|
|
if (n != 0) {
|
|
return NULL;
|
|
}
|
|
|
|
// Create the input pin if not already done so
|
|
|
|
if (m_pInputPin == NULL) {
|
|
|
|
// hr must be initialized to NOERROR because
|
|
// CRendererInputPin's constructor only changes
|
|
// hr's value if an error occurs.
|
|
HRESULT hr = NOERROR;
|
|
|
|
m_pInputPin = new CRendererInputPin(this,&hr,L"In");
|
|
if (NULL == m_pInputPin) {
|
|
return NULL;
|
|
}
|
|
|
|
if (FAILED(hr)) {
|
|
delete m_pInputPin;
|
|
m_pInputPin = NULL;
|
|
return NULL;
|
|
}
|
|
}
|
|
return m_pInputPin;
|
|
}
|
|
|
|
|
|
// If "In" then return the IPin for our input pin, otherwise NULL and error
|
|
|
|
STDMETHODIMP CBaseRenderer::FindPin(LPCWSTR Id, __deref_out IPin **ppPin)
|
|
{
|
|
CheckPointer(ppPin,E_POINTER);
|
|
|
|
if (0==lstrcmpW(Id,L"In")) {
|
|
*ppPin = GetPin(0);
|
|
if (*ppPin) {
|
|
(*ppPin)->AddRef();
|
|
} else {
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
} else {
|
|
*ppPin = NULL;
|
|
return VFW_E_NOT_FOUND;
|
|
}
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
// Called when the input pin receives an EndOfStream notification. If we have
|
|
// not got a sample, then notify EC_COMPLETE now. If we have samples, then set
|
|
// m_bEOS and check for this on completing samples. If we're waiting to pause
|
|
// then complete the transition to paused state by setting the state event
|
|
|
|
HRESULT CBaseRenderer::EndOfStream()
|
|
{
|
|
// Ignore these calls if we are stopped
|
|
|
|
if (m_State == State_Stopped) {
|
|
return NOERROR;
|
|
}
|
|
|
|
// If we have a sample then wait for it to be rendered
|
|
|
|
m_bEOS = TRUE;
|
|
if (m_pMediaSample) {
|
|
return NOERROR;
|
|
}
|
|
|
|
// If we are waiting for pause then we are now ready since we cannot now
|
|
// carry on waiting for a sample to arrive since we are being told there
|
|
// won't be any. This sets an event that the GetState function picks up
|
|
|
|
Ready();
|
|
|
|
// Only signal completion now if we are running otherwise queue it until
|
|
// we do run in StartStreaming. This is used when we seek because a seek
|
|
// causes a pause where early notification of completion is misleading
|
|
|
|
if (m_bStreaming) {
|
|
SendEndOfStream();
|
|
}
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
// When we are told to flush we should release the source thread
|
|
|
|
HRESULT CBaseRenderer::BeginFlush()
|
|
{
|
|
// If paused then report state intermediate until we get some data
|
|
|
|
if (m_State == State_Paused) {
|
|
NotReady();
|
|
}
|
|
|
|
SourceThreadCanWait(FALSE);
|
|
CancelNotification();
|
|
ClearPendingSample();
|
|
// Wait for Receive to complete
|
|
WaitForReceiveToComplete();
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
// After flushing the source thread can wait in Receive again
|
|
|
|
HRESULT CBaseRenderer::EndFlush()
|
|
{
|
|
// Reset the current sample media time
|
|
if (m_pPosition) m_pPosition->ResetMediaTime();
|
|
|
|
// There should be no outstanding advise
|
|
|
|
ASSERT(CancelNotification() == S_FALSE);
|
|
SourceThreadCanWait(TRUE);
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
// We can now send EC_REPAINTs if so required
|
|
|
|
HRESULT CBaseRenderer::CompleteConnect(IPin *pReceivePin)
|
|
{
|
|
// The caller should always hold the interface lock because
|
|
// the function uses CBaseFilter::m_State.
|
|
ASSERT(CritCheckIn(&m_InterfaceLock));
|
|
|
|
m_bAbort = FALSE;
|
|
|
|
if (State_Running == GetRealState()) {
|
|
HRESULT hr = StartStreaming();
|
|
if (FAILED(hr)) {
|
|
return hr;
|
|
}
|
|
|
|
SetRepaintStatus(FALSE);
|
|
} else {
|
|
SetRepaintStatus(TRUE);
|
|
}
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
// Called when we go paused or running
|
|
|
|
HRESULT CBaseRenderer::Active()
|
|
{
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
// Called when we go into a stopped state
|
|
|
|
HRESULT CBaseRenderer::Inactive()
|
|
{
|
|
if (m_pPosition) {
|
|
m_pPosition->ResetMediaTime();
|
|
}
|
|
// People who derive from this may want to override this behaviour
|
|
// to keep hold of the sample in some circumstances
|
|
ClearPendingSample();
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
// Tell derived classes about the media type agreed
|
|
|
|
HRESULT CBaseRenderer::SetMediaType(const CMediaType *pmt)
|
|
{
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
// When we break the input pin connection we should reset the EOS flags. When
|
|
// we are asked for either IMediaPosition or IMediaSeeking we will create a
|
|
// CPosPassThru object to handles media time pass through. When we're handed
|
|
// samples we store (by calling CPosPassThru::RegisterMediaTime) their media
|
|
// times so we can then return a real current position of data being rendered
|
|
|
|
HRESULT CBaseRenderer::BreakConnect()
|
|
{
|
|
// Do we have a quality management sink
|
|
|
|
if (m_pQSink) {
|
|
m_pQSink->Release();
|
|
m_pQSink = NULL;
|
|
}
|
|
|
|
// Check we have a valid connection
|
|
|
|
if (m_pInputPin->IsConnected() == FALSE) {
|
|
return S_FALSE;
|
|
}
|
|
|
|
// Check we are stopped before disconnecting
|
|
if (m_State != State_Stopped && !m_pInputPin->CanReconnectWhenActive()) {
|
|
return VFW_E_NOT_STOPPED;
|
|
}
|
|
|
|
SetRepaintStatus(FALSE);
|
|
ResetEndOfStream();
|
|
ClearPendingSample();
|
|
m_bAbort = FALSE;
|
|
|
|
if (State_Running == m_State) {
|
|
StopStreaming();
|
|
}
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
// Retrieves the sample times for this samples (note the sample times are
|
|
// passed in by reference not value). We return S_FALSE to say schedule this
|
|
// sample according to the times on the sample. We also return S_OK in
|
|
// which case the object should simply render the sample data immediately
|
|
|
|
HRESULT CBaseRenderer::GetSampleTimes(IMediaSample *pMediaSample,
|
|
__out REFERENCE_TIME *pStartTime,
|
|
__out REFERENCE_TIME *pEndTime)
|
|
{
|
|
ASSERT(m_dwAdvise == 0);
|
|
ASSERT(pMediaSample);
|
|
|
|
// If the stop time for this sample is before or the same as start time,
|
|
// then just ignore it (release it) and schedule the next one in line
|
|
// Source filters should always fill in the start and end times properly!
|
|
|
|
if (SUCCEEDED(pMediaSample->GetTime(pStartTime, pEndTime))) {
|
|
if (*pEndTime < *pStartTime) {
|
|
return VFW_E_START_TIME_AFTER_END;
|
|
}
|
|
} else {
|
|
// no time set in the sample... draw it now?
|
|
return S_OK;
|
|
}
|
|
|
|
// Can't synchronise without a clock so we return S_OK which tells the
|
|
// caller that the sample should be rendered immediately without going
|
|
// through the overhead of setting a timer advise link with the clock
|
|
|
|
if (m_pClock == NULL) {
|
|
return S_OK;
|
|
}
|
|
return ShouldDrawSampleNow(pMediaSample,pStartTime,pEndTime);
|
|
}
|
|
|
|
|
|
// By default all samples are drawn according to their time stamps so we
|
|
// return S_FALSE. Returning S_OK means draw immediately, this is used
|
|
// by the derived video renderer class in its quality management.
|
|
|
|
HRESULT CBaseRenderer::ShouldDrawSampleNow(IMediaSample *pMediaSample,
|
|
__out REFERENCE_TIME *ptrStart,
|
|
__out REFERENCE_TIME *ptrEnd)
|
|
{
|
|
return S_FALSE;
|
|
}
|
|
|
|
|
|
// We must always reset the current advise time to zero after a timer fires
|
|
// because there are several possible ways which lead us not to do any more
|
|
// scheduling such as the pending image being cleared after state changes
|
|
|
|
void CBaseRenderer::SignalTimerFired()
|
|
{
|
|
m_dwAdvise = 0;
|
|
}
|
|
|
|
|
|
// Cancel any notification currently scheduled. This is called by the owning
|
|
// window object when it is told to stop streaming. If there is no timer link
|
|
// outstanding then calling this is benign otherwise we go ahead and cancel
|
|
// We must always reset the render event as the quality management code can
|
|
// signal immediate rendering by setting the event without setting an advise
|
|
// link. If we're subsequently stopped and run the first attempt to setup an
|
|
// advise link with the reference clock will find the event still signalled
|
|
|
|
HRESULT CBaseRenderer::CancelNotification()
|
|
{
|
|
ASSERT(m_dwAdvise == 0 || m_pClock);
|
|
DWORD_PTR dwAdvise = m_dwAdvise;
|
|
|
|
// Have we a live advise link
|
|
|
|
if (m_dwAdvise) {
|
|
m_pClock->Unadvise(m_dwAdvise);
|
|
SignalTimerFired();
|
|
ASSERT(m_dwAdvise == 0);
|
|
}
|
|
|
|
// Clear the event and return our status
|
|
|
|
m_RenderEvent.Reset();
|
|
return (dwAdvise ? S_OK : S_FALSE);
|
|
}
|
|
|
|
|
|
// Responsible for setting up one shot advise links with the clock
|
|
// Return FALSE if the sample is to be dropped (not drawn at all)
|
|
// Return TRUE if the sample is to be drawn and in this case also
|
|
// arrange for m_RenderEvent to be set at the appropriate time
|
|
|
|
BOOL CBaseRenderer::ScheduleSample(IMediaSample *pMediaSample)
|
|
{
|
|
REFERENCE_TIME StartSample, EndSample;
|
|
|
|
// Is someone pulling our leg
|
|
|
|
if (pMediaSample == NULL) {
|
|
return FALSE;
|
|
}
|
|
|
|
// Get the next sample due up for rendering. If there aren't any ready
|
|
// then GetNextSampleTimes returns an error. If there is one to be done
|
|
// then it succeeds and yields the sample times. If it is due now then
|
|
// it returns S_OK other if it's to be done when due it returns S_FALSE
|
|
|
|
HRESULT hr = GetSampleTimes(pMediaSample, &StartSample, &EndSample);
|
|
if (FAILED(hr)) {
|
|
return FALSE;
|
|
}
|
|
|
|
// If we don't have a reference clock then we cannot set up the advise
|
|
// time so we simply set the event indicating an image to render. This
|
|
// will cause us to run flat out without any timing or synchronisation
|
|
|
|
if (hr == S_OK) {
|
|
EXECUTE_ASSERT(SetEvent((HANDLE) m_RenderEvent));
|
|
return TRUE;
|
|
}
|
|
|
|
ASSERT(m_dwAdvise == 0);
|
|
ASSERT(m_pClock);
|
|
ASSERT(WAIT_TIMEOUT == WaitForSingleObject((HANDLE)m_RenderEvent,0));
|
|
|
|
// We do have a valid reference clock interface so we can ask it to
|
|
// set an event when the image comes due for rendering. We pass in
|
|
// the reference time we were told to start at and also the current
|
|
// stream time which is the offset from the start reference time
|
|
|
|
hr = m_pClock->AdviseTime(
|
|
(REFERENCE_TIME) m_tStart, // Start run time
|
|
StartSample, // Stream time
|
|
(HEVENT)(HANDLE) m_RenderEvent, // Render notification
|
|
&m_dwAdvise); // Advise cookie
|
|
|
|
if (SUCCEEDED(hr)) {
|
|
return TRUE;
|
|
}
|
|
|
|
// We could not schedule the next sample for rendering despite the fact
|
|
// we have a valid sample here. This is a fair indication that either
|
|
// the system clock is wrong or the time stamp for the sample is duff
|
|
|
|
ASSERT(m_dwAdvise == 0);
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// This is called when a sample comes due for rendering. We pass the sample
|
|
// on to the derived class. After rendering we will initialise the timer for
|
|
// the next sample, NOTE signal that the last one fired first, if we don't
|
|
// do this it thinks there is still one outstanding that hasn't completed
|
|
|
|
HRESULT CBaseRenderer::Render(IMediaSample *pMediaSample)
|
|
{
|
|
// If the media sample is NULL then we will have been notified by the
|
|
// clock that another sample is ready but in the mean time someone has
|
|
// stopped us streaming which causes the next sample to be released
|
|
|
|
if (pMediaSample == NULL) {
|
|
return S_FALSE;
|
|
}
|
|
|
|
// If we have stopped streaming then don't render any more samples, the
|
|
// thread that got in and locked us and then reset this flag does not
|
|
// clear the pending sample as we can use it to refresh any output device
|
|
|
|
if (m_bStreaming == FALSE) {
|
|
return S_FALSE;
|
|
}
|
|
|
|
// Time how long the rendering takes
|
|
|
|
OnRenderStart(pMediaSample);
|
|
DoRenderSample(pMediaSample);
|
|
OnRenderEnd(pMediaSample);
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
// Checks if there is a sample waiting at the renderer
|
|
|
|
BOOL CBaseRenderer::HaveCurrentSample()
|
|
{
|
|
CAutoLock cRendererLock(&m_RendererLock);
|
|
return (m_pMediaSample == NULL ? FALSE : TRUE);
|
|
}
|
|
|
|
|
|
// Returns the current sample waiting at the video renderer. We AddRef the
|
|
// sample before returning so that should it come due for rendering the
|
|
// person who called this method will hold the remaining reference count
|
|
// that will stop the sample being added back onto the allocator free list
|
|
|
|
IMediaSample *CBaseRenderer::GetCurrentSample()
|
|
{
|
|
CAutoLock cRendererLock(&m_RendererLock);
|
|
if (m_pMediaSample) {
|
|
m_pMediaSample->AddRef();
|
|
}
|
|
return m_pMediaSample;
|
|
}
|
|
|
|
|
|
// Called when the source delivers us a sample. We go through a few checks to
|
|
// make sure the sample can be rendered. If we are running (streaming) then we
|
|
// have the sample scheduled with the reference clock, if we are not streaming
|
|
// then we have received an sample in paused mode so we can complete any state
|
|
// transition. On leaving this function everything will be unlocked so an app
|
|
// thread may get in and change our state to stopped (for example) in which
|
|
// case it will also signal the thread event so that our wait call is stopped
|
|
|
|
HRESULT CBaseRenderer::PrepareReceive(IMediaSample *pMediaSample)
|
|
{
|
|
CAutoLock cInterfaceLock(&m_InterfaceLock);
|
|
m_bInReceive = TRUE;
|
|
|
|
// Check our flushing and filter state
|
|
|
|
// This function must hold the interface lock because it calls
|
|
// CBaseInputPin::Receive() and CBaseInputPin::Receive() uses
|
|
// CBasePin::m_bRunTimeError.
|
|
HRESULT hr = m_pInputPin->CBaseInputPin::Receive(pMediaSample);
|
|
|
|
if (hr != NOERROR) {
|
|
m_bInReceive = FALSE;
|
|
return E_FAIL;
|
|
}
|
|
|
|
// Has the type changed on a media sample. We do all rendering
|
|
// synchronously on the source thread, which has a side effect
|
|
// that only one buffer is ever outstanding. Therefore when we
|
|
// have Receive called we can go ahead and change the format
|
|
// Since the format change can cause a SendMessage we just don't
|
|
// lock
|
|
if (m_pInputPin->SampleProps()->pMediaType) {
|
|
hr = m_pInputPin->SetMediaType(
|
|
(CMediaType *)m_pInputPin->SampleProps()->pMediaType);
|
|
if (FAILED(hr)) {
|
|
m_bInReceive = FALSE;
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
|
|
CAutoLock cSampleLock(&m_RendererLock);
|
|
|
|
ASSERT(IsActive() == TRUE);
|
|
ASSERT(m_pInputPin->IsFlushing() == FALSE);
|
|
ASSERT(m_pInputPin->IsConnected() == TRUE);
|
|
ASSERT(m_pMediaSample == NULL);
|
|
|
|
// Return an error if we already have a sample waiting for rendering
|
|
// source pins must serialise the Receive calls - we also check that
|
|
// no data is being sent after the source signalled an end of stream
|
|
|
|
if (m_pMediaSample || m_bEOS || m_bAbort) {
|
|
Ready();
|
|
m_bInReceive = FALSE;
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
// Store the media times from this sample
|
|
if (m_pPosition) m_pPosition->RegisterMediaTime(pMediaSample);
|
|
|
|
// Schedule the next sample if we are streaming
|
|
|
|
if ((m_bStreaming == TRUE) && (ScheduleSample(pMediaSample) == FALSE)) {
|
|
ASSERT(WAIT_TIMEOUT == WaitForSingleObject((HANDLE)m_RenderEvent,0));
|
|
ASSERT(CancelNotification() == S_FALSE);
|
|
m_bInReceive = FALSE;
|
|
return VFW_E_SAMPLE_REJECTED;
|
|
}
|
|
|
|
// Store the sample end time for EC_COMPLETE handling
|
|
m_SignalTime = m_pInputPin->SampleProps()->tStop;
|
|
|
|
// BEWARE we sometimes keep the sample even after returning the thread to
|
|
// the source filter such as when we go into a stopped state (we keep it
|
|
// to refresh the device with) so we must AddRef it to keep it safely. If
|
|
// we start flushing the source thread is released and any sample waiting
|
|
// will be released otherwise GetBuffer may never return (see BeginFlush)
|
|
|
|
m_pMediaSample = pMediaSample;
|
|
m_pMediaSample->AddRef();
|
|
|
|
if (m_bStreaming == FALSE) {
|
|
SetRepaintStatus(TRUE);
|
|
}
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
// Called by the source filter when we have a sample to render. Under normal
|
|
// circumstances we set an advise link with the clock, wait for the time to
|
|
// arrive and then render the data using the PURE virtual DoRenderSample that
|
|
// the derived class will have overriden. After rendering the sample we may
|
|
// also signal EOS if it was the last one sent before EndOfStream was called
|
|
|
|
HRESULT CBaseRenderer::Receive(IMediaSample *pSample)
|
|
{
|
|
ASSERT(pSample);
|
|
|
|
// It may return VFW_E_SAMPLE_REJECTED code to say don't bother
|
|
|
|
HRESULT hr = PrepareReceive(pSample);
|
|
ASSERT(m_bInReceive == SUCCEEDED(hr));
|
|
if (FAILED(hr)) {
|
|
if (hr == VFW_E_SAMPLE_REJECTED) {
|
|
return NOERROR;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
// We realize the palette in "PrepareRender()" so we have to give away the
|
|
// filter lock here.
|
|
if (m_State == State_Paused) {
|
|
PrepareRender();
|
|
// no need to use InterlockedExchange
|
|
m_bInReceive = FALSE;
|
|
{
|
|
// We must hold both these locks
|
|
CAutoLock cRendererLock(&m_InterfaceLock);
|
|
if (m_State == State_Stopped)
|
|
return NOERROR;
|
|
|
|
m_bInReceive = TRUE;
|
|
CAutoLock cSampleLock(&m_RendererLock);
|
|
OnReceiveFirstSample(pSample);
|
|
}
|
|
Ready();
|
|
}
|
|
// Having set an advise link with the clock we sit and wait. We may be
|
|
// awoken by the clock firing or by a state change. The rendering call
|
|
// will lock the critical section and check we can still render the data
|
|
|
|
hr = WaitForRenderTime();
|
|
if (FAILED(hr)) {
|
|
m_bInReceive = FALSE;
|
|
return NOERROR;
|
|
}
|
|
|
|
PrepareRender();
|
|
|
|
// Set this here and poll it until we work out the locking correctly
|
|
// It can't be right that the streaming stuff grabs the interface
|
|
// lock - after all we want to be able to wait for this stuff
|
|
// to complete
|
|
m_bInReceive = FALSE;
|
|
|
|
// We must hold both these locks
|
|
CAutoLock cRendererLock(&m_InterfaceLock);
|
|
|
|
// since we gave away the filter wide lock, the sate of the filter could
|
|
// have chnaged to Stopped
|
|
if (m_State == State_Stopped)
|
|
return NOERROR;
|
|
|
|
CAutoLock cSampleLock(&m_RendererLock);
|
|
|
|
// Deal with this sample
|
|
|
|
Render(m_pMediaSample);
|
|
ClearPendingSample();
|
|
SendEndOfStream();
|
|
CancelNotification();
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
// This is called when we stop or are inactivated to clear the pending sample
|
|
// We release the media sample interface so that they can be allocated to the
|
|
// source filter again, unless of course we are changing state to inactive in
|
|
// which case GetBuffer will return an error. We must also reset the current
|
|
// media sample to NULL so that we know we do not currently have an image
|
|
|
|
HRESULT CBaseRenderer::ClearPendingSample()
|
|
{
|
|
CAutoLock cRendererLock(&m_RendererLock);
|
|
if (m_pMediaSample) {
|
|
m_pMediaSample->Release();
|
|
m_pMediaSample = NULL;
|
|
}
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
// Used to signal end of stream according to the sample end time
|
|
|
|
void CALLBACK EndOfStreamTimer(UINT uID, // Timer identifier
|
|
UINT uMsg, // Not currently used
|
|
DWORD_PTR dwUser,// User information
|
|
DWORD_PTR dw1, // Windows reserved
|
|
DWORD_PTR dw2) // is also reserved
|
|
{
|
|
CBaseRenderer *pRenderer = (CBaseRenderer *) dwUser;
|
|
NOTE1("EndOfStreamTimer called (%d)",uID);
|
|
pRenderer->TimerCallback();
|
|
}
|
|
|
|
// Do the timer callback work
|
|
void CBaseRenderer::TimerCallback()
|
|
{
|
|
// Lock for synchronization (but don't hold this lock when calling
|
|
// timeKillEvent)
|
|
CAutoLock cRendererLock(&m_RendererLock);
|
|
|
|
// See if we should signal end of stream now
|
|
|
|
if (m_EndOfStreamTimer) {
|
|
m_EndOfStreamTimer = 0;
|
|
SendEndOfStream();
|
|
}
|
|
}
|
|
|
|
|
|
// If we are at the end of the stream signal the filter graph but do not set
|
|
// the state flag back to FALSE. Once we drop off the end of the stream we
|
|
// leave the flag set (until a subsequent ResetEndOfStream). Each sample we
|
|
// get delivered will update m_SignalTime to be the last sample's end time.
|
|
// We must wait this long before signalling end of stream to the filtergraph
|
|
|
|
#define TIMEOUT_DELIVERYWAIT 50
|
|
#define TIMEOUT_RESOLUTION 10
|
|
|
|
HRESULT CBaseRenderer::SendEndOfStream()
|
|
{
|
|
ASSERT(CritCheckIn(&m_RendererLock));
|
|
if (m_bEOS == FALSE || m_bEOSDelivered || m_EndOfStreamTimer) {
|
|
return NOERROR;
|
|
}
|
|
|
|
// If there is no clock then signal immediately
|
|
if (m_pClock == NULL) {
|
|
return NotifyEndOfStream();
|
|
}
|
|
|
|
// How long into the future is the delivery time
|
|
|
|
REFERENCE_TIME Signal = m_tStart + m_SignalTime;
|
|
REFERENCE_TIME CurrentTime;
|
|
m_pClock->GetTime(&CurrentTime);
|
|
LONG Delay = LONG((Signal - CurrentTime) / 10000);
|
|
|
|
// Dump the timing information to the debugger
|
|
|
|
NOTE1("Delay until end of stream delivery %d",Delay);
|
|
NOTE1("Current %s",(LPCTSTR)CDisp((LONGLONG)CurrentTime));
|
|
NOTE1("Signal %s",(LPCTSTR)CDisp((LONGLONG)Signal));
|
|
|
|
// Wait for the delivery time to arrive
|
|
|
|
if (Delay < TIMEOUT_DELIVERYWAIT) {
|
|
return NotifyEndOfStream();
|
|
}
|
|
|
|
// Signal a timer callback on another worker thread
|
|
|
|
m_EndOfStreamTimer = CompatibleTimeSetEvent((UINT) Delay, // Period of timer
|
|
TIMEOUT_RESOLUTION, // Timer resolution
|
|
EndOfStreamTimer, // Callback function
|
|
DWORD_PTR(this), // Used information
|
|
TIME_ONESHOT); // Type of callback
|
|
if (m_EndOfStreamTimer == 0) {
|
|
return NotifyEndOfStream();
|
|
}
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
// Signals EC_COMPLETE to the filtergraph manager
|
|
|
|
HRESULT CBaseRenderer::NotifyEndOfStream()
|
|
{
|
|
CAutoLock cRendererLock(&m_RendererLock);
|
|
ASSERT(m_bEOSDelivered == FALSE);
|
|
ASSERT(m_EndOfStreamTimer == 0);
|
|
|
|
// Has the filter changed state
|
|
|
|
if (m_bStreaming == FALSE) {
|
|
ASSERT(m_EndOfStreamTimer == 0);
|
|
return NOERROR;
|
|
}
|
|
|
|
// Reset the end of stream timer
|
|
m_EndOfStreamTimer = 0;
|
|
|
|
// If we've been using the IMediaPosition interface, set it's start
|
|
// and end media "times" to the stop position by hand. This ensures
|
|
// that we actually get to the end, even if the MPEG guestimate has
|
|
// been bad or if the quality management dropped the last few frames
|
|
|
|
if (m_pPosition) m_pPosition->EOS();
|
|
m_bEOSDelivered = TRUE;
|
|
NOTE("Sending EC_COMPLETE...");
|
|
return NotifyEvent(EC_COMPLETE,S_OK,(LONG_PTR)(IBaseFilter *)this);
|
|
}
|
|
|
|
|
|
// Reset the end of stream flag, this is typically called when we transfer to
|
|
// stopped states since that resets the current position back to the start so
|
|
// we will receive more samples or another EndOfStream if there aren't any. We
|
|
// keep two separate flags one to say we have run off the end of the stream
|
|
// (this is the m_bEOS flag) and another to say we have delivered EC_COMPLETE
|
|
// to the filter graph. We need the latter otherwise we can end up sending an
|
|
// EC_COMPLETE every time the source changes state and calls our EndOfStream
|
|
|
|
HRESULT CBaseRenderer::ResetEndOfStream()
|
|
{
|
|
ResetEndOfStreamTimer();
|
|
CAutoLock cRendererLock(&m_RendererLock);
|
|
|
|
m_bEOS = FALSE;
|
|
m_bEOSDelivered = FALSE;
|
|
m_SignalTime = 0;
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
// Kills any outstanding end of stream timer
|
|
|
|
void CBaseRenderer::ResetEndOfStreamTimer()
|
|
{
|
|
ASSERT(CritCheckOut(&m_RendererLock));
|
|
if (m_EndOfStreamTimer) {
|
|
timeKillEvent(m_EndOfStreamTimer);
|
|
m_EndOfStreamTimer = 0;
|
|
}
|
|
}
|
|
|
|
|
|
// This is called when we start running so that we can schedule any pending
|
|
// image we have with the clock and display any timing information. If we
|
|
// don't have any sample but we have queued an EOS flag then we send it. If
|
|
// we do have a sample then we wait until that has been rendered before we
|
|
// signal the filter graph otherwise we may change state before it's done
|
|
|
|
HRESULT CBaseRenderer::StartStreaming()
|
|
{
|
|
CAutoLock cRendererLock(&m_RendererLock);
|
|
if (m_bStreaming == TRUE) {
|
|
return NOERROR;
|
|
}
|
|
|
|
// Reset the streaming times ready for running
|
|
|
|
m_bStreaming = TRUE;
|
|
|
|
timeBeginPeriod(1);
|
|
OnStartStreaming();
|
|
|
|
// There should be no outstanding advise
|
|
ASSERT(WAIT_TIMEOUT == WaitForSingleObject((HANDLE)m_RenderEvent,0));
|
|
ASSERT(CancelNotification() == S_FALSE);
|
|
|
|
// If we have an EOS and no data then deliver it now
|
|
|
|
if (m_pMediaSample == NULL) {
|
|
return SendEndOfStream();
|
|
}
|
|
|
|
// Have the data rendered
|
|
|
|
ASSERT(m_pMediaSample);
|
|
if (!ScheduleSample(m_pMediaSample))
|
|
m_RenderEvent.Set();
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
// This is called when we stop streaming so that we can set our internal flag
|
|
// indicating we are not now to schedule any more samples arriving. The state
|
|
// change methods in the filter implementation take care of cancelling any
|
|
// clock advise link we have set up and clearing any pending sample we have
|
|
|
|
HRESULT CBaseRenderer::StopStreaming()
|
|
{
|
|
CAutoLock cRendererLock(&m_RendererLock);
|
|
m_bEOSDelivered = FALSE;
|
|
|
|
if (m_bStreaming == TRUE) {
|
|
m_bStreaming = FALSE;
|
|
OnStopStreaming();
|
|
timeEndPeriod(1);
|
|
}
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
// We have a boolean flag that is reset when we have signalled EC_REPAINT to
|
|
// the filter graph. We set this when we receive an image so that should any
|
|
// conditions arise again we can send another one. By having a flag we ensure
|
|
// we don't flood the filter graph with redundant calls. We do not set the
|
|
// event when we receive an EndOfStream call since there is no point in us
|
|
// sending further EC_REPAINTs. In particular the AutoShowWindow method and
|
|
// the DirectDraw object use this method to control the window repainting
|
|
|
|
void CBaseRenderer::SetRepaintStatus(BOOL bRepaint)
|
|
{
|
|
CAutoLock cSampleLock(&m_RendererLock);
|
|
m_bRepaintStatus = bRepaint;
|
|
}
|
|
|
|
|
|
// Pass the window handle to the upstream filter
|
|
|
|
void CBaseRenderer::SendNotifyWindow(IPin *pPin,HWND hwnd)
|
|
{
|
|
IMediaEventSink *pSink;
|
|
|
|
// Does the pin support IMediaEventSink
|
|
HRESULT hr = pPin->QueryInterface(IID_IMediaEventSink,(void **)&pSink);
|
|
if (SUCCEEDED(hr)) {
|
|
pSink->Notify(EC_NOTIFY_WINDOW,LONG_PTR(hwnd),0);
|
|
pSink->Release();
|
|
}
|
|
NotifyEvent(EC_NOTIFY_WINDOW,LONG_PTR(hwnd),0);
|
|
}
|
|
|
|
|
|
// Signal an EC_REPAINT to the filter graph. This can be used to have data
|
|
// sent to us. For example when a video window is first displayed it may
|
|
// not have an image to display, at which point it signals EC_REPAINT. The
|
|
// filtergraph will either pause the graph if stopped or if already paused
|
|
// it will call put_CurrentPosition of the current position. Setting the
|
|
// current position to itself has the stream flushed and the image resent
|
|
|
|
#define RLOG(_x_) DbgLog((LOG_TRACE,1,TEXT(_x_)));
|
|
|
|
void CBaseRenderer::SendRepaint()
|
|
{
|
|
CAutoLock cSampleLock(&m_RendererLock);
|
|
ASSERT(m_pInputPin);
|
|
|
|
// We should not send repaint notifications when...
|
|
// - An end of stream has been notified
|
|
// - Our input pin is being flushed
|
|
// - The input pin is not connected
|
|
// - We have aborted a video playback
|
|
// - There is a repaint already sent
|
|
|
|
if (m_bAbort == FALSE) {
|
|
if (m_pInputPin->IsConnected() == TRUE) {
|
|
if (m_pInputPin->IsFlushing() == FALSE) {
|
|
if (IsEndOfStream() == FALSE) {
|
|
if (m_bRepaintStatus == TRUE) {
|
|
IPin *pPin = (IPin *) m_pInputPin;
|
|
NotifyEvent(EC_REPAINT,(LONG_PTR) pPin,0);
|
|
SetRepaintStatus(FALSE);
|
|
RLOG("Sending repaint");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// When a video window detects a display change (WM_DISPLAYCHANGE message) it
|
|
// can send an EC_DISPLAY_CHANGED event code along with the renderer pin. The
|
|
// filtergraph will stop everyone and reconnect our input pin. As we're then
|
|
// reconnected we can accept the media type that matches the new display mode
|
|
// since we may no longer be able to draw the current image type efficiently
|
|
|
|
BOOL CBaseRenderer::OnDisplayChange()
|
|
{
|
|
// Ignore if we are not connected yet
|
|
|
|
CAutoLock cSampleLock(&m_RendererLock);
|
|
if (m_pInputPin->IsConnected() == FALSE) {
|
|
return FALSE;
|
|
}
|
|
|
|
RLOG("Notification of EC_DISPLAY_CHANGE");
|
|
|
|
// Pass our input pin as parameter on the event
|
|
|
|
IPin *pPin = (IPin *) m_pInputPin;
|
|
m_pInputPin->AddRef();
|
|
NotifyEvent(EC_DISPLAY_CHANGED,(LONG_PTR) pPin,0);
|
|
SetAbortSignal(TRUE);
|
|
ClearPendingSample();
|
|
m_pInputPin->Release();
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// Called just before we start drawing.
|
|
// Store the current time in m_trRenderStart to allow the rendering time to be
|
|
// logged. Log the time stamp of the sample and how late it is (neg is early)
|
|
|
|
void CBaseRenderer::OnRenderStart(IMediaSample *pMediaSample)
|
|
{
|
|
#ifdef PERF
|
|
REFERENCE_TIME trStart, trEnd;
|
|
pMediaSample->GetTime(&trStart, &trEnd);
|
|
|
|
MSR_INTEGER(m_idBaseStamp, (int)trStart); // dump low order 32 bits
|
|
|
|
m_pClock->GetTime(&m_trRenderStart);
|
|
MSR_INTEGER(0, (int)m_trRenderStart);
|
|
REFERENCE_TIME trStream;
|
|
trStream = m_trRenderStart-m_tStart; // convert reftime to stream time
|
|
MSR_INTEGER(0,(int)trStream);
|
|
|
|
const int trLate = (int)(trStream - trStart);
|
|
MSR_INTEGER(m_idBaseAccuracy, trLate/10000); // dump in mSec
|
|
#endif
|
|
|
|
} // OnRenderStart
|
|
|
|
|
|
// Called directly after drawing an image.
|
|
// calculate the time spent drawing and log it.
|
|
|
|
void CBaseRenderer::OnRenderEnd(IMediaSample *pMediaSample)
|
|
{
|
|
#ifdef PERF
|
|
REFERENCE_TIME trNow;
|
|
m_pClock->GetTime(&trNow);
|
|
MSR_INTEGER(0,(int)trNow);
|
|
int t = (int)((trNow - m_trRenderStart)/10000); // convert UNITS->msec
|
|
MSR_INTEGER(m_idBaseRenderTime, t);
|
|
#endif
|
|
} // OnRenderEnd
|
|
|
|
|
|
|
|
|
|
// Constructor must be passed the base renderer object
|
|
|
|
CRendererInputPin::CRendererInputPin(__inout CBaseRenderer *pRenderer,
|
|
__inout HRESULT *phr,
|
|
__in_opt LPCWSTR pPinName) :
|
|
CBaseInputPin(NAME("Renderer pin"),
|
|
pRenderer,
|
|
&pRenderer->m_InterfaceLock,
|
|
(HRESULT *) phr,
|
|
pPinName)
|
|
{
|
|
m_pRenderer = pRenderer;
|
|
ASSERT(m_pRenderer);
|
|
}
|
|
|
|
|
|
// Signals end of data stream on the input pin
|
|
|
|
STDMETHODIMP CRendererInputPin::EndOfStream()
|
|
{
|
|
CAutoLock cRendererLock(&m_pRenderer->m_InterfaceLock);
|
|
CAutoLock cSampleLock(&m_pRenderer->m_RendererLock);
|
|
|
|
// Make sure we're streaming ok
|
|
|
|
HRESULT hr = CheckStreaming();
|
|
if (hr != NOERROR) {
|
|
return hr;
|
|
}
|
|
|
|
// Pass it onto the renderer
|
|
|
|
hr = m_pRenderer->EndOfStream();
|
|
if (SUCCEEDED(hr)) {
|
|
hr = CBaseInputPin::EndOfStream();
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
// Signals start of flushing on the input pin - we do the final reset end of
|
|
// stream with the renderer lock unlocked but with the interface lock locked
|
|
// We must do this because we call timeKillEvent, our timer callback method
|
|
// has to take the renderer lock to serialise our state. Therefore holding a
|
|
// renderer lock when calling timeKillEvent could cause a deadlock condition
|
|
|
|
STDMETHODIMP CRendererInputPin::BeginFlush()
|
|
{
|
|
CAutoLock cRendererLock(&m_pRenderer->m_InterfaceLock);
|
|
{
|
|
CAutoLock cSampleLock(&m_pRenderer->m_RendererLock);
|
|
CBaseInputPin::BeginFlush();
|
|
m_pRenderer->BeginFlush();
|
|
}
|
|
return m_pRenderer->ResetEndOfStream();
|
|
}
|
|
|
|
|
|
// Signals end of flushing on the input pin
|
|
|
|
STDMETHODIMP CRendererInputPin::EndFlush()
|
|
{
|
|
CAutoLock cRendererLock(&m_pRenderer->m_InterfaceLock);
|
|
CAutoLock cSampleLock(&m_pRenderer->m_RendererLock);
|
|
|
|
HRESULT hr = m_pRenderer->EndFlush();
|
|
if (SUCCEEDED(hr)) {
|
|
hr = CBaseInputPin::EndFlush();
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
// Pass the sample straight through to the renderer object
|
|
|
|
STDMETHODIMP CRendererInputPin::Receive(IMediaSample *pSample)
|
|
{
|
|
HRESULT hr = m_pRenderer->Receive(pSample);
|
|
if (FAILED(hr)) {
|
|
|
|
// A deadlock could occur if the caller holds the renderer lock and
|
|
// attempts to acquire the interface lock.
|
|
ASSERT(CritCheckOut(&m_pRenderer->m_RendererLock));
|
|
|
|
{
|
|
// The interface lock must be held when the filter is calling
|
|
// IsStopped() or IsFlushing(). The interface lock must also
|
|
// be held because the function uses m_bRunTimeError.
|
|
CAutoLock cRendererLock(&m_pRenderer->m_InterfaceLock);
|
|
|
|
// We do not report errors which occur while the filter is stopping,
|
|
// flushing or if the m_bAbort flag is set . Errors are expected to
|
|
// occur during these operations and the streaming thread correctly
|
|
// handles the errors.
|
|
if (!IsStopped() && !IsFlushing() && !m_pRenderer->m_bAbort && !m_bRunTimeError) {
|
|
|
|
// EC_ERRORABORT's first parameter is the error which caused
|
|
// the event and its' last parameter is 0. See the Direct
|
|
// Show SDK documentation for more information.
|
|
m_pRenderer->NotifyEvent(EC_ERRORABORT,hr,0);
|
|
|
|
{
|
|
CAutoLock alRendererLock(&m_pRenderer->m_RendererLock);
|
|
if (m_pRenderer->IsStreaming() && !m_pRenderer->IsEndOfStreamDelivered()) {
|
|
m_pRenderer->NotifyEndOfStream();
|
|
}
|
|
}
|
|
|
|
m_bRunTimeError = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
// Called when the input pin is disconnected
|
|
|
|
HRESULT CRendererInputPin::BreakConnect()
|
|
{
|
|
HRESULT hr = m_pRenderer->BreakConnect();
|
|
if (FAILED(hr)) {
|
|
return hr;
|
|
}
|
|
return CBaseInputPin::BreakConnect();
|
|
}
|
|
|
|
|
|
// Called when the input pin is connected
|
|
|
|
HRESULT CRendererInputPin::CompleteConnect(IPin *pReceivePin)
|
|
{
|
|
HRESULT hr = m_pRenderer->CompleteConnect(pReceivePin);
|
|
if (FAILED(hr)) {
|
|
return hr;
|
|
}
|
|
return CBaseInputPin::CompleteConnect(pReceivePin);
|
|
}
|
|
|
|
|
|
// Give the pin id of our one and only pin
|
|
|
|
STDMETHODIMP CRendererInputPin::QueryId(__deref_out LPWSTR *Id)
|
|
{
|
|
CheckPointer(Id,E_POINTER);
|
|
|
|
const WCHAR szIn[] = L"In";
|
|
|
|
*Id = (LPWSTR)CoTaskMemAlloc(sizeof(szIn));
|
|
if (*Id == NULL) {
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
CopyMemory(*Id, szIn, sizeof(szIn));
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
// Will the filter accept this media type
|
|
|
|
HRESULT CRendererInputPin::CheckMediaType(const CMediaType *pmt)
|
|
{
|
|
return m_pRenderer->CheckMediaType(pmt);
|
|
}
|
|
|
|
|
|
// Called when we go paused or running
|
|
|
|
HRESULT CRendererInputPin::Active()
|
|
{
|
|
return m_pRenderer->Active();
|
|
}
|
|
|
|
|
|
// Called when we go into a stopped state
|
|
|
|
HRESULT CRendererInputPin::Inactive()
|
|
{
|
|
// The caller must hold the interface lock because
|
|
// this function uses m_bRunTimeError.
|
|
ASSERT(CritCheckIn(&m_pRenderer->m_InterfaceLock));
|
|
|
|
m_bRunTimeError = FALSE;
|
|
|
|
return m_pRenderer->Inactive();
|
|
}
|
|
|
|
|
|
// Tell derived classes about the media type agreed
|
|
|
|
HRESULT CRendererInputPin::SetMediaType(const CMediaType *pmt)
|
|
{
|
|
HRESULT hr = CBaseInputPin::SetMediaType(pmt);
|
|
if (FAILED(hr)) {
|
|
return hr;
|
|
}
|
|
return m_pRenderer->SetMediaType(pmt);
|
|
}
|
|
|
|
|
|
// We do not keep an event object to use when setting up a timer link with
|
|
// the clock but are given a pointer to one by the owning object through the
|
|
// SetNotificationObject method - this must be initialised before starting
|
|
// We can override the default quality management process to have it always
|
|
// draw late frames, this is currently done by having the following registry
|
|
// key (actually an INI key) called DrawLateFrames set to 1 (default is 0)
|
|
|
|
const TCHAR AMQUALITY[] = TEXT("ActiveMovie");
|
|
const TCHAR DRAWLATEFRAMES[] = TEXT("DrawLateFrames");
|
|
|
|
CBaseVideoRenderer::CBaseVideoRenderer(
|
|
REFCLSID RenderClass, // CLSID for this renderer
|
|
__in_opt LPCTSTR pName, // Debug ONLY description
|
|
__inout_opt LPUNKNOWN pUnk, // Aggregated owner object
|
|
__inout HRESULT *phr) : // General OLE return code
|
|
|
|
CBaseRenderer(RenderClass,pName,pUnk,phr),
|
|
m_cFramesDropped(0),
|
|
m_cFramesDrawn(0),
|
|
m_bSupplierHandlingQuality(FALSE)
|
|
{
|
|
ResetStreamingTimes();
|
|
|
|
#ifdef PERF
|
|
m_idTimeStamp = MSR_REGISTER(TEXT("Frame time stamp"));
|
|
m_idEarliness = MSR_REGISTER(TEXT("Earliness fudge"));
|
|
m_idTarget = MSR_REGISTER(TEXT("Target (mSec)"));
|
|
m_idSchLateTime = MSR_REGISTER(TEXT("mSec late when scheduled"));
|
|
m_idDecision = MSR_REGISTER(TEXT("Scheduler decision code"));
|
|
m_idQualityRate = MSR_REGISTER(TEXT("Quality rate sent"));
|
|
m_idQualityTime = MSR_REGISTER(TEXT("Quality time sent"));
|
|
m_idWaitReal = MSR_REGISTER(TEXT("Render wait"));
|
|
// m_idWait = MSR_REGISTER(TEXT("wait time recorded (msec)"));
|
|
m_idFrameAccuracy = MSR_REGISTER(TEXT("Frame accuracy (msecs)"));
|
|
m_bDrawLateFrames = GetProfileInt(AMQUALITY, DRAWLATEFRAMES, FALSE);
|
|
//m_idSendQuality = MSR_REGISTER(TEXT("Processing Quality message"));
|
|
|
|
m_idRenderAvg = MSR_REGISTER(TEXT("Render draw time Avg"));
|
|
m_idFrameAvg = MSR_REGISTER(TEXT("FrameAvg"));
|
|
m_idWaitAvg = MSR_REGISTER(TEXT("WaitAvg"));
|
|
m_idDuration = MSR_REGISTER(TEXT("Duration"));
|
|
m_idThrottle = MSR_REGISTER(TEXT("Audio-video throttle wait"));
|
|
// m_idDebug = MSR_REGISTER(TEXT("Debug stuff"));
|
|
#endif // PERF
|
|
} // Constructor
|
|
|
|
|
|
// Destructor is just a placeholder
|
|
|
|
CBaseVideoRenderer::~CBaseVideoRenderer()
|
|
{
|
|
ASSERT(m_dwAdvise == 0);
|
|
}
|
|
|
|
|
|
// The timing functions in this class are called by the window object and by
|
|
// the renderer's allocator.
|
|
// The windows object calls timing functions as it receives media sample
|
|
// images for drawing using GDI.
|
|
// The allocator calls timing functions when it starts passing DCI/DirectDraw
|
|
// surfaces which are not rendered in the same way; The decompressor writes
|
|
// directly to the surface with no separate rendering, so those code paths
|
|
// call direct into us. Since we only ever hand out DCI/DirectDraw surfaces
|
|
// when we have allocated one and only one image we know there cannot be any
|
|
// conflict between the two.
|
|
//
|
|
// We use timeGetTime to return the timing counts we use (since it's relative
|
|
// performance we are interested in rather than absolute compared to a clock)
|
|
// The window object sets the accuracy of the system clock (normally 1ms) by
|
|
// calling timeBeginPeriod/timeEndPeriod when it changes streaming states
|
|
|
|
|
|
// Reset all times controlling streaming.
|
|
// Set them so that
|
|
// 1. Frames will not initially be dropped
|
|
// 2. The first frame will definitely be drawn (achieved by saying that there
|
|
// has not ben a frame drawn for a long time).
|
|
|
|
HRESULT CBaseVideoRenderer::ResetStreamingTimes()
|
|
{
|
|
m_trLastDraw = -1000; // set up as first frame since ages (1 sec) ago
|
|
m_tStreamingStart = timeGetTime();
|
|
m_trRenderAvg = 0;
|
|
m_trFrameAvg = -1; // -1000 fps == "unset"
|
|
m_trDuration = 0; // 0 - strange value
|
|
m_trRenderLast = 0;
|
|
m_trWaitAvg = 0;
|
|
m_tRenderStart = 0;
|
|
m_cFramesDrawn = 0;
|
|
m_cFramesDropped = 0;
|
|
m_iTotAcc = 0;
|
|
m_iSumSqAcc = 0;
|
|
m_iSumSqFrameTime = 0;
|
|
m_trFrame = 0; // hygeine - not really needed
|
|
m_trLate = 0; // hygeine - not really needed
|
|
m_iSumFrameTime = 0;
|
|
m_nNormal = 0;
|
|
m_trEarliness = 0;
|
|
m_trTarget = -300000; // 30mSec early
|
|
m_trThrottle = 0;
|
|
m_trRememberStampForPerf = 0;
|
|
|
|
#ifdef PERF
|
|
m_trRememberFrameForPerf = 0;
|
|
#endif
|
|
|
|
return NOERROR;
|
|
} // ResetStreamingTimes
|
|
|
|
|
|
// Reset all times controlling streaming. Note that we're now streaming. We
|
|
// don't need to set the rendering event to have the source filter released
|
|
// as it is done during the Run processing. When we are run we immediately
|
|
// release the source filter thread and draw any image waiting (that image
|
|
// may already have been drawn once as a poster frame while we were paused)
|
|
|
|
HRESULT CBaseVideoRenderer::OnStartStreaming()
|
|
{
|
|
ResetStreamingTimes();
|
|
return NOERROR;
|
|
} // OnStartStreaming
|
|
|
|
|
|
// Called at end of streaming. Fixes times for property page report
|
|
|
|
HRESULT CBaseVideoRenderer::OnStopStreaming()
|
|
{
|
|
m_tStreamingStart = timeGetTime()-m_tStreamingStart;
|
|
return NOERROR;
|
|
} // OnStopStreaming
|
|
|
|
|
|
// Called when we start waiting for a rendering event.
|
|
// Used to update times spent waiting and not waiting.
|
|
|
|
void CBaseVideoRenderer::OnWaitStart()
|
|
{
|
|
MSR_START(m_idWaitReal);
|
|
} // OnWaitStart
|
|
|
|
|
|
// Called when we are awoken from the wait in the window OR by our allocator
|
|
// when it is hanging around until the next sample is due for rendering on a
|
|
// DCI/DirectDraw surface. We add the wait time into our rolling average.
|
|
// We grab the interface lock so that we're serialised with the application
|
|
// thread going through the run code - which in due course ends up calling
|
|
// ResetStreaming times - possibly as we run through this section of code
|
|
|
|
void CBaseVideoRenderer::OnWaitEnd()
|
|
{
|
|
#ifdef PERF
|
|
MSR_STOP(m_idWaitReal);
|
|
// for a perf build we want to know just exactly how late we REALLY are.
|
|
// even if this means that we have to look at the clock again.
|
|
|
|
REFERENCE_TIME trRealStream; // the real time now expressed as stream time.
|
|
#if 0
|
|
m_pClock->GetTime(&trRealStream); // Calling clock here causes W95 deadlock!
|
|
#else
|
|
// We will be discarding overflows like mad here!
|
|
// This is wrong really because timeGetTime() can wrap but it's
|
|
// only for PERF
|
|
REFERENCE_TIME tr = timeGetTime()*10000;
|
|
trRealStream = tr + m_llTimeOffset;
|
|
#endif
|
|
trRealStream -= m_tStart; // convert to stream time (this is a reftime)
|
|
|
|
if (m_trRememberStampForPerf==0) {
|
|
// This is probably the poster frame at the start, and it is not scheduled
|
|
// in the usual way at all. Just count it. The rememberstamp gets set
|
|
// in ShouldDrawSampleNow, so this does invalid frame recording until we
|
|
// actually start playing.
|
|
PreparePerformanceData(0, 0);
|
|
} else {
|
|
int trLate = (int)(trRealStream - m_trRememberStampForPerf);
|
|
int trFrame = (int)(tr - m_trRememberFrameForPerf);
|
|
PreparePerformanceData(trLate, trFrame);
|
|
}
|
|
m_trRememberFrameForPerf = tr;
|
|
#endif //PERF
|
|
} // OnWaitEnd
|
|
|
|
|
|
// Put data on one side that describes the lateness of the current frame.
|
|
// We don't yet know whether it will actually be drawn. In direct draw mode,
|
|
// this decision is up to the filter upstream, and it could change its mind.
|
|
// The rules say that if it did draw it must call Receive(). One way or
|
|
// another we eventually get into either OnRenderStart or OnDirectRender and
|
|
// these both call RecordFrameLateness to update the statistics.
|
|
|
|
void CBaseVideoRenderer::PreparePerformanceData(int trLate, int trFrame)
|
|
{
|
|
m_trLate = trLate;
|
|
m_trFrame = trFrame;
|
|
} // PreparePerformanceData
|
|
|
|
|
|
// update the statistics:
|
|
// m_iTotAcc, m_iSumSqAcc, m_iSumSqFrameTime, m_iSumFrameTime, m_cFramesDrawn
|
|
// Note that because the properties page reports using these variables,
|
|
// 1. We need to be inside a critical section
|
|
// 2. They must all be updated together. Updating the sums here and the count
|
|
// elsewhere can result in imaginary jitter (i.e. attempts to find square roots
|
|
// of negative numbers) in the property page code.
|
|
|
|
void CBaseVideoRenderer::RecordFrameLateness(int trLate, int trFrame)
|
|
{
|
|
// Record how timely we are.
|
|
int tLate = trLate/10000;
|
|
|
|
// Best estimate of moment of appearing on the screen is average of
|
|
// start and end draw times. Here we have only the end time. This may
|
|
// tend to show us as spuriously late by up to 1/2 frame rate achieved.
|
|
// Decoder probably monitors draw time. We don't bother.
|
|
MSR_INTEGER( m_idFrameAccuracy, tLate );
|
|
|
|
// This is a kludge - we can get frames that are very late
|
|
// especially (at start-up) and they invalidate the statistics.
|
|
// So ignore things that are more than 1 sec off.
|
|
if (tLate>1000 || tLate<-1000) {
|
|
if (m_cFramesDrawn<=1) {
|
|
tLate = 0;
|
|
} else if (tLate>0) {
|
|
tLate = 1000;
|
|
} else {
|
|
tLate = -1000;
|
|
}
|
|
}
|
|
// The very first frame often has a invalid time, so don't
|
|
// count it into the statistics. (???)
|
|
if (m_cFramesDrawn>1) {
|
|
m_iTotAcc += tLate;
|
|
m_iSumSqAcc += (tLate*tLate);
|
|
}
|
|
|
|
// calculate inter-frame time. Doesn't make sense for first frame
|
|
// second frame suffers from invalid first frame stamp.
|
|
if (m_cFramesDrawn>2) {
|
|
int tFrame = trFrame/10000; // convert to mSec else it overflows
|
|
|
|
// This is a kludge. It can overflow anyway (a pause can cause
|
|
// a very long inter-frame time) and it overflows at 2**31/10**7
|
|
// or about 215 seconds i.e. 3min 35sec
|
|
if (tFrame>1000||tFrame<0) tFrame = 1000;
|
|
m_iSumSqFrameTime += tFrame*tFrame;
|
|
ASSERT(m_iSumSqFrameTime>=0);
|
|
m_iSumFrameTime += tFrame;
|
|
}
|
|
++m_cFramesDrawn;
|
|
|
|
} // RecordFrameLateness
|
|
|
|
|
|
void CBaseVideoRenderer::ThrottleWait()
|
|
{
|
|
if (m_trThrottle>0) {
|
|
int iThrottle = m_trThrottle/10000; // convert to mSec
|
|
MSR_INTEGER( m_idThrottle, iThrottle);
|
|
DbgLog((LOG_TRACE, 0, TEXT("Throttle %d ms"), iThrottle));
|
|
Sleep(iThrottle);
|
|
} else {
|
|
Sleep(0);
|
|
}
|
|
} // ThrottleWait
|
|
|
|
|
|
// Whenever a frame is rendered it goes though either OnRenderStart
|
|
// or OnDirectRender. Data that are generated during ShouldDrawSample
|
|
// are added to the statistics by calling RecordFrameLateness from both
|
|
// these two places.
|
|
|
|
// Called in place of OnRenderStart..OnRenderEnd
|
|
// When a DirectDraw image is drawn
|
|
void CBaseVideoRenderer::OnDirectRender(IMediaSample *pMediaSample)
|
|
{
|
|
m_trRenderAvg = 0;
|
|
m_trRenderLast = 5000000; // If we mode switch, we do NOT want this
|
|
// to inhibit the new average getting going!
|
|
// so we set it to half a second
|
|
// MSR_INTEGER(m_idRenderAvg, m_trRenderAvg/10000);
|
|
RecordFrameLateness(m_trLate, m_trFrame);
|
|
ThrottleWait();
|
|
} // OnDirectRender
|
|
|
|
|
|
// Called just before we start drawing. All we do is to get the current clock
|
|
// time (from the system) and return. We have to store the start render time
|
|
// in a member variable because it isn't used until we complete the drawing
|
|
// The rest is just performance logging.
|
|
|
|
void CBaseVideoRenderer::OnRenderStart(IMediaSample *pMediaSample)
|
|
{
|
|
RecordFrameLateness(m_trLate, m_trFrame);
|
|
m_tRenderStart = timeGetTime();
|
|
} // OnRenderStart
|
|
|
|
|
|
// Called directly after drawing an image. We calculate the time spent in the
|
|
// drawing code and if this doesn't appear to have any odd looking spikes in
|
|
// it then we add it to the current average draw time. Measurement spikes may
|
|
// occur if the drawing thread is interrupted and switched to somewhere else.
|
|
|
|
void CBaseVideoRenderer::OnRenderEnd(IMediaSample *pMediaSample)
|
|
{
|
|
// The renderer time can vary erratically if we are interrupted so we do
|
|
// some smoothing to help get more sensible figures out but even that is
|
|
// not enough as figures can go 9,10,9,9,83,9 and we must disregard 83
|
|
|
|
int tr = (timeGetTime() - m_tRenderStart)*10000; // convert mSec->UNITS
|
|
if (tr < m_trRenderAvg*2 || tr < 2 * m_trRenderLast) {
|
|
// DO_MOVING_AVG(m_trRenderAvg, tr);
|
|
m_trRenderAvg = (tr + (AVGPERIOD-1)*m_trRenderAvg)/AVGPERIOD;
|
|
}
|
|
m_trRenderLast = tr;
|
|
ThrottleWait();
|
|
} // OnRenderEnd
|
|
|
|
|
|
STDMETHODIMP CBaseVideoRenderer::SetSink( IQualityControl * piqc)
|
|
{
|
|
|
|
m_pQSink = piqc;
|
|
|
|
return NOERROR;
|
|
} // SetSink
|
|
|
|
|
|
STDMETHODIMP CBaseVideoRenderer::Notify( IBaseFilter * pSelf, Quality q)
|
|
{
|
|
// NOTE: We are NOT getting any locks here. We could be called
|
|
// asynchronously and possibly even on a time critical thread of
|
|
// someone else's - so we do the minumum. We only set one state
|
|
// variable (an integer) and if that happens to be in the middle
|
|
// of another thread reading it they will just get either the new
|
|
// or the old value. Locking would achieve no more than this.
|
|
|
|
// It might be nice to check that we are being called from m_pGraph, but
|
|
// it turns out to be a millisecond or so per throw!
|
|
|
|
// This is heuristics, these numbers are aimed at being "what works"
|
|
// rather than anything based on some theory.
|
|
// We use a hyperbola because it's easy to calculate and it includes
|
|
// a panic button asymptote (which we push off just to the left)
|
|
// The throttling fits the following table (roughly)
|
|
// Proportion Throttle (msec)
|
|
// >=1000 0
|
|
// 900 3
|
|
// 800 7
|
|
// 700 11
|
|
// 600 17
|
|
// 500 25
|
|
// 400 35
|
|
// 300 50
|
|
// 200 72
|
|
// 125 100
|
|
// 100 112
|
|
// 50 146
|
|
// 0 200
|
|
|
|
// (some evidence that we could go for a sharper kink - e.g. no throttling
|
|
// until below the 750 mark - might give fractionally more frames on a
|
|
// P60-ish machine). The easy way to get these coefficients is to use
|
|
// Renbase.xls follow the instructions therein using excel solver.
|
|
|
|
if (q.Proportion>=1000) { m_trThrottle = 0; }
|
|
else {
|
|
// The DWORD is to make quite sure I get unsigned arithmetic
|
|
// as the constant is between 2**31 and 2**32
|
|
m_trThrottle = -330000 + (388880000/(q.Proportion+167));
|
|
}
|
|
return NOERROR;
|
|
} // Notify
|
|
|
|
|
|
// Send a message to indicate what our supplier should do about quality.
|
|
// Theory:
|
|
// What a supplier wants to know is "is the frame I'm working on NOW
|
|
// going to be late?".
|
|
// F1 is the frame at the supplier (as above)
|
|
// Tf1 is the due time for F1
|
|
// T1 is the time at that point (NOW!)
|
|
// Tr1 is the time that f1 WILL actually be rendered
|
|
// L1 is the latency of the graph for frame F1 = Tr1-T1
|
|
// D1 (for delay) is how late F1 will be beyond its due time i.e.
|
|
// D1 = (Tr1-Tf1) which is what the supplier really wants to know.
|
|
// Unfortunately Tr1 is in the future and is unknown, so is L1
|
|
//
|
|
// We could estimate L1 by its value for a previous frame,
|
|
// L0 = Tr0-T0 and work off
|
|
// D1' = ((T1+L0)-Tf1) = (T1 + (Tr0-T0) -Tf1)
|
|
// Rearranging terms:
|
|
// D1' = (T1-T0) + (Tr0-Tf1)
|
|
// adding (Tf0-Tf0) and rearranging again:
|
|
// = (T1-T0) + (Tr0-Tf0) + (Tf0-Tf1)
|
|
// = (T1-T0) - (Tf1-Tf0) + (Tr0-Tf0)
|
|
// But (Tr0-Tf0) is just D0 - how late frame zero was, and this is the
|
|
// Late field in the quality message that we send.
|
|
// The other two terms just state what correction should be applied before
|
|
// using the lateness of F0 to predict the lateness of F1.
|
|
// (T1-T0) says how much time has actually passed (we have lost this much)
|
|
// (Tf1-Tf0) says how much time should have passed if we were keeping pace
|
|
// (we have gained this much).
|
|
//
|
|
// Suppliers should therefore work off:
|
|
// Quality.Late + (T1-T0) - (Tf1-Tf0)
|
|
// and see if this is "acceptably late" or even early (i.e. negative).
|
|
// They get T1 and T0 by polling the clock, they get Tf1 and Tf0 from
|
|
// the time stamps in the frames. They get Quality.Late from us.
|
|
//
|
|
|
|
HRESULT CBaseVideoRenderer::SendQuality(REFERENCE_TIME trLate,
|
|
REFERENCE_TIME trRealStream)
|
|
{
|
|
Quality q;
|
|
HRESULT hr;
|
|
|
|
// If we are the main user of time, then report this as Flood/Dry.
|
|
// If our suppliers are, then report it as Famine/Glut.
|
|
//
|
|
// We need to take action, but avoid hunting. Hunting is caused by
|
|
// 1. Taking too much action too soon and overshooting
|
|
// 2. Taking too long to react (so averaging can CAUSE hunting).
|
|
//
|
|
// The reason why we use trLate as well as Wait is to reduce hunting;
|
|
// if the wait time is coming down and about to go into the red, we do
|
|
// NOT want to rely on some average which is only telling is that it used
|
|
// to be OK once.
|
|
|
|
q.TimeStamp = (REFERENCE_TIME)trRealStream;
|
|
|
|
if (m_trFrameAvg<0) {
|
|
q.Type = Famine; // guess
|
|
}
|
|
// Is the greater part of the time taken bltting or something else
|
|
else if (m_trFrameAvg > 2*m_trRenderAvg) {
|
|
q.Type = Famine; // mainly other
|
|
} else {
|
|
q.Type = Flood; // mainly bltting
|
|
}
|
|
|
|
q.Proportion = 1000; // default
|
|
|
|
if (m_trFrameAvg<0) {
|
|
// leave it alone - we don't know enough
|
|
}
|
|
else if ( trLate> 0 ) {
|
|
// try to catch up over the next second
|
|
// We could be Really, REALLY late, but rendering all the frames
|
|
// anyway, just because it's so cheap.
|
|
|
|
q.Proportion = 1000 - (int)((trLate)/(UNITS/1000));
|
|
if (q.Proportion<500) {
|
|
q.Proportion = 500; // don't go daft. (could've been negative!)
|
|
} else {
|
|
}
|
|
|
|
} else if ( m_trWaitAvg>20000
|
|
&& trLate<-20000
|
|
){
|
|
// Go cautiously faster - aim at 2mSec wait.
|
|
if (m_trWaitAvg>=m_trFrameAvg) {
|
|
// This can happen because of some fudges.
|
|
// The waitAvg is how long we originally planned to wait
|
|
// The frameAvg is more honest.
|
|
// It means that we are spending a LOT of time waiting
|
|
q.Proportion = 2000; // double.
|
|
} else {
|
|
if (m_trFrameAvg+20000 > m_trWaitAvg) {
|
|
q.Proportion
|
|
= 1000 * (m_trFrameAvg / (m_trFrameAvg + 20000 - m_trWaitAvg));
|
|
} else {
|
|
// We're apparently spending more than the whole frame time waiting.
|
|
// Assume that the averages are slightly out of kilter, but that we
|
|
// are indeed doing a lot of waiting. (This leg probably never
|
|
// happens, but the code avoids any potential divide by zero).
|
|
q.Proportion = 2000;
|
|
}
|
|
}
|
|
|
|
if (q.Proportion>2000) {
|
|
q.Proportion = 2000; // don't go crazy.
|
|
}
|
|
}
|
|
|
|
// Tell the supplier how late frames are when they get rendered
|
|
// That's how late we are now.
|
|
// If we are in directdraw mode then the guy upstream can see the drawing
|
|
// times and we'll just report on the start time. He can figure out any
|
|
// offset to apply. If we are in DIB Section mode then we will apply an
|
|
// extra offset which is half of our drawing time. This is usually small
|
|
// but can sometimes be the dominant effect. For this we will use the
|
|
// average drawing time rather than the last frame. If the last frame took
|
|
// a long time to draw and made us late, that's already in the lateness
|
|
// figure. We should not add it in again unless we expect the next frame
|
|
// to be the same. We don't, we expect the average to be a better shot.
|
|
// In direct draw mode the RenderAvg will be zero.
|
|
|
|
q.Late = trLate + m_trRenderAvg/2;
|
|
|
|
// log what we're doing
|
|
MSR_INTEGER(m_idQualityRate, q.Proportion);
|
|
MSR_INTEGER( m_idQualityTime, (int)q.Late / 10000 );
|
|
|
|
// A specific sink interface may be set through IPin
|
|
|
|
if (m_pQSink==NULL) {
|
|
// Get our input pin's peer. We send quality management messages
|
|
// to any nominated receiver of these things (set in the IPin
|
|
// interface), or else to our source filter.
|
|
|
|
IQualityControl *pQC = NULL;
|
|
IPin *pOutputPin = m_pInputPin->GetConnected();
|
|
ASSERT(pOutputPin != NULL);
|
|
|
|
// And get an AddRef'd quality control interface
|
|
|
|
hr = pOutputPin->QueryInterface(IID_IQualityControl,(void**) &pQC);
|
|
if (SUCCEEDED(hr)) {
|
|
m_pQSink = pQC;
|
|
}
|
|
}
|
|
if (m_pQSink) {
|
|
return m_pQSink->Notify(this,q);
|
|
}
|
|
|
|
return S_FALSE;
|
|
|
|
} // SendQuality
|
|
|
|
|
|
// We are called with a valid IMediaSample image to decide whether this is to
|
|
// be drawn or not. There must be a reference clock in operation.
|
|
// Return S_OK if it is to be drawn Now (as soon as possible)
|
|
// Return S_FALSE if it is to be drawn when it's due
|
|
// Return an error if we want to drop it
|
|
// m_nNormal=-1 indicates that we dropped the previous frame and so this
|
|
// one should be drawn early. Respect it and update it.
|
|
// Use current stream time plus a number of heuristics (detailed below)
|
|
// to make the decision
|
|
|
|
HRESULT CBaseVideoRenderer::ShouldDrawSampleNow(IMediaSample *pMediaSample,
|
|
__inout REFERENCE_TIME *ptrStart,
|
|
__inout REFERENCE_TIME *ptrEnd)
|
|
{
|
|
|
|
// Don't call us unless there's a clock interface to synchronise with
|
|
ASSERT(m_pClock);
|
|
|
|
MSR_INTEGER(m_idTimeStamp, (int)((*ptrStart)>>32)); // high order 32 bits
|
|
MSR_INTEGER(m_idTimeStamp, (int)(*ptrStart)); // low order 32 bits
|
|
|
|
// We lose a bit of time depending on the monitor type waiting for the next
|
|
// screen refresh. On average this might be about 8mSec - so it will be
|
|
// later than we think when the picture appears. To compensate a bit
|
|
// we bias the media samples by -8mSec i.e. 80000 UNITs.
|
|
// We don't ever make a stream time negative (call it paranoia)
|
|
if (*ptrStart>=80000) {
|
|
*ptrStart -= 80000;
|
|
*ptrEnd -= 80000; // bias stop to to retain valid frame duration
|
|
}
|
|
|
|
// Cache the time stamp now. We will want to compare what we did with what
|
|
// we started with (after making the monitor allowance).
|
|
m_trRememberStampForPerf = *ptrStart;
|
|
|
|
// Get reference times (current and late)
|
|
REFERENCE_TIME trRealStream; // the real time now expressed as stream time.
|
|
m_pClock->GetTime(&trRealStream);
|
|
#ifdef PERF
|
|
// While the reference clock is expensive:
|
|
// Remember the offset from timeGetTime and use that.
|
|
// This overflows all over the place, but when we subtract to get
|
|
// differences the overflows all cancel out.
|
|
m_llTimeOffset = trRealStream-timeGetTime()*10000;
|
|
#endif
|
|
trRealStream -= m_tStart; // convert to stream time (this is a reftime)
|
|
|
|
// We have to wory about two versions of "lateness". The truth, which we
|
|
// try to work out here and the one measured against m_trTarget which
|
|
// includes long term feedback. We report statistics against the truth
|
|
// but for operational decisions we work to the target.
|
|
// We use TimeDiff to make sure we get an integer because we
|
|
// may actually be late (or more likely early if there is a big time
|
|
// gap) by a very long time.
|
|
const int trTrueLate = TimeDiff(trRealStream - *ptrStart);
|
|
const int trLate = trTrueLate;
|
|
|
|
MSR_INTEGER(m_idSchLateTime, trTrueLate/10000);
|
|
|
|
// Send quality control messages upstream, measured against target
|
|
HRESULT hr = SendQuality(trLate, trRealStream);
|
|
// Note: the filter upstream is allowed to this FAIL meaning "you do it".
|
|
m_bSupplierHandlingQuality = (hr==S_OK);
|
|
|
|
// Decision time! Do we drop, draw when ready or draw immediately?
|
|
|
|
const int trDuration = (int)(*ptrEnd - *ptrStart);
|
|
{
|
|
// We need to see if the frame rate of the file has just changed.
|
|
// This would make comparing our previous frame rate with the current
|
|
// frame rate inefficent. Hang on a moment though. I've seen files
|
|
// where the frames vary between 33 and 34 mSec so as to average
|
|
// 30fps. A minor variation like that won't hurt us.
|
|
int t = m_trDuration/32;
|
|
if ( trDuration > m_trDuration+t
|
|
|| trDuration < m_trDuration-t
|
|
) {
|
|
// There's a major variation. Reset the average frame rate to
|
|
// exactly the current rate to disable decision 9002 for this frame,
|
|
// and remember the new rate.
|
|
m_trFrameAvg = trDuration;
|
|
m_trDuration = trDuration;
|
|
}
|
|
}
|
|
|
|
MSR_INTEGER(m_idEarliness, m_trEarliness/10000);
|
|
MSR_INTEGER(m_idRenderAvg, m_trRenderAvg/10000);
|
|
MSR_INTEGER(m_idFrameAvg, m_trFrameAvg/10000);
|
|
MSR_INTEGER(m_idWaitAvg, m_trWaitAvg/10000);
|
|
MSR_INTEGER(m_idDuration, trDuration/10000);
|
|
|
|
#ifdef PERF
|
|
if (S_OK==pMediaSample->IsDiscontinuity()) {
|
|
MSR_INTEGER(m_idDecision, 9000);
|
|
}
|
|
#endif
|
|
|
|
// Control the graceful slide back from slow to fast machine mode.
|
|
// After a frame drop accept an early frame and set the earliness to here
|
|
// If this frame is already later than the earliness then slide it to here
|
|
// otherwise do the standard slide (reduce by about 12% per frame).
|
|
// Note: earliness is normally NEGATIVE
|
|
BOOL bJustDroppedFrame
|
|
= ( m_bSupplierHandlingQuality
|
|
// Can't use the pin sample properties because we might
|
|
// not be in Receive when we call this
|
|
&& (S_OK == pMediaSample->IsDiscontinuity()) // he just dropped one
|
|
)
|
|
|| (m_nNormal==-1); // we just dropped one
|
|
|
|
|
|
// Set m_trEarliness (slide back from slow to fast machine mode)
|
|
if (trLate>0) {
|
|
m_trEarliness = 0; // we are no longer in fast machine mode at all!
|
|
} else if ( (trLate>=m_trEarliness) || bJustDroppedFrame) {
|
|
m_trEarliness = trLate; // Things have slipped of their own accord
|
|
} else {
|
|
m_trEarliness = m_trEarliness - m_trEarliness/8; // graceful slide
|
|
}
|
|
|
|
// prepare the new wait average - but don't pollute the old one until
|
|
// we have finished with it.
|
|
int trWaitAvg;
|
|
{
|
|
// We never mix in a negative wait. This causes us to believe in fast machines
|
|
// slightly more.
|
|
int trL = trLate<0 ? -trLate : 0;
|
|
trWaitAvg = (trL + m_trWaitAvg*(AVGPERIOD-1))/AVGPERIOD;
|
|
}
|
|
|
|
|
|
int trFrame;
|
|
{
|
|
REFERENCE_TIME tr = trRealStream - m_trLastDraw; // Cd be large - 4 min pause!
|
|
if (tr>10000000) {
|
|
tr = 10000000; // 1 second - arbitrarily.
|
|
}
|
|
trFrame = int(tr);
|
|
}
|
|
|
|
// We will DRAW this frame IF...
|
|
if (
|
|
// ...the time we are spending drawing is a small fraction of the total
|
|
// observed inter-frame time so that dropping it won't help much.
|
|
(3*m_trRenderAvg <= m_trFrameAvg)
|
|
|
|
// ...or our supplier is NOT handling things and the next frame would
|
|
// be less timely than this one or our supplier CLAIMS to be handling
|
|
// things, and is now less than a full FOUR frames late.
|
|
|| ( m_bSupplierHandlingQuality
|
|
? (trLate <= trDuration*4)
|
|
: (trLate+trLate < trDuration)
|
|
)
|
|
|
|
// ...or we are on average waiting for over eight milliseconds then
|
|
// this may be just a glitch. Draw it and we'll hope to catch up.
|
|
|| (m_trWaitAvg > 80000)
|
|
|
|
// ...or we haven't drawn an image for over a second. We will update
|
|
// the display, which stops the video looking hung.
|
|
// Do this regardless of how late this media sample is.
|
|
|| ((trRealStream - m_trLastDraw) > UNITS)
|
|
|
|
) {
|
|
HRESULT Result;
|
|
|
|
// We are going to play this frame. We may want to play it early.
|
|
// We will play it early if we think we are in slow machine mode.
|
|
// If we think we are NOT in slow machine mode, we will still play
|
|
// it early by m_trEarliness as this controls the graceful slide back.
|
|
// and in addition we aim at being m_trTarget late rather than "on time".
|
|
|
|
BOOL bPlayASAP = FALSE;
|
|
|
|
// we will play it AT ONCE (slow machine mode) if...
|
|
|
|
// ...we are playing catch-up
|
|
if ( bJustDroppedFrame) {
|
|
bPlayASAP = TRUE;
|
|
MSR_INTEGER(m_idDecision, 9001);
|
|
}
|
|
|
|
// ...or if we are running below the true frame rate
|
|
// exact comparisons are glitchy, for these measurements,
|
|
// so add an extra 5% or so
|
|
else if ( (m_trFrameAvg > trDuration + trDuration/16)
|
|
|
|
// It's possible to get into a state where we are losing ground, but
|
|
// are a very long way ahead. To avoid this or recover from it
|
|
// we refuse to play early by more than 10 frames.
|
|
&& (trLate > - trDuration*10)
|
|
){
|
|
bPlayASAP = TRUE;
|
|
MSR_INTEGER(m_idDecision, 9002);
|
|
}
|
|
#if 0
|
|
// ...or if we have been late and are less than one frame early
|
|
else if ( (trLate + trDuration > 0)
|
|
&& (m_trWaitAvg<=20000)
|
|
) {
|
|
bPlayASAP = TRUE;
|
|
MSR_INTEGER(m_idDecision, 9003);
|
|
}
|
|
#endif
|
|
// We will NOT play it at once if we are grossly early. On very slow frame
|
|
// rate movies - e.g. clock.avi - it is not a good idea to leap ahead just
|
|
// because we got starved (for instance by the net) and dropped one frame
|
|
// some time or other. If we are more than 900mSec early, then wait.
|
|
if (trLate<-9000000) {
|
|
bPlayASAP = FALSE;
|
|
}
|
|
|
|
if (bPlayASAP) {
|
|
|
|
m_nNormal = 0;
|
|
MSR_INTEGER(m_idDecision, 0);
|
|
// When we are here, we are in slow-machine mode. trLate may well
|
|
// oscillate between negative and positive when the supplier is
|
|
// dropping frames to keep sync. We should not let that mislead
|
|
// us into thinking that we have as much as zero spare time!
|
|
// We just update with a zero wait.
|
|
m_trWaitAvg = (m_trWaitAvg*(AVGPERIOD-1))/AVGPERIOD;
|
|
|
|
// Assume that we draw it immediately. Update inter-frame stats
|
|
m_trFrameAvg = (trFrame + m_trFrameAvg*(AVGPERIOD-1))/AVGPERIOD;
|
|
#ifndef PERF
|
|
// If this is NOT a perf build, then report what we know so far
|
|
// without looking at the clock any more. This assumes that we
|
|
// actually wait for exactly the time we hope to. It also reports
|
|
// how close we get to the manipulated time stamps that we now have
|
|
// rather than the ones we originally started with. It will
|
|
// therefore be a little optimistic. However it's fast.
|
|
PreparePerformanceData(trTrueLate, trFrame);
|
|
#endif
|
|
m_trLastDraw = trRealStream;
|
|
if (m_trEarliness > trLate) {
|
|
m_trEarliness = trLate; // if we are actually early, this is neg
|
|
}
|
|
Result = S_OK; // Draw it now
|
|
|
|
} else {
|
|
++m_nNormal;
|
|
// Set the average frame rate to EXACTLY the ideal rate.
|
|
// If we are exiting slow-machine mode then we will have caught up
|
|
// and be running ahead, so as we slide back to exact timing we will
|
|
// have a longer than usual gap at this point. If we record this
|
|
// real gap then we'll think that we're running slow and go back
|
|
// into slow-machine mode and vever get it straight.
|
|
m_trFrameAvg = trDuration;
|
|
MSR_INTEGER(m_idDecision, 1);
|
|
|
|
// Play it early by m_trEarliness and by m_trTarget
|
|
|
|
{
|
|
int trE = m_trEarliness;
|
|
if (trE < -m_trFrameAvg) {
|
|
trE = -m_trFrameAvg;
|
|
}
|
|
*ptrStart += trE; // N.B. earliness is negative
|
|
}
|
|
|
|
int Delay = -trTrueLate;
|
|
Result = Delay<=0 ? S_OK : S_FALSE; // OK = draw now, FALSE = wait
|
|
|
|
m_trWaitAvg = trWaitAvg;
|
|
|
|
// Predict when it will actually be drawn and update frame stats
|
|
|
|
if (Result==S_FALSE) { // We are going to wait
|
|
trFrame = TimeDiff(*ptrStart-m_trLastDraw);
|
|
m_trLastDraw = *ptrStart;
|
|
} else {
|
|
// trFrame is already = trRealStream-m_trLastDraw;
|
|
m_trLastDraw = trRealStream;
|
|
}
|
|
#ifndef PERF
|
|
int iAccuracy;
|
|
if (Delay>0) {
|
|
// Report lateness based on when we intend to play it
|
|
iAccuracy = TimeDiff(*ptrStart-m_trRememberStampForPerf);
|
|
} else {
|
|
// Report lateness based on playing it *now*.
|
|
iAccuracy = trTrueLate; // trRealStream-RememberStampForPerf;
|
|
}
|
|
PreparePerformanceData(iAccuracy, trFrame);
|
|
#endif
|
|
}
|
|
return Result;
|
|
}
|
|
|
|
// We are going to drop this frame!
|
|
// Of course in DirectDraw mode the guy upstream may draw it anyway.
|
|
|
|
// This will probably give a large negative wack to the wait avg.
|
|
m_trWaitAvg = trWaitAvg;
|
|
|
|
#ifdef PERF
|
|
// Respect registry setting - debug only!
|
|
if (m_bDrawLateFrames) {
|
|
return S_OK; // draw it when it's ready
|
|
} // even though it's late.
|
|
#endif
|
|
|
|
// We are going to drop this frame so draw the next one early
|
|
// n.b. if the supplier is doing direct draw then he may draw it anyway
|
|
// but he's doing something funny to arrive here in that case.
|
|
|
|
MSR_INTEGER(m_idDecision, 2);
|
|
m_nNormal = -1;
|
|
return E_FAIL; // drop it
|
|
|
|
} // ShouldDrawSampleNow
|
|
|
|
|
|
// NOTE we're called by both the window thread and the source filter thread
|
|
// so we have to be protected by a critical section (locked before called)
|
|
// Also, when the window thread gets signalled to render an image, it always
|
|
// does so regardless of how late it is. All the degradation is done when we
|
|
// are scheduling the next sample to be drawn. Hence when we start an advise
|
|
// link to draw a sample, that sample's time will always become the last one
|
|
// drawn - unless of course we stop streaming in which case we cancel links
|
|
|
|
BOOL CBaseVideoRenderer::ScheduleSample(IMediaSample *pMediaSample)
|
|
{
|
|
// We override ShouldDrawSampleNow to add quality management
|
|
|
|
BOOL bDrawImage = CBaseRenderer::ScheduleSample(pMediaSample);
|
|
if (bDrawImage == FALSE) {
|
|
++m_cFramesDropped;
|
|
return FALSE;
|
|
}
|
|
|
|
// m_cFramesDrawn must NOT be updated here. It has to be updated
|
|
// in RecordFrameLateness at the same time as the other statistics.
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// Implementation of IQualProp interface needed to support the property page
|
|
// This is how the property page gets the data out of the scheduler. We are
|
|
// passed into the constructor the owning object in the COM sense, this will
|
|
// either be the video renderer or an external IUnknown if we're aggregated.
|
|
// We initialise our CUnknown base class with this interface pointer. Then
|
|
// all we have to do is to override NonDelegatingQueryInterface to expose
|
|
// our IQualProp interface. The AddRef and Release are handled automatically
|
|
// by the base class and will be passed on to the appropriate outer object
|
|
|
|
STDMETHODIMP CBaseVideoRenderer::get_FramesDroppedInRenderer(__out int *pcFramesDropped)
|
|
{
|
|
CheckPointer(pcFramesDropped,E_POINTER);
|
|
CAutoLock cVideoLock(&m_InterfaceLock);
|
|
*pcFramesDropped = m_cFramesDropped;
|
|
return NOERROR;
|
|
} // get_FramesDroppedInRenderer
|
|
|
|
|
|
// Set *pcFramesDrawn to the number of frames drawn since
|
|
// streaming started.
|
|
|
|
STDMETHODIMP CBaseVideoRenderer::get_FramesDrawn( int *pcFramesDrawn)
|
|
{
|
|
CheckPointer(pcFramesDrawn,E_POINTER);
|
|
CAutoLock cVideoLock(&m_InterfaceLock);
|
|
*pcFramesDrawn = m_cFramesDrawn;
|
|
return NOERROR;
|
|
} // get_FramesDrawn
|
|
|
|
|
|
// Set iAvgFrameRate to the frames per hundred secs since
|
|
// streaming started. 0 otherwise.
|
|
|
|
STDMETHODIMP CBaseVideoRenderer::get_AvgFrameRate( int *piAvgFrameRate)
|
|
{
|
|
CheckPointer(piAvgFrameRate,E_POINTER);
|
|
CAutoLock cVideoLock(&m_InterfaceLock);
|
|
|
|
int t;
|
|
if (m_bStreaming) {
|
|
t = timeGetTime()-m_tStreamingStart;
|
|
} else {
|
|
t = m_tStreamingStart;
|
|
}
|
|
|
|
if (t<=0) {
|
|
*piAvgFrameRate = 0;
|
|
ASSERT(m_cFramesDrawn == 0);
|
|
} else {
|
|
// i is frames per hundred seconds
|
|
*piAvgFrameRate = MulDiv(100000, m_cFramesDrawn, t);
|
|
}
|
|
return NOERROR;
|
|
} // get_AvgFrameRate
|
|
|
|
|
|
// Set *piAvg to the average sync offset since streaming started
|
|
// in mSec. The sync offset is the time in mSec between when the frame
|
|
// should have been drawn and when the frame was actually drawn.
|
|
|
|
STDMETHODIMP CBaseVideoRenderer::get_AvgSyncOffset(__out int *piAvg)
|
|
{
|
|
CheckPointer(piAvg,E_POINTER);
|
|
CAutoLock cVideoLock(&m_InterfaceLock);
|
|
|
|
if (NULL==m_pClock) {
|
|
*piAvg = 0;
|
|
return NOERROR;
|
|
}
|
|
|
|
// Note that we didn't gather the stats on the first frame
|
|
// so we use m_cFramesDrawn-1 here
|
|
if (m_cFramesDrawn<=1) {
|
|
*piAvg = 0;
|
|
} else {
|
|
*piAvg = (int)(m_iTotAcc / (m_cFramesDrawn-1));
|
|
}
|
|
return NOERROR;
|
|
} // get_AvgSyncOffset
|
|
|
|
|
|
// To avoid dragging in the maths library - a cheap
|
|
// approximate integer square root.
|
|
// We do this by getting a starting guess which is between 1
|
|
// and 2 times too large, followed by THREE iterations of
|
|
// Newton Raphson. (That will give accuracy to the nearest mSec
|
|
// for the range in question - roughly 0..1000)
|
|
//
|
|
// It would be faster to use a linear interpolation and ONE NR, but
|
|
// who cares. If anyone does - the best linear interpolation is
|
|
// to approximates sqrt(x) by
|
|
// y = x * (sqrt(2)-1) + 1 - 1/sqrt(2) + 1/(8*(sqrt(2)-1))
|
|
// 0r y = x*0.41421 + 0.59467
|
|
// This minimises the maximal error in the range in question.
|
|
// (error is about +0.008883 and then one NR will give error .0000something
|
|
// (Of course these are integers, so you can't just multiply by 0.41421
|
|
// you'd have to do some sort of MulDiv).
|
|
// Anyone wanna check my maths? (This is only for a property display!)
|
|
|
|
int isqrt(int x)
|
|
{
|
|
int s = 1;
|
|
// Make s an initial guess for sqrt(x)
|
|
if (x > 0x40000000) {
|
|
s = 0x8000; // prevent any conceivable closed loop
|
|
} else {
|
|
while (s*s<x) { // loop cannot possible go more than 31 times
|
|
s = 2*s; // normally it goes about 6 times
|
|
}
|
|
// Three NR iterations.
|
|
if (x==0) {
|
|
s= 0; // Wouldn't it be tragic to divide by zero whenever our
|
|
// accuracy was perfect!
|
|
} else {
|
|
s = (s*s+x)/(2*s);
|
|
if (s>=0) s = (s*s+x)/(2*s);
|
|
if (s>=0) s = (s*s+x)/(2*s);
|
|
}
|
|
}
|
|
return s;
|
|
}
|
|
|
|
//
|
|
// Do estimates for standard deviations for per-frame
|
|
// statistics
|
|
//
|
|
HRESULT CBaseVideoRenderer::GetStdDev(
|
|
int nSamples,
|
|
__out int *piResult,
|
|
LONGLONG llSumSq,
|
|
LONGLONG iTot
|
|
)
|
|
{
|
|
CheckPointer(piResult,E_POINTER);
|
|
CAutoLock cVideoLock(&m_InterfaceLock);
|
|
|
|
if (NULL==m_pClock) {
|
|
*piResult = 0;
|
|
return NOERROR;
|
|
}
|
|
|
|
// If S is the Sum of the Squares of observations and
|
|
// T the Total (i.e. sum) of the observations and there were
|
|
// N observations, then an estimate of the standard deviation is
|
|
// sqrt( (S - T**2/N) / (N-1) )
|
|
|
|
if (nSamples<=1) {
|
|
*piResult = 0;
|
|
} else {
|
|
LONGLONG x;
|
|
// First frames have invalid stamps, so we get no stats for them
|
|
// So we need 2 frames to get 1 datum, so N is cFramesDrawn-1
|
|
|
|
// so we use m_cFramesDrawn-1 here
|
|
x = llSumSq - llMulDiv(iTot, iTot, nSamples, 0);
|
|
x = x / (nSamples-1);
|
|
ASSERT(x>=0);
|
|
*piResult = isqrt((LONG)x);
|
|
}
|
|
return NOERROR;
|
|
}
|
|
|
|
// Set *piDev to the standard deviation in mSec of the sync offset
|
|
// of each frame since streaming started.
|
|
|
|
STDMETHODIMP CBaseVideoRenderer::get_DevSyncOffset(__out int *piDev)
|
|
{
|
|
// First frames have invalid stamps, so we get no stats for them
|
|
// So we need 2 frames to get 1 datum, so N is cFramesDrawn-1
|
|
return GetStdDev(m_cFramesDrawn - 1,
|
|
piDev,
|
|
m_iSumSqAcc,
|
|
m_iTotAcc);
|
|
} // get_DevSyncOffset
|
|
|
|
|
|
// Set *piJitter to the standard deviation in mSec of the inter-frame time
|
|
// of frames since streaming started.
|
|
|
|
STDMETHODIMP CBaseVideoRenderer::get_Jitter(__out int *piJitter)
|
|
{
|
|
// First frames have invalid stamps, so we get no stats for them
|
|
// So second frame gives invalid inter-frame time
|
|
// So we need 3 frames to get 1 datum, so N is cFramesDrawn-2
|
|
return GetStdDev(m_cFramesDrawn - 2,
|
|
piJitter,
|
|
m_iSumSqFrameTime,
|
|
m_iSumFrameTime);
|
|
} // get_Jitter
|
|
|
|
|
|
// Overidden to return our IQualProp interface
|
|
|
|
STDMETHODIMP
|
|
CBaseVideoRenderer::NonDelegatingQueryInterface(REFIID riid,__deref_out VOID **ppv)
|
|
{
|
|
// We return IQualProp and delegate everything else
|
|
|
|
if (riid == IID_IQualProp) {
|
|
return GetInterface( (IQualProp *)this, ppv);
|
|
} else if (riid == IID_IQualityControl) {
|
|
return GetInterface( (IQualityControl *)this, ppv);
|
|
}
|
|
return CBaseRenderer::NonDelegatingQueryInterface(riid,ppv);
|
|
}
|
|
|
|
|
|
// Override JoinFilterGraph so that, just before leaving
|
|
// the graph we can send an EC_WINDOW_DESTROYED event
|
|
|
|
STDMETHODIMP
|
|
CBaseVideoRenderer::JoinFilterGraph(__inout_opt IFilterGraph *pGraph, __in_opt LPCWSTR pName)
|
|
{
|
|
// Since we send EC_ACTIVATE, we also need to ensure
|
|
// we send EC_WINDOW_DESTROYED or the resource manager may be
|
|
// holding us as a focus object
|
|
if (!pGraph && m_pGraph) {
|
|
|
|
// We were in a graph and now we're not
|
|
// Do this properly in case we are aggregated
|
|
IBaseFilter* pFilter = this;
|
|
NotifyEvent(EC_WINDOW_DESTROYED, (LPARAM) pFilter, 0);
|
|
}
|
|
return CBaseFilter::JoinFilterGraph(pGraph, pName);
|
|
}
|
|
|
|
|
|
// This removes a large number of level 4 warnings from the
|
|
// Microsoft compiler which in this case are not very useful
|
|
#pragma warning(disable: 4514)
|
|
|
|
#endif /* PJMEDIA_VIDEO_DEV_HAS_DSHOW */
|