outputqueue.c File Reference

#include "dshow.h"
#include "wine/debug.h"
#include "wine/unicode.h"
#include "wine/list.h"
#include "wine/strmbase.h"
#include "uuids.h"
#include "vfwmsgs.h"
#include <assert.h>

Include dependency graph for outputqueue.c:

Go to the source code of this file.

Classes
struct	tagQueuedEvent

Macros
#define	COBJMACROS

Typedefs
typedef struct tagQueuedEvent	QueuedEvent

Enumerations
enum	{ SAMPLE_PACKET , EOS_PACKET }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (strmbase)
static DWORD WINAPI	OutputQueue_InitialThreadProc (LPVOID data)
static void	OutputQueue_FreeSamples (OutputQueue *pOutputQueue)
HRESULT WINAPI	OutputQueue_Construct (BaseOutputPin *pInputPin, BOOL bAuto, BOOL bQueue, LONG lBatchSize, BOOL bBatchExact, DWORD dwPriority, const OutputQueueFuncTable *pFuncsTable, OutputQueue **ppOutputQueue)
HRESULT WINAPI	OutputQueue_Destroy (OutputQueue *pOutputQueue)
HRESULT WINAPI	OutputQueue_ReceiveMultiple (OutputQueue *pOutputQueue, IMediaSample **ppSamples, LONG nSamples, LONG *nSamplesProcessed)
HRESULT WINAPI	OutputQueue_Receive (OutputQueue *pOutputQueue, IMediaSample *pSample)
VOID WINAPI	OutputQueue_SendAnyway (OutputQueue *pOutputQueue)
VOID WINAPI	OutputQueue_EOS (OutputQueue *pOutputQueue)
DWORD WINAPI	OutputQueueImpl_ThreadProc (OutputQueue *pOutputQueue)

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 21 of file outputqueue.c.

Typedef Documentation

QueuedEvent

typedef struct tagQueuedEvent QueuedEvent

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
SAMPLE_PACKET
EOS_PACKET

Definition at line 34 of file outputqueue.c.

{SAMPLE_PACKET, EOS_PACKET};

Function Documentation

OutputQueue_Construct()

HRESULT WINAPI OutputQueue_Construct	(	BaseOutputPin *	pInputPin,
		BOOL	bAuto,
		BOOL	bQueue,
		LONG	lBatchSize,
		BOOL	bBatchExact,
		DWORD	dwPriority,
		const OutputQueueFuncTable *	pFuncsTable,
		OutputQueue **	ppOutputQueue
	)

Definition at line 60 of file outputqueue.c.

{
    BOOL threaded = FALSE;
    DWORD tid;
 
    OutputQueue *This;
 
    if (!pInputPin || !pFuncsTable || !ppOutputQueue)
        return E_INVALIDARG;
 
    *ppOutputQueue = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(OutputQueue));
    if (!*ppOutputQueue)
        return E_OUTOFMEMORY;
 
    This = *ppOutputQueue;
    This->pFuncsTable = pFuncsTable;
    This->lBatchSize = lBatchSize;
    This->bBatchExact = bBatchExact;
    InitializeCriticalSection(&This->csQueue);
    This->csQueue.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": OutputQueue.csQueue");
    list_init(&This->SampleList);
 
    This->pInputPin = pInputPin;
    IPin_AddRef(&pInputPin->pin.IPin_iface);
 
    EnterCriticalSection(&This->csQueue);
    if (bAuto && pInputPin->pMemInputPin)
        threaded = IMemInputPin_ReceiveCanBlock(pInputPin->pMemInputPin) == S_OK;
    else
        threaded = bQueue;
 
    if (threaded)
    {
        This->hThread = CreateThread(NULL, 0, OutputQueue_InitialThreadProc, This, 0, &tid);
        if (This->hThread)
        {
            SetThreadPriority(This->hThread, dwPriority);
            This->hProcessQueue = CreateEventW(NULL, 0, 0, NULL);
        }
    }
    LeaveCriticalSection(&This->csQueue);
 
    return S_OK;
}

OutputQueue_Destroy()

HRESULT WINAPI OutputQueue_Destroy

(

OutputQueue *

pOutputQueue

)

Definition at line 114 of file outputqueue.c.

{
    EnterCriticalSection(&pOutputQueue->csQueue);
    OutputQueue_FreeSamples(pOutputQueue);
    pOutputQueue->bTerminate = TRUE;
    SetEvent(pOutputQueue->hProcessQueue);
    LeaveCriticalSection(&pOutputQueue->csQueue);
 
    pOutputQueue->csQueue.DebugInfo->Spare[0] = 0;
    DeleteCriticalSection(&pOutputQueue->csQueue);
    CloseHandle(pOutputQueue->hProcessQueue);
 
    IPin_Release(&pOutputQueue->pInputPin->pin.IPin_iface);
    HeapFree(GetProcessHeap(),0,pOutputQueue);
    return S_OK;
}

OutputQueue_EOS()

VOID WINAPI OutputQueue_EOS

(

OutputQueue *

pOutputQueue

)

Definition at line 193 of file outputqueue.c.

{
    EnterCriticalSection(&pOutputQueue->csQueue);
    if (pOutputQueue->hThread)
    {
        QueuedEvent *qev = HeapAlloc(GetProcessHeap(),0,sizeof(QueuedEvent));
        if (!qev)
        {
            ERR("Out of Memory\n");
            LeaveCriticalSection(&pOutputQueue->csQueue);
            return;
        }
        qev->type = EOS_PACKET;
        qev->pSample = NULL;
        list_add_tail(&pOutputQueue->SampleList, &qev->entry);
    }
    else
    {
        IPin* ppin = NULL;
        IPin_ConnectedTo(&pOutputQueue->pInputPin->pin.IPin_iface, &ppin);
        if (ppin)
        {
            IPin_EndOfStream(ppin);
            IPin_Release(ppin);
        }
    }
    LeaveCriticalSection(&pOutputQueue->csQueue);
    /* Covers sending the Event to the worker Thread */
    OutputQueue_SendAnyway(pOutputQueue);
}

OutputQueue_FreeSamples()

static void OutputQueue_FreeSamples ( OutputQueue *  pOutputQueue )

static

Definition at line 49 of file outputqueue.c.

{
    struct list *cursor, *cursor2;
    LIST_FOR_EACH_SAFE(cursor, cursor2, &pOutputQueue->SampleList)
    {
        QueuedEvent *qev = LIST_ENTRY(cursor, QueuedEvent, entry);
        list_remove(cursor);
        HeapFree(GetProcessHeap(),0,qev);
    }
}

Referenced by OutputQueue_Destroy().

OutputQueue_InitialThreadProc()

static DWORD WINAPI OutputQueue_InitialThreadProc ( LPVOID  data )

static

Definition at line 43 of file outputqueue.c.

{
    OutputQueue *This = (OutputQueue *)data;
    return This->pFuncsTable->pfnThreadProc(This);
}

Referenced by OutputQueue_Construct().

OutputQueue_Receive()

HRESULT WINAPI OutputQueue_Receive	(	OutputQueue *	pOutputQueue,
		IMediaSample *	pSample
	)

Definition at line 173 of file outputqueue.c.

{
    LONG processed;
    return OutputQueue_ReceiveMultiple(pOutputQueue,&pSample,1,&processed);
}

OutputQueue_ReceiveMultiple()

HRESULT WINAPI OutputQueue_ReceiveMultiple	(	OutputQueue *	pOutputQueue,
		IMediaSample **	ppSamples,
		LONG	nSamples,
		LONG *	nSamplesProcessed
	)

Definition at line 131 of file outputqueue.c.

{
    HRESULT hr = S_OK;
    int i;
 
    if (!pOutputQueue->pInputPin->pin.pConnectedTo || !pOutputQueue->pInputPin->pMemInputPin)
        return VFW_E_NOT_CONNECTED;
 
    if (!pOutputQueue->hThread)
    {
        IMemInputPin_AddRef(pOutputQueue->pInputPin->pMemInputPin);
        hr = IMemInputPin_ReceiveMultiple(pOutputQueue->pInputPin->pMemInputPin,ppSamples, nSamples, nSamplesProcessed);
        IMemInputPin_Release(pOutputQueue->pInputPin->pMemInputPin);
    }
    else
    {
        EnterCriticalSection(&pOutputQueue->csQueue);
        *nSamplesProcessed = 0;
 
        for (i = 0; i < nSamples; i++)
        {
            QueuedEvent *qev = HeapAlloc(GetProcessHeap(),0,sizeof(QueuedEvent));
            if (!qev)
            {
                ERR("Out of Memory\n");
                hr = E_OUTOFMEMORY;
                break;
            }
            qev->type = SAMPLE_PACKET;
            qev->pSample = ppSamples[i];
            IMediaSample_AddRef(ppSamples[i]);
            list_add_tail(&pOutputQueue->SampleList, &qev->entry);
            (*nSamplesProcessed)++;
        }
 
        if (!pOutputQueue->bBatchExact || list_count(&pOutputQueue->SampleList) >= pOutputQueue->lBatchSize)
            SetEvent(pOutputQueue->hProcessQueue);
        LeaveCriticalSection(&pOutputQueue->csQueue);
    }
    return hr;
}

Referenced by OutputQueue_Receive().

OutputQueue_SendAnyway()

VOID WINAPI OutputQueue_SendAnyway

(

OutputQueue *

pOutputQueue

)

Definition at line 179 of file outputqueue.c.

{
    if (pOutputQueue->hThread)
    {
        EnterCriticalSection(&pOutputQueue->csQueue);
        if (!list_empty(&pOutputQueue->SampleList))
        {
            pOutputQueue->bSendAnyway = TRUE;
            SetEvent(pOutputQueue->hProcessQueue);
        }
        LeaveCriticalSection(&pOutputQueue->csQueue);
    }
}

Referenced by OutputQueue_EOS().

OutputQueueImpl_ThreadProc()

DWORD WINAPI OutputQueueImpl_ThreadProc

(

OutputQueue *

pOutputQueue

)

Definition at line 224 of file outputqueue.c.

{
    do
    {
        EnterCriticalSection(&pOutputQueue->csQueue);
        if (!list_empty(&pOutputQueue->SampleList) &&
            (!pOutputQueue->bBatchExact ||
            list_count(&pOutputQueue->SampleList) >= pOutputQueue->lBatchSize ||
            pOutputQueue->bSendAnyway
            )
           )
        {
            while (!list_empty(&pOutputQueue->SampleList))
            {
                IMediaSample **ppSamples;
                LONG nSamples;
                LONG nSamplesProcessed;
                struct list *cursor, *cursor2;
                int i = 0;
 
                /* First Pass Process Samples */
                i = list_count(&pOutputQueue->SampleList);
                ppSamples = HeapAlloc(GetProcessHeap(),0,sizeof(IMediaSample*) * i);
                nSamples = 0;
                LIST_FOR_EACH_SAFE(cursor, cursor2, &pOutputQueue->SampleList)
                {
                    QueuedEvent *qev = LIST_ENTRY(cursor, QueuedEvent, entry);
                    if (qev->type == SAMPLE_PACKET)
                        ppSamples[nSamples++] = qev->pSample;
                    else
                        break;
                    list_remove(cursor);
                    HeapFree(GetProcessHeap(),0,qev);
                }
 
                if (pOutputQueue->pInputPin->pin.pConnectedTo && pOutputQueue->pInputPin->pMemInputPin)
                {
                    IMemInputPin_AddRef(pOutputQueue->pInputPin->pMemInputPin);
                    LeaveCriticalSection(&pOutputQueue->csQueue);
                    IMemInputPin_ReceiveMultiple(pOutputQueue->pInputPin->pMemInputPin, ppSamples, nSamples, &nSamplesProcessed);
                    EnterCriticalSection(&pOutputQueue->csQueue);
                    IMemInputPin_Release(pOutputQueue->pInputPin->pMemInputPin);
                }
                for (i = 0; i < nSamples; i++)
                    IMediaSample_Release(ppSamples[i]);
                HeapFree(GetProcessHeap(),0,ppSamples);
 
                /* Process Non-Samples */
                LIST_FOR_EACH_SAFE(cursor, cursor2, &pOutputQueue->SampleList)
                {
                    QueuedEvent *qev = LIST_ENTRY(cursor, QueuedEvent, entry);
                    if (qev->type == EOS_PACKET)
                    {
                        IPin* ppin = NULL;
                        IPin_ConnectedTo(&pOutputQueue->pInputPin->pin.IPin_iface, &ppin);
                        if (ppin)
                        {
                            IPin_EndOfStream(ppin);
                            IPin_Release(ppin);
                        }
                    }
                    else if (qev->type == SAMPLE_PACKET)
                        break;
                    else
                        FIXME("Unhandled Event type %i\n",qev->type);
                    list_remove(cursor);
                    HeapFree(GetProcessHeap(),0,qev);
                }
            }
            pOutputQueue->bSendAnyway = FALSE;
        }
        LeaveCriticalSection(&pOutputQueue->csQueue);
        WaitForSingleObject(pOutputQueue->hProcessQueue, INFINITE);
    }
    while (!pOutputQueue->bTerminate);
    return S_OK;
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

strmbase

)