// Copyright (c) 2003-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 "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members
// which accompanies this distribution, and is available
// at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//

#ifndef __DEVSOUNDSTANDARDCUSTOMINTERFACES_H__
#define __DEVSOUNDSTANDARDCUSTOMINTERFACES_H__

#include <e32std.h>

/*****************************************************************************/
/**
UID associated with the custom interface MMMFDevSoundCustomInterfaceBitRate.
@publishedAll
@released
*/
const TUid KUidCustomInterfaceDevSoundBitRate = {0x101F7DD5};



/**
This class provides an interface to set and retrive the DevSound bit rate.

@publishedAll
@released
*/
class MMMFDevSoundCustomInterfaceBitRate
	{	
public:
	
	/**
	Gets the bit rates that are supported by DevSound in its current configuration.

	@param  aSupportedBitRates
	The supported bit rates, in bits per second, shall be appended to this array. Note that 
	the array shall be reset by this method.
	*/
	virtual void GetSupportedBitRatesL(RArray<TInt>& aSupportedBitRates) = 0;

	/**
	Returns	the current bit rate.

	@return	The current bit rate, in bits per second.
	*/
	virtual TInt BitRateL() = 0;

	/**
	Sets the bit rate to a new value.

	@param  aBitRate
	The new bit rate, in bits per second.
	*/
	virtual void SetBitRateL(TInt aBitRate) = 0;
	};


/*****************************************************************************/
/**
UID associated with the Custom interface MMMFDevSoundCustomInterfaceFileBlockLength.

@publishedPartner
@prototype

*/
const TUid KUidCustomInterfaceDevSoundFileBlockLength = {0x10273806};

/**
Custom interface class for setting the file's block length on the hwdevice. 

Note also that this interface is just a simple interface to 
set file's block length. No checking is perfomed on the values sent (hence the
Set methods do not return an error code).

@publishedPartner
@prototype
*/
class MMMFDevSoundCustomInterfaceFileBlockLength
	{
public:
	/**
	Sets the file's block length on the hwdevice
	@param aBlockAlign
	       The file's block length 
	*/
	virtual void SetFileBlockLength(TUint aBlockAlign)=0;
	};

/*****************************************************************************/
/**
UID associated with the Custom interface MMMFGsmConfig

@publishedPartner
@prototype
*/
const TUid KUidGsmConfig = {0x102825FC};

/**
This class provides an interface to set and retrive the GSM conversion format.

@publishedPartner
@prototype
*/
class MMMFGsmConfig
	{
public: 
	/** The GSM conversion format */
	enum TMMFGsmConversionFormat
		{
		/** no conversion specified */
		ENone, 
		/** for use in Full rate (06.10) and half rate (GSM 06.20 Half Rate (HR)) Vocoder */
		EALaw8bit, 
		/** for use in Full rate (06.10) and half rate (GSM 06.20 Half Rate (HR)) Vocoder */
		EULaw8bit,
		/** for use in GSM 06.60 Enhanced Full Rate (EFR) Vocoder.*/
		EAlawPCM
		};
		
	/**
	Set the conversion format using the TMMFGsmConversionFormat enum.
	This conversion must be set before the coder/decoder is started.

	@param aConvFormat - format desired.  For encoding behaviour, format will 
	be the input format and for decoding behaviour format will be the output 
	format.

	@return KErrNone - Format change supported, KErrNotSupported - Format 
	change not supported, KErrInUse - Format change attempted whilst decoding.
	*/	
	virtual TInt SetConversionFormat(TMMFGsmConversionFormat aConvFormat) = 0;

	/** 
	Provides the current conversion format.  Can be called at any time.

	@param aConvFormat - after the call contains the current format.
	For encoding behaviour, format will be the input format and for decoding
	behaviour format will be the output format.

	@return KErrNone if value returned successfully, 
			KErrUnknown if value has not been successfully configured using
			SetConversionFormat() at least once for the current instance of the
			interface and there is no default value.
			KErrGeneral for all other error scenario.
	*/
	virtual TInt ConversionFormat(TMMFGsmConversionFormat& aConvFormat) const = 0;
	};


/*****************************************************************************/
/**
UID associated with the Custom interface MSpeechEncoderConfig

@publishedPartner
@prototype
*/
const TUid KUidSpeechEncoderConfig = {0x102825FB};

/**
This class provides an interface to those CMMFHwDevices providing speech encoding. 
This interface is used for querying and configuring the operational modes of speech 
encoders as supported by those specific encoders. 
If a speech encoder does not support a mode provided by the interface, it will return KErrNotSupported.

@publishedPartner
@prototype

*/
class MSpeechEncoderConfig 
	{
public:
	/**
	Controls voice activity detection (VAD) mode.
	This method can be called at all times - while actively encoding or not.
	It should be noted that a VAD mode change could also instigate a change in the 
	mode of encoding (fixed rate encoding versus variable rate) e.g. in cases where 
	VAD requires variable rate encoding.
	The effects of activating VAD mode behaviour should be documented in the 
	CMMFHwDevice specification implementing it.

	@param aVadModeOn ETrue=On, EFalse=Off
	@return KErrNone if successful. KErrNotSupported if this method is not implemented 
	or not supported by the encoder. 
	*/
	virtual TInt SetVadMode(TBool aVadModeOn) = 0;

	/**
	Gets the current state of the voice activity detection (VAD) mode.
	This method can be called at all times - while actively encoding or not.

	@param aVadModeOn On output ETrue = On, EFalse = Off
	@return KErrNone if successful, KErrNotSupported if this method is not implemented 
	or not supported by the encoder. 
	*/
	virtual TInt GetVadMode(TBool& aVadModeOn) = 0;
	};

/*****************************************************************************/
/**
UID associated with the Custom interface MAacDecoderConfig

@publishedPartner
@prototype
*/
const TUid KUidAacDecoderConfig = {0x102825FD};

/**
This class provides an interface to the AAC decoder CMMFHwDevice in order 
to provide additional configuration information for decoding raw AAC data blocks. 

The sample rate can be configured via the CMMFHwDevice::SetConfig() method. 
An extension mechanism will be provided for further functionality as required.
The CMMFHwDevice does not contain Output channel configuration at time of writing. 
The HWA decoders to date have been hardcoded for 2ch (left / right) output. 
Additional configuration information may be provided by using extension mechanisms. 

@publishedPartner
@prototype
*/
class MAacDecoderConfig 
	{
public: 

	/**
	This is a class containing an enumerated type that defines the audio object types 
	required for configuring the AAC decoder for decoding raw AACDefined within TAudioConfig.
	*/
	class TAudioConfig
		{
	public:
		/**  The audio object type */
	    enum TAudioObjectType
	    	{
			/** Null */
	       	ENull    = 0,
			/** AacMain */
	       	EAacMain = 1,
			/** AacLc */
	       	EAacLc   = 2,
			/** AacSsr */
	       	EAacSsr  = 3,
			/** AacLtp */
	       	EAacLtp  = 4,
			/** Sbr */
	       	ESbr     = 5
	       	};
		TAudioObjectType iAudioObjectType;
		};	

public:
	/**
	Sets additional configuration parameters required for decoding raw AAC. 

	This method can be called when encoding is not active - anytime before the CMMFHwDevice is started. 
	
	For consistent configuration, this method should be called sometime before each 
	start is called on the CMMFHwDevice when decoding raw AAC. That is to say the 
	CMMFHwDevice is not required to retain prior configuration information, detect raw 
	AAC sent to it, and reconfigure the decoder with this saved information after stop 
	is called on the CMMFHwDevice. However, calling pause on the CMMFHwDevice implies 
	that the next start call will be resuming same content. For this condition, this API 
	is not required when restarting the CMMFHwDevice.
	
	@param aAudioConfig The structure containing the additional information required for decoding the raw AAC.

	@return KErrNone if successful or KErrInUse if this method is used when decoding is active. 
	*/
	virtual TInt SetAudioConfig(TAudioConfig& aAudioConfig) = 0;

	/**
	Gets additional configuration parameters supported for decoding raw AAC. 
	
	This method is allowable when encoding is not active - anytime before the CMMFHwDevice is started. 
		
	@param aSupportedAudioConfigs An array of structures containing the additional supported configurations.

	@return KErrNone if successful. 
			KErrInUse if this method is used when decoding is active. 
	*/
	virtual TInt GetSupportedAudioConfigs(RArray<TAudioConfig>& aSupportedAudioConfigs) = 0;
	};
	
/*****************************************************************************/
/**
UID associated with the Custom interface MEAacPlusDecoderIntfc

@publishedPartner
@prototype
*/
const TUid KUidEAacPlusDecoderIntfc = {0x102825FF};

/**
This class provides an interface to the eAAC+ decoder hwdevice in order to provide configuration information.

The Get.. methods can be used to retrieve the last successfully applied configuration parameters.  
A message is not sent to adaptation or the decoder. Instead, a locally saved set of the 
parameters will be updated upon successful use of ApplyConfig(). It is these saved values that 
the proxy maintains that will be returned to the user. For instance, if two interfaces are used 
and one interface is used to modify the settings, the other interface's Get… methods would not 
return those settings.  The Get.. methods will return an error if a successful use of ApplyConfig() 
has not been performed.

The Set.. methods are used to update a configuration structure within the implementation of the 
interface. When the interface is instantiated, the state of SBR and Downsampled modes will be 
disabled. Therefore it is not necessary to configure these parameters before using 
ApplyConfig() the first time. However, once modified using this instance of the interface, they 
remain in that state until Set.. again.  The values of these items are updated in an internal 
structure when each Set.. is called. 

The ApplyConfig() method is used to configure the encoder with the parameters specified by 
the Set.. methods. ApplyConfig will send back an error (KErrUnknown) if not all items are 
Set at least once. This check and the parameter values returned will be implemented in the interface proxy 
and will not query the actual decoder. The exception to this is for configuration parameters with defined 
default values (see next paragraph). 

Calling ApplyConfig() will send these values using a single message to the message handler.
ApplyConfig() should fail if it is used during decoding with a KErrInUse (or, as previously stated, 
KErrUnknown if a value without a default is not set). Since the interface proxy is not aware of decoding state, 
this check would have to be done in the adaptation implementation for this interface.

@publishedPartner
@prototype
*/
class MEAacPlusDecoderIntfc 
	{
public:
	/**
	Defines additional configuration elements required to decode eAAC+.
	*/
	enum TAudioObjectType
        {
        /** Null */
        ENull    = 0,
        /** AacLc */
        EAacLc   = 2,
        /** AacLtp */
        EAacLtp  = 4
        };

	/**
	Sets the value of the sampling frequency of the decoder to be configured by the ApplyConfig() 
	method. This is the sample rate of the core decoder, not the output sampling frequency of the decoder.
	This method can be called at all times but if ApplyConfig() is subsequently called 
	after changing this value whilst decoding, a KErrInUse error will result.

	@param aInputSamplingFrequency  value of the sampling frequency. 
	*/
	virtual void SetInputSamplingFrequency(TUint aInputSamplingFrequency) = 0;

	/**
	Sets the object type of the core decoder to be configured by the ApplyConfig() method.

	This method can be called at all times but if ApplyConfig() is subsequently called after 
	changing this value whilst decoding, a KErrInUse error will result.

	@param  aAudioObjectType TAudioObjectType for core decoder as supported by the decoder.
	*/
	virtual void SetAudioObjectType(TAudioObjectType aAudioObjectType) = 0;
	
	/**
	Sets the number of channels for the output of the decoder to be configured by the ApplyConfig() 
	method. The use of this method is to ensure coordination of output channels rendered by the decoder 
	and channel configuration of the audio system. This method does not imply that stereo to mono downmix 
	is supported by the decoder. The main purpose is for the case considering the presence of PS. A user 
	may not know if the decoder output will be mono or stereo based on header information alone, but may 
	configure the decoder for two channel output to match the audio system configuration. If the user were 
	to set the output to 1 channel and stereo data is present, the decoder may choose only one channel to 
	output or to downmix the stereo to mono. Regarding this interface, it would be more desirable to configure 
	the decoder when it is known to be mono source data and rely on downmix from the audio system instead of 
	from the decoder. The decoder, however, would provide for duplicating mono data into 2 channel data when 
	configured for 2 channels and the source data contains only 1 channel.
	This method is allowable at all times - while actively encoding or not, but using ApplyConfig() 
	if changing this value while encoding will return an error.
		 
	@param aNumOfChannels 1 - output one channel audio  = 0; 2 - output two channel audio.
	 */
	virtual void SetNumOfChannels(TUint aNumOfChannels) = 0;
	
	/**
	Controls the SBR mode of the decoder to be configured by the ApplyConfig() method. 

	If SBR is enabled and no SBR data is present, the audio data will be upsampled, 
	unless Down Sampled mode is enabled.

	This method can be called at all times but if ApplyConfig() is subsequently called 
	after changing this value whilst decoding, a KErrInUse error will result.

	@param aSbrEnabled ETrue - SBR mode enabled, EFalse - SBR mode disabled 
	*/
	virtual void SetSbr(TBool aSbrEnabled) = 0;

	/**
	Controls the downsampled mode of the decoder to be configured by the ApplyConfig() method. This setting is only meaningful if SBR is enabled.

	This method can be called at all times but if ApplyConfig() is subsequently called after 
	changing this value whilst decoding, a KErrInUse error will result.
		 
	@param aDsmEnabled ETrue - downsampled mode enabled, EFalse - downsampled mode disabled.
	*/
	virtual void SetDownSampledMode(TBool aDsmEnabled) = 0;

	/**
	Used to configure the decoder with parameters passed in the Set methods.

	This method can be called all times but will return an KErrInUse if the configuration 
	parameters would change while decoding (as none of the set parameters can be changed 
	during decoding). This checking operational state of the decoder would be done by the 
	adaptation implementation of this interface since the interface proxy is not aware of 
	the decoder state. The adaptation implementation will return an error if incorrect values 
	are used to configure the decoder.

	@return KErrNone if successful, KErrNotSupported if this method is not implemented, 
			KErrInUse if encoding in active and values are changed that are not allowed to be 
			changed during encoding, KErrArgument if one of the configuration items is not appropriate or not set. 
	*/
	virtual TInt ApplyConfig() = 0;

	/**
	Returns the value of the sampling frequency of the decoder that was last successfully 
	configured by the ApplyConfig() method.
	
	This method can be called at all times but must be called after a value has been set via 
	the ApplyConfig

	@param aInputSamplingFrequency last setting successfully applied using ApplyConfig().

	@return KErrNone if value returned successfully, 
			KErrUnknown if value has not been successfully configured using ApplyConfig() at 
			least once for the current instance of the interface or 
			KErrInUse if the encoder is active.
	*/
	virtual TInt GetInputSamplingFrequency(TUint& aInputSamplingFrequency) = 0;
	
	/**
	Returns the object type of the core decoder that was last successfully configured by the 
	ApplyConfig() method.
	
	This method can be called at all times. 
		 
	@param aAudioObjectType last setting successfully applied using ApplyConfig().

	@return KErrNone if value returned successfully, 
			KErrUnknown if value has not been successfully configured using ApplyConfig() 
			at least once for the current instance of the interface.
	*/
	virtual TInt GetAudioObjectType(TAudioObjectType& aAudioObjectType) = 0;

	/**
	Returns the number of channels that was last successfully configured by the 
	ApplyConfig() method.

	This method can be called at all times. It will return an error if used before 
	ApplyConfig() has been used successfully.

	@param aNumOfChannels last setting successfully applied using ApplyConfig().	 

	@return KErrNone if value returned successfully, 
			KErrUnknown if value has not been successfully configured using ApplyConfig() 
			at least once for the current instance of the interface.
	*/
	virtual TInt GetNumOfChannels(TUint& aNumOfChannels) = 0;

	/**
	Returns the SBR mode that was last successfully configured by the ApplyConfig() method.

	This method can be called at all times.  It will return an error if used before 
	ApplyConfig() has been used successfully.

	@param aSbrEnabled last setting successfully applied using ApplyConfig().

	@return KErrNone if value returned successfully, 
			KErrUnknown if value has not been successfully configured using ApplyConfig() 
			at least once for the current instance of the interface.	 
	*/
	virtual TInt GetSbr(TBool& aSbrEnabled) = 0;
	
	/**
	Returns the downsampled mode that was last successfully configured by the ApplyConfig() method.

	This method can be called at all times.  It will return an error if used before 
	ApplyConfig() has been used successfully.

	@param aDsmEnabled last setting successfully applied using ApplyConfig().	 

	@return KErrNone if value returned successfully, 
			KErrUnknown if value has not been successfully configured using ApplyConfig() at least 
			once for the current instance of the interface.
	*/
	virtual TInt GetDownSampledMode(TBool& aDsmEnabled) = 0;
	};
	
/*****************************************************************************/
/**
UID associated with the Custom interface MSbcEncoderIntfc

@publishedPartner
@prototype
*/
const TUid KUidSbcEncoderIntfc = {0x10282600};

/**
This class provides an interface to the SBC encoder hwdevice in order to provide configuration information.

The Get... supported methods can be used to check capabilities of the encoder by retrieving 
the last successfully applied configuration parameters. The purpose of the Get 
functions is to return the last successfully applied configuration of decoder by this 
interface. A message is not sent to adaptation or the decoder. Instead, a locally saved set 
of the parameters will be updated upon successful use of ApplyConfig(). The Get.. methods 
return an error (KErrUnknown ) if a successful use of ApplyConfig() has not been performed 
apart from the following methods, which return the range of properties supported by the 
implementation ( GetSupportedSamplingFrequencies, GetSupportedChannelModes, 
GetSupportedNumOfSubbands, GetSupportedAllocationMethods, GetSupportedNumOfBlocks, 
GetSupportedBitpoolRange).  These methods do not have setter functions as they are not 
configurable and hence will return valid data at all times.

ApplyConfig() will send these values using one message with these values in the internally 
defined structure. The message handler should define this structure in the SBC messages 
header file.   ApplyConfig() should fail (KErrInUse) if it is used during encoding and any 
values are changed other than bitpool value. Since the interface proxy is not aware of 
encoding state, this check would have to be done in the adaptation implementation for 
this interface.  The Bitpool can be updated during encoding to change the bitrate. This would 
require the use of the SetBitpoolSize() and ApplyConfig() methods.  Any other parameters can 
be changed but will result in a KErrInUse when ApplyConfig() is called.

The Set... methods are used update a client-side maintained configuration structure within the 
implementation of the interface.  When the structure is completed, ApplyConfig() should be called 
to send these client side settings to the actual hwdevice implementation.  There are no default 
values for the configuration parameters (hence all values must be set before ApplyConfig() is 
called or an error (KErrArgument) will result).

@note  This constraint is only true for configurations 
where this is supported (e.g. If GetSupportedChannelModes returns KErrNotSupported then SetChannelMode 
does not need to be set before ApplyConfig() is called). This check and the parameter values 
returned will be implemented in the interface proxy and will not query the actual encoder. If 
multiple instances of the interface are created, each would have this requirement.  

@publishedPartner
@prototype
*/
class MSbcEncoderIntfc 
	{
public:
	/**
	Defines the channel modes for the SBC encoder
	*/
	enum TSbcChannelMode
        {
        /** SbcChannelMono */
    	ESbcChannelMono,
        /** SbcChannelDual */
		ESbcChannelDual,
        /** SbcChannelStereo */
   	 	ESbcChannelStereo,
        /** SbcChannelJointStereo */
    	ESbcChannelJointStereo
        };

	/**	
	This type defines the allocation methods for the SBC encoder.
	*/
	enum TSbcAllocationMethod
       	{
        /** SbcAllocationSNR */
    	ESbcAllocationSNR,
        /** SbcAllocationLoudness */
    	ESbcAllocationLoudness
        };

	/**
	Retrieves the sampling frequencies supported by the encoder. See the class comments for details.
	This method can be called at all times.
	
	@param aSamplingFrequencies Reference to the location to store the array of supported 
	sampling frequencies.
	 
	@return KErrNone if successful, KErrNotSupported if this method is not supported.
	*/
	virtual TInt GetSupportedSamplingFrequencies(RArray<TUint>& aSamplingFrequencies) = 0;
	
	/**
	Retrieves the channel encoding supported by the encoder. See the class comments for details.
	
	This method can be called at all times.

	@param aChannelModes Reference to the location to store the array of supported channel encoding modes.

	@return KErrNone if successful, KErrNotSupported if this method is not supported.
	*/
	virtual TInt GetSupportedChannelModes(RArray<TSbcChannelMode>& aChannelModes) = 0;
	
	/**
	Retrieves the number of subbands supported by the encoder. See the class comments for details.
	
	This method can be called at all times.

	@param aNumOfSubbands Reference to the location to store the array of supported number of subbands.

	@return KErrNone if successful, KErrNotSupported if this method is not supported.
	*/
	virtual TInt GetSupportedNumOfSubbands(RArray<TUint>& aNumOfSubbands) = 0; 

	/**
	Retrieves the allocation methods supported by the encoder. See the class comments for details.
	
	This method can be called at all times.

	@param aAllocationMethods Reference to the location to store the array of supported allocation methods.

	@return KErrNone if successful, KErrNotSupported if this method is not supported.
	*/
	virtual TInt GetSupportedAllocationMethods(RArray<TSbcAllocationMethod>& aAllocationMethods) = 0;
	
	/**
	Retrieves the number of blocks supported by the encoder. See the class comments for details.
	
	This method can be called at all times but if ApplyConfig() is subsequently called 
	after changing this value whilst encoding, a KErrInUse error will result.

	@param aNumOfBlocks Reference to the location to store the array of supported number of blocks.

	@return KErrNone if successful, KErrNotSupported if this method is not supported.
	*/
	virtual TInt GetSupportedNumOfBlocks(RArray<TUint>& aNumOfBlocks) = 0;
	
	/**
	Retrieves the min and max bitpool values supported by the encoder. See the class comments for details.
	
	This method can be called at all times but and ApplyConfig() can be called to change the value whilst encoding.

	@param aMinSupportedBitpoolSize minimum bitpool value allowed by the encoder.
	@param aMaxSupportedBitpoolSize maximum bitpool value allowed by the encoder.

	@return KErrNone if successful, KErrNotSupported if this method is not supported.
	*/
	virtual TInt GetSupportedBitpoolRange(TUint& aMinSupportedBitpoolSize, TUint& aMaxSupportedBitpoolSize) = 0;

	/**
	Sets the value of the sampling frequency of the encoder to be configured by the ApplyConfig() method.

	This method can be called at all times but if ApplyConfig() is subsequently called 
	after changing this value whilst encoding, a KErrInUse error will result.

	@param aSamplingFrequency values according to standard and supported by encoder.
 	*/
	virtual void SetSamplingFrequency(TUint aSamplingFrequency) = 0;

	/**
	Sets the channel mode of the encoder to be configured by the ApplyConfig() method. 
	See the class comments for details.
	
	This method can be called at all times but if ApplyConfig() is subsequently called after 
	changing this value whilst encoding, a KErrInUse error will result.

	@param aChannelMode (ESbcChannelMono, ESbcChannelDual, ESbcChannelStereo, 
			ESbcChannelJointStereo) when supported by encoder.	 

	*/
	virtual void SetChannelMode(TSbcChannelMode aChannelMode) = 0;

	/**
	Sets the channel mode of the encoder to be configured by the ApplyConfig() method.  

	This method can be called at all times but if ApplyConfig() is subsequently called after 
	changing this value whilst encoding, a KErrInUse error will result.

	@param aNumOfSubbands values according to standard and supported by encoder.	

	*/
	virtual void SetNumOfSubbands(TUint aNumOfSubbands) = 0;

	/**
	Sets the allocation method of the encoder to be configured by the ApplyConfig() method.

	This method can be called at all times but if ApplyConfig() is subsequently called after 
	changing this value whilst encoding, a KErrInUse error will result.
		 
	@param aAllocationMethod ESbcAllocationSNR, ESbcAllocationLoudness when supported by encoder

	*/
	virtual void SetAllocationMethod(TSbcAllocationMethod aAllocationMethod) = 0;

	/**
	Sets the number of blocks of the encoder to be configured by the ApplyConfig() method.

	This method can be called at all times but if ApplyConfig() is subsequently called after 
	changing this value whilst encoding, a KErrInUse error will result.
		
	@param aNumOfBlocks values according to standard and supported by encoder.	  	 
	*/
	virtual void SetNumOfBlocks(TUint aNumOfBlocks) = 0;
	
	/**
	Sets the size of the bitpool of the encoder to be configured by the ApplyConfig() method.  

	This method is allowable at all times - while actively encoding or not.

	@param aBitpoolSize values according to standard and supported by encoder.

	*/
	virtual void SetBitpoolSize(TUint aBitpoolSize) = 0;

	/**
	Used to configure the encoder with parameters passed in the Set… methods.
	This method can be called at all times - while actively encoding or not. 
	An error (KErrInUse) will be returned if any configuration parameter, other 
	than bitpool size, is changed while encoding. This checking operational 
	state of the encoder would be done by the adaptation implementation of this 
	interface since the interface proxy is not aware of the encoder state. Also, 
	the adaptation implementation will return an error if incorrect values are 
	used to configure the encoder.
	
	@note  Even though some preliminary checking is done in the set methods (to see 
	if it is valid to set the values at all) it is expected that 

	@return KErrNone if successful, 
			KErrNotSupported if this method is not implemented, 
			KErrInUse if encoding in active and values are changed that are not 
			allowed to be changed during encoding, 
			KErrArgument if one of the configuration items is not appropriate or 
			if all the values are not set (unless some of the values are not 
			supported, in which case these values should be ignored).	 
	*/
	virtual TInt ApplyConfig() = 0;

	/**
	Gets the value of the sampling frequency of the encoder that was last successfully 
	configured by the ApplyConfig() method.

	This method can be called at all times - while actively encoding or not, but will 
	return an error if used before ApplyConfig() has been used successfully.

	@param aSamplingFrequency last setting successfully applied using ApplyConfig().

	@return KErrNone if value returned successfully, 
			KErrUnknown if value has not been successfully configured using ApplyConfig() 
			at least once for the current instance of the interface, 
			KErrNotSupported if this method is not implemented (to match its set and 
			getsupported methods).
	*/
	virtual TInt GetSamplingFrequency(TUint& aSamplingFrequency) = 0;

	/**
	Gets the channel mode of the encoder that was last successfully configured by the 
	ApplyConfig() method.

	This method can be called at all times - while actively encoding or not, but will 
	return an error if used before ApplyConfig() has been used successfully.

	@param aChannelMode last setting successfully applied using ApplyConfig(). 

	@return KErrNone if value returned successfully, 
			KErrUnknown if value has not been successfully configured using ApplyConfig() 
			at least once for the current instance of the interface.
	*/
	virtual TInt GetChannelMode(TSbcChannelMode& aChannelMode) = 0;

	/**
	Gets the channel mode of the encoder that was last successfully configured by the 
	ApplyConfig() method.

	This method can be called at all times - while actively encoding or not, 
	but will return an error if used before ApplyConfig() has been used successfully.
		 
	@param aNumOfSubbands last setting successfully applied using ApplyConfig().
	
	@return KErrNone if value returned successfully, 
			KErrUnknown if value has not been successfully configured using ApplyConfig() 
			at least once for the current instance of the interface, 
			KErrNotSupported if this method is not implemented (to match its set and 
			getsupported methods)
	*/
	virtual TInt GetNumOfSubbands(TUint& aNumOfSubbands) = 0;
	
	/**
	Gets the number of blocks of the encoder that was last successfully configured by 
	the ApplyConfig() method.

	This method can be called at all times - while actively encoding or not, but will 
	return an error if used before ApplyConfig() has been used successfully.

	@param aNumOfBlocks last setting successfully applied using ApplyConfig().

	@return KErrNone if value returned successfully, 
			KErrUnknown if value has not been successfully configured using ApplyConfig() 
			at least once for the current instance of the interface, 
			KErrNotSupported if this method is not implemented (to match its set and 
			getsupported methods)
	*/
	virtual TInt GetNumOfBlocks(TUint& aNumOfBlocks) = 0;

	/**
	Gets the allocation method of the encoder that was last successfully configured 
	by the ApplyConfig() method.

	This method can be called at all times - while actively encoding or not, but will 
	return an error if used before ApplyConfig() has been used successfully.
	@param aAllocationMethod last setting successfully applied using ApplyConfig().

	@return KErrNone if value returned successfully, 
			KErrUnknown if value has not been successfully configured using ApplyConfig() 
			at least once for the current instance of the interface, 
			KErrNotSupported if this method is not implemented (to match its set and 
			getsupported methods).
	*/
	virtual TInt GetAllocationMethod(TSbcAllocationMethod& aAllocationMethod) = 0;

	/**
	Gets the size of the bitpool of the encoder that was last successfully 
	configured by the ApplyConfig() method.

	This method can be called at all times - while actively encoding or not, but 
	will return an error if used before ApplyConfig() has been used successfully.

	@param aBitpoolSize last setting successfully applied using ApplyConfig().

	@return KErrNone if value returned successfully, 
			KErrUnknown if value has not been successfully configured using ApplyConfig() 
			at least once for the current instance of the interface, 
			KErrNotSupported if this method is not implemented (to match its set and 
			getsupported methods).
	*/
	virtual TInt GetBitpoolSize(TUint& aBitpoolSize) = 0;
	}; 

/*****************************************************************************/
/**
UID associated with the Custom interface MG711DecoderIntfc

@publishedPartner
@prototype
*/
const TUid KUidG711DecoderIntfc = {0x10282601};

/**
This class provides an interface to the G711 decoder CMMFHwDevice in order to provide 
additional configuration information.

@publishedPartner
@prototype
*/
class MG711DecoderIntfc 
	{
public:
	/** The Decoder mode */
	enum TDecodeMode
        {
        /** DecALaw */
        EDecALaw,
        /** DecULaw */
        EDecULaw
        };

	/**
	Informs the decoder of the encoded data format that will be sent to it.

	This method can be called when decoding is not active - anytime before started 
	or after stopped. 
	@param 	aDecodeMode the decode mode.

	@return KErrNone if successful. 
			KErrInUse if this method is used when encoding is active. 
			KErrNotSupported if this method is not implemented. 
	*/
	virtual TInt SetDecoderMode(TDecodeMode aDecodeMode) = 0;
	
	/**
	Queries the decoder of the encoded data format that has been active.

	This method can be called at all times.
	@param 	aDecodeMode the decode mode.

	@return KErrNone if successful. 
			KErrInUse if this method is used when encoding is active. 
			KErrNotSupported if this method is not implemented. 
	*/
	virtual TInt GetDecoderMode(TDecodeMode& aDecodeMode) = 0;

	/** 	
	Used to enable and disable the comfort noise generation capability.

	This method can be called when decoding is not active - anytime before started 
	or after stopped. 
	
	@param 	aCng ETrue = Comfort Noise Generation enabled; EFalse = Comfort Noise 
	Generation disabled
	
	@return	KErrNone if successful. 
			KErrInUse if this method is used when encoding is active. 
			KErrNotSupported if this method is not implemented. 
	*/
	virtual TInt SetComfortNoiseGeneration(TBool aCng) = 0;

	/** 	
	Used to find out if comfort noise generation is enabled or not.

	This method can be called when decoding is not active - anytime before started 
	or after stopped. 

	@param 	aCng ETrue = Comfort Noise Generation enabled; EFalse = Comfort Noise 
	Generation disabled

	@return	KErrNone if successful. 
			KErrInUse if this method is used when encoding is active. 
			KErrNotSupported if this method is not implemented. 
	*/
	virtual TInt GetComfortNoiseGeneration(TBool& aCng) = 0;

	/**
	Used to enable and disable the packet loss concealment capability.

	This can be called when decoding is not active - anytime before started or after 
	stopped. 

	@param	aPlc ETrue = plc enabled; EFalse = plc disabled

	@return KErrNone if successful. KErrInUse if this method is used when encoding is 
	active. KErrNotSupported if this method is not implemented.
	*/
	virtual TInt SetPacketLossConcealment(TBool aPlc) = 0;

	/** 	
	Used to find out if packet loss concealment capability is enabled or not.

	This method can be called when decoding is not active - anytime before started or 
	after stopped. 

	@param 	aPlc ETrue = packet loss concealment enabled; EFalse = packet loss 
	concealment disabled

	@return	KErrNone if successful. KErrInUse if this method is used when encoding is active. 
			KErrNotSupported if this method is not implemented. 
	*/
	virtual TInt GetPacketLossConcealment(TBool& aPlc) = 0;

	};
	
/*****************************************************************************/
/**
UID associated with the Custom interface MG711EncoderIntfc

@publishedPartner
@prototype
*/
const TUid KUidG711EncoderIntfc = {0x10282602};

/**
This class provides an interface to the G711 encoder CMMFHwDevice in order to provide 
additional configuration information.

@publishedPartner
@prototype
*/
class MG711EncoderIntfc 
	{
public:
	/** The encoder mode */
	enum TEncodeMode
        {
        /** EncALaw */
        EEncALaw,
        /** EncULaw */
        EEncULaw
        };

	/** 	
	Configures the encoder's encoding format.

	This method can be called when decoding is not active - anytime before started or 
	after stopped. 

	@param 	aEncodeMode the encode mode.

	@return	KErrNone if successful. KErrInUse if this method is used when encoding is active. 
			KErrNotSupported if this method is not implemented. 
	*/
	virtual TInt SetEncoderMode(TEncodeMode aEncodeMode) = 0;

	/** 	
	Controls voice activity detection (VAD) mode.

	This method can be called at all times.

	@param 	aVadModeOn ETrue=On, EFalse=Off

	@return	KErrNone if successful, 
			KErrNotSupported if this method is not implemented or not supported by the encoder
	*/
	virtual TInt SetVadMode(TBool aVadModeOn) = 0;

	/** 
	Gets the current state of the voice activity detection (VAD) mode.

	This method can be called at all times - while actively encoding or not.

	@param 	aVadModeOn On output ETrue=On, EFalse=Off

	@return	KErrNone if successful. 
			KErrNotSupported if this method is not implemented or VAD is not supported by the encoder. 
	*/
	virtual TInt GetVadMode(TBool& aVadModeOn) = 0;
	};

/*****************************************************************************/
/**
UID associated with the Custom interface MG729DecoderIntfc

@publishedPartner
@prototype
*/
const TUid KUidG729DecoderIntfc = {0x10282603};

/**
This class provides an interface to the G729 decoder CMMFHwDevice in order to provide additional 
configuration information.

@publishedPartner
@prototype
*/
class MG729DecoderIntfc
	{
public:
	/**
	Informs the decoder that the next buffer sent to it will contain bad LSF data.

	This method can be called when decoding is active.
 
	This method will be called after a buffer has been received from the CMMFHwDevice, 
	and before it is returned to the CMMFHwDevice.

	@return	KErrNone if successful. 
			KErrInUse if this method is used out of sequence. 
			KErrNotSupported if this method is not implemented. 
	*/
	virtual	TInt BadLsfNextBuffer() = 0;
	};

/*****************************************************************************/
/**
UID associated with the Custom interface MG729EncoderIntfc

@publishedPartner
@prototype
*/
const TUid KUidG729EncoderIntfc = {0x10282604};

/**
This class provides an interface to the G729 encoder CMMFHwDevice in order to provide 
additional configuration information.

@publishedPartner
@prototype
*/
class MG729EncoderIntfc
	{
public:
	/** 
	Controls voice activity detection (VAD) mode.

	This method is allowable at all times - while actively encoding or not.
	@param 	aVadModeOn ETrue=On, EFalse=Off

	@return	KErrNone if successful. KErrNotSupported if this method is not implemented 
	or not supported by the encoder. 
	*/
	virtual TInt SetVadMode(TBool aVadModeOn) = 0;

	/**
	Gets the current state of the voice activity detection (VAD) mode.

	This method can be called at all times - while actively encoding or not.

	@param 	aVadModeOn On output ETrue=On, EFalse=Off
	@return	KErrNone if successful. KErrNotSupported if this method is not implemented 
	or VAD is not supported by the encoder. 
	*/
	virtual TInt GetVadMode(TBool& aVadModeOn) = 0;
	};

/*****************************************************************************/
/**
UID associated with the Custom interface MIlbcDecoderIntfc

@publishedPartner
@prototype
*/
const TUid KUidIlbcDecoderIntfc = {0x10282605};

/**
This class provides an interface to the Ilbc decoder CMMFHwDevice in order to provide 
additional configuration information.

@publishedPartner
@prototype
*/
class MIlbcDecoderIntfc
	{
public:
	/** The Ibc decoder mode */
	enum TDecodeMode
        {
        /** 20msFrame */
        E20msFrame,
        /** 30msFrame */
        E30msFrame
        };

	/**
	Informs the decoder of the encoded data format that will be sent to it.

	This method can be called when decoding is not active - anytime before started or 
	after stopped. 

	@param 	aDecodeMode the decode mode.

	@return	KErrNone if successful. 
			KErrInUse if this method is used when decoding is active. 
			KErrNotSupported if this method is not implemented.
	*/
	virtual TInt SetDecoderMode(TDecodeMode aDecodeMode) = 0;

	/**
	Used to enable and disable the comfort noise generation capability.

	This method is allowable when decoding is not active - anytime before started or 
	after stopped. 

	@param 	aCng ETrue = comfort noise generation enabled; EFalse = comfort noise 
	generation disabled

	@return	KErrNone if successful. 
			KErrInUse if this method is used when encoding is active. 
			KErrNotSupported if this method is not implemented. 
	*/
	virtual TInt SetComfortNoiseGeneration(TBool aCng) = 0;

	/**
	Used to find out if comfort noise generation is enabled or not.

	This method is allowable when decoding is not active - anytime before started or 
	after stopped. 

	@param 	aCng On output ETrue = comfort noise generation enabled; EFalse = comfort 
	noise generation disabled

	@return	KErrNone if successful. 
			KErrInUse if this method is used when encoding is active. 
			KErrNotSupported if this method is not implemented. 
	*/
	virtual TInt GetComfortNoiseGeneration(TBool& aCng) = 0;
	};

/*****************************************************************************/
/**
UID associated with the Custom interface MIlbcEncoderIntfc

@publishedPartner
@prototype
*/
const TUid KUidIlbcEncoderIntfc = {0x10282606};

/**
This class provides an interface to the Ilbc encoder CMMFHwDevice in order to provide 
additional configuration information.

@publishedPartner
@prototype
*/
class MIlbcEncoderIntfc
	{
public:
	/** The Ibc encoder mode*/
	enum TEncodeMode
        {
        /** 20msFrame */
        E20msFrame,
        /** 30msFrame */
        E30msFrame
        };

	/**
	Configures the encoder's encoding format.

	This method is allowable when encoding is not active - anytime before started or 
	after stopped. 

	@param 	aEncodeMode the encode mode.

	@return	KErrNone if successful. 
			KErrInUse if this method is used when encoding is active. 
			KErrNotSupported if this method is not implemented. 
	*/
	virtual TInt SetEncoderMode(TEncodeMode aEncodeMode) = 0;

	/**
	Controls voice activity detection (VAD) mode.

	This method is allowable at all times - while actively encoding or not.

	@param 	aVadModeOn ETrue=On, EFalse=Off

	@return	KErrNone if successful. 
			KErrNotSupported if this method is not implemented or not supported by the encoder. 
	*/
	virtual TInt SetVadMode(TBool aVadModeOn) = 0;

	/**
	Gets the encoder's current encoding format.

	This method is allowable when encoding is not active - anytime before started or 
	after stopped. 

	@param 	&aEncodeMode the encode mode.

	@return	KErrNone if successful. 
			KErrInUse if this method is used when encoding is active. 
			KErrNotSupported if this method is not implemented. 
	*/
	virtual TInt GetEncoderMode(TEncodeMode &aEncodeMode) = 0;

	/**
	Gets the current state of the voice activity detection (VAD) mode.

	This method is allowable at all times - while actively encoding or not.

	@param 	aVadModeOn On output ETrue=On, EFalse=Off

	@return	KErrNone if successful. 
			KErrNotSupported if this method is not implemented or VAD is not supported 
			by the encoder. 
	*/
	virtual TInt GetVadMode(TBool& aVadModeOn) = 0;
	};

/*****************************************************************************/
/**
UID associated with the Custom interface MMMFErrorConcealmentIntfc

@publishedPartner
@prototype
*/
const TUid KUidErrorConcealmentIntfc = {0x10282607};

/**
This custom interface can be used to indicate that data has been lost. Typical usage 
would be during streaming. Lost packets of audio data would not get played, but the 
video data may still be available for playback. If video playback is synchronized to 
audio then this API can be used to indicate that audio data is lost so that video 
playback can continue. It could also be used for an audio-only source to maintain 
synchronization in time if data is lost.

@publishedPartner
@prototype
*/
class MMMFErrorConcealmentIntfc
	{
public:
	/**
	Indicates that next buffer sent to CMMFHwDevice will not contain any valid data, 
	and that a single frame of data has been lost, and that error concealment should 
	be provided for that lost frame. This method will be called after a buffer has been 
	received from the Hardware Device, and before it is returned to the Hardware Device.

	@return	KErrNone if successful. 
			KErrInUse if this method is used out of sequence. 
			KErrNotSupported if this method is not implemented.
	*/
	virtual TInt ConcealErrorForNextBuffer() = 0;
	/**
	Puts the CMMFHwDevice into frame-based operation. This may be required in cases where
	 the decoder only supports error concealment in a frame-based mode of operation. 
	 Operating in frame-based mode means that the decoder requires that each buffer it 
	 receives contains only complete data frames. 

	Frame mode is limited to a single frame per buffer. The alternative to frame-based mode 
	is buffer-based mode, the default interface for CMMFHwDevices and decoders. 

	In buffer-based mode, complete data frames are not required to be contained within a 
	single buffer. A data frame may span consecutive data buffers in buffer-based mode. 

	As it is less efficient than buffer-based mode, Frame-based mode should be used as a 
	less-preferred option where errors are present and the CMMFHwDevice implementation would 
	not be tolerant to buffer-based mode error.  This condition would be indicated by 
	FrameModeRqrdForEC resulting in its parameter being set to ETrue.
  
	This method can be called when decoding is not active - anytime before the CMMFHwDevice 
	is started, or after it is stopped.

	@param	aFrameModeOn ETrue = frame mode on; EFalse = frame mode off.
	
	@return KErrNone if successful. 
			KErrInUse if this method is used out of sequence. 
			KErrNotSupported if this method is not implemented.	
	*/
	virtual TInt SetFrameMode(TBool aFrameModeOn) = 0;

	/**
	Queries the CMMFHwDevice to find out if frame mode is required by the implementing 
	CMMFHwDevice in order for it to support error concealment.
	
	This method is allowable when decoding is not active - anytime before the CMMFHwDevice 
	is started, or after it is stopped.
	@param	aFrameModeRqrd ETrue = frame mode required; EFalse = frame mode not required
	@return	KErrNone if successful. 
			KErrInUse if this method is used during decoding. 
			KErrNotSupported if this method is not implemented. 
	*/
	virtual TInt FrameModeRqrdForEC(TBool& aFrameModeRqrd) = 0;
	};

/*****************************************************************************/
/**
UID associated with the Custom interface MAudioVibraControl

@publishedPartner
@prototype
*/
const TUid KUidAudioVibraControl = {0x10282608};

/**
This class provides an interface for controlling vibra. DevSound should interpret the 
instantiation of this interface as a vibra control request by the user. The default vibra 
behavior implemented by the DevSound for the associated stream will not be performed while 
the user has control, In other words whilst this interface is instantiated. DevSound default vibra behavior 
for the associated stream will return once this interface is deleted. Other instances of 
DevSound may be instantiated for other audio streams at the same time. When multiple instances 
of DevSound are instantiated, priority and preference values are used to determine which audio 
streams are rendered. Prioritization of vibra control is determined by adaptation. Due to 
resource conflicts, and prioritization by adaptation, it may be possible that an audio stream 
is played, but not the vibra that accompanies that audio. For instance, if audio is mixed and 
two audio streams are rendered, vibra playback might not be mixed. Vibra playback may be 
prioritized by adaptation to a single controller. The behavior in these cases would be based 
on adaptation implementation. The user is not notified if vibra is not played.

@publishedPartner
@prototype
*/
class MAudioVibraControl 
	{
public:
	/** 
	Turns vibra on.

	@return	KErrNone if successful KErrNotSupported if this method is not implemented.	
	*/
	virtual TInt StartVibra() = 0;
	
	/** 
	Turns vibra off.
	
	@return	KErrNone if successful. KErrNotSupported if this method is not implemented.	
	*/
	virtual TInt StopVibra() = 0;
	};

/*****************************************************************************/
/**
UID associated with the Custom interface MMMFSampleBuffering

@publishedPartner
@prototype
*/
const TUid KUidSampleBuffering = {0x10282609};

/**
Custom interface class to allow DevSound to support buffering of samples before playback begins. 
This allows playback to be more robust to underflow errors when playback begins at the expense 
of higher latency before playback starts.

@publishedPartner
@prototype
*/
class MMMFSampleBuffering
	{
public:
	/**
	Enables buffering up of samples before playback begins. This function is only effective before 
	CMMFDevSound::PlayInit() is called - calling the function after this will have no effect.
	@return  "This method may return one of the system-wide error codes."
	*/
	virtual TInt MmsbEnableSampleBufferingBeforePlayback() = 0;
	
	/**
	Disables buffering up of samples before playback begins. This function is only effective before 
	CMMFDevSound::PlayInit() is called - calling the function after this will have no effect.
	@return  "This method may return one of the system-wide error codes."
	*/
	virtual TInt MmsbDisableSampleBufferingBeforePlayback() = 0;

	/**
	Asynchronous request that completes when Playback actually starts.
	@param	"aStatus" "TRequestStatus that will be completed when play actually starts"
	*/
	virtual void MmsbNotifyPlayStarted(TRequestStatus& aStatus) = 0;

	/**
	Cancel any outstanding asynchronous NotifyPlayStarted requests.
	*/
	virtual void MmsbCancelNotifyPlayStarted() = 0;
	};

/*****************************************************************************/
/**
UID associated with the Custom interface MMMFPlaybackStatus.

@publishedPartner
@prototype
*/
const TUid KUidPlaybackStatus = {0x10273811};

/**
Custom interface class to enable access to the DevSound implementation to report the number of 
consumed input bytes, number of successfully decoded samples, samples played, system time and
total samples played.

@publishedPartner
@prototype
*/	
class MMMFPlaybackStatus
	{
public:
	/**  Play back status information */
	struct TMMFPlaybackStatus
		{
		/** Number of consumed input bytes */
		TInt64	aInputBytes;	
		/** Number of successfully decoded samples */
		TInt64	aDecodedSamples;		 
		/** Number of decoded samples played */
		TInt64	aDecodedSamplesPlayed;	
		/** Current system time */
		TInt64	aSystemTime;
		/**  Total samples played */
		TInt64 aTotalSamplesPlayed;
		};
	/**
	A method to query for detailed status information from a playing DevSound.
	including timestamp information from the DSP.
	@param  aStatus the current playback status.
	@return  "This method may return one of the system-wide error codes."
	*/
	virtual TInt MmpsGetPlaybackStatusInformation(TMMFPlaybackStatus& aStatus)= 0;

	/**
	Request notification of loss of sync during decode - the notification will be received 
	in the DevSound client callback SendEventToClient with the	event type set to KMMFEventLossOfDecodeSync. 
	
	@return  "This method may return one of the system-wide error codes."
	*/
	virtual TInt MmpsRequestLossOfSyncNotification() = 0;
	
	/**
	Cancel the request for notification of loss of sync.
	
	@return  "This method may return one of the system-wide error codes."
	*/
	virtual TInt MmpsCancelLossOfSyncNotification() = 0;
	};

/*****************************************************************************/
/**
UID associated with the Custom interface MMMFDSPControl

@publishedPartner
@prototype
*/
const TUid KUidDSPControl = {0x1028260A};

/**
Custom interface class to allow control of DSP behaviour.

@publishedPartner
@prototype
*/		
class MMMFDSPControl
	{
public:
	
	/**
	Get the timestamp information from the DSP
	
	@param aSamplesPlayed - number of audio samples played so far.
	@param aSystemTime - current system time 
	@param aB - bytes consumed by the decoder
	@param aT - bytes successfully decoded by the decoder.

	@return  "This method may return one of the system-wide error codes."
	*/
	virtual TInt MmdspcGetAudioPlaybackInfo(TInt64& aSamplesPlayed, TInt64& aSystemTime, TUint& aB, TUint& aT) = 0;

	/**
	Place DevSound in a mode where overflow/underflow errors on recording are ignored.
	@return "This method may return one of the system-wide error codes."
	*/
	virtual TInt MmdspcAcceptRecordBuffersInvalidFollowingStop() = 0;

	/**
	Place DevSound in a mode where overflow/underflow errors on playing are ignored.
	@return "This method may return one of the system-wide error codes."
	*/
	virtual TInt MmdspcAcceptPlaybackBuffersInvalidFollowingStop() = 0;
	};
	
/*****************************************************************************/
/**
UID associated with the Custom interface MMMFUnderflowAutoStopControl

@publishedPartner
@prototype
*/
const TUid KUidUnderflowAutoStopControl = {0x1028260B};

/**
Custom interface class to control underflow behaviour.

@publishedPartner
@prototype
*/	
class MMMFUnderflowAutoStopControl
	{	
public:
	/**
	Turn off the default DevSound behaviour of automatically Stopping when an underflow 
	occurs. The underflow will be reported but play can continue when the client sends 
	more data - it is up to the client to call stop even in the case of end of file.
	
	@return  "This method may return one of the system-wide error codes."
	*/
	virtual TInt MmuascTurnOffUnderflowAutoStop() = 0;
	};

/*****************************************************************************/
/**
UID associated with the Custom interface MMMFSetDRMProtected

@publishedPartner
@prototype
*/
const TUid KUidSetDRMProtected = {0x1028260C};

/**
This class provides an interface to mark data being played as DRM protected.

@publishedPartner
@prototype
*/	
class MMMFSetDRMProtected
	{
public:
	/**
	Indicate whether the data being played is DRM protected or not
	 
	@param  aDRMProtected the required DRM state.
	@return  "This method may return one of the system-wide error codes."
	*/
	virtual TInt MmsdpMarkDataAsDRMProtected(TBool aDRMProtected) = 0;
	};

/*****************************************************************************/
/**
UID associated with the Custom interface MMMFBufferFramesConfig.

@publishedPartner
@prototype
*/
const TUid KUidBufferFramesConfig = {0x1028260D};

/**
This class provides an interface to configure and retrive the buffer frames.

@publishedPartner
@prototype
*/		
class MMMFBufferFramesConfig
	{
public:
	/**
	For use when encoding to set the number of encoded frames contained in each buffer 
	sent back to the client. The method should be called after CMMFDevSound::InitilaizeL 
	but before RecordInitL.

	@param aFrameCount - Number of frames per buffer 
	@param aSamplesPerFrame - numer of samples per frame
	@return  "This method may return one of the system-wide error codes."
	*/
	virtual TInt MmbfcSetNumberOfFramesPerInputBuffer(TInt aFrameCount, TInt aSamplesPerFrame)=0;
	
	/**
	For use when decoding to set the number of encoded frames contained in each buffer sent 
	down to DevsSund for playback. The method should be called after CMMFDevSound::InitilaizeL 
	but before PlayInitL.

	@param aFrameCount - Number of frames per buffer 
	@param aSamplesPerFrame - numer of samples per frame
	
	@return  "This method may return one of the system-wide error codes."
	*/
	virtual TInt MmbfcSetNumberOfFramesPerOutputBuffer(TInt aFrameCount, TInt aSamplesPerFrame)=0;
	};

/*****************************************************************************/
/**
UID associated with the Custom interface MMMFGetTimestamps

@publishedPartner
@prototype
*/
const TUid KUidGetTimestamps = {0x1028260E};

/**
This class provides an interface to configure and retrive time stamps.

@publishedPartner
@prototype
*/	
class MMMFGetTimestamps
	{
public:
	/**
	Enable or disable support for system timestamps during recording, used for Audio / Video sync. 
	This method can only be called after recording has been initialised, but before recording 
	has started. Once recording is underway, the setting cannot be changed.

	@param aEnable ETrue to enable recording timestamps, EFalse to disable it.

	@return KErrNotReady if DevSound has not yet been initialised, KErrNotSupported if 
	DevSound is not in recording mode or KErrInUse if recording is already underway.
	*/
	virtual TInt MmgtSetRecordSystemTimestampsEnabled(TBool aEnable) = 0;

	/**
	This method returns the system timestamp corresponding to the CMMFDataBuffer with the 
	given position within the recording stream. This timestamp is the system time at which 
	the buffers timestamp, as returned by CMMFBuffer::TimeToPlay, was valid.
	This method can only be used if the recording timestamps were enabled before recording 
	started using the SetRecordSystemTimestampsEnabled method.

	@param aBufferPosition The timestamp from the buffer, as returned by CMMFBuffer::TimeToPlay.
	@param aTimestamp Returns the corresponding system time, in universal time.

	@return A System error code. 
			KErrNotSupported if recording is not ongoing; 
			KErrNotReady if DevSound is not initialized, or TimeStamps have not been enabled; 
			KErrNotFound if the timestamp given does not correspond to a recent record buffer.
	*/
	virtual TInt MmgtGetSystemTimestampForBuffer(const TTimeIntervalMicroSeconds& aBufferPosition, 
	                                                   TTime& aTimestamp) const = 0;
	};

/*****************************************************************************/
/**
UID associated with the Custom interface MMMFAdvancedAACEncodeSettings

@publishedPartner
@prototype
*/
const TUid KUidAdvancedAACEncoderSettings = {0x102825FE};

/**
Advanced AAC Encode Bit-rate Configuration

@publishedPartner
@prototype
*/
class MMMFAdvancedAACEncodeSettings
	{
public:
	/** AAC BItrate mode */
	enum TAACBitrateMode
		{
		/** AACBitrateModeNone */
		EAACBitrateModeNone,
		/** AACBitrateModeAbsolute */
		EAACBitrateModeAbsolute,
		/** AACBitrateModeVariable */
		EAACBitrateModeVariable,
		/** AACBitrateModeFixed */
		EAACBitrateModeFixed
		};
	/**
	SetAACEncodeBitrateMode

	Set the bitrate mode for AAC encoding. This must be called before the encoding starts.

	@param aBitrateMode the structure containing the additional information required for decoding the raw AAC.
	@return KErrNone if successful. KErrInUse if this method is used when decoding is active. 
	*/
	virtual TInt SetAACEncodeBitrateMode(TAACBitrateMode aBitrateMode)=0;

	/**
	This interface returns the current AACEncoding bitrate mode.

	@param  aBitrateMode the structure containing the additional information.
	@return  KErrNone if successful. KErrNotSupported if this method is not implemented.
	*/
	virtual TInt GetAACEncodeBitrateMode(TAACBitrateMode& aBitrateMode) = 0;
	};
	
/*****************************************************************************/

	
#endif 
	
