Modifier and Type	Class and Description
public static class	Sequencer.SyncMode A `SyncMode` object represents one of the ways in which a MIDI sequencer's notion of time can be synchronized with a master or slave device.

Modifier and Type	Field and Description
public static final int	LOOP_CONTINUOUSLY A value indicating that looping should continue indefinitely rather than complete after a specific number of loops.

Method Summary

Modifier and Type	Method and Description
public int[]	Returns: the numbers of all the MIDI controllers whose changes will now be reported to the specified listener addControllerEventListener(ControllerEventListener the controller event listener to add to the list of registered listeners listener, int[] the MIDI controller numbers for which change notification is requested controllers) Registers a controller event listener to receive notification whenever the sequencer processes a control-change event of the requested type or types.
public boolean	Returns: `true` if the listener was successfully added, otherwise `false` addMetaEventListener(MetaEventListener listener to add listener) Registers a meta-event listener to receive notification whenever a meta-event is encountered in the sequence and processed by the sequencer.
public int	Returns: the number of loops after which playback plays to the end of the sequence getLoopCount() Obtains the number of repetitions for playback.
public long	Returns: the end position of the loop, in MIDI ticks (zero-based), or -1 to indicate the end of the sequence getLoopEndPoint() Obtains the end position of the loop, in MIDI ticks.
public long	Returns: the start position of the loop, in MIDI ticks (zero-based) getLoopStartPoint() Obtains the start position of the loop, in MIDI ticks.
public Sequencer.SyncMode	Returns: the current master synchronization mode getMasterSyncMode() Obtains the current master synchronization mode for this sequencer.
public Sequencer.SyncMode[]	Returns: the available master synchronization modes getMasterSyncModes() Obtains the set of master synchronization modes supported by this sequencer.
public long	Returns: length of the sequence in microseconds getMicrosecondLength() Obtains the length of the current sequence, expressed in microseconds, or 0 if no sequence is set.
public long	Returns: the current position in microseconds getMicrosecondPosition() Redeclares javax.sound.midi.MidiDevice.getMicrosecondPosition. Obtains the current position in the sequence, expressed in microseconds.
public Sequence	Returns: the current sequence, or `null` if no sequence is currently set getSequence() Obtains the sequence on which the Sequencer is currently operating.
public Sequencer.SyncMode	Returns: the current slave synchronization mode getSlaveSyncMode() Obtains the current slave synchronization mode for this sequencer.
public Sequencer.SyncMode[]	Returns: the available slave synchronization modes getSlaveSyncModes() Obtains the set of slave synchronization modes supported by the sequencer.
public float	Returns: tempo factor getTempoFactor() Returns the current tempo factor for the sequencer.
public float	Returns: the current tempo in beats per minute getTempoInBPM() Obtains the current tempo, expressed in beats per minute.
public float	Returns: the current tempo in microseconds per quarter note getTempoInMPQ() Obtains the current tempo, expressed in microseconds per quarter note.
public long	Returns: length of the sequence in ticks getTickLength() Obtains the length of the current sequence, expressed in MIDI ticks, or 0 if no sequence is set.
public long	Returns: current tick getTickPosition() Obtains the current position in the sequence, expressed in MIDI ticks.
public boolean	Returns: `true` if muted, `false` if not getTrackMute(int the track number. Tracks in the current sequence are numbered from 0 to the number of tracks in the sequence minus 1. track) Obtains the current mute state for a track.
public boolean	Returns: `true` if solo'd, `false` if not getTrackSolo(int the track number. Tracks in the current sequence are numbered from 0 to the number of tracks in the sequence minus 1. track) Obtains the current solo state for a track.
public boolean	Returns: `true` if the Sequencer is recording, otherwise `false` isRecording() Indicates whether the Sequencer is currently recording.
public boolean	Returns: `true` if the Sequencer is running, otherwise `false` isRunning() Indicates whether the Sequencer is currently running.
public void	recordDisable(Track the track to disable for recording, or `null` to disable recording for all tracks track) Disables recording to the specified track.
public void	recordEnable(Track the track to which events will be recorded track, int the channel on which events will be received. If -1 is specified for the channel value, the track will receive data from all channels. channel) Prepares the specified track for recording events received on a particular channel.
public int[]	Returns: the numbers of all the MIDI controllers whose changes will now be reported to the specified listener removeControllerEventListener(ControllerEventListener old listener listener, int[] the MIDI controller numbers for which change notification should be cancelled, or `null` to cancel for all controllers controllers) Removes a controller event listener's interest in one or more types of controller event.
public void	removeMetaEventListener(MetaEventListener the meta-event listener to remove 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 the number of times playback should loop back from the loop's end position to the loop's start position, or `LOOP_CONTINUOUSLY` to indicate that looping should continue until interrupted count) Sets the number of repetitions of the loop for playback.
public void	setLoopEndPoint(long the loop's ending position, in MIDI ticks (zero-based), or -1 to indicate the final tick tick) Sets the last MIDI tick that will be played in the loop.
public void	setLoopStartPoint(long the loop's starting position, in MIDI ticks (zero-based) tick) Sets the first MIDI tick that will be played in the loop.
public void	setMasterSyncMode(Sequencer.SyncMode the desired master synchronization mode sync) Sets the source of timing information used by this sequencer.
public void	setMicrosecondPosition(long desired position in microseconds microseconds) Sets the current position in the sequence, expressed in microseconds.
public void	setSequence(Sequence the sequence to be loaded sequence) Sets the current sequence on which the sequencer operates.
public void	setSequence(InputStream stream containing MIDI file data stream) Sets the current sequence on which the sequencer operates.
public void	setSlaveSyncMode(Sequencer.SyncMode the desired slave synchronization mode sync) Sets the slave synchronization mode for the sequencer.
public void	setTempoFactor(float the requested tempo scalar factor) Scales the sequencer's actual playback tempo by the factor provided.
public void	setTempoInBPM(float desired new tempo in beats per minute bpm) Sets the tempo in beats per minute.
public void	setTempoInMPQ(float desired new tempo in microseconds per quarter note mpq) Sets the tempo in microseconds per quarter note.
public void	setTickPosition(long the desired tick position tick) Sets the current sequencer position in MIDI ticks.
public void	setTrackMute(int the track number. Tracks in the current sequence are numbered from 0 to the number of tracks in the sequence minus 1. track, boolean the new mute state for the track. `true` implies the track should be muted, `false` implies the track should be unmuted. mute) Sets the mute state for a track.
public void	setTrackSolo(int the track number. Tracks in the current sequence are numbered from 0 to the number of tracks in the sequence minus 1. track, boolean the new solo state for the track. `true` implies the track should be solo'd, `false` implies the track should not be solo'd. solo) Sets the solo state for a track.
public void	start() Starts playback of the MIDI data in the currently loaded sequence.
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.
public void	stopRecording() Stops recording, if active.

Inherited from javax.sound.midi.MidiDevice:: close getDeviceInfo getMaxReceivers getMaxTransmitters getReceiver getReceivers getTransmitter getTransmitters isOpen open

Field Detail

LOOP_CONTINUOUSLY back to summary

LOOP_CONTINUOUSLY	back to summary
public static final int LOOP_CONTINUOUSLY A value indicating that looping should continue indefinitely rather than complete after a specific number of loops. Since 1.5 See Also `setLoopCount`

public static final int LOOP_CONTINUOUSLY

A value indicating that looping should continue indefinitely rather than complete after a specific number of loops.

Since: 1.5
See Also: setLoopCount

Method Detail

addControllerEventListener back to summary

addControllerEventListener	back to summary
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. 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. Parameters listener:ControllerEventListener the controller event listener to add to the list of registered listeners controllers:int[] the MIDI controller numbers for which change notification is requested Returns:int[] the numbers of all the MIDI controllers whose changes will now be reported to the specified listener See Also `removeControllerEventListener`, `ControllerEventListener`

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

Parameters

listener:ControllerEventListener: the controller event listener to add to the list of registered listeners
controllers:int[]: the MIDI controller numbers for which change notification is requested

Returns:int[]

the numbers of all the MIDI controllers whose changes will now be reported to the specified listener

addMetaEventListener back to summary

addMetaEventListener	back to summary
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. This method can fail if, for instance, this class of sequencer does not support meta-event notification. Parameters listener:MetaEventListener listener to add Returns:boolean `true` if the listener was successfully added, otherwise `false` See Also `removeMetaEventListener`, `MetaEventListener`, `MetaMessage`

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. This method can fail if, for instance, this class of sequencer does not support meta-event notification.

Parameters

listener:MetaEventListener: listener to add

Returns:boolean

true if the listener was successfully added, otherwise false

getLoopCount back to summary

getLoopCount	back to summary
public int getLoopCount() Obtains the number of repetitions for playback. Returns:int the number of loops after which playback plays to the end of the sequence Since 1.5 See Also `setLoopCount`, `start`

public int getLoopCount()

Obtains the number of repetitions for playback.

Returns:int: the number of loops after which playback plays to the end of the sequence
Since: 1.5
See Also: setLoopCount, start

getLoopEndPoint back to summary

getLoopEndPoint	back to summary
public long getLoopEndPoint() Obtains the end position of the loop, in MIDI ticks. Returns:long the end position of the loop, in MIDI ticks (zero-based), or -1 to indicate the end of the sequence Since 1.5 See Also `setLoopEndPoint`

public long getLoopEndPoint()

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

Returns:long: the end position of the loop, in MIDI ticks (zero-based), or -1 to indicate the end of the sequence
Since: 1.5
See Also: setLoopEndPoint

getLoopStartPoint back to summary

getLoopStartPoint	back to summary
public long getLoopStartPoint() Obtains the start position of the loop, in MIDI ticks. Returns:long the start position of the loop, in MIDI ticks (zero-based) Since 1.5 See Also `setLoopStartPoint`

public long getLoopStartPoint()

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

Returns:long: the start position of the loop, in MIDI ticks (zero-based)
Since: 1.5
See Also: setLoopStartPoint

getMasterSyncMode back to summary

getMasterSyncMode	back to summary
public Sequencer.SyncMode getMasterSyncMode() Obtains the current master synchronization mode for this sequencer. Returns:Sequencer.SyncMode the current master synchronization mode See Also `setMasterSyncMode(SyncMode)`, `getMasterSyncModes`

public Sequencer.SyncMode getMasterSyncMode()

Obtains the current master synchronization mode for this sequencer.

Returns:Sequencer.SyncMode: the current master synchronization mode
See Also: setMasterSyncMode(SyncMode), getMasterSyncModes

getMasterSyncModes back to summary

getMasterSyncModes	back to summary
public Sequencer.SyncMode[] getMasterSyncModes() Obtains the set of master synchronization modes supported by this sequencer. Returns:Sequencer.SyncMode[] the available master synchronization modes See Also `SyncMode#INTERNAL_CLOCK`, `SyncMode#MIDI_SYNC`, `SyncMode#MIDI_TIME_CODE`, `getMasterSyncMode`, `setMasterSyncMode(SyncMode)`

public Sequencer.SyncMode[] getMasterSyncModes()

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

Returns:Sequencer.SyncMode[]: the available master synchronization modes
See Also: SyncMode#INTERNAL_CLOCK, SyncMode#MIDI_SYNC, SyncMode#MIDI_TIME_CODE, getMasterSyncMode, setMasterSyncMode(SyncMode)

getMicrosecondLength	back to summary
public long getMicrosecondLength() Obtains the length of the current sequence, expressed in microseconds, or 0 if no sequence is set. Returns:long length of the sequence in microseconds

getMicrosecondLength

back to summary

public long getMicrosecondLength()

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

Returns:long: length of the sequence in microseconds

getMicrosecondPosition back to summary

getMicrosecondPosition	back to summary
public long getMicrosecondPosition() Redeclares javax.sound.midi.MidiDevice.getMicrosecondPosition. Obtains the current position in the sequence, expressed in microseconds. Returns:long the current position in microseconds Annotations @Override See Also `setMicrosecondPosition`

public long getMicrosecondPosition()

Redeclares javax.sound.midi.MidiDevice.getMicrosecondPosition.

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

Returns:long

the current position in microseconds

Annotations

@Override

See Also

setMicrosecondPosition

getSequence back to summary

getSequence	back to summary
public Sequence getSequence() Obtains the sequence on which the Sequencer is currently operating. This method can be called even if the `Sequencer` is closed. Returns:Sequence the current sequence, or `null` if no sequence is currently set

public Sequence getSequence()

Obtains the sequence on which the Sequencer is currently operating.

This method can be called even if the Sequencer is closed.

Returns:Sequence: the current sequence, or null if no sequence is currently set

getSlaveSyncMode back to summary

getSlaveSyncMode	back to summary
public Sequencer.SyncMode getSlaveSyncMode() Obtains the current slave synchronization mode for this sequencer. Returns:Sequencer.SyncMode the current slave synchronization mode See Also `setSlaveSyncMode(SyncMode)`, `getSlaveSyncModes`

public Sequencer.SyncMode getSlaveSyncMode()

Obtains the current slave synchronization mode for this sequencer.

Returns:Sequencer.SyncMode: the current slave synchronization mode
See Also: setSlaveSyncMode(SyncMode), getSlaveSyncModes

getSlaveSyncModes back to summary

getSlaveSyncModes	back to summary
public Sequencer.SyncMode[] getSlaveSyncModes() Obtains the set of slave synchronization modes supported by the sequencer. Returns:Sequencer.SyncMode[] the available slave synchronization modes See Also `SyncMode#MIDI_SYNC`, `SyncMode#MIDI_TIME_CODE`, `SyncMode#NO_SYNC`

public Sequencer.SyncMode[] getSlaveSyncModes()

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

Returns:Sequencer.SyncMode[]: the available slave synchronization modes
See Also: SyncMode#MIDI_SYNC, SyncMode#MIDI_TIME_CODE, SyncMode#NO_SYNC

getTempoFactor back to summary

getTempoFactor	back to summary
public float getTempoFactor() Returns the current tempo factor for the sequencer. The default is 1.0. Returns:float tempo factor See Also `setTempoFactor(float)`

public float getTempoFactor()

Returns the current tempo factor for the sequencer. The default is 1.0.

Returns:float: tempo factor
See Also: setTempoFactor(float)

getTempoInBPM back to summary

getTempoInBPM	back to summary
public float getTempoInBPM() Obtains the current tempo, expressed in beats per minute. The actual tempo of playback is the product of the returned value and the tempo factor. Returns:float the current tempo in beats per minute See Also `getTempoFactor`, `setTempoInBPM(float)`, `getTempoInMPQ`

public float getTempoInBPM()

Obtains the current tempo, expressed in beats per minute. The actual tempo of playback is the product of the returned value and the tempo factor.

Returns:float: the current tempo in beats per minute
See Also: getTempoFactor, setTempoInBPM(float), getTempoInMPQ

getTempoInMPQ back to summary

getTempoInMPQ	back to summary
public float getTempoInMPQ() Obtains the current tempo, expressed in microseconds per quarter note. The actual tempo of playback is the product of the returned value and the tempo factor. Returns:float the current tempo in microseconds per quarter note See Also `getTempoFactor`, `setTempoInMPQ(float)`, `getTempoInBPM`

public float getTempoInMPQ()

Obtains the current tempo, expressed in microseconds per quarter note. The actual tempo of playback is the product of the returned value and the tempo factor.

Returns:float: the current tempo in microseconds per quarter note
See Also: getTempoFactor, setTempoInMPQ(float), getTempoInBPM

getTickLength	back to summary
public long getTickLength() Obtains the length of the current sequence, expressed in MIDI ticks, or 0 if no sequence is set. Returns:long length of the sequence in ticks

getTickLength

back to summary

public long getTickLength()

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

Returns:long: length of the sequence in ticks

getTickPosition back to summary

getTickPosition	back to summary
public long getTickPosition() 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:long current tick See Also `setTickPosition`

public long getTickPosition()

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:long: current tick
See Also: setTickPosition

getTrackMute back to summary

getTrackMute	back to summary
public boolean getTrackMute(int 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. Parameters track:int the track number. Tracks in the current sequence are numbered from 0 to the number of tracks in the sequence minus 1. Returns:boolean `true` if muted, `false` if not

public boolean getTrackMute(int 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.

Parameters

track:int: the track number. Tracks in the current sequence are numbered from 0 to the number of tracks in the sequence minus 1.

Returns:boolean

true if muted, false if not

getTrackSolo back to summary

getTrackSolo	back to summary
public boolean getTrackSolo(int 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. Parameters track:int the track number. Tracks in the current sequence are numbered from 0 to the number of tracks in the sequence minus 1. Returns:boolean `true` if solo'd, `false` if not

public boolean getTrackSolo(int 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.

Parameters

track:int: the track number. Tracks in the current sequence are numbered from 0 to the number of tracks in the sequence minus 1.

Returns:boolean

true if solo'd, false if not

isRecording back to summary

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

public boolean isRecording()

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

Returns:boolean: true if the Sequencer is recording, otherwise false

isRunning back to summary

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

public boolean isRunning()

Indicates whether the Sequencer is currently running. The default is false. The Sequencer starts running when eitherstart or startRecording is called. isRunning then returns true until playback of the sequence completes or stop is called.

Returns:boolean: true if the Sequencer is running, otherwise false

recordDisable back to summary

recordDisable	back to summary
public void recordDisable(Track track) Disables recording to the specified track. Events will no longer be recorded into this track. Parameters track:Track the track to disable for recording, or `null` to disable recording for all tracks

public void recordDisable(Track track)

Disables recording to the specified track. Events will no longer be recorded into this track.

Parameters

track:Track: the track to disable for recording, or null to disable recording for all tracks

recordEnable	back to summary
public void recordEnable(Track track, int channel) Prepares the specified track for recording events received on a particular channel. Once enabled, a track will receive events when recording is active. Parameters track:Track the track to which events will be recorded channel:int the channel on which events will be received. If -1 is specified for the channel value, the track will receive data from all channels. Exceptions IllegalArgumentException: thrown if the track is not part of the current sequence

recordEnable

back to summary

public void recordEnable(Track track, int channel)

Prepares the specified track for recording events received on a particular channel. Once enabled, a track will receive events when recording is active.

Parameters

track:Track: the track to which events will be recorded
channel:int: the channel on which events will be received. If -1 is specified for the channel value, the track will receive data from all channels.

Exceptions

IllegalArgumentException:: thrown if the track is not part of the current sequence

removeControllerEventListener back to summary

removeControllerEventListener	back to summary
public int[] removeControllerEventListener(ControllerEventListener listener, int[] controllers) 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. Parameters listener:ControllerEventListener old listener controllers:int[] the MIDI controller numbers for which change notification should be cancelled, or `null` to cancel for all controllers Returns:int[] the numbers of all the MIDI controllers whose changes will now be reported to the specified listener See Also `addControllerEventListener`

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

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.

Parameters

listener:ControllerEventListener: old listener
controllers:int[]: the MIDI controller numbers for which change notification should be cancelled, or null to cancel for all controllers

Returns:int[]

the numbers of all the MIDI controllers whose changes will now be reported to the specified listener

See Also

addControllerEventListener

removeMetaEventListener back to summary

removeMetaEventListener	back to summary
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. Parameters listener:MetaEventListener the meta-event listener to remove See Also `addMetaEventListener`

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.

Parameters

listener:MetaEventListener: the meta-event listener to remove

See Also

addMetaEventListener

setLoopCount back to summary

setLoopCount	back to summary
public void setLoopCount(int count) 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:int the number of times playback should loop back from the loop's end position to the loop's start position, or `LOOP_CONTINUOUSLY` to indicate that looping should continue until interrupted Exceptions IllegalArgumentException: if `count` is negative and not equal to `LOOP_CONTINUOUSLY` Since 1.5 See Also `setLoopStartPoint`, `setLoopEndPoint`, `getLoopCount`, `start`

public void setLoopCount(int count)

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:int: the number of times playback should loop back from the loop's end position to the loop's start position, or LOOP_CONTINUOUSLY to indicate that looping should continue until interrupted

Exceptions

IllegalArgumentException:: if count is negative and not equal to LOOP_CONTINUOUSLY

Since

1.5

setLoopEndPoint back to summary

setLoopEndPoint	back to summary
public void setLoopEndPoint(long tick) Sets the last MIDI tick that will be played in the loop. If the loop count is 0, the loop end point has no effect and playback continues to play when reaching the loop end point. A value of -1 for the ending point indicates the last tick of the sequence. Otherwise, the ending point must be greater than or equal to the starting point, and it must fall within the size of the loaded sequence. A sequencer's loop end point defaults to -1, meaning the end of the sequence. Parameters tick:long the loop's ending position, in MIDI ticks (zero-based), or -1 to indicate the final tick Exceptions IllegalArgumentException: if the requested loop point cannot be set, usually because it falls outside the sequence's duration or because the ending point is before the starting point Since 1.5 See Also `setLoopStartPoint`, `setLoopCount`, `getLoopEndPoint`, `start`

public void setLoopEndPoint(long tick)

Sets the last MIDI tick that will be played in the loop. If the loop count is 0, the loop end point has no effect and playback continues to play when reaching the loop end point.

A value of -1 for the ending point indicates the last tick of the sequence. Otherwise, the ending point must be greater than or equal to the starting point, and it must fall within the size of the loaded sequence.

A sequencer's loop end point defaults to -1, meaning the end of the sequence.

Parameters

tick:long: the loop's ending position, in MIDI ticks (zero-based), or -1 to indicate the final tick

Exceptions

IllegalArgumentException:: if the requested loop point cannot be set, usually because it falls outside the sequence's duration or because the ending point is before the starting point

Since

1.5

setLoopStartPoint back to summary

setLoopStartPoint	back to summary
public void setLoopStartPoint(long tick) Sets the first MIDI tick that will be played in the loop. If the loop count is greater than 0, playback will jump to this point when reaching the loop end point. A value of 0 for the starting point means the beginning of the loaded sequence. The starting point must be lower than or equal to the ending point, and it must fall within the size of the loaded sequence. A sequencer's loop start point defaults to start of the sequence. Parameters tick:long the loop's starting position, in MIDI ticks (zero-based) Exceptions IllegalArgumentException: if the requested loop start point cannot be set, usually because it falls outside the sequence's duration or because the start point is after the end point Since 1.5 See Also `setLoopEndPoint`, `setLoopCount`, `getLoopStartPoint`, `start`

public void setLoopStartPoint(long tick)

Sets the first MIDI tick that will be played in the loop. If the loop count is greater than 0, playback will jump to this point when reaching the loop end point.

A value of 0 for the starting point means the beginning of the loaded sequence. The starting point must be lower than or equal to the ending point, and it must fall within the size of the loaded sequence.

A sequencer's loop start point defaults to start of the sequence.

Parameters

tick:long: the loop's starting position, in MIDI ticks (zero-based)

Exceptions

IllegalArgumentException:: if the requested loop start point cannot be set, usually because it falls outside the sequence's duration or because the start point is after the end point

Since

1.5

setMasterSyncMode back to summary

setMasterSyncMode	back to summary
public void setMasterSyncMode(Sequencer.SyncMode sync) 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 `getMasterSyncModes`. Parameters sync:Sequencer.SyncMode the desired master synchronization mode See Also `SyncMode#INTERNAL_CLOCK`, `SyncMode#MIDI_SYNC`, `SyncMode#MIDI_TIME_CODE`, `getMasterSyncMode`

public void setMasterSyncMode(Sequencer.SyncMode sync)

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

Parameters

sync:Sequencer.SyncMode: the desired master synchronization mode

setMicrosecondPosition back to summary

setMicrosecondPosition	back to summary
public void setMicrosecondPosition(long microseconds) Sets the current position in the sequence, expressed in microseconds. Parameters microseconds:long desired position in microseconds See Also `getMicrosecondPosition`

public void setMicrosecondPosition(long microseconds)

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

Parameters

microseconds:long: desired position in microseconds

See Also

getMicrosecondPosition

setSequence back to summary

setSequence	back to summary
public void setSequence(Sequence sequence) throws InvalidMidiDataException Sets the current sequence on which the sequencer operates. This method can be called even if the `Sequencer` is closed. Parameters sequence:Sequence the sequence to be loaded Exceptions InvalidMidiDataException: if the sequence contains invalid MIDI data, or is not supported

public void setSequence(Sequence sequence) throws InvalidMidiDataException

Sets the current sequence on which the sequencer operates.

This method can be called even if the Sequencer is closed.

Parameters

sequence:Sequence: the sequence to be loaded

Exceptions

InvalidMidiDataException:: if the sequence contains invalid MIDI data, or is not supported

setSequence back to summary

setSequence	back to summary
public void setSequence(InputStream stream) throws IOException, InvalidMidiDataException Sets the current sequence on which the sequencer operates. The stream must point to MIDI file data. This method can be called even if the `Sequencer` is closed. Parameters stream:InputStream stream containing MIDI file data Exceptions IOException: if an I/O exception occurs during reading of the stream InvalidMidiDataException: if invalid data is encountered in the stream, or the stream is not supported

public void setSequence(InputStream stream) throws IOException, InvalidMidiDataException

Sets the current sequence on which the sequencer operates. The stream must point to MIDI file data.

This method can be called even if the Sequencer is closed.

Parameters

stream:InputStream: stream containing MIDI file data

Exceptions

IOException:: if an I/O exception occurs during reading of the stream
InvalidMidiDataException:: if invalid data is encountered in the stream, or the stream is not supported

setSlaveSyncMode back to summary

setSlaveSyncMode	back to summary
public void setSlaveSyncMode(Sequencer.SyncMode sync) 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 `getSlaveSyncModes`. Parameters sync:Sequencer.SyncMode the desired slave synchronization mode See Also `SyncMode#MIDI_SYNC`, `SyncMode#MIDI_TIME_CODE`, `SyncMode#NO_SYNC`, `getSlaveSyncModes`

public void setSlaveSyncMode(Sequencer.SyncMode sync)

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

Parameters

sync:Sequencer.SyncMode: the desired slave synchronization mode

setTempoFactor back to summary

setTempoFactor	back to summary
public void setTempoFactor(float factor) 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 `getTempoInMPQ` and `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:float the requested tempo scalar See Also `getTempoFactor`

public void setTempoFactor(float factor)

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 getTempoInMPQ and 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:float: the requested tempo scalar

See Also

getTempoFactor

setTempoInBPM back to summary

setTempoInBPM	back to summary
public void setTempoInBPM(float bpm) Sets the tempo in beats per minute. The actual tempo of playback is the product of the specified value and the tempo factor. Parameters bpm:float desired new tempo in beats per minute See Also `getTempoFactor`, `setTempoInMPQ(float)`, `getTempoInBPM`

public void setTempoInBPM(float bpm)

Sets the tempo in beats per minute. The actual tempo of playback is the product of the specified value and the tempo factor.

Parameters

bpm:float: desired new tempo in beats per minute

setTempoInMPQ back to summary

setTempoInMPQ	back to summary
public void setTempoInMPQ(float mpq) Sets the tempo in microseconds per quarter note. The actual tempo of playback is the product of the specified value and the tempo factor. Parameters mpq:float desired new tempo in microseconds per quarter note See Also `getTempoFactor`, `setTempoInBPM(float)`, `getTempoInMPQ`

public void setTempoInMPQ(float mpq)

Sets the tempo in microseconds per quarter note. The actual tempo of playback is the product of the specified value and the tempo factor.

Parameters

mpq:float: desired new tempo in microseconds per quarter note

setTickPosition back to summary

setTickPosition	back to summary
public void setTickPosition(long tick) Sets the current sequencer position in MIDI ticks. Parameters tick:long the desired tick position See Also `getTickPosition`

public void setTickPosition(long tick)

Sets the current sequencer position in MIDI ticks.

Parameters

tick:long: the desired tick position

See Also

getTickPosition

setTrackMute back to summary

setTrackMute	back to summary
public void setTrackMute(int track, boolean mute) 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 `getTrackMute`. Parameters track:int the track number. Tracks in the current sequence are numbered from 0 to the number of tracks in the sequence minus 1. mute:boolean the new mute state for the track. `true` implies the track should be muted, `false` implies the track should be unmuted. See Also `getSequence`

public void setTrackMute(int track, boolean mute)

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

Parameters

track:int: the track number. Tracks in the current sequence are numbered from 0 to the number of tracks in the sequence minus 1.
mute:boolean: the new mute state for the track. true implies the track should be muted, false implies the track should be unmuted.

See Also

getSequence

setTrackSolo back to summary

setTrackSolo	back to summary
public void setTrackSolo(int track, boolean solo) 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 `getTrackSolo`. Parameters track:int the track number. Tracks in the current sequence are numbered from 0 to the number of tracks in the sequence minus 1. solo:boolean 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 `getSequence`

public void setTrackSolo(int track, boolean solo)

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

Parameters

track:int: the track number. Tracks in the current sequence are numbered from 0 to the number of tracks in the sequence minus 1.
solo:boolean: 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

getSequence

start back to summary

start	back to summary
public void start() 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. Exceptions IllegalStateException: if the `Sequencer` is closed See Also `setLoopStartPoint`, `setLoopEndPoint`, `setLoopCount`, `stop`

public void start()

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.

Exceptions

IllegalStateException:: if the Sequencer is closed

startRecording back to summary

startRecording	back to summary
public void startRecording() Starts recording and playback of MIDI data. Data is recorded to all enabled tracks, on the channel(s) for which they were enabled. Recording begins at the current position of the sequencer. Any events already in the track are overwritten for the duration of the recording session. Events from the currently loaded sequence, if any, are delivered to the sequencer's transmitter(s) along with messages received during recording. Note that tracks are not by default enabled for recording. In order to record MIDI data, at least one track must be specifically enabled for recording. Exceptions IllegalStateException: if the `Sequencer` is closed See Also `recordEnable`, `recordDisable`

public void startRecording()

Starts recording and playback of MIDI data. Data is recorded to all enabled tracks, on the channel(s) for which they were enabled. Recording begins at the current position of the sequencer. Any events already in the track are overwritten for the duration of the recording session. Events from the currently loaded sequence, if any, are delivered to the sequencer's transmitter(s) along with messages received during recording.

Note that tracks are not by default enabled for recording. In order to record MIDI data, at least one track must be specifically enabled for recording.

Exceptions

IllegalStateException:: if the Sequencer is closed

See Also

recordEnable, recordDisable

stop back to summary

stop	back to summary
public void stop() Stops recording, if active, and playback of the currently loaded sequence, if any. Exceptions IllegalStateException: if the `Sequencer` is closed See Also `start`, `isRunning`

public void stop()

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

Exceptions

IllegalStateException:: if the Sequencer is closed

See Also

start, isRunning

stopRecording back to summary

stopRecording	back to summary
public void stopRecording() Stops recording, if active. Playback of the current sequence continues. Exceptions IllegalStateException: if the `Sequencer` is closed See Also `startRecording`, `isRecording`

public void stopRecording()

Stops recording, if active. Playback of the current sequence continues.

Exceptions

IllegalStateException:: if the Sequencer is closed

See Also

startRecording, isRecording

javax.sound.midi back to summary

public Class Sequencer.SyncMode

Class Inheritance

extends Object

java.lang.Object
javax.sound.midi.Sequencer.SyncMode

A SyncMode object represents one of the ways in which a MIDI sequencer's notion of time can be synchronized with a master or slave device. If the sequencer is being synchronized to a master, the sequencer revises its current time in response to messages from the master. If the sequencer has a slave, the sequencer similarly sends messages to control the slave's timing.

There are three predefined modes that specify possible masters for a sequencer: INTERNAL_CLOCK, MIDI_SYNC, and MIDI_TIME_CODE. The latter two work if the sequencer receives MIDI messages from another device. In these two modes, the sequencer's time gets reset based on system real-time timing clock messages or MIDI time code (MTC) messages, respectively. These two modes can also be used as slave modes, in which case the sequencer sends the corresponding types of MIDI messages to its receiver (whether or not the sequencer is also receiving them from a master). A fourth mode, NO_SYNC, is used to indicate that the sequencer should not control its receiver's timing.

See Also: Sequencer#setMasterSyncMode(SyncMode), Sequencer#setSlaveSyncMode(SyncMode)

Field Summary

Modifier and Type	Field and Description
public static final Sequencer.SyncMode	INTERNAL_CLOCK A master synchronization mode that makes the sequencer get its timing information from its internal clock.
public static final Sequencer.SyncMode	MIDI_SYNC A master or slave synchronization mode that specifies the use of MIDI clock messages.
public static final Sequencer.SyncMode	MIDI_TIME_CODE A master or slave synchronization mode that specifies the use of MIDI Time Code.
private final String	name Synchronization mode name.
public static final Sequencer.SyncMode	NO_SYNC A slave synchronization mode indicating that no timing information should be sent to the receiver.

Constructor Summary

Access	Constructor and Description
protected	SyncMode(String name of the synchronization mode name) Constructs a synchronization mode.

Method Summary

Modifier and Type	Method and Description
public final boolean	Returns: `true` if the specified object is equal to this synchronization mode; `false` otherwise equals(Object the reference object with which to compare obj) Overrides java.lang.Object.equals. Indicates whether the specified object is equal to this synchronization mode, returning `true` if the objects are the same.
public final int	Returns: a hash code value for this synchronization mode hashCode() Overrides java.lang.Object.hashCode. Returns a hash code value for this synchronization mode.
public final String	Returns: a string representation of the synchronization mode toString() Overrides java.lang.Object.toString. Returns mode's name as the string representation of the synchronization mode.

Inherited from java.lang.Object:: clone finalize getClass notify notifyAll wait wait wait

Field Detail

INTERNAL_CLOCK	back to summary
public static final Sequencer.SyncMode INTERNAL_CLOCK A master synchronization mode that makes the sequencer get its timing information from its internal clock. This is not a legal slave sync mode.

MIDI_SYNC

back to summary

public static final Sequencer.SyncMode MIDI_SYNC

A master or slave synchronization mode that specifies the use of MIDI clock messages. If this mode is used as the master sync mode, the sequencer gets its timing information from system real-time MIDI clock messages. This mode only applies as the master sync mode for sequencers that are also MIDI receivers. If this is the slave sync mode, the sequencer sends system real-time MIDI clock messages to its receiver. MIDI clock messages are sent at a rate of 24 per quarter note.

MIDI_TIME_CODE

back to summary

public static final Sequencer.SyncMode MIDI_TIME_CODE

A master or slave synchronization mode that specifies the use of MIDI Time Code. If this mode is used as the master sync mode, the sequencer gets its timing information from MIDI Time Code messages. This mode only applies as the master sync mode to sequencers that are also MIDI receivers. If this mode is used as the slave sync mode, the sequencer sends MIDI Time Code messages to its receiver. (See the MIDI 1.0 Detailed Specification for a description of MIDI Time Code.)

name	back to summary
private final String name Synchronization mode name.

NO_SYNC	back to summary
public static final Sequencer.SyncMode NO_SYNC A slave synchronization mode indicating that no timing information should be sent to the receiver. This is not a legal master sync mode.