// 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\MmfBtSwCodecRecordDatapath.cpp

 // 

 //

 #include "mmfBtSwCodecRecordDataPath.h"

 #include "mmfbtswcodecwrapper.h"

 #include <mmfpaniccodes.h>

 #include "MMFBtRoutingSoundDevice.h"

 CMMFSwCodecRecordDataPath* CMMFSwCodecRecordDataPath::NewL(CRoutingSoundRecordDevice* aSoundDevice)

 	{

 	CMMFSwCodecRecordDataPath* self = new(ELeave) CMMFSwCodecRecordDataPath(aSoundDevice);

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop();

 	return self;

 	}

 void CMMFSwCodecRecordDataPath::ConstructL()

 	{

 	iAudioRecorder = new (ELeave) CDataPathRecorder(*this,CActive::EPriorityUserInput);

 	iSoundDeviceErrorReceiver = new (ELeave) CSoundDevRecordErrorReceiver(*this, CActive::EPriorityUserInput);

 	}

 CMMFSwCodecRecordDataPath::~CMMFSwCodecRecordDataPath()

 	{	

 	delete iAudioRecorder;

 	delete iSoundDeviceErrorReceiver;

 	TRequestStatus status;

 	iSoundDevice->CloseDevice(iDeviceUid, status);

 	//TODO there should be a timeout for the line below

 	User::WaitForRequest(status);

 	if (iCodec)

 		{

 		delete iSoundDeviceBuffer;

 		if (!iCodec->IsNullCodec())

 			{

 			delete iSinkBuffer;

 			}

 		}

 #ifdef __USE_MMF_TRANSFERBUFFERS__

 	delete iTransferWindow;

 	if(iTransferBuffer)

 		{

 		iTransferBuffer->Close();

 		delete iTransferBuffer;

 		}

 #endif

 #ifdef __USE_MMF_PTRBUFFERS__

 	delete iPtrBufferMemoryBlock;

 #endif

 	}

 TInt CMMFSwCodecRecordDataPath::SetObserver(MMMFHwDeviceObserver& aObserver)

 	{

 	TInt error;

 	if (iHwDeviceObserver)

 		{

 		error =  KErrAlreadyExists;

 		}

 	else

 		{

 		iHwDeviceObserver = &aObserver;

 		error  = KErrNone;

 		}

 	return error;

 	}

 TInt CMMFSwCodecRecordDataPath::AddCodec(CMMFSwCodec& aCodec)

 	{

 	if (iCodec)

 		{

 		return KErrNotSupported; //doesn't support multiple codecs

 		}

 	TInt err = KErrNone;

 	iCodec = &aCodec;

 	iSinkBufferSize = iCodec->SinkBufferSize();

 	iSoundDevBufferSize = iCodec->SourceBufferSize();

 	if ((!iSinkBufferSize)||(!iSoundDevBufferSize))

 		{

 		err = KErrArgument; //codec plugin has not specified buffer size

 		}

 	if (err == KErrNone)

 		{

 #ifdef __USE_MMF_TRANSFERBUFFERS__

 		TRAP(err,iSoundDeviceBuffer = CreateTransferBufferL(iSoundDevBufferSize, static_cast<CMMFTransferBuffer*>(iSoundDeviceBuffer)));

 #endif

 #ifdef __USE_MMF_PTRBUFFERS__

 		TRAP(err,iSoundDeviceBuffer = CreatePtrBufferL(iSoundDevBufferSize));

 #else

 		TRAP(err,iSoundDeviceBuffer = CMMFDataBuffer::NewL(iSoundDevBufferSize));

 #endif

 		}

 	if (err == KErrNone)

 		{

 		// Allocate data buffer

 		if (iCodec->IsNullCodec())

 			{//don't need a separate sink buffer if null codec

 			iSinkBuffer = NULL; //sink buffer is the sound device buffer	

 			}

 		else

 			{//need a separate sink buffer for the codec

 			TRAP(err,iSinkBuffer = CMMFDataBuffer::NewL(iSinkBufferSize));

 			}	

 		}

 	return err;

 	}

 TInt CMMFSwCodecRecordDataPath::Start()

 	{

 	TInt startError = KErrNone;

 	if (!iCodec || !(iSoundDevice->Handle()))

 		{//check that a codec has been added and the sound device has been opened

 		startError = KErrNotReady;

 		}

 	if (!startError)

 		{

 		// Start the player objects

 		iAudioRecorder->Start();

 		iSoundDeviceErrorReceiver->Start();

 		iSoundDeviceBuffer->SetLastBuffer(EFalse);

 		TRAP(startError, FillSoundDeviceBufferL()); //get audio recorder to fill buffer

 		if (startError == KErrNone)

 			{

 			iRecordedBytesCount = 0; //used for debug purposes

 			iState = EPlaying;

 			}

    		}

 	return startError;

 	}

 // *** Main Play Loop ***

 void CMMFSwCodecRecordDataPath::FillSoundDeviceBufferL()

 	{

 #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(iSoundDeviceBuffer)

 		{

 		iSoundDeviceBuffer = CycleAudioBuffer(iSoundDeviceBuffer);

 		}

 #endif // __CYCLE_MMF_DATABUFFERS__	

 	iAudioRecorder->RecordData(*iSoundDeviceBuffer);

 	}

 void CMMFSwCodecRecordDataPath::BufferFilledL(CMMFDataBuffer& aBuffer)

 	{	

 	iSoundDeviceBuffer = &aBuffer;

 	iSoundDeviceBuffer->SetStatus(EFull);

 	 // Store this to avoid casting several times

     TUint length = iSoundDeviceBuffer->BufferSize();

 	// Update bytes recorded

 	iRecordedBytesCount += length;

 	//If paused then sound driver will keep sending buffers till

 	//its flushed - if last buffer then set last buffer flag

 	if (length < iSoundDevBufferSize)

 		{//assume it's the last buffer

 		iSoundDeviceBuffer->SetLastBuffer(ETrue);

 		}

 	//buffer ok can send to sink

 	FillSinkBufferL(); //convert to sink data type using codec

 	User::LeaveIfError(iHwDeviceObserver->EmptyThisHwBuffer(*iSinkBuffer)); //pass onto sink

 	}

 /* 

  *  FillSinkBufferL

  * 

  *	Function to take the data from an already full source buffer and by using

  *	a codec if necessary fills the sink buffer

  *  @internalComponent

  */

 void CMMFSwCodecRecordDataPath::FillSinkBufferL()

 	{

 	CMMFSwCodec::TCodecProcessResult codecProcessResult;

 	if (iCodec->IsNullCodec())

 		{//no codec so sound device buffer can be used directly as sink buffer

 		iSinkBuffer = iSoundDeviceBuffer;

 		iSinkBuffer->SetStatus(EFull);	//sink buffer is full

 		}	

 	else 

 		{

 		//pass buffer to codec for processing

 		codecProcessResult = iCodec->ProcessL(*iSoundDeviceBuffer, *iSinkBuffer);

 		if (iSoundDeviceBuffer->LastBuffer()) //if sound device is last buffer so is sound dev

 			{

 			iSinkBuffer->SetLastBuffer(ETrue);

 			}

 		if ((!iSinkBuffer->BufferSize())&&(codecProcessResult.iDstBytesAdded))

 			{//the codec has added data but not set the buffer length

 			iSinkBuffer->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(EAvailable); //source buffer is now avaialble

 			iSinkBuffer->SetStatus(EFull);	//sink buffer is full	

 			}

 		break;

 		case CMMFSwCodec::TCodecProcessResult::EDstNotFilled:

 		//finished procesing source data - sink buffer not full could be EOF

 			{

 			iSoundDeviceBuffer->SetStatus(EAvailable); //source buffer is now avaialble

 			iSinkBuffer->SetStatus(EFull);	//sink buffer may not really be full however	

 			}

 		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(EAvailable); //source buffer is now avaialble

 			iSinkBuffer->SetStatus(EFull);//sink buffer may not really be 'full' but its as full as it going to get

 			//doesn't matter if sink buffer is not full

 			}

 		break;

 		default:

 			Panic(EMMFSwCodecWrapperBadCodec); //should never get here - bad codec

 			}

 		}

 	}

 void CMMFSwCodecRecordDataPath::BufferEmptiedL(const CMMFDataBuffer& aBuffer)

 	{

 	if (&aBuffer != iSinkBuffer)

 		{

 		Panic(EMMFSwCodecWrapperBadBuffer);

 		}

 	if (!aBuffer.LastBuffer())

 		{

 		FillSoundDeviceBufferL();

 		}

 	//else the last buffer has been emptied - the observer should stop the

 	//hw device.

 	}

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

 void CMMFSwCodecRecordDataPath::Stop()

 	{

 	iAudioRecorder->Stop();//stop audio reocrder

 	iSoundDeviceErrorReceiver->Cancel(); //stop receiving events

 	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(iSoundDeviceBuffer)

 		{

 		iSoundDeviceBuffer = CycleAudioBuffer(iSoundDeviceBuffer);

 		}

 #endif // __CYCLE_MMF_DATABUFFERS__	

 	iState = EStopped;

 	}

 void CMMFSwCodecRecordDataPath::Pause()

 	{

 	// flush it anyway, whether we're active or not

 	// if we are active, then this should result in a call to RunL() pretty soon

 	//note that the Pause() in the context of record means buffers are

 	//continued to be obtained from the sound driver that have already 

 	//been recorded - it just doesn't record any new audio data

 #ifdef _SCW_DEBUG

 	RDebug::Print(_L("CMMFSwcodecRecordDataPath::Pause"));

 #endif

 	iSoundDevice->FlushBuffer();

 	}

 CRoutingSoundRecordDevice* CMMFSwCodecRecordDataPath::Device()

 	{

 	return iSoundDevice;

 	}

 void CMMFSwCodecRecordDataPath::SoundDeviceException(TInt aError)

 	{

 	//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);

 	}

 TUint CMMFSwCodecRecordDataPath::RecordedBytesCount()

 	{

 	return iRecordedBytesCount;

 	}

 /************************************************************************

  *				CDataPathRecorder										*

  ************************************************************************/

 CDataPathRecorder::CDataPathRecorder(CMMFSwCodecRecordDataPath& aParent, TInt aPriority)

 : CActive(aPriority), iParent(aParent)

 	{

 	CActiveScheduler::Add(this);

 	}

 CDataPathRecorder::~CDataPathRecorder()

 	{

 	Cancel();

 	}

 void CDataPathRecorder::Start()

 	{

 	// No implementation

 	}

 void CDataPathRecorder::RecordData(CMMFDataBuffer& aData)

 	{

 	iDataFromSource = &aData;

 	if (!IsActive())

 		{

 		iParent.Device()->RecordData(aData.Data(), iStatus);

 		SetActive();

 		}

 	}

 void CDataPathRecorder::Stop()

 	{

 #ifdef _SCW_DEBUG

 	RDebug::Print(_L("CDataPathRecorder Stop"));

 #endif

 	Cancel();

 	}

 void CDataPathRecorder::RunL()

 	{

 #ifdef _SCW_DEBUG

 	RDebug::Print(_L("CDataPathRecorder::RunL error[%d]"), iStatus.Int());

 #endif

 	if (!iStatus.Int())

 		{

 		iParent.BufferFilledL((CMMFDataBuffer&)*iDataFromSource);

 		}

 	//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 CDataPathRecorder::RunError(TInt aError)

 	{

 	Error(aError);

 	return KErrNone;

 	}

 void CDataPathRecorder::DoCancel()

 	{

 #ifdef _SCW_DEBUG

 	RDebug::Print(_L("CDataPathRecorder Cancel"));

 #endif

 	if (iParent.Device()->Handle())

 		{

 		iParent.Device()->CancelRecordData();

 		iParent.Device()->FlushBuffer();

 		}

 	}

 void CDataPathRecorder::Error(TInt aError)

 	{ 

 	iParent.SoundDeviceException(aError);

 	}

 /************************************************************************

  *				CSoundDevRecordErrorReceiver							*

  ************************************************************************/

 CSoundDevRecordErrorReceiver::CSoundDevRecordErrorReceiver(CMMFSwCodecRecordDataPath& aParent, TInt aPriority)

 : CActive(aPriority), iParent(aParent)

 	{

 	CActiveScheduler::Add(this);

 	}

 CSoundDevRecordErrorReceiver::~CSoundDevRecordErrorReceiver()

 	{

 	Cancel();

 	}

 void CSoundDevRecordErrorReceiver::Start()

 	{	

 	if (!IsActive()) 

 		{

 		iParent.Device()->NotifyError(iStatus);

 		SetActive();

 		}

 	}

 void CSoundDevRecordErrorReceiver::Stop()

 	{

 	Cancel();

 	}

 void CSoundDevRecordErrorReceiver::RunL()

 	{

 	// An error has been returned--Flush to release mic.

 	iParent.Device()->FlushBuffer();

 	iParent.SoundDeviceException(iStatus.Int());

 	}

 void CSoundDevRecordErrorReceiver::DoCancel()

 	{

 	iParent.Device()->CancelNotifyError();

 	}