--- a/epoc32/include/mdaaudiosampleeditor.h Tue Nov 24 13:55:44 2009 +0000
+++ b/epoc32/include/mdaaudiosampleeditor.h Tue Mar 16 16:12:26 2010 +0000
@@ -1,1 +1,744 @@
-mdaaudiosampleeditor.h
+// Copyright (c) 2002-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 MDAAUDIOSAMPLEEDITOR_H
+#define MDAAUDIOSAMPLEEDITOR_H
+
+
+
+#include <e32std.h>
+#include <f32file.h>
+#include <mmf/common/mmfbase.h>
+#include <mmf/common/mmfaudio.h>
+#include <mmf/common/mmfstandardcustomcommands.h>
+#include <mmf/common/mmfdrmcustomcommands.h>
+
+#include <mda/client/resource.h>
+#include <mda/client/utility.h>
+#include <mda/common/audio.h>
+#include <mmfclntutility.h>
+#include <mmf/common/mmfdurationinfocustomcommands.h>
+
+class CMdaServer;
+
+/**
+ * @publishedAll
+ * @deprecated
+ *
+ * Dummy class - not supported in 7.0s
+ */
+class CMdaAudioType : public CBase
+ {
+public:
+ /**
+ Destructor
+ */
+ IMPORT_C ~CMdaAudioType();
+ };
+
+/**
+@publishedAll
+@released
+
+This class is used by both the audio recorder and audio converter. This class should not be used,
+other than the TState enum.
+
+Prior to 7.0s the pure virtual functions in this class were implemented virtual functions. In 7.0s
+this changed, so now any classes derived from this one must implement the functions themselves.
+
+@see CMdaAudioRecorderUtility
+@see CMdaAudioConvertUtility
+*/
+class CMdaAudioClipUtility : public CBase,
+ public MMMFClientUtility
+ {
+public:
+ /**
+ Defines the possible state of the audio data sample.
+ */
+ enum TState
+ {
+ /** The audio clip recorder or audio converter has been constructed but no file or descriptor
+ has been opened.
+ */
+ ENotReady = 0,
+ /** Files or descriptors are open but no playing or recording operation is in progress.
+ */
+ EOpen,
+ /** Audio sample data is playing.
+ */
+ EPlaying,
+ /** New audio sample data is being recorded.
+ */
+ ERecording
+ };
+
+public:
+ /**
+ @internalTechnology
+
+ Returns the current state of the audio sample data.
+
+ @return The state of the audio sample data.
+
+ @since 5.0
+ */
+ virtual TState State()=0;
+
+ /**
+ @internalTechnology
+
+ Releases any currently open audio sample data.
+
+ @since 5.0
+ */
+ virtual void Close()=0;
+
+ /**
+ @internalTechnology
+
+ Begins playback of audio sample data at the current playback position using the current volume,
+ gain and priority settings.
+
+ @since 5.0
+ */
+ virtual void PlayL()=0;
+
+ /**
+ @internalTechnology
+
+ Starts appending new audio sample data.
+
+ The new audio sample data is appended to the existing audio sample data in the same format as
+ the existing audio sample data. If existing data is to be overwritten, then it should be cropped
+ to the appropriate length before appending the new data.
+
+ Note, before starting to record, make sure that the gain is set by calling
+ CMdaAudioRecorderUtility::SetGain(), as the initial gain is undefined. The gain might also
+ have been modified by another client application.
+
+
+ @since 5.0
+ @see CMdaAudioRecorderUtility
+ @see CMdaAudioRecorderUtility::SetGain()
+ */
+ virtual void RecordL()=0;
+
+ /**
+ @internalTechnology
+
+ Stops the playback or recording operation.
+
+ The operation is stopped at the current location. For a playback operation, the head is positioned at the last played data.
+
+ @since 5.0
+ */
+ virtual void Stop()=0;
+
+ /**
+ @internalTechnology
+
+ Deletes all audio sample data after the current head position. The effects of the function cannot be undone.
+
+ The function is synchronous and can leave if there is a problem. The leave code depends on the configuration.
+
+ @since 5.0
+ */
+ virtual void CropL()=0;
+
+ /**
+ @internalTechnology
+
+ Sets the head position.
+
+ The playback head is moved to a position which is defined in terms of a time interval measured
+ from the beginning of the audio sample data. A subsequent call to PlayL() starts from
+ this new position.
+
+
+ @since 5.0
+ */
+ virtual void SetPosition(const TTimeIntervalMicroSeconds& aPosition)=0;
+
+ /**
+ @internalTechnology
+
+ Returns the current head position.
+
+ The head position is defined in terms of a time interval measured from the beginning of the audio sample data.
+
+ @since 5.0
+ */
+ virtual const TTimeIntervalMicroSeconds& Position()=0;
+
+ /**
+ @internalTechnology
+
+ Returns the recording time available for the selected file or descriptor and encoding format.
+
+ @since 5.0
+ */
+ virtual const TTimeIntervalMicroSeconds& RecordTimeAvailable()=0;
+
+ /**
+ @internalTechnology
+
+ Returns the duration of the audio sample data.
+
+ @since 5.0
+ */
+ virtual const TTimeIntervalMicroSeconds& Duration()=0;
+
+ /**
+ @internalTechnology
+
+ Defines a window on the audio sample data.
+
+ The window is defined in terms of a start and end position.
+ When the current playback position reaches the window end position, or Stop() is called, the
+ current playback position is set to the window start position and playback stops.
+
+ The current playback position is not affected by a call to SetPlayWindow() unless it is outside
+ the new playback window, in which case it is set to the window start or end position depending
+ on which one is closer.
+
+ The window persists until ClearPlayWindow() is called.
+ Loading new audio sample data without adjusting or clearing the window will result in
+ playback errors if the window is outside the new data.
+
+ @param aStart
+ The position defining the start of the window, measured in microseconds. If this
+ value is less than zero, it is set to zero. If this value is greater than aEnd,
+ then it is swapped with aEnd.
+ @param aEnd
+ The position defining the end of the window, measured in microseconds. If this value
+ is greater than the value returned by Duration(), it is set to the value of Duration().
+ If this value is less than aStart, then it is swapped with aStart.
+
+ @since 5.0
+ */
+ virtual void SetPlayWindow(const TTimeIntervalMicroSeconds& aStart, const TTimeIntervalMicroSeconds& aEnd)=0;
+
+ /**
+ @internalTechnology
+
+ Removes any window defined on the audio sample data.
+
+ All subsequent playing, position setting and position querying requests are mapped to the whole of the audio sample data.
+
+ @since 5.0
+ */
+ virtual void ClearPlayWindow()=0;
+
+ /**
+ @internalTechnology
+
+ Sets the number of times the audio sample is to be repeated during the PlayL() operation.
+
+ A period of silence can follow each playing of the audio sample. The audio sample can be repeated
+ indefinitely or until stopped.
+
+ @param aRepeatNumberOfTimes
+ The number of times the audio sample, together with the trailing silence, is to
+ be repeated. If this is set to KMdaRepeatForever, then the audio sample, together with
+ the trailing silence, is repeated indefinitely. If this is set to zero, then the audio
+ sample is not repeated.
+ @param aTrailingSilence
+ The length of the trailing silence in microseconds.
+
+ @since 5.0
+ */
+ virtual void SetRepeats(TInt aRepeatNumberOfTimes, const TTimeIntervalMicroSeconds& aTrailingSilence)=0;
+
+ /**
+ @internalTechnology
+
+ This function is no longer supported. It is provided for binary compatibility with previous
+ releases and always leaves with KErrNotSupported.
+
+ @return Always returns NULL.
+
+ @since 5.0
+ */
+ virtual CMdaAudioType* TypeL();
+
+ /**
+ @internalTechnology
+
+ Sets the maximum size for a file that is being recorded.
+
+ When this limit is reached, MMF stops recording and notifies the client application. Notification is caused
+ by MMdaObjectStateChangeObserver::MoscoStateChangeEvent() with the error code KErrEof.
+
+ This function is provided so that applications such as recorders can limit the amount of file storage/memory
+ that should be allocated.
+
+ @param aMaxWriteLength
+ The maximum file size in kilobytes. If the default value is used, there is no maximum file size.
+
+ @since 5.0
+ */
+ virtual void SetMaxWriteLength(TInt aMaxWriteLength = KMdaClipLocationMaxWriteLengthNone)=0;
+
+ /**
+ @internalTechnology
+
+ Deletes all audio sample data from the beginning of the audio clip. The effects of the function cannot be undone.
+
+ The function is synchronous and can leave if there is a problem. The leave code depends on the configuration.
+
+ @since 5.0
+ */
+ virtual void CropFromBeginningL()=0;
+public:
+ // Reserved functions - do not call - to allow virtual additional functions to be added to class
+
+ /**
+ @internalTechnology
+
+ Reserved function
+ */
+ virtual void ClipUtil_Reserved3();
+
+ /**
+ @internalTechnology
+
+ Reserved function
+ */
+ virtual void ClipUtil_Reserved4();
+ };
+
+
+class CMMFMdaAudioRecorderUtility;
+
+/**
+@publishedAll
+@released
+
+Plays back, records and edits audio sample data.
+
+The class offers an interface to play, record and edit audio sample data. This data can be supplied
+either in a file or as a descriptor. The functions that start and stop playback and recording are
+defined in the base class CMdaAudioClipUtility.
+
+While this class is abstract, the static NewL() function constructs, initialises and returns a
+pointer to an instance of a concrete class derived from this abstract class. This concrete class
+is part of the MMF implementation and is private.
+
+*/
+class CMdaAudioRecorderUtility : public CMdaAudioClipUtility
+ {
+public:
+
+ /**
+ Device mode. Used by SetAudioDeviceMode method which is not used from 7.0s
+ @since 5.0
+ */
+ enum TDeviceMode
+ {
+ /**
+ The default behaviour.
+
+ When recording:
+ If a telephony call is in progress, an attempt is made to connect to the telephony downlink
+ plus the device microphone. If there is no telephony call in progress or a connection to the
+ telephony downlink fails, an attempt is made to connect to the device microphone only.
+
+ When playing:
+ If a telephony call is in progress, an attempt is made to connect to the telephony uplink.
+ If there is no telephony call in progress or a connection to the telephony uplink fails, an
+ attempt is made to connect to the device speaker.
+ */
+ EDefault = 0,
+ /** See EDefault.
+ */
+ ETelephonyOrLocal = EDefault,
+ /**
+ When recording:
+ If a telephony call is in progress the audio source is the telephony downlink mixed with
+ the device microphone. If there is no telephony call in progress or a connection to the telephony
+ downlink fails, no attempt is made to connect to the microphone.
+
+ When playing:
+ If a telephony call is in progress the audio sample data is played to the telephony uplink and
+ the device speaker. If there is no telephony call in progress or a connection to the telephony
+ uplink fails, no attempt is made to connect to the device speaker.
+ */
+ ETelephonyMixed = 1,
+ /**
+ When recording, the audio source is the telephony downlink and is not mixed with the device microphone.
+
+ When playing, the audio sample data is played to the telephony uplink and is not mixed with the
+ device speaker.
+ */
+ ETelephonyNonMixed = 2,
+ /**
+ When recording, the audio source is the device microphone.
+
+ When playing, the audio sample data is played to the device speaker.
+ */
+ ELocal = 3
+ };
+
+ virtual ~CMdaAudioRecorderUtility();
+
+ IMPORT_C static CMdaAudioRecorderUtility* NewL(
+ MMdaObjectStateChangeObserver& aObserver,
+ CMdaServer* aServer = NULL,
+ TInt aPriority = EMdaPriorityNormal,
+ TMdaPriorityPreference aPref = EMdaPriorityPreferenceTimeAndQuality);
+
+ virtual void OpenFileL(const TDesC& aFileName);
+ IMPORT_C void OpenFileL(const RFile& aFile);
+
+ IMPORT_C void OpenFileL(const TMMSource& aSource);
+
+ virtual void OpenDesL(const TDesC8& aDescriptor);
+
+ IMPORT_C void OpenDesL(TDes8& aDescriptor);
+
+ virtual void OpenL(TMdaClipLocation* aLocation,
+ TMdaClipFormat* aFormat,
+ TMdaPackage* aArg1 = NULL,
+ TMdaPackage* aArg2 = NULL);
+
+ virtual void SetAudioDeviceMode(TDeviceMode aMode);
+
+ virtual TInt MaxVolume();
+
+ virtual TInt MaxGain();
+
+ virtual TInt SetVolume(TInt aVolume);
+
+ virtual void SetGain(TInt aGain);
+
+ virtual void SetVolumeRamp(const TTimeIntervalMicroSeconds& aRampDuration);
+
+ IMPORT_C void OpenFileL(const TDesC& aFileName,
+ TUid aRecordControllerUid, // controller to use
+ TUid aPlaybackControllerUid=KNullUid, // playback controller (if different)
+ TUid aDestinationFormatUid=KNullUid, // Data format
+ TFourCC aDestinationDataType = KFourCCNULL); // data type for recording
+
+ IMPORT_C void OpenFileL(const RFile& aFile,
+ TUid aRecordControllerUid, // controller to use
+ TUid aPlaybackControllerUid=KNullUid, // playback controller (if different)
+ TUid aDestinationFormatUid=KNullUid, // Data format
+ TFourCC aDestinationDataType = KFourCCNULL); // data type for recording
+
+ IMPORT_C void OpenFileL(const TMMSource& aSource,
+ TUid aRecordControllerUid, // controller to use
+ TUid aPlaybackControllerUid=KNullUid, // playback controller (if different)
+ TUid aDestinationFormatUid=KNullUid, // Data format
+ TFourCC aDestinationDataType = KFourCCNULL); // data type for recording
+
+ IMPORT_C void OpenDesL(TDes8& aDescriptor,
+ TUid aRecordControllerUid, // controller to use
+ TUid aPlaybackControllerUid=KNullUid, // playback controller (if different)
+ TUid aDestinationFormatUid=KNullUid, // Data format
+ TFourCC aDestinationDataType = KFourCCNULL); // data type for recording
+
+ IMPORT_C void OpenUrlL(const TDesC& aUrl,
+ TInt aIapId, // internet access point
+ TUid aRecordControllerUid, // controller to use
+ TUid aPlaybackControllerUid=KNullUid, // playback controller (if different)
+ TUid aDestinationFormatUid=KNullUid, // Data format
+ TFourCC aDestinationDataType = KFourCCNULL); // data type for recording
+
+ IMPORT_C void OpenUrlL(const TDesC& aUrl,
+ TInt aIapId =KUseDefaultIap,
+ const TDesC8& aMimeType = KNullDesC8);
+
+ IMPORT_C TInt GetGain(TInt& aGain);
+
+ IMPORT_C TInt GetVolume(TInt& aVolume);
+
+ IMPORT_C TInt SetPlaybackBalance(TInt aBalance = KMMFBalanceCenter);
+
+ IMPORT_C TInt GetPlaybackBalance(TInt& aBalance);
+
+ IMPORT_C TInt SetRecordBalance(TInt aBalance = KMMFBalanceCenter);
+
+ IMPORT_C TInt GetRecordBalance(TInt& aBalance);
+
+ IMPORT_C TInt GetNumberOfMetaDataEntries(TInt& aNumEntries);
+
+ IMPORT_C CMMFMetaDataEntry* GetMetaDataEntryL(TInt aMetaDataIndex);
+
+ IMPORT_C void AddMetaDataEntryL(CMMFMetaDataEntry& aMetaDataEntry);
+
+ IMPORT_C TInt RemoveMetaDataEntry(TInt aMetaDataIndex);
+
+ IMPORT_C void ReplaceMetaDataEntryL(TInt aMetaDataIndex, CMMFMetaDataEntry& aMetaDataEntry);
+
+ IMPORT_C void SetPriority(TInt aPriority, TMdaPriorityPreference aPref);
+
+ //DataType support
+
+ IMPORT_C void GetSupportedDestinationDataTypesL(RArray<TFourCC>& aSupportedDataTypes);
+
+ IMPORT_C void SetDestinationDataTypeL(TFourCC aDataType);
+
+ IMPORT_C TFourCC DestinationDataTypeL();
+
+ // Bit rate support
+
+ IMPORT_C void SetDestinationBitRateL(TUint aBitRate);
+
+ IMPORT_C TUint DestinationBitRateL();
+
+ IMPORT_C TUint SourceBitRateL();
+
+ IMPORT_C void GetSupportedBitRatesL(RArray<TUint>& aSupportedBitRates);
+
+ // Sample rate support
+
+ IMPORT_C void SetDestinationSampleRateL(TUint aSampleRate);
+
+ IMPORT_C TUint DestinationSampleRateL();
+
+ IMPORT_C void GetSupportedSampleRatesL(RArray<TUint>& aSupportedSampleRates);
+ // Format support
+
+ IMPORT_C void SetDestinationFormatL(TUid aFormatUid);
+
+ IMPORT_C TUid DestinationFormatL();
+
+ // Number of channels
+ IMPORT_C void SetDestinationNumberOfChannelsL(TUint aNumberOfChannels);
+
+ IMPORT_C TUint DestinationNumberOfChannelsL();
+
+ IMPORT_C void GetSupportedNumberOfChannelsL(RArray<TUint>& aSupportedNumChannels);
+
+ virtual TState State();
+
+ virtual void Close();
+
+ virtual void PlayL();
+
+ virtual void RecordL();
+
+ virtual void Stop();
+
+ virtual void CropL();
+
+ virtual void SetPosition(const TTimeIntervalMicroSeconds& aPosition);
+
+ virtual const TTimeIntervalMicroSeconds& Position();
+
+ virtual const TTimeIntervalMicroSeconds& RecordTimeAvailable();
+
+ virtual const TTimeIntervalMicroSeconds& Duration();
+
+ IMPORT_C TMMFDurationInfo Duration(TTimeIntervalMicroSeconds& aDuration);
+
+ virtual void SetPlayWindow(const TTimeIntervalMicroSeconds& aStart, const TTimeIntervalMicroSeconds& aEnd);
+
+ virtual void ClearPlayWindow();
+
+ virtual void SetRepeats(TInt aRepeatNumberOfTimes, const TTimeIntervalMicroSeconds& aTrailingSilence);
+
+ virtual void SetMaxWriteLength(TInt aMaxWriteLength = KMdaClipLocationMaxWriteLengthNone);
+
+ virtual void CropFromBeginningL();
+
+ IMPORT_C void RegisterForAudioLoadingNotification(MAudioLoadingObserver& aCallback);
+
+ IMPORT_C void GetAudioLoadingProgressL(TInt& aPercentageComplete);
+
+ IMPORT_C const CMMFControllerImplementationInformation& AudioPlayControllerImplementationInformationL();
+
+ IMPORT_C const CMMFControllerImplementationInformation& AudioRecorderControllerImplementationInformationL();
+
+ IMPORT_C TInt RecordControllerCustomCommandSync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TDes8& aDataFrom);
+
+ IMPORT_C TInt RecordControllerCustomCommandSync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2);
+
+ IMPORT_C void RecordControllerCustomCommandAsync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TDes8& aDataFrom, TRequestStatus& aStatus);
+
+ IMPORT_C void RecordControllerCustomCommandAsync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TRequestStatus& aStatus);
+
+ IMPORT_C TInt PlayControllerCustomCommandSync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TDes8& aDataFrom);
+
+ IMPORT_C TInt PlayControllerCustomCommandSync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2);
+
+ IMPORT_C void PlayControllerCustomCommandAsync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TDes8& aDataFrom, TRequestStatus& aStatus);
+
+ IMPORT_C void PlayControllerCustomCommandAsync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TRequestStatus& aStatus);
+
+ IMPORT_C MMMFDRMCustomCommand* GetDRMCustomCommand();
+
+ IMPORT_C TInt RegisterAudioResourceNotification(MMMFAudioResourceNotificationCallback& aCallback,TUid aNotificationEventUid,const TDesC8& aNotificationRegistrationData = KNullDesC8);
+
+ IMPORT_C TInt CancelRegisterAudioResourceNotification(TUid aNotificationEventId);
+
+ IMPORT_C TInt WillResumePlay();
+
+ IMPORT_C TInt SetThreadPriorityPlayback(const TThreadPriority& aThreadPriority) const;
+ IMPORT_C TInt SetThreadPriorityRecord(const TThreadPriority& aThreadPriority) const;
+
+ IMPORT_C void UseSharedHeap();
+private:
+ CMMFMdaAudioRecorderUtility* iProperties;
+ };
+
+class CMMFMdaAudioConvertUtility;
+
+/**
+@publishedAll
+@released
+
+Converts the type, sample rate and format of audio data.
+
+The audio sample data can be supplied either in a file or as a descriptor.
+*/
+class CMdaAudioConvertUtility : public CMdaAudioClipUtility
+ {
+public:
+
+ IMPORT_C static CMdaAudioConvertUtility* NewL(
+ MMdaObjectStateChangeObserver& aObserver,
+ CMdaServer* aServer = NULL,
+ TInt aPriority = EMdaPriorityNormal,
+ TMdaPriorityPreference aPref = EMdaPriorityPreferenceTimeAndQuality);
+
+ virtual ~CMdaAudioConvertUtility();
+
+ virtual void OpenL(const TDesC& aPrimaryFile, const TDesC& aSecondaryFile);
+
+ virtual void OpenL(const TDesC& aPrimaryFile,
+ TMdaClipLocation* aLocation, // Normally file or descriptor
+ TMdaClipFormat* aFormat, // Data format
+ TMdaPackage* aArg1 = NULL, // Normally codec to use
+ TMdaPackage* aArg2 = NULL); // Normally audio settings
+
+ virtual void OpenL(TMdaClipLocation* aPriLocation,
+ TMdaClipLocation* aSecLocation,
+ TMdaClipFormat* aPriFormat,
+ TMdaClipFormat* aSecFormat,
+ TMdaPackage* aPriArg1 = NULL,
+ TMdaPackage* aPriArg2 = NULL,
+ TMdaPackage* aSecArg1 = NULL,
+ TMdaPackage* aSecArg2 = NULL);
+
+ // new controller based open
+ // N.B. this override is new and must NOT be made virtual. This is because
+ // it will break BC on the WINS build (due to the MS compiler grouping and
+ // reordering the overrides together in the vtable and _not_ using the
+ // declaration order!)
+
+ IMPORT_C void OpenL(TMdaClipLocation* aPriLocation,
+ TMdaClipLocation* aSecLocation,
+ TUid aControllerUid,
+ TUid aDestFormatUid,
+ TFourCC aDestDataType);
+
+ //Data type support
+
+ IMPORT_C void GetSupportedDestinationDataTypesL(RArray<TFourCC>& aSupportedDestinationDataTypes);
+
+ IMPORT_C void SetDestinationDataTypeL(TFourCC aDataType);
+
+ IMPORT_C TFourCC DestinationDataTypeL();
+
+ IMPORT_C TFourCC SourceDataTypeL();
+ // Bit rate support
+
+ IMPORT_C void SetDestinationBitRateL(TUint aBitRate);
+
+ IMPORT_C TUint DestinationBitRateL();
+
+ IMPORT_C void GetSupportedConversionBitRatesL(RArray<TUint>& aSupportedBitRates);
+
+ IMPORT_C TInt SourceBitRateL();
+
+ // Sample rate support
+ IMPORT_C void SetDestinationSampleRateL(TUint aSampleRate);
+
+ IMPORT_C TUint DestinationSampleRateL();
+
+ IMPORT_C void GetSupportedConversionSampleRatesL(RArray<TUint>& aSupportedSampleRates);
+
+ IMPORT_C TUint SourceSampleRateL();
+
+ // Format support
+ IMPORT_C void SetDestinationFormatL(TUid aFormatUid);
+
+ IMPORT_C TUid DestinationFormatL();
+
+ IMPORT_C TUid SourceFormatL();
+
+ // Number of channels
+ IMPORT_C void SetDestinationNumberOfChannelsL(TUint aNumberOfChannels);
+
+ IMPORT_C TUint DestinationNumberOfChannelsL();
+
+ IMPORT_C void GetSupportedConversionNumberOfChannelsL(RArray<TUint>& aSupportedNumChannels);
+
+ IMPORT_C TUint SourceNumberOfChannelsL();
+
+ // New function ConvertL (PlayL and RecordL now deprecated for CMdaAudioConvertUtility)
+ IMPORT_C void ConvertL();
+
+ virtual TState State();
+
+ virtual void Close();
+
+ virtual void PlayL();
+
+ virtual void RecordL();
+
+ virtual void Stop();
+
+ virtual void CropL();
+
+ virtual void SetPosition(const TTimeIntervalMicroSeconds& aPosition);
+
+ virtual const TTimeIntervalMicroSeconds& Position();
+
+ virtual const TTimeIntervalMicroSeconds& RecordTimeAvailable();
+
+ virtual const TTimeIntervalMicroSeconds& Duration();
+
+ virtual void SetPlayWindow(const TTimeIntervalMicroSeconds& aStart, const TTimeIntervalMicroSeconds& aEnd);
+
+ virtual void ClearPlayWindow();
+
+ virtual void SetRepeats(TInt aRepeatNumberOfTimes, const TTimeIntervalMicroSeconds& aTrailingSilence);
+
+ virtual void SetMaxWriteLength(TInt aMaxWriteLength = KMdaClipLocationMaxWriteLengthNone);
+
+ virtual void CropFromBeginningL();
+
+ IMPORT_C const CMMFControllerImplementationInformation& ControllerImplementationInformationL();
+
+ IMPORT_C TInt CustomCommandSync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TDes8& aDataFrom);
+
+ IMPORT_C TInt CustomCommandSync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2);
+
+ IMPORT_C void CustomCommandAsync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TDes8& aDataFrom, TRequestStatus& aStatus);
+
+ IMPORT_C void CustomCommandAsync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TRequestStatus& aStatus);
+
+ IMPORT_C TInt SetThreadPriority(const TThreadPriority& aThreadPriority) const;
+
+ IMPORT_C void UseSharedHeap();
+private:
+ CMMFMdaAudioConvertUtility* iProperties;
+
+ };
+
+#endif