DeviceManager Class Reference

#include <deviceman.h>

Public Member Functions
	DeviceManager (int def=-1)
	~DeviceManager (void)
int	initManager (void)
int	checkInit (void)
MidiOut *	chntodev (int chn)
MidiOut *	deviceForChannel (int chn)
int	deviceNumberForChannel (int chn)
void	setDeviceNumberForChannel (int chn, int dev)
int	ok (void)
int	usingAlsa (void)
void	openDev (void)
void	closeDev (void)
void	initDev (void)
void	noteOn (uchar chn, uchar note, uchar vel)
void	noteOff (uchar chn, uchar note, uchar vel)
void	keyPressure (uchar chn, uchar note, uchar vel)
void	chnPatchChange (uchar chn, uchar patch)
void	chnPressure (uchar chn, uchar vel)
void	chnPitchBender (uchar chn, uchar lsb, uchar msb)
void	chnController (uchar chn, uchar ctl, uchar v)
void	sysEx (uchar *data, ulong size)
void	wait (double ms)
void	tmrSetTempo (int v)
void	tmrStart (long int tpcn)
void	tmrStop (void)
void	tmrContinue (void)
void	allNotesOff (void)
void	sync (bool f=0)
void	setVolumePercentage (int i)
int	defaultDevice (void)
void	setDefaultDevice (int i)
int	setPatchesToUse (int *patchesused)
const char *	midiMapFilename (void)
void	setMidiMap (MidiMapper *map)
int	rate (void)
int	midiPorts (void)
int	synthDevices (void)
const char *	name (int i)
const char *	type (int i)

Protected Member Functions
void	seqbuf_dump (void)
void	seqbuf_clean (void)
void	checkAlsa (void)

Protected Attributes
MidiOut **	device
struct midi_info *	midiinfo
struct synth_info *	synthinfo
int	chn2dev [16]
int	n_synths
int	n_midi
int	n_total
int	m_rate
double	convertrate
int	timerstarted
double	lastwaittime
MidiMapper *	mapper_tmp
int	initialized
int	seqfd
int	default_dev
int	_ok
bool	alsa

Detailed Description

MIDI Device Manager class .

This class is the one you should use to send MIDI events to any device, as it creates and manages the *Out classes.

This class is usually used by creating a DeviceManager object, then call openDev() and initDev() . Then, use numberOfMidiPorts(), numberOfSynthDevices(), name() and type() to choose which device to play MIDI events to and then use defaultDevice() to set the MIDI device to play.

Manages all MIDI devices and redirects MIDI events to each one as configured.

Version

0.9.5 17/01/2000

Author

Antonio Larrosa Jimenez larro.nosp@m.sa@k.nosp@m.de.or.nosp@m.g

Definition at line 47 of file deviceman.h.

Constructor & Destructor Documentation

DeviceManager()

DeviceManager::DeviceManager

(

int

def = -1

)

Constructor.

It just initializes internal variables, before playing any music, you should call initManager(), setMidiMap() (optional), openDev(), initDev(), setPatchesToUse() (not required, unless you're playing to a GUS device, which must load the patches), tmrStart(), and finally, play the music.

Definition at line 106 of file deviceman.cpp.

~DeviceManager()

DeviceManager::~DeviceManager

(

void

)

Destructor.

It closes the device (calling closeDev() ) if it wasn't closed before.

Definition at line 153 of file deviceman.cpp.

Member Function Documentation

allNotesOff()

void DeviceManager::allNotesOff

(

void

)

Sends an all notes off event.

Definition at line 824 of file deviceman.cpp.

checkInit()

int DeviceManager::checkInit

(

void

)

Checks if the device manager has been initialized (with initManager), and in case it wasn't, initializes it.

Returns

0 if it was (or has just been) correctly initialized, and -1 if there was an error.

Definition at line 176 of file deviceman.cpp.

chnController()

void DeviceManager::chnController	(	uchar	chn,
		uchar	ctl,
		uchar	v
	)

Sends a Controller event to a MIDI channel.

This can be used for example to change the volume, set a XG patch, etc. Look for any General Midi resource page on the net for more information about the available controller events.

For example, to set the tremolo value to a maximum on the MIDI channel number one, you should pass 1 to chn, 1 to ctl and 127 to v.

Parameters

chn	the MIDI channel (0 to 15) to send the event to.
ctl	the controller (0 to 15) to send.
v	the value (data) of the controller.

Definition at line 526 of file deviceman.cpp.

chnPatchChange()

void DeviceManager::chnPatchChange	(	uchar	chn,
		uchar	patch
	)

Changes the patch (instrument) on a MIDI channel.

See also

setPatchesToUse()

Parameters

chn	the MIDI channel (0 to 15) .
patch	the General Midi patch (0 to 127) to use on the channel chn.

Definition at line 511 of file deviceman.cpp.

chnPitchBender()

void DeviceManager::chnPitchBender	(	uchar	chn,
		uchar	lsb,
		uchar	msb
	)

Changes the Pitch Bender value on a MIDI channel.

This bends the tone of each note played on this channel.

Parameters

chn	the MIDI channel (0 to 15) to use.
lsb	and msb the less significant byte and the most significant byte (0 to 127 each) of the number by which notes will be bend. a 0x4000 value means not to bend.
msb	the most significant byte

Definition at line 521 of file deviceman.cpp.

chnPressure()

void DeviceManager::chnPressure	(	uchar	chn,
		uchar	vel
	)

Changes the Pressure (Aftertouch) on a MIDI channel.

Keep in mind that some synthesizers don't like this events, and it's better not to send it.

Parameters

chn	the MIDI channel (0 to 15) to change.
vel	the velocity (0 to 127) to use on the channel chn.

Definition at line 516 of file deviceman.cpp.

chntodev()

MidiOut* DeviceManager::chntodev ( int  chn )

inline

Deprecated:

Please use deviceForChannel() instead.

Definition at line 206 of file deviceman.h.

closeDev()

void DeviceManager::closeDev

(

void

)

Closes the devices, and /dev/sequencer.

See also

openDev()

Definition at line 449 of file deviceman.cpp.

defaultDevice()

int DeviceManager::defaultDevice

(

void

)

Returns the device to which the MIDI events will be sent.

Returns -1 if there's no available device.

See also

setDefaultDevice()

Definition at line 764 of file deviceman.cpp.

deviceForChannel()

MidiOut* DeviceManager::deviceForChannel ( int  chn )

inline

It's possible to send different MIDI channels to different MIDI devices, so that you can for example send channel 1 to an external synthesizer, channel 2 to a FM device and channel 10 to an AWE synth.

Returns

the device to which MIDI events goind to channel chn should be sent.

Definition at line 217 of file deviceman.h.

deviceNumberForChannel()

int DeviceManager::deviceNumberForChannel ( int  chn )

inline

Returns the device number associated with a given channel.

Definition at line 223 of file deviceman.h.

initDev()

void DeviceManager::initDev

(

void

)

Calls MidiOut::initDev() in turn in each of the available devices.

See also

MidiOut::initDev()

Definition at line 482 of file deviceman.cpp.

initManager()

int DeviceManager::initManager

(

void

)

Initializes the MIDI Device Manager object.

The /dev/sequencer and/or /dev/snd/seq files are opened, available devices are analyzed and *Out objects are created. Then, the device files are closed.

Returns

0 if everything was OK, or -1 if there was an error and it couldn't be initialized (for example, because it couldn't open the /dev/sequencer file)

Definition at line 203 of file deviceman.cpp.

keyPressure()

void DeviceManager::keyPressure	(	uchar	chn,
		uchar	note,
		uchar	vel
	)

Sends a Key Pressure (or Aftertouch) MIDI event.

This event changes the pressure over a key after this key has been played.

Parameters

chn	the MIDI channel (0 to 15) where the note is being played.
note	the key of the note (0 to 127).
vel	the new velocity (or pressure) of the note (0 to 127).

Definition at line 506 of file deviceman.cpp.

midiMapFilename()

const char * DeviceManager::midiMapFilename

(

void

)

Returns the filename where the Midi Mapper was loaded from, or "" if no MIDI Mapper is in use.

See also

setMidiMap()

Definition at line 776 of file deviceman.cpp.

midiPorts()

int DeviceManager::midiPorts ( void  )

inline

Returns the number of MIDI ports available on the system.

It's common that users have MIDI ports available, but there are no external synthesizers connected to these ports, so sending MIDI events to these ports will not produce any music in this case.

See also

synthDevices()

setDefaultDevice()

Definition at line 504 of file deviceman.h.

name()

const char * DeviceManager::name

(

int

i

)

Returns the name of the i-th device .

In case the DeviceManager wasn't yet initialized ( see checkInit() ), the return value is NULL, and in case the parameter has a value out of the valid range ( 0 to midiPorts() + synthDevices() ) it returns an empty string.

Definition at line 716 of file deviceman.cpp.

noteOff()

void DeviceManager::noteOff	(	uchar	chn,
		uchar	note,
		uchar	vel
	)

Sends a Note Off MIDI event.

This is equivalent to send a Note On event with a vel value of 0.

Parameters

chn	the MIDI channel (0 to 15) to play the note on.
note	the key of the note to play (0 to 127).
vel	the velocity of the note (0 to 127).

See also

noteOn()

Definition at line 501 of file deviceman.cpp.

noteOn()

void DeviceManager::noteOn	(	uchar	chn,
		uchar	note,
		uchar	vel
	)

Sends a Note On MIDI event.

Parameters

chn	the MIDI channel (0 to 15) to play the note on.
note	the key of the note to play (0 to 127).
vel	the velocity of the note (0 to 127).

See also

noteOff()

Definition at line 496 of file deviceman.cpp.

ok()

int DeviceManager::ok

(

void

)

Returns

0 if there was a problem and 1 if everything was OK. Note that the return value is changed after you check it, so you can only check it once.

Definition at line 169 of file deviceman.cpp.

openDev()

void DeviceManager::openDev

(

void

)

Open the devices.

It first initializes the manager it that wasn't done yet (you should do it yourself, to be able to choose the MIDI output device, as it will be set to an external synth by default, if available).

Then /dev/sequencer is opened and the MIDI devices are opened (calling MidiOut::openDev() ).

See also

ok() to check if there was any problem

closeDev()

initDev()

Definition at line 398 of file deviceman.cpp.

rate()

int DeviceManager::rate ( void  )

inline

Returns the SNDCTL_SEQ_CTRLRATE ioctl value.

Definition at line 493 of file deviceman.h.

setDefaultDevice()

void DeviceManager::setDefaultDevice

(

int

i

)

Sets the device to send the MIDI events to.

By using midiPorts(), synthDevices(), name() and type(), you should choose which device to use (note that they are numbered with midi ports being first and synth devices next)

See also

defaultDevice()

Definition at line 769 of file deviceman.cpp.

setDeviceNumberForChannel()

void DeviceManager::setDeviceNumberForChannel	(	int	chn,
		int	dev
	)

Sets the device number associated with a given channel.

Definition at line 819 of file deviceman.cpp.

setMidiMap()

void DeviceManager::setMidiMap

(

MidiMapper *

map

)

Sets a MidiMapper object to use.

This object should already have loaded the configuration. See the description of MidiMapper for more information.

See also

MidiMapper::MidiMapper()

midiMapFilename()

Definition at line 784 of file deviceman.cpp.

setPatchesToUse()

int DeviceManager::setPatchesToUse

(

int *

patchesused

)

Loads the patches you're going to use .

This has effect only for GUS cards, although, if you use this function when defaultDevice() is not a GUS device, it will be ignored.

The parameter is an int [256] array, which contain the following:

The first 0..127 integers, are the number of times each General MIDI patch will be used, and -1 when the corresponding patch won't be used.

The 128..255 integers are the number of times each drum voice (each note on the drum channel) will be used, and -1 when the corresponding percussion won't be used.

This is done this way so that if the user has very little memory on his GUS card, and not all patches will be loaded, they are at least reordered, so that it first loads the one you're going to use most.

In case you don't worry about such users, or you don't know "a priori" the number of notes you're going to play, you can just use 1 for each patch you want to load and -1 in the rest.

See also

GUSOut::setPatchesToUse()

GUSOut::loadPatch()

Returns

0 if ok, and -1 if there wasn't enough memory to load the patches in the card's memory.

Definition at line 794 of file deviceman.cpp.

setVolumePercentage()

void DeviceManager::setVolumePercentage

(

int

i

)

Changes the "master" volume of the played events by altering next volume controller events.

The parameter i should be in the range of 0 (nothing is heard) to 150 (music is played at a 150% of the original volume).

Keep in mind that as most MIDI files already play music at near the maximum volume, an i value greater than 100 is very probably ignored most of the times.

Definition at line 808 of file deviceman.cpp.

sync()

void DeviceManager::sync

(

bool

f = 0

)

Synchronizes with the MIDI buffer.

Midi events are put into a buffer, along with timer delays (see wait() ). sync returns when the buffer is empty.

Parameters

f	if false, it syncronizes by waiting for the buffer to be sent. If true, it forces the synchronization by clearing the buffer inmediately. The "force" method is, of course, not recommended, except in rare situations.

Definition at line 632 of file deviceman.cpp.

synthDevices()

int DeviceManager::synthDevices ( void  )

inline

Returns the number of internal synthesizers available on the system.

Some of these devices will need special configuration, for example, to load sound patches.

See also

midiPorts()

setDefaultDevice()

setPatchesToUse()

Definition at line 515 of file deviceman.h.

sysEx()

void DeviceManager::sysEx	(	uchar *	data,
		ulong	size
	)

Sends a SYStem EXclusive message to the default MIDI device (usually, external MIDI synths, as most internal synths do not support sysex messages)

Parameters

data	the array of bytes that comform the system exclusive message. Without the initial 0xF0 char, and including the final 0xF7 char (end of exclusive message)
size	the size in bytes of the data to send

See also

setDefaultDevice()

Definition at line 531 of file deviceman.cpp.

tmrContinue()

void DeviceManager::tmrContinue

(

void

)

Continue the stopped timer .

It is the same than starting a new timer, but without resetting it.

Definition at line 612 of file deviceman.cpp.

tmrSetTempo()

void DeviceManager::tmrSetTempo

(

int

v

)

Sets the tempo which will be used to convert between ticks and milliseconds.

Definition at line 553 of file deviceman.cpp.

tmrStart()

void DeviceManager::tmrStart

(

long int

tpcn

)

Starts the timer.

You must call tmrStart before using wait()

Definition at line 565 of file deviceman.cpp.

tmrStop()

void DeviceManager::tmrStop

(

void

)

Stops the timer.

This will be called by closeDev() before closing the device

Definition at line 591 of file deviceman.cpp.

type()

const char * DeviceManager::type

(

int

i

)

Returns the type of device the i-th device is , in a user-friendly string .

For example, "External Midi Port" for midi ports, "FM" for FM synthesizers, "GUS" for Gravis Ultrasound devices, etc.

Definition at line 734 of file deviceman.cpp.

usingAlsa()

int DeviceManager::usingAlsa ( void  )

inline

Returns true if it's running ALSA and false if OSS is being run.

Definition at line 239 of file deviceman.h.

wait()

void DeviceManager::wait

(

double

ms

)

Sets the number of milliseconds at which the next event will be sent.

This way, you can schedule notes and events to send to the MIDI device.

See also

tmrStart()

Definition at line 537 of file deviceman.cpp.

---

The documentation for this class was generated from the following files:

• deviceman.h
• deviceman.cpp