| /* |
| * 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. |
| */ |
| |
| #include <iostream> |
| #include <string> |
| |
| #include "modules/audio_coding/neteq/tools/neteq_test.h" |
| #include "modules/audio_coding/neteq/tools/neteq_test_factory.h" |
| #include "rtc_base/flags.h" |
| #include "system_wrappers/include/field_trial.h" |
| #include "test/field_trial.h" |
| |
| namespace { |
| |
| using TestConfig = webrtc::test::NetEqTestFactory::Config; |
| |
| WEBRTC_DEFINE_bool(codec_map, |
| false, |
| "Prints the mapping between RTP payload type and " |
| "codec"); |
| WEBRTC_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."); |
| WEBRTC_DEFINE_bool(help, false, "Prints this message"); |
| // Define command line flags. |
| WEBRTC_DEFINE_int(pcmu, |
| TestConfig::default_pcmu(), |
| "RTP payload type for PCM-u"); |
| WEBRTC_DEFINE_int(pcma, |
| TestConfig::default_pcma(), |
| "RTP payload type for PCM-a"); |
| WEBRTC_DEFINE_int(ilbc, |
| TestConfig::default_ilbc(), |
| "RTP payload type for iLBC"); |
| WEBRTC_DEFINE_int(isac, |
| TestConfig::default_isac(), |
| "RTP payload type for iSAC"); |
| WEBRTC_DEFINE_int(isac_swb, |
| TestConfig::default_isac_swb(), |
| "RTP payload type for iSAC-swb (32 kHz)"); |
| WEBRTC_DEFINE_int(opus, |
| TestConfig::default_opus(), |
| "RTP payload type for Opus"); |
| WEBRTC_DEFINE_int(pcm16b, |
| TestConfig::default_pcm16b(), |
| "RTP payload type for PCM16b-nb (8 kHz)"); |
| WEBRTC_DEFINE_int(pcm16b_wb, |
| TestConfig::default_pcm16b_wb(), |
| "RTP payload type for PCM16b-wb (16 kHz)"); |
| WEBRTC_DEFINE_int(pcm16b_swb32, |
| TestConfig::default_pcm16b_swb32(), |
| "RTP payload type for PCM16b-swb32 (32 kHz)"); |
| WEBRTC_DEFINE_int(pcm16b_swb48, |
| TestConfig::default_pcm16b_swb48(), |
| "RTP payload type for PCM16b-swb48 (48 kHz)"); |
| WEBRTC_DEFINE_int(g722, |
| TestConfig::default_g722(), |
| "RTP payload type for G.722"); |
| WEBRTC_DEFINE_int(avt, |
| TestConfig::default_avt(), |
| "RTP payload type for AVT/DTMF (8 kHz)"); |
| WEBRTC_DEFINE_int(avt_16, |
| TestConfig::default_avt_16(), |
| "RTP payload type for AVT/DTMF (16 kHz)"); |
| WEBRTC_DEFINE_int(avt_32, |
| TestConfig::default_avt_32(), |
| "RTP payload type for AVT/DTMF (32 kHz)"); |
| WEBRTC_DEFINE_int(avt_48, |
| TestConfig::default_avt_48(), |
| "RTP payload type for AVT/DTMF (48 kHz)"); |
| WEBRTC_DEFINE_int(red, |
| TestConfig::default_red(), |
| "RTP payload type for redundant audio (RED)"); |
| WEBRTC_DEFINE_int(cn_nb, |
| TestConfig::default_cn_nb(), |
| "RTP payload type for comfort noise (8 kHz)"); |
| WEBRTC_DEFINE_int(cn_wb, |
| TestConfig::default_cn_wb(), |
| "RTP payload type for comfort noise (16 kHz)"); |
| WEBRTC_DEFINE_int(cn_swb32, |
| TestConfig::default_cn_swb32(), |
| "RTP payload type for comfort noise (32 kHz)"); |
| WEBRTC_DEFINE_int(cn_swb48, |
| TestConfig::default_cn_swb48(), |
| "RTP payload type for comfort noise (48 kHz)"); |
| WEBRTC_DEFINE_string(replacement_audio_file, |
| "", |
| "A PCM file that will be used to populate dummy" |
| " RTP packets"); |
| WEBRTC_DEFINE_string( |
| ssrc, |
| "", |
| "Only use packets with this SSRC (decimal or hex, the latter " |
| "starting with 0x)"); |
| WEBRTC_DEFINE_int(audio_level, |
| TestConfig::default_audio_level(), |
| "Extension ID for audio level (RFC 6464)"); |
| WEBRTC_DEFINE_int(abs_send_time, |
| TestConfig::default_abs_send_time(), |
| "Extension ID for absolute sender time"); |
| WEBRTC_DEFINE_int(transport_seq_no, |
| TestConfig::default_transport_seq_no(), |
| "Extension ID for transport sequence number"); |
| WEBRTC_DEFINE_int(video_content_type, |
| TestConfig::default_video_content_type(), |
| "Extension ID for video content type"); |
| WEBRTC_DEFINE_int(video_timing, |
| TestConfig::default_video_timing(), |
| "Extension ID for video timing"); |
| WEBRTC_DEFINE_bool(matlabplot, |
| false, |
| "Generates a matlab script for plotting the delay profile"); |
| WEBRTC_DEFINE_bool(pythonplot, |
| false, |
| "Generates a python script for plotting the delay profile"); |
| WEBRTC_DEFINE_bool(textlog, |
| false, |
| "Generates a text log describing the simulation on a " |
| "step-by-step basis."); |
| WEBRTC_DEFINE_bool(concealment_events, false, "Prints concealment events"); |
| WEBRTC_DEFINE_int(max_nr_packets_in_buffer, |
| TestConfig::default_max_nr_packets_in_buffer(), |
| "Maximum allowed number of packets in the buffer"); |
| WEBRTC_DEFINE_bool(enable_fast_accelerate, |
| false, |
| "Enables jitter buffer fast accelerate"); |
| |
| // 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<ptrdiff_t>(str.length())) |
| return false; // Part of the string was not parsed. |
| *ssrc = static_cast<uint32_t>(value); |
| return true; |
| } |
| |
| 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<int>(value)); |
| return false; |
| } |
| |
| // 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<int>(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; |
| } |
| |
| void PrintCodecMappingEntry(const char* codec, int flag) { |
| std::cout << codec << ": " << flag << std::endl; |
| } |
| |
| void PrintCodecMapping() { |
| PrintCodecMappingEntry("PCM-u", FLAG_pcmu); |
| PrintCodecMappingEntry("PCM-a", FLAG_pcma); |
| PrintCodecMappingEntry("iLBC", FLAG_ilbc); |
| PrintCodecMappingEntry("iSAC", FLAG_isac); |
| PrintCodecMappingEntry("iSAC-swb (32 kHz)", FLAG_isac_swb); |
| PrintCodecMappingEntry("Opus", FLAG_opus); |
| PrintCodecMappingEntry("PCM16b-nb (8 kHz)", FLAG_pcm16b); |
| PrintCodecMappingEntry("PCM16b-wb (16 kHz)", FLAG_pcm16b_wb); |
| PrintCodecMappingEntry("PCM16b-swb32 (32 kHz)", FLAG_pcm16b_swb32); |
| PrintCodecMappingEntry("PCM16b-swb48 (48 kHz)", FLAG_pcm16b_swb48); |
| PrintCodecMappingEntry("G.722", FLAG_g722); |
| PrintCodecMappingEntry("AVT/DTMF (8 kHz)", FLAG_avt); |
| PrintCodecMappingEntry("AVT/DTMF (16 kHz)", FLAG_avt_16); |
| PrintCodecMappingEntry("AVT/DTMF (32 kHz)", FLAG_avt_32); |
| PrintCodecMappingEntry("AVT/DTMF (48 kHz)", FLAG_avt_48); |
| PrintCodecMappingEntry("redundant audio (RED)", FLAG_red); |
| PrintCodecMappingEntry("comfort noise (8 kHz)", FLAG_cn_nb); |
| PrintCodecMappingEntry("comfort noise (16 kHz)", FLAG_cn_wb); |
| PrintCodecMappingEntry("comfort noise (32 kHz)", FLAG_cn_swb32); |
| PrintCodecMappingEntry("comfort noise (48 kHz)", FLAG_cn_swb48); |
| } |
| |
| } // namespace |
| |
| int main(int argc, char* argv[]) { |
| webrtc::test::NetEqTestFactory factory; |
| 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(); |
| exit(0); |
| } |
| if (argc != 3) { |
| // Print usage information. |
| std::cout << usage; |
| exit(0); |
| } |
| 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)); |
| |
| webrtc::test::ValidateFieldTrialsStringOrDie(FLAG_force_fieldtrials); |
| webrtc::field_trial::InitFieldTrialsFromString(FLAG_force_fieldtrials); |
| webrtc::test::NetEqTestFactory::Config config; |
| config.pcmu = FLAG_pcmu; |
| config.pcma = FLAG_pcma; |
| config.ilbc = FLAG_ilbc; |
| config.isac = FLAG_isac; |
| config.isac_swb = FLAG_isac_swb; |
| config.opus = FLAG_opus; |
| config.pcm16b = FLAG_pcm16b; |
| config.pcm16b_wb = FLAG_pcm16b_wb; |
| config.pcm16b_swb32 = FLAG_pcm16b_swb32; |
| config.pcm16b_swb48 = FLAG_pcm16b_swb48; |
| config.g722 = FLAG_g722; |
| config.avt = FLAG_avt; |
| config.avt_16 = FLAG_avt_16; |
| config.avt_32 = FLAG_avt_32; |
| config.avt_48 = FLAG_avt_48; |
| config.red = FLAG_red; |
| config.cn_nb = FLAG_cn_nb; |
| config.cn_wb = FLAG_cn_wb; |
| config.cn_swb32 = FLAG_cn_swb32; |
| config.cn_swb48 = FLAG_cn_swb48; |
| config.replacement_audio_file = FLAG_replacement_audio_file; |
| config.audio_level = FLAG_audio_level; |
| config.abs_send_time = FLAG_abs_send_time; |
| config.transport_seq_no = FLAG_transport_seq_no; |
| config.video_content_type = FLAG_video_content_type; |
| config.video_timing = FLAG_video_timing; |
| config.matlabplot = FLAG_matlabplot; |
| config.pythonplot = FLAG_pythonplot; |
| config.textlog = FLAG_textlog; |
| config.concealment_events = FLAG_concealment_events; |
| config.max_nr_packets_in_buffer = FLAG_max_nr_packets_in_buffer; |
| config.enable_fast_accelerate = FLAG_enable_fast_accelerate; |
| // 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."; |
| config.ssrc_filter = absl::make_optional(ssrc); |
| } |
| |
| std::unique_ptr<webrtc::test::NetEqTest> test = |
| factory.InitializeTest(argv[1], argv[2], config); |
| test->Run(); |
| return 0; |
| } |
