Ensure that data is not overwritten in the audio input shared memory ring buffer that sits on the b…

content/browser/renderer_host/media/audio_input_sync_writer.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 "content/browser/renderer_host/media/audio_input_sync_writer.h"
 
 #include <algorithm>
 
 #include "base/memory/shared_memory.h"
+#include "base/metrics/histogram.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 
 using media::AudioBus;
 
 namespace content {
 
+namespace {
+  // TODO BEFORE COMMIT: Which value makes sense? I.e. how long can we accept
+  // blocking the soundcard thread and wait before dropping data.
+  const base::TimeDelta kReadCheckTimeout =

[henrika (OOO until Aug 14), 2015/08/28 07:56:25]

Have you experimented with high load to see the effect of reducing this value?
Might also differ between OS:es. 

[Henrik Grunell, 2015/08/28 12:21:57]

I've stress tested on my machine, couldn't provoke any timeout at all. It can
indeed differ. I think we'll just have to choose a reasonable value.

+      base::TimeDelta::FromMilliseconds(10);
+}
+
 AudioInputSyncWriter::AudioInputSyncWriter(base::SharedMemory* shared_memory,
                                            int shared_memory_segment_count,
                                            const media::AudioParameters& params)
     : shared_memory_(shared_memory),
       shared_memory_segment_count_(shared_memory_segment_count),
       current_segment_id_(0),
       creation_time_(base::Time::Now()),
       audio_bus_memory_size_(AudioBus::CalculateMemorySize(params)),
-      next_buffer_id_(0) {
+      next_buffer_id_(0),
+      expected_buffer_reads_(0),
+      read_verification_timeouts_(0) {
   DCHECK_GT(shared_memory_segment_count, 0);
   DCHECK_EQ(shared_memory->requested_size() % shared_memory_segment_count, 0u);
   shared_memory_segment_size_ =
       shared_memory->requested_size() / shared_memory_segment_count;
   DVLOG(1) << "SharedMemory::requested_size: "
            << shared_memory->requested_size();
   DVLOG(1) << "shared_memory_segment_count: " << shared_memory_segment_count;
   DVLOG(1) << "audio_bus_memory_size: " << audio_bus_memory_size_;
 
   // Create vector of audio buses by wrapping existing blocks of memory.
   uint8* ptr = static_cast<uint8*>(shared_memory_->memory());
   for (int i = 0; i < shared_memory_segment_count; ++i) {
     CHECK((reinterpret_cast<uintptr_t>(ptr) &
           (media::AudioBus::kChannelAlignment - 1)) == 0U);
     media::AudioInputBuffer* buffer =
         reinterpret_cast<media::AudioInputBuffer*>(ptr);
     scoped_ptr<media::AudioBus> audio_bus =
         media::AudioBus::WrapMemory(params, buffer->audio);
     audio_buses_.push_back(audio_bus.release());
     ptr += shared_memory_segment_size_;
   }
 }
 
-AudioInputSyncWriter::~AudioInputSyncWriter() {}
+AudioInputSyncWriter::~AudioInputSyncWriter() {
+  // TODO BEFORE COMMIT: Maybe percentage makes more sense here?

[DaleCurtis, 2015/08/27 16:43:39]

For consistency please use the same pattern as we do on output.

[Henrik Grunell, 2015/08/28 12:21:57]

Done.

+  UMA_HISTOGRAM_COUNTS_1000("Media.AudioCapturerMissedReadDeadline",
+                            read_verification_timeouts_);
+}
 
 void AudioInputSyncWriter::Write(const media::AudioBus* data,
                                  double volume,
                                  bool key_pressed,
                                  uint32 hardware_delay_bytes) {
 #if !defined(OS_ANDROID)
   static const base::TimeDelta kLogDelayThreadhold =
       base::TimeDelta::FromMilliseconds(500);
 
   std::ostringstream oss;
@@ skipping 11 matching lines @@
     }
   }
   if (!oss.str().empty()) {
     MediaStreamManager::SendMessageToNativeLog(oss.str());
     DVLOG(1) << oss.str();
   }
 
   last_write_time_ = base::Time::Now();
 #endif
 
+  // Check that the renderer side has read data so that we don't overwrite.
+  // The renderer side sends a signal over the socket each time it has read
+  // data. Here, we count the number of reads we expect to have been done. When
+  // we reach |shared_memory_segment_count_|, we do
+  // (|shared_memory_segment_count_| / 2) socket receives, which normally is
+  // in queue. If we timeout, there's a problem with being able to read  at the
+  // high enough pace, and we throw away the audio buffer.
+  if (expected_buffer_reads_ ==

[henrika (OOO until Aug 14), 2015/08/28 07:56:25]

Did you check this scheme for a segment count equal to 1?

[Henrik Grunell, 2015/08/28 12:21:57]

Good point. I changed the for loop condition to
shared_memory_segment_count_ + 1 / 2
to round up so that size 1 also reads once. Tested that manually, works fine.

+      static_cast<int>(shared_memory_segment_count_)) {
+    size_t bytes_received = 0;
+    uint32 dummy = 0;
+    for (uint32 i = 0; i < shared_memory_segment_count_ / 2; ++i) {
+      bytes_received =
+          socket_->ReceiveWithTimeout(&dummy, sizeof(dummy), kReadCheckTimeout);
+      if (bytes_received != sizeof(dummy)) {
+        const std::string error_message =
+            "Verifying shared memory read timed out. Dropping audio data.";
+        LOG(ERROR) << error_message;
+        MediaStreamManager::SendMessageToNativeLog(error_message);
+        ++read_verification_timeouts_;
+        return;
+      }
+      --expected_buffer_reads_;
+      DCHECK_GE(expected_buffer_reads_, 0);
+    }
+  }
+
   // Write audio parameters to shared memory.
   uint8* ptr = static_cast<uint8*>(shared_memory_->memory());
   ptr += current_segment_id_ * shared_memory_segment_size_;
   media::AudioInputBuffer* buffer =
       reinterpret_cast<media::AudioInputBuffer*>(ptr);
   buffer->params.volume = volume;
   buffer->params.size = audio_bus_memory_size_;
   buffer->params.key_pressed = key_pressed;
   buffer->params.hardware_delay_bytes = hardware_delay_bytes;
   buffer->params.id = next_buffer_id_++;
 
   // Copy data from the native audio layer into shared memory using pre-
   // allocated audio buses.
   media::AudioBus* audio_bus = audio_buses_[current_segment_id_];
   data->CopyTo(audio_bus);
 
   socket_->Send(&current_segment_id_, sizeof(current_segment_id_));
 
   if (++current_segment_id_ >= shared_memory_segment_count_)
     current_segment_id_ = 0;
+
+  ++expected_buffer_reads_;
+  DCHECK_LE(expected_buffer_reads_,
+            static_cast<int>(shared_memory_segment_count_));
 }
 
 void AudioInputSyncWriter::Close() {
   socket_->Close();
 }
 
 bool AudioInputSyncWriter::Init() {
   socket_.reset(new base::CancelableSyncSocket());
   foreign_socket_.reset(new base::CancelableSyncSocket());
   return base::CancelableSyncSocket::CreatePair(socket_.get(),
                                                 foreign_socket_.get());
 }
 
 bool AudioInputSyncWriter::PrepareForeignSocket(
     base::ProcessHandle process_handle,
     base::SyncSocket::TransitDescriptor* descriptor) {
   return foreign_socket_->PrepareTransitDescriptor(process_handle, descriptor);
 }
 
 
 }  // namespace content