/*
* This component and the accompanying materials are made available
* under the terms of the License "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:
* Accenture Ltd
*
* Description: This file is a part of sound driver for Syborg adaptation.
*
*/

#include "shared_sound.h"
#include "variant_sound.h"
#include "../specific/syborg.h"

#include "virtio.h"
#include "virtio_audio.h"
#include "virtio_iohandler.h"

using namespace VirtIo;

static TInt GetSampleRate( TSoundRate aRate)
	{
	switch(aRate)
		{
		case ESoundRate7350Hz: 	return 7350;
		case ESoundRate8000Hz: 	return 8000;
		case ESoundRate8820Hz: 	return 8820;
		case ESoundRate9600Hz: 	return 9600;
		case ESoundRate11025Hz: return 11025;
		case ESoundRate12000Hz: return 12000;
		case ESoundRate14700Hz:	return 14700;
		case ESoundRate16000Hz: return 16000;
		case ESoundRate22050Hz: return 22050;
		case ESoundRate24000Hz: return 24000;
		case ESoundRate29400Hz: return 29400;
		case ESoundRate32000Hz: return 32000;
		case ESoundRate44100Hz: return 44100;
		case ESoundRate48000Hz: return 48000;
		}
	return KErrNotFound;
	}

static TInt GetSoundEncoding( TSoundEncoding aV )
	{
	switch (aV)
		{
		case ESoundEncoding8BitPCM: return Audio::EFormatS8;
		case ESoundEncoding16BitPCM: return Audio::EFormatS16;
		case ESoundEncoding24BitPCM: break; // not supported
		}
	return -KErrNotFound;
	}
static TInt GetChannels( TInt aV )
	{
	switch (aV)
		{
		case KSoundMonoChannel: return 1;
		case KSoundStereoChannel: return 2;
		}
	return KErrNotFound;
	}

DDriverSyborgSoundScPdd::DDriverSyborgSoundScPdd(DDriverSyborgSoundScPddFactory* aPhysicalDevice, 
	TInt aUnitType, VirtIo::DIoHandler* aIoHandler, TUint aDataQueueId )
	: iPhysicalDevice(aPhysicalDevice),  iUnitType(aUnitType), iIoHandler( aIoHandler ), iDataQueueId( aDataQueueId )
	{
	}

DDriverSyborgSoundScPdd::~DDriverSyborgSoundScPdd()
	{
	SYBORG_SOUND_DEBUG("~DDriverSyborgSoundScPdd()");
	iIoHandler->UnregisterClient( this );
	delete iAudioControl;
	SYBORG_SOUND_DEBUG("~DDriverSyborgSoundScPdd() - done");
	}

TInt DDriverSyborgSoundScPdd::DoCreate()
	{
	SetCaps();
	
	SYBORG_SOUND_DEBUG("DDriverSyborgSoundScPdd::DoCreate TxPdd");

	SYBORG_SOUND_DEBUG("Registering with IOHandler %x", iIoHandler );
	iIoHandler->RegisterClient( this );
	SYBORG_SOUND_DEBUG("Registered with IoHandler... Done %x", iIoHandler);
	
	iAudioControl = new Audio::DControl( *iIoHandler, iDataQueueId );
	iAudioControl->Construct();
	Audio::StreamDirection direction = static_cast<Audio::StreamDirection>(
		(iUnitType == KSoundScRxUnit0)?Audio::EDirectionRecord
		:(iUnitType == KSoundScTxUnit0)?Audio::EDirectionPlayback:-1 ); 
        
        iAudioControl->Setup( direction, 2, Audio::EFormatS16, 48000 );
		
	return KErrNone;
	}

void DDriverSyborgSoundScPdd::GetChunkCreateInfo(TChunkCreateInfo& aChunkCreateInfo)
	{
	SYBORG_SOUND_DEBUG("DDriverSyborgSoundScPdd::GetChunkCreateInfo TxPdd");
	
	aChunkCreateInfo.iType = TChunkCreateInfo::ESharedKernelMultiple;
	aChunkCreateInfo.iMapAttr = EMapAttrFullyBlocking; 	// No caching
	aChunkCreateInfo.iOwnsMemory = ETrue; 				// Using RAM pages
	aChunkCreateInfo.iDestroyedDfc = NULL; 				// No chunk destroy DFC
	}

void DDriverSyborgSoundScPdd::Caps(TDes8& aCapsBuf) const
	{
	SYBORG_SOUND_DEBUG("DDriverSyborgSoundScPdd::Caps TxPdd");
	
	// Fill the structure with zeros in case it is a newer version than we know about
	aCapsBuf.FillZ(aCapsBuf.MaxLength());

	// And copy the capabilities into the packaged structure
	TPtrC8 ptr((const TUint8*) &iCaps, sizeof(iCaps));
	aCapsBuf = ptr.Left(Min(ptr.Length(), aCapsBuf.MaxLength()));
	}

TInt DDriverSyborgSoundScPdd::SetConfig(const TDesC8& aConfigBuf)
	{
	SYBORG_SOUND_DEBUG("DDriverSyborgSoundScPdd::SetConfig TxPdd");
	
	// Read the new configuration from the LDD
	TCurrentSoundFormatV02 config;
	TPtr8 ptr((TUint8*) &config, sizeof(config));
	Kern::InfoCopy(ptr, aConfigBuf);
	
	TInt channels = GetChannels(config.iChannels);
	Audio::FormatId encoding = static_cast<Audio::FormatId>( GetSoundEncoding(config.iEncoding) );
	TInt freq = GetSampleRate(config.iRate);
	Audio::StreamDirection direction = static_cast<Audio::StreamDirection>(
		(iUnitType == KSoundScRxUnit0)?Audio::EDirectionRecord
		:(iUnitType == KSoundScTxUnit0)?Audio::EDirectionPlayback:-1 );

	SYBORG_SOUND_DEBUG("DDriverSyborgSoundScPdd::SetConfig c %x, e %x, f %x, d %x",
		channels, encoding, freq, direction );
	
	if ( (channels < 0 )
		|| ( encoding < 0 )
		|| ( freq < 0 ) 
		|| ( direction < 0 )
		)
		{
		SYBORG_SOUND_DEBUG("DDriverSyborgSoundScPdd::SetConfig failed");		
		return KErrArgument;
		}
	
	TInt st = iAudioControl->Setup( direction, channels, encoding, freq );
	if (st !=KErrNone)
		{
		SYBORG_SOUND_DEBUG("DDriverSyborgSoundScPdd::SetConfig failed %d", st);				
		return st;
		}
	
	iConfig = config;
	
	return KErrNone;
	}


TInt DDriverSyborgSoundScPdd::SetVolume(TInt aVolume)
	{
	SYBORG_SOUND_DEBUG("DDriverSyborgSoundScPdd::Setvolume TxPdd");
	
	return KErrNone;
	}


TInt DDriverSyborgSoundScPdd::StartTransfer()
	{
	SYBORG_SOUND_DEBUG("DDriverSyborgSoundScPdd::starttransfer TxPdd S");
	iAudioControl->SendCommand( Audio::DControl::ERun );
	return KErrNone;
	}
	
	
TInt DDriverSyborgSoundScPdd::CalculateBufferTime(TInt aNumBytes)
	{
	TUint samplerate=GetSampleRate( iConfig.iRate );

	// integer division by number of channels
	aNumBytes /= iConfig.iChannels;

	// integer division by bytes per sample
	switch(iConfig.iEncoding)
		{
		case ESoundEncoding8BitPCM: break;
		case ESoundEncoding16BitPCM: aNumBytes /= 2; break;
		case ESoundEncoding24BitPCM: aNumBytes /= 3; break;
		}

	return (aNumBytes * 1000) / samplerate; //return time in milliseconds
	}

TInt DDriverSyborgSoundScPdd::TransferData(TUint aTransferID, TLinAddr aLinAddr, TPhysAddr aPhysAddr, TInt aNumBytes)
	{
	SYBORG_SOUND_DEBUG("DDriverSyborgSoundScPdd::TransferData unit %x aTId=%x, linAddr=%x,phAddr=%x,len=%x", 
		iUnitType, aTransferID, aLinAddr, aPhysAddr, aNumBytes);
	
	iAudioControl->SendDataBuffer( 
		reinterpret_cast<TAny*>( aLinAddr ), aNumBytes, reinterpret_cast<Token>( aTransferID ) );

	return KErrNone;
	}

void DDriverSyborgSoundScPdd::StopTransfer()
	{
	SYBORG_SOUND_DEBUG("DDriverSyborgSoundScPdd::stoptransfer TxPdd");
	
	iAudioControl->SendCommand( Audio::DControl::EStop );
	}


TInt DDriverSyborgSoundScPdd::PauseTransfer()
	{
	SYBORG_SOUND_DEBUG("DDriverSyborgSoundScPdd::pausetransfer TxPdd");
	iAudioControl->SendCommand( Audio::DControl::EPause );
	return KErrNone;
	}


TInt DDriverSyborgSoundScPdd::ResumeTransfer()
	{
	SYBORG_SOUND_DEBUG("DDriverSyborgSoundScPdd::resumetransfer TxPdd");
	iAudioControl->SendCommand( Audio::DControl::EResume );
	return KErrNone;
	}

TInt DDriverSyborgSoundScPdd::PowerUp()
	{
	SYBORG_SOUND_DEBUG("DDriverSyborgSoundScPdd::PowerUp TxPdd");
	return KErrNone;
	}

void DDriverSyborgSoundScPdd::PowerDown()
	{
	SYBORG_SOUND_DEBUG("DDriverSyborgSoundScPdd::Powerdown TxPdd");
	}

TInt DDriverSyborgSoundScPdd::CustomConfig(TInt /*aFunction*/,TAny* /*aParam*/)
	{
	SYBORG_SOUND_DEBUG("DDriverSyborgSoundScPdd::CustomConfig TxPdd");
	return KErrNotSupported;
	}

TBool DDriverSyborgSoundScPdd::VirtIoCallback( MIoHandler& aVirtIoHandler, MQueue& aQueue, 
	Token aToken, TUint aBytesTransferred )
	{
	if ( &aQueue != &iAudioControl->DataQueue() )
		{ return ETrue; }
			
	SYBORG_SOUND_DEBUG("DDriverSyborgSoundScPdd::VirtIoCallback t%x, s%x", aToken, aBytesTransferred);
	
	if ( iCaps.iDirection == ESoundDirPlayback )
		{
		Ldd()->PlayCallback( (TUint) aToken, KErrNone, aBytesTransferred );
		}
	else
		{
		Ldd()->RecordCallback( (TUint) aToken, KErrNone, aBytesTransferred );
		}
		
	return EFalse; // cannot process any more buffers in this go due to a bug in LDD?
	}

TDfcQue*DDriverSyborgSoundScPdd::DfcQ()
	{
	return iPhysicalDevice->iDfcQ;
	}
	
TDfcQue*DDriverSyborgSoundScPdd::DfcQ( TInt /* aUinit */ )
	{
	return iPhysicalDevice->iDfcQ;
	}


TInt DDriverSyborgSoundScPdd::MaxTransferLen() const
	{
	return KMaxTransferLength; 
	}


void DDriverSyborgSoundScPdd::SetCaps()
	{
	SYBORG_SOUND_DEBUG("DDriverSyborgSoundScPdd::SetCaps TxPdd");
	
	if(iUnitType == KSoundScTxUnit0)
		{
		// The data transfer direction for this unit is play
		iCaps.iDirection = ESoundDirPlayback;
		}
	else if(iUnitType == KSoundScRxUnit0)
		{
		// The data transfer direction for this unit is play
		iCaps.iDirection = ESoundDirRecord;
		}
	
	// This unit supports both mono and stereo
	iCaps.iChannels = (KSoundMonoChannel | KSoundStereoChannel);

	// This unit supports only some of the sample rates offered by Symbian OS
	iCaps.iRates = (KSoundRate8000Hz | KSoundRate11025Hz | KSoundRate12000Hz | KSoundRate16000Hz |
					KSoundRate22050Hz | KSoundRate24000Hz | KSoundRate32000Hz | KSoundRate44100Hz |
					KSoundRate48000Hz);

	// This unit only supports 16bit PCM encoding
	iCaps.iEncodings = KSoundEncoding16BitPCM;

	// This unit only supports interleaved data format when playing stereo;  that is, a PCM data
	// stream where the left and right channel samples are interleaved as L-R-L-R-L-R etc.
	iCaps.iDataFormats = KSoundDataFormatInterleaved;

	// The iRequestMinSize member is named badly.  It is actually the value of which the length samples
	// must be a multiple of.  ie.  The sample length % iRequestMinSize must == 0.  This value must always
	// be a power of 2
	iCaps.iRequestMinSize = 4;

	// The logarithm to base 2 of the alignment required for request arguments.  DMA requests must be
	// aligned to a 32 bit boundary
	iCaps.iRequestAlignment = 2;

	// This unit is not capable of detecting changes in hardware configuration
	iCaps.iHwConfigNotificationSupport = EFalse;
	}