Jak odtwarzać pliki .wav za pomocą java

Question

Próbuję odtworzyć plik * .wav w Javie. Chcę, aby wykonano następujące czynności:
Po naciśnięciu przycisku odtwarzany jest krótki sygnał dźwiękowy.

Mam googleed, ale większość kodu nie działa. Czy ktoś może mi podać prosty fragment kodu do odtworzenia pliku .wav?

Answer 1

Wreszcie udało mi się wykonać następujące czynności i działa dobrze

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

Fragment here działa dobrze, przetestowane z oknami dźwiękowe:

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

Answer 3

Oto najbardziej elegancka forma mogę przyjść bez użycia słońca *:

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

Najkrótsza formularz (bez instalowania losowych bibliotek)?

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

Jedyny problem polega na tym, że nie ma dobrego sposobu na zablokowanie tej metody zamykania i usuwania danych po zakończeniu * .wav. clip.drain() mówi, że blokuje, ale tak nie jest. Klip nie działa PRAWO POstart(). Jedyny pracujący ale UGLY sposób znalazłem to:

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

Answer 5

Można używać detektor zdarzeń, aby zamknąć plik po to jest grać

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

Kolejny sposób to zrobić z 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

Klasa odtwarzająca plik WAV, blokująca do momentu zakończenia odtwarzania dźwięku:

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

Można użyć AudioStream w ten sposób, a także:

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

rozwiązanie bez java refleksji DataLine.Info o = new DataLine.Info (SourceDataLine.class, audioFormat); odbicie java zmniejszyć wydajność. uruchomić: 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 
    ( 
     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(); 
    } 

}