// 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 <bluetoothav.h>

 #include <mmf/server/mmfcodec.h>

 #include "mmfSBCCodecImplementationUIDs.hrh"

 #include <hal.h>

 #include "A2dpCodecUtilities.h"

 #include "AudioBufferArray.h"

 #include "RTPStreamer.h"

 /**

 RTP Streamer Panics

 **/

 enum TRTPStreamerPanic

 	{

 	ERTPStreamerSendPacketMiscount, //0

 	ERTPStreamerSendNotCompleted, //1

 	ERTPStreamerEmptyBuffer, //2

 	ERTPStreamerRTPEventError, //3

 	ERTPStreamerIncompleteSBCFrame, //4

 	ERTPStreamerUnexpectedEvent, //5

 	ERTPStreamerBufferProcessingLengthMismatch, //6

 	ERTPStreamerInvalidDataType, //7

 	ERTPStreamerNoConfiguration //8

 	};

 static void Panic(TRTPStreamerPanic aPanic)

 // Panic client

 	{

 	_LIT(KRTPStreamerPanicName, "RTP Streamer");

 	User::Panic(KRTPStreamerPanicName, aPanic);

 	}

 /**

 Creates CActiveRTPStreamer

 @param aSock RSocket that can be used to stream audio to the headset

 @param aRTPStreamObserver mixin used to inform the CA2dpBTHeadsetAudioInterface

 of asynchronous error events

 @return CActiveRTPStreamer*

 */

 CActiveRTPStreamer* CActiveRTPStreamer::NewL(RSocket& aSock, MRTPStreamerObserver& aRTPStreamerObserver)

 	{

 	CActiveRTPStreamer* self = new (ELeave) CActiveRTPStreamer (aRTPStreamerObserver);

 	CleanupStack::PushL(self);

 	self->ConstructL(aSock);

 	CleanupStack::Pop(self);

 	return self;

 	}

 /**

 Make priortiy high so other RunLs don't impact CTimer accuracy too much

 */

 CActiveRTPStreamer::CActiveRTPStreamer(MRTPStreamerObserver& aRTPStreamerObserver) : CTimer(EPriorityHigh), iRTPStreamerObserver(aRTPStreamerObserver), iRtpCanSend(ETrue)

 	{

 	CActiveScheduler::Add(this);

 	}

 CActiveRTPStreamer::~CActiveRTPStreamer()

 	{

 	Cancel();

 	delete iAudioBufferArray;

 	//RTP defect fix DEF57144- RRtpSendSource Cancel()

 	//If the line of code below does not compile then your build is too old

 	iRTPSendSource.Cancel();

 	iRTPSendSource.Close();	

 	iRTPSession.Close();	

 	}

 void CActiveRTPStreamer::ConstructL(RSocket& aSock)

 	{

 	CTimer::ConstructL();

 	// get the MTU length limit

 	TInt mtu = 0;

 	User::LeaveIfError(aSock.GetOpt(EAvdtpMediaGetMaximumPacketSize, KSolBtAVDTPMedia, mtu));

 	iMaxMTULength = mtu;//the line above wont accept iMaxMTULength directly because it is unsigned

 	iRTPSession.OpenL(aSock, iMaxMTULength);

 	iRTPSendSource = iRTPSession.NewSendSourceL();

 	//register callbacks - all terminal callbacks are one shot

 	iRTPSession.RegisterEventCallbackL(ERtpAnyEvent,RTPCallback,this);									

 	iRTPSession.RegisterEventCallbackL(ERtpSessionFail,RTPCallback,this, ERtpOneShot);

 	iRTPSession.RegisterEventCallbackL(ERtpBufferOverflow,RTPCallback,this);

 	iRTPSession.RegisterEventCallbackL(ERtpUndersizedPacket,RTPCallback,this);

 	iRTPSendSource.RegisterEventCallbackL(ERtpAnyEvent,RTPSendSourceCallback,this);

 	iRTPSendSource.RegisterEventCallbackL(ERtpSendFail,RTPSendSourceCallback,this, ERtpOneShot);

 	}

 /**

 Function called by the CA2dpBTHeadsetAudioInterface to set the codec and the codec

 settings used by the CActiveRTPStreamer.

 Calling this function forces a recalculation of all the timings the next

 time Send() is called

 @param aCodec the codec to be used.  If this is set to NULL then no codec is used

 only the CSBCCodec can be used here

 @param aConfigType a Uid to identify the aConfigData used to configure the settings

 only KMmfUidSBCConfigure is currently defined.  In future other types may be defined

 for mp3, AAC and ATRAC3

 @param aConfigData The configuration data

 @return standard SymbianOS error code

 */

 void CActiveRTPStreamer::SetCodec(CMMFCodec& aCodec)

 	{

 	//if there is a codec then it must be SBC else codec must be on the headset

 	iCodec = &aCodec;

 	}

 void CActiveRTPStreamer::SetAudioConfiguration(const CA2dpAudioCodecConfiguration& aAudioCodecConfiguration)

 	{

 	iA2dpAudioCodecConfiguration = const_cast<CA2dpAudioCodecConfiguration*>(&aAudioCodecConfiguration);

 	//if there is a new codec configuration then cannot assume the buffer 

 	//length will be the same so reset

 	iBufferLength = 0;

 	iBufferParamsInitialized = EFalse;//will result in a call to InitializeForSendL

 	iTimeStampIncrement = 0;

 	iNumberOfInputBytesToMakeRTPPacket = 0;

 	}

 /**

 Internal function to perform frame size related initialization

 ie creation and setting of the RTPSendPacket audio buffer array.

 Assumes all buffers are the same size (except for the last buffer)

 @param The length of the audio buffer sent in Send()

 */

 void CActiveRTPStreamer::InitializeForSendL(const TDesC8& aData)

 	{

 	iSendBufferSize = aData.Size(); //store buffer length - this shouldn't change till the last buffer

 	__ASSERT_DEBUG(iSendBufferSize,Panic(ERTPStreamerEmptyBuffer));

 	__ASSERT_DEBUG(iA2dpAudioCodecConfiguration,Panic(ERTPStreamerNoConfiguration));

 	TUint encodedBufferSize = iSendBufferSize;

 	if (iCodec)

 		{

 		iCodec->ResetL(); //clear out any cached data from previous settings

 		//if we are using a local codec - ie SBC then we get the frame length 

 		//and bit rate from the local codec settings

 		//since aData will contain pcm16

 		iFrameLength = iA2dpAudioCodecConfiguration->LocalSBCCodecConfiguration().CalcFrameLength();

 		iBitRate = iA2dpAudioCodecConfiguration->LocalSBCCodecConfiguration().CalcBitRate(iFrameLength)*1000;//*1000 as bitrate is in KHz

 		//if we are putting data through the local SBC codec then 

 		//the encoded buffer size sent to the headset in not the same as the aData buffer in Send()

 		encodedBufferSize = iA2dpAudioCodecConfiguration->CalculateSBCBufferLength(iSendBufferSize);

 		}

 	else

 		{

 		//if we don't use a local codec then we get the frame legth and bit rate

 		//direct from the header

 		CA2dpCodecFrameHeaderParser* headerParser = CA2dpCodecFrameHeaderParser::NewL(iA2dpAudioCodecConfiguration->HeadsetCodecDataType(), aData);

 		iFrameLength = headerParser->FrameLength();

 		iBitRate = headerParser->BitRate();

 		delete headerParser;

 		}

 	iPayloadType = TRTPa2dpCodecSpecificUtils::PayloadType(iA2dpAudioCodecConfiguration->HeadsetCodecDataType());	

 	//if the settings have changed then any existing buffered audio buffers

 	// will have the old settings so we need to delete the buffer array

 	//and recreate from new with the new settings.

 	//we also need to cancel in case we are waiting on a RTPSendSourceCallback

 	//from a previous send packet

 	//RTP defect fix DEF57144- RRtpSendSource Cancel() not in MCL

 	//decomment this out when the Cancel method is on the MCL

 	//iRTPSendSource.Cancel();

 	delete iAudioBufferArray;

 	iAudioBufferArray = NULL;

 	//calculate the size of the RTP header

 	TUint mediaPayloadHeaderLength = TRTPa2dpCodecSpecificUtils::MediaPayloadHeaderLength(iA2dpAudioCodecConfiguration->HeadsetCodecDataType());

 	TUint rtpHeaderLength = KRTPHeaderSize + mediaPayloadHeaderLength;

 	iAudioBufferArray = CAudioBufferArray::NewL(iRTPSendSource, KSendBucketSize, encodedBufferSize, iMaxMTULength, rtpHeaderLength, iFrameLength);

 	//determine the payload header

 	switch(const_cast<TFourCC&>(iA2dpAudioCodecConfiguration->HeadsetCodecDataType()).FourCC())

 		{

 		case KMMFFourCCCodeSBC:

 			iMediaPayloadHeader.Append(iAudioBufferArray->NumberOfFramesPerRtpPacket());

 			break;

 		case KMMFFourCCCodeMP3:

 			//RFC2250-section 3.5 MBZ+Frag_Offset

 			//= 4 bytes all set to 0

 			iMediaPayloadHeader.FillZ(4); //0000

 			break;

 		case KMMFFourCCCodeAAC:

 			break;

 		case KMMFFourCCCodeATRAC3:

 			break;

 		default:

 			//the datatype is a non A2DP datatype

 			//which is not supported so panic

 			Panic(ERTPStreamerInvalidDataType);

 			break;

 		}

 	//get the number of bytes of data sent that was sent to the RTP streamer

 	//that make up one RTP packet

 	//in the case of a codec this is the value pre codec processing

 	if (iCodec)	

 		{

 		iNumberOfInputBytesToMakeRTPPacket = iSendBufferSize/iAudioBufferArray->NumberOfRtpPacketsPerAudioBuffer();

 		if (iNumberOfInputBytesToMakeRTPPacket%2)

 			{//we have an odd number of bytes

 			iNumberOfInputBytesToMakeRTPPacket++;//round up to next byte

 			}

 		}

 	else

 		{

 		iNumberOfInputBytesToMakeRTPPacket = iAudioBufferArray->InputBytesPerRTPPacket();

 		}

 	//else other codecs not supported

 	//we set the iFrameDuration which is used to trigger the timer

 	//this means that RunL should be called every iFrameDuration and

 	//if an RTP packet is ready to sent then it shall be sent

 	//since there is no control channel back from the headset, the best

 	//we can hope for is to send the data at approx the rate the headset 

 	//would expect it and hope that the headset provides it's own approriate

 	//internal buffering

 	//Note that dues to other AOs running the timing is not accurate and

 	//usually slower than the specified time - what is really needed

 	//here is a feedback loop where the initial time interval is somewhat

 	//faster than the calculated time interval and is adjusted against the

 	//system clock and bit rate throughput acordingly so the throughput always

 	//matches the bit rate.

 	iRTPPacketDuration = TTimeIntervalMicroSeconds32(TFrameTimingUtils::FrameDuration(iFrameLength,iBitRate).Int() * iAudioBufferArray->NumberOfFramesPerRtpPacket());

 	RDebug::Printf("RTP Packet Duration = %d mS", iRTPPacketDuration.Int());

 	TInt fastCounterFrequency;

 	HAL::Get(HALData::EFastCounterFrequency,fastCounterFrequency);

 	RDebug::Printf("sys clock timing frequency = %d Hz", fastCounterFrequency);

 	iTimeStampIncrement = TFrameTimingUtils::TimeStampIncrementPerFrame(iA2dpAudioCodecConfiguration->HeadsetCodecDataType(), iFrameLength, iBitRate, iA2dpAudioCodecConfiguration->SampleRate())

 						 * iAudioBufferArray->NumberOfFramesPerRtpPacket();	

 	RDebug::Printf("Calculated RTP packet time stamp increment = %d",iTimeStampIncrement);

 	RDebug::Printf("FrameLength = %d", iFrameLength);

 	RDebug::Printf("Calculated bitRate = %d", iBitRate);

 	RDebug::Printf("Number of frames per RTP packet = %d", iAudioBufferArray->NumberOfFramesPerRtpPacket());

 	RDebug::Printf("Number of RTP packets per audio buffer = %d", iAudioBufferArray->NumberOfRtpPacketsPerAudioBuffer());

 	RDebug::Printf("Sample rate = %d", iA2dpAudioCodecConfiguration->SampleRate());

 	}

 /**

 Internal function to pass the pcm16 audio data in aData and use the codec

 to process the data back in aPayload

 @return the number of source bytes processed

 */

 TUint CActiveRTPStreamer::CodecProcessPayloadL(const TDesC8& aData,TDes8& aPayload)

 	{

 	TPtr8 srcBufferPtr(const_cast<TUint8*>(aData.Ptr()),aData.Length());

 	srcBufferPtr.SetLength(aData.Length());

 	//+1 -1 to skip SBC media payload header

 	TPtr8 dstBufferPtr(const_cast<TUint8*>(aPayload.Ptr()+1),aPayload.MaxLength()-1);

 	CMMFPtrBuffer* srcBuffer = CMMFPtrBuffer::NewL(srcBufferPtr);

 	CleanupStack::PushL(srcBuffer);

 	CMMFPtrBuffer* dstBuffer = CMMFPtrBuffer::NewL(dstBufferPtr);

 	CleanupStack::PushL(dstBuffer);

 	TCodecProcessResult result = iCodec->ProcessL(*srcBuffer,*dstBuffer);

 	if (result == 	TCodecProcessResult::EProcessIncomplete)

 		{

 		User::Leave(KErrArgument);

 		}

 	aPayload.Append(dstBuffer->Data());

 	CleanupStack::PopAndDestroy(dstBuffer);

 	CleanupStack::PopAndDestroy(srcBuffer);

 	return result.iSrcBytesProcessed;

 	}

 /**

 This is the main function for CActiveRTPStreamer in that it is the 

 function used to send data to the headset over RTP.

 The function is asynchronous to the RunL which does the actual sending.

 The data is stored in the CRtpSendPackets FIFO and will be sent at the 

 next RunL provided the RTP can accept the data.  If not it just stays

 buffered in the CRtpSendPackets FIFO until it can be sent.

 The request status is completed when the buffer is stored, not when it is sent

 this is to more closely mimic the behaviour of the sound driver.

 If adding the buffer to the CRtpSendPackets FIFO causes it to be full

 then the request status won't be completed until there is space in the FIFO

 which won't be until a callback from the RTP stack has been received 

 indicating that the CRtpSendPackets FIFO can now discard that entry.

 Only one Send at a time is accepted ie the request status

 of the previous send must be completed before Send can be called again.

 To simplify the software and improve performance, fixed sized buffers are assumed.ie

 the buffer length is only calculated once on the first frame and when the settings

 change.

 @param aData  The data to be sent to the headset. This may go via 

 a codec eg if the data is pcm16 or sent directly to the headset if the data is SBC,mp3,AAC,ATRAC3

 It is the responsibility of the client ie CA2dpBTHeadsetAudioInterface to

 call SetCodecConfiguration first.

 @param aStatus

 */

 void CActiveRTPStreamer::Send(const TDesC8& aData, TRequestStatus& aStatus)

 	{

 	if (iSendStatus)

 		{

 		__ASSERT_DEBUG((*iSendStatus != KRequestPending),Panic(ERTPStreamerSendNotCompleted));

 		}

 	iSendStatus = &aStatus;

 	*iSendStatus = KRequestPending;

 	if (iUnrecoverableError)

 		{

 		User::RequestComplete(iSendStatus,iUnrecoverableError);

 		return;

 		}

 	if (!iBufferParamsInitialized)

 		{

 		TRAPD(err,InitializeForSendL(aData));

 		if (err)

 			{

 			User::RequestComplete(iSendStatus,err);

 			return;

 			}

 		iBufferParamsInitialized = ETrue;

 		}

 	TUint numberOfRtpPacketsPerAudioBuffer = iAudioBufferArray->NumberOfRtpPacketsPerAudioBuffer();	

 	if (aData.Size() != iSendBufferSize)

 		{

 		//then we are on the last buffer

 		//in which case we need to recalculate the number of Rtp packets

 		//required to make up the audio frame since the last buffer

 		//is smaller.

 		TUint lastBufferLength = aData.Size();

 		if (iCodec)

 			{

 			lastBufferLength = iA2dpAudioCodecConfiguration->CalculateSBCBufferLength(aData.Size());

 			}

 		//we keep the same number of RTP packets per audio buffer as before

 		TUint numberOfSBCFramesInLastBuffer = lastBufferLength/iFrameLength;

 		TUint numberOfFramesPerRtpPacket = iAudioBufferArray->NumberOfFramesPerRtpPacket();

 		//the devisor below may not always devide without a remainder

 		//which means the last Rtp packet sent will not be full

 		//if we have a remainder then we need another Rtp packet

 		numberOfRtpPacketsPerAudioBuffer = numberOfSBCFramesInLastBuffer/numberOfFramesPerRtpPacket;

 		if (numberOfSBCFramesInLastBuffer%numberOfFramesPerRtpPacket)

 			{

 			numberOfRtpPacketsPerAudioBuffer++;

 			}

 		}

 	CRtpSendPackets* sendPackets = iAudioBufferArray->CurrentAudioBufferRtpSendPackets();

 	TUint srcBytesProcessed = 0;

 	for (TUint i=0; i<numberOfRtpPacketsPerAudioBuffer;i++)

 		{

 		RDebug::Printf("NewRTPPacketReceived %d",User::FastCounter());

 		RRtpSendPacket& sendPacket = sendPackets->Packet(i);

 		sendPacket.SetPayloadType(iPayloadType);

 		sendPacket.SetTimestamp(iTimeStamp);

 		iTimeStamp += iTimeStampIncrement;

 		TDes8& payload = sendPacket.WritePayload();

 		payload.Zero();

 		payload.Append(iMediaPayloadHeader);

 		//aData may have to be sent as multiple packets

 		TUint8* sourceDataOffset = const_cast<TUint8*>(aData.Ptr())+srcBytesProcessed;

 		TPtr8 srcBufferPtr(sourceDataOffset,iNumberOfInputBytesToMakeRTPPacket);

 		TUint srcBytesStillRemaining = aData.Size() - srcBytesProcessed;

 		TUint lengthOfsrcBuffer = iNumberOfInputBytesToMakeRTPPacket;

 		if (srcBytesStillRemaining < lengthOfsrcBuffer )

 			{//probably a last buffer condition or modulo 2 pcm16 rounding condition

 			lengthOfsrcBuffer = srcBytesStillRemaining;

 			}

 		srcBufferPtr.SetLength(lengthOfsrcBuffer);

 		//sanity check - the following should always be true

 		__ASSERT_DEBUG((srcBytesProcessed == iNumberOfInputBytesToMakeRTPPacket*i),Panic(ERTPStreamerBufferProcessingLengthMismatch));

 		if (iCodec)

 			{

 			TRAPD(err,srcBytesProcessed += CodecProcessPayloadL(srcBufferPtr,payload));

 			if (err)

 				{

 				//something has gone wrong so abort streaming

 				User::RequestComplete(iSendStatus,err);

 				return;

 				}

 			}

 		else //no need to process via codec - aData can go straight to the headset

 			{

 			srcBytesProcessed +=lengthOfsrcBuffer;

 			payload.Append(srcBufferPtr);

 			}

 		}//	for (TUint i=0; i<iAudioBufferArray->NumberOfRtpPacketsPerAudioBuffer();i++)

 	iAudioBufferArray->CurrentAudioBufferReadyToSend();

 	//else we have no more send packets so cannot complete request status

 	//until one of the send packets has been sent and acknowledged.

 	//we'll send an event to ourselves and either send the packet if we can

 	//we could complete the iSendStatus TRequestStatus here before returing 

 	//from the Send but we won't in order to more closely mimic the existing

 	// sound driver PlayData behaviour

 	//if there is already a request active then it will be the timer

 	//ie this will effectively kick things off if the timer is not running

 	TRequestStatus* stat = &iStatus;

 	if (!IsActive())

 		{

 		User::RequestComplete(stat, KErrNone);

 		SetActive();

 		}			

 	}

 /**

 Function to stop further internally buffered packets being sent to the headset

 */	

 void CActiveRTPStreamer::Pause()

 	{

 	iPaused = ETrue;

 	Cancel();

 	}

 /**

 Function called after pause to resume sending buffers to the headset

 */	

 void CActiveRTPStreamer::Resume()

 	{

 	if (iPaused)

 		{

 		iPaused = EFalse;

 		TRequestStatus* stat = &iStatus;

 		if (!IsActive())

 			{

 			User::RequestComplete(stat, KErrNone);

 			SetActive();

 			}

 		}

 	}

 /**

 Function called from  CA2dpBTHeadsetAudioInterface::CancelPlayData()

 Used to cancel an outstanding status request for a Send()

 */

 void CActiveRTPStreamer::CancelLastSendBuffer()

 	{

 	if (iSendStatus)

 		{

 		if (*iSendStatus == KRequestPending)//make sure there is a pending request to cancel

 			{

 			iAudioBufferArray->CancelMostRecentAudioBuffer(!iRtpCanSend);

 			User::RequestComplete(iSendStatus, KErrCancel);

 			}

 		}

 	}

 /**

 Function to flush out the bufferes stored in CRtpSenPackets

 */

 void CActiveRTPStreamer::FlushPendingSendBuffers()

 	{

 	iAudioBufferArray->FlushPendingPackets();

 	if(iCodec)

 		{//flush out codec cache

 		TRAP_IGNORE(iCodec->ResetL());

 		}

 	}

 /**

 Function to return total number of bytes sent prior to codec processing

 ie bytes of pcm16 not SBC

 Note this the number of bytes sent is only updated when the packet

 has been acknowledged as being sent correctly by the RTP stack

 ie this value will always be slightly less than the bytes sent in Send()

 */

 TUint CActiveRTPStreamer::BytesSent() const

 	{

 	return iBytesSent;

 	}

 /**

 Function to reset the number of bytes sent

 */	

 void CActiveRTPStreamer::ResetBytesSent()

 	{

 	iBytesSent = 0;

 	}

 /**

 The RunL is called every frame duration interval.

 It checks to see if there are any packets to be sent to the headset

 and if so send it.

 One issue to be resolved at integration testing is if there are no packets

 to send then this is analogous to a KErrUnderflow condition on the 

 sound driver. Do we need to mimic this behaviour for the a2dp interface?

 The Send request status is completed if there is room in the CRtpSendPackets

 for another buffer.

 */	

 void CActiveRTPStreamer::RunL()

 	{

 	if ((iPaused)||(!iAudioBufferArray))

 		{

 		return;

 		}

 	if(iRtpCanSend && iAudioBufferArray->NumberOfAudioBuffersReadyToSend())

 		{

 		RRtpSendPacket& sendPacket = iAudioBufferArray->CurrentSendPacket();

 		sendPacket.Send();

 		iRtpCanSend = EFalse; //have to wait for callback before we can send again

 		}

 	if (iSendStatus)

 		{

 		if ((iAudioBufferArray->NumberOfAudioBuffersReadyToSend() < KSendBucketSize)

 	    	&&(*iSendStatus == KRequestPending))

 			{//still some free packets to fill so complete request status

 			User::RequestComplete(iSendStatus, KErrNone);

 			iSendStatus = NULL;

 			}

 		//else if the iRtpSendPackets FIFO is full then we can't complete

 		//the request status until we've had an ERtpSendSucceeded event

 		}

 		//are there any more buffers that are ready to send?

 		//if so then send the next packet after a time delay

 		//keep calling this RunL every frame duration till as long as we have packets to send

 		//if there are no packets ready to send then we need to wait 

 		//for another call to Send();

 	if (iAudioBufferArray->NumberOfAudioBuffersReadyToSend()) 

 		{//there are packets ready to send so fire off next RunL after one RTP packet duration

 		RDebug::Printf("RTPPacket Sent %d",User::FastCounter());

 		After(iRTPPacketDuration);

 		}

 	}

 /**

 Cancel

 */	

 void CActiveRTPStreamer::DoCancel()

 	{

 	CTimer::DoCancel();

 	CompleteSendRequestStatus(KErrCancel);

 	}

 /**

 Utility function to complete Send TRequestStatus with aError

 */

 void CActiveRTPStreamer::CompleteSendRequestStatus(TInt aError)

 	{

 	if (iSendStatus)

 		{

 		if (*iSendStatus == KRequestPending)

 			{

 			User::RequestComplete(iSendStatus, aError);

 			}

 		}

 	}

 /**

 Called by RTP stack when a packet has been sent

 If the packet was sent ok then complete the iSendStatus if it is pending

 and update the number of bytes sent

 If the packet was not sent ok then the error is regarded as unrecoverable

 since this should not happen.  If it does happen then the CA2dpBTHeadsetAudioInterface

 is informed.  If there is an outstanding Send TRequestStatus then this is

 completed with KErrCommsFrame.  Not sure if this is the most appropriate error code?

 */	

 void CActiveRTPStreamer::PacketSent(TRtpEventType aEvent)

 	{

 	if (aEvent == ERtpSendSucceeded)

 		{

 		RDebug::Printf("Sent RTPPacket Acknowledged %d",User::FastCounter());

 		TBool entireAudioBufferSent = EFalse;	

 		iAudioBufferArray->CurrentSendPacketSent(entireAudioBufferSent);		

 		//check if there is an outstanding send request status

 		//we can only complete the send request status if all the

 		//RTP packets in the audio buffer have been sent.

 		if (entireAudioBufferSent)

 			{

 			CompleteSendRequestStatus(KErrNone);

 			}

 		iRtpCanSend = ETrue;

 		iBytesSent += iNumberOfInputBytesToMakeRTPPacket;

 		}

 	else if (aEvent == ERtpSendFail)

 		{

 		//if we fail to send the packet then chances are something

 		//has gone wrong that may not be recoverable

 		//so we will complete the request status and halt further streaming

 		//some testing may be required to see if it is possible to

 		//recover in which case the packet could be sent again

 		iUnrecoverableError = KErrCommsFrame;//probably the nearest error code

 		CompleteSendRequestStatus(iUnrecoverableError);

 		//inform iRTPStreamerObserver ie the CA2dpBTHeadsetAudioInterface

 		//this will initiate a GAVDP state machine reset which will destroy the CActiveRTPStreamer 

 		iRTPStreamerObserver.RTPStreamerEvent(iUnrecoverableError);

 		}

 	else 

 		{//we've not registered for any other events so this shouldn't happen

 		Panic(ERTPStreamerUnexpectedEvent);

 		}

 	}

 /**

 Called by RTP stack when some sort of general error has occured

 eg switching off the headset, or the headset going out of range 

 The CA2dpBTHeadsetAudioInterface is informed. 

 */

 void CActiveRTPStreamer::RTPSessionEvent(const TRtpEvent& aEvent)

 	{

 	switch(aEvent.Type())

 		{

 		case ERtpSessionFail:

 			iUnrecoverableError = KErrDisconnected;

 			break;

 		case ERtpBufferOverflow:

 			iUnrecoverableError = KErrOverflow;

 			break;

 		case ERtpUndersizedPacket:

 			iUnrecoverableError = KErrCommsFrame;

 			break;

 		default:

 			Panic(ERTPStreamerRTPEventError); //we haven't registered for anything else

 			break;

 		}

 	//complete outstanding Send (CA2dpBTHeadsetAudioInterface::PlayData) request status

 	CompleteSendRequestStatus(iUnrecoverableError);		

 	//inform CA2dpBTHeadsetAudioInterface

 	iRTPStreamerObserver.RTPStreamerEvent(iUnrecoverableError);

 	}

 /**

 Static callback from RTP stack

 */	

 void CActiveRTPStreamer::RTPSendSourceCallback(CActiveRTPStreamer* aStreamer, const TRtpEvent& aEvent)

 	{

 	__ASSERT_DEBUG((aEvent.IsSendSourceEvent()),Panic(ERTPStreamerRTPEventError));

 	__ASSERT_DEBUG((aEvent.SendSource() == aStreamer->iRTPSendSource),Panic(ERTPStreamerRTPEventError));

 	// for now assume it was sending complete

 	// do next bit

 	aStreamer->PacketSent(aEvent.Type());

 	}

 /**

 Static callback from RTP stack

 */

 void CActiveRTPStreamer::RTPCallback(CActiveRTPStreamer* aStreamer, const TRtpEvent& aEvent)

 	{

 	__ASSERT_DEBUG((aEvent.IsSessionEvent()),Panic(ERTPStreamerRTPEventError)); 

 	__ASSERT_DEBUG((aEvent.Session() == aStreamer->iRTPSession),Panic(ERTPStreamerRTPEventError));

 	aStreamer->RTPSessionEvent(aEvent);

 	}