diff -r 000000000000 -r 40261b775718 mmlibs/mmfw/MIDI/src/midistandardcustomcommands.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mmlibs/mmfw/MIDI/src/midistandardcustomcommands.cpp	Tue Feb 02 01:56:55 2010 +0200
@@ -0,0 +1,1728 @@
+// 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:
+//
+
+#include <mmf/common/midistandardcustomcommands.h>
+#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
+#include <mmf/common/mmfmidiconfig.h>
+#include <mmf/common/midieventreceiver.h>
+#endif
+
+/**
+Constructor.
+@param aController	
+       The client side controller object to be used by this custom command interface.
+*/
+EXPORT_C RMidiControllerCustomCommands::RMidiControllerCustomCommands(RMMFController& aController) :
+	RMMFCustomCommandsBase(aController, KUidInterfaceMidi)
+	{
+	}
+
+/**
+Change the position of the currently playing MIDI resource to the given position.
+May be called whenever a MIDI resource is open.
+
+@param aMicroBeats 
+       Metrical position to move to. Clamped to (0, DurationMicroBeats()).
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::SetPositionMicroBeats(TInt64 aMicroBeats) const
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	configPackage().iPositionMicroBeats = aMicroBeats;
+	return iController.CustomCommandSync(iDestinationPckg, 
+										 EMMFMidiControllerSetPositionMicroBeats, 
+										 configPackage,
+										 KNullDesC8);
+	}
+
+/**
+Gets the current metrical position of the MIDI resource being played.
+
+@param aMicroBeats 
+       (BPM*1000000) relative to the start of the resource.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::PositionMicroBeats(TInt64& aMicroBeats) const
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+											   EMMFMidiControllerPositionMicroBeats, 
+											   KNullDesC8,
+											   KNullDesC8,
+											   configPackage);
+	if (!error)
+		aMicroBeats = configPackage().iPositionMicroBeats;
+	return error;
+	}
+
+/**
+Synchronous function to play a single note.
+Multiple calls to this function will be accommodated as far as the MIDI engine can
+manage. The same functionality could be implemented using the SendMessage function.
+
+@param aChannel 
+       Logical channel to play note on. 0 <= aChannel <= 15.
+@param aNote 
+       Note to play. 0 <= aNote <= 127
+@param aDuration 
+       Length of time to play note for.
+@param aNoteOnVelocity 
+       Velocity with which to start the note. 0 <= aNoteOnVelocity <= 127.
+@param aNoteOffVelocity 
+       Velocity with which to stop the note. 0 <= aNoteOffVelocity <= 127.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::PlayNote(TInt aChannel,TInt aNote, const TTimeIntervalMicroSeconds& aDuration,TInt aNoteOnVelocity,TInt aNoteOffVelocity)
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	configPackage().iChannel = aChannel;
+	configPackage().iNote = aNote;
+	configPackage().iDurationMicroSeconds = aDuration;
+	configPackage().iNoteOnVelocity = aNoteOnVelocity;
+	configPackage().iNoteOffVelocity = aNoteOffVelocity;
+	return iController.CustomCommandSync(iDestinationPckg, 
+										 EMMFMidiControllerPlayNote, 
+										 configPackage,
+										 KNullDesC8);
+	}
+
+/**
+Synchronous function to play a single note at a specified time.
+Multiple calls to this function will be accommodated as far as the MIDI engine can
+manage. The same functionality could be implemented using the SendMessage function.
+
+@param aChannel 
+       Logical channel to play note on. 0 <= aChannel <= 15.
+@param aNote 
+       Note to play. 0 <= aNote <= 127
+@param aStartTime 
+       Specifies the time at which to start playing the note, relative 
+	   to the MIDI resource playing time or the time elapsed since Play()
+	   was called if no resource is present.
+@param aDuration 
+       Length of time to play note for.
+@param aNoteOnVelocity 
+       Velocity with which to start the note. 0 <= aNoteOnVelocity <= 127.
+@param aNoteOffVelocity 
+       Velocity with which to stop the note. 0 <= aNoteOffVelocity <= 127.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::PlayNote(TInt aChannel,TInt aNote,const TTimeIntervalMicroSeconds& aStartTime, const TTimeIntervalMicroSeconds& aDuration,TInt aNoteOnVelocity,TInt aNoteOffVelocity)
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	configPackage().iChannel = aChannel;
+	configPackage().iNote = aNote;
+	configPackage().iStartTime = aStartTime;
+	configPackage().iDurationMicroSeconds = aDuration;
+	configPackage().iNoteOnVelocity = aNoteOnVelocity;
+	configPackage().iNoteOffVelocity = aNoteOffVelocity;
+	return iController.CustomCommandSync(iDestinationPckg, 
+										 EMMFMidiControllerPlayNoteWithStartTime, 
+										 configPackage,
+										 KNullDesC8);
+	}
+
+/**
+Stops the playback of all notes on the given channel, by means of an All Notes Off MIDI message.
+
+@param aChannel 
+       Logical channel to stop notes on. 0 <= aChannel <= 15.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::StopNotes(TInt aChannel)
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	configPackage().iChannel = aChannel;
+	return iController.CustomCommandSync(iDestinationPckg, 
+										 EMMFMidiControllerStopNotes, 
+										 configPackage,
+										 KNullDesC8);
+	}
+
+/**
+Synchronous function to commence playback of a note. Multiple calls to this
+function will be accommodated as far as the MIDI engine can manage.
+
+@param aChannel 
+       Logical channel to play note on. 0 <= aChannel <= 15.
+@param aNote 
+       Note to play. 0 <= aNote <= 127.
+@param aVelocity 
+       Velocity with which to start the note. The legal integer range is
+	   0 <= aVelocity <= 127, but the value zero actually causes the message
+	   to be interpreted as a Note Off message instead of a Note On.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::NoteOn(TInt aChannel, TInt aNote, TInt aVelocity)
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	configPackage().iChannel = aChannel;
+	configPackage().iNote = aNote;
+	configPackage().iNoteOnVelocity = aVelocity;
+	return iController.CustomCommandSync(iDestinationPckg, 
+										 EMMFMidiControllerNoteOn, 
+										 configPackage,
+										 KNullDesC8);
+	}
+
+/**
+Synchronous function to terminate playback of a note. If no corresponding note
+is found then no error is raised.
+
+@param aChannel 
+       Logical channel on which the note is playing. 0 <= aChannel <= 15.
+@param aNote 
+       Note to terminate. 0 <= aNote <= 127.
+@param aVelocity 
+       Velocity with which to stop the note. 0 <= aVelocity <= 127. There is no 
+	   standard behaviour corresponding with note off velocity.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::NoteOff(TInt aChannel,TInt aNote,TInt aVelocity)
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	configPackage().iChannel = aChannel;
+	configPackage().iNote = aNote;
+	configPackage().iNoteOffVelocity = aVelocity;
+	return iController.CustomCommandSync(iDestinationPckg, 
+										 EMMFMidiControllerNoteOff, 
+										 configPackage,
+										 KNullDesC8);
+	}
+
+/**
+Gets the current playback rate factor of the currently open MIDI resource.
+The playback rate is independent from tempo, i.e., it can be used to give
+an overall speed factor for playback.
+
+@param aPlayBackRate 
+       Current playback rate in percent times 1000, i.e., 100000 means original
+	   playback speed, 200000 means double speed, and 50000 means half speed playback.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::PlaybackRate(TInt& aPlayBackRate) const
+	{
+	TPckgBuf<TMMFMidiConfig3> configPackage;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+											   EMMFMidiControllerPlaybackRate, 
+											   KNullDesC8,
+											   KNullDesC8,
+											   configPackage);
+	if (!error)
+		aPlayBackRate = configPackage().iPlayBackRate;
+	return error;
+	}
+
+/**
+Sets the playback rate for the playback of the current MIDI resource.
+The playback rate is independent from tempo, i.e., it can be used to give
+an overall speed factor for playback. May be called whether playback
+is in progress or not.
+
+@param aPlayBackRate 
+       Playback rate in percent times 1000, i.e., 100000 means original 
+	   playback speed, 200000 means double speed, and 50000 means half speed playback.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::SetPlaybackRate(TInt aPlayBackRate)
+	{
+	TPckgBuf<TMMFMidiConfig3> configPackage;
+	configPackage().iPlayBackRate = aPlayBackRate;
+	return iController.CustomCommandSync(iDestinationPckg, 
+										 EMMFMidiControllerSetPlaybackRate, 
+										 configPackage,
+										 KNullDesC8);
+	}
+
+/**
+Gets the maximum playback rate in milli-percentage from the MIDI engine.
+@see SetPlaybackRate() for milli-percentage details.
+
+@param aMaxRate
+       Playback rate supported by MIDI player.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::MaxPlaybackRate(TInt& aMaxRate) const
+	{
+	TPckgBuf<TMMFMidiConfig3> configPackage;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+												EMMFMidiControllerMaxPlaybackRate, 
+												KNullDesC8,
+												KNullDesC8,
+												configPackage);
+	if (!error)
+		aMaxRate = configPackage().iPlayBackMaxRate;
+	return error;
+	}
+
+/**
+Gets the minimum playback rate in milli-percentage from the MIDI engine.
+@see SetPlaybackRate() for milli-percentage details.
+
+@param aMinRate
+       Minimum playback rate supported by MIDI player.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::MinPlaybackRate(TInt& aMinRate) const
+	{
+	TPckgBuf<TMMFMidiConfig3> configPackage;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+												EMMFMidiControllerMinPlaybackRate, 
+												KNullDesC8,
+												KNullDesC8,
+												configPackage);
+	if (!error)
+		aMinRate = configPackage().iPlayBackMinRate;
+	return error;
+	}
+
+/**
+Gets the current tempo of the currently open MIDI resource. The tempo is independent
+from the playback rate, i.e., the resulting playback speed will be affected by both.
+
+@param  aMicroBeatsPerMinute
+        Tempo at the current position of the currently open resource in microbeats
+		per minute, i.e. BPM * 1000000. Filled in by the controller framework.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::TempoMicroBeatsPerMinute(TInt& aMicroBeatsPerMinute) const
+	{
+	TPckgBuf<TMMFMidiConfig1> configPackage;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+												EMMFMidiControllerTempo, 
+												KNullDesC8,
+												KNullDesC8,
+												configPackage);
+	if (!error)
+		aMicroBeatsPerMinute = configPackage().iTempo;
+	return error;
+	}
+
+/**
+Sets the tempo at which the current MIDI resource should be played. May be
+called whether playback is in progress or not. The tempo is independent 
+from the playback rate, i.e., the resulting playback speed will be affected by both.
+
+@param aMicroBeatsPerMinute 
+       Tempo in microbeats per minute (BPM*1000000) to set.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::SetTempo(TInt aMicroBeatsPerMinute)
+	{
+	TPckgBuf<TMMFMidiConfig1> configPackage;
+	configPackage().iTempo = aMicroBeatsPerMinute;
+	return iController.CustomCommandSync(iDestinationPckg, 
+										 EMMFMidiControllerSetTempo, 
+										 configPackage,
+										 KNullDesC8);
+	}
+
+/**
+Gets the pitch shift in use for the currently open MIDI resource.
+
+@param aPitch 
+       Shift in cents, i.e. semitones * 100. One octave equals 1200 cents.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::PitchTranspositionCents(TInt& aPitch) const
+	{
+	TPckgBuf<TMMFMidiConfig1> configPackage;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+												EMMFMidiControllerPitch, 
+												KNullDesC8,
+												KNullDesC8,
+												configPackage);
+	if (!error)
+		aPitch = configPackage().iPitch;
+	return error;
+	}
+
+/**
+Sets the pitch shift to apply to the currently open MIDI resource.
+May be called during playback.
+
+@param aCents 
+       Pitch shift in cents, i.e. semitones * 100. One octave equals 1200 cents.
+@param aCentsApplied 
+       Actual pitch shift applied - may differ from the requested value due to
+	   limitations of the MIDI engine.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::SetPitchTransposition(TInt aCents, TInt& aCentsApplied)
+	{
+	TPckgBuf<TMMFMidiConfig1> configPackage;
+	configPackage().iPitch = aCents;
+	TInt err = iController.CustomCommandSync(iDestinationPckg, 
+											EMMFMidiControllerSetPitch, 
+											configPackage,
+											KNullDesC8,
+											configPackage);
+	aCentsApplied = configPackage().iPitch;
+	return err;
+	}
+
+/**
+Gets the length of the currently open MIDI resource in micro-beats.
+
+@param aDuration 
+       Duration in microbeats (beats * 1000000).
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::DurationMicroBeats(TInt64& aDuration) const
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+												EMMFMidiControllerDurationMicroBeats, 
+												KNullDesC8,
+												KNullDesC8,
+												configPackage);
+	if (!error)
+		aDuration = configPackage().iDurationMicroBeats;
+	return error;
+	}
+
+/**
+Gets the number of tracks present in the currently open MIDI resource.
+
+@param aTracks 
+       Number of tracks.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::NumTracks(TInt& aTracks) const
+	{
+	TPckgBuf<TMMFMidiConfig1> configPackage;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+												EMMFMidiControllerNumTracks, 
+												KNullDesC8,
+												KNullDesC8,
+												configPackage);
+	if (!error)
+		aTracks = configPackage().iNumTracks;
+	return error;
+	}
+
+/**
+Mutes or unmutes a particular track.
+
+@param aTrack 
+       Index of the track to mute - 0 <= aTrack < NumTracksL().
+@param aMuted 
+       ETrue to mute the track, EFalse to unmute it.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::SetTrackMute(TInt aTrack, TBool aMuted) const
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	configPackage().iTrack = aTrack;
+	configPackage().iMuted = aMuted;
+	return iController.CustomCommandSync(iDestinationPckg, 
+										 EMMFMidiControllerSetTrackMute, 
+										 configPackage,
+										 KNullDesC8);
+	}
+
+/**
+Gets the MIME type of the MIDI resource currently open.
+
+@param aMimeType 
+       Descriptor containing the MIDI mime type.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::MimeType(TDes8& aMimeType) const
+	{
+	return iController.CustomCommandSync(iDestinationPckg, 
+										EMMFMidiControllerMimeType, 
+										KNullDesC8,										 
+										KNullDesC8,
+										aMimeType);
+	}
+
+/**
+Sets the frequency at which MMIDIClientUtilityObserver::MmcuoSyncUpdateL() is called
+to allow other components to synchronise with playback of this MIDI resource.
+
+@param aMicroSeconds 
+       Temporal interval to callback at. Used in preference to aMicroBeats if both are set.
+@param aMicroBeats 
+       Metrical interval to callback at. Set both parameters to zero to cancel.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::SetSyncUpdateCallbackInterval(const TTimeIntervalMicroSeconds& aMicroSeconds,TInt64 aMicroBeats)
+	{
+	TPckgBuf<TMMFMidiConfig3> configPackage;
+	configPackage().iCallbackIntervalMicroSeconds = aMicroSeconds;
+	configPackage().iCallbackIntervalMicroBeats = aMicroBeats;
+	return iController.CustomCommandSync(iDestinationPckg, 
+										 EMMFMidiControllerSetSyncUpdateCallbackInterval, 
+										 configPackage,
+										 KNullDesC8);
+	}
+
+/**
+Sends a single MIDI message to the MIDI engine.
+
+@param aMidiMessage 
+       Descriptor containing the MIDI message data. If there are several
+       MIDI messages in the buffer, only the first one is processed.
+@param aBytes
+       Number of bytes of the message buffer actually processed.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::SendMessage(const TDesC8& aMidiMessage, TInt& aBytes)
+	{
+	TPckgBuf<TMMFMidiConfig3> configPackage;
+	configPackage().iMidiMessage = &aMidiMessage;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+												EMMFMidiControllerSendMessage, 
+												configPackage,
+												KNullDesC8,
+												configPackage);
+	if (!error)
+		aBytes = configPackage().iBytesProcessed;
+	return error;
+	}
+
+/**
+Sends a single MIDI message, with time stamp, to the MIDI engine.
+
+@param aMidiMessage 
+       Descriptor containing the MIDI message data. If there are several
+	   MIDI messages in the buffer, only the first one is processed.
+@param aTime
+       The time at which to execute the message, relative to the MIDI resource playing
+       time or the time elapsed since Play() was called if no resource is present.
+@param aBytes
+       Number of bytes of the message buffer actually processed.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::SendMessage(const TDesC8& aMidiMessage,const TTimeIntervalMicroSeconds& aTime, TInt& aBytes)
+	{
+	TPckgBuf<TMMFMidiConfig3> configPackage;
+	configPackage().iMidiMessage = &aMidiMessage;
+	configPackage().iTimeStamp = aTime;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+												EMMFMidiControllerSendMessageWithTimeStamp, 
+												configPackage,
+												KNullDesC8,
+												configPackage);
+	if (!error)
+		aBytes = configPackage().iBytesProcessed;
+	return error;
+	}
+
+/**
+Sends a mip message to the MIDI engine. This is a convenience function,
+because the same functionality could be achieved with the SendMessage() function.
+
+@param aEntry 
+       Array of logical {channel, MIP} value pairs to send, highest priority first.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::SendMipMessage(const RArray<TMipMessageEntry>& aEntry)
+	{
+	TPckgBuf<TMMFMidiConfig1> configPackage;
+	TArray<TMipMessageEntry> mipMessage(aEntry.Array());
+	configPackage().iMipMessage = &mipMessage;
+	return iController.CustomCommandSync(iDestinationPckg, 
+										 EMMFMidiControllerSendMipMessage, 
+										 configPackage,
+										 KNullDesC8);
+	}
+
+/**
+Gets the number of standard or custom sound banks currently available.
+
+@param aCustom
+       Specifies whether to reference a custom or standard sound bank.
+@param aNumBanks 
+       Number of custom or standard sound banks available.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::NumberOfBanks(TBool aCustom, TInt& aNumBanks) const
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	configPackage().iCustom = aCustom;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+												EMMFMidiControllerNumberOfBanks, 
+												configPackage,
+												KNullDesC8,
+												configPackage);
+	if (!error)
+		aNumBanks = configPackage().iNumBanks;
+	return error;
+	}
+
+/**
+Gets the identifier of a sound bank. Bank identifier (aka bank number) is a
+14-bit value consisting of MIDI bank MSB and LSB values.
+
+@param  aCustom
+        Specifies whether to reference a custom or standard sound bank.
+@param  aBankIndex 
+        Index of sound bank where 0 <= aBankIndex < NumberOfBanks().
+@param  aBankId
+        Identifier of the specified bank occupying, at most, 14 bits.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::GetBankId(TBool aCustom, TInt aBankIndex, TInt& aBankId) const
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	configPackage().iCustom = aCustom;
+	configPackage().iBankIndex = aBankIndex;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+												EMMFMidiControllerGetBankId, 
+												configPackage,
+												KNullDesC8,
+												configPackage);
+	if (!error)
+		aBankId = configPackage().iBankId;
+	return error;
+	}
+
+
+/**
+Loads one or more custom sound banks from a file into memory for use.
+If several banks are loaded with consequent LoadCustomBanks() function calls,
+the banks are combined if the bank sets have conflicting bank numbers.
+
+@param aFileName 
+       Name of the file containing the custom sound bank.
+@param aBankCollectionIndex
+       Identifier of the custom sound bank loaded, occupying no more than 14 bits.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::LoadCustomBank(const TDesC& aFileName,TInt& aBankCollectionIndex)
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	configPackage().iFileName = &aFileName;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+												EMMFMidiControllerLoadCustomBank, 
+												configPackage,
+												KNullDesC8,
+												configPackage);
+	if (!error)
+		aBankCollectionIndex = configPackage().iBankId;
+	return error;
+	}
+
+
+/**
+Loads one or more custom sound banks from a descriptor into memory for use.
+If several banks are loaded with consequent LoadCustomBanks() function calls,
+the banks are combined if the bank sets have conflicting bank numbers.
+
+@param aBankData 
+       Descriptor containing the custom sound bank.
+@param aBankCollectionIndex
+       Identifier of the custom sound bank loaded, occupying no more than 14 bits.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::LoadCustomBankData(const TDesC8& aBankData,TInt& aBankCollectionIndex)
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	configPackage().iBankData = &aBankData;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+												EMMFMidiControllerLoadCustomBankData, 
+												configPackage,
+												KNullDesC8,
+												configPackage);
+	if (!error)
+		aBankCollectionIndex = configPackage().iBankId;
+	return error;
+	}
+
+
+/**
+Removes a custom sound bank from memory. Only valid for sound banks previously
+loaded from file. Once unloaded the custom sound bank is no longer available for use.
+
+@param aBankCollectionIndex 
+       Identifier of the custom sound bank to unload,occupying no more than 14 bits.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::UnloadCustomBank(TInt aBankCollectionIndex)
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	configPackage().iBankId= aBankCollectionIndex;
+	return iController.CustomCommandSync(iDestinationPckg, 
+										EMMFMidiControllerUnloadCustomBank, 
+										configPackage,
+										KNullDesC8);
+	}
+
+/**
+Query if a bank has been loaded to the memory.
+
+@param aBankCollectionIndex
+       Identifier of the custom sound bank to check if it's in memory or not.
+@param aBankLoaded 
+       ETrue if the specified bank is in memory, EFalse otherwise.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::CustomBankLoaded(TInt aBankCollectionIndex, TBool& aBankLoaded) const
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	configPackage().iBankId= aBankCollectionIndex;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+												EMMFMidiControllerCustomBankLoaded, 
+												configPackage,
+												KNullDesC8,
+												configPackage);
+	if (!error)
+		aBankLoaded = configPackage().iBankLoaded;
+	return error;
+	}
+
+
+/**
+Removes all custom sound banks from memory.
+
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::UnloadAllCustomBanks()
+	{
+	return iController.CustomCommandSync(iDestinationPckg, 
+										EMMFMidiControllerUnloadAllCustomBanks, 
+										KNullDesC8,
+										KNullDesC8);
+	}
+
+/**
+Gets the number of instruments available in a given sound bank.
+
+@param aBankId
+       Identifier of sound bank to reference, occupying no more than 14 bits.
+@param aCustom
+       Specifies whether to reference a custom or standard sound bank.
+@param aNumInstruments 
+       Count of the number of instruments available for the specified sound bank.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::NumberOfInstruments(TInt aBankId, TBool aCustom, TInt& aNumInstruments) const
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	configPackage().iBankId = aBankId;
+	configPackage().iCustom = aCustom;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+												EMMFMidiControllerNumberOfInstruments, 
+												configPackage,
+												KNullDesC8,
+												configPackage);
+	if (!error)
+		aNumInstruments = configPackage().iNumInstruments;
+	return error;
+	}
+
+
+/**
+Gets the identifier of an instrument.
+
+@param aBankId 
+       Identifier of the sound bank to reference, occupying no more than 14 bits.
+@param aCustom 
+       Specifies whether to reference a custom or standard sound bank.
+@param aInstrumentIndex 
+       Index of the instrument to reference where 0 <= aInstrumentIndex < NumberOfInstruments(). 
+@param aInstrumentId 
+       Identifier of specified instrument. This may differ from the index since the index
+	   simply enumerates the instruments, whereas identifiers may not be contiguous,
+	   especially where certain instruments correspond to General MIDI-defined instruments
+	   but not all instruments are present. Instrument identifiers are between 0 and 127 inclusive.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::GetInstrumentId(TInt aBankId, TBool aCustom, TInt aInstrumentIndex, TInt& aInstrumentId) const
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	configPackage().iBankId = aBankId;
+	configPackage().iCustom = aCustom;
+	configPackage().iInstrumentIndex = aInstrumentIndex;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+									 			EMMFMidiControllerGetInstrumentId, 
+												configPackage,
+												KNullDesC8,
+												configPackage);
+	if (!error)
+		aInstrumentId = configPackage().iInstrumentId;
+	return error;
+	}
+
+
+/**
+Gets the name of the given instrument.
+
+@param  aBankId 
+        Identifier of the bank that the instrument belongs to, occupying no more than 14 bits.
+@param  aCustom 
+        Specifies whether to reference a custom or standard sound bank.
+@param  aInstrumentId 
+        Identifier of the instrument under scrutiny. 0 <= aInstrumentId <= 127.
+@return Buffer containing the name of the specified instrument. If it has no name
+        then an empty descriptor is returned.
+*/
+EXPORT_C HBufC* RMidiControllerCustomCommands::InstrumentNameL(TInt aBankId, TBool aCustom, TInt aInstrumentId) const
+	{
+	// First, get the size of the instrument name so we can create a descriptor big enough to hold it
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	configPackage().iBankId = aBankId;
+	configPackage().iCustom = aCustom;
+	configPackage().iInstrumentId = aInstrumentId;
+	TPckgBuf<TInt> descriptorSizePckg;
+	User::LeaveIfError(iController.CustomCommandSync(iDestinationPckg,
+													 EMMFMidiControllerInstrumentName,
+													 configPackage,
+													 KNullDesC8,
+													 descriptorSizePckg));
+
+	// Now create a descriptor of appropriate size and get the server to copy the data into it
+	HBufC8* instrumentNameBuffer = HBufC8::NewLC(descriptorSizePckg());
+	TPtr8 instrumentNameBufferPtr = instrumentNameBuffer->Des();
+	User::LeaveIfError(iController.CustomCommandSync(iDestinationPckg,
+													 EMMFMidiControllerCopyInstrumentName,
+													 KNullDesC8,
+													 KNullDesC8,
+													 instrumentNameBufferPtr));
+
+	// Stream data out of the 8bit descriptor into a 16bit descriptor
+	RDesReadStream stream;
+	stream.Open(*instrumentNameBuffer);
+	CleanupClosePushL(stream);
+
+	HBufC* instrumentName = HBufC::NewL(stream, KMaxTInt);
+	
+	CleanupStack::PopAndDestroy();//stream
+	CleanupStack::PopAndDestroy(instrumentNameBuffer);
+
+	return instrumentName;
+	}
+
+
+/**
+Sets a logical channel to use the given instrument.
+
+@param aChannel 
+       Logical channel to set the instrument for. 0 <= aChannel <= 15.
+@param aBankId 
+       Identifier of the bank that the instrument belongs to, occupying no more than 14 bits.
+       The bank ID is a concatenation of MIDI bank MSB and LSB values.
+@param aInstrumentId 
+       Identifier of the instrument under scrutiny. 0 <= aInstrumentId <= 127.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::SetInstrument(TInt aChannel,TInt aBankId,TInt aInstrumentId)
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	configPackage().iChannel = aChannel;
+	configPackage().iBankId = aBankId;
+	configPackage().iInstrumentId = aInstrumentId;
+	return iController.CustomCommandSync(iDestinationPckg, 
+										EMMFMidiControllerSetInstrument,
+										configPackage,
+										KNullDesC8);
+	}
+
+/**
+Loads an individual instrument from file into custom sound bank memory for use.
+The bank and instrument id given in the file can be mapped into different bank
+and instrument id in memory.
+
+@param aFileName 
+       Name of the file containing the instrument.
+@param aFileBankId 
+       Identifier of the bank in the file from which to load the instrument,
+	   occupying no more than 14 bits.
+@param aFileInstrumentId 
+       Identifier of the instrument to load. 0 <= aInstrumentId <= 127.
+@param aMemoryBankId 
+       Identifier of the custom bank in memory to load the instrument into,
+       occupying no more than 14 bits.
+@param aMemoryInstrumentId 
+       Identifier of the instrument in memory to load the new instrument into.
+	   0 <= aInstrumentId <= 127.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::LoadCustomInstrument(const TDesC& aFileName, TInt aFileBankId, TInt aFileInstrumentId, TInt aMemoryBankId, TInt aMemoryInstrumentId)
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	configPackage().iFileName = &aFileName;
+	configPackage().iBankId = aFileBankId;
+	configPackage().iInstrumentId = aFileInstrumentId;
+	configPackage().iMemoryBankId = aMemoryBankId;
+	configPackage().iMemoryInstrumentId = aMemoryInstrumentId;
+	return iController.CustomCommandSync(iDestinationPckg, 
+										EMMFMidiControllerLoadCustomInstrument,
+										configPackage,
+										KNullDesC8);
+	}
+
+
+/**
+Loads an individual instrument from descriptor into custom sound bank memory for use.
+The bank and instrument id given in the descriptor can be mapped into different bank
+and instrument id in memory.
+
+@param aInstrumentData 
+       Descriptor containing the instrument.
+@param aBankDataId 
+       Identifier of the bank in the descriptor from which to load the instrument,
+       occupying no more than 14 bits.
+@param aInstrumentDataId 
+       Identifier of the instrument to load. 0 <= aInstrumentId <= 127.
+@param aMemoryBankId 
+       Identifier of the custom bank in memory to load the instrument into,
+       occupying no more than 14 bits.
+@param aMemoryInstrumentId 
+       Identifier of the instrument in memory to load the new instrument into.
+	   0 <= aInstrumentId <= 127.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::LoadCustomInstrumentData(const TDesC8& aInstrumentData, TInt aBankDataId, TInt aInstrumentDataId, TInt aMemoryBankId, TInt aMemoryInstrumentId)
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	configPackage().iInstrumentData = &aInstrumentData;
+	configPackage().iBankId = aBankDataId;
+	configPackage().iInstrumentId = aInstrumentDataId;
+	configPackage().iMemoryBankId = aMemoryBankId;
+	configPackage().iMemoryInstrumentId = aMemoryInstrumentId;
+	return iController.CustomCommandSync(iDestinationPckg, 
+										EMMFMidiControllerLoadCustomInstrumentData,
+										configPackage,
+										KNullDesC8);
+	}
+
+/**
+Removes an instrument from custom sound bank memory. Only valid for
+instruments previously loaded from file. Once unloaded the instrument
+is no longer available for use.
+
+@param aCustomBankId 
+       Identifier of the custom sound bank containing the instrument to unload,
+	   occupying no more than 14 bits.
+@param aInstrumentId
+       Identifier of the instrument to unload. 0 <= aInstrumentId <= 127.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::UnloadCustomInstrument(TInt aCustomBankId,TInt aInstrumentId)
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	configPackage().iBankId = aCustomBankId;
+	configPackage().iInstrumentId = aInstrumentId;
+	return iController.CustomCommandSync(iDestinationPckg, 
+										EMMFMidiControllerUnloadCustomInstrument,
+										configPackage,
+										KNullDesC8);
+	}
+
+/**
+Gets the name of a particular percussion key corresponding to a given note.
+
+@param aNote 
+       Note to query. 0 <= aNote <= 127.
+@param aBankId 
+       Identifier of the bank that the instrument belongs to, occupying no more than 14 bits.
+       The bank ID is a concatenation of MIDI bank MSB and LSB values.
+@param aCustom 
+       Specifies whether to reference a custom or standard sound bank.
+@param aInstrumentId
+       Identifier of an instrument.
+@return Descriptor containing the name of the percussion key. If the key
+        does not have a name then an empty descriptor is returned.
+*/
+EXPORT_C HBufC* RMidiControllerCustomCommands::PercussionKeyNameL(TInt aNote, TInt aBankId, TBool aCustom, TInt aInstrumentId) const
+	{
+	// First, get the size of the percussion key name so we can create a descriptor big enough to hold it
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	configPackage().iNote = aNote;
+	configPackage().iBankId = aBankId;
+	configPackage().iCustom = aCustom;
+	configPackage().iInstrumentId = aInstrumentId;
+	TPckgBuf<TInt> descriptorSizePckg;
+	User::LeaveIfError(iController.CustomCommandSync(iDestinationPckg,
+													 EMMFMidiControllerPercussionKeyName,
+													 configPackage,
+													 KNullDesC8,
+													 descriptorSizePckg));
+
+	// Now create a descriptor of appropriate size and get the server to copy the data into it
+	HBufC8* keyNameBuffer = HBufC8::NewLC(descriptorSizePckg());
+	TPtr8 keyNameBufferPtr = keyNameBuffer->Des();
+	User::LeaveIfError(iController.CustomCommandSync(iDestinationPckg,
+													 EMMFMidiControllerCopyPercussionKeyName,
+													 KNullDesC8,
+													 KNullDesC8,
+													 keyNameBufferPtr));
+
+	// Stream data out of the 8bit descriptor into a 16bit descriptor
+	RDesReadStream stream;
+	stream.Open(*keyNameBuffer);
+	CleanupClosePushL(stream);
+
+	HBufC* keyName = HBufC::NewL(stream, KMaxTInt);
+	
+	CleanupStack::PopAndDestroy();//stream
+	CleanupStack::PopAndDestroy(keyNameBuffer);
+	
+	return keyName;
+	}
+
+/**
+Get the stop time currently set for the MIDI resource.
+
+@param aStopTime
+       Time at which playback will stop, relative to the start of the resource.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::StopTime(TTimeIntervalMicroSeconds& aStopTime) const
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+												EMMFMidiControllerStopTime,
+												KNullDesC8,
+												KNullDesC8,
+												configPackage);
+	if (!error)
+		aStopTime = configPackage().iStopTime;
+	return error;
+	}
+
+
+/**
+Sets the stop time to use for the currently open MIDI resource
+
+@param aStopTime
+       Time at which playback will stop, relative to the start of the resource.
+       Clamped to 0 and the duration of the resource.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::SetStopTime(const TTimeIntervalMicroSeconds& aStopTime) const
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	configPackage().iStopTime = aStopTime;
+	return iController.CustomCommandSync(iDestinationPckg, 
+										EMMFMidiControllerSetStopTime,
+										configPackage,
+										KNullDesC8);
+	}
+
+/**
+Gets the polyphony of the MIDI engine.
+
+@param aNumNotes 
+       The number of currently active voices.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::Polyphony(TInt& aNumNotes) const
+	{
+	TPckgBuf<TMMFMidiConfig1> configPackage;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+											EMMFMidiControllerPolyphony,
+											KNullDesC8,
+											KNullDesC8,
+											configPackage);
+	if (!error)
+		aNumNotes = configPackage().iNumNotes;
+	return error;
+	}
+
+
+/**
+Gets the current maximum number of notes the engine can handle
+This can be greater than the value returned by RMidiControllerCustomCommands::Polyphony
+
+@param aNumNotes 
+       The maximum number of notes the engine can handle
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::MaxPolyphony(TInt& aMaxNotes) const
+	{
+	TPckgBuf<TMMFMidiConfig1> configPackage;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+											EMMFMidiControllerMaxPolyphony,
+											KNullDesC8,
+											KNullDesC8,
+											configPackage);
+	if (!error)
+		aMaxNotes = configPackage().iMaxNotes;
+	return error;
+	}
+
+/**
+Get the maximum number of logical channels supported by the MIDI engine.
+
+@param aChannels
+       The maximum number of logical channels that the MIDI engine supports,
+	   0 <= aChannels <=15.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::ChannelsSupported(TInt& aChannels) const
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+											EMMFMidiControllerChannelsSupported,
+											KNullDesC8,
+											KNullDesC8,
+											configPackage);
+	if (!error)
+		aChannels = configPackage().iChannel;
+	return error;
+	}
+
+
+/**
+Get the current volume setting of a logical channel.
+
+@param aChannel 
+       Logical channel to query. 0 <= aChannel <= 15.
+@param aChannelVol 
+       Volume currently set on the specified channel in decibels.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::ChannelVolume(TInt aChannel, TReal32& aChannelVol) const
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	configPackage().iChannel = aChannel;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+												EMMFMidiControllerChannelVolume,
+												configPackage,
+												KNullDesC8,
+												configPackage);
+	if (!error)
+		aChannelVol = configPackage().iChannelVol;
+	return error;
+	}
+
+/**
+Gets the Maximum volume setting that may be applied to a logical channel.
+
+@param aMaxVol 
+       Maximum volume setting. Minimum value is -infinity dB, which is the 
+       smallest possible value that TReal32 supports.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::MaxChannelVolume(TReal32& aMaxVol) const
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+												EMMFMidiControllerMaxChannelVolume,
+												KNullDesC8,
+												KNullDesC8,
+												configPackage);
+	if (!error)
+		aMaxVol = configPackage().iMaxChannelVol;
+	return error;
+	}
+
+/**
+Set the volume of a channel.
+
+@param aChannel 
+       Logical channel to set the volume on. 0 <= aChannel <= 15.
+@param aVolume 
+       The channel volume can be set within a range. The minimum 
+       channel volume is -infinity dB, which is the smallest possible
+       value that TReal32 supports while the maximum channel volume
+       is set via MaxVolumeL() which represents the volume level in dB
+       corresponding to the MIDI Channel Volume controller.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::SetChannelVolume(TInt aChannel,TReal32 aVolume)
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	configPackage().iChannel = aChannel;
+	configPackage().iChannelVol = aVolume;
+	return iController.CustomCommandSync(iDestinationPckg, 
+										EMMFMidiControllerSetChannelVolume,
+										configPackage,
+										KNullDesC8);
+	}
+
+/**
+Set the muting state of a channel without changing its volume setting.
+When unmuted the channel goes back to its previous volume setting.
+
+@param aChannel 
+       Logical channel to set the mute state of. 0 <= aChannel <= 15.
+@param aMuted 
+       ETrue to mute the channel, EFalse to unmute it.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::SetChannelMute(TInt aChannel,TBool aMuted)
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	configPackage().iChannel = aChannel;
+	configPackage().iMuted = aMuted;
+	return iController.CustomCommandSync(iDestinationPckg, 
+										EMMFMidiControllerSetChannelMute,
+										configPackage,
+										KNullDesC8);
+	}
+
+
+/**
+Gets the overall volume of the MIDI client.
+
+@param aVolume 
+       The current overall volume setting.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::Volume(TInt& aVolume) const
+	{
+	TPckgBuf<TMMFMidiConfig1> configPackage;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+												EMMFMidiControllerVolume,
+												KNullDesC8,
+												KNullDesC8,
+												configPackage);
+	if (!error)
+		aVolume = configPackage().iVolume;
+	return error;
+	}
+
+
+/**
+Maximum volume setting that may be applied overall.
+
+@param aMaxVolume 
+       Maximum volume setting. Minimum value is always zero which is silent.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::MaxVolume(TInt& aMaxVolume) const
+	{
+	TPckgBuf<TMMFMidiConfig1> configPackage;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+										EMMFMidiControllerMaxVolume,
+										KNullDesC8,
+										KNullDesC8,
+										configPackage);
+	if (!error)
+		aMaxVolume = configPackage().iMaxVolume;
+	return error;
+	}
+
+
+/**
+Set the overall volume of the MIDI client.
+This setting scales all channel volumes respectively so the actual volume
+that a channel is played at is (overall volume * channel volume / max volume).
+
+@param aVolume
+       Overall volume setting to use.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::SetVolume(TInt aVolume)
+	{
+	TPckgBuf<TMMFMidiConfig1> configPackage;
+	configPackage().iVolume = aVolume;
+	return iController.CustomCommandSync(iDestinationPckg, 
+										EMMFMidiControllerSetVolume,
+										configPackage,
+										KNullDesC8);
+	}
+
+/**
+Length of time over which the volume is faded up from zero to the current setting
+when playback is started.
+
+@param aRampDuration 
+       Duration of the ramping period.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::SetVolumeRamp(const TTimeIntervalMicroSeconds& aRampDuration)
+	{
+	TPckgBuf<TMMFMidiConfig1> configPackage;
+	configPackage().iRampDuration = aRampDuration;
+	return iController.CustomCommandSync(iDestinationPckg, 
+										EMMFMidiControllerSetVolumeRamp,
+										configPackage,
+										KNullDesC8);
+	}
+
+/**
+Get the current stereo balance value.
+
+@param aBalance 
+       Balance value ranging from KMMFBalanceMaxLeft to KMMFBalanceMaxRight.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::GetBalance(TInt& aBalance) const
+	{
+	TPckgBuf<TMMFMidiConfig1> configPackage;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+												EMMFMidiControllerGetBalance,
+												KNullDesC8,
+												KNullDesC8,
+												configPackage);
+	if (!error)
+		aBalance = configPackage().iBalance;
+	return error;
+	}
+
+/**
+Set the current stereo balance value.
+
+@param aBalance 
+       Balance value to set. Defaults to KMMFBalanceCenter to restore equal left-right balance.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::SetBalance(TInt aBalance)
+	{
+	TPckgBuf<TMMFMidiConfig1> configPackage;
+	configPackage().iBalance = aBalance;
+	return iController.CustomCommandSync(iDestinationPckg, 
+										EMMFMidiControllerSetBalance,
+										configPackage,
+										KNullDesC8);
+	}
+
+/**
+Set the max polyphony the engine can handle.
+
+@param aMaxNotes 
+       Max polyphony level,  1 <= Polyphony() <= aMaxNotes.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::SetMaxPolyphony(TInt aMaxNotes)
+	{
+	TPckgBuf<TMMFMidiConfig1> configPackage;
+	configPackage().iMaxNotes = aMaxNotes;
+	return iController.CustomCommandSync(iDestinationPckg, 
+										EMMFMidiControllerSetMaxPolyphony,
+										configPackage,
+										KNullDesC8);
+	}
+
+/**
+Gets the number of times the current opened resources has to be repeated.
+
+@param aNumRepeats
+       The number of times the current opened resources has to be repeated.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::GetRepeats(TInt& aNumRepeats) const
+	{
+	TPckgBuf<TMMFMidiConfig1> configPackage;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+												EMMFMidiControllerGetRepeats,
+												KNullDesC8,
+												KNullDesC8,
+												configPackage);
+	if (!error)
+		aNumRepeats = configPackage().iNumRepeats;
+	return error;
+	}
+
+/**
+Set the number of times to repeat the current MIDI resource.
+After Stop() has been called, repeat number of times and the
+trailing silence are reset.
+
+@param aRepeatNumberOfTimes 
+       Number of times to repeat the resource during playback. This includes the first playing.
+@param aTrailingSilence 
+       Time in microseconds to pause between repeats.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::SetRepeats(TInt aRepeatNumberOfTimes, const TTimeIntervalMicroSeconds& aTrailingSilence)
+	{
+	
+	TPckgBuf<TMMFMidiConfig3> configPackage;
+	configPackage().iRepeatNumberOfTimes = aRepeatNumberOfTimes;
+	configPackage().iTrailingSilence = aTrailingSilence;
+	return iController.CustomCommandSync(iDestinationPckg, 
+										EMMFMidiControllerSetRepeats,
+										configPackage,
+										KNullDesC8);
+	}
+
+/**
+Tell the MIDI engine to use a custom bank or a standard bank.
+
+@param aCustom
+       If Etrue the custom bank in memory is used otherwise the standard bank
+       is used leaving the custom bank in memory.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::SetBank(TBool aCustom)
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	configPackage().iCustom = aCustom;
+	return iController.CustomCommandSync(iDestinationPckg, 
+										EMMFMidiControllerSetBank,
+										configPackage,
+										KNullDesC8);
+	}
+
+/**
+Gets the muting status of a specific track.
+
+@param aTrack 
+       The track to query.
+@param aTrackMute 
+       The mute status of the track.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::IsTrackMute(TInt aTrack, TBool& aTrackMute) const
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	configPackage().iTrack = aTrack;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+												EMMFMidiControllerIsTrackMute,
+												configPackage,
+												KNullDesC8,
+												configPackage);
+	if (!error)
+		aTrackMute = configPackage().iMuted;
+	return error;
+	}
+
+
+/**
+Gets the muting status of a specific channel.
+
+@param aChannel
+       The channel to query.
+@param aChannelMute
+       The mute status of the channel.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::IsChannelMute(TInt aChannel, TBool& aChannelMute) const
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	configPackage().iChannel = aChannel;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+												EMMFMidiControllerIsChannelMute,
+												configPackage,
+												KNullDesC8,
+												configPackage);
+	if (!error)
+		aChannelMute = configPackage().iMuted;
+	return error;
+	}
+
+
+/**
+Gets the instrument assigned to a specified channel.
+
+@param aChannel 
+       Logical channel, 0 <= aChannel <= 15.
+@param aInstrumentId 
+       Identifier of the instrument assigned to aChannel. 0 <= aInstrumentId <= 127.
+@param aBankId 
+       Identifier of the bank that the instrument belongs to, occupying no more than 14 bits.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::GetInstrument(TInt aChannel, TInt& aInstrumentId, TInt& aBankId)
+	{
+	TPckgBuf<TMMFMidiConfig2> configPackage;
+	configPackage().iChannel = aChannel;
+	TInt error = iController.CustomCommandSync(iDestinationPckg, 
+												EMMFMidiControllerGetInstrument,
+												configPackage,
+												KNullDesC8,
+												configPackage);
+	if (!error)
+		{
+		aInstrumentId = configPackage().iInstrumentId;
+		aBankId = configPackage().iBankId;
+		}
+	return error;
+	}
+
+/**
+Closes any currently open resources, such as files, descriptors or URLs in use.
+Does nothing if there is nothing currently open.
+
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::Close()
+	{
+	return iController.CustomCommandSync(iDestinationPckg, 
+										EMMFMidiControllerClose,
+										KNullDesC8,
+										KNullDesC8);
+	}
+
+/**
+Stops playback of a resource but does not change the current position
+or release any resources. Pauses the internal timer if no resource is open.
+
+@param aFadeOutDuration 
+       Length of time over which the volume is faded out from the current setting to zero.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::Stop(const TTimeIntervalMicroSeconds& aFadeOutDuration)
+	{
+	TPckgBuf<TMMFMidiConfig1> configPackage;
+	configPackage().iFadeOutDuration = aFadeOutDuration;
+	return iController.CustomCommandSync(iDestinationPckg, 
+										EMMFMidiControllerStop,
+										configPackage,
+										KNullDesC8);
+	}
+
+
+/**
+Start receiving events from the controller. This can only be called once the controller is open.
+
+@param aSizeOfMidiEvent 
+       The size of the MIDI event object.
+@param aStatus 
+       Status flag belonging to an active object that will have it's RunL() called
+       when this request complete.
+*/
+EXPORT_C void RMidiControllerCustomCommands::ReceiveEvents(TPckgBuf<TInt>& aSizeOfMidiEvent, TRequestStatus& aStatus)
+	{
+	iController.CustomCommandAsync(iDestinationPckg, 
+									EMMFMidiControllerReceiveEvents,
+									KNullDesC8,
+									KNullDesC8,
+									aSizeOfMidiEvent,
+									aStatus);
+	}
+
+/**
+Get the MIDI event from the MIDI controller.
+
+@param aMidiEventPckg
+       MIDI event.
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::RetrieveEvent(TDes8& aMidiEventPckg)
+	{
+	return iController.CustomCommandSync(iDestinationPckg,
+										 EMMFMidiControllerRetrieveEvent,
+										 KNullDesC8,
+										 KNullDesC8,
+										 aMidiEventPckg);
+	}
+
+/**
+Stop receiving events from the MIDI controller.
+
+@return One of the system-wide error codes.
+*/
+EXPORT_C TInt RMidiControllerCustomCommands::CancelReceiveEvents()
+	{
+	return iController.CustomCommandSync(iDestinationPckg, 
+										EMMFMidiControllerCancelReceiveEvents,
+										KNullDesC8,
+										KNullDesC8);
+	}
+
+
+CMidiEventReceiver* CMidiEventReceiver::NewL(const TMMFMessage& aMessage)
+	{
+	return new(ELeave) CMidiEventReceiver(aMessage);
+	}
+
+CMidiEventReceiver::~CMidiEventReceiver()
+	{
+	if (!(iMessage.IsCompleted()))
+		iMessage.Complete(KErrDied);
+	delete iEventBuf;
+	}
+
+void CMidiEventReceiver::PrepareEventL(const CMMFMidiEvent& aEvent)
+	{
+	// eventbuf should be NULL.  delete it anyway though to prevent memory leaks in release mode
+	ASSERT(!iEventBuf);
+	
+	delete iEventBuf;
+	iEventBuf = NULL;
+
+	iEventBuf = CBufFlat::NewL(32);
+	RBufWriteStream s;
+	s.Open(*iEventBuf);
+	CleanupClosePushL(s);
+	aEvent.ExternalizeL(s);
+	CleanupStack::PopAndDestroy();//s
+	// Write the size of the externalised data back to the client
+	TPckgBuf<TInt> pckg;
+	pckg() = iEventBuf->Ptr(0).Length();
+	TInt error = iMessage.WriteDataToClient(pckg);
+	iMessage.Complete(error);
+	}
+
+void CMidiEventReceiver::SendEventL(TMMFMessage& aMessage)
+	{
+	if (!iEventBuf)
+		{
+		User::Leave(KErrNotReady);
+		}
+	else
+		{
+		aMessage.WriteDataToClientL(iEventBuf->Ptr(0));
+		}
+	}
+
+TBool CMidiEventReceiver::IsWaitingToSendEvent()
+	{
+	return (iEventBuf!=NULL);
+	}
+
+CMidiEventReceiver::CMidiEventReceiver(const TMMFMessage& aMessage) : iMessage(aMessage)
+	{
+	}
+
+
+/**
+Constructor.
+
+@param aEventType	
+       A UID to define the type of MIDI event.
+@param aErrorCode	
+       The error code associated with the MIDI event.
+*/
+EXPORT_C CMMFMidiEvent::CMMFMidiEvent(TUid aEventType, TInt aErrorCode)
+	: iEventType(aEventType), iErrorCode(aErrorCode)
+	{
+	ZeroMembers();
+	}
+
+/**
+Default constructor.
+*/
+EXPORT_C CMMFMidiEvent::CMMFMidiEvent()
+	: iEventType(KNullUid), iErrorCode(KErrNone)
+	{
+	ZeroMembers();
+	}
+
+/**
+Set to default values all the data members.
+*/
+void CMMFMidiEvent::ZeroMembers()
+	{
+	iOldState = EMidiStateClosedDisengaged;
+	iNewState = EMidiStateClosedDisengaged;
+	iMicroSeconds = 0;
+	iMicroBeats = 0;
+	iChannel = 0;
+	iVolumeInDecibels = 0;
+	iMute = EFalse;
+	iMetaDataEntryId = 0;
+	iPolyphony = 0;
+	iBankId = 0;
+	iInstrumentId = 0;
+	iTempoMicroBeats = 0;
+	}
+
+/**
+Destructor.
+*/
+EXPORT_C CMMFMidiEvent::~CMMFMidiEvent()
+	{
+	iMipMessage.Close();
+	}
+	
+/**
+Externalize the object to a stream. All the member variables will be written to the stream.
+
+@param aStream	
+       The write stream object.
+*/
+EXPORT_C void CMMFMidiEvent::ExternalizeL(RWriteStream& aStream) const
+	{
+	aStream << iEventType;
+	aStream.WriteInt32L(iErrorCode);
+	aStream.WriteInt32L(iOldState);
+	aStream.WriteInt32L(iNewState);
+	aStream << iMicroSeconds.Int64();
+	aStream << iMicroBeats;
+	aStream.WriteInt32L(iChannel);
+	aStream << iVolumeInDecibels;
+	aStream.WriteInt32L(iMute);
+	aStream.WriteInt32L(iMetaDataEntryId);
+
+	aStream.WriteInt32L(iMipMessage.Count());
+	for (TInt i=0; i<iMipMessage.Count(); i++)
+		{
+		aStream.WriteInt32L(iMipMessage[i].iChannel);
+		aStream.WriteInt32L(iMipMessage[i].iMIPValue);
+		}
+
+	aStream.WriteInt32L(iPolyphony);
+	aStream.WriteInt32L(iBankId);
+	aStream.WriteInt32L(iInstrumentId);
+	aStream.WriteInt32L(iTempoMicroBeats);
+	}
+
+/**
+Internalize the object from a stream. All the member variables will be read from the stream.
+
+@param aStream	
+       The read stream object.
+*/
+EXPORT_C void CMMFMidiEvent::InternalizeL(RReadStream& aStream)
+	{
+	aStream >> iEventType;
+	iErrorCode = aStream.ReadInt32L();
+	iOldState = STATIC_CAST(TMidiState, aStream.ReadInt32L());
+	iNewState = STATIC_CAST(TMidiState, aStream.ReadInt32L());
+
+	TInt64 microSeconds;
+	aStream >> microSeconds;
+	iMicroSeconds = microSeconds;
+	
+	aStream >> iMicroBeats;
+	iChannel = aStream.ReadInt32L();
+	aStream >> iVolumeInDecibels;
+	iMute = aStream.ReadInt32L();
+	iMetaDataEntryId = aStream.ReadInt32L();
+
+	TInt count = aStream.ReadInt32L();
+	for (TInt i=0; i<count; i++)
+		{
+		TMipMessageEntry entry;
+		entry.iChannel = aStream.ReadInt32L();
+		entry.iMIPValue = aStream.ReadInt32L();
+		User::LeaveIfError(iMipMessage.Append(entry));
+		}
+
+	iPolyphony = aStream.ReadInt32L();
+	iBankId = aStream.ReadInt32L();
+	iInstrumentId = aStream.ReadInt32L();
+	iTempoMicroBeats = aStream.ReadInt32L();
+	}
+
+/**
+Copies a MIDI event into this CMMFMidiEvent.
+
+@param aOther	
+       The CMMFMidiEvent to copy from.
+*/
+EXPORT_C void CMMFMidiEvent::CopyL(const CMMFMidiEvent& aOther)
+	{
+	iEventType = aOther.iEventType;
+	iErrorCode = aOther.iErrorCode;
+	iOldState = aOther.iOldState;
+	iNewState = aOther.iNewState;
+	iMicroSeconds = aOther.iMicroSeconds;
+	iMicroBeats = aOther.iMicroBeats;
+	iChannel = aOther.iChannel;
+	iVolumeInDecibels = aOther.iVolumeInDecibels;
+	iMute = aOther.iMute;
+	iMetaDataEntryId = aOther.iMetaDataEntryId;
+	iPolyphony = aOther.iPolyphony;
+	iBankId = aOther.iBankId;
+	iInstrumentId = aOther.iInstrumentId;
+	iTempoMicroBeats = aOther.iTempoMicroBeats;
+
+	for (TInt i=0; i<aOther.iMipMessage.Count(); i++)
+		{
+		User::LeaveIfError(iMipMessage.Append(aOther.iMipMessage[i]));
+		}
+	}
+
+