Support configuring number of audio buffers in MediaStream Pepper API.

content/renderer/pepper/pepper_media_stream_audio_track_host.cc

 // Copyright 2014 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/renderer/pepper/pepper_media_stream_audio_track_host.h"
 
+#include <algorithm>
+
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_audio_buffer.h"
+#include "ppapi/host/dispatch_host_message.h"
+#include "ppapi/host/host_message_context.h"
+#include "ppapi/proxy/ppapi_messages.h"
+#include "ppapi/shared_impl/media_stream_audio_track_shared.h"
 #include "ppapi/shared_impl/media_stream_buffer.h"
 
 using media::AudioParameters;
+using ppapi::host::HostMessageContext;
+using ppapi::MediaStreamAudioTrackShared;
 
 namespace {
 
 // Max audio buffer duration in milliseconds.
 const uint32_t kMaxDuration = 10;
 
-// TODO(penghuang): make this configurable.
-const int32_t kNumberOfBuffers = 4;
+const int32_t kDefaultNumberOfBuffers = 4;
+const int32_t kMaxNumberOfBuffers = 1000;  // 10 sec
 
 // Returns true if the |sample_rate| is supported in
 // |PP_AudioBuffer_SampleRate|, otherwise false.
 PP_AudioBuffer_SampleRate GetPPSampleRate(int sample_rate) {
   switch (sample_rate) {
     case 8000:
       return PP_AUDIOBUFFER_SAMPLERATE_8000;
     case 16000:
       return PP_AUDIOBUFFER_SAMPLERATE_16000;
     case 22050:
@@ skipping 15 matching lines @@
 
 }  // namespace
 
 namespace content {
 
 PepperMediaStreamAudioTrackHost::AudioSink::AudioSink(
     PepperMediaStreamAudioTrackHost* host)
     : host_(host),
       buffer_data_size_(0),
       main_message_loop_proxy_(base::MessageLoopProxy::current()),
-      weak_factory_(this) {}
+      weak_factory_(this),
+      number_of_buffers_(kDefaultNumberOfBuffers),
+      bytes_per_second_(0) {}
 
 PepperMediaStreamAudioTrackHost::AudioSink::~AudioSink() {
   DCHECK_EQ(main_message_loop_proxy_, base::MessageLoopProxy::current());
 }
 
 void PepperMediaStreamAudioTrackHost::AudioSink::EnqueueBuffer(int32_t index) {
   DCHECK_EQ(main_message_loop_proxy_, base::MessageLoopProxy::current());
   DCHECK_GE(index, 0);
   DCHECK_LT(index, host_->buffer_manager()->number_of_buffers());
   base::AutoLock lock(lock_);
   buffers_.push_back(index);
 }
 
-void PepperMediaStreamAudioTrackHost::AudioSink::InitBuffersOnMainThread(
-    int32_t number_of_buffers,
-    int32_t buffer_size) {
+void PepperMediaStreamAudioTrackHost::AudioSink::Configure(
+    int32_t number_of_buffers) {
   DCHECK_EQ(main_message_loop_proxy_, base::MessageLoopProxy::current());
-  bool result = host_->InitBuffers(number_of_buffers, buffer_size, kRead);
+  bool changed;
+  if (number_of_buffers != number_of_buffers_)
+    changed = true;
+  number_of_buffers_ = number_of_buffers;
+
+  // Initialize later in OnSetFormat if bytes_per_second_ is not know yet.
+  if (changed && bytes_per_second_ > 0)
+    InitBuffers();
+}
+
+void PepperMediaStreamAudioTrackHost::AudioSink::SetFormatOnMainThread(
+    int bytes_per_second) {
+  bytes_per_second_ = bytes_per_second;
+  InitBuffers();
+}
+
+void PepperMediaStreamAudioTrackHost::AudioSink::InitBuffers() {
+  DCHECK_EQ(main_message_loop_proxy_, base::MessageLoopProxy::current());
+  // The size is slightly bigger than necessary, because 8 extra bytes are
+  // added into the struct. Also see |MediaStreamBuffer|.
+  size_t buffer_size = sizeof(ppapi::MediaStreamBuffer::Audio) +
+      bytes_per_second_ * kMaxDuration / base::Time::kMillisecondsPerSecond;
+  bool result = host_->InitBuffers(number_of_buffers_,
+                                   static_cast<int32_t>(buffer_size),

[dcheng, 2014/05/28 15:55:44]

Will we need to be concerned about overflow in these calculations in the future?

[thembrown, 2014/05/28 17:13:11]

Hm - with audio @192kHz, 16Bit, 10ch bytes_per_second_ would be 38.4M, so I
guess larger values of kMaxDuration could overflow a 32bit size_t in this
calculation.
However the calculation not have changed. I think currently with kMaxDuration=10
it should not be safe.

[dcheng, 2014/05/28 17:21:06]

We use bytes per second though, not bits.

So it's 192KHz * 2 bytes per sample * 32 channels (according to the max channel
limits) = 12,880,000 bytes per second.

Combined with a max duration of 10 msec, that means each buffer is at most
122,800 bytes long. With a max of 1000 buffers, we're still short of overflowing
int32_t. My concern is for when this code is updated in the future to increase
bytes per sample/sample rate/number of channels/max buffer duration/etc though.

[thembrown, 2014/05/28 19:09:54]

I was concerned about the intermediate result of (bytes_per_second *
kMaxDuration), still safe though. 
What do you suggest to avoid possible overflows introduced by future changes?
Add a comment to kMaxDuration? Use int64_t to do the calculation and CHECK the
size of the result? I'm not sure what's appropriate.

+                                   kRead);
   // TODO(penghuang): Send PP_ERROR_NOMEMORY to plugin.
   CHECK(result);
   base::AutoLock lock(lock_);
-  for (int32_t i = 0; i < number_of_buffers; ++i) {
+  buffers_.clear();
+  for (int32_t i = 0; i < number_of_buffers_; ++i) {
     int32_t index = host_->buffer_manager()->DequeueBuffer();
     DCHECK_GE(index, 0);
     buffers_.push_back(index);
   }
 }
 
 void PepperMediaStreamAudioTrackHost::AudioSink::
     SendEnqueueBufferMessageOnMainThread(int32_t index) {
   DCHECK_EQ(main_message_loop_proxy_, base::MessageLoopProxy::current());
   host_->SendEnqueueBufferMessageToPlugin(index);
@@ skipping 54 matching lines @@
   buffer_data_size_ = params.GetBytesPerBuffer();
 
   if (original_audio_params_.IsValid()) {
     DCHECK_EQ(params.sample_rate(), original_audio_params_.sample_rate());
     DCHECK_EQ(params.bits_per_sample(),
               original_audio_params_.bits_per_sample());
     DCHECK_EQ(params.channels(), original_audio_params_.channels());
   } else {
     audio_thread_checker_.DetachFromThread();
     original_audio_params_ = params;
-    // The size is slightly bigger than necessary, because 8 extra bytes are
-    // added into the struct. Also see |MediaStreamBuffer|.
-    size_t max_data_size = params.sample_rate() * params.bits_per_sample() / 8 *
-                           params.channels() * kMaxDuration / 1000;
-    size_t size = sizeof(ppapi::MediaStreamBuffer::Audio) + max_data_size;
 
     main_message_loop_proxy_->PostTask(
         FROM_HERE,
-        base::Bind(&AudioSink::InitBuffersOnMainThread,
+        base::Bind(&AudioSink::SetFormatOnMainThread,
                    weak_factory_.GetWeakPtr(),
-                   kNumberOfBuffers,
-                   static_cast<int32_t>(size)));
+                   params.GetBytesPerSecond()));
   }
 }
 
 PepperMediaStreamAudioTrackHost::PepperMediaStreamAudioTrackHost(
     RendererPpapiHost* host,
     PP_Instance instance,
     PP_Resource resource,
     const blink::WebMediaStreamTrack& track)
     : PepperMediaStreamTrackHostBase(host, instance, resource),
       track_(track),
       connected_(false),
       audio_sink_(this) {
   DCHECK(!track_.isNull());
 }
 
 PepperMediaStreamAudioTrackHost::~PepperMediaStreamAudioTrackHost() {
   OnClose();
 }
 
+int32_t PepperMediaStreamAudioTrackHost::OnResourceMessageReceived(
+    const IPC::Message& msg,
+    HostMessageContext* context) {
+  PPAPI_BEGIN_MESSAGE_MAP(PepperMediaStreamAudioTrackHost, msg)
+    PPAPI_DISPATCH_HOST_RESOURCE_CALL(
+        PpapiHostMsg_MediaStreamAudioTrack_Configure, OnHostMsgConfigure)
+  PPAPI_END_MESSAGE_MAP()
+  return PepperMediaStreamTrackHostBase::OnResourceMessageReceived(msg,
+                                                                   context);
+}
+
+int32_t PepperMediaStreamAudioTrackHost::OnHostMsgConfigure(
+    HostMessageContext* context,
+    const MediaStreamAudioTrackShared::Attributes& attributes) {
+  if (!MediaStreamAudioTrackShared::VerifyAttributes(attributes))
+    return PP_ERROR_BADARGUMENT;
+
+  int32_t buffers = attributes.buffers
+                        ? std::min(kMaxNumberOfBuffers, attributes.buffers)
+                        : kDefaultNumberOfBuffers;
+  audio_sink_.Configure(buffers);
+
+  context->reply_msg = PpapiPluginMsg_MediaStreamAudioTrack_ConfigureReply();
+  return PP_OK;
+}
+
 void PepperMediaStreamAudioTrackHost::OnClose() {
   if (connected_) {
     MediaStreamAudioSink::RemoveFromAudioTrack(&audio_sink_, track_);
     connected_ = false;
   }
 }
 
 void PepperMediaStreamAudioTrackHost::OnNewBufferEnqueued() {
   int32_t index = buffer_manager()->DequeueBuffer();
   DCHECK_GE(index, 0);
   audio_sink_.EnqueueBuffer(index);
 }
 
 void PepperMediaStreamAudioTrackHost::DidConnectPendingHostToResource() {
   if (!connected_) {
     MediaStreamAudioSink::AddToAudioTrack(&audio_sink_, track_);
     connected_ = true;
   }
 }
 
 }  // namespace content