/*

* 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 <e32property.h>

#include "irpubsubkeys.h"

#include "irctrlcmdobserver.h"

#include "irdebug.h"

#include "irmediaclient.h"

#include "irmediaenginebuffer.h"

#include "irmediaengineinterface.h"

#include "ircontrolparams.h"

const TInt KZeroVolumeLevel = 0;

const TInt KIRBitRateDivider = 8;    // To convert bits to bytes.

const TInt KIRByteMultiplier = 1024; // To convert kilo bytes to bytes.

const TInt KIRValidBitRate = 0;      // Starting point for valid bit rate.

const TInt KIRDefBitRate = 64;       // Default bit rate for buffer size calculation.

const TInt KIRMinBitRate = 8;        // Minimum bit rate for buffer size calculation.

const TInt KIRMaxBitRate = 192;      // Maximum bit rate for buffer size calculation.

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

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

// Function : NewL

// Two Phase Constructor - NewL

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

//	 

CIRMediaClient* CIRMediaClient::NewL(CIRCtrlCmdObserver* aChannel)

	{

	IRLOG_DEBUG( "CIRMediaClient::NewL - Entering" );

	CIRMediaClient* self = NewLC(aChannel);

    CleanupStack::Pop(self);

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

    return self;	

	}

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

// Function : NewLC

// Two Phase Constructor - NewLC

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

//

CIRMediaClient* CIRMediaClient::NewLC(CIRCtrlCmdObserver* aChannel)

	{

	IRLOG_DEBUG( "CIRMediaClient::NewLC - Entering" );

	CIRMediaClient* self = new (ELeave) CIRMediaClient();

    CleanupStack::PushL(self);

    self->ConstructL(aChannel);

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

    return self;	

	}

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

// destructor function

// destructor of the player component

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

//

CIRMediaClient::~CIRMediaClient()

    {

	IRLOG_DEBUG( "CIRMediaClient::~CIRMediaClient - Entering" );

	//deletes the player

	delete iPlayer;

	//deletes the buffers associated with player

	delete[] iTempBuffer;

	delete[] iCurrentBuffer;

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

    }

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

// This is default Constructor

// for the class CIRMediaClient

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

//	

CIRMediaClient::CIRMediaClient():iInputBuffer(NULL,0,0) 

	{

	IRLOG_DEBUG( "CIRMediaClient::CIRMediaClient" );

	}

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

// Two phase ConstructL

// network component is taken as input

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

//

void CIRMediaClient::ConstructL(CIRCtrlCmdObserver* aChannel)

    {

	IRLOG_DEBUG( "CIRMediaClient::ConstructL - Entering" );

	iChannel = aChannel;

	IRLOG_DEBUG( "CIRMediaClient::ConstructL - Exiting" );

	}

										   //For Play control

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

// Function : PlayL

// Starts to play the stream

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

//

TInt CIRMediaClient::Play()

	{

	IRLOG_DEBUG( "CIRMediaClient::Play - Entering" );

	IRLOG_DEBUG( "CIRMediaClient::Play - Exiting" );

	//sents a play request to media engine

	if( iPlayer )

		{

		iPlayer->Play();

		IRLOG_DEBUG( "CIRMediaClient::Play - Exiting (1)." );

		return KErrNone;

		}

	else

		{

		IRLOG_DEBUG( "CIRMediaClient::Play - Exiting (2)." );

		return KErrNotFound;

		}	

	}

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

// Function : StopL

// Stops to play the stream

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

//

void CIRMediaClient::Stop()

	{

	IRLOG_DEBUG( "CIRMediaClient::Stop - Entering" );

	//sents a stop request to media engine

	if( iPlayer )

		{

		iPlayer->Stop();

		}

	else

		{

		iCommand = EStoppedPlaying;

		iChannel->SentRequest(iCommand,KErrNone);

		}

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

	}

										 //For Volume Control

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

// Function : SetVolume

// function to set the volume, 

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

//

void CIRMediaClient::SetVolume(TInt aVolume )

	{

	IRLOG_DEBUG( "CIRMediaClient::SetVolume - Entering" );

	//if player is exists it will set the volume

	if( iPlayer )

		{

		iPlayer->SetVolume(aVolume);	

		}		

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

	}

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

// Function : MaxVolume

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

//	

TInt CIRMediaClient::MaxVolume() const

	{

	IRLOG_DEBUG( "CIRMediaClient::MaxVolume - Entering" );

	IRLOG_DEBUG( "CIRMediaClient::MaxVolume - Exiting" );

	//if player is created it will sent the max volume else return zero instead of MaxVolume

	if( iPlayer )

		{

		IRLOG_DEBUG( "CIRMediaClient::MaxVolume - Exiting (1)." );

		//returns maximum volume if player exists

		return iPlayer->MaxVolume();	

		}		

	else

		{

		//else zero is returned

		IRLOG_DEBUG( "CIRMediaClient::MaxVolume - Exiting (2)." );

		return KZeroVolumeLevel;	

		}

	}

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

// Function : Volume

// function to returns the volume

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

//		

TInt CIRMediaClient::Volume() const

	{

	IRLOG_DEBUG( "CIRMediaClient::Volume - Entering" );

	IRLOG_DEBUG( "CIRMediaClient::Volume - Exiting" );

	//if player is created it will sent the volume else return zero instead of Volume

	if( iPlayer )

		{

		//if player exist it returns the current volume

		IRLOG_DEBUG( "CIRMediaClient::Volume - Exiting (1)." );

		return iPlayer->Volume();	

		}		

	else

		{

		//else will return negative volume

		IRLOG_DEBUG( "CIRMediaClient::Volume - Exiting (2)." );

		return KZeroVolumeLevel;	

		}

	}

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

// Function: BufferFilled

// Set the whether a Fill Buffer is currently active

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

//

void CIRMediaClient::BufferFilled()

	{

	IRLOG_DEBUG( "CIRMediaClient::BufferFilled - Entering" );

	if( iFirstTime )

		{

		//First all the buffers are filled

		iInputBufferPtr += iConfig.iPlayBufferSize;	

		if( (iInputBufferPtr + iConfig.iPlayBufferSize) <= 

			(iTempBuffer + iConfig.iPlayBufferCount*iConfig.iPlayBufferSize) )

			{

			//buffer is not completely filled

			iInputBuffer.Set(iInputBufferPtr,iConfig.iPlayBufferSize,iConfig.iPlayBufferSize);	

			if( iStopBuffering )

				{

				//if iStopBuffering is true we won't continue in this loop

				return;		

				}			

			else // if not stop buffering is called

				{

				//fills the buffer and sents the buffer percentage

				iChannel->FilltheBuffer(iInputBuffer);			

				}				

			}

		else

			{

			//buffer is completely filled

			iFirstTime = EFalse;

			iNewPlayer = EFalse;

			if( iStopBuffering )

				{

				//if stop buffering is true we will not proceed further

				return;	

				}

			else

				{

                // Error reporting done inside CreatePlayer

				if ( CreatePlayer() )

				    {

				    // Sending this event causes NowPlayingView activation

				    iBufferPercentage = K100Percentage;				

				    iChannel->SentRequest( EBufferFillStop, iBufferPercentage );	

				    //player has already buffered completely for the first time

				    //so even if StopInitialBuffering is called media client is help less

				    //to handle this situation iStopBuffering is made ETrue

				    iStopBuffering = ETrue;

				    //called for intializing a new player

				    InitializePlayer( iConfig,iChannel );

				    //calls play for the first time

				    iPlayer->Play();

				    }

				}									

			}

		}

	else

		{

		//buffer is already filled for first time

		//media engine is created and playing so Buffer filled 

		//function of media Engine should be called

		iPlayer->BufferFilled();				

		}			

	IRLOG_DEBUG( "CIRMediaClient::BufferFilled - Exiting." );

	}

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

// Function: StartNewPlayerL

// Set the whether a Fill Buffer is currently active

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

//

void CIRMediaClient::StartNewPlayerL(TConfig& aConfig,const TDesC8& aFormat

	)

	{

	IRLOG_DEBUG( "CIRMediaClient::StartNewPlayerL - Entering" );

	//format is copied

	iFormat.Copy(aFormat);

	//stop of intial buffering from media client is enable

	iStopBuffering = EFalse;

	iConfig = aConfig;

	TInt bitRate(0);

	RProperty::Get ( KUidActiveInternetRadioApp, KIRPSBitrate, bitRate );

    // Next line will round the bitrate down to be divisible by KIRBitRateDivider.

	bitRate = bitRate - (bitRate % KIRBitRateDivider);

	if( bitRate <= KIRValidBitRate )

	    {

	    // If invalid bit rate info, use default bit rate for calculating buffer sizes.

	    bitRate = KIRDefBitRate;

	    }

	else if( bitRate < KIRMinBitRate )

	    {

	    // If small bit rate info, use minimum bit rate for calculating buffer sizes.

	    // To make single buffer minimum size 1 kB.

	    bitRate = KIRMinBitRate;

	    }

	else if( bitRate > KIRMaxBitRate )

	    {

	    // If large bit rate info, use maximum bit rate for calculating buffer sizes.

	    // To make single buffer maximum size 24 kB.

	    bitRate = KIRMaxBitRate;

	    }

	else

	    {

	    }

	iConfig.iPlayBufferCount = KIRInputBufferCount;

    iConfig.iPlayBufferSize = KIRByteMultiplier*bitRate/KIRBitRateDivider;

	//creates a new instance of media buffer for new player

	iTempBuffer = new (ELeave) TUint8[iConfig.iPlayBufferCount*iConfig.iPlayBufferSize];

	iInputBufferPtr = iTempBuffer;

	//initial buffering starts

	iInputBuffer.Set(iInputBufferPtr,iConfig.iPlayBufferSize,iConfig.iPlayBufferSize);

	iNewPlayer = ETrue;

	iFirstTime = ETrue;

	//initial buffering starts

	iChannel->FilltheBuffer(iInputBuffer);	

	//starts audio fade out for the previous channel

	IRLOG_DEBUG( "CIRMediaClient::StartNewPlayerL - Exiting." );

	}

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

// Function: StopMediaBuffering

// stops buffering of media engine, the change cannot be reverted 

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

//

void CIRMediaClient::StopMediaBuffering()

	{

	IRLOG_DEBUG( "CIRMediaClient::StopMediaBuffering - Entering" );

	//calls media engine's stop buffering cancels the buffering in media engine

	if( iPlayer )

		{

		iPlayer->StopPlayerBuffering();	

		}			

	IRLOG_DEBUG( "CIRMediaClient::StopMediaBuffering - Exiting." );

	}

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

// Function: StopInitialBuffering

// stops buffering from media client, media engine is not stopped 

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

//

void CIRMediaClient::StopInitialBuffering()

	{

	IRLOG_DEBUG( "CIRMediaClient::StopInitialBuffering - Entering" );

	//initially buffering is taken care by media client and then 

	//it shift the responsibility to media engine

	//this is done because audio fade out has to take place when other channel buffers

	//if media client is handling the buffer it should be stopped

	//media client is handling the buffering

	iStopBuffering = ETrue;

	delete[] iTempBuffer;

	iTempBuffer = NULL;

	iCommand=EStereo;

	iChannel->SentRequest(iCommand,KErrNone);

	delete iPlayer;

	iPlayer = NULL;

	iStopBuffering = ETrue;

	//return true to indicate success of cancelling of buffer

	IRLOG_DEBUG( "CIRMediaClient::StopInitialBuffering - Exiting." );

	}

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

// Function: SetCodecSettings

// Creates an instance of the players and initialize it

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

//

TBool CIRMediaClient::CreatePlayer()

	{

    IRLOG_DEBUG( "CIRMediaClient::CreatePlayer" );

    TBool createResult( ETrue );

	//delete the instance of previously created player

	iCommand=EStereo;

	iChannel->SentRequest(iCommand,KErrNone);

    if ( iPlayer )

    	{

    	delete iPlayer;

    	iPlayer = NULL;

    	}

	//media engine's instance is created type is stored in iFormat (basically the mime type)

	TRAPD(error,iPlayer = CIRMediaEngineInterface::NewL(iFormat));

    if( error )

        {

        iChannel->SentRequest( EError, KIRCtrlCmdPlayerNotCreated );

        createResult = EFalse;

        }

    return createResult;    

	}

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

// CIRMediaClient::InitializePlayer

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

//

void CIRMediaClient::InitializePlayer( TConfig& aConfig,

	CIRCtrlCmdObserver* aChannel)

	{

	IRLOG_DEBUG( "CIRMediaClient::SetCodecSettings" );

	//delete the instance of buffer associated with previously playing player

	delete[] iCurrentBuffer;

	iCurrentBuffer = NULL;

	//current buffer is made same as previous buffer

	iCurrentBuffer = iTempBuffer;

	iTempBuffer = NULL;

	//intialize the media engine

	iPlayer->Intialize(aConfig,iCurrentBuffer,aChannel);

	IRLOG_DEBUG( "CIRMediaClient::SetCodecSettings - Exiting." );

	}

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

// CIRNowPlayingWrapper::GetMediaClientInstance()

// Returns the Audio Player Instance

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

//

CMdaAudioOutputStream* CIRMediaClient::GetPlayerInstance()

	{

	IRLOG_DEBUG( "CIRMediaClient::GetMediaClientInstance " );

	return (iPlayer->GetAudioPlayer());	

	}