Refactor neteq_rtpplay

webrtc/modules/audio_coding/neteq/tools/neteq_test.cc

Index: webrtc/modules/audio_coding/neteq/tools/neteq_test.cc
diff --git a/webrtc/modules/audio_coding/neteq/tools/neteq_test.cc b/webrtc/modules/audio_coding/neteq/tools/neteq_test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..5ca56af6669042204a2d117001b6ccf81f42fc5e
--- /dev/null
+++ b/webrtc/modules/audio_coding/neteq/tools/neteq_test.cc
@@ -0,0 +1,137 @@
+/*
+ *  Copyright (c) 2016 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 "webrtc/modules/audio_coding/neteq/tools/neteq_test.h"
+
+#include <iostream>
+
+#include "webrtc/modules/audio_coding/codecs/builtin_audio_decoder_factory.h"
+
+namespace webrtc {
+namespace test {
+
+void DefaultNetEqTestErrorCallback::OnInsertPacketError(
+    int error_code,
+    const NetEqInput::PacketData& packet) {
+  if (error_code == NetEq::kUnknownRtpPayloadType) {
+    std::cerr << "RTP Payload type "
+              << static_cast<int>(packet.header.header.payloadType)
+              << " is unknown." << std::endl;
+  } else {
+    std::cerr << "InsertPacket returned error code " << error_code << std::endl;
+    std::cerr << "Header data:" << std::endl;
+    std::cerr << "  PT = " << static_cast<int>(packet.header.header.payloadType)
+              << std::endl;
+    std::cerr << "  SN = " << packet.header.header.sequenceNumber << std::endl;
+    std::cerr << "  TS = " << packet.header.header.timestamp << std::endl;
+  }
+  FATAL();
+}
+
+void DefaultNetEqTestErrorCallback::OnGetAudioError(int error_code) {
+  std::cerr << "GetAudio returned error code " << error_code << std::endl;
+  FATAL();
+}
+
+NetEqTest::NetEqTest(const NetEq::Config& config,
+                     const DecoderMap& codecs,
+                     const ExtDecoderMap& ext_codecs,
+                     std::unique_ptr<NetEqInput> input,
+                     std::unique_ptr<AudioSink> output,
+                     NetEqTestErrorCallback* error_callback)
+    : neteq_(NetEq::Create(config, CreateBuiltinAudioDecoderFactory())),
+      input_(std::move(input)),
+      output_(std::move(output)),
+      error_callback_(error_callback),
+      sample_rate_hz_(config.sample_rate_hz) {
+  RTC_CHECK(!config.enable_muted_state)
+      << "The code does not handle enable_muted_state";
+  RegisterDecoders(codecs);
+  RegisterExternalDecoders(ext_codecs);
+}
+
+int64_t NetEqTest::Run() {
+  const int64_t start_time_ms = *input_->NextEventTime();
+  int64_t time_now_ms = start_time_ms;
+
+  while (!input_->ended()) {
+    // Advance time to next event.
+    RTC_DCHECK(input_->NextEventTime());
+    time_now_ms = *input_->NextEventTime();
+    // Check if it is time to insert packet.
+    while (input_->NextPacketTime() &&

[ivoc, 2016/06/14 16:39:57]

I think this can be an if instead of a while now, right?

[hlundin-webrtc, 2016/06/17 10:30:09]

Done.

+           time_now_ms >= *input_->NextPacketTime()) {
+      std::unique_ptr<NetEqInput::PacketData> packet_data = input_->GetPacket();
+      RTC_CHECK(packet_data);
+      int error = neteq_->InsertPacket(
+          packet_data->header,
+          rtc::ArrayView<const uint8_t>(packet_data->payload),
+          static_cast<uint32_t>(packet_data->time_ms * sample_rate_hz_ / 1000));
+      if (error != NetEq::kOK && error_callback_) {
+        error_callback_->OnInsertPacketError(neteq_->LastError(), *packet_data);
+      }
+    }
+
+    // Check if it is time to get output audio.
+    while (input_->NextOutputEventTime() &&

[ivoc, 2016/06/14 16:39:57]

Same here, I think.

[hlundin-webrtc, 2016/06/17 10:30:09]

Done.

+           time_now_ms >= *input_->NextOutputEventTime()) {
+      AudioFrame out_frame;
+      bool muted;
+      int error = neteq_->GetAudio(&out_frame, &muted);
+      RTC_CHECK(!muted) << "The code does not handle enable_muted_state";
+      if (error != NetEq::kOK) {
+        if (error_callback_) {
+          error_callback_->OnGetAudioError(neteq_->LastError());
+        }
+      } else {
+        sample_rate_hz_ = out_frame.sample_rate_hz_;
+      }
+
+      if (output_) {
+        RTC_CHECK(output_->WriteArray(
+            out_frame.data_,
+            out_frame.samples_per_channel_ * out_frame.num_channels_));
+      }
+
+      input_->AdvanceOutputEvent();

[ivoc, 2016/06/14 16:39:57]

Perhaps there should be a corresponding function for packets?

[hlundin-webrtc, 2016/06/17 10:30:09]

No, I don't think so. The problem is that PopPacket (previously GetPacket) moves
the ownership of the packet to the caller. So, if PopPacket did not also do the
Advance... step, the NetEqInput object would be hanging in a bad state for a
while. That is:

t = input_->NextPacketTime();   // valid
p = input_->PopPacket();  // transfer ownership to p, but won't pre-fetch the
next packet
t = input_->NextPacketTime();  // INVALID
input_->AdvancePacket();
t = input_->NextPacketTime();  // valid again

+    }
+  }
+  return time_now_ms - start_time_ms;
+}
+
+NetEqNetworkStatistics NetEqTest::SimulationStats() {
+  NetEqNetworkStatistics stats;
+  RTC_CHECK_EQ(neteq_->NetworkStatistics(&stats), 0);
+  return stats;
+}
+
+void NetEqTest::RegisterDecoders(const DecoderMap& codecs) {
+  for (const auto& c : codecs) {
+    RTC_CHECK_EQ(
+        neteq_->RegisterPayloadType(c.second.first, c.second.second, c.first),
+        NetEq::kOK)
+        << "Cannot register " << c.second.second << " to payload type "
+        << c.first;
+  }
+}
+
+void NetEqTest::RegisterExternalDecoders(const ExtDecoderMap& codecs) {
+  for (const auto& c : codecs) {
+    RTC_CHECK_EQ(neteq_->RegisterExternalDecoder(
+                     c.second.decoder, c.second.codec, c.second.codec_name,
+                     c.first, c.second.sample_rate_hz),
+                 NetEq::kOK)
+        << "Cannot register " << c.second.codec_name << " to payload type "
+        << c.first;
+  }
+}
+
+}  // namespace test
+}  // namespace webrtc