You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1774 lines
44 KiB
1774 lines
44 KiB
/*
|
|
|
|
Copyright (c) 1998-1999 Microsoft Corporation
|
|
|
|
*/
|
|
|
|
#include "stdafx.h"
|
|
#include "atlconv.h"
|
|
#include "termmgr.h"
|
|
#include "meterf.h"
|
|
#include "medpump.h"
|
|
|
|
#include <stdio.h>
|
|
#include <limits.h>
|
|
#include <tchar.h>
|
|
|
|
//
|
|
// the default value for maximum number of filters serviced by a single
|
|
// pump. can also be configurable through registry.
|
|
//
|
|
|
|
#define DEFAULT_MAX_FILTER_PER_PUMP (20)
|
|
|
|
|
|
//
|
|
// registry location where max number of filters per pump is configured
|
|
//
|
|
|
|
#define MST_REGISTRY_PATH _T("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Telephony\\MST")
|
|
#define MAX_FILTERS_PER_PUMP_KEY _T("MaximumFiltersPerPump")
|
|
|
|
DWORD WINAPI WriteMediaPumpThreadStart(void *pvPump)
|
|
{
|
|
return ((CMediaPump *)pvPump)->PumpMainLoop();
|
|
}
|
|
|
|
|
|
CMediaPump::CMediaPump(
|
|
)
|
|
: m_hThread(NULL),
|
|
m_hRegisterBeginSemaphore(NULL),
|
|
m_hRegisterEndSemaphore(NULL)
|
|
{
|
|
HRESULT hr;
|
|
|
|
LOG((MSP_TRACE, "CMediaPump::CMediaPump - enter"));
|
|
|
|
|
|
|
|
// create semaphores for registration signaling and completion -
|
|
// m_hRegisterBeginSemaphore is signaled before the Register call tries to acquire
|
|
// the critical section and m_hRegisterEndSemaphore is signaled when the Register
|
|
// call completes
|
|
// NOTE the names must be NULL, otherwise they will conflict when multiple pump threads
|
|
// are created
|
|
|
|
|
|
TCHAR *ptszSemaphoreName = NULL;
|
|
|
|
#if DBG
|
|
|
|
|
|
//
|
|
// in debug build, use named semaphores.
|
|
//
|
|
|
|
TCHAR tszSemaphoreNameString[MAX_PATH];
|
|
|
|
_stprintf(tszSemaphoreNameString, _T("RegisterBeginSemaphore_pid[0x%lx]_MediaPump[%p]_"), GetCurrentProcessId(), this);
|
|
|
|
LOG((MSP_TRACE, "CMediaPump::CMediaPump - creating semaphore[%S]", tszSemaphoreNameString));
|
|
|
|
ptszSemaphoreName = &tszSemaphoreNameString[0];
|
|
|
|
#endif
|
|
|
|
|
|
//
|
|
// create the beginning semaphore
|
|
//
|
|
|
|
m_hRegisterBeginSemaphore = CreateSemaphore(NULL, 0, LONG_MAX, ptszSemaphoreName);
|
|
|
|
if ( NULL == m_hRegisterBeginSemaphore ) goto cleanup;
|
|
|
|
|
|
#if DBG
|
|
|
|
//
|
|
// construct a name for registration end semaphore
|
|
//
|
|
|
|
_stprintf(tszSemaphoreNameString,
|
|
_T("RegisterEndSemaphore_pid[0x%lx]_MediaPump[%p]"),
|
|
GetCurrentProcessId(), this);
|
|
|
|
LOG((MSP_TRACE, "CMediaPump::CMediaPump - creating semaphore[%S]", tszSemaphoreNameString));
|
|
|
|
ptszSemaphoreName = &tszSemaphoreNameString[0];
|
|
|
|
#endif
|
|
|
|
|
|
//
|
|
// create the end semaphore
|
|
//
|
|
|
|
m_hRegisterEndSemaphore = CreateSemaphore(NULL, 0, LONG_MAX, ptszSemaphoreName);
|
|
|
|
if ( NULL == m_hRegisterEndSemaphore ) goto cleanup;
|
|
|
|
// insert the register event and the filter info to the arrays
|
|
// NOTE: we have to close and null the event in case of failure
|
|
// so that we can just check the register event handle value in
|
|
// Register to check if initialization was successful
|
|
hr = m_EventArray.Add(m_hRegisterBeginSemaphore);
|
|
if ( FAILED(hr) ) goto cleanup;
|
|
|
|
// add a corresponding NULL filter info entry
|
|
hr = m_FilterInfoArray.Add(NULL);
|
|
if ( FAILED(hr) )
|
|
{
|
|
m_EventArray.Remove(m_EventArray.GetSize()-1);
|
|
goto cleanup;
|
|
}
|
|
|
|
LOG((MSP_TRACE, "CMediaPump::CMediaPump - exit"));
|
|
|
|
return;
|
|
|
|
cleanup:
|
|
|
|
if ( NULL != m_hRegisterBeginSemaphore )
|
|
{
|
|
CloseHandle(m_hRegisterBeginSemaphore);
|
|
m_hRegisterBeginSemaphore = NULL;
|
|
}
|
|
|
|
if ( NULL != m_hRegisterEndSemaphore )
|
|
{
|
|
CloseHandle(m_hRegisterEndSemaphore);
|
|
m_hRegisterEndSemaphore = NULL;
|
|
}
|
|
|
|
LOG((MSP_TRACE, "CMediaPump::CMediaPump - cleanup exit"));
|
|
}
|
|
|
|
|
|
CMediaPump::~CMediaPump(void)
|
|
{
|
|
LOG((MSP_TRACE, "CMediaPump::~CMediaPump - enter"));
|
|
|
|
if ( NULL != m_hThread )
|
|
{
|
|
// when decommit is called on all the write terminals, the thread
|
|
// will return. this will signal the thread handle
|
|
WaitForSingleObject(m_hThread, INFINITE);
|
|
CloseHandle(m_hThread);
|
|
m_hThread = NULL;
|
|
}
|
|
|
|
if ( NULL != m_hRegisterBeginSemaphore )
|
|
{
|
|
CloseHandle(m_hRegisterBeginSemaphore);
|
|
m_hRegisterBeginSemaphore = NULL;
|
|
}
|
|
|
|
if ( NULL != m_hRegisterEndSemaphore )
|
|
{
|
|
CloseHandle(m_hRegisterEndSemaphore);
|
|
m_hRegisterEndSemaphore = NULL;
|
|
}
|
|
|
|
LOG((MSP_TRACE, "CMediaPump::~CMediaPump - exit"));
|
|
}
|
|
|
|
HRESULT
|
|
CMediaPump::CreateThreadPump(void)
|
|
{
|
|
LOG((MSP_TRACE, "CMediaPump::CreateThreadPump - enter"));
|
|
|
|
// release resources for any previous thread
|
|
if (NULL != m_hThread)
|
|
{
|
|
// when decommit is called on all the write terminals, the thread
|
|
// will return. this will signal the thread handle
|
|
// NOTE: this wait cannot cause a deadlock as we know that the
|
|
// number of entries in the array had dropped to 0 and only thread
|
|
// that can remove entries is the pump. this means that the pump thread
|
|
// must have detected that and returned
|
|
WaitForSingleObject(m_hThread, INFINITE);
|
|
CloseHandle(m_hThread);
|
|
m_hThread = NULL;
|
|
}
|
|
|
|
// create new thread
|
|
m_hThread = CreateThread(
|
|
NULL, 0, WriteMediaPumpThreadStart,
|
|
(void *)this, 0, NULL
|
|
);
|
|
if (NULL == m_hThread)
|
|
{
|
|
DWORD WinErrorCode = GetLastError();
|
|
|
|
LOG((MSP_TRACE,
|
|
"CMediaPump::CreateThreadPump - failed to create thread. LastError = 0x%lx",
|
|
WinErrorCode));
|
|
|
|
return HRESULT_FROM_ERROR_CODE(WinErrorCode);
|
|
}
|
|
|
|
LOG((MSP_TRACE, "CMediaPump::CreateThreadPump - finish"));
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
// add this filter to its wait array
|
|
HRESULT
|
|
CMediaPump::Register(
|
|
IN CMediaTerminalFilter *pFilter,
|
|
IN HANDLE hWaitEvent
|
|
)
|
|
{
|
|
LOG((MSP_TRACE, "CMediaPump::Register - enter"));
|
|
|
|
TM_ASSERT(NULL != pFilter);
|
|
TM_ASSERT(NULL != hWaitEvent);
|
|
BAIL_IF_NULL(pFilter, E_INVALIDARG);
|
|
BAIL_IF_NULL(hWaitEvent, E_INVALIDARG);
|
|
|
|
// check if the register event
|
|
if ( NULL == m_hRegisterBeginSemaphore )
|
|
{
|
|
LOG((MSP_ERROR,
|
|
"CMediaPump::Register - m_hRegisterBeginSemaphore is NULL"));
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
|
|
LONG lDebug;
|
|
|
|
// signal the register event, the pump thread will come out of the
|
|
// critical section and wait on m_hRegisterEndSemaphore
|
|
if ( !ReleaseSemaphore(m_hRegisterBeginSemaphore, 1, &lDebug) )
|
|
{
|
|
DWORD WinErrorCode = GetLastError();
|
|
|
|
LOG((MSP_ERROR,
|
|
"CMediaPump::Register - failed to release m_hRegisterBeginSemaphore. LastError = 0x%lx",
|
|
WinErrorCode));
|
|
|
|
return HRESULT_FROM_ERROR_CODE(WinErrorCode);
|
|
}
|
|
|
|
LOG((MSP_TRACE, "CMediaPump::Register - released begin semaphore - old count was %d", lDebug));
|
|
|
|
// when this SignalRegisterEnd instance is destroyed, it'll signal
|
|
// the end of registration and unblock the thread pump
|
|
//
|
|
// NOTE this releases the semaphore on DESTRUCTION of the class instance
|
|
|
|
RELEASE_SEMAPHORE_ON_DEST SignalRegisterEnd(m_hRegisterEndSemaphore);
|
|
|
|
HRESULT hr;
|
|
PUMP_LOCK LocalLock(&m_CritSec);
|
|
|
|
TM_ASSERT(m_EventArray.GetSize() == m_FilterInfoArray.GetSize());
|
|
|
|
// its possible that there is a duplicate in the array
|
|
// scenario - decommit signals the wait event but commit-register
|
|
// calls enter the critical section before the pump
|
|
|
|
DWORD Index;
|
|
if ( m_EventArray.Find(hWaitEvent, Index) )
|
|
{
|
|
LOG((MSP_TRACE, "CMediaPump::Register - event already registered"));
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
// check if we have reached the maximum allowed filters
|
|
// if we overflow, we must return a very specific error code here
|
|
// (See CMediaPumpPool)
|
|
if ( m_EventArray.GetSize() >= MAX_FILTERS )
|
|
{
|
|
LOG((MSP_ERROR, "CMediaPump::Register - reached max number of filters for this[%p] pump", this));
|
|
|
|
return TAPI_E_ALLOCATED;
|
|
}
|
|
|
|
|
|
// create CFilterInfo for holding the call parameters
|
|
|
|
CFilterInfo *pFilterInfo = new CFilterInfo(pFilter, hWaitEvent);
|
|
|
|
if (NULL == pFilterInfo)
|
|
{
|
|
LOG((MSP_ERROR, "CMediaPump::Register - failed to allocate CFilterInfo"));
|
|
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
|
|
//
|
|
// addref so the filterinfo structure we place into the array has refcount
|
|
// of one
|
|
//
|
|
|
|
pFilterInfo->AddRef();
|
|
|
|
// insert wait event into the array
|
|
hr = m_EventArray.Add(hWaitEvent);
|
|
if ( FAILED(hr) )
|
|
{
|
|
pFilterInfo->Release();
|
|
|
|
LOG((MSP_ERROR, "CMediaPump::Register - m_EventArray.Add failed hr = %lx", hr));
|
|
|
|
return hr;
|
|
}
|
|
|
|
// add a corresponding filter info entry
|
|
hr = m_FilterInfoArray.Add(pFilterInfo);
|
|
if ( FAILED(hr) )
|
|
{
|
|
m_EventArray.Remove(m_EventArray.GetSize()-1);
|
|
pFilterInfo->Release();
|
|
|
|
LOG((MSP_ERROR, "CMediaPump::Register - m_FilterInfoArray.Add failed hr = %lx", hr));
|
|
return hr;
|
|
}
|
|
|
|
// if this is the first entry into the array (beside the
|
|
// m_hRegisterBeginSemaphore, we need to create a thread pump
|
|
if (m_EventArray.GetSize() == 2)
|
|
{
|
|
hr = CreateThreadPump();
|
|
if ( FAILED(hr) )
|
|
{
|
|
RemoveFilter(m_EventArray.GetSize()-1);
|
|
|
|
LOG((MSP_ERROR, "CMediaPump::Register - CreateThreadPump failed hr = %lx", hr));
|
|
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
// ignore error code. if we have been decommitted in between, it will
|
|
// signal us through the wait event
|
|
pFilter->SignalRegisteredAtPump();
|
|
|
|
TM_ASSERT(m_EventArray.GetSize() == m_FilterInfoArray.GetSize());
|
|
|
|
|
|
LOG((MSP_TRACE, "CMediaPump::Register - exit"));
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
// remove this filter from wait array
|
|
|
|
HRESULT
|
|
CMediaPump::UnRegister(
|
|
IN HANDLE hWaitEvent
|
|
)
|
|
{
|
|
|
|
LOG((MSP_TRACE, "CMediaPump::Unregister[%p] - enter. Event[%p]",
|
|
this, hWaitEvent));
|
|
|
|
//
|
|
// if we did not get a valid event handle, debug
|
|
//
|
|
|
|
TM_ASSERT(NULL != hWaitEvent);
|
|
|
|
BAIL_IF_NULL(hWaitEvent, E_INVALIDARG);
|
|
|
|
|
|
//
|
|
// if we don't have register event, the pump is not properly initialized
|
|
//
|
|
|
|
if ( NULL == m_hRegisterBeginSemaphore )
|
|
{
|
|
|
|
LOG((MSP_ERROR,
|
|
"CMediaPump::Unregister[%p] - m_hRegisterBeginSemaphore is nUll. "
|
|
"pump is not initialized. returning E_FAIL - hWaitEvent=[%p]",
|
|
this, hWaitEvent));
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
|
|
LONG lDebugSemaphoreCount = 0;
|
|
|
|
// signal the register event, the pump thread will come out of the
|
|
// critical section and wait on m_hRegisterEndSemaphore
|
|
if ( !ReleaseSemaphore(m_hRegisterBeginSemaphore, 1, &lDebugSemaphoreCount) )
|
|
{
|
|
|
|
DWORD WinErrorCode = GetLastError();
|
|
|
|
LOG((MSP_ERROR,
|
|
"CMediaPump::Unregister - ReleaseSemaphore failed with LastError 0x%lx",
|
|
WinErrorCode));
|
|
|
|
return HRESULT_FROM_ERROR_CODE(WinErrorCode);
|
|
}
|
|
|
|
LOG((MSP_TRACE, "CMediaPump::UnRegister - released begin semaphore - old count was %d", lDebugSemaphoreCount));
|
|
|
|
|
|
// when this SignalRegisterEnd instance is destroyed, it'll signal
|
|
// the end of registration and unblock the thread pump
|
|
//
|
|
// NOTE this releases the semaphore on DESTRUCTION of the class instance
|
|
|
|
RELEASE_SEMAPHORE_ON_DEST SignalRegisterEnd(m_hRegisterEndSemaphore);
|
|
|
|
|
|
|
|
PUMP_LOCK LocalLock(&m_CritSec);
|
|
|
|
TM_ASSERT(m_EventArray.GetSize() == m_FilterInfoArray.GetSize());
|
|
|
|
|
|
//
|
|
// has this event been registered before
|
|
//
|
|
|
|
DWORD Index;
|
|
|
|
if ( !m_EventArray.Find(hWaitEvent, Index) )
|
|
{
|
|
|
|
LOG((MSP_TRACE,
|
|
"CMediaPump::UnRegister - event is not ours. returning E_FAIL. not an error."));
|
|
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
|
|
//
|
|
// found the filter that matches the event. remove the filter.
|
|
//
|
|
|
|
RemoveFilter(Index);
|
|
|
|
TM_ASSERT(m_EventArray.GetSize() == m_FilterInfoArray.GetSize());
|
|
|
|
|
|
LOG((MSP_TRACE, "CMediaPump::Unregister - finish."));
|
|
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
void
|
|
CMediaPump::RemoveFilter(
|
|
IN DWORD Index
|
|
)
|
|
{
|
|
|
|
PUMP_LOCK LocalLock(&m_CritSec);
|
|
|
|
|
|
//
|
|
// event array and filterinfo arrays must always be consistent
|
|
//
|
|
|
|
TM_ASSERT(m_EventArray.GetSize() == m_FilterInfoArray.GetSize());
|
|
|
|
|
|
//
|
|
// find the filter that needs to be removed -- it must exist
|
|
//
|
|
|
|
CFilterInfo *pFilterInfo = m_FilterInfoArray.Get(Index);
|
|
|
|
if (NULL == pFilterInfo)
|
|
{
|
|
|
|
LOG((MSP_ERROR,
|
|
"CMediaPump::RemoveFilter - filter %ld not found in filter array",
|
|
Index));
|
|
|
|
TM_ASSERT(FALSE);
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
//
|
|
// remove event and filter from the corresponding arrays
|
|
//
|
|
|
|
m_EventArray.Remove(Index);
|
|
m_FilterInfoArray.Remove(Index);
|
|
|
|
|
|
//
|
|
// remove filter from timer q and destroy it
|
|
//
|
|
|
|
LOG((MSP_TRACE,
|
|
"CMediaPump::RemoveFilter - removing filter[%ld] filterinfo[%p] from timerq",
|
|
Index,
|
|
pFilterInfo
|
|
));
|
|
|
|
m_TimerQueue.Remove(pFilterInfo);
|
|
|
|
pFilterInfo->Release();
|
|
|
|
|
|
TM_ASSERT(m_EventArray.GetSize() == m_FilterInfoArray.GetSize());
|
|
}
|
|
|
|
void
|
|
CMediaPump::RemoveFilter(
|
|
IN CFilterInfo *pFilterInfo
|
|
)
|
|
{
|
|
|
|
//
|
|
// find and remove should be atomic and need to be done in a lock
|
|
//
|
|
|
|
PUMP_LOCK LocalLock(&m_CritSec);
|
|
|
|
|
|
//
|
|
// find the array index
|
|
//
|
|
|
|
DWORD Index = 0;
|
|
|
|
if ( !m_FilterInfoArray.Find(pFilterInfo, Index) )
|
|
{
|
|
LOG((MSP_ERROR,
|
|
"CMediaPump::RemoveFilter - filter[%p] is not in the filterinfo array",
|
|
pFilterInfo));
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
//
|
|
// index found, remove the filter
|
|
//
|
|
|
|
RemoveFilter(Index);
|
|
}
|
|
|
|
|
|
void
|
|
CMediaPump::ServiceFilter(
|
|
IN CFilterInfo *pFilterInfo
|
|
)
|
|
{
|
|
if (NULL == pFilterInfo)
|
|
{
|
|
|
|
LOG((MSP_ERROR,
|
|
"CMediaPump::ServiceFilter - pFilterInfo is NULL"));
|
|
|
|
TM_ASSERT(FALSE);
|
|
|
|
return;
|
|
}
|
|
|
|
if (NULL == pFilterInfo->m_pFilter)
|
|
{
|
|
|
|
LOG((MSP_ERROR,
|
|
"CMediaPump::ServiceFilter - pFilterInfo->m_pFilter is NULL"));
|
|
|
|
TM_ASSERT(FALSE);
|
|
|
|
return;
|
|
}
|
|
|
|
DWORD dwTimeBeforeGetFilledBuffer = timeGetTime();
|
|
|
|
IMediaSample *pMediaSample;
|
|
DWORD NextTimeout;
|
|
CMediaTerminalFilter *pFilter = pFilterInfo->m_pFilter;
|
|
HRESULT hr = pFilter->GetFilledBuffer(
|
|
pMediaSample, NextTimeout
|
|
);
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
// if S_FALSE, nothing needs to be done
|
|
// its returned when we were signaled but there is no sample in
|
|
// the filter pool now.
|
|
// just continue to wait on event, no timeout needs to be scheduled
|
|
if ( S_FALSE == hr )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// if GetFilledBuffer could not get an output buffer from the sample
|
|
// queue, then there is no sample to deliver just yet, but we do
|
|
// need to schedule the next timeout.
|
|
|
|
if ( VFW_S_NO_MORE_ITEMS != hr )
|
|
{
|
|
LOG((MSP_TRACE, "CMediaPump::ServiceFilter - calling Receive on downstream filter"));
|
|
|
|
|
|
//
|
|
// ask filter to process this sample. if everything goes ok, the
|
|
// filter will pass the sample to a downstream connected pin
|
|
//
|
|
|
|
HRESULT hrReceived = pFilter->ProcessSample(pMediaSample);
|
|
|
|
LOG((MSP_TRACE, "CMediaPump::ServiceFilter - returned from Receive on downstream filter"));
|
|
|
|
if ( pFilter->m_bUsingMyAllocator )
|
|
{
|
|
CSample *pSample = ((CMediaSampleTM *)pMediaSample)->m_pSample;
|
|
|
|
pSample->m_bReceived = true;
|
|
|
|
if (hrReceived != S_OK)
|
|
{
|
|
LOG((MSP_TRACE,
|
|
"CMediaPump::ServiceFilter - downstream filter's ProcessSample returned 0x%08x. "
|
|
"Aborting I/O operation",
|
|
hrReceived));
|
|
|
|
pSample->m_MediaSampleIoStatus = E_ABORT;
|
|
}
|
|
}
|
|
|
|
pMediaSample->Release();
|
|
|
|
//
|
|
// Account for how long it took to get the buffer and call Receive
|
|
// on the sample.
|
|
//
|
|
|
|
DWORD dwTimeAfterReceive = timeGetTime();
|
|
|
|
DWORD dwServiceDuration;
|
|
|
|
if ( dwTimeAfterReceive >= dwTimeBeforeGetFilledBuffer )
|
|
{
|
|
dwServiceDuration =
|
|
dwTimeAfterReceive - dwTimeBeforeGetFilledBuffer;
|
|
}
|
|
else
|
|
{
|
|
dwServiceDuration = ( (DWORD) -1 )
|
|
- dwTimeBeforeGetFilledBuffer + dwTimeAfterReceive;
|
|
}
|
|
|
|
//
|
|
// Give it an extra 1 ms, just so we err on the side of caution.
|
|
// This won't cause us to fill up the buffers anytime soon.
|
|
//
|
|
|
|
dwServiceDuration++;
|
|
|
|
//
|
|
// Adjust the timeout.
|
|
//
|
|
|
|
if ( dwServiceDuration >= NextTimeout )
|
|
{
|
|
NextTimeout = 0;
|
|
}
|
|
else
|
|
{
|
|
NextTimeout -= dwServiceDuration;
|
|
}
|
|
|
|
LOG((MSP_TRACE, "CMediaPump::ServiceFilter - "
|
|
"timeout adjusted by %d ms; resulting timeout is %d ms",
|
|
dwServiceDuration, NextTimeout));
|
|
}
|
|
|
|
// if there is a valid timeout, schedule next timeout.
|
|
// otherwise, we'll get only signaled if a new sample is added or
|
|
// the filter is decommitted
|
|
//
|
|
// need to do this in a lock
|
|
//
|
|
|
|
PUMP_LOCK LocalLock(&m_CritSec);
|
|
|
|
|
|
//
|
|
// if the filter has not yet been unregistered, schedule next timeout
|
|
//
|
|
|
|
DWORD Index = 0;
|
|
|
|
if ( m_FilterInfoArray.Find(pFilterInfo, Index) )
|
|
{
|
|
|
|
//
|
|
// filter is still registered, schedule next timeout
|
|
//
|
|
|
|
pFilterInfo->ScheduleNextTimeout(m_TimerQueue, NextTimeout);
|
|
}
|
|
else
|
|
{
|
|
|
|
|
|
//
|
|
// filter was unregistered while we held critical section. this is
|
|
// ok, but we should no longer schedule the filter, since it will
|
|
// be deleted when this call returns and the filter is released.
|
|
//
|
|
|
|
LOG((MSP_TRACE,
|
|
"CMediaPump::ServiceFilter - filter[%p] is not in the filterinfo array",
|
|
pFilterInfo));
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
TM_ASSERT(FAILED(hr));
|
|
RemoveFilter(pFilterInfo);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
void
|
|
CMediaPump::DestroyFilterInfoArray(
|
|
)
|
|
{
|
|
for(DWORD i=1; i < m_FilterInfoArray.GetSize(); i++)
|
|
{
|
|
CFilterInfo *pFilterInfo = m_FilterInfoArray.Get(i);
|
|
TM_ASSERT(NULL != pFilterInfo);
|
|
delete pFilterInfo;
|
|
m_FilterInfoArray.Remove(i);
|
|
}
|
|
}
|
|
|
|
// waits for filter events to be activated. also waits
|
|
// for registration calls and timer events
|
|
HRESULT
|
|
CMediaPump::PumpMainLoop(
|
|
)
|
|
{
|
|
HRESULT hr;
|
|
|
|
// wait in a loop for the filter events to be set or for the timer
|
|
// events to be fired
|
|
DWORD TimeToWait = INFINITE;
|
|
DWORD ErrorCode;
|
|
BOOL InRegisterCall = FALSE;
|
|
|
|
SetThreadPriority(
|
|
GetCurrentThread(),
|
|
THREAD_PRIORITY_TIME_CRITICAL
|
|
);
|
|
do
|
|
{
|
|
|
|
// if a register call is in progress, wait for the call to signal
|
|
// us before proceeding to acquire the critical section
|
|
if ( InRegisterCall )
|
|
{
|
|
LOG((MSP_TRACE, "CMediaPump::PumpMainLoop - waiting for end semaphore"));
|
|
|
|
InRegisterCall = FALSE;
|
|
DWORD EndErrorCode = WaitForSingleObject(
|
|
m_hRegisterEndSemaphore,
|
|
INFINITE
|
|
);
|
|
if ( WAIT_OBJECT_0 != EndErrorCode )
|
|
{
|
|
LOG((MSP_ERROR,
|
|
"CMediaPump::PumpMainLoop - failed waiting for m_hRegisterEndSemaphore"));
|
|
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
|
|
//
|
|
// lock before accessing array
|
|
//
|
|
|
|
m_CritSec.Lock();
|
|
|
|
|
|
//
|
|
// see if the last filter was unregistered... if so, exit the thread.
|
|
//
|
|
|
|
if ( (1 == m_EventArray.GetSize()) )
|
|
{
|
|
|
|
m_CritSec.Unlock();
|
|
|
|
LOG((MSP_TRACE,
|
|
"CMediaPump::PumpMainLoop - a filter was unregistered. "
|
|
"no more filters. exiting thread"));
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
//
|
|
// if did not exit, keeping the lock
|
|
//
|
|
|
|
|
|
LOG((MSP_TRACE, "CMediaPump::PumpMainLoop - finished waiting for end semaphore"));
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
//
|
|
// grab pump lock before starting to wait for events
|
|
//
|
|
|
|
m_CritSec.Lock();
|
|
}
|
|
|
|
|
|
//
|
|
// we should have a lock at this point
|
|
//
|
|
|
|
|
|
TM_ASSERT(m_EventArray.GetSize() > 0);
|
|
TM_ASSERT(m_EventArray.GetSize() == \
|
|
m_FilterInfoArray.GetSize());
|
|
|
|
|
|
//
|
|
// calculate time until the thread should wake up
|
|
//
|
|
|
|
TimeToWait = m_TimerQueue.GetTimeToTimeout();
|
|
|
|
LOG((MSP_TRACE,
|
|
"CMediaPump::PumpMainLoop - starting waiting for array. timeout %lu",
|
|
TimeToWait));
|
|
|
|
|
|
//
|
|
// wait to be signaled or until a timeout
|
|
//
|
|
|
|
ErrorCode = WaitForMultipleObjects(
|
|
m_EventArray.GetSize(),
|
|
m_EventArray.GetData(),
|
|
FALSE, // don't wait for all
|
|
TimeToWait
|
|
);
|
|
|
|
C_ASSERT(WAIT_OBJECT_0 == 0);
|
|
|
|
if (WAIT_TIMEOUT == ErrorCode)
|
|
{
|
|
|
|
//
|
|
// filter timeout
|
|
//
|
|
|
|
TM_ASSERT(INFINITE != TimeToWait);
|
|
TM_ASSERT(!m_TimerQueue.IsEmpty());
|
|
|
|
LOG((MSP_TRACE, "CMediaPump::PumpMainLoop - timeout"));
|
|
|
|
CFilterInfo *pFilterInfo = m_TimerQueue.RemoveFirst();
|
|
|
|
|
|
if (NULL == pFilterInfo)
|
|
{
|
|
LOG((MSP_ERROR,
|
|
"CMediaPump::PumpMainLoop - m_TimerQueue.RemoveFirst returned NULL"));
|
|
|
|
TM_ASSERT(FALSE);
|
|
}
|
|
else
|
|
{
|
|
|
|
pFilterInfo->AddRef();
|
|
|
|
|
|
//
|
|
// release the lock while in ServiceFilter to avoid deadlock with
|
|
// CMediaPump__UnRegister
|
|
//
|
|
|
|
m_CritSec.Unlock();
|
|
|
|
ServiceFilter(pFilterInfo);
|
|
|
|
pFilterInfo->Release();
|
|
|
|
m_CritSec.Lock();
|
|
}
|
|
|
|
|
|
}
|
|
else if ( ErrorCode < (WAIT_OBJECT_0 + m_EventArray.GetSize()) )
|
|
{
|
|
LOG((MSP_TRACE, "CMediaPump::PumpMainLoop - signaled"));
|
|
|
|
DWORD nFilterInfoIndex = ErrorCode - WAIT_OBJECT_0;
|
|
|
|
if (0 == nFilterInfoIndex)
|
|
{
|
|
|
|
//
|
|
// m_hRegisterBeginSemaphore was signaled
|
|
//
|
|
|
|
InRegisterCall = TRUE;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// one of the filters was signaled
|
|
//
|
|
|
|
CFilterInfo *pFilterInfo = m_FilterInfoArray.Get(nFilterInfoIndex);
|
|
|
|
if (NULL == pFilterInfo)
|
|
{
|
|
LOG((MSP_ERROR,
|
|
"CMediaPump::PumpMainLoop - pFilterInfo at index %ld is NULL",
|
|
nFilterInfoIndex));
|
|
|
|
TM_ASSERT(FALSE);
|
|
}
|
|
else
|
|
{
|
|
|
|
pFilterInfo->AddRef();
|
|
|
|
|
|
//
|
|
// unlock while in ServiceFilter. we don't want to service
|
|
// filter in a lock to avoid deadlocks.
|
|
//
|
|
|
|
m_CritSec.Unlock();
|
|
|
|
ServiceFilter(pFilterInfo);
|
|
|
|
pFilterInfo->Release();
|
|
|
|
m_CritSec.Lock();
|
|
}
|
|
|
|
}
|
|
}
|
|
else if ( (WAIT_ABANDONED_0 <= ErrorCode) &&
|
|
(ErrorCode < (WAIT_ABANDONED_0 + m_EventArray.GetSize()) ) )
|
|
{
|
|
|
|
DWORD nFilterIndex = ErrorCode - WAIT_OBJECT_0;
|
|
|
|
LOG((MSP_TRACE,
|
|
"CMediaPump::PumpMainLoop - event 0x%lx abandoned. removing filter",
|
|
nFilterIndex));
|
|
|
|
// remove item from the arrays
|
|
RemoveFilter(nFilterIndex);
|
|
}
|
|
else
|
|
{
|
|
|
|
//
|
|
// something bad happened
|
|
//
|
|
|
|
DestroyFilterInfoArray();
|
|
|
|
m_CritSec.Unlock();
|
|
|
|
DWORD WinErrorCode = GetLastError();
|
|
|
|
LOG((MSP_ERROR,
|
|
"CMediaPump::PumpMainLoop - error %ld... exiting",
|
|
WinErrorCode));
|
|
|
|
return HRESULT_FROM_ERROR_CODE(WinErrorCode);
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// this check is performed here so that we detect the empty
|
|
// array and return, thus signaling the thread handle
|
|
//
|
|
// the case when InRegisterCall is on is not handled here -- we will
|
|
// check for the number of filters left after we have waited for the
|
|
// end event
|
|
//
|
|
|
|
if ( (1 == m_EventArray.GetSize()) && !InRegisterCall)
|
|
{
|
|
LOG((MSP_TRACE,
|
|
"CMediaPump::PumpMainLoop - no more filters in the array. exiting thread"));
|
|
|
|
m_CritSec.Unlock();
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
m_CritSec.Unlock();
|
|
|
|
}
|
|
while(1);
|
|
}
|
|
|
|
int CMediaPump::CountFilters()
|
|
{
|
|
LOG((MSP_TRACE, "CMediaPump::CountFilters[%p] - enter", this));
|
|
|
|
|
|
//
|
|
// one of the events is the registration event -- we need to account for
|
|
// it -- hence the -1
|
|
//
|
|
|
|
//
|
|
// note: it is ok to do this without locking media pump.
|
|
//
|
|
// the getsize operation is purely get, and it is ok if the value is
|
|
// sometimes misread -- this would lead to the new filter being distributed
|
|
// not in the most optimal fashion on extremely rare occasions. this slight
|
|
// abnormality in distribution will be corrected later as new filters are
|
|
// coming in.
|
|
//
|
|
// on the other hand, locking media pump to get filter count will lead to
|
|
// "deadlocks" (when main pump loop is sleeping, and nothing happens to
|
|
// wake it up), and it is not trivial to get around this deadlock condition
|
|
// without affecting performance. not locking the pump is a simple and very
|
|
// inexpensive way to accomplish the objective, with an acceptable
|
|
// trade-off.
|
|
//
|
|
|
|
int nFilters = m_EventArray.GetSize() - 1;
|
|
|
|
LOG((MSP_TRACE, "CMediaPump::CountFilters - exit. [%d] filters", nFilters));
|
|
|
|
return nFilters;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// ZoltanS: non-optimal, but relatively painless way to get around scalability
|
|
// limitation of 63 filters per pump thread. This class presents the same
|
|
// external interface as the single thread pump, but creates as many pump
|
|
// threads as are needed to serve the filters that are in use.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
CMediaPumpPool::CMediaPumpPool()
|
|
{
|
|
|
|
LOG((MSP_TRACE, "CMediaPumpPool::CMediaPumpPool - enter"));
|
|
|
|
|
|
//
|
|
// setting the default value. registry setting, if present, overwrites this
|
|
//
|
|
|
|
m_dwMaxNumberOfFilterPerPump = DEFAULT_MAX_FILTER_PER_PUMP;
|
|
|
|
|
|
LOG((MSP_TRACE, "CMediaPumpPool::CMediaPumpPool - exit"));
|
|
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Destructor: This destroys the individual pumps.
|
|
//
|
|
|
|
CMediaPumpPool::~CMediaPumpPool(void)
|
|
{
|
|
LOG((MSP_TRACE, "CMediaPumpPool::~CMediaPumpPool - enter"));
|
|
|
|
CLock lock(m_CritSection);
|
|
|
|
//
|
|
// Shut down and delete each CMediaPump; the array itself is
|
|
// cleaned up in its destructor.
|
|
//
|
|
|
|
int iSize = m_aPumps.GetSize();
|
|
|
|
for (int i = 0; i < iSize; i++ )
|
|
{
|
|
delete m_aPumps[i];
|
|
}
|
|
|
|
LOG((MSP_TRACE, "CMediaPumpPool::~CMediaPumpPool - exit"));
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CMediaPumpPool::CreatePumps
|
|
//
|
|
// this function creates the media pumps, the number of which is passed as an
|
|
// argument
|
|
//
|
|
|
|
HRESULT CMediaPumpPool::CreatePumps(int nPumpsToCreate)
|
|
{
|
|
LOG((MSP_TRACE, "CMediaPumpPool::CreatePumps - enter. nPumpsToCreate = [%d]", nPumpsToCreate));
|
|
|
|
|
|
for (int i = 0; i < nPumpsToCreate; i++)
|
|
{
|
|
|
|
//
|
|
// attempt to create a media pump
|
|
//
|
|
|
|
CMediaPump * pNewPump = new CMediaPump;
|
|
|
|
if ( pNewPump == NULL )
|
|
{
|
|
LOG((MSP_ERROR, "CMediaPumpPool::CreatePumps - "
|
|
"cannot create new media pump - "
|
|
"exit E_OUTOFMEMORY"));
|
|
|
|
//
|
|
// delete all the pumps we have created in this call
|
|
//
|
|
|
|
for (int j = i - 1; j >= 0; j--)
|
|
{
|
|
delete m_aPumps[j];
|
|
m_aPumps.RemoveAt(j);
|
|
}
|
|
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
|
|
//
|
|
// attempt to add the new media pump to the array of media pumps.
|
|
//
|
|
|
|
if ( ! m_aPumps.Add(pNewPump) )
|
|
{
|
|
LOG((MSP_ERROR, "CMediaPumpPool::CreatePumps - cannot add new media pump to array - exit E_OUTOFMEMORY"));
|
|
|
|
//
|
|
// delete all the pumps we have created in this call
|
|
//
|
|
|
|
delete pNewPump;
|
|
|
|
for (int j = i - 1; j >= 0; j--)
|
|
{
|
|
|
|
delete m_aPumps[j];
|
|
m_aPumps.RemoveAt(j);
|
|
}
|
|
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
|
|
LOG((MSP_TRACE, "CMediaPumpPool::CreatePumps - finished."));
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CMediaPumpPool::ReadRegistryValuesIfNeeded
|
|
//
|
|
// this function reads the registry setting for max number of filters per pump
|
|
// and in case of success, keeps the new value.
|
|
//
|
|
// this function is not thread safe. the caller must guarantee thread safety
|
|
//
|
|
|
|
HRESULT CMediaPumpPool::ReadRegistryValuesIfNeeded()
|
|
{
|
|
|
|
//
|
|
// we don't want to access registry more than once. so we have this static
|
|
// flag that helps us limit registry access
|
|
//
|
|
|
|
static bRegistryChecked = FALSE;
|
|
|
|
|
|
if (TRUE == bRegistryChecked)
|
|
{
|
|
|
|
//
|
|
// checked registry before. no need to do (or log) anything here
|
|
//
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
//
|
|
// we don't want to log until we know we will try to read registry
|
|
//
|
|
|
|
LOG((MSP_TRACE, "CMediaPumpPool::ReadRegistryValuesIfNeeded - enter"));
|
|
|
|
|
|
//
|
|
// whether we will succeed or fail, do not check the registry again
|
|
//
|
|
|
|
bRegistryChecked = TRUE;
|
|
|
|
|
|
//
|
|
// Open the registry key
|
|
//
|
|
|
|
HKEY hKey = 0;
|
|
|
|
LONG lResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
MST_REGISTRY_PATH,
|
|
0,
|
|
KEY_READ,
|
|
&hKey);
|
|
|
|
|
|
//
|
|
// did we manage to open the key?
|
|
//
|
|
|
|
if( ERROR_SUCCESS != lResult )
|
|
{
|
|
LOG((MSP_WARN, "CPTUtil::ReadRegistryValuesIfNeeded - "
|
|
"RegOpenKeyEx failed, returns E_FAIL"));
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
|
|
//
|
|
// read the value
|
|
//
|
|
|
|
DWORD dwMaxFiltersPerPump = 0;
|
|
|
|
DWORD dwDataSize = sizeof(DWORD);
|
|
|
|
lResult = RegQueryValueEx(
|
|
hKey,
|
|
MAX_FILTERS_PER_PUMP_KEY,
|
|
NULL,
|
|
NULL,
|
|
(LPBYTE) &dwMaxFiltersPerPump,
|
|
&dwDataSize
|
|
);
|
|
|
|
|
|
//
|
|
// don't need the key anymore
|
|
//
|
|
|
|
RegCloseKey(hKey);
|
|
hKey = NULL;
|
|
|
|
|
|
//
|
|
// any luck reading the value?
|
|
//
|
|
|
|
if( ERROR_SUCCESS != lResult )
|
|
{
|
|
LOG((MSP_WARN, "CPTUtil::ReadRegistryValuesIfNeeded - RegQueryValueEx failed, return E_FAIL"));
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
|
|
//
|
|
// got the value, keeping it.
|
|
//
|
|
|
|
m_dwMaxNumberOfFilterPerPump = dwMaxFiltersPerPump;
|
|
|
|
|
|
LOG((MSP_TRACE,
|
|
"CMediaPumpPool::ReadRegistryValuesIfNeeded - exit. MaxNumberOfFilterPerPump = %lx",
|
|
m_dwMaxNumberOfFilterPerPump));
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CMediaPumpPool::GetOptimalNumberOfPumps
|
|
//
|
|
// this function returns the number of pumps required to process all the
|
|
// filters that are currently being handled, plus the filter that is about to
|
|
// be registered
|
|
//
|
|
|
|
HRESULT CMediaPumpPool::GetOptimalNumberOfPumps(int *pnPumpsNeeded)
|
|
{
|
|
|
|
LOG((MSP_TRACE, "CMediaPumpPool::GetOptimalNumberOfPumps - enter"));
|
|
|
|
|
|
//
|
|
// if the argument is bad, it's a bug
|
|
//
|
|
|
|
if (IsBadWritePtr(pnPumpsNeeded, sizeof(int)))
|
|
{
|
|
LOG((MSP_ERROR,
|
|
"CMediaPumpPool::GetOptimalNumberOfPumps - pnPumpsNeeded[%p] is bad",
|
|
pnPumpsNeeded));
|
|
|
|
TM_ASSERT(FALSE);
|
|
|
|
return E_POINTER;
|
|
}
|
|
|
|
|
|
//
|
|
// calculate the total number of service filters
|
|
//
|
|
|
|
int nTotalExistingPumps = m_aPumps.GetSize();
|
|
|
|
|
|
//
|
|
// start with one filter (to adjust for the filter we are adding)
|
|
//
|
|
|
|
int nTotalFilters = 1;
|
|
|
|
for (int i = 0; i < nTotalExistingPumps; i++)
|
|
{
|
|
|
|
//
|
|
// note that the number of filters we get could be slightly higher then
|
|
// the real number, since the filters can be removed without involving
|
|
// pump pool (and thus getting its critical section). this is ok --
|
|
// the worst that will happen is that we will sometimes have more pumps
|
|
// then we really need.
|
|
//
|
|
|
|
nTotalFilters += m_aPumps[i]->CountFilters();
|
|
}
|
|
|
|
|
|
//
|
|
// calculated how many filters are being serviced
|
|
//
|
|
|
|
|
|
//
|
|
// what is the max number of filters a pump can service
|
|
//
|
|
|
|
DWORD dwMaxNumberOfFilterPerPump = GetMaxNumberOfFiltersPerPump();
|
|
|
|
|
|
//
|
|
// find the number of pumps needed to service all our filters
|
|
//
|
|
|
|
*pnPumpsNeeded = nTotalFilters / dwMaxNumberOfFilterPerPump;
|
|
|
|
|
|
//
|
|
// if the number of filters is not evenly divisible by the max number of
|
|
// filters serviced by a pump, we need to round up.
|
|
//
|
|
|
|
if ( 0 != (nTotalFilters % dwMaxNumberOfFilterPerPump) )
|
|
{
|
|
|
|
//
|
|
// uneven divide, roundup adjustment is necessary
|
|
//
|
|
|
|
*pnPumpsNeeded += 1;
|
|
}
|
|
|
|
|
|
//
|
|
// we have calculated the number of pumps needed to process all our filters
|
|
//
|
|
|
|
LOG((MSP_TRACE,
|
|
"CMediaPumpPool::GetOptimalNumberOfPumps - exit. [%d] filters should be serviced by [%d] pump(s)",
|
|
nTotalFilters, *pnPumpsNeeded));
|
|
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CMediaPumpPool::PickThePumpToUse
|
|
//
|
|
// this method chooses the pump that should be used to service the new filter
|
|
// the pump is picked based on the load and the number of pumps needed to
|
|
// service all pf the current filters
|
|
//
|
|
|
|
|
|
HRESULT CMediaPumpPool::PickThePumpToUse(int *pPumpToUse)
|
|
{
|
|
|
|
LOG((MSP_TRACE, "CMediaPumpPool::PickThePumpToUse - enter"));
|
|
|
|
|
|
//
|
|
// if the argument is bad, it's a bug
|
|
//
|
|
|
|
if (IsBadWritePtr(pPumpToUse, sizeof(int)))
|
|
{
|
|
LOG((MSP_ERROR, "CMediaPumpPool::PickThePumpToUse - pPumpToUse[%p] is bad", pPumpToUse));
|
|
|
|
TM_ASSERT(FALSE);
|
|
|
|
return E_POINTER;
|
|
}
|
|
|
|
|
|
//
|
|
// calculate the optimal number of pumps needed for the current number of filters
|
|
//
|
|
|
|
int nPumpsNeeded = 0;
|
|
|
|
HRESULT hr = GetOptimalNumberOfPumps(&nPumpsNeeded);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
LOG((MSP_ERROR,
|
|
"CMediaPumpPool::PickThePumpToUse - GetOptimalNumberOfPumps failed hr = [%lx]",
|
|
hr));
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
//
|
|
// if we don't have enough pumps, create more
|
|
//
|
|
|
|
int nTotalExistingPumps = m_aPumps.GetSize();
|
|
|
|
if (nTotalExistingPumps < nPumpsNeeded)
|
|
{
|
|
|
|
//
|
|
// this is how many more pumps we need to create
|
|
//
|
|
|
|
int nNewPumpsToCreate = nPumpsNeeded - nTotalExistingPumps;
|
|
|
|
|
|
//
|
|
// we will never need to create more than one new pump at a time
|
|
//
|
|
|
|
TM_ASSERT(1 == nNewPumpsToCreate);
|
|
|
|
|
|
//
|
|
// special case if we currently don't have any pumps -- create one pump
|
|
// for each processor. this will help us scale on symmetric
|
|
// multiprocessor machines.
|
|
//
|
|
|
|
if (0 == nTotalExistingPumps)
|
|
{
|
|
|
|
//
|
|
// get the number of processors. according to documentation,
|
|
// GetSystemInfo cannot fail, so there is return code to check
|
|
//
|
|
|
|
SYSTEM_INFO SystemInfo;
|
|
|
|
GetSystemInfo(&SystemInfo);
|
|
|
|
|
|
//
|
|
// we will want to create at least as many new pumps as we have
|
|
// processors, but maybe more if needed
|
|
//
|
|
//
|
|
// note: we may also want to look at the affinity mask, it may
|
|
// tell us how many CPUs are actually used
|
|
//
|
|
|
|
int nNumberOfProcessors = SystemInfo.dwNumberOfProcessors;
|
|
|
|
if (nNewPumpsToCreate < nNumberOfProcessors)
|
|
{
|
|
|
|
nNewPumpsToCreate = SystemInfo.dwNumberOfProcessors;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// we now have all the information needed to create the pumps we need.
|
|
//
|
|
|
|
hr = CreatePumps(nNewPumpsToCreate);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
LOG((MSP_ERROR,
|
|
"CMediaPumpPool::PickThePumpToUse - CreatePumps failed hr = [%lx]",
|
|
hr));
|
|
|
|
return hr;
|
|
|
|
}
|
|
|
|
|
|
LOG((MSP_TRACE, "CMediaPumpPool::PickThePumpToUse - create [%d] pumps", nNewPumpsToCreate));
|
|
}
|
|
|
|
|
|
//
|
|
// walk trough the pumps (only use pumps starting from the first N pumps,
|
|
// N being the number of pumps needed to service the number of filters that
|
|
// we are servicing
|
|
//
|
|
|
|
|
|
nTotalExistingPumps = m_aPumps.GetSize();
|
|
|
|
|
|
int nLowestLoad = INT_MAX;
|
|
int nLowestLoadPumpIndex = -1;
|
|
|
|
|
|
for (int nPumpIndex = 0; nPumpIndex < nTotalExistingPumps; nPumpIndex++)
|
|
{
|
|
|
|
int nNumberOfFiltersAtPump = 0;
|
|
|
|
|
|
//
|
|
// how many filters is this pump serving?
|
|
//
|
|
|
|
nNumberOfFiltersAtPump = m_aPumps[nPumpIndex]->CountFilters();
|
|
|
|
|
|
//
|
|
// if the pump we are looking at has less load then any of the
|
|
// previously evaluated pumps, remember it. if we don't find anything
|
|
// better, this is what we will use.
|
|
//
|
|
|
|
if (nNumberOfFiltersAtPump < nLowestLoad)
|
|
{
|
|
|
|
nLowestLoadPumpIndex = nPumpIndex;
|
|
nLowestLoad = nNumberOfFiltersAtPump;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// we had to get something!
|
|
//
|
|
|
|
if (-1 == nLowestLoadPumpIndex)
|
|
{
|
|
LOG((MSP_ERROR,
|
|
"CMediaPumpPool::PickThePumpToUse - did not find a pump to use"));
|
|
|
|
|
|
//
|
|
// we have a bug -- need to investigate
|
|
//
|
|
|
|
TM_ASSERT(FALSE);
|
|
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
|
|
//
|
|
// we found a pump to use
|
|
//
|
|
|
|
*pPumpToUse = nLowestLoadPumpIndex;
|
|
|
|
|
|
LOG((MSP_TRACE,
|
|
"CMediaPumpPool::PickThePumpToUse - finish. using pump %d, current load %d",
|
|
*pPumpToUse, nLowestLoad));
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Register: This delegates to the individual pumps, creating new ones as
|
|
// needed.
|
|
//
|
|
|
|
HRESULT CMediaPumpPool::Register(
|
|
IN CMediaTerminalFilter *pFilter,
|
|
IN HANDLE hWaitEvent
|
|
)
|
|
{
|
|
LOG((MSP_TRACE, "CMediaPumpPool::Register - enter"));
|
|
|
|
|
|
CLock lock(m_CritSection);
|
|
|
|
|
|
//
|
|
// find the pump with which to register filter
|
|
//
|
|
|
|
int nPumpToUse = 0;
|
|
|
|
HRESULT hr = PickThePumpToUse(&nPumpToUse);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
LOG((MSP_ERROR,
|
|
"CMediaPumpPool::Register - failed to find the pump to be used to service the new filter, hr = [%lx]",
|
|
hr));
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
//
|
|
// just to be on the safe side, make sure the index we got makes sense
|
|
//
|
|
|
|
int nTotalPumps = m_aPumps.GetSize();
|
|
|
|
if (nTotalPumps - 1 < nPumpToUse)
|
|
{
|
|
LOG((MSP_ERROR,
|
|
"CMediaPumpPool::Register - PickThePumpToUse return bad pump index [%d]",
|
|
nPumpToUse));
|
|
|
|
TM_ASSERT(FALSE);
|
|
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
|
|
//
|
|
// ok, all is well, register with the pump
|
|
//
|
|
|
|
hr = m_aPumps[nPumpToUse]->Register(pFilter, hWaitEvent);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
LOG((MSP_ERROR,
|
|
"CMediaPumpPool::Register - failed to register with pump [%d] at [%p]",
|
|
nPumpToUse, m_aPumps[nPumpToUse]));
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
LOG((MSP_TRACE, "CMediaPumpPool::Register - finished"));
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// UnRegister: Unregister filter. This delegates to the individual pumps
|
|
//
|
|
|
|
HRESULT CMediaPumpPool::UnRegister(
|
|
IN HANDLE hWaitEvent
|
|
)
|
|
{
|
|
|
|
LOG((MSP_TRACE, "CMediaPumpPool::UnRegister - enter"));
|
|
|
|
|
|
HRESULT hr = E_FAIL;
|
|
|
|
|
|
//
|
|
// All of this is done within a single critical section, to
|
|
// synchronize access to our array
|
|
//
|
|
|
|
CLock lock(m_CritSection);
|
|
|
|
|
|
//
|
|
// try to unregister from a pump thread in the array
|
|
//
|
|
|
|
int iSize = m_aPumps.GetSize();
|
|
|
|
for (int i = 0; i < iSize; i++ )
|
|
{
|
|
|
|
//
|
|
// Try to unregister from this pump thread.
|
|
//
|
|
|
|
hr = m_aPumps[i]->UnRegister(hWaitEvent);
|
|
|
|
|
|
//
|
|
// If succeeded unregistering from this pump, then we are done.
|
|
// Otherwise just try the next one.
|
|
//
|
|
|
|
if ( hr == S_OK )
|
|
{
|
|
LOG((MSP_TRACE,
|
|
"CMediaPumpPool::UnRegister - unregistered with media pump %d",
|
|
i));
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
LOG((MSP_TRACE,
|
|
"CMediaPumpPool::UnRegister - exit. hr = 0x%08x", hr));
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
//
|
|
// eof
|
|
//
|