FCL/sf/os/boardsupport: comparison emulator/emulatorbsp/specific/soundsc

equal deleted inserted replaced

--1:000000000000
+:cec860690d41
+// 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);
+		// Just use the paused number of bytes
+		ms=((iBytesRecordedBeforeLastPause/iBytesPerSecond)*1000);
+		TUint remainder=(iBytesRecordedBeforeLastPause%iBytesPerSecond);
+		ms+=((remainder*1000)/iBytesPerSecond);
+		ms*=1000;
+		aTimeRecorded=ms;
+		r=KErrNone;
+		}
+	TInt64 bytesTransferredSincePause = 0;
+	// If no hardware is present then we need to use iBytesSincePauseReportedToLdd + a fudge factor to allow
+	// the number of bytes processed by the "hardware" within the current transfer.
+	if(iNoHardware)
+		{
+		// Determine the # of milliseconds that have passed since the last timer triggered
+		DWORD currentTime = timeGetTime();
+		DWORD timeSinceLastEvent = (currentTime - iLastTimerEventTime);
+		// Clamp the resulting value to the duration of the timer, to prevent the millisecond count
+		// going backwards if Windows is busy and latency becomes an issue
+		if (timeSinceLastEvent > iSimulatedMsecDuration)
+			timeSinceLastEvent = iSimulatedMsecDuration;
+		bytesTransferredSincePause = iBytesSincePauseReportedToLdd;
+		WAVEHDR *buf = iWaveformBufMgr->iPendingBufList[0];
+		if(buf)
+			{
+			// Add on an estimate of the progress of the current transfer
+			bytesTransferredSincePause += ((buf->dwBufferLength * timeSinceLastEvent) / iSimulatedMsecDuration);
+			}
+		}
+	else
+		{
+		// Get the number of bytes recorded by the Windows audio system
+		MMTIME time;
+		time.wType=TIME_BYTES;
+		if ((waveInGetPosition(iRecordDeviceHandle,&time,sizeof(time)) != MMSYSERR_NOERROR) ||
+			(time.wType != TIME_BYTES))
+			{
+			// If requesting the number of bytes recorded is not supported, wType will be
+			// changed to what was actually returned, so check for this and don't continue
+			// if we got anything other than bytes
+			return KErrNotSupported;
+			}
+		bytesTransferredSincePause = time.u.cb;
+		}
+	// Kern::Printf("DWinsSoundScRxPdd::TimeTransferred - iBytesRecordedBeforeLastPause %d + bytesTransferredSincePause %d total %d (iNoHardware %d)\n",
+	// 			iBytesRecordedBeforeLastPause, TUint32(bytesTransferredSincePause), TUint32(bytesTransferredSincePause + iBytesRecordedBeforeLastPause), iNoHardware);
+	// Convert the number of bytes recorded into microseconds and return it
+	ms=(((bytesTransferredSincePause + iBytesRecordedBeforeLastPause)/iBytesPerSecond)*1000);
+	TUint64 remainder=((bytesTransferredSincePause + iBytesRecordedBeforeLastPause)%iBytesPerSecond);
+	ms+=((remainder*1000)/iBytesPerSecond);
+	ms*=1000;
+	aTimeRecorded=ms;
+	r=KErrNone;
+	return(r);
+	}
+/**
+Prepare the waveform audio buffer for record.
+@param aRecordDeviceHandle The handle to the waveform audio input device.
+*/
+void TWaveformAudioBuf::DoPrepareIn(HWAVEIN aRecordDeviceHandle)
+	{
+	MMRESULT res = waveInPrepareHeader(aRecordDeviceHandle,&iBufHdr,sizeof(WAVEHDR));
+	__KTRACE_SND(Kern::Printf("   waveInPrepareHeader(BufNo:%d Pos:%x Len:%d)-%d",iBufNum,iBufHdr.lpData,iBufHdr.dwBufferLength,res));
+	__ASSERT_ALWAYS(res==MMSYSERR_NOERROR,Kern::Fault("DWinsSoundScTxPddWIPH", res)); //WaveInPrepareHeader error.
+	}
+/**
+Cleanup the preparation performed when the waveform audio buffer was prepared for record.
+@param aRecordDeviceHandle The handle to the waveform audio input device.
+*/
+void TWaveformAudioBuf::DoUnprepareIn(HWAVEIN aRecordDeviceHandle)
+	{
+	MMRESULT res = waveInUnprepareHeader(aRecordDeviceHandle,&iBufHdr,sizeof(WAVEHDR));
+	__KTRACE_SND(Kern::Printf("   waveInUnprepareHeader(BufNo:%d)-%d",iBufNum,res));
+	__ASSERT_ALWAYS(res==MMSYSERR_NOERROR,Kern::Fault("DWinsSoundScTxPddWIUH",res)); //WaveInUnprepareHeader error.
+	}
+/**
+The waveform input callback function to handle data block transfer completion.
+This function is always executed in windows thread context.
+@param aHdr A pointer to the header for the waveform audio buffer just transferred.
+*/
+void DWinsSoundScRxPdd::WaveInProc(WAVEHDR* aHdr)
+	{
+	TInt waveBufId=aHdr->dwUser;				// Work out which waveform audio buffer is completing.
+// Kern::Printf("DWinsSoundScRxPdd::WaveInProc waveBufId %d", waveBufId);
+	StartOfInterrupt();
+	iCompletedRecordBufHdrMask|=(1<<waveBufId);	// Update the completion status mask
+	iDfc.Add();									// Queue RecordDfc().
+	EndOfInterrupt();
+	}
+/**
+The DFC used to handle data block record completion.
+This function is always executed in driver thread context.
+@param aPtr A pointer to the physical channel object.
+*/
+void DWinsSoundScRxPdd::RecordDfc(TAny* aPtr)
+	{
+	TInt i;
+	DWinsSoundScRxPdd& drv=*(DWinsSoundScRxPdd*)aPtr;
+	// More than 1 transfer may have completed so loop until all completions are handled
+	while (drv.iCompletedRecordBufHdrMask)
+		{
+		// Find the buffer ID of the next transfer that has completed
+		for (i=0 ; i<32 && !(drv.iCompletedRecordBufHdrMask&(1<<i)) ; i++) {}
+		__ASSERT_ALWAYS(i<drv.iWaveformBufMgr->iNumWaveformBufs,PANIC());
+		__e32_atomic_and_ord32(&drv.iCompletedRecordBufHdrMask, ~(1u<<i)); // Clear this bit in the mask
+		// Update the status of the waveform audio buffer which is completing
+		TWaveformAudioBuf& buf=drv.iWaveformBufMgr->iWaveformAudioBuf[i];
+		buf.iIsInUse=EFalse;
+		// Callback the LDD passing the information for the transfer that has completed
+		drv.iPendingRecord--;
+		__KTRACE_SND(Kern::Printf("   Read complete(BufNo:%x Pos:%x Len:%d)",i,buf.iBufHdr.lpData,buf.iBufHdr.dwBufferLength));
+		drv.iBytesSincePauseReportedToLdd += buf.iBufHdr.dwBufferLength;
+		drv.Ldd()->RecordCallback(buf.iTransferID,KErrNone,buf.iBufHdr.dwBufferLength);
+		}
+	}
+/**
+Issue a request from the driver thread to the windows thread to execute a command.
+@param aCommand The identifier of the command to be executed.
+@param aArg0 A first command argument, its meaning depends on the command.
+@param aArg1 A second command argument, its meaning depends on the command.
+@param aArg2 A third command argument, its meaning depends on the command.
+This function is always executed in driver thread context.
+*/
+void DWinsSoundScRxPdd::RecordThreadCommand(TThreadCommand aCommand,TInt aArg0,TInt aArg1,TInt aArg2)
+	{
+	__KTRACE_SND(Kern::Printf(">DWinsSoundScRxPdd:RecordThreadCommand"));
+	iRecordCommand = aCommand;
+	iRecordCommandArg0 = aArg0;
+	iRecordCommandArg1 = aArg1;
+	iRecordCommandArg2 = aArg2;
+	__HOST_LOCK;
+	ReleaseSemaphore(iRecordThreadSem,1,NULL);
+	}
+/**
+Pass a value from the windows thread to the driver thread.
+This function is always executed in windows thread context.
+@param aError The value to the passed to the driver thread.
+*/
+void DWinsSoundScRxPdd::RecordThreadNotifyDriver(TInt aError)
+	{
+	iRecordThreadError = aError;
+	BOOL ret = ReleaseSemaphore(iDriverThreadSem,1,NULL);
+	__ASSERT_ALWAYS(ret == TRUE,PANIC()); //Unexpected Windows Error
+	}
+#pragma warning(disable : 4702) // unreachable code
+/**
+Open the waveform input device for record. Use a default device identifier in order to select a device
+capable of meeting the current audio configuration.
+This function can be executed in either driver thread or windows thread context.
+@pre The data member DWinsSoundScRxPdd::iSoundConfig must be setup with the current audio configuration.
+*/
+TInt DWinsSoundScRxPdd::OpenWaveInDevice()
+	{
+	WAVEFORMATEX format;
+	format.wFormatTag = WAVE_FORMAT_PCM;
+	TUint16 bitsPerSample = 8;
+	switch (iSoundConfig.iEncoding)
+		{
+		case ESoundEncoding8BitPCM:
+			break;
+		case ESoundEncoding16BitPCM:
+			bitsPerSample = 16;
+			break;
+		default:
+			return KErrNotSupported;
+		};
+	TInt rateInSamplesPerSecond=RateInSamplesPerSecond(iSoundConfig.iRate);
+	format.nChannels = TUint16(iSoundConfig.iChannels);
+	format.nSamplesPerSec = rateInSamplesPerSecond;
+	format.nAvgBytesPerSec = rateInSamplesPerSecond * iSoundConfig.iChannels * bitsPerSample / 8;
+	format.nBlockAlign = TUint16(iSoundConfig.iChannels * bitsPerSample / 8);
+	format.wBitsPerSample = bitsPerSample;
+	format.cbSize = 0;
+	MMRESULT res = MMSYSERR_NOERROR;
+	__COND_HOST_LOCK;
+	if (iNoHardware)
+		{
+		timeBeginPeriod(KMMTimerRes);
+		iRecordDeviceHandle = (HWAVEIN)1;
+		}
+	else
+		{
+		res = waveInOpen(&iRecordDeviceHandle, WAVE_MAPPER, &format, (DWORD)::WaveInProc, (DWORD)this, CALLBACK_FUNCTION);
+		// On some builds of Windows (such as Windows Server 2003), the waveInGetDevCaps() trick in
+		// DoCreate() won't work, so we have another special check for missing hardware here
+		if ((res == MMSYSERR_NODRIVER) || (res == MMSYSERR_BADDEVICEID))
+			{
+			// Pretend there was no error and switch into hardware emulation mode
+			res = MMSYSERR_NOERROR;
+			iNoHardware = ETrue;
+			iRecordDeviceHandle = (HWAVEIN)1;
+			iWaveformBufMgr->iIsHardware = EFalse;
+			timeBeginPeriod(KMMTimerRes);
+			}
+		}
+	switch (res)
+		{
+		case MMSYSERR_NOERROR: // No error
+			return(KErrNone);
+		case MMSYSERR_ALLOCATED: // Specified resource is already allocated.
+			return(KErrInUse);
+		case WAVERR_BADFORMAT: // Attempted to open with an unsupported waveform-audio format
+			return(KErrNotSupported);
+		case MMSYSERR_NOMEM: // Unable to allocate or lock memory.
+			return(KErrNoMemory);
+		default:
+			return(KErrUnknown);
+		}
+	}
+#pragma warning(default : 4702) // unreachable code
+/**
+Open the audio input device.
+This function is always executed in driver thread context.
+@pre The data members DWinsSoundScRxPdd::iSoundConfig must be setup with the current audio configuration.
+*/
+TInt DWinsSoundScRxPdd::CreateRecordDevice(TBool aCheckDevice)
+	{
+	// Check if the waveform input device is already open.
+	if (iRecordDeviceHandle)
+		return(KErrNone);
+	__HOST_LOCK;
+	// Open the waveform input device for recording.
+	TInt err = OpenWaveInDevice();
+	if (err != KErrNone)
+		return(err);
+	__HOST_LOCK_OFF;
+	if (!aCheckDevice)
+		{
+		// Now, re-allocate a set of the waveform audio blocks in advance of any recording. Also, prepare one of these
+		// for each buffer within the shared chunk. Need to be in critical section while re-allocating the audio blocks.
+		NKern::ThreadEnterCS();
+		err=iWaveformBufMgr->ReAllocAndUpdate(Ldd()->BufConfig(),Ldd()->ChunkBase(),(TInt)iRecordDeviceHandle);
+		NKern::ThreadLeaveCS();
+		}
+	return(err);
+	}
+/**
+Close down the record device.
+This function is always executed in driver thread context.
+*/
+void DWinsSoundScRxPdd::CloseRecordDevice()
+	{
+	__COND_HOST_LOCK;
+	if (iNoHardware)
+		timeEndPeriod(KMMTimerRes);
+	HWAVEIN handle = iRecordDeviceHandle;
+	if (handle)
+		{
+		if (!iNoHardware)
+			waveInReset(handle);		// Stop recording.
+		// Un-prepare all the waveform audio buffers.
+		for (TInt i=0 ; i<iWaveformBufMgr->iNumWaveformBufs ; i++)
+			iWaveformBufMgr->iWaveformAudioBuf[i].Unprepare((TInt)handle);
+		if (!iNoHardware)
+			waveInClose(handle);		// Close the wavein device.
+		iRecordDeviceHandle = NULL;
+		}
+	}
+/**
+The thread function for the record windows thread.
+This function is always executed in windows thread context.
+@pre The data members DWinsSoundScRxPdd::iSoundConfig must be setup with the current audio configuration.
+*/
+void DWinsSoundScRxPdd::RecordThread()
+	{
+	iRecordThreadSem = CreateSemaphore(NULL,0,0x7fffffff,NULL);
+	__ASSERT_ALWAYS(iRecordThreadSem,PANIC()); //No Windows Memory
+	iRecordTimerEvent=CreateEvent(NULL,TRUE,FALSE,NULL);
+	HANDLE objects[2];
+	objects[0]=iRecordThreadSem;		// Indicates command from driver thread
+	objects[1]=iRecordTimerEvent;
+	// Signal driver of successful setup
+	RecordThreadNotifyDriver(KErrNone);
+	ResetEvent(iRecordTimerEvent);
+	FOREVER
+		{
+		DWORD ret=WaitForMultipleObjectsEx(2,objects,FALSE,INFINITE,TRUE);
+		switch (ret)
+			{
+			case WAIT_OBJECT_0:	// Command received from the driver thread.
+				if (ProcessRecordCommand(iRecordCommand,iRecordCommandArg0,iRecordCommandArg1,iRecordCommandArg2)==KErrCompletion)
+					return; // ********* Exit thread **************
+				break;
+			case WAIT_OBJECT_0+1:
+				HandleRecordTimerEvent();
+				break;
+			}
+		}
+	}
+/**
+Process a request from the driver thread to execute a command.
+This function is always executed in windows thread context.
+@param aCommand The identifier of the command to be executed.
+@param aArg0 A first command argument, its meaning depends on the command.
+@param aArg1 A second command argument, its meaning depends on the command.
+@param aArg2 A third command argument, its meaning depends on the command.
+@return KErrCompletion if the command to exit the windows thread has been received;
+		KErrNone otherwise;
+*/
+TInt DWinsSoundScRxPdd::ProcessRecordCommand(TThreadCommand aCommand,TInt aArg0,TInt aArg1,TInt aArg2)
+	{
+	__KTRACE_SND(Kern::Printf(">DWinsSoundScRxPdd:ProcessRecordCommand(%d)",aCommand));
+	switch(aCommand)
+		{
+		case ERecData:	// Initiate the recording of a buffers worth of data from the wavein device.
+			{
+			if (iRecordEnabled)
+				{
+				// Acquire a windows waveform audio buffer for the transfer.
+				char* startAddress=(char*)aArg1;
+				TInt bytesToRecord=aArg2;
+				__ASSERT_ALWAYS(bytesToRecord>0,PANIC());
+				TWaveformAudioBuf* waveformAudioBuf=iWaveformBufMgr->AcquireBuf(startAddress,bytesToRecord,(TInt)iRecordDeviceHandle);
+				waveformAudioBuf->iTransferID=(TUint)aArg0;
+				waveformAudioBuf->iBufHdr.dwBufferLength=bytesToRecord;
+				if (!iNoHardware)
+					{
+					// This machine has a wavein device present. Send the buffer to the wavein device.
+					waveInStart(iRecordDeviceHandle); // Start input on the wavein device - safe to call this when already started.
+					MMRESULT res = waveInAddBuffer(iRecordDeviceHandle,&waveformAudioBuf->iBufHdr,sizeof(WAVEHDR));
+					__KTRACE_SND(Kern::Printf("   waveInAddBuffer(ID:%x Pos:%x Len:%d)-%d",aArg0,startAddress,bytesToRecord,res));
+					__ASSERT_ALWAYS(res == MMSYSERR_NOERROR,PANIC());  //WaveInAddBuffer Error
+					}
+				else
+					{
+					// This machine has no audio hardware present so simulate the wavein device using a timer.
+					AddToPendingList(&waveformAudioBuf->iBufHdr,iWaveformBufMgr->iPendingBufList); // Queue the buffer on the pending list
+					// Check if the timer needs starting/re-starting
+					if (!iTimerActive)
+						{
+						iLastTimerEventTime = timeGetTime();
+						StartTimer(&waveformAudioBuf->iBufHdr);
+						}
+					}
+				}
+			// Signal the driver thread that we have completed the command.
+			RecordThreadNotifyDriver(KErrNone);
+			break;
+			}
+		case EStop:	// Terminate the recording of data from the wavein device.
+			{
+			iRecordEnabled=EFalse;	// Stop the windows thread from sending any more buffers to wavein device.
+			if (iNoHardware)
+				{
+				// This machine has no audio hardware present so simulates the waveout device using a timer.
+				StopTimer(ETrue);	// Stop the timer and cancel any buffers pending
+				}
+			// Leave the driver thread to close down the record device.
+			// Signal the driver thread that we have completed the command.
+			if (iStopSemaphore)
+				{
+				LONG prev;
+				ReleaseSemaphore(iStopSemaphore,1,&prev);
+				}
+			break;
+			}
+		case EExit:	// Close down the record device and exit the windows thread.
+			{
+			if (!iNoHardware)
+				{
+				// This machine has a wavein device present.
+				if (iRecordDeviceHandle)
+					{
+					waveInReset(iRecordDeviceHandle);   // Stop recording on the wavein device.
+					waveInClose(iRecordDeviceHandle);	// Close the wavein device.
+					}
+				}
+			else
+				{
+				// This machine has no audio hardware present so simulates the waveout device using a timer.
+				StopTimer(ETrue);	// Stop the timer and cancel any buffers pending.
+				}
+			// Logically the record device is now shut so clear the handle.
+			iRecordDeviceHandle = 0;
+			// Signal the driver thread that we have completed the command.
+			if (iDeathSemaphore)
+				{
+				LONG prev;
+				ReleaseSemaphore(iDeathSemaphore,1,&prev);
+				}
+			return(KErrCompletion); 		// ********* Exit thread **************
+			}
+		case EPause:	// Halt the recording of data from the wavein device.
+			iRecordEnabled=EFalse;
+			DWORD position;
+			if (!iNoHardware)
+				{
+				// Need to try to work out how much of the current audio buffer has been filled.
+				MMTIME time;
+				time.wType = TIME_BYTES;
+				HWAVEIN handle = iRecordDeviceHandle;
+				waveInGetPosition(handle,&time,sizeof(MMTIME));
+				position = time.u.cb;
+				// Stop recording. (Windows will mark all pending audio buffers as done).
+				waveInReset(handle);
+				}
+			else
+				{
+				// This machine has no audio hardware present so simulates the waveout device using a timer.
+				// Determine the # of milliseconds that have passed since the last timer triggered
+				DWORD currentTime = timeGetTime();
+				DWORD timeSinceLastEvent = (currentTime - iLastTimerEventTime);
+				// Clamp the resulting value to the duration of the timer, to prevent the millisecond count
+				// going backwards if Windows is busy and latency becomes an issue
+				if (timeSinceLastEvent > iSimulatedMsecDuration)
+					timeSinceLastEvent = iSimulatedMsecDuration;
+				TUint bytesTransferredSincePause = iBytesSincePauseReportedToLdd;
+				WAVEHDR *buf = iWaveformBufMgr->iPendingBufList[0];
+				if(buf)
+					{
+					// Add on an estimate of the progress of the current transfer
+					bytesTransferredSincePause += ((buf->dwBufferLength * timeSinceLastEvent) / iSimulatedMsecDuration);
+					}
+				position = bytesTransferredSincePause;
+StopTimer(ETrue);   // Stop the timer and cancel any buffers pending
+				}
+			// Signal the driver thread that we have stopped recording - returning info. on any partially filled buffer.
+			RecordThreadNotifyDriver(position);
+			break;
+		case EResume:
+			if (iNoHardware)
+				{
+				// Determine how long we were paused for and add that time to the time the timer last
+				// triggered.  This will allow us to continue as though we had never been paused
+				iLastTimerEventTime = timeGetTime();
+				}
+			break;
+		}
+	return(KErrNone);
+	}
+/**
+Handle a timer expiry event. This is only used when no audio hardware is present, with a timer expiry corresponding
+to the end of a data block transfer.
+This function is always executed in windows thread context.
+*/
+void DWinsSoundScRxPdd::HandleRecordTimerEvent()
+	{
+	__KTRACE_SND(Kern::Printf(">DWinsSoundScRxPdd:HandleRecordTimerEvent"));
+	ResetEvent(iRecordTimerEvent);	// Reset the event
+	// Remove the audio buffer just filled from the pending list and save it for the driver thread.
+	WAVEHDR* buf=RemoveFromPendingList(iWaveformBufMgr->iPendingBufList);
+	__ASSERT_ALWAYS(buf != NULL,PANIC());
+	TInt waveBufId=buf->dwUser;					// Work out which waveform audio buffer is completing.
+	// Check if there are more audio buffers waiting to be played
+	buf=iWaveformBufMgr->iPendingBufList[0];
+	if (buf)
+		{
+		iLastTimerEventTime = timeGetTime();
+		StartTimer(buf);						// Re-start the timer
+		}
+	else
+		iTimerActive=EFalse;
+	// Notify that another audio buffer has been filled.
+	StartOfInterrupt();
+	iCompletedRecordBufHdrMask|=(1<<waveBufId);	// Update the completion status mask
+	iDfc.Add();
+	EndOfInterrupt();
+	return;
+	}
+/**
+Initialise the data member DWinsSoundScRxPdd::iCaps with the capabilities of this audio device.
+*/
+void DWinsSoundScRxPdd::SetCaps()
+	{
+	__KTRACE_SND(Kern::Printf(">DWinsSoundScRxPdd::SetCaps"));
+	// The data transfer direction for this unit is record.
+	iCaps.iDirection=ESoundDirRecord;
+	// Assume this unit supports mono or stereo.
+	iCaps.iChannels=KSoundMonoChannel|KSoundStereoChannel;
+	// Assume this unit supports all sample rates.
+	iCaps.iRates=(KSoundRate7350Hz|KSoundRate8000Hz|KSoundRate8820Hz|KSoundRate9600Hz|KSoundRate11025Hz|
+				  KSoundRate12000Hz|KSoundRate14700Hz|KSoundRate16000Hz|KSoundRate22050Hz|KSoundRate24000Hz|
+				  KSoundRate29400Hz|KSoundRate32000Hz|KSoundRate44100Hz|KSoundRate48000Hz);
+	// Assume this unit supports 8bit and 16bit PCM encoding.
+	iCaps.iEncodings=(KSoundEncoding8BitPCM|KSoundEncoding16BitPCM);
+	// This unit only supports interleaved data format
+	iCaps.iDataFormats=KSoundDataFormatInterleaved;
+	// The minimum request size that the device can support.
+	iCaps.iRequestMinSize=0;	// No restriction
+	// The request alignment that this device requires.
+	iCaps.iRequestAlignment=0;	// No restriction
+	// This unit is not capable of detecting changes in hardware configuration.
+	iCaps.iHwConfigNotificationSupport=EFalse;
+	}
+/**
+Start the audio timer.
+The timer is only used when no audio hardware is present on the machine. This is in order to introduce a delay which is
+equivelent to that incurred when transferring audio data over a real audio device.
+@param aBuffer The audio buffer which would have been transferred had a real audio device been present. This contains
+	information on the number of bytes to transfer.
+*/
+void DWinsSoundScRxPdd::StartTimer(WAVEHDR* aBuffer)
+	{
+	// First, need to calculate the duration of the timer in milliseconds.
+	TInt bytesToPlay=aBuffer->dwBufferLength;
+	iSimulatedMsecDuration = bytesToPlay*1000;
+	iSimulatedMsecDuration /= (RateInSamplesPerSecond(iSoundConfig.iRate) * iSoundConfig.iChannels);
+	if (iSoundConfig.iEncoding==ESoundEncoding16BitPCM)
+		iSimulatedMsecDuration /= 2;
+	if (iSoundConfig.iEncoding==ESoundEncoding24BitPCM)
+		iSimulatedMsecDuration /= 3;
+	if (iSimulatedMsecDuration<=0)
+		iSimulatedMsecDuration=1;	// Round up to 1ms or timeSetEvent() will return an error.
+	MMRESULT res = timeSetEvent(iSimulatedMsecDuration, KMMTimerRes, (LPTIMECALLBACK)iRecordTimerEvent, 0, TIME_ONESHOT | TIME_CALLBACK_EVENT_SET);
+	__ASSERT_ALWAYS(res != NULL,PANIC()); 	// timeSetEvent error.
+	iTimerID = res;							// Save the identifier for the new timer event.
+	iTimerActive=ETrue;
+	}
+/**
+Stop the audio timer.
+The timer is only used when no audio hardware is present on the machine. This is in order to introduce a delay which is
+equivelent to that incurred when transferring audio data over a real audio device.
+@param aCancellAll Set to ETrue in order to discard any buffers queued on the pending buffer list. EFalse otherwise.
+*/
+void DWinsSoundScRxPdd::StopTimer(TBool aCancelAll)
+	{
+	if (iTimerActive)
+		{
+		MMRESULT res = timeKillEvent(iTimerID);
+		__ASSERT_ALWAYS(res == TIMERR_NOERROR,PANIC()); // timeKillEvent error
+		if (aCancelAll)
+			{
+			WAVEHDR* b;
+			do
+				b=RemoveFromPendingList(iWaveformBufMgr->iPendingBufList);
+			while(b);
+			}
+		}
+	iTimerActive=EFalse;
+	}