// 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 "A2dpCodecUtilities.h"

/**

A2dp codec utilities Panics

**/

enum TA2dpCodecUtilitiesPanic

	{

	EA2dpCodecUtilNoRemoteCodecConfig, //0

	EA2dpCodecUtilUnexpectedDataType, //1

	EA2dpCodecUtilUnsupportedDataType, //2

	EA2dpCodecUtilUnexpectedConfiguration, //3

	EA2dpCodecUtilDataMemberNotSet //4

	};

static void Panic(TA2dpCodecUtilitiesPanic aPanic)

// Panic client

	{

	_LIT(KA2dpCodecUtilitiesPanicName, "A2DP Codec Util Panic");

	User::Panic(KA2dpCodecUtilitiesPanicName, aPanic);

	}

TInt TA2dpCodecCapabilityParser::GetSupportedSBCSampleRates(const TSBCCodecCapabilities& aCodecCaps, RArray<TUint>& aSupportedDiscreteRates)

	{

	TInt err = KErrNone;

	TSBCSamplingFrequencyBitmask samplingRatesBitMask = aCodecCaps.SamplingFrequencies();

	if (samplingRatesBitMask & E16kHz)

		{

		err = aSupportedDiscreteRates.Append(16000);

		}

	if (!err && (samplingRatesBitMask & E32kHz))

		{

		err = aSupportedDiscreteRates.Append(32000);

		}

	if (!err && (samplingRatesBitMask & E44100Hz))

		{

		err = aSupportedDiscreteRates.Append(44100);

		}

	if (!err && (samplingRatesBitMask & E48kHz))

		{

		err = aSupportedDiscreteRates.Append(48000);

		}

	return err;

	}

TInt TA2dpCodecCapabilityParser::GetSupportedMPEG12SampleRates(const TNonSBCCodecCapabilities& aCodecCaps, RArray<TUint>& aSupportedDiscreteRates)

	{

	TInt err = KErrNone;

	TPtrC8 codecCapsData(aCodecCaps.CodecData());

	TMPEG12SamplingFrequencyBitmask samplingRatesBitMask = codecCapsData[1] & KA2dpMPEG12SamplingFrequencyMask;

	if (samplingRatesBitMask & EMPEG12_16kHz)

		{

		err = aSupportedDiscreteRates.Append(16000);		

		}

	if (!err && samplingRatesBitMask & EMPEG12_22050Hz)

		{

		err = aSupportedDiscreteRates.Append(22050);	

		}

	if (!err && samplingRatesBitMask & EMPEG12_24kHz)

		{

		err = aSupportedDiscreteRates.Append(24000);	

		}

	if (!err && samplingRatesBitMask & EMPEG12_32kHz)

		{

		err = aSupportedDiscreteRates.Append(32000);		

		}

	if (!err && samplingRatesBitMask & EMPEG12_44100Hz)

		{

		err = aSupportedDiscreteRates.Append(44100);		

		}

	if (!err && samplingRatesBitMask & EMPEG12_48kHz)

		{

		err = aSupportedDiscreteRates.Append(48000);			

		}

	return err;

	}

TInt TA2dpCodecCapabilityParser::GetSupportedSampleRates(const TAvdtpMediaCodecCapabilities& aCodecCaps, RArray<TUint>& aSupportedDiscreteRates)

	{

	TInt err = KErrNotSupported;

	switch(aCodecCaps.MediaCodecType())

		{

		case EAudioCodecSBC:

			err = GetSupportedSBCSampleRates(static_cast<const TSBCCodecCapabilities&>(aCodecCaps), aSupportedDiscreteRates);

			break;

		case EAudioCodecMPEG12Audio:

			err = GetSupportedMPEG12SampleRates(static_cast<const TNonSBCCodecCapabilities&>(aCodecCaps), aSupportedDiscreteRates);

			break;

		case EAudioCodecMPEG24AAC:

			break;

		case EAudioCodecATRAC:

			break;

		default:

			Panic(EA2dpCodecUtilUnexpectedDataType);

			break;

		}

	return err;

	}

TInt TA2dpCodecCapabilityParser::GetSupportedSBCChannels(const TSBCCodecCapabilities& aCodecCaps, RArray<TUint>& aSupportedChannels, TMMFStereoSupport& aStereoSupport)

	{

	TInt err = KErrNotSupported;

	TSBCChannelModeBitmask channelModesBitMask = aCodecCaps.ChannelModes();

	err = GetSupportedChannelsCommonCode(channelModesBitMask, aSupportedChannels, aStereoSupport);

	return err;

	}

TInt TA2dpCodecCapabilityParser::GetSupportedMPEG12Channels(const TNonSBCCodecCapabilities& aCodecCaps, RArray<TUint>& aSupportedChannels, TMMFStereoSupport& aStereoSupport)

	{

	TInt err = KErrNotSupported;

	TPtrC8 codecCapsData(aCodecCaps.CodecData());

	TSBCChannelModeBitmask channelModesBitMask = codecCapsData[0] & KA2dpMPEG12AudioChannelModeMask;

	err = GetSupportedChannelsCommonCode(channelModesBitMask, aSupportedChannels, aStereoSupport);

	return err;

	}

/**

MPEG12 uses the same channel mode bit mask as SBC so we'll factor out the common code

and reuse the TSBCChannelModeBitmask for mp3 as well

*/	

TInt TA2dpCodecCapabilityParser::GetSupportedChannelsCommonCode(TSBCChannelModeBitmask aChannelModesBitMask, RArray<TUint>& aSupportedChannels, TMMFStereoSupport& aStereoSupport)

	{

	TInt err = KErrNotSupported;

	if (aChannelModesBitMask & EMono)

		{

		err = aSupportedChannels.Append(EMMFMono);

		}

	if (!err)

		{

		if ((aChannelModesBitMask & EStereo) || (aChannelModesBitMask & EJointStereo))

			{

			err = aSupportedChannels.Append(EMMFStereo);

			aStereoSupport = EMMFInterleavedOnly;

			}

		}

	if (!err && (aChannelModesBitMask & EJointStereo))

		{

		//we have to cast as the TMMFStereoSupport is an enumeration

		//but is really should be a bitmap

		//but don't want to change it in order to preserve BC

		TUint aStereoSupportInt = static_cast<TUint>(aStereoSupport);

		aStereoSupportInt |= static_cast<TUint>(EMMFJoint);

		aStereoSupport = static_cast<TMMFStereoSupport>(aStereoSupportInt);

		}

	return err;

	}

TInt TA2dpCodecCapabilityParser::GetSupportedChannels(const TAvdtpMediaCodecCapabilities& aCodecCaps, RArray<TUint>& aSupportedChannels, TMMFStereoSupport& aStereoSupport)

	{

	TInt err = KErrNotSupported;

	switch(aCodecCaps.MediaCodecType())

		{

		case EAudioCodecSBC:

			err = GetSupportedSBCChannels(static_cast<const TSBCCodecCapabilities&>(aCodecCaps), aSupportedChannels, aStereoSupport);

			break;

		case EAudioCodecMPEG12Audio:

			err = GetSupportedMPEG12Channels(static_cast<const TNonSBCCodecCapabilities&>(aCodecCaps), aSupportedChannels, aStereoSupport);

			break;

		case EAudioCodecMPEG24AAC:

			Panic(EA2dpCodecUtilUnsupportedDataType);

			break;

		case EAudioCodecATRAC:

			Panic(EA2dpCodecUtilUnsupportedDataType);

			break;

		default:

			Panic(EA2dpCodecUtilUnexpectedDataType);

			break;

		}

	return err;

	}

/**

static

*/

TUint8 TRTPa2dpCodecSpecificUtils::PayloadType(const TFourCC& aCodecDataType)

	{

	TUint8 payloadType = 0;

	switch(const_cast<TFourCC&>(aCodecDataType).FourCC())

		{

		case KMMFFourCCCodeSBC:

			payloadType = KSbcRTPPayloadType;

			break;

		case KMMFFourCCCodeMP3:

			payloadType = KMPEG12RTPAudioPayloadType; 

			break;

		case KMMFFourCCCodeAAC:

			Panic(EA2dpCodecUtilUnsupportedDataType);

			break;

		case KMMFFourCCCodeATRAC3:

			Panic(EA2dpCodecUtilUnsupportedDataType);

			break;

		default:

			Panic(EA2dpCodecUtilUnexpectedDataType);

			break;

		}

	return payloadType;

	}

TUint TRTPa2dpCodecSpecificUtils::MediaPayloadHeaderLength(const TFourCC& aCodecDataType)

	{

	TUint mediaPayloadHeaderLength = 0;

	switch(const_cast<TFourCC&>(aCodecDataType).FourCC())

		{

		case KMMFFourCCCodeSBC:

			mediaPayloadHeaderLength = KSbcRTPMediaPayloadHeaderLength;

			break;

		case KMMFFourCCCodeMP3:

			mediaPayloadHeaderLength = KMPEG12RTPMediaPayloadHeaderLength;

			break;

		case KMMFFourCCCodeAAC:

			Panic(EA2dpCodecUtilUnsupportedDataType);

			break;

		case KMMFFourCCCodeATRAC3:

			Panic(EA2dpCodecUtilUnsupportedDataType);

			break;

		default:

			Panic(EA2dpCodecUtilUnexpectedDataType);

			break;

		}

	return mediaPayloadHeaderLength;

	}

TTimeIntervalMicroSeconds32 TFrameTimingUtils::FrameDuration(TUint aFrameLength, TUint aBitRate)

	{

	TUint frameDurationuS = (aFrameLength*8*1000000)/aBitRate;

	return TTimeIntervalMicroSeconds32(frameDurationuS);

	}

TUint TFrameTimingUtils::CalculateSBCTimeStampIncrementPerFrame(TUint aFrameLength, TUint aBitRate, TUint aSampleRate)

	{

	//SBC uses the sampleRate clock as the timestamp clock A2DP spec 4.3.3.1

	TUint frameDurationuS = FrameDuration(aFrameLength, aBitRate).Int();

	return (frameDurationuS*aSampleRate)/1000000;

	}

TUint TFrameTimingUtils::CalculateMPEG12TimeStampIncrementPerFrame(TUint aFrameLength, TUint aBitRate)

	{

	//MPEG12 uses a 90Khz clock as the timestamp clock RFC3551 section 4.5.13

	TUint frameDurationuS = FrameDuration(aFrameLength, aBitRate).Int();

	//div 1000000 as frame duration is in microseconds

	return (frameDurationuS*KMPEG12RTPTimeStampClock)/1000000;

	}

TUint TFrameTimingUtils::TimeStampIncrementPerFrame(const TFourCC& aCodecDataType, TUint aFrameLength, TUint aBitRate, TUint aSampleRate)

	{

	TInt timeStampIncrement = 0;

	switch (const_cast<TFourCC&>(aCodecDataType).FourCC())

		{

		case KMMFFourCCCodeSBC:

			timeStampIncrement = CalculateSBCTimeStampIncrementPerFrame(aFrameLength, aBitRate, aSampleRate);

			break;

		case KMMFFourCCCodeMP3:

			timeStampIncrement = CalculateMPEG12TimeStampIncrementPerFrame(aFrameLength, aBitRate);

			break;

		case KMMFFourCCCodeAAC:

			Panic(EA2dpCodecUtilUnsupportedDataType);

			break;

		case KMMFFourCCCodeATRAC3:

			Panic(EA2dpCodecUtilUnsupportedDataType);

			break;

		default:

			//the datatype is a non A2DP datatype

			//which is not supported so panic

			Panic(EA2dpCodecUtilUnexpectedDataType);

			break;

		}

	return timeStampIncrement;

	}

CA2dpLocalCodecCapabilities* CA2dpLocalCodecCapabilities::NewL()

	{

	return new(ELeave) CA2dpLocalCodecCapabilities();

	}

CA2dpLocalCodecCapabilities::CA2dpLocalCodecCapabilities()	

	{

	}

CA2dpLocalCodecCapabilities::~CA2dpLocalCodecCapabilities()

	{

	delete iLocalCodecCapabilities;

	}

TAvdtpMediaCodecCapabilities*  CA2dpLocalCodecCapabilities::LocalCodecCapabilities(const TFourCC& aCodecDataType)

	{

	switch(const_cast<TFourCC&>(aCodecDataType).FourCC())

		{

		case KMMFFourCCCodeSBC:

			iLocalCodecCapabilities = LocalSBCCodecCapabilities();

			break;

		case KMMFFourCCCodeMP3:

			iLocalCodecCapabilities = LocalMPEG12CodecCapabilities();

			break;

		case KMMFFourCCCodeAAC:

			Panic(EA2dpCodecUtilUnsupportedDataType);

			break;

		case KMMFFourCCCodeATRAC3:

			Panic(EA2dpCodecUtilUnsupportedDataType);

			break;

		default:

			Panic(EA2dpCodecUtilUnexpectedDataType);

			break;

		}

	return iLocalCodecCapabilities;

	}

TSBCCodecCapabilities* CA2dpLocalCodecCapabilities::LocalSBCCodecCapabilities()

	{

	delete iLocalCodecCapabilities;

	iLocalCodecCapabilities = NULL;

	TSBCCodecCapabilities* localSbcCodecCapabilities = new TSBCCodecCapabilities();

	if (localSbcCodecCapabilities)

		{

		localSbcCodecCapabilities->SetSamplingFrequencies(E16kHz|E32kHz|E44100Hz|E48kHz);

		localSbcCodecCapabilities->SetChannelModes(EMono|EStereo|EJointStereo);

		localSbcCodecCapabilities->SetBlockLengths(EBlockLenFour|EBlockLenEight|EBlockLenTwelve|EBlockLenSixteen);

		localSbcCodecCapabilities->SetSubbands(EFourSubbands|EEightSubbands);

		localSbcCodecCapabilities->SetAllocationMethods(ELoudness|ESNR);

		localSbcCodecCapabilities->SetMinBitpoolValue(KMinBitPoolValue);

		localSbcCodecCapabilities->SetMaxBitpoolValue(KMaxBitPoolValue);

		}

	return localSbcCodecCapabilities;

	}

TNonSBCCodecCapabilities* CA2dpLocalCodecCapabilities::LocalMPEG12CodecCapabilities()

	{

	delete iLocalCodecCapabilities;

	iLocalCodecCapabilities = NULL;

	TNonSBCCodecCapabilities* localSEPmpeg12CodecCapabilities = new TNonSBCCodecCapabilities(EAvdtpMediaTypeAudio, EAudioCodecMPEG12Audio);

	if (localSEPmpeg12CodecCapabilities)

		{

		TBuf8<4>	mpeg12CodecCapabilitiesData;

		//MPEG12 channel modes are the same as SBC so we'll use SBC structure

		TSBCChannelModeBitmask channelModes = (EMono|EStereo);

		mpeg12CodecCapabilitiesData.Append(KA2dpMPEG12LayerMP3Supported | channelModes);

		//no MPF-2 support, will support 16-44100khz sample

		TInt8 samplingFrequencySupport = EMPEG12_16kHz|EMPEG12_22050Hz|EMPEG12_24kHz|EMPEG12_32kHz|EMPEG12_44100Hz;

		mpeg12CodecCapabilitiesData.Append(samplingFrequencySupport);

		//no VBR all bitrates <= 96kbs-1 except free format

		mpeg12CodecCapabilitiesData.Append(0);

		mpeg12CodecCapabilitiesData.Append(KA2dpMPEG12SupportedBitRateIndex);//all bit rates <= 96kbs-1

		localSEPmpeg12CodecCapabilities->SetCodecData(mpeg12CodecCapabilitiesData);

		}

	return localSEPmpeg12CodecCapabilities;

	}

CA2dpAudioCodecConfiguration* CA2dpAudioCodecConfiguration::NewL()

	{

	return new(ELeave)CA2dpAudioCodecConfiguration();

	}

CA2dpAudioCodecConfiguration::CA2dpAudioCodecConfiguration() : iHeadsetCodecDataType(KMMFFourCCCodeSBC), iSampleRate(KDefaultSampleRate), iChannels(KDefaultChannels), iStereoSupport(KDefaultStereoSupport)

	{	

	}

CA2dpAudioCodecConfiguration::~CA2dpAudioCodecConfiguration()

	{

	delete iRemoteCodecConfiguration;

	}

void CA2dpAudioCodecConfiguration::Reset()

	{

	delete iRemoteCodecConfiguration;

	iRemoteCodecConfiguration = NULL;

	iHeadsetCodecDataType = KMMFFourCCCodeSBC;

	iSampleRate = KDefaultSampleRate;

	iChannels = KDefaultChannels;

	iStereoSupport = KDefaultStereoSupport;

	iLocalSBCCodecConfiguration.Reset();

	}

/**

Function used to return a TAvdtpMediaCodecCapabilities structure

that can be used to configure the SEP at the remote end ie on the headset

The capabilities are used to determine the configuration

need to return by pointer rather than by ref as TAvdtpMediaCodecCapabilities is abstract

Note that this parameter passed in treats the  TAvdtpMediaCodecCapabilities as 

the capabilities of the code, whereas the returned TAvdtpMediaCodecCapabilities is a

configuration ie a specific set of values that can be used to configure the remote codec

@param aCodecCapabilities  This is the capabilities supported by the remote codec

@return The configuration for the remote codec

*/

//void CA2dpAudioCodecConfiguration::GetRemoteCodecConfiguration(const TAvdtpMediaCodecCapabilities& aRemoteCodecCapabilities, TAvdtpMediaCodecCapabilities& aRemoteCodecConfiguration)

TAvdtpMediaCodecCapabilities* CA2dpAudioCodecConfiguration::UpdateRemoteCodecConfiguration(const TAvdtpMediaCodecCapabilities& aRemoteCodecCapabilities)

	{

	delete iRemoteCodecConfiguration;

	iRemoteCodecConfiguration = NULL;

		{

		//this hasn't been set yet so set it

		//first find out the capabilities of the codec

		switch (aRemoteCodecCapabilities.MediaCodecType())

			{

			case EAudioCodecSBC:

				iRemoteCodecConfiguration = GetRemoteSBCCodecConfiguration(static_cast<const TSBCCodecCapabilities&>(aRemoteCodecCapabilities));

				iHeadsetCodecDataType = KMMFFourCCCodeSBC;

				break;

			case EAudioCodecMPEG12Audio:

				iRemoteCodecConfiguration = GetRemoteMPEG12CodecConfiguration(static_cast<const TNonSBCCodecCapabilities&>(aRemoteCodecCapabilities));

				iHeadsetCodecDataType = KMMFFourCCCodeMP3;

				break;

			case EAudioCodecMPEG24AAC:

				Panic(EA2dpCodecUtilUnsupportedDataType);

				break;

			case EAudioCodecATRAC:

				Panic(EA2dpCodecUtilUnsupportedDataType);

				break;

			default:

				//the datatype is a non A2DP datatype

				//which is not supported so panic

				Panic(EA2dpCodecUtilUnexpectedDataType);

				break;

			}

		}

	return iRemoteCodecConfiguration;

	}

/**

*/

TSBCCodecCapabilities* CA2dpAudioCodecConfiguration::GetRemoteSBCCodecConfiguration(const TSBCCodecCapabilities& aCodecCaps)

	{

	TSBCCodecCapabilities* sbcCodecConfiguration = new TSBCCodecCapabilities();

	if (sbcCodecConfiguration)	

		{

		//--sampling frequency--

		TSBCSamplingFrequencyBitmask freqs;

		switch(iSampleRate)

			{

			case 16000:

				freqs = E16kHz;

				break;

			case 32000:

				freqs = E32kHz;

				break;

			case 44100:

				freqs = E44100Hz;

				break;

			case 48000:

				freqs = E48kHz;

				break;

			default:

				freqs = E16kHz;

				break;

			}

		//check we really can support this sampling frequency

		//since we may be using the default which may not be supported

		//by the headset (even if the A2DP spec says it is mandatory)

		TSBCSamplingFrequencyBitmask samplingFreqsSupportedByHeadset = aCodecCaps.SamplingFrequencies();

		if 	(iForcedRemoteSBCCodecConfiguration)

			{

			samplingFreqsSupportedByHeadset = iForcedRemoteSBCCodecConfiguration->SamplingFrequencies();

			}

		if (!(freqs & samplingFreqsSupportedByHeadset))

			{//then the headset doesn't support the sampling frequency

			//this could happen if iSampleRate is a default that the headset doesn't support

			//note that evenif the default is a mandatory sample rate eg 44100

			//we still do not make any assumptions about what is supported 

			if (samplingFreqsSupportedByHeadset & E16kHz)

				{

				iSampleRate = 16000;

				freqs = E16kHz;

				}

			else if (samplingFreqsSupportedByHeadset & E32kHz)

				{

				iSampleRate = 32000;

				freqs = E32kHz;

				}

			else if (samplingFreqsSupportedByHeadset & E44100Hz)