Add AudioDecoderFactory to NetEqTest constructor.

Update EventLogAnalyzer to not depend on builtin audio decoders.

Bug: webrtc:8396, webrtc:10080
Change-Id: Ie02ed9cda6d4f11bfdf2e65eb6482283b7520738
Reviewed-on: https://webrtc-review.googlesource.com/c/114301
Reviewed-by: Alex Loiko <aleloi@webrtc.org>
Reviewed-by: Ivo Creusen <ivoc@webrtc.org>
Reviewed-by: Björn Terelius <terelius@webrtc.org>
Commit-Queue: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#26026}

modules/audio_coding/BUILD.gn

@@ -1062,7 +1062,6 @@ rtc_source_set("neteq_tools_minimal") {
     "../../api:neteq_simulator_api",
     "../../api/audio:audio_frame_api",
     "../../api/audio_codecs:audio_codecs_api",
-    "../../api/audio_codecs:builtin_audio_decoder_factory",
     "../../rtc_base:checks",
     "../../rtc_base:rtc_base_approved",
     "../rtp_rtcp",
@@ -1512,6 +1511,7 @@ if (rtc_include_tests) {
         ":neteq",
         ":neteq_test_tools",
         "../..:webrtc_common",
+        "../../api/audio_codecs:builtin_audio_decoder_factory",
         "../../rtc_base:rtc_base_approved",
         "../../test:test_support",
         "//third_party/abseil-cpp/absl/memory",

modules/audio_coding/neteq/neteq_decoder_plc_unittest.cc

@@ -15,6 +15,7 @@
 #include <vector>
 
 #include "absl/types/optional.h"
+#include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "modules/audio_coding/codecs/pcm16b/audio_encoder_pcm16b.h"
 #include "modules/audio_coding/neteq/tools/audio_checksum.h"
 #include "modules/audio_coding/neteq/tools/audio_sink.h"
@@ -185,8 +186,9 @@ NetEqNetworkStatistics RunTest(int loss_cadence, std::string* checksum) {
   // No callback objects.
   NetEqTest::Callbacks callbacks;
 
-  NetEqTest neteq_test(config, decoders, external_decoders, nullptr,
+  NetEqTest neteq_test(config, CreateBuiltinAudioDecoderFactory(), decoders,
-                       std::move(lossy_input), std::move(output), callbacks);
+                       external_decoders, nullptr, std::move(lossy_input),
+                       std::move(output), callbacks);
   EXPECT_LE(kRunTimeMs, neteq_test.Run());
 
   auto lifetime_stats = neteq_test.LifetimeStats();

modules/audio_coding/neteq/neteq_unittest.cc

@@ -1726,8 +1726,9 @@ TEST(NetEqNoTimeStretchingMode, RunTest) {
       new TimeLimitedNetEqInput(std::move(input), 20000));
   std::unique_ptr<AudioSink> output(new VoidAudioSink);
   NetEqTest::Callbacks callbacks;
-  NetEqTest test(config, codecs, ext_codecs, nullptr,
+  NetEqTest test(config, CreateBuiltinAudioDecoderFactory(), codecs, ext_codecs,
-                 std::move(input_time_limit), std::move(output), callbacks);
+                 nullptr, std::move(input_time_limit), std::move(output),
+                 callbacks);
   test.Run();
   const auto stats = test.SimulationStats();
   EXPECT_EQ(0, stats.accelerate_rate);

modules/audio_coding/neteq/tools/neteq_test.cc

@@ -13,7 +13,6 @@
 #include <iomanip>
 #include <iostream>
 
-#include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "modules/rtp_rtcp/source/byte_io.h"
 
 namespace webrtc {
@@ -52,13 +51,14 @@ void DefaultNetEqTestErrorCallback::OnGetAudioError() {
 }
 
 NetEqTest::NetEqTest(const NetEq::Config& config,
+                     rtc::scoped_refptr<AudioDecoderFactory> decoder_factory,
                      const DecoderMap& codecs,
                      const ExtDecoderMap& ext_codecs,
                      std::unique_ptr<std::ofstream> text_log,
                      std::unique_ptr<NetEqInput> input,
                      std::unique_ptr<AudioSink> output,
                      Callbacks callbacks)
-    : neteq_(NetEq::Create(config, CreateBuiltinAudioDecoderFactory())),
+    : neteq_(NetEq::Create(config, decoder_factory)),
       input_(std::move(input)),
       output_(std::move(output)),
       callbacks_(callbacks),

modules/audio_coding/neteq/tools/neteq_test.h

@@ -18,6 +18,7 @@
 #include <utility>
 
 #include "absl/types/optional.h"
+#include "api/audio_codecs/audio_decoder_factory.h"
 #include "api/test/neteq_simulator.h"
 #include "modules/audio_coding/neteq/include/neteq.h"
 #include "modules/audio_coding/neteq/tools/audio_sink.h"
@@ -86,6 +87,7 @@ class NetEqTest : public NetEqSimulator {
   // Sets up the test with given configuration, codec mappings, input, ouput,
   // and callback objects for error reporting.
   NetEqTest(const NetEq::Config& config,
+            rtc::scoped_refptr<AudioDecoderFactory> decoder_factory,
             const DecoderMap& codecs,
             const ExtDecoderMap& ext_codecs,
             std::unique_ptr<std::ofstream> text_log,

modules/audio_coding/neteq/tools/neteq_test_factory.cc

@@ -22,6 +22,7 @@
 #include <utility>
 
 #include "absl/memory/memory.h"
+#include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "modules/audio_coding/neteq/include/neteq.h"
 #include "modules/audio_coding/neteq/tools/fake_decode_from_file.h"
 #include "modules/audio_coding/neteq/tools/input_audio_file.h"
@@ -486,9 +487,9 @@ std::unique_ptr<NetEqTest> NetEqTestFactory::InitializeTest(
   config.sample_rate_hz = *sample_rate_hz;
   config.max_packets_in_buffer = FLAG_max_nr_packets_in_buffer;
   config.enable_fast_accelerate = FLAG_enable_fast_accelerate;
-  return absl::make_unique<NetEqTest>(config, codecs, ext_codecs_,
+  return absl::make_unique<NetEqTest>(
-                                      std::move(text_log), std::move(input),
+      config, CreateBuiltinAudioDecoderFactory(), codecs, ext_codecs_,
-                                      std::move(output), callbacks);
+      std::move(text_log), std::move(input), std::move(output), callbacks);
 }
 
 }  // namespace test

rtc_tools/BUILD.gn

@@ -235,7 +235,7 @@ if (!build_with_chromium) {
 
     rtc_static_library("event_log_visualizer_utils") {
       visibility = [ "*" ]
-      allow_poison = [ "audio_codecs" ]  # TODO(bugs.webrtc.org/8396): Remove.
+      testonly = true
       sources = [
         "event_log_visualizer/analyzer.cc",
         "event_log_visualizer/analyzer.h",
@@ -255,6 +255,10 @@ if (!build_with_chromium) {
       deps = [
         ":chart_proto",
         "../:webrtc_common",
+
+        # TODO(kwiberg): Remove this dependency.
+        "../api/audio_codecs:audio_codecs_api",
+        "../api/transport:goog_cc",
         "../call:call_interfaces",
         "../call:video_stream_api",
         "../logging:rtc_event_log_api",
@@ -264,15 +268,6 @@ if (!build_with_chromium) {
         "../modules/audio_coding:ana_debug_dump_proto",
         "../modules/audio_coding:audio_network_adaptor",
         "../modules/audio_coding:neteq_tools",
-        "../modules/rtp_rtcp:rtp_rtcp_format",
-        "../rtc_base:checks",
-        "../rtc_base:rtc_base_approved",
-        "../rtc_base:rtc_numerics",
-        "../rtc_base:stringutils",
-
-        # TODO(kwiberg): Remove this dependency.
-        "../api/audio_codecs:audio_codecs_api",
-        "../api/transport:goog_cc",
         "../modules/congestion_controller",
         "../modules/congestion_controller/goog_cc:delay_based_bwe",
         "../modules/congestion_controller/goog_cc:estimators",
@@ -280,6 +275,12 @@ if (!build_with_chromium) {
         "../modules/pacing",
         "../modules/remote_bitrate_estimator",
         "../modules/rtp_rtcp",
+        "../modules/rtp_rtcp:rtp_rtcp_format",
+        "../rtc_base:checks",
+        "../rtc_base:rtc_base_approved",
+        "../rtc_base:rtc_numerics",
+        "../rtc_base:stringutils",
+        "../test:audio_codec_mocks",
         "//third_party/abseil-cpp/absl/memory",
       ]
     }

rtc_tools/event_log_visualizer/analyzer.cc

@@ -57,6 +57,7 @@
 #include "rtc_base/numerics/sequence_number_util.h"
 #include "rtc_base/rate_statistics.h"
 #include "rtc_base/strings/string_builder.h"
+#include "test/function_audio_decoder_factory.h"
 
 #ifndef BWE_TEST_LOGGING_COMPILE_TIME_ENABLE
 #define BWE_TEST_LOGGING_COMPILE_TIME_ENABLE 0
@@ -1710,20 +1711,23 @@ std::unique_ptr<test::NetEqStatsGetter> CreateNetEqTestAndRun(
 
   std::unique_ptr<test::VoidAudioSink> output(new test::VoidAudioSink());
 
+  // Factory to create a "replacement decoder" that produces the decoded audio
+  // by reading from a file rather than from the encoded payloads.
+  rtc::scoped_refptr<AudioDecoderFactory> decoder_factory =
+      new rtc::RefCountedObject<test::FunctionAudioDecoderFactory>(
+          [replacement_file_name, file_sample_rate_hz]() {
+            std::unique_ptr<test::ResampleInputAudioFile> replacement_file(
+                new test::ResampleInputAudioFile(replacement_file_name,
+                                                 file_sample_rate_hz));
+            replacement_file->set_output_rate_hz(48000);
+            return absl::make_unique<test::FakeDecodeFromFile>(
+                std::move(replacement_file), 48000, false);
+          });
+
   test::NetEqTest::DecoderMap codecs;
 
-  // Create a "replacement decoder" that produces the decoded audio by reading
+  codecs[kReplacementPt] = {NetEqDecoder::kDecoderPCM16Bswb48kHz,
-  // from a file rather than from the encoded payloads.
+                            "replacement codec"};
-  std::unique_ptr<test::ResampleInputAudioFile> replacement_file(
-      new test::ResampleInputAudioFile(replacement_file_name,
-                                       file_sample_rate_hz));
-  replacement_file->set_output_rate_hz(48000);
-  std::unique_ptr<AudioDecoder> replacement_decoder(
-      new test::FakeDecodeFromFile(std::move(replacement_file), 48000, false));
-  test::NetEqTest::ExtDecoderMap ext_codecs;
-  ext_codecs[kReplacementPt] = {replacement_decoder.get(),
-                                NetEqDecoder::kDecoderArbitrary,
-                                "replacement codec"};
 
   std::unique_ptr<test::NetEqDelayAnalyzer> delay_cb(
       new test::NetEqDelayAnalyzer);
@@ -1735,8 +1739,9 @@ std::unique_ptr<test::NetEqStatsGetter> CreateNetEqTestAndRun(
   callbacks.post_insert_packet = neteq_stats_getter->delay_analyzer();
   callbacks.get_audio_callback = neteq_stats_getter.get();
 
-  test::NetEqTest test(config, codecs, ext_codecs, nullptr, std::move(input),
+  test::NetEqTest::ExtDecoderMap ext_codecs;
-                       std::move(output), callbacks);
+  test::NetEqTest test(config, decoder_factory, codecs, ext_codecs, nullptr,
+                       std::move(input), std::move(output), callbacks);
   test.Run();
   return neteq_stats_getter;
 }

test/fuzzers/BUILD.gn

@@ -358,6 +358,7 @@ webrtc_fuzzer_test("neteq_rtp_fuzzer") {
   ]
   deps = [
     "../../api:array_view",
+    "../../api/audio_codecs:builtin_audio_decoder_factory",
     "../../modules/audio_coding:neteq",
     "../../modules/audio_coding:neteq_test_tools",
     "../../modules/audio_coding:neteq_tools_minimal",
@@ -373,6 +374,7 @@ webrtc_fuzzer_test("neteq_signal_fuzzer") {
   ]
   deps = [
     "../../api:array_view",
+    "../../api/audio_codecs:builtin_audio_decoder_factory",
     "../../modules/audio_coding:neteq",
     "../../modules/audio_coding:neteq_test_tools",
     "../../modules/audio_coding:neteq_tools_minimal",

test/fuzzers/neteq_rtp_fuzzer.cc

@@ -13,6 +13,7 @@
 #include <vector>
 
 #include "api/array_view.h"
+#include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "modules/audio_coding/codecs/pcm16b/audio_encoder_pcm16b.h"
 #include "modules/audio_coding/neteq/tools/audio_checksum.h"
 #include "modules/audio_coding/neteq/tools/encode_neteq_input.h"
@@ -138,8 +139,8 @@ void FuzzOneInputTest(const uint8_t* data, size_t size) {
 
   NetEqTest::ExtDecoderMap ext_codecs;
 
-  NetEqTest test(config, codecs, ext_codecs, nullptr, std::move(input),
+  NetEqTest test(config, CreateBuiltinAudioDecoderFactory(), codecs, ext_codecs,
-                 std::move(output), callbacks);
+                 nullptr, std::move(input), std::move(output), callbacks);
   test.Run();
 }
 

test/fuzzers/neteq_signal_fuzzer.cc

@@ -14,6 +14,7 @@
 #include <vector>
 
 #include "api/array_view.h"
+#include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "modules/audio_coding/codecs/pcm16b/audio_encoder_pcm16b.h"
 #include "modules/audio_coding/neteq/tools/audio_checksum.h"
 #include "modules/audio_coding/neteq/tools/encode_neteq_input.h"
@@ -183,8 +184,8 @@ void FuzzOneInputTest(const uint8_t* data, size_t size) {
 
   NetEqTest::ExtDecoderMap ext_codecs;
 
-  NetEqTest test(config, codecs, ext_codecs, nullptr, std::move(input),
+  NetEqTest test(config, CreateBuiltinAudioDecoderFactory(), codecs, ext_codecs,
-                 std::move(output), callbacks);
+                 nullptr, std::move(input), std::move(output), callbacks);
   test.Run();
 }