Support for remote audio into tracks

talk/app/webrtc/remoteaudiosource.cc

 /*
  * libjingle
  * Copyright 2014 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 12 matching lines @@
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "talk/app/webrtc/remoteaudiosource.h"
 
 #include <algorithm>
 #include <functional>
 
+#include "talk/app/webrtc/mediastreamprovider.h"
+#include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
+#include "webrtc/base/thread.h"
 
 namespace webrtc {
 
-rtc::scoped_refptr<RemoteAudioSource> RemoteAudioSource::Create() {
-  return new rtc::RefCountedObject<RemoteAudioSource>();
+class RemoteAudioSource::MessageHandler : public rtc::MessageHandler {
+ public:
+  MessageHandler(RemoteAudioSource* source) : source_(source) {}
+
+ private:
+  ~MessageHandler() override {}
+
+  void OnMessage(rtc::Message* msg) override {
+    source_->OnMessage(msg);
+    delete this;
+  }
+
+  const rtc::scoped_refptr<RemoteAudioSource> source_;
+  RTC_DISALLOW_COPY_AND_ASSIGN(MessageHandler);
+};
+
+rtc::scoped_refptr<RemoteAudioSource> RemoteAudioSource::Create(
+    uint32_t ssrc,
+    AudioProviderInterface* provider) {
+  return new rtc::RefCountedObject<RemoteAudioSource>(ssrc, provider);
 }
 
-RemoteAudioSource::RemoteAudioSource() {
+RemoteAudioSource::RemoteAudioSource(uint32_t ssrc,
+                                     AudioProviderInterface* provider)
+    : ssrc_(ssrc), provider_(provider), main_thread_(rtc::Thread::Current()),
+      state_(MediaSourceInterface::kLive) {
+  RTC_DCHECK(provider_);
+  RTC_DCHECK(main_thread_);
 }
 
 RemoteAudioSource::~RemoteAudioSource() {
-  ASSERT(audio_observers_.empty());
+  RTC_DCHECK(main_thread_->IsCurrent());
+  RTC_DCHECK(audio_observers_.empty());
+  RTC_DCHECK(sinks_.empty());
 }
 
 MediaSourceInterface::SourceState RemoteAudioSource::state() const {
-  return MediaSourceInterface::kLive;
+  return state_;
 }
 
 void RemoteAudioSource::SetVolume(double volume) {
-  ASSERT(volume >= 0 && volume <= 10);
-  for (AudioObserverList::iterator it = audio_observers_.begin();
-       it != audio_observers_.end(); ++it) {
-    (*it)->OnSetVolume(volume);
+  RTC_DCHECK(volume >= 0 && volume <= 10);
+  for (auto* observer : audio_observers_) {
+    observer->OnSetVolume(volume);
   }
 }
 
 void RemoteAudioSource::RegisterAudioObserver(AudioObserver* observer) {
-  ASSERT(observer != NULL);
-  ASSERT(std::find(audio_observers_.begin(), audio_observers_.end(),
+  RTC_DCHECK(observer != NULL);
+  RTC_DCHECK(std::find(audio_observers_.begin(), audio_observers_.end(),
                    observer) == audio_observers_.end());
   audio_observers_.push_back(observer);
 }
 
 void RemoteAudioSource::UnregisterAudioObserver(AudioObserver* observer) {
-  ASSERT(observer != NULL);
+  RTC_DCHECK(observer != NULL);
   audio_observers_.remove(observer);
 }
 
+void RemoteAudioSource::AddSink(AudioTrackSinkInterface* sink) {
+  RTC_DCHECK(main_thread_->IsCurrent());
+  RTC_DCHECK(sink);
+  RTC_DCHECK(state_ == MediaSourceInterface::kLive);
+
+  if (!provider_) {
+    LOG(LS_ERROR) << "No audio provider, so can't set an audio sink.";
+    return;
+  }
+
+  if (sinks_.empty())
+    provider_->SetRawAudioSink(ssrc_, this);
+
+  rtc::CritScope lock(&sink_lock_);
+  RTC_DCHECK(std::find(sinks_.begin(), sinks_.end(), sink) == sinks_.end());
+  sinks_.push_back(sink);
+}
+
+void RemoteAudioSource::RemoveSink(AudioTrackSinkInterface* sink) {
+  RTC_DCHECK(main_thread_->IsCurrent());
+  RTC_DCHECK(sink);
+  {
+    rtc::CritScope lock(&sink_lock_);
+    sinks_.remove(sink);
+  }
+
+  if (sinks_.empty() && provider_)
+    provider_->SetRawAudioSink(ssrc_, nullptr);
+}
+
+void RemoteAudioSource::OnData(const void* audio_data,
+                               int bits_per_sample,
+                               int sample_rate,
+                               int number_of_channels,
+                               size_t number_of_frames) {
+  // Called on the externally-owned audio callback thread, via/from webrtc.
+  rtc::CritScope lock(&sink_lock_);
+  for (auto* sink : sinks_) {
+    sink->OnData(audio_data, bits_per_sample, sample_rate, number_of_channels,
+                 number_of_frames);
+  }
+}
+
+void RemoteAudioSource::OnClose() {

[perkj_webrtc, 2015/12/10 12:24:05]

What triggers this?

[tommi, 2015/12/10 22:37:25]

Deletion of the session.  It tears down the voice channels which tears down
sinks to the channels, which deletes the sink that sits between this place and
the channel, which calls OnClose on destruction.  Happens on libjingle's worker
thread.

+  main_thread_->Post(new MessageHandler(this));

[perkj_webrtc, 2015/12/10 12:24:05]

use async_invoker instead. You don't need the MessageHandler since
RemoteAudioSource is also ref counted.

[tommi, 2015/12/10 22:37:25]

I started doing that but I'm hesitating.  Have you seen how much code that is
(even without the Bind() dependency)?  If we need more advanced message passing,
I think we could add an async invoker member variable, but as is, I think it's
overkill.

Regarding the RemoteAudioSource being ref counted, yes I know...  Perhaps the
name of this class is confusing.  This is RemoteAudioSource::MessageHandler, not
the MessageHandler interface.  See at the top of this file.

+}
+
+void RemoteAudioSource::OnMessage(rtc::Message* msg) {
+  RTC_DCHECK(main_thread_->IsCurrent());
+  provider_ = nullptr;
+  sinks_.clear();
+  state_ = MediaSourceInterface::kEnded;
+  FireOnChanged();
+}
+
 }  // namespace webrtc