MIDI

Java hat eine sehr professionelle Audio - Unterstützung namens Java Sound im Package javax.sound. Sie besteht aus zwei Teilen: Sampled Audio und MIDI. "Sampled Audio" befasst sich mit der Verarbeitung von digitalisierten Audiodaten. Die Figur rechts soll dies veranschaulichen: Horizontal ist die Zeit, vertikal das Tonsignal dargestellt. Zu gewissen Zeitpunkten wird das analoge blaue Tonsignal digitalisiert ("sampled", rote Punkte). Typische Dateien, welche gesampelte Daten enthalten sind .WAV oder .MP3 Dateien. Sampled Audio wird hier (vorläufig) nicht mehr weiter besprochen - siehe dazu das alte Skript.

MIDI (Musical Instrument Digital Interface) ist eine (für Informatikverhältnisse) uralte Norm aus dem Jahre 1983. Sie besteht eigentlich aus drei Teilen: Erstens beschreibt sie eine Schnittstelle für den Zusammenschluss verschiedener elektronischer Musikgeräte (Hardware). Es handelt sich dabei um runde DIN Stecker und - Buchsen und die Kabel dazwischen. Zweitens beschreibt MIDI das Protokoll mit welchem Daten via diese Stecker und Kabel von einem Gerät zum andern übermittelt werden. Und drittens beschreibt MIDI auch Formate für Musikdateien. Sampled - und MIDI - Dateien unterscheiden sich grundsätzlich voneinander. In Sampled - Dateien ist die Musik direkt gespeichert (digitalisiert und ev. komprimiert) wie wir gesehen haben. In MIDI - Dateien werden die Töne beschrieben durch sogenannte Messages. Diese können Parameter wie Tonhöhe, Lautstärke, Instrument, etc. bestimmen. Dadurch ergeben sich viel kleinere Dateien auch verglichen mit komprimierter Sampled - Musik wie etwa mp3. Weitere Angaben zu MIDI z.B. unter http://de.wikipedia.org/wiki/MIDI oder http://www.midi.org/ (englisch!).

Die nachfolgende Figur zeigt das Zusammenspiel der verschiedenen Komponenten eines MIDI Systems an einem Beispiel:

(aus dem Java Sound Programmer Guide)

Das Java MIDI System will alle denkbaren Systeme bedienen können und ist deshalb leider auch etwas komplex!

Aber beginnen wir Schritt für Schritt: Zuerst wollen wir uns erkundigen, welche MIDI Infrastruktur im Computer vorhanden ist. Die Applikation soll in einem grafischen Fenster ablaufen, also besteht sie wie immer aus zwei Teilen: Die Klasse MIDITestFrame ist das Fenster und die Klasse MIDITest ist die main - Klasse und instanziert das Fenster. Erstellen Sie also folgende zwei Klassen in den gleichnamigen zwei Dateien in einem neuen Projekt:

MIDITest.java:

/*
* Testapplikation zum Erkunden der MIDI Umgebung:
* Main - Klasse, welche Fenster - Klasse MIDITestFrame aufruft
*
* Created on 16.09.2006 / Sö
*/

public class MIDITest {

  public static void main(String[] args) {
    MIDITestFrame frame = new MIDITestFrame();
    frame.setSize(300,200);
    frame.setVisible(true);
  }
}

MIDITestFrame.java:

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextArea;

import javax.sound.midi.*;

/*
* Testapplikation zum Erkunden der MIDI Umgebung:
* Grafisches Fenster, welches von MIDITest instanziert wird
*
* Created on 16.09.2006 / Sö
*/

public class MIDITestFrame extends JFrame {

  JTextArea t;

  MIDITestFrame() {

  //Grafische Oberfläche aufbauen:
  JPanel cp = (JPanel) this.getContentPane();
  cp.setLayout(new BorderLayout());
  JButton b = new JButton("Start");
  cp.add(b,BorderLayout.NORTH);
  t = new JTextArea();
  cp.add(t,BorderLayout.CENTER);

  //Aktion bei Tastenbetätigung:
  b.addActionListener(new ActionListener() {
    public void actionPerformed (ActionEvent e) {

        //MIDI:
        MidiDevice.Info[] infos = MidiSystem.getMidiDeviceInfo();
        String s = "Vorhandene MIDI Devices: \n";
        for (int i = 0; i < infos.length; i++) {
          s = s + infos[i].getName() + "\n";
        }
        //Darstellung Ergebnis:
        t.setText(s);
      }
    }
  );
  }
}

Die Ausgabe der Applikation nach dem Drücken der Taste auf meinem privaten PC sehen Sie rechts im Bild. Die Klasse MidiSystem ist die Drehscheibe des ganzen Java - MIDI - Systems. Unter anderem kann sie nach Geräten (MidiDevice) suchen und deren Eigenschaften feststellen mit der Methode getMidiDeviceInfo(). Sie sehen schon ein Stück weit, wie das Zusammenspiel der Komponenten des ganzen MIDI Systems (Figur oben) in Java abgebildet wird.

Machen wir ein zweites kleines Einstiegsexperiment, spielen wir einen Ton auf dem Standard - Ausgabegerät. Dazu ändern wir einfach die Methode actionPerformed() ab:

public void actionPerformed(ActionEvent e) {

  // MIDI:
  // MID - Meldung definieren:
  ShortMessage myMsg = new ShortMessage();
  try {
    // Midi - Meldung konfigurieen:
    // (Note C (60) in mittlerer Lautstärke (93))
    myMsg.setMessage(ShortMessage.NOTE_ON, 0, 60, 93);
    // Zeitmarke weglassen:
    long timeStamp = -1;
    // Receiver Objekt definieren:
    Receiver rcvr = null;
    try {
      // Den Standard - Receiver (Synthi) holen:
      rcvr = MidiSystem.getReceiver();
    } catch (MidiUnavailableException e1) {
      System.out.println("Fehler beim Holen des Receivers!");
      e1.printStackTrace();
    }
    // Die Meldung an den Receiver schicken:
    rcvr.send(myMsg, timeStamp);
    try {
    // Warten, bis der Ton verklungen ist:
    Thread.sleep(2000);
    } catch (InterruptedException e2) {
      System.out.println("Fehler beim Warten!");
      e2.printStackTrace();
    }
  } catch (InvalidMidiDataException e3) {
    System.out.println("Fehler bei Meldung!");
    e3.printStackTrace();
  }
  t.setText("Fertig!");
}

Zuerst wird eineMidi - ShortMessage erstellt.Mit ihrer Methode setMessage() kann man sie konfigurieren.Hier wird ein Ton eingeschaltet im Kanal 0 mit der Tonhöhe 60 (Note C) und der Lautstärke 93. Diese Message soll an einen Empfänger (Receiver) geschickt werden. Das MidiSystem liefert diesen Receiver mit der Methode getReceiver(), in unserem Falle den Standard - Receiver, nämlich den Synthesizer der Soundkarte(das ist eine abgekürzte Version!). Mit der Methode send() des Receivers können wir ihm (also dem Synthesizer) die Meldung schicken. Zum Schluss warten wir mit der Methode sleep() noch etwas bis der Ton verklungen ist, bevor das Programm beendet wird.

Eine Melodie spielen:

Wenn wir eine ganze Melodie spielen wollen, müssen wir dafür sorgen, dass die Töne zur richtigen Zeit gespielt werden. Den Ablauf einer Tonfolge bestimmt ein Sequencer. Auch der Sequenzer ist in Java ein Midi Device, welches uns das MidiSystem zur Verfügung stellen kann. Der Sequencer schickt dann ide Messages weiter an den Synthesitzer. Die Kommunikation zwischen MidiDevices geschieht über Transmitter und Receiver: Der Transmitter des Sequencers schickt die Messages an den Receiver des Synthesizers. Wir brauchen also vier Objekte: Den Sequencer, seinen Transmitter, den Synthesizer, seinen Receiver.Und schlussendlich müssen wir sagen, welcher Transmitter welchem Receiver was schickt und den Sequencer öffen. Das sieht dann z.B. so aus:

// MIDI:
Sequencer seq;
Transmitter seqTrans;
Synthesizer synth;
Receiver synthRcvr;
seq = MidiSystem.getSequencer();
seqTrans = seq.getTransmitter();
synth = MidiSystem.getSynthesizer();
synthRcvr = synth.getReceiver();
seqTrans.setReceiver(synthRcvr);
if (seq == null) {
 System.out.println("Sequencer nicht gefunden!");
} else {
 seq.open();
}

Die Daten, welche ein Sequencer verarbeitet sind in einer Sequenz (Sequence) gespeichert. Eine Sequenz kann man im Programm direkt erzeugen, man kann sie von einem andern Midi Device beziehen (z.B. von einem Input Port) oder man kann sie aus einer .mid - Datei laden. Letzteres wird nachfolgend gezeigt:

File myMidiFile = new File("faed_4.mid");
Sequence mySeq = MidiSystem.getSequence(myMidiFile);
seq.setSequence(mySeq);
long length = mySeq.getMicrosecondLength();
seq.start();
Thread.sleep(length/1000);
seq.close();
synth.close();

Zuerst wird eine Datei (Klasse File) bereitgestellt (Die Beispieldatei faed_4.mid finden Sie hier oder wenn Sie lieber Bach mögen jbmf_4.mid hier). Dann wird vom MidiSystem mit getSequence() eine Sequenz geholt und ihr gleich die Datei übergeben. Anschliessend wird mit setSequence() dem Sequencer die Sequenz zugeordnet. Mit getMicrosecondLenth() wird die Dauer der Sequenz abgefragt (in Mikrosekunden). Mit start() wird die Sequent gestartet, also gespielt. sleep() wartet bis die Sequenz gespielt wurde, wobei die von getMicrosecondLength() übergebene Zeit in Millisekunden umgerechnet wird.

Das Ganze muss noch in einem try / catch Block sein, nicht sehr sauber aber am einfachsten fangen Sie alle Exceptions ab mit

} catch (Exception ex) {
 System.out.println("Fehler!");
}

.

.

Und jetzt wird ein externes MIDI Gerät angesteuert:

Wenn ich den ROMI/O USB MIDI Interface Adapter an den PC anschliesse, erhalte ich mit der ersten Applikation dieses Kapitels nebenstehende Ausgabe. Achtung, diese Geräte können ihre Reihenfolge auch ändern. Also immer kontrollieren ob das richtige Gerät gewählt wurde. Das Ausgabegerät ist bei mir "2-RoMI/O MIDI".

Zur Verkabelung: Midi OUT des Interfaces muss mit Midi IN des externen Midi Geätes verbunden werden! Das externe Midi Gerät ist bei mir ein Yahama Portatone PSR-GX76.

Hier ein Testprogramm, welches einen einzigen Ton auf dem externen Gerät spielt:.

// Grafik - Bibliotheken:
import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
// MIDI - Bibliothek:
import javax.sound.midi.*;

/*
* Testapplikation schickt einen Ton zu externem Gerät:
* Grafisches Fenster, welches von MIDITest instanziert wird
* Verwendete Hardware: RomI/O USB MIDI Interface und
* Yamaha Portatone PSR-GX76
*
* Created on 7.10.2006 / Sö
*/

public class MIDITestFrame extends JFrame {

  JTextArea t;

  MIDITestFrame() {

    // Grafische Oberfläche aufbauen:
    JPanel cp = (JPanel) this.getContentPane();
    cp.setLayout(new BorderLayout());
    JButton b = new JButton("Start");
    cp.add(b, BorderLayout.NORTH);
    t = new JTextArea();
    cp.add(t, BorderLayout.CENTER);

    // Aktion bei Tastenbetätigung:
    b.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) {

        // MIDI:
        // Hole vom Midisystem die Geräteinformationen:
        MidiDevice.Info[] infos = MidiSystem.getMidiDeviceInfo();
        // Deklariere das Ausgabegerät:
        MidiDevice out;
        // Deklariere den Empfänger für das Ausgabegerät:
        Receiver outRcvr;
        try {
          // Ausgabegerät ist bei mir die Nummer 2:
          int i = 2;
          // Hole dieses Gerät:
          out = MidiSystem.getMidiDevice(infos[i]);
          // und zeige seine Infos an:
          String s = "MIDI Schnittstelle: \n";
          s = s + infos[i].getName() + "\n";
          t.setText(s);
          // öffne das Gerät, falls noch nicht offen:
          if (!out.isOpen())out.open();
          else s = s + "Port schon offen\n";
          t.setText(s);
          // hole den Empfänger des Gerätes:
          outRcvr = out.getReceiver();
          // Mache einen Ton (MIDI Message):
          ShortMessage myMsg = new ShortMessage();
          // Setze die Eigenschaften des Tones:
          // (Midi Kommando, Kanal,
          // erstes Datenbyte (Tonhöhe), zweites Db.(Dynamik))
          myMsg.setMessage(ShortMessage.NOTE_ON, 0, 60, 93);
          // Kein Zeitstempel:
          long timeStamp = -1;
          // Schicke den Ton an den Empfänger des Ausgabegerätes:
          outRcvr.send(myMsg, timeStamp);
          // warte bis der Ton verklungen ist:
          Thread.sleep(2000);
          // Schliesse das Ausgabegerät:
          out.close();
          s = s + "Ende.";
          t.setText(s);
        // Fehler abfangen:
        } catch (MidiUnavailableException e1) {
          System.out.println("MIDI Geräte - Fehler!");
          e1.printStackTrace();
        } catch (InvalidMidiDataException e2) {
          System.out.println("MIDI Message - Fehler!");
          e2.printStackTrace();
        } catch (InterruptedException e3) {
          System.out.println("Thread unterbrochen!");
          e3.printStackTrace();
        }
      }
    });
  }
}

.

Quelltexte::

• MIDITestFrame (Ton auf externes Midigerät).
• MIDISequence (Erzeugen und abspielen einer Sequenz).