Update to the neteq_rtpplay utility to support RtcEventLog input files.

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.
  */
 
 // TODO(hlundin): The functionality in this file should be moved into one or
 // several classes.
 
 #include <assert.h>
 #include <errno.h>
 #include <limits.h>  // For ULONG_MAX returned by strtoul.
 #include <stdio.h>
 #include <stdlib.h>  // For strtoul.
 
 #include <algorithm>
 #include <iostream>
+#include <limits>
 #include <string>
 
 #include "google/gflags.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/modules/audio_coding/codecs/pcm16b/include/pcm16b.h"
 #include "webrtc/modules/audio_coding/neteq/interface/neteq.h"
 #include "webrtc/modules/audio_coding/neteq/tools/input_audio_file.h"
 #include "webrtc/modules/audio_coding/neteq/tools/output_audio_file.h"
 #include "webrtc/modules/audio_coding/neteq/tools/output_wav_file.h"
 #include "webrtc/modules/audio_coding/neteq/tools/packet.h"
+#include "webrtc/modules/audio_coding/neteq/tools/rtc_event_log_source.h"
 #include "webrtc/modules/audio_coding/neteq/tools/rtp_file_source.h"
 #include "webrtc/modules/interface/module_common_types.h"
 #include "webrtc/system_wrappers/interface/trace.h"
 #include "webrtc/test/testsupport/fileutils.h"
 #include "webrtc/typedefs.h"
 
 using webrtc::NetEq;
 using webrtc::WebRtcRTPHeader;
 
 namespace {
@@ skipping 334 matching lines @@
     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;
   }
 
   printf("Input file: %s\n", argv[1]);
-  rtc::scoped_ptr<webrtc::test::RtpFileSource> file_source(
-      webrtc::test::RtpFileSource::Create(argv[1]));
+
+  // Check if the magic string "#!rtpplay1.0" appears at the beginning of the

[minyue-webrtc, 2015/09/01 11:48:35]

nice!

[hlundin-webrtc, 2015/09/02 08:48:51]

Yes, but I suggest you also add RTPencode as a magic string. We used to use that
one for the rtpdump files that we created ourselves from scratch (as opposed to
converting from wireshark traces). See e.g., webrtc/test/rtp_file_reader.cc,
lines 145--.

[ivoc, 2015/09/03 08:01:31]

Ah, I did not know that. Thanks.

+  // file. If it does, the input file is an RTPdump file, otherwise we will
+  // assume it is an RtcEventLog file.
+  bool is_rtp_dump = false;

[hlundin-webrtc, 2015/09/02 08:48:51]

This is a lot of extra code to check what is essentially already checked inside
RtpFileSource. I suggest you modify RtpFileSource::OpenFile and
RtpFileSource::Create to not use FATAL and CHECK for failed files. Instead,
Create should return nullptr if the format is wrong. (You may want to do this in
a separate CL, and also go through all other uses of RtpFileSource::Create that
today blindly assumes it always works, and perhaps CHECK that we got
non-nullptr.)

Then you would not need all of this. Instead, simply try to open the file with
RtpFileSource::Create. If that fails, try with RtcEventLogSource::Create. If
that fails too: let slip the dogs of war.

[ivoc, 2015/09/03 08:01:31]

You're right, that does seem like a nicer approach. For now I replaced this code
with a temporary solution using a RtpFileReader directly to check if the file is
valid, and re-reading it if it is. I will make your suggested changes in a
follow-up CL.

+  {
+    const char magic_string[] = "#!rtpplay1.0";
+    const size_t magic_string_size = sizeof(magic_string) - 1;
+    char first_bytes[magic_string_size];
+    FILE* input_file = fopen(argv[1], "r");
+    if (input_file) {
+      size_t bytes_read = fread(first_bytes, 1, magic_string_size, input_file);
+      if (bytes_read == magic_string_size)
+        if (strncmp(magic_string, first_bytes, magic_string_size) == 0)
+          is_rtp_dump = true;
+      fclose(input_file);
+    } else {
+      std::cerr << "Unable to read input file." << std::endl;
+      return -1;
+    }
+  }
+  rtc::scoped_ptr<webrtc::test::PacketSource> file_source;
+  webrtc::test::RtcEventLogSource* event_log_source = nullptr;
+  if (is_rtp_dump) {
+    file_source.reset(webrtc::test::RtpFileSource::Create(argv[1]));
+  } else {
+    event_log_source = webrtc::test::RtcEventLogSource::Create(argv[1]);
+    file_source.reset(event_log_source);
+  }
+
   assert(file_source.get());
 
   // Check if an SSRC value was provided.
   if (!FLAGS_ssrc.empty()) {
     uint32_t ssrc;
     CHECK(ParseSsrc(FLAGS_ssrc, &ssrc)) << "Flag verification has failed.";
     file_source->SelectSsrc(ssrc);
   }
 
   // Check if a replacement audio file was provided, and if so, open it.
   bool replace_payload = false;
   rtc::scoped_ptr<webrtc::test::InputAudioFile> replacement_audio_file;
   if (!FLAGS_replacement_audio_file.empty()) {
     replacement_audio_file.reset(
         new webrtc::test::InputAudioFile(FLAGS_replacement_audio_file));
     replace_payload = true;
   }
 
   // Read first packet.
   rtc::scoped_ptr<webrtc::test::Packet> packet(file_source->NextPacket());
   if (!packet) {
     printf(
         "Warning: input file is empty, or the filters did not match any "
         "packets\n");
     webrtc::Trace::ReturnTrace();
     return 0;
   }
-  bool packet_available = true;
 
   // Check the sample rate.
   int sample_rate_hz = CodecSampleRate(packet->header().payloadType);
   if (sample_rate_hz <= 0) {
     printf("Warning: Invalid sample rate from RTP packet.\n");
     webrtc::Trace::ReturnTrace();
     return 0;
   }
 
   // Open the output file now that we know the sample rate. (Rate is only needed
@@ skipping 41 matching lines @@
     replacement_audio.reset(new int16_t[input_frame_size_timestamps]);
     payload_mem_size_bytes = 2 * input_frame_size_timestamps;
     payload.reset(new uint8_t[payload_mem_size_bytes]);
     next_packet.reset(file_source->NextPacket());
     assert(next_packet);
     next_packet_available = true;
   }
 
   // This is the main simulation loop.
   // Set the simulation clock to start immediately with the first packet.
-  int start_time_ms = packet->time_ms();
-  int time_now_ms = packet->time_ms();
-  int next_input_time_ms = time_now_ms;
-  int next_output_time_ms = time_now_ms;
+  int64_t start_time_ms = packet->time_ms();

[hlundin-webrtc, 2015/09/02 08:48:51]

packet->time_ms() actually returns a double. Suggest you use
rtc::checked_cast<int64_t>(...)

[ivoc, 2015/09/03 08:01:31]

Done.

+  int64_t time_now_ms = packet->time_ms();
+  int64_t next_input_time_ms = time_now_ms;
+  int64_t next_output_time_ms = time_now_ms;
   if (time_now_ms % kOutputBlockSizeMs != 0) {
     // Make sure that next_output_time_ms is rounded up to the next multiple
     // of kOutputBlockSizeMs. (Legacy bit-exactness.)
     next_output_time_ms +=
         kOutputBlockSizeMs - time_now_ms % kOutputBlockSizeMs;
   }
-  while (packet_available) {
+
+  bool packet_available = true;
+  bool output_event_available = true;
+  if (!is_rtp_dump) {
+    next_output_time_ms = event_log_source->NextAudioOutputEventMs();
+    if (next_output_time_ms == std::numeric_limits<int64_t>::max())
+      output_event_available = false;
+    start_time_ms = time_now_ms =
+        std::min(next_input_time_ms, next_output_time_ms);
+  }
+  while (packet_available || output_event_available) {
+    // Advance time to next event.
+    time_now_ms = std::min(next_input_time_ms, next_output_time_ms);
     // Check if it is time to insert packet.
     while (time_now_ms >= next_input_time_ms && packet_available) {
       assert(packet->virtual_payload_length_bytes() > 0);
       // Parse RTP header.
       WebRtcRTPHeader rtp_header;
       packet->ConvertHeader(&rtp_header);
       const uint8_t* payload_ptr = packet->payload();

[minyue-webrtc, 2015/09/01 11:48:35]

Not very related to this CL, just curious.

If packets have no payload and user did not specify replacement_audio_file, what
will happen?

Is it better to force replacement_audio_file in that situation?

[hlundin-webrtc, 2015/09/02 08:48:51]

There will be some errors from NetEq, but it is probably useful to issue a
warning about it here.

[ivoc, 2015/09/03 08:01:31]

I added a check for this higher up in the code, on line 442.

       size_t payload_len = packet->payload_length_bytes();
       if (replace_payload) {
         payload_len = ReplacePayload(replacement_audio_file.get(),
                                      &replacement_audio,
                                      &payload,
                                      &payload_mem_size_bytes,
                                      &input_frame_size_timestamps,
                                      &rtp_header,
                                      next_packet.get());
         payload_ptr = payload.get();
@@ skipping 21 matching lines @@
           std::cerr << "  SN = " << rtp_header.header.sequenceNumber
                     << std::endl;
           std::cerr << "  TS = " << rtp_header.header.timestamp << std::endl;
         }
       }
 
       // Get next packet from file.
       webrtc::test::Packet* temp_packet = file_source->NextPacket();
       if (temp_packet) {
         packet.reset(temp_packet);
+        if (replace_payload) {
+          // At this point |packet| contains the packet *after* |next_packet|.
+          // Swap Packet objects between |packet| and |next_packet|.
+          packet.swap(next_packet);
+          // Swap the status indicators unless they're already the same.
+          if (packet_available != next_packet_available) {
+            packet_available = !packet_available;
+            next_packet_available = !next_packet_available;
+          }
+        }
+        next_input_time_ms = packet->time_ms();

[hlundin-webrtc, 2015/09/02 08:48:51]

checked_cast here too

[ivoc, 2015/09/03 08:01:31]

Added. I also added one in the call to neteq->InsertPacket on line 551.

       } else {
+        // Set next input time to the maximum value of int64_t to prevent the
+        // time_now_ms from becoming stuck at the final value.
+        next_input_time_ms = std::numeric_limits<int64_t>::max();
         packet_available = false;
       }
-      if (replace_payload) {
-        // At this point |packet| contains the packet *after* |next_packet|.
-        // Swap Packet objects between |packet| and |next_packet|.
-        packet.swap(next_packet);
-        // Swap the status indicators unless they're already the same.
-        if (packet_available != next_packet_available) {
-          packet_available = !packet_available;
-          next_packet_available = !next_packet_available;
-        }
-      }
-      next_input_time_ms = packet->time_ms();
     }
 
     // Check if it is time to get output audio.
-    if (time_now_ms >= next_output_time_ms) {
+    while (time_now_ms >= next_output_time_ms && output_event_available) {
       static const int kOutDataLen =
           kOutputBlockSizeMs * kMaxSamplesPerMs * kMaxChannels;
       int16_t out_data[kOutDataLen];
       int num_channels;
       int samples_per_channel;
       int error = neteq->GetAudio(kOutDataLen, out_data, &samples_per_channel,
                                    &num_channels, NULL);
       if (error != NetEq::kOK) {
         std::cerr << "GetAudio returned error code " <<
             neteq->LastError() << std::endl;
       } else {
         // Calculate sample rate from output size.
         sample_rate_hz = 1000 * samples_per_channel / kOutputBlockSizeMs;
       }
 
       // Write to file.
       // TODO(hlundin): Make writing to file optional.
       size_t write_len = samples_per_channel * num_channels;
       if (!output->WriteArray(out_data, write_len)) {
         std::cerr << "Error while writing to file" << std::endl;
         webrtc::Trace::ReturnTrace();
         exit(1);
       }
-      next_output_time_ms += kOutputBlockSizeMs;
+      if (is_rtp_dump) {
+        next_output_time_ms += kOutputBlockSizeMs;
+        if (!packet_available)
+          output_event_available = false;
+      } else {
+        next_output_time_ms = event_log_source->NextAudioOutputEventMs();
+        if (next_output_time_ms == std::numeric_limits<int64_t>::max())
+          output_event_available = false;
+      }
     }
-    // Advance time to next event.
-    time_now_ms = std::min(next_input_time_ms, next_output_time_ms);
   }
-
   printf("Simulation done\n");
-  printf("Produced %i ms of audio\n", time_now_ms - start_time_ms);
+  printf("Produced %i ms of audio\n",
+         static_cast<int>(time_now_ms - start_time_ms));
 
   delete neteq;
   webrtc::Trace::ReturnTrace();
   return 0;
 }