// Copyright (c) 2005-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:
// source\server\MmfBtSwCodecPlayDatapath.cpp
// 
//

#include "mmfBtSwCodecPlayDataPath.h"
#include "mmfbtswcodecwrapper.h"
#include "mmfbtswcodecwrappercustominterfacesuids.hrh"
#include <mmfpaniccodes.h>
#include "mmfBtSwCodecUtility.h"

#include "MMFBtRoutingSoundDevice.h"
#include "A2dpBTHeadsetAudioIfClientServer.h" // for TRange (will be deprecated)

CMMFSwCodecPlayDataPath* CMMFSwCodecPlayDataPath::NewL(	CRoutingSoundPlayDevice* aSoundDevice,
														TUid aDeviceUid)
	{
	CMMFSwCodecPlayDataPath* self = new(ELeave) CMMFSwCodecPlayDataPath(aSoundDevice,
																		aDeviceUid);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self;
	}


void CMMFSwCodecPlayDataPath::ConstructL()
	{
	iAudioPlayer = new (ELeave) CDataPathPlayer(*this,CActive::EPriorityUserInput);
	iSoundDeviceErrorReceiver = new (ELeave) CSoundDevPlayErrorReceiver(*this, CActive::EPriorityUserInput);
	iUtility = CMMFSwCodecUtility::NewL();
	}


CMMFSwCodecPlayDataPath::~CMMFSwCodecPlayDataPath()
	{
	delete iAudioPlayer;
	delete iSoundDeviceErrorReceiver;
	delete iUtility;

	TRequestStatus status;
	iSoundDevice->CloseDevice(iDeviceUid, status);
	//TODO there should be a timeout for the line below
	User::WaitForRequest(status);

	if (iCodec)
		{
		delete iSourceBuffer;
		if (!iCodec->IsNullCodec()) 
			{
			delete iSoundDeviceBuffer;
			}
		}

#ifdef __USE_MMF_TRANSFERBUFFERS__
	delete iTransferWindow;

	if(iTransferBuffer)
		{
		iTransferBuffer->Close();
		delete iTransferBuffer;
		}
#endif

#ifdef __USE_MMF_PTRBUFFERS__
	delete iPtrBufferMemoryBlock;
#endif
	}


TInt CMMFSwCodecPlayDataPath::SetObserver(MMMFHwDeviceObserver& aObserver)
	{
	TInt error;
	if (iHwDeviceObserver)
		{
		error =  KErrAlreadyExists;
		}
	else
		{
		iHwDeviceObserver = &aObserver;
		error  = KErrNone;
		}
	return error;
	}


TInt CMMFSwCodecPlayDataPath::AddCodec(CMMFSwCodec& aCodec)
	{
	if (iCodec)
		{
		return KErrNotSupported; //doesn't support multiple codecs		
		}

	TInt err = KErrNone;
	
	iCodec = &aCodec;

	// Allocate data buffer
	iSourceBufferSize = iCodec->SourceBufferSize();
	iSoundDevBufferSize = iCodec->SinkBufferSize();

	if ((!iSourceBufferSize) || (!iSoundDevBufferSize))
		{
		err = KErrArgument; //codec plugin has not specified buffer size		
		}

	if (err == KErrNone)
		{
#ifdef __USE_MMF_TRANSFERBUFFERS__
		TRAP(err,iSourceBuffer = CreateTransferBufferL(iSourceBufferSize, static_cast<CMMFTransferBuffer*>(iSourceBuffer)));
#endif
#ifdef __USE_MMF_PTRBUFFERS__
		TRAP(err,iSourceBuffer = CreatePtrBufferL(iSourceBufferSize));
#else
		TRAP(err,iSourceBuffer = CMMFDataBuffer::NewL(iSourceBufferSize));
#endif
		}
	
	if (err == KErrNone)
		{
		if (iCodec->IsNullCodec())
			{//use source buffer for sound device buffer	
			iSoundDeviceBuffer = NULL;
			}
		else
			{//codec needs separate source and sound device buffers
			TRAP(err,iSoundDeviceBuffer = CMMFDataBuffer::NewL(iSoundDevBufferSize));
			}
		}
	return err;
	}


TInt CMMFSwCodecPlayDataPath::Start()
	{
	TInt startError = KErrNone;

	if (!iCodec || (!iSoundDevice->Handle()))
		{
		//check that a codec has been added and the sound device is open
		startError = KErrNotReady;
		}

	if (iState == EPaused)
		{//we are paused so need to resume play
		if (!startError)
			{
#ifdef _SCW_DEBUG
			RDebug::Print(_L("CMMFSwCodecPlayDataPath::Start-Resume"));
#endif
			iAudioPlayer->ResumePlaying();
			iState = EPlaying;
			}
		}
	else if (!startError)
		{
#ifdef _SCW_DEBUG
		RDebug::Print(_L("CMMFSwCodecPlayDataPath::Start-Normal"));
#endif
		if (!startError)
			{
			iNoMoreSourceData = EFalse;
			iSourceBuffer->SetLastBuffer(EFalse);
			iState = EPlaying;
			iSoundDeviceErrorReceiver->Start();
			TRAP(startError, FillSourceBufferL()); //get initial buffer of audio data
			if (startError == KErrNone)
				{
				// Start the player objects
				iAudioPlayer->Start();
				}
			else
				{//failed to start up correctly go back to stopped state
				iState = EStopped;
				iSoundDeviceErrorReceiver->Stop();
				}
			}
   		}
	return startError;
	}


// *** Main Play Loop ***

void CMMFSwCodecPlayDataPath::FillSourceBufferL()
	{//asks observer to fill the source buffer          
    // Ask immediately for data from the observer
#ifdef __CYCLE_MMF_DATABUFFERS__
	// Create a new buffer to replicate INC021405 Play-EOF-Play on HwAccelerated solution Panics
	// If the creation fails, we carry on regardless as the original buffer will not have been 
	// destroyed. Must do this as alloc fail tests will not run.
	if(iSourceBuffer)
		{
		iSourceBuffer = CycleAudioBuffer(iSourceBuffer);
		}
#endif // __CYCLE_MMF_DATABUFFERS__	
	User::LeaveIfError(iHwDeviceObserver->FillThisHwBuffer(*iSourceBuffer));
	
	}


void CMMFSwCodecPlayDataPath::BufferFilledL(CMMFDataBuffer& aBuffer)
	{//call back from observer to indicate buffer has been filled
	if (iState == EStopped)
		User::Leave(KErrNotReady);//ok if paused?

	iSourceBuffer = &aBuffer;
	iSourceBuffer->SetStatus(EFull);
#ifdef _SCW_DEBUG
	RDebug::Print(_L("CMMFSwCodecPlayDataPath::BufferFilledL"));
#endif

	//need to check that the buffer size is not 0 - if so assume we've reached the end of the data
	if (!iSourceBuffer->BufferSize())
		{//no buffer  - could be end of source or could be that the source has no data??
		iNoMoreSourceData = ETrue;
#ifdef _SCW_DEBUG
		RDebug::Print(_L("CMMFSwCodecPlayDataPath::BufferFilledL-NoMoreSourceData"));
#endif
		}
	//even if the buffer size is 0 we still 
	//need to perform the following to get the sound device callback
	FillSoundDeviceBufferL(); //get buffer in pcm16 format for sound device	

    // attenuate the amplitude of the samples if volume ramping has been changed
	// and is non-zero
	if (iCustomInterface)
		{
		TTimeIntervalMicroSeconds volumeRamp = iCustomInterface->VolumeRamp();
		if (volumeRamp != iVolumeRamp)
			{
			iVolumeRamp = volumeRamp;
			if (iVolumeRamp.Int64() != 0)
				{
				iUtility->ConfigAudioRamper(
					iVolumeRamp.Int64(), 
					iSampleRate, 
					iChannels);
				iRampAudioSample = ETrue;
				}
			else
				{
				iRampAudioSample = EFalse;
				}
			}
			if (iRampAudioSample)
				{
				iRampAudioSample = iUtility->RampAudio(iSoundDeviceBuffer);
				}
		}

	iAudioPlayer->PlayData(*iSoundDeviceBuffer); //play data to sound drivers

	if (iSourceBuffer->LastBuffer())//check last buffer flag
		{
		iNoMoreSourceData = ETrue;
#ifdef _SCW_DEBUG
		RDebug::Print(_L("CMMFSwCodecPlayDataPath::BufferFilledL-LBNoMoreSourceData"));
#endif
		}
	}


void CMMFSwCodecPlayDataPath::FillSoundDeviceBufferL()
	{//use CMMFSwCodec to fill the sound device buffer
	
	CMMFSwCodec::TCodecProcessResult codecProcessResult;

	if (iCodec->IsNullCodec())
		{//no codec so data can be sent direct to sink
		iSoundDeviceBuffer = iSourceBuffer;
		iSoundDeviceBuffer->SetStatus(EFull);	//sink buffer is full
		}	
	else 
		{	
		//pass buffer to codec for processing
		codecProcessResult = iCodec->ProcessL(*iSourceBuffer, *iSoundDeviceBuffer);
		if (iSourceBuffer->LastBuffer()) //if source is last buffer so is sound dev
			iSoundDeviceBuffer->SetLastBuffer(ETrue);
		if ((!iSoundDeviceBuffer->BufferSize())&&(codecProcessResult.iDstBytesAdded))
			{//the codec has added data but not set the buffer length
			iSoundDeviceBuffer->Data().SetLength(codecProcessResult.iDstBytesAdded);
			}
		//only supports EProcessComplete
		switch (codecProcessResult.iCodecProcessStatus)
			{
		case CMMFSwCodec::TCodecProcessResult::EProcessComplete:
		//finished procesing source data - all data in sink buffer
			{
			iSoundDeviceBuffer->SetStatus(EFull);	//sink buffer is full	
			}
		break;
		case CMMFSwCodec::TCodecProcessResult::EDstNotFilled:
		//could be the last buffer in which case dst might not get filled
			{
			iSoundDeviceBuffer->SetStatus(EFull);	//sink buffer is full	
			}
		break;
		case CMMFSwCodec::TCodecProcessResult::EEndOfData:
			//no more data - send what we've got to the sink
			//note we can't always rely on this  - in many cases the codec will not know when
			//it has reached the end of data.
			{
			iSoundDeviceBuffer->SetStatus(EFull);//sink buffer may not really be 'full' but its as full as it going to get
			iNoMoreSourceData = ETrue;
			//doesn't matter if sink buffer is not full
			}
		break;
		default:
			Panic(EMMFSwCodecWrapperBadCodec); //should never get here - bad codec
			}
		}
	}


void CMMFSwCodecPlayDataPath::BufferEmptiedL(const CMMFDataBuffer& aBuffer)
	{//call back from CDataPathPlayer when the sound device buffer has been emptied
	if (&aBuffer != iSoundDeviceBuffer) 
		Panic(EMMFSwCodecWrapperBadBuffer);
	if (!iNoMoreSourceData) 
		FillSourceBufferL();
	}

//*** End of Main Play Loop ***


void CMMFSwCodecPlayDataPath::Stop()
	{
	iAudioPlayer->Cancel();
	iSoundDeviceErrorReceiver->Cancel();
	TRequestStatus status;
	iSoundDevice->CloseDevice(iDeviceUid, status);
	User::WaitForRequest(status);

#ifdef __CYCLE_MMF_DATABUFFERS__
	// Create a new buffer to replicate INC021405 Play-EOF-Play on HwAccelerated solution Panics
	// If the creation fails, we carry on regardless as the original buffer will not have been 
	// destroyed. Must do this as alloc fail tests will not run.
	if(iSourceBuffer)
		{
		iSourceBuffer = CycleAudioBuffer(iSourceBuffer);
		}
#endif // __CYCLE_MMF_DATABUFFERS__	

	iState = EStopped;
	}


void CMMFSwCodecPlayDataPath::Pause()
	{
	//since a pause can happen anyway in the datatransfer -need to set to a known 
	//state so that when play is resumed the behaviour is predictable
	if (iSoundDevice->Handle())
		{
		iSoundDevice->PauseBuffer(); // ignores return value?
		iState = EPaused;
#ifdef _SCW_DEBUG
		RDebug::Print(_L("Pause"));
#endif
		}
	else
		{//an error must have occured 
		iState = EStopped;
		}
	}


CRoutingSoundPlayDevice* CMMFSwCodecPlayDataPath::Device()
	{
	return iSoundDevice;
	}

void CMMFSwCodecPlayDataPath::SoundDeviceException(TInt aError)
	{
	//this sends a request to the hw device observer usually Devsound
	//to update the bytes played
	//it is done here so that the sound driver can be closed prior to
	//updating the plicy and sending the error back
	TUid uidUpdateBytesPlayed;
	uidUpdateBytesPlayed.iUid = KMmfHwDeviceObserverUpdateBytesPlayed;
	TPtrC8 dummy(0,0);
	iHwDeviceObserver->MsgFromHwDevice(uidUpdateBytesPlayed,dummy);

	//this closes RMdaDevSound.
	Stop(); 

	//inform devsound so it can update policy
	iHwDeviceObserver->Stopped(); 

	// Inform the observer of the exception condition
	// We inform the hw device observer after the policy has been
	// updated incase the observer relied on the error to assume
	// the policy has been updated
	iHwDeviceObserver->Error(aError);
	}


void CMMFSwCodecPlayDataPath::SetPlayCustomInterface(MPlayCustomInterface& aCustomInterface)
	{
	iCustomInterface = &aCustomInterface;
	}
	
void CMMFSwCodecPlayDataPath::SetConfigForAudioRamp(TUint aSampleRate, TUint aChannels)
	{
	iSampleRate = aSampleRate;
	iChannels = aChannels;
	}

/************************************************************************
 *				CDataPathPlayer											*
 ************************************************************************/

CDataPathPlayer::CDataPathPlayer(CMMFSwCodecPlayDataPath& aParent, TInt aPriority)
: CActive(aPriority), iParent(aParent)
	{
	CActiveScheduler::Add(this);
	}


CDataPathPlayer::~CDataPathPlayer()
	{
	Cancel();
	}


void CDataPathPlayer::Start()
	{
	// No implementation
	}


void CDataPathPlayer::ResumePlaying()
	{
	if (iParent.Device()->Handle())
		{
		//should be ok to call this even if we are active
		iParent.Device()->ResumePlaying();
		iResumePlaying = ETrue;
		}
#ifdef _SCW_DEBUG
	RDebug::Print(_L("Playing Resumed"));
#endif
	}


void CDataPathPlayer::PlayData(const CMMFDataBuffer& aData)
	{
	iDataFromSource = &aData;
	if (!IsActive())
		{
#ifdef _SCW_DEBUG
		RDebug::Print(_L("CDataPathPlayer::PlayData"));
#endif
		iParent.Device()->PlayData(aData.Data(), iStatus);
		SetActive();
		}
	}


void CDataPathPlayer::Stop()
	{
	if (!IsActive())
		{
		iParent.Device()->FlushBuffer();
		}
	Cancel();
	iParent.SoundDeviceException(KErrCancel);
	}


void CDataPathPlayer::RunL()
	{
#ifdef _SCW_DEBUG
	RDebug::Print(_L("CDataPathPlayer::RunL error[%d]"), iStatus.Int());
#endif
	if (!iStatus.Int())
		{
		iParent.BufferEmptiedL(static_cast<const CMMFDataBuffer&>(*iDataFromSource));
		iResumePlaying = EFalse;
		}
	//if we don't have a sound driver handle then we have stopped
	//but the client still thinks we are recording so swallow error
	else if (iStatus.Int()!= KErrBadHandle)
		{ 	
		iParent.SoundDeviceException(iStatus.Int());
		}
	}


TInt CDataPathPlayer::RunError(TInt aError)
	{
	Error(aError);
	return KErrNone;
	}


void CDataPathPlayer::DoCancel()
	{
	if (iParent.Device()->Handle())
		{
		iParent.Device()->CancelPlayData();
		iParent.Device()->FlushBuffer();
		}
	}


void CDataPathPlayer::Error(TInt aError)
	{ 
	iParent.SoundDeviceException(aError);
	}


/************************************************************************
 *				CSoundDevPlayErrorReceiver								*
 ************************************************************************/

CSoundDevPlayErrorReceiver::CSoundDevPlayErrorReceiver(CMMFSwCodecPlayDataPath& aParent, TInt aPriority)
: CActive(aPriority), iParent(aParent)
	{
	CActiveScheduler::Add(this);
	}

CSoundDevPlayErrorReceiver::~CSoundDevPlayErrorReceiver()
	{
	Cancel();
	}

void CSoundDevPlayErrorReceiver::Start()
	{
	iParent.Device()->NotifyError(iStatus);
	SetActive();
	}

void CSoundDevPlayErrorReceiver::Stop()
	{
	Cancel();
	}

void CSoundDevPlayErrorReceiver::RunL()
	{
	// An error has been returned
#ifdef _SCW_DEBUG
	RDebug::Print(_L("CSoundDevPlayErrorReceiver::RunL[%d]"), iStatus.Int());
#endif
	iParent.SoundDeviceException(iStatus.Int());
	}

void CSoundDevPlayErrorReceiver::DoCancel()
	{
	iParent.Device()->CancelNotifyError();
	}