// ACMTransformer.cpp: implementation of the ACMTransformer class.
|
//
|
//////////////////////////////////////////////////////////////////////
|
|
#include <windows.h>
|
#include <algorithm>
|
|
#include "ACMTransformer.h"
|
#include "AudioSampleManager.h"
|
#include "AudioSample.h"
|
|
using namespace std;
|
|
//////////////////////////////////////////////////////////////////////
|
// Construction/Destruction
|
//////////////////////////////////////////////////////////////////////
|
|
ACMTransformer::ACMTransformer()
|
{
|
SetSourceFormat(WaveFormat::GetWaveFormat(WaveFormat_PCM_16_8_1));
|
SetDestinationFormat(WaveFormat::GetWaveFormat(WaveFormat_PCM_16_8_1));
|
InitializeCriticalSection(&outputQueueMutex);
|
InitializeCriticalSection(&freeBuffersMutex);
|
InitializeCriticalSection(&stateMutex);
|
InitializeCriticalSection(&acmMutex);
|
InitializeCriticalSection(&queryStateMutex);
|
freeBuffersEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
|
outputEnqueueEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
|
outputDequeueEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
|
SetOutputDuration(20);
|
char subFacilityName[100];
|
sprintf(subFacilityName, "ACMTransformer:%x", this);
|
tracer.SetSubFacilityName(subFacilityName);
|
SetRunning(false);
|
SetTraceLevel();
|
}
|
|
ACMTransformer::~ACMTransformer()
|
{
|
tracer.tracef(EE, "~ACMTransformer : begin\n");
|
DeleteCriticalSection(&outputQueueMutex);
|
DeleteCriticalSection(&freeBuffersMutex);
|
DeleteCriticalSection(&stateMutex);
|
DeleteCriticalSection(&acmMutex);
|
DeleteCriticalSection(&queryStateMutex);
|
CloseHandle(freeBuffersEvent);
|
CloseHandle(outputEnqueueEvent);
|
CloseHandle(outputDequeueEvent);
|
tracer.tracef(EE, "~ACMTransformer : end\n");
|
}
|
|
int
|
ACMTransformer::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", "ACMTransformer", 0x100000);
|
}
|
tracer.SetSystemMask(SystemMask);
|
return 0;
|
}
|
|
int
|
ACMTransformer::SetSourceFormat(WAVEFORMATEX &wfxSource)
|
{
|
sourceFormat = wfxSource;
|
return 0;
|
}
|
|
int
|
ACMTransformer::SetDestinationFormat(WAVEFORMATEX &wfxDest)
|
{
|
destFormat = wfxDest;
|
return 0;
|
}
|
|
int
|
ACMTransformer::TransformStarted()
|
{
|
tracer.tracef(EE, "TransformStarted\n");
|
int result(0);
|
tracer.tracef(ARB, "TransformStarted : entering stateMutex\n");
|
EnterCriticalSection(&stateMutex);
|
if (IsRunning())
|
{
|
tracer.tracef(SIG, "TransformStarted : Already running\n");
|
}
|
else
|
{
|
EnterCriticalSection(&acmMutex);
|
WaveFormat::TraceFormat(&tracer, ARB, sourceFormat);
|
WaveFormat::TraceFormat(&tracer, ARB, destFormat);
|
tracer.tracef(ARB, "TransformStarted : calling acmStreamOpen\n");
|
result = acmStreamOpen(&hACMStream, NULL, &sourceFormat, &destFormat, NULL, 0, 0, ACM_STREAMOPENF_NONREALTIME);
|
LeaveCriticalSection(&acmMutex);
|
if (result == 0)
|
{
|
for (int i=0; i<ACMTRANSFORMER_NUM_STREAMHEADER; i++)
|
{
|
tracer.tracef(ARB, "TransformStarted : preparing acm header %d\n", i);
|
memset(&acmStreamHeader[i], 0, sizeof(acmStreamHeader[i]));
|
acmStreamHeader[i].cbStruct = sizeof(acmStreamHeader[i]);
|
acmStreamHeader[i].fdwStatus = 0;
|
acmStreamHeader[i].pbSrc = sourceBuffer[i];
|
acmStreamHeader[i].cbSrcLength = ACMTRANSFORMER_MAX_SOURCEBUFFERSIZE;
|
acmStreamHeader[i].pbDst = destBuffer[i];
|
acmStreamHeader[i].cbDstLength = ACMTRANSFORMER_MAX_DESTBUFFERSIZE;
|
EnterCriticalSection(&acmMutex);
|
tracer.tracef(ARB, "TransformStarted : calling acmStreamPrepareHeader\n");
|
result = acmStreamPrepareHeader(hACMStream, &acmStreamHeader[i], 0);
|
LeaveCriticalSection(&acmMutex);
|
tracer.tracef(ARB, "TransformStarted : acmStreamPrepareHeader returned %d 0x%x\n", result, result);
|
acmStreamHeader[i].cbSrcLength = 0; // to show that no unconverted data
|
acmStreamHeader[i].cbSrcLengthUsed = 0;
|
if (result == 0)
|
{
|
ReleaseBuffer(&acmStreamHeader[i]); // adds it to the free buffer
|
SetRunning(true);
|
}
|
}
|
if (!IsRunning())
|
{
|
acmStreamClose(hACMStream, 0);
|
}
|
}
|
else
|
{
|
tracer.tracef(ERR, "TransformStarted : acmStreamOpen failed with error code %d 0x%x\n", result, result);
|
WaveFormat::TraceFormat(&tracer, ERR, sourceFormat);
|
WaveFormat::TraceFormat(&tracer, ERR, destFormat);
|
result = -10;
|
}
|
}
|
LeaveCriticalSection(&stateMutex);
|
tracer.tracef(ARB, "TransformStarted : left stateMutex\n");
|
if (result != 0)
|
{
|
tracer.tracef(ERR, "~TransformStarted : error %d. bRunning = %d\n", result, bRunning);
|
}
|
else
|
{
|
tracer.tracef(EE, "~TransformStarted : bRunning = %d\n", bRunning);
|
}
|
return result;
|
}
|
|
int
|
ACMTransformer::TransformStopped()
|
{
|
tracer.tracef(EE, "TransformStopped\n");
|
int result(0);
|
tracer.tracef(ARB, "TransformStopped : entering stateMutex\n");
|
EnterCriticalSection(&stateMutex);
|
if (!IsRunning())
|
{
|
tracer.tracef(SIG, "TransformStarted : Already stopped\n");
|
}
|
else
|
{
|
// if there is no input pin, then wait for buffered data to clear
|
int numSources = audioSources.size();
|
int numDest = audioSinks.size();
|
if (numSources == 0 && numDest > 0)
|
{
|
tracer.tracef(ARB, "TransformStopped : numSources = 0 & numDest = %d\n", numDest);
|
AudioSample *audioSample = NULL;
|
AudioSampleManager::GetInstance()->GetAudioSample(&audioSample, this);
|
if (audioSample)
|
{
|
audioSample->SetFormat(destFormat);
|
int minFrameSize = (audioSample->MinFrameSize() * outputDuration * 1000) / audioSample->MinFrameDuration();
|
while (true)
|
{
|
tracer.tracef(ARB, "TransformStopped : entering outputQueueMutex\n");
|
EnterCriticalSection(&outputQueueMutex);
|
if (outputQueue.size() < minFrameSize)
|
{
|
LeaveCriticalSection(&outputQueueMutex);
|
tracer.tracef(ARB, "TransformStopped : left outputQueueMutex\n");
|
break;
|
}
|
LeaveCriticalSection(&outputQueueMutex);
|
tracer.tracef(ARB, "TransformStopped : left outputQueueMutex. Begin waiting on outputDequeueEvent\n");
|
WaitForSingleObject(outputDequeueEvent, INFINITE);
|
tracer.tracef(ARB, "TransformStopped : after waiting on outputDequeueEvent\n");
|
}
|
audioSample->Release(this);
|
audioSample = NULL;
|
}
|
}
|
|
SetRunning(false);
|
tracer.tracef(ARB, "TransformStopped : entered freeBuffersMutex\n");
|
EnterCriticalSection(&freeBuffersMutex);
|
freeBuffers.clear();
|
SetEvent(freeBuffersEvent);
|
tracer.tracef(ARB, "TransformStopped : set freeBuffersEvent\n");
|
LeaveCriticalSection(&freeBuffersMutex);
|
tracer.tracef(ARB, "TransformStopped : left freeBuffersMutex\n");
|
|
tracer.tracef(ARB, "TransformStopped : entering outputQueueMutex\n");
|
EnterCriticalSection(&outputQueueMutex);
|
SetEvent(outputEnqueueEvent);
|
tracer.tracef(ARB, "TransformStopped : set outputEnqueueEvent\n");
|
SetEvent(outputDequeueEvent);
|
tracer.tracef(ARB, "TransformStopped : set outputDequeueEvent\n");
|
LeaveCriticalSection(&outputQueueMutex);
|
tracer.tracef(ARB, "TransformStopped : left outputQueueMutex. Unpreparing ACM headers\n");
|
|
for (int i=0; i<ACMTRANSFORMER_NUM_STREAMHEADER; i++)
|
{
|
acmStreamHeader[i].cbSrcLength = ACMTRANSFORMER_MAX_SOURCEBUFFERSIZE;
|
acmStreamHeader[i].cbDstLength = ACMTRANSFORMER_MAX_DESTBUFFERSIZE;
|
EnterCriticalSection(&acmMutex);
|
tracer.tracef(ARB, "TransformStopped : calling acmStreamUnprepareHeader\n");
|
result = acmStreamUnprepareHeader(hACMStream, &acmStreamHeader[i], 0);
|
LeaveCriticalSection(&acmMutex);
|
if (result != 0)
|
{
|
tracer.tracef(ERR, "TransformStopped : acmStreamUnprepareHeader returned %d 0x%x\n", result, result);
|
}
|
}
|
tracer.tracef(ARB, "TransformStopped : done unpreparing ACM headers\n");
|
EnterCriticalSection(&acmMutex);
|
tracer.tracef(ARB, "TransformStopped : calling acmStreamClose\n");
|
result = acmStreamClose(hACMStream, 0);
|
LeaveCriticalSection(&acmMutex);
|
if (result != 0)
|
{
|
tracer.tracef(ERR, "TransformStopped : acmStreamClose returned %d 0x%x\n", result, result);
|
}
|
}
|
LeaveCriticalSection(&stateMutex);
|
tracer.tracef(ARB, "TransformStopped : left stateMutex\n");
|
tracer.tracef(EE, "~TransformStopped : bRunning = %d\n", bRunning);
|
return result;
|
}
|
|
int
|
ACMTransformer::FlushBuffer()
|
{
|
tracer.tracef(DET, "FlushBuffer : entering outputQueueMutex\n");
|
EnterCriticalSection(&outputQueueMutex);
|
int numBytes = outputQueue.size();
|
for (int i=0; i<numBytes; i++)
|
{
|
outputQueue.pop();
|
}
|
LeaveCriticalSection(&outputQueueMutex);
|
tracer.tracef(DET, "FlushBuffer : left outputQueueMutex\n");
|
SetEvent(outputDequeueEvent);
|
tracer.tracef(DET, "FlushBuffer : set outputDequeueEvent\n");
|
return 0;
|
}
|
|
int
|
ACMTransformer::TransformAudioSamples(std::vector<std::pair<AudioSample *, AudioSource *> > &data, AudioSample **ppAudioSample)
|
{
|
return 0;
|
}
|
|
bool
|
ACMTransformer::IsRunning()
|
{
|
EnterCriticalSection(&queryStateMutex);
|
bool result = bRunning;
|
LeaveCriticalSection(&queryStateMutex);
|
return result;
|
}
|
|
void
|
ACMTransformer::SetRunning(bool running)
|
{
|
EnterCriticalSection(&queryStateMutex);
|
bRunning = running;
|
LeaveCriticalSection(&queryStateMutex);
|
}
|
|
ACMSTREAMHEADER *
|
ACMTransformer::GetBuffer()
|
{
|
ACMSTREAMHEADER *acmHdr = NULL;
|
while(IsRunning())
|
{
|
tracer.tracef(ARB, "GetBuffer : entering freeBuffersMutex\n");
|
EnterCriticalSection(&freeBuffersMutex);
|
if (freeBuffers.size() > 0)
|
{
|
acmHdr = freeBuffers.front();
|
freeBuffers.pop_front();
|
LeaveCriticalSection(&freeBuffersMutex);
|
tracer.tracef(ARB, "GetBuffer : left freeBuffersMutex\n");
|
break;
|
}
|
else
|
{
|
LeaveCriticalSection(&freeBuffersMutex);
|
tracer.tracef(ARB, "GetBuffer : left freeBuffersMutex\n");
|
tracer.tracef(ARB, "GetBuffer : before waiting for freeBuffersEvent\n");
|
WaitForSingleObject(freeBuffersEvent, INFINITE);
|
tracer.tracef(ARB, "GetBuffer : after waiting for freeBuffersEvent\n");
|
}
|
}
|
return acmHdr;
|
}
|
|
void
|
ACMTransformer::ReleaseBuffer(ACMSTREAMHEADER *acmHdr)
|
{
|
tracer.tracef(ARB, "ReleaseBuffer : entering freeBuffersMutex\n");
|
EnterCriticalSection(&freeBuffersMutex);
|
freeBuffers.push_back(acmHdr);
|
SetEvent(freeBuffersEvent);
|
tracer.tracef(ARB, "ReleaseBuffer : set freeBuffersEvent\n");
|
LeaveCriticalSection(&freeBuffersMutex);
|
tracer.tracef(ARB, "ReleaseBuffer : left freeBuffersMutex\n");
|
}
|
|
int
|
ACMTransformer::RenderAudioSamples(std::vector<std::pair<AudioSample *, AudioSource *> > &data)
|
{
|
tracer.tracef(DET, "RenderAudioSamples\n");
|
int result(0);
|
AudioSample *inSample = NULL;
|
if (data.size() > 0)
|
{
|
inSample = data[0].first;
|
}
|
if (inSample && IsRunning())
|
{
|
if (inSample->DataSize() > 0)
|
{
|
ACMSTREAMHEADER *acmHdr = GetBuffer();
|
if (acmHdr)
|
{
|
int extraBytes = acmHdr->cbSrcLength - acmHdr->cbSrcLengthUsed;
|
int totalBytes = inSample->DataSize() + extraBytes;
|
if ( totalBytes > 0 && totalBytes <= ACMTRANSFORMER_MAX_SOURCEBUFFERSIZE)
|
{
|
acmHdr->cbSrcLength = totalBytes;
|
memcpy(acmHdr->pbSrc, acmHdr->pbSrc + acmHdr->cbSrcLengthUsed, extraBytes);
|
memcpy(acmHdr->pbSrc + extraBytes, inSample->Data(), inSample->DataSize());
|
EnterCriticalSection(&acmMutex);
|
result = acmStreamConvert(hACMStream, acmHdr, ACM_STREAMCONVERTF_BLOCKALIGN);
|
if (result != 0)
|
{
|
LeaveCriticalSection(&acmMutex);
|
ReleaseBuffer(acmHdr);
|
tracer.tracef(ERR, "RenderAudioSamples : acmStreamConvert failed with error code %d 0x%x\n", result, result);
|
result = -10;
|
Sleep(outputDuration);
|
}
|
else if (acmHdr->cbDstLengthUsed > 0)
|
{
|
unsigned char convertedData[ACMTRANSFORMER_MAX_DESTBUFFERSIZE];
|
memcpy(convertedData, acmHdr->pbDst, acmHdr->cbDstLengthUsed);
|
LeaveCriticalSection(&acmMutex);
|
ReleaseBuffer(acmHdr);
|
AddConvertedData(convertedData, acmHdr->cbDstLengthUsed);
|
// AddConvertedData(acmHdr->pbDst, acmHdr->cbDstLengthUsed);
|
}
|
else
|
{
|
LeaveCriticalSection(&acmMutex);
|
ReleaseBuffer(acmHdr);
|
}
|
}
|
else
|
{
|
ReleaseBuffer(acmHdr);
|
Sleep(outputDuration);
|
result = -20;
|
}
|
}
|
else
|
{
|
Sleep(outputDuration);
|
result = -30;
|
}
|
}
|
else
|
{
|
Sleep(inSample->GetSilenceDuration());
|
result = -40;
|
}
|
}
|
else
|
{
|
Sleep(outputDuration);
|
result = -50;
|
}
|
tracer.tracef(DET, "~RenderAudioSamples : %d\n", result);
|
return result;
|
}
|
|
int
|
ACMTransformer::GenerateData(AudioSample **ppAudioSample)
|
{
|
tracer.tracef(DET, "GenerateData\n");
|
int result(0);
|
*ppAudioSample = NULL;
|
AudioSample *audioSample = NULL;
|
(AudioSampleManager::GetInstance())->GetAudioSample(&audioSample, this);
|
if (audioSample)
|
{
|
audioSample->SetFormat(destFormat);
|
audioSample->SetDataSize(0);
|
audioSample->SetSilenceDuration(outputDuration);
|
int numBytesToWrite = (audioSample->MinFrameSize() * outputDuration * 1000) / audioSample->MinFrameDuration();
|
|
if (IsRunning())
|
{
|
tracer.tracef(DET, "GenerateData : entering outputQueueMutex. Filter running\n");
|
EnterCriticalSection(&outputQueueMutex);
|
if (outputQueue.size() < numBytesToWrite)
|
{
|
LeaveCriticalSection(&outputQueueMutex);
|
tracer.tracef(DET, "GenerateData : left outputQueueMutex\n");
|
result = -10;
|
}
|
else
|
{
|
int numBytesToCopy = min(numBytesToWrite, audioSample->BufferSize());
|
for (int i=0; i<numBytesToCopy; i++)
|
{
|
unsigned char c = outputQueue.front();
|
outputQueue.pop();
|
(audioSample->Data())[i] = c;
|
}
|
SetEvent(outputDequeueEvent);
|
tracer.tracef(DET, "GenerateData : set outputDequeueEvent\n");
|
LeaveCriticalSection(&outputQueueMutex);
|
tracer.tracef(DET, "GenerateData : left outputQueueMutex\n");
|
audioSample->SetDataSize(numBytesToCopy);
|
}
|
}
|
else
|
{
|
tracer.tracef(DET, "GenerateData : entering outputQueueMutex\n");
|
EnterCriticalSection(&outputQueueMutex);
|
SetEvent(outputDequeueEvent);
|
tracer.tracef(DET, "GenerateData : set outputDequeueEvent\n");
|
LeaveCriticalSection(&outputQueueMutex);
|
tracer.tracef(DET, "GenerateData : left outputQueueMutex\n");
|
result = -20;
|
}
|
}
|
else
|
{
|
tracer.tracef(ERR, "GenerateData : could not get audioSample from manager\n");
|
result = -30;
|
}
|
if (result != 0)
|
{
|
if (audioSample)
|
{
|
audioSample->Release(this);
|
audioSample = NULL;
|
}
|
}
|
*ppAudioSample = audioSample;
|
if (result == 0)
|
{
|
tracer.tracef(DET, "~GenerateData : 0x%x\n", *ppAudioSample);
|
}
|
else
|
{
|
tracer.tracef(ERR, "~GenerateData : %d, 0x%x\n", result, *ppAudioSample);
|
}
|
|
return result;
|
}
|
|
int
|
ACMTransformer::AddConvertedData(unsigned char *dataIn, int numBytes)
|
{
|
while (true)
|
{
|
if (IsRunning())
|
{
|
tracer.tracef(DET, "AddConvertedData : entering outputQueueMutex\n");
|
EnterCriticalSection(&outputQueueMutex);
|
int queueSpace = ACMTRANSFORMER_OUTPUTBUFFERSIZE - outputQueue.size();
|
if (queueSpace >= numBytes)
|
{
|
for (int i=0; i<numBytes; i++)
|
{
|
outputQueue.push(dataIn[i]);
|
}
|
SetEvent(outputEnqueueEvent);
|
tracer.tracef(DET, "AddConvertedData : set outputEnqueueEvent\n");
|
LeaveCriticalSection(&outputQueueMutex);
|
tracer.tracef(DET, "AddConvertedData : left outputQueueMutex\n");
|
break;
|
}
|
else
|
{
|
LeaveCriticalSection(&outputQueueMutex);
|
tracer.tracef(DET, "AddConvertedData : left outputQueueMutex. Begin waiting on outputDequeueEvent\n");
|
WaitForSingleObject(outputDequeueEvent, INFINITE);
|
tracer.tracef(DET, "AddConvertedData : after waiting on outputDequeueEvent\n");
|
}
|
}
|
else
|
{
|
tracer.tracef(DET, "AddConvertedData : entering outputQueueMutex\n");
|
EnterCriticalSection(&outputQueueMutex);
|
SetEvent(outputEnqueueEvent);
|
tracer.tracef(DET, "AddConvertedData : set outputEnqueueEvent\n");
|
LeaveCriticalSection(&outputQueueMutex);
|
tracer.tracef(DET, "AddConvertedData : left outputQueueMutex\n");
|
break;
|
}
|
}
|
return 0;
|
}
|
|
int
|
ACMTransformer::SetOutputDuration(int millisecs)
|
{
|
outputDuration = millisecs;
|
return 0;
|
}
|
|
void CALLBACK
|
ACMTransformer::ACMCallback(HACMSTREAM has, UINT uMsg, DWORD dwInstance, LPARAM lParam1, LPARAM lParam2)
|
{
|
ACMTransformer *acmTransformer = (ACMTransformer *)dwInstance;
|
ACMSTREAMHEADER *acmHdr = (ACMSTREAMHEADER *)lParam1;
|
switch(uMsg)
|
{
|
case MM_ACM_OPEN:
|
break;
|
case MM_ACM_CLOSE:
|
break;
|
case MM_ACM_DONE:
|
if (acmHdr->cbDstLengthUsed > 0)
|
{
|
acmTransformer->AddConvertedData(acmHdr->pbDst, acmHdr->cbDstLengthUsed);
|
}
|
acmTransformer->ReleaseBuffer(acmHdr);
|
break;
|
default:
|
break;
|
}
|
}
|
