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

// This file contains an implementation of the ToneGenerator interface

// that converts all tone generation requests in to sampled audio 

// data to be played through the normal local sampled audio interface

// 

//

#include "ToneGenerator.h"

#include <e32math.h>

#include <mda/common/resource.h>

/******************************************************************************

*	Tone Generators

*

*	The following classes are used to generate simple frequency/duration tones,

*	DTMF, and SymbianOS tone sequences in a WINS environment.  The below code

*	should only be considered for WINS.

******************************************************************************/

// this defines the maximum possible amplitude allowed for TSineGen::SetFrequency()

const TInt KMaxAmplitude = 0x8000;

// default number of samples for trailing silence following a Tone

const TInt KDefaultTrailingSilenceSamples = 20;

//

// Sine tone generator

//

const TInt16 TSineGen::SineTable[KMaxSineTable] =

	{

		 0,   804,  1607,  2410,  3211,  4011,  4807,  5601,

	  6392,  7179,  7961,  8739,  9511, 10278, 11038, 11792,

	 12539, 13278, 14009, 14732, 15446, 16150, 16845, 17530,

	 18204, 18867, 19519, 20159, 20787, 21402, 22004, 22594,

	 23169, 23731, 24278, 24811, 25329, 25831, 26318, 26789,

	 27244, 27683, 28105, 28510, 28897, 29268, 29621, 29955,

	 30272, 30571, 30851, 31113, 31356, 31580, 31785, 31970,

	 32137, 32284, 32412, 32520, 32609, 32678, 32727, 32757,

	 32767, 32757, 32727, 32678, 32609, 32520, 32412, 32284,

	 32137, 31970, 31785, 31580, 31356, 31113, 30851, 30571,

	 30272, 29955, 29621, 29268, 28897, 28510, 28105, 27683,

	 27244, 26789, 26318, 25831, 25329, 24811, 24278, 23731,

	 23169, 22594, 22004, 21402, 20787, 20159, 19519, 18867,

	 18204, 17530, 16845, 16150, 15446, 14732, 14009, 13278,

	 12539, 11792, 11038, 10278,  9511,  8739,  7961,  7179,

	  6392,  5601,  4807,  4011,  3211,  2410,  1607,   804,

		 0,  -804, -1607, -2410, -3211, -4011, -4807, -5601,

	 -6392, -7179, -7961, -8739, -9511,-10278,-11038,-11792,

	-12539,-13278,-14009,-14732,-15446,-16150,-16845,-17530,

	-18204,-18867,-19519,-20159,-20787,-21402,-22004,-22594,

	-23169,-23731,-24278,-24811,-25329,-25831,-26318,-26789,

	-27244,-27683,-28105,-28510,-28897,-29268,-29621,-29955,

	-30272,-30571,-30851,-31113,-31356,-31580,-31785,-31970,

	-32137,-32284,-32412,-32520,-32609,-32678,-32727,-32757,

	-32767,-32757,-32727,-32678,-32609,-32520,-32412,-32284,

	-32137,-31970,-31785,-31580,-31356,-31113,-30851,-30571,

	-30272,-29955,-29621,-29268,-28897,-28510,-28105,-27683,

	-27244,-26789,-26318,-25831,-25329,-24811,-24278,-23731,

	-23169,-22594,-22004,-21402,-20787,-20159,-19519,-18867,

	-18204,-17530,-16845,-16150,-15446,-14732,-14009,-13278,

	-12539,-11792,-11038,-10278, -9511, -8739, -7961, -7179,

	 -6392, -5601, -4807, -4011, -3211, -2410, -1607,  -804,

	};

const TInt16 TSineGen::IncTable[KMaxSineTable] =

	{

			804,  803,  803,  801,  800,  796,  794,

	  791,  787,  782,  778,  772,  767,  760,  754,

	  747,  739,  731,  723,  714,  704,  695,  685,

	  674,  663,  652,  640,  628,  615,  602,  590,

	  575,  562,  547,  533,  518,  502,  487,  471,

	  455,  439,  422,  405,  387,  371,  353,  334,

	  317,  299,  280,  262,  243,  224,  205,  185,

	  167,  147,  128,  108,   89,   69,   49,   30,

	   10,  -10,  -30,  -49,  -69,  -89, -108, -128,

	 -147, -167, -185, -205, -224, -243, -262, -280,

	 -299, -317, -334, -353, -371, -387, -405, -422,

	 -439, -455, -471, -487, -502, -518, -533, -547,

	 -562, -575, -590, -602, -615, -628, -640, -652,

	 -663, -674, -685, -695, -704, -714, -723, -731,

	 -739, -747, -754, -760, -767, -772, -778, -782,

	 -787, -791, -794, -796, -800, -801, -803, -803,

	 -804, -804, -803, -803, -801, -800, -796, -794,

	 -791, -787, -782, -778, -772, -767, -760, -754,

	 -747, -739, -731, -723, -714, -704, -695, -685,

	 -674, -663, -652, -640, -628, -615, -602, -590,

	 -575, -562, -547, -533, -518, -502, -487, -471,

	 -455, -439, -422, -405, -387, -371, -353, -334,

	 -317, -299, -280, -262, -243, -224, -205, -185,

	 -167, -147, -128, -108,  -89,  -69,  -49,  -30,

	  -10,   10,   30,   49,   69,   89,  108,  128,

	  147,  167,  185,  205,  224,  243,  262,  280,

	  299,  317,  334,  353,  371,  387,  405,  422,

	  439,  455,  471,  487,  502,  518,  533,  547,

	  562,  575,  590,  602,  615,  628,  640,  652,

	  663,  674,  685,  695,  704,  714,  723,  731,

	  739,  747,  754,  760,  767,  772,  778,  782,

	  787,  791,  794,  796,  800,  801,  803,  803,

	  804

	};

void TSineGen::SetFrequency(TInt aFrequency,TInt aAmplitude)

//

// Given the frequency set iStep.

// Reset iPosition to the equivalent of 0 degrees.

// In the special case of aFrequency==4KHz set iPosition to 90 degrees.

//

	{

	if (aAmplitude>(1<<15))

		iAmplitude=(1<<15);

	else if (aAmplitude<-(1<<15))

		iAmplitude=-(1<<15);

	else

		iAmplitude=aAmplitude;

//

// There are 256 entries in the sine table to traverse 360 degrees.

// The codec requires samples at a rate of 8000 per second.

// Thus for a 1Hz tone the step will be 256/8000 or 4/125.

// Now we need need the integer part of the result to end up in

// the MSB so we need to multiply by 2^24. This gives the formula

// step = (f*4*2^24)/125 or (f*2^26)/125.

// Our highest frequency is 4KHz so that the term (f*2^26) exceeds

// a 32 bit result by 4000/2^6 (2^6 is the number of significant bits

// left after a multiply by 2^26). i.e. 6 bits. We overcome this by

// having 6 bits less in the fraction, so the new formula becomes

// ((f*2^20)/125)*2^6. This still gives us 20 significant bits in the

// fraction.

//

	iStep=(((TUint)aFrequency<<20)/125)<<6;

	iPosition=(aFrequency==4000 ? 0x40000000 : 0);

	}

TInt TSineGen::NextSample()

//

// Generate the next sample using linear interpolation

//

	{

	TUint pos=iPosition>>24;

	TInt amp=((IncTable[pos]*((iPosition&0x00ffffff)>>20)));

	amp>>=4;

	amp+=SineTable[pos];

	amp=(amp*iAmplitude)>>15;

	iPosition+=iStep;

	return(amp);

	}

void TSineWave::Generate(TInt16* aDest,TInt aCount)

//

// Called when more samples need to be generated.

//

	{

	while (aCount--)

		{

		*aDest++=STATIC_CAST(TInt16,iGen1.NextSample()+iGen2.NextSample());

		}

	}

void TSineWave::SetFrequency(TInt aFrequency,TInt aAmplitude)

//

// Set to generate a single frequency

//

	{

	SetFrequency(aFrequency,aAmplitude,0,0);

	}

void TSineWave::SetFrequency(TInt aFrequency1,TInt aAmplitude1,TInt aFrequency2,TInt aAmplitude2)

//

// Set to generate two frequencies

//

	{

	iGen1.SetFrequency(aFrequency1,aAmplitude1);

	iGen2.SetFrequency(aFrequency2,aAmplitude2);

	}

//

// TMdaToneGenerator

//

void TMdaToneGenerator::Configure(TInt aRate, TInt aChannels, TInt aRepeats, TInt aSilence, TInt aRampUp)

//

// Set up this tone generator to generate data at the desired sample rate

// and number of channels (typically mono/stereo)

// 

	{

	iRate = aRate;

	iChannels = aChannels;

	iSamplesLeft = 0;

	iIncompleteVolume = 0;

	iRampUpRemainder = 0;

	iRampUp = ETrue; // Default ramping to on as it is normally useful

	iRampDown = ETrue;

	iIncompleteRampDown = EFalse;

	iIncompleteRampUp = EFalse;

	iRepeats = aRepeats;

	iSilenceBetweenRepeats = aSilence;

	iRampUpCount = aRampUp;

	iRampUpLeft = aRampUp;

	iAfterRepeatSilence = EFalse;

	}

LOCAL_C void RampVolume(TInt16* aData,TInt aCount,TInt aStartVol,TInt aEndVol)

//

// Simple function to ramp down the volume of some samples 

// Typically used to prevent "clicking" artifacts at the beginning/end of tones

//

	{

	TInt step = (aEndVol - aStartVol)/aCount;

	while (aCount--)

		{

		TInt data = TInt(*aData) * aStartVol;

		*aData++ = TInt16(data>>15);

		aStartVol += step;

		}

	}

TInt TMdaToneGenerator::FillBuffer(TDes8& aBuffer)

//

// Fill the supplied buffer with tone data

// Sets the buffer length to zero if there is no more data to play

// The buffer must have a max length of at least one sample * channels

// e.g. 2 bytes mono, 4 bytes stereo

//

	{

	const TInt KRampUpSamples = 50;

	const TInt KRampDownSamples = 50;	

	ASSERT(aBuffer.MaxLength()>= (iChannels<<1));

	aBuffer.SetMax();

	TBool silence;

	TInt samples = 0; // 

	TInt used = 0; // Data used

	TInt avail = aBuffer.Length(); // Data filled

	TInt count = 0; // Data to be converted

	TBool rampUp = EFalse;

	TMdaPtr8 fill;

	fill.Set(aBuffer); // Pointer to data left to be filled

	// 

	// The rest of this function will loop around continually until the buffer

	// is filled or there is no more data to play

	//

Restart:

	silence = EFalse; // Reset

	if (iSamplesLeft == 0)

		{

		if (iTrailingSilence == 0)

			{

			TInt error = GetNextTone();

			if (error)

				return error;

			rampUp = ETrue;

			if ((iSamplesLeft==0)&&(iTrailingSilence==0))

				{ 

				if ((iSilenceBetweenRepeats)&&(!iAfterRepeatSilence))

					{

					iTrailingSilence = iSilenceBetweenRepeats;

					iAfterRepeatSilence = ETrue;

					goto Restart;

					}

				else

					{

					if ((iRepeats>0)||(iRepeats==KMdaRepeatForever))

						{

						iAfterRepeatSilence = EFalse;

						if (iRepeats>0)

							iRepeats--;

						Reset();

						goto Restart;

						}

					}

				// No more to play

				goto Finished;

				}

			goto Restart;

			}

		else

			{

			silence = ETrue;

			samples = iTrailingSilence;

			}

		}

	else

		samples = iSamplesLeft;

	count = Min(samples,avail>>1);

	fill.SetLength(count<<1);

	if (!silence)

		{ // Generate wave

		iSineWave.Generate(REINTERPRET_CAST(TInt16*,&fill[0]),count);

		if (iRampUp)

			{ 

			// Ramp up volume at beginning of tone

			if (rampUp)

				{ // Fade in first few samples

				if(count < KRampUpSamples)

					{

					// Partial rampup due to being at the end of the buffer

					TInt fadeInLength = Min(KRampUpSamples,(fill.Length()>>1));

					iIncompleteVolume = (count*((1<<15)/KRampUpSamples));

					RampVolume(CONST_CAST(TInt16*,REINTERPRET_CAST(const TInt16*,(&fill[0]))),fadeInLength,0,iIncompleteVolume);

					iRampUpRemainder = fadeInLength;

					iIncompleteRampUp = ETrue;

					}

				else

					{

					// Normal rampup

					TInt fadeInLength = Min(Min(KRampUpSamples,iSamplesLeft),(fill.Length()>>1));

					RampVolume(CONST_CAST(TInt16*,REINTERPRET_CAST(const TInt16*,(&fill[0]))),fadeInLength,0,1<<15);	

					iIncompleteRampUp = EFalse;

					}				

				}

			else if (iIncompleteRampUp)	

				{

				// Completing partial rampup at the start of a new buffer

				TInt fadeInLength = Min(Min((KRampUpSamples-iRampUpRemainder),iSamplesLeft),(fill.Length()>>1));

				RampVolume(CONST_CAST(TInt16*,REINTERPRET_CAST(const TInt16*,(&fill[0]))),fadeInLength,iIncompleteVolume,1<<15);

				iIncompleteRampUp = EFalse;

				}								

			}

		if (iRampDown)

			{ // Ramp down volume at end of tone

			if ((iSamplesLeft-count) < KRampDownSamples)

				{ 

				if(iSamplesLeft-count == 0)

					{

					// Fade out last few samples

					TInt startVolume = 1<<15;;

					TInt fadeOutLength = Min(Min(KRampDownSamples,iSamplesLeft),(fill.Length()>>1));

					if(iIncompleteRampDown)

						{

						// Completing partial rampdown at the start of a new buffer

						startVolume -= iIncompleteVolume;

						iIncompleteRampDown = EFalse;

						}

					RampVolume(CONST_CAST(TInt16*,REINTERPRET_CAST(const TInt16*,(&(fill.Right(fadeOutLength<<1))[0]))),fadeOutLength,startVolume,0);

					}					

				else if(iSamplesLeft-count > 0)

					{

					// Partial rampdown due to being at the end of the buffer

					TInt rampDifference = (KRampDownSamples-(iSamplesLeft-count));

					TInt fadeOutLength = Min(Min(rampDifference,iSamplesLeft),(fill.Length()>>1));

					iIncompleteVolume = ((rampDifference*(1<<15))/KRampDownSamples);

					RampVolume(CONST_CAST(TInt16*,REINTERPRET_CAST(const TInt16*,(&(fill.Right(fadeOutLength<<1))[0]))),fadeOutLength,1<<15,(1<<15)-iIncompleteVolume);

					iIncompleteRampDown = ETrue;

					}  					

				}

			}					

		iSamplesLeft -= count;

		}

	else

		{ // Generate silence

		fill.FillZ(count<<1);

		iTrailingSilence -= count;

		}

	used += count<<1;

	avail -= count<<1;

	fill.Shift(count<<1);	

	if (avail>(iChannels<<1))

		goto Restart;

Finished:

	aBuffer.SetLength(used);

	// Do any ramp up that is required

	if (iRampUpLeft>0)

		{

		TInt words = iRampUpLeft * iChannels;

		words = Min(words,used>>1);

		if (words>0) // In case buffer has zero length...

			{

			TInt left = iRampUpLeft * iChannels;

			TInt rampup = iRampUpCount * iChannels;

			iRampUpLeft -= words/iChannels;

			TInt16* sample = REINTERPRET_CAST(TInt16*,&aBuffer[0]);

			while (words--)

				{

				*sample++ = STATIC_CAST(TInt16,(TInt32(*sample)*(rampup-(left--)))/rampup);

				}

			}

		}

	return KErrNone;

	}

TInt TMdaToneGenerator::DurationToSamples(const TTimeIntervalMicroSeconds& aDuration)

//

// Convert the given duration to a sample count using the current settings

//

	{

	const TInt64 KTInt64OneMilion = 1000000;

	// Calculate duration as samples

	TInt64 microSeconds(aDuration.Int64());  // MSVC doesn't like "aDuration.Int64()" in line below

	TInt64 dur = ((TInt64(iRate) * TInt64(iChannels) * microSeconds) / KTInt64OneMilion);

	if (I64HIGH(dur)>0)

		return KMaxTInt; // Ridiculous!

	else

		return I64LOW(dur);

	}

//

// TMdaSimpleToneGenerator

//

void TMdaSimpleToneGenerator::Reset()

	{

	iPlayed = EFalse;

	}

void TMdaSimpleToneGenerator::SetFrequencyAndDuration(TInt aFrequency, const TTimeIntervalMicroSeconds& aDuration)

//

// Store the frequency and duration of the specified sine tone

//

	{

	iFrequency = aFrequency;

	iDuration = aDuration;

	iPlayed = EFalse;

	}

TInt TMdaSimpleToneGenerator::GetNextTone()

//

// Simple implementation - just sets the supplied frequency and duration

//

	{

	// This class only plays one tone for the specified duration

	if (!iPlayed)

		{

		iSamplesLeft = I64LOW((iDuration.Int64() * TInt64(iRate))/1000000);

		iSineWave.SetFrequency(iFrequency,1<<14);

		iPlayed = ETrue;

		iTrailingSilence = 20; // Just to stop clicking

		}

	return KErrNone;

	}

//

// TMdaDualToneGenerator

//

void TMdaDualToneGenerator::Reset()

	{

	iPlayed = EFalse;

	}

void TMdaDualToneGenerator::SetFrequencyAndDuration(TInt aFrequencyOne, TInt aFrequencyTwo, const TTimeIntervalMicroSeconds& aDuration)

	{

	// Store the frequencies and duration of the specified dual tone

	iFrequencyOne = aFrequencyOne;

	iFrequencyTwo = aFrequencyTwo;

	iDuration = aDuration;

	iPlayed = EFalse;

	}

// 

// This is called by TMdaToneGenerator::FillBuffer() 

// to calculate the number of samples (iSamplesLeft) that will be needed 

// for the tone to be played and to initialize the sine wave generator.

// If the tone has already been played, then leaves iSamplesLeft 

// unmodified (should be zero) to indicate that it has finished.

//

TInt TMdaDualToneGenerator::GetNextTone()

	{

	// This class only plays one tone for the specified duration

	if (!iPlayed)

		{

		iSamplesLeft = I64LOW((iDuration.Int64() * TInt64(iRate))/KOneMillionMicroSeconds);

		iSineWave.SetFrequency(iFrequencyOne, KMaxAmplitude/2, iFrequencyTwo, KMaxAmplitude/2);

		iPlayed = ETrue;

		iTrailingSilence = KDefaultTrailingSilenceSamples; // Just to stop clicking

		}

	return KErrNone;

	}

//

// TMdaDTMFGenerator

//

const TInt KRecalculateToneLengths = KMinTInt;

void TMdaDTMFGenerator::Reset()

	{

	iChar = 0;

	}

void TMdaDTMFGenerator::SetToneDurations(const TTimeIntervalMicroSeconds32 aOn,

							const TTimeIntervalMicroSeconds32 aOff,

							const TTimeIntervalMicroSeconds32 aPause)

//

// Setup the DTMF tone durations

// aOn can be == -1 indicating should play first tone indefinately

//

	{

	ASSERT(aOn.Int() >=-1);

	ASSERT(aOff.Int()>=0);

	ASSERT(aPause.Int()>=0);

	iOn = aOn;

	iOff = aOff;

	iPause = aPause;