Android：AudioRecord 类问题：从不调用回调

Question

我的 Android Java 应用程序需要将音频数据记录到 RAM 中并进行处理。 这就是我使用“AudioRecord”类而不是“MediaRecorder”（仅记录到文件）的原因。

到目前为止，我使用“read()”的繁忙循环轮询音频数据。到目前为止，这一直有效，但它过多地与 CPU 挂钩。 在两次轮询之间，我将线程置于睡眠状态以避免 100% 的 CPU 使用率。 然而，这并不是一个真正干净的解决方案，因为睡眠时间是 不能保证，您必须减去安全时间以免丢失音频 sn-ps。这不是 CPU 最优的。我需要尽可能多的空闲 CPU 周期 一个并行运行的线程。

现在我使用“OnRecordPositionUpdateListener”实现了录制。 根据 SDK Docs，这看起来很有希望，也是正确的方法。 一切似乎都正常（打开音频设备，读取（）数据等） 但永远不会调用 Listner。

有人知道为什么吗？

信息： 我正在使用真正的设备，而不是在模拟器下。使用忙碌循环的录音基本上可以工作（但不能令人满意）。只有回调监听器永远不会被调用。

这是我的源代码中的一个 sn-p：

public class myApplication extends Activity {

  /* audio recording */
  private static final int AUDIO_SAMPLE_FREQ = 16000;
  private static final int AUDIO_BUFFER_BYTESIZE = AUDIO_SAMPLE_FREQ * 2 * 3; // = 3000ms
  private static final int AUDIO_BUFFER_SAMPLEREAD_SIZE = AUDIO_SAMPLE_FREQ  / 10 * 2; // = 200ms

  private short[] mAudioBuffer = null; // audio buffer
  private int mSamplesRead; // how many samples are recently read
  private AudioRecord mAudioRecorder; // Audio Recorder

  ...

  private OnRecordPositionUpdateListener mRecordListener = new OnRecordPositionUpdateListener() {

    public void onPeriodicNotification(AudioRecord recorder) {
      mSamplesRead = recorder.read(mAudioBuffer, 0, AUDIO_BUFFER_SAMPLEREAD_SIZE);
      if (mSamplesRead > 0) {

        // do something here...

      }
    }

    public void onMarkerReached(AudioRecord recorder) {
      Error("What? Hu!? Where am I?");
    }
  };

  ...

  public void onCreate(Bundle savedInstanceState) {

  try {
      mAudioRecorder = new AudioRecord(
          android.media.MediaRecorder.AudioSource.MIC, 
          AUDIO_SAMPLE_FREQ,
          AudioFormat.CHANNEL_CONFIGURATION_MONO,
          AudioFormat.ENCODING_PCM_16BIT,  
          AUDIO_BUFFER_BYTESIZE);
    } catch (Exception e) {
      Error("Unable to init audio recording!");
    }

    mAudioBuffer = new short[AUDIO_BUFFER_SAMPLEREAD_SIZE];
    mAudioRecorder.setPositionNotificationPeriod(AUDIO_BUFFER_SAMPLEREAD_SIZE);
    mAudioRecorder.setRecordPositionUpdateListener(mRecordListener);
    mAudioRecorder.startRecording();

    /* test if I can read anything at all... (and yes, this here works!) */
    mSamplesRead = mAudioRecorder.read(mAudioBuffer, 0, AUDIO_BUFFER_SAMPLEREAD_SIZE);

  }
}

Answer 1

我认为问题在于您仍然需要执行读取循环。如果您设置回调，它们将在您读取为回调指定的帧数时触发。但是您仍然需要进行读取。我已经尝试过了，回调被调用得很好。当自记录开始以来读取了该数量的帧时，设置标记会导致回调。换句话说，你可以将标记设置在很远的未来，在你多次阅读之后，它就会触发。您可以将周期设置为更大的帧数，并且每次读取该帧数时都会触发回调。我认为他们这样做是为了你可以在一个紧密的循环中对原始数据进行低级处理，然后你的回调可以经常进行摘要级处理。您可以使用标记更轻松地决定何时停止记录（而不是在读取循环中计数）。

Answer 2

这是我用来查找平均噪声的代码。请注意，它基于侦听器通知，因此可以节省设备电池。这绝对是基于上面的例子。这些例子为我节省了很多时间，谢谢。

private AudioRecord recorder;
private boolean recorderStarted;
private Thread recordingThread;
private int bufferSize = 800;
private short[][] buffers = new short[256][bufferSize];
private int[] averages = new int[256];
private int lastBuffer = 0;

protected void startListenToMicrophone() {
    if (!recorderStarted) {

        recordingThread = new Thread() {
            @Override
            public void run() {
                int minBufferSize = AudioRecord.getMinBufferSize(8000, AudioFormat.CHANNEL_CONFIGURATION_MONO,
                        AudioFormat.ENCODING_PCM_16BIT);
                recorder = new AudioRecord(AudioSource.MIC, 8000, AudioFormat.CHANNEL_CONFIGURATION_MONO,
                        AudioFormat.ENCODING_PCM_16BIT, minBufferSize * 10);
                recorder.setPositionNotificationPeriod(bufferSize);
                recorder.setRecordPositionUpdateListener(new OnRecordPositionUpdateListener() {
                    @Override
                    public void onPeriodicNotification(AudioRecord recorder) {
                        short[] buffer = buffers[++lastBuffer % buffers.length];
                        recorder.read(buffer, 0, bufferSize);
                        long sum = 0;
                        for (int i = 0; i < bufferSize; ++i) {
                            sum += Math.abs(buffer[i]);
                        }
                        averages[lastBuffer % buffers.length] = (int) (sum / bufferSize);
                        lastBuffer = lastBuffer % buffers.length;
                    }

                    @Override
                    public void onMarkerReached(AudioRecord recorder) {
                    }
                });
                recorder.startRecording();
                short[] buffer = buffers[lastBuffer % buffers.length];
                recorder.read(buffer, 0, bufferSize);
                while (true) {
                    if (isInterrupted()) {
                        recorder.stop();
                        recorder.release();
                        break;
                    }
                }
            }
        };
        recordingThread.start();

        recorderStarted = true;
    }
}

private void stopListenToMicrophone() {
    if (recorderStarted) {
        if (recordingThread != null && recordingThread.isAlive() && !recordingThread.isInterrupted()) {
            recordingThread.interrupt();
        }
        recorderStarted = false;
    }
}

Answer 3

现在我使用 “OnRecordPositionUpdateListener”。这看起来很有希望，而且 根据 SDK Docs 的正确方法。一切似乎都有效 （打开音频设备，读取（）数据等）但Listner是 从来没有打电话。

有人知道为什么吗？

我发现 OnRecordPositionUpdateListener 会被忽略，直到您执行第一个 .read()。

换句话说，我发现如果我按照文档设置所有内容，我的监听器永远不会被调用。但是，如果我在执行初始.start() 之后首先调用.read()，那么监听器就会被调用——前提是我每次调用监听器时都调用.read()。

换句话说，Listener 事件似乎只对每个 .read() 或类似事件有效一次。

我还发现，如果我请求读取任何小于 buffSize/2 的样本，则不会调用 Listener。所以似乎只有在缓冲区大小至少一半的.read() 之后才调用侦听器。要继续使用侦听器回调，必须在每次运行侦听器时调用 read。 （换句话说，将调用 read 放在 Listener 代码中。）

但是，监听器似乎是在数据还没有准备好的时候被调用的，导致阻塞。

此外，如果您的通知周期或时间大于缓冲区大小的一半，它们似乎永远不会被调用。

更新：

随着我继续深入挖掘，我发现回调似乎只有在 .read() 完成时才会被调用......！

我不知道这是错误还是功能。我最初的想法是，在阅读的时候我想要一个回调。但也许 android 开发人员有相反的想法，你只需将 while(1){xxxx.read(...)} 单独放在一个线程中，并且为了让你不必跟踪每次 read() 完成的时间，回调基本上可以读取完成后告诉您。

哦。也许我刚刚才恍然大悟。而且我认为其他人已经在我之前指出了这一点，但它并没有陷入：位置或周期回调必须对已经读取的字节进行操作......

我想也许我一直在使用线程。

在这种风格中，一旦返回，就会有一个线程不断调用 read()，因为 read 是阻塞的并且耐心地等待足够的数据返回。

然后，回调将独立地每隔 x 个样本调用您指定的函数。

Answer 4

对于通过 Intent 服务录制音频的用户，他们也可能会遇到此回调问题。我最近一直在研究这个问题，我想出了一个简单的解决方案，您可以在单独的线程中调用您的录制方法。这应该在录制时调用 onPeriodicNotification 方法没有任何问题。

类似这样的：

public class TalkService extends IntentService {
...
@Override
protected void onHandleIntent(Intent intent) {
Context context = getApplicationContext();
tRecord = new Thread(new recordAudio());
tRecord.start();
...
while (tRecord.isAlive()) {
    if (getIsDone()) {
        if (aRecorder.getRecordingState() == AudioRecord.RECORDSTATE_STOPPED) {
            socketConnection(context, host, port);
        }
    }
} }
...
class recordAudio implements Runnable {

        public void run() {
            try {
                OutputStream osFile = new FileOutputStream(file);
                BufferedOutputStream bosFile = new BufferedOutputStream(osFile);
                DataOutputStream dosFile = new DataOutputStream(bosFile);

                aRecorder = new AudioRecord(MediaRecorder.AudioSource.MIC,
                        sampleRate, channelInMode, encodingMode, bufferSize);

                data = new short[bufferSize];

                aRecorder.setPositionNotificationPeriod(sampleRate);
                aRecorder
                        .setRecordPositionUpdateListener(new AudioRecord.OnRecordPositionUpdateListener() {
                            int count = 1;

                            @Override
                            public void onPeriodicNotification(
                                    AudioRecord recorder) {
                                Log.e(WiFiDirect.TAG, "Period notf: " + count++);

                                if (getRecording() == false) {
                                    aRecorder.stop();
                                    aRecorder.release();
                                    setIsDone(true);
                                    Log.d(WiFiDirect.TAG,
                                            "Recorder stopped and released prematurely");
                                }
                            }

                            @Override
                            public void onMarkerReached(AudioRecord recorder) {
                                // TODO Auto-generated method stub

                            }
                        });

                aRecorder.startRecording();
                Log.d(WiFiDirect.TAG, "start Recording");
                aRecorder.read(data, 0, bufferSize);
                for (int i = 0; i < data.length; i++) {
                    dosFile.writeShort(data[i]);
                }

                if (aRecorder.getRecordingState() == AudioRecord.RECORDSTATE_RECORDING) {
                    aRecorder.stop();
                    aRecorder.release();
                    setIsDone(true);
                    Log.d(WiFiDirect.TAG, "Recorder stopped and released");
                }

            } catch (Exception e) {
                // TODO: handle exception
            }
        }
    }