diff --git a/api/BUILD.gn b/api/BUILD.gn index ce6662743f..f8b6ca3f4c 100644 --- a/api/BUILD.gn +++ b/api/BUILD.gn @@ -309,6 +309,14 @@ rtc_source_set("libjingle_peerconnection_test_api") { ] } +rtc_source_set("neteq_simulator_api") { + visibility = [ "*" ] + sources = [ + "test/neteq_simulator.cc", + "test/neteq_simulator.h", + ] +} + if (rtc_include_tests) { if (rtc_enable_protobuf) { rtc_source_set("audioproc_f_api") { @@ -324,6 +332,20 @@ if (rtc_include_tests) { "../modules/audio_processing:audioproc_f_impl", ] } + + rtc_source_set("neteq_simulator_factory") { + visibility = [ "*" ] + testonly = true + sources = [ + "test/neteq_simulator_factory.cc", + "test/neteq_simulator_factory.h", + ] + deps = [ + ":neteq_simulator_api", + "../modules/audio_coding:neteq_test_factory", + "//third_party/abseil-cpp/absl/memory", + ] + } } rtc_source_set("simulcast_test_fixture_api") { diff --git a/api/test/neteq_simulator.cc b/api/test/neteq_simulator.cc new file mode 100644 index 0000000000..061570167b --- /dev/null +++ b/api/test/neteq_simulator.cc @@ -0,0 +1,22 @@ +/* + * Copyright (c) 2018 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 "api/test/neteq_simulator.h" + +namespace webrtc { +namespace test { + +NetEqSimulator::SimulationStepResult::SimulationStepResult() = default; +NetEqSimulator::SimulationStepResult::SimulationStepResult( + const NetEqSimulator::SimulationStepResult& other) = default; +NetEqSimulator::SimulationStepResult::~SimulationStepResult() = default; + +} // namespace test +} // namespace webrtc diff --git a/api/test/neteq_simulator.h b/api/test/neteq_simulator.h new file mode 100644 index 0000000000..8f1cd81425 --- /dev/null +++ b/api/test/neteq_simulator.h @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2018 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. + */ + +#ifndef API_TEST_NETEQ_SIMULATOR_H_ +#define API_TEST_NETEQ_SIMULATOR_H_ + +#include +#include + +namespace webrtc { +namespace test { + +class NetEqSimulator { + public: + virtual ~NetEqSimulator() = default; + + enum class Action { kNormal, kExpand, kAccelerate, kPreemptiveExpand }; + + // The results of one simulation step. + struct SimulationStepResult { + SimulationStepResult(); + SimulationStepResult(const SimulationStepResult& other); + ~SimulationStepResult(); + + bool is_simulation_finished = false; + // The amount of audio produced (in ms) with the actions in this time step. + std::map action_times_ms; + // The amount of wall clock time (in ms) that elapsed since the previous + // event. This is not necessarily equal to the sum of the values in + // action_times_ms. + int64_t simulation_step_ms = 0; + }; + + struct NetEqState { + // The sum of the packet buffer and sync buffer delay. + int current_delay_ms = 0; + // TODO(ivoc): Expand this struct with more useful metrics. + }; + + // Runs the simulation until we hit the next GetAudio event. If the simulation + // is finished, is_simulation_finished will be set to true in the returned + // SimulationStepResult. + virtual SimulationStepResult RunToNextGetAudio() = 0; + + // Set the next action to be taken by NetEq. This will override any action + // that NetEq would normally decide to take. + virtual void SetNextAction(Action next_operation) = 0; + + // Get the current state of NetEq. + virtual NetEqState GetNetEqState() = 0; +}; + +} // namespace test +} // namespace webrtc + +#endif // API_TEST_NETEQ_SIMULATOR_H_ diff --git a/api/test/neteq_simulator_factory.cc b/api/test/neteq_simulator_factory.cc new file mode 100644 index 0000000000..568e8a97e3 --- /dev/null +++ b/api/test/neteq_simulator_factory.cc @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2018 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 "api/test/neteq_simulator_factory.h" + +#include "absl/memory/memory.h" +#include "modules/audio_coding/neteq/tools/neteq_test_factory.h" + +namespace webrtc { +namespace test { + +NetEqSimulatorFactory::NetEqSimulatorFactory() + : factory_(absl::make_unique()) {} + +NetEqSimulatorFactory::~NetEqSimulatorFactory() = default; + +std::unique_ptr NetEqSimulatorFactory::CreateSimulator( + int argc, + char* argv[]) { + return factory_->InitializeTest(argc, argv); +} + +} // namespace test +} // namespace webrtc diff --git a/api/test/neteq_simulator_factory.h b/api/test/neteq_simulator_factory.h new file mode 100644 index 0000000000..e37ff55dd4 --- /dev/null +++ b/api/test/neteq_simulator_factory.h @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2018 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. + */ + +#ifndef API_TEST_NETEQ_SIMULATOR_FACTORY_H_ +#define API_TEST_NETEQ_SIMULATOR_FACTORY_H_ + +#include + +#include "api/test/neteq_simulator.h" + +namespace webrtc { +namespace test { + +class NetEqTestFactory; + +class NetEqSimulatorFactory { + public: + NetEqSimulatorFactory(); + ~NetEqSimulatorFactory(); + // This function takes the same arguments as the neteq_rtpplay utility. + std::unique_ptr CreateSimulator(int argc, char* argv[]); + + private: + std::unique_ptr factory_; +}; + +} // namespace test +} // namespace webrtc + +#endif // API_TEST_NETEQ_SIMULATOR_FACTORY_H_ diff --git a/modules/audio_coding/BUILD.gn b/modules/audio_coding/BUILD.gn index 0321c31529..4d24aff8ee 100644 --- a/modules/audio_coding/BUILD.gn +++ b/modules/audio_coding/BUILD.gn @@ -1089,6 +1089,7 @@ rtc_source_set("neteq_tools_minimal") { ":neteq", "../..:webrtc_common", "../../api:libjingle_peerconnection_api", + "../../api:neteq_simulator_api", "../../api/audio:audio_frame_api", "../../api/audio_codecs:audio_codecs_api", "../../api/audio_codecs:builtin_audio_decoder_factory", @@ -1164,6 +1165,8 @@ rtc_source_set("neteq_tools") { "neteq/tools/neteq_replacement_input.h", "neteq/tools/neteq_stats_getter.cc", "neteq/tools/neteq_stats_getter.h", + "neteq/tools/neteq_stats_plotter.cc", + "neteq/tools/neteq_stats_plotter.h", ] if (!build_with_chromium && is_clang) { @@ -1505,8 +1508,9 @@ if (rtc_include_tests) { proto_out_dir = "modules/audio_coding/neteq" } - rtc_test("neteq_rtpplay") { + rtc_source_set("neteq_test_factory") { testonly = true + visibility += webrtc_default_visibility defines = [] deps = [ "../../rtc_base:checks", @@ -1514,7 +1518,8 @@ if (rtc_include_tests) { "../../test:fileutils", ] sources = [ - "neteq/tools/neteq_rtpplay.cc", + "neteq/tools/neteq_test_factory.cc", + "neteq/tools/neteq_test_factory.h", ] if (!build_with_chromium && is_clang) { @@ -1529,6 +1534,19 @@ if (rtc_include_tests) { "../../rtc_base:rtc_base_approved", "../../system_wrappers:system_wrappers_default", "../../test:test_support", + "//third_party/abseil-cpp/absl/memory", + ] + } + + rtc_test("neteq_rtpplay") { + testonly = true + defines = [] + deps = [ + ":neteq_test_factory", + ":neteq_test_tools", + ] + sources = [ + "neteq/tools/neteq_rtpplay.cc", ] } } diff --git a/modules/audio_coding/neteq/include/neteq.h b/modules/audio_coding/neteq/include/neteq.h index fdb73c5afa..f376b0568c 100644 --- a/modules/audio_coding/neteq/include/neteq.h +++ b/modules/audio_coding/neteq/include/neteq.h @@ -21,6 +21,7 @@ #include "api/audio_codecs/audio_decoder.h" #include "api/rtp_headers.h" #include "common_types.h" // NOLINT(build/include) +#include "modules/audio_coding/neteq/defines.h" #include "modules/audio_coding/neteq/neteq_decoder_enum.h" #include "rtc_base/constructormagic.h" #include "rtc_base/scoped_ref_ptr.h" @@ -129,9 +130,14 @@ class NetEq { // If muted state is enabled (through Config::enable_muted_state), |muted| // may be set to true after a prolonged expand period. When this happens, the // |data_| in |audio_frame| is not written, but should be interpreted as being - // all zeros. + // all zeros. For testing purposes, an override can be supplied in the + // |action_override| argument, which will cause NetEq to take this action + // next, instead of the action it would normally choose. // Returns kOK on success, or kFail in case of an error. - virtual int GetAudio(AudioFrame* audio_frame, bool* muted) = 0; + virtual int GetAudio( + AudioFrame* audio_frame, + bool* muted, + absl::optional action_override = absl::nullopt) = 0; // Replaces the current set of decoders with the given one. virtual void SetCodecs(const std::map& codecs) = 0; diff --git a/modules/audio_coding/neteq/neteq_impl.cc b/modules/audio_coding/neteq/neteq_impl.cc index ddcd221dc5..3b2bd834b5 100644 --- a/modules/audio_coding/neteq/neteq_impl.cc +++ b/modules/audio_coding/neteq/neteq_impl.cc @@ -199,10 +199,12 @@ void SetAudioFrameActivityAndType(bool vad_enabled, } } // namespace -int NetEqImpl::GetAudio(AudioFrame* audio_frame, bool* muted) { +int NetEqImpl::GetAudio(AudioFrame* audio_frame, + bool* muted, + absl::optional action_override) { TRACE_EVENT0("webrtc", "NetEqImpl::GetAudio"); rtc::CritScope lock(&crit_sect_); - if (GetAudioInternal(audio_frame, muted) != 0) { + if (GetAudioInternal(audio_frame, muted, action_override) != 0) { return kFail; } RTC_DCHECK_EQ( @@ -798,7 +800,9 @@ int NetEqImpl::InsertPacketInternal(const RTPHeader& rtp_header, return 0; } -int NetEqImpl::GetAudioInternal(AudioFrame* audio_frame, bool* muted) { +int NetEqImpl::GetAudioInternal(AudioFrame* audio_frame, + bool* muted, + absl::optional action_override) { PacketList packet_list; DtmfEvent dtmf_event; Operations operation; @@ -831,9 +835,8 @@ int NetEqImpl::GetAudioInternal(AudioFrame* audio_frame, bool* muted) { *muted = true; return 0; } - - int return_value = - GetDecision(&operation, &packet_list, &dtmf_event, &play_dtmf); + int return_value = GetDecision(&operation, &packet_list, &dtmf_event, + &play_dtmf, action_override); if (return_value != 0) { last_mode_ = kModeError; return return_value; @@ -1021,7 +1024,8 @@ int NetEqImpl::GetAudioInternal(AudioFrame* audio_frame, bool* muted) { int NetEqImpl::GetDecision(Operations* operation, PacketList* packet_list, DtmfEvent* dtmf_event, - bool* play_dtmf) { + bool* play_dtmf, + absl::optional action_override) { // Initialize output variables. *play_dtmf = false; *operation = kUndefined; @@ -1093,6 +1097,10 @@ int NetEqImpl::GetDecision(Operations* operation, *sync_buffer_, *expand_, decoder_frame_length_, packet, last_mode_, *play_dtmf, generated_noise_samples, &reset_decoder_); + if (action_override) { + // Use the provided action instead of the decision NetEq decided on. + *operation = *action_override; + } // Check if we already have enough samples in the |sync_buffer_|. If so, // change decision to normal, unless the decision was merge, accelerate, or // preemptive expand. diff --git a/modules/audio_coding/neteq/neteq_impl.h b/modules/audio_coding/neteq/neteq_impl.h index 68fdf3cc96..dcb931eeb1 100644 --- a/modules/audio_coding/neteq/neteq_impl.h +++ b/modules/audio_coding/neteq/neteq_impl.h @@ -131,7 +131,10 @@ class NetEqImpl : public webrtc::NetEq { void InsertEmptyPacket(const RTPHeader& rtp_header) override; - int GetAudio(AudioFrame* audio_frame, bool* muted) override; + int GetAudio( + AudioFrame* audio_frame, + bool* muted, + absl::optional action_override = absl::nullopt) override; void SetCodecs(const std::map& codecs) override; @@ -230,7 +233,9 @@ class NetEqImpl : public webrtc::NetEq { // Delivers 10 ms of audio data. The data is written to |audio_frame|. // Returns 0 on success, otherwise an error code. - int GetAudioInternal(AudioFrame* audio_frame, bool* muted) + int GetAudioInternal(AudioFrame* audio_frame, + bool* muted, + absl::optional action_override) RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); // Provides a decision to the GetAudioInternal method. The decision what to @@ -241,7 +246,9 @@ class NetEqImpl : public webrtc::NetEq { int GetDecision(Operations* operation, PacketList* packet_list, DtmfEvent* dtmf_event, - bool* play_dtmf) RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); + bool* play_dtmf, + absl::optional action_override) + RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_sect_); // Decodes the speech packets in |packet_list|, and writes the results to // |decoded_buffer|, which is allocated to hold |decoded_buffer_length| diff --git a/modules/audio_coding/neteq/tools/neteq_rtpplay.cc b/modules/audio_coding/neteq/tools/neteq_rtpplay.cc index bf782bf3f6..2968a22885 100644 --- a/modules/audio_coding/neteq/tools/neteq_rtpplay.cc +++ b/modules/audio_coding/neteq/tools/neteq_rtpplay.cc @@ -8,544 +8,15 @@ * be found in the AUTHORS file in the root of the source tree. */ -#include -#include -#include // For ULONG_MAX returned by strtoul. #include -#include // For strtoul. -#include -#include -#include -#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" -#include "modules/audio_coding/neteq/tools/neteq_delay_analyzer.h" -#include "modules/audio_coding/neteq/tools/neteq_event_log_input.h" -#include "modules/audio_coding/neteq/tools/neteq_packet_source_input.h" -#include "modules/audio_coding/neteq/tools/neteq_replacement_input.h" -#include "modules/audio_coding/neteq/tools/neteq_stats_getter.h" #include "modules/audio_coding/neteq/tools/neteq_test.h" -#include "modules/audio_coding/neteq/tools/output_audio_file.h" -#include "modules/audio_coding/neteq/tools/output_wav_file.h" -#include "modules/audio_coding/neteq/tools/rtp_file_source.h" -#include "rtc_base/checks.h" -#include "rtc_base/flags.h" -#include "test/field_trial.h" -#include "test/testsupport/fileutils.h" - -namespace webrtc { -namespace test { -namespace { - -// Parses the input string for a valid SSRC (at the start of the string). If a -// valid SSRC is found, it is written to the output variable |ssrc|, and true is -// returned. Otherwise, false is returned. -bool ParseSsrc(const std::string& str, uint32_t* ssrc) { - if (str.empty()) - return true; - int base = 10; - // Look for "0x" or "0X" at the start and change base to 16 if found. - if ((str.compare(0, 2, "0x") == 0) || (str.compare(0, 2, "0X") == 0)) - base = 16; - errno = 0; - char* end_ptr; - unsigned long value = strtoul(str.c_str(), &end_ptr, base); - if (value == ULONG_MAX && errno == ERANGE) - return false; // Value out of range for unsigned long. - if (sizeof(unsigned long) > sizeof(uint32_t) && value > 0xFFFFFFFF) - return false; // Value out of range for uint32_t. - if (end_ptr - str.c_str() < static_cast(str.length())) - return false; // Part of the string was not parsed. - *ssrc = static_cast(value); - return true; -} - -// Flag validators. -bool ValidatePayloadType(int value) { - if (value >= 0 && value <= 127) // Value is ok. - return true; - printf("Payload type must be between 0 and 127, not %d\n", - static_cast(value)); - return false; -} - -bool ValidateSsrcValue(const std::string& str) { - uint32_t dummy_ssrc; - if (ParseSsrc(str, &dummy_ssrc)) // Value is ok. - return true; - printf("Invalid SSRC: %s\n", str.c_str()); - return false; -} - -static bool ValidateExtensionId(int value) { - if (value > 0 && value <= 255) // Value is ok. - return true; - printf("Extension ID must be between 1 and 255, not %d\n", - static_cast(value)); - return false; -} - -// Define command line flags. -DEFINE_int(pcmu, 0, "RTP payload type for PCM-u"); -DEFINE_int(pcma, 8, "RTP payload type for PCM-a"); -DEFINE_int(ilbc, 102, "RTP payload type for iLBC"); -DEFINE_int(isac, 103, "RTP payload type for iSAC"); -DEFINE_int(isac_swb, 104, "RTP payload type for iSAC-swb (32 kHz)"); -DEFINE_int(opus, 111, "RTP payload type for Opus"); -DEFINE_int(pcm16b, 93, "RTP payload type for PCM16b-nb (8 kHz)"); -DEFINE_int(pcm16b_wb, 94, "RTP payload type for PCM16b-wb (16 kHz)"); -DEFINE_int(pcm16b_swb32, 95, "RTP payload type for PCM16b-swb32 (32 kHz)"); -DEFINE_int(pcm16b_swb48, 96, "RTP payload type for PCM16b-swb48 (48 kHz)"); -DEFINE_int(g722, 9, "RTP payload type for G.722"); -DEFINE_int(avt, 106, "RTP payload type for AVT/DTMF (8 kHz)"); -DEFINE_int(avt_16, 114, "RTP payload type for AVT/DTMF (16 kHz)"); -DEFINE_int(avt_32, 115, "RTP payload type for AVT/DTMF (32 kHz)"); -DEFINE_int(avt_48, 116, "RTP payload type for AVT/DTMF (48 kHz)"); -DEFINE_int(red, 117, "RTP payload type for redundant audio (RED)"); -DEFINE_int(cn_nb, 13, "RTP payload type for comfort noise (8 kHz)"); -DEFINE_int(cn_wb, 98, "RTP payload type for comfort noise (16 kHz)"); -DEFINE_int(cn_swb32, 99, "RTP payload type for comfort noise (32 kHz)"); -DEFINE_int(cn_swb48, 100, "RTP payload type for comfort noise (48 kHz)"); -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)"); -DEFINE_int(audio_level, 1, "Extension ID for audio level (RFC 6464)"); -DEFINE_int(abs_send_time, 3, "Extension ID for absolute sender time"); -DEFINE_int(transport_seq_no, 5, "Extension ID for transport sequence number"); -DEFINE_int(video_content_type, 7, "Extension ID for video content type"); -DEFINE_int(video_timing, 8, "Extension ID for video timing"); -DEFINE_bool(matlabplot, - false, - "Generates a matlab script for plotting the delay profile"); -DEFINE_bool(pythonplot, - false, - "Generates a python script for plotting the delay profile"); -DEFINE_bool(help, false, "Prints this message"); -DEFINE_bool(concealment_events, false, "Prints concealment events"); -DEFINE_string( - force_fieldtrials, - "", - "Field trials control experimental feature code which can be forced. " - "E.g. running with --force_fieldtrials=WebRTC-FooFeature/Enable/" - " will assign the group Enable to field trial WebRTC-FooFeature."); - -// 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"; - case NetEqDecoder::kDecoderISAC: - return "iSAC"; - case NetEqDecoder::kDecoderISACswb: - return "iSAC-swb (32 kHz)"; - case NetEqDecoder::kDecoderOpus: - return "Opus"; - case NetEqDecoder::kDecoderPCM16B: - return "PCM16b-nb (8 kHz)"; - case NetEqDecoder::kDecoderPCM16Bwb: - return "PCM16b-wb (16 kHz)"; - case NetEqDecoder::kDecoderPCM16Bswb32kHz: - return "PCM16b-swb32 (32 kHz)"; - case NetEqDecoder::kDecoderPCM16Bswb48kHz: - return "PCM16b-swb48 (48 kHz)"; - case NetEqDecoder::kDecoderG722: - return "G.722"; - case NetEqDecoder::kDecoderRED: - return "redundant audio (RED)"; - case NetEqDecoder::kDecoderAVT: - return "AVT/DTMF (8 kHz)"; - case NetEqDecoder::kDecoderAVT16kHz: - return "AVT/DTMF (16 kHz)"; - case NetEqDecoder::kDecoderAVT32kHz: - return "AVT/DTMF (32 kHz)"; - case NetEqDecoder::kDecoderAVT48kHz: - return "AVT/DTMF (48 kHz)"; - case NetEqDecoder::kDecoderCNGnb: - return "comfort noise (8 kHz)"; - case NetEqDecoder::kDecoderCNGwb: - return "comfort noise (16 kHz)"; - case NetEqDecoder::kDecoderCNGswb32kHz: - return "comfort noise (32 kHz)"; - case NetEqDecoder::kDecoderCNGswb48kHz: - return "comfort noise (48 kHz)"; - default: - FATAL(); - return "undefined"; - } -} - -void PrintCodecMappingEntry(NetEqDecoder codec, int flag) { - std::cout << CodecName(codec) << ": " << flag << std::endl; -} - -void PrintCodecMapping() { - PrintCodecMappingEntry(NetEqDecoder::kDecoderPCMu, FLAG_pcmu); - PrintCodecMappingEntry(NetEqDecoder::kDecoderPCMa, FLAG_pcma); - PrintCodecMappingEntry(NetEqDecoder::kDecoderILBC, FLAG_ilbc); - PrintCodecMappingEntry(NetEqDecoder::kDecoderISAC, FLAG_isac); - PrintCodecMappingEntry(NetEqDecoder::kDecoderISACswb, FLAG_isac_swb); - PrintCodecMappingEntry(NetEqDecoder::kDecoderOpus, FLAG_opus); - PrintCodecMappingEntry(NetEqDecoder::kDecoderPCM16B, FLAG_pcm16b); - PrintCodecMappingEntry(NetEqDecoder::kDecoderPCM16Bwb, FLAG_pcm16b_wb); - PrintCodecMappingEntry(NetEqDecoder::kDecoderPCM16Bswb32kHz, - FLAG_pcm16b_swb32); - PrintCodecMappingEntry(NetEqDecoder::kDecoderPCM16Bswb48kHz, - FLAG_pcm16b_swb48); - PrintCodecMappingEntry(NetEqDecoder::kDecoderG722, FLAG_g722); - PrintCodecMappingEntry(NetEqDecoder::kDecoderAVT, FLAG_avt); - PrintCodecMappingEntry(NetEqDecoder::kDecoderAVT16kHz, FLAG_avt_16); - PrintCodecMappingEntry(NetEqDecoder::kDecoderAVT32kHz, FLAG_avt_32); - PrintCodecMappingEntry(NetEqDecoder::kDecoderAVT48kHz, FLAG_avt_48); - PrintCodecMappingEntry(NetEqDecoder::kDecoderRED, FLAG_red); - PrintCodecMappingEntry(NetEqDecoder::kDecoderCNGnb, FLAG_cn_nb); - PrintCodecMappingEntry(NetEqDecoder::kDecoderCNGwb, FLAG_cn_wb); - PrintCodecMappingEntry(NetEqDecoder::kDecoderCNGswb32kHz, FLAG_cn_swb32); - PrintCodecMappingEntry(NetEqDecoder::kDecoderCNGswb48kHz, FLAG_cn_swb48); -} - -absl::optional CodecSampleRate(uint8_t payload_type) { - if (payload_type == FLAG_pcmu || payload_type == FLAG_pcma || - payload_type == FLAG_ilbc || payload_type == FLAG_pcm16b || - payload_type == FLAG_cn_nb || payload_type == FLAG_avt) - return 8000; - if (payload_type == FLAG_isac || payload_type == FLAG_pcm16b_wb || - payload_type == FLAG_g722 || payload_type == FLAG_cn_wb || - payload_type == FLAG_avt_16) - return 16000; - if (payload_type == FLAG_isac_swb || payload_type == FLAG_pcm16b_swb32 || - payload_type == FLAG_cn_swb32 || payload_type == FLAG_avt_32) - return 32000; - if (payload_type == FLAG_opus || payload_type == FLAG_pcm16b_swb48 || - payload_type == FLAG_cn_swb48 || payload_type == FLAG_avt_48) - return 48000; - if (payload_type == FLAG_red) - return 0; - return absl::nullopt; -} - -// A callback class which prints whenver the inserted packet stream changes -// the SSRC. -class SsrcSwitchDetector : public NetEqPostInsertPacket { - public: - // Takes a pointer to another callback object, which will be invoked after - // this object finishes. This does not transfer ownership, and null is a - // valid value. - explicit SsrcSwitchDetector(NetEqPostInsertPacket* other_callback) - : other_callback_(other_callback) {} - - void AfterInsertPacket(const NetEqInput::PacketData& packet, - NetEq* neteq) override { - if (last_ssrc_ && packet.header.ssrc != *last_ssrc_) { - std::cout << "Changing streams from 0x" << std::hex << *last_ssrc_ - << " to 0x" << std::hex << packet.header.ssrc << std::dec - << " (payload type " - << static_cast(packet.header.payloadType) << ")" - << std::endl; - } - last_ssrc_ = packet.header.ssrc; - if (other_callback_) { - other_callback_->AfterInsertPacket(packet, neteq); - } - } - - private: - NetEqPostInsertPacket* other_callback_; - absl::optional last_ssrc_; -}; - -int RunTest(int argc, char* argv[]) { - std::string program_name = argv[0]; - std::string usage = - "Tool for decoding an RTP dump file using NetEq.\n" - "Run " + - program_name + - " --help for usage.\n" - "Example usage:\n" + - program_name + " input.rtp output.{pcm, wav}\n"; - if (rtc::FlagList::SetFlagsFromCommandLine(&argc, argv, true)) { - return 1; - } - if (FLAG_help) { - std::cout << usage; - rtc::FlagList::Print(nullptr, false); - return 0; - } - - if (FLAG_codec_map) { - PrintCodecMapping(); - } - - if (argc != 3) { - if (FLAG_codec_map) { - // We have already printed the codec map. Just end the program. - return 0; - } - // Print usage information. - std::cout << usage; - return 0; - } - - ValidateFieldTrialsStringOrDie(FLAG_force_fieldtrials); - ScopedFieldTrials field_trials(FLAG_force_fieldtrials); - - RTC_CHECK(ValidatePayloadType(FLAG_pcmu)); - RTC_CHECK(ValidatePayloadType(FLAG_pcma)); - RTC_CHECK(ValidatePayloadType(FLAG_ilbc)); - RTC_CHECK(ValidatePayloadType(FLAG_isac)); - RTC_CHECK(ValidatePayloadType(FLAG_isac_swb)); - RTC_CHECK(ValidatePayloadType(FLAG_opus)); - RTC_CHECK(ValidatePayloadType(FLAG_pcm16b)); - RTC_CHECK(ValidatePayloadType(FLAG_pcm16b_wb)); - RTC_CHECK(ValidatePayloadType(FLAG_pcm16b_swb32)); - RTC_CHECK(ValidatePayloadType(FLAG_pcm16b_swb48)); - RTC_CHECK(ValidatePayloadType(FLAG_g722)); - RTC_CHECK(ValidatePayloadType(FLAG_avt)); - RTC_CHECK(ValidatePayloadType(FLAG_avt_16)); - RTC_CHECK(ValidatePayloadType(FLAG_avt_32)); - RTC_CHECK(ValidatePayloadType(FLAG_avt_48)); - RTC_CHECK(ValidatePayloadType(FLAG_red)); - RTC_CHECK(ValidatePayloadType(FLAG_cn_nb)); - RTC_CHECK(ValidatePayloadType(FLAG_cn_wb)); - RTC_CHECK(ValidatePayloadType(FLAG_cn_swb32)); - RTC_CHECK(ValidatePayloadType(FLAG_cn_swb48)); - RTC_CHECK(ValidateSsrcValue(FLAG_ssrc)); - RTC_CHECK(ValidateExtensionId(FLAG_audio_level)); - RTC_CHECK(ValidateExtensionId(FLAG_abs_send_time)); - RTC_CHECK(ValidateExtensionId(FLAG_transport_seq_no)); - RTC_CHECK(ValidateExtensionId(FLAG_video_content_type)); - RTC_CHECK(ValidateExtensionId(FLAG_video_timing)); - - // Gather RTP header extensions in a map. - NetEqPacketSourceInput::RtpHeaderExtensionMap rtp_ext_map = { - {FLAG_audio_level, kRtpExtensionAudioLevel}, - {FLAG_abs_send_time, kRtpExtensionAbsoluteSendTime}, - {FLAG_transport_seq_no, kRtpExtensionTransportSequenceNumber}, - {FLAG_video_content_type, kRtpExtensionVideoContentType}, - {FLAG_video_timing, kRtpExtensionVideoTiming}}; - - const std::string input_file_name = argv[1]; - std::unique_ptr input; - if (RtpFileSource::ValidRtpDump(input_file_name) || - RtpFileSource::ValidPcap(input_file_name)) { - input.reset(new NetEqRtpDumpInput(input_file_name, rtp_ext_map)); - } else { - 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 (strlen(FLAG_ssrc) > 0) { - uint32_t ssrc; - RTC_CHECK(ParseSsrc(FLAG_ssrc, &ssrc)) << "Flag verification has failed."; - static_cast(input.get())->SelectSsrc(ssrc); - } - - // Check the sample rate. - absl::optional sample_rate_hz; - std::set> discarded_pt_and_ssrc; - while (absl::optional first_rtp_header = input->NextHeader()) { - RTC_DCHECK(first_rtp_header); - sample_rate_hz = CodecSampleRate(first_rtp_header->payloadType); - if (sample_rate_hz) { - std::cout << "Found valid packet with payload type " - << static_cast(first_rtp_header->payloadType) - << " and SSRC 0x" << std::hex << first_rtp_header->ssrc - << std::dec << std::endl; - break; - } - // Discard this packet and move to the next. Keep track of discarded payload - // types and SSRCs. - discarded_pt_and_ssrc.emplace(first_rtp_header->payloadType, - first_rtp_header->ssrc); - input->PopPacket(); - } - if (!discarded_pt_and_ssrc.empty()) { - std::cout << "Discarded initial packets with the following payload types " - "and SSRCs:" - << std::endl; - for (const auto& d : discarded_pt_and_ssrc) { - std::cout << "PT " << d.first << "; SSRC 0x" << std::hex - << static_cast(d.second) << std::dec << std::endl; - } - } - if (!sample_rate_hz) { - std::cout << "Cannot find any packets with known payload types" - << std::endl; - RTC_NOTREACHED(); - } - - // Open the output file now that we know the sample rate. (Rate is only needed - // for wav files.) - const std::string output_file_name = argv[2]; - std::unique_ptr output; - if (output_file_name.size() >= 4 && - output_file_name.substr(output_file_name.size() - 4) == ".wav") { - // Open a wav file. - output.reset(new OutputWavFile(output_file_name, *sample_rate_hz)); - } else { - // Open a pcm file. - output.reset(new OutputAudioFile(output_file_name)); - } - - std::cout << "Output file: " << output_file_name << std::endl; - - NetEqTest::DecoderMap codecs = { - {FLAG_pcmu, std::make_pair(NetEqDecoder::kDecoderPCMu, "pcmu")}, - {FLAG_pcma, std::make_pair(NetEqDecoder::kDecoderPCMa, "pcma")}, -#ifdef WEBRTC_CODEC_ILBC - {FLAG_ilbc, std::make_pair(NetEqDecoder::kDecoderILBC, "ilbc")}, -#endif - {FLAG_isac, std::make_pair(NetEqDecoder::kDecoderISAC, "isac")}, -#if !defined(WEBRTC_ANDROID) - {FLAG_isac_swb, std::make_pair(NetEqDecoder::kDecoderISACswb, "isac-swb")}, -#endif -#ifdef WEBRTC_CODEC_OPUS - {FLAG_opus, std::make_pair(NetEqDecoder::kDecoderOpus, "opus")}, -#endif - {FLAG_pcm16b, std::make_pair(NetEqDecoder::kDecoderPCM16B, "pcm16-nb")}, - {FLAG_pcm16b_wb, - std::make_pair(NetEqDecoder::kDecoderPCM16Bwb, "pcm16-wb")}, - {FLAG_pcm16b_swb32, - std::make_pair(NetEqDecoder::kDecoderPCM16Bswb32kHz, "pcm16-swb32")}, - {FLAG_pcm16b_swb48, - std::make_pair(NetEqDecoder::kDecoderPCM16Bswb48kHz, "pcm16-swb48")}, - {FLAG_g722, std::make_pair(NetEqDecoder::kDecoderG722, "g722")}, - {FLAG_avt, std::make_pair(NetEqDecoder::kDecoderAVT, "avt")}, - {FLAG_avt_16, std::make_pair(NetEqDecoder::kDecoderAVT16kHz, "avt-16")}, - {FLAG_avt_32, std::make_pair(NetEqDecoder::kDecoderAVT32kHz, "avt-32")}, - {FLAG_avt_48, std::make_pair(NetEqDecoder::kDecoderAVT48kHz, "avt-48")}, - {FLAG_red, std::make_pair(NetEqDecoder::kDecoderRED, "red")}, - {FLAG_cn_nb, std::make_pair(NetEqDecoder::kDecoderCNGnb, "cng-nb")}, - {FLAG_cn_wb, std::make_pair(NetEqDecoder::kDecoderCNGwb, "cng-wb")}, - {FLAG_cn_swb32, - std::make_pair(NetEqDecoder::kDecoderCNGswb32kHz, "cng-swb32")}, - {FLAG_cn_swb48, - std::make_pair(NetEqDecoder::kDecoderCNGswb48kHz, "cng-swb48")} - }; - - // Check if a replacement audio file was provided. - std::unique_ptr replacement_decoder; - NetEqTest::ExtDecoderMap ext_codecs; - if (strlen(FLAG_replacement_audio_file) > 0) { - // Find largest unused payload type. - int replacement_pt = 127; - while (!(codecs.find(replacement_pt) == codecs.end() && - ext_codecs.find(replacement_pt) == ext_codecs.end())) { - --replacement_pt; - RTC_CHECK_GE(replacement_pt, 0); - } - - auto std_set_int32_to_uint8 = [](const std::set& a) { - std::set b; - for (auto& x : a) { - b.insert(static_cast(x)); - } - return b; - }; - - std::set cn_types = std_set_int32_to_uint8( - {FLAG_cn_nb, FLAG_cn_wb, FLAG_cn_swb32, FLAG_cn_swb48}); - std::set forbidden_types = std_set_int32_to_uint8( - {FLAG_g722, FLAG_red, FLAG_avt, FLAG_avt_16, FLAG_avt_32, FLAG_avt_48}); - input.reset(new NetEqReplacementInput(std::move(input), replacement_pt, - cn_types, forbidden_types)); - - replacement_decoder.reset(new FakeDecodeFromFile( - std::unique_ptr( - new InputAudioFile(FLAG_replacement_audio_file)), - 48000, false)); - NetEqTest::ExternalDecoderInfo ext_dec_info = { - replacement_decoder.get(), NetEqDecoder::kDecoderArbitrary, - "replacement codec"}; - ext_codecs[replacement_pt] = ext_dec_info; - } - - NetEqTest::Callbacks callbacks; - std::unique_ptr delay_analyzer; - if (FLAG_matlabplot || FLAG_pythonplot) { - delay_analyzer.reset(new NetEqDelayAnalyzer); - } - - SsrcSwitchDetector ssrc_switch_detector(delay_analyzer.get()); - callbacks.post_insert_packet = &ssrc_switch_detector; - NetEqStatsGetter stats_getter(std::move(delay_analyzer)); - callbacks.get_audio_callback = &stats_getter; - NetEq::Config config; - config.sample_rate_hz = *sample_rate_hz; - NetEqTest test(config, codecs, ext_codecs, std::move(input), - std::move(output), callbacks); - - int64_t test_duration_ms = test.Run(); - - if (FLAG_matlabplot) { - auto matlab_script_name = output_file_name; - std::replace(matlab_script_name.begin(), matlab_script_name.end(), '.', - '_'); - std::cout << "Creating Matlab plot script " << matlab_script_name + ".m" - << std::endl; - stats_getter.delay_analyzer()->CreateMatlabScript(matlab_script_name + - ".m"); - } - if (FLAG_pythonplot) { - auto python_script_name = output_file_name; - std::replace(python_script_name.begin(), python_script_name.end(), '.', - '_'); - std::cout << "Creating Python plot script " << python_script_name + ".py" - << std::endl; - stats_getter.delay_analyzer()->CreatePythonScript(python_script_name + - ".py"); - } - - printf("Simulation statistics:\n"); - printf(" output duration: %" PRId64 " ms\n", test_duration_ms); - auto stats = stats_getter.AverageStats(); - printf(" packet_loss_rate: %f %%\n", 100.0 * stats.packet_loss_rate); - printf(" expand_rate: %f %%\n", 100.0 * stats.expand_rate); - printf(" speech_expand_rate: %f %%\n", 100.0 * stats.speech_expand_rate); - printf(" preemptive_rate: %f %%\n", 100.0 * stats.preemptive_rate); - printf(" accelerate_rate: %f %%\n", 100.0 * stats.accelerate_rate); - printf(" secondary_decoded_rate: %f %%\n", - 100.0 * stats.secondary_decoded_rate); - printf(" secondary_discarded_rate: %f %%\n", - 100.0 * stats.secondary_discarded_rate); - printf(" clockdrift_ppm: %f ppm\n", stats.clockdrift_ppm); - printf(" mean_waiting_time_ms: %f ms\n", stats.mean_waiting_time_ms); - printf(" median_waiting_time_ms: %f ms\n", stats.median_waiting_time_ms); - printf(" min_waiting_time_ms: %f ms\n", stats.min_waiting_time_ms); - printf(" max_waiting_time_ms: %f ms\n", stats.max_waiting_time_ms); - printf(" current_buffer_size_ms: %f ms\n", stats.current_buffer_size_ms); - printf(" preferred_buffer_size_ms: %f ms\n", stats.preferred_buffer_size_ms); - if (FLAG_concealment_events) { - std::cout << " concealment_events_ms:" << std::endl; - for (auto concealment_event : stats_getter.concealment_events()) - std::cout << concealment_event.ToString() << std::endl; - std::cout << " end of concealment_events_ms" << std::endl; - } - return 0; -} - -} // namespace -} // namespace test -} // namespace webrtc +#include "modules/audio_coding/neteq/tools/neteq_test_factory.h" int main(int argc, char* argv[]) { - return webrtc::test::RunTest(argc, argv); + webrtc::test::NetEqTestFactory factory; + std::unique_ptr test = + factory.InitializeTest(argc, argv); + test->Run(); + return 0; } diff --git a/modules/audio_coding/neteq/tools/neteq_stats_plotter.cc b/modules/audio_coding/neteq/tools/neteq_stats_plotter.cc new file mode 100644 index 0000000000..3f86cfdb22 --- /dev/null +++ b/modules/audio_coding/neteq/tools/neteq_stats_plotter.cc @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2018 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 "modules/audio_coding/neteq/tools/neteq_stats_plotter.h" + +#include +#include +#include + +namespace webrtc { +namespace test { + +NetEqStatsPlotter::NetEqStatsPlotter(bool make_matlab_plot, + bool make_python_plot, + bool show_concealment_events, + std::string base_file_name) + : make_matlab_plot_(make_matlab_plot), + make_python_plot_(make_python_plot), + show_concealment_events_(show_concealment_events), + base_file_name_(base_file_name) { + std::unique_ptr delay_analyzer; + if (make_matlab_plot || make_python_plot) { + delay_analyzer.reset(new NetEqDelayAnalyzer); + } + stats_getter_.reset(new NetEqStatsGetter(std::move(delay_analyzer))); +} + +void NetEqStatsPlotter::SimulationEnded(int64_t simulation_time_ms) { + if (make_matlab_plot_) { + auto matlab_script_name = base_file_name_; + std::replace(matlab_script_name.begin(), matlab_script_name.end(), '.', + '_'); + printf("Creating Matlab plot script %s.m\n", matlab_script_name.c_str()); + stats_getter_->delay_analyzer()->CreateMatlabScript(matlab_script_name + + ".m"); + } + if (make_python_plot_) { + auto python_script_name = base_file_name_; + std::replace(python_script_name.begin(), python_script_name.end(), '.', + '_'); + printf("Creating Python plot script %s.py\n", python_script_name.c_str()); + stats_getter_->delay_analyzer()->CreatePythonScript(python_script_name + + ".py"); + } + + printf("Simulation statistics:\n"); + printf(" output duration: %" PRId64 " ms\n", simulation_time_ms); + auto stats = stats_getter_->AverageStats(); + printf(" packet_loss_rate: %f %%\n", 100.0 * stats.packet_loss_rate); + printf(" expand_rate: %f %%\n", 100.0 * stats.expand_rate); + printf(" speech_expand_rate: %f %%\n", 100.0 * stats.speech_expand_rate); + printf(" preemptive_rate: %f %%\n", 100.0 * stats.preemptive_rate); + printf(" accelerate_rate: %f %%\n", 100.0 * stats.accelerate_rate); + printf(" secondary_decoded_rate: %f %%\n", + 100.0 * stats.secondary_decoded_rate); + printf(" secondary_discarded_rate: %f %%\n", + 100.0 * stats.secondary_discarded_rate); + printf(" clockdrift_ppm: %f ppm\n", stats.clockdrift_ppm); + printf(" mean_waiting_time_ms: %f ms\n", stats.mean_waiting_time_ms); + printf(" median_waiting_time_ms: %f ms\n", stats.median_waiting_time_ms); + printf(" min_waiting_time_ms: %f ms\n", stats.min_waiting_time_ms); + printf(" max_waiting_time_ms: %f ms\n", stats.max_waiting_time_ms); + printf(" current_buffer_size_ms: %f ms\n", stats.current_buffer_size_ms); + printf(" preferred_buffer_size_ms: %f ms\n", stats.preferred_buffer_size_ms); + if (show_concealment_events_) { + printf(" concealment_events_ms:\n"); + for (auto concealment_event : stats_getter_->concealment_events()) + printf("%s\n", concealment_event.ToString().c_str()); + printf(" end of concealment_events_ms\n"); + } +} + +} // namespace test +} // namespace webrtc diff --git a/modules/audio_coding/neteq/tools/neteq_stats_plotter.h b/modules/audio_coding/neteq/tools/neteq_stats_plotter.h new file mode 100644 index 0000000000..c4df24e073 --- /dev/null +++ b/modules/audio_coding/neteq/tools/neteq_stats_plotter.h @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2018 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. + */ + +#ifndef MODULES_AUDIO_CODING_NETEQ_TOOLS_NETEQ_STATS_PLOTTER_H_ +#define MODULES_AUDIO_CODING_NETEQ_TOOLS_NETEQ_STATS_PLOTTER_H_ + +#include +#include + +#include "modules/audio_coding/neteq/tools/neteq_delay_analyzer.h" +#include "modules/audio_coding/neteq/tools/neteq_stats_getter.h" +#include "modules/audio_coding/neteq/tools/neteq_test.h" + +namespace webrtc { +namespace test { + +class NetEqStatsPlotter : public NetEqSimulationEndedCallback { + public: + NetEqStatsPlotter(bool make_matlab_plot, + bool make_python_plot, + bool show_concealment_events, + std::string base_file_name); + + void SimulationEnded(int64_t simulation_time_ms) override; + + NetEqStatsGetter* stats_getter() { return stats_getter_.get(); } + + private: + std::unique_ptr stats_getter_; + const bool make_matlab_plot_; + const bool make_python_plot_; + const bool show_concealment_events_; + const std::string base_file_name_; +}; + +} // namespace test +} // namespace webrtc + +#endif // MODULES_AUDIO_CODING_NETEQ_TOOLS_NETEQ_STATS_PLOTTER_H_ diff --git a/modules/audio_coding/neteq/tools/neteq_test.cc b/modules/audio_coding/neteq/tools/neteq_test.cc index 3448f4e840..110819c85b 100644 --- a/modules/audio_coding/neteq/tools/neteq_test.cc +++ b/modules/audio_coding/neteq/tools/neteq_test.cc @@ -16,6 +16,26 @@ namespace webrtc { namespace test { +namespace { + +absl::optional ActionToOperations( + absl::optional a) { + if (!a) { + return absl::nullopt; + } + switch (*a) { + case NetEqSimulator::Action::kAccelerate: + return absl::make_optional(kAccelerate); + case NetEqSimulator::Action::kExpand: + return absl::make_optional(kExpand); + case NetEqSimulator::Action::kNormal: + return absl::make_optional(kNormal); + case NetEqSimulator::Action::kPreemptiveExpand: + return absl::make_optional(kPreemptiveExpand); + } +} + +} // namespace void DefaultNetEqTestErrorCallback::OnInsertPacketError( const NetEqInput::PacketData& packet) { @@ -49,6 +69,20 @@ NetEqTest::NetEqTest(const NetEq::Config& config, NetEqTest::~NetEqTest() = default; int64_t NetEqTest::Run() { + int64_t simulation_time = 0; + SimulationStepResult step_result; + do { + step_result = RunToNextGetAudio(); + simulation_time += step_result.simulation_step_ms; + } while (!step_result.is_simulation_finished); + if (callbacks_.simulation_ended_callback) { + callbacks_.simulation_ended_callback->SimulationEnded(simulation_time); + } + return simulation_time; +} + +NetEqTest::SimulationStepResult NetEqTest::RunToNextGetAudio() { + SimulationStepResult result; const int64_t start_time_ms = *input_->NextEventTime(); int64_t time_now_ms = start_time_ms; @@ -81,7 +115,9 @@ int64_t NetEqTest::Run() { } AudioFrame out_frame; bool muted; - int error = neteq_->GetAudio(&out_frame, &muted); + int error = neteq_->GetAudio(&out_frame, &muted, + ActionToOperations(next_action_)); + next_action_ = absl::nullopt; RTC_CHECK(!muted) << "The code does not handle enable_muted_state"; if (error != NetEq::kOK) { if (callbacks_.error_callback) { @@ -102,9 +138,26 @@ int64_t NetEqTest::Run() { } input_->AdvanceOutputEvent(); + result.simulation_step_ms = time_now_ms - start_time_ms; + // TODO(ivoc): Set the result._ms values correctly. + result.is_simulation_finished = input_->ended(); + return result; } } - return time_now_ms - start_time_ms; + result.simulation_step_ms = time_now_ms - start_time_ms; + result.is_simulation_finished = true; + return result; +} + +void NetEqTest::SetNextAction(NetEqTest::Action next_operation) { + next_action_ = absl::optional(next_operation); +} + +NetEqTest::NetEqState NetEqTest::GetNetEqState() { + NetEqState state; + const auto network_stats = SimulationStats(); + state.current_delay_ms = network_stats.current_buffer_size_ms; + return state; } NetEqNetworkStatistics NetEqTest::SimulationStats() { diff --git a/modules/audio_coding/neteq/tools/neteq_test.h b/modules/audio_coding/neteq/tools/neteq_test.h index ada6bab5bc..c5580456ad 100644 --- a/modules/audio_coding/neteq/tools/neteq_test.h +++ b/modules/audio_coding/neteq/tools/neteq_test.h @@ -16,6 +16,8 @@ #include #include +#include "absl/types/optional.h" +#include "api/test/neteq_simulator.h" #include "modules/audio_coding/neteq/include/neteq.h" #include "modules/audio_coding/neteq/tools/audio_sink.h" #include "modules/audio_coding/neteq/tools/neteq_input.h" @@ -52,10 +54,16 @@ class NetEqGetAudioCallback { NetEq* neteq) = 0; }; +class NetEqSimulationEndedCallback { + public: + virtual ~NetEqSimulationEndedCallback() = default; + virtual void SimulationEnded(int64_t simulation_time_ms) = 0; +}; + // Class that provides an input--output test for NetEq. The input (both packets // and output events) is provided by a NetEqInput object, while the output is // directed to an AudioSink object. -class NetEqTest { +class NetEqTest : public NetEqSimulator { public: using DecoderMap = std::map >; @@ -71,6 +79,7 @@ class NetEqTest { NetEqTestErrorCallback* error_callback = nullptr; NetEqPostInsertPacket* post_insert_packet = nullptr; NetEqGetAudioCallback* get_audio_callback = nullptr; + NetEqSimulationEndedCallback* simulation_ended_callback = nullptr; }; // Sets up the test with given configuration, codec mappings, input, ouput, @@ -82,10 +91,17 @@ class NetEqTest { std::unique_ptr output, Callbacks callbacks); - ~NetEqTest(); + ~NetEqTest() override; // Runs the test. Returns the duration of the produced audio in ms. int64_t Run(); + // Runs the simulation until we hit the next GetAudio event. If the simulation + // is finished, is_simulation_finished will be set to true in the returned + // SimulationStepResult. + SimulationStepResult RunToNextGetAudio() override; + + void SetNextAction(Action next_operation) override; + NetEqState GetNetEqState() override; // Returns the statistics from NetEq. NetEqNetworkStatistics SimulationStats(); @@ -96,7 +112,7 @@ class NetEqTest { private: void RegisterDecoders(const DecoderMap& codecs); void RegisterExternalDecoders(const ExtDecoderMap& codecs); - + absl::optional next_action_; std::unique_ptr neteq_; std::unique_ptr input_; std::unique_ptr output_; diff --git a/modules/audio_coding/neteq/tools/neteq_test_factory.cc b/modules/audio_coding/neteq/tools/neteq_test_factory.cc new file mode 100644 index 0000000000..9ab2310593 --- /dev/null +++ b/modules/audio_coding/neteq/tools/neteq_test_factory.cc @@ -0,0 +1,509 @@ +/* + * Copyright (c) 2018 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 "modules/audio_coding/neteq/tools/neteq_test_factory.h" + +#include +#include // For ULONG_MAX returned by strtoul. +#include +#include // For strtoul. +#include +#include +#include +#include +#include + +#include "absl/memory/memory.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" +#include "modules/audio_coding/neteq/tools/neteq_delay_analyzer.h" +#include "modules/audio_coding/neteq/tools/neteq_event_log_input.h" +#include "modules/audio_coding/neteq/tools/neteq_packet_source_input.h" +#include "modules/audio_coding/neteq/tools/neteq_replacement_input.h" +#include "modules/audio_coding/neteq/tools/neteq_stats_getter.h" +#include "modules/audio_coding/neteq/tools/neteq_stats_plotter.h" +#include "modules/audio_coding/neteq/tools/neteq_test.h" +#include "modules/audio_coding/neteq/tools/output_audio_file.h" +#include "modules/audio_coding/neteq/tools/output_wav_file.h" +#include "modules/audio_coding/neteq/tools/rtp_file_source.h" +#include "rtc_base/checks.h" +#include "rtc_base/flags.h" +#include "test/field_trial.h" +#include "test/testsupport/fileutils.h" + +namespace webrtc { +namespace test { +namespace { + +// Parses the input string for a valid SSRC (at the start of the string). If a +// valid SSRC is found, it is written to the output variable |ssrc|, and true is +// returned. Otherwise, false is returned. +bool ParseSsrc(const std::string& str, uint32_t* ssrc) { + if (str.empty()) + return true; + int base = 10; + // Look for "0x" or "0X" at the start and change base to 16 if found. + if ((str.compare(0, 2, "0x") == 0) || (str.compare(0, 2, "0X") == 0)) + base = 16; + errno = 0; + char* end_ptr; + unsigned long value = strtoul(str.c_str(), &end_ptr, base); // NOLINT + if (value == ULONG_MAX && errno == ERANGE) + return false; // Value out of range for unsigned long. + if (sizeof(unsigned long) > sizeof(uint32_t) && value > 0xFFFFFFFF) // NOLINT + return false; // Value out of range for uint32_t. + if (end_ptr - str.c_str() < static_cast(str.length())) + return false; // Part of the string was not parsed. + *ssrc = static_cast(value); + return true; +} + +// Flag validators. +bool ValidatePayloadType(int value) { + if (value >= 0 && value <= 127) // Value is ok. + return true; + printf("Payload type must be between 0 and 127, not %d\n", + static_cast(value)); + return false; +} + +bool ValidateSsrcValue(const std::string& str) { + uint32_t dummy_ssrc; + if (ParseSsrc(str, &dummy_ssrc)) // Value is ok. + return true; + printf("Invalid SSRC: %s\n", str.c_str()); + return false; +} + +static bool ValidateExtensionId(int value) { + if (value > 0 && value <= 255) // Value is ok. + return true; + printf("Extension ID must be between 1 and 255, not %d\n", + static_cast(value)); + return false; +} + +// Define command line flags. +DEFINE_int(pcmu, 0, "RTP payload type for PCM-u"); +DEFINE_int(pcma, 8, "RTP payload type for PCM-a"); +DEFINE_int(ilbc, 102, "RTP payload type for iLBC"); +DEFINE_int(isac, 103, "RTP payload type for iSAC"); +DEFINE_int(isac_swb, 104, "RTP payload type for iSAC-swb (32 kHz)"); +DEFINE_int(opus, 111, "RTP payload type for Opus"); +DEFINE_int(pcm16b, 93, "RTP payload type for PCM16b-nb (8 kHz)"); +DEFINE_int(pcm16b_wb, 94, "RTP payload type for PCM16b-wb (16 kHz)"); +DEFINE_int(pcm16b_swb32, 95, "RTP payload type for PCM16b-swb32 (32 kHz)"); +DEFINE_int(pcm16b_swb48, 96, "RTP payload type for PCM16b-swb48 (48 kHz)"); +DEFINE_int(g722, 9, "RTP payload type for G.722"); +DEFINE_int(avt, 106, "RTP payload type for AVT/DTMF (8 kHz)"); +DEFINE_int(avt_16, 114, "RTP payload type for AVT/DTMF (16 kHz)"); +DEFINE_int(avt_32, 115, "RTP payload type for AVT/DTMF (32 kHz)"); +DEFINE_int(avt_48, 116, "RTP payload type for AVT/DTMF (48 kHz)"); +DEFINE_int(red, 117, "RTP payload type for redundant audio (RED)"); +DEFINE_int(cn_nb, 13, "RTP payload type for comfort noise (8 kHz)"); +DEFINE_int(cn_wb, 98, "RTP payload type for comfort noise (16 kHz)"); +DEFINE_int(cn_swb32, 99, "RTP payload type for comfort noise (32 kHz)"); +DEFINE_int(cn_swb48, 100, "RTP payload type for comfort noise (48 kHz)"); +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)"); +DEFINE_int(audio_level, 1, "Extension ID for audio level (RFC 6464)"); +DEFINE_int(abs_send_time, 3, "Extension ID for absolute sender time"); +DEFINE_int(transport_seq_no, 5, "Extension ID for transport sequence number"); +DEFINE_int(video_content_type, 7, "Extension ID for video content type"); +DEFINE_int(video_timing, 8, "Extension ID for video timing"); +DEFINE_bool(matlabplot, + false, + "Generates a matlab script for plotting the delay profile"); +DEFINE_bool(pythonplot, + false, + "Generates a python script for plotting the delay profile"); +DEFINE_bool(help, false, "Prints this message"); +DEFINE_bool(concealment_events, false, "Prints concealment events"); +DEFINE_string( + force_fieldtrials, + "", + "Field trials control experimental feature code which can be forced. " + "E.g. running with --force_fieldtrials=WebRTC-FooFeature/Enable/" + " will assign the group Enable to field trial WebRTC-FooFeature."); + +// 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"; + case NetEqDecoder::kDecoderISAC: + return "iSAC"; + case NetEqDecoder::kDecoderISACswb: + return "iSAC-swb (32 kHz)"; + case NetEqDecoder::kDecoderOpus: + return "Opus"; + case NetEqDecoder::kDecoderPCM16B: + return "PCM16b-nb (8 kHz)"; + case NetEqDecoder::kDecoderPCM16Bwb: + return "PCM16b-wb (16 kHz)"; + case NetEqDecoder::kDecoderPCM16Bswb32kHz: + return "PCM16b-swb32 (32 kHz)"; + case NetEqDecoder::kDecoderPCM16Bswb48kHz: + return "PCM16b-swb48 (48 kHz)"; + case NetEqDecoder::kDecoderG722: + return "G.722"; + case NetEqDecoder::kDecoderRED: + return "redundant audio (RED)"; + case NetEqDecoder::kDecoderAVT: + return "AVT/DTMF (8 kHz)"; + case NetEqDecoder::kDecoderAVT16kHz: + return "AVT/DTMF (16 kHz)"; + case NetEqDecoder::kDecoderAVT32kHz: + return "AVT/DTMF (32 kHz)"; + case NetEqDecoder::kDecoderAVT48kHz: + return "AVT/DTMF (48 kHz)"; + case NetEqDecoder::kDecoderCNGnb: + return "comfort noise (8 kHz)"; + case NetEqDecoder::kDecoderCNGwb: + return "comfort noise (16 kHz)"; + case NetEqDecoder::kDecoderCNGswb32kHz: + return "comfort noise (32 kHz)"; + case NetEqDecoder::kDecoderCNGswb48kHz: + return "comfort noise (48 kHz)"; + default: + FATAL(); + return "undefined"; + } +} + +void PrintCodecMappingEntry(NetEqDecoder codec, int flag) { + std::cout << CodecName(codec) << ": " << flag << std::endl; +} + +void PrintCodecMapping() { + PrintCodecMappingEntry(NetEqDecoder::kDecoderPCMu, FLAG_pcmu); + PrintCodecMappingEntry(NetEqDecoder::kDecoderPCMa, FLAG_pcma); + PrintCodecMappingEntry(NetEqDecoder::kDecoderILBC, FLAG_ilbc); + PrintCodecMappingEntry(NetEqDecoder::kDecoderISAC, FLAG_isac); + PrintCodecMappingEntry(NetEqDecoder::kDecoderISACswb, FLAG_isac_swb); + PrintCodecMappingEntry(NetEqDecoder::kDecoderOpus, FLAG_opus); + PrintCodecMappingEntry(NetEqDecoder::kDecoderPCM16B, FLAG_pcm16b); + PrintCodecMappingEntry(NetEqDecoder::kDecoderPCM16Bwb, FLAG_pcm16b_wb); + PrintCodecMappingEntry(NetEqDecoder::kDecoderPCM16Bswb32kHz, + FLAG_pcm16b_swb32); + PrintCodecMappingEntry(NetEqDecoder::kDecoderPCM16Bswb48kHz, + FLAG_pcm16b_swb48); + PrintCodecMappingEntry(NetEqDecoder::kDecoderG722, FLAG_g722); + PrintCodecMappingEntry(NetEqDecoder::kDecoderAVT, FLAG_avt); + PrintCodecMappingEntry(NetEqDecoder::kDecoderAVT16kHz, FLAG_avt_16); + PrintCodecMappingEntry(NetEqDecoder::kDecoderAVT32kHz, FLAG_avt_32); + PrintCodecMappingEntry(NetEqDecoder::kDecoderAVT48kHz, FLAG_avt_48); + PrintCodecMappingEntry(NetEqDecoder::kDecoderRED, FLAG_red); + PrintCodecMappingEntry(NetEqDecoder::kDecoderCNGnb, FLAG_cn_nb); + PrintCodecMappingEntry(NetEqDecoder::kDecoderCNGwb, FLAG_cn_wb); + PrintCodecMappingEntry(NetEqDecoder::kDecoderCNGswb32kHz, FLAG_cn_swb32); + PrintCodecMappingEntry(NetEqDecoder::kDecoderCNGswb48kHz, FLAG_cn_swb48); +} + +absl::optional CodecSampleRate(uint8_t payload_type) { + if (payload_type == FLAG_pcmu || payload_type == FLAG_pcma || + payload_type == FLAG_ilbc || payload_type == FLAG_pcm16b || + payload_type == FLAG_cn_nb || payload_type == FLAG_avt) + return 8000; + if (payload_type == FLAG_isac || payload_type == FLAG_pcm16b_wb || + payload_type == FLAG_g722 || payload_type == FLAG_cn_wb || + payload_type == FLAG_avt_16) + return 16000; + if (payload_type == FLAG_isac_swb || payload_type == FLAG_pcm16b_swb32 || + payload_type == FLAG_cn_swb32 || payload_type == FLAG_avt_32) + return 32000; + if (payload_type == FLAG_opus || payload_type == FLAG_pcm16b_swb48 || + payload_type == FLAG_cn_swb48 || payload_type == FLAG_avt_48) + return 48000; + if (payload_type == FLAG_red) + return 0; + return absl::nullopt; +} + +} // namespace + +// A callback class which prints whenver the inserted packet stream changes +// the SSRC. +class SsrcSwitchDetector : public NetEqPostInsertPacket { + public: + // Takes a pointer to another callback object, which will be invoked after + // this object finishes. This does not transfer ownership, and null is a + // valid value. + explicit SsrcSwitchDetector(NetEqPostInsertPacket* other_callback) + : other_callback_(other_callback) {} + + void AfterInsertPacket(const NetEqInput::PacketData& packet, + NetEq* neteq) override { + if (last_ssrc_ && packet.header.ssrc != *last_ssrc_) { + std::cout << "Changing streams from 0x" << std::hex << *last_ssrc_ + << " to 0x" << std::hex << packet.header.ssrc << std::dec + << " (payload type " + << static_cast(packet.header.payloadType) << ")" + << std::endl; + } + last_ssrc_ = packet.header.ssrc; + if (other_callback_) { + other_callback_->AfterInsertPacket(packet, neteq); + } + } + + private: + NetEqPostInsertPacket* other_callback_; + absl::optional last_ssrc_; +}; + +NetEqTestFactory::NetEqTestFactory() = default; + +NetEqTestFactory::~NetEqTestFactory() = default; + +std::unique_ptr NetEqTestFactory::InitializeTest(int argc, + char* argv[]) { + std::string program_name = argv[0]; + std::string usage = + "Tool for decoding an RTP dump file using NetEq.\n" + "Run " + + program_name + + " --help for usage.\n" + "Example usage:\n" + + program_name + " input.rtp output.{pcm, wav}\n"; + if (rtc::FlagList::SetFlagsFromCommandLine(&argc, argv, true)) { + exit(1); + } + if (FLAG_help) { + std::cout << usage; + rtc::FlagList::Print(nullptr, false); + exit(0); + } + + if (FLAG_codec_map) { + PrintCodecMapping(); + } + + if (argc != 3) { + if (FLAG_codec_map) { + // We have already printed the codec map. Just end the program. + exit(0); + } + // Print usage information. + std::cout << usage; + exit(0); + } + + ValidateFieldTrialsStringOrDie(FLAG_force_fieldtrials); + ScopedFieldTrials field_trials(FLAG_force_fieldtrials); + + RTC_CHECK(ValidatePayloadType(FLAG_pcmu)); + RTC_CHECK(ValidatePayloadType(FLAG_pcma)); + RTC_CHECK(ValidatePayloadType(FLAG_ilbc)); + RTC_CHECK(ValidatePayloadType(FLAG_isac)); + RTC_CHECK(ValidatePayloadType(FLAG_isac_swb)); + RTC_CHECK(ValidatePayloadType(FLAG_opus)); + RTC_CHECK(ValidatePayloadType(FLAG_pcm16b)); + RTC_CHECK(ValidatePayloadType(FLAG_pcm16b_wb)); + RTC_CHECK(ValidatePayloadType(FLAG_pcm16b_swb32)); + RTC_CHECK(ValidatePayloadType(FLAG_pcm16b_swb48)); + RTC_CHECK(ValidatePayloadType(FLAG_g722)); + RTC_CHECK(ValidatePayloadType(FLAG_avt)); + RTC_CHECK(ValidatePayloadType(FLAG_avt_16)); + RTC_CHECK(ValidatePayloadType(FLAG_avt_32)); + RTC_CHECK(ValidatePayloadType(FLAG_avt_48)); + RTC_CHECK(ValidatePayloadType(FLAG_red)); + RTC_CHECK(ValidatePayloadType(FLAG_cn_nb)); + RTC_CHECK(ValidatePayloadType(FLAG_cn_wb)); + RTC_CHECK(ValidatePayloadType(FLAG_cn_swb32)); + RTC_CHECK(ValidatePayloadType(FLAG_cn_swb48)); + RTC_CHECK(ValidateSsrcValue(FLAG_ssrc)); + RTC_CHECK(ValidateExtensionId(FLAG_audio_level)); + RTC_CHECK(ValidateExtensionId(FLAG_abs_send_time)); + RTC_CHECK(ValidateExtensionId(FLAG_transport_seq_no)); + RTC_CHECK(ValidateExtensionId(FLAG_video_content_type)); + RTC_CHECK(ValidateExtensionId(FLAG_video_timing)); + + // Gather RTP header extensions in a map. + NetEqPacketSourceInput::RtpHeaderExtensionMap rtp_ext_map = { + {FLAG_audio_level, kRtpExtensionAudioLevel}, + {FLAG_abs_send_time, kRtpExtensionAbsoluteSendTime}, + {FLAG_transport_seq_no, kRtpExtensionTransportSequenceNumber}, + {FLAG_video_content_type, kRtpExtensionVideoContentType}, + {FLAG_video_timing, kRtpExtensionVideoTiming}}; + + const std::string input_file_name = argv[1]; + std::unique_ptr input; + if (RtpFileSource::ValidRtpDump(input_file_name) || + RtpFileSource::ValidPcap(input_file_name)) { + input.reset(new NetEqRtpDumpInput(input_file_name, rtp_ext_map)); + } else { + 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 (strlen(FLAG_ssrc) > 0) { + uint32_t ssrc; + RTC_CHECK(ParseSsrc(FLAG_ssrc, &ssrc)) << "Flag verification has failed."; + static_cast(input.get())->SelectSsrc(ssrc); + } + + // Check the sample rate. + absl::optional sample_rate_hz; + std::set> discarded_pt_and_ssrc; + while (absl::optional first_rtp_header = input->NextHeader()) { + RTC_DCHECK(first_rtp_header); + sample_rate_hz = CodecSampleRate(first_rtp_header->payloadType); + if (sample_rate_hz) { + std::cout << "Found valid packet with payload type " + << static_cast(first_rtp_header->payloadType) + << " and SSRC 0x" << std::hex << first_rtp_header->ssrc + << std::dec << std::endl; + break; + } + // Discard this packet and move to the next. Keep track of discarded payload + // types and SSRCs. + discarded_pt_and_ssrc.emplace(first_rtp_header->payloadType, + first_rtp_header->ssrc); + input->PopPacket(); + } + if (!discarded_pt_and_ssrc.empty()) { + std::cout << "Discarded initial packets with the following payload types " + "and SSRCs:" + << std::endl; + for (const auto& d : discarded_pt_and_ssrc) { + std::cout << "PT " << d.first << "; SSRC 0x" << std::hex + << static_cast(d.second) << std::dec << std::endl; + } + } + if (!sample_rate_hz) { + std::cout << "Cannot find any packets with known payload types" + << std::endl; + RTC_NOTREACHED(); + } + + // Open the output file now that we know the sample rate. (Rate is only needed + // for wav files.) + const std::string output_file_name = argv[2]; + std::unique_ptr output; + if (output_file_name.size() >= 4 && + output_file_name.substr(output_file_name.size() - 4) == ".wav") { + // Open a wav file. + output.reset(new OutputWavFile(output_file_name, *sample_rate_hz)); + } else { + // Open a pcm file. + output.reset(new OutputAudioFile(output_file_name)); + } + + std::cout << "Output file: " << output_file_name << std::endl; + + NetEqTest::DecoderMap codecs = { + {FLAG_pcmu, std::make_pair(NetEqDecoder::kDecoderPCMu, "pcmu")}, + {FLAG_pcma, std::make_pair(NetEqDecoder::kDecoderPCMa, "pcma")}, +#ifdef WEBRTC_CODEC_ILBC + {FLAG_ilbc, std::make_pair(NetEqDecoder::kDecoderILBC, "ilbc")}, +#endif + {FLAG_isac, std::make_pair(NetEqDecoder::kDecoderISAC, "isac")}, +#if !defined(WEBRTC_ANDROID) + {FLAG_isac_swb, std::make_pair(NetEqDecoder::kDecoderISACswb, "isac-swb")}, +#endif +#ifdef WEBRTC_CODEC_OPUS + {FLAG_opus, std::make_pair(NetEqDecoder::kDecoderOpus, "opus")}, +#endif + {FLAG_pcm16b, std::make_pair(NetEqDecoder::kDecoderPCM16B, "pcm16-nb")}, + {FLAG_pcm16b_wb, + std::make_pair(NetEqDecoder::kDecoderPCM16Bwb, "pcm16-wb")}, + {FLAG_pcm16b_swb32, + std::make_pair(NetEqDecoder::kDecoderPCM16Bswb32kHz, "pcm16-swb32")}, + {FLAG_pcm16b_swb48, + std::make_pair(NetEqDecoder::kDecoderPCM16Bswb48kHz, "pcm16-swb48")}, + {FLAG_g722, std::make_pair(NetEqDecoder::kDecoderG722, "g722")}, + {FLAG_avt, std::make_pair(NetEqDecoder::kDecoderAVT, "avt")}, + {FLAG_avt_16, std::make_pair(NetEqDecoder::kDecoderAVT16kHz, "avt-16")}, + {FLAG_avt_32, std::make_pair(NetEqDecoder::kDecoderAVT32kHz, "avt-32")}, + {FLAG_avt_48, std::make_pair(NetEqDecoder::kDecoderAVT48kHz, "avt-48")}, + {FLAG_red, std::make_pair(NetEqDecoder::kDecoderRED, "red")}, + {FLAG_cn_nb, std::make_pair(NetEqDecoder::kDecoderCNGnb, "cng-nb")}, + {FLAG_cn_wb, std::make_pair(NetEqDecoder::kDecoderCNGwb, "cng-wb")}, + {FLAG_cn_swb32, + std::make_pair(NetEqDecoder::kDecoderCNGswb32kHz, "cng-swb32")}, + {FLAG_cn_swb48, + std::make_pair(NetEqDecoder::kDecoderCNGswb48kHz, "cng-swb48")} + }; + + // Check if a replacement audio file was provided. + if (strlen(FLAG_replacement_audio_file) > 0) { + // Find largest unused payload type. + int replacement_pt = 127; + while (!(codecs.find(replacement_pt) == codecs.end() && + ext_codecs_.find(replacement_pt) == ext_codecs_.end())) { + --replacement_pt; + RTC_CHECK_GE(replacement_pt, 0); + } + + auto std_set_int32_to_uint8 = [](const std::set& a) { + std::set b; + for (auto& x : a) { + b.insert(static_cast(x)); + } + return b; + }; + + std::set cn_types = std_set_int32_to_uint8( + {FLAG_cn_nb, FLAG_cn_wb, FLAG_cn_swb32, FLAG_cn_swb48}); + std::set forbidden_types = std_set_int32_to_uint8( + {FLAG_g722, FLAG_red, FLAG_avt, FLAG_avt_16, FLAG_avt_32, FLAG_avt_48}); + input.reset(new NetEqReplacementInput(std::move(input), replacement_pt, + cn_types, forbidden_types)); + + replacement_decoder_.reset(new FakeDecodeFromFile( + std::unique_ptr( + new InputAudioFile(FLAG_replacement_audio_file)), + 48000, false)); + NetEqTest::ExternalDecoderInfo ext_dec_info = { + replacement_decoder_.get(), NetEqDecoder::kDecoderArbitrary, + "replacement codec"}; + ext_codecs_[replacement_pt] = ext_dec_info; + } + + NetEqTest::Callbacks callbacks; + stats_plotter_.reset(new NetEqStatsPlotter(FLAG_matlabplot, FLAG_pythonplot, + FLAG_concealment_events, + output_file_name)); + + ssrc_switch_detector_.reset( + new SsrcSwitchDetector(stats_plotter_->stats_getter()->delay_analyzer())); + callbacks.post_insert_packet = ssrc_switch_detector_.get(); + callbacks.get_audio_callback = stats_plotter_->stats_getter(); + callbacks.simulation_ended_callback = stats_plotter_.get(); + NetEq::Config config; + config.sample_rate_hz = *sample_rate_hz; + return absl::make_unique(config, codecs, ext_codecs_, + std::move(input), std::move(output), + callbacks); +} + +} // namespace test +} // namespace webrtc diff --git a/modules/audio_coding/neteq/tools/neteq_test_factory.h b/modules/audio_coding/neteq/tools/neteq_test_factory.h new file mode 100644 index 0000000000..210c3e36a7 --- /dev/null +++ b/modules/audio_coding/neteq/tools/neteq_test_factory.h @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2018 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. + */ + +#ifndef MODULES_AUDIO_CODING_NETEQ_TOOLS_NETEQ_TEST_FACTORY_H_ +#define MODULES_AUDIO_CODING_NETEQ_TOOLS_NETEQ_TEST_FACTORY_H_ + +#include + +#include "modules/audio_coding/neteq/tools/neteq_test.h" + +namespace webrtc { +namespace test { + +class SsrcSwitchDetector; +class NetEqStatsGetter; +class NetEqStatsPlotter; + +// Note that the NetEqTestFactory needs to be alive when the NetEqTest object is +// used for a simulation. +class NetEqTestFactory { + public: + NetEqTestFactory(); + ~NetEqTestFactory(); + std::unique_ptr InitializeTest(int argc, char* argv[]); + + private: + std::unique_ptr replacement_decoder_; + NetEqTest::ExtDecoderMap ext_codecs_; + std::unique_ptr ssrc_switch_detector_; + std::unique_ptr stats_plotter_; +}; + +} // namespace test +} // namespace webrtc + +#endif // MODULES_AUDIO_CODING_NETEQ_TOOLS_NETEQ_TEST_FACTORY_H_