src/filters/BaseClasses/source.cpp

   1 //------------------------------------------------------------------------------
   2 // File: Source.cpp
   3 //
   4 // Desc: DirectShow  base classes - implements CSource, which is a Quartz
   5 //       source filter 'template.'
   6 //
   7 // Copyright (c) 1992-2002 Microsoft Corporation.  All rights reserved.
   8 //------------------------------------------------------------------------------
   9
  10
  11 // Locking Strategy.
  12 //
  13 // Hold the filter critical section (m_pFilter->pStateLock()) to serialise
  14 // access to functions. Note that, in general, this lock may be held
  15 // by a function when the worker thread may want to hold it. Therefore
  16 // if you wish to access shared state from the worker thread you will
  17 // need to add another critical section object. The execption is during
  18 // the threads processing loop, when it is safe to get the filter critical
  19 // section from within FillBuffer().
  20
  21 #include <streams.h>
  22
  23
  24 //
  25 // CSource::Constructor
  26 //
  27 // Initialise the pin count for the filter. The user will create the pins in
  28 // the derived class.
  29 CSource::CSource(TCHAR *pName, LPUNKNOWN lpunk, CLSID clsid)
  30     : CBaseFilter(pName, lpunk, &m_cStateLock, clsid),
  31       m_iPins(0),
  32       m_paStreams(NULL)
  33 {
  34 }
  35
  36 CSource::CSource(TCHAR *pName, LPUNKNOWN lpunk, CLSID clsid, HRESULT *phr)
  37     : CBaseFilter(pName, lpunk, &m_cStateLock, clsid),
  38       m_iPins(0),
  39       m_paStreams(NULL)
  40 {
  41     UNREFERENCED_PARAMETER(phr);
  42 }
  43
  44 #ifdef UNICODE
  45 CSource::CSource(CHAR *pName, LPUNKNOWN lpunk, CLSID clsid)
  46     : CBaseFilter(pName, lpunk, &m_cStateLock, clsid),
  47       m_iPins(0),
  48       m_paStreams(NULL)
  49 {
  50 }
  51
  52 CSource::CSource(CHAR *pName, LPUNKNOWN lpunk, CLSID clsid, HRESULT *phr)
  53     : CBaseFilter(pName, lpunk, &m_cStateLock, clsid),
  54       m_iPins(0),
  55       m_paStreams(NULL)
  56 {
  57     UNREFERENCED_PARAMETER(phr);
  58 }
  59 #endif
  60
  61 //
  62 // CSource::Destructor
  63 //
  64 CSource::~CSource()
  65 {
  66     /*  Free our pins and pin array */
  67     while (m_iPins != 0) {
  68         // deleting the pins causes them to be removed from the array...
  69         delete m_paStreams[m_iPins - 1];
  70     }
  71
  72     ASSERT(m_paStreams == NULL);
  73 }
  74
  75
  76 //
  77 //  Add a new pin
  78 //
  79 HRESULT CSource::AddPin(CSourceStream *pStream)
  80 {
  81     CAutoLock lock(&m_cStateLock);
  82
  83     /*  Allocate space for this pin and the old ones */
  84     CSourceStream **paStreams = new CSourceStream *[m_iPins + 1];
  85     if (paStreams == NULL) {
  86         return E_OUTOFMEMORY;
  87     }
  88     if (m_paStreams != NULL) {
  89         CopyMemory((PVOID)paStreams, (PVOID)m_paStreams,
  90                    m_iPins * sizeof(m_paStreams[0]));
  91         paStreams[m_iPins] = pStream;
  92         delete [] m_paStreams;
  93     }
  94     m_paStreams = paStreams;
  95     m_paStreams[m_iPins] = pStream;
  96     m_iPins++;
  97     return S_OK;
  98 }
  99
 100 //
 101 //  Remove a pin - pStream is NOT deleted
 102 //
 103 HRESULT CSource::RemovePin(CSourceStream *pStream)
 104 {
 105     int i;
 106     for (i = 0; i < m_iPins; i++) {
 107         if (m_paStreams[i] == pStream) {
 108             if (m_iPins == 1) {
 109                 delete [] m_paStreams;
 110                 m_paStreams = NULL;
 111             } else {
 112                 /*  no need to reallocate */
 113                 while (++i < m_iPins)
 114                     m_paStreams[i - 1] = m_paStreams[i];
 115             }
 116             m_iPins--;
 117             return S_OK;
 118         }
 119     }
 120     return S_FALSE;
 121 }
 122
 123 //
 124 // FindPin
 125 //
 126 // Set *ppPin to the IPin* that has the id Id.
 127 // or to NULL if the Id cannot be matched.
 128 STDMETHODIMP CSource::FindPin(LPCWSTR Id, IPin **ppPin)
 129 {
 130     CheckPointer(ppPin,E_POINTER);
 131     ValidateReadWritePtr(ppPin,sizeof(IPin *));
 132     // The -1 undoes the +1 in QueryId and ensures that totally invalid
 133     // strings (for which WstrToInt delivers 0) give a deliver a NULL pin.
 134     int i = WstrToInt(Id) -1;
 135     *ppPin = GetPin(i);
 136     if (*ppPin!=NULL){
 137         (*ppPin)->AddRef();
 138         return NOERROR;
 139     } else {
 140         return VFW_E_NOT_FOUND;
 141     }
 142 }
 143
 144 //
 145 // FindPinNumber
 146 //
 147 // return the number of the pin with this IPin* or -1 if none
 148 int CSource::FindPinNumber(IPin *iPin) {
 149     int i;
 150     for (i=0; i<m_iPins; ++i) {
 151         if ((IPin *)(m_paStreams[i])==iPin) {
 152             return i;
 153         }
 154     }
 155     return -1;
 156 }
 157
 158 //
 159 // GetPinCount
 160 //
 161 // Returns the number of pins this filter has
 162 int CSource::GetPinCount(void) {
 163
 164     CAutoLock lock(&m_cStateLock);
 165     return m_iPins;
 166 }
 167
 168
 169 //
 170 // GetPin
 171 //
 172 // Return a non-addref'd pointer to pin n
 173 // needed by CBaseFilter
 174 CBasePin *CSource::GetPin(int n) {
 175
 176     CAutoLock lock(&m_cStateLock);
 177
 178     // n must be in the range 0..m_iPins-1
 179     // if m_iPins>n  && n>=0 it follows that m_iPins>0
 180     // which is what used to be checked (i.e. checking that we have a pin)
 181     if ((n >= 0) && (n < m_iPins)) {
 182
 183         ASSERT(m_paStreams[n]);
 184         return m_paStreams[n];
 185     }
 186     return NULL;
 187 }
 188
 189
 190 //
 191
 192
 193 // *
 194 // * --- CSourceStream ----
 195 // *
 196
 197 //
 198 // Set Id to point to a CoTaskMemAlloc'd
 199 STDMETHODIMP CSourceStream::QueryId(LPWSTR *Id) {
 200     CheckPointer(Id,E_POINTER);
 201     ValidateReadWritePtr(Id,sizeof(LPWSTR));
 202
 203     // We give the pins id's which are 1,2,...
 204     // FindPinNumber returns -1 for an invalid pin
 205     int i = 1+ m_pFilter->FindPinNumber(this);
 206     if (i<1) return VFW_E_NOT_FOUND;
 207     *Id = (LPWSTR)CoTaskMemAlloc(8);
 208     if (*Id==NULL) {
 209        return E_OUTOFMEMORY;
 210     }
 211     IntToWstr(i, *Id);
 212     return NOERROR;
 213 }
 214
 215
 216
 217 //
 218 // CSourceStream::Constructor
 219 //
 220 // increments the number of pins present on the filter
 221 CSourceStream::CSourceStream(
 222     TCHAR *pObjectName,
 223     HRESULT *phr,
 224     CSource *ps,
 225     LPCWSTR pPinName)
 226     : CBaseOutputPin(pObjectName, ps, ps->pStateLock(), phr, pPinName),
 227       m_pFilter(ps) {
 228
 229      *phr = m_pFilter->AddPin(this);
 230 }
 231
 232 #ifdef UNICODE
 233 CSourceStream::CSourceStream(
 234     char *pObjectName,
 235     HRESULT *phr,
 236     CSource *ps,
 237     LPCWSTR pPinName)
 238     : CBaseOutputPin(pObjectName, ps, ps->pStateLock(), phr, pPinName),
 239       m_pFilter(ps) {
 240
 241      *phr = m_pFilter->AddPin(this);
 242 }
 243 #endif
 244 //
 245 // CSourceStream::Destructor
 246 //
 247 // Decrements the number of pins on this filter
 248 CSourceStream::~CSourceStream(void) {
 249
 250      m_pFilter->RemovePin(this);
 251 }
 252
 253
 254 //
 255 // CheckMediaType
 256 //
 257 // Do we support this type? Provides the default support for 1 type.
 258 HRESULT CSourceStream::CheckMediaType(const CMediaType *pMediaType) {
 259
 260     CAutoLock lock(m_pFilter->pStateLock());
 261
 262     CMediaType mt;
 263     GetMediaType(&mt);
 264
 265     if (mt == *pMediaType) {
 266         return NOERROR;
 267     }
 268
 269     return E_FAIL;
 270 }
 271
 272
 273 //
 274 // GetMediaType/3
 275 //
 276 // By default we support only one type
 277 // iPosition indexes are 0-n
 278 HRESULT CSourceStream::GetMediaType(int iPosition, CMediaType *pMediaType) {
 279
 280     CAutoLock lock(m_pFilter->pStateLock());
 281
 282     if (iPosition<0) {
 283         return E_INVALIDARG;
 284     }
 285     if (iPosition>0) {
 286         return VFW_S_NO_MORE_ITEMS;
 287     }
 288     return GetMediaType(pMediaType);
 289 }
 290
 291
 292 //
 293 // Active
 294 //
 295 // The pin is active - start up the worker thread
 296 HRESULT CSourceStream::Active(void) {
 297
 298     CAutoLock lock(m_pFilter->pStateLock());
 299
 300     HRESULT hr;
 301
 302     if (m_pFilter->IsActive()) {
 303         return S_FALSE; // succeeded, but did not allocate resources (they already exist...)
 304     }
 305
 306     // do nothing if not connected - its ok not to connect to
 307     // all pins of a source filter
 308     if (!IsConnected()) {
 309         return NOERROR;
 310     }
 311
 312     hr = CBaseOutputPin::Active();
 313     if (FAILED(hr)) {
 314         return hr;
 315     }
 316
 317     ASSERT(!ThreadExists());
 318
 319     // start the thread
 320     if (!Create()) {
 321         return E_FAIL;
 322     }
 323
 324     // Tell thread to initialize. If OnThreadCreate Fails, so does this.
 325     hr = Init();
 326     if (FAILED(hr))
 327         return hr;
 328
 329     return Pause();
 330 }
 331
 332
 333 //
 334 // Inactive
 335 //
 336 // Pin is inactive - shut down the worker thread
 337 // Waits for the worker to exit before returning.
 338 HRESULT CSourceStream::Inactive(void) {
 339
 340     CAutoLock lock(m_pFilter->pStateLock());
 341
 342     HRESULT hr;
 343
 344     // do nothing if not connected - its ok not to connect to
 345     // all pins of a source filter
 346     if (!IsConnected()) {
 347         return NOERROR;
 348     }
 349
 350     // !!! need to do this before trying to stop the thread, because
 351     // we may be stuck waiting for our own allocator!!!
 352
 353     hr = CBaseOutputPin::Inactive();  // call this first to Decommit the allocator
 354     if (FAILED(hr)) {
 355         return hr;
 356     }
 357
 358     if (ThreadExists()) {
 359         hr = Stop();
 360
 361         if (FAILED(hr)) {
 362             return hr;
 363         }
 364
 365         hr = Exit();
 366         if (FAILED(hr)) {
 367             return hr;
 368         }
 369
 370         Close();        // Wait for the thread to exit, then tidy up.
 371     }
 372
 373     // hr = CBaseOutputPin::Inactive();  // call this first to Decommit the allocator
 374     //if (FAILED(hr)) {
 375     //  return hr;
 376     //}
 377
 378     return NOERROR;
 379 }
 380
 381
 382 //
 383 // ThreadProc
 384 //
 385 // When this returns the thread exits
 386 // Return codes > 0 indicate an error occured
 387 DWORD CSourceStream::ThreadProc(void) {
 388
 389     HRESULT hr;  // the return code from calls
 390     Command com;
 391
 392     do {
 393         com = GetRequest();
 394         if (com != CMD_INIT) {
 395             DbgLog((LOG_ERROR, 1, TEXT("Thread expected init command")));
 396             Reply((DWORD) E_UNEXPECTED);
 397         }
 398     } while (com != CMD_INIT);
 399
 400     DbgLog((LOG_TRACE, 1, TEXT("CSourceStream worker thread initializing")));
 401
 402     hr = OnThreadCreate(); // perform set up tasks
 403     if (FAILED(hr)) {
 404         DbgLog((LOG_ERROR, 1, TEXT("CSourceStream::OnThreadCreate failed. Aborting thread.")));
 405         OnThreadDestroy();
 406         Reply(hr);      // send failed return code from OnThreadCreate
 407         return 1;
 408     }
 409
 410     // Initialisation suceeded
 411     Reply(NOERROR);
 412
 413     Command cmd;
 414     do {
 415         cmd = GetRequest();
 416
 417         switch (cmd) {
 418
 419         case CMD_EXIT:
 420             Reply(NOERROR);
 421             break;
 422
 423         case CMD_RUN:
 424             DbgLog((LOG_ERROR, 1, TEXT("CMD_RUN received before a CMD_PAUSE???")));
 425             // !!! fall through???
 426
 427         case CMD_PAUSE:
 428             Reply(NOERROR);
 429             DoBufferProcessingLoop();
 430             break;
 431
 432         case CMD_STOP:
 433             Reply(NOERROR);
 434             break;
 435
 436         default:
 437             DbgLog((LOG_ERROR, 1, TEXT("Unknown command %d received!"), cmd));
 438             Reply((DWORD) E_NOTIMPL);
 439             break;
 440         }
 441     } while (cmd != CMD_EXIT);
 442
 443     hr = OnThreadDestroy();     // tidy up.
 444     if (FAILED(hr)) {
 445         DbgLog((LOG_ERROR, 1, TEXT("CSourceStream::OnThreadDestroy failed. Exiting thread.")));
 446         return 1;
 447     }
 448
 449     DbgLog((LOG_TRACE, 1, TEXT("CSourceStream worker thread exiting")));
 450     return 0;
 451 }
 452
 453
 454 //
 455 // DoBufferProcessingLoop
 456 //
 457 // Grabs a buffer and calls the users processing function.
 458 // Overridable, so that different delivery styles can be catered for.
 459 HRESULT CSourceStream::DoBufferProcessingLoop(void) {
 460
 461     Command com;
 462
 463     OnThreadStartPlay();
 464
 465     do {
 466         while (!CheckRequest(&com)) {
 467
 468             IMediaSample *pSample;
 469
 470             HRESULT hr = GetDeliveryBuffer(&pSample,NULL,NULL,0);
 471             if (FAILED(hr)) {
 472                 Sleep(1);
 473                 continue;       // go round again. Perhaps the error will go away
 474                             // or the allocator is decommited & we will be asked to
 475                             // exit soon.
 476             }
 477
 478             // Virtual function user will override.
 479             hr = FillBuffer(pSample);
 480
 481             if (hr == S_OK) {
 482                 hr = Deliver(pSample);
 483                 pSample->Release();
 484
 485                 // downstream filter returns S_FALSE if it wants us to
 486                 // stop or an error if it's reporting an error.
 487                 if(hr != S_OK)
 488                 {
 489                   DbgLog((LOG_TRACE, 2, TEXT("Deliver() returned %08x; stopping"), hr));
 490                   return S_OK;
 491                 }
 492
 493             } else if (hr == S_FALSE) {
 494                 // derived class wants us to stop pushing data
 495                 pSample->Release();
 496                 DeliverEndOfStream();
 497                 return S_OK;
 498             } else {
 499                 // derived class encountered an error
 500                 pSample->Release();
 501                 DbgLog((LOG_ERROR, 1, TEXT("Error %08lX from FillBuffer!!!"), hr));
 502                 DeliverEndOfStream();
 503                 m_pFilter->NotifyEvent(EC_ERRORABORT, hr, 0);
 504                 return hr;
 505             }
 506
 507             // all paths release the sample
 508         }
 509
 510         // For all commands sent to us there must be a Reply call!
 511
 512         if (com == CMD_RUN || com == CMD_PAUSE) {
 513             Reply(NOERROR);
 514         } else if (com != CMD_STOP) {
 515             Reply((DWORD) E_UNEXPECTED);
 516             DbgLog((LOG_ERROR, 1, TEXT("Unexpected command!!!")));
 517         }
 518     } while (com != CMD_STOP);
 519
 520     return S_FALSE;
 521 }
 522