diff -r 000000000000 -r a41df078684a kernel/eka/include/d32soundsc.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kernel/eka/include/d32soundsc.h	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,620 @@
+// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// 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:
+//
+// Description:
+// e32\include\d32soundsc.h
+// User side class definition for the shared chunk sound driver.
+// 
+//
+
+/**
+ @file
+ @publishedPartner
+ @prototype
+*/
+
+#ifndef __D32SOUNDSC_H__
+#define __D32SOUNDSC_H__
+
+#include <e32cmn.h>
+#include <e32ver.h>
+#ifndef __KERNEL_MODE__
+#include <e32std.h>
+#endif
+
+_LIT(KDevSoundScName,"SoundSc");
+
+const TInt KSoundScTxUnit0=0;
+const TInt KSoundScTxUnit1=1;
+/**
+@capability UserEnvironment
+@ref RSoundSc::Open An RSoundSc may not be opened for record without UserEnvironment
+*/
+const TInt KSoundScRxUnit0=4;
+/**
+@capability UserEnvironment
+@ref RSoundSc::Open An RSoundSc may not be opened for record without UserEnvironment
+*/
+const TInt KSoundScRxUnit1=5;
+
+// Note that the implementation in the sound driver LDD to calculate a default audio configuration assumes a 
+// monotonic ordering of all caps bitfields. If it is necessary to break this ordering then this implementation
+// will need to be reviewed and possibly changed.
+
+/**
+Sound driver capability constants - bitmasks of the audio channel configurations supported
+by a unit. @see TSoundFormatsSupportedV02.
+*/
+/** The unit supports Mono (i.e. a single audio channel). */
+const TUint KSoundMonoChannel = 0x0001;
+/** The unit supports Stereo (i.e. two audio channels). */
+const TUint KSoundStereoChannel = 0x0002;
+/** The unit supports three audio channels. */
+const TUint KSoundThreeChannel = 0x0004;
+/** The unit supports four audio channels. */
+const TUint KSoundFourChannel = 0x0008;
+/** The unit supports five audio channels. */
+const TUint KSoundFiveChannel = 0x0010;
+/** The unit supports six audio channels. */
+const TUint KSoundSixChannel = 0x0020;
+
+/**
+Sound driver capability constants - bitmasks of supported sample rates. @see TSoundFormatsSupportedV02.
+*/
+/** The device supports the 7.35KHz sample rate. */
+const TUint KSoundRate7350Hz = 0x0001;
+/** The device supports the 8KHz sample rate. */
+const TUint KSoundRate8000Hz = 0x0002;
+/** The device supports the 8.82KHz sample rate. */
+const TUint KSoundRate8820Hz = 0x0004;
+/** The device supports the 9.6KHz sample rate. */
+const TUint KSoundRate9600Hz = 0x0008;
+/** The device supports the 11.025KHz sample rate. */
+const TUint KSoundRate11025Hz = 0x0010;
+/** The device supports the 12KHz sample rate. */
+const TUint KSoundRate12000Hz = 0x0020;
+/** The device supports the 14.7KHz sample rate. */
+const TUint KSoundRate14700Hz = 0x0040;
+/** The device supports the 16KHz sample rate. */
+const TUint KSoundRate16000Hz = 0x0080;
+/** The device supports the 22.05KHz sample rate. */
+const TUint KSoundRate22050Hz = 0x0100;
+/** The device supports the 24KHz sample rate. */
+const TUint KSoundRate24000Hz = 0x0200;
+/** The device supports the 29.4KHz sample rate. */
+const TUint KSoundRate29400Hz = 0x0400;
+/** The device supports the 32KHz sample rate. */
+const TUint KSoundRate32000Hz = 0x0800;
+/** The device supports the 44.1KHz sample rate. */
+const TUint KSoundRate44100Hz = 0x1000;
+/** The device supports the 48KHz sample rate. */
+const TUint KSoundRate48000Hz = 0x2000;
+
+/**
+Sound driver capability constants - bitmasks of supported encoding formats. @see TSoundFormatsSupportedV02.
+*/
+/** The device supports 8bit PCM encoding format. */
+const TUint KSoundEncoding8BitPCM = 0x0001;
+/** The device supports 16bit PCM encoding format. */
+const TUint KSoundEncoding16BitPCM = 0x0002;
+/** The device supports 24bit PCM encoding format. */
+const TUint KSoundEncoding24BitPCM = 0x0004;
+
+/**
+Sound driver capability constants - bitmasks of the data formats supported
+by the device. @see TSoundFormatsSupportedV02.
+*/
+/** The device supports an interleaved data format (i.e. data for each channel is interleaved throughout
+each data buffer). */
+const TUint KSoundDataFormatInterleaved = 0x0001;
+/** The device supports a non-interleaved data format (i.e. data for each channel is arranged in
+contiguous regions within each data buffer). */
+const TUint KSoundDataFormatNonInterleaved = 0x0002;
+
+/** The maximum setting possible for the record level / volume. */
+const TInt KSoundMaxVolume = 255;
+
+/**
+Enumeration of possible data transfer directions. @see TSoundFormatsSupportedV02.
+*/
+enum TSoundDirection
+	{
+	/**	A unit for recording data. */
+	ESoundDirRecord,
+	/** A unit for playing data. */
+	ESoundDirPlayback
+	};
+
+/**
+Enumeration of possible sample rates. @see TCurrentSoundFormatV02.
+*/	
+enum TSoundRate
+	{
+	/** 7.35KHz sample rate. */
+	ESoundRate7350Hz,
+	/** 8KHz sample rate. */
+	ESoundRate8000Hz,
+	/** 8.82KHz sample rate. */
+	ESoundRate8820Hz,
+	/** 9.6KHz sample rate. */
+	ESoundRate9600Hz,
+	/** 11.025KHz sample rate. */
+	ESoundRate11025Hz,
+	/** 12KHz sample rate. */
+	ESoundRate12000Hz,
+	/** 14.7KHz sample rate. */
+	ESoundRate14700Hz,
+	/** 16KHz sample rate. */
+	ESoundRate16000Hz,
+	/** 22.05KHz sample rate. */
+	ESoundRate22050Hz,
+	/** 24KHz sample rate. */
+	ESoundRate24000Hz,
+	/** 29.4KHz sample rate. */
+	ESoundRate29400Hz,
+	/** 32KHz sample rate. */
+	ESoundRate32000Hz,
+	/** 44.1KHz sample rate. */
+	ESoundRate44100Hz,
+	/** 48KHz sample rate. */
+	ESoundRate48000Hz
+	};
+
+/**
+Enumeration of possible sound encoding formats. @see TCurrentSoundFormatV02.
+*/
+enum TSoundEncoding
+	{
+	/** 8bit PCM encoding format. */
+	ESoundEncoding8BitPCM,
+	/** 16bit PCM encoding format. */
+	ESoundEncoding16BitPCM,
+	/** 24bit PCM encoding format. */
+	ESoundEncoding24BitPCM
+	};
+	
+/**
+Enumeration of possible sound data formats. @see TCurrentSoundFormatV02.
+*/
+enum TSoundDataFormat
+	{
+	/** The device supports an interleaved data format. */ 
+	ESoundDataFormatInterleaved,
+	/** The device supports a non-interleaved data format. */
+	ESoundDataFormatNonInterleaved
+	};	
+	
+/**
+The general driver capabilites class - returned by the LDD factory in response to RDevice::GetCaps().
+*/
+class TCapsSoundScV01
+	{
+public:
+	TVersion iVersion;
+	};
+
+/**
+The main audio capabilities class. This is used by the LDD to get either the play or record capabilities
+of a particular sound device once a channel to it has been opened.
+*/
+class TSoundFormatsSupportedV02
+	{
+public:
+	/** The data transfer direction for this unit: play or record. @see TSoundDirection. */
+	TSoundDirection iDirection;
+	/** The audio channel configurations supported by this unit - a bitfield. */
+	TUint32 iChannels;
+	/** The sample rates supported - a bitfield. */
+	TUint32 iRates;
+	/** The encoding formats supported - a bitfield. */
+	TUint32 iEncodings;
+	/** The data formats supported - a bitfield. */
+	TUint32 iDataFormats;
+	/** The minimum request size that the device can support. All requests to play or record data must be of a
+	length that is a multiple of this value. */
+	TInt iRequestMinSize;
+	/** The logarithm to base 2 of the alignment required for request arguments. All requests to play or
+	record data must specify locations in the shared chunk which conform to this alignment.
+	For example, iRequestAlignment of 1 is 2 byte aligned (2^1), 2 is 4 byte aligned (2^2) etc. */
+	TInt iRequestAlignment;
+	/** Indicates whether this unit is capable of detecting changes in its hardware configuration. */
+	TBool iHwConfigNotificationSupport;
+	/** Reserved field. */
+	TInt iReserved1;
+	};
+typedef TPckgBuf<TSoundFormatsSupportedV02> TSoundFormatsSupportedV02Buf;
+
+/**
+The sound format configuration class. This is used to get and set the current configuration
+of the sound device (both for playing and recording).
+*/
+class TCurrentSoundFormatV02
+	{
+public:
+	/** The audio channel configuration: 1=Mono, 2=Stereo etc. */ 
+	TInt iChannels;
+	/** The sample rate. @see TSoundRate. */
+	TSoundRate iRate;
+	/** The encoding format. @see TSoundEncoding. */
+	TSoundEncoding iEncoding;
+	/** The data format: interleaved, non-interleaved etc. @see TSoundDataFormat. */
+	TSoundDataFormat iDataFormat;
+	/** Reserved field. */
+	TInt iReserved1;
+	};
+typedef TPckgBuf<TCurrentSoundFormatV02> TCurrentSoundFormatV02Buf;
+
+/**
+A flag that can be passed via the 'aFlags' argument of the function RSoundSc::PlayData(). This being
+set signifies that this particular play request is the last one of a series (ie EOF) and therefore an underflow is
+expected after this request completes.
+*/
+const TUint KSndFlagLastSample=0x00000001;
+
+/** Reserved settings used with CustomConfig(). */
+const TInt KSndCustomConfigMaxReserved=0x0FFFFFFF;
+#ifdef _DEBUG
+const TInt KSndCustom_ForceHwConfigNotifSupported=0x00;
+const TInt KSndCustom_CompleteChangeOfHwConfig=0x01;
+const TInt KSndCustom_ForceStartTransferError=0x02;
+const TInt KSndCustom_ForceTransferDataError=0x03;
+const TInt KSndCustom_ForceTransferTimeout=0x04;
+#endif
+
+/** A structure used to assemble arguments for the function RSoundSc::PlayData() and to pass these to the driver. */
+struct SRequestPlayDataInfo
+	{
+	TInt iBufferOffset;
+	TInt iLength;
+	TUint iFlags;
+	};	
+
+#ifndef __KERNEL_MODE__
+typedef TPckgBuf<TTimeIntervalMicroSeconds> TTimeIntervalMicroSecondsBuf;
+#endif
+
+class RSoundSc : public RBusLogicalChannel
+	{
+private:	
+	enum TRequest
+	/**
+	 Asynchronous request types
+	 */
+		{
+		EMsgRequestPlayData,
+		ERequestNotifyChangeOfHwConfig,
+		EMsgRequestMax=3,				// All requests less than this value are handled in the driver DFC thread.
+		ERequestRecordData,
+		ENumRequests,
+		EAllRequests = (1<<ENumRequests)-1
+		};
+		
+	enum TControl
+	/**
+	 Synchronous request types
+	*/
+		{
+		EMsgControlSetAudioFormat,
+		EMsgControlSetBufChunkCreate,
+		EMsgControlSetBufChunkOpen,
+		EMsgControlSetVolume,
+		EMsgControlPause,
+		EMsgControlResume,
+		EMsgControlCancelSpecific,
+		EMsgControlCustomConfig,
+		EControlTimePlayed,
+		EControlTimeRecorded,
+		EMsgControlMax=10,				// All requests less than this value are handled in the driver DFC thread.
+		EControlGetCaps,
+		EControlGetAudioFormat,
+		EControlGetBufConfig,
+		EControlGetVolume,
+		EControlBytesTransferred,
+		EControlResetBytesTransferred,
+		EControlReleaseBuffer
+		};
+	friend class DSoundScLdd;	
+public:
+	/**
+	Get the version number of sound driver interface.
+    @return The sound driver interface version number.
+	*/
+	inline static TVersion VersionRequired();
+
+#ifndef __KERNEL_MODE__
+	/**
+	Open a channel on a specified sound device. This driver allows more than one channel to be opened on each device.
+	@capability MultimediaDD
+	@capability Dependent UserEnvironment Is required when opening a record channel.
+	@param aUnit The unit number of the sound device.
+	@return KErrNone, if successful; KErrPermissionDenied, if process lacks required capabilities
+        	otherwise one of the other system-wide error codes. 
+	*/
+	inline TInt Open(TInt aUnit=KNullUnit);
+	
+	/**
+	Get the capabilities of the sound device.
+	@param aCapsBuf A packaged object which will be filled with the capabilities of the device.
+	@see TSoundFormatsSupportedV02.
+	*/
+	inline void Caps(TDes8& aCapsBuf);
+	
+	/**
+  	Get the current audio format configuration.
+  	@param aFormatBuf A packaged object which will be filled with the audio configuration settings.
+    @see TCurrentSoundFormatV02.
+	*/
+	inline void AudioFormat(TDes8& aFormatBuf);
+	
+	/**
+  	Set the current audio format configuration.
+  	This can't be changed while the driver is currently playing or recording data.
+	@param aFormatBuf A packaged object holding the new audio configuration settings to be used.
+  	@return KErrNone if successful;
+  			KErrInUse if the playing or recording of data is in progress;
+          	KErrNotSupported if any configuration values are invalid;
+		  	otherwise one of the other system-wide error codes.
+	@see TCurrentSoundFormatV02.
+	*/
+	inline TInt SetAudioFormat(const TDesC8& aFormatBuf);
+	
+ 	/**
+  	Get the current buffer configuration.
+	@param aConfigBuf A packaged TSharedChunkBufConfigBase derived object which will be filled with the buffer
+					  configuration settings.
+	@see TSharedChunkBufConfigBase.
+	*/
+ 	inline void GetBufferConfig(TDes8& aConfigBuf);
+ 	
+ 	/**
+  	Set the current buffer configuration - creating a shared chunk.
+  	The driver will create a shared chunk according to the buffer specification supplied (and will commit
+  	memory to it). This will replace any previous shared chunk created by this driver. A handle to
+  	the chunk will then be created for the client thread which will be assigned to the RChunk object supplied
+  	by the client.
+  	The buffer configuration cannot be changed while the driver is currently playing or recording data.
+  	Note that a minimum of three buffers are required when recording: one being loaded with record data by the driver,
+  	another also owned by the driver - queued ready for the next transfer and a third owned by the client for processing.
+  	Note that for record channels, the buffer size specified effectively determines the size of each record request.
+  	Hence, for record channels the buffer size must be a multiple of the minimum request size as specified in the capabilities 
+  	class. @see TSoundFormatsSupportedV02. It should also be a multiple of the number of bytes per audio sample (e.g. a multiple 
+  	of 4 for 2 channels of 16bit PCM).  
+	@param aConfigBuf A packaged TSharedChunkBufConfigBase derived object which must be set with the new buffer configuration
+					  settings to be used. Note that this function will ignore any buffer offset information specified by the 
+					  caller (i.e. setting the flag KScFlagBufOffsetListInUse has no effect).
+	@param aChunk An RChunk object to which the chunk handle will be assigned. 
+  	@return KErrNone if successful;
+  			KErrInUse if the playing or recording of data is in progress;
+          	KErrArgument if any configuration values are invalid;
+          	KErrNoMemory if the driver failed to allocate memory for the shared chunk specified;
+		  	otherwise one of the other system-wide error codes.
+	@see TSharedChunkBufConfigBase.
+	*/
+ 	inline TInt SetBufferChunkCreate(const TDesC8& aConfigBuf,RChunk& aChunk);
+ 	
+ 	/**
+  	Set the current buffer configuration - using an existing shared chunk.
+  	The client supplies an existing shared chunk which is to be used by the driver as the play or record buffer. 
+  	Any shared chunk previously created by the driver will be closed by it.
+  	The buffer configuration cannot be changed while the driver is currently playing or recording data.
+  	See RSoundSc::SetBufferChunkCreate for details on the buffer configuration setting necessary for playback or record.
+	@param aConfigBuf A packaged TSharedChunkBufConfigBase derived object which must be set with the buffer configuration
+					  settings of the chunk supplied. This must include buffer offset information (i.e. the flag 
+					  KScFlagBufOffsetListInUse must be set).
+	@param aChunk A handle to the shared chunk which is to be used as the play or record buffer. (This must
+				  be a valid handle for the calling thread).
+  	@return KErrNone if successful;
+  			KErrInUse if the playing or recording of data is in progress;
+          	KErrArgument if any configuration values are invalid;
+		  	otherwise one of the other system-wide error codes.
+	@see TSharedChunkBufConfigBase.
+	*/
+ 	inline TInt SetBufferChunkOpen(const TDesC8& aConfigBuf,RChunk& aChunk);
+ 	
+ 	/**
+  	Get the current play volume or record level.
+	@return The current play volume / record level - a value in the range 0 to 255. The value 255 equates to
+	the maximum volume and each value below this equates to a 0.5dB step below it.
+	*/
+	inline TInt Volume();
+	
+	/**
+	Set the current play volume or record level. The volume can be altered while the driver is in the process
+	of playing or recording data.
+	@param aVolume The play volume / record level to be set - a value in the range 0 to 255. The value 255
+		equates to the maximum volume and each value below this equates to a 0.5dB step below it.
+    @return KErrNone if successful;
+          	KErrArgument if the specified volume is out of range;
+		  	otherwise one of the other system-wide error codes.
+	*/
+	inline TInt SetVolume(TInt aVolume);
+	
+	/**
+	Submit a request to play (write data) to the sound device from a buffer.
+  	The buffer must be contained within the driver's shared chunk. A single play request may not span more than one
+  	buffer even if two or more buffers are contiguous within the shared chunk.
+  	The driver will allow more than one play request to be pending at any time. It will
+  	process requests in FIFO order. This is an asynchronous operation with the driver completing the request and
+  	returning the request status once all the specified data has been delivered to the sound device. The driver
+  	will return a request status of KErrUnderflow each time it completes the last pending play request unless this
+  	request was marked with the KSndFlagLastSample flag. If this flag is set, the driver will return
+  	KErrNone in this situation. Therefore when it is required to play uninterrupted audio by issuing a series of play
+  	requests, the client should mark the last play request using this flag.
+	@param aStatus 		 The request status which is signalled when all of the specified data has been transferred to
+						 the sound device (or when an error occurs). Possible values:
+								KErrNone:	   if all the specified data was successfully transferred and no underflow
+											   occured following this transfer (or if an underflow occurred but the
+											   request was marked with the KSndFlagLastSample flag);
+								KErrUnderflow: if data underflow occurred during or immediately following the transfer;
+								otherwise one of the system-wide error codes.
+	@param aBufferOffset Offset from the beginning of the shared chunk for the start of data to be played. This must be
+						 aligned to a value conforming to the iRequestAlignment member of the capabilities structure.
+						 @see TSoundFormatsSupportedV02.
+  	@param aLength 		 Number of bytes of data to be played. This must be a multiple of the minimum request size as
+  						 specified in the capabilities class. @see TSoundFormatsSupportedV02. It should also be a multiple
+  						 of the number of bytes per audio sample (e.g. a multiple of 4 for 2 channels of 16bit PCM).
+  	@param aFlags 		 Play request flags. Use KSndFlagLastSample to mark the last play request in a series of play
+  						 requests.
+	@pre The buffer must have been previously initialised by a call to SetBufferChunkN().
+	*/
+	inline void PlayData(TRequestStatus& aStatus,TInt aBufferOffset,TInt aLength,TUint aFlags=0);
+	
+	/**
+	Get the next available record buffer. More than one request may be pending at any time. This is an asynchronous
+	operation. If the driver is not already recording then the issuing of this request will start the capturing of
+	record data from the sound device into a record buffer.
+	@param aStatus	The request status which is signalled when buffer is available (or an error occurs). If
+					the request is successful then this result value is set to the offset within the shared chunk
+					where the buffer resides. Alternatively, if an error occurs, it will be set to one of
+					the system wide error values. These include:
+					KErrInUse: if the client needs to free up record buffers;
+					KErrOverflow: if it was necessary for the driver to over-write unread record data since the
+								  last record request;
+					KErrCancel: if the device is paused and there is no un-read record data available.			  
+					otherwise one of the system-wide error codes.
+  	@param aLength	On return, this contains the number of record bytes successfully stored in the buffer. 
+	@pre The record buffer must have been previously initialised by a call to SetBufferChunkN().
+	*/
+	inline void RecordData(TRequestStatus& aStatus, TInt& aLength);
+	
+	/**
+	Release a record buffer - making it available again for the driver to record into.
+	@param aChunkOffset: The chunk offset of the image to be released. This is the value that was returned by the
+						 RecordData() request when the buffer was claimed by the client.
+	@return KErrNone: if successful;
+			KErrNotFound: if the chunk offset is invalid;
+			otherwise one of the system-wide error codes.
+	*/
+	inline TInt ReleaseBuffer(TInt aChunkOffset);
+	
+	/**
+	Cancel all outstanding play requests.
+	This immediately stops the driver playing data and all outstanding play requests are completed with KErrCancel.
+	*/
+	inline void CancelPlayData();
+	
+	/**
+	Cancel all outstanding record requests.
+	This immediately stops the driver from capturing record data and all outstanding record requests are completed
+	with KErrCancel.
+	*/
+	inline void CancelRecordData();
+	
+	/**
+	Cancel a specific record or play request.
+	The outstanding request completes with KErrCancel.
+	@param aStatus The request status object associated with the request to be cancelled.
+	*/			   
+	inline void Cancel(const TRequestStatus& aStatus);
+	
+	/**
+	For a play back units, this method returns the number of bytes delivered to the sound device hardware. For
+	recording units, this method returns the number of bytes read from the sound device hardware. This is the
+	count since the driver was opened or since the last ResetBytesTransferred() command was issued.	
+	@return The number of bytes transferred.
+	@see ResetBytesTransferred()
+	*/
+	inline TInt BytesTransferred();
+	
+	/**
+	Reset the count of the number of bytes transferred by the sound device..
+	@see BytesTransferred().
+	*/
+	inline void ResetBytesTransferred();
+	
+	/**
+	Halt the playing or recording of data from the sound device.
+	Playing or recording can be resumed using Resume().
+	If an incomplete play request is outstanding when the device is paused, this request does not complete as a 
+	result. Resuming play operation following a pause will cause the driver to re-commence playing data from the 
+	next sample following the last one played - even of this is part way through a play buffer.
+	However, if an incomplete record request is outstanding when recording is paused, this will be completed immediately
+	as a result. Typically this will be a partially filled record buffer and the number of valid bytes in the buffer are
+	indicated via the length argument of the RecordData() method. The client should release this buffer in the normal
+	way in order to make it available again to the driver when recoding is resumed. Any other outstanding record
+	requests are completed immediately when recording is halted with a return value of KErrCancel. Likewise, record 
+	requests received after the device has been paused will complete immediately in the same way - either successfully
+	if un-read data is available or KErrCancel if not. The device must be resumed before it can be primed to capture a
+	new record buffer. The driver will capture no record data while it is in the paused state. If recording is resumed,
+	the driver will begin storing the received data from the beginning of its next available record buffer.
+	@return KErrNone if successful;
+  			KErrNotReady: if the driver is not currently playing or recording;
+		  	otherwise one of the other system-wide error codes.
+	@see Resume()
+	*/
+	inline TInt Pause();
+	
+	/**
+	Allow the sound device to resume playing or recording data.
+	This is used resume the operation of the driver following a earlier Pause() command to pause play or record.
+	@return KErrNone if successful;
+  			KErrNotReady: if the driver is not currently paused;
+		  	otherwise one of the other system-wide error codes.
+	@see Pause()
+	*/
+	inline TInt Resume();
+	
+	/**
+	Register for notification of a change in the hardware configuration of the device.
+	This is an asynchronous operation. Only one request of this type can be outstanding per driver channel.
+	@param aStatus The request status which is signalled when a change in hardware configuration occurs. Possible
+		values returned:
+			KErrNotSupported: The unit cannot detect changes in configuration;
+			KErrInUse: A notification request is already outstanding for this driver channel.
+			KErrNone: A normal change in hardware configuration has occured;
+			otherwise one of the other system-wide error codes.
+	@param aHeadsetPresent On return, this is set to ETrue if the unit is connected to a microphone or headset socket and
+		this is now present. Otherwise it returns EFalse.
+	*/
+	inline void NotifyChangeOfHwConfig(TRequestStatus& aStatus,TBool& aHeadsetPresent);
+
+	/**
+	Cancel a request for notification of a change in the hardware configuration.
+	This results in a pending request being completed immediately with KErrCancel.
+	*/
+	inline void CancelNotifyChangeOfHwConfig();
+	
+	/**
+	Issue a custom configuration request.
+	@param aFunction A number identifying the request. (Values below 0x10000000 are reserved).
+	@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.
+	*/
+	inline TInt CustomConfig(TInt aFunction,TAny* aParam=NULL);
+
+	/**
+	Calculates and returns the number of microseconds of data played since the start of playback.  If playback ends or
+	if CancelPlayData() is called, this number will be reset.
+	@param aTimePlayed A packaged TTimeIntervalMicroSecondsBuf into which to place the number of microseconds played.
+	@return	KErrNone if successful.
+			KErrNotSupported if unit is not open for playback.
+			Otherwise one of the other system wide error codes.
+	*/
+	inline TInt TimePlayed(TTimeIntervalMicroSecondsBuf& aTimePlayed);
+
+	/**
+	Calculates and returns the number of microseconds of data recorded since the start of record.  If recording ends or
+	if CancelRecord() is called, this number will be reset.
+	@param aTimeRecorded A packaged TTimeIntervalMicroSecondsBuf into which to place the number of microseconds played.
+	@return	KErrNone if successful.
+			KErrNotSupported if unit is not open for recording.
+			Otherwise one of the other system wide error codes.
+	*/
+	inline TInt TimeRecorded(TTimeIntervalMicroSecondsBuf& aTimeRecorded);
+
+#endif	// __KERNEL_MODE__
+	};
+
+#include <d32soundsc.inl>
+
+#endif // __D32SOUNDSC_H__
+