Make neteq_rtpplay parse RTP header extensions

webrtc/modules/audio_coding/neteq/tools/neteq_rtpplay.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 56 matching lines @@
     return true;
   printf("Invalid value for --%s: %d\n", flagname, static_cast<int>(value));
   return false;
 }
 
 bool ValidateSsrcValue(const char* flagname, const std::string& str) {
   uint32_t dummy_ssrc;
   return ParseSsrc(str, &dummy_ssrc);
 }
 
+static bool ValidateExtensionId(const char* flagname, int32_t value) {
+  if (value > 0 && value <= 255)  // Value is ok.
+    return true;
+  printf("Invalid value for --%s: %d\n", flagname, static_cast<int>(value));

[ivoc, 2016/08/24 15:06:07]

The style guide says we should prefer cout over printf.

[hlundin-webrtc, 2016/08/24 15:26:46]

I'd rather keep the printf for consistency with the other flag validators in
this file.

+  return false;
+}
+
 // Define command line flags.
 DEFINE_int32(pcmu, 0, "RTP payload type for PCM-u");
 const bool pcmu_dummy =
     google::RegisterFlagValidator(&FLAGS_pcmu, &ValidatePayloadType);
 DEFINE_int32(pcma, 8, "RTP payload type for PCM-a");
 const bool pcma_dummy =
     google::RegisterFlagValidator(&FLAGS_pcma, &ValidatePayloadType);
 DEFINE_int32(ilbc, 102, "RTP payload type for iLBC");
 const bool ilbc_dummy =
     google::RegisterFlagValidator(&FLAGS_ilbc, &ValidatePayloadType);
@@ skipping 42 matching lines @@
 DEFINE_bool(codec_map, false, "Prints the mapping between RTP payload type and "
     "codec");
 DEFINE_string(replacement_audio_file, "",
               "A PCM file that will be used to populate ""dummy"" RTP packets");
 DEFINE_string(ssrc,
               "",
               "Only use packets with this SSRC (decimal or hex, the latter "
               "starting with 0x)");
 const bool hex_ssrc_dummy =
     google::RegisterFlagValidator(&FLAGS_ssrc, &ValidateSsrcValue);
+DEFINE_int32(audio_level, 1, "Extension ID for audio level (RFC 6464)");
+const bool audio_level_dummy =
+    google::RegisterFlagValidator(&FLAGS_audio_level, &ValidateExtensionId);
+DEFINE_int32(abs_send_time, 3, "Extension ID for absolute sender time");
+const bool abs_send_time_dummy =
+    google::RegisterFlagValidator(&FLAGS_abs_send_time, &ValidateExtensionId);
 
 // Maps a codec type to a printable name string.
 std::string CodecName(NetEqDecoder codec) {
   switch (codec) {
     case NetEqDecoder::kDecoderPCMu:
       return "PCM-u";
     case NetEqDecoder::kDecoderPCMa:
       return "PCM-a";
     case NetEqDecoder::kDecoderILBC:
       return "iLBC";
@@ skipping 141 matching lines @@
   if (argc != 3) {
     if (FLAGS_codec_map) {
       // We have already printed the codec map. Just end the program.
       return 0;
     }
     // Print usage information.
     std::cout << google::ProgramUsage();
     return 0;
   }
 
+  // Gather RTP header extensions in a map.
+  NetEqPacketSourceInput::RtpHeaderExtensionMap rtp_ext_map = {
+      {FLAGS_audio_level, kRtpExtensionAudioLevel},
+      {FLAGS_abs_send_time, kRtpExtensionAbsoluteSendTime}};
+
   const std::string input_file_name = argv[1];
   std::unique_ptr<NetEqInput> input;
   if (RtpFileSource::ValidRtpDump(input_file_name) ||
       RtpFileSource::ValidPcap(input_file_name)) {
-    input.reset(new NetEqRtpDumpInput(input_file_name));
+    input.reset(new NetEqRtpDumpInput(input_file_name, rtp_ext_map));
   } else {
-    input.reset(new NetEqEventLogInput(input_file_name));
+    input.reset(new NetEqEventLogInput(input_file_name, rtp_ext_map));
   }
 
   std::cout << "Input file: " << input_file_name << std::endl;
   RTC_CHECK(input) << "Cannot open input file";
   RTC_CHECK(!input->ended()) << "Input file is empty";
 
   // Check if an SSRC value was provided.
   if (!FLAGS_ssrc.empty()) {
     uint32_t ssrc;
     RTC_CHECK(ParseSsrc(FLAGS_ssrc, &ssrc)) << "Flag verification has failed.";
@@ skipping 114 matching lines @@
   return 0;
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace webrtc
 
 int main(int argc, char* argv[]) {
   webrtc::test::RunTest(argc, argv);
 }