// Copyright (c) 2002-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:

//

#include "MmfAudioInput.h"

#include <ecom/implementationproxy.h>

#include <mmf/server/mmfformat.h>

#include <mmf/plugin/mmfaudioiointerfaceuids.hrh>

void Panic(TInt aPanicCode)

	{

	_LIT(KMMFAudioInputPanicCategory, "MMFAudioInput");

	User::Panic(KMMFAudioInputPanicCategory, aPanicCode);

	}

/**

Static standard SymbianOS 2 phase constuction method.

Constucts this audio device.

@return A pointer to a MDataSource returned on successful construction.

*/

MDataSource* CMMFAudioInput::NewSourceL()

	{

	CMMFAudioInput* self = new (ELeave) CMMFAudioInput ;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return  STATIC_CAST( MDataSource*, self );

	}

/**

Standard SymbianOS ConstructL.

Used to initialise member varibles with device specific behaviour.

*/

void CMMFAudioInput::ConstructL()

	{

	iDataTypeCode = KMMFFourCCCodePCM16;

	iActiveSchedulerWait = new(ELeave) CActiveSchedulerWait;

	}

/**

Standard SymbianOS destructor.

*/

CMMFAudioInput::~CMMFAudioInput()

	{

	delete iActiveSchedulerWait;

	if (iMMFDevSound)

		{

		iMMFDevSound->Stop();

		delete iMMFDevSound;

		}

	}

/**

Overridable constuctor specific to this datasource.

@param  aInitData

        The initialisation data.

*/

void CMMFAudioInput::ConstructSourceL( const TDesC8& /*aInitData*/ ) 

	{

	}

/**

@deprecated

Gets audio from hardware device abstracted MMFDevsound (not used).

@param  aBuffer

        The data to read in from a Hardware Device

@param  aConsumer

        The MDataSink consuming the data contained in aBuffer.

*/

void CMMFAudioInput::HWFillBufferL(CMMFBuffer* /*aBuffer*/, MDataSink* /*aConsumer*/)

	{

	}

/**

Gets audio from MMFDevsound.

@pre

iMMFDevSound must be loaded.

@param  aBuffer

        The data to read in from a Devsound device.

@param  aConsumer

        The MDataSink consuming the data contained in aBuffer.

@param  aMediaId

        Type of data supplied - currently ignored.

*/

void CMMFAudioInput::FillBufferL(CMMFBuffer* aBuffer, MDataSink* aConsumer, TMediaId /* aMediaId */)

	{

	iConsumer = aConsumer;

	if (!iMMFDevSound)

		Panic(EMMFAudioInputDevSoundNotLoaded);

	if ((iState == EPaused) && (iPausePending != EFalse) && (iFirstBufferRequested) )

  		{

  		User::Leave(KErrNotReady);

  		}

	if ((aBuffer != NULL) && (!CMMFBuffer::IsSupportedDataBuffer(aBuffer->Type())))

		User::Leave(KErrNotSupported);

	if (aConsumer == NULL)

		User::Leave(KErrArgument);

	//this is a one-shot "prime" funtion for MMFDevSound as first buffer is uninitialised

	if (!iFirstBufferRequested)

		{

		iMMFDevSound->RecordInitL();

		iFirstBufferRequested = ETrue;

		return;

		}

	if (iState != EDevSoundReady && iState != EPaused)

		{

		User::Leave(KErrNotReady);

		}

	iMMFDevSound->RecordData();

	}

/**

Indicates the data sink has emptied the buffer.

Called by the data path's MDataSink when it has emptied the buffer.

The default implementation is empty.

@param  aBuffer

        The data buffer that has been emptied (not used).

*/

void CMMFAudioInput::BufferEmptiedL(CMMFBuffer* /*aBuffer*/)

	{

	}

/**

Tests whether a source buffer can be created.

The default imlpementation returns true.

@return	A boolean indicating if the buffer can be made. ETrue if the buffer can be created, false

        otherwise.

*/

TBool CMMFAudioInput::CanCreateSourceBuffer()

	{

	return ETrue;

	}

/**

Creates a source buffer.

Intended for asynchronous usage (buffers supplied by Devsound device)

@param  aMediaId

		The Media ID. Not used in the default implementation.

@param  aReference

        A boolean indicating if MDataSource owns the buffer. ETrue if it does, EFalse if it does 

        not.

@return The buffer created (this will always be NULL when asychronous).

*/

CMMFBuffer* CMMFAudioInput::CreateSourceBufferL(TMediaId /*aMediaId*/, TBool &aReference)

	{

	CMMFDataBuffer* buf = NULL;

	aReference = ETrue; // This is a reference from DevSound

	return buf;

	}

/**

Creates a source buffer.

Intended for synchronous usage.

@param  aMediaId

        The Media ID. Not used in the default implementation.

@return The buffer created

*/

CMMFBuffer* CMMFAudioInput::CreateSourceBufferL(TMediaId /*aMediaId*/)

	{

	CMMFDataBuffer* buf = CMMFDataBuffer::NewL(KAudioInputDefaultFrameSize);

	return buf;

	}

/**

Primes the source.

This is a virtual function that each derived class must implement, but may be left blank for

default behaviour.

Overridable PrimeL method. Additional Prime method specific to this DataSource.

*/

void CMMFAudioInput::SourcePrimeL()

	{

	iState = EDevSoundReady;

	}

/**

Pauses the source.

This is a virtual function that each derived class must implement, but may be left blank for default 

behaviour.

Overridable PauseL method. Additional Pause method specific to this DataSource.

*/

void CMMFAudioInput::SourcePauseL()

	{

	if (iState == EDevSoundReady)

		{//not waiting on a buffer being played so stop devsound now

		iState = EPaused;

		if (iFirstBufferRead)

			{

			if (!iMMFDevSound)

				Panic(EMMFAudioInputDevSoundNotLoaded);

			else

				iMMFDevSound->Pause();

			}

		else

			iPausePending = ETrue; // Wait for recording to get started.

		}

	//else if Devsound isn't ready then no point in stopping it

	}

/**

Stops the source.

This is a virtual function that each derived class must implement, but may be left blank for default 

behaviour.

Overridable StopL method. Additional Stop method specific to this DataSource.

*/

void CMMFAudioInput::SourceStopL()

	{

	iStopped = ETrue;

	// This is done in Audio Output as well, not sure whether its needed here or not.

	// Pause will be called before SourceStopL() and pause will take care of closing

	// DevSound

	if (iState == EDevSoundReady  || iState == EPaused)

		{//not waiting on a buffer being played so stop devsound now

		iState = EIdle;

		if (iFirstBufferRequested)

			{

			if (!iMMFDevSound)

				Panic(EMMFAudioInputDevSoundNotLoaded);

			else

				{

				iMMFDevSound->Stop();

				}

			iFirstBufferRequested = EFalse;

			iFirstBufferRead = EFalse;

			}

		}

	//else if Devsound isn't ready then no point in stopping it

	}

/**

Plays the source.

This is a virtual function that each derived class must implement, but may be left blank for default

behaviour.

Overridable PlayL method. Additional Play method specific to this DataSource.

*/

void CMMFAudioInput::SourcePlayL()

	{

	}

/**

Logs on the source thread.

Thread specific initialization procedure for this device. Runs automatically on thread construction.

@param  aEventHandler

        The event handler.

@return An error code indicating if the function call was successful. KErrNone on success, otherwise

        another of the system-wide error codes.

*/

TInt CMMFAudioInput::SourceThreadLogon(MAsyncEventHandler& aEventHandler)

	{

	iEventHandler = &aEventHandler;

	TInt err = KErrNone;

	if (!iDevSoundLoaded)

		TRAP(err, LoadL());

	return err;

	}

/**

Logs off the source thread.

Thread specific destruction procedure for this device. Runs automatically on thread destruction.

*/

void CMMFAudioInput::SourceThreadLogoff()

	{

	if(iMMFDevSound)

		{

		iMMFDevSound->Stop();

		delete iMMFDevSound;

		iMMFDevSound = NULL;

		}

	iDevSoundLoaded = EFalse;

	iState = EIdle;

	}

/*

@internaTechnology

@pre

dev sound should be created and loaded.

*/

void CMMFAudioInput::ConfigDevSoundL()

	{

	//[precondition dev sound created ]

	ASSERT( iMMFDevSound );

	// Query DevSound capabilities and Try to use DevSound sample rate and 

	// mono/stereo capability

	TMMFCapabilities devSoundCaps = iMMFDevSound->Capabilities();

	// get current config

	TMMFCapabilities devSoundConfig = iMMFDevSound->Config();

	// Default PCM16

	devSoundConfig.iEncoding = EMMFSoundEncoding16BitPCM;

	// 1 = Monophonic and 2 == Stereo

	if (((iSinkChannels == 1) && (devSoundCaps.iChannels & EMMFMono)) ||

		((iSinkChannels == 2) && (devSoundCaps.iChannels & EMMFStereo)))

		devSoundConfig.iChannels = iSinkChannels;

	// Check for std sample rates.

	if ((iSinkSampleRate == 96000) && (devSoundCaps.iRate & EMMFSampleRate96000Hz))

		devSoundConfig.iRate = EMMFSampleRate96000Hz;

	else if ((iSinkSampleRate == 88200) && (devSoundCaps.iRate & EMMFSampleRate88200Hz))

		devSoundConfig.iRate = EMMFSampleRate88200Hz;

	else if ((iSinkSampleRate == 64000) && (devSoundCaps.iRate & EMMFSampleRate64000Hz))

		devSoundConfig.iRate = EMMFSampleRate64000Hz;

	else if ((iSinkSampleRate == 48000) && (devSoundCaps.iRate & EMMFSampleRate48000Hz))

		devSoundConfig.iRate = EMMFSampleRate48000Hz;

	else if ((iSinkSampleRate == 44100) && (devSoundCaps.iRate & EMMFSampleRate44100Hz))

		devSoundConfig.iRate = EMMFSampleRate44100Hz;

	else if ((iSinkSampleRate == 32000) && (devSoundCaps.iRate & EMMFSampleRate32000Hz))

		devSoundConfig.iRate = EMMFSampleRate32000Hz;

	else if ((iSinkSampleRate == 24000) && (devSoundCaps.iRate & EMMFSampleRate24000Hz))

		devSoundConfig.iRate = EMMFSampleRate24000Hz;

	else if ((iSinkSampleRate == 22050) && (devSoundCaps.iRate & EMMFSampleRate22050Hz))

		devSoundConfig.iRate = EMMFSampleRate22050Hz;

	else if ((iSinkSampleRate == 16000) && (devSoundCaps.iRate & EMMFSampleRate16000Hz))

		devSoundConfig.iRate = EMMFSampleRate16000Hz;

	else if ((iSinkSampleRate == 12000) && (devSoundCaps.iRate & EMMFSampleRate12000Hz))

		devSoundConfig.iRate = EMMFSampleRate12000Hz;

	else if ((iSinkSampleRate == 11025) && (devSoundCaps.iRate & EMMFSampleRate11025Hz))

		devSoundConfig.iRate = EMMFSampleRate11025Hz;

	else if ((iSinkSampleRate == 8000) && (devSoundCaps.iRate & EMMFSampleRate8000Hz))

		devSoundConfig.iRate = EMMFSampleRate8000Hz; 

	else 

		{

		// pick the maximum sample rate available

		if (devSoundCaps.iRate & EMMFSampleRate96000Hz)

			devSoundConfig.iRate = EMMFSampleRate96000Hz;

		else if (devSoundCaps.iRate & EMMFSampleRate88200Hz)

			devSoundConfig.iRate = EMMFSampleRate88200Hz;

		else if (devSoundCaps.iRate & EMMFSampleRate64000Hz)

			devSoundConfig.iRate = EMMFSampleRate64000Hz;

		else if (devSoundCaps.iRate & EMMFSampleRate48000Hz)

			devSoundConfig.iRate = EMMFSampleRate48000Hz;

		else if (devSoundCaps.iRate & EMMFSampleRate44100Hz)

			devSoundConfig.iRate = EMMFSampleRate44100Hz;

		else if (devSoundCaps.iRate & EMMFSampleRate32000Hz)

			devSoundConfig.iRate = EMMFSampleRate32000Hz;

		else if (devSoundCaps.iRate & EMMFSampleRate24000Hz)

			devSoundConfig.iRate = EMMFSampleRate24000Hz;

		else if (devSoundCaps.iRate & EMMFSampleRate22050Hz)

			devSoundConfig.iRate = EMMFSampleRate22050Hz;

		else if (devSoundCaps.iRate & EMMFSampleRate16000Hz)

			devSoundConfig.iRate = EMMFSampleRate16000Hz;

		else if (devSoundCaps.iRate & EMMFSampleRate12000Hz)

			devSoundConfig.iRate = EMMFSampleRate12000Hz;

		else if (devSoundCaps.iRate & EMMFSampleRate11025Hz)

			devSoundConfig.iRate = EMMFSampleRate11025Hz;

		else if (devSoundCaps.iRate & EMMFSampleRate8000Hz)

			devSoundConfig.iRate = EMMFSampleRate8000Hz;

		else

			ASSERT(EFalse); // if we don't support any sample rates, there is not much we can do

		}

	iMMFDevSound->SetConfigL(devSoundConfig);

	}

/**

Negotiates with the sink.

Called if the source's setup depends on sink.

@param  aSink

        The Data sink. Takes an MDataSink reference so a DataSource can negotiate with this

        MDataSource.

*/

void CMMFAudioInput::NegotiateSourceL(MDataSink& aSink)

	{

	if (aSink.DataSinkType() == KUidMmfFormatEncode) 

		{//sink is a clip so for now set sink settings to match sink

		iSinkSampleRate = ((CMMFFormatEncode&)aSink).SampleRate(); 

		iSinkChannels = ((CMMFFormatEncode&)aSink).NumChannels();

		iSinkFourCC.Set(aSink.SinkDataTypeCode(TMediaId(KUidMediaTypeAudio)));

		// if the sink's sample rate is undefined, try to obtain and use a

		// default sample rate from the sink. If this is zero, use 8K

		if (iSinkSampleRate == 0)

			{

			iSinkSampleRate = ((CMMFFormatEncode&)aSink).GetDefaultSampleRate(); 

			if (iSinkSampleRate == 0)

				iSinkSampleRate = 8000;

			}

		}

	if (iMMFDevSound == NULL)

  		User::Leave(KErrNotReady);

	TMMFState prioritySettingsState = iPrioritySettings.iState; //should be EMMFStateRecording

	//to use the GetSupportedOutputDatatypes but we'll save it just in case it's not

	iPrioritySettings.iState = EMMFStateRecording; //if playing does not support any output data types

	RArray<TFourCC> supportedDataTypes;

	//note Output data types becuase if we are recording audio ie audio input

	//the data is sent as an output from DevSound

	TRAPD(err, iMMFDevSound->GetSupportedOutputDataTypesL(supportedDataTypes, iPrioritySettings));

	iPrioritySettings.iState = prioritySettingsState;

	if (err == KErrNone)

		{

		if (supportedDataTypes.Find(iSinkFourCC) == KErrNotFound)

			{//the source fourCC code could not be found in the list of 

			//data types supported by the Devsound therefor default to pcm16

			iDataTypeCode = KMMFFourCCCodePCM16;	

			}

		else

			{

			//the DevSound does support the same datatype as the source 

			//so set the fourcc to that of the source

			iDataTypeCode = iSinkFourCC;

			}

		}

	supportedDataTypes.Close();

	if (err == KErrNotSupported)

		{//if the Devsound does not support the GetSupportedOutputDataTypesL method

		//then assume that the DevSound is pcm16 only

		iDataTypeCode = KMMFFourCCCodePCM16;	

		}

	else if (err != KErrNone) //we had a real leave error from GetSupportedOuputDataTypesL

		{

		User::Leave(err);

		}

    // Prevent defect when SourcePrimeL is called before NegotiateSourceL()

	// since characterization is ambiguous

    if(iState == EDevSoundReady)

      {

      iState = EIdle;

      }

  	// moved from LoadL - fix for DEF037168 - AD

	iMMFDevSound->InitializeL(*this, iDataTypeCode, EMMFStateRecording);

	// In some implementations InitializeComplete is sent

	// in context, so check before starting activeSchedulerWait.

	if (iState != EDevSoundReady)

		{

		iInitializeState = KRequestPending;

		iActiveSchedulerWait->Start();

		}		

	User::LeaveIfError(iInitializeState);

	iMMFDevSound->SetPrioritySettings(iPrioritySettings);

	// Attempt to configure DevSound to the same settings as the sink.

	// Need to do this after calling CMMFDevSound::InitializeL() as

	// this sets up the device capabilities 

	// (returned by iMMFDevSound->Capabilities()).

	ConfigDevSoundL();

	}

/**

Sets the source's priority settings.

@param  aPrioritySettings

        The source priority settings. Takes enumerations to determine audio record priority. Higher 

        numbers mean high priority (can interrupt lower priorities).

*/

void CMMFAudioInput::SetSourcePrioritySettings(const TMMFPrioritySettings& aPrioritySettings)

	{

	iPrioritySettings = aPrioritySettings;

	if (!iMMFDevSound)

		Panic(EMMFAudioInputDevSoundNotLoaded);

	else

		iMMFDevSound->SetPrioritySettings(iPrioritySettings);

	}

/**

Gets the data type code for the source specified by the media ID.

@param  aMediaId

        An optional parameter to specifiy a specific stream when the datasource contains more than

        one stream of data.

@return The 4CC of the data supplied by this source.

*/

TFourCC CMMFAudioInput::SourceDataTypeCode(TMediaId /*aMediaId*/)

	{

	return iDataTypeCode;

	}

/**

Sets the data type code for the source.

@param  aSourceFourCC

        The 4CC of the data supplied by this source.

@param  aMediaId

        The Media ID. An optional parameter to specifiy specific stream when datasource contains

        more than one stream of data.

@return An error code indicating if the function call was successful. KErrNone on success, otherwise

        another of the system-wide error codes.

*/

TInt CMMFAudioInput::SetSourceDataTypeCode(TFourCC aSourceFourCC, TMediaId /*aMediaId*/)

	{

	iDataTypeCode = aSourceFourCC;

	return KErrNone;

	}

/**

Gets the number of bytes played.

@return	The number of bytes played. If 16-bit divide this number returned by 2 to get word length.

*/

TInt CMMFAudioInput::BytesPlayed()

	{

	if (!iMMFDevSound)

		Panic(EMMFAudioInputDevSoundNotLoaded);

	return iMMFDevSound->SamplesPlayed();

	}

/**

Returns the sound device.

@pre

Dev Sound should be loaded.

Accessor function exposing public CMMFDevsound methods.

@return A reference to a CMMFDevSound objector.

*/

CMMFDevSound& CMMFAudioInput::SoundDevice()

	{

	if (!iMMFDevSound)

		{

		Panic(EMMFAudioInputDevSoundNotLoaded);

		}

	return *iMMFDevSound;

	}

/**

@deprecated

This method should not be used - it is provided to maintain SC with v7.0s.

@param  aAudioType

        The 4CC of the data supplied by this source.

*/

void CMMFAudioInput::SetDataTypeL(TFourCC aAudioType)

	{

	if (aAudioType != KMMFFourCCCodePCM16)

		{

		User::Leave(KErrNotSupported);

		}

	}	

/**

@deprecated

This method should not be used - it is provided to maintain SC with v7.0s.

@return The 4CC of the data supplied by this source.

*/

TFourCC CMMFAudioInput::DataType() const

	{

	return KMMFFourCCCodePCM16;

	}

/**

Loads audio device drivers and initialise this device.

*/

void CMMFAudioInput::LoadL()

	{

	//[ do all the work that can fail first

	// before we modify the internal state ]

	iMMFDevSound = CMMFDevSound::NewL();

	iFirstBufferRequested = EFalse;

	iFirstBufferRead = EFalse;

	if (iState != EDevSoundReady) 

		{

		iState = EIdle;

		}

	iDevSoundLoaded = ETrue;

	//[ assert dev sound has been constructed]

	ASSERT( iMMFDevSound );

	ASSERT( iDevSoundLoaded );

    ASSERT( !iFirstBufferRead );

	}

void CMMFAudioInput::DeviceMessage(TUid /*aMessageType*/, const TDesC8& /* aMsg */)

	{

	}

void CMMFAudioInput::InitializeComplete(TInt aError)

	{

	if (aError == KErrNone)

		{

		iState = EDevSoundReady;

		}

	if(iInitializeState == KRequestPending)

		{

		iInitializeState = aError;

		iActiveSchedulerWait->AsyncStop();

		}

	}

/**

ToneFinished MMFDevSoundObserver - should never get called.

*/

void CMMFAudioInput::ToneFinished(TInt /*aError*/)

	{

	//we should never get here during a record session!

	__ASSERT_DEBUG(EFalse,Panic(EMMFAudioInputPanicToneFinishedNotSupported));

	}

/**

BuffferToBeEmptied MMFDevSoundObserver

Called when stopped due to error.

*/

void CMMFAudioInput::BufferToBeEmptied(CMMFBuffer* aBuffer)

	{

	iDevSoundBuf = aBuffer;

	if (iFirstBufferRequested)

		{

		if (iPausePending)

			{

			aBuffer->SetLastBuffer(ETrue);

			iPausePending = EFalse;

			}

#ifdef _DEBUG

		TRAPD(err, iConsumer->BufferFilledL(aBuffer));

		__ASSERT_DEBUG(!err, Panic(err));

#else

		TRAP_IGNORE(iConsumer->BufferFilledL(aBuffer));

#endif

		iFirstBufferRead = ETrue;

		}

	}	

/**

RecordError MMFDevSoundObserver

Called when stopped due to error.

*/

void CMMFAudioInput::RecordError(TInt aError)

	{

	//[  two event categories will be used

	// which mirrors the datapath response ]

	//[ record the error ]

	iMMFDevsoundError = aError;

	TMMFEvent event( KMMFEventCategoryPlaybackComplete, aError);

	//[ send the event to the client.

	SendEventToClient(event);    

	// clear flags if there is an error.

	iPausePending = EFalse;

	//[ we are not going to stop devsound ]

	}

/**

BufferToBeFilled MMFDevSoundObserver - should never get called.

*/

void CMMFAudioInput::BufferToBeFilled(CMMFBuffer* /*aBuffer*/)

	{

	//we should never get here during a play session!

	__ASSERT_DEBUG(EFalse, Panic(EMMFAudioInputPanicPlayerDataUsedNotSupported));

	}

/**

PlayError MMFDevSoundObserver - should never get called.

*/

void CMMFAudioInput::PlayError(TInt /*aError*/)

	{

	//we should never get here during a record session!

	__ASSERT_DEBUG(EFalse, Panic(EMMFAudioInputPanicPlayErrorNotSupported));

	}

/**

ConvertError MMFDevSoundObserver - should never get called.

*/

void CMMFAudioInput::ConvertError(TInt /*aError*/)

	{

	}

void CMMFAudioInput::SendEventToClient(const TMMFEvent& aEvent)

	{

	iEventHandler->SendEventToClient(aEvent);

	}

// _________________________________________________________________________

// Exported proxy for instantiation method resolution

// Define the interface UIDs

const TImplementationProxy ImplementationTable[] = 

	{

		IMPLEMENTATION_PROXY_ENTRY(KMmfUidAudioInputInterface,	CMMFAudioInput::NewSourceL)

	};

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

	{

	aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

	return ImplementationTable;

	}