/*

    Copyright (c) 1998-1999  Microsoft Corporation

*/

#ifndef __MEDIA_TERMINAL_FILTER__
#define __MEDIA_TERMINAL_FILTER__

// include header files for the amovie types
#include "Stream.h"
#include "Sample.h"

// number of internal buffers allocated by default
// (for write terminal)
const DWORD DEFAULT_AM_MST_NUM_BUFFERS = 5;

// while this is a LONG, it should actually be a positive value that'll
// fit in a LONG (the buffer size and data size variables of the sample)
// are LONG, so this is long as well
const LONG DEFAULT_AM_MST_SAMPLE_SIZE = 640;

// alignment of buffers allocated
const LONG DEFAULT_AM_MST_BUFFER_ALIGNMENT = 1;

// number of prefix bytes in buffers allocated
const LONG DEFAULT_AM_MST_BUFFER_PREFIX = 0;

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//
// CNBQueue
//
// Non blocking version of active movie queue class.  Very basic Q built
// entirely on Win32.
//
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

template <class T> class CNBQueue {
private:
    HANDLE          hSemPut;        // Semaphore controlling queue "putting"
    HANDLE          hSemGet;        // Semaphore controlling queue "getting"
    CRITICAL_SECTION CritSect;      // Thread seriallization
    int             nMax;           // Max objects allowed in queue
    int             iNextPut;       // Array index of next "PutMsg"
    int             iNextGet;       // Array index of next "GetMsg"
    T             **QueueObjects;   // Array of objects (ptr's to void)

public:
    
    
    BOOL InitializeQ(int n) 
    {

        LOG((MSP_TRACE, "CNBQueue::InitializeQ[%p] - enter", this));

        //
        // the argument had better be valid
        //

        if (0 > n)
        {
            TM_ASSERT(FALSE);

            return FALSE;
        }


        if (QueueObjects != NULL)
        {

            //
            // already initialized. this is a bug.
            //

            TM_ASSERT(FALSE);

            return FALSE;
        }


        iNextPut = 0;
        iNextGet = 0;

        
        //
        // attempt to create critical section
        //
        
        try
        {

            InitializeCriticalSection(&CritSect);
        }
        catch(...)
        {

            //
            // failed to create critical section
            //

            LOG((MSP_ERROR, "CNBQueue::InitializeQ - failed to initialize critical section"));

            return FALSE;
        }


        //
        // attempt to create a semaphore
        //

        TCHAR *ptczSemaphoreName = NULL;

#if DBG

        //
        // in debug build, use named semaphores.
        //

        TCHAR tszPutSemaphoreName[MAX_PATH];

        _stprintf(tszPutSemaphoreName, 
            _T("CNBQueuePutSemaphore_pid[0x%lx]_CNBQueue[%p]_"),
            GetCurrentProcessId(), this);

        
        LOG((MSP_TRACE, "CNBQueue::InitializeQ - creating put semaphore [%S]",
            tszPutSemaphoreName));


        ptczSemaphoreName = &tszPutSemaphoreName[0];


#endif

        hSemPut = CreateSemaphore(NULL, n, n, ptczSemaphoreName);

        if (NULL == hSemPut)
        {
            //
            // cleanup and exit
            //

            DeleteCriticalSection(&CritSect);
            
            LOG((MSP_ERROR, "CNBQueue::InitializeQ - failed to create put semaphore"));

            return FALSE;
        }



#if DBG

        //
        // in debug build, use named semaphores.
        //

        TCHAR tszGetSemaphoreName[MAX_PATH];

        _stprintf(tszGetSemaphoreName, 
            _T("CNBQueueGetSemaphore_pid[0x%lx]_CNBQueue[%p]_"),
            GetCurrentProcessId(), this);

        
        LOG((MSP_TRACE, "CNBQueue::InitializeQ - creating get semaphore [%S]",
            tszGetSemaphoreName));


        ptczSemaphoreName = &tszGetSemaphoreName[0];


#endif


        hSemGet = CreateSemaphore(NULL, 0, n, ptczSemaphoreName);

        if (NULL == hSemGet)
        {
            //
            // cleanup and exit
            //

            CloseHandle(hSemPut);
            hSemPut = NULL;


            DeleteCriticalSection(&CritSect);

            
            LOG((MSP_ERROR, "CNBQueue::InitializeQ - failed to create get semaphore"));

            return FALSE;

        }


        //
        // attempt to allocate queue
        //

        QueueObjects = new T*[n];

        if (NULL == QueueObjects)
        {

            //
            // cleanup and exit
            //

            CloseHandle(hSemPut);
            hSemPut = NULL;


            CloseHandle(hSemGet);
            hSemGet = NULL;


            DeleteCriticalSection(&CritSect);

            LOG((MSP_ERROR, "CNBQueue::InitializeQ - failed to allocate queue objects"));

            return FALSE;

        }


        nMax = n;
        
        LOG((MSP_TRACE, "CNBQueue::InitializeQ - exit"));

        return TRUE;
    }

    void ShutdownQ()
    {
        //
        // QueueObjects also doubles as "Object Initialized" flag
        //
        // if object is initialized, _all_ its resource data members must 
        // be released
        //

        if (NULL != QueueObjects)
        {
            delete [] QueueObjects;
            QueueObjects = NULL;

            DeleteCriticalSection(&CritSect);
            
            CloseHandle(hSemPut);
            hSemPut = NULL;

            CloseHandle(hSemGet);
            hSemGet = NULL;
        }

    }


public:

    CNBQueue()		
        : QueueObjects(NULL),
          hSemPut(NULL),
          hSemGet(NULL),
          iNextPut(0),
          iNextGet(0),
          nMax(0)
    {}

    ~CNBQueue()
    {

        //
        // deallocate resources if needed
        //

        ShutdownQ();
    }


    T *DeQueue(BOOL fBlock = TRUE)
    {

        
        if (NULL == QueueObjects)
        {

            //
            // the queue is not initialized
            //

            return NULL;
        }



        //
        // block as needed
        //

        if (fBlock)
        {
            DWORD dwr = WaitForSingleObject(hSemGet, INFINITE);

            if ( WAIT_OBJECT_0 != dwr)
            {
                //
                // something's wrong
                // 

                return NULL;
            }
        }
        else 
        {
            //
            // Check for something on the queue but don't wait.  If there
            //  is nothing in the queue then we'll let the caller deal with
            //  it.
            //
            DWORD dwr = WaitForSingleObject(hSemGet, 0);

            if (dwr == WAIT_TIMEOUT)
            {
                return NULL;
            }
        }


        //
        // get an object from the queue
        //

        EnterCriticalSection(&CritSect);
        
        int iSlot = iNextGet++ % nMax;
        T *pObject = QueueObjects[iSlot];
        
        LeaveCriticalSection(&CritSect);

        // Release anyone waiting to put an object onto our queue as there
        // is now space available in the queue.
        //
        
        ReleaseSemaphore(hSemPut, 1L, NULL);
        return pObject;
    }

    BOOL EnQueue(T *pObject)
    {

        
        if (NULL == QueueObjects)
        {

            //
            // the queue is not initialized
            //

            return FALSE;
        }


        // Wait for someone to get something from our queue, returns straight
        // away is there is already an empty slot on the queue.
        //
        DWORD dwr = WaitForSingleObject(hSemPut, INFINITE);

        if ( WAIT_OBJECT_0 != dwr)
        {
            //
            // something's wrong
            // 

            return FALSE;
        }


        EnterCriticalSection(&CritSect);
        int iSlot = iNextPut++ % nMax;
        QueueObjects[iSlot] = pObject;
        LeaveCriticalSection(&CritSect);

        // Release anyone waiting to remove an object from our queue as there
        // is now an object available to be removed.
        //
        ReleaseSemaphore(hSemGet, 1L, NULL);

        return TRUE;
    }
};

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//
// define class CTMStreamSample - this is used by CMediaTerminalFilter
// currently, the actual buffer used by the sample is created dynamically on 
// the heap and when the sample is destroyed the buffer is also destroyed
// this may be changed to using a fixed size buffer pool in future
//
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

class CTMStreamSample : public CSample
{
    friend class CMediaTerminalFilter;
public:

    inline CTMStreamSample();

    // needs to be virtual, or the derived classes' destructor may  not
    // be called when a CTMStreamSample * is deleted
    virtual ~CTMStreamSample()
    {}

    // calls CSample::InitSample(pStream, bIsInternalSample)
    // sets member variables
    HRESULT Init(
        CStream &Stream, 
        bool    bIsInternalSample,
        PBYTE   pBuffer,
        LONG    BufferSize
        );
        
    inline void SetBufferInfo(
        DWORD   BufferSize,
        BYTE    *pBuffer,
        DWORD   DataSize
        );


    inline void GetBufferInfo(
        DWORD &BufferSize,
        BYTE  *&pBuffer,
        DWORD &DataSize
        );
    
    // copy the contents of the src media sample into this instance
    // CSample::CopyFrom doesn't set time (start/stop) valid flags
    // this fixes the problem.
    void CopyFrom(
        IN IMediaSample *pSrcMediaSample
        );

protected:

    PBYTE   m_pBuffer;
    LONG    m_BufferSize;
    LONG    m_DataSize;

private:

    //  Methods forwarded from MediaSample object.

    HRESULT MSCallback_GetPointer(BYTE ** ppBuffer) { *ppBuffer = m_pBuffer; return NOERROR; }

    LONG MSCallback_GetSize(void) { return m_BufferSize; }
        
    LONG MSCallback_GetActualDataLength(void) { return m_DataSize; }
        
    HRESULT MSCallback_SetActualDataLength(LONG lActual)
    {
        if (lActual <= m_BufferSize) {
            m_DataSize = lActual;
            return NOERROR;
            }
        return E_INVALIDARG;
    };
};

inline 
CTMStreamSample::CTMStreamSample(
    )
    : m_pBuffer(NULL),
      m_BufferSize(0),
      m_DataSize(0)
{
}


inline void 
CTMStreamSample::SetBufferInfo(
    DWORD   BufferSize,
    BYTE    *pBuffer,
    DWORD   DataSize
    )
{
    m_BufferSize    = BufferSize;
    m_pBuffer       = pBuffer;
    m_DataSize      = DataSize;
}


inline void 
CTMStreamSample::GetBufferInfo(
    DWORD &BufferSize,
    BYTE  *&pBuffer,
    DWORD &DataSize
    )
{
    BufferSize  = m_BufferSize;
    pBuffer     = m_pBuffer;
    DataSize    = m_DataSize;
}


class CQueueMediaSample : public CTMStreamSample
{
public:

    inline CQueueMediaSample();

#if DBG
	virtual ~CQueueMediaSample();
#endif // DBG

    // calls CTMStreamSample::Init, sets members
    HRESULT Init(
        IN CStream                      &pStream, 
        IN CNBQueue<CQueueMediaSample>  &pQueue
        );

    void HoldFragment(
        IN DWORD        FragSize,
        IN BYTE         *pbData,
        IN IMediaSample &FragMediaSample
        );

	inline DWORD GetDataSize() { return m_DataSize; }

protected:

    // pointer to a queue that contains us!
    CNBQueue<CQueueMediaSample> *m_pSampleQueue;

    // ptr to the sample being fragmented
    CComPtr<IMediaSample>       m_pFragMediaSample;
    
    // Overridden to provide different behavior
    void FinalMediaSampleRelease();

};


inline 
CQueueMediaSample::CQueueMediaSample(
    )
    : m_pSampleQueue(NULL)
{
}


class CUserMediaSample : 
        public CTMStreamSample,
        public IMemoryData,
        public ITAMMediaFormat
{
public:

BEGIN_COM_MAP(CUserMediaSample)
    COM_INTERFACE_ENTRY2(IUnknown, IStreamSample)
    COM_INTERFACE_ENTRY(IStreamSample)
    COM_INTERFACE_ENTRY(IMemoryData)
    COM_INTERFACE_ENTRY(ITAMMediaFormat)
    COM_INTERFACE_ENTRY_AGGREGATE(IID_IMarshal, m_pFTM)
END_COM_MAP()
    
    inline CUserMediaSample();

    virtual ~CUserMediaSample();

    // if asked to allocate buffers, verify allocator properties
    static BOOL VerifyAllocatorProperties(
        IN BOOL                         bAllocateBuffers,
        IN const ALLOCATOR_PROPERTIES   &AllocProps
        );

    // calls CTMStreamSample::Init, sets members
    HRESULT Init(
        IN CStream              &Stream, 
        IN BOOL                 bAllocateBuffer,
		IN DWORD				ReqdBufferSize,
        IN const ALLOCATOR_PROPERTIES &AllocProps
        );

    void BeginFragment(
        IN      BOOL                bNoteCurrentTime
        );

    // assign fragment to CQueueMediaSample
    void Fragment(
        IN      BOOL                bFragment,
        IN      LONG                AllocBufferSize,
        IN OUT  CQueueMediaSample   &QueueMediaSample,
        OUT     BOOL                &bDone
        );

    // copy fragment to downstream allocator's IMediaSample
    HRESULT CopyFragment(
        IN      BOOL           bFragment,
        IN      LONG           AllocBufferSize,
        IN OUT  IMediaSample * pDestMediaSample,
        OUT     BOOL         & bDone
        );

    // computes the time to wait. it checks the time at which the last
    // fragmented byte would be due and determines the time to wait using
    // the time delay since the beginning of fragmentation 
    DWORD GetTimeToWait(
        IN DOUBLE DelayPerByte
        );

    // when we are decommitted/aborted while being fragmented, we
    // need to get rid of our refcnt on internal IMediaSample and set
    // the error code to E_ABORT. this will be signaled to the user 
    // only when the last refcnt on IMediaSample is released 
    // (possibly by an outstanding queue sample)
    void AbortDuringFragmentation();

    // copy the contents of the src media sample into this instance
    HRESULT CopyFrom(
        IN IMediaSample *pSrcMediaSample
        );

	HRESULT CopyFrom(
		IN		IMediaSample	*pSrcMediaSample,
		IN OUT	BYTE			*&pBuffer,
		IN OUT	LONG			&DataLength
		);
        
    // over-ridden to check if the instance is committed before
    // adding the sample to the CStream buffer pool
    virtual HRESULT SetCompletionStatus(HRESULT hrCompletionStatus);

    // IStreamSample

    // this method is over-ridden from the base class so that we can
    // decrement the refcnt on a sample if stealing it from the CStream
    // free buffer pool is successful
    STDMETHODIMP CompletionStatus(
        IN   DWORD dwFlags,
        IN   /* [optional] */ DWORD dwMilliseconds
        );

    // IMemoryData

    STDMETHOD(SetBuffer)(
        IN  DWORD cbSize,
        IN  BYTE * pbData,
        IN  DWORD dwFlags
        );


    STDMETHOD(GetInfo)(
        OUT  DWORD *pdwLength,
        OUT  BYTE **ppbData,
        OUT  DWORD *pcbActualData
        );


    STDMETHOD(SetActual)(
        IN   DWORD cbDataValid
        );

    // ITAMMediaFormat

    // redirect this call to ((CMediaTerminalFilter *)m_pStream)
    STDMETHOD(get_MediaFormat)(
        OUT /* [optional] */ AM_MEDIA_TYPE **ppFormat
        );

    // this is not allowed
    STDMETHOD(put_MediaFormat)(
        IN  const AM_MEDIA_TYPE *pFormat
        );

protected:

    // marshaller
	IUnknown *m_pFTM;

    // TRUE if we allocated the buffer (then, we need to destroy it too)
    BOOL    m_bWeAllocatedBuffer;

    // time at which BeginFragment was called (value returned
    // by timeGetTime)
    DWORD   m_BeginFragmentTime;

    // these many bytes of the buffer have already been fragmented
    LONG   m_NumBytesFragmented;

    // TRUE if being fragmented
    BOOL    m_bBeingFragmented;


    // size of the buffer that the application will have to provide, if app 
    // does its own memory allocation

    DWORD m_dwRequiredBufferSize;

        
    // this calls the base class FinalMediaSampleRelease and
    // then releases reference to self obtained in BeginFragment
    virtual void FinalMediaSampleRelease();

private:

    virtual HRESULT InternalUpdate(
                        DWORD dwFlags,
                        HANDLE hEvent,
                        PAPCFUNC pfnAPC,
                        DWORD_PTR dwptrAPCData
                        );
};


inline 
CUserMediaSample::CUserMediaSample(
    )
    : m_bWeAllocatedBuffer(FALSE),
      m_NumBytesFragmented(0),
      m_bBeingFragmented(FALSE),
      m_BeginFragmentTime(0),
      m_dwRequiredBufferSize(0)
{
    // can fail
    CoCreateFreeThreadedMarshaler(
			GetControllingUnknown(), 
            &m_pFTM
            );
}


inline
CUserMediaSample::~CUserMediaSample(
    )
{
    if (m_bWeAllocatedBuffer) 
    {
        if (NULL != m_pBuffer)
        {
            delete m_pBuffer;
        }
    }

    // if there is an outstanding APC call and the user handle
    // (the targe thread handle) has not been closed, close it
    if ((NULL != m_UserAPC) && (NULL != m_hUserHandle))
    {
        CloseHandle(m_hUserHandle);
    }
    
    if (NULL != m_pFTM)
    {
        m_pFTM->Release();
        m_pFTM = NULL;
    }
}


/* The media stream terminal filter */

// uses class CMediaPumpPool
class CMediaPumpPool;

// friend
class CMediaTerminal;

class CMediaTerminalFilter :
        public CStream,
        public ITAllocatorProperties
{    
    friend CMediaTerminal;

public:

DECLARE_AGGREGATABLE(CMediaTerminalFilter)
DECLARE_GET_CONTROLLING_UNKNOWN()

BEGIN_COM_MAP(CMediaTerminalFilter)
        COM_INTERFACE_ENTRY(ITAllocatorProperties)
        COM_INTERFACE_ENTRY_CHAIN(CStream)
END_COM_MAP()

    // set the member variables
    inline CMediaTerminalFilter();

    virtual ~CMediaTerminalFilter();

    // calls the IAMMediaStream::Initialize(NULL, 0, PurposeId, StreamType),
    // sets certain member variables
    // ex. m_pAmovieMajorType
    virtual HRESULT Init(
        IN REFMSPID             PurposeId, 
        IN const STREAM_TYPE    StreamType,
        IN const GUID           &AmovieMajorType
        );

    // the thread pump calls the filter back during the registration
    // to tell it that registration succeeded and that the pump will be
    // waiting on the m_hWaitFreeSem handle
    HRESULT SignalRegisteredAtPump();

    // this method only makes sense for a write terminal and is used by CMediaPump
    // to obtain a filled buffer for passing downstream
    virtual HRESULT GetFilledBuffer(
        OUT IMediaSample    *&pMediaSample,
        OUT DWORD           &WaitTime
        );

    // the caller is supposed to call DeleteMediaType(*ppmt) (on success)
    HRESULT GetFormat(
        OUT AM_MEDIA_TYPE **ppmt
        );
    
    // This method can only be called after initialization when the stream 
    // is not connected. It can only be called if the stream is writeable.
    // it is used in writeable filters to set the media format to negotiate
    // when connected to the filter graph.
    HRESULT SetFormat(
        IN AM_MEDIA_TYPE *pmt
        );

    // checks if the filter is committed before adding the sample
    // to the CStream buffer pool
    HRESULT AddToPoolIfCommitted(
        IN  CSample *pSample
        );

    // first check if this sample is the one being fragmented currently, 
    // then check the free pool
    BOOL StealSample(
        IN CSample *pSample
        );

    // ITAllocatorProperties -
    // exposes the allocator properties of the Media Streaming Terminal 
    // (MST) to a user. A user only needs to use this interface when he 
    // needs to use his own buffers or needs to operate with a fixed set 
    // of samples

    // this method may only be called before connection and will
    // force the MST to use these values during filter negotiation
    // if the connecting filter doesn't accept these, the connection
    // shall not be established
    STDMETHOD(SetAllocatorProperties)(
        IN  ALLOCATOR_PROPERTIES *pAllocProperties
        );

    // gets current values for the allocator properties
    // after connection, this provides the negotiated values
    // it is invalid before connection. The MST will accept
    // any values suggested by the filters it connects to
    STDMETHOD(GetAllocatorProperties)(
        OUT  ALLOCATOR_PROPERTIES *pAllocProperties
        );

    // TRUE by default. when set to FALSE, the sample allocated
    // by the MST don't have any buffers and they must be supplied
    // before Update is called on the samples
    STDMETHOD(SetAllocateBuffers)(
        IN  BOOL bAllocBuffers
        );

    // returns the current value of this boolean configuration parameter
    STDMETHOD(GetAllocateBuffers)(
        OUT  BOOL *pbAllocBuffers
        );

    // this size is used for allocating buffers when AllocateSample is
	// called. this is only valid when we have been told to allocate buffers
    STDMETHOD(SetBufferSize)(
        IN  DWORD	BufferSize
        );

    // returns the value used to allocate buffers when AllocateSample is
	// called. this is only valid when we have been told to allocate buffers
    STDMETHOD(GetBufferSize)(
        OUT  DWORD	*pBufferSize
        );

    // over-ridden base class methods

    // CStream
    // IAMMediaStream

    // over-ride this to return failure. we don't allow it to join a multi-media
    // stream because the multi-media stream thinks it owns the stream
    STDMETHOD(JoinAMMultiMediaStream)(
        IN  IAMMultiMediaStream *pAMMultiMediaStream
        );
        
    // over-ride this to return failure if the filter is anything other than the internally
    // created filter. The internally created media stream filter has only one IAMMediaStream 
    // (this one) in it
    STDMETHOD(JoinFilter)(
        IN  IMediaStreamFilter *pMediaStreamFilter
        );

    STDMETHOD(AllocateSample)(
        IN   DWORD dwFlags,
        OUT  IStreamSample **ppSample
        );

    STDMETHOD(CreateSharedSample)(
        IN   IStreamSample *pExistingSample,
        IN   DWORD dwFlags,
        OUT  IStreamSample **ppNewSample
        );

    STDMETHOD(SetSameFormat)(
        IN  IMediaStream *pStream, 
        IN  DWORD dwFlags
        );

    // CStream over-ride - this method had to be replaced because 
    // of references to CPump which itself is being replaced by CMediaPump
    STDMETHODIMP SetState(
        IN  FILTER_STATE State
        );

    // CStream - end

    // IMemInputPin
        
    STDMETHOD(GetAllocatorRequirements)(
        IN  ALLOCATOR_PROPERTIES*pProps
        );

    STDMETHOD(Receive)(
        IN  IMediaSample *pSample
        );



    // supports IAMBufferNegotiation interface on TERMINAL
    // this is necessary because ITAllocatorProperties also
    // has an identical GetAllocatorProperties method!

    STDMETHOD(SuggestAllocatorProperties)(
        IN  const ALLOCATOR_PROPERTIES *pProperties
        );

    // IMemAllocator

    STDMETHOD(GetBuffer)(IMediaSample **ppBuffer, REFERENCE_TIME * pStartTime,
                               REFERENCE_TIME * pEndTime, DWORD dwFlags);

    // ** figure out what needs to be done for this allocator interface
    // since the number of buffers that can be created is unbounded
    STDMETHOD(SetProperties)(ALLOCATOR_PROPERTIES* pRequest, ALLOCATOR_PROPERTIES* pActual);

    STDMETHOD(GetProperties)(ALLOCATOR_PROPERTIES* pProps);

    STDMETHOD(Commit)();

    STDMETHOD(Decommit)();

    // IPin
        
    STDMETHOD(Connect)(IPin * pReceivePin, const AM_MEDIA_TYPE *pmt);  
    
    STDMETHOD(ReceiveConnection)(IPin * pConnector, const AM_MEDIA_TYPE *pmt);

    // the base class implementation doesn't validate the parameter
    STDMETHOD(ConnectionMediaType)(AM_MEDIA_TYPE *pmt);

    // should accept all media types which match the major type corresponding to the purpose id
    STDMETHOD(QueryAccept)(const AM_MEDIA_TYPE *pmt);

    // over-ridden from CStream to set the end of stream flag to false
    // this is done instead of setting it in Connect and ReceiveConnection
    STDMETHODIMP Disconnect();



    //
    // this is called by media pump when it has a sample for us to process
    //

    STDMETHODIMP ProcessSample(IMediaSample *pSample);

protected:

    // last sample ended at this (calculated) time

    REFERENCE_TIME m_rtLastSampleEndedAt;

    //
    // calculated duration of the sample that was last submitted
    //

    REFERENCE_TIME m_rtLastSampleDuration;


    //
    // real (measured) time of submission of the last sample
    //
    
    REFERENCE_TIME m_rtRealTimeOfLastSample;


    // flag to check if this is an audio filter, the CStream member 
    // m_PurposeId is a guiid and this just provides a less expensive 
    // way of checking the same thing
    BOOL m_bIsAudio;

    // contains the samples that will be passed to downstream filters.
    CNBQueue<CQueueMediaSample> m_SampleQueue;

    // These datamembers provide some fragmentation support 
    // for buffers going downstream
    CUserMediaSample *m_pSampleBeingFragmented;

    // flag for allocating buffers for samples when AllocateSample is 
    // called. Its TRUE by default, but the user can set it before 
    // connection
    BOOL    m_bAllocateBuffers;

	// size of buffers to allocate in AllocateSample if m_bAllocateBuffers
	// is TRUE. if this isn't set (i.e. set to 0), the negotiated 
	// allocator properties buffer size is used in its place
	DWORD	m_AllocateSampleBufferSize;

    // FALSE by default. This is set to TRUE if the user specifies 
    // allocator properties for them to see.
    // (we used to insist on our own allocator properties when this
    //  was TRUE, but now this just means that we need to translate
    //  between disjoint buffer sizes if needed)
    BOOL                 m_bUserAllocProps;
    ALLOCATOR_PROPERTIES m_UserAllocProps;

    // allocator properties negotiated -- if none suggested (by msp) and
    // none requested by user, we use whatever the other filter has
    BOOL                 m_bSuggestedAllocProps;
    ALLOCATOR_PROPERTIES m_AllocProps;

	// per byte delay for audio samples - only valid for write filter
	DOUBLE	m_AudioDelayPerByte;

	// per frame delay for video samples - only valid for write filter
	DWORD	m_VideoDelayPerFrame;

    // the filter restricts the acceptable media types to those that match the major type
    // this corresponds to the purpose id of the IAMMediaStream (set in Init)
    const GUID *m_pAmovieMajorType;

    // this is the media type suggested by a user of the terminal
    // it is only valid for writeable streams if put_MediaType was called
    // (i.e. not valid for readable streams)
    // this needs to be freed in the destructor
    // cstream - cbaseterm gets\sets it through methods
    AM_MEDIA_TYPE *m_pSuggestedMediaType;

    // this pump replaces the CStream related implementation of CPump
    // CPump uses a separate thread for each write terminal, 
    // it uses IMemAllocator::GetBuffer to get a user written media 
    // sample (for passing on downstream). This method should only be 
    // used to get the next free buffer to write into.

    // CStream methods

    // this is only used during Connect and ReceiveConnect to supply the optional media type
    // since we over-ride Connect and ReceiveConnection methods, this should never get called
    virtual HRESULT GetMediaType(ULONG Index, AM_MEDIA_TYPE **ppMediaType);

    // others

    // sets the time to delay - per byte for audio, per frame for video
    void GetTimingInfo(
        IN const AM_MEDIA_TYPE &MediaType
        );

    // timestamps the sample
    HRESULT SetTime(
            IN IMediaSample *pMediaSample
            );


    // set discontinuity flag on the sample it the sample came too late -- we
    // assume that if the application stopped feeding mst with data, this is 
    // because there was a gap in the actual data flow

    HRESULT SetDiscontinuityIfNeeded(
            IN IMediaSample *pMediaSample
            );

    // set the default allocator properties
    void SetDefaultAllocatorProperties();

    //
    // Helper methods for GetFilledBuffer.
    //

    virtual HRESULT FillDownstreamAllocatorBuffer(
        OUT IMediaSample   *& pMediaSample, 
        OUT DWORD          &  WaitTime,
        OUT BOOL           *  pfDone
        );

    virtual HRESULT FillMyBuffer(
        OUT IMediaSample   *& pMediaSample, 
        OUT DWORD          &  WaitTime,
        OUT BOOL           *  pfDone
        );


private :

    // this is a weak reference and should not be a CComPtr
    // this tells us that we should only accept this media stream filter
    // when a non-null value is proposed in JoinFilter
    IMediaStreamFilter *m_pMediaStreamFilterToAccept;

    // sets the media stream filter that may be acceptable
    inline void SetMediaStreamFilter(
        IN IMediaStreamFilter *pMediaStreamFilter
        )
    {
        m_pMediaStreamFilterToAccept = pMediaStreamFilter;
    }

public:
    // implements single thread pump for all write terminal filters
    // it uses GetFilledBuffer to obtain filled samples to write downstream
    // and to detect when to remove this filter from its list of filters to
    // service
    // ZoltanS: must be public so we can access it in DllMain
    // ZoltanS: no longer single thread pump; it is a wrapper which delegated
    // to one or more single thread pumps

    static CMediaPumpPool   ms_MediaPumpPool;

};


// set the member variables
inline 
CMediaTerminalFilter::CMediaTerminalFilter(
    )
    : m_bIsAudio(TRUE),
      m_bAllocateBuffers(TRUE),
      m_AllocateSampleBufferSize(0),
      m_bUserAllocProps(FALSE),
      m_bSuggestedAllocProps(FALSE),
      m_AudioDelayPerByte(0),
      m_VideoDelayPerFrame(0),
      m_pAmovieMajorType(NULL),
      m_pSuggestedMediaType(NULL),
      m_pSampleBeingFragmented(NULL),
      m_pMediaStreamFilterToAccept(NULL),
      m_rtLastSampleEndedAt(0),
      m_rtLastSampleDuration(0),
      m_rtRealTimeOfLastSample(0)
{
}


#endif // __MEDIA_TERMINAL_FILTER__