Category

Development Platform
Home > SourceCode/Document > Multimedia program > mpeg mp3 > View Code
alloc.h
Package: h264src.zip　[view]
Upload User: sunbaby
Upload Date: 2013-05-31
Package Size: 242k
Code Size: 3k
Category:

mpeg mp3

Development Platform:

Visual C++

alloc.h：Code Content
  1. //==========================================================================;
  2. //
  3. //  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
  4. //  KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  5. //  IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
  6. //  PURPOSE.
  7. //
  8. //  Copyright (c) 1996 - 1997  Microsoft Corporation.  All Rights Reserved.
  9. //
  10. //--------------------------------------------------------------------------;
  11. /*  Allocator for sequential buffers
  12.     Like CBaseAllocator BUT always allocates the next buffer
  13. */
  15. typedef CMediaSample *LPCMEDIASAMPLE;
  17. class CSequentialAllocator : public CMemAllocator
  18. {
  19. public:
  20.     CSequentialAllocator(
  21.         LPUNKNOWN  pUnk,
  22.         HRESULT   *phr
  23.     );
  25.     ~CSequentialAllocator();
  27.     STDMETHODIMP GetBuffer(
  28.         IMediaSample **ppBuffer,
  29.         REFERENCE_TIME * pStartTime,
  30.         REFERENCE_TIME * pEndTime,
  31.         DWORD dwFlags);
  33.     HRESULT Alloc();
  35.     /*  Get buffer index */
  36.     int BufferIndex(PBYTE pbBuffer);
  38.     /*  Given an address get the IMediaSample pointer -
  39.         NB needs optimizing
  40.     */
  41.     CMediaSample *SampleFromBuffer(PBYTE pBuffer);
  43.     /*  Add a buffer to the valid list */
  44.     void AddBuffer(CMediaSample *pSample);
  46.     /*  Step through valid data */
  47.     HRESULT Advance(LONG lAdvance);
  49.     /*  Get the valid part */
  50.     PBYTE GetValid(LONG *plValid);
  52.     /*  Wrap end to go back to start */
  53.     HRESULT Wrap(void);
  55.     /*  Flush the allocator - just discard all the data in it */
  56.     void Flush();
  58. private:
  59.     PBYTE           m_pbNext;
  60.     LPCMEDIASAMPLE *m_parSamples;
  62.     /*  Simple wrap around buffer stuff */
  63.     LONG            m_lValid;
  64.     PBYTE           m_pbStartValid;
  65.     PBYTE           m_pBuffer;  /* Copy of CMemAllocator's which is private */
  66. };
  68. /*  Allocator for subsamples */
  69. class CSubAllocator : public CBaseAllocator
  70. {
  71. public:
  72.     CSubAllocator(
  73.         LPUNKNOWN  pUnk,
  74.         HRESULT   *phr,
  75.         CSequentialAllocator *pAlloc
  76.     ) : CBaseAllocator(NAME("CSubAllocator"), pUnk, phr),
  77.         m_pAlloc(pAlloc)
  78.     {
  79.     }
  81.     CMediaSample *GetSample(PBYTE pbData, DWORD dwLen)
  82.     {
  83.         HRESULT hr = S_OK;
  84.         CMediaSample *pSample = new CMediaSample(
  85.                                         NAME("CMediaSample"),
  86.                                         this,
  87.                                         &hr,
  88.                                         pbData,
  89.                                         dwLen);
  90.         if (pSample != NULL) {
  92.             /*  We only need to lock the first buffer because
  93.                 the super allocator allocates samples sequentially
  94.                 so it can't allocate subsequent samples until
  95.                 the first one has been freed
  96.             */
  97.             m_pAlloc->SampleFromBuffer(pbData)->AddRef();
  99.             /*  AddRef() ourselves too to conform to the rules */
  100.             pSample->AddRef();
  102.             /*  Make sure WE don't go away too ! */
  103.             AddRef();
  104.         }
  105.         return pSample;
  106.     }
  108.     STDMETHODIMP ReleaseBuffer(IMediaSample * pSample)
  109.     {
  110.         /*  Free the superallocator's buffer */
  111.         CMediaSample *pMediaSample = (CMediaSample *)pSample;
  112.         PBYTE pBuffer;
  113.         pSample->GetPointer(&pBuffer);
  114.         m_pAlloc->SampleFromBuffer(pBuffer)->Release();
  115.         delete pMediaSample;
  117.         Release();
  118.         return NOERROR;
  119.     }
  122.     /*  Must override Free() */
  123.     void Free() {}
  125. private:
  126.     CSequentialAllocator *const m_pAlloc;
  127. };
  130. /*  Track samples in buffer */