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

content/renderer/pepper/pepper_media_stream_audio_track_host.cc

+// 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 {
+
+const uint32_t kMaxNumbferOfFrames = 64u;
+// TODO(penghuang): make it configurable.

[bbudge, 2014/01/31 20:29:35]

s/it/this

[Peng, 2014/01/31 21:09:25]

Done.

+const int32_t kNumberOfFrames = 4;
+
+}  // namespace
+
+namespace content {
+
+PepperMediaStreamAudioTrackHost::AudioSink::AudioSink(
+    PepperMediaStreamAudioTrackHost* host)
+    : host_(host),
+      frame_data_size_(0),
+      frames_(0ll),

[bbudge, 2014/01/31 20:29:35]

This is confusing at first. Can we use 0LL?

[Peng, 2014/01/31 21:09:25]

Done.

+      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());
+  DCHECK(!(base::subtle::NoBarrier_Load(&frames_) & (1 << index)));
+
+  // Set the bit for the frame index. Automic does not support and/or

[bbudge, 2014/01/31 20:29:35]

s/Automic/Atomic

[Peng, 2014/01/31 21:09:25]

Done.

+  // operations, so we use add/sub instead.
+  base::subtle::NoBarrier_AtomicIncrement(&frames_, 1 << index);

[bbudge, 2014/01/31 20:29:35]

Using AtomicIncrement here makes me nervous, since if the bit is already set
somehow, we'd get a carry that could potentially propagate through several
frames. Even if this is correct, it is hard to understand, leading to bugs if
other developers change the code.

If you really want to use atomics, it might be better to use
NoBarrier_CompareAndSwap.

However, I agree with Yuzhu (and now David) that lock would be so much easier to
understand, and very fast if there is no contention, which seems likely.

[Peng, 2014/01/31 21:09:25]

Fixed by using base::Lock

+}
+
+void PepperMediaStreamAudioTrackHost::AudioSink::InitFramesOnMainThread(
+    uint32_t number_of_frames, uint32_t frame_size) {
+  DCHECK_LE(number_of_frames, kMaxNumbferOfFrames);
+  bool result = host_->InitFrames(number_of_frames, frame_size);
+  DCHECK(result);
+  for (uint32_t i = 0; i < number_of_frames; ++i) {
+    int32_t index = host_->frame_buffer()->DequeueFrame();
+    DCHECK_GE(index, 0);
+  }
+
+  base::subtle::Atomic64 frames = base::subtle::NoBarrier_CompareAndSwap(
+      &frames_, 0ll, (1ll << number_of_frames) - 1ll);
+  DCHECK(!frames);
+}
+
+void PepperMediaStreamAudioTrackHost::AudioSink::OnData(const int16* audio_data,
+                                                        int sample_rate,
+                                                        int number_of_channels,
+                                                        int number_of_frames) {
+  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());
+
+  base::subtle::Atomic64 frames = base::subtle::NoBarrier_Load(&frames_);
+  if (frames) {
+    // If frames isn't zero, the |frame_buffer()| should be initialized already,
+    // and |frame_buffer()|'s attributes (|number_of_frames()|, |frame_size()|,
+    // etc) will not be changed. So it is safe to read them in the audio thread.
+    int32_t index = 0;
+    int32_t n = host_->frame_buffer()->number_of_frames();
+
+    // Find a free frame.
+    while(index < n && !(frames & (1 << index)))
+      index++;
+
+    if (index < n) {
+      // 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_);
+
+      // Clear the bit for the frame index. Automic does not support and/or
+      // operations, so we use add/sub instead.
+      base::subtle::NoBarrier_AtomicIncrement(&frames_, -(1ll << index));
+
+      // This function is called from the audio thread, but
+      // |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);
+
+  // 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|.
+  int32_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, 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