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.
  */
 
 #include <stdio.h>
 
 #include <map>
 #include <memory>
 #include <sstream>
 
 #include "gflags/gflags.h"
 #include "webrtc/api/video_codecs/video_decoder.h"
 #include "webrtc/call/call.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/logging/rtc_event_log/rtc_event_log.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
 #include "webrtc/rtc_base/checks.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/sleep.h"
+#include "webrtc/test/call_test.h"
 #include "webrtc/test/encoder_settings.h"
 #include "webrtc/test/fake_decoder.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/test/null_transport.h"
 #include "webrtc/test/rtp_file_reader.h"
 #include "webrtc/test/run_loop.h"
 #include "webrtc/test/run_test.h"
 #include "webrtc/test/video_capturer.h"
 #include "webrtc/test/video_renderer.h"
 #include "webrtc/typedefs.h"
 
 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, test::CallTest::kPayloadTypeVP8, "Payload type");
 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,
+             test::CallTest::kSendRtxPayloadType,
+             "RTX 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, test::CallTest::kVideoSendSsrcs[0], "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, test::CallTest::kSendRtxSsrcs[0], "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;
 }