Use multiple shared memory buffers cyclically for audio capture.

media/audio/audio_input_device.cc

 // Copyright (c) 2012 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/audio_input_device.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/base/audio_bus.h"
 
+namespace {
+// The number of shared memory buffer segments indicated to browser process
+// in order to avoid data overwriting. This number can be any positive number,
+// dependent how fast the renderer process can pick up captured data from
+// shared memory.
+int kRequestedSharedMemoryCount = 10;

[DaleCurtis, 2013/03/07 02:04:37]

static const int or make it an enum.  media/ code doesn't traditionally use the
unnamed namespace approach.

[wjia(left Chromium), 2013/03/10 18:19:49]

anonymous namespace is better than static since it doesn't pollute namespace
media. I do see some const is defined in anonymous namespace in media/.

[DaleCurtis, 2013/03/11 20:00:47]

While the Chromium style guide explicitly says unnamed namespaces are preferred,
consistency with the surrounding code should be favored. It's not directly
comparable, but there is an order of magnitude difference between the two:

$ git grep "namespace {" | wc -l
32
$ git grep "static const" | wc -l
597

I just discussed with the team and the answers were:
1. It doesn't matter for pure const.
2. Favor consistency.
3. If you don't mind the code churn, converting all static const to unnamed
namespace would be valid.
4. http://go/static-or-anonymous-namespace (but more for functions).

Please favor consistency in this instance.

[wjia(left Chromium), 2013/03/11 20:34:27]

Done.

+}
+
 namespace media {
 
 // Takes care of invoking the capture callback on the audio thread.
 // An instance of this class is created for each capture stream in
 // OnLowLatencyCreated().
 class AudioInputDevice::AudioThreadCallback
     : public AudioDeviceThread::Callback {
  public:
   AudioThreadCallback(const AudioParameters& audio_parameters,
                       base::SharedMemoryHandle memory,
                       int memory_length,
+                      int total_segments,
                       CaptureCallback* capture_callback);
   virtual ~AudioThreadCallback();
 
   virtual void MapSharedMemory() OVERRIDE;
 
   // Called whenever we receive notifications about pending data.
   virtual void Process(int pending_data) OVERRIDE;
 
  private:
+  int current_segment_id_;
   CaptureCallback* capture_callback_;
   scoped_ptr<AudioBus> audio_bus_;
   DISALLOW_COPY_AND_ASSIGN(AudioThreadCallback);
 };
 
 AudioInputDevice::AudioInputDevice(
     AudioInputIPC* ipc,
     const scoped_refptr<base::MessageLoopProxy>& io_loop)
     : ScopedLoopObserver(io_loop),
       callback_(NULL),
@@ skipping 53 matching lines @@
 void AudioInputDevice::SetAutomaticGainControl(bool enabled) {
   DVLOG(1) << "SetAutomaticGainControl(enabled=" << enabled << ")";
   message_loop()->PostTask(FROM_HERE,
       base::Bind(&AudioInputDevice::SetAutomaticGainControlOnIOThread,
           this, enabled));
 }
 
 void AudioInputDevice::OnStreamCreated(
     base::SharedMemoryHandle handle,
     base::SyncSocket::Handle socket_handle,
-    int length) {
+    int length,
+    int total_segments) {
   DCHECK(message_loop()->BelongsToCurrentThread());
 #if defined(OS_WIN)
   DCHECK(handle);
   DCHECK(socket_handle);
 #else
   DCHECK_GE(handle.fd, 0);
   DCHECK_GE(socket_handle, 0);
 #endif
   DCHECK(length);
   DVLOG(1) << "OnStreamCreated (stream_id=" << stream_id_ << ")";
 
   // We should only get this callback if stream_id_ is valid.  If it is not,
   // the IPC layer should have closed the shared memory and socket handles
   // for us and not invoked the callback.  The basic assertion is that when
   // stream_id_ is 0 the AudioInputDevice instance is not registered as a
   // delegate and hence it should not receive callbacks.
   DCHECK(stream_id_);
 
   base::AutoLock auto_lock(audio_thread_lock_);
 
   DCHECK(audio_thread_.IsStopped());
   audio_callback_.reset(
-      new AudioInputDevice::AudioThreadCallback(audio_parameters_, handle,
-                                                length, callback_));
+      new AudioInputDevice::AudioThreadCallback(
+          audio_parameters_, handle, length, total_segments, callback_));
   audio_thread_.Start(audio_callback_.get(), socket_handle, "AudioInputDevice");
 
   MessageLoop::current()->PostTask(FROM_HERE,
       base::Bind(&AudioInputDevice::StartOnIOThread, this));
 }
 
 void AudioInputDevice::OnVolume(double volume) {
   NOTIMPLEMENTED();
 }
 
@@ skipping 47 matching lines @@
   if (!pending_device_ready_)
     return;
 
   // If AudioInputDeviceManager returns an empty string, it means no device
   // is ready for start.
   if (device_id.empty()) {
     ipc_->RemoveDelegate(stream_id_);
     stream_id_ = 0;
   } else {
     ipc_->CreateStream(stream_id_, audio_parameters_, device_id,
-                       agc_is_enabled_);
+                       agc_is_enabled_, kRequestedSharedMemoryCount);
   }
 
   pending_device_ready_ = false;
   // Notify the client that the device has been started.
   if (event_handler_)
     event_handler_->OnDeviceStarted(device_id);
 }
 
 void AudioInputDevice::OnIPCClosed() {
   ipc_ = NULL;
@@ skipping 11 matching lines @@
   DCHECK_EQ(0, stream_id_);
   if (stream_id_)
     return;
 
   stream_id_ = ipc_->AddDelegate(this);
   // If |session_id_| is not specified, it will directly create the stream;
   // otherwise it will send a AudioInputHostMsg_StartDevice msg to the browser
   // and create the stream when getting a OnDeviceReady() callback.
   if (!session_id_) {
     ipc_->CreateStream(stream_id_, audio_parameters_,
-        AudioManagerBase::kDefaultDeviceId, agc_is_enabled_);
+        AudioManagerBase::kDefaultDeviceId, agc_is_enabled_,
+        kRequestedSharedMemoryCount);
   } else {
     ipc_->StartDevice(stream_id_, session_id_);
     pending_device_ready_ = true;
   }
 }
 
 void AudioInputDevice::SetSessionIdOnIOThread(int session_id) {
   DCHECK(message_loop()->BelongsToCurrentThread());
   session_id_ = session_id;
 }
@@ skipping 53 matching lines @@
 void AudioInputDevice::WillDestroyCurrentMessageLoop() {
   LOG(ERROR) << "IO loop going away before the input device has been stopped";
   ShutDownOnIOThread();
 }
 
 // AudioInputDevice::AudioThreadCallback
 AudioInputDevice::AudioThreadCallback::AudioThreadCallback(
     const AudioParameters& audio_parameters,
     base::SharedMemoryHandle memory,
     int memory_length,
+    int total_segments,
     CaptureCallback* capture_callback)
-    : AudioDeviceThread::Callback(audio_parameters, memory, memory_length),
+    : AudioDeviceThread::Callback(audio_parameters, memory, memory_length,
+                                  total_segments),
+      current_segment_id_(0),
       capture_callback_(capture_callback) {
   audio_bus_ = AudioBus::Create(audio_parameters_);
 }
 
 AudioInputDevice::AudioThreadCallback::~AudioThreadCallback() {
 }
 
 void AudioInputDevice::AudioThreadCallback::MapSharedMemory() {
   shared_memory_.Map(memory_length_);
 }
 
 void AudioInputDevice::AudioThreadCallback::Process(int pending_data) {
   // The shared memory represents parameters, size of the data buffer and the
   // actual data buffer containing audio data. Map the memory into this
   // structure and parse out parameters and the data area.
-  AudioInputBuffer* buffer =
-      reinterpret_cast<AudioInputBuffer*>(shared_memory_.memory());
+  uint8* ptr = reinterpret_cast<uint8*>(shared_memory_.memory());

[DaleCurtis, 2013/03/07 02:04:37]

static_cast ?

[wjia(left Chromium), 2013/03/10 18:19:49]

Done.

+  ptr += current_segment_id_ * segment_length_;
+  AudioInputBuffer* buffer = reinterpret_cast<AudioInputBuffer*>(ptr);
   DCHECK_EQ(buffer->params.size,
-            memory_length_ - sizeof(AudioInputBufferParameters));
+            segment_length_ - sizeof(AudioInputBufferParameters));
   double volume = buffer->params.volume;
 
   int audio_delay_milliseconds = pending_data / bytes_per_ms_;
   int16* memory = reinterpret_cast<int16*>(&buffer->audio[0]);
   const int bytes_per_sample = sizeof(memory[0]);
 
+  if (++current_segment_id_ >= total_segments_)

[DaleCurtis, 2013/03/07 02:04:37]

Same modulus comment.

[wjia(left Chromium), 2013/03/10 18:19:49]

Same reply. :-)

+    current_segment_id_ = 0;
+
   // Deinterleave each channel and convert to 32-bit floating-point
   // with nominal range -1.0 -> +1.0.
   audio_bus_->FromInterleaved(memory, audio_bus_->frames(), bytes_per_sample);
 
   // Deliver captured data to the client in floating point format
   // and update the audio-delay measurement.
   capture_callback_->Capture(audio_bus_.get(),
                              audio_delay_milliseconds, volume);
 }
 
 }  // namespace media