Android-如何将音频原始数据转换为wav？

我已经在我的android应用程序中实现了录制音频的功能。我的应用程序在linux上运行良好。但当我在MacOSX上运行同一个应用程序并录制音频时，它会使我的应用程序崩溃

       private AudioRecordingThread recordingThread;

       recordingThread = new AudioRecordingThread(fileName,
            new AudioRecordingHandler() {
                @Override
                public void onFftDataCapture(final byte[] bytes) {
                    runOnUiThread(new Runnable() {
                        public void run() {
                            if (visualizerView != null) {
                                visualizerView.updateVisualizerFFT(bytes);
                            }
                        }
                    });
                }

                @Override
                public void onRecordSuccess() {
                }

                @Override
                public void onRecordingError() {
                    runOnUiThread(new Runnable() {
                        public void run() {
                            recordStop();
                            NotificationUtils.showInfoDialog(
                                    ActivityCropImage.this,
                                    "Error in saving");
                        }
                    });
                }

                @Override
                public void onRecordSaveError() {
                    runOnUiThread(new Runnable() {
                        public void run() {
                            recordStop();
                            NotificationUtils.showInfoDialog(
                                    ActivityCropImage.this,
                                    "Error in recording");
                        }
                    });
                }
            });
        PcmAudioHelper.convertRawToWav(WavAudioFormat.mono16Bit(SAMPLING_RATE), file_raw, file_wav);

这是我的应用程序崩溃的代码行。我在我的项目中使用了库。

package com.record.util；
package com.record.util;

import android.media.AudioFormat;
import android.media.AudioRecord;
import android.media.MediaRecorder;
import android.os.Environment;
import android.text.format.Time;
import android.util.Log;

import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

public class RecordWavMaster {
    private static final int samplingRates[] = {16000, 11025, 11000, 8000, 6000};
    public static int SAMPLE_RATE = 16000;
    private AudioRecord mRecorder;
    private File mRecording;
    private short[] mBuffer;
    private String audioFilePath;
    private boolean mIsRecording = false;
    private String RECORD_WAV_PATH = Environment.getExternalStorageDirectory() + File.separator + "AudioRecord";

    /* Initializing AudioRecording MIC */
    public RecordWavMaster() {
        initRecorder();
    }

    /* Get Supported Sample Rate */
    public static int getValidSampleRates() {
        for (int rate : samplingRates) {
            int bufferSize = AudioRecord.getMinBufferSize(rate, AudioFormat.CHANNEL_CONFIGURATION_DEFAULT, AudioFormat.ENCODING_PCM_16BIT);
            if (bufferSize > 0) {
                return rate;
            }
        }
        return SAMPLE_RATE;
    }

    /* Start AudioRecording */
    public void recordWavStart() {
        mIsRecording = true;
        mRecorder.startRecording();
        mRecording = getFile("raw");
        startBufferedWrite(mRecording);
    }

    /* Stop AudioRecording */
    public String recordWavStop() {
        try {
            mIsRecording = false;
            mRecorder.stop();
            File waveFile = getFile("wav");
            rawToWave(mRecording, waveFile);
            Log.e("path_audioFilePath",audioFilePath);
            return audioFilePath;
        } catch (Exception e) {
            Log.e("Error saving file : ", e.getMessage());
        }
        return  null;
    }

    /* Release device MIC */
    public void releaseRecord() {
        mRecorder.release();
    }

    /* Initializing AudioRecording MIC */
    private void initRecorder() {
        SAMPLE_RATE = getValidSampleRates();
        int bufferSize = AudioRecord.getMinBufferSize(SAMPLE_RATE, AudioFormat.CHANNEL_IN_MONO,
                AudioFormat.ENCODING_PCM_16BIT);
        mBuffer = new short[bufferSize];
        mRecorder = new AudioRecord(MediaRecorder.AudioSource.MIC, SAMPLE_RATE, AudioFormat.CHANNEL_IN_MONO,
                AudioFormat.ENCODING_PCM_16BIT, bufferSize);
        new File(RECORD_WAV_PATH).mkdir();
    }

    /* Writing RAW file */
    private void startBufferedWrite(final File file) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                DataOutputStream output = null;
                try {
                    output = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(file)));
                    while (mIsRecording) {
                        double sum = 0;
                        int readSize = mRecorder.read(mBuffer, 0, mBuffer.length);
                        for (int i = 0; i < readSize; i++) {
                            output.writeShort(mBuffer[i]);
                            sum += mBuffer[i] * mBuffer[i];
                        }
                        if (readSize > 0) {
                            final double amplitude = sum / readSize;
                        }
                    }
                } catch (IOException e) {
                    Log.e("Error writing file : ", e.getMessage());
                } finally {

                    if (output != null) {
                        try {
                            output.flush();
                        } catch (IOException e) {
                            Log.e("Error writing file : ", e.getMessage());
                        } finally {
                            try {
                                output.close();
                            } catch (IOException e) {
                                Log.e("Error writing file : ", e.getMessage());
                            }
                        }
                    }
                }
            }
        }).start();
    }

    /* Converting RAW format To WAV Format*/
    private void rawToWave(final File rawFile, final File waveFile) throws IOException {

        byte[] rawData = new byte[(int) rawFile.length()];
        DataInputStream input = null;
        try {
            input = new DataInputStream(new FileInputStream(rawFile));
            input.read(rawData);
        } finally {
            if (input != null) {
                input.close();
            }
        }
        DataOutputStream output = null;
        try {
            output = new DataOutputStream(new FileOutputStream(waveFile));
            // WAVE header
            writeString(output, "RIFF"); // chunk id
            writeInt(output, 36 + rawData.length); // chunk size
            writeString(output, "WAVE"); // format
            writeString(output, "fmt "); // subchunk 1 id
            writeInt(output, 16); // subchunk 1 size
            writeShort(output, (short) 1); // audio format (1 = PCM)
            writeShort(output, (short) 1); // number of channels
            writeInt(output, SAMPLE_RATE); // sample rate
            writeInt(output, SAMPLE_RATE * 2); // byte rate
            writeShort(output, (short) 2); // block align
            writeShort(output, (short) 16); // bits per sample
            writeString(output, "data"); // subchunk 2 id
            writeInt(output, rawData.length); // subchunk 2 size
            // Audio data (conversion big endian -> little endian)
            short[] shorts = new short[rawData.length / 2];
            ByteBuffer.wrap(rawData).order(ByteOrder.LITTLE_ENDIAN).asShortBuffer().get(shorts);
            ByteBuffer bytes = ByteBuffer.allocate(shorts.length * 2);
            for (short s : shorts) {
                bytes.putShort(s);
            }
            output.write(bytes.array());
        } finally {
            if (output != null) {
                output.close();
                rawFile.delete();
            }
        }


    }

    /* Get file name */
    private File getFile(final String suffix) {
        Time time = new Time();
        time.setToNow();
        audioFilePath = time.format("%Y%m%d%H%M%S");
        return new File(RECORD_WAV_PATH, time.format("%Y%m%d%H%M%S") + "." + suffix);
    }

    private void writeInt(final DataOutputStream output, final int value) throws IOException {
        output.write(value >> 0);
        output.write(value >> 8);
        output.write(value >> 16);
        output.write(value >> 24);
    }

    private void writeShort(final DataOutputStream output, final short value) throws IOException {
        output.write(value >> 0);
        output.write(value >> 8);
    }

    private void writeString(final DataOutputStream output, final String value) throws IOException {
        for (int i = 0; i < value.length(); i++) {
            output.write(value.charAt(i));
        }
    }

    public String getFileName (final String time_suffix) {
        return (RECORD_WAV_PATH+time_suffix+ "." + "wav");
    }

    public Boolean getRecordingState () {
      if(  mRecorder.getRecordingState() == AudioRecord.RECORDSTATE_STOPPED) {
       return false;
      }
        return true;
    }
}

导入android.media.AudioFormat；
导入android.media.AudioRecord；
导入android.media.MediaRecorder；
导入android.os.Environment；
导入android.text.format.Time；
导入android.util.Log；
导入java.io.BufferedOutputStream；
导入java.io.DataInputStream；
导入java.io.DataOutputStream；
导入java.io.File；
导入java.io.FileInputStream；
导入java.io.FileOutputStream；
导入java.io.IOException；
导入java.nio.ByteBuffer；
导入java.nio.ByteOrder；
公共类录音主机{
私有静态最终整数抽样[]={16000110251100080006000}；
公共静态整数抽样率=16000；
私人录音机；
私有文件记录；
私人卖空者；
私有字符串音频文件路径；
私有布尔错误记录=假；
私有字符串记录\u WAV\u PATH=Environment.getExternalStorageDirectory（）+File.separator+“AudioRecord”；
/*初始化录音麦克风*/
公共录音主机（）{
initRecorder（）；
}
/*获取支持的采样率*/
公共静态int getValidSampleRates（）{
用于（整数率：抽样）{
int bufferSize=AudioRecord.getMinBufferSize（速率，AudioFormat.CHANNEL\u配置\u默认值，AudioFormat.ENCODING\u PCM\u 16位）；
如果（缓冲区大小>0）{
回报率；
}
}
退货率；
}
/*开始录音*/
public void recordWavStart（）{
错误记录=正确；
mRecorder.startRecording（）；
mRecording=getFile（“原始”）；
开始缓冲写入（mRecording）；
}
/*停止录音*/
公共字符串recordWavStop（）{
试一试{
错误记录=错误；
mRecorder.stop（）；
File waveFile=getFile（“wav”）；
rawToWave（mRecording，waveFile）；
Log.e（“路径\音频文件路径”，音频文件路径）；
返回音频文件路径；
}捕获（例外e）{
Log.e（“保存文件时出错：”，e.getMessage（））；
}
返回null；
}
/*释放装置话筒*/
公开无效释放记录（）{
mRecorder.release（）；
}
/*初始化录音麦克风*/
私有void initRecorder（）{
样本率=getValidSampleRates（）；
int bufferSize=AudioRecord.getMinBufferSize（采样率，单声道中的AudioFormat.CHANNEL），
音频格式。编码（PCM（16位）；
mBuffer=新短[缓冲区大小]；
mRecorder=新的音频记录（单声道中的MediaRecorder.AudioSource.MIC、采样率、AudioFormat.CHANNEL），
AudioFormat.ENCODING_PCM_16位，缓冲区大小）；
新文件（RECORD_WAV_PATH）.mkdir（）；
}
/*写入原始文件*/
私有void startBufferedWrite（最终文件）{
新线程（newrunnable（））{
@凌驾
公开募捐{
DataOutputStream输出=null；
试一试{
输出=新的DataOutputStream（新的BufferedOutputStream（新的FileOutputStream（文件）））；
同时（误录）{
双和=0；
int readSize=mRecorder.read（mBuffer，0，mBuffer.length）；
对于（int i=0；i0）{
最终双振幅=总和/读数大小；
}
}
}捕获（IOE异常）{
Log.e（“写入文件时出错：，e.getMessage（））；
}最后{
if（输出！=null）{
试一试{
output.flush（）；
}捕获（IOE异常）{
Log.e（“写入文件时出错：，e.getMessage（））；
}最后{
试一试{
output.close（）；
}捕获（IOE异常）{
Log.e（“写入文件时出错：，e.getMessage（））；
}
}
}
}
}
}).start（）；
}
/*将原始格式转换为WAV格式*/
私有void rawToWave（最终文件rawFile，最终文件waveFile）引发IOException{
byte[]rawData=新字节[（int）rawFile.length（）]；
DataInputStream输入=null；
试一试{
输入=新数据输入流（新文件输入流（rawFile））；
输入。读取（原始数据）；
}最后{
如果（输入！=null）{
input.close（）；
}
}
DataOutputStream输出=null；
试一试{
输出=新数据输出流（新文件输出流（波形文件））；
//波头
writeString（输出，“RIFF”）；//块id
writeInt（输出，36+rawData.length）；//块大小
writeString（输出，“WAVE”）；//格式
writeString（输出，“fmt”）；//子块1 id
writeInt（输出，16）；//子块1大小
writeShort（输出，（短）1）；//音频格式（1=PCM）
writeShort（输出，（短）1）；//通道数
writeInt（输出，采样率）；//采样率
writeInt（输出，采样率*2）；//字节率
writeShort（输出，（短）2）；//块对齐
writeShort（输出，（短）16）；//每个采样位
writeString（输出，“数据”）；//子块
 <!--Permission record-->
    <uses-permission android:name="android.permission.RECORD_AUDIO" />
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />