prj/tech/libsrc/actmovie/amalloc.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // $Source: x:/prj/tech/libsrc/actmovie/RCS/amalloc.cpp $
   3 // $Author: JON $
   4 // $Date: 1996/09/18 11:32:28 $
   5 // $Revision: 1.3 $
   6 //
   7
   8 #include <windows.h>
   9 #include <lg.h>
  10
  11 #include <comtools.h>
  12
  13 #include <actmovie.h>
  14
  15 #include <control.h>
  16 #include <strmif.h>
  17 #include <evcode.h>
  18 #include <uuids.h>
  19 #include <vfwmsgs.h>
  20
  21 #include <amalloc.h>
  22
  23 ///////////////////////////////////////////////////////////////////////////////
  24 //
  25 // @Note (toml 09-06-96):  The following are HACKS to get this file to compiler
  26 //
  27
  28 // @TBD (toml 09-06-96): Thse macros are placeholders for things in mtype.*, which needs to be imported (?)
  29 #define DeleteMediaType(p)
  30 #define CreateMediaType(p) (p)
  31
  32 // @TBD (toml 09-06-96): these are things from wxutil
  33 #define ValidateReadPtr(p,cb)
  34 #define ValidateWritePtr(p,cb)
  35 #define ValidateReadWritePtr(p,cb)
  36 #define ValidateStringPtr(p)
  37 #define ValidateStringPtrA(p)
  38 #define ValidateStringPtrW(p)
  39
  40 // @TBD (toml 09-06-96): From wxdebug
  41 #define CheckPointer(p,ret) {if((p)==NULL) return (ret);}
  42
  43 #undef DbgLog
  44 #define DbgLog(x)
  45
  46 #define NAME(s) NULL
  47
  48 ///////////////////////////////////////////////////////////////////////////////
  49 //
  50 // CLASS: cMediaSample
  51 //
  52 // Memory allocation class, implements cMediaSample
  53 //
  54
  55 ///////////////////////////////////////
  56 //
  57 // Pre-fab COM implementations
  58 //
  59
  60 IMPLEMENT_UNAGGREGATABLE(cMediaSample, IMediaSample);
  61
  62 ///////////////////////////////////////
  63
  64 #pragma off(unreferenced)
  65 cMediaSample::cMediaSample(char *pName,
  66                            cBaseAllocator * pAllocator,
  67                            HRESULT * phr,
  68                            BYTE * pBuffer,
  69                            long length)
  70   : m_pBuffer(pBuffer),                          // Initialise the buffer
  71     m_cbBuffer(length),                          // And it's length
  72     m_lActual(length),                           // By default, actual = length
  73     m_pMediaType(NULL),                          // No media type change
  74     m_dwFlags(0)                                 // Nothing set
  75     {
  76     /* We must have an owner and it must also be derived from class cBaseAllocator BUT we do not hold a reference count on it */
  77     m_pAllocator = pAllocator;
  78     Assert_(pAllocator);
  79
  80     if (pAllocator == NULL)
  81         {
  82         *phr = VFW_E_NEED_OWNER;
  83         }
  84     }
  85 #pragma on(unreferenced)
  86
  87
  88 ///////////////////////////////////////
  89
  90 cMediaSample::~cMediaSample()
  91     {
  92     if (m_pMediaType)
  93         {
  94         DeleteMediaType(m_pMediaType);
  95         m_pMediaType = NULL;
  96         }
  97     }
  98
  99
 100 ///////////////////////////////////////
 101 //
 102 // On final release of this sample buffer it is not deleted but
 103 // returned to the freelist of the owning memory allocator
 104 //
 105 // The allocator may be waiting for the last buffer to be placed on the free
 106 // list in order to decommit all the memory, so the ReleaseBuffer() call may
 107 // result in this sample being deleted. We also need to hold a refcount on
 108 // the allocator to stop that going away until we have finished with this.
 109 // However, we cannot release the allocator before the ReleaseBuffer, as the
 110 // release may cause us to be deleted. Similarly we can't do it afterwards.
 111 //
 112 // Thus we must leave it to the allocator to hold an addref on our behalf.
 113 // When he issues us in GetBuffer, he addref's himself. When ReleaseBuffer
 114 // is called, he releases himself, possibly causing us and him to be deleted.
 115
 116 void cMediaSample::OnFinalRelease()
 117     {
 118     /* Free all resources */
 119     SetMediaType(NULL);
 120     m_dwFlags = 0;
 121
 122     /* This may cause us to be deleted */
 123     // Our refcount is reliably 0 thus no-one will mess with us
 124     m_pAllocator->ReleaseBuffer(this);
 125     }
 126
 127
 128 ///////////////////////////////////////
 129 //
 130 // set the buffer pointer and length. Used by allocators that
 131 // want variable sized pointers or pointers into already-read data.
 132 // This is only available through a cMediaSample* not an IMediaSample*
 133 // and so cannot be changed by clients.
 134 //
 135
 136 HRESULT cMediaSample::SetPointer(BYTE * ptr, long cBytes)
 137     {
 138     m_pBuffer = ptr;                             // new buffer area (could be null)
 139     m_cbBuffer = cBytes;                         // length of buffer
 140     m_lActual = cBytes;                          // length of data in buffer (assume full)
 141
 142     return S_OK;
 143     }
 144
 145
 146 ///////////////////////////////////////
 147 //
 148 // get me a read/write pointer to this buffer's memory. I will actually
 149 // want to use sizeUsed bytes.
 150 //
 151
 152 STDMETHODIMP cMediaSample::GetPointer(BYTE ** ppBuffer)
 153     {
 154     CheckPointer(ppBuffer, E_POINTER);
 155     ValidateReadWritePtr(ppBuffer, sizeof(BYTE *));
 156
 157     // creator must have set pointer either during
 158     // constructor or by SetPointer
 159     Assert_(m_pBuffer);
 160     if (m_pBuffer == 0)
 161         {
 162         return VFW_E_BUFFER_NOTSET;
 163         }
 164
 165     *ppBuffer = m_pBuffer;
 166     return NOERROR;
 167     }
 168
 169
 170 ///////////////////////////////////////
 171 //
 172 // return the size in bytes of this buffer
 173 //
 174
 175 STDMETHODIMP_(long) cMediaSample::GetSize(void)
 176     {
 177     return m_cbBuffer;
 178     }
 179
 180
 181 ///////////////////////////////////////
 182 //
 183 // get the stream time at which this sample should start and finish.
 184 //
 185
 186 STDMETHODIMP cMediaSample::GetTime(REFERENCE_TIME * pTimeStart,      // put time here
 187                                    REFERENCE_TIME * pTimeEnd)
 188     {
 189     CheckPointer(pTimeStart, E_POINTER);
 190     CheckPointer(pTimeEnd, E_POINTER);
 191     ValidateReadWritePtr(pTimeStart, sizeof(REFERENCE_TIME));
 192     ValidateReadWritePtr(pTimeEnd, sizeof(REFERENCE_TIME));
 193
 194     if (!(m_dwFlags & Sample_TimeValid))
 195         {
 196         return VFW_E_SAMPLE_TIME_NOT_SET;
 197         }
 198
 199     *pTimeStart = m_Start;
 200     *pTimeEnd = m_End;
 201     return NOERROR;
 202     }
 203
 204
 205 ///////////////////////////////////////
 206 //
 207 // Set the stream time at which this sample should start and finish.
 208 //
 209 STDMETHODIMP cMediaSample::SetTime(REFERENCE_TIME * pTimeStart,
 210                                    REFERENCE_TIME * pTimeEnd)
 211     {
 212     if (!pTimeStart || !pTimeEnd)
 213         {
 214         if (!pTimeStart && !pTimeEnd)
 215             {
 216             m_dwFlags &= ~Sample_TimeValid;
 217             }
 218         else
 219             {
 220             CheckPointer(pTimeStart, E_POINTER);
 221             CheckPointer(pTimeEnd, E_POINTER);
 222             }
 223         }
 224     else
 225         {
 226         ValidateReadPtr(pTimeStart, sizeof(REFERENCE_TIME));
 227         ValidateReadPtr(pTimeEnd, sizeof(REFERENCE_TIME));
 228         Assert_(*pTimeEnd >= *pTimeStart);
 229
 230         m_Start = *pTimeStart;
 231         m_End = *pTimeEnd;
 232         m_dwFlags |= Sample_TimeValid;
 233         }
 234     return NOERROR;
 235     }
 236
 237
 238 ///////////////////////////////////////
 239 //
 240 // get the media times (eg bytes) for this sample
 241 //
 242
 243 STDMETHODIMP cMediaSample::GetMediaTime(LONGLONG * pTimeStart,
 244                                         LONGLONG * pTimeEnd)
 245     {
 246     CheckPointer(pTimeStart, E_POINTER);
 247     CheckPointer(pTimeEnd, E_POINTER);
 248     ValidateReadWritePtr(pTimeStart, sizeof(LONGLONG));
 249     ValidateReadWritePtr(pTimeEnd, sizeof(LONGLONG));
 250
 251     if (!(m_dwFlags & Sample_MediaTimeValid))
 252         {
 253         return VFW_E_MEDIA_TIME_NOT_SET;
 254         }
 255
 256     *pTimeStart = m_MediaStart;
 257     *pTimeEnd = (m_MediaStart + m_MediaEnd);
 258     return NOERROR;
 259     }
 260
 261
 262 ///////////////////////////////////////
 263 //
 264 // Set the media times for this sample
 265 //
 266
 267 STDMETHODIMP cMediaSample::SetMediaTime(LONGLONG * pTimeStart,
 268                                         LONGLONG * pTimeEnd)
 269     {
 270     if (!pTimeStart && !pTimeEnd)
 271         {
 272         m_dwFlags &= ~Sample_MediaTimeValid;
 273         }
 274     else
 275         {
 276         CheckPointer(pTimeStart, E_POINTER);
 277         CheckPointer(pTimeEnd, E_POINTER);
 278         ValidateReadPtr(pTimeStart, sizeof(LONGLONG));
 279         ValidateReadPtr(pTimeEnd, sizeof(LONGLONG));
 280         Assert_(*pTimeEnd >= *pTimeStart);
 281
 282         m_MediaStart = *pTimeStart;
 283         m_MediaEnd = (long) (*pTimeEnd - *pTimeStart);
 284         m_dwFlags |= Sample_MediaTimeValid;
 285         }
 286     return NOERROR;
 287     }
 288
 289
 290 ///////////////////////////////////////
 291
 292 STDMETHODIMP cMediaSample::IsSyncPoint(void)
 293     {
 294     if (m_dwFlags & Sample_SyncPoint)
 295         {
 296         return S_OK;
 297         }
 298     else
 299         {
 300         return S_FALSE;
 301         }
 302     }
 303
 304
 305 ///////////////////////////////////////
 306
 307 STDMETHODIMP cMediaSample::SetSyncPoint(BOOL bIsSyncPoint)
 308     {
 309     if (bIsSyncPoint)
 310         {
 311         m_dwFlags |= Sample_SyncPoint;
 312         }
 313     else
 314         {
 315         m_dwFlags &= ~Sample_SyncPoint;
 316         }
 317     return NOERROR;
 318     }
 319
 320 ///////////////////////////////////////
 321 //
 322 // returns S_OK if there is a discontinuity in the data (this same is
 323 // not a continuation of the previous stream of data
 324 // - there has been a seek).
 325 //
 326
 327 STDMETHODIMP cMediaSample::IsDiscontinuity(void)
 328     {
 329     if (m_dwFlags & Sample_Discontinuity)
 330         {
 331         return S_OK;
 332         }
 333     else
 334         {
 335         return S_FALSE;
 336         }
 337     }
 338
 339 ///////////////////////////////////////
 340 //
 341 // set the discontinuity property - TRUE if this sample is not a
 342 // continuation, but a new sample after a seek.
 343 //
 344
 345 STDMETHODIMP cMediaSample::SetDiscontinuity(BOOL bDiscont)
 346     {
 347     // should be TRUE or FALSE
 348     if (bDiscont)
 349         {
 350         m_dwFlags |= Sample_Discontinuity;
 351         }
 352     else
 353         {
 354         m_dwFlags &= ~Sample_Discontinuity;
 355         }
 356     return S_OK;
 357     }
 358
 359 ///////////////////////////////////////
 360
 361 STDMETHODIMP cMediaSample::IsPreroll(void)
 362     {
 363     if (m_dwFlags & Sample_Preroll)
 364         {
 365         return S_OK;
 366         }
 367     else
 368         {
 369         return S_FALSE;
 370         }
 371     }
 372
 373
 374 ///////////////////////////////////////
 375
 376 STDMETHODIMP cMediaSample::SetPreroll(BOOL bIsPreroll)
 377     {
 378     if (bIsPreroll)
 379         {
 380         m_dwFlags |= Sample_Preroll;
 381         }
 382     else
 383         {
 384         m_dwFlags &= ~Sample_Preroll;
 385         }
 386     return NOERROR;
 387     }
 388
 389 ///////////////////////////////////////
 390
 391 STDMETHODIMP_(long) cMediaSample::GetActualDataLength(void)
 392     {
 393     return m_lActual;
 394     }
 395
 396
 397 ///////////////////////////////////////
 398
 399 STDMETHODIMP cMediaSample::SetActualDataLength(long lActual)
 400     {
 401     if (lActual > GetSize())
 402         {
 403         Assert_(lActual <= GetSize());
 404         return VFW_E_BUFFER_OVERFLOW;
 405         }
 406     m_lActual = lActual;
 407     return NOERROR;
 408     }
 409
 410
 411 ///////////////////////////////////////
 412
 413 STDMETHODIMP cMediaSample::GetMediaType(AM_MEDIA_TYPE ** ppMediaType)
 414     {
 415     CheckPointer(ppMediaType, E_POINTER);
 416     ValidateReadWritePtr(ppMediaType, sizeof(AM_MEDIA_TYPE *));
 417     Assert_(ppMediaType);
 418
 419     /* Do we have a new media type for them */
 420
 421     if (!(m_dwFlags & Sample_TypeChanged))
 422         {
 423         Assert_(m_pMediaType == NULL);
 424         *ppMediaType = NULL;
 425         return S_FALSE;
 426         }
 427
 428     Assert_(m_pMediaType);
 429
 430     /* Create a copy of our media type */
 431
 432     *ppMediaType = CreateMediaType(m_pMediaType);
 433     if (*ppMediaType == NULL)
 434         {
 435         return E_OUTOFMEMORY;
 436         }
 437     return NOERROR;
 438     }
 439
 440
 441 ///////////////////////////////////////
 442
 443 STDMETHODIMP cMediaSample::SetMediaType(AM_MEDIA_TYPE * pMediaType)
 444     {
 445     /* Delete the current media type */
 446
 447     if (m_pMediaType)
 448         {
 449         DeleteMediaType(m_pMediaType);
 450         m_pMediaType = NULL;
 451         }
 452
 453     /* Mechanism for resetting the format type */
 454
 455     if (pMediaType == NULL)
 456         {
 457         m_dwFlags &= ~Sample_TypeChanged;
 458         return NOERROR;
 459         }
 460
 461     Assert_(pMediaType);
 462     ValidateReadPtr(pMediaType, sizeof(AM_MEDIA_TYPE));
 463
 464     /* Take a copy of the media type */
 465
 466     m_pMediaType = CreateMediaType(pMediaType);
 467     if (m_pMediaType == NULL)
 468         {
 469         m_dwFlags &= ~Sample_TypeChanged;
 470         return E_OUTOFMEMORY;
 471         }
 472
 473     m_dwFlags |= Sample_TypeChanged;
 474     return NOERROR;
 475     }
 476
 477 ///////////////////////////////////////////////////////////////////////////////
 478 //
 479 // CLASS: cBaseAllocator
 480 //
 481
 482 ///////////////////////////////////////
 483 //
 484 // Pre-fab COM implementations
 485 //
 486
 487 IMPLEMENT_UNAGGREGATABLE_SELF_DELETE(cBaseAllocator, IMemAllocator);
 488
 489 ///////////////////////////////////////
 490
 491 #pragma off(unreferenced)
 492 cBaseAllocator::cBaseAllocator(char *pName, LPUNKNOWN pUnk, HRESULT * phr, BOOL bEvent)
 493   : m_lAllocated(0),
 494     m_bChanged(FALSE),
 495     m_bCommitted(FALSE),
 496     m_bDecommitInProgress(FALSE),
 497     m_lSize(0),
 498     m_lCount(0),
 499     m_lAlignment(0),
 500     m_lPrefix(0),
 501     m_hSem(NULL),
 502     m_lWaiting(0)
 503     {
 504     AssertMsg(!pUnk, "Aggregation of cBaseAllocator not implemented!");
 505     if (bEvent)
 506         {
 507         m_hSem = CreateSemaphore(NULL, 0, 0x7FFFFFFF, NULL);
 508         if (m_hSem == NULL)
 509             {
 510             *phr = E_OUTOFMEMORY;
 511             return;
 512             }
 513         }
 514     }
 515 #pragma on(unreferenced)
 516
 517
 518 ///////////////////////////////////////
 519
 520 cBaseAllocator::~cBaseAllocator()
 521     {
 522     // we can't call Decommit here since that would mean a call to a
 523     // pure virtual in destructor.
 524     // We must assume that the derived class has gone into decommit state in
 525     // its destructor.
 526     Assert_(!m_bCommitted);
 527     if (m_hSem != NULL)
 528         {
 529         Verify(CloseHandle(m_hSem));
 530         }
 531     }
 532
 533
 534 ///////////////////////////////////////
 535
 536 /* This sets the size and count of the required samples. The memory isn't
 537    actually allocated until Commit() is called, if memory has already been
 538    allocated then assuming no samples are outstanding the user may call us
 539    to change the buffering, the memory will be released in Commit() */
 540
 541 STDMETHODIMP cBaseAllocator::SetProperties(ALLOCATOR_PROPERTIES * pRequest,
 542                                            ALLOCATOR_PROPERTIES * pActual)
 543     {
 544     CheckPointer(pRequest, E_POINTER);
 545     CheckPointer(pActual, E_POINTER);
 546     ValidateReadWritePtr(pActual, sizeof(ALLOCATOR_PROPERTIES));
 547     cAutoLock lock(m_Lock);
 548     ZeroMemory(pActual, sizeof(ALLOCATOR_PROPERTIES));
 549
 550     Assert_(pRequest->cbBuffer > 0);
 551
 552     /* Check the alignment requested */
 553     if (pRequest->cbAlign != 1)
 554         {
 555         DbgLog((LOG_ERROR, 2, TEXT("Alignment requested was 0x%x, not 1"),
 556                 pRequest->cbAlign));
 557         return VFW_E_BADALIGN;
 558         }
 559
 560     /* Can't do this if already committed, there is an argument that says we should not reject the SetProperties call if there
 561        are buffers still active. However this is called by the source filter, which is the same person who is holding the
 562        samples. Therefore it is not unreasonable for them to free all their samples before changing the requirements */
 563
 564     if (m_bCommitted)
 565         {
 566         return VFW_E_ALREADY_COMMITTED;
 567         }
 568
 569     /* Must be no outstanding buffers */
 570
 571     if (m_lAllocated != m_lFree.GetCount())
 572         {
 573         return VFW_E_BUFFERS_OUTSTANDING;
 574         }
 575
 576     /* There isn't any real need to check the parameters as they will just be rejected when the user finally calls Commit */
 577
 578     pActual->cbBuffer = m_lSize = pRequest->cbBuffer;
 579     pActual->cBuffers = m_lCount = pRequest->cBuffers;
 580     pActual->cbAlign = m_lAlignment = pRequest->cbAlign;
 581     pActual->cbPrefix = m_lPrefix = pRequest->cbPrefix;
 582
 583     m_bChanged = TRUE;
 584     return NOERROR;
 585     }
 586
 587 ///////////////////////////////////////
 588
 589 STDMETHODIMP cBaseAllocator::GetProperties(ALLOCATOR_PROPERTIES * pActual)
 590     {
 591     CheckPointer(pActual, E_POINTER);
 592     ValidateReadWritePtr(pActual, sizeof(ALLOCATOR_PROPERTIES));
 593
 594     cAutoLock lock(m_Lock);
 595     pActual->cbBuffer = m_lSize;
 596     pActual->cBuffers = m_lCount;
 597     pActual->cbAlign = m_lAlignment;
 598     pActual->cbPrefix = m_lPrefix;
 599     return NOERROR;
 600     }
 601
 602 ///////////////////////////////////////
 603 // get container for a sample. Blocking, synchronous call to get the
 604 // next free buffer (as represented by an IMediaSample interface).
 605 // on return, the time etc properties will be invalid, but the buffer
 606 // pointer and size will be correct.
 607
 608 HRESULT cBaseAllocator::GetBuffer(IMediaSample ** ppBuffer,
 609                                   REFERENCE_TIME * /* pStartTime */,
 610                                   REFERENCE_TIME * /*pEndTime */,
 611                                   DWORD /* dwFlags */)
 612     {
 613     cMediaSample *pSample;
 614     *ppBuffer = NULL;
 615     for (;;)
 616         {
 617             {                                    // scope for lock
 618             cAutoLock lock(m_Lock);
 619             /* Check we are committed */
 620             if (!m_bCommitted)
 621                 {
 622                 return VFW_E_NOT_COMMITTED;
 623                 }
 624             pSample = (cMediaSample *) m_lFree.RemoveHead();
 625             if (pSample == NULL)
 626                 {
 627                 SetWaiting();
 628                 }
 629             }
 630
 631         /* If we didn't get a sample then wait for the list to signal */
 632
 633         if (pSample)
 634             {
 635             break;
 636             }
 637         Assert_(m_hSem != NULL);
 638         WaitForSingleObject(m_hSem, INFINITE);
 639         }
 640
 641     /* This QueryInterface should addref the buffer up to one. On release back to zero instead of being deleted, it will
 642        requeue itself by calling the ReleaseBuffer member function. NOTE the owner of a media sample must always be derived
 643        from cBaseAllocator */
 644
 645     HRESULT hr = pSample->QueryInterface(IID_IMediaSample, (void **) ppBuffer);
 646     /* For each sample outstanding, we need to AddRef ourselves on his behalf he cannot do it, as there is no correct ordering
 647        of his release and his call to ReleaseBuffer as both could destroy him. We release this count in ReleaseBuffer, called
 648        when the sample's count drops to zero */
 649
 650     AddRef();
 651     return NOERROR;
 652     }
 653
 654
 655 ///////////////////////////////////////
 656
 657 /* Final release of a cMediaSample will call this */
 658
 659 STDMETHODIMP cBaseAllocator::ReleaseBuffer(IMediaSample * pSample)
 660     {
 661     CheckPointer(pSample, E_POINTER);
 662     ValidateReadPtr(pSample, sizeof(IMediaSample));
 663         {
 664         cAutoLock lock(m_Lock);
 665         /* Put back on the free list */
 666
 667         m_lFree.Add((cMediaSample *) pSample);
 668         NotifySample();
 669
 670         // if there is a pending Decommit, then we need to complete it by
 671         // calling Free() when the last buffer is placed on the free list
 672
 673         long l1 = m_lFree.GetCount();
 674         if (m_bDecommitInProgress && (l1 == m_lAllocated))
 675             {
 676             Free();
 677             m_bDecommitInProgress = FALSE;
 678             }
 679         }
 680
 681     /* For each buffer there is one AddRef, made in GetBuffer and released here. This may cause the allocator and all samples
 682        to be deleted */
 683
 684     Release();
 685     return NOERROR;
 686     }
 687
 688 ///////////////////////////////////////
 689
 690 void cBaseAllocator::NotifySample()
 691     {
 692     if (m_lWaiting != 0)
 693         {
 694         Assert_(m_hSem != NULL);
 695         ReleaseSemaphore(m_hSem, m_lWaiting, 0);
 696         m_lWaiting = 0;
 697         }
 698     }
 699
 700 ///////////////////////////////////////
 701
 702 STDMETHODIMP cBaseAllocator::Commit()
 703     {
 704     /* Check we are not decommitted */
 705     cAutoLock lock(m_Lock);
 706     // cannot need to alloc or re-alloc if we are committed
 707     if (m_bCommitted)
 708         {
 709         return NOERROR;
 710         }
 711
 712     /* Allow GetBuffer calls */
 713
 714     m_bCommitted = TRUE;
 715
 716     // is there a pending decommit ? if so, just cancel it
 717     if (m_bDecommitInProgress)
 718         {
 719         m_bDecommitInProgress = FALSE;
 720
 721         // don't call Alloc at this point. He cannot allow SetProperties
 722         // between Decommit and the last free, so the buffer size cannot have
 723         // changed. And because some of the buffers are not free yet, he
 724         // cannot re-alloc anyway.
 725         return NOERROR;
 726         }
 727
 728     DbgLog((LOG_MEMORY, 1, TEXT("Allocating: %ldx%ld"), m_lCount, m_lSize));
 729
 730     // actually need to allocate the samples
 731     HRESULT hr = Alloc();
 732     if (FAILED(hr))
 733         {
 734         m_bCommitted = FALSE;
 735         return hr;
 736         }
 737     return NOERROR;
 738     }
 739
 740
 741 ///////////////////////////////////////
 742
 743 STDMETHODIMP cBaseAllocator::Decommit()
 744     {
 745     /* Check we are not already decommitted */
 746     cAutoLock lock(m_Lock);
 747     if (m_bCommitted == FALSE)
 748         {
 749         if (m_bDecommitInProgress == FALSE)
 750             {
 751             return NOERROR;
 752             }
 753         }
 754
 755     /* No more GetBuffer calls will succeed */
 756     m_bCommitted = FALSE;
 757
 758     // are any buffers outstanding?
 759     if (m_lFree.GetCount() < m_lAllocated)
 760         {
 761         // please complete the decommit when last buffer is freed
 762         m_bDecommitInProgress = TRUE;
 763         }
 764     else
 765         {
 766         m_bDecommitInProgress = FALSE;
 767
 768         // need to complete the decommit here as there are no
 769         // outstanding buffers
 770
 771         Free();
 772         }
 773
 774     // Tell anyone whose waiting that they can go now so we can
 775     // reject their call
 776     NotifySample();
 777
 778     return NOERROR;
 779     }
 780
 781
 782 ///////////////////////////////////////
 783
 784 /* Base definition of allocation which checks we are ok to go ahead and do
 785    the full allocation. We return S_FALSE if the requirements are the same */
 786
 787 HRESULT cBaseAllocator::Alloc(void)
 788     {
 789     /* Error if he hasn't set the size yet */
 790     if (m_lCount <= 0 || m_lSize <= 0 || m_lAlignment <= 0)
 791         {
 792         return VFW_E_SIZENOTSET;
 793         }
 794
 795     /* should never get here while buffers outstanding */
 796     Assert_(m_lFree.GetCount() == m_lAllocated);
 797
 798     /* If the requirements haven't changed then don't reallocate */
 799     if (m_bChanged == FALSE)
 800         {
 801         return S_FALSE;
 802         }
 803
 804     return NOERROR;
 805     }
 806
 807 ///////////////////////////////////////
 808
 809 /*  Implement cBaseAllocator::cSampleList::Remove(pSample)
 810     Removes pSample from the list
 811 */
 812 void cBaseAllocator::cSampleList::Remove(cMediaSample * pSample)
 813     {
 814     cMediaSample **pSearch;
 815     for (pSearch = &m_List;
 816          *pSearch != NULL;
 817          pSearch = &(cBaseAllocator::NextSample(*pSearch)))
 818         {
 819         if (*pSearch == pSample)
 820             {
 821             *pSearch = cBaseAllocator::NextSample(pSample);
 822             cBaseAllocator::NextSample(pSample) = NULL;
 823             m_nOnList--;
 824             return;
 825             }
 826         }
 827
 828     CriticalMsg("Couldn't find sample in list");
 829     }
 830
 831 ///////////////////////////////////////////////////////////////////////////////
 832 //
 833 // CLASS: cMemAllocator
 834 //
 835
 836
 837 cMemAllocator::cMemAllocator(char *pName,
 838                              LPUNKNOWN pUnk,
 839                              HRESULT * phr)
 840   : cBaseAllocator(pName, pUnk, phr),
 841     m_pBuffer(NULL)
 842     {
 843     }
 844
 845 ///////////////////////////////////////
 846
 847 /* This sets the size and count of the required samples. The memory isn't
 848    actually allocated until Commit() is called, if memory has already been
 849    allocated then assuming no samples are outstanding the user may call us
 850    to change the buffering, the memory will be released in Commit() */
 851 STDMETHODIMP cMemAllocator::SetProperties(ALLOCATOR_PROPERTIES * pRequest,
 852                                           ALLOCATOR_PROPERTIES * pActual)
 853     {
 854     CheckPointer(pActual, E_POINTER);
 855     ValidateReadWritePtr(pActual, sizeof(ALLOCATOR_PROPERTIES));
 856     cAutoLock lock(m_Lock);
 857     ZeroMemory(pActual, sizeof(ALLOCATOR_PROPERTIES));
 858
 859     Assert_(pRequest->cbBuffer > 0);
 860
 861     SYSTEM_INFO SysInfo;
 862     GetSystemInfo(&SysInfo);
 863
 864     /* Check the alignment request is a power of 2 */
 865     if ((-pRequest->cbAlign & pRequest->cbAlign) != pRequest->cbAlign)
 866         {
 867         DbgLog((LOG_ERROR, 1, TEXT("Alignment requested 0x%x not a power of 2!"),
 868                 pRequest->cbAlign));
 869         }
 870     /* Check the alignment requested */
 871     if (pRequest->cbAlign == 0 ||
 872         SysInfo.dwAllocationGranularity & (pRequest->cbAlign - 1) != 0)
 873         {
 874         DbgLog((LOG_ERROR, 1, TEXT("Invalid alignment 0x%x requested - granularity = 0x%x"),
 875                 pRequest->cbAlign, SysInfo.dwAllocationGranularity));
 876         return VFW_E_BADALIGN;
 877         }
 878
 879     /* Can't do this if already committed, there is an argument that says we should not reject the SetProperties call if there
 880        are buffers still active. However this is called by the source filter, which is the same person who is holding the
 881        samples. Therefore it is not unreasonable for them to free all their samples before changing the requirements */
 882
 883     if (m_bCommitted == TRUE)
 884         {
 885         return VFW_E_ALREADY_COMMITTED;
 886         }
 887
 888     /* Must be no outstanding buffers */
 889
 890     if (m_lFree.GetCount() < m_lAllocated)
 891         {
 892         return VFW_E_BUFFERS_OUTSTANDING;
 893         }
 894
 895     /* There isn't any real need to check the parameters as they will just be rejected when the user finally calls Commit */
 896
 897     // round length up to alignment - remember that prefix is included in
 898     // the alignment
 899     long lSize = pRequest->cbBuffer + pRequest->cbPrefix;
 900     long lRemainder = lSize % pRequest->cbAlign;
 901     if (lRemainder != 0)
 902         {
 903         lSize = lSize - lRemainder + pRequest->cbAlign;
 904         }
 905     pActual->cbBuffer = m_lSize = (lSize - pRequest->cbPrefix);
 906
 907     pActual->cBuffers = m_lCount = pRequest->cBuffers;
 908     pActual->cbAlign = m_lAlignment = pRequest->cbAlign;
 909     pActual->cbPrefix = m_lPrefix = pRequest->cbPrefix;
 910
 911     m_bChanged = TRUE;
 912     return NOERROR;
 913     }
 914
 915 ///////////////////////////////////////
 916 // override this to allocate our resources when Commit is called.
 917 //
 918 // note that our resources may be already allocated when this is called,
 919 // since we don't free them on Decommit. We will only be called when in
 920 // decommit state with all buffers free.
 921 //
 922 // object locked by caller
 923
 924 HRESULT cMemAllocator::Alloc(void)
 925     {
 926     cAutoLock lock(m_Lock);
 927     /* Check he has called SetProperties */
 928     HRESULT hr = cBaseAllocator::Alloc();
 929     if (FAILED(hr))
 930         {
 931         return hr;
 932         }
 933
 934     /* If the requirements haven't changed then don't reallocate */
 935     if (hr == S_FALSE)
 936         {
 937         Assert_(m_pBuffer);
 938         return NOERROR;
 939         }
 940     Assert_(hr == S_OK);                          // we use this fact in the loop below
 941
 942     /* Free the old resources */
 943     if (m_pBuffer)
 944         {
 945         ReallyFree();
 946         }
 947
 948     /* Create the contiguous memory block for the samples making sure it's properly aligned (64K should be enough!) */
 949     Assert_(m_lAlignment != 0 &&
 950            (m_lSize + m_lPrefix) % m_lAlignment == 0);
 951
 952     m_pBuffer = (PBYTE) VirtualAlloc(NULL,
 953                                      m_lCount * (m_lSize + m_lPrefix),
 954                                      MEM_COMMIT,
 955                                      PAGE_READWRITE);
 956
 957     if (m_pBuffer == NULL)
 958         {
 959         return E_OUTOFMEMORY;
 960         }
 961
 962     BYTE *pNext = m_pBuffer;
 963     cMediaSample *pSample;
 964     Assert_(m_lAllocated == 0);
 965
 966     // Create the new samples - we have allocated m_lSize bytes for each sample
 967     // plus m_lPrefix bytes per sample as a prefix. We set the pointer to
 968     // the memory after the prefix - so that GetPointer() will return a pointer
 969     // to m_lSize bytes.
 970     for (; m_lAllocated < m_lCount; m_lAllocated++, pNext += (m_lSize + m_lPrefix))
 971         {
 972
 973
 974         pSample = new cMediaSample(NAME("Default memory media sample"),
 975                                    this,
 976                                    &hr,
 977                                    pNext + m_lPrefix,   // GetPointer() value
 978                                    m_lSize);     // not including prefix
 979
 980         if (FAILED(hr) || pSample == NULL)
 981             {
 982             delete pSample;
 983             return E_OUTOFMEMORY;
 984             }
 985
 986         // This CANNOT fail
 987         //        m_lFree.Add(pSample);
 988         // Our new results in a 1 reference count not zero, so we start by releasing the sample
 989         // (which decrements the reference count and then adds it to the free list anyway).
 990         // This should fix things so that media samples are actually released when we're finished with them.
 991         pSample->Release();
 992         }
 993
 994     m_bChanged = FALSE;
 995     return NOERROR;
 996     }
 997
 998
 999 ///////////////////////////////////////
1000 // override this to free up any resources we have allocated.
1001 // called from the base class on Decommit when all buffers have been
1002 // returned to the free list.
1003 //
1004 // caller has already locked the object.
1005
1006 // in our case, we keep the memory until we are deleted, so
1007 // we do nothing here. The memory is deleted in the destructor by
1008 // calling ReallyFree()
1009
1010 void cMemAllocator::Free(void)
1011     {
1012     return;
1013     }
1014
1015
1016 ///////////////////////////////////////
1017 // called from the destructor (and from Alloc if changing size/count) to
1018 // actually free up the memory
1019
1020 void cMemAllocator::ReallyFree(void)
1021     {
1022     /* Should never be deleting this unless all buffers are freed */
1023
1024     Assert_(m_lAllocated == m_lFree.GetCount());
1025
1026     /* Free up all the cMediaSamples */
1027
1028     cMediaSample *pSample;
1029     for (;;)
1030         {
1031         pSample = m_lFree.RemoveHead();
1032         if (pSample != NULL)
1033             {
1034             delete pSample;
1035             }
1036         else
1037             {
1038             break;
1039             }
1040         }
1041
1042     m_lAllocated = 0;
1043
1044     // free the block of buffer memory
1045     if (m_pBuffer)
1046         {
1047         Verify(VirtualFree(m_pBuffer, 0, MEM_RELEASE));
1048         m_pBuffer = NULL;
1049         }
1050     }
1051
1052
1053 ///////////////////////////////////////
1054
1055 /* Destructor frees our memory resources */
1056
1057 cMemAllocator::~cMemAllocator()
1058     {
1059     Decommit();
1060     ReallyFree();
1061     }
1062
1063 ///////////////////////////////////////////////////////////////////////////////
1064
1065 #pragma off(unreferenced)
1066 cDDSample::cDDSample(
1067                TCHAR *pName,
1068                cBaseAllocator *pAllocator,
1069                HRESULT *phr,
1070                LPDIRECTDRAWSURFACE pDDSurface,
1071                IDirectDrawSurface *pIDDSurface,
1072                LPDDSURFACEDESC pDDSurfaceDesc,
1073                LONG length):
1074    cMediaSample(pName, pAllocator, phr, (BYTE*)pDDSurfaceDesc->lpSurface, length),
1075    m_pDDSurface(pDDSurface),
1076    m_pDDSurfaceDesc(pDDSurfaceDesc),
1077    m_pIDDSurface(pIDDSurface)
1078 {
1079
1080 }
1081 #pragma on(unreferenced)
1082
1083 LPDIRECTDRAWSURFACE cDDSample::GetDDSurface()
1084 {
1085    return m_pDDSurface;
1086 }
1087
1088 IDirectDrawSurface *cDDSample::GetIDDSurface()
1089 {
1090    return m_pIDDSurface;
1091 }
1092
1093 LPDDSURFACEDESC cDDSample::GetDDSurfaceDesc()
1094 {
1095    return m_pDDSurfaceDesc;
1096 }
1097
1098 #pragma off(unreferenced)
1099 cBitmapSample::cBitmapSample(
1100                              TCHAR *pName,
1101                              cBaseAllocator *pAllocator,
1102                              HRESULT *phr,
1103                              grs_bitmap *pBitmap,
1104                              LONG length):
1105    cMediaSample(pName, pAllocator, phr, (BYTE*)pBitmap->bits, length),
1106    m_pBitmap(pBitmap)
1107 {
1108 }
1109 #pragma on(unreferenced)
1110
1111 grs_bitmap *cBitmapSample::GetBitmap()
1112 {
1113    return m_pBitmap;
1114 }
1115
1116
1117
1118
1119
1120