Home » openjdk-7 » javax.sound » midi » [javadoc | source]
javax.sound.midi
public interface: Sequencer [javadoc | source]

All Implemented Interfaces:
    MidiDevice

A hardware or software device that plays back a MIDI 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:

In addition, the following operations are supported, either directly, or indirectly through objects that the Sequencer has access to:
Nested Class Summary:
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. 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. 

Field Summary
public static final  int LOOP_CONTINUOUSLY    A value indicating that looping should continue indefinitely rather than complete after a specific number of loops. 
Method from javax.sound.midi.Sequencer Summary:
addControllerEventListener,   addMetaEventListener,   getLoopCount,   getLoopEndPoint,   getLoopStartPoint,   getMasterSyncMode,   getMasterSyncModes,   getMicrosecondLength,   getMicrosecondPosition,   getSequence,   getSlaveSyncMode,   getSlaveSyncModes,   getTempoFactor,   getTempoInBPM,   getTempoInMPQ,   getTickLength,   getTickPosition,   getTrackMute,   getTrackSolo,   isRecording,   isRunning,   recordDisable,   recordEnable,   removeControllerEventListener,   removeMetaEventListener,   setLoopCount,   setLoopEndPoint,   setLoopStartPoint,   setMasterSyncMode,   setMicrosecondPosition,   setSequence,   setSequence,   setSlaveSyncMode,   setTempoFactor,   setTempoInBPM,   setTempoInMPQ,   setTickPosition,   setTrackMute,   setTrackSolo,   start,   startRecording,   stop,   stopRecording
Method from javax.sound.midi.Sequencer Detail:
 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.
 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.
 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()
    Obtains the current position in the sequence, expressed in
microseconds.
 public Sequence getSequence()
    Obtains the sequence on which the Sequencer is currently operating.


    This method can be called even if the
Sequencer is closed.
 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.  The default is
1.0.
 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.
 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.
 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.  (The duration of a tick in seconds is determined both by
the tempo and by the timing resolution stored in the
Sequence .)
 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.
 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.
 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.
 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.
 public  void recordDisable(Track track)
    Disables recording to the specified track.  Events will no longer be recorded
into this track.
 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.
 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.
 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.
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.
 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.
 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.
 public  void setMasterSyncMode(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 .
 public  void setMicrosecondPosition(long microseconds)
    Sets the current position in the sequence, expressed in microseconds
 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.
 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.
 public  void setSlaveSyncMode(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 .
 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.
 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.
 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.
 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.  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 .
 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 .
 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.
 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.
 public  void stop()
    Stops recording, if active, and playback of the currently loaded sequence,
if any.
 public  void stopRecording()
    Stops recording, if active.  Playback of the current sequence continues.