// WaveAudioSink.cpp: implementation of the WaveAudioSink class.
|
//
|
//////////////////////////////////////////////////////////////////////
|
|
#include "AudioSample.h"
|
#include "AudioSource.h"
|
#include "WaveAudioSink.h"
|
|
using namespace std;
|
|
//////////////////////////////////////////////////////////////////////
|
// Construction/Destruction
|
//////////////////////////////////////////////////////////////////////
|
|
WaveAudioSink::WaveAudioSink()
|
{
|
char subFacilityName[100];
|
sprintf(subFacilityName, "WaveAudioSink:%x", this);
|
tracer.SetSubFacilityName(subFacilityName);
|
SetTraceLevel();
|
tracer.tracef(EE, "Constructor begin\n");
|
enabled = true;
|
waveoutDeviceID = WAVE_MAPPER;
|
frameSize = WAVESINK_DEFAULT_WAVEHDR_SIZE;
|
numFrames = WAVESINK_NUM_WAVEHDR;
|
InitializeCriticalSection(&dataMutex);
|
InitializeCriticalSection(&freeBuffersMutex);
|
InitializeCriticalSection(&filterMutex);
|
dataEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
|
pauseEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
|
|
// set default format
|
wfx.nAvgBytesPerSec = 16000;
|
wfx.wFormatTag = WAVE_FORMAT_PCM;
|
wfx.wBitsPerSample = 16;
|
wfx.nChannels = 1;
|
wfx.nBlockAlign = 2;
|
wfx.nSamplesPerSec = 8000;
|
wfx.cbSize = 0;
|
tracer.tracef(EE, "Constructor end\n");
|
}
|
|
WaveAudioSink::~WaveAudioSink()
|
{
|
tracer.tracef(EE, "Destructor begin\n");
|
EnterCriticalSection(&filterMutex);
|
tracer.tracef(ARB, "WaveAudioSink~ : entered filterMutex\n");
|
LeaveCriticalSection(&filterMutex);
|
tracer.tracef(ARB, "WaveAudioSink~ : left filterMutex\n");
|
DeleteCriticalSection(&dataMutex);
|
DeleteCriticalSection(&freeBuffersMutex);
|
DeleteCriticalSection(&filterMutex);
|
CloseHandle(dataEvent);
|
CloseHandle(pauseEvent);
|
tracer.tracef(EE, "Destructor end\n");
|
}
|
|
int
|
WaveAudioSink::SetTraceLevel()
|
{
|
long SystemMask = 0;
|
if ((SystemMask = GetRegKeyLong(HKEY_CURRENT_USER, "Software\\Cisco Systems\\MTC\\Tracing", "AllComponents", 0x0)) == 0)
|
{
|
SystemMask = GetRegKeyLong(HKEY_CURRENT_USER, "Software\\Cisco Systems\\MTC\\Tracing", "WaveAudioSink", 0x100000);
|
}
|
tracer.SetSystemMask(SystemMask);
|
return 0;
|
}
|
|
int
|
WaveAudioSink::SetVolume(unsigned long volume)
|
{
|
tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "SetVolume %d\n", volume);
|
volume = min(100, volume);
|
unsigned long normalizedVolume = (volume * 0xffff) / 100;
|
unsigned long volumeToSet = (normalizedVolume << 16) + normalizedVolume;
|
tracer.tracef(SDI_LEVEL_DETAILED, "SetVolume : Entering dataMutex\n");
|
EnterCriticalSection(&dataMutex);
|
if (bRunning)
|
{
|
tracer.tracef(SDI_LEVEL_ARBITRARY, "SetVolume : waveOutSetVolume\n");
|
MMRESULT mr = waveOutSetVolume(hWaveOut, volumeToSet);
|
tracer.tracef(SDI_LEVEL_ARBITRARY, "SetVolume : ~waveOutSetVolume\n");
|
LeaveCriticalSection(&dataMutex);
|
tracer.tracef(SDI_LEVEL_DETAILED, "SetVolume : Left dataMutex\n");
|
if (FAILED(mr))
|
{
|
tracer.tracef(SDI_LEVEL_ERROR, "SetVolume : e-waveOutSetVolume : 0x%x\n", mr);
|
}
|
}
|
else
|
{
|
LeaveCriticalSection(&dataMutex);
|
tracer.tracef(SDI_LEVEL_DETAILED, "SetVolume : Left dataMutex\n");
|
}
|
tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~SetVolume\n");
|
return NOERROR;
|
}
|
|
|
int
|
WaveAudioSink::SetFrameSize(unsigned long size)
|
{
|
tracer.tracef(EE, "SetFrameSize %u\n", size);
|
frameSize = min(size, WAVESINK_MAX_WAVEHDR_SIZE);
|
tracer.tracef(EE, "~SetFrameSize\n");
|
return NOERROR;
|
}
|
|
|
int
|
WaveAudioSink::SetNumFrames(unsigned long num)
|
{
|
tracer.tracef(EE, "SetNumFrames %u\n", num);
|
numFrames = min(num, WAVESINK_MAX_WAVEHDR);
|
tracer.tracef(EE, "~SetNumFrames\n");
|
return NOERROR;
|
}
|
|
|
|
int
|
WaveAudioSink::BeginAudioRender()
|
{
|
tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "BeginAudioRender\n");
|
HRESULT result = NOERROR;
|
|
tracer.tracef(SDI_LEVEL_DETAILED, "BeginAudioRender : Entering freeBuffersMutex\n");
|
EnterCriticalSection(&freeBuffersMutex);
|
freeBuffers.clear();
|
LeaveCriticalSection(&freeBuffersMutex);
|
tracer.tracef(SDI_LEVEL_DETAILED, "BeginAudioRender : Left freeBuffersMutex\n");
|
|
MMRESULT mr = NOERROR;
|
WaveFormat::TraceFormat(&tracer, ARB, wfx);
|
tracer.tracef(SDI_LEVEL_ARBITRARY, "BeginAudioRender : waveOutOpen\n");
|
mr = waveOutOpen(&hWaveOut, waveoutDeviceID, &wfx, (DWORD)SpeakerCallback, DWORD(this), CALLBACK_FUNCTION);
|
tracer.tracef(SDI_LEVEL_ARBITRARY, "BeginAudioRender : ~waveOutOpen\n");
|
if (mr != NOERROR)
|
{
|
tracer.tracef(SDI_LEVEL_ERROR, "BeginAudioRender : e-waveOutOpen : 0x%x\n", mr);
|
WaveFormat::TraceFormat(&tracer, ERR, wfx);
|
Sleep(1000);
|
tracer.tracef(SDI_LEVEL_ERROR, "BeginAudioRender : waveOutOpen : 2nd try\n");
|
mr = waveOutOpen(&hWaveOut, waveoutDeviceID, &wfx, (DWORD)SpeakerCallback, DWORD(this), CALLBACK_FUNCTION);
|
tracer.tracef(SDI_LEVEL_ERROR, "BeginAudioRender : ~waveOutOpen : returned 0x%x\n", mr);
|
if (mr != NOERROR)
|
{
|
tracer.tracef(SDI_LEVEL_ERROR, "BeginAudioRender : e-waveOutOpen : 0x%x\n", mr);
|
WaveFormat::TraceFormat(&tracer, ERR, wfx);
|
result = -10;
|
}
|
}
|
if (result == 0)
|
{
|
for (int i=0; i<numFrames; i++)
|
{
|
memset(&(waveHdr[i]), 0, sizeof(waveHdr[i]));
|
waveHdr[i].lpData = dataBuffer[i];
|
waveHdr[i].dwBufferLength = frameSize;
|
waveHdr[i].dwFlags = 0;
|
waveHdr[i].dwUser = i;
|
|
tracer.tracef(SDI_LEVEL_ARBITRARY, "BeginAudioRender : waveOutPrepareHeader\n");
|
result = waveOutPrepareHeader(hWaveOut, &(waveHdr[i]), sizeof(waveHdr[i]));
|
tracer.tracef(SDI_LEVEL_ARBITRARY, "BeginAudioRender : ~waveOutPrepareHeader\n");
|
if (result != MMSYSERR_NOERROR)
|
{
|
tracer.tracef(SDI_LEVEL_ERROR, "BeginAudioRender : e-waveOutPrepareHeader : 0x%x\n", result);
|
}
|
else
|
{
|
tracer.tracef(SDI_LEVEL_ARBITRARY, "BeginAudioRender : Entering freeBuffersMutex\n");
|
EnterCriticalSection(&freeBuffersMutex);
|
freeBuffers.push_back(&(waveHdr[i]));
|
LeaveCriticalSection(&freeBuffersMutex);
|
}
|
}
|
}
|
if (result == 0)
|
{
|
tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~BeginAudioRender : returning %d 0x%x\n", result, result);
|
}
|
else
|
{
|
tracer.tracef(ERR, "~BeginAudioRender : returning %d 0x%x\n", result, result);
|
}
|
return result;
|
}
|
|
|
int
|
WaveAudioSink::EndAudioRender()
|
{
|
tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "EndAudioRender\n");
|
HRESULT result = NOERROR;
|
|
tracer.tracef(SDI_LEVEL_ARBITRARY, "EndAudioRender : waveOutReset\n");
|
result = waveOutReset(hWaveOut);
|
tracer.tracef(SDI_LEVEL_ARBITRARY, "EndAudioRender : ~waveOutReset\n");
|
if (result != MMSYSERR_NOERROR)
|
{
|
tracer.tracef(SDI_LEVEL_ERROR, "EndAudioRender : e-waveOutReset : 0x%x\n", result);
|
result = -10;
|
}
|
else
|
{
|
for (int i=0; i<numFrames; i++)
|
{
|
tracer.tracef(SDI_LEVEL_ARBITRARY, "EndAudioRender : waveOutUnprepareHeader\n");
|
result = waveOutUnprepareHeader(hWaveOut, &(waveHdr[i]), sizeof(waveHdr[i]));
|
tracer.tracef(SDI_LEVEL_ARBITRARY, "EndAudioRender : ~waveOutUnprepareHeader\n");
|
if (result != MMSYSERR_NOERROR)
|
{
|
tracer.tracef(SDI_LEVEL_ERROR, "EndAudioRender : e-waveOutUnprepareHeader : 0x%x\n", result);
|
}
|
}
|
tracer.tracef(SDI_LEVEL_ARBITRARY, "EndAudioRender : waveOutClose\n");
|
result = waveOutClose(hWaveOut);
|
tracer.tracef(SDI_LEVEL_ARBITRARY, "EndAudioRender : ~waveOutClose\n");
|
if (result != MMSYSERR_NOERROR)
|
{
|
tracer.tracef(SDI_LEVEL_ERROR, "EndAudioRender : e-waveOutClose : 0x%x\n", result);
|
result = -30;
|
}
|
}
|
tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~EndAudioRender : returning %d 0x%x\n", result, result);
|
return result;
|
}
|
|
|
int
|
WaveAudioSink::ResetAudioRender()
|
{
|
tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "ResetAudioRender\n");
|
HRESULT result = NOERROR;
|
result = EndAudioRender();
|
if (result == MMSYSERR_NOERROR)
|
{
|
result = BeginAudioRender();
|
}
|
tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~ResetAudioRender : %d 0x%x\n", result, result);
|
return result;
|
}
|
|
|
WAVEHDR *
|
WaveAudioSink::GetBuffer()
|
{
|
tracer.tracef(DET, "GetBuffer\n");
|
HRESULT result = NOERROR;
|
WAVEHDR *wHdr = NULL;
|
int bufferLength;
|
while(true) {
|
tracer.tracef(SDI_LEVEL_DETAILED, "GetBuffer : Entering dataMutex\n");
|
EnterCriticalSection(&dataMutex);
|
bool running = bRunning;
|
LeaveCriticalSection(&dataMutex);
|
tracer.tracef(SDI_LEVEL_DETAILED, "GetBuffer : Left dataMutex\n");
|
if (!running)
|
{
|
tracer.tracef(SDI_LEVEL_DETAILED, "GetBuffer : !bRunning\n");
|
break;
|
}
|
tracer.tracef(SDI_LEVEL_DETAILED, "GetBuffer : Entering freeBuffersMutex\n");
|
EnterCriticalSection(&freeBuffersMutex);
|
bufferLength = freeBuffers.size();
|
if (bufferLength > 0)
|
{
|
tracer.tracef(SDI_LEVEL_DETAILED, "GetBuffer : bufferLength > 0\n");
|
wHdr = freeBuffers.front();
|
freeBuffers.pop_front();
|
LeaveCriticalSection(&freeBuffersMutex);
|
tracer.tracef(SDI_LEVEL_DETAILED, "GetBuffer : Left freeBuffersMutex\n");
|
break;
|
}
|
else
|
{
|
tracer.tracef(SDI_LEVEL_DETAILED, "GetBuffer : bufferLength <= 0\n");
|
ResetEvent(dataEvent);
|
LeaveCriticalSection(&freeBuffersMutex);
|
tracer.tracef(SDI_LEVEL_DETAILED, "GetBuffer : Left freeBuffersMutex - waiting for dataEvent (1000 ms)\n");
|
WaitForSingleObject(dataEvent, 1000);
|
}
|
}
|
tracer.tracef(DET, "~GetBuffer\n");
|
return wHdr;
|
}
|
|
|
void CALLBACK
|
WaveAudioSink::SpeakerCallback(HWAVEOUT hWaveOut, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2) {
|
WAVEHDR *wHdr;
|
WaveAudioSink *filter = (WaveAudioSink *)dwInstance;
|
// (filter->tracer).tracef(SDI_LEVEL_ENTRY_EXIT, "SpeakerCallback\n");
|
switch(uMsg) {
|
case WOM_OPEN:
|
// (filter->tracer).tracef(SDI_LEVEL_ARBITRARY, "SpeakerCallback : WOM_OPEN\n");
|
break;
|
case WOM_CLOSE:
|
// (filter->tracer).tracef(SDI_LEVEL_ARBITRARY, "SpeakerCallback : WOM_CLOSE\n");
|
SetEvent(filter->dataEvent);
|
break;
|
case WOM_DONE:
|
(filter->tracer).tracef(SDI_LEVEL_DETAILED, "SpeakerCallback : WOM_DONE\n");
|
wHdr = (WAVEHDR *)dwParam1;
|
(filter->tracer).tracef(SDI_LEVEL_DETAILED, "SpeakerCallback : Entering freeBuffersMutex\n");
|
EnterCriticalSection(&(filter->freeBuffersMutex));
|
(filter->freeBuffers).push_back(wHdr);
|
SetEvent(filter->dataEvent); // we do this within the critsec because getbuffer resets this within the same critsec
|
LeaveCriticalSection(&(filter->freeBuffersMutex));
|
(filter->tracer).tracef(SDI_LEVEL_DETAILED, "SpeakerCallback : Left freeBuffersMutex\n");
|
break;
|
default:
|
break;
|
}
|
// (filter->tracer).tracef(SDI_LEVEL_ENTRY_EXIT, "~SpeakerCallback\n");
|
}
|
|
|
int
|
WaveAudioSink::SinkStarted()
|
{
|
int result(0);
|
int returnCode(0);
|
tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "SinkStarted\n");
|
EnterCriticalSection(&filterMutex);
|
tracer.tracef(ARB, "SinkStarted : entered filterMutex\n");
|
do
|
{
|
if (bRunning)
|
{
|
tracer.tracef(ERR, "SinkStarted : e-error : already running\n");
|
result = -10;
|
break;
|
}
|
returnCode = BeginAudioRender();
|
if (returnCode != 0)
|
{
|
tracer.tracef(ERR, "SinkStarted : e-BeginAudioRender : %d 0x%x\n", returnCode, returnCode);
|
result = -20;
|
break;
|
}
|
bRunning = true;
|
}
|
while (false);
|
|
LeaveCriticalSection(&filterMutex);
|
tracer.tracef(ARB, "SinkStarted : left filterMutex\n");
|
tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~SinkStarted : returning %d\n", result);
|
return result;
|
}
|
|
|
int
|
WaveAudioSink::SinkStopped()
|
{
|
int result(0);
|
int returnCode(0);
|
tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "SinkStopped\n");
|
EnterCriticalSection(&filterMutex);
|
tracer.tracef(ARB, "SinkStopped : entered filterMutex\n");
|
do
|
{
|
if (!bRunning)
|
{
|
tracer.tracef(ERR, "SinkStopped : e-error : not running\n");
|
result = -10;
|
break;
|
}
|
returnCode = EndAudioRender();
|
if (returnCode != 0)
|
{
|
tracer.tracef(ERR, "SinkStopped : e-EndAudioRender : %d 0x%x\n", returnCode, returnCode);
|
result = -20;
|
break;
|
}
|
bRunning = false;
|
}
|
while (false);
|
LeaveCriticalSection(&filterMutex);
|
tracer.tracef(ARB, "SinkStopped : left filterMutex\n");
|
tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~SinkStopped : returning %d\n", result);
|
return result;
|
}
|
|
int
|
WaveAudioSink::SinkThreadStarted(HANDLE sourceThreadHandle, DWORD sourceThreadID)
|
{
|
int result(0);
|
int returnCode(0);
|
SetTraceLevel();
|
tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "SinkThreadStarted\n");
|
EnterCriticalSection(&filterMutex);
|
tracer.tracef(ARB, "SinkThreadStarted : entered filterMutex\n");
|
do
|
{
|
returnCode = SetThreadPriority(sinkThreadHandle, THREAD_PRIORITY_TIME_CRITICAL);
|
if (returnCode == 0)
|
{
|
returnCode = GetLastError();
|
tracer.tracef(ERR, "SinkThreadStarted : e-SetThreadPriority : %d 0x%x\n", returnCode, returnCode);
|
}
|
returnCode = BeginAudioRender();
|
if (returnCode != 0)
|
{
|
tracer.tracef(ERR, "SinkThreadStarted : e-BeginAudioRender : %d 0x%x\n", returnCode, returnCode);
|
result = -10;
|
break;
|
}
|
bRunning = true;
|
}
|
while (false);
|
LeaveCriticalSection(&filterMutex);
|
tracer.tracef(ARB, "SinkThreadStarted : left filterMutex\n");
|
tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~SinkThreadStarted : returning %d\n", result);
|
return result;
|
}
|
|
int
|
WaveAudioSink::SinkThreadStopped(HANDLE sourceThreadHandle, DWORD sourceThreadID)
|
{
|
int result(0);
|
int returnCode(0);
|
tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "SinkThreadStopped\n");
|
EnterCriticalSection(&filterMutex);
|
tracer.tracef(ARB, "SinkThreadStopped : entered filterMutex\n");
|
do
|
{
|
if (!bRunning)
|
{
|
tracer.tracef(ERR, "SinkThreadStopped : not running\n");
|
result = -10;
|
break;
|
}
|
returnCode = EndAudioRender();
|
if (returnCode != 0)
|
{
|
tracer.tracef(ERR, "SinkThreadStopped : e-EndAudioRender : %d 0x%x\n", returnCode, returnCode);
|
result = -20;
|
break;
|
}
|
bRunning = false;
|
}
|
while (false);
|
LeaveCriticalSection(&filterMutex);
|
tracer.tracef(ARB, "SinkThreadStopped : left filterMutex\n");
|
tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~SinkThreadStopped : returning %d\n", result);
|
return result;
|
}
|
|
int
|
WaveAudioSink::SetDeviceID(unsigned int deviceID)
|
{
|
waveoutDeviceID = deviceID;
|
return 0;
|
}
|
|
unsigned int
|
WaveAudioSink::GetDeviceID()
|
{
|
return (unsigned int)waveoutDeviceID;
|
}
|
|
int
|
WaveAudioSink::SetFormat(int waveFormatNumber)
|
{
|
tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "SetFormat %d\n", waveFormatNumber);
|
wfx = WaveFormat::GetWaveFormat(waveFormatNumber);
|
tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "~SetFormat\n");
|
return 0;
|
}
|
|
|
int
|
WaveAudioSink::RenderAudioSamples(std::vector<std::pair<AudioSample*, AudioSource* > > &data)
|
{
|
tracer.tracef(SDI_LEVEL_DETAILED, "RenderAudioSamples\n");
|
HRESULT result = NOERROR;
|
AudioSample *sample = NULL;
|
if (data.size() > 0)
|
{
|
sample = data[0].first;
|
}
|
else
|
{
|
Sleep(5);
|
}
|
if (sample)
|
{
|
WAVEHDR *wHdr = GetBuffer();
|
if (!wHdr)
|
{
|
Sleep(5);
|
result = -10;
|
}
|
else
|
{
|
int bytesToPlay;
|
if (sample->DataSize() > 0)
|
{
|
bytesToPlay = min(frameSize, sample->DataSize());
|
tracer.tracef(SDI_LEVEL_DETAILED, "RenderAudioSamples : memcpy(0x%x, 0x%x, %d)\n", wHdr->lpData, sample->Data(), bytesToPlay);
|
memcpy(wHdr->lpData, sample->Data(), bytesToPlay);
|
}
|
else
|
{
|
bytesToPlay = min(frameSize, sample->SilenceSize());
|
tracer.tracef(SDI_LEVEL_DETAILED, "RenderAudioSamples : memset(0x%x, 0, %d)\n", wHdr->lpData, bytesToPlay);
|
memset(wHdr->lpData, 0, bytesToPlay);
|
}
|
wHdr->dwBufferLength = bytesToPlay;
|
tracer.tracef(SDI_LEVEL_DETAILED, "RenderAudioSamples : Entering dataMutex\n");
|
EnterCriticalSection(&dataMutex);
|
tracer.tracef(SDI_LEVEL_DETAILED, "RenderAudioSamples : waveOutWrite\n");
|
MMRESULT mmr = waveOutWrite(hWaveOut, wHdr, sizeof(*wHdr));
|
tracer.tracef(SDI_LEVEL_DETAILED, "RenderAudioSamples : ~waveOutWrite\n");
|
LeaveCriticalSection(&dataMutex);
|
tracer.tracef(SDI_LEVEL_DETAILED, "RenderAudioSamples : Left dataMutex\n");
|
}
|
}
|
tracer.tracef(SDI_LEVEL_DETAILED, "~RenderAudioSamples\n");
|
return result;
|
}
|
