// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//

#include "AudioBufferArray.h"
#include "BtSBCFrameParameters.h"
#include "A2dpCodecUtilities.h"

/**
Audio Buffer Array Panics
**/
enum TAudioBufferArrayPanic
	{
	EAudioBufferArrayIncompleteFrame, //0
	EAudioBufferArrayMiscount, //1
	EAudioBufferArrayNonA2dpDataType, //2
	EAudioBufferArrayNoRTPPacketsPerAudioBuffer //3
	};


static void Panic(TAudioBufferArrayPanic aPanic)
// Panic client
	{
	_LIT(KAudioBufferArrayPanicName, "A2DP Audio Buf Panic");
	User::Panic(KAudioBufferArrayPanicName, aPanic);
	}
	

/**
Creates a CRtpSendPackets array of RRtpSendPackets

@param aRtpSendSource
@param aNumberOfPackets this is the number of RRtpSendPackets stored in
the array
*/	
CRtpSendPackets* CRtpSendPackets::NewL(RRtpSendSource& aRtpSendSource, TUint aNumberOfPackets)
	{
	CRtpSendPackets* self = new (ELeave) CRtpSendPackets ();
	CleanupStack::PushL(self);
	self->ConstructL(aRtpSendSource, aNumberOfPackets);
	CleanupStack::Pop(self);
	return self;
	}

	
void CRtpSendPackets::ConstructL(RRtpSendSource& aRtpSendSource, TUint aNumberOfPackets)
	{
	// create all the RTP send packets now	
	TInt err = KErrNone;
	for (TInt i=0; i<aNumberOfPackets; i++)
		{
		RRtpSendPacket sendPacket = aRtpSendSource.NewSendPacketL();
		err = iRtpSendPackets.Append(sendPacket);
		if (err)
			{//probably run out of memory so need to close the packets
			CloseAndResetSendPackets();
			User::Leave(err);
			}
		}
	}

	
CRtpSendPackets::~CRtpSendPackets()
	{
	CloseAndResetSendPackets();
	}


void CRtpSendPackets::CloseAndResetSendPackets()
	{
	// destroy all the RTP send packets now
	TUint numberOfSendPackets = iRtpSendPackets.Count();
	for (TInt i=0; i<numberOfSendPackets; i++)
		{
		RRtpSendPacket& p = iRtpSendPackets[i];
		p.Close();
		}
	iRtpSendPackets.Reset();
	}

/**
Creates  a FIFO array of audio buffers stored as CRtpSendPackets
The paramers passed in are used to determine the size and number
of RTP packets required to store an audio buffer
The payload size on aRtpSendSource is set.

@param aRtpSendSource used to create the send packets that contain
the audio buffers.  The payload size is set on the aRtpSendSource to
a value calculated from the other parameters
@param aNumberOfAudioBuffers this is the number of audio buffers
stored in the FIFO
@param aAudioBufferLength this is the length of the audio buffer that needs
to be sent to the headset ie buffer size after SBC processing in the case of SBC
@param aMTULength this is the max data length allowing for the restriction imposed
by the underlying MTU bearer ie bluetooth and the headset.
@param aTotalRTPHeaderLength the RTP header length including the 
RTP media payload header ie RTP header length + media payload header length
@param aFrameLength 
*/	
CAudioBufferArray* CAudioBufferArray::NewL(RRtpSendSource& aRtpSendSource, 
									TUint aNumberOfAudioBuffers, 
									TUint aAudioBufferLength, 
									TUint aMTULength, 
								    TUint aTotalRTPHeaderLength,
									TUint aFrameLength)
	{
	CAudioBufferArray* self = new (ELeave) CAudioBufferArray();
	CleanupStack::PushL(self);
	self->ConstructL(aRtpSendSource, aNumberOfAudioBuffers, aAudioBufferLength, aMTULength, aTotalRTPHeaderLength, aFrameLength);
	CleanupStack::Pop(self);
	return self;
	}


void CAudioBufferArray::ConstructL(RRtpSendSource& aRtpSendSource,
						TUint aNumberOfAudioBuffers,
						TUint aAudioBufferLength,
						TUint aMTULength,
						TUint aTotalRTPHeaderLength,
						TUint aFrameLength)
	{
	//the buffer should always contain an intiger number of audio frames
	//the following ASSERT_DEBUG should be present but is commented out as the RVCT 
	//compiler generates a warning
	//__ASSERT_DEBUG(!(aAudioBufferLength%aFrameLength),EAudioBufferArrayIncompleteFrame);
	
	//calculate the number of frames in the audio buffer size and if 
	//more than 15 frames then calculate the highest common factor and use this 
	//calculate the frames length
	iFrameLength = aFrameLength;

	//calculate the total number of frames in the buffer
	TUint numberOfFramesPerAudioBuffer = aAudioBufferLength/iFrameLength;
	//for now set the number of audio frames in an RTP packet to the total
	iNumberOfFramesPerRtpPacket = numberOfFramesPerAudioBuffer;
	
	TUint lengthOfAudioDataInRtpPacket = 0;
	TInt usableRTPPayloadLength = aMTULength-aTotalRTPHeaderLength;
	
	//check whether all the audio frames will actually fit into one RTP packet
	if ((numberOfFramesPerAudioBuffer > KMaxNumberOfSBCFramesPerRTPPacket)||((aAudioBufferLength+iFrameLength)>usableRTPPayloadLength))//+iFrameLength in case of cached frame
		{
		//we cannot get all the audio frames into a single RTP packet
		//for SBC only a max of 15 SBC frames allowed per packet
		//if the buffer size exceeds 15 frames and/or is too large
		//for the underlying MTU size then we need to break
		//the buffer into buffers of less then 16 frames.
		//for non SBC the frames are generaly larger so we'll keep
		//the 15 for now even for non SBC
		//we need to calculate how may frames should go into
		//each RTP packet and how many RTP packets we need to send a
		//complete audio buffer
		//we are going to calculate such that every RTP packet
		//has the same number of frames
		//note that if we are using non SBC then the frame size tends to be larger
		//so the MTU limit is likely to be the dominant factor
		//although in principle this code should only use the 15 frame limit for
		//for SBC
		iNumberOfFramesPerRtpPacket = 0; 
		
		
		//only a max of 15 SBC frames allowed per packet
		//if the buffer size exceeds 15 frames then we need to break
		//the buffer into buffers of less then 16 frames.
		//so find HCF 
		//-1 for cached frames ie if iNumberOfFramesPerRtpPacket
		//was the same as KMaxNumberOfSBCFramesPerRTPPacket and we got a cached frame
		//then we would blow the limit
		for (TUint i=KMaxNumberOfSBCFramesPerRTPPacket-1; i; i--)
			{
			if (!(numberOfFramesPerAudioBuffer%i))
				{
				//check we don't blow the MTU size
				if ((i*iFrameLength) <= usableRTPPayloadLength)
					{
					iNumberOfFramesPerRtpPacket = i;
					break;
					}
				}
			}
		if (!iNumberOfFramesPerRtpPacket)
			{//the frame length was too big for the MTU length
			//one frame of audio + one frame of cached audio
			//would exceed the length supported by the underlying bearer
			//note that the A2DP specification section 4.3.4 does allow
			//SBC frames to be fragmented across multiple packets if
			//less than one frame, but this ref implementation
			//does not support this, since this should be rare.
			//this may happen more often for non SBC eg mp3 frames
			//but we don't support fragmented frames
			User::Leave(KErrTooBig);
			}
		iNumberOfRtpPacketsPerAudioBuffer = numberOfFramesPerAudioBuffer/iNumberOfFramesPerRtpPacket;
		
		//this could probably be optimized somewhat such that the
		//iInputBytesPerRtpPacket value was such that no caching was required 
		//in the codec
		
		if (!iNumberOfRtpPacketsPerAudioBuffer)//this isn't really necessary or could be ASSERT but needed supress armv5 compiler warning
			{
			Panic(EAudioBufferArrayNoRTPPacketsPerAudioBuffer);
			}
			
		iInputBytesPerRtpPacket = aAudioBufferLength/iNumberOfRtpPacketsPerAudioBuffer;
		if (iInputBytesPerRtpPacket%2)
			{//we have an odd number of bytes
			iInputBytesPerRtpPacket++;//round up to next byte
			}
		lengthOfAudioDataInRtpPacket = iNumberOfFramesPerRtpPacket*iFrameLength;
		}//if ((numberOfFramesPerAudioBuffer > KMaxNumberOfSBCFramesPerRTPPacket)||((encodedAudioBufferLength+iFrameLength)>aMaxMTULength))
	else
		{//we can fit the entire buffer in one RTP packet
		iNumberOfRtpPacketsPerAudioBuffer = 1;
		iInputBytesPerRtpPacket = aAudioBufferLength;
		lengthOfAudioDataInRtpPacket = aAudioBufferLength;
		}

	TUint payloadSize = aTotalRTPHeaderLength+lengthOfAudioDataInRtpPacket+iFrameLength;//+ extra framelength for cached frames
	aRtpSendSource.SetDefaultPayloadSize(payloadSize);
	
	//now we have set the payload size we can create the audio buffers
	//stored as CRtpSendPackets* 
	for (TInt i=0; i<aNumberOfAudioBuffers; i++)
		{
		CRtpSendPackets* sendPacketArray = CRtpSendPackets::NewL(aRtpSendSource, iNumberOfRtpPacketsPerAudioBuffer);
		User::LeaveIfError(iAudioBufferArray.Append(sendPacketArray));
		}
	}

	
CAudioBufferArray::~CAudioBufferArray()
	{
	// destroy all the audio buffers now
	TUint numberOfAudioBuffers = iAudioBufferArray.Count();
	for (TInt i=0; i<numberOfAudioBuffers; i++)
		{
		CRtpSendPackets* sendPacketArray = iAudioBufferArray[i];
		delete sendPacketArray;
		}
	iAudioBufferArray.Close();
	}


/**
This function is called when the current audio buffer has been filled
with audio and is in a state to be sent to the headset
The function updates the next audio buffer to fill to the next 
available free audio buffer
*/
void CAudioBufferArray::CurrentAudioBufferReadyToSend()
	{
	iNextAudioBufferToFill++;
	if (iNextAudioBufferToFill >= iAudioBufferArray.Count())
		{
		iNextAudioBufferToFill = 0;
		}
	iNumberOfReadyAudioBuffers++;
	__ASSERT_DEBUG((iNumberOfReadyAudioBuffers<=iAudioBufferArray.Count()),Panic(EAudioBufferArrayMiscount));
	}


/**
This function cancels the most recently filled audio buffer that is ready to send
The audio buffer corresponds to the audio buffer sent in the last CActiveRTPStreamer::Send()
This is used in order to cancel a Send request.
It effectively undoes the operation performed in CurrentAudioBufferReadyToSend()
so CurrentAudioBufferReadyToSend() must have been called at least once prior.

@param aSendInProgress set to ETrue if an audio buffer is currently being
sent
*/
void CAudioBufferArray::CancelMostRecentAudioBuffer(TBool aSendInProgress)
	{
	__ASSERT_DEBUG((iNumberOfReadyAudioBuffers),Panic(EAudioBufferArrayMiscount));
	if ((iNumberOfReadyAudioBuffers == 1) && (aSendInProgress))
		{//then we only have one ready buffer , which is being sent
		//so we want to stop any further sending of the current buffer
		__ASSERT_DEBUG((iAudioBufferBeingSent == iNextAudioBufferToFill),Panic(EAudioBufferArrayMiscount));
		//now we need prevent any further send packets in the current audio buffer being sent
		//the following line of code will force us to move onto the next audio 
		//buffer discarding any RTP packets in the current audio buffer
		//see CurrentSendPacketSent()
		iNextRtpPacketToSend = iNumberOfRtpPacketsPerAudioBuffer-1;
		}
	else if (iNumberOfReadyAudioBuffers)
		{
		if (!iNextAudioBufferToFill)
			{
			iNextAudioBufferToFill = iAudioBufferArray.Count();
			}
		else
			{
			iNextAudioBufferToFill--;
			}
		iNumberOfReadyAudioBuffers--;
		}	
	}
	

/**
This function flushes the pending send packets that are ready to send.
Only the current send packet is valid
*/
void CAudioBufferArray::FlushPendingPackets()	
	{
	//check that we actually have some audio buffers to flush
	if (iNumberOfReadyAudioBuffers > 1)
		{
		if (iAudioBufferBeingSent >= iAudioBufferArray.Count())
			{
			iNextAudioBufferToFill = 0;
			}
		else
			{
			iNextAudioBufferToFill = iAudioBufferBeingSent+1;
			}
		iNumberOfReadyAudioBuffers = 1; //the current send packet
		}
	else if (iNumberOfReadyAudioBuffers == 1)
		{
		//now we need to flush out the send packets in the current audio buffer being sent
		//the following line of code will force us to move onto the next audio 
		//buffer discarding any RTP packets in the current audio buffer
		//see CurrentSendPacketSent()
		iNextRtpPacketToSend = iNumberOfRtpPacketsPerAudioBuffer-1;
		}
	}

	
/*
This function returns the current RTP packet to be sent to the headet
if there are no packets that are ready to be sent
ie iNumberOfReadyPackets = 0 then the RRtpSendPacket
will be invalid.
CurrentSendPacketSent() needs to be called when a send packet has been
acknowledged as being sent by the RTP stack
*/	
RRtpSendPacket& CAudioBufferArray::CurrentSendPacket()
	{
	CRtpSendPackets* currentSendAudioBuffer = iAudioBufferArray[iAudioBufferBeingSent];
	return currentSendAudioBuffer->Packet(iNextRtpPacketToSend);
	}	


/*
This function is called when the RTP module has made the callback indicating that the 
current send packet has been sent.
The function updates the current send packet to the next packet to be sent

@param aEntireAudioBufferSent this is set to true if the 
current entire audio buffer has been sent.  The RTPStreamer uses
this information to determine whether to complete the send request status
*/	
void CAudioBufferArray::CurrentSendPacketSent(TBool& aEntireAudioBufferSent)
	{
	aEntireAudioBufferSent = EFalse;
	if (iNumberOfReadyAudioBuffers)//this could be 0 if the current packet sent was sent and subsequently cancelled
		{
		iNextRtpPacketToSend++;
		if (iNextRtpPacketToSend >= iNumberOfRtpPacketsPerAudioBuffer)
			{//then we have sent all the RTP packets in the current audio buffer
			iNextRtpPacketToSend = 0;
			iAudioBufferBeingSent++; //we've finished with this audio buffer so move onto the next one
			//do something to show we are finished with audio buffer and complete request status
			if (iAudioBufferBeingSent >= iAudioBufferArray.Count())
				{
				iAudioBufferBeingSent = 0;
				}
			iNumberOfReadyAudioBuffers--;
			aEntireAudioBufferSent = ETrue;	
			}		
		}
	//else if iNumberOfReadyAudioBuffers = 0 then the packet must have been canceled so do nothing
	__ASSERT_DEBUG((iNumberOfReadyAudioBuffers<=iAudioBufferArray.Count()),Panic(EAudioBufferArrayMiscount));//check underflow
	}