Android（Java）和Matlab读取Wav文件中的数据。它有何不同？

我正在尝试录制一个wav文件，并在android中读取和保存一个wav文件的数据。除了在Matlab中读取的值与在android中保存的数据之间的差异外，一切正常 这是我的密码

private static final int    RECORDER_BPP                = 16;
private static final String AUDIO_RECORDER_FILE_EXT_WAV = ".wav";
private static final String AUDIO_RECORDER_FOLDER       = "AudioRecorder";
private static final String AUDIO_RECORDER_TEMP_FILE    = "record_temp.raw";
private static final int    RECORDER_SAMPLERATE         = 44100;
private static final int    RECORDER_CHANNELS           = AudioFormat.CHANNEL_IN_MONO;
private static final int    RECORDER_AUDIO_ENCODING     = AudioFormat.ENCODING_PCM_16BIT;

private AudioRecord         recorder                    = null;
private int                 bufferSize                  = 0;
private Thread              recordingThread             = null;
private boolean             isRecording                 = false;



@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);

    setButtonHandlers();
    enableButtons(false);

    bufferSize = AudioRecord.getMinBufferSize(RECORDER_SAMPLERATE, RECORDER_CHANNELS, RECORDER_AUDIO_ENCODING);
}



private void setButtonHandlers() {
    ((Button) findViewById(R.id.btnStart)).setOnClickListener(btnClick);
    ((Button) findViewById(R.id.btnStop)).setOnClickListener(btnClick);
}



private void enableButton(int id, boolean isEnable) {
    ((Button) findViewById(id)).setEnabled(isEnable);
}



private void enableButtons(boolean isRecording) {
    enableButton(R.id.btnStart, !isRecording);
    enableButton(R.id.btnStop, isRecording);
}



private String getFilename() {
    String filepath = Environment.getExternalStorageDirectory().getPath();
    File file = new File(filepath, AUDIO_RECORDER_FOLDER);

    if ( !file.exists()) {
        file.mkdirs();
    }

    return (file.getAbsolutePath() + "/" + 11 + AUDIO_RECORDER_FILE_EXT_WAV);
}







private String getTempFilename() {
    String filepath = Environment.getExternalStorageDirectory().getPath();
    File file = new File(filepath, AUDIO_RECORDER_FOLDER);

    if ( !file.exists()) {
        file.mkdirs();
    }

    File tempFile = new File(filepath, AUDIO_RECORDER_TEMP_FILE);

    if (tempFile.exists())
        tempFile.delete();

    return (file.getAbsolutePath() + "/" + AUDIO_RECORDER_TEMP_FILE);
}



private String getfftFilename() {
    String filepath = Environment.getExternalStorageDirectory().getPath();
    File file = new File(filepath, AUDIO_RECORDER_FOLDER);

    if ( !file.exists()) {
        file.mkdirs();
    }

    return (file.getAbsolutePath() + "/" + "fft" + ".txt");
}



private void startRecording() {
    recorder = new AudioRecord(MediaRecorder.AudioSource.MIC,
            RECORDER_SAMPLERATE, RECORDER_CHANNELS, RECORDER_AUDIO_ENCODING, bufferSize);

    recorder.startRecording();

    isRecording = true;

    recordingThread = new Thread(new Runnable() {

        @Override
        public void run() {
            writeAudioDataToFile();
        }
    }, "AudioRecorder Thread");

    recordingThread.start();
}



private void writeAudioDataToFile() {
    byte data[] = new byte[bufferSize];
    String filename = getTempFilename();
    FileOutputStream os = null;

    try {
        os = new FileOutputStream(filename);
    }
    catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    int read = 0;

    if (null != os) {
        while (isRecording) {
            read = recorder.read(data, 0, bufferSize);
            if (AudioRecord.ERROR_INVALID_OPERATION != read) {
                try {
                    os.write(data);
                }
                catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }
    }

    try {
        os.close();
    }
    catch (IOException e) {
        e.printStackTrace();
    }
}



private void stopRecording() {
    if (null != recorder) {
        isRecording = false;

        recorder.stop();
        recorder.release();

        recorder = null;
        recordingThread = null;
    }

    copyWaveFile(getTempFilename(), getFilename());
    ////coding(getTempFilename(), getrainroom(), getstegan());
    ////decoding(getstegan(), getdecodeFilename(), getrainroom());
    fftbegir(getTempFilename(), getfftFilename());
    deleteTempFile();
}



private void deleteTempFile() {
    File file = new File(getTempFilename());

    file.delete();
}



private void copyWaveFile(String inFilename, String outFilename) {
    FileInputStream in = null;
    FileOutputStream out = null;
    long totalAudioLen = 0;
    long totalDataLen = totalAudioLen + 36;
    long longSampleRate = RECORDER_SAMPLERATE;
    int channels = 1;
    long byteRate = RECORDER_BPP * RECORDER_SAMPLERATE * channels / 8;

    byte[] data = new byte[bufferSize];

    try {
        in = new FileInputStream(inFilename);
        out = new FileOutputStream(outFilename);
        totalAudioLen = in.getChannel().size();
        totalDataLen = totalAudioLen + 36;

        AppLog.logString("File size: " + totalDataLen);

        WriteWaveFileHeader(out, totalAudioLen, totalDataLen,
                longSampleRate, channels, byteRate);

        while (in.read(data) != -1) {
            out.write(data);
        }

        in.close();
        out.close();
    }
    catch (FileNotFoundException e) {
        e.printStackTrace();
    }
    catch (IOException e) {
        e.printStackTrace();
    }
}



private void fftbegir(String input, String output) {
    FileInputStream in5 = null;
    FileOutputStream out5 = null;
    FileOutputStream stream = null;
    byte[] data7 = new byte[10000];
    double[] data8;
    long totalAudioLen = 0;
    long totalDataLen = totalAudioLen + 36;
    long longSampleRate = RECORDER_SAMPLERATE;
    int channels = 1;
    int i = 0;
    int r, k, l;
    double b;
    int m = 2;
    long byteRate = RECORDER_BPP * RECORDER_SAMPLERATE * channels / 8;
    String filepath = Environment.getExternalStorageDirectory().getPath();
    File tempFile = new File(filepath, AUDIO_RECORDER_TEMP_FILE);

    try {
        in5 = new FileInputStream(input);
        out5 = new FileOutputStream(output);
        String strI = "nxkxaprojext;)";
        out5.write(strI.getBytes());

        AppLog.logString("File size: " + totalDataLen);
        totalAudioLen = in5.getChannel().size();
        strI = Long.toString(totalAudioLen);
        out5.write(strI.getBytes());
        out5.write(" ".getBytes());

        data8 = SoundDataUtils.load16BitPCMRawDataFileAsDoubleArray();
        l = data8.length;

        strI = Integer.toString(l);
        out5.write(strI.getBytes());
        out5.write(" ".getBytes());

        while (l > m) {
            m = m * 2;
        }
        strI = Integer.toString(m);
        out5.write(strI.getBytes());
        out5.write(" ".getBytes());
        strI = Double.toString(data8[50]);
        out5.write(strI.getBytes());
        Complex[] x = new Complex[m];
        while (i < l) {
            strI = Double.toString(data8[i]);
            out5.write(strI.getBytes());
            out5.write(" ".getBytes());
            //x[i] = new Complex(data8[i], 0);
            i++;
        }
        in5.close();
        ///i--;

        ///for (i = l; i < m; i++) {
        ///  x[i] = new Complex(0, 0);
        /// }
        ///  FFT f = new FFT();
        //// Complex[] y = f.fft(x);

        /*try {
            for (i = 0; i < m; i++) {
                b = y[i].re();
                strI = Double.toString(b);
                out5.write(strI.getBytes());
                out5.write("  ".getBytes());
                b = y[i].im();
                strI = Double.toString(b);
                out5.write(strI.getBytes());
                out5.write("j".getBytes());
                out5.write("  ".getBytes());

            }
        }*/// finally {
           ///  out5.close();
           ////}

    }
    catch (FileNotFoundException e) {
        e.printStackTrace();
    }
    catch (IOException e) {
        e.printStackTrace();
    }

}



private void WriteWaveFileHeader(
                                 FileOutputStream out, long totalAudioLen,
                                 long totalDataLen, long longSampleRate, int channels,
                                 long byteRate) throws IOException {

    byte[] header = new byte[44];

    header[0] = 'R'; // RIFF/WAVE header
    header[1] = 'I';
    header[2] = 'F';
    header[3] = 'F';
    header[4] = (byte) (totalDataLen & 0xff);
    header[5] = (byte) ((totalDataLen >> 8) & 0xff);
    header[6] = (byte) ((totalDataLen >> 16) & 0xff);
    header[7] = (byte) ((totalDataLen >> 24) & 0xff);
    header[8] = 'W';
    header[9] = 'A';
    header[10] = 'V';
    header[11] = 'E';
    header[12] = 'f'; // 'fmt ' chunk
    header[13] = 'm';
    header[14] = 't';
    header[15] = ' ';
    header[16] = 16; // 4 bytes: size of 'fmt ' chunk
    header[17] = 0;
    header[18] = 0;
    header[19] = 0;
    header[20] = 1; // format = 1
    header[21] = 0;
    header[22] = (byte) channels;
    header[23] = 0;
    header[24] = (byte) (longSampleRate & 0xff);
    header[25] = (byte) ((longSampleRate >> 8) & 0xff);
    header[26] = (byte) ((longSampleRate >> 16) & 0xff);
    header[27] = (byte) ((longSampleRate >> 24) & 0xff);
    header[28] = (byte) (byteRate & 0xff);
    header[29] = (byte) ((byteRate >> 8) & 0xff);
    header[30] = (byte) ((byteRate >> 16) & 0xff);
    header[31] = (byte) ((byteRate >> 24) & 0xff);
    header[32] = (byte) (1 * 16 / 8); // block align
    header[33] = 0;
    header[34] = RECORDER_BPP; // bits per sample
    header[35] = 0;
    header[36] = 'd';
    header[37] = 'a';
    header[38] = 't';
    header[39] = 'a';
    header[40] = (byte) (totalAudioLen & 0xff);
    header[41] = (byte) ((totalAudioLen >> 8) & 0xff);
    header[42] = (byte) ((totalAudioLen >> 16) & 0xff);
    header[43] = (byte) ((totalAudioLen >> 24) & 0xff);

    out.write(header, 0, 44);
}

private View.OnClickListener btnClick = new View.OnClickListener() {

                                          @Override
                                          public void onClick(View v) {
                                              switch (v.getId()) {
                                                  case R.id.btnStart: {
                                                      AppLog.logString("Start Recording");

                                                      enableButtons(true);
                                                      startRecording();

                                                      break;
                                                  }
                                                  case R.id.btnStop: {
                                                      AppLog.logString("Start Recording");

                                                      enableButtons(false);
                                                      stopRecording();

                                                      break;
                                                  }
                                              }
                                          }
                                      };

private static final int RECORDER_BPP=16；
专用静态最终字符串音频\u记录器\u文件\u EXT\u WAV=“.WAV”；
专用静态最终字符串音频\u记录器\u文件夹=“音频记录器”；
专用静态最终字符串音频\u记录器\u TEMP\u FILE=“录制\u TEMP.raw”；
专用静态最终积分记录仪\u采样器=44100；
专用静态最终整数记录器\u通道=单声道中的AudioFormat.CHANNEL\u；
专用静态最终整数记录器\u音频\u编码=AudioFormat.ENCODING\u PCM\u 16位；
专用录音机=空；
私有int bufferSize=0；
私有线程recordingThread=null；
私有布尔值isRecording=false；
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.main）；
setButtonHandlers（）；
启用按钮（错误）；
bufferSize=AudioRecord.getMinBufferSize（记录器采样器、记录器通道、记录器音频编码）；
}
私有void setButtonHandlers（）{
（（按钮）findviewbyd（R.id.btnStart））.setOnClickListener（btnClick）；
（（按钮）findviewbyd（R.id.btnStop））.setOnClickListener（btnClick）；
}
私有void enableButton（int-id，boolean-isEnable）{
（（按钮）findViewById（id））.setEnabled（isEnable）；
}
专用void启用按钮（布尔值isRecording）{
启用按钮（R.id.btnStart，！isRecording）；
启用按钮（R.id.btnStop，isRecording）；
}
私有字符串getFilename（）{
字符串filepath=Environment.getExternalStorageDirectory（）.getPath（）；
文件=新文件（文件路径、音频\u录制器\u文件夹）；
如果（！file.exists（））{
mkdirs（）文件；
}
返回（file.getAbsolutePath（）+“/”+11+音频\u记录器\u文件\u外部\u WAV）；
}
私有字符串getTempFilename（）{
字符串filepath=Environment.getExternalStorageDirectory（）.getPath（）；
文件=新文件（文件路径、音频\u录制器\u文件夹）；
如果（！file.exists（））{
mkdirs（）文件；
}
File tempFile=新文件（文件路径、音频记录器临时文件）；
if（tempFile.exists（））
tempFile.delete（）；
返回（file.getAbsolutePath（）+“/”+音频记录器临时文件）；
}
私有字符串getfftFilename（）{
字符串filepath=Environment.getExternalStorageDirectory（）.getPath（）；
文件=新文件（文件路径、音频\u录制器\u文件夹）；
如果（！file.exists（））{
mkdirs（）文件；
}
返回（file.getAbsolutePath（）+“/”+“fft”+“.txt”）；
}
私有无效开始记录（）{
录音机=新的录音机（MediaRecorder.AudioSource.MIC，
录像机采样器、录像机通道、录像机音频编码、缓冲区大小）；
记录器。开始记录（）；
isRecording=true；
recordingThread=新线程（new Runnable（））{
@凌驾
公开募捐{
WriteeAudioDataToFile（）；
}
}“录音机线程”）；
recordingThread.start（）；
}
私有void writeeAudioDataToFile（）{
字节数据[]=新字节[bufferSize]；
字符串文件名=getTempFilename（）；
FileOutputStream os=null；
试一试{
os=新文件输出流（文件名）；
}
catch（filenotfounde异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
int read=0；
如果（null！=os）{
while（isRecording）{
读取=记录器。读取（数据，0，缓冲区大小）；
if（AudioRecord.ERROR\u无效\u操作！=读取）{
试一试{
写（数据）；
}
捕获（IOE异常）{
e、 printStackTrace（）；
}
}
}
}
试一试{
os.close（）；
}
捕获（IOE异常）{
e、 printStackTrace（）；
}
}
私有void stopRecording（）{
如果（空！=记录器）{
isRecording=false；
录音机。停止（）；
记录器。释放（）；
记录器=空；
recordingThread=null；
}
copyWaveFile（getTempFilename（），getFilename（））；
////编码（getTempFilename（），getrainroom（），getstegan（））；
////解码（getstegan（），getdecodeFilename（），getrainroom（））；
fftbegir（getTempFilename（），getfftFilename（））；
deleteTempFile（）；
}
私有void deleteTempFile（）{
File File=新文件（getTempFilename（））；
delete（）；
}
私有void copyWaveFile（字符串填充名、字符串输出名）{
FileInputStream in=null；
FileOutputStream out=null；
长总听力=0；
long totalDataLen=totalAudioLen+36；
long longSampleRate=记录仪和采样器；
int通道=1；
long byteRate=记录器\ BPP*记录器\采样器*通道/8；
字节[]数据=新字节[bufferSize]；
试一试{
in=新文件输入流（inFilename）；
out=新文件输出流（outFilename）；
totalAudioLen=in.getChannel（）.size（）；
totalDataLen=totalAudioLen+36；
logString（“文件大小：“+totalDataLen”）；
WriteWaveFileHeader（输出、totalAudioLen、totalDataLen、，
长安培拉、通道、byteRate）；
while（in.read（数据）！=-1）{
输出。写入（数据）；
}
in.close（）；
out.close（）；
}
catch（filenotfounde异常）{
e、 printStackTrace（）；
}
捕获（IOE异常）{
e、 printStackTrace（）；
}
}
私有void fftbegir（字符串输入、字符串输出）{
FileInputStream in5=null；
FileOutputStream out5=null；
FileOutputStream=null；
字节[]数据7=新字节[10000]；
双[]数据8；
长总听力=0；
long totalDataLen=totalAudioLen+36；
long longSampleRate=记录仪和采样器；
int通道=1；
public static double[] load16BitPCMRawDataFileAsDoubleArray() throws IOException {
    String filepath = Environment.getExternalStorageDirectory().getPath();
    File file = new File(filepath, "AudioRecorder");
    if ( !file.exists()) {
        file.mkdirs();
    }
    File tempFile = new File(filepath + "/AudioRecorder", "record_temp.raw");

    InputStream in = null;
    long size = tempFile.length();
    try {
        in = new FileInputStream(tempFile);

        return readStreamAsDoubleArray(in, size);
    }
    catch (Exception e) {}

    return null;
}



public static double[] readStreamAsDoubleArray(InputStream in, long size)
                                                                         throws IOException {
    int bufferSize = (int) (size / 2);
    double[] result = new double[bufferSize];
    DataInputStream is = new DataInputStream(in);
    for (int i = 0; i < bufferSize; i++) {
        result[i] = is.readShort() / 32768.0;
    }
    return result;
}