// Copyright (c) 2004-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 <mmf/plugin/mmfsbccodecimplementationuids.hrh> // KMmfUidSBCConfigure

#include "SBCEncoder.h"

#include "SBCConst.h"

#include "SBCFrameParameters.h"

/**

The sbc configuration UID, used to identify configuration type, 

have to use this to configure any sbc codec.

*/

const TUid   KSBCConfigTypeUid = { KMmfUidSBCConfigure };

/**

SBC CRC shift register initial value for SBC CRC calculation

*/

const TUint8 KSbcCRCShiftRegisterInit 	 = 0x0f;

/**

SBC CRC XOR mask, derived from polynomial G(X) = X^8 + X^4 + X^3 + X^2 + 1

*/

const TUint8 KSbcCRCShiftRegisterXorMask = 0x1d;

#ifdef _DEBUG

enum 

	{

	ESbcBitstreamPosErr,

	ESbcSampleOverflow

	};

_LIT(KSBCEncoderPanicCategory, "CSBCEncoder");

static inline void Panic(TInt aError)

	{

	User::Panic(KSBCEncoderPanicCategory, aError);

	}

#endif

/* ========================= class CBitStreamParser ========================= */

/**

class CBitStreamParser constructor

@internalComponent

@param aBitStream

The bit stream buffer to be parsed

*/

CBitStreamParser::CBitStreamParser(TDes8& aBitStream) : iBitStream(aBitStream),	

	iByteOffset(0), iBitOffset(0)

	{

	iPtr = const_cast<TUint8*>(aBitStream.Ptr() );

	}

/**

class CBitStreamParser destructor

@internalComponent

*/

CBitStreamParser::~CBitStreamParser()

	{

	}

/**

class CBitStreamParser second phase constructor

@internalComponent

*/

void CBitStreamParser::ConstructL()

	{

	}

/**

This function creates a new CBitStreamParser object and push it into CleanupStack.

@internalComponent

@param aBitStream

The bit stream buffer to be parsed

@return pointer to the new CBitStreamParser object

@leave if out of memory

*/

CBitStreamParser* CBitStreamParser::NewLC(TDes8& aBitStream)

	{

	CBitStreamParser* self = new(ELeave) CBitStreamParser(aBitStream);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

/**

This function reset the internal bit position of CBitStreamParser

@internalComponent

*/

void CBitStreamParser::Reset()

	{

	iPtr = const_cast<TUint8*>(iBitStream.Ptr() );

	iByteOffset = 0;

	iBitOffset = 0;

	}

/**

This function reads a number of bits from bit stream buffer at current bit position

and change the bit position to then end of the last bit read.

@internalComponent

@param aBitsToRead

Number of bits to read, at most 8 bits

@return the bits value in byte

@panic if bit position is outside of the stream buffer

*/

TUint8 CBitStreamParser::ReadBits(TInt aBitsToRead)

	{

	TUint8 result = 0;

	if (aBitsToRead >= 8 - iBitOffset)

		{

		__ASSERT_DEBUG(iByteOffset < static_cast<TUint>(iBitStream.MaxLength() ), Panic(ESbcBitstreamPosErr) );

		// extra code to handle exception for URel version

		if (iByteOffset >= static_cast<TUint>(iBitStream.MaxLength() ) )

			{

			return 0;

			}

		aBitsToRead -= (8 - iBitOffset);

		result = static_cast<TUint8>( (*iPtr & (0xff >> iBitOffset) ) << aBitsToRead);

		iPtr++;

		iByteOffset++;

		iBitOffset = 0;

		}

	if (aBitsToRead > 0)

		{

		__ASSERT_DEBUG(iByteOffset < static_cast<TUint>(iBitStream.MaxLength() ), Panic(ESbcBitstreamPosErr) );

		// extra code to handle exception for URel version

		if (iByteOffset >= static_cast<TUint>(iBitStream.MaxLength() ) )

			{

			return 0;

			}

		result |= static_cast<TUint8>( (*iPtr & (0xff >> iBitOffset) ) >> (8 - iBitOffset - aBitsToRead) );

		iBitOffset = static_cast<TUint8>(iBitOffset + aBitsToRead);

		}

	return result;

	}

/**

This function writes a number of bits to the bit stream buffer at current bit position

and change the bit position to then end of the last bit written.

@internalComponent

@param aBitsToWrite

Number of bits to write, at most 8 bits

@param aBitsValue

The bits value to write in byte

@panic if bit position is outside of the stream buffer

*/

void CBitStreamParser::WriteBits(TInt aBitsToWrite, TUint8 aBitsValue)

	{

	if (aBitsToWrite >= 8 - iBitOffset)

		{

		__ASSERT_DEBUG(iByteOffset < static_cast<TUint>(iBitStream.MaxLength() ), Panic(ESbcBitstreamPosErr) );

		// extra code to handle exception for URel version

		if (iByteOffset >= static_cast<TUint>(iBitStream.MaxLength() ) )

			{

			return;

			}

		aBitsToWrite -= (8 - iBitOffset);

		*iPtr &= ~(0xff >> iBitOffset); // clear bits

		*iPtr |= (aBitsValue >> aBitsToWrite) & (0xff >> iBitOffset); // set bits

		iPtr++;

		iByteOffset++;

		iBitOffset = 0;

		}

	if (aBitsToWrite > 0)

		{

		__ASSERT_DEBUG(iByteOffset < static_cast<TUint>(iBitStream.MaxLength() ), Panic(ESbcBitstreamPosErr) );

		// extra code to handle exception for URel version

		if (iByteOffset >= static_cast<TUint>(iBitStream.MaxLength() ) )

			{

			return;

			}

		*iPtr &= (0xff << (8 - iBitOffset) ) | (0xff >> (iBitOffset + aBitsToWrite) ); // clear bits

		*iPtr |= (aBitsValue << (8 - iBitOffset - aBitsToWrite) ) & (0xff >> iBitOffset); // set bits

		iBitOffset = static_cast<TUint8>(iBitOffset + aBitsToWrite);

		}

	}

/**

This function reads 8 bits from bit stream buffer at current bit position

and change the bit position to then end of the last bit read.

@internalComponent

@return the bits value in byte

*/

TUint8 CBitStreamParser::ReadByte()

	{

	return ReadBits(8);

	}

/**

This function writes 8 bits to the bit stream buffer at current bit position

and change the bit position to then end of the last bit written.

@internalComponent

@param aByteValue

The byte value to write

*/

void CBitStreamParser::WriteByte(TUint8 aByteValue)

	{

	WriteBits(8, aByteValue);

	}

/**

This function sets the bit position to a specific position.

@internalComponent

@param aByteOffset

New byte position to set

@param aBitOffset

New bit position to set

@panic if bit position is outside of the stream buffer

*/

void CBitStreamParser::SetPosition(TUint aByteOffset, TUint8 aBitOffset)

	{

	while (aBitOffset >= 8)

		{

		aBitOffset -= 8;

		iByteOffset++;

		}

	__ASSERT_DEBUG(iByteOffset < static_cast<TUint>(iBitStream.MaxLength() ), Panic(ESbcBitstreamPosErr) );

	// extra code to handle exception for URel version

	if (iByteOffset >= static_cast<TUint>(iBitStream.MaxLength() ) )

		{

		aBitOffset = 0;

		iByteOffset = iBitStream.MaxLength();

		}

	iPtr = const_cast<TUint8*>(iBitStream.Ptr() ) + aByteOffset;

	iByteOffset = aByteOffset;

	iBitOffset = aBitOffset;

	}

/**

This function gets the bit position.

@internalComponent

@param aByteOffset

Read byte position

@param aBitOffset

Read bit position

*/

void CBitStreamParser::Position(TUint& aByteOffset, TUint8& aBitOffset) const

	{

	aByteOffset = iByteOffset;

	aBitOffset = iBitOffset;

	}

/* ========================= class CSbcCRCCalculator ========================= */

/**

Constructor

@internalComponent

*/

CSbcCRCCalculator::CSbcCRCCalculator() : iShiftRegister(KSbcCRCShiftRegisterInit)

	{

	}

/**

This function resets the shift register value to intial SBC CRC value

@internalComponent

*/

void CSbcCRCCalculator::Reset()

	{

	iShiftRegister = KSbcCRCShiftRegisterInit;

	}

/**

This function inputs one bit into the shift register

@internalComponent

@param aBit

The lowest bit contains the bit to input. 

*/

void CSbcCRCCalculator::InputBit(TUint8 aBit)

	{

	TUint8 inputBit = static_cast<TUint8>( (iShiftRegister >> 7) ^ (aBit & 0x1) );

	iShiftRegister <<= 1;

	if (inputBit)

		{

		iShiftRegister ^= KSbcCRCShiftRegisterXorMask;

		}

	}

/**

This function inputs a number of bits into the shift register

@internalComponent

@param aBits

The number of bits to input, at most 8 bits.

@param aValue

The input bits value. 

*/

void CSbcCRCCalculator::InputBits(TUint8 aBits, TUint8 aValue)

	{

	for (TInt bit = aBits - 1; bit >= 0; bit--)

		{

		InputBit(static_cast<TUint8>(aValue >> bit) );

		}

	}

/**

This function inputs 8 bits into the shift register.

@internalComponent

@param aValue

The input byte value. 

*/

void CSbcCRCCalculator::InputByte(TUint8 aByte)

	{

	InputBit(static_cast<TUint8>(aByte >> 7) );

	InputBit(static_cast<TUint8>(aByte >> 6) );

	InputBit(static_cast<TUint8>(aByte >> 5) );

	InputBit(static_cast<TUint8>(aByte >> 4) );

	InputBit(static_cast<TUint8>(aByte >> 3) );

	InputBit(static_cast<TUint8>(aByte >> 2) );

	InputBit(static_cast<TUint8>(aByte >> 1) );

	InputBit(aByte);

	}

/**

This function gets the shift register value.

@internalComponent

@return the shift register value. 

*/

TUint8 CSbcCRCCalculator::ShiftRegister()

	{

	return iShiftRegister;

	}

/* ============================ class CSBCEncoder ============================ */

/**

Constructor.

@internalComponent

*/

CSBCEncoder::CSBCEncoder()

	{

	}

/**

Destructor.

@internalComponent

*/

CSBCEncoder::~CSBCEncoder()

	{

	delete iSbcFrameEncoder;

	delete iPcmSampleCach; // this is used to cache any remaining samples less than on frame

	}

/**

Second phase constructor.

@internalComponent

@param aInitParams

Initial parameters for creating this object, not in use for the moment

@leave never

*/

void CSBCEncoder::ConstructL(TAny* /*aInitParams*/)

	{

	}

/**

This function resets any existing audio samples from the cach.

@internalComponent

@leave never

*/

void CSBCEncoder::ResetL()

	{

	if (iPcmSampleCach)

		{

		iPcmSampleCach->Des().Zero();

		}

	}

/**

This function creates a new CSBCEncoder object.

@internalComponent

@param aInitParams

Initial parameters for creating this object, not in use for the moment

@leave if out of memory

*/

CMMFCodec* CSBCEncoder::NewL(TAny* aInitParams)

	{

	CSBCEncoder* self = new(ELeave) CSBCEncoder();

	CleanupStack::PushL(self);

	self->ConstructL(aInitParams);

	CleanupStack::Pop();

	return self;

	}

/**

This function is used for configuring the CSBCEncoder object. Should be called before encode

@internalComponent

@param aConfigType

Configuration UID, has to be set to KSBCConfigTypeUid

@param aConfigData

A package buffer which contains all the settings

@leave KErrNotSupported if configuration UID does't match or parameters setting is invalid.

*/

void CSBCEncoder::ConfigureL(TUid aConfigType, const TDesC8& aConfigData)

	{

	if (aConfigType != KSBCConfigTypeUid)

		{

		User::Leave(KErrNotSupported);

		}

	const TSBCFrameParameters& param = 

		static_cast<const TPckgBuf<TSBCFrameParameters>&>(aConfigData)();

	if (param.Validate() != 0)

		{

		User::Leave(KErrArgument);

		}

	iParameters = param;

	if (iPcmSampleCach)

		{

		delete iPcmSampleCach;

		iPcmSampleCach = NULL;

		}

	if (iSbcFrameEncoder)

		{

		// must call this whenever ConfigureL() is called to make sure CSBCFrameEncoder

		// uses the new configuration, as we can change the configuration without creating 

		// a new CSBCFrameEncoder object

		iSbcFrameEncoder->Configure(iParameters); 

		}

	iSbcFrameLength = iParameters.CalcFrameLength();

	iPcmFrameSize = sizeof(TInt16) * param.BlockLength() * param.Subbands() * param.Channels();

	}

/**

This function encodes sbc audio stream with PCM16 audio source samples, and write processed 

result to destination buffer. It also caches any less than one frame remaining audio samples.

@internalComponent

@param aSrc

Source buffer contains the PCM16 audio source samples

@param aDst

Destination buffer to contain the encoded sbc audio stream

@return processed result

@leave 

	KErrAbort if configuration is invalid, 

	KErrArgument if destination buffer size is smaller than one frame length,

	KErrCorrupt if output bytes is not the same as frame length or 

				if we still have enough src and dst but the process stoped, 

	Or other errors e.g. out of memory error.

*/

TCodecProcessResult CSBCEncoder::ProcessL(const CMMFBuffer& aSrc, CMMFBuffer& aDst)

	{

	// check if ConfigureL gets called already

	if (iParameters.Validate() != 0)

		{

		User::Leave(KErrAbort);

		}

	// check if dst big enough to hold at least one frame

	CMMFDataBuffer* dst = static_cast<CMMFDataBuffer*>(&aDst);

	const TUint dstMaxLen = dst->Data().MaxLength();

	if (dstMaxLen < iSbcFrameLength)

		{

		User::Leave(KErrArgument);

		}

	// process data

	const CMMFDataBuffer* src = static_cast<const CMMFDataBuffer*>(&aSrc);

	const TUint srcLen = src->Data().Length();

	TUint srcPos = src->Position();

	TUint dstPos = dst->Position();

	const TUint8* srcPtr = src->Data().Ptr();

	TUint8* dstPtr = const_cast<TUint8*>(dst->Data().Ptr() );

	TUint cachedSize = CachedSampleSize();

	while (cachedSize + srcLen - srcPos >= iPcmFrameSize && dstMaxLen - dstPos >= iSbcFrameLength)

		{

		TPtrC8 srcDes(srcPtr + srcPos, iPcmFrameSize);

		TPtr8  dstDes(dstPtr + dstPos, iSbcFrameLength);

		srcPos += EncodeFrameL(srcDes, dstDes);

		dstPos += iSbcFrameLength;

		cachedSize = 0;

		}

	// check result

	TCodecProcessResult result;

	result.iStatus = TCodecProcessResult::EProcessComplete;

	if (dstMaxLen - dstPos >= iSbcFrameLength) // still enough dst buffer

		{

		result.iStatus = TCodecProcessResult::EDstNotFilled;

		}

	// cach remaining src

	if (CachedSampleSize() + srcLen - srcPos >= iPcmFrameSize) // still enough src

		{

		if (result.iStatus == TCodecProcessResult::EDstNotFilled)

			{

			User::Leave(KErrCorrupt);

			}

		else

			{

			result.iStatus = TCodecProcessResult::EProcessIncomplete;

			}

		}

	else if (srcLen - srcPos > 1) // remaining src less than one frame, cach it

		{

		srcPos += CachePcmSamplesL(*src, srcPos);

		}

	// set new position for dst