[PPAPI] Pepper MediaStream API audio track implementation and example.

content/renderer/pepper/pepper_media_stream_audio_track_host.cc

Index: content/renderer/pepper/pepper_media_stream_audio_track_host.cc
diff --git a/content/renderer/pepper/pepper_media_stream_audio_track_host.cc b/content/renderer/pepper/pepper_media_stream_audio_track_host.cc
new file mode 100644
index 0000000000000000000000000000000000000000..4dc9ccfd503ebfc9bb0fb9467a250580c4fdb0a3
--- /dev/null
+++ b/content/renderer/pepper/pepper_media_stream_audio_track_host.cc
@@ -0,0 +1,166 @@
+// Copyright (c) 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 "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_frame.h"
+#include "ppapi/shared_impl/media_stream_frame.h"
+
+using media::AudioParameters;
+
+namespace {
+
+// TODO(penghuang): make this configurable.
+const int32_t kNumberOfFrames = 4;
+
+}  // namespace
+
+namespace content {
+
+PepperMediaStreamAudioTrackHost::AudioSink::AudioSink(
+    PepperMediaStreamAudioTrackHost* host)
+    : host_(host),
+      frame_data_size_(0),
+      main_message_loop_proxy_(base::MessageLoopProxy::current()) {
+}
+
+PepperMediaStreamAudioTrackHost::AudioSink::~AudioSink() {
+  DCHECK_EQ(main_message_loop_proxy_, base::MessageLoopProxy::current());
+}
+
+void PepperMediaStreamAudioTrackHost::AudioSink::EnqueueFrame(int32_t index) {
+  DCHECK_EQ(main_message_loop_proxy_, base::MessageLoopProxy::current());
+  DCHECK_GE(index, 0);
+  DCHECK_LT(index, host_->frame_buffer()->number_of_frames());
+  base::AutoLock lock(lock_);
+  frames_.push_back(index);
+}
+
+void PepperMediaStreamAudioTrackHost::AudioSink::InitFramesOnMainThread(
+    int32_t number_of_frames, int32_t frame_size) {
+  DCHECK_EQ(main_message_loop_proxy_, base::MessageLoopProxy::current());
+  bool result = host_->InitFrames(number_of_frames, frame_size);
+  DCHECK(result);
+  base::AutoLock lock(lock_);
+  for (int32_t i = 0; i < number_of_frames; ++i) {
+    int32_t index = host_->frame_buffer()->DequeueFrame();
+    DCHECK_GE(index, 0);
+    frames_.push_back(index);
+  }
+}
+
+void PepperMediaStreamAudioTrackHost::AudioSink::OnData(const int16* audio_data,
+                                                        int sample_rate,
+                                                        int number_of_channels,
+                                                        int number_of_frames) {
+  DCHECK(capture_thread_checker_.CalledOnValidThread());
+  DCHECK(audio_data);
+  DCHECK_EQ(sample_rate, audio_params_.sample_rate());
+  DCHECK_EQ(number_of_channels, audio_params_.channels());
+  DCHECK_EQ(number_of_frames, audio_params_.frames_per_buffer());
+  int32_t index = -1;
+  {
+    base::AutoLock lock(lock_);
+    if (!frames_.empty()) {
+      index = frames_.front();
+      frames_.pop_front();
+    }
+  }
+
+  if (index != -1) {
+    // TODO(penghuang): support re-sampling, etc.
+    ppapi::MediaStreamFrame::Audio* frame =
+        &(host_->frame_buffer()->GetFramePointer(index)->audio);
+    frame->header.size = host_->frame_buffer()->frame_size();
+    frame->header.type = ppapi::MediaStreamFrame::TYPE_AUDIO;
+    frame->timestamp = timestamp_.InMillisecondsF();
+    frame->sample_rate = static_cast<PP_AudioFrame_SampleRate>(sample_rate);
+    frame->number_of_channels = number_of_channels;
+    frame->number_of_samples = number_of_channels * number_of_frames;
+    frame->data_size = frame_data_size_;
+    memcpy(frame->data, audio_data, frame_data_size_);

[yzshen1, 2014/02/03 18:14:36]

Can we check that |frame->data| is big enough to store the data of size
|frame_data_size_|? We need to fail gracefully or die directly. DCHECK on line
50 is not sufficient.

(Do we need to also check whether |audio_data| has that much data?)

[Peng, 2014/02/03 19:21:08]

Add DCHECK_GE(host_->frame_buffer()->frame_size(), frame_size) in
InitFramesOnMainThread().
Done

+
+    // This function is called from the audio thread, but

[yzshen1, 2014/02/03 18:14:36]

We cannot assume SendEnqueueFrameMessageToPlugin() is thread safe.
For example, we don't guarantee that the IPC::Sender interface that PpapiHost
uses is thread safe.
The current impl "happens to" be safe doesn't mean we can rely on it, IMO. If we
want to go down this direction, we need to make it explicit and formally
supported.

I cannot think up a better way than asking the main thread to do the send. :/

[Peng, 2014/02/03 19:21:08]

Done.

+    // |SendEnqueueFrameMessageToPlugin()| doesn't use any sync IPC,
+    // so it is safe to call it from the audio thread directly.
+    host_->SendEnqueueFrameMessageToPlugin(index);
+  }
+  timestamp_ += frame_duration_;
+}
+
+void PepperMediaStreamAudioTrackHost::AudioSink::OnSetFormat(
+    const AudioParameters& params) {
+  DCHECK(!audio_params_.IsValid());
+  DCHECK(params.IsValid());
+  DCHECK_EQ(params.bits_per_sample(), 16);
+  DCHECK((params.sample_rate() == AudioParameters::kTelephoneSampleRate) ||
+         (params.sample_rate() == AudioParameters::kAudioCDSampleRate));
+
+  COMPILE_ASSERT(AudioParameters::kTelephoneSampleRate == 8000,
+                 audio_sample_rate_does_not_match);
+  COMPILE_ASSERT(AudioParameters::kAudioCDSampleRate == 44100,
+                 audio_sample_rate_does_not_match);
+
+  capture_thread_checker_.DetachFromThread();
+
+  // TODO(penghuang): support setting format more than once.
+  audio_params_ = params;
+  frame_duration_ = audio_params_.GetBufferDuration();
+  frame_data_size_ = audio_params_.GetBytesPerBuffer();
+
+  // The size is slightly bigger than necessary, because 8 extra bytes are added
+  // into the struct. Also see |MediaStreamFrame|.
+  size_t size = sizeof(ppapi::MediaStreamFrame::Audio) + frame_data_size_;
+
+  // This function is called from the audio thread and |InitFrames()| uses some
+  // sync IPC. So we have to call |InitFrames()| from the main thread.
+  main_message_loop_proxy_->PostTask(
+      FROM_HERE,
+      base::Bind(&AudioSink::InitFramesOnMainThread,
+                 AsWeakPtr(), kNumberOfFrames, static_cast<int32_t>(size)));
+}
+
+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();
+}
+
+void PepperMediaStreamAudioTrackHost::OnClose() {
+  if (connected_) {
+    MediaStreamAudioSink::RemoveFromAudioTrack(&audio_sink_, track_);
+    connected_ = false;
+  }
+}
+
+void PepperMediaStreamAudioTrackHost::OnNewFrameEnqueued() {
+  int32_t index = frame_buffer()->DequeueFrame();
+  DCHECK_GE(index, 0);
+  audio_sink_.EnqueueFrame(index);
+}
+
+void PepperMediaStreamAudioTrackHost::DidConnectPendingHostToResource() {
+  if (!connected_) {
+    MediaStreamAudioSink::AddToAudioTrack(&audio_sink_, track_);
+    connected_ = true;
+  }
+}
+
+}  // namespace content