Fixing audio in mac

media/audio/mac/audio_output_mac.cc

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/audio/mac/audio_manager_mac.h"
 #include "media/audio/mac/audio_output_mac.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 
@@ skipping 19 matching lines @@
   kAudioQueueErr_EnqueueDuringReset = -66632
 };
 
 PCMQueueOutAudioOutputStream::PCMQueueOutAudioOutputStream(
     AudioManagerMac* manager, int channels, int sampling_rate,
     char bits_per_sample)
         : format_(),
           audio_queue_(NULL),
           buffer_(),
           source_(NULL),
-          manager_(manager) {
+          manager_(manager),
+          silence_bytes_(0),
+          pending_bytes_(0) {
   // We must have a manager.
   DCHECK(manager_);
   // A frame is one sample across all channels. In interleaved audio the per
   // frame fields identify the set of n |channels|. In uncompressed audio, a
   // packet is always one frame.
   format_.mSampleRate = sampling_rate;
   format_.mFormatID = kAudioFormatLinearPCM;
   format_.mFormatFlags = kLinearPCMFormatFlagIsPacked |
                          kLinearPCMFormatFlagIsSignedInteger;
   format_.mBitsPerChannel = bits_per_sample;
   format_.mChannelsPerFrame = channels;
   format_.mFramesPerPacket = 1;
   format_.mBytesPerPacket = (format_.mBitsPerChannel * channels) / 8;
   format_.mBytesPerFrame = format_.mBytesPerPacket;
+
+  // Silence buffer has a duration of 6ms to simulate the behavior of Windows.
+  // This value is choosen by experiments and macs cannot keep up with
+  // anything less than 6ms.
+  silence_bytes_ = format_.mBytesPerFrame * sampling_rate * 6 / 1000;
 }
 
 PCMQueueOutAudioOutputStream::~PCMQueueOutAudioOutputStream() {
 }
 
 void PCMQueueOutAudioOutputStream::HandleError(OSStatus err) {
   // source_ can be set to NULL from another thread. We need to cache its
   // pointer while we operate here. Note that does not mean that the source
   // has been destroyed.
   AudioSourceCallback* source = source_;
@@ skipping 87 matching lines @@
 void PCMQueueOutAudioOutputStream::RenderCallback(void* p_this,
                                                   AudioQueueRef queue,
                                                   AudioQueueBufferRef buffer) {
   PCMQueueOutAudioOutputStream* audio_stream =
       static_cast<PCMQueueOutAudioOutputStream*>(p_this);
   // Call the audio source to fill the free buffer with data. Not having a
   // source means that the queue has been closed. This is not an error.
   AudioSourceCallback* source = audio_stream->source_;
   if (!source)
     return;
+
+  // Adjust the number of pending bytes by subtracting the amount played.
+  audio_stream->pending_bytes_ -= buffer->mAudioDataByteSize;
   size_t capacity = buffer->mAudioDataBytesCapacity;
-  // TODO(hclam): Provide pending bytes.
   size_t filled = source->OnMoreData(audio_stream, buffer->mAudioData,
-                                     capacity, 0);
+                                     capacity, audio_stream->pending_bytes_);
+
+  // In order to keep the callback running, we need to provide a positive amount
+  // of data to the audio queue. To simulate the behavior of Windows, we write
+  // a buffer of silence.
+  if (!filled) {
+    CHECK(audio_stream->silence_bytes_ <= static_cast<int>(capacity));
+    filled = audio_stream->silence_bytes_;
+    memset(buffer->mAudioData, 0, filled);
+  }
+

[cpu_(ooo_6.6-7.5), 2009/09/16 18:06:26]

Won't it be much easier we just simply don't call AudioQueueEnqueueBuffer() if
filled == 0 ?

[Alpha Left Google, 2009/09/16 18:25:34]

AudioQueue works as a circular buffer, if we don't enqueue buffer you don't get
a callback. The output stream is a pull base model and we can't signal it to
enqueue buffer again once there's enough buffer. So doing this to simulate the
behavior of windows. In windows, if you waveOutWrite(0) you get a callback after
~2ms.

   if (filled > capacity) {
     // User probably overran our buffer.
     audio_stream->HandleError(0);
     return;
   }
   buffer->mAudioDataByteSize = filled;
+  // Incremnet bytes by amount filled into audio buffer.
+  audio_stream->pending_bytes_ += filled;
   if (NULL == queue)
     return;
   // Queue the audio data to the audio driver.
   OSStatus err = AudioQueueEnqueueBuffer(queue, buffer, 0, NULL);
   if (err != noErr) {
     if (err == kAudioQueueErr_EnqueueDuringReset) {
       // This is the error you get if you try to enqueue a buffer and the
       // queue has been closed. Not really a problem if indeed the queue
       // has been closed.
       if (!audio_stream->source_)
         return;
     }
     audio_stream->HandleError(err);
   }
 }
 
 void PCMQueueOutAudioOutputStream::Start(AudioSourceCallback* callback) {
   DCHECK(callback);
-  OSStatus err = AudioQueueStart(audio_queue_, NULL);
-  if (err != noErr) {
-    HandleError(err);
-    return;
-  }
+  OSStatus err = noErr;
   source_ = callback;
+  pending_bytes_ = 0;
   // Ask the source to pre-fill all our buffers before playing.
   for(size_t ix = 0; ix != kNumBuffers; ++ix) {
+    buffer_[ix]->mAudioDataByteSize = 0;
     RenderCallback(this, NULL, buffer_[ix]);
   }
   // Queue the buffers to the audio driver, sounds starts now.
   for(size_t ix = 0; ix != kNumBuffers; ++ix) {
     err = AudioQueueEnqueueBuffer(audio_queue_, buffer_[ix], 0, NULL);
     if (err != noErr) {
       HandleError(err);
       return;
     }
   }
+  err  = AudioQueueStart(audio_queue_, NULL);
+  if (err != noErr) {
+    HandleError(err);
+    return;
+  }
 }