mirror of
https://github.com/PCSX2/pcsx2.git
synced 2025-04-02 10:52:54 -04:00
ab9bdb009b
Update it to the version found at https://github.com/Microsoft/Windows-classic-samples , which is in an MIT licensed repo, and add the LICENSE file (edited to remove the SIL Open Font LICENSE part since that doesn't apply). Some modifications have been made to reduce the diff/stop git complaining (not including any file that wasn't in the previous version and removing the related header includes in streams.h, and fixing some but not all of the whitespace issues).
402 lines
12 KiB
C++
402 lines
12 KiB
C++
//------------------------------------------------------------------------------
|
|
// 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();
|
|
}
|