/*

* 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:  The functions in this module implements the common behavior

*                for the audio decoder base class.

*

*/

// INCLUDE FILES

#include "AdvancedAudioDecoder.h"

#include "DebugMacros.h"

#include <mmfdatabuffer.h>

// CONSTANTS

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

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

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

// might leave.

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

//

EXPORT_C CAdvancedAudioDecoder::CAdvancedAudioDecoder(

	TInt aPriority)

    :   CActive(aPriority),

    	iState(EIdle),

        iSharedBuffers(NULL),

        iMMFDevSound(NULL),

    	iObserver(NULL)

    {

    DP0(_L("CAdvancedAudioDecoder::CAdvancedAudioDecoder()"));

    iDecoderUtilityObserver = NULL;

    iFrameTable = NULL;

    }

// Destructor

EXPORT_C CAdvancedAudioDecoder::~CAdvancedAudioDecoder()

	{

    DP0(_L("CAdvancedAudioDecoder::~CAdvancedAudioDecoder()"));

	iRenderEnableConfig.Close();

	iRenderDisableConfig.Close();

	iMarkPlayEndConfig.Close();

	iUnMarkPlayEndConfig.Close();

	iEnableConfig.Close();

	iDisableConfig.Close();

	delete iConvertBuffer;

	delete iChannelAndSampleRateConverterFactory;

	}

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

// CAdvancedAudioDecoder::SetDevSound

// Sets the DevSound instance.

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

//

EXPORT_C void CAdvancedAudioDecoder::SetDevSound(

	CMMFDevSound& aDevSound)

	{

	iMMFDevSound = &aDevSound;

	}

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

// CAdvancedAudioDecoder::SetObserver

// Sets the observer instance.

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

//

EXPORT_C void CAdvancedAudioDecoder::SetObserver(

	MAdvancedAudioDecoderObserver& aObserver)

	{

	iObserver = &aObserver;

	}

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

// CAdvancedAudioDecoder::SetDecoderUtilityObserver

// Sets the observer instance.

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

//

EXPORT_C void CAdvancedAudioDecoder::SetDecoderUtilityObserver(MAdvancedAudioDecoderUtilityObserver& aDecoderUtilityObserver)

	{

	iDecoderUtilityObserver = &aDecoderUtilityObserver;

	}

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

// CAdvancedAudioDecoder::SetSourceBuffers

// Sets the source buffer for conversion operations.

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

//

EXPORT_C void CAdvancedAudioDecoder::SetSourceBuffers(

	RPointerArray<CMMFDataBuffer>* aBuffers)

	{

	iSharedBuffers = aBuffers;

	}

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

// CAdvancedAudioDecoder::SetConfigL

// Sets audio decoder settings and attributes

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

//

EXPORT_C void CAdvancedAudioDecoder::SetConfigL(

    TUint aSourceSampleRate,

    TUint aSourceChannels,

    TUint aSWConvertSampleRate,

    TUint aSWConvertChannels,

    const RArray<TInt>& aCodecConfigData,

    TInt aIndex)

    {

    DP0(_L("CAdvancedAudioDecoder::SetConfigL"));

	CodecConfig(const_cast<RArray<TInt>&>(aCodecConfigData));

	QueueThisBuffer(aIndex); // will set iNextBuffer (current buffer) and update iSharedBufferIndex (to next buffer)

   	if(aSourceSampleRate != aSWConvertSampleRate && !IsHwAccelerated())  // Sampling Rate Conversion is needed

   		{

	    if (!iChannelAndSampleRateConverterFactory)

			{

		    iChannelAndSampleRateConverterFactory = new(ELeave) CMMFChannelAndSampleRateConverterFactory;

	    	iChannelAndSampleRateConverter = iChannelAndSampleRateConverterFactory->CreateConverterL(aSourceSampleRate, aSourceChannels,

		                                                                                         aSWConvertSampleRate, aSWConvertChannels);

		    }

		iNeedsSWConversion = ETrue;

    	}

	Enable();

    }

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

// CAdvancedAudioDecoder::FillBuffer

// Request to fill the specified buffer with converted data.

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

//

EXPORT_C void CAdvancedAudioDecoder::FillBufferL(

	CMMFBuffer* aBuffer)

	{

    DP0(_L("CAdvancedAudioDecoder::FillBufferL"));

	iBufferToFill = aBuffer;

	iState = EDecoding;

	iStatus = KRequestPending; // service request would be made here and pending set by service provider

    SetActive();

	Ready(KErrNone);

	}

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

// CAdvancedAudioDecoder::Stop

// Stops decoding process.

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

//

EXPORT_C void CAdvancedAudioDecoder::Stop()

	{

    DP0(_L("CAdvancedAudioDecoder::Stop"));

	iState = EIdle;

	Disable();

	RenderEnable();

	iEventPos = 0;

	// cancel any outstanding FrameTable Seeking event callback

	if (iFrameTable)

	    {

	    TInt err = iFrameTable->UnRegisterForEvent(CFrameTable::EPosReached, this);

	    // Fix for the error ou1cimx1#137567 - SXUU-7S9SLD

	    //TInt err1 = iFrameTable->UnRegisterForEvent(CFrameTable::EPlayWindowEndPosReached, this);

	    //if (err|err1 != KErrNone)

	    if (err != KErrNone)

	        {

            //DP2(_L("CAdvancedAudioDecoder::Stop, UnRegisterForEvent errs[%d][%d]"), err, err1);

	        DP1(_L("CAdvancedAudioDecoder::Stop, UnRegisterForEvent err[%d]"), err);

	        }

	    }	

	}

EXPORT_C TInt CAdvancedAudioDecoder::SetSourceReference(TUint aTimeMs, TUint aPos)

	{

    if (!iFrameTable)

        return KErrNotSupported;

    return iFrameTable->SetSourceReference(aTimeMs, aPos);

	}

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

// CAdvancedAudioDecoder::FindFramePosFromTime

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

//

EXPORT_C TInt CAdvancedAudioDecoder::FindFramePosFromTime(TUint& aTimeMs, TUint& aPos)

	{

    if (!iFrameTable)

        return KErrNotSupported;

    return iFrameTable->FindFramePosFromTime(aTimeMs, aPos);

	}

EXPORT_C TInt CAdvancedAudioDecoder::FindFrameTimeFromPos(TUint& aTime, TUint& aPos)

    {

    if (!iFrameTable)

        return KErrNotSupported;

    return iFrameTable->FindFrameTimeFromPos(aTime, aPos);

    }

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

// CAdvancedAudioDecoder::LastFramePos

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

//

EXPORT_C TInt CAdvancedAudioDecoder::LastFramePos(TUint& aPos)

	{

    if (!iFrameTable)

        return KErrNotSupported;

    return iFrameTable->LastFramePos(aPos);

	}

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

// CAdvancedAudioDecoder::LastFrameTime

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

//

EXPORT_C TInt CAdvancedAudioDecoder::LastFrameTime(TUint& aTimeMs)

	{

    if (!iFrameTable)

        return KErrNotSupported;

    return iFrameTable->LastFrameTime(aTimeMs);

	}

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

// CAdvancedAudioDecoder::ResetTable

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

//

EXPORT_C TInt CAdvancedAudioDecoder::ResetTable()

	{

    if (!iFrameTable)

        return KErrNotSupported;

    iFrameTable->ResetTable();

    return KErrNone;

	}

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

// CAdvancedAudioDecoder::SeekToTimeMs

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

//	

EXPORT_C TInt CAdvancedAudioDecoder::SeekToTimeMs(TUint aTimeMs)

	{

    if (!iFrameTable)

        return KErrNotSupported;

    if (aTimeMs == KMaxTUint)

        {

        // Only other place that we unregister is when we stop the decoder.

        // Here we need to unregister explicitly such as when there is an outstanding

        // seek and we seek again, but if we are not playing yet, we won't stop the output

        // and unregister outstanding events by stopping the output.

        DP0(_L("CAdvancedAudioDecoder::SeekToTimeMs unregistering events"));

        TInt status1 = iFrameTable->UnRegisterForEvent(CFrameTable::EPosReached, this);

        return status1;

        }

    RenderDisable();

    iSeekToTimeMs = aTimeMs;

    return iFrameTable->RegisterForEvent(CFrameTable::EPosReached, this, aTimeMs);

	}

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

// CAdvancedAudioDecoder::SetPlayEndTimeMs

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

//	

EXPORT_C TInt CAdvancedAudioDecoder::SetPlayWindowEndTimeMs(TUint aTimeMs)

	{

	TInt status = KErrNotSupported;

    if (iFrameTable)

    	{

	    if (aTimeMs == 0)

    		{

	    	status = iFrameTable->UnRegisterForEvent(CFrameTable::EPlayWindowEndPosReached, this);

	    	}

    	else

	    	{

    		status = iFrameTable->RegisterForEvent(CFrameTable::EPlayWindowEndPosReached, this, aTimeMs);

    		}	

    	}

    return status;

	}

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

// CAdvancedAudioDecoder::BitRate

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

//	

EXPORT_C TInt CAdvancedAudioDecoder::BitRate()

	{

	if (!iFrameTable)

        return KErrNotSupported;

	return iFrameTable->Bitrate();

	}

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

// CAdvancedAudioDecoder::EnableDecodeIntervalEvent

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

//	

EXPORT_C TInt CAdvancedAudioDecoder::EnableDecodeIntervalEvent(TBool aEnable, TUint aTimeMs)

	{

    if (!iFrameTable)

        return KErrNotSupported;

    else

	    {

    	if (aEnable)

            return iFrameTable->RegisterForEvent(CFrameTable::EDecodeInterval, this, aTimeMs);

        else

            return iFrameTable->UnRegisterForEvent(CFrameTable::EDecodeInterval, this);

    	}

    }

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

// CAdvancedAudioDecoder::HandleFrameTableEvent

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

//	

EXPORT_C TInt CAdvancedAudioDecoder::HandleFrameTableEvent(CFrameTable::TFrameTableEvent aEvent)

	{

	TInt status = KErrNone;

	switch (aEvent)

		{

		case CFrameTable::EPlayWindowEndPosReached:

		case CFrameTable::EPosReached:

			RenderEnable();

		    if (iDecoderUtilityObserver)

		        {

		        if (aEvent == CFrameTable::EPosReached)

		        	{

		            DP0(_L("CAdvancedAudioDecoder::HandleFrameTableEvent, EPosReached"));

			        // to allow the iTimePositionInMicroSecs to be updated to seek time in controller

					TInt offsets;

					TUint pos;

					status = iDecoderUtilityObserver->GetOffsets(offsets);

					status = iFrameTable->GetLastPosEvent(pos);

		            DP2(_L("CAdvancedAudioDecoder::HandleFrameTableEvent, pos = %U, offsets = %U"),pos,offsets);

					iEventPos = pos + offsets;

   					iDecoderUtilityObserver->SeekPositionReached(iSeekToTimeMs);

		        	}

		        else

		        	{ // play window end

                    DP0(_L("CAdvancedAudioDecoder::HandleFrameTableEvent play window end reached"));

   					iDecoderUtilityObserver->PlayWindowEndPositionReached();

   					MarkPlayEnd();

		        	}

		        }

			break;

		case CFrameTable::EDecodeInterval:

            DP0(_L("CAdvancedAudioDecoder::HandleFrameTableEvent, EDecodeInterval"));

		    if (iDecoderUtilityObserver)

		        {

			    iDecoderUtilityObserver->DecodeIntervalEvent();

		        }

			break;

		default:

		    User::Panic(_L("CAdvancedAudioDecoder::HandleFrameTableEvent, Unexpected event"), KErrArgument);

		    break;

		}

	return status;

	}

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

// CAdvancedAudioDecoder::Ready

// Utility function to post a request complete

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

//

void CAdvancedAudioDecoder::Ready(

    const TInt aStatus)

    {

    TRequestStatus* stat = &iStatus;

    User::RequestComplete(stat, aStatus);

    }

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

// CAdvancedAudioDecoder::QueueThisBuffer

// gets buffer at aBufferIndex ready for decoding

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

//

EXPORT_C void CAdvancedAudioDecoder::QueueThisBuffer(TUint aBufferIndex)

	{

    iNextBuffer = (*iSharedBuffers)[aBufferIndex];

    DP4(_L("CAdvancedAudioDecoder::QueueThisBuffer, Index[%d] [%x] last[%d] pos[%d]"), 

   			aBufferIndex, static_cast<CMMFDataBuffer*>(iNextBuffer)->Data().Ptr(), iNextBuffer->LastBuffer(), iNextBuffer->Position());

    iSharedBufferIndex = aBufferIndex + 1;

    if (iSharedBufferIndex == iSharedBuffers->Count())

     	{

   	    iSharedBufferIndex = 0;

       	}

    iFrameTable->ShrinkTable();

	}

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

// CAdvancedAudioDecoder::NextSharedBufferL

// Determine the next available shared buffer from the pool of shared buffers

// iNextBuffer is actually the current buffer in use

// iSharedBufferIndex points to the next buffer to be used

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

//

void CAdvancedAudioDecoder::NextSharedBufferL()

    {

    CMMFBuffer* refillBuffer = NULL;

    // index is the next buffer, index-1 is current buffer, check 2 buffers back from the one being selected

// ou1cimx1#205863    

    //TInt checkBufIndex = iSharedBufferIndex-2;

    TInt checkBufIndex = iSharedBufferIndex- (iSharedBuffers->Count()-1) ;

    if (checkBufIndex < 0)

    	{

        checkBufIndex = checkBufIndex+iSharedBuffers->Count();

    	}

    if ((*iSharedBuffers)[checkBufIndex]->Status() == EBeingEmptied)

        {

// ou1cimx1#205863

/*        if (iSharedBuffers->Count() <= 2)

            {

            DP1(_L("CAdvancedAudioDecoder::NextSharedBufferL leave, EBeingEmptied is used on Count[%d]"), iSharedBuffers->Count());

            User::Leave(KErrAbort);

            }

*/            

        DP2(_L("CAdvancedAudioDecoder::NextSharedBufferL, index[%d] [%x] is EBeingEmptied"), 

            	checkBufIndex, static_cast<CMMFDataBuffer*>((*iSharedBuffers)[checkBufIndex])->Data().Ptr() );

        refillBuffer = (*iSharedBuffers)[checkBufIndex];

	    }

	if (refillBuffer)

		{

    	iObserver->RefillBuffer(refillBuffer);

		}

    if ((*iSharedBuffers)[iSharedBufferIndex]->Status() == EFull)

   	    {

        QueueThisBuffer(iSharedBufferIndex);

   	    DP1(_L("CAdvancedAudioDecoder::NextSharedBufferL, After Increment, index[%d]"), iSharedBufferIndex);

     	}

   	else

   		{

       	DP2(_L("CAdvancedAudioDecoder::NextSharedBufferL - not ready, Index[%d] [%x]"),

       					iSharedBufferIndex, static_cast<CMMFDataBuffer*>((*iSharedBuffers)[iSharedBufferIndex])->Data().Ptr() );

        QueueThisBuffer(iSharedBufferIndex); // we should still have the buffer ready to be used when it is filled

        User::Leave(KErrBufferNotReady);

   	 	}

    }

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

// CAdvancedAudioDecoder::RunL

// Invoke by the active scheduler when a request completes

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

//

EXPORT_C void CAdvancedAudioDecoder::RunL()

	{

    DP0(_L("CAdvancedAudioDecoder::RunL"));

	if (iState == EDecoding)

		{

		TRAPD(err,HandleFillBufferL());

		if (err) // if error is encountered, an event is generated and the playback is paused.

			{

			iObserver->SendEvent(TMMFEvent(KMMFEventCategoryPlaybackComplete, err));

			}

		}

	}

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

// CAdvancedAudioDecoder::HandleFillBufferL

// Handle the request to fill the specified buffer with converted data.

// Fill next buffer with audio data. If soft codec, data must first be decoded.

// If source buffer is depleted, a request to the controller is sent to refill

// the buffer with more data and the next source buffer is used.

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

//

EXPORT_C void CAdvancedAudioDecoder::HandleFillBufferL()

	{

    DP3(_L("CAdvancedAudioDecoder::HandleFillBufferL ptr[%x] iRenderEnabled[%d] Position[%d]"), static_cast<CMMFDataBuffer*>(iNextBuffer)->Data().Ptr(), iRenderEnabled, iNextBuffer->Position());

    DP3(_L("CAdvancedAudioDecoder::HandleFillBufferL frm#[%d] d0[%x] dp[%x]"), static_cast<CMMFDataBuffer*>(iNextBuffer)->FrameNumber(), static_cast<CMMFDataBuffer*>(iNextBuffer)->Data().Ptr()[0],

     static_cast<CMMFDataBuffer*>(iNextBuffer)->Data().Ptr()[iNextBuffer->Position()]);

// ou1cimx1#205863

//    iBufferToFill->SetPosition(0);

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

    iBufferToFill->SetLastBuffer(EFalse);

    TCodecProcessResult result;

    TBool moreProcessing = ETrue;

    while (moreProcessing)

        {

        TRAPD(err, result = ProcessL(*iNextBuffer, *iBufferToFill));

        DP4(_L ("CAdvancedAudioDecoder::HandleFillBufferL - ProcessL stat[%d] result[%d] iEnabled[%d] iMarkPlayEnd[%d]"),

                err, result, iEnabled, iMarkPlayEnd);

   		if (!iEnabled)

            { // output buffers are invalid when stopped - don't use them

	        DP0(_L ("CAdvancedAudioDecoder::HandleFillBufferL - disabled - returning"));

            return;

            }

        if (err != 0)

            {

            if (err == KErrCorrupt)

                { // go ahead and use corrupt if the codec determines the data is corrupt.

                User::Leave(KErrCorrupt);

                }

            else

                { // don't use KErrDied or controller will pause

                User::Leave(KErrGeneral);

                }

            }

		if (iMarkPlayEnd)

			{