// Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members

// which accompanies this distribution, and is available

// at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// Mmf\Common\MmfMidi.h

// 

//

#ifndef __MMF_COMMON_MMFMIDI_H__

#define __MMF_COMMON_MMFMIDI_H__

// Standard EPOC32 includes

#include <e32base.h>

// Public Media Server includes

#include <mmf/common/mmfbase.h>

#include <mmf/common/mmfutilities.h>

#include <midiclientutility.h>

/**

MIDI event usued by a MIDI controller to signal to a 

client that a MIDI source open request has completed.

@publishedAll

@released

*/

const TUid KMMFEventCategoryMidiOpenDataSourceComplete = {0x101F8F85};

/**

MIDI event used by a MIDI controller to signal to a 

client that play of a MIDI resource has commenced.

@publishedAll

@released

*/

const TUid KMMFEventCategoryMidiPlaying = {0x101F8F86};

/**

MIDI event used by a MIDI controller to signal to 

a client that play of a MIDI resource has commenced 

but not all SP-MIDI requirements can be met.

@publishedAll

@released

*/

const TUid KMMFEventCategoryMidiPlaybackIncompatible = {0x101F8F87};

/**

MIDI event used by a MIDI controller to signal to a client that play

of a MIDI resource has commenced but due to system resource constraints

and SP-MIDI content constraints, there is no audible MIDI content

during playback.

@publishedAll

@released

*/

const TUid KMMFEventCategoryMidiPlaybackSilent = {0x101F8F88};

/**

MIDI event used by a MIDI controller to signal to

a client that play of a MIDI resource has completed.

@publishedAll

@released

*/

const TUid KMMFEventCategoryMidiPlayingComplete = {0x101F8F89};

/**

MIDI event used by a MIDI controller to signal to

a client a sync update event. The frequency of this event is

set by the client with SetSyncUpdateCallbackIntervalL.

@publishedAll

@released

*/

const TUid KMMFEventCategoryMidiSyncUpdate = {0x101F8F8A};

/**

MIDI event used by a MIDI controller to signal to

a client that any currently opened resources have been closed.

@publishedAll

@released

*/

const TUid KMMFEventCategoryMidiClose = {0x101F8F8B};

/**

MIDI event used by a MIDI controller to signal to a client that the 

MIDI controller has been primed and it's ready to play.

@publishedAll

@released

*/

const TUid KMMFEventCategoryMidiPrime = {0x101F8F8C};

/**

MIDI event used by a MIDI controller to signal to a client that the MIDI

resource has encountered a tempo change message in the MIDI data stream.

@publishedAll

@released

*/

const TUid KMMFEventCategoryTempoChanged = {0x101F8F8D};

/**

MIDI event used by a MIDI controller to signal to a client that the MIDI

resource has encountered a volume change message in the MIDI data stream.

@publishedAll

@released

*/

const TUid KMMFEventCategoryVolumeChanged = {0x101F8F8E};

/**

MIDI event used by a MIDI controller to signal to a client that the 

MIDI resource has encountered a mute message in the MIDI data stream.

@publishedAll

@released

*/

const TUid KMMFEventCategoryMuteChanged = {0x101F8F8F};

/**

MIDI event used by a MIDI controller to signal to a client that the polyphony

of the MIDI engine has changed.

@publishedAll

@released

*/

const TUid KMMFEventCategoryPolyphonyChanged = {0x101F8F90};

/**

MIDI event used by a MIDI controller to signal to a client that

an instrument has been changed on a channel.

@publishedAll

@released

*/

const TUid KMMFEventCategoryInstrumentChanged = {0x101F8F91};

/**

MIDI event used by a MIDI controller to signal to a client that a timed

meta data entry has been found in the MIDI data stream.

@publishedAll

@released

*/

const TUid KMMFEventCategoryMetaDataEntryFound  = {0x101F8F92};

/**

MIDI event used by a MIDI controller to signal to a client that a 

MIP message has been found in the MIDI data stream.

@publishedAll

@released

*/

const TUid KMMFEventCategoryMipMessageReceived  = {0x101F8F93};

/**

@internalComponent

*/

class TMMFMidiConfig1

	{

public:

	inline TMMFMidiConfig1();

public:

	/** 

	 * Number of tracks present in the currently open MIDI resource.

	 */

	TInt iNumTracks;

	/** 

	 * Current state of the MIDI client utility object 

	 * (EMidiStateClosedDisengaged,EMidiStateOpenDisengaged,EMidiStateOpenPlaying,EMidiStatePlaybackIncompatible,

	 *  EMidiStatePlaybackSilent, EMidiStateClosedEngaged, EMidiStateOpenEngaged).

	 */

	TInt iState;

	/** 

	 * Tempo in microbeats per minute (BPM*1000000).

	 */

	TInt iTempo;

	/** 

	 * Pitch shift in cents, i.e. semitones * 100. One octave equals 1200 cents.

	 */

	TInt iPitch;

	/** 

	 * Array of logical {channel, MIP} value pairs to send SP-MIDI MIP message to the MIDI engine.

	 */

	const TArray<TMipMessageEntry>* iMipMessage; 

	/** 

	 * The maximum number of notes that the MIDI engine supports simultaneously (polyphony).

	 */

	TInt iNumNotes; 

	/** 

	 * Max polyphony level: 0 <= PolyphonyL() <= iMaxNotes.

	 */

	TInt iMaxNotes;

	/** 

	 * Overall volume of the MIDI client.

	 */

	TInt iVolume;

	/** 

	 * Maximum volume that may be applied overall to the MIDI client.

	 */

	TInt iMaxVolume;

	/** 

	 * Length of time over which the volume is faded up from zero to the current settings when playback is started.

	 */

	TTimeIntervalMicroSeconds iRampDuration;

	/** 

	 * Stereo balance value: KMMFBalanceMaxLeft <= iBalance <= KMMFBalanceMaxRight.

	 */

	TInt iBalance;

	/** 

	 * The number of times the current opened resources has to be repeated.

	 * This includes the first instance of playing.

	 */

	TInt iNumRepeats;

	/** 

	 * Length of time over which the volume is faded out from the current settings to zero.

	 */

	TTimeIntervalMicroSeconds iFadeOutDuration;

	};

/**

@internalComponent

*/

class TMMFMidiConfig2

	{

public:

	inline TMMFMidiConfig2();

public:

	/** 

	 * Index of the track to mute: 0 <= iTrack < NumTracksL().

	 */

	TInt iTrack;

	/** 

	 * ETrue to mute the track/channel, EFalse to unmute it.

	 */

	TBool iMuted;

	/** 

	 * Note to play ot to terminate: 0 <= iNote <= 127.

	 */

	TInt iNote;

	/** 

	 * Length of time to play the note for.

	 */

	TTimeIntervalMicroSeconds iDurationMicroSeconds;

	/** 

	 * Specifying the time at which to start playing the note.

	 * It's relative to the MIDI resource playing time or the time elapsed

	 * since Play() was called if no resource is present.

	 */

	TTimeIntervalMicroSeconds iStartTime;

	/** 

	 * Velocity with which to start the note: 0 <= iNoteOnVelocity <= 127.

	 */

	TInt iNoteOnVelocity;

	/** 

	 * Velocity with which to stop the note: 0 <= iNoteOffVelocity <= 127.

	 */

	TInt iNoteOffVelocity;

	/** 

	 * Number of standard or custom sound banks currently available.

	 */

	TInt iNumBanks;

	/** 

	 * Specifies whether to reference a custom or standard sound bank.

	 */

	TBool iCustom;

	/** 

	 * Index of custom/deault bank: 0 <= iBankIndex < NumberOfBanksL()

	 */

	TInt iBankIndex;

	/** 

	 * Custom/deault Bank's Identifier.

	 */

	TInt iBankId;

	/** 

	 * Identifier of the custom bank in memory.

	 */

	TInt iMemoryBankId;

	/** 

	 * Name of the file containing the custom sound bank or the name 

	 * of the file containing the instrument. Includes the directory path. 

	 */

	const TDesC* iFileName;

	/** 

	 * Descriptor containing the custom sound bank.

	 */

	const TDesC8* iBankData;

	/** 

	 * Descriptor containing the instrument.

	 */

	const TDesC8* iInstrumentData;

	/** 

	 * ETrue if the specified bank is in memory, EFalse otherwise.

	 */

	TBool iBankLoaded;

	/** 

	 * Number of instruments available for the specified sound bank.

	 */

	TInt iNumInstruments;

	/** 

	 * Index of the instrument to reference: 0 <= aInstrumentIndex < NumberOfInstrumentsL().

	 */

	TInt iInstrumentIndex;

	/** 

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

	 * 0 <= iInstrumentId <= 127.

	 */

	TInt iInstrumentId;

	/** 

	 * Identifier of the instrument in memory.

	 */

	TInt iMemoryInstrumentId;

	/** 

	 * Current metrical position of the MIDI resource being played.

	 * Microbeats (BPM*1000000) relative to the start of the resource.

	 */

	TInt64 iPositionMicroBeats;

	/** 

	 * Length of the currently open MIDI resource.

	 * Duration in microbeats (beats * 1000000).

	 */

	TInt64 iDurationMicroBeats;

	/** 

	 * Time at which playback will stop, relative to the start of the resource.

	 * Clamped to 0 and the duration of the resource.

	 */

	TTimeIntervalMicroSeconds iStopTime;

	/** 

	 * Logical channel: 0 <= iChannel < ChannelsSupportedL().

	 */

	TInt iChannel;

	/** 

	 * Volume level in dB corresponding to the MIDI Channel:

	 * -infinity <= iChannelVol <= MaxVolumeL().

	 */

	TReal32 iChannelVol;

	/** 

	 * Maximum volume setting in dB, should always be 0 dB and 

	 * correspond to the MIDI Channel Volume controller maximum value.

	 */

	TReal32 iMaxChannelVol;

	};

/**

@internalComponent

*/

class TMMFMidiConfig3

	{

public:

	inline TMMFMidiConfig3();

public:

	/** 

	 * Temporal interval between MmcuoSyncUpdate callback.

	 */

	TTimeIntervalMicroSeconds iCallbackIntervalMicroSeconds;

	/** 

	 * Metrical interval between MmcuoSyncUpdate callback.

	 */

	TInt64 iCallbackIntervalMicroBeats;

	/** 

	 * Number of bytes of the MIDI message buffer actually processed when client

	 * calls SendMessageL.

	 */

	TInt iBytesProcessed;

	/** 

	 * Time at which to execute the MIDI message sent by SendMessageL.

	 * It's relative to the MIDI resource playing time or the time elapsed 

	 * since Play() was called if no resource is present.

	 */

	TTimeIntervalMicroSeconds iTimeStamp;

	/** 

	 * Number of time to repeat the resource during playback. This includes the first playing.

	 */

	TInt iRepeatNumberOfTimes;

	/** 

	 * Time in microseconds to pause between repeats.

	 */

	TTimeIntervalMicroSeconds iTrailingSilence;

	/** 

	 * Playback rate for the playback of the current MIDI resource

	 * in percent times 1000, i.e., 100000 means original playback speed,

	 * 200000 means double speed, and 50000 means half speed playback.

	 */

	TInt iPlayBackRate;

	/** 

	 * Maximum playback rate supported by MIDI player.

	 */

	TInt iPlayBackMaxRate;

	/** 

	 * Minimum playback rate supported by MIDI player.

	 */

	TInt iPlayBackMinRate;

	/** 

	 * Descriptor containing a MIDI message data. If there

	 * are several MIDI messages in the buffer, only the first

	 * one is processed.

	 */

	const TDesC8* iMidiMessage;

	};

inline TMMFMidiConfig1::TMMFMidiConfig1()

{};

inline TMMFMidiConfig2::TMMFMidiConfig2()

{};

inline TMMFMidiConfig3::TMMFMidiConfig3()

{};

#endif