public boolean init(int nbells) {
fNBells = nbells;
try {
fSequencer = MidiSystem.getSequencer();
fSequencer.addMetaEventListener(fListener);
fSynthesizer = MidiSystem.getSynthesizer();
fMidiOut = fSynthesizer.getReceiver();
fSequencer.getTransmitter().setReceiver(fMidiOut);
/*
System.out.println(" Listing available midi devices: ");
MidiDevice.Info[] info = MidiSystem.getMidiDeviceInfo();
for (int i=0; i<info.length; i++)
{
Class c = MidiSystem.getMidiDevice(info[i]).getClass();
System.out.println(" MIDI device "+i+": "+info[i]+" is a "+c);
}
System.out.println("Using Sequencer "+fSequencer.getClass()+" and receiver "+fMidiOut.getClass());
*/
} catch (MidiUnavailableException e) {
System.out.println("Could not obtain MIDI device: " + e);
return false;
}
return true;
}
public void PlayMidiFile(String name, String filename) {
Sequencer seq = null;
Transmitter seqTrans = null;
Synthesizer synth;
Receiver synthRcvr = null;
File midiFile = null;
try {
seq = MidiSystem.getSequencer();
seqTrans = seq.getTransmitter();
synth = MidiSystem.getSynthesizer();
synthRcvr = synth.getReceiver();
midiFile = new File(filename);
if (seq == null) {
Debug.showMessage("MidiCSD::PlayMidiFile: Sequencer nicht gefunden!");
} else {
seq.open();
seqTrans.setReceiver(synthRcvr);
Sequence mySeq;
mySeq = MidiSystem.getSequence(midiFile);
new Player(name, seq, mySeq, synth, m_playing).start();
}
} catch (MidiUnavailableException e) {
Debug.showException(e, "MidiCSD::PlayMidiFile: MidiUnavailable" + e.getMessage());
} catch (InvalidMidiDataException e) {
Debug.showException(e, "MidiCSD::PlayMidiFile: InvalidMidiDataException" + e.getMessage());
} catch (IOException e) {
Debug.showException(e, "MidiCSD::PlayMidiFile:IOException (fn:" + filename + ")");
}
}
public Sequencer(int instrument, int tempo) {
// Set up initial settings for the sequencer
this.instrument = instrument;
this.tempo = tempo;
Synthesizer synth;
ticks = 0;
velocity = 64; // Mid volume
try {
// Setup values to create sequencer
sequence = new Sequence(Sequence.PPQ, 16);
sequencer = MidiSystem.getSequencer();
sequencer.open();
synth = MidiSystem.getSynthesizer();
synth.open();
sequencer.getTransmitter().setReceiver(synth.getReceiver());
sequencer.setTempoInBPM(tempo);
track = sequence.createTrack();
} catch (InvalidMidiDataException e) {
e.printStackTrace();
} catch (MidiUnavailableException e) {
e.printStackTrace();
}
}
public MidiViewImpl() {
try {
this.synth = MidiSystem.getSynthesizer();
this.receiver = synth.getReceiver();
this.synth.open();
} catch (MidiUnavailableException e) {
e.printStackTrace();
}
}
public synchronized void init() throws MidiUnavailableException {
if (unusedChannels != null) return;
if (synthesizer == null) synthesizer = MidiSystem.getSynthesizer();
if (!synthesizer.isOpen()) synthesizer.open();
MidiChannel[] chn = synthesizer.getChannels();
playTasks = new ArrayList<PlayTask>();
if (receiver == null) receiver = synthesizer.getReceiver();
unusedChannels = new ArrayList<Integer>(chn.length);
for (int i = 0; i < chn.length; i++) if (i != 9) unusedChannels.add(i);
}
/**
* Construct a MidiView with the specified model and synthesizer
*
* @param model the model to display with this view
* @param synth the synthsizer Midi object
* @throws NullPointerException if the given model is null
*/
public MidiView(MusicEditorModel model, Synthesizer synth) {
Objects.requireNonNull(model);
this.model = new MusicEditorViewModel(model);
this.synth = synth;
Receiver rcvr = null;
try {
rcvr = synth.getReceiver();
} catch (MidiUnavailableException e) {
System.err.println("unable to access Midi receiver");
}
this.receiver = rcvr;
}
/**
* Constructs a default MidiView by constructing a synthesizer and receiver, and turning the
* synthesizer open. If a MidiSystem is unavailable, an exception is thrown.
*/
public MidiView(MusicEditorModel model) {
Synthesizer synthesizer = null;
Receiver rcvr = null;
try {
synthesizer = MidiSystem.getSynthesizer();
rcvr = synthesizer.getReceiver();
} catch (MidiUnavailableException e) {
e.printStackTrace();
}
this.synth = synthesizer;
try {
this.synth.open();
} catch (MidiUnavailableException e) {
System.err.println("Midi device is unavailable");
}
this.receiver = rcvr;
this.model = new MusicEditorViewModel(model);
}
/**
* Returns an instance of a Sequencer that uses the provided Synthesizer as its receiver. This is
* useful when you have made changes to a specific Synthesizer--for example, you've loaded in new
* patches--that you want the Sequencer to use. You can then pass the Sequencer to the Player
* constructor.
*
* @param synth The Synthesizer to use as the receiver for the returned Sequencer
* @return a Sequencer with the provided Synthesizer as its receiver
* @throws MidiUnavailableException
* @version 4.0
*/
public static Sequencer getSequencerConnectedToSynthesizer(Synthesizer synth)
throws MidiUnavailableException {
Sequencer sequencer = MidiSystem.getSequencer(false); // Get Sequencer
// which is not
// connected to
// new
// Synthesizer.
sequencer.open();
if (!synth.isOpen()) {
synth.open();
}
sequencer.getTransmitter().setReceiver(synth.getReceiver()); // Connect
// the
// Synthesizer
// to
// our
// synthesizer
// instance.
return sequencer;
}
/** Gets the default transmitter and receiver, and then links them. */
private void linkTransmitterToReceiver() {
try {
// Set up the sequencer (including its tempo)
sequencer.open();
sequencer.setSequence(sequence);
sequencer.setTempoInBPM(song.getBPM());
// Get the system's default synthesizer and set that up, too.
Synthesizer synth = MidiSystem.getSynthesizer();
synth.open();
// Get the receiver and transmitter to use and set those up.
Receiver receiver = synth.getReceiver();
Transmitter transmitter = sequencer.getTransmitter();
transmitter.setReceiver(receiver);
} catch (Exception ex) {
// Something went wrong.
ex.printStackTrace();
System.exit(1);
}
}
public void run() {
try {
if (waitfor != null) waitfor.join();
Resource res = Loading.waitforint(this.res);
try {
seq = MidiSystem.getSequencer(false);
synth = MidiSystem.getSynthesizer();
seq.open();
seq.setSequence(res.layer(Resource.Music.class).seq);
synth.open();
seq.getTransmitter().setReceiver(synth.getReceiver());
} catch (MidiUnavailableException e) {
return;
} catch (InvalidMidiDataException e) {
return;
} catch (IllegalArgumentException e) {
/* The soft synthesizer appears to be throwing
* non-checked exceptions through from the sampled
* audio system. Ignore them and only them. */
if (e.getMessage().startsWith("No line matching")) return;
throw (e);
}
seq.addMetaEventListener(
new MetaEventListener() {
public void meta(MetaMessage msg) {
debug("Meta " + msg.getType());
if (msg.getType() == 47) {
synchronized (Player.this) {
done = true;
Player.this.notifyAll();
}
}
}
});
do {
debug("Start loop");
done = false;
seq.start();
synchronized (this) {
while (!done) this.wait();
}
seq.setTickPosition(0);
} while (loop);
} catch (InterruptedException e) {
} finally {
try {
debug("Exit player");
if (seq != null) seq.close();
try {
if (synth != null) synth.close();
} catch (Throwable e2) {
if (e2 instanceof InterruptedException) {
/* XXX: There appears to be a bug in Sun's
* software MIDI implementation that throws back
* an unchecked InterruptedException here when two
* interrupts come close together (such as in the
* case when the current player is first stopped,
* and then another started immediately afterwards
* on a new song before the first one has had time
* to terminate entirely). */
} else {
throw (new RuntimeException(e2));
}
}
} finally {
synchronized (Music.class) {
if (player == this) player = null;
}
}
}
}
