[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