src/filters/BaseClasses/strmctl.cpp

   1 //------------------------------------------------------------------------------
   2 // File: StrmCtl.cpp
   3 //
   4 // Desc: DirectShow base classes.
   5 //
   6 // Copyright (c) 1996-2002 Microsoft Corporation.  All rights reserved.
   7 //------------------------------------------------------------------------------
   8
   9
  10 #include <streams.h>
  11 #include <strmctl.h>
  12
  13 CBaseStreamControl::CBaseStreamControl()
  14 : m_StreamState(STREAM_FLOWING)
  15 , m_StreamStateOnStop(STREAM_FLOWING) // means no pending stop
  16 , m_tStartTime(MAX_TIME)
  17 , m_tStopTime(MAX_TIME)
  18 , m_dwStartCookie(0)
  19 , m_dwStopCookie(0)
  20 , m_pRefClock(NULL)
  21 , m_FilterState(State_Stopped)
  22 , m_bIsFlushing(FALSE)
  23 , m_bStopSendExtra(FALSE)
  24 {}
  25
  26 CBaseStreamControl::~CBaseStreamControl()
  27 {
  28     // Make sure we release the clock.
  29     SetSyncSource(NULL);
  30     return;
  31 }
  32
  33
  34 STDMETHODIMP CBaseStreamControl::StopAt(const REFERENCE_TIME * ptStop, BOOL bSendExtra, DWORD dwCookie)
  35 {
  36     CAutoLock lck(&m_CritSec);
  37     m_bStopSendExtra = FALSE;   // reset
  38     m_bStopExtraSent = FALSE;
  39     if (ptStop)
  40     {
  41         if (*ptStop == MAX_TIME)
  42         {
  43             DbgLog((LOG_TRACE,2,TEXT("StopAt: Cancel stop")));
  44             CancelStop();
  45             // If there's now a command to start in the future, we assume
  46             // they want to be stopped when the graph is first run
  47             if (m_FilterState == State_Stopped && m_tStartTime < MAX_TIME) {
  48                 m_StreamState = STREAM_DISCARDING;
  49                 DbgLog((LOG_TRACE,2,TEXT("graph will begin by DISCARDING")));
  50             }
  51             return NOERROR;
  52         }
  53         DbgLog((LOG_TRACE,2,TEXT("StopAt: %dms extra=%d"),
  54                                 (int)(*ptStop/10000), bSendExtra));
  55         // if the first command is to stop in the future, then we assume they
  56         // want to be started when the graph is first run
  57         if (m_FilterState == State_Stopped && m_tStartTime > *ptStop) {
  58             m_StreamState = STREAM_FLOWING;
  59             DbgLog((LOG_TRACE,2,TEXT("graph will begin by FLOWING")));
  60         }
  61         m_bStopSendExtra = bSendExtra;
  62         m_tStopTime = *ptStop;
  63         m_dwStopCookie = dwCookie;
  64         m_StreamStateOnStop = STREAM_DISCARDING;
  65     }
  66     else
  67     {
  68         DbgLog((LOG_TRACE,2,TEXT("StopAt: now")));
  69         // sending an extra frame when told to stop now would mess people up
  70         m_bStopSendExtra = FALSE;
  71         m_tStopTime = MAX_TIME;
  72         m_dwStopCookie = 0;
  73         m_StreamState = STREAM_DISCARDING;
  74         m_StreamStateOnStop = STREAM_FLOWING;   // no pending stop
  75     }
  76     // we might change our mind what to do with a sample we're blocking
  77     m_StreamEvent.Set();
  78     return NOERROR;
  79 }
  80
  81 STDMETHODIMP CBaseStreamControl::StartAt
  82 ( const REFERENCE_TIME *ptStart, DWORD dwCookie )
  83 {
  84     CAutoLock lck(&m_CritSec);
  85     if (ptStart)
  86     {
  87         if (*ptStart == MAX_TIME)
  88         {
  89             DbgLog((LOG_TRACE,2,TEXT("StartAt: Cancel start")));
  90             CancelStart();
  91             // If there's now a command to stop in the future, we assume
  92             // they want to be started when the graph is first run
  93             if (m_FilterState == State_Stopped && m_tStopTime < MAX_TIME) {
  94                 DbgLog((LOG_TRACE,2,TEXT("graph will begin by FLOWING")));
  95                 m_StreamState = STREAM_FLOWING;
  96             }
  97             return NOERROR;
  98         }
  99         DbgLog((LOG_TRACE,2,TEXT("StartAt: %dms"), (int)(*ptStart/10000)));
 100         // if the first command is to start in the future, then we assume they
 101         // want to be stopped when the graph is first run
 102         if (m_FilterState == State_Stopped && m_tStopTime >= *ptStart) {
 103             DbgLog((LOG_TRACE,2,TEXT("graph will begin by DISCARDING")));
 104             m_StreamState = STREAM_DISCARDING;
 105         }
 106         m_tStartTime = *ptStart;
 107         m_dwStartCookie = dwCookie;
 108         // if (m_tStopTime == m_tStartTime) CancelStop();
 109     }
 110     else
 111     {
 112         DbgLog((LOG_TRACE,2,TEXT("StartAt: now")));
 113         m_tStartTime = MAX_TIME;
 114         m_dwStartCookie = 0;
 115         m_StreamState = STREAM_FLOWING;
 116     }
 117     // we might change our mind what to do with a sample we're blocking
 118     m_StreamEvent.Set();
 119     return NOERROR;
 120 }
 121
 122 //  Retrieve information about current settings
 123 STDMETHODIMP CBaseStreamControl::GetInfo(AM_STREAM_INFO *pInfo)
 124 {
 125     if (pInfo == NULL)
 126         return E_POINTER;
 127
 128     pInfo->tStart = m_tStartTime;
 129     pInfo->tStop  = m_tStopTime;
 130     pInfo->dwStartCookie = m_dwStartCookie;
 131     pInfo->dwStopCookie  = m_dwStopCookie;
 132     pInfo->dwFlags = m_bStopSendExtra ? AM_STREAM_INFO_STOP_SEND_EXTRA : 0;
 133     pInfo->dwFlags |= m_tStartTime == MAX_TIME ? 0 : AM_STREAM_INFO_START_DEFINED;
 134     pInfo->dwFlags |= m_tStopTime == MAX_TIME ? 0 : AM_STREAM_INFO_STOP_DEFINED;
 135     switch (m_StreamState) {
 136     default:
 137         DbgBreak("Invalid stream state");
 138     case STREAM_FLOWING:
 139         break;
 140     case STREAM_DISCARDING:
 141         pInfo->dwFlags |= AM_STREAM_INFO_DISCARDING;
 142         break;
 143     }
 144     return S_OK;
 145 }
 146
 147
 148 void CBaseStreamControl::ExecuteStop()
 149 {
 150     ASSERT(CritCheckIn(&m_CritSec));
 151     m_StreamState = m_StreamStateOnStop;
 152     if (m_dwStopCookie && m_pSink) {
 153         DbgLog((LOG_TRACE,2,TEXT("*sending EC_STREAM_CONTROL_STOPPED (%d)"),
 154                                                         m_dwStopCookie));
 155         m_pSink->Notify(EC_STREAM_CONTROL_STOPPED, (LONG_PTR)this, m_dwStopCookie);
 156     }
 157     CancelStop(); // This will do the tidy up
 158 }
 159
 160 void CBaseStreamControl::ExecuteStart()
 161 {
 162     ASSERT(CritCheckIn(&m_CritSec));
 163     m_StreamState = STREAM_FLOWING;
 164     if (m_dwStartCookie) {
 165         DbgLog((LOG_TRACE,2,TEXT("*sending EC_STREAM_CONTROL_STARTED (%d)"),
 166                                                         m_dwStartCookie));
 167         m_pSink->Notify(EC_STREAM_CONTROL_STARTED, (LONG_PTR)this, m_dwStartCookie);
 168     }
 169     CancelStart(); // This will do the tidy up
 170 }
 171
 172 void CBaseStreamControl::CancelStop()
 173 {
 174     ASSERT(CritCheckIn(&m_CritSec));
 175     m_tStopTime = MAX_TIME;
 176     m_dwStopCookie = 0;
 177     m_StreamStateOnStop = STREAM_FLOWING;
 178 }
 179
 180 void CBaseStreamControl::CancelStart()
 181 {
 182     ASSERT(CritCheckIn(&m_CritSec));
 183     m_tStartTime = MAX_TIME;
 184     m_dwStartCookie = 0;
 185 }
 186
 187
 188 // This guy will return one of the three StreamControlState's.  Here's what the caller
 189 // should do for each one:
 190 //
 191 // STREAM_FLOWING:      Proceed as usual (render or pass the sample on)
 192 // STREAM_DISCARDING:   Calculate the time 'til *pSampleStart and wait that long
 193 //                      for the event handle (GetStreamEventHandle()).  If the
 194 //                      wait expires, throw the sample away.  If the event
 195 //                      fires, call me back, I've changed my mind.
 196 //                      I use pSampleStart (not Stop) so that live sources don't
 197 //                      block for the duration of their samples, since the clock
 198 //                      will always read approximately pSampleStart when called
 199
 200
 201 // All through this code, you'll notice the following rules:
 202 // - When start and stop time are the same, it's as if start was first
 203 // - An event is considered inside the sample when it's >= sample start time
 204 //   but < sample stop time
 205 // - if any part of the sample is supposed to be sent, we'll send the whole
 206 //   thing since we don't break it into smaller pieces
 207 // - If we skip over a start or stop without doing it, we still signal the event
 208 //   and reset ourselves in case somebody's waiting for the event, and to make
 209 //   sure we notice that the event is past and should be forgotten
 210 // Here are the 19 cases that have to be handled (x=start o=stop <-->=sample):
 211 //
 212 // 1.   xo<-->          start then stop
 213 // 2.   ox<-->          stop then start
 214 // 3.    x<o->          start
 215 // 4.    o<x->          stop then start
 216 // 5.    x<-->o         start
 217 // 6.    o<-->x         stop
 218 // 7.     <x->o         start
 219 // 8.     <o->x         no change
 220 // 9.     <xo>          start
 221 // 10.    <ox>          stop then start
 222 // 11.    <-->xo        no change
 223 // 12.    <-->ox        no change
 224 // 13.   x<-->          start
 225 // 14.    <x->          start
 226 // 15.    <-->x         no change
 227 // 16.   o<-->          stop
 228 // 17.    <o->          no change
 229 // 18.    <-->o         no change
 230 // 19.    <-->          no change
 231
 232
 233 enum CBaseStreamControl::StreamControlState CBaseStreamControl::CheckSampleTimes
 234 ( const REFERENCE_TIME * pSampleStart, const REFERENCE_TIME * pSampleStop )
 235 {
 236     CAutoLock lck(&m_CritSec);
 237
 238     ASSERT(!m_bIsFlushing);
 239     ASSERT(pSampleStart && pSampleStop);
 240
 241     // Don't ask me how I came up with the code below to handle all 19 cases
 242     // - DannyMi
 243
 244     if (m_tStopTime >= *pSampleStart)
 245     {
 246         if (m_tStartTime >= *pSampleStop)
 247             return m_StreamState;               // cases  8 11 12 15 17 18 19
 248         if (m_tStopTime < m_tStartTime)
 249             ExecuteStop();                      // case 10
 250         ExecuteStart();                         // cases 3 5 7 9 13 14
 251         return m_StreamState;
 252     }
 253
 254     if (m_tStartTime >= *pSampleStop)
 255     {
 256         ExecuteStop();                          // cases 6 16
 257         return m_StreamState;
 258     }
 259
 260     if (m_tStartTime <= m_tStopTime)
 261     {
 262         ExecuteStart();
 263         ExecuteStop();
 264         return m_StreamState;           // case 1
 265     }
 266     else
 267     {
 268         ExecuteStop();
 269         ExecuteStart();
 270         return m_StreamState;           // cases 2 4
 271     }
 272 }
 273
 274
 275 enum CBaseStreamControl::StreamControlState CBaseStreamControl::CheckStreamState( IMediaSample * pSample )
 276 {
 277
 278     REFERENCE_TIME rtBufferStart, rtBufferStop;
 279     const BOOL bNoBufferTimes =
 280               pSample == NULL ||
 281               FAILED(pSample->GetTime(&rtBufferStart, &rtBufferStop));
 282
 283     StreamControlState state;
 284     LONG lWait;
 285
 286     do
 287         {
 288             // something has to break out of the blocking
 289             if (m_bIsFlushing || m_FilterState == State_Stopped)
 290                 return STREAM_DISCARDING;
 291
 292             if (bNoBufferTimes) {
 293                 //  Can't do anything until we get a time stamp
 294                 state = m_StreamState;
 295                 break;
 296             } else {
 297                 state = CheckSampleTimes( &rtBufferStart, &rtBufferStop );
 298                 if (state == STREAM_FLOWING)
 299                     break;
 300
 301                 // we aren't supposed to send this, but we've been
 302                 // told to send one more than we were supposed to
 303                 // (and the stop isn't still pending and we're streaming)
 304                 if (m_bStopSendExtra && !m_bStopExtraSent &&
 305                                         m_tStopTime == MAX_TIME &&
 306                                         m_FilterState != State_Stopped) {
 307                     m_bStopExtraSent = TRUE;
 308                     DbgLog((LOG_TRACE,2,TEXT("%d sending an EXTRA frame"),
 309                                                             m_dwStopCookie));
 310                     state = STREAM_FLOWING;
 311                     break;
 312                 }
 313             }
 314
 315             // We're in discarding mode
 316
 317             // If we've no clock, discard as fast as we can
 318             if (!m_pRefClock) {
 319                 break;
 320
 321             // If we're paused, we can't discard in a timely manner because
 322             // there's no such thing as stream times.  We must block until
 323             // we run or stop, or we'll end up throwing the whole stream away
 324             // as quickly as possible
 325             } else if (m_FilterState == State_Paused) {
 326                 lWait = INFINITE;
 327
 328             } else {
 329                 // wait until it's time for the sample until we say "discard"
 330                 // ("discard in a timely fashion")
 331                 REFERENCE_TIME rtNow;
 332                 EXECUTE_ASSERT(SUCCEEDED(m_pRefClock->GetTime(&rtNow)));
 333                 rtNow -= m_tRunStart;   // Into relative ref-time
 334                 lWait = LONG((rtBufferStart - rtNow)/10000); // 100ns -> ms
 335                 if (lWait < 10) break; // Not worth waiting - discard early
 336             }
 337
 338     } while(WaitForSingleObject(GetStreamEventHandle(), lWait) != WAIT_TIMEOUT);
 339
 340     return state;
 341 }
 342
 343
 344 void CBaseStreamControl::NotifyFilterState( FILTER_STATE new_state, REFERENCE_TIME tStart )
 345 {
 346     CAutoLock lck(&m_CritSec);
 347
 348     // or we will get confused
 349     if (m_FilterState == new_state)
 350         return;
 351
 352     switch (new_state)
 353     {
 354         case State_Stopped:
 355
 356             DbgLog((LOG_TRACE,2,TEXT("Filter is STOPPED")));
 357
 358             // execute any pending starts and stops in the right order,
 359             // to make sure all notifications get sent, and we end up
 360             // in the right state to begin next time (??? why not?)
 361
 362             if (m_tStartTime != MAX_TIME && m_tStopTime == MAX_TIME) {
 363                 ExecuteStart();
 364             } else if (m_tStopTime != MAX_TIME && m_tStartTime == MAX_TIME) {
 365                 ExecuteStop();
 366             } else if (m_tStopTime != MAX_TIME && m_tStartTime != MAX_TIME) {
 367                 if (m_tStartTime <= m_tStopTime) {
 368                     ExecuteStart();
 369                     ExecuteStop();
 370                 } else {
 371                     ExecuteStop();
 372                     ExecuteStart();
 373                 }
 374             }
 375             // always start off flowing when the graph starts streaming
 376             // unless told otherwise
 377             m_StreamState = STREAM_FLOWING;
 378             m_FilterState = new_state;
 379             break;
 380
 381         case State_Running:
 382
 383             DbgLog((LOG_TRACE,2,TEXT("Filter is RUNNING")));
 384
 385             m_tRunStart = tStart;
 386             // fall-through
 387
 388         default: // case State_Paused:
 389             m_FilterState = new_state;
 390     }
 391     // unblock!
 392     m_StreamEvent.Set();
 393 }
 394
 395
 396 void CBaseStreamControl::Flushing(BOOL bInProgress)
 397 {
 398     CAutoLock lck(&m_CritSec);
 399     m_bIsFlushing = bInProgress;
 400     m_StreamEvent.Set();
 401 }