//------------------------------------------------------------------------------
// File: StrmCtl.cpp
//
// Desc: DirectShow base classes.
//
// Copyright (c) 1996-2001 Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------
#include "streams.h"
#include "strmctl.h"
CBaseStreamControl::CBaseStreamControl(__inout HRESULT *phr)
: m_StreamState(STREAM_FLOWING)
, m_StreamStateOnStop(STREAM_FLOWING) // means no pending stop
, m_tStartTime(MAX_TIME)
, m_tStopTime(MAX_TIME)
, m_StreamEvent(FALSE, phr)
, m_dwStartCookie(0)
, m_dwStopCookie(0)
, m_pRefClock(NULL)
, m_FilterState(State_Stopped)
, m_bIsFlushing(FALSE)
, m_bStopSendExtra(FALSE)
{}
CBaseStreamControl::~CBaseStreamControl()
{
// Make sure we release the clock.
SetSyncSource(NULL);
return;
}
STDMETHODIMP CBaseStreamControl::StopAt(const REFERENCE_TIME * ptStop, BOOL bSendExtra, DWORD dwCookie)
{
CAutoLock lck(&m_CritSec);
m_bStopSendExtra = FALSE; // reset
m_bStopExtraSent = FALSE;
if (ptStop)
{
if (*ptStop == MAX_TIME)
{
DbgLog((LOG_TRACE,2,TEXT("StopAt: Cancel stop")));
CancelStop();
// If there's now a command to start in the future, we assume
// they want to be stopped when the graph is first run
if (m_FilterState == State_Stopped && m_tStartTime < MAX_TIME) {
m_StreamState = STREAM_DISCARDING;
DbgLog((LOG_TRACE,2,TEXT("graph will begin by DISCARDING")));
}
return NOERROR;
}
DbgLog((LOG_TRACE,2,TEXT("StopAt: %dms extra=%d"),
(int)(*ptStop/10000), bSendExtra));
// if the first command is to stop in the future, then we assume they
// want to be started when the graph is first run
if (m_FilterState == State_Stopped && m_tStartTime > *ptStop) {
m_StreamState = STREAM_FLOWING;
DbgLog((LOG_TRACE,2,TEXT("graph will begin by FLOWING")));
}
m_bStopSendExtra = bSendExtra;
m_tStopTime = *ptStop;
m_dwStopCookie = dwCookie;
m_StreamStateOnStop = STREAM_DISCARDING;
}
else
{
DbgLog((LOG_TRACE,2,TEXT("StopAt: now")));
// sending an extra frame when told to stop now would mess people up
m_bStopSendExtra = FALSE;
m_tStopTime = MAX_TIME;
m_dwStopCookie = 0;
m_StreamState = STREAM_DISCARDING;
m_StreamStateOnStop = STREAM_FLOWING; // no pending stop
}
// we might change our mind what to do with a sample we're blocking
m_StreamEvent.Set();
return NOERROR;
}
STDMETHODIMP CBaseStreamControl::StartAt
( const REFERENCE_TIME *ptStart, DWORD dwCookie )
{
CAutoLock lck(&m_CritSec);
if (ptStart)
{
if (*ptStart == MAX_TIME)
{
DbgLog((LOG_TRACE,2,TEXT("StartAt: Cancel start")));
CancelStart();
// If there's now a command to stop in the future, we assume
// they want to be started when the graph is first run
if (m_FilterState == State_Stopped && m_tStopTime < MAX_TIME) {
DbgLog((LOG_TRACE,2,TEXT("graph will begin by FLOWING")));
m_StreamState = STREAM_FLOWING;
}
return NOERROR;
}
DbgLog((LOG_TRACE,2,TEXT("StartAt: %dms"), (int)(*ptStart/10000)));
// if the first command is to start in the future, then we assume they
// want to be stopped when the graph is first run
if (m_FilterState == State_Stopped && m_tStopTime >= *ptStart) {
DbgLog((LOG_TRACE,2,TEXT("graph will begin by DISCARDING")));
m_StreamState = STREAM_DISCARDING;
}
m_tStartTime = *ptStart;
m_dwStartCookie = dwCookie;
// if (m_tStopTime == m_tStartTime) CancelStop();
}
else
{
DbgLog((LOG_TRACE,2,TEXT("StartAt: now")));
m_tStartTime = MAX_TIME;
m_dwStartCookie = 0;
m_StreamState = STREAM_FLOWING;
}
// we might change our mind what to do with a sample we're blocking
m_StreamEvent.Set();
return NOERROR;
}
// Retrieve information about current settings
STDMETHODIMP CBaseStreamControl::GetInfo(__out AM_STREAM_INFO *pInfo)
{
if (pInfo == NULL)
return E_POINTER;
pInfo->tStart = m_tStartTime;
pInfo->tStop = m_tStopTime;
pInfo->dwStartCookie = m_dwStartCookie;
pInfo->dwStopCookie = m_dwStopCookie;
pInfo->dwFlags = m_bStopSendExtra ? AM_STREAM_INFO_STOP_SEND_EXTRA : 0;
pInfo->dwFlags |= m_tStartTime == MAX_TIME ? 0 : AM_STREAM_INFO_START_DEFINED;
pInfo->dwFlags |= m_tStopTime == MAX_TIME ? 0 : AM_STREAM_INFO_STOP_DEFINED;
switch (m_StreamState) {
default:
DbgBreak("Invalid stream state");
case STREAM_FLOWING:
break;
case STREAM_DISCARDING:
pInfo->dwFlags |= AM_STREAM_INFO_DISCARDING;
break;
}
return S_OK;
}
void CBaseStreamControl::ExecuteStop()
{
ASSERT(CritCheckIn(&m_CritSec));
m_StreamState = m_StreamStateOnStop;
if (m_dwStopCookie && m_pSink) {
DbgLog((LOG_TRACE,2,TEXT("*sending EC_STREAM_CONTROL_STOPPED (%d)"),
m_dwStopCookie));
m_pSink->Notify(EC_STREAM_CONTROL_STOPPED, (LONG_PTR)this, m_dwStopCookie);
}
CancelStop(); // This will do the tidy up
}
void CBaseStreamControl::ExecuteStart()
{
ASSERT(CritCheckIn(&m_CritSec));
m_StreamState = STREAM_FLOWING;
if (m_dwStartCookie) {
DbgLog((LOG_TRACE,2,TEXT("*sending EC_STREAM_CONTROL_STARTED (%d)"),
m_dwStartCookie));
m_pSink->Notify(EC_STREAM_CONTROL_STARTED, (LONG_PTR)this, m_dwStartCookie);
}
CancelStart(); // This will do the tidy up
}
void CBaseStreamControl::CancelStop()
{
ASSERT(CritCheckIn(&m_CritSec));
m_tStopTime = MAX_TIME;
m_dwStopCookie = 0;
m_StreamStateOnStop = STREAM_FLOWING;
}
void CBaseStreamControl::CancelStart()
{
ASSERT(CritCheckIn(&m_CritSec));
m_tStartTime = MAX_TIME;
m_dwStartCookie = 0;
}
// This guy will return one of the three StreamControlState's. Here's what the caller
// should do for each one:
//
// STREAM_FLOWING: Proceed as usual (render or pass the sample on)
// STREAM_DISCARDING: Calculate the time 'til *pSampleStart and wait that long
// for the event handle (GetStreamEventHandle()). If the
// wait expires, throw the sample away. If the event
// fires, call me back, I've changed my mind.
// I use pSampleStart (not Stop) so that live sources don't
// block for the duration of their samples, since the clock
// will always read approximately pSampleStart when called
// All through this code, you'll notice the following rules:
// - When start and stop time are the same, it's as if start was first
// - An event is considered inside the sample when it's >= sample start time
// but < sample stop time
// - if any part of the sample is supposed to be sent, we'll send the whole
// thing since we don't break it into smaller pieces
// - If we skip over a start or stop without doing it, we still signal the event
// and reset ourselves in case somebody's waiting for the event, and to make
// sure we notice that the event is past and should be forgotten
// Here are the 19 cases that have to be handled (x=start o=stop <-->=sample):
//
// 1. xo<--> start then stop
// 2. ox<--> stop then start
// 3. x<o-> start
// 4. o<x-> stop then start
// 5. x<-->o start
// 6. o<-->x stop
// 7. <x->o start
// 8. <o->x no change
// 9. <xo> start
// 10. <ox> stop then start
// 11. <-->xo no change
// 12. <-->ox no change
// 13. x<--> start
// 14. <x-> start
// 15. <-->x no change
// 16. o<--> stop
// 17. <o-> no change
// 18. <-->o no change
// 19. <--> no change
enum CBaseStreamControl::StreamControlState CBaseStreamControl::CheckSampleTimes
( __in const REFERENCE_TIME * pSampleStart, __in const REFERENCE_TIME * pSampleStop )
{
CAutoLock lck(&m_CritSec);
ASSERT(!m_bIsFlushing);
ASSERT(pSampleStart && pSampleStop);
// Don't ask me how I came up with the code below to handle all 19 cases
// - DannyMi
if (m_tStopTime >= *pSampleStart)
{
if (m_tStartTime >= *pSampleStop)
return m_StreamState; // cases 8 11 12 15 17 18 19
if (m_tStopTime < m_tStartTime)
ExecuteStop(); // case 10
ExecuteStart(); // cases 3 5 7 9 13 14
return m_StreamState;
}
if (m_tStartTime >= *pSampleStop)
{
ExecuteStop(); // cases 6 16
return m_StreamState;
}
if (m_tStartTime <= m_tStopTime)
{
ExecuteStart();
ExecuteStop();
return m_StreamState; // case 1
}
else
{
ExecuteStop();
ExecuteStart();
return m_StreamState; // cases 2 4
}
}
enum CBaseStreamControl::StreamControlState CBaseStreamControl::CheckStreamState( IMediaSample * pSample )
{
REFERENCE_TIME rtBufferStart, rtBufferStop;
const BOOL bNoBufferTimes =
pSample == NULL ||
FAILED(pSample->GetTime(&rtBufferStart, &rtBufferStop));
StreamControlState state;
LONG lWait;
do
{
// something has to break out of the blocking
if (m_bIsFlushing || m_FilterState == State_Stopped)
return STREAM_DISCARDING;
if (bNoBufferTimes) {
// Can't do anything until we get a time stamp
state = m_StreamState;
break;
} else {
state = CheckSampleTimes( &rtBufferStart, &rtBufferStop );
if (state == STREAM_FLOWING)
break;
// we aren't supposed to send this, but we've been
// told to send one more than we were supposed to
// (and the stop isn't still pending and we're streaming)
if (m_bStopSendExtra && !m_bStopExtraSent &&
m_tStopTime == MAX_TIME &&
m_FilterState != State_Stopped) {
m_bStopExtraSent = TRUE;
DbgLog((LOG_TRACE,2,TEXT("%d sending an EXTRA frame"),
m_dwStopCookie));
state = STREAM_FLOWING;
break;
}
}
// We're in discarding mode
// If we've no clock, discard as fast as we can
if (!m_pRefClock) {
break;
// If we're paused, we can't discard in a timely manner because
// there's no such thing as stream times. We must block until
// we run or stop, or we'll end up throwing the whole stream away
// as quickly as possible
} else if (m_FilterState == State_Paused) {
lWait = INFINITE;
} else {
// wait until it's time for the sample until we say "discard"
// ("discard in a timely fashion")
REFERENCE_TIME rtNow;
EXECUTE_ASSERT(SUCCEEDED(m_pRefClock->GetTime(&rtNow)));
rtNow -= m_tRunStart; // Into relative ref-time
lWait = LONG((rtBufferStart - rtNow)/10000); // 100ns -> ms
if (lWait < 10) break; // Not worth waiting - discard early
}
} while(WaitForSingleObject(GetStreamEventHandle(), lWait) != WAIT_TIMEOUT);
return state;
}
void CBaseStreamControl::NotifyFilterState( FILTER_STATE new_state, REFERENCE_TIME tStart )
{
CAutoLock lck(&m_CritSec);
// or we will get confused
if (m_FilterState == new_state)
return;
switch (new_state)
{
case State_Stopped:
DbgLog((LOG_TRACE,2,TEXT("Filter is STOPPED")));
// execute any pending starts and stops in the right order,
// to make sure all notifications get sent, and we end up
// in the right state to begin next time (??? why not?)
if (m_tStartTime != MAX_TIME && m_tStopTime == MAX_TIME) {
ExecuteStart();
} else if (m_tStopTime != MAX_TIME && m_tStartTime == MAX_TIME) {
ExecuteStop();
} else if (m_tStopTime != MAX_TIME && m_tStartTime != MAX_TIME) {
if (m_tStartTime <= m_tStopTime) {
ExecuteStart();
ExecuteStop();
} else {
ExecuteStop();
ExecuteStart();
}
}
// always start off flowing when the graph starts streaming
// unless told otherwise
m_StreamState = STREAM_FLOWING;
m_FilterState = new_state;
break;
case State_Running:
DbgLog((LOG_TRACE,2,TEXT("Filter is RUNNING")));
m_tRunStart = tStart;
// fall-through
default: // case State_Paused:
m_FilterState = new_state;
}
// unblock!
m_StreamEvent.Set();
}
void CBaseStreamControl::Flushing(BOOL bInProgress)
{
CAutoLock lck(&m_CritSec);
m_bIsFlushing = bInProgress;
m_StreamEvent.Set();
}
↑ V730 Not all members of a class are initialized inside the constructor. Consider inspecting: m_bStopExtraSent, m_pSink, m_tRunStart.