modules/audio_coding/neteq/tools/neteq_rtpplay.cc

/*
 *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

#include <iostream>
#include <string>

#include "absl/flags/flag.h"
#include "absl/flags/parse.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "modules/audio_coding/neteq/tools/neteq_test.h"
#include "modules/audio_coding/neteq/tools/neteq_test_factory.h"
#include "rtc_base/strings/string_builder.h"
#include "system_wrappers/include/field_trial.h"
#include "test/field_trial.h"

using TestConfig = webrtc::test::NetEqTestFactory::Config;

ABSL_FLAG(bool,
          codec_map,
          false,
          "Prints the mapping between RTP payload type and "
          "codec");
ABSL_FLAG(std::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.");
ABSL_FLAG(int, pcmu, TestConfig::default_pcmu(), "RTP payload type for PCM-u");
ABSL_FLAG(int, pcma, TestConfig::default_pcma(), "RTP payload type for PCM-a");
ABSL_FLAG(int, ilbc, TestConfig::default_ilbc(), "RTP payload type for iLBC");
ABSL_FLAG(int, isac, TestConfig::default_isac(), "RTP payload type for iSAC");
ABSL_FLAG(int,
          isac_swb,
          TestConfig::default_isac_swb(),
          "RTP payload type for iSAC-swb (32 kHz)");
ABSL_FLAG(int, opus, TestConfig::default_opus(), "RTP payload type for Opus");
ABSL_FLAG(int,
          pcm16b,
          TestConfig::default_pcm16b(),
          "RTP payload type for PCM16b-nb (8 kHz)");
ABSL_FLAG(int,
          pcm16b_wb,
          TestConfig::default_pcm16b_wb(),
          "RTP payload type for PCM16b-wb (16 kHz)");
ABSL_FLAG(int,
          pcm16b_swb32,
          TestConfig::default_pcm16b_swb32(),
          "RTP payload type for PCM16b-swb32 (32 kHz)");
ABSL_FLAG(int,
          pcm16b_swb48,
          TestConfig::default_pcm16b_swb48(),
          "RTP payload type for PCM16b-swb48 (48 kHz)");
ABSL_FLAG(int, g722, TestConfig::default_g722(), "RTP payload type for G.722");
ABSL_FLAG(int,
          avt,
          TestConfig::default_avt(),
          "RTP payload type for AVT/DTMF (8 kHz)");
ABSL_FLAG(int,
          avt_16,
          TestConfig::default_avt_16(),
          "RTP payload type for AVT/DTMF (16 kHz)");
ABSL_FLAG(int,
          avt_32,
          TestConfig::default_avt_32(),
          "RTP payload type for AVT/DTMF (32 kHz)");
ABSL_FLAG(int,
          avt_48,
          TestConfig::default_avt_48(),
          "RTP payload type for AVT/DTMF (48 kHz)");
ABSL_FLAG(int,
          red,
          TestConfig::default_red(),
          "RTP payload type for redundant audio (RED)");
ABSL_FLAG(int,
          cn_nb,
          TestConfig::default_cn_nb(),
          "RTP payload type for comfort noise (8 kHz)");
ABSL_FLAG(int,
          cn_wb,
          TestConfig::default_cn_wb(),
          "RTP payload type for comfort noise (16 kHz)");
ABSL_FLAG(int,
          cn_swb32,
          TestConfig::default_cn_swb32(),
          "RTP payload type for comfort noise (32 kHz)");
ABSL_FLAG(int,
          cn_swb48,
          TestConfig::default_cn_swb48(),
          "RTP payload type for comfort noise (48 kHz)");
ABSL_FLAG(std::string,
          replacement_audio_file,
          "",
          "A PCM file that will be used to populate dummy"
          " RTP packets");
ABSL_FLAG(std::string,
          ssrc,
          "",
          "Only use packets with this SSRC (decimal or hex, the latter "
          "starting with 0x)");
ABSL_FLAG(int,
          audio_level,
          TestConfig::default_audio_level(),
          "Extension ID for audio level (RFC 6464)");
ABSL_FLAG(int,
          abs_send_time,
          TestConfig::default_abs_send_time(),
          "Extension ID for absolute sender time");
ABSL_FLAG(int,
          transport_seq_no,
          TestConfig::default_transport_seq_no(),
          "Extension ID for transport sequence number");
ABSL_FLAG(int,
          video_content_type,
          TestConfig::default_video_content_type(),
          "Extension ID for video content type");
ABSL_FLAG(int,
          video_timing,
          TestConfig::default_video_timing(),
          "Extension ID for video timing");
ABSL_FLAG(std::string,
          output_files_base_name,
          "",
          "Custom path used as prefix for the output files - i.e., "
          "matlab plot, python plot, text log.");
ABSL_FLAG(bool,
          matlabplot,
          false,
          "Generates a matlab script for plotting the delay profile");
ABSL_FLAG(bool,
          pythonplot,
          false,
          "Generates a python script for plotting the delay profile");
ABSL_FLAG(bool,
          textlog,
          false,
          "Generates a text log describing the simulation on a "
          "step-by-step basis.");
ABSL_FLAG(bool, concealment_events, false, "Prints concealment events");
ABSL_FLAG(int,
          max_nr_packets_in_buffer,
          TestConfig::default_max_nr_packets_in_buffer(),
          "Maximum allowed number of packets in the buffer");
ABSL_FLAG(bool,
          enable_fast_accelerate,
          false,
          "Enables jitter buffer fast accelerate");

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<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", absl::GetFlag(FLAGS_pcmu));
  PrintCodecMappingEntry("PCM-a", absl::GetFlag(FLAGS_pcma));
  PrintCodecMappingEntry("iLBC", absl::GetFlag(FLAGS_ilbc));
  PrintCodecMappingEntry("iSAC", absl::GetFlag(FLAGS_isac));
  PrintCodecMappingEntry("iSAC-swb (32 kHz)", absl::GetFlag(FLAGS_isac_swb));
  PrintCodecMappingEntry("Opus", absl::GetFlag(FLAGS_opus));
  PrintCodecMappingEntry("PCM16b-nb (8 kHz)", absl::GetFlag(FLAGS_pcm16b));
  PrintCodecMappingEntry("PCM16b-wb (16 kHz)", absl::GetFlag(FLAGS_pcm16b_wb));
  PrintCodecMappingEntry("PCM16b-swb32 (32 kHz)",
                         absl::GetFlag(FLAGS_pcm16b_swb32));
  PrintCodecMappingEntry("PCM16b-swb48 (48 kHz)",
                         absl::GetFlag(FLAGS_pcm16b_swb48));
  PrintCodecMappingEntry("G.722", absl::GetFlag(FLAGS_g722));
  PrintCodecMappingEntry("AVT/DTMF (8 kHz)", absl::GetFlag(FLAGS_avt));
  PrintCodecMappingEntry("AVT/DTMF (16 kHz)", absl::GetFlag(FLAGS_avt_16));
  PrintCodecMappingEntry("AVT/DTMF (32 kHz)", absl::GetFlag(FLAGS_avt_32));
  PrintCodecMappingEntry("AVT/DTMF (48 kHz)", absl::GetFlag(FLAGS_avt_48));
  PrintCodecMappingEntry("redundant audio (RED)", absl::GetFlag(FLAGS_red));
  PrintCodecMappingEntry("comfort noise (8 kHz)", absl::GetFlag(FLAGS_cn_nb));
  PrintCodecMappingEntry("comfort noise (16 kHz)", absl::GetFlag(FLAGS_cn_wb));
  PrintCodecMappingEntry("comfort noise (32 kHz)",
                         absl::GetFlag(FLAGS_cn_swb32));
  PrintCodecMappingEntry("comfort noise (48 kHz)",
                         absl::GetFlag(FLAGS_cn_swb48));
}

bool ValidateOutputFilesOptions(bool textlog,
                                bool plotting,
                                absl::string_view output_files_base_name,
                                absl::string_view output_audio_filename) {
  bool output_files_base_name_specified = !output_files_base_name.empty();
  if (!textlog && !plotting && output_files_base_name_specified) {
    std::cout << "Error: --output_files_base_name cannot be used without at "
              << "least one of the following flags: --textlog, --matlabplot, "
              << "--pythonplot." << std::endl;
    return false;
  }
  // Without |output_audio_filename|, |output_files_base_name| is required when
  // plotting output files must be generated (in order to form a valid output
  // file name).
  if (output_audio_filename.empty() && plotting &&
      !output_files_base_name_specified) {
    std::cout << "Error: when no output audio file is specified and "
              << "--matlabplot and/or --pythonplot are used, "
              << "--output_files_base_name must be also used." << std::endl;
    return false;
  }
  return true;
}

absl::optional<std::string> CreateOptionalOutputFileName(
    bool output_requested,
    absl::string_view basename,
    absl::string_view output_audio_filename,
    absl::string_view suffix) {
  if (!output_requested) {
    return absl::nullopt;
  }
  if (!basename.empty()) {
    // Override the automatic assignment.
    rtc::StringBuilder sb(basename);
    sb << suffix;
    return sb.str();
  }
  if (!output_audio_filename.empty()) {
    // Automatically assign name.
    rtc::StringBuilder sb(output_audio_filename);
    sb << suffix;
    return sb.str();
  }
  std::cout << "Error: invalid text log file parameters.";
  return absl::nullopt;
}

}  // namespace

int main(int argc, char* argv[]) {
  std::vector<char*> args = absl::ParseCommandLine(argc, argv);
  webrtc::test::NetEqTestFactory factory;
  std::string usage =
      "Tool for decoding an RTP dump file using NetEq.\n"
      "Example usage:\n"
      "./neteq_rtpplay input.rtp [output.{pcm, wav}]\n";
  if (absl::GetFlag(FLAGS_codec_map)) {
    PrintCodecMapping();
    exit(0);
  }
  if (args.size() != 2 &&
      args.size() != 3) {  // The output audio file is optional.
    // Print usage information.
    std::cout << usage;
    exit(0);
  }
  const std::string output_audio_filename((args.size() == 3) ? args[2] : "");
  const std::string output_files_base_name(
      absl::GetFlag(FLAGS_output_files_base_name));
  RTC_CHECK(ValidateOutputFilesOptions(
      absl::GetFlag(FLAGS_textlog),
      absl::GetFlag(FLAGS_matlabplot) || absl::GetFlag(FLAGS_pythonplot),
      output_files_base_name, output_audio_filename));
  RTC_CHECK(ValidatePayloadType(absl::GetFlag(FLAGS_pcmu)));
  RTC_CHECK(ValidatePayloadType(absl::GetFlag(FLAGS_pcma)));
  RTC_CHECK(ValidatePayloadType(absl::GetFlag(FLAGS_ilbc)));
  RTC_CHECK(ValidatePayloadType(absl::GetFlag(FLAGS_isac)));
  RTC_CHECK(ValidatePayloadType(absl::GetFlag(FLAGS_isac_swb)));
  RTC_CHECK(ValidatePayloadType(absl::GetFlag(FLAGS_opus)));
  RTC_CHECK(ValidatePayloadType(absl::GetFlag(FLAGS_pcm16b)));
  RTC_CHECK(ValidatePayloadType(absl::GetFlag(FLAGS_pcm16b_wb)));
  RTC_CHECK(ValidatePayloadType(absl::GetFlag(FLAGS_pcm16b_swb32)));
  RTC_CHECK(ValidatePayloadType(absl::GetFlag(FLAGS_pcm16b_swb48)));
  RTC_CHECK(ValidatePayloadType(absl::GetFlag(FLAGS_g722)));
  RTC_CHECK(ValidatePayloadType(absl::GetFlag(FLAGS_avt)));
  RTC_CHECK(ValidatePayloadType(absl::GetFlag(FLAGS_avt_16)));
  RTC_CHECK(ValidatePayloadType(absl::GetFlag(FLAGS_avt_32)));
  RTC_CHECK(ValidatePayloadType(absl::GetFlag(FLAGS_avt_48)));
  RTC_CHECK(ValidatePayloadType(absl::GetFlag(FLAGS_red)));
  RTC_CHECK(ValidatePayloadType(absl::GetFlag(FLAGS_cn_nb)));
  RTC_CHECK(ValidatePayloadType(absl::GetFlag(FLAGS_cn_wb)));
  RTC_CHECK(ValidatePayloadType(absl::GetFlag(FLAGS_cn_swb32)));
  RTC_CHECK(ValidatePayloadType(absl::GetFlag(FLAGS_cn_swb48)));
  RTC_CHECK(ValidateSsrcValue(absl::GetFlag(FLAGS_ssrc)));
  RTC_CHECK(ValidateExtensionId(absl::GetFlag(FLAGS_audio_level)));
  RTC_CHECK(ValidateExtensionId(absl::GetFlag(FLAGS_abs_send_time)));
  RTC_CHECK(ValidateExtensionId(absl::GetFlag(FLAGS_transport_seq_no)));
  RTC_CHECK(ValidateExtensionId(absl::GetFlag(FLAGS_video_content_type)));
  RTC_CHECK(ValidateExtensionId(absl::GetFlag(FLAGS_video_timing)));

  // Make force_fieldtrials persistent string during entire program live as
  // absl::GetFlag creates temporary string and c_str() will point to
  // deallocated string.
  const std::string force_fieldtrials = absl::GetFlag(FLAGS_force_fieldtrials);
  webrtc::field_trial::InitFieldTrialsFromString(force_fieldtrials.c_str());

  webrtc::test::NetEqTestFactory::Config config;
  config.pcmu = absl::GetFlag(FLAGS_pcmu);
  config.pcma = absl::GetFlag(FLAGS_pcma);
  config.ilbc = absl::GetFlag(FLAGS_ilbc);
  config.isac = absl::GetFlag(FLAGS_isac);
  config.isac_swb = absl::GetFlag(FLAGS_isac_swb);
  config.opus = absl::GetFlag(FLAGS_opus);
  config.pcm16b = absl::GetFlag(FLAGS_pcm16b);
  config.pcm16b_wb = absl::GetFlag(FLAGS_pcm16b_wb);
  config.pcm16b_swb32 = absl::GetFlag(FLAGS_pcm16b_swb32);
  config.pcm16b_swb48 = absl::GetFlag(FLAGS_pcm16b_swb48);
  config.g722 = absl::GetFlag(FLAGS_g722);
  config.avt = absl::GetFlag(FLAGS_avt);
  config.avt_16 = absl::GetFlag(FLAGS_avt_16);
  config.avt_32 = absl::GetFlag(FLAGS_avt_32);
  config.avt_48 = absl::GetFlag(FLAGS_avt_48);
  config.red = absl::GetFlag(FLAGS_red);
  config.cn_nb = absl::GetFlag(FLAGS_cn_nb);
  config.cn_wb = absl::GetFlag(FLAGS_cn_wb);
  config.cn_swb32 = absl::GetFlag(FLAGS_cn_swb32);
  config.cn_swb48 = absl::GetFlag(FLAGS_cn_swb48);
  config.replacement_audio_file = absl::GetFlag(FLAGS_replacement_audio_file);
  config.audio_level = absl::GetFlag(FLAGS_audio_level);
  config.abs_send_time = absl::GetFlag(FLAGS_abs_send_time);
  config.transport_seq_no = absl::GetFlag(FLAGS_transport_seq_no);
  config.video_content_type = absl::GetFlag(FLAGS_video_content_type);
  config.video_timing = absl::GetFlag(FLAGS_video_timing);
  config.matlabplot = absl::GetFlag(FLAGS_matlabplot);
  config.pythonplot = absl::GetFlag(FLAGS_pythonplot);
  config.concealment_events = absl::GetFlag(FLAGS_concealment_events);
  config.max_nr_packets_in_buffer =
      absl::GetFlag(FLAGS_max_nr_packets_in_buffer);
  config.enable_fast_accelerate = absl::GetFlag(FLAGS_enable_fast_accelerate);
  if (!output_audio_filename.empty()) {
    config.output_audio_filename = output_audio_filename;
  }
  config.textlog = absl::GetFlag(FLAGS_textlog);
  config.textlog_filename = CreateOptionalOutputFileName(
      absl::GetFlag(FLAGS_textlog), output_files_base_name,
      output_audio_filename, ".text_log.txt");
  config.plot_scripts_basename = CreateOptionalOutputFileName(
      absl::GetFlag(FLAGS_matlabplot) || absl::GetFlag(FLAGS_pythonplot),
      output_files_base_name, output_audio_filename, "");

  // Check if an SSRC value was provided.
  if (absl::GetFlag(FLAGS_ssrc).size() > 0) {
    uint32_t ssrc;
    RTC_CHECK(ParseSsrc(absl::GetFlag(FLAGS_ssrc), &ssrc))
        << "Flag verification has failed.";
    config.ssrc_filter = absl::make_optional(ssrc);
  }

  std::unique_ptr<webrtc::test::NetEqTest> test =
      factory.InitializeTestFromFile(/*input_filename=*/args[1], config);
  RTC_CHECK(test) << "ERROR: Unable to run test";
  test->Run();
  return 0;
}