// 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 "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:
//
/**
@publishedAll
@released
@file
*/
#ifndef __DEVSOUNDSTANDARDCUSTOMINTERFACES_H__
#define __DEVSOUNDSTANDARDCUSTOMINTERFACES_H__
#include <e32std.h>
/**
UID associated with the custom interface MMMFDevSoundCustomInterfaceBitRate.
*/
const TUid KUidCustomInterfaceDevSoundBitRate = {0x101F7DD5};
/**
This class provides an interface to set and retrive the DevSound bit rate.
*/
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.
*/
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).
*/
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
*/
const TUid KUidGsmConfig = {0x102825FC};
/**
This class provides an interface to set and retrive the GSM conversion format.
*/
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
*/
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.
*/
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
*/
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.
*/
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
*/
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.
*/
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
*/
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.
*/
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
*/
const TUid KUidG711DecoderIntfc = {0x10282601};
/**
This class provides an interface to the G711 decoder CMMFHwDevice in order to provide
additional configuration information.
*/
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
*/
const TUid KUidG711EncoderIntfc = {0x10282602};
/**
This class provides an interface to the G711 encoder CMMFHwDevice in order to provide
additional configuration information.
*/
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
*/
const TUid KUidG729DecoderIntfc = {0x10282603};
/**
This class provides an interface to the G729 decoder CMMFHwDevice in order to provide additional
configuration information.
*/
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
*/
const TUid KUidG729EncoderIntfc = {0x10282604};
/**
This class provides an interface to the G729 encoder CMMFHwDevice in order to provide
additional configuration information.
*/
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
*/
const TUid KUidIlbcDecoderIntfc = {0x10282605};
/**
This class provides an interface to the Ilbc decoder CMMFHwDevice in order to provide
additional configuration information.
*/
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
*/
const TUid KUidIlbcEncoderIntfc = {0x10282606};
/**
This class provides an interface to the Ilbc encoder CMMFHwDevice in order to provide
additional configuration information.
*/
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
*/
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.
*/
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
*/
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.
*/
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
*/
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.
*/
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.
*/
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.
*/
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
*/
const TUid KUidDSPControl = {0x1028260A};
/**
Custom interface class to allow control of DSP behaviour.
*/
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
*/
const TUid KUidUnderflowAutoStopControl = {0x1028260B};
/**
Custom interface class to control underflow behaviour.
*/
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
*/
const TUid KUidSetDRMProtected = {0x1028260C};
/**
This class provides an interface to mark data being played as DRM protected.
*/
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.
*/
const TUid KUidBufferFramesConfig = {0x1028260D};
/**
This class provides an interface to configure and retrive the buffer frames.
*/
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
*/
const TUid KUidGetTimestamps = {0x1028260E};
/**
This class provides an interface to configure and retrive time stamps.
*/
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
*/
const TUid KUidAdvancedAACEncoderSettings = {0x102825FE};
/**
Advanced AAC Encode Bit-rate Configuration
*/
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