Avoid using legacy rtp header parser in the rtp_to_text tool

Bug: None
Change-Id: I4c0ab1ba7730bdcdd826aa41b67b80a96d92c8f3
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/221204
Reviewed-by: Björn Terelius <terelius@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#34231}

modules/remote_bitrate_estimator/BUILD.gn

@@ -78,10 +78,9 @@ if (!build_with_chromium) {
       "tools/bwe_rtp.h",
     ]
     deps = [
-      ":remote_bitrate_estimator",
       "../../rtc_base:rtc_base_approved",
       "../../test:rtp_test_utils",
-      "../rtp_rtcp",
+      "../rtp_rtcp:rtp_rtcp_format",
     ]
     absl_deps = [
       "//third_party/abseil-cpp/absl/flags:flag",
@@ -94,10 +93,10 @@ if (!build_with_chromium) {
     sources = [ "tools/rtp_to_text.cc" ]
     deps = [
       ":bwe_rtp",
-      "../../modules/rtp_rtcp",
       "../../rtc_base:macromagic",
       "../../rtc_base:stringutils",
       "../../test:rtp_test_utils",
+      "../rtp_rtcp:rtp_rtcp_format",
     ]
   }
 }

modules/remote_bitrate_estimator/tools/bwe_rtp.cc

@@ -18,10 +18,8 @@
 
 #include "absl/flags/flag.h"
 #include "absl/flags/parse.h"
-#include "modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.h"
-#include "modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.h"
+#include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
 #include "test/rtp_file_reader.h"
-#include "test/rtp_header_parser.h"
 
 ABSL_FLAG(std::string,
           extension_type,
@@ -65,14 +63,11 @@ std::set<uint32_t> SsrcFilter() {
   return ssrcs;
 }
 
-std::unique_ptr<webrtc::RtpHeaderParser> ParseArgsAndSetupEstimator(
+bool ParseArgsAndSetupRtpReader(
     int argc,
     char** argv,
-    webrtc::Clock* clock,
-    webrtc::RemoteBitrateObserver* observer,
-    std::unique_ptr<webrtc::test::RtpFileReader>* rtp_reader,
-    std::unique_ptr<webrtc::RemoteBitrateEstimator>* estimator,
-    std::string* estimator_used) {
+    std::unique_ptr<webrtc::test::RtpFileReader>& rtp_reader,
+    webrtc::RtpHeaderExtensionMap& rtp_header_extensions) {
   absl::ParseCommandLine(argc, argv);
   std::string filename = InputFile();
 
@@ -84,16 +79,16 @@ std::unique_ptr<webrtc::RtpHeaderParser> ParseArgsAndSetupEstimator(
   fprintf(stderr, "\n");
   if (filename.substr(filename.find_last_of('.')) == ".pcap") {
     fprintf(stderr, "Opening as pcap\n");
-    rtp_reader->reset(webrtc::test::RtpFileReader::Create(
+    rtp_reader.reset(webrtc::test::RtpFileReader::Create(
         webrtc::test::RtpFileReader::kPcap, filename.c_str(), SsrcFilter()));
   } else {
     fprintf(stderr, "Opening as rtp\n");
-    rtp_reader->reset(webrtc::test::RtpFileReader::Create(
+    rtp_reader.reset(webrtc::test::RtpFileReader::Create(
         webrtc::test::RtpFileReader::kRtpDump, filename.c_str()));
   }
-  if (!*rtp_reader) {
+  if (!rtp_reader) {
     fprintf(stderr, "Cannot open input file %s\n", filename.c_str());
-    return nullptr;
+    return false;
   }
   fprintf(stderr, "Input file: %s\n\n", filename.c_str());
 
@@ -105,31 +100,10 @@ std::unique_ptr<webrtc::RtpHeaderParser> ParseArgsAndSetupEstimator(
     fprintf(stderr, "Extension: abs\n");
   } else {
     fprintf(stderr, "Unknown extension type\n");
-    return nullptr;
+    return false;
   }
 
-  // Setup the RTP header parser and the bitrate estimator.
-  auto parser = webrtc::RtpHeaderParser::CreateForTest();
-  parser->RegisterRtpHeaderExtension(extension, ExtensionId());
-  if (estimator) {
-    switch (extension) {
-      case webrtc::kRtpExtensionAbsoluteSendTime: {
-        estimator->reset(
-            new webrtc::RemoteBitrateEstimatorAbsSendTime(observer, clock));
-        *estimator_used = "AbsoluteSendTimeRemoteBitrateEstimator";
-        break;
-      }
-      case webrtc::kRtpExtensionTransmissionTimeOffset: {
-        estimator->reset(
-            new webrtc::RemoteBitrateEstimatorSingleStream(observer, clock));
-        *estimator_used = "RemoteBitrateEstimator";
-        break;
-      }
-      default:
-        assert(false);
-        return nullptr;
-    }
-  }
+  rtp_header_extensions.RegisterByType(ExtensionId(), extension);
 
-  return parser;
+  return true;
 }

modules/remote_bitrate_estimator/tools/bwe_rtp.h

@@ -12,25 +12,14 @@
 #define MODULES_REMOTE_BITRATE_ESTIMATOR_TOOLS_BWE_RTP_H_
 
 #include <memory>
-#include <string>
 
-namespace webrtc {
-class Clock;
-class RemoteBitrateEstimator;
-class RemoteBitrateObserver;
-class RtpHeaderParser;
-namespace test {
-class RtpFileReader;
-}
-}  // namespace webrtc
+#include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
+#include "test/rtp_file_reader.h"
 
-std::unique_ptr<webrtc::RtpHeaderParser> ParseArgsAndSetupEstimator(
+bool ParseArgsAndSetupRtpReader(
     int argc,
     char** argv,
-    webrtc::Clock* clock,
-    webrtc::RemoteBitrateObserver* observer,
-    std::unique_ptr<webrtc::test::RtpFileReader>* rtp_reader,
-    std::unique_ptr<webrtc::RemoteBitrateEstimator>* estimator,
-    std::string* estimator_used);
+    std::unique_ptr<webrtc::test::RtpFileReader>& rtp_reader,
+    webrtc::RtpHeaderExtensionMap& rtp_header_extensions);
 
 #endif  // MODULES_REMOTE_BITRATE_ESTIMATOR_TOOLS_BWE_RTP_H_

modules/remote_bitrate_estimator/tools/rtp_to_text.cc

@@ -13,17 +13,19 @@
 #include <memory>
 
 #include "modules/remote_bitrate_estimator/tools/bwe_rtp.h"
+#include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
+#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
+#include "modules/rtp_rtcp/source/rtp_packet.h"
 #include "rtc_base/format_macros.h"
 #include "rtc_base/strings/string_builder.h"
 #include "test/rtp_file_reader.h"
-#include "test/rtp_header_parser.h"
 
 int main(int argc, char* argv[]) {
   std::unique_ptr<webrtc::test::RtpFileReader> reader;
-  std::unique_ptr<webrtc::RtpHeaderParser> parser(ParseArgsAndSetupEstimator(
-      argc, argv, nullptr, nullptr, &reader, nullptr, nullptr));
-  if (!parser)
+  webrtc::RtpHeaderExtensionMap rtp_header_extensions;
+  if (!ParseArgsAndSetupRtpReader(argc, argv, reader, rtp_header_extensions)) {
     return -1;
+  }
 
   bool arrival_time_only = (argc >= 5 && strncmp(argv[4], "-t", 2) == 0);
 
@@ -35,11 +37,15 @@ int main(int argc, char* argv[]) {
   int non_zero_ts_offsets = 0;
   webrtc::test::RtpPacket packet;
   while (reader->NextPacket(&packet)) {
-    webrtc::RTPHeader header;
-    parser->Parse(packet.data, packet.length, &header);
-    if (header.extension.absoluteSendTime != 0)
+    webrtc::RtpPacket header(&rtp_header_extensions);
+    header.Parse(packet.data, packet.length);
+    uint32_t abs_send_time = 0;
+    if (header.GetExtension<webrtc::AbsoluteSendTime>(&abs_send_time) &&
+        abs_send_time != 0)
       ++non_zero_abs_send_time;
-    if (header.extension.transmissionTimeOffset != 0)
+    int32_t toffset = 0;
+    if (header.GetExtension<webrtc::TransmissionOffset>(&toffset) &&
+        toffset != 0)
       ++non_zero_ts_offsets;
     if (arrival_time_only) {
       rtc::StringBuilder ss;
@@ -47,11 +53,9 @@ int main(int argc, char* argv[]) {
       fprintf(stdout, "%s\n", ss.str().c_str());
     } else {
       fprintf(stdout, "%u %u %d %u %u %d %u %" RTC_PRIuS " %" RTC_PRIuS "\n",
-              header.sequenceNumber, header.timestamp,
-              header.extension.transmissionTimeOffset,
-              header.extension.absoluteSendTime, packet.time_ms,
-              header.markerBit, header.ssrc, packet.length,
-              packet.original_length);
+              header.SequenceNumber(), header.Timestamp(), toffset,
+              abs_send_time, packet.time_ms, header.Marker(), header.Ssrc(),
+              packet.length, packet.original_length);
     }
     ++packet_counter;
   }