/*

* Copyright (c) 2006 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 the base class from which specific audio

*                play controllers are derived. This class encapsulates common

*                behavior for all audio play controllers.

*

*/

// INCLUDE FILES

#include "AdvancedAudioPlayController.h"

#include "AdvancedAudioResource.h"

#include "DebugMacros.h"

#include <AudioOutput.h>

#include <MetaDataFieldContainer.h>

#include <MetaDataUtility.h>

#include <mmfformatimplementationuids.hrh>

#include <mmfmeta.h>

#include <MultimediaDataSourceEvents.h>

#include <MultimediaDataSourceFactory.h>

#include <oma2dcf.h>

// KMdaRepeatForever constant is defined in this file

#include <mda/common/resource.h>

// CONSTANTS

const TInt KOneThousandMilliSecond = 1000;      // 1 sec

// ============================= LOCAL FUNCTIONS ===============================

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

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

// CAdvancedAudioPlayController::CAdvancedAudioPlayController

// C++ default constructor can NOT contain any code, that might leave.

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

//

EXPORT_C CAdvancedAudioPlayController::CAdvancedAudioPlayController()

	:	iState(EStopped),

		iAudioOutput(NULL),

		iAudioResource(NULL),

		iAudioUtility(NULL),

		iDisableAutoIntent (EFalse),

    iDecoderExists(EFalse),

    iRepeatCount(-1),

    iCurrentRepeatCount(0),

    iLoopPlayEnabled(EFalse),

    iRepeatForever(EFalse),

    iTrailingSilenceMs(0),

    iSavedTimePositionInMicroSecs(0) //,

	{

    iEventsEnabled = EFalse;

    RThread().SetPriority(EPriorityRealTime);

    }

EXPORT_C void CAdvancedAudioPlayController::ConstructL()

	{

	DP1(_L("CAdvancedAudioPlayController::ConstructL this[%x]"), this);

	CAdvancedAudioController::ConstructL();

    // Construct custom command parsers

    CMMFAudioPlayDeviceCustomCommandParser* audPlayDevParser =

    	CMMFAudioPlayDeviceCustomCommandParser::NewL(*this);

    CleanupStack::PushL(audPlayDevParser);

    AddCustomCommandParserL(*audPlayDevParser);

    CleanupStack::Pop(audPlayDevParser);

    CMMFAudioPlayControllerCustomCommandParser* audPlayConParser =

    	CMMFAudioPlayControllerCustomCommandParser::NewL(*this);

    CleanupStack::PushL(audPlayConParser);

    AddCustomCommandParserL(*audPlayConParser);

    CleanupStack::Pop(audPlayConParser);

	CMMFDRMCustomCommandParser* drmParser = CMMFDRMCustomCommandParser::NewL(*this);

	CleanupStack::PushL(drmParser);

	AddCustomCommandParserL(*drmParser);

	CleanupStack::Pop(drmParser);

    CStreamControlCustomCommandParser* scCCParser = CStreamControlCustomCommandParser::NewL(*this);

    CleanupStack::PushL(scCCParser);

    AddCustomCommandParserL(*scCCParser);

    CleanupStack::Pop(scCCParser);

    // new custom command parser to implement the MapcSetRepeats custom command from the client

    CMMFAudioPlayControllerSetRepeatsCustomCommandParser* audPlayConSetRepeatsParser =

            CMMFAudioPlayControllerSetRepeatsCustomCommandParser::NewL(*this);

    CleanupStack::PushL(audPlayConSetRepeatsParser);

    AddCustomCommandParserL(*audPlayConSetRepeatsParser);

    CleanupStack::Pop(audPlayConSetRepeatsParser);

	}

// Destructor

EXPORT_C CAdvancedAudioPlayController::~CAdvancedAudioPlayController()

    {

    DP1(_L("CAdvancedAudioPlayController::~CAdvancedAudioPlayController start this[%x]"), this);

    DP4(_L("CAdvancedAudioPlayController::~CAdvancedAudioPlayController iState[%d] iWait[%d] iBlockSetPos[%d] iSharedBuffers.Count[%d]"),

            iState, iWait, iBlockSetPos, iSharedBuffers.Count());

	RThread().SetPriority(EPriorityNormal);

    if (iMetaDataEntries.Count())

    	{

        iMetaDataEntries.ResetAndDestroy();

		iMetaDataEntries.Close();

		}

    if (iTrailingSilenceTimer)

        {

        delete iTrailingSilenceTimer;

        iTrailingSilenceTimer = NULL;

        }

	delete iDataSourceAdapter;

	delete iWait;

	delete iBlockSetPos;

	iSharedBuffers.ResetAndDestroy();

	iSharedBuffers.Close();

    DP0(_L("CAdvancedAudioPlayController::~CAdvancedAudioPlayController end"));

    }

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

// CAdvancedAudioPlayController::DoReadHeaderL

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

//

EXPORT_C void CAdvancedAudioPlayController::DoReadHeaderL(CMMFDataBuffer* /*aBuffer*/)

    {

    // do nothing

    }

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

// CAdvancedAudioPlayController::DoSetPositionL

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

//

EXPORT_C void CAdvancedAudioPlayController::DoSetPositionL(const TTimeIntervalMicroSeconds& aTimePos)

    {

    DP0(_L("CAdvancedAudioPlayController::DoSetPositionL start -----------"));

    TInt err = KErrNone;

    TInt foundPosition;

    TInt foundTimeMs;

    TBool seekFwd = EFalse;

	TUint timeMs = aTimePos.Int64()/1000;

    DP2(_L("CAdvancedAudioPlayController::DoSetPositionL timeMs[%u] pre[%d]"), timeMs, (iPreSeekTime.Int64()/1000));

    // Fix for the error ou1cimx1#151598 - ESLM-7T5GJH

    // unregisters any old position entries from the FrameTable before setting any new play seek positions

    iAudioUtility->SeekToTimeMs(KMaxTUint);

	if (aTimePos < 0)

		{

		timeMs = 0;

		}

    // get current position in time

    // if we need to play to seek forward (not in table), the time will be advanced immediately

    // if we pause before we get there, pause will set pos to that time - which is what we want.

    // but we need to remember that we are not there yet so we can still seek forward. So we use pre-seek time.

    if (!iPlaySeeking)

        {

        iPreSeekTime = PositionL();

	    DP1(_L("CAdvancedAudioPlayController::DoSetPositionL save pre-seek time[%d]"), iPreSeekTime.Int64()/1000);

        }

    if (aTimePos > iPreSeekTime)

    	{

    	seekFwd = ETrue;

    	}

    DP1(_L("CAdvancedAudioPlayController::DoSetPositionL seekFwd[%d]"), seekFwd);

   	TUint const seekTime = timeMs;

    TUint position = 0;

    TBool posFoundInTable = EFalse;

    // look in current buffers first

    DP0(_L("CAdvancedAudioPlayController::DoSetPositionL not time seekable"));

    err = SetPositionInSharedBuffers(timeMs, foundPosition, foundTimeMs);

    if (!iSourceIsTimeSeekable && !iSourceIsPosSeekable)

        { 

    	if (err == KErrNone)

	        { // found exact position

		    DP0(_L("CAdvancedAudioPlayController::DoSetPositionL found exact position"));

    	    iCurrentPosition = foundPosition; // absolute position into file or content

        	iTimePositionInMicroSecs = foundTimeMs;

        	iTimePositionInMicroSecs *=1000;

            DP1(_L("CAdvancedAudioPlayController::DoSetPositionL iTimePositionInMicroSecs[%d]"),foundTimeMs);

			iAudioUtility->SetSourceReference(iTimePositionInMicroSecs/1000, iCurrentPosition-iHeaderOffset-iSyncOffset);

		    RefillPreceedingBuffersL();

    		DP0(_L("CAdvancedAudioPlayController::DoSetPositionL end -----------"));

    	    return;

        	}

	    // err means it just found something close

        ASSERT(err != KErrGeneral);

        if (err == KErrGeneral)

            { // KErrGeneral means it did not find anything and we have to stop.

    		DP0(_L("CAdvancedAudioPlayController::DoSetPositionL abort -------"));

    		TMMFEvent event(KMMFEventCategoryPlaybackComplete,KErrGeneral);

    		SendEvent(event);

            return;

            }

        // source is not seekable so use buffered data

	    // use closest time and position found above

		DP0(_L("CAdvancedAudioPlayController::DoSetPositionL using closest position"));

    	iCurrentPosition = foundPosition;

        iTimePositionInMicroSecs = foundTimeMs;

        iTimePositionInMicroSecs *=1000;

        DP1(_L("CAdvancedAudioPlayController::DoSetPositionL iTimePositionInMicroSecs[%d]"),foundTimeMs);

		iAudioUtility->SetSourceReference(iTimePositionInMicroSecs/1000, iCurrentPosition-iHeaderOffset-iSyncOffset);

		RefillPreceedingBuffersL();

        }

    if (iSourceIsTimeSeekable)

	  	{ // time seekable source won't have accurate table positions

	    DP0(_L("CAdvancedAudioPlayController::DoSetPositionL is time seekable"));

        iPreSeekTime = 0;

		iDataSourceAdapter->SourceStopL(); // clear the buffers in the source before seeking and priming it

		iDataSourceAdapter->SourcePrimeL();

	  	err = iDataSourceAdapter->SeekToTime(seekTime, timeMs);

	    iAudioUtility->ResetTable();

		iDataSourceAdapter->SourcePlayL();

		iTimePositionInMicroSecs = timeMs;

		iTimePositionInMicroSecs *=1000;

        DP1(_L("CAdvancedAudioPlayController::DoSetPositionL iTimePositionInMicroSecs[%d]"),timeMs);

		iSourceReadPosition = 0; // we don't know the position - source doesn't give us that

	    // iCurrentPosition = iSourceReadPosition;

		iCurrentPosition = KMaxTUint;

		iAudioUtility->SetSourceReference(iTimePositionInMicroSecs/1000, 0);

        TRAP(err, RefillSharedBuffersL());

    	}

    else if (iSourceIsPosSeekable)

    	{

	    DP0(_L("CAdvancedAudioPlayController::DoSetPositionL is position seekable"));

	    TInt err = iAudioUtility->FindFramePosFromTime(timeMs, position);

	    if (err == KErrNone)

    		{

   			DP0(_L("CAdvancedAudioPlayController::DoSetPositionL pos found in table"));

    		posFoundInTable = ETrue;

    		}

	    TBool tryForAccuracy = EFalse;

		if (posFoundInTable)

			{ // seek in source is taken care of below

			// The position was found in the table, and assuming it was found in the low res table

			// lets try to seek fwd to the exact position.

			// The reason for this is that the record utility does a stop play instead of a pause play

			// The inaccuracy in the resume position is then visible, using the low res table.

			tryForAccuracy = ETrue;

			}

		else

			{ // then we must be going forward or just starting

   			DP0(_L("CAdvancedAudioPlayController::DoSetPositionL pos not found in table"));

   			err = iAudioUtility->LastFramePos(position);

   			if (err) // use KErrDoesNotExist or something

   				{ // do this a little better, maybe return something different from LastFramePos

   				position = 0;

   				timeMs = 0;

   				}

   			else

	   			{

			    err = iAudioUtility->FindFrameTimeFromPos(timeMs, position);

   				}	

			}

		// seek in source		

		DP0(_L("CAdvancedAudioPlayController::DoSetPositionL seek in the source"));

	    iSourceReadPosition = position+iHeaderOffset+iSyncOffset;

		iDataSourceAdapter->SourceStopL(); // clear the buffers in the source before seeking and priming it

		iDataSourceAdapter->SourcePrimeL();

	    iDataSourceAdapter->SeekToPosition(iSourceReadPosition);

	    iAudioUtility->ResetTable();

		iDataSourceAdapter->SourcePlayL();

	    iCurrentPosition = iSourceReadPosition;

	    iTimePositionInMicroSecs = timeMs;

	    iTimePositionInMicroSecs *=1000; // bh 21Mar08 // need this time to correlate to the position found

        DP1(_L("CAdvancedAudioPlayController::DoSetPositionL iTimePositionInMicroSecs[%d]"),timeMs);

		iAudioUtility->SetSourceReference(iTimePositionInMicroSecs/1000, iCurrentPosition-iHeaderOffset-iSyncOffset);

        TRAP(err, RefillSharedBuffersL());

		DP1(_L("CAdvancedAudioPlayController::DoSetPositionL RefillSharedBuffersL[%d]"),err);

        if (seekFwd && (!posFoundInTable || tryForAccuracy))

           	{

			// seeking forward past entries available in table

			// will scan buffers for frame lengths without rendering 

			// which will add table entries and notify when pos is reached

   			DP0(_L("CAdvancedAudioPlayController::DoSetPositionL do non-render seek fwd"));

           	SeekToTimeMsL(seekTime); // this will set iTimePositionInMicroSecs to the seek fwd time

           	}

       	else

       	    {

            iPreSeekTime = 0;

       	    }

    	}

    else

        { // continue from closest position and render once the time is reached

		DP0(_L("CAdvancedAudioPlayController::DoSetPositionL src not seekable continue"));

		if (seekFwd)

			{

			DP0(_L("CAdvancedAudioPlayController::DoSetPositionL src not seekable do non-render seek fwd"));

	       	SeekToTimeMsL(seekTime);

			}

        }

    DP0(_L("CAdvancedAudioPlayController::DoSetPositionL end -----------"));

    }

void CAdvancedAudioPlayController::SeekToTimeMsL(TUint aTimeMs)

	{ // used when seeking forward without rendering

	DP1(_L("CAdvancedAudioPlayController::SeekToTimeMs[%d]"),aTimeMs);

	iAudioUtility->SeekToTimeMs(aTimeMs);

	iPlaySeeking = ETrue;

	// ok to set the time forward because during this seek, devsound won't be getting

	// any data - so it's samples played would stay 0 and not keep incrementing if position is called

    iTimePositionInMicroSecs = aTimeMs;

    iTimePositionInMicroSecs *=1000;

    DP1(_L("CAdvancedAudioPlayController::SeekToTimeMs iTimePositionInMicroSecs[%d]"),iTimePositionInMicroSecs);

    if (iState == EPaused)

        {

        PlayForPauseSeekL();

        }

    else if (iState == EInitialized)

    	{

		PlayForInitPositionL();

    	}

	}

void CAdvancedAudioPlayController::GoToInitPositionL()

	{

    DP1(_L("CAdvancedAudioPlayController::GoToInitPositionL[%d]"),iInitPosition.Int64());

	if (iInitPosition >= 0)

		{ // -1 is inactive, >=0 will seek

		TTimeIntervalMicroSeconds position = iInitPosition;

	    DP0(_L("CAdvancedAudioPlayController::GoToInitPositionL clearing iInitPosition and seeking"));

		iInitPosition = -1;		

		DoSetPositionL(position);

		}

    // Register for the Playwindow end position, if PlayWindow is created

    if (iPlayWindowEndPosition > 0)

        {

        iAudioUtility->SetPlayWindowEndTimeMs(iPlayWindowEndPosition.Int64()/1000);

        }

	}

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

// CAdvancedAudioPlayController::RefillSharedBuffersL

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

//

void CAdvancedAudioPlayController::RefillSharedBuffersL()

    {

	DP0(_L("CAdvancedAudioPlayController::RefillSharedBuffersL"));

    TInt i;

    ClearSharedBuffersL();

    for (i=0; i < iSharedBufferMaxNum; i++)

        {

        FillSharedBufferL(iSharedBuffers[i]);

        }

    }

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

// CAdvancedAudioPlayController::ReinitSharedBuffersL

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

//

void CAdvancedAudioPlayController::ClearSharedBuffersL()

    {

	DP0(_L("CAdvancedAudioPlayController::ClearSharedBuffersL"));

    for (TInt i=0; i < iSharedBufferMaxNum; i++)

        {

    	static_cast<CMMFDataBuffer*>(iSharedBuffers[i])->Data().SetLength(0);

    	iSharedBuffers[i]->SetLastBuffer(EFalse);

    	iSharedBuffers[i]->SetStatus(EAvailable);

        }

    }

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

// CAdvancedAudioPlayController::InitSharedBuffersL

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

//

EXPORT_C void CAdvancedAudioPlayController::InitSharedBuffersL()

    {

	DP0(_L("CAdvancedAudioPlayController::InitSharedBuffersL"));

    TInt i;

	ResetSharedBuffersL(iSharedBufferMaxNum, iSharedBufferMaxSize);

    for (i=0; i < iSharedBufferMaxNum; i++)

        {

        FillSharedBufferL(iSharedBuffers[i]);

        }

    }

EXPORT_C void CAdvancedAudioPlayController::RefillPreceedingBuffersL()

	{

	DP0(_L("CAdvancedAudioPlayController::RefillPreceedingBuffersL"));

	TInt curIndex = iSharedBufferIndex;

	TInt curPos = iSharedBuffers[curIndex]->FrameNumber();

	TInt maxNum = iSharedBufferMaxNum;

	// buffers are filled in increasing order

	TInt index = iSharedBufferIndex;

	TInt pos;

	TInt stat;

	for (TInt i=0; i< maxNum-1; i++)

		{

		index++;

		if (index >= maxNum)

			{

			index = 0;

			}

        stat = iSharedBuffers[index]->Status();

		pos = iSharedBuffers[index]->FrameNumber();

		DP4(_L("CAdvancedAudioPlayController::RefillPreceedingBuffersL index[%d] stat[%d] pos[%d] bufpos[%d]"), 

				index, stat, pos, iSharedBuffers[index]->Position());

		if ((pos < curPos) && (stat == EFull))

			{

			DP1(_L("CAdvancedAudioPlayController::RefillPreceedingBuffersL index[%d]"),index);

	        FillSharedBufferL(iSharedBuffers[index]);

			}

		}

	}

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

// CAdvancedAudioPlayController::SourceSinkStopL

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

//

EXPORT_C void CAdvancedAudioPlayController::SourceSinkStopL()

    {

	iDataSourceAdapter->SourceStopL();

    if (iDataSink->DataSinkType() == KUidMmfFileSink)

        {

        iDataSink->SinkStopL();

        }

    }

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

// CAdvancedAudioPlayController::FillSharedBufferL

// Read the next block of data from source into the given buffer.

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

//

EXPORT_C void CAdvancedAudioPlayController::FillSharedBufferL(

    CMMFBuffer* aBuffer)

    {

    DP2(_L("CAdvancedAudioPlayController::FillSharedBufferL ptr[%x], iState[%d]"),

            static_cast<CMMFDataBuffer*>(aBuffer)->Data().Ptr(), iState);

    aBuffer->SetLastBuffer(EFalse);

    aBuffer->SetStatus(EBeingFilled);

	aBuffer->SetPosition(0);

	static_cast<CMMFDataBuffer*>(aBuffer)->Data().SetLength(0);

	TMediaId mediaId(KUidMediaTypeAudio);

	iDataSourceAdapter->FillBufferL(aBuffer, this, mediaId);

    }

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

// CAdvancedAudioPlayController::FindBufferFromPos

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

// aPos is relative to source position in that it includes any header offsets

// Will return KErrNotFound if the position is not found in the buffers.

// Will look only in full buffers.

EXPORT_C TInt CAdvancedAudioPlayController::FindBufferFromPos(TUint aPos)

	{

    DP1(_L("CAdvancedAudioPlayController::FindBufferFromPos, aPos[%d]"), aPos);

    TInt retVal = KErrNotFound;

    for (TInt i = 0; i < iSharedBufferMaxNum; i++)

        {

        DP5(_L("CAdvancedAudioPlayController::FindBufferFromPos iSharedBuffers[%d], ptr=%x, FrameNumber[%d], Status[%d], LastBuffer[%d]"), i, iSharedBuffers[i]->Data().Ptr(), iSharedBuffers[i]->FrameNumber(), iSharedBuffers[i]->Status(), iSharedBuffers[i]->LastBuffer());

        TUint framenumber = iSharedBuffers[i]->FrameNumber();

        TUint buffersize = iSharedBuffers[i]->BufferSize();

        DP6(_L("CAdvancedAudioPlayController::FindBufferFromPos iSharedBuffers[%d], ptr=%x, FrameNumber[%d], Status[%d], LastBuffer[%d], BufferSize[%d]"), i, iSharedBuffers[i]->Data().Ptr(), framenumber, iSharedBuffers[i]->Status(), iSharedBuffers[i]->LastBuffer(), buffersize);

        if ((aPos >= framenumber) && (aPos < (framenumber+buffersize)) &&

//        if ((aPos >= framenumber) && (aPos < (framenumber+iSharedBufferMaxSize)) &&

        	(iSharedBuffers[i]->Status() == EFull))

            {

            iSharedBuffers[i]->SetPosition(aPos-framenumber);

            DP1(_L("CAdvancedAudioPlayController::FindBufferFromPos setting position to [%d]"), iSharedBuffers[i]->Position());

			retVal = i;

			break;

            }

        }

    DP1(_L("CAdvancedAudioPlayController::FindBufferFromPos retVal[%d]"), retVal);

	return retVal;

	}	

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

// CAdvancedAudioPlayController::SetPositionInSharedBuffers

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

//

/*

This function will look in current buffers that aren't being filled and set the

buffer and position in it to the corresponding current time.

An error will be returned if the exact position was not located in a full buffer.

A closest available will be calculated. 

The buffers past the set will be sent to be filled.

If a buffer is full, it can be used.

If it is being filled, it can not be used here.

If a buffer is other than full or being filled, it should be sent to be filled

in the correct sequence after the buffer position is determined.

*/

EXPORT_C TInt CAdvancedAudioPlayController::SetPositionInSharedBuffers(TUint aTimeMs, TInt& aFoundPosition, TInt& aFoundTimeMs)

    {

    TInt err = KErrNone;

    TUint position;

    TUint timeMs;

    DP1(_L("CAdvancedAudioPlayController::SetPositionInSharedBuffersL -- start this[%x]"), this);

    for (TInt i = 0; i < iSharedBufferMaxNum; i++)

        {

        DP6(_L("CAdvancedAudioPlayController::SetPositionInSharedBuffersL iSharedBuffers[%d] ptr[%x] FrameNumber[%d] Status[%d] LastBuffer[%d] bufpos[%d]"),

         	i, iSharedBuffers[i]->Data().Ptr(), iSharedBuffers[i]->FrameNumber(), iSharedBuffers[i]->Status(), iSharedBuffers[i]->LastBuffer(), iSharedBuffers[i]->Position());

        if (iSharedBuffers[i]->Status() != EBeingFilled)

            { // reset the positions on the buffers that the source does not have

            iSharedBuffers[i]->SetPosition(0);

            }

        if (iSharedBuffers[i]->Status() == EBeingEmptied)

        	{

	        iSharedBuffers[i]->SetStatus(EFull);

        	}

        }

    timeMs = aTimeMs;

    // get the closest position from the table for the given time

    err = iAudioUtility->FindFramePosFromTime(timeMs, position); // err indicates if position found, or just what was available

	// see if the buffer with this position exists

    iSharedBufferIndex = FindBufferFromPos(position + iHeaderOffset + iSyncOffset);