935 lines
21 KiB
C++
935 lines
21 KiB
C++
/*
|
|
DATAPUMP.C
|
|
*/
|
|
|
|
#include "precomp.h"
|
|
#include "confreg.h"
|
|
#include "mixer.h"
|
|
#include "dscStream.h"
|
|
|
|
extern UINT g_MinDSEmulAudioDelayMs; // minimum millisecs of introduced playback delay (DirectSound on emulated drivers)
|
|
extern UINT g_MinWaveAudioDelayMs; // minimum millisecs of introduced playback delay (Wave)
|
|
extern UINT g_MaxAudioDelayMs; // maximum milliesecs of introduced playback delay
|
|
extern UINT g_AudioPacketDurationMs; // preferred packet duration
|
|
|
|
extern int g_wavein_prepare, g_waveout_prepare;
|
|
extern int g_videoin_prepare, g_videoout_prepare;
|
|
|
|
#define RSVP_KEY TEXT("RSVP")
|
|
|
|
HANDLE g_hEventHalfDuplex = NULL;
|
|
|
|
HWND DataPump::m_hAppWnd = NULL;
|
|
HINSTANCE DataPump::m_hAppInst = NULL;
|
|
|
|
|
|
HRESULT WINAPI CreateStreamProvider(IMediaChannelBuilder **lplpSP)
|
|
{
|
|
DataPump * pDataPump;
|
|
if(!lplpSP)
|
|
return DPR_INVALID_PARAMETER;
|
|
|
|
DBG_SAVE_FILE_LINE
|
|
pDataPump = new DataPump;
|
|
if(NULL == pDataPump)
|
|
return DPR_OUT_OF_MEMORY;
|
|
|
|
// the refcount of DataPump is 1. Don't call pDataPump->QueryInterface(),
|
|
// just do what QueryInterface() would do except don't increment refcount
|
|
*lplpSP = (IMediaChannelBuilder *)pDataPump;
|
|
return hrSuccess;
|
|
}
|
|
|
|
|
|
DataPump::DataPump(void)
|
|
:m_uRef(1)
|
|
{
|
|
ClearStruct( &m_Audio );
|
|
ClearStruct( &m_Video );
|
|
InitializeCriticalSection(&m_crs);
|
|
|
|
// Create performance counters
|
|
InitCountersAndReports();
|
|
}
|
|
|
|
DataPump::~DataPump(void)
|
|
{
|
|
ReleaseResources();
|
|
|
|
WSACleanup();
|
|
DeleteCriticalSection(&m_crs);
|
|
|
|
// We're done with performance counters
|
|
DoneCountersAndReports();
|
|
}
|
|
|
|
HRESULT __stdcall DataPump::Initialize(HWND hWnd, HINSTANCE hInst)
|
|
{
|
|
HRESULT hr = DPR_OUT_OF_MEMORY;
|
|
FX_ENTRY ("DP::Init")
|
|
WSADATA WSAData;
|
|
int status;
|
|
BOOL fDisableWS2;
|
|
UINT uMinDelay;
|
|
TCHAR *szKey = NACOBJECT_KEY TEXT("\\") RSVP_KEY;
|
|
RegEntry reRSVP(szKey, HKEY_LOCAL_MACHINE, FALSE);
|
|
|
|
if((NULL == hWnd) || (NULL == hInst))
|
|
goto InitError;
|
|
|
|
m_hAppInst = hInst;
|
|
m_hAppWnd = hWnd;
|
|
|
|
status = WSAStartup(MAKEWORD(1,1), &WSAData);
|
|
if(status !=0)
|
|
{
|
|
ERRORMESSAGE(("CNac::Init:WSAStartup failed\r\n"));
|
|
goto InitError;
|
|
}
|
|
|
|
// Introduce scope to allow creation of object after goto statements
|
|
{
|
|
|
|
// get settings from registry
|
|
RegEntry reNac(szRegInternetPhone TEXT("\\") szRegInternetPhoneNac,
|
|
HKEY_LOCAL_MACHINE,
|
|
FALSE,
|
|
KEY_READ);
|
|
|
|
g_MaxAudioDelayMs = reNac.GetNumberIniStyle(TEXT ("MaxAudioDelayMs"), g_MaxAudioDelayMs);
|
|
|
|
uMinDelay = reNac.GetNumberIniStyle(TEXT ("MinAudioDelayMs"), 0);
|
|
|
|
if (uMinDelay != 0)
|
|
{
|
|
g_MinWaveAudioDelayMs = uMinDelay;
|
|
g_MinDSEmulAudioDelayMs = uMinDelay;
|
|
}
|
|
|
|
fDisableWS2 = reNac.GetNumberIniStyle(TEXT ("DisableWinsock2"), 0);
|
|
|
|
}
|
|
#ifdef OLDSTUFF
|
|
// to be safe, only try loading WS2_32 if WSOCK32 is passing
|
|
// thru to it. Once we make sure that we link to the same DLL for all
|
|
// Winsock calls to a socket, this check can possibly be removed.
|
|
if (LOBYTE(WSAData.wHighVersion) >= 2 && !fDisableWS2)
|
|
TryLoadWinsock2();
|
|
#endif
|
|
// Initialize data (should be in constructor)
|
|
|
|
g_hEventHalfDuplex = CreateEvent (NULL, FALSE, TRUE, __TEXT ("AVC:HalfDuplex"));
|
|
if (g_hEventHalfDuplex == NULL)
|
|
{
|
|
DEBUGMSG (ZONE_DP, ("%s: CreateEvent failed, LastErr=%lu\r\n", _fx_, GetLastError ()));
|
|
hr = DPR_CANT_CREATE_EVENT;
|
|
return hr;
|
|
}
|
|
|
|
// Initialize QoS. If it fails, that's Ok, we'll do without it.
|
|
// No need to set the resource ourselves, this now done by the UI
|
|
hr = CreateQoS (NULL, IID_IQoS, (void **)&m_pIQoS);
|
|
if (hr != DPR_SUCCESS)
|
|
m_pIQoS = (LPIQOS)NULL;
|
|
|
|
m_bDisableRSVP = reRSVP.GetNumber("DisableRSVP", FALSE);
|
|
|
|
|
|
LogInit(); // Initialize log
|
|
|
|
//No receive channels yet
|
|
m_nReceivers=0;
|
|
|
|
// IVideoDevice initialize
|
|
m_uVideoCaptureId = -1; // (VIDEO_MAPPER)
|
|
|
|
// IAudioDevice initialize
|
|
m_uWaveInID = WAVE_MAPPER;
|
|
m_uWaveOutID = WAVE_MAPPER;
|
|
m_bFullDuplex = FALSE;
|
|
m_uSilenceLevel = 1000; // automatic silence detection
|
|
m_bAutoMix = FALSE;
|
|
m_bDirectSound = FALSE;
|
|
|
|
|
|
return DPR_SUCCESS;
|
|
|
|
InitError:
|
|
ERRORMESSAGE( ("DataPump::Initialize: exit, hr=0x%lX\r\n", hr));
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
DataPump::CreateMediaChannel( UINT flags, IMediaChannel **ppIMC)
|
|
{
|
|
IUnknown *pUnkOuter = NULL;
|
|
IMediaChannel *pStream = NULL;
|
|
HRESULT hr = E_FAIL;
|
|
|
|
// try to be consistant about which parent classes we cast to
|
|
|
|
*ppIMC = NULL;
|
|
|
|
|
|
if (flags & MCF_AUDIO)
|
|
{
|
|
if ((flags & MCF_SEND) && !m_Audio.pSendStream)
|
|
{
|
|
if (m_bDirectSound && (DSC_Manager::Initialize() == S_OK))
|
|
{
|
|
DBG_SAVE_FILE_LINE
|
|
pStream = (IMediaChannel*)(SendMediaStream*)new SendDSCStream;
|
|
}
|
|
else
|
|
{
|
|
DBG_SAVE_FILE_LINE
|
|
pStream = (IMediaChannel*)(SendMediaStream*)new SendAudioStream;
|
|
}
|
|
|
|
}
|
|
else if ((flags & MCF_RECV) && !m_Audio.pRecvStream)
|
|
{
|
|
if (m_bDirectSound && (DirectSoundMgr::Initialize() == S_OK))
|
|
{
|
|
DBG_SAVE_FILE_LINE
|
|
pStream = (IMediaChannel*)(RecvMediaStream*)new RecvDSAudioStream;
|
|
}
|
|
else
|
|
{
|
|
DBG_SAVE_FILE_LINE
|
|
pStream = (IMediaChannel*)(RecvMediaStream*)new RecvAudioStream;
|
|
}
|
|
}
|
|
}
|
|
else if (flags & MCF_VIDEO)
|
|
{
|
|
if ((flags & MCF_SEND) && !m_Video.pSendStream)
|
|
{
|
|
DBG_SAVE_FILE_LINE
|
|
pStream = (IMediaChannel*)(SendMediaStream*) new SendVideoStream;
|
|
}
|
|
else if ((flags & MCF_RECV) && !m_Video.pRecvStream)
|
|
{
|
|
DBG_SAVE_FILE_LINE
|
|
pStream = (IMediaChannel*)(RecvMediaStream*) new RecvVideoStream;
|
|
}
|
|
}
|
|
else
|
|
hr = E_INVALIDARG;
|
|
|
|
if (pStream != NULL) {
|
|
// need to inc the refCount of the object
|
|
pStream->AddRef();
|
|
|
|
hr = (flags & MCF_SEND) ?
|
|
((SendMediaStream *)pStream)->Initialize( this)
|
|
: ((RecvMediaStream *)pStream)->Initialize(this);
|
|
|
|
if (hr == S_OK)
|
|
{
|
|
hr = pStream->QueryInterface(IID_IMediaChannel, (void **)ppIMC);
|
|
}
|
|
if (hr == S_OK)
|
|
{
|
|
AddMediaChannel(flags, pStream);
|
|
}
|
|
|
|
|
|
// calling to the IVideoDevice and IAudioDevice methods
|
|
// prior to creating the corresponding channel object
|
|
// require when they get created
|
|
|
|
// video only needs it's device ID set
|
|
if ((flags & MCF_SEND) && (flags & MCF_VIDEO))
|
|
{
|
|
SetCurrCapDevID(m_uVideoCaptureId);
|
|
}
|
|
|
|
// audio streams need several properties set
|
|
if (flags & MCF_AUDIO)
|
|
{
|
|
if (flags & MCF_SEND)
|
|
{
|
|
SetSilenceLevel(m_uSilenceLevel);
|
|
SetAutoMix(m_bAutoMix);
|
|
SetRecordID(m_uWaveInID);
|
|
}
|
|
else if (flags & MCF_RECV)
|
|
{
|
|
SetPlaybackID(m_uWaveOutID);
|
|
}
|
|
SetStreamDuplex(pStream, m_bFullDuplex);
|
|
}
|
|
|
|
// to avoid a circular ref-count,
|
|
// dont keep a hard reference to MediaChannel objects
|
|
// MediaChannel will call RemoveMediaChannel before it goes away..
|
|
pStream->Release();
|
|
pStream = NULL;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP DataPump::SetStreamEventObj(IStreamEventNotify *pNotify)
|
|
{
|
|
|
|
EnterCriticalSection(&m_crs);
|
|
|
|
if (m_pTEP)
|
|
{
|
|
delete m_pTEP;
|
|
m_pTEP = NULL;
|
|
}
|
|
|
|
if (pNotify)
|
|
{
|
|
DBG_SAVE_FILE_LINE
|
|
m_pTEP = new ThreadEventProxy(pNotify, m_hAppInst);
|
|
}
|
|
|
|
LeaveCriticalSection(&m_crs);
|
|
|
|
return S_OK;
|
|
|
|
}
|
|
|
|
|
|
// this function gets called by the stream threads when an event occurs
|
|
STDMETHODIMP DataPump::StreamEvent(UINT uDirection, UINT uMediaType,
|
|
UINT uEventType, UINT uSubCode)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
|
|
EnterCriticalSection(&m_crs);
|
|
|
|
if (m_pTEP)
|
|
{
|
|
bRet = m_pTEP->ThreadEvent(uDirection, uMediaType, uEventType, uSubCode);
|
|
}
|
|
|
|
LeaveCriticalSection(&m_crs);
|
|
|
|
return bRet ? DPR_INVALID_PARAMETER : DPR_SUCCESS;
|
|
}
|
|
|
|
|
|
void
|
|
DataPump::AddMediaChannel(UINT flags, IMediaChannel *pMediaChannel)
|
|
{
|
|
EnterCriticalSection(&m_crs);
|
|
if (flags & MCF_SEND)
|
|
{
|
|
SendMediaStream *pS = static_cast<SendMediaStream *> (pMediaChannel);
|
|
if (flags & MCF_AUDIO)
|
|
m_Audio.pSendStream = pS;
|
|
else if (flags & MCF_VIDEO)
|
|
m_Video.pSendStream = pS;
|
|
}
|
|
else if (flags & MCF_RECV)
|
|
{
|
|
RecvMediaStream *pR = static_cast<RecvMediaStream *> (pMediaChannel);
|
|
if (flags & MCF_AUDIO)
|
|
m_Audio.pRecvStream = pR;
|
|
else if (flags & MCF_VIDEO)
|
|
m_Video.pRecvStream = pR;
|
|
}
|
|
LeaveCriticalSection(&m_crs);
|
|
}
|
|
|
|
void
|
|
DataPump::RemoveMediaChannel(UINT flags, IMediaChannel *pMediaChannel)
|
|
{
|
|
EnterCriticalSection(&m_crs);
|
|
if (flags & MCF_SEND)
|
|
{
|
|
if (flags & MCF_AUDIO)
|
|
{
|
|
ASSERT(pMediaChannel == m_Audio.pSendStream);
|
|
if (pMediaChannel == m_Audio.pSendStream)
|
|
m_Audio.pSendStream = NULL;
|
|
}
|
|
else if (flags & MCF_VIDEO)
|
|
{
|
|
ASSERT(pMediaChannel == m_Video.pSendStream);
|
|
m_Video.pSendStream = NULL;
|
|
}
|
|
}
|
|
else if (flags & MCF_RECV)
|
|
{
|
|
if (flags & MCF_AUDIO)
|
|
{
|
|
ASSERT(pMediaChannel == m_Audio.pRecvStream);
|
|
m_Audio.pRecvStream = NULL;
|
|
}
|
|
else if (flags & MCF_VIDEO)
|
|
{
|
|
ASSERT(pMediaChannel == m_Video.pRecvStream);
|
|
m_Video.pRecvStream = NULL;
|
|
}
|
|
}
|
|
LeaveCriticalSection(&m_crs);
|
|
|
|
}
|
|
|
|
// called by Record Thread and Receive Thread, usually to get the
|
|
// opposite channel
|
|
HRESULT DataPump::GetMediaChannelInterface( UINT flags, IMediaChannel **ppI)
|
|
{
|
|
// extern IID IID_IMediaChannel;
|
|
|
|
IMediaChannel *pStream = NULL;
|
|
|
|
HRESULT hr;
|
|
EnterCriticalSection(&m_crs);
|
|
if (flags & MCF_AUDIO) {
|
|
if (flags & MCF_SEND) {
|
|
pStream = m_Audio.pSendStream;
|
|
} else if (flags & MCF_RECV) {
|
|
pStream = m_Audio.pRecvStream;
|
|
}
|
|
}
|
|
else if (flags & MCF_VIDEO) {
|
|
if (flags & MCF_SEND) {
|
|
pStream = m_Video.pSendStream;
|
|
} else if (flags & MCF_RECV) {
|
|
pStream = m_Video.pRecvStream;
|
|
}
|
|
} else
|
|
hr = DPR_INVALID_PARAMETER;
|
|
if (pStream) {
|
|
// need to inc the refCount of the object
|
|
hr = (pStream)->QueryInterface(IID_IMediaChannel, (PVOID *)ppI);
|
|
} else
|
|
hr = E_NOINTERFACE;
|
|
LeaveCriticalSection(&m_crs);
|
|
return hr;
|
|
}
|
|
|
|
|
|
DWORD __stdcall StartDPRecvThread(PVOID pVoid)
|
|
{
|
|
DataPump *pDP = (DataPump*)pVoid;
|
|
return pDP->CommonWS2RecvThread();
|
|
}
|
|
|
|
|
|
|
|
STDMETHODIMP DataPump::QueryInterface( REFIID iid, void ** ppvObject)
|
|
{
|
|
// this breaks the rules for the official COM QueryInterface because
|
|
// the interfaces that are queried for are not necessarily real COM
|
|
// interfaces. The reflexive property of QueryInterface would be broken in
|
|
// that case.
|
|
HRESULT hr = E_NOINTERFACE;
|
|
if(!ppvObject)
|
|
return hr;
|
|
|
|
*ppvObject = NULL;
|
|
if(iid == IID_IUnknown)// satisfy symmetric property of QI
|
|
{
|
|
*ppvObject = this;
|
|
hr = hrSuccess;
|
|
AddRef();
|
|
}
|
|
else if(iid == IID_IMediaChannelBuilder)
|
|
{
|
|
*ppvObject = (IMediaChannelBuilder *)this;
|
|
hr = hrSuccess;
|
|
AddRef();
|
|
}
|
|
else if (iid == IID_IVideoDevice)
|
|
{
|
|
*ppvObject = (IVideoDevice *)this;
|
|
hr = hrSuccess;
|
|
AddRef();
|
|
}
|
|
|
|
else if (iid == IID_IAudioDevice)
|
|
{
|
|
*ppvObject = (IAudioDevice*)this;
|
|
hr = hrSuccess;
|
|
AddRef();
|
|
}
|
|
|
|
return (hr);
|
|
}
|
|
ULONG DataPump::AddRef()
|
|
{
|
|
m_uRef++;
|
|
return m_uRef;
|
|
}
|
|
|
|
ULONG DataPump::Release()
|
|
{
|
|
m_uRef--;
|
|
if(m_uRef == 0)
|
|
{
|
|
m_hAppWnd = NULL;
|
|
m_hAppInst = NULL;
|
|
delete this;
|
|
return 0;
|
|
}
|
|
return m_uRef;
|
|
}
|
|
|
|
|
|
void
|
|
DataPump::ReleaseResources()
|
|
{
|
|
FX_ENTRY ("DP::ReleaseResources")
|
|
|
|
#ifdef DEBUG
|
|
if (m_Audio.pSendStream)
|
|
ERRORMESSAGE(("%s: Audio Send stream still around => Ref count LEAK!\n", _fx_));
|
|
if (m_Audio.pRecvStream)
|
|
ERRORMESSAGE(("%s: Audio Recv stream still around => Ref count LEAK!\n", _fx_));
|
|
if (m_Video.pSendStream)
|
|
ERRORMESSAGE(("%s: Video Send stream still around => Ref count LEAK!\n", _fx_));
|
|
if (m_Video.pRecvStream)
|
|
ERRORMESSAGE(("%s: Video Recv stream still around => Ref count LEAK!\n", _fx_));
|
|
#endif
|
|
|
|
// close debug log
|
|
LogClose();
|
|
|
|
// Free QoS resources
|
|
if (m_pIQoS)
|
|
{
|
|
m_pIQoS->Release();
|
|
m_pIQoS = (LPIQOS)NULL;
|
|
}
|
|
|
|
// Close the receive and transmit streams
|
|
if (g_hEventHalfDuplex)
|
|
{
|
|
CloseHandle (g_hEventHalfDuplex);
|
|
g_hEventHalfDuplex = NULL;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
HRESULT DataPump::SetStreamDuplex(IMediaChannel *pStream, BOOL bFullDuplex)
|
|
{
|
|
BOOL fOn = (pStream->GetState() == MSSTATE_STARTED);
|
|
BOOL bStreamFullDuplex;
|
|
UINT uSize = sizeof(BOOL);
|
|
|
|
pStream->GetProperty(PROP_DUPLEX_TYPE, &bStreamFullDuplex, &uSize);
|
|
|
|
if (bStreamFullDuplex != bFullDuplex)
|
|
{
|
|
if (fOn)
|
|
{
|
|
pStream->Stop();
|
|
}
|
|
|
|
pStream->SetProperty(DP_PROP_DUPLEX_TYPE, &bFullDuplex, sizeof(BOOL));
|
|
|
|
if (fOn)
|
|
{
|
|
pStream->Start();
|
|
}
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
HRESULT __stdcall DataPump::SetDuplex(BOOL bFullDuplex)
|
|
{
|
|
IMediaChannel *pS = m_Audio.pSendStream;
|
|
IMediaChannel *pR = m_Audio.pRecvStream;
|
|
IMediaChannel *pStream;
|
|
BOOL fPlayOn = FALSE;
|
|
BOOL fRecOn = FALSE;
|
|
UINT uSize;
|
|
BOOL bRecDuplex, bPlayDuplex;
|
|
|
|
m_bFullDuplex = bFullDuplex ? TRUE : FALSE;
|
|
|
|
UPDATE_REPORT_ENTRY(g_prptSystemSettings, (m_bFullDuplex) ? 1 : 0, REP_SYS_AUDIO_DUPLEX);
|
|
RETAILMSG(("NAC: Audio Duplex Type: %s",(m_bFullDuplex) ? "Full Duplex" : "Half Duplex"));
|
|
|
|
|
|
// no streams ? No problem.
|
|
if ((pS == NULL) && (pR == NULL))
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
// only one stream
|
|
if ((pS || pR) && !(pS && pR))
|
|
{
|
|
if (pS)
|
|
pStream = pS;
|
|
else
|
|
pStream = pR;
|
|
|
|
return SetStreamDuplex(pStream, m_bFullDuplex);
|
|
}
|
|
|
|
|
|
// assert - pS && pR
|
|
|
|
// both streams exist
|
|
|
|
// try to avoid the whole start/stop sequence if the duplex
|
|
// is the same
|
|
uSize=sizeof(BOOL);
|
|
pR->GetProperty(PROP_DUPLEX_TYPE, &bRecDuplex, &uSize);
|
|
uSize=sizeof(BOOL);
|
|
pS->GetProperty(PROP_DUPLEX_TYPE, &bPlayDuplex, &uSize);
|
|
|
|
if ( (bPlayDuplex == m_bFullDuplex) &&
|
|
(bRecDuplex == m_bFullDuplex))
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
// save the old thread flags
|
|
fPlayOn = (pR->GetState() == MSSTATE_STARTED);
|
|
fRecOn = (pS->GetState() == MSSTATE_STARTED);
|
|
|
|
// Ensure the record and playback threads are stopped
|
|
pR->Stop();
|
|
pS->Stop();
|
|
|
|
SetStreamDuplex(pR, m_bFullDuplex);
|
|
SetStreamDuplex(pS, m_bFullDuplex);
|
|
|
|
// Resume the record/playback
|
|
// Try to let play start before record - DirectS and SB16 prefer that!
|
|
if (fPlayOn)
|
|
{
|
|
pR->Start();
|
|
}
|
|
|
|
if (fRecOn)
|
|
{
|
|
pS->Start();
|
|
}
|
|
|
|
return DPR_SUCCESS;
|
|
}
|
|
|
|
#define LONGTIME 60000 // 60 seconds
|
|
|
|
// utility function to synchronously communicate a
|
|
// a state change to the recv thread
|
|
HRESULT DataPump::RecvThreadMessage(UINT msg, RecvMediaStream *pMS)
|
|
{
|
|
BOOL fSignaled;
|
|
DWORD dwWaitStatus;
|
|
HANDLE handle;
|
|
// Unfortunately cant use PostThreadMessage to signal the thread
|
|
// because it doesnt have a message loop
|
|
m_pCurRecvStream = pMS;
|
|
m_CurRecvMsg = msg;
|
|
fSignaled = SetEvent(m_hRecvThreadSignalEvent);
|
|
|
|
|
|
if (fSignaled) {
|
|
|
|
handle = (msg == MSG_EXIT_RECV ? m_hRecvThread : m_hRecvThreadAckEvent);
|
|
dwWaitStatus = WaitForSingleObject(handle, LONGTIME);
|
|
ASSERT(dwWaitStatus == WAIT_OBJECT_0);
|
|
if (dwWaitStatus != WAIT_OBJECT_0)
|
|
return GetLastError();
|
|
} else
|
|
return GetLastError();
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
// start receiving on this stream
|
|
// will create the receive thread if necessary.
|
|
HRESULT
|
|
DataPump::StartReceiving(RecvMediaStream *pMS)
|
|
{
|
|
DWORD dwWaitStatus;
|
|
FX_ENTRY("DP::StartReceiving")
|
|
// one more stream
|
|
m_nReceivers++;
|
|
if (!m_hRecvThread) {
|
|
ASSERT(m_nReceivers==1);
|
|
ASSERT(!m_hRecvThreadAckEvent);
|
|
//Use this for thread event notifications. I.e. Video started/stopped, audio stopped, et al.
|
|
//m_hRecvThreadChangeEvent=CreateEvent (NULL,FALSE,FALSE,NULL);
|
|
//create the stopping sync event
|
|
m_hRecvThreadAckEvent=CreateEvent (NULL,FALSE,FALSE,NULL);
|
|
m_hRecvThreadSignalEvent = CreateEvent(NULL,FALSE,FALSE,NULL);
|
|
|
|
m_hRecvThread = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)StartDPRecvThread,(PVOID)this,0,&m_RecvThId);
|
|
DEBUGMSG(ZONE_DP,("%s: RecvThread Id=%x\n",_fx_,m_RecvThId));
|
|
// thread will signal event soon as its message loop is ready
|
|
dwWaitStatus = WaitForSingleObject(m_hRecvThreadAckEvent, LONGTIME);
|
|
ASSERT(dwWaitStatus == WAIT_OBJECT_0);
|
|
}
|
|
|
|
//Tell the recv Thread to start receiving on this MediaStream
|
|
return RecvThreadMessage(MSG_START_RECV,pMS);
|
|
|
|
|
|
}
|
|
|
|
// Stop receiving on the stream
|
|
// will stop the receive thread if necessary
|
|
HRESULT
|
|
DataPump::StopReceiving(RecvMediaStream *pMS)
|
|
{
|
|
HANDLE rgh[2];
|
|
ASSERT(m_nReceivers > 0);
|
|
ASSERT(m_hRecvThread);
|
|
if (m_nReceivers > 0)
|
|
m_nReceivers--;
|
|
|
|
RecvThreadMessage(MSG_STOP_RECV, pMS);
|
|
|
|
if (!m_nReceivers && m_hRecvThread) {
|
|
// kill the receive thread
|
|
RecvThreadMessage(MSG_EXIT_RECV,NULL);
|
|
|
|
CloseHandle(m_hRecvThread);
|
|
CloseHandle(m_hRecvThreadAckEvent);
|
|
m_hRecvThread = NULL;
|
|
m_hRecvThreadAckEvent = NULL;
|
|
if (m_hRecvThreadSignalEvent) {
|
|
CloseHandle(m_hRecvThreadSignalEvent);
|
|
m_hRecvThreadSignalEvent = NULL;
|
|
}
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
//
|
|
// IVideoDevice Methods
|
|
//
|
|
|
|
// Capture device methods
|
|
|
|
// Gets the number of enabled capture devices
|
|
// Returns -1L on error
|
|
HRESULT __stdcall DataPump::GetNumCapDev()
|
|
{
|
|
FINDCAPTUREDEVICE fcd;
|
|
|
|
// scan for broken or unplugged devices
|
|
FindFirstCaptureDevice(&fcd, NULL);
|
|
|
|
return (GetNumCaptureDevices());
|
|
}
|
|
|
|
// Gets the max size of the captuire device name
|
|
// Returns -1L on error
|
|
HRESULT __stdcall DataPump::GetMaxCapDevNameLen()
|
|
{
|
|
return (MAX_CAPDEV_NAME + MAX_CAPDEV_DESCRIPTION);
|
|
}
|
|
|
|
// Enum list of enabled capture devices
|
|
// Fills up 1st buffer with device IDs, 2nd buffer with device names
|
|
// Third parameter is the max number of devices to enum
|
|
// Returns number of devices enum-ed
|
|
HRESULT __stdcall DataPump::EnumCapDev(DWORD *pdwCapDevIDs, TCHAR *pszCapDevNames, DWORD dwNumCapDev)
|
|
{
|
|
FINDCAPTUREDEVICE fcd;
|
|
DWORD dwNumCapDevFound = 0;
|
|
|
|
fcd.dwSize = sizeof (FINDCAPTUREDEVICE);
|
|
if (FindFirstCaptureDevice(&fcd, NULL))
|
|
{
|
|
do
|
|
{
|
|
pdwCapDevIDs[dwNumCapDevFound] = fcd.nDeviceIndex;
|
|
|
|
// Build device name out of the capture device strings
|
|
if (fcd.szDeviceDescription && fcd.szDeviceDescription[0] != '\0')
|
|
lstrcpy(pszCapDevNames + dwNumCapDevFound * (MAX_CAPDEV_NAME + MAX_CAPDEV_DESCRIPTION), fcd.szDeviceDescription);
|
|
else
|
|
lstrcpy(pszCapDevNames + dwNumCapDevFound * (MAX_CAPDEV_NAME + MAX_CAPDEV_DESCRIPTION), fcd.szDeviceName);
|
|
if (fcd.szDeviceVersion && fcd.szDeviceVersion[0] != '\0')
|
|
{
|
|
lstrcat(pszCapDevNames + dwNumCapDevFound * (MAX_CAPDEV_NAME + MAX_CAPDEV_DESCRIPTION), ", ");
|
|
lstrcat(pszCapDevNames + dwNumCapDevFound * (MAX_CAPDEV_NAME + MAX_CAPDEV_DESCRIPTION), fcd.szDeviceVersion);
|
|
}
|
|
dwNumCapDevFound++;
|
|
} while ((dwNumCapDevFound < dwNumCapDev) && FindNextCaptureDevice(&fcd));
|
|
}
|
|
|
|
return (dwNumCapDevFound);
|
|
}
|
|
|
|
HRESULT __stdcall DataPump::GetCurrCapDevID()
|
|
{
|
|
UINT uCapID;
|
|
UINT uSize = sizeof(UINT);
|
|
|
|
// even though we know the value of the last call
|
|
// to SetCurrCapDevID, the stream may have resulted in using
|
|
// wave_mapper (-1). We want to be able to return -1, if this
|
|
// is the case. However, the channel objects don't do this yet.
|
|
// (they still return the same value as m_uVideoCaptureId)
|
|
|
|
if (m_Video.pSendStream)
|
|
{
|
|
m_Video.pSendStream->GetProperty(PROP_CAPTURE_DEVICE, &uCapID, &uSize);
|
|
#ifdef DEBUG
|
|
if (uCapID != m_uVideoCaptureId)
|
|
{
|
|
DEBUGMSG(ZONE_DP,("Video capture stream had to revert to MAPPER or some other device"));
|
|
}
|
|
#endif
|
|
return uCapID;
|
|
}
|
|
|
|
return m_uVideoCaptureId;
|
|
|
|
}
|
|
|
|
|
|
HRESULT __stdcall DataPump::SetCurrCapDevID(int nCapDevID)
|
|
{
|
|
m_uVideoCaptureId = (UINT)nCapDevID;
|
|
|
|
if (m_Video.pSendStream)
|
|
{
|
|
m_Video.pSendStream->SetProperty(PROP_CAPTURE_DEVICE, &m_uVideoCaptureId, sizeof(m_uVideoCaptureId));
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
|
|
// IAudioDevice methods
|
|
HRESULT __stdcall DataPump::GetRecordID(UINT *puWaveDevID)
|
|
{
|
|
*puWaveDevID = m_uWaveInID;
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT __stdcall DataPump::SetRecordID(UINT uWaveDevID)
|
|
{
|
|
m_uWaveInID = uWaveDevID;
|
|
|
|
if (m_Audio.pSendStream)
|
|
{
|
|
m_Audio.pSendStream->SetProperty(PROP_RECORD_DEVICE, &m_uWaveInID, sizeof(m_uWaveInID));
|
|
}
|
|
return S_OK;
|
|
|
|
}
|
|
|
|
|
|
HRESULT __stdcall DataPump::GetPlaybackID(UINT *puWaveDevID)
|
|
{
|
|
// like video, the audio device may have resorted to using
|
|
// WAVE_MAPPER. We'd like to be able to detect that
|
|
|
|
*puWaveDevID = m_uWaveOutID;
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT __stdcall DataPump::SetPlaybackID(UINT uWaveDevID)
|
|
{
|
|
m_uWaveOutID = uWaveDevID;
|
|
|
|
if (m_Audio.pRecvStream)
|
|
{
|
|
m_Audio.pRecvStream->SetProperty(PROP_PLAYBACK_DEVICE, &m_uWaveOutID, sizeof(m_uWaveOutID));
|
|
}
|
|
return S_OK;
|
|
|
|
}
|
|
|
|
HRESULT __stdcall DataPump::GetSilenceLevel(UINT *puLevel)
|
|
{
|
|
*puLevel = m_uSilenceLevel;
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
HRESULT __stdcall DataPump::SetSilenceLevel(UINT uLevel)
|
|
{
|
|
m_uSilenceLevel = uLevel;
|
|
|
|
if (m_Audio.pSendStream)
|
|
{
|
|
m_Audio.pSendStream->SetProperty(PROP_SILENCE_LEVEL, &m_uSilenceLevel, sizeof(m_uSilenceLevel));
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
HRESULT __stdcall DataPump::GetDuplex(BOOL *pbFullDuplex)
|
|
{
|
|
*pbFullDuplex = m_bFullDuplex;
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
HRESULT __stdcall DataPump::GetMixer(HWND hwnd, BOOL bPlayback, IMixer **ppMixer)
|
|
{
|
|
CMixerDevice *pMixerDevice = NULL;
|
|
DWORD dwFlags;
|
|
HRESULT hr = E_NOINTERFACE;
|
|
|
|
// unfortunately, trying to create a mixer when WAVE_MAPPER
|
|
// has been specified as the device ID results in a mixer
|
|
// that doesn't work on Win95.
|
|
|
|
*ppMixer = NULL;
|
|
|
|
if ((bPlayback) && (m_uWaveOutID != WAVE_MAPPER))
|
|
{
|
|
pMixerDevice = CMixerDevice::GetMixerForWaveDevice(hwnd, m_uWaveOutID, MIXER_OBJECTF_WAVEOUT);
|
|
}
|
|
else if (m_uWaveInID != WAVE_MAPPER)
|
|
{
|
|
pMixerDevice = CMixerDevice::GetMixerForWaveDevice(hwnd, m_uWaveInID, MIXER_OBJECTF_WAVEIN);
|
|
}
|
|
|
|
if (pMixerDevice)
|
|
{
|
|
hr = pMixerDevice->QueryInterface(IID_IMixer, (void**)ppMixer);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT __stdcall DataPump::GetAutoMix(BOOL *pbAutoMix)
|
|
{
|
|
*pbAutoMix = m_bAutoMix;
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT __stdcall DataPump::SetAutoMix(BOOL bAutoMix)
|
|
{
|
|
m_bAutoMix = bAutoMix;
|
|
if (m_Audio.pSendStream)
|
|
{
|
|
m_Audio.pSendStream->SetProperty(PROP_AUDIO_AUTOMIX, &m_bAutoMix, sizeof(m_bAutoMix));
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT __stdcall DataPump::GetDirectSound(BOOL *pbDS)
|
|
{
|
|
*pbDS = m_bDirectSound;
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT __stdcall DataPump::SetDirectSound(BOOL bDS)
|
|
{
|
|
m_bDirectSound = bDS;
|
|
return S_OK;
|
|
}
|