| |||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
Sequencer sequencer = MidiSystem.getSequencer();
Based on 67 examples
public interface Sequencer extends MidiDevice
A hardware or software device that plays back a MIDI
{@link Sequence sequence}
is known as a sequencer.
A MIDI sequence contains lists of time-stamped MIDI data, such as
might be read from a standard MIDI file. Most
sequencers also provide functions for creating and editing sequences.
The Sequencer
interface includes methods for the following
basic MIDI sequencer operations:
Sequencer
has access to:
Nested Class Summary | |
---|---|
static class |
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. |
Nested classes/interfaces inherited from class javax.sound.midi.MidiDevice |
---|
MidiDevice.Info |
Field Summary | |
---|---|
static int |
LOOP_CONTINUOUSLY
A value indicating that looping should continue indefinitely rather than complete after a specific number of loops. |
Method Summary | |
---|---|
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. |
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. |
int |
Obtains the number of repetitions for playback. |
long |
Obtains the end position of the loop, in MIDI ticks. |
long |
Obtains the start position of the loop, in MIDI ticks. |
Sequencer.SyncMode |
Obtains the current master synchronization mode for this sequencer. |
Sequencer.SyncMode[] |
Obtains the set of master synchronization modes supported by this sequencer. |
long |
Obtains the length of the current sequence, expressed in microseconds, or 0 if no sequence is set. |
long |
Obtains the current position in the sequence, expressed in microseconds. |
Sequence |
Obtains the sequence on which the Sequencer is currently operating. |
Sequencer.SyncMode |
Obtains the current slave synchronization mode for this sequencer. |
Sequencer.SyncMode[] |
Obtains the set of slave synchronization modes supported by the sequencer. |
float |
Returns the current tempo factor for the sequencer. |
float |
Obtains the current tempo, expressed in beats per minute. |
float |
Obtains the current tempo, expressed in microseconds per quarter note. |
long |
Obtains the length of the current sequence, expressed in MIDI ticks, or 0 if no sequence is set. |
long |
Obtains the current position in the sequence, expressed in MIDI ticks. |
boolean |
getTrackMute(int track) Obtains the current mute state for a track. |
boolean |
getTrackSolo(int track) Obtains the current solo state for a track. |
boolean |
Indicates whether the Sequencer is currently recording. |
boolean |
Indicates whether the Sequencer is currently running. |
void |
recordDisable(Track track) Disables recording to the specified track. |
void |
recordEnable(Track track, int channel) Prepares the specified track for recording events received on a particular channel. |
int[] |
removeControllerEventListener(ControllerEventListener listener, int[] controllers) Removes a controller event listener's interest in one or more types of controller event. |
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. |
void |
setLoopCount(int count) Sets the number of repetitions of the loop for playback. |
void |
setLoopEndPoint(long tick) Sets the last MIDI tick that will be played in the loop. |
void |
setLoopStartPoint(long tick) Sets the first MIDI tick that will be played in the loop. |
void |
Sets the source of timing information used by this sequencer. |
void |
setMicrosecondPosition(long microseconds) Sets the current position in the sequence, expressed in microseconds |
void |
setSequence(InputStream stream) Sets the current sequence on which the sequencer operates. |
void |
setSequence(Sequence sequence) Sets the current sequence on which the sequencer operates. |
void |
Sets the slave synchronization mode for the sequencer. |
void |
setTempoFactor(float factor) Scales the sequencer's actual playback tempo by the factor provided. |
void |
setTempoInBPM(float bpm) Sets the tempo in beats per minute. |
void |
setTempoInMPQ(float mpq) Sets the tempo in microseconds per quarter note. |
void |
setTickPosition(long tick) Sets the current sequencer position in MIDI ticks |
void |
setTrackMute(int track, boolean mute) Sets the mute state for a track. |
void |
setTrackSolo(int track, boolean solo) Sets the solo state for a track. |
void |
start() Starts playback of the MIDI data in the currently loaded sequence. |
void |
Starts recording and playback of MIDI data. |
void |
stop() Stops recording, if active, and playback of the currently loaded sequence, if any. |
void |
Stops recording, if active. |
Methods inherited from class javax.sound.midi.MidiDevice |
---|
close, getDeviceInfo, getMaxReceivers, getMaxTransmitters, getMicrosecondPosition, getReceiver, getReceivers, getTransmitter, getTransmitters, isOpen, open |
Field Detail |
---|
public static final int LOOP_CONTINUOUSLY
Method Detail |
---|
public int[] addControllerEventListener(ControllerEventListener listener, int[] controllers)
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.
listener
- the controller event listener to add to the list of
registered listenerscontrollers
- the MIDI controller numbers for which change
notification is requestedpublic boolean addMetaEventListener(MetaEventListener listener)
listener
- listener to addtrue
if the listener was successfully added,
otherwise false
public int getLoopCount()
public long getLoopEndPoint()
public long getLoopStartPoint()
public Sequencer.SyncMode getMasterSyncMode()
public Sequencer.SyncMode[] getMasterSyncModes()
public long getMicrosecondLength()
public long getMicrosecondPosition()
public Sequence getSequence()
This method can be called even if the
Sequencer
is closed.
null
if no sequence is currently set.public Sequencer.SyncMode getSlaveSyncMode()
public Sequencer.SyncMode[] getSlaveSyncModes()
public float getTempoFactor()
public float getTempoInBPM()
public float getTempoInMPQ()
public long getTickLength()
public long getTickPosition()
{@link Sequence}
.)
public boolean getTrackMute(int track)
track
- the track number. Tracks in the current sequence are numbered
from 0 to the number of tracks in the sequence minus 1.true
if muted, false
if not.public boolean getTrackSolo(int track)
track
- the track number. Tracks in the current sequence are numbered
from 0 to the number of tracks in the sequence minus 1.true
if solo'd, false
if not.public boolean isRecording()
false
.
The Sequencer begins recording when {@link #startRecording}
is called,
and then returns true
until {@link #stop}
or {@link #stopRecording}
is called.
true
if the Sequencer is recording, otherwise false
public boolean isRunning()
false
.
The Sequencer starts running when either {@link #start}
or {@link #startRecording}
is called. isRunning
then returns true
until playback of the
sequence completes or {@link #stop}
is called.
true
if the Sequencer is running, otherwise false
public void recordDisable(Track track)
track
- the track to disable for recording, or null
to disable
recording for all tracks.public void recordEnable(Track track, int channel)
track
- the track to which events will be recordedchannel
- the channel on which events will be received. If -1 is specified
for the channel value, the track will receive data from all channels.public int[] removeControllerEventListener(ControllerEventListener listener, int[] controllers)
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.
listener
- old listenercontrollers
- the MIDI controller numbers for which change
notification should be cancelled, or null
to cancel
for all controllerspublic void removeMetaEventListener(MetaEventListener listener)
listener
- the meta-event listener to removepublic void setLoopCount(int count)
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.
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 interruptedpublic void setLoopEndPoint(long tick)
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.
tick
- the loop's ending position,
in MIDI ticks (zero-based), or
-1 to indicate the final tickpublic void setLoopStartPoint(long tick)
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.
tick
- the loop's starting position,
in MIDI ticks (zero-based)public void setMasterSyncMode(Sequencer.SyncMode sync)
sync
. The sync
argument must be one
of the supported modes, as returned by
{@link #getMasterSyncModes}
.
sync
- the desired master synchronization modepublic void setMicrosecondPosition(long microseconds)
microseconds
- desired position in microsecondspublic void setSequence(InputStream stream) throws IOException, InvalidMidiDataException
This method can be called even if the
Sequencer
is closed.
stream
- stream containing MIDI file data.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(Sequence sequence) throws InvalidMidiDataException
This method can be called even if the
Sequencer
is closed.
sequence
- the sequence to be loaded.InvalidMidiDataException
- if the sequence contains invalid
MIDI data, or is not supported.public void setSlaveSyncMode(Sequencer.SyncMode sync)
sync
argument must be one
of the supported modes, as returned by
{@link #getSlaveSyncModes}
.
sync
- the desired slave synchronization modepublic void setTempoFactor(float factor)
{@link #getTempoInMPQ}
and {@link #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.
factor
- the requested tempo scalarpublic void setTempoInBPM(float bpm)
bpm
- desired new tempo in beats per minutepublic void setTempoInMPQ(float mpq)
mpq
- desired new tempo in microseconds per quarter note.public void setTickPosition(long tick)
tick
- the desired tick positionpublic void setTrackMute(int track, boolean mute)
{@link #getTrackMute}
.
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.public void setTrackSolo(int track, boolean solo)
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 {@link #getTrackSolo}
.
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.public void start()
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.
public void startRecording()
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.
public void stop()
public void stopRecording()
| |||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |