Add WebrtcAudioModule

remoting/protocol/webrtc_audio_module.cc

+// Copyright 2016 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 "remoting/protocol/webrtc_audio_module.h"
+
+#include "base/bind.h"
+#include "base/stl_util.h"
+#include "base/threading/thread_task_runner_handle.h"
+
+namespace remoting {
+namespace protocol {
+
+namespace {

[nicholss, 2016/10/04 21:42:00]

Is the plan to finish implementing the reset of these functions at a later date?

[Sergey Ulanov, 2016/10/04 22:32:32]

Nope. The only reason we need this class is to call
audio_transport_->PullRenderData() regularly. Otherwise audio streams can be
send/received through AudioTrackSinkInterface.

+
+const int kSamplingRate = 48000;
+
+// Webrtc uses 10ms frames.
+const int kFrameLengthMs = 10;
+const int kSamplesPerFrame = kSamplingRate * kFrameLengthMs / 1000;
+
+constexpr base::TimeDelta kPollInterval =
+    base::TimeDelta::FromMilliseconds(5 * kFrameLengthMs);
+const int kChannels = 2;
+const int kBytesPerSample = 2;
+
+}  // namespace
+
+WebrtcAudioModule::WebrtcAudioModule() {}
+WebrtcAudioModule::~WebrtcAudioModule() {}
+
+void WebrtcAudioModule::Initialize(
+    scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner) {
+  DCHECK(!audio_task_runner_);
+  DCHECK(audio_task_runner);
+  audio_task_runner_ = audio_task_runner;
+}
+
+int64_t WebrtcAudioModule::TimeUntilNextProcess() {
+  // We don't need to do anything in Process(), so returning just an arbitrary
+  // value that's not too low, so that Process() doesn't get called too
+  // frequently.
+  return 1000000;
+}
+
+void WebrtcAudioModule::Process() {}
+
+int32_t WebrtcAudioModule::ActiveAudioLayer(AudioLayer* audio_layer) const {
+  NOTREACHED();
+  return -1;
+}
+
+WebrtcAudioModule::ErrorCode WebrtcAudioModule::LastError() const {
+  return kAdmErrNone;
+}
+
+int32_t WebrtcAudioModule::RegisterEventObserver(
+    webrtc::AudioDeviceObserver* event_callback) {
+  return 0;
+}
+
+int32_t WebrtcAudioModule::RegisterAudioCallback(
+    webrtc::AudioTransport* audio_transport) {
+  base::AutoLock lock(lock_);
+  audio_transport_ = audio_transport;
+  return 0;
+}
+
+int32_t WebrtcAudioModule::Init() {
+  base::AutoLock auto_lock(lock_);
+  initialized_ = true;
+  return 0;
+}
+
+int32_t WebrtcAudioModule::Terminate() {
+  base::AutoLock auto_lock(lock_);
+  initialized_ = false;
+  return 0;
+}
+
+bool WebrtcAudioModule::Initialized() const {
+  base::AutoLock auto_lock(lock_);
+  return initialized_;
+}
+
+int16_t WebrtcAudioModule::PlayoutDevices() {
+  return 0;
+}
+
+int16_t WebrtcAudioModule::RecordingDevices() {
+  return 0;
+}
+
+int32_t WebrtcAudioModule::PlayoutDeviceName(
+    uint16_t index,
+    char name[webrtc::kAdmMaxDeviceNameSize],
+    char guid[webrtc::kAdmMaxGuidSize]) {
+  return 0;
+}
+
+int32_t WebrtcAudioModule::RecordingDeviceName(
+    uint16_t index,
+    char name[webrtc::kAdmMaxDeviceNameSize],
+    char guid[webrtc::kAdmMaxGuidSize]) {
+  return 0;
+}
+
+int32_t WebrtcAudioModule::SetPlayoutDevice(uint16_t index) {
+  return 0;
+}
+
+int32_t WebrtcAudioModule::SetPlayoutDevice(WindowsDeviceType device) {
+  return 0;
+}
+
+int32_t WebrtcAudioModule::SetRecordingDevice(uint16_t index) {
+  return 0;
+}
+
+int32_t WebrtcAudioModule::SetRecordingDevice(WindowsDeviceType device) {
+  return 0;
+}
+
+int32_t WebrtcAudioModule::PlayoutIsAvailable(bool* available) {
+  base::AutoLock auto_lock(lock_);
+  *available = initialized_;

[nicholss, 2016/10/04 21:42:00]

Is this call intended to be a buffer check? PlayoutIsAvailable seems to be
asking if there is data ready to be played, not just if the module has been
initialized. I could be wrong, I have been looking for webrtc docs but have not
found anything on this function.

[Sergey Ulanov, 2016/10/04 22:32:32]

I assume the intended use of this method is to detect when there are audio
playback devices available. Overall this interface is very badly designed and
it's not documented properly. This logic was copied from
content/renderer/media/webrtc_audio_device_impl.cc (implementation used by
chrome), but it looks like it's not really necessary. This method is never
called. Added NOTREACHED() here.

+  return 0;
+}
+
+int32_t WebrtcAudioModule::InitPlayout() {
+  return 0;
+}
+
+bool WebrtcAudioModule::PlayoutIsInitialized() const {
+  base::AutoLock auto_lock(lock_);
+  return initialized_;
+}
+
+int32_t WebrtcAudioModule::RecordingIsAvailable(bool* available) {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::InitRecording() {
+  return 0;
+}
+
+bool WebrtcAudioModule::RecordingIsInitialized() const {
+  return false;
+}
+
+int32_t WebrtcAudioModule::StartPlayout() {
+  base::AutoLock auto_lock(lock_);
+  if (!playing_ && audio_task_runner_) {
+    audio_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&WebrtcAudioModule::StartPlayoutOnAudioThread, this));
+    playing_ = true;
+  }
+  return 0;
+}
+
+int32_t WebrtcAudioModule::StopPlayout() {
+  base::AutoLock auto_lock(lock_);
+  if (playing_) {
+    audio_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&WebrtcAudioModule::StopPlayoutOnAudioThread, this));
+    playing_ = false;
+  }
+  return 0;
+}
+
+bool WebrtcAudioModule::Playing() const {
+  base::AutoLock auto_lock(lock_);
+  return playing_;
+}
+
+int32_t WebrtcAudioModule::StartRecording() {
+  return 0;
+}
+
+int32_t WebrtcAudioModule::StopRecording() {
+  return 0;
+}
+
+bool WebrtcAudioModule::Recording() const {
+  return false;
+}
+
+int32_t WebrtcAudioModule::SetAGC(bool enable) {
+  return 0;
+}
+
+bool WebrtcAudioModule::AGC() const {
+  NOTREACHED();
+  return false;
+}
+
+int32_t WebrtcAudioModule::SetWaveOutVolume(uint16_t volume_left,
+                                            uint16_t volume_right) {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::WaveOutVolume(uint16_t* volume_left,
+                                         uint16_t* volume_right) const {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::InitSpeaker() {
+  return 0;
+}
+
+bool WebrtcAudioModule::SpeakerIsInitialized() const {
+  return false;
+}
+
+int32_t WebrtcAudioModule::InitMicrophone() {
+  return 0;
+}
+
+bool WebrtcAudioModule::MicrophoneIsInitialized() const {
+  return false;
+}
+
+int32_t WebrtcAudioModule::SpeakerVolumeIsAvailable(bool* available) {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::SetSpeakerVolume(uint32_t volume) {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::SpeakerVolume(uint32_t* volume) const {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::MaxSpeakerVolume(uint32_t* max_volume) const {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::MinSpeakerVolume(uint32_t* min_volume) const {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::SpeakerVolumeStepSize(uint16_t* step_size) const {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::MicrophoneVolumeIsAvailable(bool* available) {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::SetMicrophoneVolume(uint32_t volume) {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::MicrophoneVolume(uint32_t* volume) const {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::MaxMicrophoneVolume(uint32_t* max_volume) const {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::MinMicrophoneVolume(uint32_t* min_volume) const {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::MicrophoneVolumeStepSize(uint16_t* step_size) const {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::SpeakerMuteIsAvailable(bool* available) {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::SetSpeakerMute(bool enable) {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::SpeakerMute(bool* enabled) const {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::MicrophoneMuteIsAvailable(bool* available) {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::SetMicrophoneMute(bool enable) {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::MicrophoneMute(bool* enabled) const {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::MicrophoneBoostIsAvailable(bool* available) {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::SetMicrophoneBoost(bool enable) {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::MicrophoneBoost(bool* enabled) const {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::StereoPlayoutIsAvailable(bool* available) const {
+  *available = true;
+  return 0;
+}
+
+int32_t WebrtcAudioModule::SetStereoPlayout(bool enable) {
+  DCHECK(enable);
+  return 0;
+}
+
+int32_t WebrtcAudioModule::StereoPlayout(bool* enabled) const {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::StereoRecordingIsAvailable(bool* available) const {
+  *available = false;
+  return 0;
+}
+
+int32_t WebrtcAudioModule::SetStereoRecording(bool enable) {
+  return 0;
+}
+
+int32_t WebrtcAudioModule::StereoRecording(bool* enabled) const {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::SetRecordingChannel(const ChannelType channel) {
+  return 0;
+}
+
+int32_t WebrtcAudioModule::RecordingChannel(ChannelType* channel) const {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::SetPlayoutBuffer(const BufferType type,
+                                            uint16_t size_ms) {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::PlayoutBuffer(BufferType* type,
+                                         uint16_t* size_ms) const {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::PlayoutDelay(uint16_t* delay_ms) const {
+  *delay_ms = 0;
+  return 0;
+}
+
+int32_t WebrtcAudioModule::RecordingDelay(uint16_t* delay_ms) const {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::CPULoad(uint16_t* load) const {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::StartRawOutputFileRecording(
+    const char pcm_file_name_utf8[webrtc::kAdmMaxFileNameSize]) {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::StopRawOutputFileRecording() {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::StartRawInputFileRecording(
+    const char pcm_file_name_utf8[webrtc::kAdmMaxFileNameSize]) {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::StopRawInputFileRecording() {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::SetRecordingSampleRate(
+    const uint32_t samples_per_sec) {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::RecordingSampleRate(
+    uint32_t* samples_per_sec) const {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::SetPlayoutSampleRate(
+    const uint32_t samples_per_sec) {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::PlayoutSampleRate(uint32_t* samples_per_sec) const {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::ResetAudioDevice() {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::SetLoudspeakerStatus(bool enable) {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::GetLoudspeakerStatus(bool* enabled) const {
+  NOTREACHED();
+  return -1;
+}
+
+bool WebrtcAudioModule::BuiltInAECIsAvailable() const {
+  return false;
+}
+
+bool WebrtcAudioModule::BuiltInAGCIsAvailable() const {
+  return false;
+}
+
+bool WebrtcAudioModule::BuiltInNSIsAvailable() const {
+  return false;
+}
+
+int32_t WebrtcAudioModule::EnableBuiltInAEC(bool enable) {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::EnableBuiltInAGC(bool enable) {
+  NOTREACHED();
+  return -1;
+}
+
+int32_t WebrtcAudioModule::EnableBuiltInNS(bool enable) {
+  NOTREACHED();
+  return -1;
+}
+
+#if defined(WEBRTC_IOS)
+int WebrtcAudioModule::GetPlayoutAudioParameters(
+    AudioParameters* params) const {
+  NOTREACHED();
+  return -1;
+}
+
+int WebrtcAudioModule::GetRecordAudioParameters(AudioParameters* params) const {
+}
+#endif  // WEBRTC_IOS
+
+void WebrtcAudioModule::StartPlayoutOnAudioThread() {
+  DCHECK(audio_task_runner_->BelongsToCurrentThread());
+  poll_timer_.Start(
+      FROM_HERE, kPollInterval,
+      base::Bind(&WebrtcAudioModule::PollFromSource, base::Unretained(this)));
+}
+
+void WebrtcAudioModule::StopPlayoutOnAudioThread() {
+  DCHECK(audio_task_runner_->BelongsToCurrentThread());
+  poll_timer_.Stop();
+}
+
+void WebrtcAudioModule::PollFromSource() {
+  DCHECK(audio_task_runner_->BelongsToCurrentThread());
+
+  base::AutoLock lock(lock_);
+  if (!audio_transport_)
+    return;
+
+  for (int i = 0; i < kPollInterval.InMilliseconds() / kFrameLengthMs; i++) {
+    int64_t elapsed_time_ms = -1;
+    int64_t ntp_time_ms = -1;
+    char data[kBytesPerSample * kChannels * kSamplesPerFrame];
+    audio_transport_->PullRenderData(kBytesPerSample * 8, kSamplingRate,
+                                     kChannels, kSamplesPerFrame, data,
+                                     &elapsed_time_ms, &ntp_time_ms);
+  }
+}
+
+}  // namespace protocol
+}  // namespace remoting