www.Gerhard-Raabe.de
  Java Package
 
 
Back   Sound
 
Copyright: Das nachfolgenden Packages ist frei verfügbar, solange es nicht kommerziell verwendet wird! Falls es so wie veröffentlicht, in Teilen oder abgewandelt zum Einsatz kommt, würde ich mich sehr über eine kurze E-Mail freuen.
 
Package-Name: Sound
 
Enthaltende Klassen: Sound.CSound
Sound.CChannel
Sound.CConfigMIDIDialog
Sound.CConfigNoteDialog
Sound.CPiano
 
Anwendung: In diesem Package sind Funktionalitäten zum Erzeugen, Abspielen und Speichern von Sequencen hinterlegt. Grundsätzlich ist es noch weiter ausbaubar.

Darüberhinaus werden hier auch zwei Konfigurationsdialoge zur Verfügung gestellt. Mit dem Dialog CConfigMIDIDialog können die Parameter des Synthesizer konfiguriert werden. Für die Erzeugung eigener Sequencen ermöglicht der Dialog CConfigNoteDialog die Länge und Klangdauer der Noten festzulegen.
 
Beschreibung: An dieser Stelle wird auf eine ausführliche Beschreibung der MIDI-Schnittstelle verzichtet. Diese ist ausführlich in der einschlägigen Literatur und an diversen Stellen im Internet beschrieben.

MIDI-Initalisierung:

Zum Erzeugen und Abspielen einer Ton-Sequence wird zunächst wird eine Synthesizer benötigt, der aus der Klasse MidiSystem bezogen werden kann:

  public static Synthesizer MidiSystem.getSynthesizer()  

Mittels:

  Synthesizer.open()  

wird der Synthesizer initalisiert. Die Informationen über die MIDI-Channels lassen sich dann über:

  public MidiChannel[] Synthesizer.getChannels();  

auslesen. Die Eigenschafte eines jeden Channels können dann über seine zugehörige MidiChannel-Klasse modifiziert werden.

Die installierten Instrument können der Soundbank-Klasse entnommen werden. Diese kann ebenfalls aus der Synthesizer-Klasse ausgelesen werden.

        .
      .
      .
Synthesizer l_Synthesizer = Synthesizer MidiSystem.getSynthesizer();

// read instrument-informations and set the first instrument in the list as default
Soundbank l_Soundbank = l_Synthesizer.getDefaultSoundbank();
if (l_Soundbank != null)
{
      m_Instruments = l_Soundbank.getInstruments();
      m_Synthesizer.loadInstrument(m_Instruments[0]);
}
      .
      .
      .
 


Erzeugen einer Sequence:

Zum Erzeugen einer eigenen Sequence kann diese über ihren Konstruktor erzeugt werden:

  public Sequence(float divisionType, int resolution)  

Das erste Argument gibt die Art und Weise an, wie das Timing erzeugt werden soll. Hier gibt es im wesentlichen die Möglichkeiten, einen internen Timer zu verwenden, der auf Bruchteilen von Viertelnoten basiert, oder mit externer Synchronisation zu arbeiten, bei der die Timing-Informationen im SMPTE-Format zur Verfügung gestellt werden. Meist wird die erste Variante gewählen und dazu die Konstante Sequence.PPQ als erstes Argument übergeben. Das zweite Argument resoultion bezieht sich auf das erste und gibt die Auflösung des Timers an.

Um eine Sequence mit Daten zu füllen, wird mindestens ein Track benötigt, der durch Aufruf von createTrack erzeugt werden kann:

  public Track createTrack()  

Ein Track-Objekt ist zunächst leer und wird durch wiederholte Aufrufe von add mit Midi-Ereignissen versehen:

  public boolean add(MidiEvent event)  

Nachdem die Sequence fertiggestellt ist, kann sie durch Aufruf von setSequence an den Sequencer übergeben werden:

  public void setSequence(Sequence sequence)  


Arbeiten mit Sequencen:

Eine Sequence kann dann über die Sequencer-Klasse abgespielt bzw gestoppt werden:

  public void stop()
 
  public void stop()
 
  public boolean isRunning()
 

Sequencen können über eine statische Methode des MIDI-System auf das FileSystem gespeichert werden:

  MidiSystem.write(Sequence in, int type, File out);  


Beispiel zum Erzeugen einer Sequence:

        .
      .
      .
// Create Note-List
int[] l_Note = new int [ .. ];
      .
      .
      .
// Init Parameter
int l_ChannelId = 0;
int l_InstrumentId = 0;
int l_CurrentTick = 0;
int l_Velocity = 64;
int l_Resolution = 20;
int l_NoteLength = 10;
int l_Stakkato = 60;

// Create Sequence
Sequence l_Sequence = new Sequence(Sequence.PPQ, l_Resolution);

// Create Track
Track l_Track = l_Sequence.createTrack();

// Set Instrument
ShortMessage l_ShortMessage = new ShortMessage();
l_ShortMessage.setMessage(ShortMessage.PROGRAM_CHANGE, l_ChannelId, l_InstrumentId, 0);
l_Track.add(new MidiEvent(l_ShortMessage, l_CurrentTick));

for (int l_Index = 0; l_Index < Note.length; l_Index++)
{
      l_ShortMessage = new ShortMessage();
      l_ShortMessage.setMessage(ShortMessage.NOTE_ON, l_ChannelId, Note[l_Index], l_Velocity);
      l_Track.add(new MidiEvent(l_ShortMessage, l_CurrentTick));
      l_CurrentTick = l_CurrentTick + (int)((double)l_NoteLength / 100.0 * l_Stakkato);

      l_ShortMessage = new ShortMessage();
      l_ShortMessage.setMessage(ShortMessage.NOTE_OFF, l_ChannelId, Note[l_Index], 0);
      l_Track.add(new MidiEvent(l_ShortMessage, l_CurrentTick));
      l_CurrentTick = l_CurrentTick + l_NoteLength - (int)((double)l_NoteLength / 100.0 * l_Stakkato);
}
      .
      .
      .
 

 
Methoden: Die Klasse CSound:

CSound verwaltet unter anderem die Channels des MIDI-Synthesizer Der aktive kann Channel kann mit den folgenden Methoden verändert werden:

  public int getChannelId()  
  public void setChannelId(int ChannelId)  
  public int getMaxNrOfChannel()  

Die Eigenschaften der einzelnen oder des aktiven Channels können mit den nachfolgenden Methoden modifiziert und abgefragt werden:

  public int getInstrumentId()  
  public int getInstrumentId(int ChannelId)  
  public void setInstrumentId(int InstrumentId)  
  public void setInstrumentId(int ChannelId, int InstrumentId)  
  public int getVelocity()  
  public int getVelocity(int ChannelId)  
  public void setVelocity(int Velocity)  
  public void setVelocity(int ChannelId, int Velocity)  
  public int getPressure()  
  public int getPressure(int ChannelId)  
  public void setPressure(int Pressure)  
  public void setPressure(int ChannelId, int Pressure)  
  public int getReverb()  
  public int getReverb(int ChannelId)  
  public void setReverb(int Reverb)  
  public void setReverb(int ChannelId, int Reverb)  
  public int getBend()  
  public int getBend(int ChannelId)  
  public void setBend(int Bend)  
  public void setBend(int ChannelId, int Bend)  
  public boolean getMute()  
  public boolean getMute(int ChannelId)  
  public void setMute(boolean Mute)  
  public void setMute(int ChannelId, boolean Mute)  
  public boolean getSolo()  
  public boolean getSolo(int ChannelId)  
  public void setSolo(boolean Solo)  
  public void setSolo(int ChannelId, boolean Solo)  
  public boolean getMono()  
  public boolean getMono(int ChannelId)  
  public void setMono(boolean Mono)  
  public void setMono(int ChannelId, boolean Mono)  

Für die Erzeugung eigener Sequencen kann die Resolution (Schläge / sec) angegeben werden. Die Notenlänge definiert sich in Anzahl Schlägen. Stakkato ist der Zeitanteil der Notenlänge, in der die Note klingkt:

  public int getResolution()  
  public void setResolution(int Resolution)  
  public int getNoteLength()  
  public void setNoteLength(int NoteLength)  
  public int getStakkato()  
  public void setStakkato(int Stakkato)  

Eigene Sequencen lassen sich mit createSequence erzeugen. Dazu wird der Methode eine Notenliste übergeben, aus der entsprechend der Einstellungen eine Sequence erzeugt wird:

  public Sequence createSequence(int[] Note)  

Die zu übergebenen Integer-Werte entsprechen dabei den folgenden Noten:

  c cis/des d dis/es e f fis/ges g gis/as a ais/b h  
  Subkontra
Oktave
C2-H2 12 13 14 15 16 17 18 19 20 21 22 23  
  Kontra
Oktave
C1-H1 24 25 26 27 28 29 30 31 32 33 34 35  
  Große
Oktave
C-H 36 37 38 39 40 41 42 43 44 45 46 47  
  Kleine
Oktave
c-h 48 49 50 51 52 53 54 55 56 57 58 59  
  eingestrichene
Oktave
c1-h1 60 61 62 63 64 65 66 67 68 69 70 71  
  zwegestrichene
Oktave
c2-h2 72 73 74 75 76 77 78 79 80 81 82 83  
  dreigestrichene
Oktave
c3-h3 84 85 86 87 88 89 90 91 92 93 94 95  
  viergestrichene
Oktave
c4-h4 96 97 98 99 100 101 102 103 104 105 106 107  

Die folgenden Methoden dienen zum Abspielen, Stoppen und Speichern von Sequencen. Wird keine spezifische Sequence angegeben, dann wird die aktive Sequence der Klasse CSound verwendet:

  public void playSequence()  
  public void playSequence(Sequence sequence)  
  public void stopSequence()  
  public void saveSequence()  
  public void saveSequence(Sequence sequence)  


Der Dialog CConfigMIDIDialog:

CConfigMIDIDialog dient zur Konfiguration des MIDI-Synthesizer:

  public CConfigMIDIDialog(Frame owner, String Titel, CSound Sound)  

CCConfigMIDIDialog


Der Dialog CConfigNoteDialog:

Mit CConfigNoteDialog können die Parameter zur Notenbildung beeinflußt werden:

  public CConfigNoteDialog(Frame owner, String Titel, CSound Sound)  

CCConfigNoteDialog

 
Beispiel:
        .
      .
      .
CSound l_Sound = new CSound()
      .
      .
      .
// Open MIDI-Config
CConfigMIDIDialog l_ConfigMIDIDialog = new CConfigMIDIDialog(this, "Titel", l_Sound);
l_ConfigMIDIDialog.show();
      .
      .
      .
// Open Note-Config
CConfigNoteDialog l_ConfigNoteDialog = new CConfigNoteDialog(this, "Titel", l_Sound);
l_ConfigNoteDialog.show();
      .
      .
      .
// Create Note-List
int[] l_Note = new int [ .. ];
      .
      .
      .
// Create Sequence
Sequence l_Sequence = l_Sound.createSequence(l_Note);

// Play Sequence
l_Sound.playSequence(l_Sequence);
      .
      .
      .
 

 
Download:
Next   *.class
Next
  *.java
372892 Besucher - seit dem 01.02.2005 - 1 Besucher online © 2004-2015 by Gerhard Raabe ##, ## ### #### - ##:##:##