// 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.