[JAVA] Spiegazione codice d'inserimento di un file sonoro

[alessia86]

guardando su dei libri ho trovato il seguente codice che mi permette d'inserire un file sonoro di tipo wave..Ma non ho capito bene come funziona..Qualcuno può spiegarmelo?

import java.io.DataInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
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;


public class sound {

public AudioFormat format;
public byte[] samples;

public sound(String filename){
try{
// System.out.println(filename);
AudioInputStream stream = AudioSystem.getAudioInputStream(new File(filename));
format = stream.getFormat();
samples = getSamples(stream);
}
catch (UnsupportedAudioFileException e){
e.printStackTrace();
}
catch (IOException e){
e.printStackTrace();
}
}

public byte[] getSamples(){
return samples;
}


public byte[] getSamples(AudioInputStream stream){
int length = (int)(stream.getFrameLength() * format.getFrameSize());
byte[] samples = new byte[length];
DataInputStream in = new DataInputStream(stream);
try{
in.readFully(samples);
}
catch (IOException e){
e.printStackTrace();
}
return samples;
}


public void play(InputStream source){
// 100 ms buffer for real time change to the sound stream
int bufferSize = format.getFrameSize() * Math.round(format.getSampleRate() / 10);
byte[] buffer = new byte[bufferSize];
SourceDataLine line;
try{
DataLine.Info info = new DataLine.Info(SourceDataLine.class, format);
line = (SourceDataLine)AudioSystem.getLine(info);
line.open(format, bufferSize);
}
catch (LineUnavailableException e){
e.printStackTrace();
return;
}

line.start();
try{
int numBytesRead = 0;
while (numBytesRead != -1){
numBytesRead = source.read(buffer, 0, buffer.length);
if (numBytesRead != -1)
line.write(buffer, 0, numBytesRead);
}
}
catch (IOException e){
e.printStackTrace();
}
line.drain();
line.close();
}


}



Grazie ;)

[PGI-Bis]

Il bello della rete è che si trovano certi dinosauri...

1. prendi il file audio:

File file = new File("z:\\audio\\sample.wav");

2. Crei un flusso audio che punta a quel file:

AudioInputStream stream = AudioSystem.getAudioInputStream(file);

3. Apri un Clip - che è un riproduttore di file audio

Clip player = AudioSystem.getClip();

4. passi al clip il flusso audio:

player.open(stream);

5. avvii il clip:

player.start();

Fine.

Questo è un esempio completo:

import javax.sound.sampled.*;
import java.io.*;

public class Main {

public static void main(String[] args) throws Throwable {
File file = new File("z:\\audio\\RRUU005W.wav");
AudioInputStream in = AudioSystem.getAudioInputStream(file);
Clip clip = AudioSystem.getClip();
clip.open(in);
clip.start();
Thread.sleep(10000);
}
}

Lo sleep serve per mantenere in vita la JVM mentre il sotto sistema audio riproduce il file. Non è necessario nel caso di un'applicazione reale perchè in quel caso sarà l'interfaccia a tenere in vita l'applicazione.

[alessia86]

Ok :) grazie..l'ho appena provato e va alla grande...e qst almeno è molto semplice...Ne ho trovato un altra per i file midi..ma anche qst non sono riuscita a capirla bene


import java.io.File;
import java.io.IOException;

import javax.sound.midi.InvalidMidiDataException;
import javax.sound.midi.MidiFileFormat;
import javax.sound.midi.MidiSystem;
import javax.sound.midi.MidiUnavailableException;
import javax.sound.midi.Sequence;
import javax.sound.midi.Sequencer;
import javax.swing.*;

public class MusicFile extends JFrame{

String F;
Sequence S;
Sequencer seq;

public MusicFile(String fil){

F=fil;
try
{
File f2=new File(F);
MidiFileFormat mff2=MidiSystem.getMidiFileFormat(f2);
S=MidiSystem.getSequence(f2);
seq=MidiSystem.getSequencer();
seq.open();
seq.setSequence(S);
seq.setLoopCount(99);
seq.start();


}
catch(MidiUnavailableException ecc){}
catch(InvalidMidiDataException ecc2){}
catch(IOException ecc3){}
;
}
}

[PGI-Bis]

La parte sul formato puoi saltarla. Funziona come il clip solo che cambiano i nomi. Prendi un file, ottieni il "flusso dati" - che per MidiSystem è una Sequence anzichè un AudioInputStream:

File file = un File midi
Sequence sequence = MidiSystem.getSequence(file);

Poi prendi un player, in questo caso un Sequencer:

Sequencer player = MidiSystem.getSequencer(true);

lo apri

player.open();

gli passi la sequenza e lo lanci

player.setSequence(sequence);
player.start();

import javax.sound.midi.*;
import java.io.*;

public class Main {

public static void main(String[] args) throws Throwable {
File file = new File("z:\\prova.mid");
Sequence sequence = MidiSystem.getSequence(file);
Sequencer player = MidiSystem.getSequencer(true);
player.open();
player.setSequence(sequence);
player.start();
Thread.sleep(20000);
player.close();
}
}

"setLoop(x)" serve se vuoi riprodurre il suono x volte, come il "loop" di Clip. Se vuoi riprodurre il suono in continuazione dirai setLoop(Sequencer.LOOP_CONTINUOSLY) e lo fermi con stop().

I formati servono quando si ha a che fare con tipi di file audio che non sono direttamente supportati dal sistema di plug-in di javasound (ad esempio ogg per i clip, non so cosa per midi). I file wav, mp3 e midi girano tranquillamente con quelle poche righe su riportate.

[alessia86]

grazie :)