// 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 <e32std.h>

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

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

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

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

#include "log.h"

#include "omxilmicsourceprocessingfunction.h"

#include "omxilmicsourceconst.h"

//The maxium number of sample rates the sound driver can support

const TInt KSAMPERATESNUMBER = ESoundRate48000Hz + 1;

const OMX_U32

COmxILMicSourceProcessingFunction::KSampleRates[KSAMPERATESNUMBER] = {7350, 8000, 8820,

																	  9600, 11025, 12000,

																	  14700, 16000,22050,

																	  24000, 29400, 32000,

																	  44100, 48000};

const TInt COmxILMicSourceProcessingFunction::CCommandsQueue::KMaxMsgQueueEntries;

COmxILMicSourceProcessingFunction*

COmxILMicSourceProcessingFunction::NewL(MOmxILCallbackNotificationIf& aCallbacks,

										MOmxILClockComponentCmdsIf& aClientClockPort)

	{

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

	COmxILMicSourceProcessingFunction* self =

		new (ELeave)COmxILMicSourceProcessingFunction(aCallbacks, aClientClockPort);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void

COmxILMicSourceProcessingFunction::ConstructL()

	{

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

    iTransitionToPauseWait = new(ELeave) CActiveSchedulerWait();

    User::LeaveIfError(iTransitionToPauseWaitSemaphore.CreateLocal(0));

    //record the ID of the creator thread for later use

    iOwnerThreadId = RThread().Id();

    //Loading physical sound device

    TInt err = User::LoadPhysicalDevice(KSndPddFileName);

	if(err != KErrNone && err != KErrAlreadyExists)

		{

		User::Leave(err);

		}

    //Loading logical sound driver

	err = User::LoadLogicalDevice(KSndLddFileName);

	if(err != KErrNone && err != KErrAlreadyExists)

		{

		User::Leave(err);

		}

#ifdef SYMBIAN_MICSOURCE_DYNAMIC_SETTINGS

    User::LeaveIfError(iMicSource.Open(KSoundScRxUnit0));

    //Get initial setting from device

    iMicSourceSettings.iVolume = iMicSource.Volume();

    TSoundFormatsSupportedV02Buf capsBuf;

    iMicSource.Caps(capsBuf);

    iMicSourceSettings.iSupportedSoundFormat = capsBuf();

    TCurrentSoundFormatV02Buf audioFormatBuf;

    iMicSource.AudioFormat(audioFormatBuf);

    iMicSourceSettings.iCurSoundFormat = audioFormatBuf();

    iMicSource.Close();

#else //SYMBIAN_MICSOURCE_DYNAMIC_SETTINGS

    iMicSourceSettings.iVolume = KMICSOURCE_VOLUME_DEFAULT;

	iMicSourceSettings.iMute = EFalse;

    //fill in default supported settings

    iMicSourceSettings.iSupportedSoundFormat.iChannels = KMICSOURCE_CHANNELS_SUPPORT;

    iMicSourceSettings.iSupportedSoundFormat.iDataFormats = KMICSOURCE_DATAFORMATS_SUPPORT;

    iMicSourceSettings.iSupportedSoundFormat.iDirection = KMICSOURCE_SOUNDDIRECTION;

    iMicSourceSettings.iSupportedSoundFormat.iEncodings = KMICSOURCE_ENCODING_SUPPORT;

    iMicSourceSettings.iSupportedSoundFormat.iHwConfigNotificationSupport = KMICSOURCE_HWCONFIGNOTIFICATION_SUPPORT;

    iMicSourceSettings.iSupportedSoundFormat.iRates = KMICSOURCE_SAMPLERATES_SUPPORT;

    iMicSourceSettings.iSupportedSoundFormat.iRequestAlignment = KMICSOURCE_REQUESTALIGNMENT_SUPPORT;

    iMicSourceSettings.iSupportedSoundFormat.iRequestMinSize = KMICSOURCE_REQUESTMINSIZE_SUPPORT;

    //fill in default current sound settings

    iMicSourceSettings.iCurSoundFormat.iChannels = KMICSOURCE_CHANNELS_DEFAULT;

    iMicSourceSettings.iCurSoundFormat.iDataFormat = KMICSOURCE_SOUNDDATAFORMAT_DEFAULT;

    iMicSourceSettings.iCurSoundFormat.iEncoding = KMICSOURCE_SOUNDENCODING_DEFAULT;

    iMicSourceSettings.iCurSoundFormat.iRate = KMICSOURCE_SOUNDRATE_DEFAULT;

#endif //SYMBIAN_MICSOURCE_DYNAMIC_SETTINGS

	iBufferQueue = CBufferQueue::NewL(*this);

	iCommandsQueue = CCommandsQueue::NewL(*this);

	iMediaStartTime = 0;

	iTotalBytesRecorded = 0;

	}

COmxILMicSourceProcessingFunction::COmxILMicSourceProcessingFunction(

	MOmxILCallbackNotificationIf& aCallbacks,

	MOmxILClockComponentCmdsIf& aClientClockPort)

	:

	COmxILProcessingFunction(aCallbacks),

	iInitialPendingBufferOffset(-1),

	ipClientClockPort(&aClientClockPort)

	{

    DEBUG_PRINTF(_L8("COmxILMicSourceProcessingFunction::COmxILMicSourceProcessingFunction"));

	}

COmxILMicSourceProcessingFunction::~COmxILMicSourceProcessingFunction()

	{

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

    delete iTransitionToPauseWait;

    iTransitionToPauseWaitSemaphore.Close();

    delete iBufferQueue;

    delete iCommandsQueue;

    iMicSource.Close();

	User::FreeLogicalDevice(KDevSoundScName);

	TName pddName(KDevSoundScName);

	pddName.Append(KSndPddWildcardExtension);

	TFindPhysicalDevice findPD(pddName);

	TFullName findResult;

	while(KErrNone == findPD.Next(findResult))

		{

		User::FreePhysicalDevice(findResult);

		findPD.Find(pddName); // Reset the find handle now that we have deleted something from the container.

		}

	}

void COmxILMicSourceProcessingFunction::FillParamPCMModeType(OMX_AUDIO_PARAM_PCMMODETYPE& aPcmModeType) const

	{

    DEBUG_PRINTF(_L8("COmxILMicSourceProcessingFunction::FillParamPCMModeType"));

	aPcmModeType.eNumData = OMX_NumericalDataSigned;

    aPcmModeType.eEndian = OMX_EndianBig;

    aPcmModeType.bInterleaved =

	(iMicSourceSettings.iCurSoundFormat.iDataFormat == ESoundDataFormatInterleaved)

		? OMX_TRUE : OMX_FALSE;

	aPcmModeType.nBitPerSample = ConvertEnumToBitsPerSample(

		iMicSourceSettings.iCurSoundFormat.iEncoding);

    aPcmModeType.nSamplingRate = ConvertEnumToSampleRate(iMicSourceSettings.iCurSoundFormat.iRate);

	aPcmModeType.ePCMMode = OMX_AUDIO_PCMModeLinear;

    aPcmModeType.nChannels = static_cast<OMX_U32>(iMicSourceSettings.iCurSoundFormat.iChannels);

	if(aPcmModeType.nChannels == 1)

		{

		aPcmModeType.eChannelMapping[0] = OMX_AUDIO_ChannelCF;

		}

	else

		{

		//Assume the device only supports 2 channels as maxium

		//TODO: Add more channel mapping options for different number of channels.

		aPcmModeType.eChannelMapping[0] = OMX_AUDIO_ChannelLF;

		aPcmModeType.eChannelMapping[1] = OMX_AUDIO_ChannelRF;

		}

	}

TInt COmxILMicSourceProcessingFunction::GetVolume() const

	{

    DEBUG_PRINTF(_L8("COmxILMicSourceProcessingFunction::GetVolume"));

	return iMicSourceSettings.iVolume;

	}

OMX_U32 COmxILMicSourceProcessingFunction::ConvertEnumToSampleRate(TSoundRate aEnum)

	{

	return KSampleRates[aEnum];

	}

OMX_U32 COmxILMicSourceProcessingFunction::ConvertEnumToBitsPerSample(

	TSoundEncoding aEnum)

	{

	OMX_U32 nBitPerSample = 0;

	switch(aEnum)

	{

	case ESoundEncoding8BitPCM:

		nBitPerSample = 8;

		break;

	case ESoundEncoding16BitPCM:

		nBitPerSample = 16;

		break;

	case ESoundEncoding24BitPCM:

		nBitPerSample = 24;

		break;

	default:

		// Assume the default is 16 bits

		nBitPerSample = 16;

		break;

	};

	return nBitPerSample;

	}

TSoundRate COmxILMicSourceProcessingFunction::ConvertEnumToSampleRate(OMX_U32 aSampleRate)

	{

	TSoundRate rate = ESoundRate48000Hz;

	for(TInt index = 0; index < KSAMPERATESNUMBER; ++index)

		{

		if(KSampleRates[index] == aSampleRate)

			{

			rate = static_cast<TSoundRate>(index);

			break;

			}

		}

	return rate;

	}

OMX_ERRORTYPE

COmxILMicSourceProcessingFunction::StateTransitionIndication(TStateIndex aNewState)

	{

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

    OMX_ERRORTYPE err = OMX_ErrorNone;

	switch(aNewState)

		{

	case EStateExecuting:

		{

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

		OMX_STATETYPE previousState = iState;

        iState = OMX_StateExecuting;

		if (ipClientClockPort->IsClockComponentAvailable())

		    {

		    // Only record if clock is running

		    OMX_TIME_CONFIG_CLOCKSTATETYPE clockState;

		    OMX_ERRORTYPE omxError = ipClientClockPort->GetClockState(clockState);

		    if (OMX_ErrorNone != omxError)

		        {

		        iCallbacks.ErrorEventNotification(omxError);

		        break;     

		        }

		    if (OMX_TIME_ClockStateRunning != clockState.eState)

		        {

		        break;

		        }

		    }

		TInt error(KErrGeneral);

		if(previousState == OMX_StatePause) //going from Paused to Executing -> resume recording

		    {

		    error = iCommandsQueue->Resume();

		    }

		else

		    {

		    error = iCommandsQueue->StartRecording();

		    }

        if (error != KErrNone)

			{

			//TODO: should not we roll back to the previous state here? ie: iState = previousState;

			return OMX_ErrorInsufficientResources;

			}

		}

		break;

	case EStateInvalid:

		{

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

		iStartedRecording = EFalse;

		if(iState == OMX_StateExecuting || iState == OMX_StatePause)

			{

			iCommandsQueue->CleanupBufferQueue();

			iCommandsQueue->CloseDevice();

			}

		iState = OMX_StateInvalid;

		}

		break;

	case EStatePause:

		{

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

		if(iState == OMX_StateExecuting) //only do anything iff pausing in executing state

		    {

		    iStartedRecording = EFalse;

            if (iCommandsQueue->Pause() != KErrNone)

                {

                iState = OMX_StateExecuting; //transition to Paused state failed; roll back state to Exectuing

                return OMX_ErrorInsufficientResources;

                }

            WaitForTransitionToPauseToFinish(); //blocking this state transition here until Bufferqueue finishes processing data

		    }

		else //going from a state other than Executing -> no action needed

		    {

		    iState = OMX_StatePause;

		    }

		}

		break;

	case EStateIdle:

		{

		iStartedRecording = EFalse;

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

		iState = OMX_StateIdle;

		}

		break;

	case EStateLoaded:

		{

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

		iCommandsQueue->CloseDevice();

		iState = OMX_StateLoaded;

		}

		break;

	case EStateWaitForResources:

		{

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

		if(iState == OMX_StateExecuting || iState == OMX_StatePause)

			{

			if (iCommandsQueue->StopAndReset() != KErrNone)

				{

				return OMX_ErrorInsufficientResources;

				}

			if (iCommandsQueue->CleanupBufferQueue() != KErrNone)

				{

				return OMX_ErrorInsufficientResources;

				}

			}

		iState = OMX_StateWaitForResources;

		}

		break;

	case ESubStateLoadedToIdle:

		{

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

		//always cleanup the buffer queue before other initialization

		iBufferQueue->Cleanup();

		if (iMicSource.Open(KSoundScRxUnit0) != KErrNone)

			{

			return OMX_ErrorInsufficientResources;

			}

		TInt currentVolume = iMicSource.Volume();

		TInt volume = (iMicSourceSettings.iMute) ? 0 : iMicSourceSettings.iVolume;

		if(currentVolume != volume && KErrNone != iMicSource.SetVolume(volume))

			{

			iMicSourceSettings.iVolume = currentVolume;

			iMicSourceSettings.iMute = EFalse;

			err = PostVolumeChangeEvent();

			}

		TPckgBuf<TCurrentSoundFormatV02> curSoundFormatBuf(iMicSourceSettings.iCurSoundFormat);

		if(KErrNone != iMicSource.SetAudioFormat(curSoundFormatBuf))

			{

		    TCurrentSoundFormatV02Buf audioFormatBuf;

		    iMicSource.AudioFormat(audioFormatBuf);

		    iMicSourceSettings.iCurSoundFormat = audioFormatBuf();

			err = PostAudioFormatChangeEvent();

			}

		}

		break;

	case ESubStateIdleToLoaded:

		{

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

		if (iCommandsQueue->CleanupBufferQueue() != KErrNone)

			{

			return OMX_ErrorInsufficientResources;

			}

		}

		break;

	case ESubStateExecutingToIdle:

	case ESubStatePauseToIdle:

		{

		if (iCommandsQueue->StopAndReset() != KErrNone)

			{

			return OMX_ErrorInsufficientResources;

			}

		}

		break;

	default:

		{

		return OMX_ErrorIncorrectStateTransition;

		}

		};

	return err;

	}

OMX_ERRORTYPE COmxILMicSourceProcessingFunction::PostVolumeChangeEvent()

	{

	OMX_AUDIO_CONFIG_VOLUMETYPE volumeType;

	volumeType.sVolume.nValue = iMicSourceSettings.iVolume;

	volumeType.sVolume.nMin = KMICSOURCE_VOLUME_MIN;

	volumeType.sVolume.nMax = KMICSOURCE_VOLUME_MAX;

	volumeType.nSize = sizeof(OMX_AUDIO_CONFIG_VOLUMETYPE);

	volumeType.bLinear = OMX_TRUE;

	volumeType.nPortIndex = KMICSOURCE_APB0PORT_INDEX;

	volumeType.nVersion = TOmxILVersion(KMicSourceComponentVersionMajor,

										KMicSourceComponentVersionMinor,

										KMicSourceComponentVersionRevision,

										KMicSourceComponentVersionStep);

	TPckgBuf<OMX_AUDIO_CONFIG_VOLUMETYPE> volumeTypeBuf(volumeType);

	return iCallbacks.PortSettingsChangeNotification(KMICSOURCE_APB0PORT_INDEX,

													 OMX_IndexConfigAudioVolume,

													 volumeTypeBuf);

	}

OMX_ERRORTYPE COmxILMicSourceProcessingFunction::PostAudioFormatChangeEvent()

	{

	OMX_AUDIO_PARAM_PCMMODETYPE pcmProfile;

	pcmProfile.nSize = sizeof(OMX_AUDIO_PARAM_PCMMODETYPE);

	pcmProfile.nVersion = TOmxILVersion(KMicSourceComponentVersionMajor,

										KMicSourceComponentVersionMinor,

										KMicSourceComponentVersionRevision,

										KMicSourceComponentVersionStep);

	pcmProfile.nPortIndex = KMICSOURCE_APB0PORT_INDEX;

	FillParamPCMModeType(pcmProfile);

	TPckgBuf<OMX_AUDIO_PARAM_PCMMODETYPE> pcmProfileBuf(pcmProfile);

	return iCallbacks.PortSettingsChangeNotification(KMICSOURCE_APB0PORT_INDEX,

													OMX_IndexParamAudioPcm,

													pcmProfileBuf);

	}

OMX_ERRORTYPE

COmxILMicSourceProcessingFunction::BufferFlushingIndication(TUint32 aPortIndex,

															OMX_DIRTYPE aDirection)

	{

    DEBUG_PRINTF(_L8("COmxILMicSourceProcessingFunction::BufferFlushingIndication"));

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

		(aPortIndex == 0 && aDirection == OMX_DirOutput))

		{

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

			{

			return OMX_ErrorInsufficientResources;

			}

		iBufferQueue->FlushBuffers(OMX_DirOutput);

		}

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE

COmxILMicSourceProcessingFunction::ParamIndication(OMX_INDEXTYPE aParamIndex,

												const TAny* apComponentParameterStructure)

	{

    DEBUG_PRINTF(_L8("COmxILMicSourceProcessingFunction::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);

		TCurrentSoundFormatV02 newSoundFormat;

		newSoundFormat.iChannels = pPcmProfile->nChannels;

		newSoundFormat.iReserved1 = 0;

		if(0 == (iMicSourceSettings.iSupportedSoundFormat.iChannels & (KSoundMonoChannel << (newSoundFormat.iChannels - 1))))

			{

			err = OMX_ErrorUnsupportedSetting;

			break;

			}

		newSoundFormat.iDataFormat = (pPcmProfile->bInterleaved == OMX_TRUE)

									 ? ESoundDataFormatInterleaved : ESoundDataFormatNonInterleaved;

		if(0 == (iMicSourceSettings.iSupportedSoundFormat.iDataFormats & (KSoundDataFormatInterleaved << newSoundFormat.iDataFormat)))

			{

			err = OMX_ErrorUnsupportedSetting;

			break;

			}

		switch(pPcmProfile->nBitPerSample)

			{

			case 8:

				newSoundFormat.iEncoding = ESoundEncoding8BitPCM;

				break;

			case 24:

				newSoundFormat.iEncoding = ESoundEncoding24BitPCM;

				break;

			default:

				newSoundFormat.iEncoding = ESoundEncoding16BitPCM;

				break;

			}

		if(0 == (iMicSourceSettings.iSupportedSoundFormat.iEncodings & (KSoundEncoding8BitPCM << newSoundFormat.iEncoding)))

			{

			err = OMX_ErrorUnsupportedSetting;

			break;

			}

		newSoundFormat.iRate = ConvertEnumToSampleRate(pPcmProfile->nSamplingRate);

		if(0 == (iMicSourceSettings.iSupportedSoundFormat.iRates & (KSoundRate7350Hz << newSoundFormat.iRate)))

			{

			err = OMX_ErrorUnsupportedSetting;

			break;

			}