Come riprodurre i file .wav con java

Sto cercando di riprodurre un file *. Wav con Java. Voglio che faccia quanto segue:
Quando viene premuto un pulsante, riprodurre un breve segnale acustico.

L’ho cercato su google, ma la maggior parte del codice non funzionava. Qualcuno può darmi un semplice snippet di codice per riprodurre un file .wav?

Finalmente sono riuscito a fare quanto segue e funziona bene

import java.io.File; import java.io.IOException; 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; public class MakeSound { private final int BUFFER_SIZE = 128000; private File soundFile; private AudioInputStream audioStream; private AudioFormat audioFormat; private SourceDataLine sourceLine; /** * @param filename the name of the file that is going to be played */ public void playSound(String filename){ String strFilename = filename; try { soundFile = new File(strFilename); } catch (Exception e) { e.printStackTrace(); System.exit(1); } try { audioStream = AudioSystem.getAudioInputStream(soundFile); } catch (Exception e){ e.printStackTrace(); System.exit(1); } audioFormat = audioStream.getFormat(); DataLine.Info info = new DataLine.Info(SourceDataLine.class, audioFormat); try { sourceLine = (SourceDataLine) AudioSystem.getLine(info); sourceLine.open(audioFormat); } catch (LineUnavailableException e) { e.printStackTrace(); System.exit(1); } catch (Exception e) { e.printStackTrace(); System.exit(1); } sourceLine.start(); int nBytesRead = 0; byte[] abData = new byte[BUFFER_SIZE]; while (nBytesRead != -1) { try { nBytesRead = audioStream.read(abData, 0, abData.length); } catch (IOException e) { e.printStackTrace(); } if (nBytesRead >= 0) { @SuppressWarnings("unused") int nBytesWritten = sourceLine.write(abData, 0, nBytesRead); } } sourceLine.drain(); sourceLine.close(); } } 

Ecco la forma più elegante che potrei trovare senza usare il sole. *:

 import java.io.*; import javax.sound.sampled.*; try { File yourFile; AudioInputStream stream; AudioFormat format; DataLine.Info info; Clip clip; stream = AudioSystem.getAudioInputStream(yourFile); format = stream.getFormat(); info = new DataLine.Info(Clip.class, format); clip = (Clip) AudioSystem.getLine(info); clip.open(stream); clip.start(); } catch (Exception e) { //whatevers } 

Forma più breve (senza dover installare librerie casuali)?

 public static void play(String filename) { try { Clip clip = AudioSystem.getClip(); clip.open(AudioSystem.getAudioInputStream(new File(filename))); clip.start(); } catch (Exception exc) { exc.printStackTrace(System.out); } } 

L’unico problema è che non esiste un buon metodo per bloccare questo metodo e chiudere i dati dopo che * .wav è terminato. clip.drain() dice che sta bloccando ma non lo è. La clip non funziona RIGHT AFTER start() . L’unico modo di lavorare ma UGLY che ho trovato è:

 // ... clip.start(); while (!clip.isRunning()) Thread.sleep(10); while (clip.isRunning()) Thread.sleep(10); clip.close(); 

È ansible utilizzare un listener di eventi per chiudere la clip dopo che è stata riprodotta

 import java.io.File; import javax.sound.sampled.*; public void play(File file) { try { final Clip clip = (Clip)AudioSystem.getLine(new Line.Info(Clip.class)); clip.addLineListener(new LineListener() { @Override public void update(LineEvent event) { if (event.getType() == LineEvent.Type.STOP) clip.close(); } }); clip.open(AudioSystem.getAudioInputStream(file)); clip.start(); } catch (Exception exc) { exc.printStackTrace(System.out); } } 

Lo snippet qui funziona bene, testato con Windows Sound:

 public static void main(String[] args) { AePlayWave aw = new AePlayWave( "C:\\WINDOWS\\Media\\tada.wav" ); aw.start(); } 

Una class che riprodurrà un file WAV, bloccando fino al termine dell’esecuzione del suono:

 class Sound implements Playable { private final Path wavPath; private final CyclicBarrier barrier = new CyclicBarrier(2); Sound(final Path wavPath) { this.wavPath = wavPath; } @Override public void play() throws LineUnavailableException, IOException, UnsupportedAudioFileException { try (final AudioInputStream audioIn = AudioSystem.getAudioInputStream(wavPath.toFile()); final Clip clip = AudioSystem.getClip()) { listenForEndOf(clip); clip.open(audioIn); clip.start(); waitForSoundEnd(); } } private void listenForEndOf(final Clip clip) { clip.addLineListener(event -> { if (event.getType() == LineEvent.Type.STOP) waitOnBarrier(); }); } private void waitOnBarrier() { try { barrier.await(); } catch (final InterruptedException ignored) { } catch (final BrokenBarrierException e) { throw new RuntimeException(e); } } private void waitForSoundEnd() { waitOnBarrier(); } } 

Un altro modo di farlo con AudioInputStream :

 import java.io.File; import javax.sound.sampled.AudioInputStream; import javax.sound.sampled.AudioSystem; import javax.sound.sampled.Clip; import javax.sound.sampled.Line; import javax.sound.sampled.LineEvent; import javax.sound.sampled.LineListener; import javax.swing.JDialog; import javax.swing.JFileChooser; public class CoreJavaSound extends Object implements LineListener { File soundFile; JDialog playingDialog; Clip clip; public static void main(String[] args) throws Exception { CoreJavaSound s = new CoreJavaSound(); } public CoreJavaSound() throws Exception { JFileChooser chooser = new JFileChooser(); chooser.showOpenDialog(null); soundFile = chooser.getSelectedFile(); System.out.println("Playing " + soundFile.getName()); Line.Info linfo = new Line.Info(Clip.class); Line line = AudioSystem.getLine(linfo); clip = (Clip) line; clip.addLineListener(this); AudioInputStream ais = AudioSystem.getAudioInputStream(soundFile); clip.open(ais); clip.start(); } public void update(LineEvent le) { LineEvent.Type type = le.getType(); if (type == LineEvent.Type.OPEN) { System.out.println("OPEN"); } else if (type == LineEvent.Type.CLOSE) { System.out.println("CLOSE"); System.exit(0); } else if (type == LineEvent.Type.START) { System.out.println("START"); playingDialog.setVisible(true); } else if (type == LineEvent.Type.STOP) { System.out.println("STOP"); playingDialog.setVisible(false); clip.close(); } } } 

Una soluzione senza riflessione Java DataLine.Info info = new DataLine.Info(SourceDataLine.class, audioFormat)

La riflessione di Java riduce le prestazioni. per eseguire: java playsound absoluteFilePathTo/file.wav

 import javax.sound.sampled.*; import java.io.*; public class playsound { public static void main (String args[]) throws Exception { playSound (args[0]); } public static void playSound () throws Exception { AudioInputStream audioStream = AudioSystem.getAudioInputStream(new File (filename)); int BUFFER_SIZE = 128000; AudioFormat audioFormat = null; SourceDataLine sourceLine = null; audioFormat = audioStream.getFormat(); sourceLine = AudioSystem.getSourceDataLine(audioFormat); sourceLine.open(audioFormat); sourceLine.start(); int nBytesRead = 0; byte[] abData = new byte[BUFFER_SIZE]; while (nBytesRead != -1) { try { nBytesRead = audioStream.read(abData, 0, abData.length); } catch (IOException e) { e.printStackTrace(); } if (nBytesRead >= 0) { int nBytesWritten = sourceLine.write(abData, 0, nBytesRead); } } sourceLine.drain(); sourceLine.close(); } } 

Puoi anche utilizzare AudioStream in questo modo:

 import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStream; import javax.swing.JButton; import javax.swing.JFrame; import javax.swing.JPanel; import sun.audio.AudioPlayer; import sun.audio.AudioStream; public class AudioWizz extends JPanel implements ActionListener { private static final long serialVersionUID = 1L; //you like your cereal and the program likes their "serial" static AudioWizz a; static JButton playBuddon; static JFrame frame; public static void main(String arguments[]){ frame= new JFrame("AudioWizz"); frame.setSize(300,300); frame.setVisible(true); a= new AudioWizz(); playBuddon= new JButton("PUSH ME"); playBuddon.setBounds(10,10,80,30); playBuddon.addActionListener(a); frame.add(playBuddon); frame.add(a); } public void actionPerformsd(ActionEvent e){ //an eventListener if (e.getSource() == playBuddon) { try { InputStream in = new FileInputStream("*.wav"); AudioStream sound = new AudioStream(in); AudioPlayer.player.start(sound); } catch(FileNotFoundException e1) { e1.printStackTrace(); } catch (IOException e1) { e1.printStackTrace(); } } } }