/*

* Copyright (c) 2008-2009 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:

*

*/

/**

 @file

 @internalComponent

*/

#include <openmax/il/khronos/v1_x/OMX_Audio.h>

#include <d32soundsc.h>

#include "log.h"

#include <openmax/il/common/omxilcallbacknotificationif.h>

#include <openmax/il/common/omxilclockcomponentcmdsif.h>

#include <openmax/il/extensions/omxilsymbianaudiopcmextensions.h>

#include "omxilpcmrendererprocessingfunction.h"

const TInt COmxILPcmRendererProcessingFunction::CPFHelper::KMaxMsgQueueEntries;

COmxILPcmRendererProcessingFunction*

COmxILPcmRendererProcessingFunction::NewL(MOmxILCallbackNotificationIf& aCallbacks, 

										MOmxILClockComponentCmdsIf& aClientClockPort)

	{

    DEBUG_PRINTF(_L8("COmxILPcmRendererProcessingFunction::NewL"));

	COmxILPcmRendererProcessingFunction* self =

		new (ELeave)COmxILPcmRendererProcessingFunction(aCallbacks, aClientClockPort);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void

COmxILPcmRendererProcessingFunction::ConstructL()

	{

    DEBUG_PRINTF(_L8("COmxILPcmRendererProcessingFunction::ConstructL"));

    iAudioDevice = CAudioDevice::NewL(*this);

    iPFHelper = CPFHelper::NewL(*iAudioDevice);

	}

COmxILPcmRendererProcessingFunction::COmxILPcmRendererProcessingFunction(

	MOmxILCallbackNotificationIf& aCallbacks, 

	MOmxILClockComponentCmdsIf& aClientClockPort)

	:

	COmxILProcessingFunction(aCallbacks),

	iClientClockPortPtr(&aClientClockPort)

	{

    DEBUG_PRINTF(_L8("COmxILPcmRendererProcessingFunction::COmxILPcmRendererProcessingFunction"));

	}

COmxILPcmRendererProcessingFunction::~COmxILPcmRendererProcessingFunction()

	{

    DEBUG_PRINTF(_L8("COmxILPcmRendererProcessingFunction::~COmxILPcmRendererProcessingFunction"));

	// Check in case the Sound Device has not been closed. That would happen in

	// an scenario where the component is not being deleted in an orderer way.

	if(iAudioDevice && iPFHelper &&

	   (iState == OMX_StateInvalid   ||

	    iState == OMX_StateExecuting ||

	    iState == OMX_StatePause))

		{

		// Ignore error if the following call fails

		iPFHelper->CloseDeviceOnError();

		}

	// Buffer headers are not owned by the processing function

    iBuffersToEmpty.Close();

    iBuffersEmptied.Close();

    delete iAudioDevice;

    delete iPFHelper;

	}

OMX_ERRORTYPE

COmxILPcmRendererProcessingFunction::StateTransitionIndication(TStateIndex aNewState)

	{

    DEBUG_PRINTF(_L8("COmxILPcmRendererProcessingFunction::StateTransitionIndication"));

    OMX_ERRORTYPE err = OMX_ErrorNone;

	switch(aNewState)

		{

	case EStateExecuting:

		{

		DEBUG_PRINTF(_L8("StateTransitionIndication : OMX_StateExecuting"));

		if (iPFHelper->Execute() != KErrNone)

			{

			return OMX_ErrorInsufficientResources;

			}

		}

		break;

	case EStateInvalid:

		{

		DEBUG_PRINTF(_L8("StateTransitionIndication : OMX_StateInvalid"));

		if (iPFHelper->Stop() != KErrNone)

			{ // InsufficientResources to stop???

			return OMX_ErrorInsufficientResources;

			}

		}

		break;

	case EStatePause:

		{

		DEBUG_PRINTF(_L8("StateTransitionIndication : OMX_StatePause"));

		err = iAudioDevice->MoveToPausedState();

		}

		break;

	case EStateIdle:

		{

		DEBUG_PRINTF(_L8("StateTransitionIndication : OMX_StateIdle"));

		iBuffersToEmpty.Reset();

		if (iPFHelper->Stop() != KErrNone)

			{ // InsufficientResources to stop???

			return OMX_ErrorInsufficientResources;

			}

		}

		break;

	case EStateLoaded:

	case EStateWaitForResources:

		{

		DEBUG_PRINTF(_L8("StateTransitionIndication : OMX_StateLoaded, OMX_StateWaitForResources"));

		if (iPFHelper->Stop() != KErrNone)

			{ // InsufficientResources to stop???

			return OMX_ErrorInsufficientResources;

			}

		}

		break;

	case ESubStateLoadedToIdle:

		{

		DEBUG_PRINTF(_L8("StateTransitionIndication : ESubStateLoadedToIdle"));

		if (iPFHelper->OpenDevice() != KErrNone)

			{

			return OMX_ErrorInsufficientResources;

			}

		}

		break;

	case ESubStateIdleToLoaded:

		{

		DEBUG_PRINTF(_L8("StateTransitionIndication : ESubStateIdleToLoaded"));

		if (iPFHelper->CloseDevice() != KErrNone)

			{ // InsufficientResources to close???

			return OMX_ErrorInsufficientResources;

			}

		}

		break;

	case ESubStateExecutingToIdle:

	case ESubStatePauseToIdle:

		{

		// Ignore these transitions...

		return OMX_ErrorNone;

		}

	default:

		{

		// Always ASSERT; This would be a problem in the framework.

		ASSERT(0);

		return OMX_ErrorIncorrectStateTransition;

		}

		};

	return err;

	}

OMX_ERRORTYPE

COmxILPcmRendererProcessingFunction::BufferFlushingIndication(

	TUint32 aPortIndex,

	OMX_DIRTYPE aDirection)

	{

    DEBUG_PRINTF2(_L8("COmxILPcmRendererProcessingFunction::BufferFlushingIndication : aPortIndex[%d]"), aPortIndex);

    if ((aPortIndex == OMX_ALL && aDirection == OMX_DirMax) ||

		(aPortIndex == KPCMRENDERER_APB0PORT_INDEX && aDirection == OMX_DirInput))

		{

		// If we are currently processing a buffer then cancel

		if (iPFHelper->CancelDevice() != KErrNone)

			{

			return OMX_ErrorInsufficientResources;

			}

		// Send BufferDone notifications for each emptied buffer...

		FlushBufferList(iBuffersEmptied);

	    // Send BufferDone notifications for each pending buffer...

		FlushBufferList(iBuffersToEmpty);

		return OMX_ErrorNone;

		}

	else if (aPortIndex == KPCMRENDERER_OPB0PORT_INDEX && aDirection == OMX_DirInput)

		{

		// Since the clock port buffers are returned immediately, 

		// there's nothing to flush for the port

		return OMX_ErrorNone;

		}

	else

		{

		// Always ASSERT; This would be a problem in the framework.

		ASSERT(0);

		return OMX_ErrorBadParameter;

		}

	}

void

COmxILPcmRendererProcessingFunction::FlushBufferList(

	RPointerArray<OMX_BUFFERHEADERTYPE>& aBufferList)

	{

    DEBUG_PRINTF2(_L8("COmxILPcmRendererProcessingFunction::FlushBufferList : [%s]"),

				  &aBufferList == &iBuffersToEmpty ? "iBuffersToEmpty" : "iBuffersEmptied");

	const TUint bufferCount = aBufferList.Count();

	OMX_BUFFERHEADERTYPE* pBufferHeader = 0;

	// We know there is only one input port...

	OMX_DIRTYPE portDirection = OMX_DirInput;

	for (TUint i=0; i<bufferCount; ++i)

		{

		pBufferHeader = aBufferList[i];

		pBufferHeader->nFilledLen = 0;

		iCallbacks.

			BufferDoneNotification(

				pBufferHeader,

				pBufferHeader->nInputPortIndex,

				portDirection

				);

		}

	// Empty buffer list...

	aBufferList.Reset();

	}

OMX_ERRORTYPE

COmxILPcmRendererProcessingFunction::ParamIndication(

	OMX_INDEXTYPE aParamIndex,

	const TAny* apComponentParameterStructure)

	{

    DEBUG_PRINTF(_L8("COmxILPcmRendererProcessingFunction::ParamIndication"));

    OMX_ERRORTYPE err = OMX_ErrorNone;

    switch(aParamIndex)

	{

	case OMX_IndexParamAudioPcm:

		{

		const OMX_AUDIO_PARAM_PCMMODETYPE* pPcmProfile

			= static_cast<const OMX_AUDIO_PARAM_PCMMODETYPE*>(

				apComponentParameterStructure);

		if((pPcmProfile->nChannels == 1 || pPcmProfile->nChannels == 2) &&

		  (pPcmProfile->eNumData == OMX_NumericalDataSigned) &&

		  (pPcmProfile->eEndian == OMX_EndianBig) &&

		  (pPcmProfile->bInterleaved == OMX_TRUE) &&

		  (pPcmProfile->nBitPerSample == 16) &&

		  ((pPcmProfile->nSamplingRate == 8000)  ||

		   (pPcmProfile->nSamplingRate == 11025) ||

		   (pPcmProfile->nSamplingRate == 12000) ||

		   (pPcmProfile->nSamplingRate == 16000) ||

		   (pPcmProfile->nSamplingRate == 22050) ||

		   (pPcmProfile->nSamplingRate == 24000) ||

		   (pPcmProfile->nSamplingRate == 32000) ||

		   (pPcmProfile->nSamplingRate == 44100) ||

		   (pPcmProfile->nSamplingRate == 48000)) &&

		  (pPcmProfile->ePCMMode == OMX_AUDIO_PCMModeLinear) &&

		  (pPcmProfile->eChannelMapping[0] == OMX_AUDIO_ChannelLF) &&

		  (pPcmProfile->eChannelMapping[1] == OMX_AUDIO_ChannelRF))

			{

			if (iPFHelper->ParamIndication(pPcmProfile) != KErrNone)

				{

				err = OMX_ErrorInsufficientResources;

				}

			}

		else

			{

			err = OMX_ErrorBadParameter;

			}

		}

		break;

	default:

		{

		// Ignore other port param changes...

		}

	};

	return err;

	}

OMX_ERRORTYPE

COmxILPcmRendererProcessingFunction::ConfigIndication(OMX_INDEXTYPE aConfigIndex,

													  const TAny* apComponentConfigStructure)

	{

    DEBUG_PRINTF2(_L8("COmxILPcmRendererProcessingFunction::ConfigIndication %X"), aConfigIndex);

    OMX_ERRORTYPE err = OMX_ErrorNone;

    switch(aConfigIndex)

	{

	case OMX_SymbianIndexConfigAudioPcmVolumeRamp:

		{

		const OMX_SYMBIAN_AUDIO_CONFIG_PCM_VOLUMERAMP*

			pPcmVolumeRamp

			= static_cast<

			const OMX_SYMBIAN_AUDIO_CONFIG_PCM_VOLUMERAMP*>(

					apComponentConfigStructure);

		if (iPFHelper->SetVolumeRamp(pPcmVolumeRamp->nRampDuration) != KErrNone)

			{

			err = OMX_ErrorInsufficientResources;

			}

		}

		break;

	case OMX_IndexConfigAudioVolume:

		{

		const OMX_AUDIO_CONFIG_VOLUMETYPE* pVolumeType

			= static_cast<const OMX_AUDIO_CONFIG_VOLUMETYPE*>(

					apComponentConfigStructure);

        if (pVolumeType->bLinear == OMX_TRUE)

            {

            // Some configuration structures contain read-only fields. The 

            // OMX_SetConfig method will preserve read-only fields in configuration

            // structures that contain them, and shall not generate an error when 

            // the caller attempts to change the value of a read-only field.

            err = OMX_ErrorNone;

            break;

            }

		if ((pVolumeType->sVolume.nValue <= pVolumeType->sVolume.nMax) &&

		   (pVolumeType->sVolume.nValue >= pVolumeType->sVolume.nMin))

			{

			if (iPFHelper->SetVolume(pVolumeType->sVolume.nValue) != KErrNone)

				{

				err = OMX_ErrorInsufficientResources;

				}

			}

		else

			{

			err = OMX_ErrorBadParameter;

			}

		}

		break;

	case OMX_IndexConfigAudioMute:

		{

		const OMX_AUDIO_CONFIG_MUTETYPE* pVolumeType

		= static_cast<const OMX_AUDIO_CONFIG_MUTETYPE*>(

				apComponentConfigStructure);

		if (iPFHelper->SetMuted(pVolumeType->bMute) != KErrNone)

			{

			err = OMX_ErrorInsufficientResources;

			}

		}

		break;

	default:

		{

		// Ignore other port config changes...

		}

	};

	return err;

	}

OMX_ERRORTYPE

COmxILPcmRendererProcessingFunction::BufferIndication(

	OMX_BUFFERHEADERTYPE* apBufferHeader,

	OMX_DIRTYPE aDirection)

	{

    DEBUG_PRINTF2(_L8("COmxILPcmRendererProcessingFunction::BufferIndication : [%X]"), apBufferHeader);

	if (aDirection != OMX_DirInput)

		{

		return OMX_ErrorBadParameter;

		}

	if (iBuffersToEmpty.Append(apBufferHeader) != KErrNone)

		{

		return OMX_ErrorInsufficientResources;

		}

	// If we are not in an executing state or if the audio device is busy, delay playing back the buffer

	if (iState != OMX_StateExecuting || iAudioDevice->IsActive())

		{

		return OMX_ErrorNone;

		}

	if (iPFHelper->BufferIndication() != KErrNone)

		{

		return OMX_ErrorInsufficientResources;

		}

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE COmxILPcmRendererProcessingFunction::MediaTimeIndication(const OMX_TIME_MEDIATIMETYPE& aMediaTimeType)

	{

	// Received a requested media time notification.

	DEBUG_PRINTF5(_L8("MediaTimeIndication : eUpdateType = %d eState = %d xScale = %d nMediaTimestamp = %d "), 

						aMediaTimeType.eUpdateType, aMediaTimeType.eState, aMediaTimeType.xScale, aMediaTimeType.nMediaTimestamp);

	iPFHelper->MediaTimeIndication(aMediaTimeType);

	return OMX_ErrorNone;

	}

OMX_BOOL

COmxILPcmRendererProcessingFunction::BufferRemovalIndication(

	OMX_BUFFERHEADERTYPE* apBufferHeader,

	OMX_DIRTYPE /* aDirection */)

	{

    DEBUG_PRINTF2(_L8("COmxILPcmRendererProcessingFunction::BufferRemovalIndication : BUFFER [%X]"), apBufferHeader);

    TBool headerDeletionResult = ETrue;

    // Check if the buffer we want to remove is the one is being currently processed

    if (iAudioDevice->IsActive() && iAudioDevice->GetCurrentBuffer() == apBufferHeader)

		{

		if (iPFHelper->CancelDevice() != KErrNone)

			{

			return OMX_FALSE;

			}

		// if you cancel the audio device then you send the buffer to the other end of the tunnel

		// so you shouldn't say that you had the buffer in the processing function in this situation.

		headerDeletionResult = EFalse;

		}

    else

		{

		TInt headerIndexInArray = KErrNotFound;

		if (KErrNotFound !=

			(headerIndexInArray =

			 iBuffersToEmpty.Find(apBufferHeader)))

			{

			iBuffersToEmpty.Remove(headerIndexInArray);

			}

		else if(KErrNotFound !=

				(headerIndexInArray =

				 iBuffersEmptied.Find(apBufferHeader)))

			{

			iBuffersEmptied.Remove(headerIndexInArray);

			}

		else

			{

			headerDeletionResult = EFalse;

			}

		}

    DEBUG_PRINTF2(_L8("BufferRemovalIndication : Removal result [%s]"), (headerDeletionResult ? "YES" : "NO"));

    return (headerDeletionResult ? OMX_TRUE : OMX_FALSE);

	}

TInt

COmxILPcmRendererProcessingFunction::GetBytesPlayed() const

	{

	return iAudioDevice->GetBytesPlayed();

	}

COmxILPcmRendererProcessingFunction::CAudioDevice* COmxILPcmRendererProcessingFunction::CAudioDevice::NewL(COmxILPcmRendererProcessingFunction& aParent)

	{

	CAudioDevice* self = new (ELeave) CAudioDevice(aParent);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

COmxILPcmRendererProcessingFunction::CAudioDevice::CAudioDevice(COmxILPcmRendererProcessingFunction& aParent)

: CActive(EPriorityUserInput),

  iParent(aParent),

  iSampleRate(KDefaultSampleRate),

  iChannels(KDefaultNumberChannels),

  iEncoding(KDefaultEncoding),

  iVolume(KDefaultVolume),

  iMuted(KDefaultMuted),

  iBufferSize(KBufferSize),

  iClockStateRunning(EFalse),

  iPausedClockViaScale(EFalse),

  iIsStartTimeFlagSet(EFalse)

	{

	CActiveScheduler::Add(this);

	}

void COmxILPcmRendererProcessingFunction::CAudioDevice::ConstructL()

    {

	iCachedPlayBuffer.CreateL(0);

	}

COmxILPcmRendererProcessingFunction::CAudioDevice::~CAudioDevice()

	{

	delete iPeriodic;

	Cancel();

	iCachedPlayBuffer.Close();

	}

void COmxILPcmRendererProcessingFunction::CAudioDevice::RunL()

	{

	DEBUG_PRINTF(_L8("CAudioDevice::RunL : "));

	if (iStatus != KErrNone)

		{

		switch(iStatus.Int())

			{

		case KErrUnderflow:

			DEBUG_PRINTF(_L8("CAudioDevice::RunL : KErrUnderflow"));

			iParent.iCallbacks.ErrorEventNotification(OMX_ErrorUnderflow);

			break;

		case KErrOverflow:

			DEBUG_PRINTF(_L8("CAudioDevice::RunL : KErrOverflow"));