// RTPAudioStream.cpp: implementation of the RTPAudioStream class.
|
//
|
//////////////////////////////////////////////////////////////////////
|
|
#include "RTPAudioStream.h"
|
#include "Parameters.h"
|
#include "AudioSample.h"
|
#include "AudioSampleManager.h"
|
#include "RTPPacket.h"
|
|
#define STATS_INTERVAL 100
|
int avgBufferSize(0);
|
int minBufferSize(0);
|
int numRepeats(0);
|
int numPackets(0);
|
|
using namespace std;
|
|
//////////////////////////////////////////////////////////////////////
|
// Construction/Destruction
|
//////////////////////////////////////////////////////////////////////
|
|
RTPAudioStream::RTPAudioStream(unsigned long ssrc)
|
{
|
char subFacilityName[100];
|
sprintf(subFacilityName, "RTPAudioStream:%x", this);
|
tracer.SetSubFacilityName(subFacilityName);
|
SetTraceLevel();
|
dynamicJitterBuffer = GetRegKeyBool(HKEY_CURRENT_USER, "Software\\Cisco Systems\\CCNMediaTerm\\1.0", "UseDynamicJitterBuffer", true);
|
jitterBufferDepth = 0;
|
lastOutputDuration = 0;
|
lastOutputTimestamp = 0;
|
lastPacketRepeatCount = 0;
|
lastPacketTransmitted = NULL;
|
numSIDPackets = 0;
|
restartThreshold = DEFAULT_JITTERBUFFER_SIZE;
|
silenceIntervalInProgress = true;
|
this->ssrc = ssrc;
|
this->tracer = tracer;
|
InitializeCriticalSection(&packetQueueMutex);
|
InitializeCriticalSection(&audioStreamMutex);
|
}
|
|
RTPAudioStream::~RTPAudioStream()
|
{
|
EnterCriticalSection(&audioStreamMutex);
|
SetLastTransmittedPacket(NULL);
|
while (packetQueue.size() > 0)
|
{
|
AudioSample *audioSample = NULL;;
|
PopNextPacket(&audioSample);
|
audioSample->Release(this);
|
audioSample = NULL;
|
}
|
LeaveCriticalSection(&audioStreamMutex);
|
DeleteCriticalSection(&packetQueueMutex);
|
DeleteCriticalSection(&audioStreamMutex);
|
}
|
|
int
|
RTPAudioStream::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", "RTPJitterBuffer", 0x100000);
|
}
|
tracer.SetSystemMask(SystemMask);
|
return 0;
|
}
|
|
int
|
RTPAudioStream::SetRestartThreshold(int depthInMillisec)
|
{
|
EnterCriticalSection(&audioStreamMutex);
|
restartThreshold = depthInMillisec;
|
LeaveCriticalSection(&audioStreamMutex);
|
return 0;
|
}
|
|
int
|
RTPAudioStream::NumQueuedPackets()
|
{
|
EnterCriticalSection(&audioStreamMutex);
|
int numQdPackets = packetQueue.size();
|
LeaveCriticalSection(&audioStreamMutex);
|
return numQdPackets;
|
}
|
|
int
|
RTPAudioStream::JitterBufferDepth()
|
{
|
EnterCriticalSection(&audioStreamMutex);
|
int depth = jitterBufferDepth;
|
LeaveCriticalSection(&audioStreamMutex);
|
return depth;
|
}
|
|
unsigned long
|
RTPAudioStream::SSRC()
|
{
|
EnterCriticalSection(&audioStreamMutex);
|
unsigned long ssrcValue= this->ssrc;
|
LeaveCriticalSection(&audioStreamMutex);
|
return ssrcValue;
|
}
|
|
int
|
RTPAudioStream::SetLastTransmittedPacket(AudioSample *newPacket)
|
{
|
EnterCriticalSection(&audioStreamMutex);
|
if (newPacket != lastPacketTransmitted)
|
{
|
if (lastPacketTransmitted)
|
{
|
lastPacketTransmitted->Release(this);
|
lastPacketTransmitted = NULL;
|
lastPacketRepeatCount = 0;
|
}
|
lastPacketTransmitted = newPacket;
|
if (newPacket)
|
{
|
newPacket->AddRef(this);
|
}
|
}
|
LeaveCriticalSection(&audioStreamMutex);
|
return 0;
|
}
|
|
int
|
RTPAudioStream::TimeDifference(unsigned long timestamp1, unsigned long timestamp2)
|
{
|
int result(0);
|
unsigned long timediff = timestamp1 > timestamp2 ? timestamp1 - timestamp2 : timestamp2 - timestamp1;
|
if (timediff < 0x8fffffff)
|
{
|
result = timediff;
|
return timestamp1 > timestamp2 ? -result : result;
|
}
|
else
|
{
|
unsigned long temp = (0xffffffff - timediff) + 1;
|
result = temp;
|
return timestamp1 > timestamp2 ? result : -result;
|
}
|
}
|
|
int
|
RTPAudioStream::TimeDifference(AudioSample *sample1, AudioSample *sample2)
|
{
|
return TimeDifference(sample1->RTPHeader()->Timestamp(), sample2->RTPHeader()->Timestamp());
|
}
|
|
int
|
RTPAudioStream::TimeDifferenceMillisec(AudioSample *sample1, AudioSample *sample2)
|
{
|
int timestampDiff = TimeDifference(sample1, sample2);
|
return (int)(((double)timestampDiff * sample1->MinFrameDuration())/1000.0 + 0.5);
|
}
|
|
int
|
RTPAudioStream::Clear()
|
{
|
EnterCriticalSection(&audioStreamMutex);
|
while(packetQueue.size() > 0)
|
{
|
AudioSample *audioSample = NULL;
|
PopNextPacket(&audioSample);
|
if (audioSample)
|
{
|
audioSample->Release(this);
|
audioSample = NULL;
|
}
|
}
|
silenceIntervalInProgress = true;
|
SetLastTransmittedPacket(NULL);
|
lastOutputTimestamp = 0;
|
lastOutputDuration = 0;
|
lastPacketRepeatCount = 0;
|
numSIDPackets = 0;
|
jitterBufferDepth = 0;
|
numPackets = 0;
|
numRepeats = 0;
|
dynamicJitterBuffer = GetRegKeyBool(HKEY_CURRENT_USER, "Software\\Cisco Systems\\CCNMediaTerm\\1.0", "UseDynamicJitterBuffer", true);
|
LeaveCriticalSection(&audioStreamMutex);
|
return 0;
|
}
|
|
/**
|
* AddPacket makes sure that all samples added to the queue have an RTP header
|
*/
|
int
|
RTPAudioStream::AddPacket(AudioSample *newPacket)
|
{
|
RTPPacket *rtpHeader = newPacket->RTPHeader();
|
if (rtpHeader)
|
{
|
EnterCriticalSection(&audioStreamMutex);
|
if (jitterBufferDepth < restartThreshold * JITTERBUFFER_MAXSIZE_MULTIPLE)
|
{
|
if (rtpHeader->PayloadType() == RTP_PAYLOADTYPE_SID)
|
{
|
numSIDPackets++;
|
}
|
newPacket->AddRef(this);
|
packetQueue.push(newPacket);
|
jitterBufferDepth += newPacket->GetDuration();
|
tracer.tracef(ARB, "RTPAudioStream:%x : AddPacket : pushed audioSample 0x%x, ssrc %u, seqNo %u\n", this, newPacket, rtpHeader->Ssrc(), rtpHeader->SeqNo());
|
}
|
LeaveCriticalSection(&audioStreamMutex);
|
}
|
return 0;
|
}
|
|
int
|
RTPAudioStream::PopNextPacket(AudioSample **pAudioSample)
|
{
|
*pAudioSample = NULL;
|
EnterCriticalSection(&audioStreamMutex);
|
if (packetQueue.size() > 0)
|
{
|
*pAudioSample = packetQueue.top();
|
packetQueue.pop();
|
RTPPacket *rtpHeader = (*pAudioSample)->RTPHeader();
|
tracer.tracef(ARB, "RTPAudioStream:%x : PopNextPacket : popped audioSample 0x%x, ssrc %u, seqNo %u\n", this, *pAudioSample, rtpHeader->Ssrc(), rtpHeader->SeqNo());
|
if (rtpHeader->PayloadType() == RTP_PAYLOADTYPE_SID)
|
{
|
numSIDPackets--;
|
}
|
else
|
{
|
jitterBufferDepth -= (*pAudioSample)->GetDuration();
|
}
|
}
|
LeaveCriticalSection(&audioStreamMutex);
|
return 0;
|
}
|
|
int
|
RTPAudioStream::PopNextPacketForTransmit(AudioSample **pOutSample)
|
{
|
AudioSample *audioSample = NULL;
|
EnterCriticalSection(&audioStreamMutex);
|
PopNextPacket(&audioSample);
|
if (audioSample)
|
{
|
RTPPacket *rtpHeader = audioSample->RTPHeader();
|
SetLastTransmittedPacket(audioSample);
|
*pOutSample = audioSample;
|
lastOutputTimestamp = rtpHeader->Timestamp();
|
lastOutputDuration = audioSample->GetDuration();
|
lastPacketRepeatCount = 1;
|
}
|
LeaveCriticalSection(&audioStreamMutex);
|
return 0;
|
}
|
|
/*
|
makes sure that only audiosamples with valid rtpheader are added
|
*/
|
int
|
RTPAudioStream::InsertRTPPacket(AudioSample *audioSample)
|
{
|
tracer.tracef(DET, "RTPAudioStream:%x : InsertRTPPacket 0x%x\n", this, audioSample);
|
RTPPacket *newPacketRTPHeader = audioSample->RTPHeader();
|
if (newPacketRTPHeader)
|
{
|
EnterCriticalSection(&audioStreamMutex);
|
if (lastPacketTransmitted && (TimeDifference(lastPacketTransmitted, audioSample) < 0))
|
{
|
RTPPacket *lastPacketRTPHeader = lastPacketTransmitted->RTPHeader();
|
// if we receive a packet that is 25 packets before the last transmitted packet, it means a new stream
|
if ((int)(newPacketRTPHeader->SeqNo()) - ((int)lastPacketRTPHeader->SeqNo()) < -25)
|
{
|
Clear();
|
AddPacket(audioSample);
|
}
|
}
|
else
|
{
|
AddPacket(audioSample);
|
}
|
LeaveCriticalSection(&audioStreamMutex);
|
}
|
else
|
{
|
tracer.tracef(ERR, "RTPAudioStream:%x : InserRTPPacket : audioSample has no rtpHeader\n", this);
|
}
|
return 0;
|
}
|
|
int
|
RTPAudioStream::GiveNextRTPPacket(AudioSample **pOutSample)
|
{
|
EnterCriticalSection(&audioStreamMutex);
|
*pOutSample = NULL;
|
if (silenceIntervalInProgress && (numSIDPackets > 0 || jitterBufferDepth >= restartThreshold))
|
{
|
silenceIntervalInProgress = false;
|
}
|
do
|
{
|
if (silenceIntervalInProgress)
|
{
|
break;
|
}
|
if (dynamicJitterBuffer && numPackets == 99)
|
{
|
tracer.tracef(EE, "RTPAudioStream:%x : GiveNextRTPPacket : numRepeats = %d\n", this, numRepeats);
|
if (numRepeats <= 1)
|
{
|
int newThreshold(restartThreshold);
|
if (jitterBufferDepth <= restartThreshold + 40)
|
{
|
newThreshold = restartThreshold - 20;
|
if (newThreshold < 40) newThreshold = 40;
|
}
|
tracer.tracef(EE, "RTPAudioStream:%x : GiveNextRTPPacket : restartThreshold = %d, newThreshold = %d\n", this, restartThreshold, newThreshold);
|
SetRestartThreshold(newThreshold);
|
tracer.tracef(EE, "RTPAudioStream:%x : GiveNextRTPPacket : jitter buffer depth = %d\n", this, jitterBufferDepth);
|
int durationDeleted(0);
|
while(jitterBufferDepth > restartThreshold)
|
{
|
AudioSample *discardSample = NULL;
|
PopNextPacketForTransmit(&discardSample);
|
if (discardSample)
|
{
|
durationDeleted += discardSample->GetDuration();
|
discardSample->Release(this);
|
discardSample = NULL;
|
}
|
if (durationDeleted >= 60)
|
{
|
break;
|
}
|
}
|
numRepeats = 0;
|
numPackets = 100;
|
}
|
else
|
{
|
numRepeats = 0;
|
restartThreshold = restartThreshold + 20;
|
numPackets = 100;
|
tracer.tracef(EE, "RTPAudioStream:%x : GiveNextRTPPacket : increased restartThreshold by 20 to %d\n", this, restartThreshold);
|
}
|
}
|
if (packetQueue.size() <= 0)
|
{
|
if (lastPacketTransmitted && lastPacketRepeatCount < JITTERBUFFER_PLC_MAXREPEATS)
|
{
|
lastPacketTransmitted->AddRef(this);
|
lastPacketRepeatCount++;
|
if (lastPacketRepeatCount == 2)
|
{
|
numRepeats++;
|
}
|
lastOutputTimestamp += (lastOutputDuration * 1000) / lastPacketTransmitted->MinFrameDuration();
|
*pOutSample = lastPacketTransmitted;
|
numPackets = (numPackets + 1) % 100;
|
break;
|
}
|
else
|
{
|
silenceIntervalInProgress = true;
|
SetLastTransmittedPacket(NULL);
|
break;
|
}
|
break;
|
}
|
|
AudioSample *audioSample = packetQueue.top();
|
tracer.tracef(DET, "RTPAudioStream:%x : GiveNextRTPPacket : packetQueue.top = audioSample 0x%x\n", this, audioSample);
|
RTPPacket *rtpHeader = audioSample->RTPHeader();
|
if (rtpHeader->PayloadType() == RTP_PAYLOADTYPE_SID)
|
{
|
PopNextPacket(&audioSample);
|
audioSample->Release(this);
|
audioSample = NULL;
|
silenceIntervalInProgress = true;
|
SetLastTransmittedPacket(NULL);
|
break;
|
}
|
if (!lastPacketTransmitted)
|
{
|
// transmit whichever is the next packet
|
PopNextPacketForTransmit(pOutSample);
|
numPackets = (numPackets + 1) % 100;
|
break;
|
}
|
int timeDifference = TimeDifferenceMillisec(lastPacketTransmitted, audioSample) - lastOutputDuration * lastPacketRepeatCount;
|
if (timeDifference < (int)lastOutputDuration)
|
{
|
PopNextPacketForTransmit(pOutSample);
|
numPackets = (numPackets + 1) % 100;
|
break;
|
}
|
if (lastPacketRepeatCount < JITTERBUFFER_PLC_MAXREPEATS)
|
{
|
lastPacketTransmitted->AddRef(this);
|
lastPacketRepeatCount++;
|
lastOutputTimestamp += (lastOutputDuration * 1000) / lastPacketTransmitted->MinFrameDuration();
|
*pOutSample = lastPacketTransmitted;
|
numPackets = (numPackets + 1) % 100;
|
break;
|
}
|
silenceIntervalInProgress = true;
|
SetLastTransmittedPacket(NULL);
|
|
} while(false);
|
|
LeaveCriticalSection(&audioStreamMutex);
|
return 0;
|
}
|
