// Copyright (c) 2003-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:

//

/**

 @file

 @publishedPartner

*/

#include <bluetoothav.h>

#include "gavdpinterface.h"

#include "avdtpSBCCodecCapability.h"

/**

Default constructor for SBC codec details

*/

EXPORT_C TSBCCodecCapabilities::TSBCCodecCapabilities()

: TAvdtpMediaCodecCapabilities(SymbianBluetoothAV::EAvdtpMediaTypeAudio,

								SymbianBluetoothAV::EAudioCodecSBC,

								KServiceCatLOSCSBCCodec)

	{

	}

/**

@internalTechnology

*/	

EXPORT_C /*virtual*/ TInt TSBCCodecCapabilities::AsProtocol(RBuf8& aBuffer) const

	{

	using namespace SymbianBluetoothAV;

	TInt ret = AddHeader(aBuffer);

	if (ret == KErrNone)

		{		

		aBuffer.Append(static_cast<TChar>(iMediaType));

		aBuffer.Append(static_cast<TChar>(iMediaCodecType));

		TUint8 octet = (iSamplingFrequencies << KSBCIESampFreqOffset) |

					   (iChannelModes & KSBCIEChModeMask);

		aBuffer.Append(static_cast<TChar>(octet));

		octet = (iBlockLengths << KSBCIEBlockLenOffset) |

			    ((iSubbands & KSBCIESubbandsMask) << KSBCIESubbandsOffset) |

			    (iAllocationMethod & KSBCIEAllocMethMask);

		aBuffer.Append(static_cast<TChar>(octet));

		aBuffer.Append(static_cast<TChar>(iMinimumBitpoolValue));

		aBuffer.Append(static_cast<TChar>(iMaximumBitpoolValue));

		}

	return ret;

	}

/**

@internalTechnology

*/	

EXPORT_C /*virtual*/ void TSBCCodecCapabilities::Parse(const TDesC8& aPtr)

	{

	TInt ptrLength = aPtr.Length();

#ifdef _DEBUG

	_LIT(KSBCCodecCapabilitiesPanic, "SBCConfigPanic");

#endif

	__ASSERT_DEBUG(ptrLength>=6, User::Panic(KSBCCodecCapabilitiesPanic, 0));

	// parse the media type and codec type via base-class

	TAvdtpMediaCodecCapabilities::Parse(aPtr);

	iSamplingFrequencies = 0;

	iChannelModes = 0;

	iBlockLengths = 0;

	iSubbands = 0;

	iAllocationMethod = 0;

	iMinimumBitpoolValue = 0;

	iMaximumBitpoolValue = 0;

	//set the values according to the length of the package

	switch(ptrLength) {

		case 6:

			iMaximumBitpoolValue = static_cast<TInt>(aPtr[5]);

		case 5:

			iMinimumBitpoolValue = static_cast<TInt>(aPtr[4]);

		case 4:

			iBlockLengths = static_cast<TSBCBlockLengthBitmask>(aPtr[3]>>KSBCIEBlockLenOffset);

			iSubbands = static_cast<TSBCSubbandsBitmask>((aPtr[3]>>KSBCIESubbandsOffset)&KSBCIESubbandsMask);

			iAllocationMethod = static_cast<TSBCAllocationMethodBitmask>(aPtr[3]&KSBCIEAllocMethMask);

		case 3:

			iSamplingFrequencies = static_cast<TSBCSamplingFrequencyBitmask>(aPtr[2]>>KSBCIESampFreqOffset);

			iChannelModes = static_cast<TSBCChannelModeBitmask>(aPtr[2]&KSBCIEChModeMask);

		default:

			break;

		}

	}

/**

Get the SBC sampling frequencies

@return bitmask of supported sampling frequencies

*/	

EXPORT_C TSBCSamplingFrequencyBitmask TSBCCodecCapabilities::SamplingFrequencies() const

	{

	return iSamplingFrequencies;

	}

/**

Set the SBC sampling frequencies

@param aSampFreq bitmask of supported sampling frequencies

*/	

EXPORT_C void TSBCCodecCapabilities::SetSamplingFrequencies(TSBCSamplingFrequencyBitmask aSampFreq)

	{

	iSamplingFrequencies = aSampFreq;

	}

/**

Get the SBC channel modes

@return bitmask of supported channel modes

*/	

EXPORT_C TSBCChannelModeBitmask TSBCCodecCapabilities::ChannelModes() const

	{

	return iChannelModes;

	}

/**

Set the SBC channel modes

@param aChModes bitmask of supported channel modes

*/	

EXPORT_C void TSBCCodecCapabilities::SetChannelModes(TSBCChannelModeBitmask aChModes)

	{

	iChannelModes = aChModes;

	}

/**

Get the SBC block lengths

@return bitmask of supported block lengths

*/	

EXPORT_C TSBCBlockLengthBitmask TSBCCodecCapabilities::BlockLengths() const

	{

	return iBlockLengths;

	}

/**

Set the SBC block lengths

@param aBlockLens bitmask of supported block lengths

*/	

EXPORT_C void TSBCCodecCapabilities::SetBlockLengths(TSBCBlockLengthBitmask aBlockLens)

	{

	iBlockLengths=aBlockLens;

	}

/**

Get the SBC subbands

@return bitmask of supported subbands

*/	

EXPORT_C TSBCSubbandsBitmask TSBCCodecCapabilities::Subbands() const

	{

	return iSubbands;

	}

/**

Set the SBC subbands

@param aSubbands bitmask of supported subbands

*/	

EXPORT_C void TSBCCodecCapabilities::SetSubbands(TSBCSubbandsBitmask aSubbands)

	{

	iSubbands = aSubbands;

	}

/**

Get the SBC allocation methods

@return bitmask of supported allocation methods

*/	

EXPORT_C TSBCAllocationMethodBitmask TSBCCodecCapabilities::AllocationMethods() const

	{

	return iAllocationMethod;

	}

/**

Set the SBC allocation methods

@param aAllocMeths of supported allocation methods

*/	

EXPORT_C void TSBCCodecCapabilities::SetAllocationMethods(TSBCAllocationMethodBitmask aAllocMeths)

	{

	iAllocationMethod = aAllocMeths;

	}

/**

Get the SBC minimum bitpool value

@return minimum bitpool value

*/	

EXPORT_C TInt TSBCCodecCapabilities::MinBitpoolValue() const

	{

	return iMinimumBitpoolValue;

	}

/**

Set the SBC minimum bitpool value

@param aMinBP minimum bitpool value

*/	

EXPORT_C void TSBCCodecCapabilities::SetMinBitpoolValue(TInt aMinBP)

	{

	iMinimumBitpoolValue = aMinBP;

	}

/**

Get the SBC maximum bitpool value

@return maximum bitpool value

*/	

EXPORT_C TInt TSBCCodecCapabilities::MaxBitpoolValue() const

	{

	return iMaximumBitpoolValue;

	}

/**

Set the SBC maximum bitpool value

@param aMaxBP maximum bitpool value

*/	

EXPORT_C void TSBCCodecCapabilities::SetMaxBitpoolValue(TInt aMaxBP)

	{

	iMaximumBitpoolValue = aMaxBP;

	}