Define RtpTransportControllerSendInterface.

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 <cmath>
 #include <sstream>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/file.h"
 #include "webrtc/base/location.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/base/weak_ptr.h"
+#include "webrtc/call/rtp_transport_controller.h"
 #include "webrtc/common_types.h"
 #include "webrtc/common_video/include/video_bitrate_allocator.h"
 #include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
 #include "webrtc/modules/congestion_controller/include/congestion_controller.h"
 #include "webrtc/modules/pacing/packet_router.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "webrtc/modules/utility/include/process_thread.h"
 #include "webrtc/modules/video_coding/utility/ivf_file_writer.h"
 #include "webrtc/system_wrappers/include/field_trial.h"
 #include "webrtc/video/call_stats.h"
+#include "webrtc/video/payload_router.h"
 #include "webrtc/video/vie_remb.h"
 #include "webrtc/video_send_stream.h"
 
 namespace webrtc {
 
 static const int kMinSendSidePacketHistorySize = 600;
 namespace {
 
 // We don't do MTU discovery, so assume that we have the standard ethernet MTU.
 const size_t kPathMTU = 1500;
 
 std::vector<RtpRtcp*> CreateRtpRtcpModules(
     Transport* outgoing_transport,
     RtcpIntraFrameObserver* intra_frame_callback,
     RtcpBandwidthObserver* bandwidth_callback,
-    TransportFeedbackObserver* transport_feedback_callback,
+    RtpTransportControllerSendInterface* transport,
     RtcpRttStats* rtt_stats,
-    RtpPacketSender* paced_sender,
-    TransportSequenceNumberAllocator* transport_sequence_number_allocator,
     FlexfecSender* flexfec_sender,
     SendStatisticsProxy* stats_proxy,
     SendDelayStats* send_delay_stats,
     RtcEventLog* event_log,
     RateLimiter* retransmission_rate_limiter,
     OverheadObserver* overhead_observer,
     size_t num_modules) {
   RTC_DCHECK_GT(num_modules, 0);
   RtpRtcp::Configuration configuration;
   ReceiveStatistics* null_receive_statistics = configuration.receive_statistics;
   configuration.audio = false;
   configuration.receiver_only = false;
   configuration.flexfec_sender = flexfec_sender;
   configuration.receive_statistics = null_receive_statistics;
   configuration.outgoing_transport = outgoing_transport;
   configuration.intra_frame_callback = intra_frame_callback;
   configuration.bandwidth_callback = bandwidth_callback;
-  configuration.transport_feedback_callback = transport_feedback_callback;
+  configuration.transport_feedback_callback =
+      transport->transport_feedback_observer();
   configuration.rtt_stats = rtt_stats;
   configuration.rtcp_packet_type_counter_observer = stats_proxy;
-  configuration.paced_sender = paced_sender;
+  configuration.paced_sender = transport->packet_sender();
   configuration.transport_sequence_number_allocator =
-      transport_sequence_number_allocator;
+      transport->packet_router();
   configuration.send_bitrate_observer = stats_proxy;
   configuration.send_frame_count_observer = stats_proxy;
   configuration.send_side_delay_observer = stats_proxy;
   configuration.send_packet_observer = send_delay_stats;
   configuration.event_log = event_log;
   configuration.retransmission_rate_limiter = retransmission_rate_limiter;
   configuration.overhead_observer = overhead_observer;
   std::vector<RtpRtcp*> modules;
   for (size_t i = 0; i < num_modules; ++i) {
     RtpRtcp* rtp_rtcp = RtpRtcp::CreateRtpRtcp(configuration);
@@ skipping 231 matching lines @@
 // arbitrary thread.
 class VideoSendStreamImpl : public webrtc::BitrateAllocatorObserver,
                             public webrtc::OverheadObserver,
                             public webrtc::VCMProtectionCallback,
                             public ViEEncoder::EncoderSink,
                             public VideoBitrateAllocationObserver {
  public:
   VideoSendStreamImpl(SendStatisticsProxy* stats_proxy,
                       rtc::TaskQueue* worker_queue,
                       CallStats* call_stats,
-                      CongestionController* congestion_controller,
-                      PacketRouter* packet_router,
+                      RtpTransportControllerSendInterface* transport,
                       BitrateAllocator* bitrate_allocator,
                       SendDelayStats* send_delay_stats,
-                      VieRemb* remb,
                       ViEEncoder* vie_encoder,
                       RtcEventLog* event_log,
                       const VideoSendStream::Config* config,
                       int initial_encoder_max_bitrate,
                       std::map<uint32_t, RtpState> suspended_ssrcs);
   ~VideoSendStreamImpl() override;
 
   // RegisterProcessThread register |module_process_thread| with those objects
   // that use it. Registration has to happen on the thread were
   // |module_process_thread| was created (libjingle's worker thread).
@@ skipping 61 matching lines @@
 
   ProcessThread* module_process_thread_;
   rtc::ThreadChecker module_process_thread_checker_;
   rtc::TaskQueue* const worker_queue_;
 
   rtc::CriticalSection encoder_activity_crit_sect_;
   CheckEncoderActivityTask* check_encoder_activity_task_
       GUARDED_BY(encoder_activity_crit_sect_);
 
   CallStats* const call_stats_;
-  CongestionController* const congestion_controller_;
-  PacketRouter* const packet_router_;
+  RtpTransportControllerSendInterface* const transport_;
   BitrateAllocator* const bitrate_allocator_;
-  VieRemb* const remb_;
 
   // TODO(brandtr): Consider moving this to a new FlexfecSendStream class.
   std::unique_ptr<FlexfecSender> flexfec_sender_;
 
   rtc::CriticalSection ivf_writers_crit_;
   std::unique_ptr<IvfFileWriter> file_writers_[kMaxSimulcastStreams] GUARDED_BY(
       ivf_writers_crit_);
 
   int max_padding_bitrate_;
   int encoder_min_bitrate_bps_;
@@ skipping 25 matching lines @@
 // TODO(tommi): See if there's a more elegant way to create a task that creates
 // an object on the correct task queue.
 class VideoSendStream::ConstructionTask : public rtc::QueuedTask {
  public:
   ConstructionTask(std::unique_ptr<VideoSendStreamImpl>* send_stream,
                    rtc::Event* done_event,
                    SendStatisticsProxy* stats_proxy,
                    ViEEncoder* vie_encoder,
                    ProcessThread* module_process_thread,
                    CallStats* call_stats,
-                   CongestionController* congestion_controller,
-                   PacketRouter* packet_router,
+                   RtpTransportControllerSendInterface* transport,
                    BitrateAllocator* bitrate_allocator,
                    SendDelayStats* send_delay_stats,
-                   VieRemb* remb,
                    RtcEventLog* event_log,
                    const VideoSendStream::Config* config,
                    int initial_encoder_max_bitrate,
                    const std::map<uint32_t, RtpState>& suspended_ssrcs)
       : send_stream_(send_stream),
         done_event_(done_event),
         stats_proxy_(stats_proxy),
         vie_encoder_(vie_encoder),
         call_stats_(call_stats),
-        congestion_controller_(congestion_controller),
-        packet_router_(packet_router),
+        transport_(transport),
         bitrate_allocator_(bitrate_allocator),
         send_delay_stats_(send_delay_stats),
-        remb_(remb),
         event_log_(event_log),
         config_(config),
         initial_encoder_max_bitrate_(initial_encoder_max_bitrate),
         suspended_ssrcs_(suspended_ssrcs) {}
 
   ~ConstructionTask() override { done_event_->Set(); }
 
  private:
   bool Run() override {
     send_stream_->reset(new VideoSendStreamImpl(
-        stats_proxy_, rtc::TaskQueue::Current(), call_stats_,
-        congestion_controller_, packet_router_, bitrate_allocator_,
-        send_delay_stats_, remb_, vie_encoder_, event_log_, config_,
-        initial_encoder_max_bitrate_, std::move(suspended_ssrcs_)));
+        stats_proxy_, rtc::TaskQueue::Current(), call_stats_, transport_,
+        bitrate_allocator_, send_delay_stats_, vie_encoder_, event_log_,
+        config_, initial_encoder_max_bitrate_, std::move(suspended_ssrcs_)));
     return true;
   }
 
   std::unique_ptr<VideoSendStreamImpl>* const send_stream_;
   rtc::Event* const done_event_;
   SendStatisticsProxy* const stats_proxy_;
   ViEEncoder* const vie_encoder_;
   CallStats* const call_stats_;
-  CongestionController* const congestion_controller_;
-  PacketRouter* const packet_router_;
+  RtpTransportControllerSendInterface* const transport_;
   BitrateAllocator* const bitrate_allocator_;
   SendDelayStats* const send_delay_stats_;
-  VieRemb* const remb_;
   RtcEventLog* const event_log_;
   const VideoSendStream::Config* config_;
   int initial_encoder_max_bitrate_;
   std::map<uint32_t, RtpState> suspended_ssrcs_;
 };
 
 class VideoSendStream::DestructAndGetRtpStateTask : public rtc::QueuedTask {
  public:
   DestructAndGetRtpStateTask(VideoSendStream::RtpStateMap* state_map,
                              std::unique_ptr<VideoSendStreamImpl> send_stream,
@@ skipping 90 matching lines @@
   rtc::WeakPtr<VideoSendStreamImpl> send_stream_;
   std::vector<VideoStream> streams_;
   int min_transmit_bitrate_bps_;
 };
 
 VideoSendStream::VideoSendStream(
     int num_cpu_cores,
     ProcessThread* module_process_thread,
     rtc::TaskQueue* worker_queue,
     CallStats* call_stats,
-    CongestionController* congestion_controller,
-    PacketRouter* packet_router,
+    RtpTransportControllerSendInterface* transport,
     BitrateAllocator* bitrate_allocator,
     SendDelayStats* send_delay_stats,
-    VieRemb* remb,
     RtcEventLog* event_log,
     VideoSendStream::Config config,
     VideoEncoderConfig encoder_config,
     const std::map<uint32_t, RtpState>& suspended_ssrcs)
     : worker_queue_(worker_queue),
       thread_sync_event_(false /* manual_reset */, false),
       stats_proxy_(Clock::GetRealTimeClock(),
                    config,
                    encoder_config.content_type),
       config_(std::move(config)),
       content_type_(encoder_config.content_type) {
   vie_encoder_.reset(new ViEEncoder(
       num_cpu_cores, &stats_proxy_, config_.encoder_settings,
       config_.pre_encode_callback, config_.post_encode_callback));
   worker_queue_->PostTask(std::unique_ptr<rtc::QueuedTask>(new ConstructionTask(
       &send_stream_, &thread_sync_event_, &stats_proxy_, vie_encoder_.get(),
-      module_process_thread, call_stats, congestion_controller, packet_router,
-      bitrate_allocator, send_delay_stats, remb, event_log, &config_,
-      encoder_config.max_bitrate_bps, suspended_ssrcs)));
+      module_process_thread, call_stats, transport, bitrate_allocator,
+      send_delay_stats, event_log, &config_, encoder_config.max_bitrate_bps,
+      suspended_ssrcs)));
 
   // Wait for ConstructionTask to complete so that |send_stream_| can be used.
   // |module_process_thread| must be registered and deregistered on the thread
   // it was created on.
   thread_sync_event_.Wait(rtc::Event::kForever);
   send_stream_->RegisterProcessThread(module_process_thread);
   // TODO(sprang): Enable this also for regular video calls if it works well.
   if (encoder_config.content_type == VideoEncoderConfig::ContentType::kScreen) {
     // Only signal target bitrate for screenshare streams, for now.
     vie_encoder_->SetBitrateObserver(send_stream_.get());
@@ skipping 90 matching lines @@
 void VideoSendStream::EnableEncodedFrameRecording(
     const std::vector<rtc::PlatformFile>& files,
     size_t byte_limit) {
   send_stream_->EnableEncodedFrameRecording(files, byte_limit);
 }
 
 VideoSendStreamImpl::VideoSendStreamImpl(
     SendStatisticsProxy* stats_proxy,
     rtc::TaskQueue* worker_queue,
     CallStats* call_stats,
-    CongestionController* congestion_controller,
-    PacketRouter* packet_router,
+    RtpTransportControllerSendInterface* transport,
     BitrateAllocator* bitrate_allocator,
     SendDelayStats* send_delay_stats,
-    VieRemb* remb,
     ViEEncoder* vie_encoder,
     RtcEventLog* event_log,
     const VideoSendStream::Config* config,
     int initial_encoder_max_bitrate,
     std::map<uint32_t, RtpState> suspended_ssrcs)
     : send_side_bwe_with_overhead_(
           webrtc::field_trial::IsEnabled("WebRTC-SendSideBwe-WithOverhead")),
       stats_proxy_(stats_proxy),
       config_(config),
       suspended_ssrcs_(std::move(suspended_ssrcs)),
       module_process_thread_(nullptr),
       worker_queue_(worker_queue),
       check_encoder_activity_task_(nullptr),
       call_stats_(call_stats),
-      congestion_controller_(congestion_controller),
-      packet_router_(packet_router),
+      transport_(transport),
       bitrate_allocator_(bitrate_allocator),
-      remb_(remb),
       flexfec_sender_(MaybeCreateFlexfecSender(*config_)),
       max_padding_bitrate_(0),
       encoder_min_bitrate_bps_(0),
       encoder_max_bitrate_bps_(initial_encoder_max_bitrate),
       encoder_target_rate_bps_(0),
       vie_encoder_(vie_encoder),
       encoder_feedback_(Clock::GetRealTimeClock(),
                         config_->rtp.ssrcs,
                         vie_encoder),
       protection_bitrate_calculator_(Clock::GetRealTimeClock(), this),
-      bandwidth_observer_(congestion_controller_->GetBitrateController()
+      bandwidth_observer_(transport->congestion_controller()
+                              ->GetBitrateController()
                               ->CreateRtcpBandwidthObserver()),
       rtp_rtcp_modules_(CreateRtpRtcpModules(
           config_->send_transport,
           &encoder_feedback_,
           bandwidth_observer_.get(),
-          congestion_controller_,
+          transport,
           call_stats_->rtcp_rtt_stats(),
-          congestion_controller_->pacer(),
-          packet_router_,
           flexfec_sender_.get(),
           stats_proxy_,
           send_delay_stats,
           event_log,
-          congestion_controller_->GetRetransmissionRateLimiter(),
+          transport->congestion_controller()->GetRetransmissionRateLimiter(),
           this,
           config_->rtp.ssrcs.size())),
       payload_router_(rtp_rtcp_modules_,
                       config_->encoder_settings.payload_type),
       weak_ptr_factory_(this),
       overhead_bytes_per_packet_(0),
       transport_overhead_bytes_per_packet_(0) {
   RTC_DCHECK_RUN_ON(worker_queue_);
   LOG(LS_INFO) << "VideoSendStreamInternal: " << config_->ToString();
   weak_ptr_ = weak_ptr_factory_.GetWeakPtr();
   module_process_thread_checker_.DetachFromThread();
 
   RTC_DCHECK(!config_->rtp.ssrcs.empty());
   RTC_DCHECK(call_stats_);
-  RTC_DCHECK(congestion_controller_);
-  RTC_DCHECK(remb_);
+  RTC_DCHECK(transport_);
+  RTC_DCHECK(transport_->congestion_controller());
+  RTC_DCHECK(transport_->remb());
 
-  congestion_controller_->EnablePeriodicAlrProbing(
+  transport->congestion_controller()->EnablePeriodicAlrProbing(
       config_->periodic_alr_bandwidth_probing);
 
   // RTP/RTCP initialization.
 
   // We add the highest spatial layer first to ensure it'll be prioritized
   // when sending padding, with the hope that the packet rate will be smaller,
   // and that it's more important to protect than the lower layers.
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
-    packet_router_->AddRtpModule(rtp_rtcp);
+    transport->packet_router()->AddRtpModule(rtp_rtcp);
 
   for (size_t i = 0; i < config_->rtp.extensions.size(); ++i) {
     const std::string& extension = config_->rtp.extensions[i].uri;
     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);
     RTC_DCHECK(RtpExtension::IsSupportedForVideo(extension));
     for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
       RTC_CHECK_EQ(0, rtp_rtcp->RegisterSendRtpHeaderExtension(
                           StringToRtpExtensionType(extension), id));
     }
   }
 
-  remb_->AddRembSender(rtp_rtcp_modules_[0]);
+  transport->remb()->AddRembSender(rtp_rtcp_modules_[0]);
   rtp_rtcp_modules_[0]->SetREMBStatus(true);
 
   ConfigureProtection();
   ConfigureSsrcs();
 
   // TODO(pbos): Should we set CNAME on all RTP modules?
   rtp_rtcp_modules_.front()->SetCNAME(config_->rtp.c_name.c_str());
 
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     rtp_rtcp->RegisterRtcpStatisticsCallback(stats_proxy_);
@@ skipping 40 matching lines @@
     module_process_thread_->DeRegisterModule(rtp_rtcp);
 }
 
 VideoSendStreamImpl::~VideoSendStreamImpl() {
   RTC_DCHECK_RUN_ON(worker_queue_);
   RTC_DCHECK(!payload_router_.IsActive())
       << "VideoSendStreamImpl::Stop not called";
   LOG(LS_INFO) << "~VideoSendStreamInternal: " << config_->ToString();
 
   rtp_rtcp_modules_[0]->SetREMBStatus(false);
-  remb_->RemoveRembSender(rtp_rtcp_modules_[0]);
+  transport_->remb()->RemoveRembSender(rtp_rtcp_modules_[0]);
 
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
-    packet_router_->RemoveRtpModule(rtp_rtcp);
+    transport_->packet_router()->RemoveRtpModule(rtp_rtcp);
     delete rtp_rtcp;
   }
 }
 
 bool VideoSendStreamImpl::DeliverRtcp(const uint8_t* packet, size_t length) {
   // Runs on a network thread.
   RTC_DCHECK(!worker_queue_->IsCurrent());
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
     rtp_rtcp->IncomingRtcpPacket(packet, length);
   return true;
@@ skipping 410 matching lines @@
 
 void VideoSendStreamImpl::SetTransportOverhead(
     size_t transport_overhead_bytes_per_packet) {
   if (transport_overhead_bytes_per_packet >= static_cast<int>(kPathMTU)) {
     LOG(LS_ERROR) << "Transport overhead exceeds size of ethernet frame";
     return;
   }
 
   transport_overhead_bytes_per_packet_ = transport_overhead_bytes_per_packet;
 
-  congestion_controller_->SetTransportOverhead(
+  transport_->congestion_controller()->SetTransportOverhead(
       transport_overhead_bytes_per_packet_);
 
   size_t rtp_packet_size =
       std::min(config_->rtp.max_packet_size,
                kPathMTU - transport_overhead_bytes_per_packet_);
 
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     rtp_rtcp->SetMaxRtpPacketSize(rtp_packet_size);
   }
 }
 
 }  // namespace internal
 }  // namespace webrtc