Wire up send-side bandwidth estimation.

webrtc/video/loopback.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.
  */
 
@@ skipping 19 matching lines @@
 #include "webrtc/test/run_loop.h"
 #include "webrtc/test/testsupport/trace_to_stderr.h"
 #include "webrtc/test/video_capturer.h"
 #include "webrtc/test/video_renderer.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
 namespace test {
 
 static const int kAbsSendTimeExtensionId = 7;
+static const int kTransportSeqExtensionId = 8;
 
 static const uint32_t kSendSsrc = 0x654321;
 static const uint32_t kSendRtxSsrc = 0x654322;
 static const uint32_t kReceiverLocalSsrc = 0x123456;
 
 static const uint8_t kRtxVideoPayloadType = 96;
 static const uint8_t kVideoPayloadTypeVP8 = 124;
 static const uint8_t kVideoPayloadTypeVP9 = 125;
 
 Loopback::Loopback(const Config& config)
@@ skipping 36 matching lines @@
       static_cast<uint8_t>(config_.sl_discard_threshold));
 
   // Loopback, call sends to itself.
   send_transport.SetReceiver(call->Receiver());
 
   VideoSendStream::Config send_config(&send_transport);
   send_config.rtp.ssrcs.push_back(kSendSsrc);
   send_config.rtp.rtx.ssrcs.push_back(kSendRtxSsrc);
   send_config.rtp.rtx.payload_type = kRtxVideoPayloadType;
   send_config.rtp.nack.rtp_history_ms = 1000;
+  if (config_.send_side_bwe) {
+    send_config.rtp.extensions.push_back(RtpExtension(
+        RtpExtension::kTransportSequenceNumber, kTransportSeqExtensionId));
+  } else {
   send_config.rtp.extensions.push_back(

[stefan-webrtc, 2015/09/17 10:33:19]

indentation

[sprang_webrtc, 2015/09/17 15:08:28]

Done.

       RtpExtension(RtpExtension::kAbsSendTime, kAbsSendTimeExtensionId));
+  }
 
   send_config.local_renderer = local_preview.get();
   rtc::scoped_ptr<VideoEncoder> encoder;
   if (config_.codec == "VP8") {
     encoder.reset(VideoEncoder::Create(VideoEncoder::kVp8));
   } else if (config_.codec == "VP9") {
     encoder.reset(VideoEncoder::Create(VideoEncoder::kVp9));
   } else {
     // Codec not supported.
     RTC_NOTREACHED() << "Codec not supported!";
@@ skipping 12 matching lines @@
 
   rtc::scoped_ptr<test::VideoCapturer> capturer(CreateCapturer(send_stream));
 
   VideoReceiveStream::Config receive_config(&send_transport);
   receive_config.rtp.remote_ssrc = send_config.rtp.ssrcs[0];
   receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
   receive_config.rtp.nack.rtp_history_ms = 1000;
   receive_config.rtp.remb = true;
   receive_config.rtp.rtx[payload_type].ssrc = kSendRtxSsrc;
   receive_config.rtp.rtx[payload_type].payload_type = kRtxVideoPayloadType;
-  receive_config.rtp.extensions.push_back(
-      RtpExtension(RtpExtension::kAbsSendTime, kAbsSendTimeExtensionId));
+  if (config_.send_side_bwe) {
+    receive_config.rtp.extensions.push_back(RtpExtension(
+        RtpExtension::kTransportSequenceNumber, kTransportSeqExtensionId));
+  } else {
+    receive_config.rtp.extensions.push_back(
+        RtpExtension(RtpExtension::kAbsSendTime, kAbsSendTimeExtensionId));
+    receive_config.rtp.remb = true;
+  }
   receive_config.renderer = loopback_video.get();
   VideoReceiveStream::Decoder decoder =
       test::CreateMatchingDecoder(send_config.encoder_settings);
   receive_config.decoders.push_back(decoder);
 
   VideoReceiveStream* receive_stream =
       call->CreateVideoReceiveStream(receive_config);
 
   receive_stream->Start();
   send_stream->Start();
@@ skipping 32 matching lines @@
   return encoder_config;
 }
 
 test::VideoCapturer* Loopback::CreateCapturer(VideoSendStream* send_stream) {
   return test::VideoCapturer::Create(send_stream->Input(), config_.width,
                                      config_.height, config_.fps, clock_);
 }
 
 }  // namespace test
 }  // namespace webrtc