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

 //

 #ifndef __AUDIOBUFFERARRAY_H__

 #define __AUDIOBUFFERARRAY_H__

 #include <e32base.h>

 #include <rtp.h>

 const TUint KMaxNumberOfSBCFramesPerRTPPacket = 15;

 class TSBCFrameParameters;

 class CA2dpAudioCodecConfiguration;

 /**

 This class contains an array of RRtpSendPackets that contain

 the audio to be sent to the headset over RTP

 Note that the RRtpSendPackets are only created once upfront

 it is assumed that these packets can be recycled

 Each audio buffer consists of one CRtpSendPackets class instance,

 however due to the underlying restrictions imposed by A2DP and 

 the BT L2CAP bearer MTU size limit- each CRtpSendPackets may

 consist of one or more RRtpSendPacket

 @internalComponent

 */

 NONSHARABLE_CLASS(CRtpSendPackets) : public CBase

 	{

 public:

 	static CRtpSendPackets* NewL(RRtpSendSource& aRtpSendSource, TUint aNumberOfPackets);

 	~CRtpSendPackets();

 	void ConstructL(RRtpSendSource& aRtpSendSource, TUint aNumberOfPackets);

 	inline RRtpSendPacket& Packet(TUint aPacketNumber);

 private:

 	void CloseAndResetSendPackets();

 private:

 	RArray<RRtpSendPacket> iRtpSendPackets;

 	};

 /**

 This function obtains the next free RTPsendPacket

 that is available to be filled with audio data

 @return RRtpSendPacket that is free and hence can be filled with audio

 */	

 inline RRtpSendPacket& CRtpSendPackets::Packet(TUint aPacketNumber)

 	{

 	return iRtpSendPackets[aPacketNumber];

 	}

 /**

 This class is used by CActiveRTPStreamer

 It is a FIFO used to provide a buffer array of audio buffers.

 Each audio buffer is contained in one CRtpSendPackets which 

 may itself be broken up into multiple RTP packets.

 The size and number of packets each audio buffer is broken down is

 calculated from the various input parameters provided to the NewL.

 This class makes the assumption than provided the audio parameters

 are unchanged, then the buffer length stays the same for each buffer sent,

 (except the last buffer)

 This assumption has been made, as by not assuming this, then the frame duration

 and number of frames calculations would need to be recalculated for every audio buffer

 and the RTPSendPackets would need to be created for every buffer.

 @internalComponent

 */	

 NONSHARABLE_CLASS(CAudioBufferArray) : public CBase

 	{

 public:

 	static CAudioBufferArray* NewL(RRtpSendSource& aRtpSendSource,

 							TUint aNumberOfAudioBuffers,

 							TUint aAudioBufferSize,

 							TUint aMTULength,

 							TUint aTotalRTPHeaderLength,

 							TUint aFrameLength);

 	~CAudioBufferArray();

 	void CurrentAudioBufferReadyToSend();

 	void CancelMostRecentAudioBuffer(TBool aSendInProgress);

 	void FlushPendingPackets();

 	RRtpSendPacket& CurrentSendPacket();

 	void CurrentSendPacketSent(TBool& aEntireAudioBufferSent);

 	inline CRtpSendPackets* CurrentAudioBufferRtpSendPackets() const;

 	inline TUint NumberOfAudioBuffersReadyToSend() const;

 	inline TUint MaxNumberOfAudioBuffers() const;

 	inline TUint InputBytesPerRTPPacket() const;

 	inline TUint NumberOfRtpPacketsPerAudioBuffer() const;

 	inline TUint NumberOfFramesPerRtpPacket() const;

 private:

 	void ConstructL(RRtpSendSource& aRtpSendSource, 

 				TUint aNumberOfAudioBuffers,

 				TUint aAudioBufferSize,

 				TUint aMTULength,

 				TUint aTotalRTPHeaderLength,

 				TUint aFrameLength);

 private:

 	RPointerArray<CRtpSendPackets> iAudioBufferArray;

 	TUint	iAudioBufferBeingSent;

 	TUint	iNextRtpPacketToSend;

 	TUint	iNextAudioBufferToFill;

 	TUint	iNumberOfReadyAudioBuffers; 

 	TUint	iNumberOfRtpPacketsPerAudioBuffer;

 	TUint	iInputBytesPerRtpPacket;

 	TUint	iFrameLength;

 	TUint	iNumberOfFramesPerRtpPacket;

 	};

 /**

 This function obtains the current free audio buffer

 in the form of a CRTPsendPackets

 The  CRTPsendPackets returned are available to be filled with audio data

 @return CRtpSendPackets array that is free and hence can be filled with audio

 */	

 inline CRtpSendPackets* CAudioBufferArray::CurrentAudioBufferRtpSendPackets() const

 	{

 	return iAudioBufferArray[iNextAudioBufferToFill];

 	}

 /**

 This function returns the total number of audio buffers in the

 audio buffer array that have been filled with audio and hence are

 ready to be sent to the headset.

 @return number of audio buffers ready to send

 */	

 inline TUint CAudioBufferArray::NumberOfAudioBuffersReadyToSend() const

 	{

 	return iNumberOfReadyAudioBuffers;

 	}

 /**

 This function returns the maximum number of audio buffers that 

 can be stored in the audio buffer array.

 It is set by the aNumberOfAudioBuffers parameter in the constructor

 @return max number of audio buffers that can be stored in the audio 

 buffer array

 */	

 inline TUint CAudioBufferArray::MaxNumberOfAudioBuffers() const

 	{

 	return iAudioBufferArray.Count();

 	}

 /**

 This function returns the number of input bytes 

 ie bytes prior to any codec processing that will

 (after possible codec processing) constitute an RTP packet

 @return input bytes per RTP packet

 */

 inline TUint CAudioBufferArray::InputBytesPerRTPPacket() const

 	{

 	return iInputBytesPerRtpPacket;

 	}

 /**

 This function returns the number of RTP packets that make up an audio buffer

 @return number of RTP packets

 */	

 inline TUint CAudioBufferArray::NumberOfRtpPacketsPerAudioBuffer() const

 	{

 	return iNumberOfRtpPacketsPerAudioBuffer;

 	}

 /**

 This function returns the number of audio frames in a single RTP packet

 ie the total number of audio frames in a single audio buffer is given by:

 NumberOfFramesPerRtpPacket()*NumberOfRtpPacketsPerAudioBuffer()

 @return number of audio frames in a single RTP packet

 */	

 inline TUint CAudioBufferArray::NumberOfFramesPerRtpPacket() const 

 	{

 	return iNumberOfFramesPerRtpPacket;

 	};

 #endif