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

#include "RTPPacket.h"
#include "RTPAudioSink.h"
#include "AudioSample.h"

using namespace std;

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

RTPAudioSink::RTPAudioSink()
{
	char subFacilityName[100];
	sprintf(subFacilityName, "RTPAudioSink:%x", this);
	tracer.SetSubFacilityName(subFacilityName);
	SetTraceLevel();
	tracer.tracef(EE, "Constructor begin\n");
	rtpSocket = NULL;
	destinationIP = 0;
	destinationIPString = "127.0.0.1";
	destinationPort = 0;
	localPort = 0;
	tos = 0;
	bRunning = false;
	InitializeCriticalSection(&filterMutex);
	WSADATA wsaData;
	int result = WSAStartup(MAKEWORD(1,1), &wsaData);
	lastCodec = -1;
	tracer.tracef(EE, "Constructor end : 0x%x\n", result);
}

RTPAudioSink::~RTPAudioSink()
{
	tracer.tracef(EE, "Destructor begin\n");
	int result(0);
	EnterCriticalSection(&filterMutex);
	tracer.tracef(ARB, "RTPAudioSink~ : entered filterMutex\n");
	LeaveCriticalSection(&filterMutex);
	tracer.tracef(ARB, "RTPAudioSink~ : left filterMutex\n");
	result = CloseSocket();
	result = WSACleanup();
	DeleteCriticalSection(&filterMutex);
	tracer.tracef(EE, "Destructor end : 0x%x\n", result);
}

int
RTPAudioSink::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", "RTPAudioSink", 0x100000);
	}
	tracer.SetSystemMask(SystemMask);
	return 0;
}


int
RTPAudioSink::SetCodecInRegistry(char *codecName)
{
	SetRegKeyString(HKEY_CURRENT_USER, "Software\\Cisco Systems\\CCNMediaTerm\\1.0", "RTPTransmitCodec", codecName);
	return 0;
}

int
RTPAudioSink::SetDestination(std::string ipAddress, unsigned short udpPort)
{
	tracer.tracef(EE, "SetDestination %s %u\n", ipAddress.c_str(), udpPort);
	EnterCriticalSection(&filterMutex);
	int result = 0;
	destinationIPString = ipAddress;
	destinationPort = udpPort;

//	hostent *hostEnt = gethostbyname(ipAddress.c_str());
//	if (hostEnt != NULL)
//	{
//		destinationIP = *((long *)(hostEnt->h_addr));
//	}
//	else
//	{
		destinationIP = inet_addr(ipAddress.c_str());
//	}

	if (!rtpSocket)
	{
		int result = CreateSocket();
	}
	if (result == 0)
	{
		memset((char *)&destinationSockAddr, 0, sizeof(destinationSockAddr));
		destinationSockAddr.sin_family = AF_INET;
		destinationSockAddr.sin_port = htons(destinationPort);
		destinationSockAddr.sin_addr.S_un.S_addr = destinationIP;
//		result = connect(rtpSocket, (sockaddr *)&destinationAddr, sizeof(destinationAddr));
	}
	LeaveCriticalSection(&filterMutex);
	tracer.tracef(EE, "~SetDestination : %d 0x%x\n", result, result);
	return result;
}

int
RTPAudioSink::SetTOS(unsigned char tosByte)
{
	tracer.tracef(EE, "SetTOS 0x%x\n", tosByte);
	EnterCriticalSection(&filterMutex);
	int result = 0;
	tos = tosByte;
	int tosValueInt = (int)tos;
	int tosLen = sizeof(int);
	if (rtpSocket)
	{
		tracer.tracef(SDI_LEVEL_ARBITRARY, "SetTOS : setsockopt\n");
		result = setsockopt(rtpSocket, IPPROTO_IP, IP_TOS, (char *)&tosValueInt, tosLen);
		if (result != 0)
		{
			result = WSAGetLastError();
			tracer.tracef(ERR, "SetTOS : e-setsockopt 0x%x\n", result);
		}
	}
	LeaveCriticalSection(&filterMutex);
	tracer.tracef(EE, "~SetTOS : %d 0x%x\n", result, result);
	return result;
}

int
RTPAudioSink::SetLocalPort(unsigned short port)
{
	tracer.tracef(EE, "SetLocalPort %u : localPort %u\n", port, localPort);
	EnterCriticalSection(&filterMutex);
	int result(0);
	if (localPort != port)
	{
		localPort = port;
		if (rtpSocket)
		{
			result = CloseSocket();
			if (result == 0)
			{
				result = CreateSocket();
				if (result == 0)
				{
					result = SetDestination(destinationIPString, destinationPort);
				}
			}
		}
	}
	LeaveCriticalSection(&filterMutex);
	tracer.tracef(EE, "~SetLocalPort : %d 0x%x\n", result, result);
	return result;
}

int
RTPAudioSink::CreateSocket()
{
	tracer.tracef(EE, "CreateSocket\n");
	EnterCriticalSection(&filterMutex);
	int result;

	if (rtpSocket)
	{
		result = CloseSocket();
	}
	rtpSocket = socket(AF_INET, SOCK_DGRAM, 0);

	sockaddr_in localSockAddr;
	memset((char *)&localSockAddr, 0, sizeof(localSockAddr));
	localSockAddr.sin_family = AF_INET;
	localSockAddr.sin_port = htons(localPort);
	localSockAddr.sin_addr.S_un.S_addr = INADDR_ANY;
	result = bind(rtpSocket, (sockaddr *)&localSockAddr, sizeof(localSockAddr));
	if (result != 0)
	{
		result = WSAGetLastError();
		tracer.tracef(ERR, "CreateSocket : e-bind : 0x%x\n", result);
	}
	else
	{
		sockaddr_in boundSockAddr;
		int sizeOfBoundSockAddr = sizeof(boundSockAddr);
		result = getsockname(rtpSocket, (sockaddr *)&boundSockAddr, &sizeOfBoundSockAddr);
		if (result == 0)
		{
			SetRegKeyLong(HKEY_CURRENT_USER, "Software\\Cisco Systems\\CCNMediaTerm\\1.0", "TransmitPort", ntohs(boundSockAddr.sin_port));
		}
		else
		{
			result = WSAGetLastError();
			tracer.tracef(ERR, "CreateSocket : e-getsockname : %d 0x%x\n", result, result);
		}
	}
	result = setsockopt(rtpSocket, IPPROTO_IP, IP_TOS, (char *)&tos, 1);
	if (result != 0)
	{
		result = WSAGetLastError();
		tracer.tracef(ERR, "CreateSocket : e-setsockopt : %d 0x%x\n", result, result);
	}
	LeaveCriticalSection(&filterMutex);
	tracer.tracef(EE, "~CreateSocket : %d 0x%x\n", result, result);
	return result;
}


int
RTPAudioSink::CloseSocket()
{
	tracer.tracef(EE, "CloseSocket\n");
	EnterCriticalSection(&filterMutex);
	int result(0);
	if (rtpSocket)
	{
		tracer.tracef(ARB, "CloseSocket : closesocket\n");
		result = closesocket(rtpSocket);
		if (result != 0)
		{
			tracer.tracef(ERR, "CloseSocket : e-closesocket : 0x%x\n", WSAGetLastError());
			result = -10;
		}
	}
	rtpSocket = NULL;
	LeaveCriticalSection(&filterMutex);
	tracer.tracef(EE, "~CloseSocket : %d 0x%x\n", result, result);
	return 0;
}

int
RTPAudioSink::RenderAudioSamples(std::vector<std::pair<AudioSample*, AudioSource* > > &data)
{
	tracer.tracef(DET, "RenderAudioSamples\n");
	AudioSample *sample = NULL;
	if (data.size() > 0)
	{
		sample = data[0].first;
	}
	if (sample)
	{
		int dataSize = 0;
		int durationMillisec;

		char RTPPayloadType;
		bool transmitPacket = false;	// whether a packet will be transmitted
		bool setMarkerBit = false;

		int numBytes = sample->DataSize();
		durationMillisec = sample->GetDuration();
		if (durationMillisec <= 0)
		{
			durationMillisec = sample->GetSilenceDuration();
		}
		tracer.tracef(DET, "RenderAudioSamples : durationMillisec = %d\n", durationMillisec);

		timestamp += durationMillisec * 8;
		seqno = (seqno + 1) % 65536;

		if (numBytes > 0)
		{
			transmitPacket = true;
			setMarkerBit = silenceInterval;
			silenceInterval = false;

			tracer.tracef(DET, "RenderAudioSamples : memcpy(0x%x, 0x%x, %d)\n", sendBuffer+12, sample->Data(), sample->DataSize());
			memcpy(sendBuffer+12, sample->Data(), sample->DataSize());
			dataSize = 12 + sample->DataSize();

			WAVEFORMATEX wfx;
			sample->GetFormat(&wfx);
			bool writeCodec = false;
			if (lastCodec != wfx.wFormatTag)
			{
				lastCodec = wfx.wFormatTag;
				writeCodec = true;
			}
			switch(wfx.wFormatTag) 
			{
			case WAVE_FORMAT_MULAW:
				RTPPayloadType	= 0x00;
				if (writeCodec) SetCodecInRegistry("G.711 ULaw");
				break;
			case WAVE_FORMAT_ALAW:
				RTPPayloadType	= 0x08;
				if (writeCodec) SetCodecInRegistry("G.711 ALaw");
				break;
			case WAVE_FORMAT_CISCO_G729:
				RTPPayloadType	= 0x12;
				if (writeCodec) SetCodecInRegistry("G.729");
				break;
			case WAVE_FORMAT_CISCO_G723_53:
				RTPPayloadType	= 0x04;
				if (writeCodec) SetCodecInRegistry("G.723 5.3kbps");
				break;
			case WAVE_FORMAT_CISCO_G723_63:
				RTPPayloadType	= 0x04;
				if (writeCodec) SetCodecInRegistry("G.723 6.4kbps");
				break;
			default:
				char codecName[100];
				sprintf(codecName, "WAVE_FORMAT %u (ERROR)");
				if (writeCodec) SetCodecInRegistry(codecName);
				break;
			}
		}
		else if (!silenceInterval)
		{
			transmitPacket	= true;
			silenceInterval	= true;
			RTPPayloadType	= RTP_PAYLOADTYPE_SID;
			// See internet draft "RTP Payload for Comfort Noise". Actually 1 byte of data (although min amount
			// of data in RTP packet is 4 bytes. First byte is important. all others should be zero.
			// first byte = value between 0 to 127. If it is X, then noise level is -X dB. so 0 is loudest, and
			// 127 is quietest.
			// Pascal Huart in Dallas gave me this information
			*((long *)(sendBuffer + 12)) = htonl(0);
			sendBuffer[12] = 100;
			dataSize = 12 + 4;
		}

		if (transmitPacket)
		{
			sendBuffer[0] = 0x80;
			sendBuffer[1] = RTPPayloadType;
			if (setMarkerBit)
			{
				sendBuffer[1] |= 0x80;
			}
			*((short *)(sendBuffer + 2))	= htons((short)seqno);
			*((long  *)(sendBuffer + 4))	= htonl((long)timestamp);
			*((long  *)(sendBuffer + 8))	= htonl((long)ssrc);
			
			tracer.tracef(DET, "RenderAudioSamples : sending %d bytes\n", dataSize);
			EnterCriticalSection(&filterMutex);
			if (rtpSocket)
			{
				sendto(rtpSocket, (char *)sendBuffer, dataSize, 0, (struct sockaddr *)(&destinationSockAddr), sizeof(destinationSockAddr));
			}
			LeaveCriticalSection(&filterMutex);
		}
		tracer.tracef(DET, "~RenderAudioSamples : seqno = %d, timeStamp = %d\n", seqno, timestamp);
	}
	else
	{
		tracer.tracef(ERR, "~RenderAudioSample : asked to transmit NULL sample\n");
	}
	return 0;
}

int
RTPAudioSink::PrepareSink()
{
	int result(0);
	int returnCode(0);
	tracer.tracef(EE, "PrepareSink\n");
	srand((unsigned int)GetTickCount());
	ssrc = (unsigned long)rand();
	timestamp = (unsigned long)rand();
	seqno = (unsigned short)((unsigned long)(rand() % 65536));
	silenceInterval = true;		// so that the marker bit is set after the first packet
	SetRegKeyString(HKEY_CURRENT_USER, "Software\\Cisco Systems\\CCNMediaTerm\\1.0", "DestinationAddress", destinationIPString.c_str());
	SetRegKeyLong(HKEY_CURRENT_USER, "Software\\Cisco Systems\\CCNMediaTerm\\1.0", "DestinationPort", destinationPort);
	tracer.tracef(EE, "PrepareSink : returning %d\n", result);
	return result;
}

int
RTPAudioSink::UnprepareSink()
{
	int result(0);
	int returnCode(0);
	tracer.tracef(EE, "UnprepareSink\n");
	SetRegKeyString(HKEY_CURRENT_USER, "Software\\Cisco Systems\\CCNMediaTerm\\1.0", "DestinationAddress", "");
	SetRegKeyLong(HKEY_CURRENT_USER, "Software\\Cisco Systems\\CCNMediaTerm\\1.0", "DestinationPort", 0);
	returnCode = CloseSocket();
	if (returnCode < 0)
	{
		result = -10;
	}
	tracer.tracef(EE, "UnprepareSink : returning %d\n", result);
	return result;
}

int
RTPAudioSink::SinkStarted()
{
	int result(0);
	int returnCode(0);
	tracer.tracef(EE, "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 = PrepareSink();
		if (returnCode != 0)
		{
			tracer.tracef(ERR, "SinkStarted : e-PrepareSink : %d 0x%x\n", returnCode, returnCode);
			result = -20;
			break;
		}
		bRunning = true;
	}
	while (false);

	LeaveCriticalSection(&filterMutex);
	tracer.tracef(ARB, "SinkStarted : left filterMutex\n");
	tracer.tracef(EE, "~SinkStarted : returning %d\n", result);
	return result;
}

int
RTPAudioSink::SinkStopped()
{
	int result(0);
	int returnCode(0);
	tracer.tracef(EE, "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 = UnprepareSink();
		if (returnCode != 0)
		{
			tracer.tracef(ERR, "SinkStopped : e-UnprepareSink : %d 0x%x\n", returnCode, returnCode);
			result = -20;
			break;
		}
		bRunning = false;
	}
	while (false);

	LeaveCriticalSection(&filterMutex);
	tracer.tracef(ARB, "SinkStopped : left filterMutex\n");
	SetCodecInRegistry("");
	lastCodec = -1;
	tracer.tracef(EE, "~SinkStopped : returning %d\n", result);
	return result;
}

int
RTPAudioSink::SinkThreadStarted(HANDLE sinkThreadHandle, DWORD sinkThreadID)
{
	int returnCode(0);
	int result(0);
	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 = PrepareSink();
		if (returnCode != 0)
		{
			tracer.tracef(ERR, "SinkThreadStarted : e-PrepareSink : %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 : %d 0x%x\n", result, result);
	return result;
}

int
RTPAudioSink::SinkThreadStopped(HANDLE sinkThreadHandle, DWORD sinkThreadID)
{
	tracer.tracef(SDI_LEVEL_ENTRY_EXIT, "SinkThreadStopped\n");
	int result(0);
	int returnCode(0);
	EnterCriticalSection(&filterMutex);
	tracer.tracef(ARB, "SinkThreadStopped : entered filterMutex\n");
	do
	{
		if (!bRunning)
		{
			tracer.tracef(ERR, "SinkThreadStopped : not running\n");
			result = -10;
			break;
		}
		returnCode = UnprepareSink();
		if (returnCode != 0)
		{
			tracer.tracef(ERR, "SinkThreadStopped : e-UnprepareSink : %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 : %d 0x%x\n", result, result);
	return result;
}