Issuu on Google+

__________________________________________________________________________________________ Sound-Programmierung in Java -1-


Einführung

Dieses Tutorial soll eine kurze Einführung in die Möglichkeiten darstellen, die die Sprache Java bietet, um mit ihr Sounds, bzw Musik wiederzugeben, oder auch eigenständig aufnehmen zu können. Das Tutorial ist in drei Teile gegliedert. Teil I und II beschäftigen sich ausschliesslich mit der Java Sound API V0.99, die als Teil des Java Media Frameworks (JMF) vertrieben wird. Teil III bietet darüber hinaus eine knappe Einführung in das Java Media Framework. Zum Zeitpunkt der Textbearbeitung, befand sich die Java Sound API schon in der Version 1.0, die fester Bestandteil des Java SDK 1.3 RC1 ist. Nach Angaben von Sun sollen aber keine gravierenden Änderungen zwischen der Version 0.99 und 1.0 stattgefunden haben; daher sind die Aussagen, die hier getroffen werden auch für die aktuellere Version gültig. Das Anliegen dieses Tutorials ist nicht, die gesamte API, bzw. das gesamte JMF mit all ihren Klassen und Methoden zu beschreiben, sondern es soll dem Leser als Erleichterung dienen, seine Programme um die Möglichkeiten der Java Sound API bzw. des JMF zu erweitern. Zu nennen wäre hier beispielsweise das Abspielen von Sounddateien in Programmen (z.B. die korrekte Aussprache einer Vokabel in einem Vokabeltrainer) oder aber auch die Möglichkeit, eigene Sounddateien zu kreieren. Für eine komplette Übersicht über alle Klassen und Methoden der Java Sound API und des Java Media Framework sei der Leser auf die Java Sound Page von Sun [1] verwiesen. Das Tutorial ist so angelegt, neben unausweichlichen Theorieaspekten der Soundgenerierung, ohne die man die Klassengliederung der API und des JMF nicht nachvollziehen kann, vor allem an möglichst einfach gehaltenen Beispielprogrammen das Einbinden von Sound in die eigenen Programme zu zeigen. Hierfür gibt es die sogenannten „Wie kann man ...“ - Abschnitte im Text, die sich einfachen Fragestellungen widmen (zum Beispiel Wie kann man ... Sounddateien wiedergeben, die sich auf der Festplatte befinden?) und dem Leser hoffentlich bei Standardproblemen bzw. -fragen helfen. Man kann diese Abschnitte also als eine Sammlung von „Kochrezepten“ verstehen, die bei auftretenden Problemen helfen sollen. Im Text wird auch außerdem auf Probleme mit der API hingewiesen, die uns beim Verfassen des Textes aufgefallen sind. Einige Klassen befinden sich noch in einem - nach unserer Meinung - nicht ganz ausgereiftem Stadium und erfüllen nicht alle Aufgaben so, wie sie von Sun in der Dokumentation spezifiziert wurden.

__________________________________________________________________________________________ Sound-Programmierung in Java -2-


Die Java Sound API gliedert sich in die vier Unterpakete: • javax.sound.sampled • javax.sound.sampled.spi • javax.sound.midi • javax.sound.midi.spi

In diesem Text werden nur die beiden Pakete javax.sound.sampled , javax.sound.midi näher beschrieben . Die beiden anderen Unterpakete und die darin enthaltenen Klassen, sind für Hersteller gedacht, um mit ihnen – z.B. eigene Audiokomprimierungsverfahren - einfach ihre Erweiterungen in die Java Sound API einbinden zu können. Wer nähere Informationen zu diesen beiden Paketen benötigt, findet eine kurze Einführung in der offiziellen Sun-Dokumentation zur Sound API, die man unter [1] finden kann. Teil I dieses Tutorials widmet sich dem Paket javax.sound.sampled und den dazu passenden Problem- und Fragestellungen. Teil II hingegen beschäftigt sich mit dem javax.sound.midi - Paket und dessen Anwendung in der Praxis. Teil III bespricht die audiophilen Aspekte des Java Media Framework.

__________________________________________________________________________________________ Sound-Programmierung in Java -3-


TEIL I javax.sound.sampled

__________________________________________________________________________________________ Sound-Programmierung in Java -4-


Kapitel 1 - Einführung in Sampled Audio

Das Paket javax.sound.sampled richtet seinen Hauptaugenmerk auf den Transport von AudioDaten, d.h. in erster Linie auf das Abspielen und Aufnehmen von digitalem Sound. Die wichtigste Aufgabe ist hierbei, wie die AudioBytes in das System hinein- und wieder heraus transportiert werden. Die Java Sound API kann den Audio-Datentransport auf zwei verschiedene Arten bewerkstelligen. Es gibt auf der einen Seite den gepufferten und gestreamten Weg und auf der anderen den in-memory ungepufferten. Der erste bietet sich bei kleinen Sounddateien an (um auf unser Vokabeltrainerbeispiel zurückzukommen wären dies die Vokabel-Sounddateien), der zweite bei sehr grossen Dateien (zum Beispiel bei gegrabbten Audio-Tracks einer CD). Beide Ansätze werden genauer im Kapitel 2 - Abspielen von Audio-Files besprochen. Kommen wir jetzt zu den grundlegenden Eigenschaften der API.

Was benötigt man um Soundfiles mit der API abspielen zu können ? Um Sound wiederzugeben oder aufzunehmen werden 3 wichtige Dinge benötigt: in einem bestimmten Format vorliegende Audio-Daten (z.B. den Audio-Track einer CD als Wave Datei), einen sogenannten Mixer und eine Line.

Was sind formatierte Audio-Daten ? Als formatierte Audio-Daten werden Sounds bezeichnet, die in einem Standard-Sounddateiformat vorliegen; dazu zählen beispielsweise WAV - Dateien oder AU - Dateien. Die Java Sound API unterscheidet zwischen Datenformaten und Fileformaten. Das Datenformat einer Sounddatei bestimmt, wie das Programm, das die Sounddatei bzw. dessen Audiodaten wiedergibt, diese interpretieren soll. Repräsentiert werden diese Informationen z.B. durch die Sample-Rate (d.h. wie viele Samples der Original-Audiodaten pro Sekunde gespeichert werden) oder durch die Anzahl der Kanäle (d.h. 1 Kanal = Mono-, 2 Kanäle = Stereoqualität usw.). Das Datenformat einer Sounddatei wird in der Java Sound API durch die Klasse AudioFormat spezifiziert. Das Fileformat einer Sounddatei bestimmt die innere Struktur einer Audiodatei, z.B. die Angabe in welchem Audioformat die Sounddatei vorliegt.

__________________________________________________________________________________________ Sound-Programmierung in Java -5-


Standard-Audiofileformate gibt es einige. Zu nennen wären hier WAVE (die Windows .wav-Dateien), AIFF, oder AU. Diese verschiedenen Formate besitzen alle eine unterschiedliche interne Strukturen die die Informationen über die Sounddatei widerspiegeln. In der Java Sound API wird das Fileformat durch die Klasse AudioFileFormat spezifiziert. Sie enthält Informationen über das Audiofileformat der verknüpften Sounddatei, deren Länge in Bytes usw.

Was ist ein Mixer ? In der Java Sound API werden Audiogeräte, die sich in oder an der Maschine befinden, durch die sogenannte Mixer Klasse repräsentiert. Der Anspruch dieser Klasse liegt darin, die AudioIn - und Outputströme in das jeweilige Gerät zu koordinieren oder zu beeinflussen (beispielsweise dieLaustärke bei der Ausgabe); der Mixer fungiert also in ähnlicher Weise wie ein Mischpult. In der Java Sound API sind den Eingängen und Ausgängen einer Soundkarte keine eigenen Mixer zugeordnet, sondern sogenannte Ports die in der Klasse Port zusammengefaßt werden. Diese Ports (z.B. der Mikrofoneingang an der Soundkarte) werden durch den Mixer gesteuert. Da in den hier besprochenen Standardproblemen die Mixer nicht benötigt werden, finden sie in diesem Tutorial auch keine weitere Beachtung und sollen an dieser Stelle nur der Vollständigkeit halber erwähnt werden. Wichtig sind die Mixerobjekte erst dann, wenn ein anderes installiertes Gerät als die Standardsoundkarte zur Sounderzeugung bzw. –aufnahme benutzt wird. Anzumerken ist hier, daß sich die Portobjekte in der Version 0.99 (und nach den Angaben in der Java Sound Mailingliste[4] auch in der Version 1.0) noch in nicht nutzbarem Stadium befinden. Es ist nicht möglich, etwa den Mikrofoneingang und dessen Einstellungen über ein Portobjekt zu beeinflussen oder ihn auf stumm zu schalten.

Was ist eine Line ? Als Line wird in der Java Sound API der Pfad beschrieben, auf dem Audiodaten in das System hineingelangen oder hinausgelangen. Ein Beispiel für den Pfad in das System wäre das Mikrofon, ein Pfad aus dem System heraus die angeschlossenen Lautsprecher. Java Sound API – Objekte, die als Line bezeichnet werden, sind Ports, TargetDataLine, SourceDataLine

und Clip.

Kommen wir nun nach den theoretischen Grundlagen der API zur Anwendung dieser Klassen und damit zunächst zur Soundgenerierung.

__________________________________________________________________________________________ Sound-Programmierung in Java -6-


Kapitel 2 - Die Soundgenerierung

Die wichtigste Klasse in dem Paket javax.sound.sampled ist die statische Klasse AudioSystem. Mit Hilfe dieser Klasse hat man Zugriff auf die installierten Audiogeräte in einem System. Dies bedeutet im einzelnen, daß mit der Klasse AudioSystem :

-

Mixer - Objekte erzeugt kann mit denen man auf bestimmte Geräte im System speziell zugreifen kann das man Lineobjekte erzeugen kann um den Strom von Audiodaten in das System herein und

-

wieder heraus zu ermöglichen -

das

man

mit

ihrer

Hilfe

Audiodaten

konvertieren

kann

zwischen

verschiedenen

Audiodatenformaten -

streams zu Audiodaten geöffnet werden, um diese zu lesen oder zu schreiben.

Wichtigster Punkt ist aber, daß man mit ihr direkt auf die Soundkarte zugreifen kann ohne, vorher umständlich ein Mixer - Objekte anzulegen und dann über diese die Soundkarte und die Soundgenerierung zu steuern. Da die Klasse AudioSystem für unseren Ansatz vollkommen ausreicht, werden in diesem Tutorial keine Mixer – Objekte benutzt. Bevor wir mit dem Generieren von Sound beginnen, müssen wir noch auf die verschiedenen Sicherheitsaspekte hinweisen, wenn der Java Security Manager im Einsatz ist. Folgende Zugriffe sind per default erlaubt und sollten beim Programmieren mit der API berücksichtigt werden: • Applets Soundwiedergabe möglich, Soundaufnahme nicht möglich • Applikationen, die mit keinem security manager laufen, können Sound sowohl aufnehmen als auch wiedergeben • Applikationen, die mit dem default security manager laufen, können Sound wiedergeben, aber keinen Sound aufnehmen

Beim Generieren von Sound kommen wir zunächst wieder zum schon besprochenen Lineobjekt zurück. Wir haben zwei Ansatzmöglichkeiten den Sound mit der API wiederzugeben. Zum Einen können Audio-files vor dem Abspielen komplett in den Arbeitsspeicher des Rechners geladen werden (was nur bei sehr kleinen Dateien zu empfehlen ist), zum anderen können jeweils nur kleine Teile des Audiofiles in den __________________________________________________________________________________________ Sound-Programmierung in Java -7-


Speicher geladen und dann abgespielt werden. Dies spiegelt sich in den Klassen wider, die zum Abspielen benutzt werden können: die Clip Klasse, die den ersten Ansatz verfolgt, und die SourceDataLine Klasse, die den zweiten Ansatz realisiert. Beide werden zu den Lineobjekten

gezählt.

Wie kann man ... Audiofiles als Clip abspielen ? Erster Schritt beim Abspielen einer Sounddatei mit Hilfe der Clip-Klasse sollte sein, ein File Objekt zu erzeugen, das auf die wiederzugebende Sounddatei verweist. File file = new File("ding.wav"); In unserem Beispiel soll eine Wave-Datei mit dem Namen „ding.wav“ wiedergegeben werden. Als nächsten Schritt müssen wir von dem Java Sound System einen sogenannten AudioInputStream anfordern, der später die Daten der Sounddatei für uns in den Speicher des Rechners liest. AudioInputStream stream = AudioSystem.getAudioInputStream(file); Als Übergabeparameter geben wir der getAudioInputStream - Methode das File - Objekt. Danach benötigt man ein Line - Objekt, das den Eingang für das Java Sound System spezifiziert. D.h. welche Eingangsquelle das Java Sound System bei der Soundgenerierung benutzen soll. In unserem Fall, handelt es sich um ein Clip - Objekt, da wir die Audiodaten vor der Wiedergabe komplett in den Hauptspeicher lesen und von dort aus die Wiedergabe durchführen wollen. Um an dieses Clip Objekt über das Java Audiosystem zu gelangen, muss im voraus ein sogenanntes LineInfo - Objekt erzeugt werden. Dieses definiert dem Java AudioSystem welche Art von Dateneingangsquelle wir bei der Wiedergabe unseres Sound benutzen wollen. Ein solches Objekt (in der Java Sound API repräsentiert durch die Line.info Klasse) kann aber nicht direkt erzeugt werden, sondern nur ein Objekt seiner Unterklassen Port.info oder DataLine.info. Da die Port - Objekte in der aktuellen Version des Paketes noch nicht vollständig implementiert sind, werden hier nur die DataLine - Objekte (Clip, SourceDataLine und TargetDataLine) benutzt und besprochen. Wir werden also nun ein DataLine - Objekt erzeugen: DataLine.Info info = newDataLine.Info(Clip.class,stream.getFormat()); Als Parameter erwartet der Konstruktor den Klassentyp, der zur Wiedergabe benutzt werden soll (also Clip - Klasse oder SourceDataLine - Klasse) und das Audiodatenformat der Sounddatei, die abgespielt werden soll. Das Format unserer Datei bekommen wir einfach, indem wir die AudioInputStream - Methode getFormat() benutzen.

__________________________________________________________________________________________ Sound-Programmierung in Java -8-


Nachdem wir diese Vorarbeiten geleistet haben, fordern wir unser Clip - Objekt von dem Soundsystem an. Hierzu wird dem AudioSystem die vorbereitete DataLine.info Klasse übergeben: Clip clip = (Clip) AudioSystem.getLine(info); Als nächstes müssen wir für unsere Applikation dieses Clip – Objekt reservieren, damit kein anderes Programm dieses Objekt währendessen nutzen kann. Dies geschieht durch eine open - Anweisung: clip.open(stream); Der Anweisung muß der AudioInputStream übergeben werden, der mit der wiederzugebenden AudioDatei verknüpft ist. Nachdem der Clip geöffnet und so für unsere Anwendung reserviert wurde, können wir die Wiedergabe starten. Dies geschieht, indem wir eine start - Anweisung benutzen: clip.start(); Nun wird der Clip bzw. unsere Sounddatei wiedergegeben. Um die Wiedergabe zu unterbrechen genügt eine einfache stop - Anweisung: clip.stop(); Gibt man nun wieder eine start - Anweisung, wird die Wiedergabe exakt an der Stelle fortgesetzt, an der vorher die stop - Anweisung gegeben wurde. Ist die Wiedergabe des Clips beendet und man der Clip bzw. die Datei soll nicht noch einmal wiedergeben werden, gibt man durch eine close - Anweisung alle gebundenen Resourcen wieder frei: clip.close(); Dies sind die typischen Schritte bei der Wiedergabe einer Sounddatei über den Clip - Ansatz. Hier nun ein komplettes Beispielprogramm PlaySound.java : import javax.sound.sampled.*; import java.io.*; class PlaySound { static File file = null; static AudioInputStream stream = null; static Clip clip = null; public static void main (String args[]) { System.out.println("Spiele wav ..."); //bestimme welche Sounddatei abgespielt werden soll file = new File("ding.wav"); //versuche EingabeStream auf die abzuspielende Sounddatei zu //bekommen __________________________________________________________________________________________ Sound-Programmierung in Java -9-


try { stream = AudioSystem.getAudioInputStream(file); }catch(UnsupportedAudioFileExceptione){System.out.println("Kein unterstuetztes AudioFormat!");System.exit(0);} catch(IOException e2){System.out.println("Fehler beim Oeffnen der Sounddatei!");System.exit(1);} //erzeuge LineObjekt das spezifiziert welche Line vom AudioSystem zur //Wiedergabe benutzt werden soll DataLine.Info info = new DataLine.Inf(Clip.class,stream.getFormat()); //versuche gewuenschte Eingangs-Line beim AudioSystem anzumelden try{ clip = (Clip) AudioSystem.getLine(info); }catch(LineUnavailableException e){System.out.println("Line konnte nicht benutzt werden");System.exit(1);} //oeffne das Clipobjekt und reserviere es somit fuer diese //Applikation try{ clip.open(stream); }catch(LineUnavailableException e){System.out.println("Fehler beim Öffnen des AudioStreams");System.exit(1);} catch(IOException e){} //beginne die Wiedergabe clip.start(); //warte solange wie das AudioSystem den Clip wiedergibt while(clip.isActive()){} //stoppe Clip nachdem er komplett wiedergegeben wurde clip.stop(); //schliesse den Clip und gib somit die gebundenen Resourcen wieder //frei clip.close(); //beende ordnungsgemaess das Programm System.exit(0); } }

Dieses Programm spielt eine Wave - Datei in der vorher besprochenen Weise ab. Hinzugekommen ist dabei noch die Clip - Methode [Clip].isActive(). Diese gibt ein false zurück, wenn die Wiedergabe des Soundclips gestoppt wurde, entweder weil das Ende der Audiodatei erreicht wurde, oder weil eine stop - Anweisung vorher erfolgt ist. An dieser Stelle wird gut sichtbar, welche Methoden Java Exceptions auslösen können und um welche es sich __________________________________________________________________________________________ Sound-Programmierung in Java - 10 -


dabei handelt. Für eine komplette Übersicht der bisher behandelten Methoden, die Exceptions auslösen können, sei auf das Ende dieses Kapitels verwiesen. Weitere Clip – Methoden, die hier nicht weiter besprochen werden, aber in manchen Anwendungen hilfreich sein können, sind:

void loop(int count) - startet die Wiedergabe eines Clips und wiederholt diesen count - mal long getMicrosecondLength() - gibt die Länge des Sounds in Mikrosekunden an long getMicrosecondPosition() - gibt die aktuelle Position bei der Wiedergabe in Mikrosekunden an Nun zeigen wir, wie man den zweiten Ansatz vollziehen kann bei der Wiedergabe einer Sounddatei, nämlich ...

Wie kann man ... Audiofiles als SourceDataLine abspielen ? Zunächst erzeugt man wie beim ersten Ansatz ein File Objekt. Danach wird wieder ein Objekt vom Typ

AudioInputStream

generiert.

Als

nächster

Schritt

liegt

die

Erzeugung

eines

DataLine.info Objekt vor. Num kommen wir zum ersten Unterschied zum ersten Ansatz. Dem Konstruktor der DataLine.info Klasse wird nun nämlich mitgeteilt das eine SourceDataLine gewünscht wird. Man ersetzt also Clip.class durch SourceDataLine.class und erhält: DataLine.Info info = new DataLine.Info(SourceDataLine.class, stream.getFormat()); Als nächste wird vom AudioSystem ein Objekt vom Typ SourceDataLine angefordert: SourceDataLine sl = (SourceDataLine)AudioSystem.getLine(info); Dies geschieht auf gleichem Wege wie bei dem Clip - Ansatz. Die nächsten Schritte sind ebenfalls gleich, da nun eine open - Anweisung - gefolgt von einer start Anweisung - gemacht werden muss. Vor dem eigentlich Lesen der Audiodaten aus der Sounddatei muss noch ein Byte-Array angelegt werden, in dem die gelesenen Audiodaten gepuffert werden. Ist dies erledigt, folgt das Auslesen der Audioinformationen aus der Sounddatei. Da die Klasse AudioInputStream eine von der Klasse InputStream abgeleitete Klasse darstellt, wird hierzu die bekannte read - Methode benutzt. __________________________________________________________________________________________ Sound-Programmierung in Java - 11 -


Es wird solange die Anweisung int numBytesRead = stream.read(ba,0,1024); wie numBytesRead nicht den Wert -1 annimmt. Wird dieser Wert nämlich zurückgeliefert, ist das Ende der Sounddatei beim Auslesen der Audioinformationen erreicht. Die Methode read schreibt in das vorher angelegte ByteArray ba die ausgelesenen Audiodaten der Quelldatei. Hierbei werden die Arrayfelder 0 bis 1024 benutzt. Nach der read - Anweisung wird das ByteArray der SourceDataLine - Methode write übergeben, was die Wiedergabe der darin enthaltenen Audiodaten veranlasst. Nach dem Verlassen der read - write -Schleife, also nachdem das Ende der Quelldatei erreicht und alle Audiodaten ausgelesen wurden, wird die SourceDataLine - Methode drain() aufgerufen, die solange blockt, bis alle sich noch im internen Puffer befindlichen Audiodaten verarbeitet wurden; somit ist gewährleistet, daß die Sounddatei komplett wiedergegeben wurde. Danach erfolgen - wie schon von dem Clip - Ansatz her bekannt - noch stop - und close Anweisungen. Damit wären alle Schritte abgehandelt, die nötig sind, um mit Hilfe einer SourceDataLine eine Sounddatei wiederzugeben. Nun wollen wir dazu ein komplettes Beispiel zeigen, nämlich PlaySoundStreamed.java: import javax.sound.sampled.*; import javax.sound.midi.*; import java.io.*; class PlaySoundStreamed { static File file = null;

//die zu streamende Datei

static AudioInputStream stream = null;//ueber diesen Stream //werden die AudioDaten aus der //Datei "file" gelesen static SourceDataLine sl = null;

//ueber diese DataLine wird die //Datei "file" abgespielt

static byte

ba[] = null;

// Array enthaelt die //Sounddateibytes die aktuell aus //dem AudioInputStream "stream" //gelesen wurden und dann ueber //die SourceDataLine "sl" //abgespielt werden

static int numBytesRead = 0;

//Anzahl der gelesenen Bytes aus //dem InputStream

static PlaySoundStreamed pss = null; __________________________________________________________________________________________ Sound-Programmierung in Java - 12 -


public PlaySoundStreamed(File fi) { //erzeuge den InputStream auf die Datei "file" try { stream = AudioSystem.getAudioInputStream(file); }catch(UnsupportedAudioFileException e) {System.out.println("AudioFormat wird nicht unterstuetzt!");} catch(IOException e2){System.out.println("Fehler beim Oeffnen der Quelldatei!");} //erzeuge DataLine.info die spezifiziert welche Art von Eingabe man //haben will beim AudioSystem DataLine.Info info = new DataLine.Info (SourceDataLine.class, stream.getFormat()); //versuche mit Hilfe von "info" die gewünschte Eingabe beim //AudioSystem zu bekommen try{ sl = (SourceDataLine) AudioSystem.getLine(info); }catch(LineUnavailableException e){System.out.println("Line konnte nicht benutzt werden");System.exit(1);} } public static void main (String args[]) { file = new File("1-welcome.wav"); pss = new PlaySoundStreamed(file); System.out.println("Spiele wav ..."); // oeffne und reserviere somit fuer diese Applikation die //SourceDataLine try{ sl.open(); }catch(LineUnavailableException e){System.out.println("Fehler beim Öffnen des AudioStreams");System.exit(1);} // starte die Line zum Abspielen des Sounds sl.start(); // lege den Buffer an in den die Sounddateidaten eingelesen werden //ueber die AudioInputStream ba = new byte[1024]; //Spiele Sound while(true) { __________________________________________________________________________________________ Sound-Programmierung in Java - 13 -


//lese SounddateiDaten in Buffer ein try { numBytesRead = stream.read(ba,0,1024); }catch(IOException e){System.out.println("Fehler beim Lesen der Sounddatei-Bytes"); System.exit(1);} //wenn Ende der Sounddatei bzw. Streams erreicht beende Schleife if (numBytesRead == -1) break; //Ende der Sounddatei erreicht! // schreibe gelesene Sounddateidaten in SourceDataLine und veranlasse //somit das Abspielen der Daten sl.write(ba,0,ba.length); } // blockiere bis die letzten Daten abgespielt wurden sl.drain(); // halte die Line an und schliesse die Line sl.stop(); sl.close(); sl=null; System.out.println("

... Fertig!");

System.exit(0); } }

Wie man sieht, gibt es bis auf die while - Schleife keine großen Unterschiede zur PlaySound Applikation. In dieser Schleife werden jeweils kleine Pakete von Sounddaten aus der Quelldatei gelesen und dann auf die SourceDataLine geschrieben. Dieses Schreiben veranlasst, daß Java Sound System, die empfangenen Sounddaten über die Soundkarte abzuspielen. Ungewöhnlich erscheint vielleicht der

Aufruf der Methode [SourceDataLine].drain() nach dem Verlassen der Schleife. Diese Methode ist wichtig, damit beim Austritt aus der Schleife nicht direkt die stop - Anweisung folgt und dadurch die Wiedergabe gestoppt wird, obwohl sich eventuell noch nicht wiedergegebene Sounddaten im System befinden. Die Methode blockt also solange,

bis

alle

Daten korrekt abgespielt wurden. __________________________________________________________________________________________ Sound-Programmierung in Java - 14 -


Eine verfeinerte Version des obigen Programms findet man im Anhang A, bei dem man jederzeit die Wiedergabe durch Tastendruck beenden kann (siehe PlaySoundStreamedT.java). Zum Schluß dieses Kapitels, fassen wir in einer Tabelle noch einmal die Methoden der Java Sound API zusammen, die die Möglichkeit haben, Java Exceptions zu erzeugen:

Methode AudioSystem.getAudioInputStream( ) AudioSystem.getLine( ) [Line – Objekt].open( ) [AudioInputStream – Objekt].read( ) [AudioOutputStream – Objekt].write( )

erzeugte Exception UnsupportedAudioFileException, IOException, LineUnavailableException, SecurityException, IllegalArgumentException LineUnavailableException IOException IOException

__________________________________________________________________________________________ Sound-Programmierung in Java - 15 -


Kapitel 3 - Die Aufnahme

Die Aufnahme einer Sounddatei gestaltet sich in großen Abschnitten ähnlich wie das Abspielen von Dateien. Neu hinzugekommen sind Objekte vom Typ TargetDataLine.

Was ist eine TargetDataLine ? Über eine TargetDataLine hat man die Möglichkeit Audiodaten, die in das Java Sound System hinein gelangen, zu lesen. Daher stellen diese Line - Objekte die wichtigsten Werkzeuge dar, mit denen bei der Soundaufnahme gearbeitet wird. TargetDataLine bekommt seine Daten direkt von einem „vorgeschaltenen“ Mixer - Objekte oder von der AudioSystem - Klasse der Java Sound API. Diese beiden Objekte können Audiodaten, die sie eventuell vorher noch bearbeitet haben (beispielsweise Hall hinzufügen oder die Balance zwischen linken und rechtem Kanal beinflussen) direkt in den internen Puffer einer TargetDataLine hineinschreiben. An diese Daten gelangt man dann über eine read - Methode, deren Übergabeparameter gleich denen der read - Methode bei der Klasse InputStream sind. Dies resultiert aus der Tatsache, das TargetDataLine eine von InputStream abgeleitete Klasse darstellt. Diese zu verarbeitenden Audioinformationen können beispielsweise über ein angeschlossenes Mikrofon oder über den Line-In - Eingang der Soundkarte in das Java Sound System gelangen.

Wie kann man ... selber Audiodaten aufnehmen ? Man entscheidet zunächst, in welchem Format und mit welcher Qualität die Daten aufgezeichnet werden sollen. Hierzu wird ein AudioFormat - Objekt erzeugt, das diese Punkte genau spezifiziert. AudioFormat af = new AudioFormat((float)11025.0,16,2, true,false); Danach erfolgt das schon bekannte Erzeugen eines DataLine.info - Objektes. DataLine.info info = new DataLine.Info (TargetDataLine.class,af); Zu beachten ist jetzt hierbei, das dem Konstruktor als erster Parameter TargetDataLine.class übergeben wird, da wir ja solch ein Line - Objekt im folgenden Schritt vom AudioSystem erhalten wollen:

TargetDataLine tl = (TargetDataLine) AudioSystem.getLine(info); __________________________________________________________________________________________ Sound-Programmierung in Java - 16 -


Als nächstes müssen wir unsere TargetDataLine tl für unsere Applikation reservieren, damit keine andere Anwendung diese für sich beanspruchen kann. Das geschieht durch eine einfache open Anweisung: tl.open(af); Als Übergabeparamter haben wir hier nicht den AudioInputStream wie bei dem Verfahren zur Soundwiedergabe

gesehen,

sondern

das

gewünschte

Audioformat,

in

dem

über

die

TargetDataLine nachher die Audioaufnahmen gemacht werden sollen. Nun wird die start() - Methode der TargetDataLine aufgerufen: tl.start();

Alle Audiodaten, die in das AudioSystem fliessen, können nun mit der eben schon erwähnten read - Methode über die TargetDataLine gelesen werden. Zur Verdeutlichung, sei an dieser Stelle folgendes Beispielprogramm mit dem Namen CaptureAudio.java eingebracht: import javax.sound.sampled.*; import java.io.*; class CaptureAudio extends Thread { static AudioInputStream stream = null; //uber diesen Stream werden //die aufgenommenen AudioDaten //ausgelesen static AudioFormat af = null;

//gibt das AudioFormat an in dem //die Aufnahme gemacht werden soll

static byte

ba[] = null,

// Array enthaelt die Sounddateibytes //die aktuell aus dem AudioInputStream //"stream" gelesen wurden und dann ueber //die SourceDataLine "sl" abgespielt //werden

caB[] = null; static

int numBytesRead = 0;// Anzahl der gelesenen Bytes

static CaptureAudio ca = null; static boolean capture = true; static SourceDataLine sl = null; static TargetDataLine tl = null; static ByteArrayOutputStream baOut = null; static ByteArrayInputStream baIn = null; static DataLine.Info info; public CaptureAudio() {

__________________________________________________________________________________________ Sound-Programmierung in Java - 17 -


// bestimmt das Soundformat in dem die Aufnahme gemacht werden soll af = new AudioFormat((float)11025.0,16,2,true,false); // bestimmt welche Art von Line vom AudioSystem angefordert wird info = new DataLine.Info (TargetDataLine.class,af); // versuche Line von AudioSystem anzufordern try { tl

= (TargetDataLine) AudioSystem.getLine(info);

}catch(LineUnavailableException e) {System.out.println("AudioSystem hat keine Line frei"); System.exit(1);} //oeffne und reserviere somit fuer diese Applikation die //TargetDataLine try { tl.open(af); }catch(LineUnavailableException e){System.out.println("Fehler beim Ă–ffnen des AudioStreams");System.exit(1);} }

public void run() { baOut = new ByteArrayOutputStream(); int numBytesRead = 0; //Puffer in den die aufgenommenen Daten eingelesen werden ba = new byte [64]; // starte die Line zum Aufnehmen des Sounds tl.start(); // starte Aufnahme while(capture) { //lese SounddateiDaten in Buffer ein numBytesRead = tl.read(ba,0,ba.length); //schreibe in aktuelle AudioDatenbytes auf OutputStream baOut.write(ba,0,numBytesRead); }

// blockiere bis die letzten Daten geschrieben wurden tl.drain(); // halte die Line an und schliesse die Line tl.stop(); __________________________________________________________________________________________ Sound-Programmierung in Java - 18 -


tl.close(); tl=null; System.out.println("

... Fertig mit Aufnahme");

System.out.println("...STOP"); System.out.println("Spiele aufgenommenen Sound ab ...");

//lese aufgenommene Audiodaten aus caB = baOut.toByteArray(); System.out.println("Anzahl der gecaptureten Bytes:"+caB.length); //uebergebe alle gelesenen Audiodaten an Inputstream baIn = new ByteArrayInputStream(caB); //oeffne InputStream auf gelesene Audiodaten stream = new AudioInputStream(baIn, af,caB.length / af.getFrameSize()); //erzeuge DataLine.info die spezifiziert welche Art von Eingabe man //haben will beim AudioSystem info = new DataLine.Info(SourceDataLine.class, stream.getFormat()); //versuche mit Hilfe von "info" die gewünschte Eingabe beim //AudioSystem zu bekommen try{ sl = (SourceDataLine) AudioSystem.getLine(info); }catch(LineUnavailableException e){System.out.println("Line konnte nicht benutzt werden");System.exit(1);} try{ // öffne Line zum Abspielen des Sounds sl.open(); }catch(LineUnavailableException e){System.out.println("Fehler beim Öffnen des AudioStreams");System.exit(1);} // starte die Line zum Abspielen der aufgenommenen Audiodaten sl.start(); while(true) { //lese SounddateiDaten in Buffer ein try { numBytesRead = stream.read(ba,0,64); }catch(IOException e){System.out.println("Fehler beim Lesen der SounddateiDaten");System.exit(1);}

__________________________________________________________________________________________ Sound-Programmierung in Java - 19 -


//wenn Ende der Sounddatei bzw. Streams erreicht beende Schleife if (numBytesRead == -1) break; //Ende der Sounddatei erreicht! // schreibe gelesene Sounddateidaten in //SourceDataLine und veranlasse somit das Abspielen //der Daten sl.write(ba,0,ba.length); }

// blockiere bis die lezten Daten abgespielt wurden sl.drain(); // halte die Line an und schliesse die Line sl.stop(); sl.close(); System.out.println("

... Fertig!");

System.exit(0); } public static void main (String args[]) { ca = new CaptureAudio(); //starte den Aufnahmethread ca.start(); System.out.println("Aufnahme ..."); System.out.println("Druecke <RETURN> fuer Aufnahme-STOP"); try { int c = System.in.read(); }catch(IOException e){System.exit(1);} capture = false; } }

Dieses Beispielprogramm dem Nutzer, eine Audioaufnahme zu machen, die das Programm anschließend noch einmal abspielt. Das Programm beginnt zunächst damit, im Konstruktor die oben beschriebenen Schritte durchzuführen bzw. abzuarbeiten. Es wird ein Audioformat gewählt (für eine genaue Beschreibung, welche Formate man wählen kann und wie man sie erstellt s. Kapitel 4 - Audioformate): In unserem Beispiel soll in einer Qualität von 11025Hz, 16Bit und Stereo aufgenommen werden. __________________________________________________________________________________________ Sound-Programmierung in Java - 20 -


Als nächstes wird eine TargetDataLine erzeugt und geöffnet, die Line wird gestartet und die Aufnahme kann beginnen. Dies wird in der run - Methode des Threads erledigt. Man durchläuft hier solange eine Schleife, bis der Nutzer die Return-Taste betätigt und dadurch der boolschen Variable capture den Wert false zuweist. In dieser Schleife wird die TargetDataLine - Methode read()mit einem vorher angelegten Bytearray aufgerufen. Dieses Array stellt als erster Parameter einen Puffer dar. Der zweite Paramter benennt die Position des Arrays, an der begonnen werden soll es mit gelesenen Audiodaten zu füllen; der dritte Parameter gibt den Index an, bis zu dem dies durchgeführt werden soll. Dieses Vorgehen entspricht dem bei einem InputStream und sollte daher dem Leser nicht neu vorkommen. Die read - Methode liefert die Anzahl der beim letzten Aufruf gelesenen Bytes zurück. Als

nächsten

Schritt

in

der

while

-Schleife

wird

das

gelesene

Array

ba

in

den

ByteArrayOutputStream baOut geschrieben. An dieser Stelle könnte auch ein anderer Stream auftreten, zum Beispiel einer, der die Daten auf die Festplatte schreibt. Dieser read - write - Zyklus wird, wie schon erwähnt, so lange wiederholt, bis der User die Return Taste betätigt. Geschieht dies, wird nach der Schleife die TargetDataLine - Methode drain() aufgerufen. Damit wird dem System Zeit gegeben, eventuell noch im internen Puffer der TargetDataLine - Klasse befindliche Audiodaten korrekt auszulesen und zu schreiben (in diesem Beispiel auf den baOut - Stream). Die Methode blockt solange, bis dies vollständig erledigt ist. Zuletzt wird die TargetDataLine noch gestoppt und dann geschlossen, damit alle damit gebundenen Resourcen dem System wieder zur Verfügung gestellt werden können. Nun wird in das ByteArray caB die bei der Aufnahmen gelesenen Audiodaten mit der toByteArray() - Methode geschrieben. Das Array caB ByteArrayInputStream

dient als Eingabe für den

baIn. Dieser wiederum ist der erste Paramter um einen

AudioInputStream zu erstellen. Der zweite Parameter, ist das Audioformat in dem die Audiodaten vorliegen, welche durch den AudioInputStream gelesen werden sollen. Als dritten Parameter benötigt der Konstruktor die Grösse der zu lesenden Datei in Frames.

Was ist ein Frame ? Eine Sounddatei ist nicht nur durch die Länge in Bytes charakterisiert, sondern sie ist auch in eine Abfolge von sogenannten Frames unterteilt. Ein Frame enthält die Audiodaten für alle Kanäle, die die Datei zu einem bestimmten Zeitpunkt benutzt. Bei den Wave - Dateien entspricht die Anzahl der Frames, in die die Audiodatei aufgeteilt ist, der Anzahl der Samples pro Sekunde.

__________________________________________________________________________________________ Sound-Programmierung in Java - 21 -


Kommen wir jetzt wieder zu unserem Beispielprogramm zurück. Nachdem wir also unseren AudioInputStream erzeugt haben, fahren wir in der schon bekannten Weise (siehe Kapitel 2 – Soundgenerierung) fort. Wir erzeugen ein DataLine.info - Objekt und beziehen damit vom AudioSystem eine SourceDataLine

sl. Was nun folgt ist schon aus dem Beispiel

PlaySoundStreamed aus dem vorhergehenden Kapitel bekannt. In einer while – Schleife, die ver-lassen wird, wenn das Ende des Streams erreicht wurde (typisch hier der bei read zurückgelieferte Wert -1), wird mit read auf dem AudioInputStream gelesen und mit write auf der SourceDataLine geschrieben. Zum Schluss ...

Wie kann man ... aufgenommene Sounds auf Platte speichern ? Bei dieser Aufgabenstellung ist die Methode write() der AudioSystem Klasse der Java Sound API die entsprechende Lösung. Man ruft die Methode mit dem ersten Parameter - einem AudioInputStream - auf, als zweiten spezifiert man das gewünschte Zielaudioformat der Soundatei und als dritten und letzten Paramter erwartet die Methode ein File Objekt. Um dieses Verfahren zu verdeutlichen verändern wir die run - Methode der im vorherigen Abschnitt besprochenen Applikation CaptureAudio.java wie folgt: public void run() { baOut = new ByteArrayOutputStream(); int numBytesRead = 0; ba = new byte [64]; // starte die Line zum Aufnehmen des Sounds tl.start(); // starte Aufnahme while(capture) { //lese SounddateiDaten in Buffer ein numBytesRead = tl.read(ba,0,ba.length); baOut.write(ba,0,numBytesRead); } // blockiere bis die lezten Daten abgespielt wurden tl.drain(); // halte die Line an und schliesse die Line tl.stop(); tl.close(); __________________________________________________________________________________________ Sound-Programmierung in Java - 22 -


tl=null; System.out.println("

... Fertig mit Aufnahme");

System.out.println("...STOP"); System.out.println("Schreibe aufgenommenen Sound ..."); caB = baOut.toByteArray(); System.out.println("Anzahl der gecaptureten Bytes:"+caB.length); File file = new File("my.wav"); baIn = new ByteArrayInputStream(caB); stream = new AudioInputStream(baIn, af,caB.length / af.getFrameSize()); try { AudioSystem.write(stream, AudioFileFormat.Type.WAVE,file); }catch(IOException e){System.out.println( "Kann Datei nicht schreiben!");} System.out.println("

... Fertig!");

System.exit(0); } Man sieht, daß hier die write Methode mit dem vorher erzeugten AudioInputStream stream aufgerufen wird. Das zweite übergebene Objekt AudioFileFormat.Type.WAVE bestimmt, daß die zu schreibende Datei, im WAVE - Audioformat erstellt werden soll. Näheres zu den verschiedenen Audioformaten, die vom Java Sound System unterstützt werden, findet man im Kapitel 4 – Audio-formate. Als dritter Parameter ist noch das vorher erzeugte File Objekt zu nennen. Soviel also zu den Verfahren, mit denen typischerweise Audioaufzeichnungen mit der Java Sound API durchgeführt werden. Weitere Informationen findet man natürlich wieder in der Java Sound API Dokumentation[2] oder dem offiziellen Java Sound API Programmers Guide[3].

__________________________________________________________________________________________ Sound-Programmierung in Java - 23 -


Kapitel 4 - Audioformate

Dieses Kapitel beschäftigt sich mit den verschiedenen Audioformaten, die von der Java Sound API unterstützt werden und wie man von einem Format in ein anderes konvertiert. Doch zunächst müssen wir uns folgende Frage stellen.

Was sind überhaupt formatierte Audiodaten ? Formatierte Audiodaten beziehen sich auf Sounds, die sich in einem bestimmten Standard Audioformat befinden. Die Java Sound API unterscheidet zwei große Gruppen von formatierten Audiodaten: Zum einen die Gruppe der Datenformate und zum andere Seite die Gruppe der Fileformate.

Was sind Datenformate ? Das Datenformat einer Sounddatei beschreibt, wie die Abfolge der „rohen“ Bytes in einer Sounddatei zu interpretieren ist. Es ist beispielsweise wichtig zu wissen, aus wie vielen Bits sich ein Sample (die kleinste Einheit, in die man Audiodaten aufteilen kann) zusammensetzt, oder wie die sogenannte Samplerate (gibt an, wie schnell auf ein Sample ein nächstes folgt) lautet. In der Java Sound API wird das Datenformat einer Sounddatei durch ein AudioFormat Objekt spezifiziert. In diesem Objekt sind folgende Eigenschaften eines Soundformates gespeichert: • encoding Technik: zu nennen sind hier das PCM - Verfahren (das üblichste) und das

ULAW/ALAW - Verfahren • Anzahl der Kanäle d.h. wieviele Kanäle benutzt werden: 1 entspricht hierbei Mono und 2

Stereo • Samplerate: die Anzahl der Samples pro Sekunde und pro benutzten Kanal • Anzahl der Bits pro Sample: also wieviel Bits benutzt werden, um die Informationen

eines Samples zu speichern • Framerate • Grösse eines Frames in Bytes • Byte – Order: d.h. sind die Audiodaten als little Endian oder big Endian zu lesen

An dieser Stelle soll nun nicht weiter auf die einzelnen Felder der Klasse eingegangen werden. Hierzu sei auf das Sun Tutorial[3] verwiesen, das die Klassen näher und ausführlicher beschreibt. __________________________________________________________________________________________ Sound-Programmierung in Java - 24 -


Wie kann man ... nun ein geeignetes Audioformat finden ? Diese Frage stellt sich beispielsweise, wenn man in seinem Programm die Möglichkeit einbauen möchte, daß der User eigene Sounds aufnehmen kann (etwa bei einem selbstprogrammierten Audio Recorder). Wie wir schon bei der CaptureAudio.java Anwendung aus dem vorhergehenden Kapitel gesehen haben, wird bei der Konstruktion eines AudioInputStreams ein AudioFormat Objekt benötigt, um zu bestimmen, in welcher Qualität der aufgenommene Sound später vorliegen soll. Typischerweise nutzt man folgendes Objekt mit eventuellen Veränderungen: AudioFormat af = new AudioFormat(11025.0,16,2,true,false); Wichtig sind hierbei die drei ersten Werte, da sie die Qualität bestimmen, in der später der Sound vorliegt. Um CD - Qualität zu erlangen würde man 11025.0 (bestimmt die Samplerate) durch den Wert 44100.0 ersetzen, da dies der Samplerate einer CD entspricht. Der Wert 16 im Konstruktor bestimmt, daß für ein Sample 16 Bit benutzt werden sollen. Hier könnte man den Wert durch eine 8 ersetzen und somit festlegen, daß eine geringere Qualität verlangt wird, um die Sounddatei möglichst klein zu halten. Eine weitere Möglichkeit die Dateigröße zu minimieren, wäre, den Wert 2 (bestimmt eine Stereoqualität) durch eine 1 zu ersetzen und dadurch die Aufnahme nur in Monoqualität durchzuführen. Die beiden letzten Werte können auf einem Windows - Rechner so übernommen werden. Für eine nähere Beschreibung sei auf die Java Sound API Dokumentation[2] oder an den Java Sound Programmer´s Guide[3] verwiesen.

Wie kann man ... von einem Audiodatenformat in ein anderes konvertieren ? Grundsätzlich ist eine Konvertierung von Audiodaten zulässig und sogar vorgesehen in der Java Sound API. Leider mussten wir beim Verfassen dieses Tutorials feststellen, daß ähnlich dem unfertigen Zustand der Port Objekte, auch die Konvertierung noch nicht endgültig implementiert wird. In [3] wird zwar beschrieben, wie man eine Konvertierung in eigene Programme einbauen kann, doch realisieren lässt sie sich so nicht. Es werden bisher nur einige wenige Konvertierungen unterstützt und der vielleicht wichtigste Aspekt, nämlich das Herunterkonvertieren von einer guten, speicherplatzzehrenden Formatierung auf ein schlechteres aber dafür weitaus weniger speicherplatzbenötigendes Format kann nicht durchgeführt werden. Mit Hilfe des Java Sound Boards (ein wichtiger Anlaufpunkt bei Problemen mit der API wie wir festgestellt haben)[4] konnten wir folgende unterstützten Konvertierungen zusammentragen:

__________________________________________________________________________________________ Sound-Programmierung in Java - 25 -


Quellformat 16 Bit, PCM signed/unsigned 8 Bit, ULAW/ALAW PCM signed PCM unsigned PCM little Endian PCM big Endian

Zielformat 8 Bit, ULAW/ALAW 16 Bit, PCM signed/unsigned PCM unsigned PCM signed PCM big Endian PCM little Endian

Die Tabelle zeigt, welche Werte jeweils bei der Konvertierung von einem Format in ein anderes verändert werden dürfen. Alle anderen Parameter des Audioformates dürfen nicht verändert werden., weshalb eine „Herunterkonvertierung“, wie oben beschrieben, auch nicht möglich ist. An einem kleinen Beispiel wollen wir nun zeigen wie man generell eine Konvertierung durchführen kann. Hier der Beispielcode der AudioDataConverter.java Klasse:

import javax.sound.sampled.*; import java.io.File; import java.io.IOException; class AudioDataConverter { static AudioFormat sAudioFormat = null; static AudioFormat tAudioFormat = null; static AudioInputStream highResStream = null; static AudioInputStream lowResStream = null; static File sFile = null; public static void main (String args[]) { // pruefe ob Datei angegeben wurde die konvertiert werden sollte if (args.length == 0) throw new IllegalArgumentException ("Syntax: AudioDataConverter <path_to_wav-File>"); // erzeuge FileObject mit Referenz auf Quelldatei sFile = new File(args[0]);

try { // erstelle AudioInputStream auf Quelldatei highResStream = AudioSystem.getAudioInputStream(sFile); // ermittle AudioFormat der Quelldatei sAudioFormat = highResStream.getFormat(); __________________________________________________________________________________________ Sound-Programmierung in Java - 26 -


// bestimme Werte des Originalformates AudioFormat.Encoding enc = sAudioFormat.getEncoding(); float sampleRate = sAudioFormat.getSampleRate(); int sampleBits = sAudioFormat.getSampleSizeInBits(); int channels = sAudioFormat.getChannels(); int frameSize = sAudioFormat.getFrameSize(); float frameRate = sAudioFormat.getFrameRate(); boolean endian = sAudioFormat.isBigEndian(); // erstelle gewuenschtes Zielformat tAudioFormat = new AudioFormat(enc ,sampleRate, sampleBits, channels, frameSize, frameRate,(!endian)); // pruefe ob das Soundsystem auf der Maschine die Konvertierung // unterstuetzt if(AudioSystem.isConversionSupported(tAudioFormat, sAudioFormat)) { // erstelle AudioInputStream auf die Quelldatei mit vorher festgelegtem //Ziel-AudioDatenFormat lowResStream = AudioSystem.getAudioInputStream(tAudioFormat, highResStream); AudioSystem.write(lowResStream, AudioFileFormat.Type.WAV,new File("convert.wav")); lowResStream.close(); highResStream.close(); } else { System.out.println("Die Konvertierung wird vom AudioSystem nicht unterstuetzt."); } }catch(UnsupportedAudioFileException e){System.out.println("Die von Ihnen spezifizierte Sounddatei hat ein vom AudioSystem nicht unterstuetztes Format.");} catch(IOException e){System.out.println("Fehler beim Lesen der Quelldatei.");} System.exit(0); } }

__________________________________________________________________________________________ Sound-Programmierung in Java - 27 -


Unser Programm erwartet beim Aufruf den Pfad zu der zu konvertierenden Audiodatei als Übergabeparameter. Als nächsten Schritt erzeugen wir einen AudioInputStream auf diese Datei, genauso als wollten wir sie wiedergeben. Daraufhin wird das Audioformat unserer Quelldatei bestimmt, in der Variablen sAudioFormat zwischengespeichert sind und dann die einzelnen Audioformat-parameter bestimmt. Dies ist notwendig, da wir ja nur die in der obigen Tabelle angegebenen Werte bei der Konvertierung verändern dürfen und alle anderen unberührt bleiben müssen. Unser Programm soll hierbei den ausgelesen Zustand des bigEndian - Parameters der Quelldatei invertieren, d.h. eine Datei, die vor dem Aufruf im bigEndian - Format geschrieben wurde, wird durch unser Programm in das littleEndian - Format konvertiert und als „convert.wav“ geschrieben. Nachdem wir die Parameter der Quelldatei ausgelesen haben, erzeugen wir unser Zielformat tAudioFormat, bei dem alle Parameter bis auf den invertierten bigEndian - Wert gleich bleiben. Wenn wir also Quell - und Zielaudioformat bestimmt sind, wird das AudioSystem befragt, ob diese Konvertierung überhaupt von dem System unterstützt wird. Die geschieht mit dem Aufruf von boolean AudioSystem.isConversionSupported(Zielformat, Quellformat); Diese Methode ist sehr wichtig bei der Konvertierung, da man damit vorher prüfen kann, ob die Konvertierungsart überhaupt vom System unterstützt wird. Um die Zieldatei zu schreiben und die Konvertierung durchzuführen, wird die schon bekannte write() - Methode der AudioSystem - Klasse benutzt int AudioSystem.write(AudioInputStream,Zieldatenformat, Zielfile - Objekt); Nachdem wir uns also mit den (bisher noch unzulänglichen) Möglichkeiten der Audiodatenkonvertierung beschäftigt haben, wollen wir uns nun den Audiofileformaten zuwenden, die von der Java Sound API unterstützt werden.

__________________________________________________________________________________________ Sound-Programmierung in Java - 28 -


Was sind Audiofileformate ? Audiofileformate spezifizieren, wie die rohen Audiodaten in einem Soundfile angeordnet sind. In der Java Sound API sind die verschiedenen Audioformate durch die Klasse AudioFormat repräsentiert, und ein Audiofile durch die Klasse AudioFileFormat. Die API unterstützt folgende Standardaudioformate, definiert als AudioFileFormat.Type.X - Objekte, wobei X für • AIFC • AIFF • SND • AU • WAVE steht. Die Java Sound API unterstützt die Konvertierung zwischen oben genannten Standardaudioformaten.

Wie kann man ... zwischen verschiedenen Audiofileformaten konvertieren ? Die Konvertierung zwischen verschiedenen Audiofileformaten erweist sich als einfacher und vor allem als vollständig in die API implementiert. Das Vorgehen bei dieser Aufgabe wollen wir uns an der entscheidenden Methode des Beispielprogramms FileConverter.java, dessen kompletten Quellcode in Anhang A zu finden ist, ansehen. Hierbei handelt es sich um die Methode write():

private static void write (AudioInputStream in,AudioFileFormat.Type fileType,File file) { System.out.println("Konvertiere Quelldatei nach <"+file.getName()+">"); int

writtenBytes = 0;

try { writtenBytes = AudioSystem.write(in, fileType, file); } catch(IllegalArgumentException e){System.out.println("Das von Ihnen gewaehlte Soundformat wird nicht unterstuetzt!"); System.exit(0);} catch (IOException e){System.out.println("Fehler beim Schreiben in Zieldatei!");System.exit(1);} System.out.println("... Konvertierung erfolgreich beendet"); System.out.println("\nGeschrieben : "+writtenBytes+" Bytes als "+fileType.getExtension()); } __________________________________________________________________________________________ Sound-Programmierung in Java - 29 -


Die Methode erwartet einen - bereits auf die Quelldatei geöffneten - AudioInputStream, das Zielformat, in welches die Quelldatei konvertiert werden soll und schliesslich ein File Objekt, daß die Zieldatei spezifiziert. Die eigentliche Formatkonvertierung führt die uns schon bekannte write() - Methode der AudioSystem Klasse durch. Zum Abschluss noch die neu hinzugekommenen Methoden und die von ihnen erzeugten Exceptions:

Methode AudioSystem.write( )

erzeugte Exception IllegalArgumentException, IOException

__________________________________________________________________________________________ Sound-Programmierung in Java - 30 -


Kapitel 5 - Kontrollen

Dieses Kapitel soll sich mit den noch verbleibenden Aspekten des Paketes javax.sound.sampled beschäftigen. Erwähnenswert sind beispielsweise noch die sogenannten Control Objekte der API. Sie dienen dazu, etwa die Lautstärke der Wiedergabe zu regeln, oder die Balance zwischen rechtem und linken Kanal zu verändern. Es gibt vier verschiedene Subklassen der Control Objekte, die man in seinen Programmen nutzen kann: • BooleanControl - repräsentiert Kontrollen, die durch 2 verschiedene Zustände charakterisiert werden können; Beispiel: Stummschalten einer Line an/aus • FloatControl - erlaubt Kontrolle über Objekte, die mit Fließkommazahlen arbeiten; Beispiel: Lautstärke der Wiedergabe eines Sounds • EnumControl - wird benutzt, wenn man die Wahl zwischen verschiedenen Kontrollobjekten implementieren möchte; Beispiel: User hat die Wahl zwischen verschiedenen festgelegten Lautstärkeeinstellungen • CompoundControl - ermöglicht den gleichzeitigen Zugriff auf Control Objekte, die zu einer Gruppe zusammengefaßt sind; Beispiel: ein Equalizer

In diesem Tutorial beschränken wir uns darauf, eine kurze Einführung in die FloatControl Objekte zu geben, da sie uns in der Praxis am wichtigsten erscheinen. Für eine weiterführende Beschreibung der anderen Klassen, sei der Leser auf [2] und [3] verwiesen. Die von der Java Sound API zur Verfügung gestellten FloatControl Objekte werden durch folgende FloatControl.Type.X Objekte repräsentiert: X steht für: •

AUX_RETURN

AUX_SEND

BALANCE

MASTER_GAIN

PAN

REVERB_RETURN

REVERB_SEND

SAMPLE_RATE

VOLUME

__________________________________________________________________________________________ Sound-Programmierung in Java - 31 -


Möchte man dem User in einem Programm z.B. die Möglichkeit geben, die Lautstärke, in der eine Sounddatei wiedergegeben wird, selber zu regeln, geschieht dies darin, sich ein FloatControl Objekt zu generieren, das vom Typ FloatControl.Type.MASTER_GAIN ist. Damit kommen wir zu der Frage ...

Wie kann man ... auf FloatControl Objekte erzeugen ? Zunächst einmal ist die Frage zu klären, welches FloatControl Objekt man überhaupt benutzen möchte. In unserem folgenden Beispiel soll die Lautstärke geregelt werden, in der die Soundausgabe erfolgt. Wir benötigen also ein Objekt vom Typ FloatControl.Type.MASTER_GAIN. Als ersten Schritt müssen wir prüfen, ob wir auf der Line, auf der wir die Ausgabe durchführen wollen, überhaupt die Möglichkeit haben, das von uns gewünschte FloatControl Objekt zu nutzen.

Hierzu

rufen

wir

die

Line

-

Methode

isControlSupported(FloatControl.Type.X) auf. Sie gibt einen boolschen Wert zurück, an dem wir erkennen können, ob unser gewünschtes Control - Objekt verfügbar ist. Schauen wir uns diesen Schritt an einem beispielhaften Auszug aus der Klasse PlayBack.java an (das vollständige Programm AudioPlayer und seine Klassen steht in Anhang A): private void createClip()throws LineUnavailableException { DataLine.Info info = new DataLine.Info(Clip.class, audioFormat); clip = (Clip) AudioSystem.getLine(info); if (clip.isControlSupported (FloatControl.Type.MASTER_GAIN)) { clipGainControl = (FloatControl) clip.getControl(FloatControl.Type.MASTER_GAIN); } if (clip.isControlSupported(FloatControl.Type.PAN)) { clipPanControl = (FloatControl) clip.getControl(FloatControl.Type.PAN); } } In dieser Methode createClip() wird zunächst ein Clip Objekt als Line erzeugt auf der die Soundausgabe erfolgen soll. Im nächsten Schritt wird geprüft, ob die Line eine Lautstärkeregelung __________________________________________________________________________________________ Sound-Programmierung in Java - 32 -


zulässt. Hierzu wird die Methode isControlSupported() benutzt. Wenn sie ein true zurückliefert, wird das gewünschte Control Objekt erzeugt, in dem man die Line - Methode getControl(X) aufgerufen wird. Wichtig hierbei ist der vorgestellte Cast - Operator, der das zurückgelieferte Control - Objekt, zu einem FloatControl - Objekt castet. Zum Schluss wird versucht, Zugriff auf die Balance - Steuerung zwischen rechtem und linkem Kanal zu erhalten, in dem ein Control Objekt vom Typ FloatControl.Type.PAN erzeugt wird. Nachdem wir nun also gesehen haben, wie wir Control Objekte erzeugen können, die die von uns gewünschten Aufgaben erfüllen bleibt noch ...

Wie kann man ... Werte bei FloatControl Objekten verändern ? Kommen wir noch einmal auf unser Beispiel zurück, bei dem der User eines Programmes selbst bestimmen können soll, wie laut oder leise die Wiedergabe einer Sounddatei erfolgen soll. Die Eingabe des neuen Wertes könnte beispielsweise über Swing Elemente ( zum Beispiel über ein Slider Objekt) erfolgen. Dieser Ansatz wird in dem Beispielprogramm AudioPlayer, das im Anhang A zu finden ist, durchgeführt. Über ein Slider Objekt kann der User die Lautstärke und die Balance zwischen linkem und rechtem Kanal beeinflussen. Der gewünschte Wert muss nun über ein FloatControl Objekt auf die benutzte Line angewendet werden. Im vorherigen Abschnitt haben wir ja schon gezeigt, wie wir bei dem AudioPlayer Programm, die FloatControl Elemente erzeugen. Nehmen wir beispielsweise das PAN Objekt. Um hierbei die gewünschte Balance einzustellen, wird die setValue() - Methode der FloatControl Klasse benutzt. Dies geschieht wie folgt: void [FloatControl-Objekt].setValue(float neuerWert); Der so gesetzte neue Wert, wird sofort auf die benutzte Line angewendet. In unserem Beispielprogramm sieht dies wie folgt aus: clipPanControl.setValue(fPan);

Zum Schluss seien noch folgende FloatControl - Methoden genannt, die bei der Arbeit mit den Control Objekten nützlich sein können,: float [FloatControl-Objekt].getMaximum();

- gibt den maximalen Wert zurück, den das Element annehmen kann float [FloatControl-Objekt].getMinimum(); - gibt den minimalsten Wert zurück, den das Element annehmen kann float [FloatControl-Objekt].getValue(); - gibt den aktuellen Wert des Elementes an

__________________________________________________________________________________________ Sound-Programmierung in Java - 33 -


Zum Ende dieses Kapitels sei noch eine letzte nützliche Klasse genannt, die sogenannten LineListener. Mit Hilfe dieser Klasse kann der Status einer Line - also der Status eines Clips, einer Source- bzw. TargetDataLine oder eines Ports - überwacht werden und kann daher auch zu den Kontrollen gezählt werden, die von der Java Sound API zur Verfügung gestellt werden. Line - Objekte erzeugen sogenannte LineEvent - Objekte, wenn sie sich in einem bestimmten Zustand befinden. Diese Zustände sind START, STOP, OPEN, CLOSE. Wird zum Beispiel die Wiedergabe eines Sounds gestartet, so wird ein Start - LineEvent - Objekt erzeugt und an die LineListener übergeben, die an die gestartete Line gebunden sind.

Wie kann man ... LineListener benutzen ? Man geht hierbei ähnlich vor, wie bei AWT - Events. Typischerweise benutzt man eine innere Klasse. Schauen wir uns folgendes Beispiel an: clip.addLineListener(new LineListener () { public void update (LineEvent e){ if (e.getType() == LineEvent.Type.STOP) { //schliesse den Clip und gib somit die gebundenen Resourcen wieder frei clip.close(); } if(e.getType() == LineEvent.Type.CLOSE) { //beende Programm System.exit(0); } }});

In diesem Beispiel wird ein LineListener an ein Line Objekt clip gebunden, um dessen Status zu überwachen. Hierbei sollen STOP und CLOSE Zustände behandelt werden. Man implementiert also eine innere Klasse LineListener und schreibt die Methode update(). Diese Methode wird immer dann aufgerufen, wenn das Line Objekt, das an diesen LineListener gebunden ist, ein LineEvent Objekt erzeugt. Das erzeugte Objekt wird anschließend der update Methode übergeben. Um festzustellen, um welchen Event es sich handelt, wird die LineEvent Methode getType() benutzt.

__________________________________________________________________________________________ Sound-Programmierung in Java - 34 -


Der gelieferte Wert wird dann mit den folgenden möglichen LineEvent.Type Objekten verglichen: • LineEvent.Type.START • LineEvent.Type.STOP • LineEvent.Type.OPEN • LineEvent.Type.CLOSE

und es wird entsprechend reagiert. Zum Ende des Kapitels, wieder alle neu hinzugekommenen Methoden, die die Möglichkeit haben, Exceptions zu erzeugen:

Methode [Line – Objekt].getControl() [FloatControl – Objekt].setValue( )

erzeugte Exception IllegalArgumentException IllegalArgumentException

__________________________________________________________________________________________ Sound-Programmierung in Java - 35 -


TEIL II javax.sound.midi

__________________________________________________________________________________________ Sound-Programmierung in Java - 36 -


Kapitel 6 - MIDI - Wiedergabe

Dieses Kapitel beschäftigt sich mit der Wiedergabe von Midi - Audiodateien mit Hilfe der Java Sound API. Es werden einige Midi - spezifische Audrücke benutzt werden müssen, die in diesem Tutorial nicht ausführlich besprochen werden können. Für alle, die mehr über die Midi - Spezifikation erfahren wollen, sei die offizielle Midi – Seite, die man unter [5] findet, empfohlen. Kommen wir nun zu unserer ersten Frage - bzw. Problemstellung.

Wie kann mann ... mit der Java Sound API Midi - Dateien wiedergeben ? Die wichtigste Klasse im Paket javax.sound.midi ist die sogenannte statische Klasse MidiSystem. Sie kann mit der statischen Klasse AudioSystem aus dem sampled - Paket der Java Sound API verglichen werden. Das MidiSystem bzw. die Klasse erstellt die beiden wichtigsten Klassen, die bei der Wiedergabe von Mididateien eine Rolle spielen, nämlich einmal die Sequencer Klasse und zum anderen die Synthesizer Klasse. Ein Sequencer kann man sich als Steuerung für den Synthesizer vorstellen. Er „liest“ die Noten aus einer Midi - Datei aus und spielt sie auf dem richtigen Instrument auf dem Synthesizer ab. Daher liegt es nahe, als ersten Schritt bei der Erstellung eines Programms, das Midi - Dateien bearbeiten soll, ein Sequencer und Synthesizer Objekt zu erzeugen. Dies geschieht über die MidiSystem - Methoden getSequencer() und getSynthesizer() wie folgt: Sequencer sequencer = MidiSystem.getSequencer(); Synthesizer synthesizer = MidiSystem.getSynthesizer(); Als nächsten Schritt öffnet man den Sequencer und den Synthesizer mit einfachen open() - Methoden: sequencer.open(); synthesizer.open(); Somit werden die beiden Objekte exklusiv für diese Anwendung reserviert und kein anderes Programm kann sie benutzen. Um nun eine Verbindung zwischen dem Synthesizer und dem Sequencer herzustellen und damit die Wiedergabe zu ermöglichen, werden sogenannte Receiver und Transmitter Objekte aus der API benötigt. Ein Transmitter wird immer mit einem Receiver verbunden damit der Receiver die vom Transmitter ausgesendeten Daten empfängt und an seine Klasse weitergibt, welche die Daten dann verarbeitet. In unserem Beispiel wird für den Sequencer ein Transmitter benötigt (da der Sequencer ja später den Synthesizer steuern soll) und für den Synthesizer ein Receiver Objekt,

__________________________________________________________________________________________ Sound-Programmierung in Java - 37 -


damit dieses die Daten vom Sequencer aufnimmt und an ihn weitergibt: Transmitter trans = sequencer.getTransmitter(); Receiver receive = synthesizer.getReceiver(); Im nächsten Schritt soll dem erstellten Transmitter Objekt ein Receiver Objekt zugewiesen, so daß dieses später den Empfänger der „auszusendenden“ Daten kennt. Dies wird durch den Aufruf der Transmitter Methode setReceiver() gewährleistet und wie folgt in die Praxis umgesetzt: trans.setReceiver(receive); Nach solchen vorbereitenden Massnahmen müssen wir uns vor der Wiedergabe der Datei noch mit dieser selbst auseinandersetzen. Nachdem wir ein File Objekt erzeugt haben, das sich auf die wiederzugebende Midi - Datei bezieht, muss damit ein sogenanntes Sequence Objekt erzeugt werden. In der Java Sound API werden die Midi - Informationen einer Midi - Datei durch Sequence Objekte dargestellt. Wir verfahren also nun weiter, indem wir File file = new File (Pfad zu einer Midi - Datei); Sequence sequence = new Sequence (file); Objekte erzeugen. Der letzte Schritt, den wir vor dem Abspielen der Midi - Datei file durchführen müssen, ist, die erstellte sequence dem Sequencer zu übergeben, damit dieser die sequence abarbeiten kann und dadurch die Midi - Datei auf dem Synthesizer abgespielt wird. Folgende Anweisung übernimmt diese Aufgabe: sequencer.setSequence(sequence); Um die Wiedergabe der Midi - Datei file zu starten, ist nur noch eine start - Anweisung nötig und der Sequencer beginnt die Musikwiedergabe auf dem Synthesizer: sequencer.start(); Diese Vorgehensweise wollen wir uns nun an einem konkreten Beispiel ansehen, nämlich an dem Programm PlayMidi.java:

import javax.sound.midi.*; import java.io.IOException; import java.io.File; class PlayMidi { static PlayMidi playMidi = null; static Synthesizer synth = null; static Sequencer sequencer = null; static Receiver synthReceiver = null; static Transmitter seqTransmitter =null;

__________________________________________________________________________________________ Sound-Programmierung in Java - 38 -


public static void main(String args[]) { if (args.length == 0) throw new IllegalArgumentException ("Syntax: java PlayMidi <midifile>"); try { //erzeuge Sequencer und รถffne diesen sequencer = MidiSystem.getSequencer(); sequencer.open(); //erzeuge Transmitter seqTransmitter = sequencer.getTransmitter(); //erzeuge Synthesizer und รถffne diesen synth = MidiSystem.getSynthesizer(); synth.open(); //erzeuge Receiver, der mit dem Transmitter verbunden wird, um Daten//uebertragung zwischen Synthesizer und Sequenzer zu erlauben synthReceiver = synth.getReceiver(); seqTransmitter.setReceiver(synthReceiver); //erzeuge File Objekt auf uebergebenen Midi-Datei-Pfad File midiFile = new File(args[0]); //erzeuge Sequence mit der Midi-Datei Sequence sequence = MidiSystem.getSequence(midiFile); //uebergib dem Sequencer die Sequence, die er abspielen soll sequencer.setSequence(sequence); //lass Sequencer von MetaL. ueberwachen, um festzustellen, wann //Ende der Midi-Datei bzw. Sequence erreicht sequencer.addMetaEventListener(new MetaEventListener() { public void meta(MetaMessage event) { if (event.getType() == 47) { sequencer.stop(); //gib dem Synthesizer Zeit, die letzte Note klingen zu lassen try { Thread.sleep(1000); }catch(InterruptedException e){} sequencer.close(); synthesizer.close(); System.exit(0); } }}); __________________________________________________________________________________________ Sound-Programmierung in Java - 39 -


}catch(MidiUnavailableException e) {System.out.println("Kein MidiGeraet verfuegbar."); System.exit(0);} catch(InvalidMidiDataException e){System.out.println("Die Datei "+args[0]+" enthaelt keine gueltigen MidiDaten."); System.exit(0);} catch(IOException e){System.out.println("Konnte Datei "+args[0]+" nicht oeffnen."); System.exit(1);} System.out.println("Spiele Midi-Datei ..."); System.out.println("Druecke <RETURN> fuer STOP"); //starte den Sequencer und somit die Wiedergabe sequencer.start(); //warte bis Nutzer Return drueckt oder Ende der Midi-Datei erreicht wird try { int c = System.in.read(); }catch(IOException e){System.exit(1);} sequencer.stop(); System.out.println("...STOP"); //gib die gebundenen Resourcen wieder frei sequencer.close(); synthesizer.close(); System.exit(0); } }

In diesem Beispielcode findet man alle oben beschriebenen Schritte wieder. Wichtigste Neuerung ist hier die Einbindung einer sogenannten MetaEventListener Klasse. Vergleichbar ist diese Klasse mit der LineListener Klasse aus dem sampled - Paket in Teil II dieses Tutorials. Sie dient ebenfalls zur Überwachung der Wiedergabe einer Datei. Der Unterschied besteht allerdings darin, daß keine LineEvent Objekte erzeugt werden, wenn bestimmte Situationen während der Wiedergabe auftreten, sondern sogenannte MetaEvent Objekte. Diese MetaEvents können von einem Sequencer Objekt interpretiert werden. MetaEvent Objekten sind bestimmte Nummern nach der Midi - Spezifikation zugeordnet. In unserem Beispiel wird ein Event mit der Nummer 47 abgefragt. Dies bedeutet Ende der Sequence und der Sequencer selbst kann durch eine stop() - Anweisung beendet werden. Nach der stop() - Anweisung sollte dem Synthesizer noch eine gewisse Zeitspanne gegeben werden, um die letzte Note auch vollkommen verklingen zu lassen. Stoppt man einfach den Sequencer und beendet das Programm, wirkt die Wiedergabe der letzten Note unnatürlich abgehakt.

__________________________________________________________________________________________ Sound-Programmierung in Java - 40 -


Daher in unserem Beispiel die Thread.sleep(1000); Anweisung damit das Programm nach einer Wartezeit von einer Sekunde beendet wird. Wenn die Geräte Sequencer und Synthesizer nicht mehr benötigt werden, sollten ihre Resourcen, durch einfache close() - Anweisungen dem System wieder zur Verfügung gestellt werden, damit andere Programme nun auch diese Geräte nutzen können: sequencer.close(); synthesizer.close();

Mit Hilfe der Java Sound API ist es darüber hinaus möglich, nicht nur den eingebauten Synthesizer zu benutzen, sondern auch andere, an das System angeschlossene, Midi - Geräte. Die führt zu der Frage ...

Wie kann man ... andere Midi - Geräte ansprechen ? Um herauszufinden, welche Midi - Geräte überhaupt in einem System zur Verfügung stehen, kann die statische Klasse MidiSystem befragt werden. Sie kann eine Liste mit Informationen über alle verfügbaren Geräte erstellen, auf die man über die Java Sound API Zugriff hat. Informationen über die Eigenschaften eines Midi - Gerätes, werden in sogenannten MidiDevice.info Objekten gespeichert. Dies geschieht wie folgt: MidiDevice.info info[] = MidiSystem.getMidiDeviceInfo(); Im Array info sind nun Informationen über alle verfügbaren Geräte gespeichert. Jedem Gerät ist ein MidiDevice.info Objekt zugeordnet. Um an ein bestimmtes Midi - Gerät zu gelangen, muss ein MidiDevice - Objekt erzeugt werden. Dies geschieht, indem man dem MidiSystem ein MidiDevice.info Objekt übergibt, das die Informationen des gewünschten Objektes enthält. Nehmen wir an, in unserem Array info hätten wir unter Index 2 unser gesuchtes Midi - Gerät gefunden. Um

Zugriff auf dieses Gerät zu erhalten, fragen wir beim MidiSystem an. Dies

geschieht mit folgender Anweisung: MidiDevice unserDevice = MidiSystem.getMidiDevice(info[2]); Wenn wir Zugriff auf dieses Gerät haben, müssen wir wieder - wie schon im letzten Abschnitt - eine open() Anweisung benutzen, um das Gerät exklusiv für unsere Anwendung zu reservieren: unserDevice.open(); Um nun überhaupt mit dem Gerät arbeiten zu können, benötigen wir von ihm entweder ein Receiver Objekt oder ein Transmitter Objekt. Dies geschieht wiederum mit den schon bekannten Methoden getReceiver() oder getTransmitter(). Nehmen wir einfach an, dass __________________________________________________________________________________________ Sound-Programmierung in Java - 41 -


unser Midi - Gerät unserDevice eine Referenz auf einen Synthesizer darstellt. Dann benötigen wir natürlich ein Receiver - Objekt von ihm, damit ein anderer Transmitter Daten an unseren Receiver senden kann. Dies erfolgt wie im vorangegangenen Abschnitt: Receiver unserReceiver = unserDevice.getReceiver(); Sollten wir unser Gerät nicht mehr weiter benötigen, geben wir die Resourcen wieder durch eine close() - Anweisung frei: unserDevice.close();

Dies waren die entscheidenden Schritte, wie man das Midi - System nutzt, um Midi - Geräte von ihm anzufordern und auf einfache Weise eine Midi - Datei auf diesen wiederzugeben. Im nächsten Kapitel beschäftigen wir uns mit der Dateienwiedergabe, sondern damit selbst einzelne Noten auf einem Midi - Gerät wiederzugeben. Zum Schluss, in einer Tabelle zusammengefaßt, alle neuen Methoden, die die Möglichkeit haben, Java Exceptions auszulösen:

Methode MidiSystem.getSequencer( ) MidiSystem.getSequencer( ) [MidiDevice – Objekt].open( ) [MidiDevice – Objekt].getTransmitter ( ) MidiDevice – Objekt].getReceiver ( ) Sequence – Konstruktor [Sequencer – Objekt].setSequence( ) MidiSystem.getMidiDevice( )

erzeugte Exception MidiUnavailableException MidiUnavailableException MidiUnavailableException MidiUnavailableException MidiUnavailableException InvalidMidiDataException InvalidMidiDataException, IOException MidiUnavailableException, IllegalArgumentException

__________________________________________________________________________________________ Sound-Programmierung in Java - 42 -


Kapitel 7 - Tonwiedergabe

Dieses Kapitel beschäftigt sich mit der Wiedergabe einzelner Töne bzw. Noten auf Midi - Geräten. Eine praktische Anwendung hierfür wäre ein virtuelles Keyboard. Der User könnte z.B. , über eine Swing - Anwendung, die ein Keyboard zeichnet, auf diesem spielen. Die Problemstellung wäre also zu erkennen, welche Noten gespielt werden sollen, und wie man das Midi - System dazu veranlasst, diese auch wiederzugeben. Die erste Frage soll hier nicht weiter beantwortet werden, da es sich dabei um ein Swing bzw. AWT - Problem handelt. Wir kommen daher zu ...

Wie kann man ... einzelne Noten wiedergeben mit dem Midi - System ? Zunächst fordert man ein Synthesizer Objekt bei dem MidiSystem an, oder man erzeugt sich ein MidiDevice wie im vorigen Kapitel beschrieben. Der Einfachheit halber, werden wir hier nur ein Synthesizer vom MidiSystem beziehen. Synthesizer synthesizer = MidiSystem.getSynthesizer(); Haben wir dies erledigt, müssen wir noch den Synthesizer für unsere Anwendung reservieren, indem wir die open() - Methode benutzen. Nun kommt ein uns neues Java Sound API Objekt, das sogenannte MidiChannel Objekt, hinzu. Nach der MIDI - Spezifikation kann ein Synthesizer verschiedene Kanäle - sogenannte Channels -besitzen, auf denen er Töne generiert bzw. wiedergibt. Ein MidiChannel Objekt ist also die Umsetzung der Spezifikation in die API Umgebung. Um an die von unserem Synthesizer unterstützten Kanäle zu gelangen, müssen wir folgenden Schritt in unser Programm implementieren: MidiChannel channel[] = synthesizer.getChannels(); Mit Hilfe der Methode [Synthesizer-Objekt].getChannels(); erhält man ein Array von MidiChannel Objekten, die die verfügbaren Kanäle des Synthesizers repräsentieren. Um eine Note wiederzugeben, müssen wir den Kanal, auf dem die Note beim Synthesizer gespielt werden soll, angeben, welche Note gespielt und wie stark diese Note „angeschlagen“ werden soll. Das „Anschlagen“ muß man sich wie bei einem realen Klavier vorstellen. Je stärker die einzelne Klaviertaste gespielt wird, desto lauter erklingt der entsprechende Ton. In der Java Sound API wird dies als Velocity bezeichnet

__________________________________________________________________________________________ Sound-Programmierung in Java - 43 -


In unserem Programm sieht dieses Vorgehen wie folgt aus: channels[0].noteOn(zu spielende note, velocity); Die zu spielende Note muss als Integer - Wert zwischen 0 und 127 angegeben werden. Dies richtet sich nach der schon erwähnten Midi - Spezifikation. Für eine genaue Auflistung der einzelnen Noten und deren entsprechenden Integer - Werte sei auf [5] verwiesen. Ebenso wie die zu spielende Note, wird der Velocity - Wert als Integer übergeben. Als Gegenstück zum noteOn - Befehl gibt es noch den noteOff - Befehl, den man einem Synthesizer Objekt geben kann: channels[0].noteOff(zu spielende Note); Dieser Befehl signalisiert dem Synthesizer, das die „virtuelle“ Taste nicht mehr gedrückt ist, und er entsprechend reagieren soll. An einem einfachen Beispielprogramm, wollen wir uns nun diese Schritte in der Praxis ansehen. Bei dem Demo handelt es sich um die PlayMidiSelf.java Applikation: import

javax.sound.midi.*;

public class PlayMidiSelf { static int note = 0;

//nimmt zu spielende Note auf

static int velocity = 0;

//nimmt Tastenanschlagstaerke auf

static int duration = 0;

//nimmt Zeit auf, fuer die die Taste //gedrueckt bleiben soll

static int instrument = 0;//nimmt die Nummer des Instrumentes auf, //auf dem Note gespielt werden soll static Synthesizer synth = null; static MidiChannel[]channels = null; static Soundbank sb = null;//Referenz auf die benutzte Soundbank static Instrument inst [] = null;//Liste der unterstuetzten //Instrumente durch die Soundbank public static void main(String[] args) { if (args.length < 4) throw new IllegalArgumentException("Syntax: java PlayMidiSelf <note number> <velocity> <duration> <instrument>"); try { synth = MidiSystem.getSynthesizer(); } catch (MidiUnavailableException e) { } __________________________________________________________________________________________ Sound-Programmierung in Java - 44 -


try { synth.open(); } catch (MidiUnavailableException e) { e.printStackTrace(); System.exit(1); } //bestimme die verfuegbaren Midi-Kanaele channels = synth.getChannels(); //bestimme die Soundbank die der Synthesizer benutzt sb = synth.getDefaultSoundbank(); //bestimme welche Instrumente die Soundbank zur Verfuegung stellt inst = sb.getInstruments(); //passe die ueber Konsole gelesenen Werte an note = Integer.parseInt(args[0]); note = Math.min(127, Math.max(0, note)); velocity = Integer.parseInt(args[1]); velocity = Math.min(127, Math.max(0, velocity)); duration = Integer.parseInt(args[2]); duration = Math.max(0, duration); instrument = Integer.parseInt(args[3]); instrument = Math.max(0,Math.min(instrument,inst.length)); System.out.println("Spiele auf Instrument Nr. "+instrument+" mit der Bezeichnung :"+inst[instrument-1].getName()); //wechsle auf das gewuenschte Instrument channels[0].programChange(instrument); //spiele die gewuenschte Note channels[0].noteOn(note, velocity); //halte die Note ueber die gewuenschte Zeit try { Thread.sleep(duration); } catch (InterruptedException e) { } //signalisiere, das Taste nicht mehr gedrueckt channels[0].noteOff(note); //gib Synthesizer genug Zeit die Note ausklingen zu lassen bevor /Programm beendet wird __________________________________________________________________________________________ Sound-Programmierung in Java - 45 -


try { Thread.sleep(1000); } catch (InterruptedException e) { } System.exit(0); } }

Das Programm verlangt vom Nutzer vor dem Start auf Konsolenebene als Programmparameter eine Note, die es spielen soll, die Velocity, mit der die Note angespielt wird und wie lange die „virtuelle“ Taste auf dem Synthesizer gehalten werden soll (die duration). Es ist möglich, dem Synthesizer vorzuschreiben, auf welchem virtuellen Instrument er die Note spielen soll. Dieses Instrument kann aus einer Liste, der sogenannten Soundbank, ausgewählt werden; die gewählte Nummer stellt den vierten Parameter dar. Es ist möglich, mit der API eine andere Soundbank in einen Synthesizer zu laden oder nur einzelne Instrumente oder Geräuschefekte aus einer bereits im Synthesizer befindlichen Bank auszutauschen. Diese Punkte gehen aber weit über den knappen Rahmen dieses Tutorials hinaus. Von daher sei auf [2] oder [3] verwiesen. Im weiteren Verlauf benutzen wir, daher nur die bereits im Synthesizer befindliche Soundbank und deren Instrumente und Geräuschefekte. Nun aber wieder zu unserem Programm und dessen Aufbau. Zu Beginn wird ein Synthesizer Objekt vom MidiSystem angefordert auf dem später dann, die vom User bestimmte Note gespielt wird. Dann wird dieses Synthesizer Objekt durch eine open() Anweisung für unsere Anwendung reserviert und anschließend bestimmt, welche Kanäle zur Verfügung gestellt werden. Als neuen Schritt finden wir die getDefaultSoundbank() -Anweisung, die das Format Soundbank unsereSB = [Synthesizer-Objekt].getDefaultSoundbank();

hat. Mit Hilfe dieser Methode bestimmen wir die aktuell im Synthesizer befindliche Soundbank. Mit der Soundbank unsereSB haben wir nun die Möglichkeit, uns eine Liste von den Instrumenten erstellen zu lassen, die momentan in unserem Synthesizer verfügbar sind. Die Instrumente einer Soundbank werden in der Java Sound API durch die Instrument Objekte repräsentiert. Wir erstellen also nun durch inst = sb.getInstruments();

ein Array von Instrument Objekten mit den Namen inst.

__________________________________________________________________________________________ Sound-Programmierung in Java - 46 -


In den darauffolgenden Zeilen werden die von der Konsolenebene übergebenen Parameter in ein bestimmtes Format gebracht. Wenn dies erfolgt ist, wird der Syntesizer angewiesen, auf dem Kanal, über den später die Note gespielt werden soll, auf das vom Nutzer gewünschte Instrument zu wechseln: channels[0].programChange(instrument);

Man benutzt also die programChange Methode eines MidiChannel Objektes, die folgendes Format hat: [MidiChannel - Objekt].programChange(int-Wert der Nummer von gewünschten Instrument entspricht); Hat man das Programm des Synthesizers auf das gewünschte Instrument umgestellt, erfolgen die schon besprochenen noteOn() und noteOff() - Anweisungen an den Synthesizer, die das Anspielen der Note auslösen. An diesem kleinen Beispiel lässt sich erkennen, wie eine größere Applikation aussehen könnte, die ein Midi - Keyboard simuliert, auf dem gespielt und zwischen verschiedenen Instrumenten gewählt werden kann.

__________________________________________________________________________________________ Sound-Programmierung in Java - 47 -


Kapitel 8 - Aufzeichnung von Midi-Informationen

Dieses Kapitel beschäftigt sich mit der Aufnahme von Midistücken und dem Sichern des Stückes auf der Festplatte.

Wie kann man ... eigene Midistücke als eigenen Miditrack aufzeichnen ? Wir wollen im folgenden zeigen, wie man eine eigene Sequence aufzeichnet, die dann von jedem anderen Midi - Gerät abgespielt werden kann. Als einleitenden Schritt fordern wir beim MidiSystem zunächst ein Sequencer Objekt an. Mit einer getReceiver() Anweisung erzeugen wir ein Receiver Objekt, das unsere Midi – Daten, die aufgezeichnet werden sollen, an den Sequencer weitergibt. Wie man vermuten kann, ist der Sequencer bei dieser Problemstellung also unsere zentrale Klasse und spielt die wichtigste Rolle bei der Aufzeichnung einer Sequence. Bis jetzt haben wir also folgende Schritte in unserem Programm abzuarbeiten: Sequencer sequencer = MidiSystem.getSequencer(); Receiver seqReceiver = sequencer.getReceiver(); Nach diesen - für uns nicht neuen - Schritten, müssen wir nun ein eigenes Sequence - Objekt erzeugen. Sequence Objekte kennen wir schon aus dem Kapitel 6, bei dem wir eine Midi - Datei bzw. die darin enthaltene Sequence an Midi - Informationen wiedergegeben haben. Neu ist hierbei allerdings, daß wir ja unsere eigene Sequence erzeugen wollen. Wir müssen also zunächst ein „leeres“ Sequence Objekt konstruieren, das wir über folgende Anweisung durchführen: Sequence unsereSeq = new Sequence(Sequence.PPQ, 10); Dem Konstruktor müssen wir zwei Midi - spezifische Argumente übergeben: einmal eine sogenannte timing - resolution und andererseits noch ein divisionType. Es sei hier nur soviel erwähnt, daß es zwei verschiedene Verfahren gibt, wie man Midi - Sequencen in Zeiteinheiten aufteilt: das hier verwendete PPQ (Zeiteinheit in Takte pro Viertelnote) oder das SMPTE (Takte pro Frame, ein Format, das aus der Filmindustrie stammt) - Verfahren. Man übergibt dem Sequence - Konstruktor also entweder als ersten Parameter ein Sequence.PPQ oder ein Sequence.X (X ist entweder: SMPTE_24, SMPTE_25, SMPTE_30, oder SMPTE_30DROP) Objekt. Für eine genauere Beschreibung dieser beiden Begriffe sei auch an dieser Stelle wieder auf [3] oder [5] verwiesen. Der zweite Wert, den wir dem Sequence - Konstruktor übergeben müssen, bezieht sich darauf, wieviele Takte pro gewählter Zeiteinheit benutzt werden sollen. In unserem Fall also 10 Takte pro Viertelnote.

__________________________________________________________________________________________ Sound-Programmierung in Java - 48 -


Auch der nun folgende Schritt ist neu für uns. Midi - Sequencen können verschiedene sogenannte Tracks besitzen, die jeweils parallel von einem Synthesizer abgearbeitet werden. Diese Tracks enthalten unter anderen Informationen darüber, wann der Synthesizer welche Note spielen soll. Um einen Track in einer Sequence zu erzeugen, wird Track track = unsereSeq.createTrack(); ausgeführt. Jetzt wird der Sequencer angewiesen, unsere Sequence zu bearbeiten, in dem wir sequencer.setSequence(unsereSeq); ausführen. Wenn wir nun sequencer.recordEnable(track, -1); in unserem Programm abarbeiten lassen, versetzen wir den Sequencer in Aufnahmebereitschaft. Um dies zu erreichen, müssen wir ihm mitteilen, auf welchem Track er in der aktuellen Sequence bearbeitet die Aufnahme durchführen soll und auf welchem Kanal die zu speichernden Midi Informationen herein-kommen werden. Übergibt man hier eine -1, wird jeder zur Verfügung stehende Kanal benutzt, d.h. alle Midi – Informationen, die der Sequencer auf seinen Kanälen erhält, werden in die Sequence geschrieben; gibt man die Nummer eines bestimmten Kanals an, werden nur die Informationen, die den Sequencer dort erreichen, auch wirklich in die Sequence geschrieben. Nach diesen umfangreicheren Befehlen, erfolgt nun der wesentlich einfachere sequencer.startRecording(); und die Aufnahme beginnt, d.h. alle Informationen, die nun den Sequencer erreichen, werden auch in die Sequence geschrieben. Um die Aufnahme zu stoppen, wird einfach sequencer.stopRecording(); ausgeführt. Zuletzt bleibt noch, die Sequence auch wirklich auf einer Platte zu sichern. Hierzu bedient man sich der write() - Methode, die die MidiSystem - Klasse zur Verfügung stellt. MidiSystem.write(unsereSeq, 0, File - Objekt); Als ersten Parameter, erwartet die Methode die zu schreibende Sequence, als zweiten einen Integer Wert, der den Midifile - Typ bestimmt (für Näheres über die verschiedenen Midifiletypen siehe [5]) und schliesslich ein File Objekt, das die Zieldatei spezifiziert. Nachdem wir gesehen haben, wie man eine Sequence erzeugen und diese als Midi - File schreiben kann, bleibt die Frage, wie man überhaupt die Informationen über die zu spielenden Noten in eine Sequence eingebracht werden. Daher kommen wir zu ...

__________________________________________________________________________________________ Sound-Programmierung in Java - 49 -


Wie kann man ... eigene Noten in eine Sequence schreiben ? Um diese Frage zu lösen, benötigen wir sogenannte MidiMessages. Diese MidiMessages sind nach der Midi - Spezifikation wie folgt definiert. Es gibt drei verschiedene Gruppen von Messages, nämlich: 1. Short - Message 2. Sysex - Message 3. Meta - Message Wir werden hier nur die erste Art benutzen. Für eine Übersicht über die anderen Arten sei auch hier wieder auf [5] und in knapper Form auf [3] verwiesen. Kommen wir zu den Short - Messages. In einer solchen Nachricht sind Midi - Daten (z.B. „spiele Note x mit dem Anschlag y“) gekapselt. Diese Eigenschaft werden wir ausnutzen und somit eine Möglichkeit haben, in unsere Sequence eine Abfolge von Short - Messages zu schreiben, in denen unsere Noten gekapselt sind. Eine Short - Message, wird in der Java Sound API durch sogenannte ShortMessage Objekte repräsentiert. Bei der Erstellung einer Short - Message verfährt man wie folgt: ShortMessage meineNote = new ShortMessage(); erzeugt zunächst einmal ein „leeres“ ShortMessage Objekt, das noch keinerlei Midi - Informationen enthält. Diese gelangen erst durch meineNote.setMessage(ShortMessage.NOTE_ON, 0, 60, 93); in das Objekt. setMessage erwartet als ersten Parameter ein Kommando (die wichtigsten wären ShortMessage.NOTE_ON, ShortMessage.NOTE_OFF), als zweiten die Nummer des Midi – Kanals, auf den die Message bei einem Gerät gesendet werden soll, drittens die zu spielende Note als Integer - Wert (hier die 60, die einem mittleren C entspricht) und schliesslich einen Integer, der bestimmt, wie stark die Note auf dem virtuellen Keyboad angeschlagen werden soll, also die Velocity. Um nun eine solche Midi - Nachricht an ein Midi - Gerät zu schicken, benötigen wir ein dem Gerät zugeordnetes Receiver - Objekt und benutzen die Receiver - Methode send(). Konkret sieht dies wie folgt aus: [Receiver-Obj. des Gerätes zu dem Nachricht geschickt wird].send(shortM,time); shortM ist hierbei die zu sendende Short - Message bzw. das entsprechende Java Objekt. Noch neu für uns ist der Wert time. Dieser im long - Format vorliegende Wert gibt den sogenannten Zeitstempel der Midi - Nachricht an. Zeitstempel bedeutet, daß einer Midi - Nachricht eine Zeit zugeordnet werden kann zu der das Midi - Gerät die Nachricht verarbeiten soll. Setzt man diesen Wert auf

eine

-1, wird dem Gerät überlassen, wann es die Nachricht verarbeitet; eine genaue Zeit wird also nicht vorgeschrieben. Näheres zu den Zeitstempeln bei Midi - Messages findet man wieder unter [5] und __________________________________________________________________________________________ Sound-Programmierung in Java - 50 -


[3]. In unseren einfachen Beispielen werden wir nur den Wert -1 benutzen und es somit dem Gerät überlassen, wann es die Nachricht verarbeitet. Nach diesen theoretischen Aspekten kommen wir nun zu einem praktischen Beispiel, in dem alle - in diesem Kapitel neu hinzugekommenen - Sachverhalte angewendet werden. Bei diesem Programm handelt es sich um die RecMidi.java Applikation: import javax.sound.midi.*; import java.io.File; import java.io.IOException; class RecMidi { static Sequencer sequencer = null; static Receiver seqReceiver = null; static ShortMessage message = null; static Sequence newSequence = null; static Track track = null; static void main(String args[]) { try { sequencer = MidiSystem.getSequencer(); sequencer.open(); seqReceiver = sequencer.getReceiver(); }catch(MidiUnavailableException e) {System.out.println("Synthesizer nicht verfuegbar!"); System.exit(0);} try { //erzeuge unsere eigene Sequence in die wir später unsere Noten schreiben newSequence = new Sequence(Sequence.PPQ, 10); //erzeuge einen Track in dieser Sequence der unsere Noten aufnimmt track = newSequence.createTrack(); //übergib dem Sequencer unsere Sequence als seine aktuelle Sequence sequencer.setSequence(newSequence); }catch(InvalidMidiDataException e){System.out.println("Kein gueltiges MidiFormat!");System.exit(0);} //Sequencer vorbereiten für Aufnahme sequencer.recordEnable(track, 0); __________________________________________________________________________________________ Sound-Programmierung in Java - 51 -


//beginne die Aufnahme sequencer.startRecording(); // erzeuge nun die MidiMessages die aufgenommen werden sollen // und schicke diese zum Sequencer damit dieser sie aufnimmt in Sequence message = new ShortMessage(); try { message.setMessage(ShortMessage.NOTE_ON, 0, 60, 93); seqReceiver.send(message, -1); message.setMessage(ShortMessage.NOTE_OFF, 0, 60, 93); seqReceiver.send(message, -1); message.setMessage(ShortMessage.NOTE_ON, 0, 62, 93); seqReceiver.send(message, -1); message.setMessage(ShortMessage.NOTE_OFF, 0, 62, 93); seqReceiver.send(message, -1); message.setMessage(ShortMessage.NOTE_ON, 0, 64, 93); seqReceiver.send(message, -1); message.setMessage(ShortMessage.NOTE_OFF, 0, 64, 93); seqReceiver.send(message, -1); }catch(InvalidMidiDataException e) {System.out.println("MidiDaten nicht korrekt!"); System.exit(0);} //Aufnahme beendet sequencer.stopRecording(); //Erzeuge File - Objekt das Zieldatei bestimmt File file = new File("my.mid"); //schreibe Midi - File auf Platte try { MidiSystem.write(newSequence, 0, file); }catch(IOException e){System.out.println("Fehler beim Schreiben des MidiFiles!");System.exit(1);} //stoppe den Sequencer sequencer.stop(); try { Thread.sleep(5000); } catch (InterruptedException e) { } System.exit(0); } } __________________________________________________________________________________________ Sound-Programmierung in Java - 52 -


Das Programm erzeugt eine kleine Midi - Datei „my.mid“. In dieser Datei ist eine kleine Sequence enthalten, die eine Abfolge von drei Tönen auf einem Track beinhaltet. Begonnen wird mit dem mittleren C (die Note 60), dann die Note 62 und schliesslich 64. Schauen wir uns das Programm nun genauer an. Zu Beginn werden die schon vertrauten Dinge veranlasst. Man fordert einen Sequencer bei dem MidiSystem an, fordert von diesem wiederum einen Receiver an, über den wir später unsere Midi Messages an den Sequencer schicken können. Daraufhin erzeugen wir eine Sequence, in die der Track eingebettet ist, der unsere Noten aufnimmt: newSequence = new Sequence(Sequence.PPQ, 10);

Wir können sehen, daß in dem Beispiel das „Takte - Pro - Viertelnote - Zeiteinheiten“ - Verfahren benutzt wird (PPQ), und daß pro Viertelnote 10 Takte zu erfolgen haben. Im Anschluss daran, wird ein Track in unserer Sequence erzeugt track = newSequence.createTrack(); und die Sequence an den Sequencer übergeben: sequencer.setSequence(newSequence); Die nächsten Schritte versetzen den Sequencer in Aufnahmebereitschaft: sequencer.recordEnable(track, 0); sequencer.startRecording(); Er wird angewiesen, nur die Midi – Informationen, die auf seinem Kanal 0 eintreffen (bestimmt durch den zweiten Integer - Parameter), in unsere Sequence und speziell dort im Track track aufzunehmen. Im nächsten Anweisungsblock, werden unsere ShortMessage - Objekte erzeugt, die über den Receiver seqReceiver und dessen send() - Methode an den Sequencer geschickt werden und von diesem in unsere Sequence bzw. in unseren Track übernommen werden. Zum Schluss wird die Aufnahme durch sequencer.stopRecording(); gestoppt; was noch bleibt, ist, unser kleines Midi - Stück in eine Datei mit dem Namen „my.mid“ zu schreiben. Dies übernehmen folgende Anweisungen: File file = new File("my.mid"); MidiSystem.write(newSequence, 0, file); Zum Schluss wird dem System noch die Zeit gegeben, die Aufgabe zu erfüllen, bevor der Sequencer gestoppt und das Programm beendet wird. Dieses kleine Beispielprogramm sollte zeigen, wie man eigene Midi - Stücke aufnehmen kann und diese anschließend in eine Midi - Datei schreibt. Eine Anwendung hierfür wäre beispielsweise unsere __________________________________________________________________________________________ Sound-Programmierung in Java - 53 -


schon erwähnte Swing - Applikation, bei der ein User auf einem „virtuellen“ Keyboard spielen kann. Vorstellbar wäre diesen Ansatz um die Möglichkeit zu erweitern, sein Spiel auf dem Keyboard als Midi - Datei auf der Festplatte zu konservieren. Bei den in diesem Kapitel neu hinzugekommenen Methoden die die Möglichkeit haben, Java Exceptions zu erzeugen, handelt es sich um:

Methode [Sequencer – Objekt].recordEnable( ) MidiSystem.write( ) [MidiMessage – Objekt].setMessage( ) [Receiver – Objekt].send( )

erzeugte Exception IllegalArgumentException IllegalArgumentException, IOException IllegalArgumentException IllegalStateException

Mit dem Schluss des Teils II haben wir die kurze Einführung zum Thema Java Sound API beendet. In Teil III wird kurz auf eine weitere Möglichkeit eingegangen Java zur Soundgenerierung zu benutzen: das sogenannte Java Media Framework

__________________________________________________________________________________________ Sound-Programmierung in Java - 54 -


TEIL III Java Media Framework (javax.media.*)

__________________________________________________________________________________________ Sound-Programmierung in Java - 55 -


Kapitel 9 - Musik - Player : Die Grundfunktion

Das Java Media Framework ist durch die Unterstützung von fast allen gängigen Audio- und Videoformaten relativ einfach als universeller Player nutzbar. Wenn man im Internet nach Beispielen für die Nutzung des Java Media Framework sucht, wird man fast nur Applets oder mit Unterstützung von Swing erstellte Programme finden. Der Grund liegt darin, daß es direkt im Java Media Framework Klassen für eine grafische Benutzeroberfläche gibt. Im folgenden wird vor allem die Funktion von Java Media Framework als Musik - Player betrachtet. Dies wird aber der Übersichtlichkeit halber nicht mit Hilfe der grafischen Benutzeroberfläche gezeigt. In den Kapiteln 9.1 bis 9.5 wird das Grundgerüst des in Kapitel 9.6 abgedruckten Players schrittweise beschrieben. Im Kapitel 10 wird beschrieben, wie mit dem Java Media Framework eigene Musikstücke aufgenommen werden können. Der Umgang mit der grafischen Benutzeroberfläche wird mit Hilfe eines Beispielprogrammes von SUN in Kapitel 11 erläutert. Einige interessante Möglichkeiten, die das Java Media Framework noch bietet, werden kurz im Kapitel 12 beschrieben. In Anhang B finden sich die hier im Text benutzten Quellen.

Kapitel 9.1 - Initialisierung

Um einen Player zu erzeugen, muß man zuerst eine Variable vom Type Player definieren Player wplayer = null

und danach den Player initialisieren wplayer = Manager.createPlayer(url)

Falls der Player

hier aus irgendeinem Grund nicht initialisiert werden konnte, wird

NoPlayerException zurückgegeben. Außerdem kann es eine IOException auftreten, da der

Player versucht, die in einer Url stehende Datei zu öffnen. Wie man sehen kann, muß der Player mit einer Url aufgerufen werden. Um die Url zu erzeugen, benötigt man nur einen Dateinamen oder direkt eine Internet-Adresse. Wir gehen im folgenden von __________________________________________________________________________________________ Sound-Programmierung in Java - 56 -


der Situation aus, daß wir eine Datei von der Festplatte abspielen möchten. Bei der Eingabe eines Dateinamens mit Pfadangabe, ist es nur wichtig zu wissen, daß anstatt des in DOS üblichen Backslash nur ein Slash benutzt wird. Da die Datei auf der Festplatte liegt, muß vor dem Dateinamen noch ein "file:" eingefügt werden. Nun muß die Url (hier als src bezeichnet) nur noch in ein für den Player gültiges Format geändert werden url = new URL(src)

Hierbei kann es zu einer MalformedURLException kommen, falls die übergebene Adresse falsch war. Bevor der Player gestartet werden kann, müssen noch die Befehle wplayer.realize() und wplayer.prefetch() ausgeführt werden. Diese Befehle sorgen dafür, daß die Variablen, Puffer,

usw. für den Player eingerichtet werden. Mit Hilfe des in Kapitel 12 beschriebenen ControllerListener ist es möglich, zu erfahren, wann realize und prefetch abgeschlossen

sind, da RealizeCompleteEvent und PrefetchCompleteEvent beim Beenden von realize und prefetch ausgelöst werden. Neben der hier beschriebenen Methode createPlayer() gibt es auch noch die Methode createProcessor(), die es erlaubt, Musik nicht nur abzuspielen, sondern vorher auch noch zu

bearbeiten. Solange das Java Media Framework nur zum Abspielen von Musik benutzt wird, sollte createPlayer() reichen.

Kapitel 9.2 - Play, Stop

Nachdem der Player initialisiert wurde, kann jetzt begonnen werden, das bei der Initialisierung angegebene

Musikstück

abzuspielen.

Um

den

Player

zu

starten,

genügt

es

einfach

wplayer.start() aufrufen. Um das Abspielen zu stoppen, reicht wplayer.stop(). Damit der

Player nicht unnötig viele Ressourcen nutzt, ist es besser nach dem Befehl wplayer.stop() die belegten Ressourcen mit wplayer.deallocate() wieder frei zu geben. Dies sollte aber auf jeden Fall beim Beenden des Players geschehen (siehe Kapitel 9.5). Wenn der Player mit wplayer.stop() angehalten wurde, kann mit dem Befehl wplayer.start() an der gleichen Stelle im Musikstück das Abspielen fortgesetzt werden.

__________________________________________________________________________________________ Sound-Programmierung in Java - 57 -


Kapitel 9.3 - Aktuelle Spielzeit auslesen, neue Spielzeit setzen

Mit

Time AktuelleZeit = wplayer.getMediaTime()

kann die aktuelle Spielzeit vom Musikstück ausgelesen werden. Mit wplayer.setMediaTime(new Time(0))

kann man z.B. die aktuelle Spielzeit auf den Anfang des Musikstückes setzen. Die Befehle setMediaTime und getMediaTime können aufgerufen werden, während der Player ein Musikstück

abspielt. Bei setMediaTime springt der Player dann sofort zu der angegebenen Stelle und spielt die Musik weiter ab. Um die Gesamtspiellänge zu ermitteln, kann man Time Gesamtlaenge = wplayer.getDuration()

benutzen.

Kapitel 9.4 - Schneller Vorlauf

Bei

einigen Formaten ist Java Media Framework sogar in der Lage, Dateien in doppelter

Geschwindigkeit abzuspielen. Die aktuelle Spielgeschwindigkeit kann man mit getRate() abgefragt werden. Wenn man aber die Geschwindigkeit mit setRate((int) Geschwindigkeit) setzen will, muß vorher sichergestellt sein, daß der Player gerade kein Stück abspielt. Das Abspielen mit doppelter Geschwindigkeit ist z.B. bei *.wav ,*.au ,*.aif möglich. Nicht möglich ist es dagegen bei *.mp3.

__________________________________________________________________________________________ Sound-Programmierung in Java - 58 -


Kapitel 9.5 - Player schließen

Um den Player zu schließen, sollte man am besten folgendermaßen vorgehen : -

Player stoppen

-

Ressourcen freigeben

-

Player schließen

Wie schon in Kapitel 1.2 beschrieben, wird der Player mit stop() gestoppt und die Ressourcen werden mit deallocate() freigegeben. Um den Player endgültig zu beenden, genügt der Befehl close().

Kapitel 9.6 - Ein Beispielprogramm

Dieses Beispielprogramm zeigt einen Musik-Player, der die Grundfunktionen Start, Stop, Zurücksetzen der aktuellen Zeit auf Null und das Einstellen der Wiedergabe mit doppelter Geschwindigkeit beherrscht. Das Programm wurde mit folgenden Dateitypen getestet : *.wav, *.mp3, *.au, *.aif Das Programm ist wie folgt aufzurufen : java WavPlayer <Musikdatei> import javax.media.*;

// JMF

import javax.media.protocol.*;

// JMF

import java.io.*;

// für Bildschirmausgabe...

import java.net.*;

// URL...

public class WavPlayer { Player wplayer = null; public static void main (String args[]) { if (args.length == 0) throw new IllegalArgumentException ("Fehler : Keine Datei angegeben! z.B. WavPlayer test.wav"); __________________________________________________________________________________________ Sound-Programmierung in Java - 59 -


WavPlayer wplay = new WavPlayer(args[0]); } private void Menu() { System.out.println("Funktionen :"); System.out.println("

e = Ende");

System.out.println("

s = Stop");

System.out.println("

a = Start");

System.out.println("

o = Startposition 0");

System.out.println("

r = Rate 1 oder 2");

} public WavPlayer(String datei) { String src = "file:"+datei;// Dateinamen für lokale Festplatte ändern URL url = null; // Datei - Adresse ändern ;

Player initialisieren

try { // Den gesamten Dateinamen in url - Format umändern if ((url = new URL(src)) == null) { System.out.println("Fehler URL=null ;"+src+";"+url); System.out.println("Bitte die Schreibweise überprüfen"); System.out.println("z.B. WavPlayer test.wav oder WavPlayer e:/test.wav"); return; } try { // Player erzeugen wplayer = Manager.createPlayer(url); } catch (NoPlayerException e) { System.out.println("Fehler - create Player"); } } catch (MalformedURLException e) { // Fehler bei url - Erstellung System.out.println("Fehler URL : "+datei); } catch (IOException e) { System.out.println("Fehler IO"); } wplayer.realize(); wplayer.prefetch(); // Player ist bereit ... char Taste = 'b';

// dummy - Taste zur Initialisierung

float Rate; __________________________________________________________________________________________ Sound-Programmierung in Java - 60 -


// Programmschleife Menu(); do { try { Taste = (char) System.in.read(); } catch (IOException e) { System.out.println("Fehler beim einlesen der Taste"); System.exit(2); } switch(Taste) { case 's' : wplayer.stop();wplayer.deallocate();break; case 'a' : { wplayer.start(); break; } case 'r' : { wplayer.stop(); //Rate kann nicht ge채ndert werden, wenn der player l채uft Rate = wplayer.getRate(); System.out.println("aktuelle - Rate : " + Rate); if (Rate == 1.0) { Rate = (float) 2.0; } else { Rate = (float) 1.0; } System.out.println("neue - Rate : " + wplayer.setRate(Rate)); System.out.println("Falls sich der Player jetzt ausgeschaltet hat, bitte a f체r Start eingeben"); break; } case 'o' : wplayer.setMediaTime(new Time(0));break; } } while (Taste != 'e'); // Player - Ende wplayer.stop(); // falls der Player nicht manuell beendet wurde wplayer.deallocate(); wplayer.close(); System.exit(0); } } __________________________________________________________________________________________ Sound-Programmierung in Java - 61 -


Kapitel 10 - Aufnahme von Musikstücken

Dieses Kapitel bezieht sich auf das Programm SoundRecorder.java (und den dazugehörigen Programmteil StateHelper.java) im Anhang A. Es ist noch zu erwähnen, daß dieses Programm aus den Hilfe-Dateien von SUN [6] herauskopiert ist. Leider war es nicht möglich, das Programm auszuführen. Zuerst muß man ein Eingabegerät mit Vector deviceList = CaptureDeviceManager.getDeviceList (new AudioFormat(AudioFormat.LINEAR, 44100, 16, 2))

auswählen. Hier werden die Geräte ausgesucht, die eine Samplerate von 44 kHz mit 16 Bit und Stereo beherrschen. Als nächstes muß ein Gerät ausgesucht werden. Für das Mikrofon als Eingabegerät muß nun mit CaptureDeviceInfo di = (CaptureDeviceInfo) deviceList.firstElement()

ein Player, wie in Kapitel 9.1 beschrieben, initialisiert werden. Anstatt der Url gibt man hier den oben erzeugten MediaLocator ein. Der Aufruf sieht also wie folgt aus : Player p = Manager.createPlayer(di.getLocator())

Mit p.start() beginnt der Player mit der Aufnahme und endet mit p.stop(). Es stellt sich nun die Frage , wie die Aufnahme gespeichert werden kann. Für diesen Fall gibt es DataSink. Mit Hilfe von DataSink kann man aufgenommene Musikstücke relativ einfach auf der Festplatte speichern. Um die Daten zu speichern, die der Player jetzt vom Mikrofon bekommt, muß zuerst der Dateityp mit p.setContentDescriptor(new FileTypeDescriptor(FileTypeDescriptor.WAVE))

festgelegt werden (hier *.wav). Danach wird die Ausgabe des Players mit DataSource source = p.getDataOutput()

geholt. Als letzte Variable fehlt jetzt noch der Dateiname, unter dem die Daten gespeichert werden sollen, und der mit MediaLocator dest = newMediaLocator(Dateiname)

gesetzt wird. Nun wird der DataSink mit DataSink filewriter = Manager.createDataSink(source, dest)

erzeugt. Nachdem der DataSink mit open() geöffnet wurde, kann man mit start() die Aufnahme beginnen und mit stop() beenden. Mit close() wird der DataSink wieder geschlossen. Um das Erzeugen zu großer Dateien zu verhindern kann mit StreamWriterControl swc = (StreamWriterControl) p.getControl ("javax.media.control.StreamWriterControl"); If (swc != null) swc.setStreamSizeLimit(größe in Byte);

die maximale Dateigröße festgelegt werden. __________________________________________________________________________________________ Sound-Programmierung in Java - 62 -


Kapitel 11 - Musik-Player und Swing

Kapitel 11.1 - Grafische Oberfläche

Wie bereits in Kapitel 9 beschrieben, gibt es die Möglichkeit mit einer grafischen Oberfläche zu arbeiten. Das Aussehen läßt sich mit Hilfe von java.awt.* (AWT Layout Manager) steuern. Die Einstellungen lassen sich durch Component visual = wplayer.getVisualComponent()

verändern; so kann z.B. durch visual.width und visual.height die Breite und Höhe des Players verändert werden. Weiterhin besteht die Möglichkeit, ein Control Panel einzurichten. Dafür muß man Component control = wplayer.getControlPanelComponent() mit getContentPane().add("South", control)

zum Fenster hinzufügen. In diesem Control Panel sind standardmäßig Buttons für Start, Stop, Pause und eine Laufleiste für die aktuelle Wiedergabe - Position im Musikstück vorhanden. Falls ein Musikstück z.B. zuerst noch aus dem Internet heruntergeladen werden muß, kann mit getCachingControl und getProgressBar noch eine Anzeige des Download – Fortschritts

erzeugt werden. Es ist außerdem möglich, dem Fenster mit getGainControl einen Lautstärkeregler hinzuzufügen.

Kapitel 11.2 - Ein Beispielprogramm

MDIApp.java

: Dies ist ein Beispielprogramm, das aus den Internet-Seiten von SUN [7]

entnommen ist. Es zeigt einen Sound-Player unter Swing.

__________________________________________________________________________________________ Sound-Programmierung in Java - 63 -


import javax.media.*; import com.sun.media.ui.*; import javax.media.protocol.*; import javax.swing.*; import javax.swing.event.*; import java.awt.*; import java.awt.event.*; import java.net.*; import java.io.*; import java.util.Vector; public class MDIApp extends Frame { /********************************************************************** *** * MAIN PROGRAM / STATIC METHODS ********************************************************************** ***/ public static void main(String args[]) { MDIApp mdi = new MDIApp(); } static void Fatal(String s) { MessageBox mb = new MessageBox("JMF Error", s); } /********************************************************************** *** * VARIABLES ********************************************************************** ***/ JMFrame jmframe = null; JDesktopPane desktop; FileDialog fd = null; CheckboxMenuItem cbAutoLoop = null; Player player = null; Player newPlayer = null; String filename; /********************************************************************** *** * METHODS __________________________________________________________________________________________ Sound-Programmierung in Java - 64 -


********************************************************************** ***/ public MDIApp() { super("Java Media Player"); // Add the desktop pane setLayout( new BorderLayout() ); desktop = new JDesktopPane(); desktop.setDoubleBuffered(true); add("Center", desktop); setMenuBar(createMenuBar()); setSize(640, 480); setVisible(true); try { UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel"); } catch (Exception e) { System.err.println("Could not initialize java.awt Metal lnf"); } addWindowListener( new WindowAdapter() { public void windowClosing(WindowEvent we) { System.exit(0); } } ); Manager.setHint(Manager.LIGHTWEIGHT_RENDERER, new Boolean(true)); } private MenuBar createMenuBar() { ActionListener al = new ActionListener() { public void actionPerformed(ActionEvent ae) { String command = ae.getActionCommand(); if (command.equals("Open")) { if (fd == null) { fd = new FileDialog(MDIApp.this, "Open File", FileDialog.LOAD);

fd.setDirectory("/movies"); } fd.show(); if (fd.getFile() != null) { __________________________________________________________________________________________ Sound-Programmierung in Java - 65 -


String filename = fd.getDirectory() + fd.getFile(); openFile("file:" + filename); } } else if (command.equals("Exit")) { dispose(); System.exit(0); } } }; MenuItem item; MenuBar mb = new MenuBar(); // File Menu Menu mnFile = new Menu("File"); mnFile.add(item = new MenuItem("Open")); item.addActionListener(al); mnFile.add(item = new MenuItem("Exit")); item.addActionListener(al); // Options Menu Menu mnOptions = new Menu("Options"); cbAutoLoop = new CheckboxMenuItem("Auto replay"); cbAutoLoop.setState(true); mnOptions.add(cbAutoLoop); mb.add(mnFile); mb.add(mnOptions); return mb; } /** * Open a media file. */ public void openFile(String filename) { String mediaFile = filename; Player player = null; // URL for our media file URL url = null; try { // Create an url from the file name and the url to the // document containing this applet. if ((url = new URL(mediaFile)) == null) { Fatal("Can't build URL for " + mediaFile); __________________________________________________________________________________________ Sound-Programmierung in Java - 66 -


return; } // Create an instance of a player for this media try { player = Manager.createPlayer(url); } catch (NoPlayerException e) { Fatal("Error: " + e); } } catch (MalformedURLException e) { Fatal("Error:" + e); } catch (IOException e) { Fatal("Error:" + e); } if (player != null) { this.filename = filename; JMFrame jmframe = new JMFrame(player, filename); desktop.add(jmframe); } } } class JMFrame extends JInternalFrame implements ControllerListener { Player mplayer; Component visual = null; Component control = null; int videoWidth = 0; int videoHeight = 0; int controlHeight = 30; int insetWidth = 10; int insetHeight = 30; boolean firstTime = true; public JMFrame(Player player, String title) { super(title, true, true, true, true); getContentPane().setLayout( new BorderLayout() ); setSize(320, 10); setLocation(50, 50); setVisible(true); mplayer = player; mplayer.addControllerListener((ControllerListener) this); mplayer.realize(); addInternalFrameListener( new InternalFrameAdapter() { __________________________________________________________________________________________ Sound-Programmierung in Java - 67 -


public void internalFrameClosing(InternalFrameEvent ife) { mplayer.close(); } } ); } public void controllerUpdate(ControllerEvent ce) { if (ce instanceof RealizeCompleteEvent) { mplayer.prefetch(); } else if (ce instanceof PrefetchCompleteEvent) { if (visual != null) return; if ((visual = mplayer.getVisualComponent()) != null) { Dimension size = visual.getPreferredSize(); videoWidth = size.width; videoHeight = size.height; getContentPane().add("Center", visual); } else videoWidth = 320; if ((control = mplayer.getControlPanelComponent()) != null) { controlHeight = control.getPreferredSize().height; getContentPane().add("South", control); } setSize(videoWidth + insetWidth, videoHeight + controlHeight + insetHeight); validate(); mplayer.start(); } else if (ce instanceof EndOfMediaEvent) { mplayer.setMediaTime(new Time(0)); mplayer.start(); } } }

__________________________________________________________________________________________ Sound-Programmierung in Java - 68 -


Kapitel 12 - Weitere ausgewählte Funktionen

Es gibt noch einige interessante Funktionen des Java Media Framework, die hier zumindest noch Erwähnung finden sollten. Wenn beispielsweise der Player nach einer bestimmten Zeit aufhören soll, ein Musikstück wiederzugeben, so kann dazu setStopTime(Zeit) benutzt werden. Manchmal ist es auch nötig mehrere Musikstücke gleichzeitig abzuspielen; in diesem Fall ist es ratsam, die beiden Player zu synchronisieren. Dies geschieht mit getTimeBase, setTimeBase und syncStart.

In Kapitel 9.1 wurde schon vom ControllerListener gesprochen. Nun zu der Frage, wofür der denn da ist.

Nicht nur realize und prefetch lösen Events aus, sondern fast alles hier

Beschrieben kann Events auslösen. Wenn ein Musikstück zu ende ist, wird z.B. EndOfMediaEvent ausgelöst. Dies kann dazu benutzt werden, wieder an den Anfang zurückzuspringen. Weitere Events sind : CachingControlEvent (siehe oben in diesem Kapitel); StartEvent (nach dem Start der Wiedergabe); StopByRequestEvent (falls versucht wird, einen bereits gestoppten Player noch mal zu stoppen);

ControllerColsedEvent (falls der Controller mit close()

geschlossen wurde); uvm.

__________________________________________________________________________________________ Sound-Programmierung in Java - 69 -


Anhang A Programmbeispiele

__________________________________________________________________________________________ Sound-Programmierung in Java - 70 -


In diesem Anhang finden sich alle Beispiele, die aus Platzmangel im Fliesstext keine Ber端cksichtigung finden konnten. Das erste Beispielprogramm, ist das Programm PlaySoundStreamedT.java aus Kapitel 2 Soundgenerierung

import javax.sound.sampled.*; import javax.sound.midi.*; import java.io.*; class PlaySoundStreamedT extends Thread { static File file = null;

// die zu streamende Datei

static AudioInputStream stream = null;//ueber diesen Stream werden //die AudioDaten aus der Datei //"file" gelesen static AudioFormat af = null; // gibt das AudioFormat der Datei "file" //an static SourceDataLine sl = null;// ueber diese DataLine wird die //Datei "file" abgespielt static byte

ba[] = null;// Array enthaelt die Sounddateibytes die //aktuell aus dem AudioInputStream "stream" //gelesen wurden und dann ueber die //SourceDataLine "sl" abgespielt werden

static int numBytesRead = 0;// Anzahl der gelesenen Bytes aus dem //Soundfile static long frames = 0, // Anzahl der Frames aus der die //Sounddatei besteht die in "file" //angegeben ist bSize = 0;

// Groesse der Sounddatei die in "file" //angegeben ist in Bytes

static PlaySoundStreamedT pss = null; static boolean play = true; public PlaySoundStreamedT(File fi) {

__________________________________________________________________________________________ Sound-Programmierung in Java - 71 -


// Erzeuge den InputStream auf die Datei "file" try { stream = AudioSystem.getAudioInputStream(file); }catch(UnsupportedAudioFileException e){System.out.println("Die gewaehlte Sounddatei wird nicht unterstuetzt!"); System.exit(1);} catch(IOException e2){System.out.println("Fehler beim Erzeugen des AudioInputStreams");System.exit(1);} //bestimme das Format der abzuspielenden Datei af = stream.getFormat(); // bestimmt die Länge der Sounddatei in Frames frames = stream.getFrameLength(); // bestimmt die Länge der Sounddatei in Bytes bSize = frames * af.getFrameSize(); System.out.println("Die Dateigroesse betraegt:"+bSize+" in Bytes"); //erzeuge DataLine.info die spezifiziert welche Art von Eingabe man haben //will beim AudioSystem DataLine.Info info = new DataLine.Info (SourceDataLine.class,af); //versuche mit Hilfe von "info" die gewünschte Eingabe beim AudioSystem zu //bekommen try{ sl = (SourceDataLine) AudioSystem.getLine(info); }catch(LineUnavailableException e){System.out.println("Line konnte nicht benutzt werden");System.exit(1);} } //die Hauptmethode der Applikation public void run() { //oeffne und reserviere somit fuer diese Applikation die SourceDataLine try{ sl.open(); }catch(LineUnavailableException e){System.out.println("Fehler beim Öffnen des AudioStreams");System.exit(1);} //starte die Line zum Abspielen des Sounds sl.start(); int ava=0;

__________________________________________________________________________________________ Sound-Programmierung in Java - 72 -


//lege den Buffer an in den die Sounddateidaten eingelesen werden ueber //die AudioInputStream ba = new byte[1024]; //gib dem User an wieviele Bytes an Audiodaten zu lesen sind try { ava = stream.available(); }catch(IOException e){System.exit(1);} System.out.println("Bytes zu lesen:"+ava); //Spiele Sound while(play) { //lese SounddateiDaten in Buffer ein try { numBytesRead = stream.read(ba,0,1024); }catch(IOException e){System.out.println("Fehler beim Lesen der SounddateiDaten"); System.exit(1);} //wenn Ende der Sounddatei bzw. Streams erreicht beende Schleife if (numBytesRead == -1) break;//Ende der Sounddatei erreicht! //schreibe gelesene Sounddateidaten in SourceDataLine und veranlasse somit //das Abspielen der Daten sl.write(ba,0,ba.length); } // blockiere bis die letzten Daten abgespielt wurden sl.drain(); // halte die Line an und schliesse die Line sl.stop(); sl.close(); sl=null; System.out.println("

... Fertig!");

return; } // main - Methode der Applikation public static void main (String args[]) { if(args.length == 0) throw new IllegalArgumentException ("Syntax: java PlaySoundStreamedT <file>"); file = new File(args[0]); pss = new PlaySoundStreamedT(file); __________________________________________________________________________________________ Sound-Programmierung in Java - 73 -


pss.start(); System.out.println("Spiele wav ..."); System.out.println("Druecke <RETURN> fuer STOP"); try { int c = System.in.read(); }catch(IOException e){System.exit(1);} play = false; System.out.println("...STOP"); System.exit(0); } }

Dieses Programm erwartet beim Start als Parameter den Name oder den Pfad der wiederzugebenden Sounddatei. Das Abspielen der Datei kann jederzeit, durch den Druck auf die RETURN – Taste, beendet werden. Dieses Beispielprogramm soll einen einfachen auf Konsolenebene laufenden Audio Player realisieren. Nach dem schon gezeigten einfachen Kommandozeilenplayer, kommen wir nun zu einer Swing Applikation, die einen Player realisiert, der sich vollständig über GUI - Elemente steuern läßt. Dieses Beispielprogramm wurde in Kapitel 5 - Kontrollen erwähnt, in dem die Control – Objekte der Java Sound API vorgestellt wurden. Das Programm gliedert sich in folgende drei Klassen: • AudioPlayer.java - die Klasse, welche die Applikation startet • AudioPlayerPanel.java - die Klasse, die die GUI aufbaut • PlayBack.java - die Klasse, die die Wiedergabe der Sounddateien durchführt

Hier nun zuerst den Quellcode der AudioPlayer.java - Klasse: import

java.awt.BorderLayout;

import

java.awt.GridLayout;

import

java.awt.FlowLayout;

import

java.awt.event.ActionEvent;

import

java.awt.event.ActionListener;

import

java.awt.event.WindowEvent;

import

java.awt.event.WindowAdapter;

import

java.io.BufferedInputStream;

import

java.io.File;

import

java.io.FileInputStream;

import

java.io.InputStream;

import

java.io.IOException;

__________________________________________________________________________________________ Sound-Programmierung in Java - 74 -


import

javax.sound.sampled.UnsupportedAudioFileException;

import

javax.sound.sampled.LineUnavailableException;

import

javax.swing.JFrame;

import

javax.swing.JCheckBox;

import

javax.swing.JButton;

import

javax.swing.JPanel;

import

javax.swing.JLabel;

import

javax.swing.JSlider;

import

javax.swing.JFileChooser;

import

javax.swing.event.ChangeEvent;

import

javax.swing.event.ChangeListener;

public class AudioPlayer extends

JFrame

{ private JButton

loadB;

private JLabel

fileName;

private JFileChooser

fileChooser;

private AudioPlayerPanel

panel;

public AudioPlayer() { super("AudioPlayer1.0"); //端berwache das Schliessen des Applikationsfensters this.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent we) { System.exit(0); } }); JPanel

filePanel = new JPanel();

filePanel.setLayout(new FlowLayout()); //erstelle einen LOAD - Button mit einem entsprechenden Listener loadB = new JButton("Load..:"); loadB.addActionListener(new ActionListener() { public voidactionPerformed (ActionEvent ae) { loadAudioFile(); } }); __________________________________________________________________________________________ Sound-Programmierung in Java - 75 -


filePanel.add(loadB); fileName = new JLabel("Kein AudioFile geladen!"); filePanel.add(fileName); panel = new AudioPlayerPanel(filePanel); this.getContentPane().add(panel); } //Methode wird aufgerufen wenn Load-Button gedrueckt wurde private void loadAudioFile() { //erzeuge ein FileChooser Element um Auswahl der Datei die abgespielt //werden soll zu vereinfachen if (fileChooser == null) { fileChooser = new JFileChooser(); } int

nOption = fileChooser.showOpenDialog(this);

if (nOption != JFileChooser.APPROVE_OPTION) { return; } //bestimme die vom User gew채hlte Datei File audioFile = fileChooser.getSelectedFile(); if (panel.setAudioFile(audioFile)) { fileName.setText(audioFile.getName()); } } public static void main(String[] args) { AudioPlayer ap = new AudioPlayer(); ap.pack(); ap.show(); } }

Nun folgt der Quellcode f체r AudioPlayerPanel.java: import

java.awt.BorderLayout;

import

java.awt.GridLayout;

import

java.awt.FlowLayout;

import

java.awt.event.ActionEvent;

import

java.awt.event.ActionListener;

import

java.awt.event.WindowEvent;

__________________________________________________________________________________________ Sound-Programmierung in Java - 76 -


import

java.awt.event.WindowAdapter;

import

java.io.BufferedInputStream;

import

java.io.File;

import

java.io.FileInputStream;

import

java.io.InputStream;

import

java.io.IOException;

import

javax.sound.sampled.UnsupportedAudioFileException;

import

javax.sound.sampled.LineUnavailableException;

import

javax.swing.JFrame;

import

javax.swing.JCheckBox;

import

javax.swing.JButton;

import

javax.swing.JPanel;

import

javax.swing.JLabel;

import

javax.swing.JSlider;

import

javax.swing.JFileChooser;

import

javax.swing.JOptionPane;

import

javax.swing.event.ChangeEvent;

import

javax.swing.event.ChangeListener;

public class AudioPlayerPanel extends

JPanel

{ protected JButton

loadB;

protected JLabel

fileName;

protected JButton

startB;

protected JButton

stopB;

protected JButton

pauseB;

protected JButton

resumeB;

protected JSlider

gainS;

protected JSlider

panS;

private PlayBack

playBack;

private File

audioFile;

private File

dataFile;

public AudioPlayerPanel(JPanel northPanel) { playBack = new PlayBack(); this.setLayout(new BorderLayout()); this.add("North", northPanel); Jpanel controlPanel = new JPanel(); controlPanel.setLayout(new GridLayout(0, 1)); this.add("South", controlPanel); Jpanel subControlPanel1 = new JPanel(); __________________________________________________________________________________________ Sound-Programmierung in Java - 77 -


subControlPanel1.setLayout(new FlowLayout()); controlPanel.add(subControlPanel1); //ueber START - Button ist das Starten der Wiedergabe der //gelesenen Audiodatei mรถglich startB = new JButton("Start"); startB.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent ae) { //starte die Wiedergabe startPlayback(); } }); subControlPanel1.add(startB); //ueber den STOP-Button haelt man die Wiedergabe an stopB = new JButton("Stop"); stopB.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent ae) { //stoppe die Wiedergabe stopPlayback(); } }); subControlPanel1.add(stopB); JPanel

subControlPanel2 = new JPanel();

subControlPanel2.setLayout(new FlowLayout()); controlPanel.add(subControlPanel2); //PAUSE-Button veranlasst die Wiedergabe zu pausieren pauseB = new JButton("Pause"); pauseB.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent ae) { //pausiere mit der Wiedergabe pausePlayback(); } }); subControlPanel2.add(pauseB); //RESUME-Button ermรถglicht es die pausierte Wiedergabe __________________________________________________________________________________________ Sound-Programmierung in Java - 78 -


//fortzusetzen resumeB = new JButton("Resume"); resumeB.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent ae) { //setze pausierte Wiedergabe fort resumePlayback(); } }); subControlPanel2.add(resumeB); startB.setEnabled(false); stopB.setEnabled(false); pauseB.setEnabled(false); resumeB.setEnabled(false); //mit Volume laest sich Wiedergabelautstaerke regeln subControlPanel1.add(new JLabel("Volume")); gainS = new JSlider(JSlider.HORIZONTAL, -90, 24, 0); gainS.addChangeListener(new ChangeListener() { public void stateChanged(ChangeEvent ce) { //passe Lautstaerke an changeGain(); } }); subControlPanel1.add(gainS); //mit Balance laesst sich Verhaeltnis rechter/linker Kanal //beeinflussen subControlPanel2.add(new JLabel("Balance")); panS = new JSlider(JSlider.HORIZONTAL, -100, 100, 0); panS.addChangeListener(new ChangeListener() { public void stateChanged(ChangeEvent ce) { //passe Balance an changePan(); } }); subControlPanel2.add(panS); __________________________________________________________________________________________ Sound-Programmierung in Java - 79 -


} //Methode bestimmt aktuelles Audiofile das wiedergegeben werden soll public boolean setAudioFile(File file) { dataFile = file; //erzeuge ein Playback Objekt mit dem die Datei wiedergegeben wird try { playBack = new PlayBack(dataFile, this); } catch (UnsupportedAudioFileException e) { JOptionPane.showMessageDialog(null, "Das Audioformat wird nicht unterstuetzt."); return false; } catch (IllegalArgumentException e) { JOptionPane.showMessageDialog(null, "Das Audioformat wird nicht unterstuetzt."); return false; } catch (LineUnavailableException e) { JOptionPane.showMessageDialog(null, "Keine Line zum Abspielen vorhanden!"); return false; } catch (IOException e) { JOptionPane.showMessageDialog(null, "IOFehler!."); return false; } audioFile = dataFile; startB.setEnabled(true); stopB.setEnabled(false); pauseB.setEnabled(false); resumeB.setEnabled(false); return true; } //startet die Wiedergabe bei einem Playback Objekt private void startPlayback() { __________________________________________________________________________________________ Sound-Programmierung in Java - 80 -


playBack.start(); startB.setEnabled(false); stopB.setEnabled(true); pauseB.setEnabled(true); resumeB.setEnabled(false); } //stoppt die Wiedergabe bei einem Playback Objekt protected void stopPlayback() { playBack.stop(); startB.setEnabled(true); stopB.setEnabled(false); pauseB.setEnabled(false); resumeB.setEnabled(false); } //pausiert die Wiedergabe bei einem Playback Objekt private void pausePlayback() { playBack.pause(); startB.setEnabled(false); stopB.setEnabled(true); pauseB.setEnabled(false); resumeB.setEnabled(true); } //setzt die Wiedergabe bei einem Playback Objekt fort private void resumePlayback() { playBack.resume(); startB.setEnabled(false); stopB.setEnabled(true); pauseB.setEnabled(true); resumeB.setEnabled(false); } //aendert die Wiedergabelautstaerke bei einem Playback Objekt private void changeGain() { int

nValue = gainS.getValue();

float fGain = (float) nValue; playBack.setGain(fGain); __________________________________________________________________________________________ Sound-Programmierung in Java - 81 -


} //aendert die Balance bei einem Playback Objekt private void changePan() { int

nValue = panS.getValue();

float fPan = nValue * 0.01F; playBack.setPan(fPan); } }

Zuletzt noch die wichtigste Klasse der Applikation, n채mlich PlayBack.java: import

java.io.File;

import

java.io.IOException;

import

javax.sound.sampled.AudioFormat;

import

javax.sound.sampled.AudioInputStream;

import

javax.sound.sampled.Clip;

import

javax.sound.sampled.AudioSystem;

import

javax.sound.sampled.DataLine;

import

javax.sound.sampled.LineUnavailableException;

import

javax.sound.sampled.SourceDataLine;

import

javax.sound.sampled.UnsupportedAudioFileException;

import

javax.sound.sampled.FloatControl;

public class PlayBack implements

Runnable

{ private static boolean isRunning; private static boolean paused = false; private static Thread

thread = null;

private static File

audioFile;

private static AudioInputStream

stream;

private static FloatControl

clipGainControl;

private static FloatControl

clipPanControl;

private static AudioFormat audioFormat; private static Clip clip; private static AudioPlayerPanel parent = null; public PlayBack() { audioFile = null; }

__________________________________________________________________________________________ Sound-Programmierung in Java - 82 -


public PlayBack(File file,AudioPlayerPanel parent)throws UnsupportedAudioFileException, LineUnavailableException,IOException { this(); audioFile = file; this.parent = parent; initAudioInputStream(audioFile); } private void initAudioInputStream(File file)throws UnsupportedAudioFileException,LineUnavailableException,IOException { //erzeuge AudioInputStream auf Quelldatei try { stream = AudioSystem.getAudioInputStream(file); } catch (IOException e) { throw new IllegalArgumentException("Kann keinen AudioInputStream erzeugen auf: " + file); } if (stream == null) { throw new IllegalArgumentException("Kann keinen AudioInputStream erzeugen auf: " + file); } //bereite den Clip vor um die Wiedergabe zu starten initClip(); } //Methode erstellt alle nötigen Voraussetzungen um Clip abzuspielen private void initClip()throws LineUnavailableException,IOException { DataLine.Info info = new DataLine.Info(Clip.class,audioFormat); clip = (Clip) AudioSystem.getLine(info); //pruefe welche Control Objekte zur Verfügung stehen if (clip.isControlSupported(FloatControl.Type.MASTER_GAIN)) { clipGainControl = (FloatControl) clip.getControl(FloatControl.Type.MASTER_GAIN); }

__________________________________________________________________________________________ Sound-Programmierung in Java - 83 -


if (clip.isControlSupported(FloatControl.Type.PAN)) { clipPanControl = (FloatControl) clip.getControl(FloatControl.Type.PAN); } //reserviere Clip fuer diese Anwendung clip.open(stream); } //starte die Wiedergabe in dem Thread erzeugt wird public void start() { thread = new Thread(this); thread.start(); } //stoppe die Wiedergabe und setze entsprechend die Button //eigenschaften bei Panel public void stop() { clip.stop(); clip.setFramePosition(0); parent.startB.setEnabled(true); parent.stopB.setEnabled(false); parent.pauseB.setEnabled(false); parent.resumeB.setEnabled(false); isRunning = false; } //pausiere Wiedergabe public void pause() { clip.stop(); isRunning = false; paused = true; } //setzte Wiedergabe fort public void resume() { isRunning = true; paused = false; thread = new Thread(this); thread.start(); } //im Thread wird Wiedergabe gestartet __________________________________________________________________________________________ Sound-Programmierung in Java - 84 -


public void run() { isRunning = true; clip.start(); while(clip.isActive() && isRunning){} if(paused) clip.stop(); else stop(); } //setzt den neuen Lautstaerkewert public void setGain(float fGain) { if(clipGainControl != null) clipGainControl.setValue(fGain); } //setzt den neuen Balance-Wert public void setPan(float fPan) { if(clipPanControl != null) clipPanControl.setValue(fPan); } }

SoundRecorder.java : Ein Beispielprogramm zur Aufnahme von Sound-Dateien, kopiert aus den Hilfe-Dateien von SUN [6]. Aufruf : java SoundRecorder import import import import import import import

javax.media.*; javax.media.protocol.*; javax.media.format.*; javax.media.control.*; java.io.*; java.net.*; java.util.*;

public class SoundRecorder { public static void main (String args[]) { SoundRecorder srec = new SoundRecorder(); } public SoundRecorder() { CaptureDeviceInfo di = null; Processor p = null; StateHelper sh = null; Vector deviceList = CaptureDeviceManager.getDeviceList(new AudioFormat(AudioFormat.LINEAR, 44100, 16, 2)); __________________________________________________________________________________________ Sound-Programmierung in Java - 85 -


if (deviceList.size() > 0) di = (CaptureDeviceInfo)deviceList.firstElement(); else // Exit if we can't find a device that does linear, // 44100Hz, 16 bit, // stereo audio. System.exit(-1); try { p = Manager.createProcessor(di.getLocator()); sh = new StateHelper(p); } catch (IOException e) { System.exit(-1); } catch (NoProcessorException e) { System.exit(-1); } // Configure the processor if (!sh.configure(10000)) System.exit(-1); // Set the output content type and realize the processor p.setContentDescriptor(new FileTypeDescriptor(FileTypeDescriptor.WAVE)); if (!sh.realize(10000)) System.exit(-1); // get the output of the processor DataSource source = p.getDataOutput(); // create a File protocol MediaLocator with the location of the // file to which the data is to be written MediaLocator dest = new MediaLocator("file://foo.wav"); // create a datasink to do the file writing & open the sink to // make sure we can write to it. DataSink filewriter = null; try { filewriter = Manager.createDataSink(source, dest); filewriter.open(); } catch (NoDataSinkException e) { System.exit(-1); } catch (IOException e) { System.exit(-1); } catch (SecurityException e) { System.exit(-1); } // if the Processor implements StreamWriterControl, we can // call setStreamSizeLimit // to set a limit on the size of the file that is written. StreamWriterControl swc = (StreamWriterControl) p.getControl("javax.media.control.StreamWriterControl"); //set limit to 5MB if (swc != null) swc.setStreamSizeLimit(5000000);

}

}

// now start the filewriter and processor try { filewriter.start(); } catch (IOException e) { System.exit(-1); } // Capture for 5 seconds sh.playToEndOfMedia(5000); sh.close(); // Wait for an EndOfStream from the DataSink and close it... filewriter.close();

__________________________________________________________________________________________ Sound-Programmierung in Java - 86 -


StateHelper.java : Dieses Programm wird fĂźr SoundRecorder.java benĂśtigt und ist ebenfalls aus den Hilfe-Dateien von SUN [6] kopiert. import javax.media.*;

public class StateHelper implements javax.media.ControllerListener { Player player = null; boolean configured = false; boolean realized = false; boolean prefetched = false; boolean eom = false; boolean failed = false; boolean closed = false; public StateHelper(Player p) { player = p; p.addControllerListener(this); } public boolean configure(int timeOutMillis) { long startTime = System.currentTimeMillis(); synchronized (this) { if (player instanceof Processor) ((Processor)player).configure(); else return false; while (!configured && !failed) { try { wait(timeOutMillis); } catch (InterruptedException ie) { } if(System.currentTimeMillis()- startTime > timeOutMillis) break; } } return configured; }

__________________________________________________________________________________________ Sound-Programmierung in Java - 87 -


public boolean realize(int timeOutMillis) { long startTime = System.currentTimeMillis(); synchronized (this) { player.realize(); while (!realized && !failed) { try { wait(timeOutMillis); } catch (InterruptedException ie) { } if(System.currentTimeMillis()- startTime > timeOutMillis) break; } } return realized; } public boolean prefetch(int timeOutMillis) { long startTime = System.currentTimeMillis(); synchronized (this) { player.prefetch(); while (!prefetched && !failed) { try { wait(timeOutMillis); } catch (InterruptedException ie) { } if(System.currentTimeMillis()- startTime > timeOutMillis) break; } } return prefetched && !failed; } public boolean playToEndOfMedia(int timeOutMillis) { long startTime = System.currentTimeMillis(); eom = false; synchronized (this) { player.start(); while (!eom && !failed) { try { wait(timeOutMillis); } catch (InterruptedException ie) { } if (System.currentTimeMillis() - startTime > timeOutMillis) __________________________________________________________________________________________ Sound-Programmierung in Java - 88 -


break; } } return eom && !failed; } public void close() { synchronized (this) { player.close(); while (!closed) { try { wait(100); } catch (InterruptedException ie) { } } } player.removeControllerListener(this); } public synchronized void controllerUpdate(ControllerEvent ce) { if (ce instanceof RealizeCompleteEvent) { realized = true; } else if (ce instanceof ConfigureCompleteEvent) { configured = true; } else if (ce instanceof PrefetchCompleteEvent) { prefetched = true; } else if (ce instanceof EndOfMediaEvent) { eom = true; } else if (ce instanceof ControllerErrorEvent) { failed = true; } else if (ce instanceof ControllerClosedEvent) { closed = true; } else { return; } notifyAll(); } }

__________________________________________________________________________________________ Sound-Programmierung in Java - 89 -


Anhang B Quellenangaben

[1] http://java.sun.com/products/java-media/sound/ [2] http://java.sun.com/products/jdk/1.3/docs/guide/sound API - Doku [3] http://java.sun.com/products/jdk/1.3/docs/guide/sound/ [4] http://archives.java.sun.com/archives/javasound-interest.html [5] http://www.midi.org [6] http://java.sun.com/products/java-media/jmf/2.0/specdownload.html [7] http://java.sun.com/products/java-media/jmf/2.0/solutions/SwingJMF.html

__________________________________________________________________________________________ Sound-Programmierung in Java - 90 -


test