Movable support for VideoReceiveStream::Config and avoid copies

webrtc/video/rtp_stream_receiver.cc

 /*
  *  Copyright (c) 2012 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.
  */
 
@@ skipping 59 matching lines @@
 static const int kPacketLogIntervalMs = 10000;
 
 RtpStreamReceiver::RtpStreamReceiver(
     vcm::VideoReceiver* video_receiver,
     RemoteBitrateEstimator* remote_bitrate_estimator,
     Transport* transport,
     RtcpRttStats* rtt_stats,
     PacedSender* paced_sender,
     PacketRouter* packet_router,
     VieRemb* remb,
-    const VideoReceiveStream::Config& config,
+    const VideoReceiveStream::Config* config,
     ReceiveStatisticsProxy* receive_stats_proxy,
     ProcessThread* process_thread)
     : clock_(Clock::GetRealTimeClock()),
-      config_(config),
+      config_(*config),
       video_receiver_(video_receiver),
       remote_bitrate_estimator_(remote_bitrate_estimator),
       packet_router_(packet_router),
       remb_(remb),
       process_thread_(process_thread),
       ntp_estimator_(clock_),
       rtp_payload_registry_(RTPPayloadStrategy::CreateStrategy(false)),
       rtp_header_parser_(RtpHeaderParser::Create()),
       rtp_receiver_(RtpReceiver::CreateVideoReceiver(clock_,
                                                      this,
                                                      this,
                                                      &rtp_payload_registry_)),
       rtp_receive_statistics_(ReceiveStatistics::Create(clock_)),
       fec_receiver_(FecReceiver::Create(this)),
       receiving_(false),
       restored_packet_in_use_(false),
       last_packet_log_ms_(-1),
       rtp_rtcp_(CreateRtpRtcpModule(rtp_receive_statistics_.get(),
                                     transport,
                                     rtt_stats,
                                     receive_stats_proxy,
                                     remote_bitrate_estimator_,
                                     paced_sender,
                                     packet_router)) {
   packet_router_->AddRtpModule(rtp_rtcp_.get());
   rtp_receive_statistics_->RegisterRtpStatisticsCallback(receive_stats_proxy);
   rtp_receive_statistics_->RegisterRtcpStatisticsCallback(receive_stats_proxy);
 
-  RTC_DCHECK(config.rtp.rtcp_mode != RtcpMode::kOff)
+  RTC_DCHECK(config_.rtp.rtcp_mode != RtcpMode::kOff)
       << "A stream should not be configured with RTCP disabled. This value is "
          "reserved for internal usage.";
   RTC_DCHECK(config_.rtp.remote_ssrc != 0);
   // TODO(pbos): What's an appropriate local_ssrc for receive-only streams?
   RTC_DCHECK(config_.rtp.local_ssrc != 0);
   RTC_DCHECK(config_.rtp.remote_ssrc != config_.rtp.local_ssrc);
 
-  rtp_rtcp_->SetRTCPStatus(config.rtp.rtcp_mode);
-  rtp_rtcp_->SetSSRC(config.rtp.local_ssrc);
+  rtp_rtcp_->SetRTCPStatus(config_.rtp.rtcp_mode);
+  rtp_rtcp_->SetSSRC(config_.rtp.local_ssrc);
   rtp_rtcp_->SetKeyFrameRequestMethod(kKeyFrameReqPliRtcp);
-  if (config.rtp.remb) {
+  if (config_.rtp.remb) {
     rtp_rtcp_->SetREMBStatus(true);
     remb_->AddReceiveChannel(rtp_rtcp_.get());
   }
 
-  for (size_t i = 0; i < config.rtp.extensions.size(); ++i) {
-    EnableReceiveRtpHeaderExtension(config.rtp.extensions[i].uri,
-                                    config.rtp.extensions[i].id);
+  for (size_t i = 0; i < config_.rtp.extensions.size(); ++i) {
+    EnableReceiveRtpHeaderExtension(config_.rtp.extensions[i].uri,
+                                    config_.rtp.extensions[i].id);
   }
 
   static const int kMaxPacketAgeToNack = 450;
-  const int max_reordering_threshold = (config.rtp.nack.rtp_history_ms > 0)
-      ? kMaxPacketAgeToNack : kDefaultMaxReorderingThreshold;
+  const int max_reordering_threshold = (config_.rtp.nack.rtp_history_ms > 0)
+                                           ? kMaxPacketAgeToNack
+                                           : kDefaultMaxReorderingThreshold;
   rtp_receive_statistics_->SetMaxReorderingThreshold(max_reordering_threshold);
 
   // TODO(pbos): Support multiple RTX, per video payload.
   for (const auto& kv : config_.rtp.rtx) {
     RTC_DCHECK(kv.second.ssrc != 0);
     RTC_DCHECK(kv.second.payload_type != 0);
 
     rtp_payload_registry_.SetRtxSsrc(kv.second.ssrc);
     rtp_payload_registry_.SetRtxPayloadType(kv.second.payload_type,
                                             kv.first);
@@ skipping 24 matching lines @@
       rtp_payload_registry_.SetRtxPayloadType(
           config_.rtp.fec.red_rtx_payload_type,
           config_.rtp.fec.red_payload_type);
     }
 
     rtp_rtcp_->SetGenericFECStatus(true,
                                    config_.rtp.fec.red_payload_type,
                                    config_.rtp.fec.ulpfec_payload_type);
   }
 
-  if (config.rtp.rtcp_xr.receiver_reference_time_report)
+  if (config_.rtp.rtcp_xr.receiver_reference_time_report)
     rtp_rtcp_->SetRtcpXrRrtrStatus(true);
 
   // Stats callback for CNAME changes.
   rtp_rtcp_->RegisterRtcpStatisticsCallback(receive_stats_proxy);
 
   process_thread_->RegisterModule(rtp_receive_statistics_.get());
   process_thread_->RegisterModule(rtp_rtcp_.get());
 }
 
 RtpStreamReceiver::~RtpStreamReceiver() {
@@ skipping 343 matching lines @@
     const std::string& extension, int 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));
   RTC_CHECK(rtp_header_parser_->RegisterRtpHeaderExtension(
       StringToRtpExtensionType(extension), id));
 }
 
 }  // namespace webrtc