// 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

	}