2085 lines
72 KiB
Java
2085 lines
72 KiB
Java
/*
|
|
* Copyright (c) 2003, 2016, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation. Oracle designates this
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Oracle in the LICENSE file that accompanied this code.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
package com.sun.media.sound;
|
|
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.WeakHashMap;
|
|
|
|
import javax.sound.midi.*;
|
|
|
|
|
|
/**
|
|
* A Real Time Sequencer
|
|
*
|
|
* @author Florian Bomers
|
|
*/
|
|
|
|
/* TODO:
|
|
* - rename PlayThread to PlayEngine (because isn't a thread)
|
|
*/
|
|
final class RealTimeSequencer extends AbstractMidiDevice
|
|
implements Sequencer, AutoConnectSequencer {
|
|
|
|
// STATIC VARIABLES
|
|
|
|
/** debugging flags */
|
|
private final static boolean DEBUG_PUMP = false;
|
|
private final static boolean DEBUG_PUMP_ALL = false;
|
|
|
|
/**
|
|
* Event Dispatcher thread. Should be using a shared event
|
|
* dispatcher instance with a factory in EventDispatcher
|
|
*/
|
|
private static final Map<ThreadGroup, EventDispatcher> dispatchers =
|
|
new WeakHashMap<>();
|
|
|
|
/**
|
|
* All RealTimeSequencers share this info object.
|
|
*/
|
|
static final RealTimeSequencerInfo info = new RealTimeSequencerInfo();
|
|
|
|
|
|
private static final Sequencer.SyncMode[] masterSyncModes = { Sequencer.SyncMode.INTERNAL_CLOCK };
|
|
private static final Sequencer.SyncMode[] slaveSyncModes = { Sequencer.SyncMode.NO_SYNC };
|
|
|
|
private static final Sequencer.SyncMode masterSyncMode = Sequencer.SyncMode.INTERNAL_CLOCK;
|
|
private static final Sequencer.SyncMode slaveSyncMode = Sequencer.SyncMode.NO_SYNC;
|
|
|
|
|
|
/**
|
|
* Sequence on which this sequencer is operating.
|
|
*/
|
|
private Sequence sequence = null;
|
|
|
|
// caches
|
|
|
|
/**
|
|
* Same for setTempoInMPQ...
|
|
* -1 means not set.
|
|
*/
|
|
private double cacheTempoMPQ = -1;
|
|
|
|
|
|
/**
|
|
* cache value for tempo factor until sequence is set
|
|
* -1 means not set.
|
|
*/
|
|
private float cacheTempoFactor = -1;
|
|
|
|
|
|
/** if a particular track is muted */
|
|
private boolean[] trackMuted = null;
|
|
/** if a particular track is solo */
|
|
private boolean[] trackSolo = null;
|
|
|
|
/** tempo cache for getMicrosecondPosition */
|
|
private final MidiUtils.TempoCache tempoCache = new MidiUtils.TempoCache();
|
|
|
|
/**
|
|
* True if the sequence is running.
|
|
*/
|
|
private volatile boolean running;
|
|
|
|
|
|
/** the thread for pushing out the MIDI messages */
|
|
private PlayThread playThread;
|
|
|
|
|
|
/**
|
|
* True if we are recording
|
|
*/
|
|
private volatile boolean recording;
|
|
|
|
|
|
/**
|
|
* List of tracks to which we're recording
|
|
*/
|
|
private final List recordingTracks = new ArrayList();
|
|
|
|
|
|
private long loopStart = 0;
|
|
private long loopEnd = -1;
|
|
private int loopCount = 0;
|
|
|
|
|
|
/**
|
|
* Meta event listeners
|
|
*/
|
|
private final ArrayList metaEventListeners = new ArrayList();
|
|
|
|
|
|
/**
|
|
* Control change listeners
|
|
*/
|
|
private final ArrayList controllerEventListeners = new ArrayList();
|
|
|
|
|
|
/** automatic connection support */
|
|
private boolean autoConnect = false;
|
|
|
|
/** if we need to autoconnect at next open */
|
|
private boolean doAutoConnectAtNextOpen = false;
|
|
|
|
/** the receiver that this device is auto-connected to */
|
|
Receiver autoConnectedReceiver = null;
|
|
|
|
|
|
/* ****************************** CONSTRUCTOR ****************************** */
|
|
|
|
RealTimeSequencer() throws MidiUnavailableException {
|
|
super(info);
|
|
|
|
if (Printer.trace) Printer.trace(">> RealTimeSequencer CONSTRUCTOR");
|
|
if (Printer.trace) Printer.trace("<< RealTimeSequencer CONSTRUCTOR completed");
|
|
}
|
|
|
|
|
|
/* ****************************** SEQUENCER METHODS ******************** */
|
|
|
|
public synchronized void setSequence(Sequence sequence)
|
|
throws InvalidMidiDataException {
|
|
|
|
if (Printer.trace) Printer.trace(">> RealTimeSequencer: setSequence(" + sequence +")");
|
|
|
|
if (sequence != this.sequence) {
|
|
if (this.sequence != null && sequence == null) {
|
|
setCaches();
|
|
stop();
|
|
// initialize some non-cached values
|
|
trackMuted = null;
|
|
trackSolo = null;
|
|
loopStart = 0;
|
|
loopEnd = -1;
|
|
loopCount = 0;
|
|
if (getDataPump() != null) {
|
|
getDataPump().setTickPos(0);
|
|
getDataPump().resetLoopCount();
|
|
}
|
|
}
|
|
|
|
if (playThread != null) {
|
|
playThread.setSequence(sequence);
|
|
}
|
|
|
|
// store this sequence (do not copy - we want to give the possibility
|
|
// of modifying the sequence at runtime)
|
|
this.sequence = sequence;
|
|
|
|
if (sequence != null) {
|
|
tempoCache.refresh(sequence);
|
|
// rewind to the beginning
|
|
setTickPosition(0);
|
|
// propagate caches
|
|
propagateCaches();
|
|
}
|
|
}
|
|
else if (sequence != null) {
|
|
tempoCache.refresh(sequence);
|
|
if (playThread != null) {
|
|
playThread.setSequence(sequence);
|
|
}
|
|
}
|
|
|
|
if (Printer.trace) Printer.trace("<< RealTimeSequencer: setSequence(" + sequence +") completed");
|
|
}
|
|
|
|
|
|
public synchronized void setSequence(InputStream stream) throws IOException, InvalidMidiDataException {
|
|
|
|
if (Printer.trace) Printer.trace(">> RealTimeSequencer: setSequence(" + stream +")");
|
|
|
|
if (stream == null) {
|
|
setSequence((Sequence) null);
|
|
return;
|
|
}
|
|
|
|
Sequence seq = MidiSystem.getSequence(stream); // can throw IOException, InvalidMidiDataException
|
|
|
|
setSequence(seq);
|
|
|
|
if (Printer.trace) Printer.trace("<< RealTimeSequencer: setSequence(" + stream +") completed");
|
|
|
|
}
|
|
|
|
|
|
public Sequence getSequence() {
|
|
return sequence;
|
|
}
|
|
|
|
|
|
public synchronized void start() {
|
|
if (Printer.trace) Printer.trace(">> RealTimeSequencer: start()");
|
|
|
|
// sequencer not open: throw an exception
|
|
if (!isOpen()) {
|
|
throw new IllegalStateException("sequencer not open");
|
|
}
|
|
|
|
// sequence not available: throw an exception
|
|
if (sequence == null) {
|
|
throw new IllegalStateException("sequence not set");
|
|
}
|
|
|
|
// already running: return quietly
|
|
if (running == true) {
|
|
return;
|
|
}
|
|
|
|
// start playback
|
|
implStart();
|
|
|
|
if (Printer.trace) Printer.trace("<< RealTimeSequencer: start() completed");
|
|
}
|
|
|
|
|
|
public synchronized void stop() {
|
|
if (Printer.trace) Printer.trace(">> RealTimeSequencer: stop()");
|
|
|
|
if (!isOpen()) {
|
|
throw new IllegalStateException("sequencer not open");
|
|
}
|
|
stopRecording();
|
|
|
|
// not running; just return
|
|
if (running == false) {
|
|
if (Printer.trace) Printer.trace("<< RealTimeSequencer: stop() not running!");
|
|
return;
|
|
}
|
|
|
|
// stop playback
|
|
implStop();
|
|
|
|
if (Printer.trace) Printer.trace("<< RealTimeSequencer: stop() completed");
|
|
}
|
|
|
|
|
|
public boolean isRunning() {
|
|
return running;
|
|
}
|
|
|
|
|
|
public void startRecording() {
|
|
if (!isOpen()) {
|
|
throw new IllegalStateException("Sequencer not open");
|
|
}
|
|
|
|
start();
|
|
recording = true;
|
|
}
|
|
|
|
|
|
public void stopRecording() {
|
|
if (!isOpen()) {
|
|
throw new IllegalStateException("Sequencer not open");
|
|
}
|
|
recording = false;
|
|
}
|
|
|
|
|
|
public boolean isRecording() {
|
|
return recording;
|
|
}
|
|
|
|
|
|
public void recordEnable(Track track, int channel) {
|
|
if (!findTrack(track)) {
|
|
throw new IllegalArgumentException("Track does not exist in the current sequence");
|
|
}
|
|
|
|
synchronized(recordingTracks) {
|
|
RecordingTrack rc = RecordingTrack.get(recordingTracks, track);
|
|
if (rc != null) {
|
|
rc.channel = channel;
|
|
} else {
|
|
recordingTracks.add(new RecordingTrack(track, channel));
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
public void recordDisable(Track track) {
|
|
synchronized(recordingTracks) {
|
|
RecordingTrack rc = RecordingTrack.get(recordingTracks, track);
|
|
if (rc != null) {
|
|
recordingTracks.remove(rc);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
private boolean findTrack(Track track) {
|
|
boolean found = false;
|
|
if (sequence != null) {
|
|
Track[] tracks = sequence.getTracks();
|
|
for (int i = 0; i < tracks.length; i++) {
|
|
if (track == tracks[i]) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return found;
|
|
}
|
|
|
|
|
|
public float getTempoInBPM() {
|
|
if (Printer.trace) Printer.trace(">> RealTimeSequencer: getTempoInBPM() ");
|
|
|
|
return (float) MidiUtils.convertTempo(getTempoInMPQ());
|
|
}
|
|
|
|
|
|
public void setTempoInBPM(float bpm) {
|
|
if (Printer.trace) Printer.trace(">> RealTimeSequencer: setTempoInBPM() ");
|
|
if (bpm <= 0) {
|
|
// should throw IllegalArgumentException
|
|
bpm = 1.0f;
|
|
}
|
|
|
|
setTempoInMPQ((float) MidiUtils.convertTempo((double) bpm));
|
|
}
|
|
|
|
|
|
public float getTempoInMPQ() {
|
|
if (Printer.trace) Printer.trace(">> RealTimeSequencer: getTempoInMPQ() ");
|
|
|
|
if (needCaching()) {
|
|
// if the sequencer is closed, return cached value
|
|
if (cacheTempoMPQ != -1) {
|
|
return (float) cacheTempoMPQ;
|
|
}
|
|
// if sequence is set, return current tempo
|
|
if (sequence != null) {
|
|
return tempoCache.getTempoMPQAt(getTickPosition());
|
|
}
|
|
|
|
// last resort: return a standard tempo: 120bpm
|
|
return (float) MidiUtils.DEFAULT_TEMPO_MPQ;
|
|
}
|
|
return (float)getDataPump().getTempoMPQ();
|
|
}
|
|
|
|
|
|
public void setTempoInMPQ(float mpq) {
|
|
if (mpq <= 0) {
|
|
// should throw IllegalArgumentException
|
|
mpq = 1.0f;
|
|
}
|
|
|
|
if (Printer.trace) Printer.trace(">> RealTimeSequencer: setTempoInMPQ() ");
|
|
|
|
if (needCaching()) {
|
|
// cache the value
|
|
cacheTempoMPQ = mpq;
|
|
} else {
|
|
// set the native tempo in MPQ
|
|
getDataPump().setTempoMPQ(mpq);
|
|
|
|
// reset the tempoInBPM and tempoInMPQ values so we won't use them again
|
|
cacheTempoMPQ = -1;
|
|
}
|
|
}
|
|
|
|
|
|
public void setTempoFactor(float factor) {
|
|
if (factor <= 0) {
|
|
// should throw IllegalArgumentException
|
|
return;
|
|
}
|
|
|
|
if (Printer.trace) Printer.trace(">> RealTimeSequencer: setTempoFactor() ");
|
|
|
|
if (needCaching()) {
|
|
cacheTempoFactor = factor;
|
|
} else {
|
|
getDataPump().setTempoFactor(factor);
|
|
// don't need cache anymore
|
|
cacheTempoFactor = -1;
|
|
}
|
|
}
|
|
|
|
|
|
public float getTempoFactor() {
|
|
if (Printer.trace) Printer.trace(">> RealTimeSequencer: getTempoFactor() ");
|
|
|
|
if (needCaching()) {
|
|
if (cacheTempoFactor != -1) {
|
|
return cacheTempoFactor;
|
|
}
|
|
return 1.0f;
|
|
}
|
|
return getDataPump().getTempoFactor();
|
|
}
|
|
|
|
|
|
public long getTickLength() {
|
|
if (Printer.trace) Printer.trace(">> RealTimeSequencer: getTickLength() ");
|
|
|
|
if (sequence == null) {
|
|
return 0;
|
|
}
|
|
|
|
return sequence.getTickLength();
|
|
}
|
|
|
|
|
|
public synchronized long getTickPosition() {
|
|
if (Printer.trace) Printer.trace(">> RealTimeSequencer: getTickPosition() ");
|
|
|
|
if (getDataPump() == null || sequence == null) {
|
|
return 0;
|
|
}
|
|
|
|
return getDataPump().getTickPos();
|
|
}
|
|
|
|
|
|
public synchronized void setTickPosition(long tick) {
|
|
if (tick < 0) {
|
|
// should throw IllegalArgumentException
|
|
return;
|
|
}
|
|
|
|
if (Printer.trace) Printer.trace(">> RealTimeSequencer: setTickPosition("+tick+") ");
|
|
|
|
if (getDataPump() == null) {
|
|
if (tick != 0) {
|
|
// throw new InvalidStateException("cannot set position in closed state");
|
|
}
|
|
}
|
|
else if (sequence == null) {
|
|
if (tick != 0) {
|
|
// throw new InvalidStateException("cannot set position if sequence is not set");
|
|
}
|
|
} else {
|
|
getDataPump().setTickPos(tick);
|
|
}
|
|
}
|
|
|
|
|
|
public long getMicrosecondLength() {
|
|
if (Printer.trace) Printer.trace(">> RealTimeSequencer: getMicrosecondLength() ");
|
|
|
|
if (sequence == null) {
|
|
return 0;
|
|
}
|
|
|
|
return sequence.getMicrosecondLength();
|
|
}
|
|
|
|
|
|
public long getMicrosecondPosition() {
|
|
if (Printer.trace) Printer.trace(">> RealTimeSequencer: getMicrosecondPosition() ");
|
|
|
|
if (getDataPump() == null || sequence == null) {
|
|
return 0;
|
|
}
|
|
synchronized (tempoCache) {
|
|
return MidiUtils.tick2microsecond(sequence, getDataPump().getTickPos(), tempoCache);
|
|
}
|
|
}
|
|
|
|
|
|
public void setMicrosecondPosition(long microseconds) {
|
|
if (microseconds < 0) {
|
|
// should throw IllegalArgumentException
|
|
return;
|
|
}
|
|
|
|
if (Printer.trace) Printer.trace(">> RealTimeSequencer: setMicrosecondPosition("+microseconds+") ");
|
|
|
|
if (getDataPump() == null) {
|
|
if (microseconds != 0) {
|
|
// throw new InvalidStateException("cannot set position in closed state");
|
|
}
|
|
}
|
|
else if (sequence == null) {
|
|
if (microseconds != 0) {
|
|
// throw new InvalidStateException("cannot set position if sequence is not set");
|
|
}
|
|
} else {
|
|
synchronized(tempoCache) {
|
|
setTickPosition(MidiUtils.microsecond2tick(sequence, microseconds, tempoCache));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public void setMasterSyncMode(Sequencer.SyncMode sync) {
|
|
// not supported
|
|
}
|
|
|
|
|
|
public Sequencer.SyncMode getMasterSyncMode() {
|
|
return masterSyncMode;
|
|
}
|
|
|
|
|
|
public Sequencer.SyncMode[] getMasterSyncModes() {
|
|
Sequencer.SyncMode[] returnedModes = new Sequencer.SyncMode[masterSyncModes.length];
|
|
System.arraycopy(masterSyncModes, 0, returnedModes, 0, masterSyncModes.length);
|
|
return returnedModes;
|
|
}
|
|
|
|
|
|
public void setSlaveSyncMode(Sequencer.SyncMode sync) {
|
|
// not supported
|
|
}
|
|
|
|
|
|
public Sequencer.SyncMode getSlaveSyncMode() {
|
|
return slaveSyncMode;
|
|
}
|
|
|
|
|
|
public Sequencer.SyncMode[] getSlaveSyncModes() {
|
|
Sequencer.SyncMode[] returnedModes = new Sequencer.SyncMode[slaveSyncModes.length];
|
|
System.arraycopy(slaveSyncModes, 0, returnedModes, 0, slaveSyncModes.length);
|
|
return returnedModes;
|
|
}
|
|
|
|
int getTrackCount() {
|
|
Sequence seq = getSequence();
|
|
if (seq != null) {
|
|
// $$fb wish there was a nicer way to get the number of tracks...
|
|
return sequence.getTracks().length;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
public synchronized void setTrackMute(int track, boolean mute) {
|
|
int trackCount = getTrackCount();
|
|
if (track < 0 || track >= getTrackCount()) return;
|
|
trackMuted = ensureBoolArraySize(trackMuted, trackCount);
|
|
trackMuted[track] = mute;
|
|
if (getDataPump() != null) {
|
|
getDataPump().muteSoloChanged();
|
|
}
|
|
}
|
|
|
|
|
|
public synchronized boolean getTrackMute(int track) {
|
|
if (track < 0 || track >= getTrackCount()) return false;
|
|
if (trackMuted == null || trackMuted.length <= track) return false;
|
|
return trackMuted[track];
|
|
}
|
|
|
|
|
|
public synchronized void setTrackSolo(int track, boolean solo) {
|
|
int trackCount = getTrackCount();
|
|
if (track < 0 || track >= getTrackCount()) return;
|
|
trackSolo = ensureBoolArraySize(trackSolo, trackCount);
|
|
trackSolo[track] = solo;
|
|
if (getDataPump() != null) {
|
|
getDataPump().muteSoloChanged();
|
|
}
|
|
}
|
|
|
|
|
|
public synchronized boolean getTrackSolo(int track) {
|
|
if (track < 0 || track >= getTrackCount()) return false;
|
|
if (trackSolo == null || trackSolo.length <= track) return false;
|
|
return trackSolo[track];
|
|
}
|
|
|
|
|
|
public boolean addMetaEventListener(MetaEventListener listener) {
|
|
synchronized(metaEventListeners) {
|
|
if (! metaEventListeners.contains(listener)) {
|
|
|
|
metaEventListeners.add(listener);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
|
|
public void removeMetaEventListener(MetaEventListener listener) {
|
|
synchronized(metaEventListeners) {
|
|
int index = metaEventListeners.indexOf(listener);
|
|
if (index >= 0) {
|
|
metaEventListeners.remove(index);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public int[] addControllerEventListener(ControllerEventListener listener, int[] controllers) {
|
|
synchronized(controllerEventListeners) {
|
|
|
|
// first find the listener. if we have one, add the controllers
|
|
// if not, create a new element for it.
|
|
ControllerListElement cve = null;
|
|
boolean flag = false;
|
|
for(int i=0; i < controllerEventListeners.size(); i++) {
|
|
|
|
cve = (ControllerListElement) controllerEventListeners.get(i);
|
|
|
|
if (cve.listener.equals(listener)) {
|
|
cve.addControllers(controllers);
|
|
flag = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!flag) {
|
|
cve = new ControllerListElement(listener, controllers);
|
|
controllerEventListeners.add(cve);
|
|
}
|
|
|
|
// and return all the controllers this listener is interested in
|
|
return cve.getControllers();
|
|
}
|
|
}
|
|
|
|
|
|
public int[] removeControllerEventListener(ControllerEventListener listener, int[] controllers) {
|
|
synchronized(controllerEventListeners) {
|
|
ControllerListElement cve = null;
|
|
boolean flag = false;
|
|
for (int i=0; i < controllerEventListeners.size(); i++) {
|
|
cve = (ControllerListElement) controllerEventListeners.get(i);
|
|
if (cve.listener.equals(listener)) {
|
|
cve.removeControllers(controllers);
|
|
flag = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!flag) {
|
|
return new int[0];
|
|
}
|
|
if (controllers == null) {
|
|
int index = controllerEventListeners.indexOf(cve);
|
|
if (index >= 0) {
|
|
controllerEventListeners.remove(index);
|
|
}
|
|
return new int[0];
|
|
}
|
|
return cve.getControllers();
|
|
}
|
|
}
|
|
|
|
|
|
////////////////// LOOPING (added in 1.5) ///////////////////////
|
|
|
|
public void setLoopStartPoint(long tick) {
|
|
if ((tick > getTickLength())
|
|
|| ((loopEnd != -1) && (tick > loopEnd))
|
|
|| (tick < 0)) {
|
|
throw new IllegalArgumentException("invalid loop start point: "+tick);
|
|
}
|
|
loopStart = tick;
|
|
}
|
|
|
|
public long getLoopStartPoint() {
|
|
return loopStart;
|
|
}
|
|
|
|
public void setLoopEndPoint(long tick) {
|
|
if ((tick > getTickLength())
|
|
|| ((loopStart > tick) && (tick != -1))
|
|
|| (tick < -1)) {
|
|
throw new IllegalArgumentException("invalid loop end point: "+tick);
|
|
}
|
|
loopEnd = tick;
|
|
}
|
|
|
|
public long getLoopEndPoint() {
|
|
return loopEnd;
|
|
}
|
|
|
|
public void setLoopCount(int count) {
|
|
if (count != LOOP_CONTINUOUSLY
|
|
&& count < 0) {
|
|
throw new IllegalArgumentException("illegal value for loop count: "+count);
|
|
}
|
|
loopCount = count;
|
|
if (getDataPump() != null) {
|
|
getDataPump().resetLoopCount();
|
|
}
|
|
}
|
|
|
|
public int getLoopCount() {
|
|
return loopCount;
|
|
}
|
|
|
|
|
|
/* *********************************** play control ************************* */
|
|
|
|
/*
|
|
*/
|
|
protected void implOpen() throws MidiUnavailableException {
|
|
if (Printer.trace) Printer.trace(">> RealTimeSequencer: implOpen()");
|
|
|
|
//openInternalSynth();
|
|
|
|
// create PlayThread
|
|
playThread = new PlayThread();
|
|
|
|
//id = nOpen();
|
|
//if (id == 0) {
|
|
// throw new MidiUnavailableException("unable to open sequencer");
|
|
//}
|
|
if (sequence != null) {
|
|
playThread.setSequence(sequence);
|
|
}
|
|
|
|
// propagate caches
|
|
propagateCaches();
|
|
|
|
if (doAutoConnectAtNextOpen) {
|
|
doAutoConnect();
|
|
}
|
|
if (Printer.trace) Printer.trace("<< RealTimeSequencer: implOpen() succeeded");
|
|
}
|
|
|
|
private void doAutoConnect() {
|
|
if (Printer.trace) Printer.trace(">> RealTimeSequencer: doAutoConnect()");
|
|
Receiver rec = null;
|
|
// first try to connect to the default synthesizer
|
|
// IMPORTANT: this code needs to be synch'ed with
|
|
// MidiSystem.getSequencer(boolean), because the same
|
|
// algorithm needs to be used!
|
|
try {
|
|
Synthesizer synth = MidiSystem.getSynthesizer();
|
|
if (synth instanceof ReferenceCountingDevice) {
|
|
rec = ((ReferenceCountingDevice) synth).getReceiverReferenceCounting();
|
|
} else {
|
|
synth.open();
|
|
try {
|
|
rec = synth.getReceiver();
|
|
} finally {
|
|
// make sure that the synth is properly closed
|
|
if (rec == null) {
|
|
synth.close();
|
|
}
|
|
}
|
|
}
|
|
} catch (Exception e) {
|
|
// something went wrong with synth
|
|
}
|
|
if (rec == null) {
|
|
// then try to connect to the default Receiver
|
|
try {
|
|
rec = MidiSystem.getReceiver();
|
|
} catch (Exception e) {
|
|
// something went wrong. Nothing to do then!
|
|
}
|
|
}
|
|
if (rec != null) {
|
|
autoConnectedReceiver = rec;
|
|
try {
|
|
getTransmitter().setReceiver(rec);
|
|
} catch (Exception e) {}
|
|
}
|
|
if (Printer.trace) Printer.trace("<< RealTimeSequencer: doAutoConnect() succeeded");
|
|
}
|
|
|
|
private synchronized void propagateCaches() {
|
|
// only set caches if open and sequence is set
|
|
if (sequence != null && isOpen()) {
|
|
if (cacheTempoFactor != -1) {
|
|
setTempoFactor(cacheTempoFactor);
|
|
}
|
|
if (cacheTempoMPQ == -1) {
|
|
setTempoInMPQ((new MidiUtils.TempoCache(sequence)).getTempoMPQAt(getTickPosition()));
|
|
} else {
|
|
setTempoInMPQ((float) cacheTempoMPQ);
|
|
}
|
|
}
|
|
}
|
|
|
|
/** populate the caches with the current values */
|
|
private synchronized void setCaches() {
|
|
cacheTempoFactor = getTempoFactor();
|
|
cacheTempoMPQ = getTempoInMPQ();
|
|
}
|
|
|
|
|
|
|
|
protected synchronized void implClose() {
|
|
if (Printer.trace) Printer.trace(">> RealTimeSequencer: implClose() ");
|
|
|
|
if (playThread == null) {
|
|
if (Printer.err) Printer.err("RealTimeSequencer.implClose() called, but playThread not instanciated!");
|
|
} else {
|
|
// Interrupt playback loop.
|
|
playThread.close();
|
|
playThread = null;
|
|
}
|
|
|
|
super.implClose();
|
|
|
|
sequence = null;
|
|
running = false;
|
|
cacheTempoMPQ = -1;
|
|
cacheTempoFactor = -1;
|
|
trackMuted = null;
|
|
trackSolo = null;
|
|
loopStart = 0;
|
|
loopEnd = -1;
|
|
loopCount = 0;
|
|
|
|
/** if this sequencer is set to autoconnect, need to
|
|
* re-establish the connection at next open!
|
|
*/
|
|
doAutoConnectAtNextOpen = autoConnect;
|
|
|
|
if (autoConnectedReceiver != null) {
|
|
try {
|
|
autoConnectedReceiver.close();
|
|
} catch (Exception e) {}
|
|
autoConnectedReceiver = null;
|
|
}
|
|
|
|
if (Printer.trace) Printer.trace("<< RealTimeSequencer: implClose() completed");
|
|
}
|
|
|
|
void implStart() {
|
|
if (Printer.trace) Printer.trace(">> RealTimeSequencer: implStart()");
|
|
|
|
if (playThread == null) {
|
|
if (Printer.err) Printer.err("RealTimeSequencer.implStart() called, but playThread not instanciated!");
|
|
return;
|
|
}
|
|
|
|
tempoCache.refresh(sequence);
|
|
if (!running) {
|
|
running = true;
|
|
playThread.start();
|
|
}
|
|
if (Printer.trace) Printer.trace("<< RealTimeSequencer: implStart() completed");
|
|
}
|
|
|
|
|
|
void implStop() {
|
|
if (Printer.trace) Printer.trace(">> RealTimeSequencer: implStop()");
|
|
|
|
if (playThread == null) {
|
|
if (Printer.err) Printer.err("RealTimeSequencer.implStop() called, but playThread not instanciated!");
|
|
return;
|
|
}
|
|
|
|
recording = false;
|
|
if (running) {
|
|
running = false;
|
|
playThread.stop();
|
|
}
|
|
if (Printer.trace) Printer.trace("<< RealTimeSequencer: implStop() completed");
|
|
}
|
|
|
|
private static EventDispatcher getEventDispatcher() {
|
|
// create and start the global event thread
|
|
//TODO need a way to stop this thread when the engine is done
|
|
final ThreadGroup tg = Thread.currentThread().getThreadGroup();
|
|
synchronized (dispatchers) {
|
|
EventDispatcher eventDispatcher = dispatchers.get(tg);
|
|
if (eventDispatcher == null) {
|
|
eventDispatcher = new EventDispatcher();
|
|
dispatchers.put(tg, eventDispatcher);
|
|
eventDispatcher.start();
|
|
}
|
|
return eventDispatcher;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Send midi player events.
|
|
* must not be synchronized on "this"
|
|
*/
|
|
void sendMetaEvents(MidiMessage message) {
|
|
if (metaEventListeners.size() == 0) return;
|
|
|
|
//if (Printer.debug) Printer.debug("sending a meta event");
|
|
getEventDispatcher().sendAudioEvents(message, metaEventListeners);
|
|
}
|
|
|
|
/**
|
|
* Send midi player events.
|
|
*/
|
|
void sendControllerEvents(MidiMessage message) {
|
|
int size = controllerEventListeners.size();
|
|
if (size == 0) return;
|
|
|
|
//if (Printer.debug) Printer.debug("sending a controller event");
|
|
|
|
if (! (message instanceof ShortMessage)) {
|
|
if (Printer.debug) Printer.debug("sendControllerEvents: message is NOT instanceof ShortMessage!");
|
|
return;
|
|
}
|
|
ShortMessage msg = (ShortMessage) message;
|
|
int controller = msg.getData1();
|
|
List sendToListeners = new ArrayList();
|
|
for (int i = 0; i < size; i++) {
|
|
ControllerListElement cve = (ControllerListElement) controllerEventListeners.get(i);
|
|
for(int j = 0; j < cve.controllers.length; j++) {
|
|
if (cve.controllers[j] == controller) {
|
|
sendToListeners.add(cve.listener);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
getEventDispatcher().sendAudioEvents(message, sendToListeners);
|
|
}
|
|
|
|
|
|
|
|
private boolean needCaching() {
|
|
return !isOpen() || (sequence == null) || (playThread == null);
|
|
}
|
|
|
|
/**
|
|
* return the data pump instance, owned by play thread
|
|
* if playthread is null, return null.
|
|
* This method is guaranteed to return non-null if
|
|
* needCaching returns false
|
|
*/
|
|
private DataPump getDataPump() {
|
|
if (playThread != null) {
|
|
return playThread.getDataPump();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private MidiUtils.TempoCache getTempoCache() {
|
|
return tempoCache;
|
|
}
|
|
|
|
private static boolean[] ensureBoolArraySize(boolean[] array, int desiredSize) {
|
|
if (array == null) {
|
|
return new boolean[desiredSize];
|
|
}
|
|
if (array.length < desiredSize) {
|
|
boolean[] newArray = new boolean[desiredSize];
|
|
System.arraycopy(array, 0, newArray, 0, array.length);
|
|
return newArray;
|
|
}
|
|
return array;
|
|
}
|
|
|
|
|
|
// OVERRIDES OF ABSTRACT MIDI DEVICE METHODS
|
|
|
|
protected boolean hasReceivers() {
|
|
return true;
|
|
}
|
|
|
|
// for recording
|
|
protected Receiver createReceiver() throws MidiUnavailableException {
|
|
return new SequencerReceiver();
|
|
}
|
|
|
|
|
|
protected boolean hasTransmitters() {
|
|
return true;
|
|
}
|
|
|
|
|
|
protected Transmitter createTransmitter() throws MidiUnavailableException {
|
|
return new SequencerTransmitter();
|
|
}
|
|
|
|
|
|
// interface AutoConnectSequencer
|
|
public void setAutoConnect(Receiver autoConnectedReceiver) {
|
|
this.autoConnect = (autoConnectedReceiver != null);
|
|
this.autoConnectedReceiver = autoConnectedReceiver;
|
|
}
|
|
|
|
|
|
|
|
// INNER CLASSES
|
|
|
|
/**
|
|
* An own class to distinguish the class name from
|
|
* the transmitter of other devices
|
|
*/
|
|
private class SequencerTransmitter extends BasicTransmitter {
|
|
private SequencerTransmitter() {
|
|
super();
|
|
}
|
|
}
|
|
|
|
|
|
final class SequencerReceiver extends AbstractReceiver {
|
|
|
|
void implSend(MidiMessage message, long timeStamp) {
|
|
if (recording) {
|
|
long tickPos = 0;
|
|
|
|
// convert timeStamp to ticks
|
|
if (timeStamp < 0) {
|
|
tickPos = getTickPosition();
|
|
} else {
|
|
synchronized(tempoCache) {
|
|
tickPos = MidiUtils.microsecond2tick(sequence, timeStamp, tempoCache);
|
|
}
|
|
}
|
|
|
|
// and record to the first matching Track
|
|
Track track = null;
|
|
// do not record real-time events
|
|
// see 5048381: NullPointerException when saving a MIDI sequence
|
|
if (message.getLength() > 1) {
|
|
if (message instanceof ShortMessage) {
|
|
ShortMessage sm = (ShortMessage) message;
|
|
// all real-time messages have 0xF in the high nibble of the status byte
|
|
if ((sm.getStatus() & 0xF0) != 0xF0) {
|
|
track = RecordingTrack.get(recordingTracks, sm.getChannel());
|
|
}
|
|
} else {
|
|
// $$jb: where to record meta, sysex events?
|
|
// $$fb: the first recording track
|
|
track = RecordingTrack.get(recordingTracks, -1);
|
|
}
|
|
if (track != null) {
|
|
// create a copy of this message
|
|
if (message instanceof ShortMessage) {
|
|
message = new FastShortMessage((ShortMessage) message);
|
|
} else {
|
|
message = (MidiMessage) message.clone();
|
|
}
|
|
|
|
// create new MidiEvent
|
|
MidiEvent me = new MidiEvent(message, tickPos);
|
|
track.add(me);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
private static class RealTimeSequencerInfo extends MidiDevice.Info {
|
|
|
|
private static final String name = "Real Time Sequencer";
|
|
private static final String vendor = "Oracle Corporation";
|
|
private static final String description = "Software sequencer";
|
|
private static final String version = "Version 1.0";
|
|
|
|
private RealTimeSequencerInfo() {
|
|
super(name, vendor, description, version);
|
|
}
|
|
} // class Info
|
|
|
|
|
|
private class ControllerListElement {
|
|
|
|
// $$jb: using an array for controllers b/c its
|
|
// easier to deal with than turning all the
|
|
// ints into objects to use a Vector
|
|
int [] controllers;
|
|
final ControllerEventListener listener;
|
|
|
|
private ControllerListElement(ControllerEventListener listener, int[] controllers) {
|
|
|
|
this.listener = listener;
|
|
if (controllers == null) {
|
|
controllers = new int[128];
|
|
for (int i = 0; i < 128; i++) {
|
|
controllers[i] = i;
|
|
}
|
|
}
|
|
this.controllers = controllers;
|
|
}
|
|
|
|
private void addControllers(int[] c) {
|
|
|
|
if (c==null) {
|
|
controllers = new int[128];
|
|
for (int i = 0; i < 128; i++) {
|
|
controllers[i] = i;
|
|
}
|
|
return;
|
|
}
|
|
int temp[] = new int[ controllers.length + c.length ];
|
|
int elements;
|
|
|
|
// first add what we have
|
|
for(int i=0; i<controllers.length; i++) {
|
|
temp[i] = controllers[i];
|
|
}
|
|
elements = controllers.length;
|
|
// now add the new controllers only if we don't already have them
|
|
for(int i=0; i<c.length; i++) {
|
|
boolean flag = false;
|
|
|
|
for(int j=0; j<controllers.length; j++) {
|
|
if (c[i] == controllers[j]) {
|
|
flag = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!flag) {
|
|
temp[elements++] = c[i];
|
|
}
|
|
}
|
|
// now keep only the elements we need
|
|
int newc[] = new int[ elements ];
|
|
for(int i=0; i<elements; i++){
|
|
newc[i] = temp[i];
|
|
}
|
|
controllers = newc;
|
|
}
|
|
|
|
private void removeControllers(int[] c) {
|
|
|
|
if (c==null) {
|
|
controllers = new int[0];
|
|
} else {
|
|
int temp[] = new int[ controllers.length ];
|
|
int elements = 0;
|
|
|
|
|
|
for(int i=0; i<controllers.length; i++){
|
|
boolean flag = false;
|
|
for(int j=0; j<c.length; j++) {
|
|
if (controllers[i] == c[j]) {
|
|
flag = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!flag){
|
|
temp[elements++] = controllers[i];
|
|
}
|
|
}
|
|
// now keep only the elements remaining
|
|
int newc[] = new int[ elements ];
|
|
for(int i=0; i<elements; i++) {
|
|
newc[i] = temp[i];
|
|
}
|
|
controllers = newc;
|
|
|
|
}
|
|
}
|
|
|
|
private int[] getControllers() {
|
|
|
|
// return a copy of our array of controllers,
|
|
// so others can't mess with it
|
|
if (controllers == null) {
|
|
return null;
|
|
}
|
|
|
|
int c[] = new int[controllers.length];
|
|
|
|
for(int i=0; i<controllers.length; i++){
|
|
c[i] = controllers[i];
|
|
}
|
|
return c;
|
|
}
|
|
|
|
} // class ControllerListElement
|
|
|
|
|
|
static class RecordingTrack {
|
|
|
|
private final Track track;
|
|
private int channel;
|
|
|
|
RecordingTrack(Track track, int channel) {
|
|
this.track = track;
|
|
this.channel = channel;
|
|
}
|
|
|
|
static RecordingTrack get(List recordingTracks, Track track) {
|
|
|
|
synchronized(recordingTracks) {
|
|
int size = recordingTracks.size();
|
|
|
|
for (int i = 0; i < size; i++) {
|
|
RecordingTrack current = (RecordingTrack)recordingTracks.get(i);
|
|
if (current.track == track) {
|
|
return current;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
static Track get(List recordingTracks, int channel) {
|
|
|
|
synchronized(recordingTracks) {
|
|
int size = recordingTracks.size();
|
|
for (int i = 0; i < size; i++) {
|
|
RecordingTrack current = (RecordingTrack)recordingTracks.get(i);
|
|
if ((current.channel == channel) || (current.channel == -1)) {
|
|
return current.track;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
|
|
}
|
|
}
|
|
|
|
|
|
final class PlayThread implements Runnable {
|
|
private Thread thread;
|
|
private final Object lock = new Object();
|
|
|
|
/** true if playback is interrupted (in close) */
|
|
boolean interrupted = false;
|
|
boolean isPumping = false;
|
|
|
|
private final DataPump dataPump = new DataPump();
|
|
|
|
|
|
PlayThread() {
|
|
// nearly MAX_PRIORITY
|
|
int priority = Thread.NORM_PRIORITY
|
|
+ ((Thread.MAX_PRIORITY - Thread.NORM_PRIORITY) * 3) / 4;
|
|
thread = JSSecurityManager.createThread(this,
|
|
"Java Sound Sequencer", // name
|
|
false, // daemon
|
|
priority, // priority
|
|
true); // doStart
|
|
}
|
|
|
|
DataPump getDataPump() {
|
|
return dataPump;
|
|
}
|
|
|
|
synchronized void setSequence(Sequence seq) {
|
|
dataPump.setSequence(seq);
|
|
}
|
|
|
|
|
|
/** start thread and pump. Requires up-to-date tempoCache */
|
|
synchronized void start() {
|
|
// mark the sequencer running
|
|
running = true;
|
|
|
|
if (!dataPump.hasCachedTempo()) {
|
|
long tickPos = getTickPosition();
|
|
dataPump.setTempoMPQ(tempoCache.getTempoMPQAt(tickPos));
|
|
}
|
|
dataPump.checkPointMillis = 0; // means restarted
|
|
dataPump.clearNoteOnCache();
|
|
dataPump.needReindex = true;
|
|
|
|
dataPump.resetLoopCount();
|
|
|
|
// notify the thread
|
|
synchronized(lock) {
|
|
lock.notifyAll();
|
|
}
|
|
|
|
if (Printer.debug) Printer.debug(" ->Started MIDI play thread");
|
|
|
|
}
|
|
|
|
// waits until stopped
|
|
synchronized void stop() {
|
|
playThreadImplStop();
|
|
long t = System.nanoTime() / 1000000l;
|
|
while (isPumping) {
|
|
synchronized(lock) {
|
|
try {
|
|
lock.wait(2000);
|
|
} catch (InterruptedException ie) {
|
|
// ignore
|
|
}
|
|
}
|
|
// don't wait for more than 2 seconds
|
|
if ((System.nanoTime()/1000000l) - t > 1900) {
|
|
if (Printer.err) Printer.err("Waited more than 2 seconds in RealTimeSequencer.PlayThread.stop()!");
|
|
//break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void playThreadImplStop() {
|
|
// mark the sequencer running
|
|
running = false;
|
|
synchronized(lock) {
|
|
lock.notifyAll();
|
|
}
|
|
}
|
|
|
|
void close() {
|
|
Thread oldThread = null;
|
|
synchronized (this) {
|
|
// dispose of thread
|
|
interrupted = true;
|
|
oldThread = thread;
|
|
thread = null;
|
|
}
|
|
if (oldThread != null) {
|
|
// wake up the thread if it's in wait()
|
|
synchronized(lock) {
|
|
lock.notifyAll();
|
|
}
|
|
}
|
|
// wait for the thread to terminate itself,
|
|
// but max. 2 seconds. Must not be synchronized!
|
|
if (oldThread != null) {
|
|
try {
|
|
oldThread.join(2000);
|
|
} catch (InterruptedException ie) {}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Main process loop driving the media flow.
|
|
*
|
|
* Make sure to NOT synchronize on RealTimeSequencer
|
|
* anywhere here (even implicit). That is a sure deadlock!
|
|
*/
|
|
public void run() {
|
|
|
|
while (!interrupted) {
|
|
boolean EOM = false;
|
|
boolean wasRunning = running;
|
|
isPumping = !interrupted && running;
|
|
while (!EOM && !interrupted && running) {
|
|
EOM = dataPump.pump();
|
|
|
|
try {
|
|
Thread.sleep(1);
|
|
} catch (InterruptedException ie) {
|
|
// ignore
|
|
}
|
|
}
|
|
if (Printer.debug) {
|
|
Printer.debug("Exited main pump loop because: ");
|
|
if (EOM) Printer.debug(" -> EOM is reached");
|
|
if (!running) Printer.debug(" -> running was set to false");
|
|
if (interrupted) Printer.debug(" -> interrupted was set to true");
|
|
}
|
|
|
|
playThreadImplStop();
|
|
if (wasRunning) {
|
|
dataPump.notesOff(true);
|
|
}
|
|
if (EOM) {
|
|
dataPump.setTickPos(sequence.getTickLength());
|
|
|
|
// send EOT event (mis-used for end of media)
|
|
MetaMessage message = new MetaMessage();
|
|
try{
|
|
message.setMessage(MidiUtils.META_END_OF_TRACK_TYPE, new byte[0], 0);
|
|
} catch(InvalidMidiDataException e1) {}
|
|
sendMetaEvents(message);
|
|
}
|
|
synchronized (lock) {
|
|
isPumping = false;
|
|
// wake up a waiting stop() method
|
|
lock.notifyAll();
|
|
while (!running && !interrupted) {
|
|
try {
|
|
lock.wait();
|
|
} catch (Exception ex) {}
|
|
}
|
|
}
|
|
} // end of while(!EOM && !interrupted && running)
|
|
if (Printer.debug) Printer.debug("end of play thread");
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* class that does the actual dispatching of events,
|
|
* used to be in native in MMAPI
|
|
*/
|
|
private class DataPump {
|
|
private float currTempo; // MPQ tempo
|
|
private float tempoFactor; // 1.0 is default
|
|
private float inverseTempoFactor;// = 1.0 / tempoFactor
|
|
private long ignoreTempoEventAt; // ignore next META tempo during playback at this tick pos only
|
|
private int resolution;
|
|
private float divisionType;
|
|
private long checkPointMillis; // microseconds at checkoint
|
|
private long checkPointTick; // ticks at checkpoint
|
|
private int[] noteOnCache; // bit-mask of notes that are currently on
|
|
private Track[] tracks;
|
|
private boolean[] trackDisabled; // if true, do not play this track
|
|
private int[] trackReadPos; // read index per track
|
|
private long lastTick;
|
|
private boolean needReindex = false;
|
|
private int currLoopCounter = 0;
|
|
|
|
//private sun.misc.Perf perf = sun.misc.Perf.getPerf();
|
|
//private long perfFreq = perf.highResFrequency();
|
|
|
|
|
|
DataPump() {
|
|
init();
|
|
}
|
|
|
|
synchronized void init() {
|
|
ignoreTempoEventAt = -1;
|
|
tempoFactor = 1.0f;
|
|
inverseTempoFactor = 1.0f;
|
|
noteOnCache = new int[128];
|
|
tracks = null;
|
|
trackDisabled = null;
|
|
}
|
|
|
|
synchronized void setTickPos(long tickPos) {
|
|
long oldLastTick = tickPos;
|
|
lastTick = tickPos;
|
|
if (running) {
|
|
notesOff(false);
|
|
}
|
|
if (running || tickPos > 0) {
|
|
// will also reindex
|
|
chaseEvents(oldLastTick, tickPos);
|
|
} else {
|
|
needReindex = true;
|
|
}
|
|
if (!hasCachedTempo()) {
|
|
setTempoMPQ(getTempoCache().getTempoMPQAt(lastTick, currTempo));
|
|
// treat this as if it is a real time tempo change
|
|
ignoreTempoEventAt = -1;
|
|
}
|
|
// trigger re-configuration
|
|
checkPointMillis = 0;
|
|
}
|
|
|
|
long getTickPos() {
|
|
return lastTick;
|
|
}
|
|
|
|
// hasCachedTempo is only valid if it is the current position
|
|
boolean hasCachedTempo() {
|
|
if (ignoreTempoEventAt != lastTick) {
|
|
ignoreTempoEventAt = -1;
|
|
}
|
|
return ignoreTempoEventAt >= 0;
|
|
}
|
|
|
|
// this method is also used internally in the pump!
|
|
synchronized void setTempoMPQ(float tempoMPQ) {
|
|
if (tempoMPQ > 0 && tempoMPQ != currTempo) {
|
|
ignoreTempoEventAt = lastTick;
|
|
this.currTempo = tempoMPQ;
|
|
// re-calculate check point
|
|
checkPointMillis = 0;
|
|
}
|
|
}
|
|
|
|
float getTempoMPQ() {
|
|
return currTempo;
|
|
}
|
|
|
|
synchronized void setTempoFactor(float factor) {
|
|
if (factor > 0 && factor != this.tempoFactor) {
|
|
tempoFactor = factor;
|
|
inverseTempoFactor = 1.0f / factor;
|
|
// re-calculate check point
|
|
checkPointMillis = 0;
|
|
}
|
|
}
|
|
|
|
float getTempoFactor() {
|
|
return tempoFactor;
|
|
}
|
|
|
|
synchronized void muteSoloChanged() {
|
|
boolean[] newDisabled = makeDisabledArray();
|
|
if (running) {
|
|
applyDisabledTracks(trackDisabled, newDisabled);
|
|
}
|
|
trackDisabled = newDisabled;
|
|
}
|
|
|
|
|
|
|
|
synchronized void setSequence(Sequence seq) {
|
|
if (seq == null) {
|
|
init();
|
|
return;
|
|
}
|
|
tracks = seq.getTracks();
|
|
muteSoloChanged();
|
|
resolution = seq.getResolution();
|
|
divisionType = seq.getDivisionType();
|
|
trackReadPos = new int[tracks.length];
|
|
// trigger re-initialization
|
|
checkPointMillis = 0;
|
|
needReindex = true;
|
|
}
|
|
|
|
synchronized void resetLoopCount() {
|
|
currLoopCounter = loopCount;
|
|
}
|
|
|
|
void clearNoteOnCache() {
|
|
for (int i = 0; i < 128; i++) {
|
|
noteOnCache[i] = 0;
|
|
}
|
|
}
|
|
|
|
void notesOff(boolean doControllers) {
|
|
int done = 0;
|
|
for (int ch=0; ch<16; ch++) {
|
|
int channelMask = (1<<ch);
|
|
for (int i=0; i<128; i++) {
|
|
if ((noteOnCache[i] & channelMask) != 0) {
|
|
noteOnCache[i] ^= channelMask;
|
|
// send note on with velocity 0
|
|
getTransmitterList().sendMessage((ShortMessage.NOTE_ON | ch) | (i<<8), -1);
|
|
done++;
|
|
}
|
|
}
|
|
/* all notes off */
|
|
getTransmitterList().sendMessage((ShortMessage.CONTROL_CHANGE | ch) | (123<<8), -1);
|
|
/* sustain off */
|
|
getTransmitterList().sendMessage((ShortMessage.CONTROL_CHANGE | ch) | (64<<8), -1);
|
|
if (doControllers) {
|
|
/* reset all controllers */
|
|
getTransmitterList().sendMessage((ShortMessage.CONTROL_CHANGE | ch) | (121<<8), -1);
|
|
done++;
|
|
}
|
|
}
|
|
if (DEBUG_PUMP) Printer.println(" noteOff: sent "+done+" messages.");
|
|
}
|
|
|
|
|
|
private boolean[] makeDisabledArray() {
|
|
if (tracks == null) {
|
|
return null;
|
|
}
|
|
boolean[] newTrackDisabled = new boolean[tracks.length];
|
|
boolean[] solo;
|
|
boolean[] mute;
|
|
synchronized(RealTimeSequencer.this) {
|
|
mute = trackMuted;
|
|
solo = trackSolo;
|
|
}
|
|
// if one track is solo, then only play solo
|
|
boolean hasSolo = false;
|
|
if (solo != null) {
|
|
for (int i = 0; i < solo.length; i++) {
|
|
if (solo[i]) {
|
|
hasSolo = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (hasSolo) {
|
|
// only the channels with solo play, regardless of mute
|
|
for (int i = 0; i < newTrackDisabled.length; i++) {
|
|
newTrackDisabled[i] = (i >= solo.length) || (!solo[i]);
|
|
}
|
|
} else {
|
|
// mute the selected channels
|
|
for (int i = 0; i < newTrackDisabled.length; i++) {
|
|
newTrackDisabled[i] = (mute != null) && (i < mute.length) && (mute[i]);
|
|
}
|
|
}
|
|
return newTrackDisabled;
|
|
}
|
|
|
|
/**
|
|
* chase all events from beginning of Track
|
|
* and send note off for those events that are active
|
|
* in noteOnCache array.
|
|
* It is possible, of course, to catch notes from other tracks,
|
|
* but better than more complicated logic to detect
|
|
* which notes are really from this track
|
|
*/
|
|
private void sendNoteOffIfOn(Track track, long endTick) {
|
|
int size = track.size();
|
|
int done = 0;
|
|
try {
|
|
for (int i = 0; i < size; i++) {
|
|
MidiEvent event = track.get(i);
|
|
if (event.getTick() > endTick) break;
|
|
MidiMessage msg = event.getMessage();
|
|
int status = msg.getStatus();
|
|
int len = msg.getLength();
|
|
if (len == 3 && ((status & 0xF0) == ShortMessage.NOTE_ON)) {
|
|
int note = -1;
|
|
if (msg instanceof ShortMessage) {
|
|
ShortMessage smsg = (ShortMessage) msg;
|
|
if (smsg.getData2() > 0) {
|
|
// only consider Note On with velocity > 0
|
|
note = smsg.getData1();
|
|
}
|
|
} else {
|
|
byte[] data = msg.getMessage();
|
|
if ((data[2] & 0x7F) > 0) {
|
|
// only consider Note On with velocity > 0
|
|
note = data[1] & 0x7F;
|
|
}
|
|
}
|
|
if (note >= 0) {
|
|
int bit = 1<<(status & 0x0F);
|
|
if ((noteOnCache[note] & bit) != 0) {
|
|
// the bit is set. Send Note Off
|
|
getTransmitterList().sendMessage(status | (note<<8), -1);
|
|
// clear the bit
|
|
noteOnCache[note] &= (0xFFFF ^ bit);
|
|
done++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} catch (ArrayIndexOutOfBoundsException aioobe) {
|
|
// this happens when messages are removed
|
|
// from the track while this method executes
|
|
}
|
|
if (DEBUG_PUMP) Printer.println(" sendNoteOffIfOn: sent "+done+" messages.");
|
|
}
|
|
|
|
|
|
/**
|
|
* Runtime application of mute/solo:
|
|
* if a track is muted that was previously playing, send
|
|
* note off events for all currently playing notes
|
|
*/
|
|
private void applyDisabledTracks(boolean[] oldDisabled, boolean[] newDisabled) {
|
|
byte[][] tempArray = null;
|
|
synchronized(RealTimeSequencer.this) {
|
|
for (int i = 0; i < newDisabled.length; i++) {
|
|
if (((oldDisabled == null)
|
|
|| (i >= oldDisabled.length)
|
|
|| !oldDisabled[i])
|
|
&& newDisabled[i]) {
|
|
// case that a track gets muted: need to
|
|
// send appropriate note off events to prevent
|
|
// hanging notes
|
|
|
|
if (tracks.length > i) {
|
|
sendNoteOffIfOn(tracks[i], lastTick);
|
|
}
|
|
}
|
|
else if ((oldDisabled != null)
|
|
&& (i < oldDisabled.length)
|
|
&& oldDisabled[i]
|
|
&& !newDisabled[i]) {
|
|
// case that a track was muted and is now unmuted
|
|
// need to chase events and re-index this track
|
|
if (tempArray == null) {
|
|
tempArray = new byte[128][16];
|
|
}
|
|
chaseTrackEvents(i, 0, lastTick, true, tempArray);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/** go through all events from startTick to endTick
|
|
* chase the controller state and program change state
|
|
* and then set the end-states at once.
|
|
*
|
|
* needs to be called in synchronized state
|
|
* @param tempArray an byte[128][16] to hold controller messages
|
|
*/
|
|
private void chaseTrackEvents(int trackNum,
|
|
long startTick,
|
|
long endTick,
|
|
boolean doReindex,
|
|
byte[][] tempArray) {
|
|
if (startTick > endTick) {
|
|
// start from the beginning
|
|
startTick = 0;
|
|
}
|
|
byte[] progs = new byte[16];
|
|
// init temp array with impossible values
|
|
for (int ch = 0; ch < 16; ch++) {
|
|
progs[ch] = -1;
|
|
for (int co = 0; co < 128; co++) {
|
|
tempArray[co][ch] = -1;
|
|
}
|
|
}
|
|
Track track = tracks[trackNum];
|
|
int size = track.size();
|
|
try {
|
|
for (int i = 0; i < size; i++) {
|
|
MidiEvent event = track.get(i);
|
|
if (event.getTick() >= endTick) {
|
|
if (doReindex && (trackNum < trackReadPos.length)) {
|
|
trackReadPos[trackNum] = (i > 0)?(i-1):0;
|
|
if (DEBUG_PUMP) Printer.println(" chaseEvents: setting trackReadPos["+trackNum+"] = "+trackReadPos[trackNum]);
|
|
}
|
|
break;
|
|
}
|
|
MidiMessage msg = event.getMessage();
|
|
int status = msg.getStatus();
|
|
int len = msg.getLength();
|
|
if (len == 3 && ((status & 0xF0) == ShortMessage.CONTROL_CHANGE)) {
|
|
if (msg instanceof ShortMessage) {
|
|
ShortMessage smsg = (ShortMessage) msg;
|
|
tempArray[smsg.getData1() & 0x7F][status & 0x0F] = (byte) smsg.getData2();
|
|
} else {
|
|
byte[] data = msg.getMessage();
|
|
tempArray[data[1] & 0x7F][status & 0x0F] = data[2];
|
|
}
|
|
}
|
|
if (len == 2 && ((status & 0xF0) == ShortMessage.PROGRAM_CHANGE)) {
|
|
if (msg instanceof ShortMessage) {
|
|
ShortMessage smsg = (ShortMessage) msg;
|
|
progs[status & 0x0F] = (byte) smsg.getData1();
|
|
} else {
|
|
byte[] data = msg.getMessage();
|
|
progs[status & 0x0F] = data[1];
|
|
}
|
|
}
|
|
}
|
|
} catch (ArrayIndexOutOfBoundsException aioobe) {
|
|
// this happens when messages are removed
|
|
// from the track while this method executes
|
|
}
|
|
int numControllersSent = 0;
|
|
// now send out the aggregated controllers and program changes
|
|
for (int ch = 0; ch < 16; ch++) {
|
|
for (int co = 0; co < 128; co++) {
|
|
byte controllerValue = tempArray[co][ch];
|
|
if (controllerValue >= 0) {
|
|
int packedMsg = (ShortMessage.CONTROL_CHANGE | ch) | (co<<8) | (controllerValue<<16);
|
|
getTransmitterList().sendMessage(packedMsg, -1);
|
|
numControllersSent++;
|
|
}
|
|
}
|
|
// send program change *after* controllers, to
|
|
// correctly initialize banks
|
|
if (progs[ch] >= 0) {
|
|
getTransmitterList().sendMessage((ShortMessage.PROGRAM_CHANGE | ch) | (progs[ch]<<8), -1);
|
|
}
|
|
if (progs[ch] >= 0 || startTick == 0 || endTick == 0) {
|
|
// reset pitch bend on this channel (E0 00 40)
|
|
getTransmitterList().sendMessage((ShortMessage.PITCH_BEND | ch) | (0x40 << 16), -1);
|
|
// reset sustain pedal on this channel
|
|
getTransmitterList().sendMessage((ShortMessage.CONTROL_CHANGE | ch) | (64 << 8), -1);
|
|
}
|
|
}
|
|
if (DEBUG_PUMP) Printer.println(" chaseTrackEvents track "+trackNum+": sent "+numControllersSent+" controllers.");
|
|
}
|
|
|
|
|
|
/** chase controllers and program for all tracks */
|
|
synchronized void chaseEvents(long startTick, long endTick) {
|
|
if (DEBUG_PUMP) Printer.println(">> chaseEvents from tick "+startTick+".."+(endTick-1));
|
|
byte[][] tempArray = new byte[128][16];
|
|
for (int t = 0; t < tracks.length; t++) {
|
|
if ((trackDisabled == null)
|
|
|| (trackDisabled.length <= t)
|
|
|| (!trackDisabled[t])) {
|
|
// if track is not disabled, chase the events for it
|
|
chaseTrackEvents(t, startTick, endTick, true, tempArray);
|
|
}
|
|
}
|
|
if (DEBUG_PUMP) Printer.println("<< chaseEvents");
|
|
}
|
|
|
|
|
|
// playback related methods (pumping)
|
|
|
|
private long getCurrentTimeMillis() {
|
|
return System.nanoTime() / 1000000l;
|
|
//return perf.highResCounter() * 1000 / perfFreq;
|
|
}
|
|
|
|
private long millis2tick(long millis) {
|
|
if (divisionType != Sequence.PPQ) {
|
|
double dTick = ((((double) millis) * tempoFactor)
|
|
* ((double) divisionType)
|
|
* ((double) resolution))
|
|
/ ((double) 1000);
|
|
return (long) dTick;
|
|
}
|
|
return MidiUtils.microsec2ticks(millis * 1000,
|
|
currTempo * inverseTempoFactor,
|
|
resolution);
|
|
}
|
|
|
|
private long tick2millis(long tick) {
|
|
if (divisionType != Sequence.PPQ) {
|
|
double dMillis = ((((double) tick) * 1000) /
|
|
(tempoFactor * ((double) divisionType) * ((double) resolution)));
|
|
return (long) dMillis;
|
|
}
|
|
return MidiUtils.ticks2microsec(tick,
|
|
currTempo * inverseTempoFactor,
|
|
resolution) / 1000;
|
|
}
|
|
|
|
private void ReindexTrack(int trackNum, long tick) {
|
|
if (trackNum < trackReadPos.length && trackNum < tracks.length) {
|
|
trackReadPos[trackNum] = MidiUtils.tick2index(tracks[trackNum], tick);
|
|
if (DEBUG_PUMP) Printer.println(" reindexTrack: setting trackReadPos["+trackNum+"] = "+trackReadPos[trackNum]);
|
|
}
|
|
}
|
|
|
|
/* returns if changes are pending */
|
|
private boolean dispatchMessage(int trackNum, MidiEvent event) {
|
|
boolean changesPending = false;
|
|
MidiMessage message = event.getMessage();
|
|
int msgStatus = message.getStatus();
|
|
int msgLen = message.getLength();
|
|
if (msgStatus == MetaMessage.META && msgLen >= 2) {
|
|
// a meta message. Do not send it to the device.
|
|
// 0xFF with length=1 is a MIDI realtime message
|
|
// which shouldn't be in a Sequence, but we play it
|
|
// nonetheless.
|
|
|
|
// see if this is a tempo message. Only on track 0.
|
|
if (trackNum == 0) {
|
|
int newTempo = MidiUtils.getTempoMPQ(message);
|
|
if (newTempo > 0) {
|
|
if (event.getTick() != ignoreTempoEventAt) {
|
|
setTempoMPQ(newTempo); // sets ignoreTempoEventAt!
|
|
changesPending = true;
|
|
}
|
|
// next loop, do not ignore anymore tempo events.
|
|
ignoreTempoEventAt = -1;
|
|
}
|
|
}
|
|
// send to listeners
|
|
sendMetaEvents(message);
|
|
|
|
} else {
|
|
// not meta, send to device
|
|
getTransmitterList().sendMessage(message, -1);
|
|
|
|
switch (msgStatus & 0xF0) {
|
|
case ShortMessage.NOTE_OFF: {
|
|
// note off - clear the bit in the noteOnCache array
|
|
int note = ((ShortMessage) message).getData1() & 0x7F;
|
|
noteOnCache[note] &= (0xFFFF ^ (1<<(msgStatus & 0x0F)));
|
|
break;
|
|
}
|
|
|
|
case ShortMessage.NOTE_ON: {
|
|
// note on
|
|
ShortMessage smsg = (ShortMessage) message;
|
|
int note = smsg.getData1() & 0x7F;
|
|
int vel = smsg.getData2() & 0x7F;
|
|
if (vel > 0) {
|
|
// if velocity > 0 set the bit in the noteOnCache array
|
|
noteOnCache[note] |= 1<<(msgStatus & 0x0F);
|
|
} else {
|
|
// if velocity = 0 clear the bit in the noteOnCache array
|
|
noteOnCache[note] &= (0xFFFF ^ (1<<(msgStatus & 0x0F)));
|
|
}
|
|
break;
|
|
}
|
|
|
|
case ShortMessage.CONTROL_CHANGE:
|
|
// if controller message, send controller listeners
|
|
sendControllerEvents(message);
|
|
break;
|
|
|
|
}
|
|
}
|
|
return changesPending;
|
|
}
|
|
|
|
|
|
/** the main pump method
|
|
* @return true if end of sequence is reached
|
|
*/
|
|
synchronized boolean pump() {
|
|
long currMillis;
|
|
long targetTick = lastTick;
|
|
MidiEvent currEvent;
|
|
boolean changesPending = false;
|
|
boolean doLoop = false;
|
|
boolean EOM = false;
|
|
|
|
currMillis = getCurrentTimeMillis();
|
|
int finishedTracks = 0;
|
|
do {
|
|
changesPending = false;
|
|
|
|
// need to re-find indexes in tracks?
|
|
if (needReindex) {
|
|
if (DEBUG_PUMP) Printer.println("Need to re-index at "+currMillis+" millis. TargetTick="+targetTick);
|
|
if (trackReadPos.length < tracks.length) {
|
|
trackReadPos = new int[tracks.length];
|
|
}
|
|
for (int t = 0; t < tracks.length; t++) {
|
|
ReindexTrack(t, targetTick);
|
|
if (DEBUG_PUMP_ALL) Printer.println(" Setting trackReadPos["+t+"]="+trackReadPos[t]);
|
|
}
|
|
needReindex = false;
|
|
checkPointMillis = 0;
|
|
}
|
|
|
|
// get target tick from current time in millis
|
|
if (checkPointMillis == 0) {
|
|
// new check point
|
|
currMillis = getCurrentTimeMillis();
|
|
checkPointMillis = currMillis;
|
|
targetTick = lastTick;
|
|
checkPointTick = targetTick;
|
|
if (DEBUG_PUMP) Printer.println("New checkpoint to "+currMillis+" millis. "
|
|
+"TargetTick="+targetTick
|
|
+" new tempo="+MidiUtils.convertTempo(currTempo)+"bpm");
|
|
} else {
|
|
// calculate current tick based on current time in milliseconds
|
|
targetTick = checkPointTick + millis2tick(currMillis - checkPointMillis);
|
|
if (DEBUG_PUMP_ALL) Printer.println("targetTick = "+targetTick+" at "+currMillis+" millis");
|
|
if ((loopEnd != -1)
|
|
&& ((loopCount > 0 && currLoopCounter > 0)
|
|
|| (loopCount == LOOP_CONTINUOUSLY))) {
|
|
if (lastTick <= loopEnd && targetTick >= loopEnd) {
|
|
// need to loop!
|
|
// only play until loop end
|
|
targetTick = loopEnd - 1;
|
|
doLoop = true;
|
|
if (DEBUG_PUMP) Printer.println("set doLoop to true. lastTick="+lastTick
|
|
+" targetTick="+targetTick
|
|
+" loopEnd="+loopEnd
|
|
+" jumping to loopStart="+loopStart
|
|
+" new currLoopCounter="+currLoopCounter);
|
|
if (DEBUG_PUMP) Printer.println(" currMillis="+currMillis
|
|
+" checkPointMillis="+checkPointMillis
|
|
+" checkPointTick="+checkPointTick);
|
|
|
|
}
|
|
}
|
|
lastTick = targetTick;
|
|
}
|
|
|
|
finishedTracks = 0;
|
|
|
|
for (int t = 0; t < tracks.length; t++) {
|
|
try {
|
|
boolean disabled = trackDisabled[t];
|
|
Track thisTrack = tracks[t];
|
|
int readPos = trackReadPos[t];
|
|
int size = thisTrack.size();
|
|
// play all events that are due until targetTick
|
|
while (!changesPending && (readPos < size)
|
|
&& (currEvent = thisTrack.get(readPos)).getTick() <= targetTick) {
|
|
|
|
if ((readPos == size -1) && MidiUtils.isMetaEndOfTrack(currEvent.getMessage())) {
|
|
// do not send out this message. Finished with this track
|
|
readPos = size;
|
|
break;
|
|
}
|
|
// TODO: some kind of heuristics if the MIDI messages have changed
|
|
// significantly (i.e. deleted or inserted a bunch of messages)
|
|
// since last time. Would need to set needReindex = true then
|
|
readPos++;
|
|
// only play this event if the track is enabled,
|
|
// or if it is a tempo message on track 0
|
|
// Note: cannot put this check outside
|
|
// this inner loop in order to detect end of file
|
|
if (!disabled ||
|
|
((t == 0) && (MidiUtils.isMetaTempo(currEvent.getMessage())))) {
|
|
changesPending = dispatchMessage(t, currEvent);
|
|
}
|
|
}
|
|
if (readPos >= size) {
|
|
finishedTracks++;
|
|
}
|
|
if (DEBUG_PUMP_ALL) {
|
|
System.out.print(" pumped track "+t+" ("+size+" events) "
|
|
+" from index: "+trackReadPos[t]
|
|
+" to "+(readPos-1));
|
|
System.out.print(" -> ticks: ");
|
|
if (trackReadPos[t] < size) {
|
|
System.out.print(""+(thisTrack.get(trackReadPos[t]).getTick()));
|
|
} else {
|
|
System.out.print("EOT");
|
|
}
|
|
System.out.print(" to ");
|
|
if (readPos < size) {
|
|
System.out.print(""+(thisTrack.get(readPos-1).getTick()));
|
|
} else {
|
|
System.out.print("EOT");
|
|
}
|
|
System.out.println();
|
|
}
|
|
trackReadPos[t] = readPos;
|
|
} catch(Exception e) {
|
|
if (Printer.debug) Printer.debug("Exception in Sequencer pump!");
|
|
if (Printer.debug) e.printStackTrace();
|
|
if (e instanceof ArrayIndexOutOfBoundsException) {
|
|
needReindex = true;
|
|
changesPending = true;
|
|
}
|
|
}
|
|
if (changesPending) {
|
|
break;
|
|
}
|
|
}
|
|
EOM = (finishedTracks == tracks.length);
|
|
if (doLoop
|
|
|| ( ((loopCount > 0 && currLoopCounter > 0)
|
|
|| (loopCount == LOOP_CONTINUOUSLY))
|
|
&& !changesPending
|
|
&& (loopEnd == -1)
|
|
&& EOM)) {
|
|
|
|
long oldCheckPointMillis = checkPointMillis;
|
|
long loopEndTick = loopEnd;
|
|
if (loopEndTick == -1) {
|
|
loopEndTick = lastTick;
|
|
}
|
|
|
|
// need to loop back!
|
|
if (loopCount != LOOP_CONTINUOUSLY) {
|
|
currLoopCounter--;
|
|
}
|
|
if (DEBUG_PUMP) Printer.println("Execute loop: lastTick="+lastTick
|
|
+" loopEnd="+loopEnd
|
|
+" jumping to loopStart="+loopStart
|
|
+" new currLoopCounter="+currLoopCounter);
|
|
setTickPos(loopStart);
|
|
// now patch the checkPointMillis so that
|
|
// it points to the exact beginning of when the loop was finished
|
|
|
|
// $$fb TODO: although this is mathematically correct (i.e. the loop position
|
|
// is correct, and doesn't drift away with several repetition,
|
|
// there is a slight lag when looping back, probably caused
|
|
// by the chasing.
|
|
|
|
checkPointMillis = oldCheckPointMillis + tick2millis(loopEndTick - checkPointTick);
|
|
checkPointTick = loopStart;
|
|
if (DEBUG_PUMP) Printer.println(" Setting currMillis="+currMillis
|
|
+" new checkPointMillis="+checkPointMillis
|
|
+" new checkPointTick="+checkPointTick);
|
|
// no need for reindexing, is done in setTickPos
|
|
needReindex = false;
|
|
changesPending = false;
|
|
// reset doLoop flag
|
|
doLoop = false;
|
|
EOM = false;
|
|
}
|
|
} while (changesPending);
|
|
|
|
return EOM;
|
|
}
|
|
|
|
} // class DataPump
|
|
|
|
}
|