/*

* 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 "iraacplayer.h"

#include "iraacplayerlocal.h"

#include "irbuffercontainer.h"

#include "irctrlcmdobserver.h"

#include "irdebug.h"

#include "irmediaenginebuffer.h"

// Constants

const TInt KZERO = 0 ;

const TInt KONE = 1 ;

const TInt KTWO = 2 ;

const TInt KTHREE = 3 ;

const TInt KFOUR = 4 ;

const TInt KFIVE = 5 ;

const TInt KSIX = 6 ;

const TInt KELEVEN = 11 ;

const TInt KTWENTYONE = 21 ;

const TInt KTWENTYFOUR = 24 ;

const TInt KSIXTEEN = 16 ;

const TInt KEIGHT = 8 ;

const TInt KONEFIVETHREESIX = 1536 ;

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

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

// Function : NewL

// function returns an instance of CIRAACPlayer

// Two phase constructor

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

//

CIRAACPlayer* CIRAACPlayer::NewL()

	{

	IRLOG_DEBUG( "CIRAACPlayer::NewL" );

	CIRAACPlayer* self = CIRAACPlayer::NewLC();

	CleanupStack::Pop(self);

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

	return self;

	}

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

// Function : NewLC

// function creates an instance of CIRAACPlayer

// Two phase constructor

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

//

CIRAACPlayer* CIRAACPlayer::NewLC()

	{

	IRLOG_DEBUG( "CIRAACPlayer::NewLC" );

	CIRAACPlayer* self = new (ELeave) CIRAACPlayer;

	CleanupStack::PushL(self);

	self->ConstructL();

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

	return self;

	}

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

// Function : ~CIRAACPlayer

// Default Destructor

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

//

CIRAACPlayer::~CIRAACPlayer()

	{

	IRLOG_DEBUG( "CIRAACPlayer::~CIRAACPlayer" );

	delete iAudioPlayer;

	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( "CIRAACPlayer::~CIRAACPlayer - Exiting." );

	}

									//Function for Play control

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

// Function : Play

// function which intiates the player to start playing

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

//

void CIRAACPlayer::Play()

	{

	IRLOG_DEBUG( "CIRAACPlayer::Play" );

	if ( EPlaying == iState ) //If the current state is playing

		{

		//internally stopped before playing so no need of sending

		//stop status

		iSkipPlayCompleted = ETrue;

		iAudioPlayer->Stop(); //then we have to stop it then restart the play from begining

		iSkipPlayCompleted = EFalse;

		}

	iState = ENotReady;

	iBufferPercentage = KZeroPercentage;

	iHeaderFound = EFalse;

	iStopState = EFalse;

	//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

	//opening the current player component

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

	iChannel->SentRequest(EPlayingState,KErrNone);			

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

	}

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

// Function : Stop

// function which stops the player

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

//

void CIRAACPlayer::Stop()

	{

	IRLOG_DEBUG( "CIRAACPlayer::Stop" );

	//If the current state is playing

	if ( EPlaying == iState )

		{

		iAudioPlayer->Stop();

		}

	else

		{

		//sending the updated status as stopped

		iChannel->SentRequest( EStoppedPlaying, KErrNone );

		}

	iState = EReadyToPlay;

	iStopState = ETrue;

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

	}

										//Functions for Volume Control

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

// Function : SetVolume

// function to set the volume

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

//

void CIRAACPlayer::SetVolume(TInt aVolume )

	{

	IRLOG_DEBUG( "CIRAACPlayer::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((TInt)(aVolume));

		iConfig.iVolume = iCurrentVolume = aVolume;

		}

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

	}

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

// Function : MaxVolume

// function to returns the maximum volume

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

//

TInt CIRAACPlayer::MaxVolume() const

	{

	IRLOG_DEBUG( "CIRAACPlayer::MaxVolume" );

	return iAudioPlayer->MaxVolume();

	}

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

// Function : Volume

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

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

//

TInt CIRAACPlayer::Volume() const

	{

	IRLOG_DEBUG( "CIRAACPlayer::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 CIRAACPlayer::Intialize(TConfig& aConfig,TUint8* aInitParams,

	CIRCtrlCmdObserver* aChannel)

	{

	IRLOG_DEBUG( "CIRAACPlayer::Intialize" );

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

	//Configuration information

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

	iPlayBufferSize = iConfig.iPlayBufferSize;

	iInputBufferSize = iConfig.iPlayBufferCount*iPlayBufferSize;

    iBufferOffset = iPlayBufferSize;

	iDataType.Set(KMMFFourCCCodeAAC); //! Set the data type as AAC

	iChannel = reinterpret_cast<CIRCtrlCmdObserver*> (aChannel);

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

	TRAPD(err,CreateBufferL()); //creates the buffer

	if( err )

		{

		iChannel->SentRequest( EError, KIRCtrlCmdGeneralPlayerError );

		return;

		}

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

	}

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

// Function: StopPlayerBuffering

// Function is used to freeze bufferring

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

//

void CIRAACPlayer::StopPlayerBuffering()

	{

	IRLOG_DEBUG( "CIRAACPlayer::StopPlayerBuffering" );

	iStopPlayerBuffering = ETrue;

	}

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

// Function: BufferFilled

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

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

//

void CIRAACPlayer::BufferFilled()

	{

	IRLOG_DEBUG( "CIRAACPlayer::BufferFilled" );

	if( !iNewPlayer )

		{

		//if not playing for the first time

		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 it is playing for first time or rebuffering

		if( !iNewPlayer )

			{

			//if not playing for the first time

			if( !iSourceBufferQ.IsEmpty() )

				{

				//fill the entire buffer source queue

				//if the entire source buffer queue is not filled

				if( !iStopPlayerBuffering )

					{

					iTempBufferHolder = iSourceBufferQ.First();

					iTempbuffer = iTempBufferHolder->Des();

					iInputBuffer.Set

						(iTempbuffer,iPlayBufferSize,iPlayBufferSize);

					if( !iStopState )

						{

						//! Calls the fill the buffer for next subsequent times until the source buffer queue is empty

						iChannel->FilltheBuffer(iInputBuffer);

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

						return;

						}

					}

				}

			else

				{

				//if the entire source buffer queue is filled

				//gets the header informations like sampling rate and channel

				//this function here is called to find proper header and

				//rearrange buffer accordingly

				GetAACAudioProperties();

				//buffer is completetly filled and indicates that buffering is completed

				iBufferPercentage = K100Percentage;

				iChannel->SentRequest( EBufferFillStop, iBufferPercentage );

				//takes the first buffer from sink buffer queue

				if( !iSinkBufferQ.IsEmpty() )

					{

					iTempBufferHolder = iSinkBufferQ.First();

					}

				iTempbuffer = iTempBufferHolder->Des();

				iInput.Set(iTempbuffer,iPlayBufferSize,iPlayBufferSize);

				iFirstTime = EFalse;

				iState = EPlaying;

				if( !iStopState )

					{

					//! Calls the play for the first time

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

					if( err )

						{

						iChannel->SentRequest( EError, KIRCtrlCmdGeneralPlayerError );

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

						return;

						}

					}

				}

			}

		else

			{

			//if a new player

			TInt err( KErrNone );

			//get audio properties like sampling rate and channel

			if( !iHeaderFound )

				{

				GetAACAudioProperties();

				}

			//sets the audio properties like sampling rate and channel

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

														 iSettings.iChannels));

			if( err )

				{

				iChannel->SentRequest( EError, KIRCtrlCmdGeneralPlayerError );

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

				return;

				}

			//indicates that it is ready to play to client

			iBufferPercentage = K100Percentage;

			iChannel->SentRequest( EBufferFadeInReady, iBufferPercentage );

			if( !iSinkBufferQ.IsEmpty() )

				{

				iTempBufferHolder = iSinkBufferQ.First();

				}

			iTempbuffer = iTempBufferHolder->Des();

			//takes the first buffer from sink buffer queue

			iInput.Set(iTempbuffer,iPlayBufferSize,iPlayBufferSize);

			iFirstTime = EFalse;

			iState = EPlaying;

			iNewPlayer = EFalse;

			if( !iStopState )

				{

				//! Calls the play for the first time

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

				if( err )

					{

					iChannel->SentRequest( EError, KIRCtrlCmdGeneralPlayerError );

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

					return;

					}

				}

			}

		}

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

	}

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

// Function: CIRAACPlayer

// This function is the default constructor

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

//

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

	{

	IRLOG_DEBUG( "CIRAACPlayer()::CIRAACPlayer" );

	}

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

// Function: ConstructL

// Two phase constructor is used to intialize data members

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

//

void CIRAACPlayer::ConstructL()

	{

	IRLOG_DEBUG( "CIRAACPlayer::ConstructL" );

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

		(TMdaPriorityPreference)KAudioPrefRealOneStreaming );

										//creates an instance of the player

	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 freeze buffering

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

	iState = ENotReady;//current state not ready

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

	}

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

// Function: CreateBufferL

// Allocates memory and  creates buffers of sink queue

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

//

void CIRAACPlayer::CreateBufferL()

	{

	IRLOG_DEBUG( "CIRAACPlayer::CreateBufferL" );

	TUint8* bufferaddress = iInputBufferPtr;

	//Created memory to buffer and allocates buffers to buffer queues

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

		{

		iTempBufferHolder =

			CIRBufferContainer::NewL(bufferaddress,iPlayBufferSize);

		iSinkBufferQ.AddLast(*iTempBufferHolder);

		bufferaddress += iBufferOffset;

		}

	IRLOG_DEBUG( "CIRAACPlayer::CreateBufferL - Exiting." );

	}

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

// Function: ReCreateBufferL

// Recreates buffers of source queue

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

//

void CIRAACPlayer::ReCreateBufferL()

	{

	IRLOG_DEBUG( "CIRAACPlayer::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;

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

		{

		//reallocates the buffer to source buffer queue

		iTempBufferHolder =

			CIRBufferContainer::NewL(bufferaddress,iPlayBufferSize);

		iSourceBufferQ.AddLast(*iTempBufferHolder);

		bufferaddress += iBufferOffset;

		}

	IRLOG_DEBUG( "CIRAACPlayer::ReCreateBufferL - Exiting." );

	}

									//Call back functions

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

// Function: MaoscBufferCopied

// call back to be implemented for using CMdaAudioOutputStream

// Call as callback from the CMdaAudioOutputStream::WriteL

// after frame work has copied stream to a buffer * @param Error code

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

//

void CIRAACPlayer::MaoscBufferCopied(TInt aError, const TDesC8& /*aBuffer*/)

	{

	IRLOG_DEBUG( "CIRAACPlayer::MaoscBufferCopied" );

	if( aError )

		{

		iChannel->SentRequest( EError, KIRCtrlCmdGeneralPlayerError );

		IRLOG_DEBUG( "CIRAACPlayer::MaoscBufferCopied - Exiting (1)." );

		return;

		}

	else

		{

        if ( iCurrentVolume < iConfig.iVolume )

            {

            iCurrentVolume = iConfig.iVolume;

            IRLOG_INFO2( "CIRAACPlayer::MaoscBufferCopied - Setting volume to %d", iCurrentVolume );

            iAudioPlayer->SetVolume( iCurrentVolume );

            }

		if( !iSinkBufferQ.IsEmpty() )

			{

			//removing the previously read buffer

			iTempBufferHolder = iSinkBufferQ.First();

			iSinkBufferQ.Remove(*iTempBufferHolder);

			if(iTempBufferHolder->Size() == iPlayBufferSize)

				{

				iSourceBufferQ.AddLast(*iTempBufferHolder);

				}

			else

				{

				delete iTempBufferHolder;

				iTempBufferHolder = NULL;

				}

			}

		if( !iStopPlayerBuffering )

			{

			if( !iSourceBufferQ.IsEmpty() )

				{

				//refilling the first empty buffer from the source queue

				iFirstTime = EFalse;

				iTempBufferHolder = iSourceBufferQ.First();

				iTempbuffer = iTempBufferHolder->Des();

				iInputBuffer.Set

					(iTempbuffer,iPlayBufferSize,iPlayBufferSize);

				iChannel->FilltheBuffer(iInputBuffer);

				}

			}

		if( iStopState )

			{