如何跟踪音频播放位置？

Question

我创建了一个线程，通过将其转换为一个字节数组来播放Java文件中的mp3文件。

我想知道如果我可以跟踪当前的播放位置，因为MP3正在播放。

首先，我建立了我的音乐流像这样：

try { 
     AudioInputStream in = AudioSystem.getAudioInputStream(file); 

     musicInputStream = AudioSystem.getAudioInputStream(MUSIC_FORMAT, in); 

     DataLine.Info dataLineInfo = new DataLine.Info(SourceDataLine.class, MUSIC_FORMAT); 
     musicDataLine = (SourceDataLine) AudioSystem.getLine(dataLineInfo); 
     musicDataLine.open(MUSIC_FORMAT); 
     musicDataLine.start();    
     startMusicThread(); 
    } catch(Exception e) { 
     e.printStackTrace(); 
    } 

接下来，我的音乐主题是这样的：

private class MusicThread extends Thread {  
    byte musicBuffer[] = new byte[BUFFER_SIZE]; 
    public void run() { 
     try { 
      int musicCount = 0; 
      while(writeOutput){ 
       if(writeMusic && (musicCount = musicInputStream.read(musicBuffer, 0, musicBuffer.length)) > 0){ 
        musicDataLine.write(musicBuffer, 0, musicCount); 
       } 
      } 
     } catch (Exception e) { 
      System.out.println("AudioStream Exception - Music Thread"+e); 
      e.printStackTrace(); 
     } 
    } 
} 

---

我想到了一个可能性，创建另一个用一个计时器进行线程，该计时器慢慢地逐渐减小，以显示MP3歌曲的剩余时间量。但这似乎不是一个好的解决方案。

Answer 1

您的int musicCount（来自AudioInputStream.read(...)的返回值）告诉您读取的字节数，因此您可以做一个小计算来确定您在流中的位置。 （DataLine有一些方法做一些数学题的你，但他们不能总是使用...见下文）。

int musicCount = 0; 
int totalBytes = 0; 

while (loop stuff) { 
    // accumulate it 
    // and do whatever you need with it 
    totalBytes += musicCount; 

    musicDataLine.write(...); 
} 

要获得的秒数流逝，你可以做以下的事情：

AudioFormat fmt = musicInputStream.getFormat(); 

long framesRead = totalBytes/fmt.getFrameSize(); 
long totalFrames = musicInputStream.getFrameLength(); 

double totalSeconds = (double) totalFrames/fmt.getSampleRate(); 

double elapsedSeconds = 
    ((double) framesRead/(double) totalFrames) * totalSeconds; 

因此，您只需将每个循环的经过时间放在任何需要的地方即可。请注意，这种类型的准确性取决于缓冲区的大小。缓冲区越小，越准确。

此外，Clip有一些方法来为你查询这个（但你可能不得不改变你做了很多）。

这些方法（get(Long)FramePosition/getMicrosecondPosition）从DataLine继承，所以你也可以打电话给他们在SourceDataLine，以及如果你不想自己做数学题。 但是，你基本上需要为每一个你玩的文件换一行，所以这取决于你如何使用该行。 （我个人宁愿只是做了自己的分工要求，因为该行是一种不透明的。）

---

BTW：

musicDataLine.open(MUSIC_FORMAT); 

你应该打开你自己的缓冲区大小指定的路线，使用(AudioFormat, int)过载。 SourceDataLine.write(...)只有当内部缓冲区已满时才会阻止，所以如果它与您的字节数组大小不同，有时您的循环被阻塞，有时它只是旋转。

---

MCVE的好措施：

import javax.swing.*; 
import java.awt.*; 
import java.awt.event.*; 
import java.io.*; 
import java.util.*; 
import javax.sound.sampled.*; 

public class SimplePlaybackProgress 
extends WindowAdapter implements Runnable, ActionListener { 
    class AudioPlayer extends Thread { 
     volatile boolean shouldPlay = true; 
     final int bufferSize; 

     final AudioFormat fmt; 

     final AudioInputStream audioIn; 
     final SourceDataLine audioOut; 

     final long frameSize; 
     final long totalFrames; 
     final double sampleRate; 

     AudioPlayer(File file) 
       throws UnsupportedAudioFileException, 
         IOException, 
         LineUnavailableException { 

      audioIn  = AudioSystem.getAudioInputStream(file); 
      fmt   = audioIn.getFormat(); 
      bufferSize = fmt.getFrameSize() * 8192; 
      frameSize = fmt.getFrameSize(); 
      totalFrames = audioIn.getFrameLength(); 
      sampleRate = fmt.getSampleRate(); 
      try { 
       audioOut = AudioSystem.getSourceDataLine(audioIn.getFormat()); 
       audioOut.open(fmt, bufferSize); 
      } catch (LineUnavailableException x) { 
       try { 
        audioIn.close(); 
       } catch(IOException suppressed) { 
        // Java 7+ 
        // x.addSuppressed(suppressed); 
       } 
       throw x; 
      } 
     } 

     @Override 
     public void run() { 
      final byte[] buffer = new byte[bufferSize]; 
      long framePosition = 0; 

      try { 
       audioOut.start(); 

       while (shouldPlay) { 
        int bytesRead = audioIn.read(buffer); 
        if (bytesRead < 0) { 
         break; 
        } 

        int bytesWritten = audioOut.write(buffer, 0, bytesRead); 
        if (bytesWritten != bytesRead) { 
         // shouldn't happen 
         throw new RuntimeException(String.format(
          "read: %d, wrote: %d", bytesWritten, bytesRead)); 
        } 

        framePosition += bytesRead/frameSize; 
        // or 
        // framePosition = audioOut.getLongFramePosition(); 
        updateProgressBar(framePosition); 
       } 

       audioOut.drain(); 
       audioOut.stop(); 
      } catch (Throwable x) { 
       showErrorMessage(x); 
      } finally { 
       updateProgressBar(0); 

       try { 
        audioIn.close(); 
       } catch (IOException x) { 
        showErrorMessage(x); 
       } 

       audioOut.close(); 
      } 
     } 

     void updateProgressBar(
       final long framePosition) { 
      SwingUtilities.invokeLater(new Runnable() { 
       @Override 
       public void run() { 
        double fractionalProgress = 
         (double) framePosition/(double) totalFrames; 
        int progressValue = (int) Math.round(
         fractionalProgress * theProgressBar.getMaximum()); 

        theProgressBar.setValue(progressValue); 

        int secondsElapsed = (int) Math.round(
         (double) framePosition/sampleRate); 
        int minutes = secondsElapsed/60; 
        int seconds = secondsElapsed % 60; 

        theProgressBar.setString(String.format(
         "%d:%02d", minutes, seconds)); 
       } 
      }); 
     } 

     void stopPlaybackAndDrain() throws InterruptedException { 
      shouldPlay = false; 
      this.join(); 
     } 
    } 

    /* * */ 

    public static void main(String[] args) { 
     SwingUtilities.invokeLater(new SimplePlaybackProgress()); 
    } 

    JFrame theFrame; 
    JButton theButton; 
    JProgressBar theProgressBar; 

    // this should only ever have 1 thing in it... 
    // multithreaded code with poor behavior just bugs me, 
    // even for improbable cases, so the queue makes it more robust 
    final Queue<AudioPlayer> thePlayerQueue = new ArrayDeque<AudioPlayer>(); 

    @Override 
    public void run() { 
     theFrame = new JFrame("Playback Progress"); 
     theFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 

     theButton = new JButton("Open"); 
     theProgressBar = new JProgressBar(
      SwingConstants.HORIZONTAL, 0, 1000); 
     theProgressBar.setStringPainted(true); 
     theProgressBar.setString("0:00"); 

     Container contentPane = theFrame.getContentPane(); 
     ((JPanel) contentPane).setBorder(
      BorderFactory.createEmptyBorder(8, 8, 8, 8)); 
     contentPane.add(theButton, BorderLayout.WEST); 
     contentPane.add(theProgressBar, BorderLayout.CENTER); 

     theFrame.pack(); 
     theFrame.setResizable(false); 
     theFrame.setLocationRelativeTo(null); 
     theFrame.setVisible(true); 

     theButton.addActionListener(this); 
     theFrame.addWindowListener(this); 
    } 

    @Override 
    public void actionPerformed(ActionEvent ae) { 
     JFileChooser dialog = new JFileChooser(); 
     int option = dialog.showOpenDialog(theFrame); 

     if (option == JFileChooser.APPROVE_OPTION) { 
      File file = dialog.getSelectedFile(); 
      try { 
       enqueueNewPlayer(new AudioPlayer(file)); 
      } catch (UnsupportedAudioFileException x) { // ew, Java 6 
       showErrorMessage(x);     // 
      } catch (IOException x) {     // 
       showErrorMessage(x);     // 
      } catch (LineUnavailableException x) {  // 
       showErrorMessage(x);     // 
      }           // 
     } 
    } 

    @Override 
    public void windowClosing(WindowEvent we) { 
     stopEverything(); 
    } 

    void enqueueNewPlayer(final AudioPlayer newPlayer) { 
     // stopPlaybackAndDrain calls join 
     // so we want to do it off the EDT 
     new Thread() { 
      @Override 
      public void run() { 
       synchronized (thePlayerQueue) { 
        stopEverything(); 
        newPlayer.start(); 
        thePlayerQueue.add(newPlayer); 
       } 
      } 
     }.start(); 
    } 

    void stopEverything() { 
     synchronized (thePlayerQueue) { 
      while (!thePlayerQueue.isEmpty()) { 
       try { 
        thePlayerQueue.remove().stopPlaybackAndDrain(); 
       } catch (InterruptedException x) { 
        // shouldn't happen 
        showErrorMessage(x); 
       } 
      } 
     } 
    } 

    void showErrorMessage(Throwable x) { 
     x.printStackTrace(System.out); 
     String errorMsg = String.format(
      "%s:%n\"%s\"", x.getClass().getSimpleName(), x.getMessage()); 
     JOptionPane.showMessageDialog(theFrame, errorMsg); 
    } 
} 

对于Clip，你就必须像一个Swing计时器（或另一侧线程），并常常但查询它：

new javax.swing.Timer(100, new ActionListener() { 
    @Override 
    public void actionPerformed(ActionEvent ae) { 
     long usPosition = theClip.getMicrosecondPosition(); 
     // put it somewhere 
    } 
}).start(); 

---

相关：

• How to calculate the level/amplitude/db of audio signal in java?
• How to make waveform rendering more interesting?