Add send transports to individual webrtc::Call streams.

talk/media/webrtc/webrtcvideoengine2.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 770 matching lines @@
     WebRtcVideoDecoderFactory* external_decoder_factory)
     : unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),
       voice_channel_(voice_channel),
       voice_channel_id_(voice_channel ? voice_channel->voe_channel() : -1),
       external_encoder_factory_(external_encoder_factory),
       external_decoder_factory_(external_decoder_factory) {
   DCHECK(thread_checker_.CalledOnValidThread());
   SetDefaultOptions();
   options_.SetAll(options);
   options_.cpu_overuse_detection.Get(&signal_cpu_adaptation_);
-  webrtc::Call::Config config(this);
+  webrtc::Call::Config config;
   config.overuse_callback = this;
   if (voice_engine != NULL) {
     config.voice_engine = voice_engine->voe()->engine();
   }
   config.bitrate_config.min_bitrate_bps = kMinBandwidthBps;
   config.bitrate_config.start_bitrate_bps = kStartBandwidthBps;
   config.bitrate_config.max_bitrate_bps = kMaxBandwidthBps;
   call_.reset(call_factory->CreateCall(config));
   if (voice_channel_) {
     voice_channel_->SetCall(call_.get());
@@ skipping 310 matching lines @@
   rtc::CritScope stream_lock(&stream_crit_);
 
   if (!ValidateSendSsrcAvailability(sp))
     return false;
 
   for (uint32 used_ssrc : sp.ssrcs)
     send_ssrcs_.insert(used_ssrc);
 
   WebRtcVideoSendStream* stream =
       new WebRtcVideoSendStream(call_.get(),
+                                sp,
+                                webrtc::VideoSendStream::Config(this),
                                 external_encoder_factory_,
                                 options_,
                                 bitrate_config_.max_bitrate_bps,
                                 send_codec_,
-                                sp,
                                 send_rtp_extensions_);
 
   uint32 ssrc = sp.first_ssrc();
   DCHECK(ssrc != 0);
   send_streams_[ssrc] = stream;
 
   if (rtcp_receiver_report_ssrc_ == kDefaultRtcpReceiverReportSsrc) {
     rtcp_receiver_report_ssrc_ = ssrc;
     LOG(LS_INFO) << "SetLocalSsrc on all the receive streams because we added "
                     "a send stream.";
@@ skipping 83 matching lines @@
     DeleteReceiveStream(prev_stream->second);
     receive_streams_.erase(prev_stream);
   }
 
   if (!ValidateReceiveSsrcAvailability(sp))
     return false;
 
   for (uint32 used_ssrc : sp.ssrcs)
     receive_ssrcs_.insert(used_ssrc);
 
-  webrtc::VideoReceiveStream::Config config;
+  webrtc::VideoReceiveStream::Config config(this);
   ConfigureReceiverRtp(&config, sp);
 
   // Set up A/V sync group based on sync label.
   config.sync_group = sp.sync_label;
 
   config.rtp.remb = false;
   VideoCodecSettings send_codec;
   if (send_codec_.Get(&send_codec)) {
     config.rtp.remb = HasRemb(send_codec.codec);
   }
 
   receive_streams_[ssrc] = new WebRtcVideoReceiveStream(
-      call_.get(), sp, external_decoder_factory_, default_stream, config,
+      call_.get(), sp, config, external_decoder_factory_, default_stream,
       recv_codecs_);
 
   return true;
 }
 
 void WebRtcVideoChannel2::ConfigureReceiverRtp(
     webrtc::VideoReceiveStream::Config* config,
     const StreamParams& sp) const {
   uint32 ssrc = sp.first_ssrc();
 
@@ skipping 471 matching lines @@
       external(external) {
   if (external) {
     external_encoder = encoder;
     this->encoder =
         new webrtc::VideoEncoderSoftwareFallbackWrapper(type, encoder);
   }
 }
 
 WebRtcVideoChannel2::WebRtcVideoSendStream::WebRtcVideoSendStream(
     webrtc::Call* call,
+    const StreamParams& sp,
+    const webrtc::VideoSendStream::Config& config,
     WebRtcVideoEncoderFactory* external_encoder_factory,
     const VideoOptions& options,
     int max_bitrate_bps,
     const Settable<VideoCodecSettings>& codec_settings,
-    const StreamParams& sp,
     const std::vector<webrtc::RtpExtension>& rtp_extensions)
     : ssrcs_(sp.ssrcs),
       ssrc_groups_(sp.ssrc_groups),
       call_(call),
       external_encoder_factory_(external_encoder_factory),
       stream_(NULL),
-      parameters_(webrtc::VideoSendStream::Config(),
-                  options,
-                  max_bitrate_bps,
-                  codec_settings),
+      parameters_(config, options, max_bitrate_bps, codec_settings),
       allocated_encoder_(NULL, webrtc::kVideoCodecUnknown, false),
       capturer_(NULL),
       sending_(false),
       muted_(false),
       old_adapt_changes_(0),
       first_frame_timestamp_ms_(0),
       last_frame_timestamp_ms_(0) {
   parameters_.config.rtp.max_packet_size = kVideoMtu;
 
   sp.GetPrimarySsrcs(&parameters_.config.rtp.ssrcs);
@@ skipping 568 matching lines @@
   parameters_.encoder_config.encoder_specific_settings = NULL;
 
   if (sending_) {
     stream_->Start();
   }
 }
 
 WebRtcVideoChannel2::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream(
     webrtc::Call* call,
     const StreamParams& sp,
+    const webrtc::VideoReceiveStream::Config& config,
     WebRtcVideoDecoderFactory* external_decoder_factory,
     bool default_stream,
-    const webrtc::VideoReceiveStream::Config& config,
     const std::vector<VideoCodecSettings>& recv_codecs)
     : call_(call),
       ssrcs_(sp.ssrcs),
       ssrc_groups_(sp.ssrc_groups),
       stream_(NULL),
       default_stream_(default_stream),
       config_(config),
       external_decoder_factory_(external_decoder_factory),
       renderer_(NULL),
       last_width_(-1),
@@ skipping 381 matching lines @@
       video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
     }
   }
 
   return video_codecs;
 }
 
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VIDEO