Fix video_replay tool to respect RTX stream and fix default parameters.

webrtc/video/replay.cc

 /*
  *  Copyright (c) 2014 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 25 matching lines @@
 
 namespace webrtc {
 namespace flags {
 
 // TODO(pbos): Multiple receivers.
 
 // Flag for payload type.
 static bool ValidatePayloadType(const char* flagname, int32_t payload_type) {
   return payload_type > 0 && payload_type <= 127;
 }
-DEFINE_int32(payload_type, 0, "Payload type");
+DEFINE_int32(payload_type, 123, "Payload type");

[sprang_webrtc, 2017/07/10 16:00:48]

The new default values, do they need to be literals?
Otherwise it might be nice to reference the code from whence they came. Egg
CallTest for ssrcs and video_quality_test.cc for the payload types.

[ilnik, 2017/07/10 16:17:49]

Done.

 static int PayloadType() { return static_cast<int>(FLAGS_payload_type); }
 static const bool payload_dummy =
     google::RegisterFlagValidator(&FLAGS_payload_type, &ValidatePayloadType);
 
+DEFINE_int32(payload_type_rtx, 98, "Payload type");
+static int PayloadTypeRtx() {
+  return static_cast<int>(FLAGS_payload_type_rtx);
+}
+static const bool payload_rtx_dummy =
+    google::RegisterFlagValidator(&FLAGS_payload_type_rtx,
+                                  &ValidatePayloadType);
+
 // Flag for SSRC.
 static bool ValidateSsrc(const char* flagname, uint64_t ssrc) {
   return ssrc > 0 && ssrc <= 0xFFFFFFFFu;
 }
 
-DEFINE_uint64(ssrc, 0, "Incoming SSRC");
+DEFINE_uint64(ssrc, 0xC0FFED, "Incoming SSRC");
 static uint32_t Ssrc() { return static_cast<uint32_t>(FLAGS_ssrc); }
 static const bool ssrc_dummy =
     google::RegisterFlagValidator(&FLAGS_ssrc, &ValidateSsrc);
 
+DEFINE_uint64(ssrc_rtx, 0xBADCAFD, "Incoming RTX SSRC");
+static uint32_t SsrcRtx() {
+  return static_cast<uint32_t>(FLAGS_ssrc_rtx);
+}
+static const bool ssrc_rtx_dummy =
+    google::RegisterFlagValidator(&FLAGS_ssrc_rtx, &ValidateSsrc);
+
 static bool ValidateOptionalPayloadType(const char* flagname,
                                         int32_t payload_type) {
   return payload_type == -1 || ValidatePayloadType(flagname, payload_type);
 }
 
 // Flag for RED payload type.
 DEFINE_int32(red_payload_type, -1, "RED payload type");
 static int RedPayloadType() {
   return static_cast<int>(FLAGS_red_payload_type);
 }
@@ skipping 141 matching lines @@
   FileRenderPassthrough file_passthrough(flags::OutBase(),
                                          playback_video.get());
 
   webrtc::RtcEventLogNullImpl event_log;
   std::unique_ptr<Call> call(Call::Create(Call::Config(&event_log)));
 
   test::NullTransport transport;
   VideoReceiveStream::Config receive_config(&transport);
   receive_config.rtp.remote_ssrc = flags::Ssrc();
   receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
+  receive_config.rtp.rtx_ssrc = flags::SsrcRtx();
+  receive_config.rtp.rtx_payload_types[flags::PayloadType()] =
+      flags::PayloadTypeRtx();
   receive_config.rtp.ulpfec.ulpfec_payload_type = flags::FecPayloadType();
   receive_config.rtp.ulpfec.red_payload_type = flags::RedPayloadType();
   receive_config.rtp.nack.rtp_history_ms = 1000;
   if (flags::TransmissionOffsetId() != -1) {
     receive_config.rtp.extensions.push_back(RtpExtension(
         RtpExtension::kTimestampOffsetUri, flags::TransmissionOffsetId()));
   }
   if (flags::AbsSendTimeId() != -1) {
     receive_config.rtp.extensions.push_back(
         RtpExtension(RtpExtension::kAbsSendTimeUri, flags::AbsSendTimeId()));
@@ skipping 95 matching lines @@
 }
 }  // namespace webrtc
 
 int main(int argc, char* argv[]) {
   ::testing::InitGoogleTest(&argc, argv);
   google::ParseCommandLineFlags(&argc, &argv, true);
 
   webrtc::test::RunTest(webrtc::RtpReplay);
   return 0;
 }