[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/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"
+
+namespace {
+
+// TODO(penghuang): make it configurable.
+const int32_t kNumberOfFrames = 4;
+
+}  // namespace
+
+namespace content {
+
+PepperMediaStreamAudioTrackHost::AudioSink::AudioSink(
+    PepperMediaStreamAudioTrackHost* host)
+    : host_(host),
+      frame_data_size_(0),
+      frames_(0),
+      main_message_loop_proxy_(base::MessageLoopProxy::current()) {
+}
+
+PepperMediaStreamAudioTrackHost::AudioSink::~AudioSink() {}
+
+void PepperMediaStreamAudioTrackHost::AudioSink::EnqueueFrame(int32_t index) {
+  DCHECK_GE(index, 0);
+  DCHECK_LT(index, host_->frame_buffer()->number_of_frames());
+  base::subtle::Atomic32 frames = base::subtle::NoBarrier_Load(&frames_);
+  DCHECK(!(frames & (1 << index)));
+

[bbudge, 2014/01/22 22:06:37]

I don't understand your use of atomics here. Between the NoBarrier_Load and the
NoBarrier_AtomicIncrement, it seems the value could change.

Is this method called by more than one thread? If so, it seems like it won't be
thread safe.

[Peng, 2014/01/23 01:14:22]

This method is only called from the main thread. And OnData() and OnSetFormat()
will be only called from the audio thread.

In this function, the NoBarrier_Load() is not necessary at all. Actually it is
only used for below DCHECK() for debugging only. Probably I should make them
into one line. Like:

DCHECK(!(base::subtle::NoBarrier_Load(&frames_) & (1 << index)));

+  // Set the bit for the frame index. Automic does not support and/or
+  // operations, so we use add/sub instead.
+  base::subtle::NoBarrier_AtomicIncrement(&frames_, 1 << index);
+}
+
+void PepperMediaStreamAudioTrackHost::AudioSink::InitFramesOnMainThread(
+    uint32_t number_of_frames, uint32_t frame_size) {
+  // Maybe use Atomic64 to support more frames.
+  DCHECK_LE(number_of_frames, 32u);
+  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::Atomic32 frames = base::subtle::NoBarrier_CompareAndSwap(
+      &frames_, 0, (1 << number_of_frames) - 1);
+  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::Atomic32 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_AudioSampleRate>(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_, -(1 << 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 media::AudioParameters& params) {
+  DCHECK(!audio_params_.IsValid());
+  DCHECK(params.IsValid());
+  DCHECK_EQ(params.bits_per_sample(), 16);
+
+  // 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;
+  }
+}
+
+bool PepperMediaStreamAudioTrackHost::OnNewFramePreEnqueued(int32_t index) {
+  audio_sink_.EnqueueFrame(index);
+  return true;
+}
+
+void PepperMediaStreamAudioTrackHost::DidConnectPendingHostToResource() {
+  if (!connected_) {
+    MediaStreamAudioSink::AddToAudioTrack(&audio_sink_, track_);
+    connected_ = true;
+  }
+}
+
+}  // namespace content