// 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:

// wins\specific\soundsc_rx.cpp

// Emulator record functions for the shared chunk sound driver PDD.

// 

//

/**

 @file

 @internalTechnology

 @prototype

*/

#include "winssoundsc.h"

/**

The thread function for the record windows thread.

This function is always executed in windows thread context.

*/

LOCAL_C TUint RecordThreadFunction(DWinsSoundScRxPdd *aSoundPdd)

	{

	aSoundPdd->RecordThread();

	return 0;

	}

/**

The waveform input callback function. This can receive the following messages:-

WIM_OPEN when the input device is opened, WIM_CLOSE when the input device is closed,

and WIM_DATA each time a record data block has been filled (i.e. completion of waveInAddBuffer).

This function is always executed in windows thread context.

*/

LOCAL_C void CALLBACK WaveInProc(HWAVEIN /*hwi*/, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD /*dwParam2*/)

	{

	if (uMsg == WIM_DATA)

		{

		DWinsSoundScRxPdd * pdd = (DWinsSoundScRxPdd*)dwInstance;

		pdd->WaveInProc((WAVEHDR*)dwParam1);

		}

	}			

/**

Constructor for the WINS shared chunk record PDD.

This function is always executed in driver thread context.

*/

DWinsSoundScRxPdd::DWinsSoundScRxPdd()

	: iDfc(DWinsSoundScRxPdd::RecordDfc,this,2)

	{		

	__KTRACE_SND(Kern::Printf(">DWinsSoundScRxPdd::DWinsSoundScRxPdd"));

//	iDriverThreadSem=0;

//	iRecordThread=0;

//	iRecordThreadMutex=0;

//	iRecordThreadSem=0;

//	iStopSemaphore=0;

//	iDeathSemaphore=0;

//	iRecordDeviceHandle=0;

//	iRecordCommand=ERecData;

//	iRecordCommandArg0=0;

//	iRecordCommandArg1=0;

//	iPendingRecord=0;

//	iRecordThreadError=0;

///	iWaveformBufMgr=NULL;

//	iCompletedRecordBufHdrMask=0;

//	iRecordBufferSize=0;

//	iRecordEnabled=EFalse;

//	iNoHardware=EFalse;

//	iRecordTimerEvent=0;

//	iTimerID=0;

//	iTimerActive=EFalse;

	}

/**

Destructor for the WINS shared chunk record PDD.

This function is always executed in driver thread context.

*/

DWinsSoundScRxPdd::~DWinsSoundScRxPdd()

	{

	// If the Windows thread started up successfully, signal it to shut down and wait for it to do so

	if (iRecordThreadRunning)

		{

		// Signal the windows thread to close down the record device and exit the windows thread.

		iDeathSemaphore = CreateSemaphore(NULL, 0, 2, NULL);

		RecordThreadCommand(EExit);

		// Wait for the record thread to terminate.

		if (iDeathSemaphore)

			{

			Emulator::Escape();

			WaitForSingleObject(iDeathSemaphore, INFINITE); 

			Emulator::Reenter();

			__HOST_LOCK;

			CloseHandle(iDeathSemaphore);

			}

		}

	if (iRecordTimerEvent)

		CloseHandle(iRecordTimerEvent); 

	if (iRecordThreadSem)

		CloseHandle(iRecordThreadSem); 

	if (iRecordThread)

		CloseHandle(iRecordThread);

	if (iDriverThreadSem)

		CloseHandle(iDriverThreadSem); 	

	if (iWaveformBufMgr)

		delete iWaveformBufMgr;

	}

/**

Second stage constructor for the WINS shared chunk record PDD.

Note that this constructor is called before the second stage constructor for the LDD so it is not

possible to call methods on the LDD here.

This function is always executed in driver thread context.

@param aPhysicalDevice A pointer to the factory class that is creating this PDD.

@return KErrNone if successful, otherwise one of the other system wide error codes.

*/	

TInt DWinsSoundScRxPdd::DoCreate(DWinsSoundScPddFactory* aPhysicalDevice)

	{

	__KTRACE_SND(Kern::Printf(">DWinsSoundScRxPdd::DoCreate"));

	iPhysicalDevice=aPhysicalDevice;

	// Set up the correct DFC queue.

	iDfc.SetDfcQ(iPhysicalDevice->iDfcQ);

	SetCaps();	// Setup the capabilities of this device.

	// Setup the default audio configuration

	iSoundConfig.iChannels=2;

	iSoundConfig.iRate=ESoundRate48000Hz;

	iSoundConfig.iEncoding=ESoundEncoding16BitPCM;

	iSoundConfig.iDataFormat=ESoundDataFormatInterleaved;

	__HOST_LOCK;

	// Query the waveform device capabilities using the default device identifier in order

	// to check if there is a functioning waveform device present.  Note that some versions of

	// Windows (such as Windows Server 2003) will actually return MMSYSERR_NOERROR when this is

	// called, even if there is no waveform device present, so we have a further check in

	// when waveInOpen() is called

	WAVEINCAPS waveInCaps;

	MMRESULT res = waveInGetDevCaps(WAVE_MAPPER,&waveInCaps,sizeof(WAVEINCAPS));

#ifdef FORCE_NO_HARDWARE

	res=MMSYSERR_NOERROR+1;

#endif

	if (res != MMSYSERR_NOERROR)

		iNoHardware = ETrue;

	__HOST_LOCK_OFF;

	// Create the windows waveform audio buffer manager.

	iWaveformBufMgr=new TWaveformBufMgr(ESoundDirRecord,!iNoHardware);

	if (!iWaveformBufMgr)

		return(KErrNoMemory);

	// Create the driver thread semaphore.

	iDriverThreadSem = CreateSemaphore(NULL,0,0x7fffffff,NULL);

	if (!iDriverThreadSem)

		return(KErrNoMemory);

	// Create the record windows thread.

	if ((iRecordThread=CreateWin32Thread(EThreadEvent,(LPTHREAD_START_ROUTINE)RecordThreadFunction,(void *)this, FALSE))==NULL)

		return(Emulator::LastError());

	SetThreadPriority(iRecordThread,THREAD_PRIORITY_HIGHEST);

	__ASSERT_ALWAYS( ResumeThread(iRecordThread) != 0xffffffff, PANIC()); //Windows Unexpected Error

	// Wait to be notified of successful thread initialization

	Emulator::Escape();

	WaitForSingleObject(iDriverThreadSem,INFINITE);

	Emulator::Reenter();

	// If the Windows thread started up successfully, indicate this fact so that when shutting down we know

	// to signal to the thread to exit

	if (iRecordThreadError == KErrNone)

		iRecordThreadRunning = ETrue;

	return(iRecordThreadError);

	}

/**

Called from the LDD to return the DFC queue to be used by this device.

This function is always executed in driver thread context.

@return The DFC queue to use.

*/	

TDfcQue* DWinsSoundScRxPdd::DfcQ(TInt /*aUnit*/)

	{

	return(iPhysicalDevice->iDfcQ);

	}

/** 

Called from the LDD to return the shared chunk create information to be used by this device.

This function is always executed in driver thread context.

@param aChunkCreateInfo A chunk create info. object to be to be filled with the settings

						required for this device.

*/		

void DWinsSoundScRxPdd::GetChunkCreateInfo(TChunkCreateInfo& aChunkCreateInfo)

	{

	__KTRACE_SND(Kern::Printf(">DWinsSoundScRxPdd::GetChunkCreateInfo"));

	aChunkCreateInfo.iType=TChunkCreateInfo::ESharedKernelMultiple;

	aChunkCreateInfo.iMapAttr=0;

	aChunkCreateInfo.iOwnsMemory=ETrue; 				// Using RAM pages.

	aChunkCreateInfo.iDestroyedDfc=NULL; 				// No chunk destroy DFC.

	}

/**

Called from the LDD to return the capabilities of this device.

This function is always executed in driver thread context.

@param aCapsBuf A packaged TSoundFormatsSupportedV02 object to be filled with the record

				capabilities of this device. This descriptor is in kernel memory and can be accessed directly.

@see TSoundFormatsSupportedV02.

*/

void DWinsSoundScRxPdd::Caps(TDes8& aCapsBuf) const

	{

	__KTRACE_SND(Kern::Printf(">DWinsSoundScRxPdd::Caps"));

	// Copy iCaps back.

	TPtrC8 ptr((const TUint8*)&iCaps,sizeof(iCaps));

	aCapsBuf.FillZ(aCapsBuf.MaxLength());

	aCapsBuf=ptr.Left(Min(ptr.Length(),aCapsBuf.MaxLength()));	

	}

/**

Called from the LDD to return the maximum transfer length in bytes that this device can support in a single data transfer.

@return The maximum transfer length in bytes.

*/

TInt DWinsSoundScRxPdd::MaxTransferLen() const

	{

	return(KWinsMaxAudioTransferLen);		// 32K

	}		

/**

Called from the LDD to power up the sound device.

This function is always executed in driver thread context.

@return KErrNone if successful, otherwise one of the other system wide error codes.

*/

TInt DWinsSoundScRxPdd::PowerUp()

	{

	return(KErrNone);

	}

/**

Called from the LDD to configure or reconfigure the device using the the configuration supplied.

This function is always executed in driver thread context.

@param aConfigBuf A packaged TCurrentSoundFormatV02 object which contains the new configuration settings.

				  This descriptor is in kernel memory and can be accessed directly.

@return KErrNone if successful, otherwise one of the other system wide error codes.

@see TCurrentSoundFormatV02.

*/	

TInt DWinsSoundScRxPdd::SetConfig(const TDesC8& aConfigBuf)

	{

	__KTRACE_SND(Kern::Printf(">DWinsSoundScRxPdd::SetConfig"));

	// Cannot change the configuration while the device is open and recording. (LDD should prevent

	// this anyway but better safe than sorry).

	if (iRecordDeviceHandle)

		return(KErrInUse);

	// Save the current settings so we can restore them if there is a problem with the new ones.

	TCurrentSoundFormatV02 saved=iSoundConfig;

	// Read the new configuration from the LDD.

	TPtr8 ptr((TUint8*)&iSoundConfig,sizeof(iSoundConfig));

	Kern::InfoCopy(ptr,aConfigBuf);

	// Open the record device with the new settings to check they are supported. Then close it

	// again - don't leave it open yet.

	TInt r = CreateRecordDevice(ETrue);

	if (r==KErrNone)

		CloseRecordDevice();

	else

		iSoundConfig=saved;	// Restore the previous settings

	return(r);

	}

/**

Called from the LDD to set the record level.

This function is always executed in driver thread context.

@param aLevel The record level to be set - a value in the range 0 to 255. The value 255 equates 

	   to the maximum record level and each value below this equates to a 0.5dB step below it.

@return KErrNone if successful, otherwise one of the other system wide error codes.

*/

TInt DWinsSoundScRxPdd::SetVolume(TInt /*aVolume*/)

	{

	__KTRACE_SND(Kern::Printf(">DWinsSoundScRxPdd::SetVolume"));

	// There's no adjustment of the record level on the wave in device.

	return(KErrNone);

	}

/**

Called from the LDD to prepare the audio device for recording.

This function is always executed in driver thread context.

@return KErrNone if successful, otherwise one of the other system wide error codes.

*/

TInt DWinsSoundScRxPdd::StartTransfer()

	{

	__KTRACE_SND(Kern::Printf(">DWinsSoundScRxPdd::StartTransfer"));

	// Convert the enum representing the current sample rate into an integer

	TInt samplesPerSecond=RateInSamplesPerSecond(iSoundConfig.iRate);

	if (samplesPerSecond==0)

		return(KErrNotSupported);

	// Now convert the sample rate into the number of bytes per second and save for later use

	iBytesPerSecond=samplesPerSecond;

	if (iSoundConfig.iChannels==2)

		iBytesPerSecond*=2;

	if (iSoundConfig.iEncoding==ESoundEncoding16BitPCM)

		iBytesPerSecond*=2;

	iBytesRecordedBeforeLastPause = 0;

	iBytesSincePauseReportedToLdd = 0;

	iRecordEnabled=ETrue;

	// Open the record device with the current settings.

	iPendingRecord=0;

	iCompletedRecordBufHdrMask=0;					// Reset the completion status mask

	TInt r = CreateRecordDevice();

	return(r);

	}

/**

Called from the LDD to initiate the recording of a portion of data from the audio device. 

When the transfer is complete, the PDD signals this event using the LDD function RecordCallback().

This function is always executed in driver thread context.

@param aTransferID A value assigned by the LDD to allow it to uniquely identify a particular transfer fragment.

@param aLinAddr The linear address within the shared chunk for storing the recorded data.

@param aPhysAddr The physical address within the shared chunk for storing the recorded data.

@param aNumBytes The number of bytes to be recorded. 

@return KErrNone if the transfer has been initiated successfully;

  		KErrNotReady if the device is unable to accept the transfer for the moment;

		otherwise one of the other system-wide error codes.

*/

TInt DWinsSoundScRxPdd::TransferData(TUint aTransferID,TLinAddr aLinAddr,TPhysAddr /*aPhysAddr*/,TInt aNumBytes)

	{

	__KTRACE_SND(Kern::Printf(">DWinsSoundScRxPdd::TransferData(ID:%xH)",aTransferID));

	// Check that we can accept the request

	if (aNumBytes>KWinsMaxAudioTransferLen)

		return(KErrArgument);

	if (iPendingRecord>=iWaveformBufMgr->iNumWaveformBufs)	// LDD may issue multiple data transfers per buffer.

		return(KErrNotReady);

	// Signal the windows thread to initiate the recording of a buffers worth of data from the wavein device.

	iPendingRecord++;

	RecordThreadCommand(ERecData,aTransferID,aLinAddr,aNumBytes);

	// Although the windows thread runs at a higher priority, its not safe to assume we will always get pre-empted at this

	// point while the the higher priority thread processes and completes the request. Instead we need to wait until it

	// signals back completion of the command.

	Emulator::Escape();

	WaitForSingleObject(iDriverThreadSem,INFINITE);

	Emulator::Reenter();	

	return(iRecordThreadError);	

	}

/**

Called from the LDD to terminate the recording of a data from the device and to release any resources necessary for

recording.

The LDD will leave the audio device capturing record data even when there are no record requests pending from the client.

Transfer will only be terminated when the client either issues RSoundSc::CancelRecordData() or closes the channel. Once

this function had been called, the LDD will not issue  any further TransferData() commands without first issueing a

StartTransfer() command.

This function is always executed in driver thread context.

*/

void DWinsSoundScRxPdd::StopTransfer()

	{

	__KTRACE_SND(Kern::Printf(">DWinsSoundScRxPdd::StopTransfer"));

	// Signal the windows thread to stop it from sending any more buffers to wavein device.

	iStopSemaphore = CreateSemaphore(NULL, 0, 1, NULL);

	RecordThreadCommand(EStop);

	// Need to wait for the record thread to finish using the record handle before it's safe to close the device and 

	// set the handle to NULL.

	if (iStopSemaphore)

		{

		// Wait for the record thread to stop.

		Emulator::Escape();

		WaitForSingleObject(iStopSemaphore, INFINITE);  

		Emulator::Reenter();

		__HOST_LOCK;

		CloseHandle(iStopSemaphore);

		iStopSemaphore = NULL;

		}

	// Make sure the DFC is not queued.

	iDfc.Cancel();	

	CloseRecordDevice();							// Close down the record device.

	iPendingRecord=0;

	iCompletedRecordBufHdrMask=0;					// Reset the completion status mask

	}

/**

Called from the LDD to halt the recording of data from the sound device but not to release any resources necessary for

recording.

All active transfers should be aborted. When recording is halted the PDD signals this event with a single call of the LDD 

function RecordCallback() - reporting back any partial data already received. If transfer is resumed later, the LDD will

issue a new TransferData() request to re-commence data transfer.

This function is always executed in driver thread context.

@return KErrNone if successful, otherwise one of the other system wide error codes.

*/

TInt DWinsSoundScRxPdd::PauseTransfer()

	{

	__KTRACE_SND(Kern::Printf(">DWinsSoundScRxPdd::PauseTransfer"));

	// Signal the windows thread to stop recording on the wavein device - aborting any transfers queued.

	RecordThreadCommand(EPause);

	// Wait for the windows thread to complete the request

	Emulator::Escape();

	WaitForSingleObject(iDriverThreadSem,INFINITE);

	Emulator::Reenter();

	// Make sure the DFC is not queued.

	iDfc.Cancel();

	// The windows thread returns the total bytes recorded since the last pause (as reported by windows). 

	TUint totalRecordedSincePause = iRecordThreadError;

	TUint lastTransferLength = totalRecordedSincePause - iBytesSincePauseReportedToLdd;

	Kern::Printf("totalRecordedSincePause %d - iBytesSincePauseReportedToLdd %d = lastTransferLength %d\n",

				 totalRecordedSincePause, iBytesSincePauseReportedToLdd, lastTransferLength);

	iBytesRecordedBeforeLastPause += totalRecordedSincePause;

	iBytesSincePauseReportedToLdd = 0;

	if (iPendingRecord)

		{

		Ldd()->RecordCallback(0, KErrNone, lastTransferLength);	// We can use a NULL tranfer ID when pausing.

		// The LDD will abandon any other transfers queued so we can mark all buffers as not in use.

    	for (TInt i=0 ; i<iWaveformBufMgr->iNumWaveformBufs ; i++)

    		{

    		TWaveformAudioBuf* buf=&iWaveformBufMgr->iWaveformAudioBuf[i];

    		if (buf->iIsInUse)

    			buf->iIsInUse=EFalse;

    		}

		iPendingRecord=0;

		}

	// Indicate that all request to Windows for recording have been cancelled

	iCompletedRecordBufHdrMask=0;

	return(KErrNone);

	}

/**

Called from the LDD to resume the recording of data from the sound device following a request to halt recording.

Any active transfer would have been aborted when the device was halted so its just a case of re-creating the same setup

acheived following StartTransfer().

This function is always executed in driver thread context.

@return KErrNone if successful, otherwise one of the other system wide error codes.

*/

TInt DWinsSoundScRxPdd::ResumeTransfer()

	{

	__KTRACE_SND(Kern::Printf(">DWinsSoundScRxPdd::ResumeTransfer"));

	iPendingRecord=0;

	iCompletedRecordBufHdrMask=0; // All buffers would have completed during pausing (waveInReset) so clear mask.

	iRecordEnabled=ETrue; // Simply set the flag to enable the windows thread to restart sending buffers to wavein device. 

	// Signal the windows thread to resume recording on the wavein device.

	RecordThreadCommand(EResume);

	return(KErrNone);

	}

/**

Called from the LDD to power down the sound device.

This function is always executed in driver thread context.

*/

void DWinsSoundScRxPdd::PowerDown()

	{

	}

/**

Called from the LDD to handle a custom configuration request.

@param aFunction A number identifying the request.

@param aParam A 32-bit value passed to the driver. Its meaning depends on the request.

@return KErrNone if successful, otherwise one of the other system wide error codes.

*/

TInt DWinsSoundScRxPdd::CustomConfig(TInt /*aFunction*/,TAny* /*aParam*/)

	{

	return(KErrNotSupported);

	}

/**

Called from the LDD to find out how many microseconds of data have been recorded.  This is called

in the context of the DFC thread.

@param aTimeTransferred	A reference to a variable into which to place the number of microseconds of audio.

@param aStatus			The current status of this channel

@return KErrNone if time is valid or KErrNotSupported.

*/

TInt DWinsSoundScRxPdd::TimeTransferred(TInt64& aTimeRecorded, TInt aState)

	{

	TInt r=KErrGeneral;

	TInt64 ms=0;

	if(iRecordDeviceHandle == 0)

		{

		// Recording not started yet

		aTimeRecorded = 0;

		return KErrNone;

		}

	// Kern::Printf("DWinsSoundScRxPdd::TimeTransferred - (iBytesSincePauseReportedToLdd=%d)\n", iBytesSincePauseReportedToLdd);

	if (aState == DSoundScLdd::EPaused)

		{

		// Kern::Printf("DWinsSoundScRxPdd::TimeTransferred (paused) - iBytesRecordedBeforeLastPause %d\n", iBytesRecordedBeforeLastPause);