• Android使用AudioTrack播放WAV音频文件

    目录

    1、wav文件格式

    2、wav文件解析

    3、wav文件播放

    QA：

    开始播放wav的时候使用了系统的播放器mediaplayer进行播放，但是无奈mediaplayer支持的实在不好。

    好些年前自己做过pcm播放使用的是audiotrack，参考：Android 利用AudioTrack播放 PCM 格式音频_mldxs的博客-CSDN博客

    其实WAV和PCM两者之间只差了一个wav文件头而已，所以实现了一套audiotrack播放wav的功能。同时支持本地文件播放和网络文件播放

    1、wav文件格式

    参考了：wav文件格式解析_全职编码的博客-CSDN博客_wav文件格式

    wav文件一般结构

     其中对我们比较重要的字段：

    1. NumChannels ： 声道（一般1-8）
    2. SampleRate：采样频率（常见的有8000,16000，44100，48000）
    3. BitsPerSample：采样精度（常见的有8、16、32，分别代表着一个采样占据1、2、4个字节）

    其余字段解释，详见wav文件格式解析_全职编码的博客-CSDN博客_wav文件格式

    wav文件头共44个字节，文件头后紧跟着的就是pcm数据，也就是真正的播放数据了。

    2、wav文件解析

    1. package com.macoli.wav_player
    2.  
    3. import java.io.DataInputStream
    4. import java.io.InputStream
    5. import java.nio.ByteBuffer
    6. import java.nio.ByteOrder
    7. class Wav(private val inputStream : InputStream) {
    8.     val wavHeader : WavHeader = WavHeader()
    9.     init {
    10.         parseHeader()
    11.     }
    12.     private fun parseHeader() {
    13.         val dataInputStream : DataInputStream = DataInputStream(inputStream)
    14.  
    15.         val intValue = ByteArray(4)
    16.         val shortValue = ByteArray(2)
    17.  
    18.         try {
    19.             wavHeader.mChunkID = "" + Char(dataInputStream.readByte().toUShort()) + Char(
    20.                 dataInputStream.readByte().toUShort()
    21.             ) + Char(dataInputStream.readByte().toUShort()) + Char(
    22.                 dataInputStream.readByte().toUShort()
    23.             )
    24.             dataInputStream.read(intValue)
    25.             wavHeader.mChunkSize = byteArrayToInt(intValue)
    26.             wavHeader.mFormat = "" + Char(dataInputStream.readByte().toUShort()) + Char(
    27.                 dataInputStream.readByte().toUShort()
    28.             ) + Char(dataInputStream.readByte().toUShort()) + Char(
    29.                 dataInputStream.readByte().toUShort()
    30.             )
    31.             wavHeader.mSubChunk1ID = "" + Char(dataInputStream.readByte().toUShort()) + Char(
    32.                 dataInputStream.readByte().toUShort()
    33.             ) + Char(dataInputStream.readByte().toUShort()) + Char(
    34.                 dataInputStream.readByte().toUShort()
    35.             )
    36.             dataInputStream.read(intValue)
    37.             wavHeader.mSubChunk1Size = byteArrayToInt(intValue)
    38.             dataInputStream.read(shortValue)
    39.             wavHeader.mAudioFormat = byteArrayToShort(shortValue)
    40.             dataInputStream.read(shortValue)
    41.             wavHeader.mNumChannel = byteArrayToShort(shortValue)
    42.             dataInputStream.read(intValue)
    43.             wavHeader.mSampleRate = byteArrayToInt(intValue)
    44.             dataInputStream.read(intValue)
    45.             wavHeader.mByteRate = byteArrayToInt(intValue)
    46.             dataInputStream.read(shortValue)
    47.             wavHeader.mBlockAlign = byteArrayToShort(shortValue)
    48.             dataInputStream.read(shortValue)
    49.             wavHeader.mBitsPerSample = byteArrayToShort(shortValue)
    50.             wavHeader.mSubChunk2ID = "" + Char(dataInputStream.readByte().toUShort()) + Char(
    51.                 dataInputStream.readByte().toUShort()
    52.             ) + Char(dataInputStream.readByte().toUShort()) + Char(
    53.                 dataInputStream.readByte().toUShort()
    54.             )
    55.             dataInputStream.read(intValue)
    56.             wavHeader.mSubChunk2Size = byteArrayToInt(intValue)
    57.         } catch (e: Exception) {
    58.             e.printStackTrace()
    59.         }
    60.     }
    61.  
    62.     private fun byteArrayToShort(b: ByteArray): Short {
    63.         return ByteBuffer.wrap(b).order(ByteOrder.LITTLE_ENDIAN).short
    64.     }
    65.  
    66.     private fun byteArrayToInt(b: ByteArray): Int {
    67.         return ByteBuffer.wrap(b).order(ByteOrder.LITTLE_ENDIAN).int
    68.     }
    69.  
    70.     /**
    71.      * WAV文件头
    72.      * */
    73.     class WavHeader {
    74.         var mChunkID = "RIFF"
    75.         var mChunkSize = 0
    76.         var mFormat = "WAVE"
    77.         var mSubChunk1ID = "fmt "
    78.         var mSubChunk1Size = 16
    79.         var mAudioFormat: Short = 1
    80.         var mNumChannel: Short = 1
    81.         var mSampleRate = 8000
    82.         var mByteRate = 0
    83.         var mBlockAlign: Short = 0
    84.         var mBitsPerSample: Short = 8
    85.         var mSubChunk2ID = "data"
    86.         var mSubChunk2Size = 0
    87.  
    88.         constructor() {}
    89.         constructor(chunkSize: Int, sampleRateInHz: Int, channels: Int, bitsPerSample: Int) {
    90.             mChunkSize = chunkSize
    91.             mSampleRate = sampleRateInHz
    92.             mBitsPerSample = bitsPerSample.toShort()
    93.             mNumChannel = channels.toShort()
    94.             mByteRate = mSampleRate * mNumChannel * mBitsPerSample / 8
    95.             mBlockAlign = (mNumChannel * mBitsPerSample / 8).toShort()
    96.         }
    97.  
    98.         override fun toString(): String {
    99.             return "WavFileHeader{" +
    100.                     "mChunkID='" + mChunkID + '\'' +
    101.                     ", mChunkSize=" + mChunkSize +
    102.                     ", mFormat='" + mFormat + '\'' +
    103.                     ", mSubChunk1ID='" + mSubChunk1ID + '\'' +
    104.                     ", mSubChunk1Size=" + mSubChunk1Size +
    105.                     ", mAudioFormat=" + mAudioFormat +
    106.                     ", mNumChannel=" + mNumChannel +
    107.                     ", mSampleRate=" + mSampleRate +
    108.                     ", mByteRate=" + mByteRate +
    109.                     ", mBlockAlign=" + mBlockAlign +
    110.                     ", mBitsPerSample=" + mBitsPerSample +
    111.                     ", mSubChunk2ID='" + mSubChunk2ID + '\'' +
    112.                     ", mSubChunk2Size=" + mSubChunk2Size +
    113.                     '}'
    114.         }
    115.     }
    116. }

    3、wav文件播放

    使用audiotrack播放wav一般有3个步骤：

    1. 下载wav文件
    2. 初始化audiotrack（初始化audiotrack依赖刚刚解析wav文件头的信息）
    1. private void initAudioTracker(){
    2.             AudioAttributes audioAttributes = new AudioAttributes.Builder()
    3.                     .setUsage(AudioAttributes.USAGE_MEDIA)
    4.                     .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
    5.                     .build();
    6.             AudioFormat audioFormat = new AudioFormat.Builder()
    7.                     .setEncoding(getEncoding())
    8.                     .setSampleRate(mWav.getWavHeader().getMSampleRate())
    9.                     .build();
    10.             mAudioTrack = new AudioTrack(audioAttributes, audioFormat, getMiniBufferSize()
    11.                     , AudioTrack.MODE_STREAM, AudioManager.AUDIO_SESSION_ID_GENERATE);
    12.  
    13.         }
    1. audiotrack.write播放音频

    下面是真正播放wav的代码了，代码很简单，不做过多介绍了：

    使用单独的Downloader线程对wav文件进行下载，加快缓冲速度，避免播放出现卡顿杂音现象。

    使用RealPlayer线程对wav文件进行播放。

    其中Downloader线程对应生产者，RealPlayer对应消费者。mSoundData则是生产者消费者之间的缓冲区。

    1. package com.macoli.wav_player;
    2.  
    3. import android.media.AudioAttributes;
    4. import android.media.AudioFormat;
    5. import android.media.AudioManager;
    6. import android.media.AudioTrack;
    7.  
    8. import java.io.BufferedInputStream;
    9. import java.io.FileInputStream;
    10. import java.io.IOException;
    11. import java.io.InputStream;
    12. import java.net.URL;
    13. import java.net.URLConnection;
    14. import java.nio.ByteBuffer;
    15. import java.nio.ByteOrder;
    16. import java.nio.FloatBuffer;
    17. import java.nio.ShortBuffer;
    18. import java.util.Arrays;
    19. import java.util.concurrent.LinkedBlockingQueue;
    20.  
    21. public class WavPlayer {
    22.     public volatile boolean isPlaying = false ;
    23.     private final LinkedBlockingQueue<byte[]> mSoundData = new LinkedBlockingQueue<>() ;
    24.     private volatile Wav mWav ;
    25.     private volatile int mDownloadComplete = -1 ;
    26.     private final byte[] mWavReady = new byte[1] ;
    27.     public WavPlayer() {
    28.  
    29.     }
    30.     public void play(String urlStr , boolean local) {
    31.         isPlaying = true ;
    32.         mSoundData.clear();
    33.         mDownloadComplete = -1 ;
    34.         mWav = null ;
    35.         new Thread(new Downloader(urlStr , local)).start();
    36.         new Thread(new RealPlayer()).start();
    37.     }
    38.  
    39.     private int getChannel() {
    40.         return mWav.getWavHeader().getMNumChannel() == 1 ? AudioFormat.CHANNEL_OUT_MONO : AudioFormat.CHANNEL_OUT_STEREO;
    41.     }
    42.  
    43.     private int getEncoding() {
    44.         int ENCODING = AudioFormat.ENCODING_DEFAULT;
    45.         if (mWav.getWavHeader().getMBitsPerSample() == 8) {
    46.             ENCODING = AudioFormat.ENCODING_PCM_8BIT;
    47.         } else if (mWav.getWavHeader().getMBitsPerSample() == 16) {
    48.             ENCODING = AudioFormat.ENCODING_PCM_16BIT;
    49.         } else if (mWav.getWavHeader().getMBitsPerSample() == 32) {
    50.             ENCODING = AudioFormat.ENCODING_PCM_FLOAT;
    51.         }
    52.         return ENCODING ;
    53.     }
    54.  
    55.     private int getMiniBufferSize() {
    56.         return AudioTrack.getMinBufferSize(
    57.                 mWav.getWavHeader().getMSampleRate(), getChannel(), getEncoding());
    58.     }
    59.  
    60.     private WavOnCompletionListener onCompletionListener ;
    61.     public void setOnCompletionListener(WavOnCompletionListener onCompletionListener) {
    62.         this.onCompletionListener = onCompletionListener ;
    63.     }
    64.  
    65.     public interface WavOnCompletionListener{
    66.         void onCompletion(int status) ;
    67.     }
    68.  
    69.     private class Downloader implements Runnable {
    70.  
    71.         private final String mUrlStr ;
    72.         private final boolean isLocal ;
    73.         private Downloader(String urlStr , boolean local) {
    74.             mUrlStr = urlStr ;
    75.             isLocal = local ;
    76.         }
    77.         @Override
    78.         public void run() {
    79.             mDownloadComplete = -1 ;
    80.             InputStream in = null ;
    81.             try {
    82.                 if (!isLocal) {
    83.                     URL url = new URL(mUrlStr);
    84.                     URLConnection urlConnection = url.openConnection() ;
    85.                     in = new BufferedInputStream(urlConnection.getInputStream()) ;
    86.                 } else {
    87.                     in = new BufferedInputStream(new FileInputStream(mUrlStr)) ;
    88.                 }
    89.  
    90.                 if (in == null) {
    91.                     mDownloadComplete = -2 ;
    92.                     isPlaying = false ;
    93.                     onCompletionListener.onCompletion(-2);
    94.                     synchronized (mWavReady) {
    95.                         mWavReady.notifyAll();
    96.                     }
    97.  
    98.                     return ;
    99.                 }
    100.                 synchronized (mWavReady) {
    101.                     mWav = new Wav(in) ;
    102.                     mWavReady.notifyAll();
    103.                 }
    104.             } catch (Exception e) {
    105.  
    106.                 mDownloadComplete = -2 ;
    107.                 isPlaying = false ;
    108.                 onCompletionListener.onCompletion(-2);
    109.                 synchronized (mWavReady) {
    110.                     mWavReady.notifyAll();
    111.                 }
    112.                 return ;
    113.  
    114.             }
    115.             int iniBufferSize = getMiniBufferSize() ;
    116.             byte[] buffer = new byte[iniBufferSize] ;
    117.             int read = 0 ;
    118.             long startTime = System.currentTimeMillis() ;
    119.  
    120.             try {
    121.                 int bufferFilledCount = 0 ;
    122.                 while ((read = in.read(buffer , bufferFilledCount , iniBufferSize - bufferFilledCount)) != -1) {
    123.                     bufferFilledCount += read ;
    124.                     if (bufferFilledCount >= iniBufferSize) {
    125.                         byte[] newBuffer = Arrays.copyOf(buffer , iniBufferSize) ;
    126.                         mSoundData.put(newBuffer) ;
    127.                         read = 0 ;
    128.                         bufferFilledCount = 0 ;
    129.                     }
    130.                 }
    131.  
    132.                 mDownloadComplete = 1 ;
    133.             } catch (IOException | InterruptedException e) {
    134.                 mDownloadComplete = -2 ;
    135.                 isPlaying = false ;
    136.                 onCompletionListener.onCompletion(-2);
    137.             } finally {
    138.                 if (in != null) {
    139.                     try {
    140.                         in.close();
    141.                     } catch (IOException e) {
    142.                         e.printStackTrace();
    143.                     }
    144.                 }
    145.             }
    146.         }
    147.     }
    148.  
    149.     private class RealPlayer implements Runnable{
    150.         private AudioTrack mAudioTrack;
    151.         private void initAudioTracker(){
    152.             AudioAttributes audioAttributes = new AudioAttributes.Builder()
    153.                     .setUsage(AudioAttributes.USAGE_MEDIA)
    154.                     .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
    155.                     .build();
    156.             AudioFormat audioFormat = new AudioFormat.Builder()
    157.                     .setEncoding(getEncoding())
    158.                     .setSampleRate(mWav.getWavHeader().getMSampleRate())
    159.                     .build();
    160.             mAudioTrack = new AudioTrack(audioAttributes, audioFormat, getMiniBufferSize()
    161.                     , AudioTrack.MODE_STREAM, AudioManager.AUDIO_SESSION_ID_GENERATE);
    162.  
    163.         }
    164.         public void play() {
    165.             mAudioTrack.play() ;
    166.             byte[] buffer ;
    167.             try {
    168.                 while(true) {
    169.                     buffer = mSoundData.take();
    170.                     if (mWav.getWavHeader().getMBitsPerSample() == 8) {
    171.                         try {
    172.                             mAudioTrack.write(buffer, 0, buffer.length, AudioTrack.WRITE_BLOCKING);
    173.                         } catch (Exception e) {
    174.                         }
    175.                     } else if (mWav.getWavHeader().getMBitsPerSample() == 16) {
    176.                         try {
    177.                             ShortBuffer sb = ByteBuffer.wrap(buffer, 0, buffer.length).order(ByteOrder.LITTLE_ENDIAN).asShortBuffer();
    178.                             short[] out = new short[sb.capacity()];
    179.                             sb.get(out);
    180.                             mAudioTrack.write(out, 0, out.length, AudioTrack.WRITE_BLOCKING);
    181.                         } catch (Exception e) {
    182.  
    183.                         }
    184.                     } else if (mWav.getWavHeader().getMBitsPerSample() == 32) {
    185.                         try {
    186.                             FloatBuffer fb = ByteBuffer.wrap(buffer, 0, buffer.length).order(ByteOrder.LITTLE_ENDIAN).asFloatBuffer();
    187.                             float[] out = new float[fb.capacity()];
    188.                             fb.get(out);
    189.                             mAudioTrack.write(out, 0, out.length, AudioTrack.WRITE_BLOCKING);
    190. //                        mAudioTrack.write(mBuffer, 0, read ,  AudioTrack.WRITE_BLOCKING);
    191.                         } catch (Exception e) {
    192.  
    193.                         }
    194.                     }
    195.                     if ((1 == mDownloadComplete && mSoundData.isEmpty()) || -2 == mDownloadComplete) {
    196.                         break ;
    197.                     }
    198.                 }
    199.             } catch (Exception e) {
    200.                 isPlaying = false ;
    201.                 onCompletionListener.onCompletion(-2);
    202.                 return ;
    203.             } finally {
    204.                 mAudioTrack.stop();
    205.                 mAudioTrack.release();
    206.                 mAudioTrack = null;
    207.                 isPlaying = false ;
    208.             }
    209.             onCompletionListener.onCompletion(1);
    210.         }
    211.  
    212.         @Override
    213.         public void run() {
    214.             synchronized (mWavReady) {
    215.                 if (mWav == null) {
    216.                     try {
    217.                         mWavReady.wait();
    218.                         if (mWav == null) {
    219.                             return ;
    220.                         }
    221.                     } catch (InterruptedException e) {
    222.                         e.printStackTrace();
    223.                     }
    224.                 }
    225.             }
    226.             initAudioTracker() ;
    227.             play();
    228.         }
    229.     }
    230. }

    调用wavplayer播放wav：

    wavplayer.play(url , 是否是本地wav文件)

    1.  val wavPlayer = WavPlayer()
    2.  wavPlayer.play("/sdcard/Music/3.wav" , true)

    QA：

    Q：1、播放wav第一帧有爆音。

    A： 由于wav文件有44字节的文件头，在读取文件的时候需要跳过wav文件头再向AudioTrack.write中进行写入。

    Q：2、播放网络wav有杂音。

    A：由于网络读取wav文件每次读取的字节数会远远小于我们设置的minbuffer，所以每次读取网络流的时候我们都要等待minbuffer填充满的时候再使用AudioTrack.write进行写入。

    1. int bufferFilledCount = 0 ;
    2.                 while ((read = in.read(buffer , bufferFilledCount , iniBufferSize - bufferFilledCount)) != -1) {
    3.                     bufferFilledCount += read ;
    4.                     if (bufferFilledCount >= iniBufferSize) {
    5.                         byte[] newBuffer = Arrays.copyOf(buffer , iniBufferSize) ;
    6.                         mSoundData.put(newBuffer) ;
    7.                         read = 0 ;
    8.                         bufferFilledCount = 0 ;
    9.                     }
    10.                 }

    Q：3、播放wav失败，全部都是杂音。

    A：查看wav文件头，看看wav的采样精度，如果采样精度是32的话，必须使用write(float[])，否则肯定播放失败。

    1. public int write(@NonNull float[] audioData, int offsetInFloats, int sizeInFloats,
    2.             @WriteMode int writeMode)

    完整源码已上传：https://gitee.com/gggl/wav-player

  • 相关阅读:
    spring框架
    全国各省市建设工程类专业职称评审要求总结（欢迎补充完善、沟通交流）
    04-二维数组的查找
    智慧风电：数字孪生 3D 风机智能设备运维
    「未来已来」三大办公领域巨头(Google、Microsoft、金山)，开启AI办公新纪元
    2022年全国最新消防设施操作员（初级消防设施操作员）模拟题及答案
    MySQL：快照读和当前读
    DVWA 靶场之 Command Injection（命令执行）middle&high
    前端周刊第二十三期
    2024年6月 青少年python一级等级考试真题试卷
  • 原文地址：https://blog.csdn.net/mldxs/article/details/128062029