//audiocodec.cpp

// Copyright (c) 2006-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 <a3f/a3fbase.h>

#include <a3f/a3ffourcclookup.h>

#include <a3f/audioprocessingunittypeuids.h>

#include "maudiocodecadaptationobserver.h"

#include "audiocodec.h"

#include "resourcedata.h"

// THIS WILL REMAIN UNTIL THE REQUIREMENT WILL BE DEFINED

// THIS IMPLEMENTATION WILL WORK ONLY FOR HW DEVICES IMPLEMNETED AS SOFTWARE CODEC WRAPPERS

#define INCLUDE_HWDEVICES_AS_SWCODEC_WRAPPERS

#ifdef INCLUDE_HWDEVICES_AS_SWCODEC_WRAPPERS

#include <mmf/server/mmfswcodecwrappercustominterfacesuids.hrh>

#endif

const TInt KMicroSecsInOneSec = 1000000;

const TInt KHwDeviceDefaultDataLength= 9;

const TUint KDefaultMaxGain = 255; // TODO should discover at run time but this is value of current Symbian sound driver adaptor

//Values to find the request ask by the client

const TInt KRequestSampleRate = 0x0001;

const TInt KRequestMode = 0x0002;

const TAudioModeTableEntry KModeTableLookup[] = {

							{ EMMFMono, {KA3FModeMonoValue} },

							{ EMMFStereo, {KA3FModeStereoNonInterleavedValue} },

							};

// ---------------------------------------------------------------------------

// Constructor

// ---------------------------------------------------------------------------

CAudioCodec::CAudioCodec(TUid aTypeId, const CFourCCConvertor& aFourCCConvertor)

	: CActive(EPriorityStandard),

	iLastBuffer(EFalse),

	iHwDeviceState(EIdle),

	iLastBufferAck(EFalse), 

	iRampOperation(KNullUid)

	{

	TRACE_CREATE();

	DP_CONTEXT(CAudioCodec::CAudioCodec *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	if(aTypeId==KUidAudioEncoder)

		{

		iMode = EEncode;

		}

	else if(aTypeId==KUidAudioDecoder)

		{

		iMode = EDecode;

		}

	iFourCCConvertor = static_cast<CFourCCConvertor*>( const_cast<CFourCCConvertor*>(&aFourCCConvertor) );

	iHwDeviceInitArgs.iEapStreamId = 0;

	iHwDeviceInitArgs.iPolicyId = 0;

	DP_OUT();

	}

// ---------------------------------------------------------------------------

// Factory method

// ---------------------------------------------------------------------------

EXPORT_C CAudioCodec* CAudioCodec::NewL(TUid aTypeId, const CFourCCConvertor& aFourCCConvertor)

	{

	DP_STATIC_CONTEXT(CAudioCodec::NewL *CD0*, CtxDevSound, DPLOCAL);

	DP_IN();

	CAudioCodec* self = new(ELeave)CAudioCodec(aTypeId, aFourCCConvertor);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	DP0_RET(self, "0x%x");

	}

// ---------------------------------------------------------------------------

// Second phase constructor

// ---------------------------------------------------------------------------

void CAudioCodec::ConstructL()

	{

	DP_CONTEXT(CAudioCodec::ConstructL *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	CActiveScheduler::Add(this);

	DP_OUT();

	}

// ---------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------

CAudioCodec::~CAudioCodec()

	{

	DP_CONTEXT(CAudioCodec::~CAudioCodec *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	iAudioCodecObservers.Close();

	if (iHwDevice)

		{

		if (!iHwDeviceState == EStopped)

			{

			DP0(DLINFO, "StopAndDeleteCodec");

			iHwDevice->StopAndDeleteCodec();

			}

		delete iHwDevice;

		iHwDevice = NULL;

		}

	Cancel();

	DP_OUT();

	}

// ---------------------------------------------------------------------------

// CAudioCodec::SetFormat

// ---------------------------------------------------------------------------

EXPORT_C TInt CAudioCodec::SetFormat(TUid aFormat)

	{

	DP_CONTEXT(CAudioCodec::SetFormat *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	iFormat = aFormat;

	DP0_RET(KErrNone, "%d");

	}

// ---------------------------------------------------------------------------

// CAudioCodec::Initialize

// ---------------------------------------------------------------------------

EXPORT_C TInt CAudioCodec::Initialize()

	{

	DP_CONTEXT(CAudioCodec::Initialize *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err(KErrNone);

	TFourCC aFourCC(0);

	err = iFourCCConvertor->FormatToFourCC(iFormat,aFourCC);

	if(err == KErrNotFound)

		{

		err = KErrNotSupported;

		}

	if(err == KErrNone)

		{

		TRAP(err,  FourCCToHwDeviceUidL(aFourCC, iMode, iDeviceUid) );

		}

	if (err == KErrNone)

		{

		err = LoadHwDevice();

		}

#ifdef INCLUDE_HWDEVICES_AS_SWCODEC_WRAPPERS

	if (err == KErrNone)

		{

		TUid interfaceUid = {0};

		TAny* interface = NULL;

		if (iMode == EDecode)

			{

			interfaceUid.iUid = KMmfPlaySettingsCustomInterface;

			}

		else if(iMode == EEncode)

			{

			interfaceUid.iUid = KMmfRecordSettingsCustomInterface;

			}

		// This call at the sw codec wrapper creates the custom interfaces for playing and record

		if(iHwDevice)

			{

			interface = iHwDevice->CustomInterface(interfaceUid);

			if (iMode == EDecode)

				{

				iPlayCustomInterface = static_cast<MPlayCustomInterface*>(interface);

				}

			else if(iMode == EEncode)

				{

				iRecordCustomInterface = static_cast<MRecordCustomInterface*>(interface);

				}

			}

		}

#endif

	if(err == KErrNone)

		{

		err = InitHwDevice();

		}

	DP0_RET(err, "%d");

	}

// ---------------------------------------------------------------------------

// CAudioCodec::Load

// ---------------------------------------------------------------------------

EXPORT_C TInt CAudioCodec::Load(TInt aSampleRate, TUid aMode)

	{

	DP_CONTEXT(CAudioCodec::Load *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	iSampleRateConfig = aSampleRate;

	iModeConfig = aMode;

	TInt err(KErrNone);

	err = SetHwDeviceConfig();

	DP0_RET(err, "%d");

	}

// ---------------------------------------------------------------------------

// CAudioCodec::Start

// ---------------------------------------------------------------------------

EXPORT_C TInt CAudioCodec::Start()

	{

	DP_CONTEXT(CAudioCodec::Start *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err(KErrNone);

	iLastBuffer = EFalse;

	// Needed since ToneHwDevice only exchange one buffer with its client

	// Resume shouldn't clear the last buffer flag 

	// since this wont' result on a new buffer request

	if(iHwDeviceState == EPaused && iDeviceUid.iUid == KUidToneHwDevice)

		{

		iLastBuffer = ETrue;

		}

	if (iHwDevice)

		{

		PRF(PRF_ID, PRF_START, PRF_TIME, AA_DS_StartHwDevice, "");

		if (iMode == EDecode)

			{

			// PLAY

			err = iHwDevice->Start(EDevDecode, EDevOutFlow);

			DP1(DLINFO,"hwdevice decode start: error %d",err);

			iIgnoreUnderflowInterface = reinterpret_cast<MIgnoreUnderflowEventsCustomInterface*>(iHwDevice->CustomInterface(KIgnoreUnderflowCustomInterfaceTypeUid));	

			if(iIgnoreUnderflowInterface)

				{

				iIgnoreUnderflowInterface->IgnoreUnderflowEvents();

				}

			}

		else if (iMode == EEncode)

			{

			// RECORD

			err = iHwDevice->Start(EDevEncode, EDevInFlow);

			DP1(DLINFO,"hwdevice encode start: error %d",err);

			}

		else

			{

			err = KErrNotSupported;

			DP1(DLINFO,"CAudioCodec::StartHwDevice - Unknown mode %d", iMode);

			}

		PRF(PRF_ID, PRF_STOP, PRF_TIME, AA_DS_StartHwDevice, "");

		}

	else

		{

		err = KErrHardwareNotAvailable;

		}

	if (err == KErrNone)

		{

		iHwDeviceState = ERunning;

		}

	iLastBufferAck = EFalse;	

	DP0_RET(err, "%d");

	}

// ---------------------------------------------------------------------------

// CAudioCodec::Pause

// ---------------------------------------------------------------------------

EXPORT_C TInt CAudioCodec::Pause()

	{

	DP_CONTEXT(CAudioCodec::Pause *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err(KErrNone);

	if (iHwDevice)

		{

		DP0(DLINFO,"Pause hwdevice");

		err = iHwDevice->Pause();

		}

	iHwDeviceState = EPaused;

	DP0_RET(err, "%d");

	}

// ---------------------------------------------------------------------------

// CAudioCodec::Stop

// ---------------------------------------------------------------------------

EXPORT_C TInt CAudioCodec::Stop()

	{

	DP_CONTEXT(CAudioCodec::Stop *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err(KErrNone);

	if (iHwDevice && !(iHwDeviceState == EStopped)) 

		{

		DP0(DLINFO,"Stop hwdevice");

		UpdateBytesPlayed();

		err = iHwDevice->Stop();

		iHwDeviceState = EStopped;

		}

	iLastBufferAck = EFalse;

	DP0_RET(err, "%d");

	}

// ---------------------------------------------------------------------------

// CAudioCodec::GetSupportedSampleRates

// ---------------------------------------------------------------------------

TInt CAudioCodec::GetSupportedSampleRates(RArray<TInt>& aSupportedRates)

	{

	DP_CONTEXT(CAudioCodec::GetSupportedSampleRates *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err(KErrNone);

	aSupportedRates.Reset();

	// Ask for rates from resource files

	err = ReadResourceRates(aSupportedRates);

	DP0_RET(err, "%d");

	}

// ---------------------------------------------------------------------------

// CAudioCodec::GetSupportedModes

// ---------------------------------------------------------------------------

TInt CAudioCodec::GetSupportedModes(RArray<TUid>& aSupportedModes)

	{

	DP_CONTEXT(CAudioCodec::GetSupportedModes *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err(KErrNone);

	aSupportedModes.Reset();

	// Ask for modes from resource files

	err = ReadResourceModes(aSupportedModes);

	DP0_RET(err, "%d");

	}

// ---------------------------------------------------------------------------

// CAudioCodec::GetCustomInterface

// ---------------------------------------------------------------------------

TInt CAudioCodec::RequestCustomInterface(TUid aUid, TAny*& aPtr)

	{

	DP_CONTEXT(CAudioCodec::GetCustomInterface *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err = KErrNone;

	if(iHwDevice)

		{

		aPtr = iHwDevice->CustomInterface(aUid);

		}

	else

		{

		err = KErrNotReady;

		}

	DP0_RET(err, "%d");

	}

// ---------------------------------------------------------------------------

// CAudioCodec::RegisterObserver

// ---------------------------------------------------------------------------

TInt CAudioCodec::RegisterObserver(MCustomInterfaceSupportObserver& aObserver)

	{

	DP_CONTEXT(CAudioCodec::RegisterObserver *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err = KErrNone;

	err = iCISupportObservers.Find(&aObserver);

	if( err != KErrNotFound )

		{

		err = KErrAlreadyExists;

		}

	else

		{

		err = iCISupportObservers.Append(&aObserver);

		}

	DP0_RET(err, "%d");

	}

// ---------------------------------------------------------------------------

// CAudioCodec::UnRegisterObserver

// ---------------------------------------------------------------------------

void CAudioCodec::UnRegisterObserver(MCustomInterfaceSupportObserver& aObserver)

	{

	DP_CONTEXT(CAudioCodec::UnRegisterObserver *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt idxOrErr = iCISupportObservers.Find(&aObserver);

	if( idxOrErr != KErrNotFound )

		{

		iCISupportObservers.Remove(idxOrErr);

		}

	DP_OUT();

	}

// ---------------------------------------------------------------------------

// CAudioCodec::LoadHwDevice

// ---------------------------------------------------------------------------

TInt CAudioCodec::LoadHwDevice()

	{

	DP_CONTEXT(CAudioCodec::LoadHwDevice *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err(KErrNone);

	if(iDeviceUid==KNullUid)

		{

		DP0_RET(KErrNotSupported, "%d");

		}

	TRAP(err, iHwDevice = CMMFHwDevice::NewL(iDeviceUid));

	if(err == KErrNotFound)

		{

		err = KErrNotSupported;

		}

	DP0_RET(err, "%d");

	}

// ---------------------------------------------------------------------------

// CAudioCodec::InitHwDevice

// ---------------------------------------------------------------------------

TInt CAudioCodec::InitHwDevice()

	{

	DP_CONTEXT(CAudioCodec::InitHwDevice *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err(KErrNone);

	DP1(DLINFO, "eapStreamId %d", iHwDeviceInitArgs.iEapStreamId);

	DP1(DLINFO, "policyId %d", iHwDeviceInitArgs.iPolicyId);

	iHwDeviceInitParams.iHwDeviceObserver = this;

	iHwDeviceInitParams.iHwDeviceInitArgsPtr.Set((TUint8*)&(iHwDeviceInitArgs),

														sizeof(THwDeviceInitArgs),

														sizeof(THwDeviceInitArgs));

	if (iHwDevice)

		{

		err = iHwDevice->Init(iHwDeviceInitParams);

		}

	else

		{

		err = KErrHardwareNotAvailable;

		}

	DP0_RET(err, "%d");

	}

// ---------------------------------------------------------------------------

// CAudioCodec::SetHwDeviceConfig

// ---------------------------------------------------------------------------

TInt CAudioCodec::SetHwDeviceConfig()

	{

	DP_CONTEXT(CAudioCodec::SetHwDeviceConfig *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err(KErrNone);

	//TODO Look for another way to set those parameters

	TTaskConfig taskconfig;

	taskconfig.iUid = KUidRefDevSoundTaskConfig;

	taskconfig.iStereoMode = ResolveMode(iModeConfig);

	taskconfig.iRate = iSampleRateConfig;

	DP1(DLINFO, "taskconfig.iRate %d", taskconfig.iRate);

	DP1(DLINFO, "taskconfig.iStereoMode %d", taskconfig.iStereoMode);

	DP1(DLINFO, "taskconfig.iUid %d", taskconfig.iUid);

	if (err == KErrNone && iHwDevice)

		{

		err = iHwDevice->SetConfig(taskconfig);

		}

	else

		{

		err = KErrHardwareNotAvailable;

		}

	DP0_RET(err, "%d");

	}

// ---------------------------------------------------------------------------

// CAudioCodec::ReadResourceRates

// ---------------------------------------------------------------------------

TInt CAudioCodec::ReadResourceRates(RArray<TInt>& aRates)

	{

	DP_CONTEXT(CAudioCodec::ReadResourceRates*CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err(KErrNone);

	CResourceData* resource = NULL;

	TRAP(err, resource = CResourceData::NewL(iDeviceUid));

	if (err == KErrNone && resource)

		{

		err = resource->GetSSampleRates(iMode,aRates);

		delete resource;

		}

	DP0_RET(err, "%d");

	}

// ---------------------------------------------------------------------------

// CAudioCodec::ReadResourceModes

// ---------------------------------------------------------------------------

TInt CAudioCodec::ReadResourceModes(RArray<TUid>& aModes)

	{

	DP_CONTEXT(CAudioCodec::ReadResourceModes*CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err(KErrNone);

	CResourceData* resource = NULL;

	TRAP(err, resource = CResourceData::NewL(iDeviceUid));

	if (err == KErrNone && resource)

		{

		err = resource->GetSModes(iMode,aModes);

		delete resource;

		}

	DP0_RET(err, "%d");

	}

// ---------------------------------------------------------------------------

// from class MAudioComponent

// CAudioCodec::GetOutputPort

// ---------------------------------------------------------------------------

TInt CAudioCodec::GetOutputPort(MOutputPort*& aOutputPort)

	{

	DP_CONTEXT(CAudioCodec::GetOutputPort *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	aOutputPort = this;

	DP0_RET(KErrNone, "%d");

	}

// ---------------------------------------------------------------------------

// from class MAudioComponent

// CAudioCodec::GetInputPort

// ---------------------------------------------------------------------------

TInt CAudioCodec::GetInputPort(MInputPort*& aInputPort)

	{

	DP_CONTEXT(CAudioCodec::GetInputPort *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	aInputPort = this;

	DP0_RET(KErrNone, "%d");

	}

// ---------------------------------------------------------------------------