Support for remote audio into tracks

talk/media/webrtc/webrtcvoiceengine.cc

 /*
  * libjingle
  * Copyright 2004 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 1207 matching lines @@
     config_.rtp.remote_ssrc = remote_ssrc;
     config_.rtp.local_ssrc = local_ssrc;
     config_.voe_channel_id = ch;
     config_.sync_group = sync_group;
     RecreateAudioReceiveStream(use_combined_bwe, extensions);
   }
 
   ~WebRtcAudioReceiveStream() {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     call_->DestroyAudioReceiveStream(stream_);
+    RTC_DCHECK(!audio_callback_.get());
   }
 
   void RecreateAudioReceiveStream(
       const std::vector<webrtc::RtpExtension>& extensions) {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     RecreateAudioReceiveStream(config_.combined_audio_video_bwe, extensions);
   }
   void RecreateAudioReceiveStream(bool use_combined_bwe) {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     RecreateAudioReceiveStream(use_combined_bwe, config_.rtp.extensions);
   }
 
   webrtc::AudioReceiveStream::Stats GetStats() const {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     RTC_DCHECK(stream_);
     return stream_->GetStats();
   }
 
   int channel() const {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     return config_.voe_channel_id;
   }
 
+  void SetRawAudioSink(webrtc::VoEExternalMedia* external_media,
+                       AudioRenderer::Sink* sink) {
+    RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+    if (sink) {
+      RTC_DCHECK(!audio_callback_.get());
+      audio_callback_.reset(new AudioCallback(sink));
+      int err = external_media->RegisterExternalMediaProcessing(

[the sun, 2015/12/10 12:36:32]

Add an API on AudioReceiveStream instead: SetRawAudioSink(AudioRenderer::Sink*)
and either of:

a) Use the external media processing interface from the AudioReceiveStream
implementation. (less work for you but I'll have to clean it up later).
b) Add the appropriate call in VoE::Channel (and ChannelProxy) to take and
AudioRenderer::Sink all the way down (this is the way we want to go regardless).

+          channel(), webrtc::kPlaybackPerChannel, *audio_callback_.get());
+      if (err != 0)
+        audio_callback_.reset();
+    } else if (audio_callback_) {
+      external_media->DeRegisterExternalMediaProcessing(
+          channel(), webrtc::kPlaybackPerChannel);
+      audio_callback_.reset();
+    }
+  }
+
  private:
   void RecreateAudioReceiveStream(bool use_combined_bwe,
       const std::vector<webrtc::RtpExtension>& extensions) {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     if (stream_) {
       call_->DestroyAudioReceiveStream(stream_);
       stream_ = nullptr;
     }
     config_.rtp.extensions = extensions;
     config_.combined_audio_video_bwe = use_combined_bwe;
     RTC_DCHECK(!stream_);
     stream_ = call_->CreateAudioReceiveStream(config_);
     RTC_CHECK(stream_);
   }
 
+  class AudioCallback : public webrtc::VoEMediaProcess {
+   public:
+    explicit AudioCallback(AudioRenderer::Sink* sink) : sink_(sink) {}
+    ~AudioCallback() {
+      RTC_DCHECK(thread_checker_.CalledOnValidThread());
+      sink_->OnClose();
+    }
+
+   private:
+    // VoEMediaProcess implementation.
+    void Process(int channel,
+                 webrtc::ProcessingTypes type,
+                 int16_t audio_10ms[],
+                 size_t length,
+                 int sampling_freq,
+                 bool is_stereo) override {
+      // Called on the audio thread from webrtc.  This can be a ProcessThread
+      // belonging to WebRTC or an externally owned thread.
+      sink_->OnData(&audio_10ms[0], 16, sampling_freq, is_stereo ? 2 : 1,
+                    length);
+    }
+
+    rtc::ThreadChecker thread_checker_;
+    AudioRenderer::Sink* const sink_;
+    RTC_DISALLOW_COPY_AND_ASSIGN(AudioCallback);
+  };
+
   rtc::ThreadChecker worker_thread_checker_;
   webrtc::Call* call_ = nullptr;
   webrtc::AudioReceiveStream::Config config_;
   // The stream is owned by WebRtcAudioReceiveStream and may be reallocated if
   // configuration changes.
   webrtc::AudioReceiveStream* stream_ = nullptr;
+  rtc::scoped_ptr<AudioCallback> audio_callback_;
 
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(WebRtcAudioReceiveStream);
 };
 
 WebRtcVoiceMediaChannel::WebRtcVoiceMediaChannel(WebRtcVoiceEngine* engine,
                                                  const AudioOptions& options,
                                                  webrtc::Call* call)
     : engine_(engine), call_(call) {
   LOG(LS_VERBOSE) << "WebRtcVoiceMediaChannel::WebRtcVoiceMediaChannel";
   RTC_DCHECK(call);
@@ skipping 743 matching lines @@
   // Deregister default channel, if that's the one being destroyed.
   if (IsDefaultRecvStream(ssrc)) {
     default_recv_ssrc_ = -1;
   }
 
   const int channel = it->second->channel();
 
   // Clean up and delete the receive stream+channel.
   LOG(LS_INFO) << "Removing audio receive stream " << ssrc
                << " with VoiceEngine channel #" << channel << ".";
+  it->second->SetRawAudioSink(engine()->voe()->external_media(), nullptr);
   delete it->second;
   recv_streams_.erase(it);
   return DeleteVoEChannel(channel);
 }
 
 bool WebRtcVoiceMediaChannel::SetLocalRenderer(uint32_t ssrc,
                                                AudioRenderer* renderer) {
   auto it = send_streams_.find(ssrc);
   if (it == send_streams_.end()) {
     if (renderer) {
@@ skipping 356 matching lines @@
     rinfo.decoding_plc = stats.decoding_plc;
     rinfo.decoding_cng = stats.decoding_cng;
     rinfo.decoding_plc_cng = stats.decoding_plc_cng;
     rinfo.capture_start_ntp_time_ms = stats.capture_start_ntp_time_ms;
     info->receivers.push_back(rinfo);
   }
 
   return true;
 }
 
+void WebRtcVoiceMediaChannel::SetRawAudioSink(uint32_t ssrc,
+                                              AudioRenderer::Sink* sink) {
+  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+  const auto it = recv_streams_.find(ssrc);
+  if (it == recv_streams_.end()) {
+    LOG(LS_WARNING) << "SetRawAudioSink: no recv stream" << ssrc;
+    return;
+  }
+  it->second->SetRawAudioSink(engine()->voe()->external_media(), sink);
+}
+
 int WebRtcVoiceMediaChannel::GetOutputLevel(int channel) {
   unsigned int ulevel = 0;
   int ret = engine()->voe()->volume()->GetSpeechOutputLevel(channel, ulevel);
   return (ret == 0) ? static_cast<int>(ulevel) : -1;
 }
 
 int WebRtcVoiceMediaChannel::GetReceiveChannelId(uint32_t ssrc) const {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   const auto it = recv_streams_.find(ssrc);
   if (it != recv_streams_.end()) {
@@ skipping 64 matching lines @@
     }
   } else {
     LOG(LS_INFO) << "Stopping playout for channel #" << channel;
     engine()->voe()->base()->StopPlayout(channel);
   }
   return true;
 }
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE