// AudioSample.cpp: implementation of the AudioSample class.
|
//
|
//////////////////////////////////////////////////////////////////////
|
|
#include "RTPPacket.h"
|
#include "AudioSample.h"
|
#include "AudioSampleManager.h"
|
#include "Parameters.h"
|
|
//////////////////////////////////////////////////////////////////////
|
// Construction/Destruction
|
//////////////////////////////////////////////////////////////////////
|
|
AudioSample::AudioSample(AudioSampleManager *audioSampleManager, int size = DEFAULT_AUDIOSAMPLE_BUFFERSIZE)
|
{
|
InitializeCriticalSection(&sampleMutex);
|
Initialize(audioSampleManager, size);
|
}
|
|
|
AudioSample::AudioSample(AudioSampleManager *audioSampleManager)
|
{
|
InitializeCriticalSection(&sampleMutex);
|
Initialize(audioSampleManager, DEFAULT_AUDIOSAMPLE_BUFFERSIZE);
|
}
|
|
AudioSample::~AudioSample()
|
{
|
EnterCriticalSection(&sampleMutex);
|
if (data)
|
{
|
delete [] data;
|
}
|
if (rtpHeader)
|
{
|
delete rtpHeader;
|
}
|
LeaveCriticalSection(&sampleMutex);
|
DeleteCriticalSection(&sampleMutex);
|
}
|
|
bool
|
AudioSample::operator < (AudioSample &a )
|
{
|
if (!a.RTPHeader() || !this->RTPHeader())
|
{
|
return false;
|
}
|
unsigned long timestamp1 = (a.RTPHeader())->Timestamp();
|
unsigned long timestamp2 = (this->RTPHeader())->Timestamp();
|
unsigned long timediff = timestamp1 > timestamp2 ? timestamp1 - timestamp2 : timestamp2 - timestamp1;
|
if (timestamp2 != timestamp1)
|
{
|
|
return timediff < 0x8fffffff ? (timestamp2 < timestamp1) : (timestamp1 < timestamp2);
|
}
|
else
|
{
|
unsigned short seqno1 = (a.RTPHeader())->SeqNo();
|
unsigned short seqno2 = (this->RTPHeader())->SeqNo();
|
unsigned short seqdiff = seqno1 > seqno2 ? seqno1 - seqno2 : seqno2 - seqno1;
|
return seqdiff < 0x8fff ? (seqno2 < seqno1) : (seqno1 < seqno2);
|
}
|
}
|
|
bool
|
AudioSample::operator >= (AudioSample &a )
|
{
|
return !(*this < a);
|
}
|
|
int
|
AudioSample::Initialize(AudioSampleManager *audioSampleManager, int size)
|
{
|
EnterCriticalSection(&sampleMutex);
|
data = new char[size];
|
rtpHeader = NULL;
|
bufferSize = size;
|
dataSize = 0;
|
refCount = 0;
|
manager = audioSampleManager;
|
char subFacilityName[100];
|
sprintf(subFacilityName, "AudioSample:%x", this);
|
tracer.SetSubFacilityName(subFacilityName);
|
SetTraceLevel();
|
LeaveCriticalSection(&sampleMutex);
|
return 0;
|
}
|
|
int
|
AudioSample::Uninitialize()
|
{
|
if (rtpHeader)
|
{
|
delete rtpHeader;
|
rtpHeader = NULL;
|
dataSize = 0;
|
}
|
return 0;
|
}
|
|
int
|
AudioSample::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", "AudioSample", EE);
|
}
|
tracer.SetSystemMask(SystemMask);
|
return 0;
|
}
|
|
int
|
AudioSample::BufferSize()
|
{
|
return bufferSize;
|
}
|
|
int
|
AudioSample::DataSize()
|
{
|
return dataSize;
|
}
|
|
int
|
AudioSample::SilenceSize()
|
{
|
return (silenceLengthMilliseconds * 1000 * minFrameSize) / minFrameDuration; // silenceDuration is in millisecs, minFrameDuration is in microsecs
|
}
|
|
char *
|
AudioSample::Data()
|
{
|
return data;
|
}
|
|
RTPPacket *
|
AudioSample::RTPHeader()
|
{
|
EnterCriticalSection(&sampleMutex);
|
RTPPacket *header = rtpHeader;
|
LeaveCriticalSection(&sampleMutex);
|
return header;
|
}
|
|
int
|
AudioSample::SetRTPHeader(RTPPacket *headerPtr)
|
{
|
EnterCriticalSection(&sampleMutex);
|
if (rtpHeader)
|
{
|
delete rtpHeader;
|
}
|
rtpHeader = headerPtr;
|
LeaveCriticalSection(&sampleMutex);
|
return 0;
|
}
|
|
int
|
AudioSample::AddRef()
|
{
|
EnterCriticalSection(&sampleMutex);
|
int result(0);
|
result = ++refCount;
|
LeaveCriticalSection(&sampleMutex);
|
return result;
|
}
|
|
int
|
AudioSample::AddRef(TraceUser *container)
|
{
|
EnterCriticalSection(&sampleMutex);
|
int result(0);
|
if (refCount == 0)
|
{
|
tracer.tracef(ERR, "AddRef : by 0x%x:%s on sample 0x%x with refCount = 0 !\n", container, container->TraceName(), this);
|
result = -10;
|
refCount = 1000;
|
Sleep(500);
|
}
|
else
|
{
|
result = ++refCount;
|
}
|
LeaveCriticalSection(&sampleMutex);
|
return result;
|
}
|
|
int
|
AudioSample::Release()
|
{
|
EnterCriticalSection(&sampleMutex);
|
int result = 0;
|
if (refCount > 0)
|
{
|
result = --refCount;
|
if (refCount == 0)
|
{
|
Uninitialize();
|
manager->AudioSampleReleased(this);
|
}
|
}
|
else
|
{
|
tracer.tracef(ERR, "Release : e-refCount : Error : refCount = %d\n", refCount);
|
result = -10;
|
Sleep(500);
|
}
|
LeaveCriticalSection(&sampleMutex);
|
return result;
|
}
|
|
int
|
AudioSample::Release(TraceUser *container)
|
{
|
EnterCriticalSection(&sampleMutex);
|
int result = 0;
|
if (refCount > 0)
|
{
|
result = --refCount;
|
if (refCount == 0)
|
{
|
#ifdef DEBUG_AUDIOSAMPLES
|
tracer.tracef(EE, "Release : Sample 0x%x returned to manager by 0x%x : %s\n", this, container, container->TraceName());
|
#endif
|
Uninitialize();
|
manager->AudioSampleReleased(this);
|
}
|
}
|
else
|
{
|
tracer.tracef(ERR, "Release : Sample 0x%x has invalid refCount ! by 0x%x : %s\n", this, container, container->TraceName());
|
refCount = 1000;
|
result = -10;
|
Sleep(500);
|
}
|
LeaveCriticalSection(&sampleMutex);
|
return result;
|
}
|
|
int
|
AudioSample::GetFormat(WAVEFORMATEX *waveFormat)
|
{
|
if (waveFormat != NULL)
|
{
|
*waveFormat = format;
|
}
|
return 0;
|
}
|
|
int
|
AudioSample::SetFormat(WAVEFORMATEX &waveFormat)
|
{
|
if (refCount <= 1)
|
{
|
format = waveFormat;
|
switch(format.wFormatTag)
|
{
|
case WAVE_FORMAT_PCM:
|
minFrameDuration = 1000000 / format.nSamplesPerSec; // min frame duration in microseconds
|
minFrameSize = (format.wBitsPerSample * format.nChannels) / 8; // min frame size in bytes
|
break;
|
case WAVE_FORMAT_MULAW:
|
case WAVE_FORMAT_ALAW:
|
minFrameDuration = 125;
|
minFrameSize = 1;
|
break;
|
case WAVE_FORMAT_CISCO_G729:
|
minFrameDuration = 10000; // 10ms
|
minFrameSize = 10; // 10 bytes
|
break;
|
case WAVE_FORMAT_CISCO_G723_53:
|
minFrameDuration = 30000;
|
minFrameSize = 20;
|
break;
|
case WAVE_FORMAT_CISCO_G723_63:
|
minFrameDuration = 30000;
|
minFrameSize = 24;
|
break;
|
default:
|
break;
|
}
|
}
|
else
|
{
|
tracer.tracef(ERR, "SetFormat : e-refCount : Error : refCount = %d\n", refCount);
|
}
|
return 0;
|
}
|
|
int
|
AudioSample::MinFrameDuration()
|
{
|
return minFrameDuration;
|
}
|
|
int
|
AudioSample::MinFrameSize()
|
{
|
return minFrameSize;
|
}
|
|
int
|
AudioSample::SetDataSize(int size)
|
{
|
dataSize = size;
|
if (dataSize > 0)
|
{
|
SetSilenceDuration(0);
|
}
|
return 0;
|
}
|
|
int
|
AudioSample::GetSilenceDuration()
|
{
|
// tracer.tracef(DET, "GetSilenceDuration : silenceLengthMilliseconds = %d\n", silenceLengthMilliseconds);
|
return silenceLengthMilliseconds;
|
}
|
|
int
|
AudioSample::SetSilenceDuration(int milliseconds)
|
{
|
silenceLengthMilliseconds = milliseconds;
|
return 0;
|
}
|
|
/**
|
Returns the length of audio in this frame in milliseconds
|
*/
|
int
|
AudioSample::GetDuration()
|
{
|
// tracer.tracef(DET, "GetDuration : minFrameDuration = %d, dataSize = %d, minFrameSize = %d\n", minFrameDuration, dataSize, minFrameSize);
|
return ((minFrameDuration * dataSize) / minFrameSize) / 1000; // minFrameDuration is in microsec, GetDuration returns millisec
|
}
|
