| /* |
| * Copyright (c) 2003, 2013, 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 boolean running = false; |
| |
| |
| /** the thread for pushing out the MIDI messages */ |
| private PlayThread playThread; |
| |
| |
| /** |
| * True if we are recording |
| */ |
| private boolean recording = false; |
| |
| |
| /** |
| * 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 |
| |
| } |
