// Copyright (c) 2002-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\utils\rateconvert.cpp
// Note this code used to be in mmfutilities.cpp but split off here to allow
// scaling of descriptors instead of just CMMFBuffers.
// 
//

#include "rateconvertimpl.h" // includes rateconvert.h itself
#include <e32const.h>

const TInt KMaxInt16Bit = 65536 ; 

/*
The rate conversion algorithms used here are extremely basic, using nearest neighbour, not
even interpolation. An increment is created - initially a real, but converted to 16.16 fixed
point notation for efficiency purposes. For example, from 8000 to 11025 this increment is set
at 8000/11025 (~ 0.73). Each increment to the destination buffer conceptually increments the
src pointer by this value (0.73). On each iteration the nearest src sample is used.

The idea is that successive buffers run on from each other. The index is adjusted so at the end
of the run it is correct for the next buffer, and this is saved from one iteration to the next.
If the client wants to convert separate buffers, it should call Reset(), where the index is reset
to 0. 

Note the algorithm is even then not ideal, as it effectively truncates and not rounds the 
fixed-point index. However, a feature of this is that the nearest src sample is always behind the
conceptual fixed-point index. This makes it easy to ensure that processing of the next buffer
never needs data from the previous cycle - except this index value.

*/

enum TPanicCodes
	{
	EPanicNoDestinationBuffer=1,
	EPanicNoSourceConsumed
	};

#ifdef _DEBUG

static void Panic(TInt aPanicCode)
	{
	_LIT(KRateConvert,"RateConvert");
	User::Panic(KRateConvert, aPanicCode);
	}
	
#endif // _DEBUG

//
// CChannelAndSampleRateConverter 
//

CChannelAndSampleRateConverter::CChannelAndSampleRateConverter()
	{
	// constructor does nothing but ensures can't derive from outside dll
	}

// Factory function
CChannelAndSampleRateConverter* CChannelAndSampleRateConverter::CreateL(TInt aFromRate,
																				 TInt aFromChannels,
										 										 TInt aToRate,
										 										 TInt aToChannels)
	{
	// check that the params in range so we can assume OK later on
	if (aFromChannels <= 0 || aFromChannels > 2 ||
		aToChannels <= 0 || aToChannels > 2 ||
		aFromRate <= 0 || aToRate <= 0)
		{
		User::Leave(KErrArgument);
		}
		
	CChannelAndSampleRateConverterCommon* converter = NULL;

	if (aFromChannels==aToChannels)
		{
		if (aFromChannels==1)
			{
			converter = new (ELeave) CMonoToMonoRateConverter;			
			}
		else
			{
			converter = new (ELeave) CStereoToStereoRateConverter;
			}
		}
	else
		{
		if (aFromChannels==1)
			{
			if (aFromRate!=aToRate)
				{
				converter = new (ELeave) CMonoToStereoRateConverter;				
				}
			else
				{
				converter = new (ELeave) CMonoToStereoConverter;				
				}
			}
		else
			{
            ASSERT(aFromChannels>1 && aToChannels==1);
			if (aFromRate!=aToRate)
				{
				converter = new (ELeave) CStereoToMonoRateConverter;				
				}
			else
				{
 				converter = new (ELeave) CStereoToMonoConverter;				
				}
			}
		}
	converter->SetRates(aFromRate,aToRate);
	return converter;
	}
	
//
// CChannelAndSampleRateConverterImpl
//

CChannelAndSampleRateConverterCommon::CChannelAndSampleRateConverterCommon()
	{
	}

void CChannelAndSampleRateConverterCommon::Reset()
	{
	// default does nothing
	}
	
void CChannelAndSampleRateConverterCommon::SetRates(TInt /*aFromRate*/, TInt /*aToRate*/)
	{
	// in default no need to know so don't cache
	}

TInt CChannelAndSampleRateConverterCommon::MaxConvertBufferSize(TInt aSrcBufferSize, TBool aRoundUpToPower)
	{
	// assume aSrcBuffer takes channel change into account
	TInt rawValue = aSrcBufferSize;
	if (aRoundUpToPower)
		{
		return NextPowerUp(rawValue); 
		}
	else
		{
		return rawValue;
		}
	}
	
TInt CChannelAndSampleRateConverterCommon::NextPowerUp(TInt aValue)
	{
	TInt power = 128; // no need to start lower
	while (power<aValue)
		{
		power *= 2;
		}
	return power;
	}
	
//
// CChannelAndSampleRateConvert
//

CChannelAndSampleRateConvert::CChannelAndSampleRateConvert()
	{
	}

	
TInt CChannelAndSampleRateConvert::MaxConvertBufferSize(TInt aSrcBufferSize, TBool aRoundUpToPower)
	{
	// take rate conversion into account. Assumed channel mismatch handled by the child class.
	TInt rawValue = aSrcBufferSize;
	if (iFromRate < iToRate)
		{
		TInt result = SizeOfUpsampleBuffer(rawValue);
		return result; // always rounded up to next size
		}
	else
		{
		if (aRoundUpToPower)
			{
			return NextPowerUp(rawValue); 
			}
		else
			{
			return rawValue;
			}
		}
	}
	
void CChannelAndSampleRateConvert::SetRates(TInt aFromRate, TInt aToRate)
	{
	iFromRate=aFromRate;
	iToRate=aToRate;

	TReal ratio = TReal(aFromRate) / TReal(aToRate);
	TInt quotient = TInt(ratio);
	TReal remainder = ratio - TReal(quotient);
	iFraction = (quotient << 16) + TInt32(remainder * KMaxInt16Bit);

	Reset();
	}
	
void CChannelAndSampleRateConvert::Reset()
	{
	iIndex = 0;
	}
	
TInt CChannelAndSampleRateConvert::SizeOfUpsampleBuffer(TInt aBufferLength)
	{
	TInt rawValue = aBufferLength;
	ASSERT(iFromRate < iToRate); // should not be called otherwise
	// upsample - will generate more data. use floats to avoid extra round error
	rawValue = TInt(rawValue * TReal(iToRate) / TReal(iFromRate) + 0.5) + 4*sizeof(TInt16); // add some fudge factor just in case
	rawValue = NextPowerUp(rawValue); // when upscaling always give nice power
	return rawValue;	
	}

//
// Specific converter code
//

CStereoToStereoRateConverter::CStereoToStereoRateConverter()
	{
	}

TInt CStereoToStereoRateConverter::Convert(const TDesC8& aSrcBuffer, TDes8& aDstBuffer)
	{
	const TInt32* srcPtr = reinterpret_cast<const TInt32*>(aSrcBuffer.Ptr());
	TInt32* dstPtr = const_cast<TInt32*>(reinterpret_cast<const TInt32*>(aDstBuffer.Ptr()));
	
	const TInt32* srcLimit=srcPtr+LengthBytesTo32Bit(aSrcBuffer.Length()); // ptr+n does *4 for TInt32* ptr
	TInt32* dstLimit=dstPtr+LengthBytesTo32Bit(aDstBuffer.MaxLength()); // ditto

	// add left over from last buffer
	TUint index = iIndex;
	const TInt32* src = srcPtr + (index>>16);
	TInt32* dst = dstPtr;

	if (dst>=dstLimit)
		{
		__ASSERT_DEBUG(EFalse,Panic(EPanicNoDestinationBuffer));
		return 0;
		}

	while (src<srcLimit && dst<dstLimit)
		{
  		*dst++ = *src;
		index += iFraction;
		src = srcPtr + (index>>16); // truncate fix-point index
		}

	// get amount by which index exceeded end of buffer
	// so that we can add it back to start of next buffer
	const TInt32* conceptualLastSrc = Min(src, srcLimit); // ptr to last src we have we'd _not_ used next iteration
	TInt srcSamplesCopied = conceptualLastSrc - srcPtr;
	__ASSERT_DEBUG(srcSamplesCopied>0, Panic(EPanicNoSourceConsumed)); // should always be ok if we have some destination space
	iIndex = index - (srcSamplesCopied << 16); 

	// return sample byte count and setup output buffer
	TInt dstLength = Length32BitToBytes(dst-dstPtr);
	aDstBuffer.SetLength(dstLength); //adjust length of destination buffer
	return Length32BitToBytes(srcSamplesCopied);
	}
	
CMonoToStereoRateConverter::CMonoToStereoRateConverter()
	{
	}

TInt CMonoToStereoRateConverter::Convert(const TDesC8& aSrcBuffer, TDes8& aDstBuffer)
	{
	const TInt16* srcPtr = reinterpret_cast<const TInt16*>(aSrcBuffer.Ptr());
	TInt32* dstPtr = const_cast<TInt32*>(reinterpret_cast<const TInt32*>(aDstBuffer.Ptr()));
	
	const TInt16* srcLimit=srcPtr+LengthBytesTo16Bit(aSrcBuffer.Length()); // as ptr+n does *2 for TInt16* ptr
	TInt32* dstLimit=dstPtr+LengthBytesTo32Bit(aDstBuffer.MaxLength()); // ditto but does *4 for TInt32*

	// add left over from last buffer
	TUint index = iIndex;
	const TInt16* src = srcPtr + (index>>16);
	TInt32* dst = dstPtr;

	if (dst>=dstLimit)
		{
		__ASSERT_DEBUG(EFalse,Panic(EPanicNoDestinationBuffer));
		return 0;
		}

	while (src<srcLimit && dst<dstLimit-1)
		{
		TInt16 sample = *src;
		TInt32 stereoSample = MonoToStereo(sample);
		*dst++ = stereoSample;
		index += iFraction;
		src = srcPtr + (index>>16); // truncate fix-point index
		}

	// get amount by which index exceeded end of buffer
	// so that we can add it back to start of next buffer
	const TInt16* conceptualLastSrc = Min(src, srcLimit); // ptr to last src we have we'd _not_ used next iteration
	TInt srcSamplesCopied = conceptualLastSrc - srcPtr;
	__ASSERT_DEBUG(srcSamplesCopied>0, Panic(EPanicNoSourceConsumed)); // should always be ok if we have some destination space
	iIndex = index - (srcSamplesCopied << 16); 

	// return sample byte count and setup output buffer
	TInt dstLength = Length32BitToBytes(dst-dstPtr);			// size in bytes
	aDstBuffer.SetLength(dstLength); //adjust length of destination buffer
	return Length16BitToBytes(srcSamplesCopied);
	}	
	

TInt CMonoToStereoRateConverter::MaxConvertBufferSize(TInt aSrcBufferSize, TBool aRoundUpToPower)
	{
	return CChannelAndSampleRateConvert::MaxConvertBufferSize(aSrcBufferSize*2, aRoundUpToPower);
	}
	
CMonoToMonoRateConverter::CMonoToMonoRateConverter()
	{
	}

TInt CMonoToMonoRateConverter::Convert(const TDesC8& aSrcBuffer, TDes8& aDstBuffer)
	{
	const TInt16* srcPtr = reinterpret_cast<const TInt16*>(aSrcBuffer.Ptr());
	TInt16* dstPtr = const_cast<TInt16*>(reinterpret_cast<const TInt16*>(aDstBuffer.Ptr()));
	
	const TInt16* srcLimit=srcPtr+LengthBytesTo16Bit(aSrcBuffer.Length()); // ptr+n does *2 for TInt16* ptr
	TInt16* dstLimit=dstPtr+LengthBytesTo16Bit(aDstBuffer.MaxLength()); // ditto

	// add left over from last buffer
	TUint index = iIndex;
	const TInt16* src = srcPtr + (index>>16);
	TInt16* dst = dstPtr;

	if (dst>=dstLimit)
		{
		__ASSERT_DEBUG(EFalse,Panic(EPanicNoDestinationBuffer));
		return 0;
		}

	while (src<srcLimit && dst<dstLimit)
		{
  		*dst++ = *src;
		index += iFraction;
		src = srcPtr + (index>>16); // truncate fix-point index
		}

	// get amount by which index exceeded end of buffer
	// so that we can add it back to start of next buffer
	const TInt16* conceptualLastSrc = Min(src, srcLimit); // ptr to last src we have we'd _not_ used next iteration
	TInt srcSamplesCopied = conceptualLastSrc - srcPtr;
	__ASSERT_DEBUG(srcSamplesCopied>0, Panic(EPanicNoSourceConsumed)); // should always be ok if we have some destination space
	iIndex = index - (srcSamplesCopied << 16); 

	// return sample byte count and setup output buffer
	TInt dstLength = Length16BitToBytes(dst-dstPtr);		// size in bytes
	aDstBuffer.SetLength(dstLength); //adjust length of destination buffer
	return Length16BitToBytes(srcSamplesCopied);
	}	
	
CStereoToMonoRateConverter::CStereoToMonoRateConverter()
	{
	}

//This method takes the left and right sample of interleaved PCM and sums it, then divides by 2
TInt CStereoToMonoRateConverter::Convert(const TDesC8& aSrcBuffer, TDes8& aDstBuffer)
	{
	const TInt32* srcPtr = reinterpret_cast<const TInt32*>(aSrcBuffer.Ptr());
	TInt16* dstPtr = const_cast<TInt16*>(reinterpret_cast<const TInt16*>(aDstBuffer.Ptr()));
	
	const TInt32* srcLimit=srcPtr+LengthBytesTo32Bit(aSrcBuffer.Length()); // ptr+n does *4 for TInt32* ptr
	TInt16* dstLimit=dstPtr+LengthBytesTo16Bit(aDstBuffer.MaxLength()); // ditto but *2 for TInt16*

	// add left over from last buffer
	TUint index = iIndex;
	const TInt32* src = srcPtr + (index>>16);
	TInt16* dst = dstPtr;

	if (dst>=dstLimit)
		{
		__ASSERT_DEBUG(EFalse,Panic(EPanicNoDestinationBuffer));
		return 0;
		}

	while (src<srcLimit && dst<dstLimit)
		{
		TInt32 sample = *src;
		TInt16 monoSample = StereoToMono(sample);
  		*dst++ =  monoSample;
		index += iFraction;
		src = srcPtr + (index>>16); // truncate fix-point index
		}

	// get amount by which index exceeded end of buffer
	// so that we can add it back to start of next buffer
	const TInt32* conceptualLastSrc = Min(src, srcLimit); // ptr to last src we have we'd _not_ used next iteration
	TInt srcSamplesCopied = conceptualLastSrc - srcPtr;
	__ASSERT_DEBUG(srcSamplesCopied>0, Panic(EPanicNoSourceConsumed)); // should always be ok if we have some destination space
	iIndex = index - (srcSamplesCopied << 16); 

	// return sample byte count and setup output buffer
	TInt dstLength = Length16BitToBytes(dst-dstPtr);			// size in bytes
	aDstBuffer.SetLength(dstLength); //adjust length of destination buffer
	return Length32BitToBytes(srcSamplesCopied);
	}


TInt CStereoToMonoRateConverter::MaxConvertBufferSize(TInt aSrcBufferSize, TBool aRoundUpToPower)
	{
	TUint size = aSrcBufferSize/2;
	size += aSrcBufferSize & 1; //avoid round down error
	return CChannelAndSampleRateConvert::MaxConvertBufferSize(size, aRoundUpToPower);
	}
	
CStereoToMonoConverter::CStereoToMonoConverter()
	{
	}

//This method takes the left and right sample of interleaved PCM and sums it, then divides by 2
TInt CStereoToMonoConverter::Convert(const TDesC8& aSrcBuffer, TDes8& aDstBuffer)
	{
	const TInt32* src = reinterpret_cast<const TInt32*>(aSrcBuffer.Ptr());
	TInt16* dst = const_cast<TInt16*>(reinterpret_cast<const TInt16*>(aDstBuffer.Ptr()));

	TInt srcCount = LengthBytesTo32Bit(aSrcBuffer.Length());
	TInt dstCount = LengthBytesTo16Bit(aDstBuffer.MaxLength());
	TInt count = Min(srcCount, dstCount); // if aDstBuffer is short, just copy that much
	
	for (TUint i=0;i<count;++i)
		{
		TInt32 sample = *src++;
		TInt16 monoSample = StereoToMono(sample);
  		*dst++ = monoSample;
		}
		
	aDstBuffer.SetLength(Length16BitToBytes(count)); // *2 because is mono
	return Length32BitToBytes(count); // *4 as is stereo
	}	

TInt CStereoToMonoConverter::MaxConvertBufferSize(TInt aSrcBufferSize, TBool aRoundUpToPower)
	{
	TUint size = aSrcBufferSize/2;
	size += aSrcBufferSize & 1; //avoid round down error
	return CChannelAndSampleRateConverterCommon::MaxConvertBufferSize(size, aRoundUpToPower);
	}
	
CMonoToStereoConverter::CMonoToStereoConverter()
	{
	}

TInt CMonoToStereoConverter::Convert(const TDesC8& aSrcBuffer, TDes8& aDstBuffer)
	{
	const TInt16* src = reinterpret_cast<const TInt16*>(aSrcBuffer.Ptr());
	TInt32* dst = const_cast<TInt32*>(reinterpret_cast<const TInt32*>(aDstBuffer.Ptr()));

	TInt srcCount = LengthBytesTo16Bit(aSrcBuffer.Length());
	TInt dstCount = LengthBytesTo32Bit(aDstBuffer.MaxLength());
	TInt count = Min(srcCount, dstCount); // if aDstBuffer is short, just copy that much
	
	for (TUint i=0;i<count;i++)
		{
		TInt16 sample = *src++;
		TInt32 stereoSample = MonoToStereo(sample);
  		*dst++ =  stereoSample;
		}
		
	aDstBuffer.SetLength(Length32BitToBytes(count)); // *4 because is stereo
	return Length16BitToBytes(count); // *2 as is mono
	}	

TInt CMonoToStereoConverter::MaxConvertBufferSize(TInt aSrcBufferSize, TBool aRoundUpToPower)
	{
	return CChannelAndSampleRateConverterCommon::MaxConvertBufferSize(aSrcBufferSize*2, aRoundUpToPower);
	}