able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/enduser/netmeeting/av/nac/threads.cpp

1157 lines
28 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#include "precomp.h"
#include "mixer.h"
#include "agc.h"
// #define LOGSTATISTICS_ON 1
DWORD SendAudioStream::RecordingThread ()
{
HRESULT hr = DPR_SUCCESS;
MediaPacket *pPacket;
DWORD dwWait;
HANDLE hEvent;
DWORD dwDuplexType;
DWORD dwVoiceSwitch;
DWORD_PTR dwPropVal;
DWORD dwSamplesPerPkt;
DWORD dwSamplesPerSec;
DWORD dwSilenceLimit, dwMaxStrength, dwLengthMS;
WORD wPeakStrength;
UINT u, uBufferSize;
UINT uSilenceCount = 0;
UINT uPrefeed = 0;
UINT uTimeout = 0;
DevMediaQueue dq;
BOOL fSilent;
AGC agc(NULL); // audio gain control object
CMixerDevice *pMixer = NULL;
int nFailCount = 0;
bool bCanSignalOpen=true; // should we signal that the device is open
// note: pMC is an artifact of when this thread was in the Datapump
// namespace. We can probably start phasing this variable out.
// in the mean time: "pMC = this" will suffice
// SendAudioStream *pMC = (SendAudioStream *)(m_pDP->m_Audio.pSendStream);
SendAudioStream *pMC = this;
ASSERT(pMC && (pMC->m_DPFlags & DPFLAG_INITIALIZED));
TxStream *pStream = pMC->m_SendStream;
AcmFilter *pAudioFilter = pMC->m_pAudioFilter;
// warning: typecasting a base class ptr to a derived class ptr.
WaveInControl *pMediaCtrl = (WaveInControl *)pMC->m_InMedia;
FX_ENTRY ("DP::RcrdTh:")
// get thread context
if (pStream == NULL || pAudioFilter == NULL || pMediaCtrl == NULL)
{
return DPR_INVALID_PARAMETER;
}
// Enter critical section: QoS thread also reads the statistics
EnterCriticalSection(&pMC->m_crsQos);
// Initialize QoS structure
ZeroMemory(&pMC->m_Stats, 4UL * sizeof(DWORD));
// Initialize oldest QoS callback timestamp
pMC->m_Stats.dwNewestTs = pMC->m_Stats.dwOldestTs = timeGetTime();
// Leave critical section
LeaveCriticalSection(&pMC->m_crsQos);
pMediaCtrl->GetProp(MC_PROP_MEDIA_DEV_ID, &dwPropVal);
if (dwPropVal != (DWORD)WAVE_MAPPER)
{
pMixer = CMixerDevice::GetMixerForWaveDevice(NULL, (DWORD)dwPropVal, MIXER_OBJECTF_WAVEIN);
}
// even if pMixer is null, this is fine, AGC will catch subsequent errors
agc.SetMixer(pMixer);
// get thresholds
pMediaCtrl->GetProp (MC_PROP_TIMEOUT, &dwPropVal);
uTimeout = (DWORD)dwPropVal;
pMediaCtrl->GetProp (MC_PROP_PREFEED, &dwPropVal);
uPrefeed = (DWORD)dwPropVal;
// get duplex type
pMediaCtrl->GetProp (MC_PROP_DUPLEX_TYPE, &dwPropVal);
dwDuplexType = (DWORD)dwPropVal;
// get Samples/Pkt and Samples/Sec
pMediaCtrl->GetProp (MC_PROP_SPP, &dwPropVal);
dwSamplesPerPkt = (DWORD)dwPropVal;
pMediaCtrl->GetProp (MC_PROP_SPS, &dwPropVal);
dwSamplesPerSec = (DWORD)dwPropVal;
pMediaCtrl->GetProp (MC_PROP_SILENCE_DURATION, &dwPropVal);
dwSilenceLimit = (DWORD)dwPropVal;
// calculate silence limit in units of packets
// silence_time_in_ms/packet_duration_in_ms
dwSilenceLimit = dwSilenceLimit*dwSamplesPerSec/(dwSamplesPerPkt*1000);
// length of a packet in millisecs
dwLengthMS = (dwSamplesPerPkt * 1000) / dwSamplesPerSec;
dq.SetSize (MAX_TXRING_SIZE);
WaitForSignal:
// DEBUGMSG (1, ("%s: WaitForSignal\r\n", _fx_));
{
pMediaCtrl->GetProp (MC_PROP_MEDIA_DEV_HANDLE, &dwPropVal);
if (dwPropVal)
{
DEBUGMSG (ZONE_DP, ("%s: already open\r\n", _fx_));
goto SendLoop; // sound device already open
}
// in the full-duplex case, open and prepare the device and charge ahead.
// in the half duplex case wait for playback's signal before opening the device
while (TRUE)
{
// should I stop now???
if (pMC->m_ThreadFlags & DPTFLAG_STOP_RECORD)
{
DEBUGMSG (ZONE_DP, ("%s: STOP_1\r\n", _fx_));
goto MyEndThread;
}
dwWait = (dwDuplexType & DP_FLAG_HALF_DUPLEX) ? WaitForSingleObject (g_hEventHalfDuplex, uTimeout)
: WAIT_OBJECT_0;
// now, let's check why I don't need to wait
if (dwWait == WAIT_OBJECT_0)
{
//DEBUGMSG (ZONE_DP, ("%s: try to open audio dev\r\n", _fx_));
LOG((LOGMSG_OPEN_AUDIO));
hr = pMediaCtrl->Open ();
if (hr != DPR_SUCCESS)
{
DEBUGMSG (ZONE_DP, ("%s: MediaCtrl::Open failed, hr=0x%lX\r\n", _fx_, hr));
pMediaCtrl->SetProp(MC_PROP_AUDIO_JAMMED, TRUE);
SetEvent(g_hEventHalfDuplex);
nFailCount++;
if (nFailCount == MAX_FAILCOUNT)
{
// three attempts to open the device have failed
// signal to the UI that something is wrong
m_pDP->StreamEvent(MCF_SEND, MCF_AUDIO, STREAM_EVENT_DEVICE_FAILURE, 0);
bCanSignalOpen = true;
}
Sleep(2000); // Sleep for two seconds
continue;
}
// Notification is not used. if needed do it thru Channel
//pMC->m_Connection->DoNotification(CONNECTION_OPEN_MIC);
pMediaCtrl->PrepareHeaders ();
goto SendLoop;
}
} // while
}
SendLoop:
nFailCount = 0;
pMediaCtrl->SetProp(MC_PROP_AUDIO_JAMMED, FALSE);
if (bCanSignalOpen)
{
m_pDP->StreamEvent(MCF_SEND, MCF_AUDIO, STREAM_EVENT_DEVICE_OPEN, 0);
bCanSignalOpen = false; // don't signal more than once per session
}
// DEBUGMSG (1, ("%s: SendLoop\r\n", _fx_));
// get event handle
pMediaCtrl->GetProp (MC_PROP_EVENT_HANDLE, &dwPropVal);
hEvent = (HANDLE) dwPropVal;
if (hEvent == NULL)
{
DEBUGMSG (ZONE_DP, ("%s: invalid event\r\n", _fx_));
return DPR_CANT_CREATE_EVENT;
}
// hey, in the very beginning, let's 'Start' it
hr = pMediaCtrl->Start ();
if (hr != DPR_SUCCESS)
{
DEBUGMSG (ZONE_DP, ("%s: MediaControl::Start failed, hr=0x%lX\r\n", _fx_, hr));
goto MyEndThread;
}
// update timestamp to account for the 'sleep' period
pMC->m_SendTimestamp += (GetTickCount() - pMC->m_SavedTickCount)*dwSamplesPerSec/1000;
// let's feed four buffers first
for (u = 0; u < uPrefeed; u++)
{
if ((pPacket = pStream->GetFree ()) != NULL)
{
if ((hr = pPacket->Record ()) != DPR_SUCCESS)
{
DEBUGMSG (ZONE_DP, ("%s: Record failed, hr=0x%lX\r\n", _fx_, hr));
}
dq.Put (pPacket);
}
}
// let's get into the loop, mm system notification loop
pMC->m_fSending= FALSE;
while (TRUE)
{
dwWait = WaitForSingleObject (hEvent, uTimeout);
// should I stop now???
if (pMC->m_ThreadFlags & DPTFLAG_STOP_RECORD)
{
DEBUGMSG (ZONE_DP, ("%s: STOP_3\r\n", _fx_));
goto HalfDuplexYield;
}
// get current voice switching mode
pMediaCtrl->GetProp (MC_PROP_VOICE_SWITCH, &dwPropVal);
dwVoiceSwitch = (DWORD)dwPropVal;
// see why I don't need to wait
if (dwWait != WAIT_TIMEOUT)
{
while (TRUE)
{
if ((pPacket = dq.Peek ()) != NULL)
{
if (! pPacket->IsBufferDone ())
{
break;
}
else
{
if (pMC->m_mmioSrc.fPlayFromFile && pMC->m_mmioSrc.hmmioSrc)
pPacket->ReadFromFile (&pMC->m_mmioSrc);
u--; // one less buffer with the wave device
}
}
else
{
DEBUGMSG (ZONE_VERBOSE, ("%s: Peek is NULL\r\n", _fx_));
break;
}
pPacket = dq.Get ();
((AudioPacket*)pPacket)->ComputePower (&dwMaxStrength, &wPeakStrength);
// is this packet silent?
fSilent = pMC->m_AudioMonitor.SilenceDetect((WORD)dwMaxStrength);
if((dwVoiceSwitch == DP_FLAG_AUTO_SWITCH)
&& fSilent)
{
// pPacket->SetState (MP_STATE_RESET); // note: done in Recycle
if (++uSilenceCount >= dwSilenceLimit)
{
pMC->m_fSending = FALSE; // stop sending packets
// if half duplex mode and playback thread may be waiting
if (dwDuplexType & DP_FLAG_HALF_DUPLEX)
{
IMediaChannel *pIMC = NULL;
RecvMediaStream *pRecv;
m_pDP->GetMediaChannelInterface(MCF_RECV | MCF_AUDIO, &pIMC);
if (pIMC)
{
pRecv = static_cast<RecvMediaStream *> (pIMC);
if (pRecv->IsEmpty()==FALSE)
{
//DEBUGMSG (ZONE_DP, ("%s: too many silence and Yield\r\n", _fx_));
LOG((LOGMSG_REC_YIELD));
pPacket->Recycle ();
pStream->PutNextRecorded (pPacket);
uSilenceCount = 0;
pIMC->Release();
goto HalfDuplexYield;
}
pIMC->Release();
}
}
}
}
else
{
switch(dwVoiceSwitch)
{
// either there was NO silence, or manual switching is in effect
default:
case DP_FLAG_AUTO_SWITCH: // this proves no silence (in this path because of non-silence)
case DP_FLAG_MIC_ON:
pMC->m_fSending = TRUE;
uSilenceCount = 0;
break;
case DP_FLAG_MIC_OFF:
pMC->m_fSending = FALSE;
break;
}
}
if (pMC->m_fSending)
{
pPacket->SetState (MP_STATE_RECORDED);
// do AUTOMIX, but ignore DTMF tones
if (pMC->m_bAutoMix)
{
agc.Update(wPeakStrength, dwLengthMS);
}
}
else
{
pPacket->Recycle();
// Enter critical section: QoS thread also reads the statistics
EnterCriticalSection(&pMC->m_crsQos);
// Update total number of packets recorded
pMC->m_Stats.dwCount++;
// Leave critical section
LeaveCriticalSection(&pMC->m_crsQos);
}
pPacket->SetProp(MP_PROP_TIMESTAMP,pMC->m_SendTimestamp);
// pPacket->SetProp(MP_PROP_TIMESTAMP,GetTickCount());
pMC->m_SendTimestamp += dwSamplesPerPkt;
pStream->PutNextRecorded (pPacket);
} // while
}
else
{
if (dwDuplexType & DP_FLAG_HALF_DUPLEX)
{
DEBUGMSG (ZONE_DP, ("%s: Timeout and Yield\r\n", _fx_));
goto HalfDuplexYield;
}
} // if
pMC->Send();
// Make sure the recorder has an adequate number of buffers
while ((pPacket = pStream->GetFree()) != NULL)
{
if ((hr = pPacket->Record ()) == DPR_SUCCESS)
{
dq.Put (pPacket);
}
else
{
dq.Put (pPacket);
DEBUGMSG (ZONE_DP, ("%s: Record FAILED, hr=0x%lX\r\n", _fx_, hr));
break;
}
u++;
}
if (u < uPrefeed)
{
DEBUGMSG (ZONE_DP, ("%s: NO FREE BUFFERS\r\n", _fx_));
}
} // while TRUE
goto MyEndThread;
HalfDuplexYield:
// stop and reset audio device
pMediaCtrl->Reset ();
// flush dq
while ((pPacket = dq.Get ()) != NULL)
{
pStream->PutNextRecorded (pPacket);
pPacket->Recycle ();
}
// save real time so we can update the timestamp when we restart
pMC->m_SavedTickCount = GetTickCount();
// reset the event
ResetEvent (hEvent);
// close audio device
pMediaCtrl->UnprepareHeaders ();
pMediaCtrl->Close ();
// signal playback thread to start
SetEvent (g_hEventHalfDuplex);
if (!(pMC->m_ThreadFlags & DPTFLAG_STOP_RECORD)) {
// yield
// playback has to claim the device within 100ms or we take it back.
Sleep (100);
// wait for playback's signal
goto WaitForSignal;
}
MyEndThread:
if (pMixer)
delete pMixer;
pMediaCtrl->SetProp(MC_PROP_AUDIO_JAMMED, FALSE);
pMC->m_fSending = FALSE;
DEBUGMSG (ZONE_DP, ("%s: Exiting.\r\n", _fx_));
return hr;
}
DWORD RecvAudioStream::PlaybackThread ( void)
{
HRESULT hr = DPR_SUCCESS;
MediaPacket * pPacket;
MediaPacket * pPrevPacket;
MediaPacket * pNextPacket;
DWORD dwWait;
HANDLE hEvent;
DWORD dwDuplexType;
DWORD_PTR dwPropVal;
UINT u;
UINT uMissingCount = 0;
UINT uPrefeed = 0;
UINT uTimeout = 0;
UINT uSamplesPerPkt=0;
DevMediaQueue dq;
UINT uGoodPacketsQueued = 0;
int nFailCount = 0;
bool bCanSignalOpen=true;
//warning: casting from base to dervied class
// note: pMC is an artifact of when this thread was in the Datapump
// namespace. We can probably start phasing this variable out.
// in the mean time: "pMC = this" will suffice
// RecvAudioStream *pMC = (RecvAudioStream *)(m_pDP->m_Audio.pRecvStream);
RecvAudioStream *pMC = this;
RxStream *pStream = pMC->m_RecvStream;
MediaControl *pMediaCtrl = pMC->m_OutMedia;
#if 0
NETBUF * pStaticNetBuf;
#endif
FX_ENTRY ("DP::PlayTh")
if (pStream == NULL || m_pAudioFilter == NULL || pMediaCtrl == NULL)
{
return DPR_INVALID_PARAMETER;
}
// get event handle
pMediaCtrl->GetProp (MC_PROP_EVENT_HANDLE, &dwPropVal);
hEvent = (HANDLE) dwPropVal;
if (hEvent == NULL)
{
DEBUGMSG (ZONE_DP, ("%s: invalid event\r\n", _fx_));
return DPR_CANT_CREATE_EVENT;
}
// get thresholds
pMediaCtrl->GetProp (MC_PROP_TIMEOUT, &dwPropVal);
uTimeout = (DWORD)dwPropVal;
uPrefeed = pStream->BufferDelay();
// get samples per pkt
pMediaCtrl->GetProp(MC_PROP_SPP, &dwPropVal);
uSamplesPerPkt = (DWORD)dwPropVal;
// get duplex type
pMediaCtrl->GetProp (MC_PROP_DUPLEX_TYPE, &dwPropVal);
dwDuplexType = (DWORD)dwPropVal;
// set dq size
dq.SetSize (uPrefeed);
WaitForSignal:
// DEBUGMSG (1, ("%s: WaitForSignal\r\n", _fx_));
pMediaCtrl->GetProp (MC_PROP_MEDIA_DEV_HANDLE, &dwPropVal);
if (dwPropVal)
{
DEBUGMSG (ZONE_DP, ("%s: already open\r\n", _fx_));
goto RecvLoop; // already open
}
// in the full-duplex case, open and prepare the device and charge ahead.
// in the half duplex case wait for playback's signal before opening the device
while (TRUE)
{
// should I stop now???
if (pMC->m_ThreadFlags & DPTFLAG_STOP_PLAY)
{
DEBUGMSG (ZONE_VERBOSE, ("%s: STOP_1\r\n", _fx_));
goto MyEndThread;
}
dwWait = (dwDuplexType & DP_FLAG_HALF_DUPLEX) ? WaitForSingleObject (g_hEventHalfDuplex, uTimeout)
: WAIT_OBJECT_0;
// to see why I don't need to wait
if (dwWait == WAIT_OBJECT_0)
{
// DEBUGMSG (1, ("%s: try to open audio dev\r\n", _fx_));
pStream->FastForward(FALSE); // GJ - flush receive queue
hr = pMediaCtrl->Open ();
if (hr != DPR_SUCCESS)
{
// somebody may have commandeered the wave out device
// this could be a temporary problem so lets give it some time
DEBUGMSG (ZONE_DP, ("%s: MediaControl::Open failed, hr=0x%lX\r\n", _fx_, hr));
pMediaCtrl->SetProp(MC_PROP_AUDIO_JAMMED, TRUE);
SetEvent(g_hEventHalfDuplex);
nFailCount++;
if (nFailCount == MAX_FAILCOUNT)
{
// three attempts to open the device have failed
// signal to the UI that something is wrong
m_pDP->StreamEvent(MCF_RECV, MCF_AUDIO, STREAM_EVENT_DEVICE_FAILURE, 0);
bCanSignalOpen = true;
}
Sleep(2000); // sleep for two seconds
continue;
}
// Notification is not used. if needed do it thru Channel
//pMC->m_Connection->DoNotification(CONNECTION_OPEN_SPK);
pMediaCtrl->PrepareHeaders ();
goto RecvLoop;
}
} // while
RecvLoop:
nFailCount = 0;
pMediaCtrl->SetProp(MC_PROP_AUDIO_JAMMED, FALSE);
if (bCanSignalOpen)
{
m_pDP->StreamEvent(MCF_RECV, MCF_AUDIO, STREAM_EVENT_DEVICE_OPEN, 0);
bCanSignalOpen = false; // don't signal open more than once per session
}
// Set my thread priority high
// This thread doesnt do any compute intensive work (except maybe
// interpolate?).
// Its sole purpose is to stream ready buffers to the sound device
SetThreadPriority(pMC->m_hRenderingThread, THREAD_PRIORITY_HIGHEST);
// DEBUGMSG (1, ("%s: SendLoop\r\n", _fx_));
// let's feed four buffers first
// But make sure the receive stream has enough buffering delay
// so we dont read past the last packet.
//if (uPrefeed > pStream->BufferDelay())
uGoodPacketsQueued = 0;
for (u = 0; u < uPrefeed; u++)
{
if ((pPacket = pStream->GetNextPlay ()) != NULL)
{
if (pPacket->GetState () == MP_STATE_RESET)
{
// hr = pPacket->Play (pStaticNetBuf);
hr = pPacket->Play (&pMC->m_mmioDest, MP_DATATYPE_SILENCE);
}
else
{
// hr = pPacket->Play ();
hr = pPacket->Play (&pMC->m_mmioDest, MP_DATATYPE_FROMWIRE);
uGoodPacketsQueued++;
}
if (hr != DPR_SUCCESS)
{
DEBUGMSG (ZONE_DP, ("%s: Play failed, hr=0x%lX\r\n", _fx_, hr));
SetEvent(hEvent);
}
dq.Put (pPacket);
}
}
pMC->m_fReceiving = TRUE;
// let's get into the loop
uMissingCount = 0;
while (TRUE)
{
dwWait = WaitForSingleObject (hEvent, uTimeout);
// should I stop now???
if (pMC->m_ThreadFlags & DPTFLAG_STOP_PLAY)
{
DEBUGMSG (ZONE_VERBOSE, ("%s: STOP_3\r\n", _fx_));
goto HalfDuplexYield;
}
// see why I don't need to wait
if (dwWait != WAIT_TIMEOUT)
{
while (TRUE)
{
if ((pPacket = dq.Peek ()) != NULL)
{
if (! pPacket->IsBufferDone ())
{
break;
}
}
else
{
DEBUGMSG (ZONE_VERBOSE, ("%s: Peek is NULL\r\n", _fx_));
break;
}
pPacket = dq.Get ();
if (pPacket->GetState() != MP_STATE_PLAYING_SILENCE)
uGoodPacketsQueued--; // a non-empty buffer just got done
pMC->m_PlaybackTimestamp = pPacket->GetTimestamp() + uSamplesPerPkt;
pPacket->Recycle ();
pStream->Release (pPacket);
if ((pPacket = pStream->GetNextPlay ()) != NULL)
{
// check if we are in half-duplex mode and also if
// the recording thread is around.
if (dwDuplexType & DP_FLAG_HALF_DUPLEX)
{
IMediaChannel *pIMC = NULL;
BOOL fSending = FALSE;
m_pDP->GetMediaChannelInterface(MCF_SEND | MCF_AUDIO, &pIMC);
if (pIMC)
{
fSending = (pIMC->GetState() == MSSTATE_STARTED);
pIMC->Release();
}
if (fSending) {
if (pPacket->GetState () == MP_STATE_RESET)
{
// Decide if its time to yield
// Dont want to yield until we've finished playing all data packets
//
if (!uGoodPacketsQueued &&
(pStream->IsEmpty() || ++uMissingCount >= DEF_MISSING_LIMIT))
{
//DEBUGMSG (ZONE_DP, ("%s: too many missings and Yield\r\n", _fx_));
LOG( (LOGMSG_PLAY_YIELD));
pPacket->Recycle ();
pStream->Release (pPacket);
goto HalfDuplexYield;
}
}
else
{
uMissingCount = 0;
}
}
}
if (pPacket->GetState () == MP_STATE_RESET)
{
pPrevPacket = pStream->PeekPrevPlay ();
pNextPacket = pStream->PeekNextPlay ();
hr = pPacket->Interpolate(pPrevPacket, pNextPacket);
if (hr != DPR_SUCCESS)
{
//DEBUGMSG (ZONE_DP, ("%s: Interpolate failed, hr=0x%lX\r\n", _fx_, hr));
hr = pPacket->Play (&pMC->m_mmioDest, MP_DATATYPE_SILENCE);
}
else
hr = pPacket->Play (&pMC->m_mmioDest, MP_DATATYPE_INTERPOLATED);
}
else
{
// hr = pPacket->Play ();
hr = pPacket->Play (&pMC->m_mmioDest, MP_DATATYPE_FROMWIRE);
uGoodPacketsQueued++;
}
if (hr != DPR_SUCCESS)
{
DEBUGMSG (ZONE_DP, ("%s: Play failed, hr=0x%lX\r\n", _fx_, hr));
SetEvent(hEvent);
}
dq.Put (pPacket);
} else {
DEBUGMSG( ZONE_DP, ("%s: NO PLAY BUFFERS!",_fx_));
}
} // while
}
else
{
if (dwDuplexType & DP_FLAG_HALF_DUPLEX)
{
DEBUGMSG (ZONE_DP, ("%s: Timeout and Yield!\r\n", _fx_));
goto HalfDuplexYield;
}
}
} // while TRUE
goto MyEndThread;
HalfDuplexYield:
pMC->m_fReceiving = FALSE;
// stop and reset audio device
pMediaCtrl->Reset ();
// flush dq
while ((pPacket = dq.Get ()) != NULL)
{
pPacket->Recycle ();
pStream->Release (pPacket);
}
// reset the event
ResetEvent (hEvent);
// close audio device
pMediaCtrl->UnprepareHeaders ();
pMediaCtrl->Close ();
// signal recording thread to start
SetEvent (g_hEventHalfDuplex);
if (!(pMC->m_ThreadFlags & DPTFLAG_STOP_PLAY)) {
// yield
Sleep (0);
// wait for recording's signal
// restore thread priority
SetThreadPriority(pMC->m_hRenderingThread,THREAD_PRIORITY_NORMAL);
goto WaitForSignal;
}
MyEndThread:
pMediaCtrl->SetProp(MC_PROP_AUDIO_JAMMED, FALSE);
DEBUGMSG(ZONE_DP, ("%s: Exiting.\n", _fx_));
return hr;
}
DWORD SendAudioStream::Send()
{
MMRESULT mmr;
MediaPacket *pAP;
void *pBuffer;
DWORD dwBeforeEncode;
DWORD dwAfterEncode;
DWORD dwPacketSize;
UINT uBytesSent;
#ifdef LOGSTATISTICS_ON
char szDebug[256];
DWORD dwDebugSaveBits;
#endif
while ( pAP = m_SendStream->GetNext()) {
if (!(m_ThreadFlags & DPTFLAG_PAUSE_SEND)) {
dwBeforeEncode = timeGetTime();
mmr = m_pAudioFilter->Convert((AudioPacket*)pAP, AP_ENCODE);
if (mmr == MMSYSERR_NOERROR)
{
pAP->SetState(MP_STATE_ENCODED);
}
// Time the encoding operation
dwAfterEncode = timeGetTime() - dwBeforeEncode;
if (mmr == MMSYSERR_NOERROR)
{
SendPacket((AudioPacket*)pAP, &uBytesSent);
}
else
{
uBytesSent = 0;
}
UPDATE_COUNTER(g_pctrAudioSendBytes, uBytesSent*8);
// Enter critical section: QoS thread also reads the statistics
EnterCriticalSection(&m_crsQos);
// Update total number of packets recorded
m_Stats.dwCount++;
// Save the perfs in our stats structure for QoS
#ifdef LOGSTATISTICS_ON
dwDebugSaveBits = m_Stats.dwBits;
#endif
// Add this new frame size to the cumulated size
m_Stats.dwBits += (uBytesSent * 8);
// Add this compression time to total compression time
m_Stats.dwMsComp += dwAfterEncode;
#ifdef LOGSTATISTICS_ON
wsprintf(szDebug, " A: (Voiced) dwBits = %ld up from %ld (file: %s line: %ld)\r\n", m_Stats.dwBits, dwDebugSaveBits, __FILE__, __LINE__);
OutputDebugString(szDebug);
#endif
// Leave critical section
LeaveCriticalSection(&m_crsQos);
}
// whether or not we sent the packet, we need to return
// it to the free queue
pAP->m_fMark=0;
pAP->SetState(MP_STATE_RESET);
m_SendStream->Release(pAP);
}
return DPR_SUCCESS;
}
// queues and sends the packet
// if the packet failed the encode process, it doesn't get sent
HRESULT SendAudioStream::SendPacket(AudioPacket *pAP, UINT *puBytesSent)
{
PS_QUEUE_ELEMENT psq;
UINT uLength;
int nPacketsSent=0;
if (pAP->GetState() != MP_STATE_ENCODED)
{
DEBUGMSG (ZONE_ACM, ("SendAudioStream::SendPacket: Packet not compressed\r\n"));
*puBytesSent = 0;
return E_FAIL;
}
ASSERT(m_pRTPSend);
psq.pMP = pAP;
psq.dwPacketType = PS_AUDIO;
psq.pRTPSend = m_pRTPSend;
pAP->GetNetData((void**)(&(psq.data)), &uLength);
ASSERT(psq.data);
psq.dwSize = uLength;
psq.fMark = pAP->m_fMark;
psq.pHeaderInfo = NULL;
psq.dwHdrSize = 0;
*puBytesSent = uLength + sizeof(RTP_HDR) + IP_HEADER_SIZE + UDP_HEADER_SIZE;
// add audio packets to the front of the queue
m_pDP->m_PacketSender.m_SendQueue.PushFront(psq);
while (m_pDP->m_PacketSender.SendPacket())
{
;
}
return S_OK;
};
#ifdef OLDSTUFF
/*
// Winsock 1 receive thread
// Creates a hidden window and a message loop to process WINSOCK window
// messages. Also processes private messages from the datapump to start/stop
// receiving on a particular media stream
*/
DWORD
DataPump::CommonRecvThread (void )
{
HRESULT hr;
HWND hWnd = (HWND)NULL;
RecvMediaStream *pRecvMC;
BOOL fChange = FALSE;
MSG msg;
DWORD curTime, nextUpdateTime = 0, t;
UINT timerId = 0;
FX_ENTRY ("DP::RecvTh")
// Create hidden window
hWnd =
CreateWindowEx(
WS_EX_NOPARENTNOTIFY,
"SockMgrWClass", /* See RegisterClass() call. */
NULL,
WS_CHILD , /* Window style. */
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
m_hAppWnd, /* the application window is the parent. */
(HMENU)this, /* hardcoded ID */
m_hAppInst, /* the application owns this window. */
NULL /* Pointer not needed. */
);
if(!hWnd)
{
hr = GetLastError();
DEBUGMSG(ZONE_DP,("CreateWindow returned %d\n",hr));
goto CLEANUPEXIT;
}
SetThreadPriority(m_hRecvThread, THREAD_PRIORITY_ABOVE_NORMAL);
// This function is guaranteed to create a queue on this thread
PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE);
// notify thread creator that we're ready to recv messages
SetEvent(m_hRecvThreadAckEvent);
// Wait for control messages from Start()/Stop() or Winsock messages directed to
// our hidden window
while (GetMessage(&msg, NULL, 0, 0)) {
switch(msg.message) {
case MSG_START_RECV:
// Start receiving on the specified media stream
DEBUGMSG(ZONE_VERBOSE,("%s: MSG_START_RECV\n",_fx_));
pRecvMC = (RecvMediaStream *)msg.lParam;
// call the stream to post recv buffers and
// tell Winsock to start sending socket msgs to our window
pRecvMC->StartRecv(hWnd);
fChange = TRUE;
break;
case MSG_STOP_RECV:
// Stop receiving on the specified media stream
DEBUGMSG(ZONE_VERBOSE,("%s: MSG_STOP_RECV\n",_fx_));
pRecvMC = (RecvMediaStream *)msg.lParam;
// call the stream to cancel outstanding recvs etc.
// currently we assume this can be done synchronously
pRecvMC->StopRecv();
fChange = TRUE;
break;
case MSG_EXIT_RECV:
// Exit the recv thread.
// Assume that we are not currently receving on any stream.
DEBUGMSG(ZONE_VERBOSE,("%s: MSG_EXIT_RECV\n",_fx_));
fChange = TRUE;
if (DestroyWindow(hWnd)) {
break;
}
DEBUGMSG(ZONE_DP,("DestroyWindow returned %d\n",GetLastError()));
// fall thru to PostQuitMessage()
case WM_DESTROY:
PostQuitMessage(0);
break;
case WM_TIMER:
if (msg.hwnd == NULL) {
// this timer is for the benefit of ThreadTimer::UpdateTime()
// however, we are calling UpdateTime after every message (see below)
// so we dont do anything special here.
break;
}
default:
TranslateMessage(&msg);
DispatchMessage(&msg);
}
if (fChange) {
// the thread MSGs need to be acked
SetEvent(m_hRecvThreadAckEvent);
fChange = FALSE;
}
t = m_RecvTimer.UpdateTime(curTime=GetTickCount());
if (t != nextUpdateTime) {
// Thread timer wants to change its update time
nextUpdateTime = t;
if (timerId) {
KillTimer(NULL,timerId);
timerId = 0;
}
// if nextTime is zero, there are no scheduled timeouts so we dont need to call UpdateTime
if (nextUpdateTime)
timerId = SetTimer(NULL, 0, nextUpdateTime - curTime + 50, NULL);
}
}
CLEANUPEXIT:
DEBUGMSG(ZONE_DP,("%s terminating.\n", _fx_));
return hr;
}
#endif
/*
Winsock 2 receive thread. Main differnce here is that it has a WaitEx loop
where we wait for Start/Stop commands from the datapump while allowing
WS2 APCs to be handled.
Note: Only way to use the same thread routine for WS1 and WS2 is with
MsgWaitForMultipleObjectsEx, which unfortunately is not implemented in Win95
*/
DWORD
DataPump::CommonWS2RecvThread (void )
{
HRESULT hr;
RecvMediaStream *pRecvMC;
BOOL fChange = FALSE, fExit = FALSE;
DWORD dwWaitStatus;
DWORD curTime, t;
FX_ENTRY ("DP::WS2RecvTh")
SetThreadPriority(m_hRecvThread, THREAD_PRIORITY_ABOVE_NORMAL);
// notify thread creator that we're ready to recv messages
SetEvent(m_hRecvThreadAckEvent);
while (!fExit) {
// Wait for control messages from Start()/Stop() or Winsock async
// thread callbacks
// dispatch expired timeouts and check how long we need to wait
t = m_RecvTimer.UpdateTime(curTime=GetTickCount());
t = (t ? t-curTime+50 : INFINITE);
dwWaitStatus = WaitForSingleObjectEx(m_hRecvThreadSignalEvent,t,TRUE);
if (dwWaitStatus == WAIT_OBJECT_0) {
switch(m_CurRecvMsg) {
case MSG_START_RECV:
// Start receiving on the specified media stream
DEBUGMSG(ZONE_VERBOSE,("%s: MSG_START_RECV\n",_fx_));
pRecvMC = m_pCurRecvStream;
// call the stream to post recv buffers and
// tell Winsock to start sending socket msgs to our window
pRecvMC->StartRecv(NULL);
fChange = TRUE;
break;
case MSG_STOP_RECV:
// Stop receiving on the specified media stream
DEBUGMSG(ZONE_VERBOSE,("%s: MSG_STOP_RECV\n",_fx_));
pRecvMC = m_pCurRecvStream;
// call the stream to cancel outstanding recvs etc.
// currently we assume this can be done synchronously
pRecvMC->StopRecv();
fChange = TRUE;
break;
case MSG_EXIT_RECV:
// Exit the recv thread.
// Assume that we are not currently receving on any stream.
DEBUGMSG(ZONE_VERBOSE,("%s: MSG_EXIT_RECV\n",_fx_));
fChange = TRUE;
fExit = TRUE;
break;
case MSG_PLAY_SOUND:
fChange = TRUE;
pRecvMC->OnDTMFBeep();
break;
default:
// shouldnt be anything else
ASSERT(0);
}
if (fChange) {
// the thread MSGs need to be acked
SetEvent(m_hRecvThreadAckEvent);
fChange = FALSE;
}
} else if (dwWaitStatus == WAIT_IO_COMPLETION) {
// nothing to do here
} else if (dwWaitStatus != WAIT_TIMEOUT) {
DEBUGMSG(ZONE_DP,("%s: Wait failed with %d",_fx_,GetLastError()));
fExit=TRUE;
}
}
DEBUGMSG(ZONE_DP,("%s terminating.\n", _fx_));
return 0;
}
void ThreadTimer::SetTimeout(TTimeout *pTObj)
{
DWORD time = pTObj->GetDueTime();
// insert in increasing order of timeout
for (TTimeout *pT = m_TimeoutList.pNext; pT != &m_TimeoutList; pT = pT->pNext) {
if ((int)(pT->m_DueTime- m_CurTime) > (int) (time - m_CurTime))
break;
}
pTObj->InsertAfter(pT->pPrev);
}
void ThreadTimer::CancelTimeout(TTimeout *pTObj)
{
pTObj->Remove(); // remove from list
}
// Called by thread with the current time as input (usually obtained from GetTickCount())
// Returns the time by which UpdateTime() should be called again or currentTime+0xFFFFFFFF if there
// are no scheduled timeouts
DWORD ThreadTimer::UpdateTime(DWORD curTime)
{
TTimeout *pT;
m_CurTime = curTime;
// figure out which timeouts have elapsed and do the callbacks
while (!IsEmpty()) {
pT = m_TimeoutList.pNext;
if ((int)(pT->m_DueTime-m_CurTime) <= 0) {
pT->Remove();
pT->TimeoutIndication();
} else
break;
}
return (IsEmpty() ? m_CurTime+INFINITE : m_TimeoutList.pNext->m_DueTime);
}

Reference in a new issue Copy permalink