Untangle ViEChannel and ViEEncoder.

webrtc/video/video_send_stream.cc

 /*
  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/video/video_send_stream.h"
 
 #include <algorithm>
 #include <sstream>
 #include <string>
 #include <vector>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/call/congestion_controller.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
 #include "webrtc/modules/pacing/packet_router.h"
 #include "webrtc/video/call_stats.h"
 #include "webrtc/video/encoder_state_feedback.h"
-#include "webrtc/video/payload_router.h"
 #include "webrtc/video/video_capture_input.h"
 #include "webrtc/video/vie_channel.h"
 #include "webrtc/video/vie_encoder.h"
 #include "webrtc/video_send_stream.h"
 
 namespace webrtc {
 
 class PacedSender;
 class RtcpIntraFrameObserver;
 class TransportFeedbackObserver;
@@ skipping 79 matching lines @@
     const VideoSendStream::Config& config,
     const VideoEncoderConfig& encoder_config,
     const std::map<uint32_t, RtpState>& suspended_ssrcs)
     : stats_proxy_(Clock::GetRealTimeClock(),
                    config,
                    encoder_config.content_type),
       transport_adapter_(config.send_transport),
       encoded_frame_proxy_(config.post_encode_callback),
       config_(config),
       suspended_ssrcs_(suspended_ssrcs),
-      module_process_thread_(module_process_thread),
       call_stats_(call_stats),
       congestion_controller_(congestion_controller),
       encoder_feedback_(new EncoderStateFeedback()),
       use_config_bitrate_(true) {
   LOG(LS_INFO) << "VideoSendStream: " << config_.ToString();
   RTC_DCHECK(!config_.rtp.ssrcs.empty());
 
   // Set up Call-wide sequence numbers, if configured for this send stream.
   TransportFeedbackObserver* transport_feedback_observer = nullptr;
   for (const RtpExtension& extension : config.rtp.extensions) {
     if (extension.name == RtpExtension::kTransportSequenceNumber) {
       transport_feedback_observer =
           congestion_controller_->GetTransportFeedbackObserver();
       break;
     }
   }
 
   const std::vector<uint32_t>& ssrcs = config.rtp.ssrcs;
 
-  vie_encoder_.reset(new ViEEncoder(
-      num_cpu_cores, module_process_thread_, &stats_proxy_,
-      config.pre_encode_callback, congestion_controller_->pacer(),
-      bitrate_allocator));
+  vie_encoder_.reset(new ViEEncoder(num_cpu_cores, module_process_thread,
+                                    &stats_proxy_, config.pre_encode_callback,
+                                    congestion_controller_->pacer(),
+                                    &payload_router_, bitrate_allocator));
+  vcm_ = vie_encoder_->vcm();
   RTC_CHECK(vie_encoder_->Init());
 
   vie_channel_.reset(new ViEChannel(
-      num_cpu_cores, config.send_transport, module_process_thread_,
-      encoder_feedback_->GetRtcpIntraFrameObserver(),
-      congestion_controller_->GetBitrateController()->
-          CreateRtcpBandwidthObserver(),
+      num_cpu_cores, config.send_transport, module_process_thread,
+      &payload_router_, nullptr, encoder_feedback_->GetRtcpIntraFrameObserver(),
+      congestion_controller_->GetBitrateController()
+          ->CreateRtcpBandwidthObserver(),
       transport_feedback_observer,
       congestion_controller_->GetRemoteBitrateEstimator(false),
       call_stats_->rtcp_rtt_stats(), congestion_controller_->pacer(),
       congestion_controller_->packet_router(), ssrcs.size(), true));
   RTC_CHECK(vie_channel_->Init() == 0);
 
+  vcm_->RegisterProtectionCallback(vie_channel_->vcm_protection_callback());
+
   call_stats_->RegisterStatsObserver(vie_channel_->GetStatsObserver());
 
-  vie_encoder_->StartThreadsAndSetSharedMembers(
-      vie_channel_->send_payload_router(),
-      vie_channel_->vcm_protection_callback());
-
   std::vector<uint32_t> first_ssrc(1, ssrcs[0]);
   vie_encoder_->SetSsrcs(first_ssrc);
 
   for (size_t i = 0; i < config_.rtp.extensions.size(); ++i) {
     const std::string& extension = config_.rtp.extensions[i].name;
     int id = config_.rtp.extensions[i].id;
     // One-byte-extension local identifiers are in the range 1-14 inclusive.
     RTC_DCHECK_GE(id, 1);
     RTC_DCHECK_LE(id, 14);
     if (extension == RtpExtension::kTOffset) {
@@ skipping 20 matching lines @@
                                   config_.rtp.fec.red_payload_type,
                                   config_.rtp.fec.ulpfec_payload_type);
   vie_encoder_->SetProtectionMethod(enable_protection_nack,
                                     enable_protection_fec);
 
   ConfigureSsrcs();
 
   vie_channel_->SetRTCPCName(config_.rtp.c_name.c_str());
 
   input_.reset(new internal::VideoCaptureInput(
-      module_process_thread_, vie_encoder_.get(), config_.local_renderer,
+      module_process_thread, vie_encoder_.get(), config_.local_renderer,
       &stats_proxy_, this, config_.encoding_time_observer));
 
   // 28 to match packet overhead in ModuleRtpRtcpImpl.
   RTC_DCHECK_LE(config_.rtp.max_packet_size, static_cast<size_t>(0xFFFF - 28));
   vie_channel_->SetMTU(static_cast<uint16_t>(config_.rtp.max_packet_size + 28));
 
   RTC_DCHECK(config.encoder_settings.encoder != nullptr);
   RTC_DCHECK_GE(config.encoder_settings.payload_type, 0);
   RTC_DCHECK_LE(config.encoder_settings.payload_type, 127);
   RTC_CHECK_EQ(0, vie_encoder_->RegisterExternalEncoder(
@@ skipping 16 matching lines @@
 
   vie_channel_->RegisterSendChannelRtcpStatisticsCallback(&stats_proxy_);
   vie_channel_->RegisterSendChannelRtpStatisticsCallback(&stats_proxy_);
   vie_channel_->RegisterRtcpPacketTypeCounterObserver(&stats_proxy_);
   vie_channel_->RegisterSendBitrateObserver(&stats_proxy_);
   vie_channel_->RegisterSendFrameCountObserver(&stats_proxy_);
 }
 
 VideoSendStream::~VideoSendStream() {
   LOG(LS_INFO) << "~VideoSendStream: " << config_.ToString();
+  // Remove vcm_protection_callback (part of vie_channel_) before destroying
+  // ViEChannel. vcm_ is owned by ViEEncoder and the registered callback does
+  // not outlive it.
+  vcm_->RegisterProtectionCallback(nullptr);
   vie_channel_->RegisterSendFrameCountObserver(nullptr);
   vie_channel_->RegisterSendBitrateObserver(nullptr);
   vie_channel_->RegisterRtcpPacketTypeCounterObserver(nullptr);
   vie_channel_->RegisterSendChannelRtpStatisticsCallback(nullptr);
   vie_channel_->RegisterSendChannelRtcpStatisticsCallback(nullptr);
 
   // Remove capture input (thread) so that it's not running after the current
   // channel is deleted.
   input_.reset();
 
   vie_encoder_->DeRegisterExternalEncoder(
       config_.encoder_settings.payload_type);
 
   call_stats_->DeregisterStatsObserver(vie_channel_->GetStatsObserver());
   congestion_controller_->SetChannelRembStatus(false, false,
                                                vie_channel_->rtp_rtcp());
 
   // Remove the feedback, stop all encoding threads and processing. This must be
   // done before deleting the channel.
   congestion_controller_->RemoveEncoder(vie_encoder_.get());
   encoder_feedback_->RemoveEncoder(vie_encoder_.get());
-  vie_encoder_->StopThreadsAndRemoveSharedMembers();
 
   uint32_t remote_ssrc = vie_channel_->GetRemoteSSRC();
   congestion_controller_->GetRemoteBitrateEstimator(false)->RemoveStream(
       remote_ssrc);
 }
 
 VideoCaptureInput* VideoSendStream::Input() {
   return input_.get();
 }
 
@@ skipping 301 matching lines @@
   vie_encoder_->SetSsrcs(used_ssrcs);
 
   // Restart the media flow
   vie_encoder_->Restart();
 
   return true;
 }
 
 }  // namespace internal
 }  // namespace webrtc