Cómo jugar archivos .wav con java

Question

Estoy tratando de reproducir un archivo * .wav con Java. Quiero que haga lo siguiente:
Cuando se presiona un botón, se emite un breve pitido.

Lo he buscado en Google, pero la mayor parte del código no funcionaba. ¿Alguien puede darme un fragmento de código simple para reproducir un archivo .wav?

Answer 1

fin he conseguido hacer lo siguiente y funciona bien

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(); 
    } 
} 

Answer 2

El fragmento here funciona bien, probado con ventanas de sonido:

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

Answer 3

Esta es la forma más elegante que podría venir sin usar sun. *:

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 
} 

Answer 4

Shortest forma (sin tener que instalar bibliotecas aleatorias)?

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); 
    } 
} 

El único problema es que no hay buena manera de hacer el bloqueo para cerrar y disponer los datos después de acabados * .wav este método. clip.drain() dice que está bloqueando pero no es así. El clip no se está ejecutando DERECHO DESPUÉSstart(). El único trabajo pero FEO manera que he encontrado es:

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

Answer 5

puede utilizar un detector de eventos para cerrar la pinza después de que se juega

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); 
    } 
} 

Answer 6

Otra forma de hacerlo 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(); 
     } 
    } 
} 

Answer 7

Una clase que reproducirá un archivo WAV, bloqueando hasta que el sonido haya terminado de reproducirse:

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(); 
    } 
} 

Answer 8

Puede utilizar AudioStream esta manera también:

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 actionPerformed(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(); 
      } 
     } 
    } 

} 

Answer 9

una solución sin java reflexión DataLine.Info info = nueva DataLine.Info (SourceDataLine.class, audioFormat); reflexión de java, disminución del rendimiento. a ejecutar: java tocarsonido 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 
    ( 
     String filename 
    ) throws Exception 
    { 

     AudioInputStream 
     audioStream = 
     AudioSystem.getAudioInputStream 
     (new File (filename)); 

     int BUFFER_SIZE = 128000; 
     AudioFormat audioFormat = null; 
     SourceDataLine sourceLine = null; 

     audioFormat = audioStream.getFormat(); 

     sourceLine = (SourceDataLine) 
     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(); 
    } 

}