Use multiple shared memory buffers cyclically for audio capture.

Currently, only one buffer of shared memory (10ms) is used to transfer captured audio data from browser process to renderer process. This results in data overwriting on both desktop and mobile, since it gives renderer process only 10ms to pick up the data and renderer process will likely miss reading data in time from time to time due to various reasons, e.g., thread scheduling.

This patch adds a scheme using multiple buffers of shared memory cyclically so that renderer process can have much more time to pick up the data. This can mitigate most data owerwriting cases which happen typically in burst mode. This approach does not introduce any new delay in browser process.

The number of buffers is currently set to 10. It can be set to any positive number and be tuned if needed.

BUG=178040
Review URL: https://codereview.chromium.org/12379071

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@187393 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 43 insertions, 14 deletions

diff --git a/content/browser/renderer_host/media/audio_input_renderer_host.cc b/content/browser/renderer_host/media/audio_input_renderer_host.cc
index f83d19a..18b7e70 100644
--- a/content/browser/renderer_host/media/audio_input_renderer_host.cc
+++ b/content/browser/renderer_host/media/audio_input_renderer_host.cc
@@ -27,8 +27,10 @@ struct AudioInputRendererHost::AudioEntry {
   // The audio input stream ID in the render view.
   int stream_id;
 
-  // Shared memory for transmission of the audio data.
+  // Shared memory for transmission of the audio data. It has
+  // |shared_memory_segment_count| equal lengthed segments.
   base::SharedMemory shared_memory;
+  int shared_memory_segment_count;
 
   // The synchronous writer to be used by the controller. We have the
   // ownership of the writer.
@@ -40,6 +42,7 @@ struct AudioInputRendererHost::AudioEntry {
 
 AudioInputRendererHost::AudioEntry::AudioEntry()
     : stream_id(0),
+      shared_memory_segment_count(0),
       pending_close(false) {
 }
 
@@ -155,7 +158,8 @@ void AudioInputRendererHost::DoCompleteCreation(
 
   Send(new AudioInputMsg_NotifyStreamCreated(entry->stream_id,
       foreign_memory_handle, foreign_socket_handle,
-      entry->shared_memory.created_size()));
+      entry->shared_memory.created_size(),
+      entry->shared_memory_segment_count));
 }
 
 void AudioInputRendererHost::DoSendRecordingMessage(
@@ -209,8 +213,11 @@ void AudioInputRendererHost::OnStartDevice(int stream_id, int session_id) {
 }
 
 void AudioInputRendererHost::OnCreateStream(
-    int stream_id, const media::AudioParameters& params,
-    const std::string& device_id, bool automatic_gain_control) {
+    int stream_id,
+    const media::AudioParameters& params,
+    const std::string& device_id,
+    bool automatic_gain_control,
+    int shared_memory_count) {
   VLOG(1) << "AudioInputRendererHost::OnCreateStream(stream_id="
           << stream_id << ")";
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
@@ -234,18 +241,22 @@ void AudioInputRendererHost::OnCreateStream(
   // Create a new AudioEntry structure.
   scoped_ptr<AudioEntry> entry(new AudioEntry());
 
-  uint32 mem_size = sizeof(media::AudioInputBufferParameters) + buffer_size;
+  uint32 segment_size =
+      sizeof(media::AudioInputBufferParameters) + buffer_size;
+  entry->shared_memory_segment_count = shared_memory_count;
 
   // Create the shared memory and share it with the renderer process
   // using a new SyncWriter object.
-  if (!entry->shared_memory.CreateAndMapAnonymous(mem_size)) {
+  if (!entry->shared_memory.CreateAndMapAnonymous(
+      segment_size * entry->shared_memory_segment_count)) {
     // If creation of shared memory failed then send an error message.
     SendErrorMessage(stream_id);
     return;
   }
 
   scoped_ptr<AudioInputSyncWriter> writer(
-      new AudioInputSyncWriter(&entry->shared_memory));
+      new AudioInputSyncWriter(&entry->shared_memory,
+                               entry->shared_memory_segment_count));
 
   if (!writer->Init()) {
     SendErrorMessage(stream_id);
diff --git a/content/browser/renderer_host/media/audio_input_renderer_host.h b/content/browser/renderer_host/media/audio_input_renderer_host.h
index d0d4438..ab71ef4 100644
--- a/content/browser/renderer_host/media/audio_input_renderer_host.h
+++ b/content/browser/renderer_host/media/audio_input_renderer_host.h
@@ -125,7 +125,8 @@ class CONTENT_EXPORT AudioInputRendererHost
   void OnCreateStream(int stream_id,
                       const media::AudioParameters& params,
                       const std::string& device_id,
-                      bool automatic_gain_control);
+                      bool automatic_gain_control,
+                      int shared_memory_count);
 
   // Track that the data for the audio stream referenced by |stream_id| is
   // consumed by an entity in the render view referenced by |render_view_id|.
diff --git a/content/browser/renderer_host/media/audio_input_sync_writer.cc b/content/browser/renderer_host/media/audio_input_sync_writer.cc
index fb5676e..2af937d 100644
--- a/content/browser/renderer_host/media/audio_input_sync_writer.cc
+++ b/content/browser/renderer_host/media/audio_input_sync_writer.cc
@@ -11,8 +11,16 @@
 
 namespace content {
 
-AudioInputSyncWriter::AudioInputSyncWriter(base::SharedMemory* shared_memory)
-    : shared_memory_(shared_memory) {
+AudioInputSyncWriter::AudioInputSyncWriter(
+    base::SharedMemory* shared_memory,
+    int shared_memory_segment_count)
+    : shared_memory_(shared_memory),
+      shared_memory_segment_count_(shared_memory_segment_count),
+      current_segment_id_(0) {
+  DCHECK_GT(shared_memory_segment_count, 0);
+  DCHECK_EQ(shared_memory->created_size() % shared_memory_segment_count, 0u);
+  shared_memory_segment_size_ =
+      shared_memory->created_size() / shared_memory_segment_count;
 }
 
 AudioInputSyncWriter::~AudioInputSyncWriter() {}
@@ -22,14 +30,19 @@ void AudioInputSyncWriter::UpdateRecordedBytes(uint32 bytes) {
   socket_->Send(&bytes, sizeof(bytes));
 }
 
-uint32 AudioInputSyncWriter::Write(const void* data, uint32 size,
-                                   double volume) {
+uint32 AudioInputSyncWriter::Write(
+    const void* data, uint32 size, double volume) {
+  uint8* ptr = static_cast<uint8*>(shared_memory_->memory());
+  ptr += current_segment_id_ * shared_memory_segment_size_;
   media::AudioInputBuffer* buffer =
-      reinterpret_cast<media::AudioInputBuffer*>(shared_memory_->memory());
+      reinterpret_cast<media::AudioInputBuffer*>(ptr);
   buffer->params.volume = volume;
   buffer->params.size = size;
   memcpy(buffer->audio, data, size);
 
+  if (++current_segment_id_ >= shared_memory_segment_count_)
+    current_segment_id_ = 0;
+
   return size;
 }
 
diff --git a/content/browser/renderer_host/media/audio_input_sync_writer.h b/content/browser/renderer_host/media/audio_input_sync_writer.h
index 6997a93..868219b 100644
--- a/content/browser/renderer_host/media/audio_input_sync_writer.h
+++ b/content/browser/renderer_host/media/audio_input_sync_writer.h
@@ -21,7 +21,8 @@ namespace content {
 // process.
 class AudioInputSyncWriter : public media::AudioInputController::SyncWriter {
  public:
-  explicit AudioInputSyncWriter(base::SharedMemory* shared_memory);
+  explicit AudioInputSyncWriter(base::SharedMemory* shared_memory,
+                                int shared_memory_segment_count);
 
   virtual ~AudioInputSyncWriter();
 
@@ -40,6 +41,9 @@ class AudioInputSyncWriter : public media::AudioInputController::SyncWriter {
 
  private:
   base::SharedMemory* shared_memory_;
+  uint32 shared_memory_segment_size_;
+  uint32 shared_memory_segment_count_;
+  uint32 current_segment_id_;
 
   // Socket for transmitting audio data.
   scoped_ptr<base::CancelableSyncSocket> socket_;