在android中使用AudioRecord录制音频

Question

从下面的代码我可以创建 test.pcm 文件，但我无法在手机或电脑上播放它。

我也厌倦了 test.mp3、test.wav 和 test.raw。我得知播放器不支持这种类型的文件。

有谁知道我如何播放我使用 AudioRecord 录制的文件？

使用下面的代码我从麦克风获取短路数组并将其写入 SdCard。

这是代码：

package com.anroid.AudioProcess;

import java.io.File;

import android.app.Activity;
import android.os.Bundle;
import android.os.Environment;

import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import android.media.AudioFormat;
import android.media.AudioRecord;
import android.media.MediaRecorder;


public class AudioProcess extends Activity {
    /** Called when the activity is first created. */
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        // Record 20 seconds of audio.
        Recorder recorderInstance = new Recorder();
        Thread th = new Thread(recorderInstance);
        recorderInstance.setFileName(new File(Environment.getExternalStorageDirectory().getAbsolutePath() + "/test.pcm"));
        th.start();
        recorderInstance.setRecording(true);
        synchronized (this) {
        try {
            this.wait(20000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        }
        recorderInstance.setRecording(false);
        try {
            th.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


    }
}





 class Recorder implements Runnable {
    private int frequency;
    private int channelConfiguration;
    private volatile boolean isPaused;
    private File fileName;
    private volatile boolean isRecording;
    private final Object mutex = new Object();

    // Changing the sample resolution changes sample type. byte vs. short.
    private static final int audioEncoding = AudioFormat.ENCODING_PCM_16BIT;

    /**
     * 
     */
    public Recorder() {
        super();
        this.setFrequency(11025);
        this.setChannelConfiguration(AudioFormat.CHANNEL_CONFIGURATION_MONO);
        this.setPaused(false);
    }

    public void run() {
        // Wait until we're recording...
        synchronized (mutex) {
            while (!this.isRecording) {
                try {
                    mutex.wait();
                } catch (InterruptedException e) {
                    throw new IllegalStateException("Wait() interrupted!", e);
                }
            }
        }

        // Open output stream...
        if (this.fileName == null) {
            throw new IllegalStateException("fileName is null");
        }
        BufferedOutputStream bufferedStreamInstance = null;
        if (fileName.exists()) {
            fileName.delete();
        }
        try {
            fileName.createNewFile();
        } catch (IOException e) {
            throw new IllegalStateException("Cannot create file: " + fileName.toString());
        }
        try {
            bufferedStreamInstance = new BufferedOutputStream(
                    new FileOutputStream(this.fileName));
        } catch (FileNotFoundException e) {
            throw new IllegalStateException("Cannot Open File", e);
        }
        DataOutputStream dataOutputStreamInstance = 
            new DataOutputStream(bufferedStreamInstance);

        // We're important...
        android.os.Process
                .setThreadPriority(android.os.Process.THREAD_PRIORITY_URGENT_AUDIO);

        // Allocate Recorder and Start Recording...
        int bufferRead = 0;
        int bufferSize = AudioRecord.getMinBufferSize(this.getFrequency(),
                this.getChannelConfiguration(), this.getAudioEncoding());
        AudioRecord recordInstance = new AudioRecord(
                MediaRecorder.AudioSource.MIC, this.getFrequency(), this
                        .getChannelConfiguration(), this.getAudioEncoding(),
                bufferSize);
        short[] tempBuffer = new short[bufferSize];
        recordInstance.startRecording();
        while (this.isRecording) {
            // Are we paused?
            synchronized (mutex) {
                if (this.isPaused) {
                    try {
                        mutex.wait(250);
                    } catch (InterruptedException e) {
                        throw new IllegalStateException("Wait() interrupted!",
                                e);
                    }
                    continue;
                }
            }

            bufferRead = recordInstance.read(tempBuffer, 0, bufferSize);
            if (bufferRead == AudioRecord.ERROR_INVALID_OPERATION) {
                throw new IllegalStateException(
                        "read() returned AudioRecord.ERROR_INVALID_OPERATION");
            } else if (bufferRead == AudioRecord.ERROR_BAD_VALUE) {
                throw new IllegalStateException(
                        "read() returned AudioRecord.ERROR_BAD_VALUE");
            } else if (bufferRead == AudioRecord.ERROR_INVALID_OPERATION) {
                throw new IllegalStateException(
                        "read() returned AudioRecord.ERROR_INVALID_OPERATION");
            }
            try {
                for (int idxBuffer = 0; idxBuffer < bufferRead; ++idxBuffer) {
                    dataOutputStreamInstance.writeShort(tempBuffer[idxBuffer]);
                }
            } catch (IOException e) {
                throw new IllegalStateException(
                    "dataOutputStreamInstance.writeShort(curVal)");
            }

        }

        // Close resources...
        recordInstance.stop();
        try {
            bufferedStreamInstance.close();
        } catch (IOException e) {
            throw new IllegalStateException("Cannot close buffered writer.");
        }
    }

    public void setFileName(File fileName) {
        this.fileName = fileName;
    }

    public File getFileName() {
        return fileName;
    }

    /**
     * @param isRecording
     *            the isRecording to set
     */
    public void setRecording(boolean isRecording) {
        synchronized (mutex) {
            this.isRecording = isRecording;
            if (this.isRecording) {
                mutex.notify();
            }
        }
    }

    /**
     * @return the isRecording
     */
    public boolean isRecording() {
        synchronized (mutex) {
            return isRecording;
        }
    }

    /**
     * @param frequency
     *            the frequency to set
     */
    public void setFrequency(int frequency) {
        this.frequency = frequency;
    }

    /**
     * @return the frequency
     */
    public int getFrequency() {
        return frequency;
    }

    /**
     * @param channelConfiguration
     *            the channelConfiguration to set
     */
    public void setChannelConfiguration(int channelConfiguration) {
        this.channelConfiguration = channelConfiguration;
    }

    /**
     * @return the channelConfiguration
     */
    public int getChannelConfiguration() {
        return channelConfiguration;
    }

    /**
     * @return the audioEncoding
     */
    public int getAudioEncoding() {
        return audioEncoding;
    }

    /**
     * @param isPaused
     *            the isPaused to set
     */
    public void setPaused(boolean isPaused) {
        synchronized (mutex) {
            this.isPaused = isPaused;
        }
    }

    /**
     * @return the isPaused
     */
    public boolean isPaused() {
        synchronized (mutex) {
            return isPaused;
        }
    }

}

Answer 1

MediaRecorder 是您的需要。如果您不打算摆弄原始音频数据，请使用 MediaRecorder 对象进行录制。将输出格式设置为 THREE_GPP，它应该适合您。

Answer 2

更改文件扩展名不会更改文件格式，因此，例如，输入 .mp3 不会自动创建 MP3 文件。 AudioRecord 生成原始 PCM 数据。

您必须告诉媒体播放器播放原始文件，以及期望什么样的数据（采样率、编码等），就像您在录制时所做的那样，因为这些信息不是由文件本身给出的。

您可以在此处阅读 Audacity 中执行此操作的说明：http://delog.wordpress.com/2011/03/25/playing-raw-pcm-audio-using-audacity/

Answer 3

认为您应该使用另一个类然后 AudioRecord。
AudioRecord 是当前声音端口上内容的原始数字印象。
你在那里“借用”的代码只是一系列数字。

尝试使用 AudioManager，认为这更适合您的风格。