sl@0: // Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: // source\server\mmfswcodecrecorddatapath.cpp
sl@0: //
sl@0: //
sl@0: 
sl@0: #include "mmfSwCodecRecordDataPath.h"
sl@0: #include <mmf/server/mmfswcodecwrapper.h>
sl@0: #include <mmf/common/mmfpaniccodes.h>
sl@0: 
sl@0: #ifdef SYMBIAN_SCW_DEBUG
sl@0: 
sl@0: const TText* const KStateNames[] = // must agree with TRecordState
sl@0:             {
sl@0:             _S("ERecordStateCreated"),
sl@0:             _S("ERecordStateFailed"),
sl@0:             _S("ERecordStateRecording"),
sl@0:             _S("ERecordStateSendingBuffer"),
sl@0:             _S("ERecordStateSendingPartialBuffer"),
sl@0:             _S("ERecordStateEmptiedPartialBuffer"),
sl@0:             _S("ERecordStateRecordingPaused"),
sl@0:             _S("ERecordStateSendingBufferPaused"),
sl@0:             _S("ERecordStateSendingPartialBufferPaused"),
sl@0:             _S("ERecordStateEmptiedPartialBufferPaused"),
sl@0:             };
sl@0: 
sl@0: static const TText* StateName(TInt aState)
sl@0:     {
sl@0:     return KStateNames[aState];
sl@0:     }
sl@0: 
sl@0: #endif // SYMBIAN_SCW_DEBUG
sl@0: 
sl@0: // Table of next state used when resuming or pausing.
sl@0: const CMMFSwCodecRecordDataPath::TRecordState CMMFSwCodecRecordDataPath::KResumePauseTable[] =
sl@0:     {
sl@0:     ERecordStateCreated,                    //ERecordStateCreated                       // note order here is important - see State(), RecordOrPause() etc
sl@0:     ERecordStateFailed,                     //ERecordStateFailed
sl@0:     ERecordStateRecordingPaused,            //ERecordStateRecording
sl@0:     ERecordStateSendingBufferPaused,        //ERecordStateSendingBuffer
sl@0:     ERecordStateSendingPartialBufferPaused, //ERecordStateSendingPartialBuffer
sl@0:     ERecordStateEmptiedPartialBufferPaused, //ERecordStateEmptiedPartialBuffer
sl@0:     ERecordStateRecording,                  //ERecordStateRecordingPaused
sl@0:     ERecordStateSendingBuffer,              //ERecordStateSendingBufferPaused
sl@0:     ERecordStateSendingPartialBuffer,       //ERecordStateSendingPartialBufferPaused
sl@0:     ERecordStateEmptiedPartialBuffer,       //ERecordStateEmptiedPartialBufferPaused
sl@0:     };
sl@0: 
sl@0: 
sl@0: CMMFSwCodecRecordDataPath* CMMFSwCodecRecordDataPath::NewL()
sl@0: 	{
sl@0: 	CMMFSwCodecRecordDataPath* self = new(ELeave) CMMFSwCodecRecordDataPath;
sl@0: 	CleanupStack::PushL(self);
sl@0: 	self->ConstructL();
sl@0: 	CleanupStack::Pop();
sl@0: 	return self;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: void CMMFSwCodecRecordDataPath::ConstructL()
sl@0: 	{
sl@0: 	iAudioInput = MAudioInput::CreateL(*this);
sl@0: 	TCallBack callback(Callback, this);
sl@0: 	iAsyncCallback = new (ELeave) CAsyncCallBack(callback, CActive::EPriorityStandard);
sl@0: 	}
sl@0: 
sl@0: CMMFSwCodecRecordDataPath::CMMFSwCodecRecordDataPath():
sl@0: 		iShadowData(NULL, 0, 0)
sl@0: 	{
sl@0: 	ASSERT(iState==ERecordStateCreated); // assume this value is 0, so no need to assign
sl@0: 	}
sl@0: 
sl@0: CMMFSwCodecRecordDataPath::~CMMFSwCodecRecordDataPath()
sl@0: 	{
sl@0: 	if (iAudioInput)
sl@0: 		{
sl@0: 		iAudioInput->Release();
sl@0: 		}
sl@0: 
sl@0: 	delete iCodecBuffer;
sl@0: 	delete iInputBuffer;
sl@0: 	delete iAsyncCallback;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: TInt CMMFSwCodecRecordDataPath::SetObserver(MMMFHwDeviceObserver& aObserver)
sl@0: 	{
sl@0: 	TInt error;
sl@0: 	if (iHwDeviceObserver)
sl@0: 		{
sl@0: 		error =  KErrAlreadyExists;
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		iHwDeviceObserver = &aObserver;
sl@0: 		error  = KErrNone;
sl@0: 		}
sl@0: 	return error;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: TInt CMMFSwCodecRecordDataPath::AddCodec(CMMFSwCodec& aCodec)
sl@0: 	{
sl@0: 	TInt err = KErrNone;
sl@0: 
sl@0: 	if (iCodec)
sl@0: 		{
sl@0: 		err = KErrNotSupported; //doesn't support multiple codecs
sl@0: 		}
sl@0: 
sl@0: 	if (!err)
sl@0: 		{
sl@0: 		iCodec = &aCodec;
sl@0: 
sl@0: 		iSinkBufferSize = iCodec->SinkBufferSize();
sl@0: 		iAudioInputBufferSize = iCodec->SourceBufferSize(); // the buffer size we want from the input device
sl@0: 
sl@0: 		if (!iSinkBufferSize || !iAudioInputBufferSize)
sl@0: 			{
sl@0: 			err = KErrArgument; //codec plugin has not specified buffer size
sl@0: 			}
sl@0: 		}
sl@0: 
sl@0: 	if (!err)
sl@0: 		{
sl@0: 		// Allocate data buffer
sl@0: 		if (iCodec->IsNullCodec())
sl@0: 			{//don't need a separate sink buffer if null codec
sl@0: 			iSinkBuffer = NULL; //sink buffer is the sound device buffer
sl@0: 			iAudioInputBufferSize = iSinkBufferSize; // the audio input buffer becomes the sink buffer
sl@0: 			}
sl@0: 		else
sl@0: 			{//need a separate sink buffer for the codec - this is the buffer passed to our client
sl@0: 			ASSERT(!iCodecBuffer); // can't happen because can only call AddCodec once
sl@0: 			TRAP(err,iCodecBuffer = CMMFDataBuffer::NewL(iSinkBufferSize));
sl@0: 			iSinkBuffer = iCodecBuffer;
sl@0: 			}
sl@0: 		}
sl@0: 	if (!err)
sl@0: 		{
sl@0: 		ASSERT(!iInputBuffer); // can't happen because can only call AddCodec once
sl@0: 		TRAP(err,iInputBuffer = CMMFPtrBuffer::NewL());
sl@0: 		}
sl@0: 	if (!err)
sl@0: 		{
sl@0: 		// point iSinkBuffer at the right place
sl@0: 		if (iCodec->IsNullCodec())
sl@0: 			{
sl@0: 			iSinkBuffer = iInputBuffer;
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			iSinkBuffer = iCodecBuffer;
sl@0: 			}
sl@0: 		}
sl@0: 	return err;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: TInt CMMFSwCodecRecordDataPath::Start()
sl@0: 	{
sl@0: #ifdef SYMBIAN_SCW_DEBUG
sl@0:     RDebug::Print(_L("CMMFSwcodecRecordDataPath::Start() state=%s"), StateName(iState));
sl@0: #endif
sl@0: 	TInt err = KErrNone;
sl@0: 	if (!iCodec)
sl@0: 		{//check that a codec has been added
sl@0: 		err = KErrNotReady;
sl@0: 		}
sl@0: 	if (!err)
sl@0: 		{
sl@0: 		switch (iState)
sl@0: 		    {
sl@0: 		    case ERecordStateCreated:
sl@0: 		        {
sl@0: 	            TAudioInputParams params;
sl@0: 	            params.iInitialGain = iGain;
sl@0: 	            params.iSampleRate = iSampleRate;
sl@0: 	            params.iNumChannels = iNumChannels;
sl@0: 	            params.iNominalBufferSize = iAudioInputBufferSize;
sl@0: 	            err = iAudioInput->Initialize(params);
sl@0:                 if (!err)
sl@0:                     {
sl@0:                     err = iAudioInput->Start();
sl@0:                     if (err)
sl@0:                         {
sl@0:                         iAudioInput->Close();
sl@0:                         ASSERT(iState == ERecordStateCreated); // end up in same state
sl@0:                         }
sl@0:                     else
sl@0:                         {
sl@0:                         iState = ERecordStateRecording;
sl@0:                         iInputHasFinished = EFalse;
sl@0:                         iRecordedBytesCount = 0; //used for debug purposes
sl@0:                         }
sl@0:                     }
sl@0: 		        }
sl@0: 		        break;
sl@0: 		    case ERecordStateRecordingPaused:
sl@0: 		    case ERecordStateSendingPartialBufferPaused:
sl@0: 		    case ERecordStateEmptiedPartialBufferPaused:
sl@0: 		        {
sl@0: 		        // effectively in paused state, resume and switch to equivalent state
sl@0: 		        iAudioInput->Resume();
sl@0:                 iInputHasFinished = EFalse;
sl@0: 		        iState = KResumePauseTable[iState];
sl@0: 		        }
sl@0: 		        break;
sl@0:             case ERecordStateSendingBufferPaused:
sl@0:                 {
sl@0: 				iAudioInput->Resume();
sl@0:                 if (iInputHasFinished)
sl@0:                     {
sl@0:                     iState = ERecordStateRecording; // as we follow InputHasFinished, we don't wait for the buffer
sl@0: 					iInputHasFinished = EFalse;
sl@0:                     }
sl@0:                 else
sl@0:                     {
sl@0:                     // effectively in paused state, resume and switch to equivalent state
sl@0:                     iState = KResumePauseTable[iState];
sl@0:                     }
sl@0:                 }
sl@0:                 break;
sl@0:             case ERecordStateFailed:
sl@0: 		    default:
sl@0: 		        {
sl@0: 		        // anything else assume already recording and ignore
sl@0: 		        }
sl@0: 		        break;
sl@0: 		    }
sl@0: 		}
sl@0: 
sl@0: #ifdef SYMBIAN_SCW_DEBUG
sl@0:     RDebug::Print(_L("End CMMFSwcodecRecordDataPath::Start(%d) state=%s"), err, StateName(iState));
sl@0: #endif
sl@0: 	return err;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: void CMMFSwCodecRecordDataPath::InputBufferAvailable(const TDesC8& aBuffer)
sl@0: 	{
sl@0: #ifdef SYMBIAN_SCW_DEBUG
sl@0:     RDebug::Print(_L("CMMFSwcodecRecordDataPath::InputBufferAvailable(%d) state=%s"), aBuffer.Length(), StateName(iState));
sl@0: #endif
sl@0: 	ASSERT(iState==ERecordStateRecording || iState==ERecordStateRecordingPaused);
sl@0: 	iInputData = &aBuffer;
sl@0:     TUint length = aBuffer.Length();
sl@0: 	// Update bytes recorded
sl@0: 	iRecordedBytesCount += length;
sl@0: 
sl@0: 	//buffer ok can send to sink
sl@0: 	iInputOffset = 0;
sl@0: 	TRAPD(err,ProcessBufferL(EFalse)); //convert to sink data type using codec
sl@0: 	if (err != KErrNone)
sl@0: 	    {
sl@0: 	    iHwDeviceObserver->Error(err);
sl@0: 	    }
sl@0: #ifdef SYMBIAN_SCW_DEBUG
sl@0:     RDebug::Print(_L("End CMMFSwcodecRecordDataPath::InputBufferAvailable state=%s"), StateName(iState));
sl@0: #endif
sl@0: 	}
sl@0: 
sl@0: void CMMFSwCodecRecordDataPath::InputFinished()
sl@0: 	{
sl@0: #ifdef SYMBIAN_SCW_DEBUG
sl@0:     RDebug::Print(_L("CMMFSwcodecRecordDataPath::InputFinished state=%s"), StateName(iState));
sl@0: #endif
sl@0:     ASSERT(iState==ERecordStateRecording || iState==ERecordStateRecordingPaused);
sl@0: 	iInputOffset = 0;
sl@0: 	iInputHasFinished = ETrue;
sl@0: 	TRAPD(err,ProcessBufferL(ETrue)); // finish off any conversion	
sl@0: 	if (err != KErrNone)
sl@0: 	    {
sl@0: 	    iHwDeviceObserver->Error(err);
sl@0: 	    }
sl@0: #ifdef SYMBIAN_SCW_DEBUG
sl@0:     RDebug::Print(_L("End CMMFSwcodecRecordDataPath::InputFinished state=%s"), StateName(iState));
sl@0: #endif
sl@0: 	}
sl@0: 
sl@0: void CMMFSwCodecRecordDataPath::InputError(TInt aError)
sl@0: 	{
sl@0: #ifdef SYMBIAN_SCW_DEBUG
sl@0:     RDebug::Print(_L("CMMFSwcodecRecordDataPath::InputBufferAvailable(%d) state=%s"), aError, StateName(iState));
sl@0: #endif
sl@0: 	if (iState!=ERecordStateFailed)
sl@0: 	    {
sl@0: 	    iState = ERecordStateFailed;
sl@0: 	    if (iHwDeviceObserver)
sl@0: 	        {
sl@0: 	        // Inform the observer of the exception condition
sl@0: 	        // Assume it will subsequently call Stop(), and thus update policy
sl@0: 	        iHwDeviceObserver->Error(aError);
sl@0: 	        }
sl@0: 	    }
sl@0: #ifdef SYMBIAN_SCW_DEBUG
sl@0:     RDebug::Print(_L("CMMFSwcodecRecordDataPath::InputBufferAvailable() state=%s"), StateName(iState));
sl@0: #endif
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /*
sl@0:  *  FillSinkBufferL
sl@0:  *
sl@0:  *	Function to take the data from an already full source buffer and by using
sl@0:  *	a codec if necessary fills the sink buffer
sl@0:  *  If aLastBuffer, treat as a last buffer with zero length
sl@0:  */
sl@0: void CMMFSwCodecRecordDataPath::ProcessBufferL(TBool aLastBuffer)
sl@0: 	{
sl@0:     ASSERT(iState==ERecordStateRecording || iState==ERecordStateRecordingPaused ||
sl@0:            iState==ERecordStateEmptiedPartialBuffer || iState==ERecordStateEmptiedPartialBufferPaused); // only valid states
sl@0: 	if (iCodec->IsNullCodec())
sl@0: 		{//no codec so sound device buffer can be used directly as sink buffer
sl@0: 		ASSERT(iSinkBuffer==iInputBuffer); // just assume this
sl@0: 		if (aLastBuffer)
sl@0: 			{
sl@0: 			iShadowData.Set(NULL, 0, 0);
sl@0: 			iInputBuffer->SetPtr(iShadowData);
sl@0: 			iInputBuffer->SetLastBuffer(ETrue);
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			iShadowData.Set(const_cast<TUint8*>(iInputData->Ptr()), iInputData->Length(), iInputData->Length());
sl@0: 			iInputBuffer->SetPtr(iShadowData);
sl@0: 			iInputBuffer->SetLastBuffer(EFalse);
sl@0: 			}
sl@0: 		iInputBuffer->SetStatus(EFull);	//sink buffer is "full"
sl@0: 		TRecordState oldState = iState;
sl@0:         switch (iState)
sl@0:             {
sl@0:             case ERecordStateRecording:
sl@0:                 iState = ERecordStateSendingBuffer;
sl@0:                 break;
sl@0:             case ERecordStateRecordingPaused:
sl@0:                 iState = ERecordStateSendingBufferPaused;
sl@0:                 break;
sl@0:             case ERecordStateEmptiedPartialBuffer:
sl@0:             case ERecordStateEmptiedPartialBufferPaused:
sl@0:                 ASSERT(EFalse); // Technically these can occur but not if IsNullCodec is true, Complete is effectively always true
sl@0:                 break;
sl@0:             }
sl@0: 		TInt err = iHwDeviceObserver->EmptyThisHwBuffer(*iSinkBuffer); //pass onto sink
sl@0: 		if (err)
sl@0:             {
sl@0:             iState = oldState; // rewind
sl@0:             User::Leave(err);
sl@0:             }
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		ASSERT(iSinkBuffer==iCodecBuffer); // sink and codec buffers are synonym, so just talk to iSinkBuffer
sl@0: 		if (aLastBuffer)
sl@0: 			{
sl@0: 			iShadowData.Set(NULL, 0, 0);
sl@0: 			iInputBuffer->SetPtr(iShadowData); // empty buffer
sl@0: 			iInputBuffer->SetLastBuffer(ETrue);
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			TPtrC8 tempData = iInputData->Mid(iInputOffset);
sl@0: 			iShadowData.Set(const_cast<TUint8*>(tempData.Ptr()), tempData.Length(), tempData.Length());
sl@0: 			iInputBuffer->SetPtr(iShadowData);
sl@0: 			iInputBuffer->SetLastBuffer(EFalse);
sl@0: 			}
sl@0: 		//pass buffer to codec for processing
sl@0: 		CMMFSwCodec::TCodecProcessResult codecProcessResult = iCodec->ProcessL(*iInputBuffer, *iSinkBuffer);
sl@0: 		if ((!iSinkBuffer->BufferSize())&&(codecProcessResult.iDstBytesAdded))
sl@0: 			{//the codec has added data but not set the buffer length
sl@0: 			iSinkBuffer->Data().SetLength(codecProcessResult.iDstBytesAdded);
sl@0: 			}
sl@0: 		//only supports EProcessComplete
sl@0: 		TRecordState oldState = iState;
sl@0: 		TInt err = KErrNone;
sl@0: 		switch (codecProcessResult.iCodecProcessStatus)
sl@0: 			{
sl@0: 			case CMMFSwCodec::TCodecProcessResult::EProcessComplete: //finished procesing source data - all data in sink buffer
sl@0: 			case CMMFSwCodec::TCodecProcessResult::EDstNotFilled: //finished procesing source data - sink buffer not full could be EOF
sl@0: 			case CMMFSwCodec::TCodecProcessResult::EEndOfData: //no more data - send what we've got to the sink
sl@0: 				{
sl@0: 				iSinkBuffer->SetStatus(EFull);	// treat sink buffer as full
sl@0: 				iState = IsPaused() ? ERecordStateSendingBufferPaused : ERecordStateSendingBuffer;
sl@0: 				err = EmptyBufferL();
sl@0: 				break;
sl@0: 				}
sl@0: 			case CMMFSwCodec::TCodecProcessResult::EProcessIncomplete:
sl@0: 				{
sl@0: 				// codec has not yet finished with input - send buffer and come back around
sl@0: 				iSinkBuffer->SetStatus(EFull);	// treat sink buffer as full
sl@0: 				iInputOffset = codecProcessResult.iSrcBytesProcessed;
sl@0:                 iState = IsPaused() ? ERecordStateSendingPartialBufferPaused : ERecordStateSendingPartialBuffer;
sl@0:                 err = EmptyBufferL();
sl@0: 				break;
sl@0: 				}
sl@0: 			default:
sl@0: 				Panic(EMMFSwCodecWrapperBadCodec); //should never get here - bad codec
sl@0: 			}
sl@0: 		if (err)
sl@0: 		    {
sl@0: 		    iState = oldState; // rewind prior to handle
sl@0: 		    User::Leave(err);
sl@0: 		    }
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: TInt CMMFSwCodecRecordDataPath::EmptyBufferL()
sl@0: 	{
sl@0: 	// This code supports an assumption made by the vorbis encoder, which assumes it can safely generate empty buffers.
sl@0: 	// VbrFlag here implies the vorbis encoder.
sl@0: 	// TODO: Replace this with a generic solution - e.g. on EDstNotFilled we request a buffer from AudioInput instead
sl@0: 	// 		 of calling the client back.
sl@0: 	if(iVbrFlag)
sl@0: 		{
sl@0: 		if(!iSinkBuffer->Data().Length() && !iInputBuffer->LastBuffer())
sl@0: 			{
sl@0: 			BufferEmptiedL(STATIC_CAST(CMMFDataBuffer&, *iSinkBuffer));
sl@0: 			return KErrNone;
sl@0: 			}
sl@0: 		}
sl@0: 	TInt err = iHwDeviceObserver->EmptyThisHwBuffer(*iSinkBuffer); //pass onto sink
sl@0: 	return err;
sl@0: 	}
sl@0: 
sl@0: void CMMFSwCodecRecordDataPath::BufferEmptiedL(const CMMFDataBuffer& aBuffer)
sl@0: 	{
sl@0: #ifdef SYMBIAN_SCW_DEBUG
sl@0:     RDebug::Print(_L("CMMFSwcodecRecordDataPath::BufferEmptiedL() state=%s"), StateName(iState));
sl@0: #endif
sl@0: 	if (&aBuffer != iSinkBuffer)
sl@0: 		{
sl@0: 		// we are only single buffering at the moment...
sl@0: 		Panic(EMMFSwCodecWrapperBadBuffer);
sl@0: 		}
sl@0: 	ASSERT(iState==ERecordStateSendingBuffer || iState==ERecordStateSendingBufferPaused ||
sl@0: 	       iState==ERecordStateSendingPartialBuffer || iState==ERecordStateSendingPartialBufferPaused ||
sl@0: 	       iState==ERecordStateFailed);
sl@0: 	switch (iState)
sl@0: 		{
sl@0: 		case ERecordStateSendingBuffer:
sl@0: 		case ERecordStateSendingBufferPaused:
sl@0: 			{
sl@0:             iState = (iState==ERecordStateSendingBuffer) ? ERecordStateRecording : ERecordStateRecordingPaused;
sl@0: 			if (!iInputHasFinished)
sl@0: 			    {
sl@0: 	            iAudioInput->BufferAck();
sl@0: 			    }
sl@0: 			break;
sl@0: 			}
sl@0:         case ERecordStateSendingPartialBuffer:
sl@0:         case ERecordStateSendingPartialBufferPaused:
sl@0: 			{
sl@0:             iState = (iState==ERecordStateSendingPartialBuffer) ?
sl@0:                 ERecordStateEmptiedPartialBuffer : ERecordStateEmptiedPartialBufferPaused;
sl@0: 			RequestCallback(); // go back around to ensure next callback to client is asynchronous
sl@0: 			break;
sl@0: 			}
sl@0:         default:
sl@0:             {
sl@0:             // anything else just ignore - e.g. are waiting for Stop following an error
sl@0:             }
sl@0: 		}
sl@0: #ifdef SYMBIAN_SCW_DEBUG
sl@0:     RDebug::Print(_L("End CMMFSwcodecRecordDataPath::BufferEmptiedL() state=%s"), StateName(iState));
sl@0: #endif
sl@0: 	}
sl@0: 
sl@0: // Async callback support - used on PartialBuffer::BufferEmptiedL() transition
sl@0: 
sl@0: void CMMFSwCodecRecordDataPath::RequestCallback()
sl@0: 	{
sl@0: 	iAsyncCallback->CallBack();
sl@0: 	}
sl@0: 
sl@0: TInt CMMFSwCodecRecordDataPath::Callback(TAny* aPtr)
sl@0: 	{
sl@0: 	CMMFSwCodecRecordDataPath* self = static_cast<CMMFSwCodecRecordDataPath*>(aPtr);
sl@0: 	return self->DoCallback();
sl@0: 	}
sl@0: 
sl@0: TInt CMMFSwCodecRecordDataPath::DoCallback()
sl@0: 	{
sl@0: 	ASSERT(iState==ERecordStateEmptiedPartialBuffer || iState==ERecordStateEmptiedPartialBufferPaused); // only legal ones
sl@0: 	TRAPD(err,ProcessBufferL(EFalse));
sl@0: 	if (err != KErrNone)
sl@0: 	    {
sl@0: 	    iHwDeviceObserver->Error(err);
sl@0: 	    }
sl@0: 	return err;
sl@0: 	}
sl@0: 
sl@0: void CMMFSwCodecRecordDataPath::Stop()
sl@0: 	{
sl@0: #ifdef SYMBIAN_SCW_DEBUG
sl@0:     RDebug::Print(_L("CMMFSwcodecRecordDataPath::Stop() state=%s"), StateName(iState));
sl@0: #endif
sl@0: 	iAudioInput->Close();
sl@0: 	iState = ERecordStateCreated;
sl@0: #ifdef SYMBIAN_SCW_DEBUG
sl@0:     RDebug::Print(_L("End CMMFSwcodecRecordDataPath::Stop() state=%s"), StateName(iState));
sl@0: #endif
sl@0: 	}
sl@0: 
sl@0: 
sl@0: void CMMFSwCodecRecordDataPath::Pause()
sl@0: 	{
sl@0: 	// flush it anyway, whether we're active or not
sl@0: 	// if we are active, then this should result in a call to RunL() pretty soon
sl@0: 	//note that the Pause() in the context of record means buffers are
sl@0: 	//continued to be obtained from the sound driver that have already
sl@0: 	//been recorded - it just doesn't record any new audio data
sl@0: #ifdef SYMBIAN_SCW_DEBUG
sl@0: 	RDebug::Print(_L("CMMFSwcodecRecordDataPath::Pause state=%s"), StateName(iState));
sl@0: #endif
sl@0: 	switch (iState)
sl@0: 	    {
sl@0: 	    case ERecordStateRecording:
sl@0: 	    case ERecordStateSendingBuffer:
sl@0: 	    case ERecordStateSendingPartialBuffer:
sl@0: 	    case ERecordStateEmptiedPartialBuffer:
sl@0: 	        {
sl@0: 	        iAudioInput->Pause();
sl@0: 	        iState = KResumePauseTable[iState];
sl@0: 	        }
sl@0: 	        break;
sl@0: 	    default: ;
sl@0: 	        // do nothing - treat as no-op
sl@0: 	    }
sl@0: #ifdef SYMBIAN_SCW_DEBUG
sl@0:     RDebug::Print(_L("End CMMFSwcodecRecordDataPath::Pause state=%s"), StateName(iState));
sl@0: #endif
sl@0: 	}
sl@0: 
sl@0: 
sl@0: RMdaDevSound& CMMFSwCodecRecordDataPath::Device()
sl@0: 	{
sl@0: 	ASSERT(EFalse); // TODO should not be called - future remove if we can
sl@0: 	return iDummyDevSound;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: TUint CMMFSwCodecRecordDataPath::RecordedBytesCount()
sl@0: 	{
sl@0: 	return iRecordedBytesCount;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Retrieves a custom interface to the device.
sl@0: The reference CMMFSwCodecWrapper supports one custom interfaces,
sl@0: MSetVbrFlagCustomInterface
sl@0: 
sl@0: @param	aInterface
sl@0: 		Interface UID, defined with the custom interface.
sl@0: 		aInterface = KSetVbrFlagCustomInterfaceTypeUid for MSetVbrFlagCustomInterface.
sl@0: 
sl@0: 
sl@0: @return A pointer to the interface implementation, or NULL if the device can not
sl@0: 		implement the interface requested. The return value must be cast to the
sl@0: 		correct type by the user.
sl@0: */
sl@0: TAny* CMMFSwCodecRecordDataPath::CustomInterface(TUid aInterface)
sl@0: 	{
sl@0: 	TAny* ret = NULL;
sl@0: 
sl@0: 	if(aInterface.iUid == KSetVbrFlagCustomInterfaceTypeUid)
sl@0: 		{
sl@0: 		SetVbrFlag();
sl@0: 		}
sl@0: 	else if (aInterface == KUidSwSetParamInterface)
sl@0: 		{
sl@0: 		MSwSetParamInterface* self = this;
sl@0: 		return self;
sl@0: 		}
sl@0: 	else if (aInterface == KUidSwInfoInterface)
sl@0: 	    {
sl@0:         MSwInfoInterface* self = this;
sl@0:         return self;
sl@0: 	    }
sl@0: 	return ret;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Used to set iVbrFlag on the datapath.
sl@0: 
sl@0: This method is used to set the iVbrFlag in datapath. This flag is added to datapath to avail the
sl@0: alternative dataflow wherein datapath makes sure that destinationbuffer is filled to its maximum length
sl@0: before sending it to the sound driver. Sending the buffer directly to the device causes underflow incase of VBR codecs.
sl@0: */
sl@0: void CMMFSwCodecRecordDataPath::SetVbrFlag()
sl@0: 	{
sl@0: 	iVbrFlag = ETrue; // TODO this is seemingly redundant in a record case and could be pruned
sl@0: 	}
sl@0: 
sl@0: // MSwSetParamInterface - set various parameters etc
sl@0: 
sl@0: TInt CMMFSwCodecRecordDataPath::SetSampleRate(TInt aSampleRate)
sl@0: 	{
sl@0: 	iSampleRate = aSampleRate;
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 
sl@0: TInt CMMFSwCodecRecordDataPath::SetNumChannels(TInt aNumChannels)
sl@0: 	{
sl@0: 	iNumChannels = aNumChannels;
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 
sl@0: TInt CMMFSwCodecRecordDataPath::SetGain(TInt aGain)
sl@0: 	{
sl@0: 	iGain = aGain; // cache here so would be used on next Initialize()
sl@0: 	TInt error = KErrNone;
sl@0: 	if (iAudioInput)
sl@0: 		{
sl@0: 		MAIParamInterface* paramInterface = static_cast<MAIParamInterface*>(iAudioInput->Interface(KUidAIParamInterface));
sl@0: 		if (paramInterface)
sl@0: 			{
sl@0: 			error = paramInterface->SetGain(aGain);
sl@0: 			}
sl@0: 		}
sl@0: 	return error;
sl@0: 	}
sl@0: 
sl@0: TInt CMMFSwCodecRecordDataPath::GetBufferSizes(TInt& aMinSize, TInt& aMaxSize)
sl@0: 	{
sl@0: 	TInt error = KErrNotReady;
sl@0: 	if (iAudioInput)
sl@0: 		{
sl@0: 		MAIParamInterface* paramInterface = static_cast<MAIParamInterface*>(iAudioInput->Interface(KUidAIParamInterface));
sl@0: 		if (paramInterface)
sl@0: 			{
sl@0: 			error = paramInterface->GetBufferSizes(aMinSize, aMaxSize);
sl@0: 			}
sl@0: 		}
sl@0: 	return error;
sl@0: 	}
sl@0: 
sl@0: TInt CMMFSwCodecRecordDataPath::GetSupportedSampleRates(RArray<TInt>& aSupportedSampleRates)
sl@0:     {
sl@0:     TInt error = KErrNotReady;
sl@0:     if (iAudioInput)
sl@0:         {
sl@0:         MAIParamInterface* paramInterface = static_cast<MAIParamInterface*>(iAudioInput->Interface(KUidAIParamInterface));
sl@0:         if (paramInterface)
sl@0:             {
sl@0:             error = paramInterface->GetSupportedSampleRates(aSupportedSampleRates);
sl@0:             }
sl@0:         }
sl@0:     return error;
sl@0:     }
sl@0: 
sl@0: CMMFSwCodecRecordDataPath::TSwCodecDataPathState CMMFSwCodecRecordDataPath::State() const
sl@0:     {
sl@0:     // Note: code assumes stopped, record and paused states are grouped consecutively
sl@0:     if (iState==ERecordStateCreated)
sl@0:         {
sl@0:         return EStopped;
sl@0:         }
sl@0:     else if (iState >= ERecordStateRecording && iState <= ERecordStateEmptiedPartialBuffer)
sl@0:         {
sl@0:         return EPlaying;
sl@0:         }
sl@0:     else
sl@0:         {
sl@0:         return EPaused;
sl@0:         }
sl@0:     }
sl@0: 
sl@0: TBool CMMFSwCodecRecordDataPath::RecordOrPause() const
sl@0:     {
sl@0:     // Note: code assumes stopped, record and paused states are grouped consecutively
sl@0:     return iState >= ERecordStateRecording;
sl@0:     }
sl@0: 
sl@0: TBool CMMFSwCodecRecordDataPath::IsPaused() const
sl@0:     {
sl@0:     // Note: code assumes stopped, record and paused states are grouped consecutively
sl@0:     return iState >= ERecordStateRecordingPaused;
sl@0:     }
sl@0: 
sl@0: // TODO - these functions are padding out from the old RMdaDevSound scheme.
sl@0: // They are no longer used here, but are used for playing...
sl@0: 
sl@0: void CMMFSwCodecRecordDataPath::BufferFilledL(CMMFDataBuffer& /*aBuffer*/)
sl@0: 	{
sl@0: 	ASSERT(EFalse);
sl@0: 	}
sl@0: 
sl@0: void CMMFSwCodecRecordDataPath::SoundDeviceException(TInt /*aError*/)
sl@0: 	{
sl@0: 	ASSERT(EFalse);
sl@0: 	}
sl@0: