/*

* Copyright (c) 2006-2007 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:  ?Description

*

*/

#include <AudioPreference.h>

#include "irbuffercontainer.h"

#include "irctrlcmdobserver.h"

#include "irdebug.h"

#include "irmediaenginebuffer.h"

#include "irmp3player.h"

#include "irmp3playerlocal.h"

#ifdef __WINS__

#include "irtestingaudioplayer.h"

#endif //__WINS__

// Constants

const TInt KZero = 0;

const TInt KOne = 1;

const TInt KTwo = 2;

const TInt KThree = 3;

const TInt KTwentyFour = 24;

const TInt KSixteen = 16;

const TInt KEight = 8;

const TInt KSamplesPerFrame1 = 576;

const TInt KSamplesPerFrame2 = 1152;

const TInt KOneFourFour = 144;

const TInt KThousand = 1000;

// ============================ MEMBER FUNCTIONS ===============================

// ---------------------------------------------------------------------------

// Function : NewL

// function returns an instance of CIRMP3Player

// Two phase constructor

// ---------------------------------------------------------------------------

//

CIRMP3Player* CIRMP3Player::NewL()

	{

	IRLOG_DEBUG( "CIRMP3Player::NewL" );

	CIRMP3Player* self = CIRMP3Player::NewLC();

	CleanupStack::Pop(self);

	IRLOG_DEBUG( "CIRMP3Player::NewL - Exiting." );

	return self;

	}

// ---------------------------------------------------------------------------

// Function : NewLC

// function creates an instance of CIRMP3Player

// Two phase constructor

// ---------------------------------------------------------------------------

//

CIRMP3Player* CIRMP3Player::NewLC()

	{

	IRLOG_DEBUG( "CIRMP3Player::NewLC" );

	CIRMP3Player* self = new (ELeave) CIRMP3Player;

	CleanupStack::PushL(self);

	self->ConstructL();

	IRLOG_DEBUG( "CIRMP3Player::NewLC - Exiting." );

	return self;

	}

// ---------------------------------------------------------------------------

// Function : ~CIRMP3Player

// Default Destructor

// ---------------------------------------------------------------------------

//

CIRMP3Player::~CIRMP3Player()

	{

	IRLOG_DEBUG( "CIRMP3Player::~CIRMP3Player" );

	//delete the instance of the player

	delete iAudioPlayer;

#ifdef __WINS__

	if(iTestingAudioPlayer)

		{

		iTestingAudioPlayer->Close();

		delete iTestingAudioPlayer;

		iTestingAudioPlayer = NULL;

		}

	CActiveScheduler::Delete(iTestingAudioPlayer);

#endif //__WINS__

	while(!iSinkBufferQ.IsEmpty())

		{

		//Deleting all the entries in sink buffers queue

		iTempBufferHolder = iSinkBufferQ.First();

		iSinkBufferQ.Remove(*iTempBufferHolder);

		delete iTempBufferHolder;

		}

	while(!iSourceBufferQ.IsEmpty())

		{

		//deleting all the entries in source buffers queue

		iTempBufferHolder = iSourceBufferQ.First();

		iSourceBufferQ.Remove(*iTempBufferHolder);

		delete iTempBufferHolder;

		}

	IRLOG_DEBUG( "CIRMP3Player::~CIRMP3Player - Exiting." );	

	}

									//Function for Play control

// ---------------------------------------------------------------------------

// Function : Play

// function to which intiate the player

// ---------------------------------------------------------------------------

//

void CIRMP3Player::Play()

	{

	IRLOG_DEBUG( "CIRMP3Player::Play" );

	//! then we have to stop it then restart the play from begining

	if ( EPlaying == iState )

		{

		//internally stopped before playing so no need of sending

		//stop status		

		iSkipPlayCompleted = ETrue;

#ifdef __WINS__

		iTestingAudioPlayer->Stop();

#else 

		iAudioPlayer->Stop(); 

#endif //__WINS__

		iSkipPlayCompleted = EFalse;		

		}

	iState = ENotReady;

	iStopState = EFalse;

	iBufferPercentage = KZeroPercentage;

	//note : using TRAP_IGNORE to suppress a codescanner warning

	//"Ignoring the return value from Open() functions"

	//this cannot be checked as this symbian API returns void

#ifdef __WINS__

	TRAP_IGNORE ( iTestingAudioPlayer->Open() );

#else 

	//opening the current player component

	TRAP_IGNORE ( iAudioPlayer->Open(&iSettings) );

#endif //__WINS__

	iChannel->SentRequest(EPlayingState,KErrNone);	

	IRLOG_DEBUG( "CIRMP3Player::Play - Exiting." );	

	}

// ---------------------------------------------------------------------------

// Function : Stop

// function to which stop the player

// ---------------------------------------------------------------------------

//

void CIRMP3Player::Stop()

	{

	IRLOG_DEBUG( "CIRMP3Player::Stop" );	

	//If the current state is playing 	

	if ( EPlaying == iState )

		{

#ifdef __WINS__

		iTestingAudioPlayer->Stop();

#else

		iAudioPlayer->Stop();	

#endif //__WINS__

		}		

	else

		{

	IRRDEBUG2("CIRMP3Player::Stop EStoppedPlaying", KNullDesC); 

		//sending the updated status as stopped

		iChannel->SentRequest( EStoppedPlaying, KErrNone );	

		}		

	iState = EReadyToPlay;

	iStopState = ETrue;

	IRLOG_DEBUG( "CIRMP3Player::Stop - Exiting." );	

	}

										//Functions for Volume Control

// ---------------------------------------------------------------------------

// Function : SetVolume

// function to set the volume 

// ---------------------------------------------------------------------------

//	

void CIRMP3Player::SetVolume(TInt aVolume )

	{	

	IRLOG_DEBUG( "CIRMP3Player::SetVolume" );		

	//! If volume should be less than maximum value and greater than or equal to zero then set the volume

	if( KZeroVolume <= aVolume && iAudioPlayer->MaxVolume() >= aVolume )

		{

		iAudioPlayer->SetVolume( aVolume );	

		iConfig.iVolume = iCurrentVolume = aVolume;

		}		

	IRLOG_DEBUG( "CIRMP3Player::SetVolume - Exiting." );	

	}

// ---------------------------------------------------------------------------

// Function : MaxVolume

// function to returns the maximum volume 

// ---------------------------------------------------------------------------

//

TInt CIRMP3Player::MaxVolume() const

	{

	IRLOG_DEBUG( "CIRMP3Player::MaxVolume" );

	return iAudioPlayer->MaxVolume();	

	}

// ---------------------------------------------------------------------------

// Function : Volume

// function to returns the volume, integer level of volume is the Output

// ---------------------------------------------------------------------------

//

TInt CIRMP3Player::Volume() const

	{

	IRLOG_DEBUG( "CIRMP3Player::Volume" );

	return iAudioPlayer->Volume();

	}

									//Intialization of Codec Settings

// ---------------------------------------------------------------------------

// Function: Intialize

// Set the codec type and sampling rate channel of stream

// This is set to initial settings which is required to start the player

// ---------------------------------------------------------------------------

//

void CIRMP3Player::Intialize(TConfig& aConfig,TUint8* aInitParams,

	CIRCtrlCmdObserver* aChannel)

	{

	IRLOG_DEBUG( "CIRMP3Player::Intialize" );

	iInputBufferPtr = reinterpret_cast<TUint8*> (aInitParams); //instance of buffer

	iConfig = aConfig; //! Set all the configuration information like volume

	iPlayBufferSize = iConfig.iPlayBufferSize;

	iInputBufferSize = iConfig.iPlayBufferCount*iPlayBufferSize;

    iBufferOffset = iPlayBufferSize;

	iDataType.Set(KMMFFourCCCodeMP3); //! Set the data type as MP3

	iChannel = reinterpret_cast<CIRCtrlCmdObserver*> (aChannel);

	TRAPD(err,CreateBufferL()); // allocates buffer to the queue

	if( err )

		{

	IRRDEBUG2("CIRMP3Player::Intialize - EError", KNullDesC);

		iChannel->SentRequest( EError, KIRCtrlCmdGeneralPlayerError );

		return;	

		}

	iChannel->SentRequest(EPlayerChanged,KErrNone);									//creates an instance of the player

	IRLOG_DEBUG( "CIRMP3Player::Intialize - Exiting." );

	}

// ---------------------------------------------------------------------------

// Function: StopPlayerBuffering

// Function is used to stop buffering 

// ---------------------------------------------------------------------------

//

void CIRMP3Player::StopPlayerBuffering()

	{

	IRLOG_DEBUG( "CIRMP3Player::StopPlayerBuffering" );

	//stops the player from buffering

	iStopPlayerBuffering = ETrue;	

	}

// ---------------------------------------------------------------------------

// Function: BufferFilled

// Function which is called when network gets the buffer filled with data

// ---------------------------------------------------------------------------

//

void CIRMP3Player::BufferFilled()

	{

	IRLOG_DEBUG( "CIRMP3Player::BufferFilled" );

	if( !iNewPlayer )

		{

		if( !iSourceBufferQ.IsEmpty() )

			{

			//! Initially all unfilled buffers are in source buffer Queue

			//! Once the buffer in the source buffer queue is filled it is moved to queue of buffer

			//! to the sink

			iTempBufferHolder = iSourceBufferQ.First();

			iSourceBufferQ.Remove(*iTempBufferHolder);

			iSinkBufferQ.AddLast(*iTempBufferHolder);

			}

		}

	if( iFirstTime )

		{

		if( !iNewPlayer )

			{

			// During rebuffering only

			if( !iSourceBufferQ.IsEmpty() ) 

				{

				//if source buffer is empty

				//first buffer of source buffer is taken and refilled

				iTempBufferHolder = iSourceBufferQ.First();							

				iTempbuffer = iTempBufferHolder->Des();

				iInputBuffer.Set(iTempbuffer,iPlayBufferSize,iPlayBufferSize);

				if( iStopState )

					{

                    IRLOG_DEBUG( "CIRMP3Player::BufferFilled - Exiting (1)." );

					return;

					}

				if( !iStopPlayerBuffering )

					{								

					//Calls the fill the buffer for next subsequent times 

					//until the source buffer queue is empty

					iChannel->FilltheBuffer(iInputBuffer); 

					}

				else

					{

                    IRLOG_DEBUG( "CIRMP3Player::BufferFilled - Exiting (2)." );

					//if stopPlayerBuffering is set it has return without buffering

					return;	

					}

				}

			else

				{

				//once it is rebuffered it has trigger play

				//it has to indicate that rebuffering has completed for client

				TInt err( KErrNone ); 

				if( !iReBuffering )

					{

					GetMP3AudioProperties();

					//Sets the audio properties of the player like sampling rate and channel

					TRAP(err, iAudioPlayer->SetAudioPropertiesL(iSettings.iSampleRate,

																iSettings.iChannels));

					if ( err )

						{

					IRRDEBUG2("CIRMP3Player::BufferFilled - EError", KNullDesC);

						iChannel->SentRequest( EError, KIRCtrlCmdGeneralPlayerError );	

                        IRLOG_DEBUG( "CIRMP3Player::BufferFilled - Exiting (3)." );

						return;

						}

					}

				iReBuffering = EFalse;

				//buffer reached 100% headers are decoded ready to play			

				iBufferPercentage = K100Percentage;

				iChannel->SentRequest( EBufferFillStop, iBufferPercentage ); 

				if( !iSinkBufferQ.IsEmpty() )

					{

					iTempBufferHolder = iSinkBufferQ.First();	

					}					

				iTempbuffer = iTempBufferHolder->Des();

				//Take first source buffer queue to be filled

				iInput.Set(iTempbuffer,iPlayBufferSize,iPlayBufferSize);

				iFirstTime = EFalse;

				iState = EPlaying;

				if( !iStopState )

					{

#ifdef __WINS__

					iTestingAudioPlayer->Write();

#else

					//writing to mmp based buffer to trigger play

					TRAP(err,iAudioPlayer->WriteL(iInput));	

					if( err )

						{

						//error condition

			IRRDEBUG2("CIRMP3Player::BufferFilled - EError1", KNullDesC);

						iChannel->SentRequest( EError, KIRCtrlCmdGeneralPlayerError );	

                        IRLOG_DEBUG( "CIRMP3Player::BufferFilled - Exiting (4)." );

						return;

						}

#endif //__WINS__	

					}

				//! Calls the play for the first time after rebuffering

				}

			}

		else

			{

			//First time when the player is created

			TInt err( KErrNone );

			GetMP3AudioProperties();			

			//! Sets the audio properties of the player like sampling rate and channel

			//Sets the audio properties of the player like sampling rate and channel

			TRAP(err, iAudioPlayer->SetAudioPropertiesL(iSettings.iSampleRate,

														iSettings.iChannels));

			if ( err )

				{

		IRRDEBUG2("CIRMP3Player::BufferFilled - EError2", KNullDesC);

				iChannel->SentRequest( EError, KIRCtrlCmdGeneralPlayerError );	

	            IRLOG_DEBUG( "CIRMP3Player::BufferFilled - Exiting (5)." );

				return;

				}

			//buffer percentage is 100%							

			iBufferPercentage = K100Percentage;

			//indicating it has rebuffered

			iChannel->SentRequest( EBufferFadeInReady, iBufferPercentage ); 			

			if( !iSinkBufferQ.IsEmpty() )

				{

				iTempBufferHolder = iSinkBufferQ.First();

				}

			iTempbuffer = iTempBufferHolder->Des();

			//first buffer of sink is taken and played

			iInput.Set(iTempbuffer,iPlayBufferSize,iPlayBufferSize);

			iNewPlayer = EFalse;

			iFirstTime = EFalse;

			iState = EPlaying;

			//Calls the play for the first time

			if( !iStopState )

				{

#ifdef __WINS__

				iTestingAudioPlayer->Write();

#else

				//writing to MMF buffers

				TRAP(err,iAudioPlayer->WriteL(iInput));	

				if( err )

					{

			IRRDEBUG2("CIRMP3Player::BufferFilled - EError3", KNullDesC);

					iChannel->SentRequest( EError, KIRCtrlCmdGeneralPlayerError );	

					IRLOG_DEBUG( "CIRMP3Player::BufferFilled - Exiting (6)." );	

					return;

					}	

#endif //__WINS__

				}

			}	

		}		

	IRLOG_DEBUG( "CIRMP3Player::BufferFilled - Exiting (7)." );

	}

// ---------------------------------------------------------------------------

// Function: CIRMP3Player

// This function is the default constructor

// ---------------------------------------------------------------------------

//

CIRMP3Player::CIRMP3Player() : iInputBuffer(NULL,0,0), iInput(NULL,0,0)

	{

	IRLOG_DEBUG( "CIRMP3Player::CIRMP3Player" );

	}

// ---------------------------------------------------------------------------

// Function: ConstructL

// Two phase constructor is used to intialize data members

// Function can leave if CMdaAudioOutputStream::NewL leaves

// ---------------------------------------------------------------------------

//

void CIRMP3Player::ConstructL()

	{

	IRLOG_DEBUG( "CIRMP3Player::ConstructL" );

	iAudioPlayer = CMdaAudioOutputStream::NewL(*this,KAudioPriorityRealOnePlayer,

		(TMdaPriorityPreference)KAudioPrefRealOneStreaming );

										//creates an instance of the player

#ifdef __WINS__			

	iTestingAudioPlayer = CIRTestingAudioPlayer::NewL(*this);

	CActiveScheduler::Add(iTestingAudioPlayer);

#endif //__WINS__

	TInt f_off = _FOFF(CIRBufferContainer,iLink); //for the buffer queue which is maintained

    iSinkBufferQ.SetOffset(f_off);	 //It is Queue of buffer used by media Sink

    iSourceBufferQ.SetOffset(f_off); // Source of buffer which is ready to fill

	iNewPlayer = ETrue;	//indicates that this a newly created player

	iStopPlayerBuffering = EFalse;	//indicates whether to stop buffering

	iState = ENotReady;	//current state not ready	

	iNeedReBuffering = EFalse;//if rebuffering is required this is to set true

	iStopState = EFalse; //

	IRLOG_DEBUG( "CIRMP3Player::ConstructL - Exiting." );	

	}

// ---------------------------------------------------------------------------

// Function: CreateBufferL 

// Created buffers in sink buffer queue and allocates memory to sink buffer queues

// ---------------------------------------------------------------------------

//

void CIRMP3Player::CreateBufferL()

	{

	IRLOG_DEBUG( "CIRMP3Player::CreatebufferL" );	

	TUint8* bufferaddress = iInputBufferPtr;

	//! source buffers not created since initially all buffers are filled with data and is ready to play	

	//! Created buffers in sink buffer queue and allocates memory to sink buffer queues

	for(TInt buffercount = 0; buffercount < KIRInputBufferCount; buffercount++)

		{		

		iTempBufferHolder = CIRBufferContainer::NewL(bufferaddress,

			iPlayBufferSize);

		iSinkBufferQ.AddLast(*iTempBufferHolder);

		bufferaddress += iBufferOffset;

		}

	IRLOG_DEBUG( "CIRMP3Player::CreatebufferL - Exiting." );	

	}

// ---------------------------------------------------------------------------

// Function: ReCreateBufferL 

// Recreates buffers of source queue

// ---------------------------------------------------------------------------

//

void CIRMP3Player::ReCreateBufferL()

	{

	IRLOG_DEBUG( "CIRMP3Player::ReCreateBufferL " );

	while(!iSinkBufferQ.IsEmpty())

		{

		//Deleting all the entries in sink buffers queue

		iTempBufferHolder = iSinkBufferQ.First();

		iSinkBufferQ.Remove(*iTempBufferHolder);

		delete iTempBufferHolder;

		iTempBufferHolder = NULL;	

		}

	while(!iSourceBufferQ.IsEmpty())

		{

		//deleting all the entries in source buffers queue

		iTempBufferHolder = iSourceBufferQ.First();

		iSourceBufferQ.Remove(*iTempBufferHolder);

		delete iTempBufferHolder;

		iTempBufferHolder = NULL;	

		}

	TUint8* bufferaddress = iInputBufferPtr; 

	//reallocates the buffer to source buffer queue

	for(TInt buffercount = 0; buffercount < KIRInputBufferCount; buffercount++)

		{