Sequencer JDK 1.6)

public int addControllerEventListener (ControllerEventListener listener, int[] controllers)

Registers a controller event listener to receive notification whenever the sequencer processes a control-change event of the requested type or types.

Registers a controller event listener to receive notification whenever the sequencer processes a control-change event of the requested type or types. The types are specified by the controllers argument, which should contain an array of MIDI controller numbers. (Each number should be between 0 and 127, inclusive. See the MIDI 1.0 Specification for the numbers that correspond to various types of controllers.)

The returned array contains the MIDI controller numbers for which the listener will now receive events. Some sequencers might not support controller event notification, in which case the array has a length of 0. Other sequencers might support notification for some controllers but not all. This method may be invoked repeatedly. Each time, the returned array indicates all the controllers that the listener will be notified about, not only the controllers requested in that particular invocation.
Returns: the numbers of all the MIDI controllers whose changes will now be reported to the specified listener
Parameters:
- listener - the controller event listener to add to the list of registered listeners
- controllers - the MIDI controller numbers for which change notification is requested
See Also: Sequencer.removeControllerEventListener(javax.sound.midi.ControllerEventListener, int[]), ControllerEventListener,

public boolean addMetaEventListener (MetaEventListener listener)

Registers a meta-event listener to receive notification whenever a meta-event is encountered in the sequence and processed by the sequencer.

Registers a meta-event listener to receive
notification whenever a meta-event is encountered in the sequence
and processed by the sequencer. This method can fail if, for
instance,this class of sequencer does not support meta-event
notification.
Returns: true if the listener was successfully added, otherwise false
Parameters:
- listener - listener to add
See Also: Sequencer.removeMetaEventListener(javax.sound.midi.MetaEventListener), MetaEventListener, MetaMessage,

public int getLoopCount ()

Obtains the number of repetitions for playback.

public long getLoopEndPoint ()

Obtains the end position of the loop, in MIDI ticks.

public long getLoopStartPoint ()

Obtains the start position of the loop, in MIDI ticks.

public SyncMode getMasterSyncMode ()

Obtains the current master synchronization mode for this sequencer.

public SyncMode getMasterSyncModes ()

Obtains the set of master synchronization modes supported by this sequencer.

public long getMicrosecondLength ()

Obtains the length of the current sequence, expressed in microseconds, or 0 if no sequence is set.

public long getMicrosecondPosition () [Specified in MidiDevice]

Obtains the current position in the sequence, expressed in microseconds.

public Sequence getSequence ()

Obtains the sequence on which the Sequencer is currently operating.

public SyncMode getSlaveSyncMode ()

Obtains the current slave synchronization mode for this sequencer.

public SyncMode getSlaveSyncModes ()

Obtains the set of slave synchronization modes supported by the sequencer.

public float getTempoFactor ()

Returns the current tempo factor for the sequencer.

public float getTempoInBPM ()

Obtains the current tempo, expressed in beats per minute.

public float getTempoInMPQ ()

Obtains the current tempo, expressed in microseconds per quarter note.

public long getTickLength ()

Obtains the length of the current sequence, expressed in MIDI ticks, or 0 if no sequence is set.

public long getTickPosition ()

Obtains the current position in the sequence, expressed in MIDI ticks.

Obtains the current position in the sequence, expressed in MIDI
ticks. (The duration of a tick in seconds is determined both by
the tempo and by the timing resolution stored in the
Sequence.)
Returns: current tick
See Also: Sequencer.setTickPosition(long),

public boolean getTrackMute (int track)

Obtains the current mute state for a track.

Obtains the current mute state for a track. The default mute
state for all tracks which have not been muted is false. In any
case where the specified track has not been muted, this method should
return false. This applies if the sequencer does not support muting
of tracks, and if the specified track index is not valid.
Returns: true if muted, false if not.
Parameters:
- track - the track number. Tracks in the current sequence are numbered from 0 to the number of tracks in the sequence minus 1.

public boolean getTrackSolo (int track)

Obtains the current solo state for a track.

Obtains the current solo state for a track. The default mute
state for all tracks which have not been solo'd is false. In any
case where the specified track has not been solo'd, this method should
return false. This applies if the sequencer does not support soloing
of tracks, and if the specified track index is not valid.
Returns: true if solo'd, false if not.
Parameters:
- track - the track number. Tracks in the current sequence are numbered from 0 to the number of tracks in the sequence minus 1.

public boolean isRecording ()

Indicates whether the Sequencer is currently recording.

Indicates whether the Sequencer is currently recording. The default is false.
The Sequencer begins recording when Sequencer.startRecording() is called,
and then returns true until Sequencer.stop() or Sequencer.stopRecording()
is called.
Returns: true if the Sequencer is recording, otherwise false

public boolean isRunning ()

Indicates whether the Sequencer is currently running.

Indicates whether the Sequencer is currently running. The default is false.
The Sequencer starts running when either Sequencer.start() or Sequencer.startRecording()
is called. isRunning then returns true until playback of the
sequence completes or Sequencer.stop() is called.
Returns: true if the Sequencer is running, otherwise false

public void recordDisable (Track track)

Disables recording to the specified track.

Disables recording to the specified track. Events will no longer be recorded
into this track.
Parameters:
- track - the track to disable for recording, or null to disable recording for all tracks.

public void recordEnable (Track track, int channel)

Prepares the specified track for recording events received on a particular channel.

public int removeControllerEventListener (ControllerEventListener listener, int[] controllers)

Removes a controller event listener's interest in one or more types of controller event.

Removes a controller event listener's interest in one or more
types of controller event. The controllers argument
is an array of MIDI numbers corresponding to the controllers for
which the listener should no longer receive change notifications.
To completely remove this listener from the list of registered
listeners, pass in null for controllers.
The returned array contains the MIDI controller
numbers for which the listener will now receive events. The
array has a length of 0 if the listener will not receive
change notifications for any controllers.
Returns: the numbers of all the MIDI controllers whose changes will now be reported to the specified listener
Parameters:
- listener - old listener
- controllers - the MIDI controller numbers for which change notification should be cancelled, or null to cancel for all controllers
See Also: Sequencer.addControllerEventListener(javax.sound.midi.ControllerEventListener, int[]),

public void removeMetaEventListener (MetaEventListener listener)

Removes the specified meta-event listener from this sequencer's list of registered listeners, if in fact the listener is registered.

public void setLoopCount (int count)

Sets the number of repetitions of the loop for playback.

Sets the number of repetitions of the loop for playback. When the playback position reaches the loop end point, it will loop back to the loop start point count times, after which playback will continue to play to the end of the sequence.

If the current position when this method is invoked is greater than the loop end point, playback continues to the end of the sequence without looping, unless the loop end point is changed subsequently.

A count value of 0 disables looping: playback will continue at the loop end point, and it will not loop back to the loop start point. This is a sequencer's default.

If playback is stopped during looping, the current loop status is cleared; subsequent start requests are not affected by an interrupted loop operation.
Parameters:
- count - the number of times playback should loop back from the loop's end position to the loop's start position, or {@link #LOOP_CONTINUOUSLY} to indicate that looping should continue until interrupted
Throws:
- IllegalArgumentException - if count is negative and not equal to {@link #LOOP_CONTINUOUSLY}
Since: 1.5
See Also: Sequencer.setLoopStartPoint(long), Sequencer.setLoopEndPoint(long), Sequencer.getLoopCount(), Sequencer.start(),

public void setLoopEndPoint (long tick)

Sets the last MIDI tick that will be played in the loop.

public void setLoopStartPoint (long tick)

Sets the first MIDI tick that will be played in the loop.

public void setMasterSyncMode (SyncMode sync)

Sets the source of timing information used by this sequencer.

Sets the source of timing information used by this sequencer.
The sequencer synchronizes to the master, which is the internal clock,
MIDI clock, or MIDI time code, depending on the value of
sync. The sync argument must be one
of the supported modes, as returned by
Sequencer.getMasterSyncModes().
Parameters:
- sync - the desired master synchronization mode
See Also: Sequencer.SyncMode.INTERNAL_CLOCK, Sequencer.SyncMode.MIDI_SYNC, Sequencer.SyncMode.MIDI_TIME_CODE, Sequencer.getMasterSyncMode(),

public void setMicrosecondPosition (long microseconds)

Sets the current position in the sequence, expressed in microseconds

public void setSequence (InputStream stream) throws IOException InvalidMidiDataException

Sets the current sequence on which the sequencer operates.

public void setSequence (Sequence sequence) throws InvalidMidiDataException

Sets the current sequence on which the sequencer operates.

public void setSlaveSyncMode (SyncMode sync)

Sets the slave synchronization mode for the sequencer.

Sets the slave synchronization mode for the sequencer.
This indicates the type of timing information sent by the sequencer
to its receiver. The sync argument must be one
of the supported modes, as returned by
Sequencer.getSlaveSyncModes().
Parameters:
- sync - the desired slave synchronization mode
See Also: Sequencer.SyncMode.MIDI_SYNC, Sequencer.SyncMode.MIDI_TIME_CODE, Sequencer.SyncMode.NO_SYNC, Sequencer.getSlaveSyncModes(),

public void setTempoFactor (float factor)

Scales the sequencer's actual playback tempo by the factor provided.

Scales the sequencer's actual playback tempo by the factor provided. The default is 1.0. A value of 1.0 represents the natural rate (the tempo specified in the sequence), 2.0 means twice as fast, etc. The tempo factor does not affect the values returned by Sequencer.getTempoInMPQ() and Sequencer.getTempoInBPM(). Those values indicate the tempo prior to scaling.

Note that the tempo factor cannot be adjusted when external synchronization is used. In that situation, setTempoFactor always sets the tempo factor to 1.0.
Parameters:
- factor - the requested tempo scalar
See Also: Sequencer.getTempoFactor(),

public void setTempoInBPM (float bpm)

Sets the tempo in beats per minute.

public void setTempoInMPQ (float mpq)

Sets the tempo in microseconds per quarter note.

public void setTickPosition (long tick)

Sets the current sequencer position in MIDI ticks

public void setTrackMute (int track, boolean mute)

Sets the mute state for a track.

Sets the mute state for a track. This method may fail for a number
of reasons. For example, the track number specified may not be valid
for the current sequence, or the sequencer may not support this functionality.
An application which needs to verify whether this operation succeeded should
follow this call with a call to Sequencer.getTrackMute(int).
Parameters:
- track - the track number. Tracks in the current sequence are numbered from 0 to the number of tracks in the sequence minus 1.
- mute - the new mute state for the track. true implies the track should be muted, false implies the track should be unmuted.
See Also: Sequencer.getSequence(),

public void setTrackSolo (int track, boolean solo)

Sets the solo state for a track.

Sets the solo state for a track. If solo is true only this track and other solo'd tracks will sound. If solo is false then only other solo'd tracks will sound, unless no tracks are solo'd in which case all un-muted tracks will sound.

This method may fail for a number of reasons. For example, the track number specified may not be valid for the current sequence, or the sequencer may not support this functionality. An application which needs to verify whether this operation succeeded should follow this call with a call to Sequencer.getTrackSolo(int).
Parameters:
- track - the track number. Tracks in the current sequence are numbered from 0 to the number of tracks in the sequence minus 1.
- solo - the new solo state for the track. true implies the track should be solo'd, false implies the track should not be solo'd.
See Also: Sequencer.getSequence(),

public void start ()

Starts playback of the MIDI data in the currently loaded sequence.

Starts playback of the MIDI data in the currently loaded sequence. Playback will begin from the current position. If the playback position reaches the loop end point, and the loop count is greater than 0, playback will resume at the loop start point for the number of repetitions set with setLoopCount. After that, or if the loop count is 0, playback will continue to play to the end of the sequence.

The implementation ensures that the synthesizer is brought to a consistent state when jumping to the loop start point by sending appropriate controllers, pitch bend, and program change events.
Throws:
- IllegalStateException - if the Sequencer is closed.
See Also: Sequencer.setLoopStartPoint(long), Sequencer.setLoopEndPoint(long), Sequencer.setLoopCount(int), Sequencer.stop(),

public void startRecording ()

Starts recording and playback of MIDI data.

public void stop ()

Stops recording, if active, and playback of the currently loaded sequence, if any.

Stops recording, if active, and playback of the currently loaded sequence,
if any.
Throws:
- IllegalStateException - if the Sequencer is closed.
See Also: Sequencer.start(), Sequencer.isRunning(),

public void stopRecording ()

Stops recording, if active.

Stops recording, if active. Playback of the current sequence continues.
Throws:
- IllegalStateException - if the Sequencer is closed.
See Also: Sequencer.startRecording(), Sequencer.isRecording(),