Modifies AudioInputCallback::OnData and use media::AudioBus instead of plain byte vector

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 "content/browser/renderer_host/media/media_stream_manager.h"
+#include "media/base/audio_bus.h"
 
 namespace content {
 
 AudioInputSyncWriter::AudioInputSyncWriter(
     base::SharedMemory* shared_memory,
-    int shared_memory_segment_count)
+    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()) {
+      creation_time_(base::Time::Now()),
+      params_(params) {
   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;
 }
 
 AudioInputSyncWriter::~AudioInputSyncWriter() {}
 
 // TODO(henrika): Combine into one method (including Write).
 void AudioInputSyncWriter::UpdateRecordedBytes(uint32 bytes) {
   socket_->Send(&bytes, sizeof(bytes));
 }
 
-uint32 AudioInputSyncWriter::Write(const void* data,
-                                   uint32 size,
+uint32 AudioInputSyncWriter::Write(const media::AudioBus* data,
                                    double volume,
                                    bool key_pressed) {
 #if !defined(OS_ANDROID)
   static const base::TimeDelta kLogDelayThreadhold =
       base::TimeDelta::FromMilliseconds(500);
 
   std::ostringstream oss;
   if (last_write_time_.is_null()) {
     // This is the first time Write is called.
     base::TimeDelta interval = base::Time::Now() - creation_time_;
@@ skipping 11 matching lines @@
     MediaStreamManager::SendMessageToNativeLog(oss.str());
 
   last_write_time_ = base::Time::Now();
 #endif
 
   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 = size;
+  buffer->params.size = params_.GetBytesPerBuffer();
   buffer->params.key_pressed = key_pressed;
-  memcpy(buffer->audio, data, size);
-
+  data->ToInterleaved(data->frames(), params_.bits_per_sample() / 8,

[henrika (OOO until Aug 14), 2014/06/03 14:43:51]

Can we do something here to prevent what is done currently:

Native (interleaved) -> FromInterleaved to AudioBus -> ToInterleaved -> Shared
Memory -> FromInterleaved to AudioBus

[DaleCurtis, 2014/06/03 21:03:06]

Just use AudioBus::WrapMemory() and size the shared memory appropriately: N *
(AudioBus::CalculateMemorySize() + sizeof(AudioInputBuffer)) where N == number
of segments.  You'll still need at least a CopyTo() with this model, which I
think is fine.

You could go further, but it'd be a bit difficult and weird.  Essentially you'd
need to have the AudioSyncWriter construct the AudioBus using WrapMemory() and
then hand it all the way down to the input stream.  The input stream would then
be writing directly into the shared memory itself.

[henrika (OOO until Aug 14), 2014/06/04 07:50:22]

Thanks Dale! I will use your first idea and upload new version. Really
appreciate your fast reply.

[no longer working on chromium, 2014/06/04 12:38:12]

This is a bit hard, on the input side, we create a vector of share memories
(size is [shared_memory_segment_count_]) to pass the data to the renderer, it is
because the capture callbacks can come in a row with irregular intervals and we
simply cache the data to the share memory if the renderer has not consumed it
yet.

+                      buffer->audio);
   if (++current_segment_id_ >= shared_memory_segment_count_)
     current_segment_id_ = 0;
 
-  return size;
+  return params_.GetBytesPerBuffer();
 }
 
 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(),
@@ skipping 17 matching lines @@
     base::ProcessHandle process_handle,
     base::FileDescriptor* foreign_handle) {
   foreign_handle->fd = foreign_socket_->handle();
   foreign_handle->auto_close = false;
   return (foreign_handle->fd != -1);
 }
 
 #endif
 
 }  // namespace content