// 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 __BTSBCENCODER_H__
#define __BTSBCENCODER_H__

#include <e32std.h>
#include <mmf/server/mmfcodec.h>

#include "BtSBCFrameParameters.h"

const TUint8 KSbcMaxBlocks = 16;
const TUint8 KSbcMaxChannels = 2;
const TUint8 KSbcMaxSubbands = 8;

/**
This class is for manipulating (reading/writing) raw bit stream. 
It is used in sbc encoder for generating sbc frame bit stream.
@internalComponent
*/
class CBitStreamParser : public CBase
	{
public:
	static CBitStreamParser* NewLC(TDes8& aBitStream);
	void 	Reset();
	
	/** relative position */
	TUint8	ReadBits(TInt aBitsToRead);
	void	WriteBits(TInt aBitsToWrite, TUint8 aBitsValue);
	
	inline TUint8	ReadByte();
	inline void		WriteByte(TUint8 aByteValue);
	
	/** absolute position */
	inline void		SetPosition(TUint aByteOffset, TUint8 aBitOffset);
	inline void		Position(TUint& aByteOffset, TUint8& aBitOffset) const;

private:
	CBitStreamParser(TDes8& aBitStream);
	~CBitStreamParser();
	
	void	ConstructL();

private:
	TDes8&  iBitStream;
	TUint8*	iPtr;
	TUint	iByteOffset;
	TUint8	iBitOffset;
	};
	
/**
This class is for checking and generating SBC CRC code. 
It is used in sbc encoder for generating SBC CRC check number.
@internalComponent
*/
class CSbcCRCCalculator : public CBase
	{
public:
	CSbcCRCCalculator();
	
	void 	Reset();
	void 	InputBit(TUint8 aBit);
	void	InputBits(TUint8 aBits, TUint8 aValue);
	void 	InputByte(TUint8 aByte);
	
	TUint8 	ShiftRegister();
	
private:
	TUint8 	iShiftRegister;
	};

/**
This class is for encoding one SBC frame
@internalComponent
*/
class CSBCFrameEncoder : public CBase
	{
public:
	static CSBCFrameEncoder* NewL();
	~CSBCFrameEncoder();
	void EncodeFrameL(const TDesC8& aSrc, TDes8& aFrame);
	void Configure(const TSBCFrameParameters& aParameters);
	void Reset();
	
private:
	CSBCFrameEncoder();
	void 	ConstructL();
	
	/** encode frame */
	void 	Analyse(const TDesC8& aSrc);
	void 	CalcScaleFactors();
	void	JoinSubbands();
	void 	CalcBitAllocation();
	void 	Quantize();
	
	void 	AnalyseMono(const TInt16 aInputSamples[]);
	void 	AnalyseOneChannel(const TInt16 aInputSamples[], TUint8 aChannel);
	void 	Analyse4Subbands(const TInt16 aInputSamples[], TUint8 aBlock, TUint8 aChannel);
	void 	Analyse8Subbands(const TInt16 aInputSamples[], TUint8 aBlock, TUint8 aChannel);

	void	DoJoinSubbands();
	
	void 	CalcBitAllocIndependent();
	void 	CalcBitneedIndependent(TInt8 aBitneed[], const TUint8 aScaleFactors[]);
	TInt8 	MaxBitneedIndependent(const TInt8 aBitneed[]);
	TInt8 	CalcBitSlicesIndependent(const TInt8 aBitneed[], TInt& aBitCount);
	void 	DistributeBitsIndependent(const TInt8 aBitneed[], TUint8 aBits[]);

	void 	CalcBitAllocCombined();
	void 	CalcBitneedCombined(TInt8 aBitneed[][KSbcMaxSubbands]);
	TInt8 	MaxBitneedCombined(const TInt8 aBitneed[][KSbcMaxSubbands]);
	TInt8 	CalcBitSlicesCombined(const TInt8 aBitneed[][KSbcMaxSubbands], TInt& aBitCount);
	void 	DistributeBitsCombined(const TInt8 aBitneed[][KSbcMaxSubbands]);
	
	TUint8 	CalcCRC();
	
	/** writing result back */
	void	WriteFrameL(TDes8& aFrame);
	void 	WriteHeader(CBitStreamParser& aParser);
	void 	WriteScaleFactors(CBitStreamParser& aParser);
	void 	WriteData(CBitStreamParser& aParser);
	void 	WritePaddingL(CBitStreamParser& aParser);
	
private:
	/** input parameters, set before encode */
	TSBCFrameParameters	iParameters;
	
	TInt16 iAnalysisSamples[2][KSbcMaxSubbands * 10];
	TUint8 iScaleFactors[2][KSbcMaxSubbands];
	TUint8 iBits[2][KSbcMaxSubbands];
	TInt32 iOutputSamples[KSbcMaxBlocks][2][KSbcMaxSubbands];
	TUint8 iJoin[KSbcMaxSubbands];
	};
	
/**
This class is for encoding one SBC frame
@internalComponent
*/
class CSBCEncoder : public CMMFCodec
	{
public:
	static CMMFCodec* NewL(TAny* aInitParams);
	virtual ~CSBCEncoder();
	void ConfigureL(TUid aConfigType, const TDesC8& aConfigData);
	TCodecProcessResult ProcessL(const CMMFBuffer& aSrc, CMMFBuffer& aDst);

private:
	CSBCEncoder();
	void 	ConstructL(TAny* aInitParams);
	void 	ResetL();
	
	TUint 	EncodeFrameL(const TDesC8& aSrc, TDes8& aDst);
	TUint 	CachePcmSamplesL(const CMMFDataBuffer& aSrc, TUint aSrcPos);
	TUint 	CachedSampleSize();
	
private:
	/** input parameters, set before encode */
	TSBCFrameParameters	iParameters;
	TUint iPcmFrameSize;
	
	/** CSBCFrameEncoder encodes each frame */
	CSBCFrameEncoder*	iSbcFrameEncoder;
	TUint iSbcFrameLength;
	
	/** pcm audio sample cach */
	HBufC8* iPcmSampleCach;
	};
	
#endif // __BTSBCENCODER_H__

