Update Files

Kha/Kinc/Backends/System/Windows/Libraries/DirectShow/BaseClasses/strmctl.cpp

@@ -0,0 +1,402 @@
+//------------------------------------------------------------------------------
+// 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();
+}