audiosample.cxx

rtp在linux下的实现

// AudioSample.cpp: implementation of the AudioSample class.
//
//////////////////////////////////////////////////////////////////////

#include "RTPPacket.h"
#include "stdio.h"
#include "AudioSample.h"
#include "AudioSampleManager.h"
#include "Parameters.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

AudioSample::AudioSample(AudioSampleManager *audioSampleManager, int size = DEFAULT_AUDIOSAMPLE_BUFFERSIZE)
{
	Initialize(audioSampleManager, size);
}


AudioSample::AudioSample(AudioSampleManager *audioSampleManager)
{
	Initialize(audioSampleManager, DEFAULT_AUDIOSAMPLE_BUFFERSIZE);
}

AudioSample::~AudioSample()
{
	if (data)
	{
		delete [] data;
	}
	if (rtpHeader)
	{
		delete rtpHeader;
	}
}

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)
{
	data = new char[size];
	rtpHeader = NULL;
	bufferSize = size;
	dataSize = 0;
	refCount = 0;
	manager = audioSampleManager;
	return 0;
}

int
AudioSample::Uninitialize()
{
	if (rtpHeader)
	{
		delete rtpHeader;
		rtpHeader = NULL;
		dataSize = 0;
	}
	return 0;
}

int
AudioSample::SetTraceLevel()
{
	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()
{
	return rtpHeader;
}

int
AudioSample::SetRTPHeader(RTPPacket *headerPtr)
{
	if (rtpHeader)
	{
		delete rtpHeader;
	}
	rtpHeader = headerPtr;
	return 0;
}

int
AudioSample::AddRef()
{
	return ++refCount;
}

int
AudioSample::Release()
{
	if (refCount > 0)
	{
		--refCount;
	}
	else
	{
		tracer.tracef(ERR, "Release : e-refCount : Error : refCount = %d\n", refCount);
	}
	int result = refCount;
	if (refCount == 0)
	{
		Uninitialize();
		manager->AudioSampleReleased(this);
	}
	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
}