uk.org.toot.midi.core.channel
Class DefaultMidiChannelWriter

java.lang.Object
  extended by uk.org.toot.midi.core.channel.DefaultMidiChannelWriter
All Implemented Interfaces:
MidiChannelWriter

public class DefaultMidiChannelWriter
extends java.lang.Object
implements MidiChannelWriter

This class provides a channel-based write API. Requires no state.


Constructor Summary
DefaultMidiChannelWriter(MidiTransport port, int index)
           
 
Method Summary
 void allNotesOff()
          Turns off all notes that are currently sounding on this channel.
 void allSoundOff()
          Immediately turns off all sounding notes on this channel, ignoring the state of the Hold Pedal and the internal decay rate of the current Instrument.
 void controlChange(int controller, int value)
          Reacts to a change in the specified controller's value.
 void encode(int command, int data)
           
 void encode(int command, int data1, int data2)
           
 int getIndex()
           
 boolean localControl(boolean local)
          Turns local control on or off.
 void noteOff(int noteNumber)
          Turns the specified note off.
 void noteOff(int noteNumber, int velocity)
          Turns the specified note off.
 void noteOn(int noteNumber, int velocity)
          Starts the specified note sounding.
 void programChange(int program)
          Changes a program (patch).
 void programChange(int bank, int program)
          Changes the program using bank and program (patch) numbers.
 void resetAllControllers()
          Resets all the implemented controllers to their default values.
 void setChannelPressure(int pressure)
          Reacts to a change in the keyboard pressure.
 void setControl(int control, int value)
          Set the controller with the specified index to the specified value.
 void setMono(boolean on)
          Turns mono mode on or off.
 void setMute(boolean mute)
          Sets the mute state for this channel.
 void setOmni(boolean on)
          Turns omni mode on or off.
 void setPan(int pan)
           
 void setPitchBend(int bend)
          Changes the pitch offset for all notes on this channel.
 void setPolyPressure(int noteNumber, int pressure)
          Reacts to a change in the specified note's key pressure.
 void setSolo(boolean soloState)
          Sets the solo state for this channel.
 void setVolume(int volume)
           
 
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

DefaultMidiChannelWriter

public DefaultMidiChannelWriter(MidiTransport port,
                                int index)
Method Detail

getIndex

public int getIndex()
Specified by:
getIndex in interface MidiChannelWriter

encode

public void encode(int command,
                   int data1,
                   int data2)

encode

public void encode(int command,
                   int data)

setPitchBend

public void setPitchBend(int bend)
Changes the pitch offset for all notes on this channel. This affects all currently sounding notes as well as subsequent ones. (For pitch bend to cease, the value needs to be reset to the center position.)

The MIDI specification stipulates that pitch bend be a 14-bit value, where zero is maximum downward bend, 16383 is maximum upward bend, and 8192 is the center (no pitch bend). The actual amount of pitch change is not specified; it can be changed by a pitch-bend sensitivity setting. However, the General MIDI specification says that the default range should be two semitones up and down from center.

Specified by:
setPitchBend in interface MidiChannelWriter
Parameters:
bend - the amount of pitch change, as a nonnegative 14-bit value (8192 = no bend)
See Also:
#getPitchBend

setControl

public void setControl(int control,
                       int value)
Description copied from interface: MidiChannelWriter
Set the controller with the specified index to the specified value. This method determines whether the specified controller is 7 bit or 14 bit and results in one or two controlChange() calls as appropriate.

Specified by:
setControl in interface MidiChannelWriter

noteOn

public void noteOn(int noteNumber,
                   int velocity)
Starts the specified note sounding. The key-down velocity usually controls the note's volume and/or brightness. If velocity is zero, this method instead acts like noteOff(int), terminating the note.

Specified by:
noteOn in interface MidiChannelWriter
Parameters:
noteNumber - the MIDI note number, from 0 to 127 (60 = Middle C)
velocity - the speed with which the key was depressed
See Also:
noteOff(int, int)

noteOff

public void noteOff(int noteNumber,
                    int velocity)
Turns the specified note off. The key-up velocity, if not ignored, can be used to affect how quickly the note decays. In any case, the note might not die away instantaneously; its decay rate is determined by the internals of the Instrument. If the Hold Pedal (a controller; see controlChange) is down, the effect of this method is deferred until the pedal is released.

Specified by:
noteOff in interface MidiChannelWriter
Parameters:
noteNumber - the MIDI note number, from 0 to 127 (60 = Middle C)
velocity - the speed with which the key was released
See Also:
noteOff(int), noteOn(int, int), allNotesOff(), allSoundOff()

noteOff

public void noteOff(int noteNumber)
Turns the specified note off.

Specified by:
noteOff in interface MidiChannelWriter
Parameters:
noteNumber - the MIDI note number, from 0 to 127 (60 = Middle C)
See Also:
noteOff(int, int)

setPolyPressure

public void setPolyPressure(int noteNumber,
                            int pressure)
Reacts to a change in the specified note's key pressure. Polyphonic key pressure allows a keyboard player to press multiple keys simultaneously, each with a different amount of pressure. The pressure, if not ignored, is typically used to vary such features as the volume, brightness, or vibrato of the note.

Specified by:
setPolyPressure in interface MidiChannelWriter
Parameters:
noteNumber - the MIDI note number, from 0 to 127 (60 = Middle C)
pressure - value for the specified key, from 0 to 127 (127 = maximum pressure)
See Also:
#getPolyPressure(int)

setChannelPressure

public void setChannelPressure(int pressure)
Reacts to a change in the keyboard pressure. Channel pressure indicates how hard the keyboard player is depressing the entire keyboard. This can be the maximum or average of the per-key pressure-sensor values, as set by setPolyPressure. More commonly, it is a measurement of a single sensor on a device that doesn't implement polyphonic key pressure. Pressure can be used to control various aspects of the sound, as described under setPolyPressure.

Specified by:
setChannelPressure in interface MidiChannelWriter
Parameters:
pressure - the pressure with which the keyboard is being depressed, from 0 to 127 (127 = maximum pressure)
See Also:
setPolyPressure(int, int), #getChannelPressure

controlChange

public void controlChange(int controller,
                          int value)
Reacts to a change in the specified controller's value. A controller is some control other than a keyboard key, such as a switch, slider, pedal, wheel, or breath-pressure sensor. The MIDI 1.0 Specification provides standard numbers for typical controllers on MIDI devices, and describes the intended effect for some of the controllers. The way in which an Instrument reacts to a controller change may be specific to the Instrument.

The MIDI 1.0 Specification defines both 7-bit controllers and 14-bit controllers. Continuous controllers, such as wheels and sliders, typically have 14 bits (two MIDI bytes), while discrete controllers, such as switches, typically have 7 bits (one MIDI byte). Refer to the specification to see the expected resolution for each type of control.

Controllers 64 through 95 (0x40 - 0x5F) allow 7-bit precision. The value of a 7-bit controller is set completely by the value argument. An additional set of controllers provide 14-bit precision by using two controller numbers, one for the most significant 7 bits and another for the least significant 7 bits. Controller numbers 0 through 31 (0x00 - 0x1F) control the most significant 7 bits of 14-bit controllers; controller numbers 32 through 63 (0x20 - 0x3F) control the least significant 7 bits of these controllers. For example, controller number 7 (0x07) controls the upper 7 bits of the channel volume controller, and controller number 39 (0x27) controls the lower 7 bits. The value of a 14-bit controller is determined by the interaction of the two halves. When the most significant 7 bits of a controller are set (using controller numbers 0 through 31), the lower 7 bits are automatically set to 0. The corresponding controller number for the lower 7 bits may then be used to further modulate the controller value.

Specified by:
controlChange in interface MidiChannelWriter
Parameters:
controller - the controller number (0 to 127; see the MIDI 1.0 Specification for the interpretation)
value - the value to which the specified controller is changed (0 to 127)
See Also:
#getController(int)

programChange

public void programChange(int program)
Changes a program (patch). This selects a specific instrument from the currently selected bank of instruments.

The MIDI specification does not dictate whether notes that are already sounding should switch to the new instrument (timbre) or continue with their original timbre until terminated by a note-off.

The program number is zero-based (expressed from 0 to 127). Note that MIDI hardware displays and literature about MIDI typically use the range 1 to 128 instead.

Specified by:
programChange in interface MidiChannelWriter
Parameters:
program - the program number to switch to (0 to 127)
See Also:
programChange(int, int), #getProgram()

programChange

public void programChange(int bank,
                          int program)
Changes the program using bank and program (patch) numbers.

Specified by:
programChange in interface MidiChannelWriter
Parameters:
bank - the bank number to switch to (0 to 16383)
program - the program (patch) to use in the specified bank (0 to 127)
See Also:
programChange(int), #getProgram()

resetAllControllers

public void resetAllControllers()
Resets all the implemented controllers to their default values.

Specified by:
resetAllControllers in interface MidiChannelWriter
See Also:
controlChange(int, int)

allNotesOff

public void allNotesOff()
Turns off all notes that are currently sounding on this channel. The notes might not die away instantaneously; their decay rate is determined by the internals of the Instrument. If the Hold Pedal controller (see controlChange) is down, the effect of this method is deferred until the pedal is released.

Specified by:
allNotesOff in interface MidiChannelWriter
See Also:
allSoundOff(), noteOff(int)

allSoundOff

public void allSoundOff()
Immediately turns off all sounding notes on this channel, ignoring the state of the Hold Pedal and the internal decay rate of the current Instrument.

Specified by:
allSoundOff in interface MidiChannelWriter
See Also:
allNotesOff()

localControl

public boolean localControl(boolean local)
Turns local control on or off. The default is for local control to be on. The "on" setting means that if a device is capable of both synthesizing sound and transmitting MIDI messages, it will synthesize sound in response to the note-on and note-off messages that it itself transmits. It will also respond to messages received from other transmitting devices. The "off" setting means that the synthesizer will ignore its own transmitted MIDI messages, but not those received from other devices.

Specified by:
localControl in interface MidiChannelWriter
Parameters:
local - true to turn local control on, false to turn local control off
Returns:
the new local-control value

setVolume

public void setVolume(int volume)
Specified by:
setVolume in interface MidiChannelWriter

setPan

public void setPan(int pan)
Specified by:
setPan in interface MidiChannelWriter

setMono

public void setMono(boolean on)
Turns mono mode on or off. In mono mode, the channel synthesizes only one note at a time. In poly mode (identical to mono mode off), the channel can synthesize multiple notes simultaneously. The default is mono off (poly mode on).

"Mono" is short for the word "monophonic," which in this context is opposed to the word "polyphonic" and refers to a single synthesizer voice per MIDI channel. It has nothing to do with how many audio channels there might be (as in "monophonic" versus "stereophonic" recordings).

Specified by:
setMono in interface MidiChannelWriter
Parameters:
on - true to turn mono mode on, false to turn it off (which means turning poly mode on).
See Also:
#getMono

setOmni

public void setOmni(boolean on)
Turns omni mode on or off. In omni mode, the channel responds to messages sent on all channels. When omni is off, the channel responds only to messages sent on its channel number. The default is omni off.

Specified by:
setOmni in interface MidiChannelWriter
Parameters:
on - true to turn omni mode on, false to turn it off.
See Also:
#getOmni

setMute

public void setMute(boolean mute)
Sets the mute state for this channel. A value of true means the channel is to be muted, false means the channel can sound (if other channels are not soloed).

Unlike allSoundOff(), this method applies to only a specific channel, not to all channels. Further, it silences not only currently sounding notes, but also subsequently received notes.

Specified by:
setMute in interface MidiChannelWriter
Parameters:
mute - the new mute state
See Also:
#getMute, setSolo(boolean)

setSolo

public void setSolo(boolean soloState)
Sets the solo state for this channel. If solo is true only this channel and other soloed channels will sound. If solo is false then only other soloed channels will sound, unless no channels are soloed, in which case all unmuted channels will sound.

Specified by:
setSolo in interface MidiChannelWriter
Parameters:
soloState - new solo state for the channel
See Also:
#getSolo, setMute(boolean)


Copyright © 2004, 2005, 2006, 2007 Steve Taylor. All Rights Reserved.