Upload Audio_Effects_SDK/samples/effects_delayed_streams_demo/effects_delayed_streams_demo.cpp with huggingface_hub

Audio_Effects_SDK/samples/effects_delayed_streams_demo/effects_delayed_streams_demo.cpp

@@ -0,0 +1,924 @@
+/*
+Copyright (c) 2021-2022, NVIDIA CORPORATION. All rights reserved.
+
+NVIDIA CORPORATION and its licensors retain all intellectual property
+and proprietary rights in and to this software, related documentation
+and any modifications thereto. Any use, reproduction, disclosure or
+distribution of this software and related documentation without an express
+license agreement from NVIDIA CORPORATION is strictly prohibited.
+*/
+#include <math.h>
+#include <limits.h>
+
+#include <algorithm>
+#include <chrono>
+#include <cstring>
+#include <iostream>
+#include <iomanip>
+#include <map>
+#include <memory>
+#include <set>
+#include <sstream>
+#include <thread>
+#include <tuple>
+
+#include "utils/wave_reader/waveReadWrite.hpp"
+#include "utils/ConfigReader.hpp"
+
+#include <nvAudioEffects.h>
+
+namespace {
+
+const char kConfigEffectVariable[] = "effect";
+const char kConfigSampleRateVariable[] = "sample_rate";
+const char kConfigFileInputVariable[] = "input_wav_list";
+const char kConfigFileInputFarendVariable[] = "input_farend_wav_list";
+const char kConfigFileOutputVariable[] = "output_wav_list";
+const char kConfigResetVariable[] = "reset";
+const char kConfigFrameSize[] = "frame_size";
+const char kConfigOneStepDelayStreams[] = "one_step_delay_streams";
+const char kConfigTwoStepDelayStreams[] = "two_step_delay_streams";
+const char kConfigLogTarget[] = "log_target_list";
+const char kConfigLogTargetFile[] = "log_target_file";
+const char kConfigLogLevel[] = "log_level";
+const char kConfigLogTargetFileDefault[] = "/tmp/nvAudioEffects_log.txt";
+const char kConfigFileModelVariable[] = "model";
+const char kConfigVadEnable[] = "enable_vad";
+
+/* allowed sample rates */
+const std::vector<uint32_t> kAllowedSampleRates = { 8000, 16000, 48000 };
+
+static std::vector<uint32_t> ConvertStrVectorToUINT32Vector(const std::vector<std::string>& string_vector) {
+  std::vector<uint32_t> uint_vector;
+  std::transform(string_vector.begin(), string_vector.end(), std::back_inserter(uint_vector),
+                 [](const std::string& str){ return std::strtoul(str.c_str(), nullptr, 0); });
+  return uint_vector;
+}
+
+static bool ValidateDelayedStreams(std::vector<uint32_t> one_step_delay_streams,
+                                   std::vector<uint32_t> two_step_delay_streams,
+                                   uint32_t num_streams) {
+  // stream ids should be less than the total number of streams                                 
+  if (std::all_of(one_step_delay_streams.begin(), one_step_delay_streams.end(),
+                  [num_streams](uint32_t v) { return v < num_streams; }) == false) {
+    std::cout << "Error: One or more streams ids in one_step_delay_streams is greater than the total number of streams"
+              << std::endl;
+    return false;
+  }
+  if (std::all_of(two_step_delay_streams.begin(), two_step_delay_streams.end(),
+                  [num_streams](uint32_t v) { return v < num_streams; }) == false) {
+    std::cout << "Error: One or more streams ids in two_step_delay_streams is greater than the total number of streams"
+              << std::endl;
+    return false;
+  }
+
+  // one_step_delay_streams and two_step_delay_streams should not have common stream ids
+  for (const auto& stream_id : one_step_delay_streams) {
+    auto itr = std::find(two_step_delay_streams.begin(), two_step_delay_streams.end(), stream_id);
+    if (itr != two_step_delay_streams.end()) {
+      std::cout << "Error: one_step_delay_streams and two_steps_delayed_streams cannot have common stream indices"
+                << std::endl;
+      return false;
+    }
+  }
+
+  // one_step_delay_streams should not have duplicates
+  std::sort(one_step_delay_streams.begin(), one_step_delay_streams.end());
+  auto itr = std::adjacent_find(one_step_delay_streams.begin(), one_step_delay_streams.end());
+  if (itr != one_step_delay_streams.end()) {
+    std::cout << "Error: one_step_delay_streams cannot have duplicate stream indices"
+              << std::endl;
+    return false;
+  }
+  // two_step_delay_streams should not have duplicates
+  std::sort(two_step_delay_streams.begin(), two_step_delay_streams.end());
+  itr = std::adjacent_find(two_step_delay_streams.begin(), two_step_delay_streams.end());
+  if (itr != two_step_delay_streams.end()) {
+    std::cout << "Error: two_step_delay_streams cannot have duplicate stream indices"
+              << std::endl;
+    return false;
+  }
+  return true;
+}
+
+} // namespace
+
+struct StreamData {
+  // Wav file name(s) separated by ';'
+  std::string input_wav_file;
+  // Total number of samples in all input wav files together
+  unsigned num_samples = 0;
+  // Number of audio samples written to output file
+  unsigned already_written = 0;
+  // Current offset for the input in the input data of the stream
+  unsigned current_offset = 0;
+  // 32-bit float audio samples read from all input wav files
+  std::vector<float>* input_wav_samples;
+  // (AEC only) 32-bit float audio samples for farend input wav files
+  std::vector<float>* input_farend_wav_samples;
+  // Wav file name(s) to write the output data
+  std::string output_wav_file;
+  // Object for wav writing library
+  std::unique_ptr<CWaveFileWrite> wav_write;
+  // Index of each input file end in the audio data vector
+  std::vector<int> file_end_offsets;
+  // Index of current output file used as suffix to filename
+  int output_file_num;
+};
+
+class EffectsDemoApp {
+ public:
+  bool run(const ConfigReader& config_reader);
+
+ private:
+  // Validate configuration data.
+  bool validateConfig(const ConfigReader& config_reader);
+  // write to output wav
+  bool writeOutputWav(const float* output_samples, size_t num_samples, int stream_index);
+  // Apply the effect on the streams
+  bool runEffect(NvAFX_Handle handle, const std::vector<uint32_t>& streams, 
+                  std::vector<float>& input_frame, std::vector<float>& output_frame);
+  // Load the input data
+  void loadInputFrame(const std::vector<uint32_t>& streams, std::vector<float>& input_frame);
+
+  // sample rate config
+  uint32_t input_sample_rate_ = 0;
+  // output sample rate config
+  uint32_t output_sample_rate_ = 0;
+  // number of samples per frame
+  unsigned int num_input_samples_per_frame_ = 0;
+  // number of output samples per frame
+    unsigned int num_output_samples_per_frame_ = 0;
+  // number of input channels
+  uint32_t num_input_channels_ = 0;
+  // number of output channels
+  uint32_t num_output_channels_ = 0;
+  // Total run time of the effect
+  float total_run_time_ = 0.f;
+  // stream data
+  std::vector<StreamData> stream_data_;
+  // Input files list
+  std::vector<std::string> input_wav_list_;
+  // Whether AEC is enabled
+  bool is_aec_ = false;
+   // VAD
+  bool vad_supported_ = false;
+  // Obtain farend audio if effect is AEC
+  std::vector<std::string> input_farend_wav_list_;
+  // Output files list
+  std::vector<std::string> output_wav_list_;
+  // Reset list. Set based on entries in config file
+  std::vector<bool> reset_list_;
+  // Reset map. Set based on reset_list and stream input change
+  std::vector<NvAFX_Bool> reset_map_;
+  // Activity map
+  std::vector<NvAFX_Bool> activity_map_;
+};
+
+bool EffectsDemoApp::validateConfig(const ConfigReader& config_reader) {
+  if (config_reader.IsConfigValueAvailable(kConfigEffectVariable) == false) {
+    std::cerr << "No " << kConfigEffectVariable << " variable found" << std::endl;
+    return false;
+  }
+
+  std::string input_sample_rate_str;
+  if (config_reader.GetConfigValue(kConfigSampleRateVariable, &input_sample_rate_str)) {
+    input_sample_rate_ = std::strtoul(input_sample_rate_str.c_str(), nullptr, 0);
+    if (std::find(kAllowedSampleRates.begin(), kAllowedSampleRates.end(), input_sample_rate_) ==
+        kAllowedSampleRates.end()) {
+      std::cerr << "Sample rate " << input_sample_rate_ << " not supported" << std::endl;
+      return false;
+    }
+  } else {
+    std::cerr << "No " << kConfigSampleRateVariable << " variable found" << std::endl;
+    return false;
+  }
+
+  if (config_reader.IsConfigValueAvailable(kConfigFileModelVariable) == false) {
+    std::cerr << "No " << kConfigFileModelVariable << " variable found" << std::endl;
+    return false;
+  }
+
+  if (config_reader.IsConfigValueAvailable(kConfigFileInputVariable) == false) {
+    std::cerr << "No " << kConfigFileInputVariable << " variable found" << std::endl;
+    return false;
+  }
+
+  if (config_reader.IsConfigValueAvailable(kConfigFileOutputVariable) == false) {
+    std::cerr << "No " << kConfigFileOutputVariable << " variable found" << std::endl;
+    return false;
+  }
+
+  if (config_reader.IsConfigValueAvailable(kConfigResetVariable)) {
+    std::cout << "Reset available" << std::endl;
+  }
+
+  if (config_reader.IsConfigValueAvailable(kConfigOneStepDelayStreams) == false) {
+    std::cerr << "No " << kConfigOneStepDelayStreams << " variable found" << std::endl;
+    return false;
+  }
+
+  if (config_reader.IsConfigValueAvailable(kConfigTwoStepDelayStreams) == false) {
+    std::cerr << "No " << kConfigTwoStepDelayStreams << " variable found" << std::endl;
+    return false;
+  }
+
+  return true;
+}
+
+bool EffectsDemoApp::writeOutputWav(const float* output_samples, size_t num_samples,
+                                    int stream_index) {
+  auto to_write = num_samples;
+  auto max_allowed = stream_data_[stream_index].num_samples *
+      (output_sample_rate_/input_sample_rate_);
+  auto already_written = stream_data_[stream_index].already_written;
+  auto can_write = static_cast<size_t>(max_allowed - already_written);
+  if (can_write == 0) { return true; }
+  auto will_write = std::min(to_write, can_write);
+  if (!stream_data_[stream_index].wav_write->writeChunk(output_samples,
+                                                        will_write * sizeof(float))) {
+    std::cerr << "Could not write output to file "
+              << stream_data_[stream_index].output_wav_file << std::endl;
+    return false;
+  }
+  stream_data_[stream_index].already_written += will_write;
+  return true;
+}
+
+void EffectsDemoApp::loadInputFrame(const std::vector<uint32_t>& streams,
+                                    std::vector<float>& input_frame) {
+  for (const auto& stream_id : streams) {
+    auto stream_offset = stream_data_[stream_id].current_offset;
+    float *in = stream_data_[stream_id].input_wav_samples->data() + stream_offset;
+    std::copy(in, in + num_input_samples_per_frame_, &input_frame[stream_id * num_input_samples_per_frame_]);
+    if (is_aec_) {
+      int num_streams = stream_data_.size();
+      in = stream_data_[stream_id].input_farend_wav_samples->data() + stream_offset;
+      std::copy(in, in + num_input_samples_per_frame_,
+                &input_frame[(num_streams + stream_id) * num_input_samples_per_frame_]);
+    }
+    // Check if this file is finished, if so, start a new file
+    if (stream_data_[stream_id].file_end_offsets.size() && 
+        stream_offset == static_cast<unsigned>(stream_data_[stream_id].file_end_offsets[0])) {
+      stream_data_[stream_id].file_end_offsets
+                             .erase(stream_data_[stream_id].file_end_offsets.begin());
+      if (stream_data_[stream_id].file_end_offsets.size()) {
+        // Open a new file only if this isn't the last one
+        stream_data_[stream_id].wav_write->commitFile();
+        auto ext = output_wav_list_[stream_id].find_last_of(".");
+        std::string filename = output_wav_list_[stream_id].substr(0, ext) + "_" +
+                               std::to_string(++stream_data_[stream_id].output_file_num) + ".wav";
+        stream_data_[stream_id].wav_write =
+            std::unique_ptr<CWaveFileWrite>(new CWaveFileWrite(filename, output_sample_rate_, 1, 32, true));
+        if (reset_list_[stream_id]) {
+          reset_map_[stream_id] = NVAFX_TRUE;
+        }
+      }
+    }
+    stream_data_[stream_id].current_offset += num_input_samples_per_frame_;
+  }
+}
+
+bool EffectsDemoApp::runEffect(NvAFX_Handle handle, const std::vector<uint32_t>& streams,
+                               std::vector<float>& input_frame, std::vector<float>& output_frame) {
+  loadInputFrame(streams, input_frame);
+
+  for (const auto& stream_id : streams) {
+    activity_map_[stream_id] = NVAFX_TRUE;
+  }
+  if (NvAFX_SetBoolList(handle, NVAFX_PARAM_ACTIVE_STREAMS, 
+                        activity_map_.data(), activity_map_.size()) != NVAFX_STATUS_SUCCESS) {
+    std::cerr << "NvAFX_SetBoolList() failed" << std::endl;
+    return false;
+  }
+  memset(activity_map_.data(), NVAFX_FALSE, sizeof(activity_map_[0]) * activity_map_.size());
+
+  if (std::find(reset_map_.begin(), reset_map_.end(), NVAFX_TRUE) != reset_map_.end()) {
+    if (NvAFX_Reset(handle, reset_map_.data(), reset_map_.size()) != NVAFX_STATUS_SUCCESS) {
+      std::cerr << "Reset failed" << std::endl;
+      return false;
+    }
+    memset(reset_map_.data(), NVAFX_FALSE, sizeof(reset_map_[0]) * reset_map_.size());
+  }
+
+  const float* input[2];
+  float* output[1];
+  input[0] = input_frame.data();
+  if (is_aec_) {
+    input[1] = &input_frame[input_frame.size()/num_input_channels_];
+  }
+  output[0] = output_frame.data();
+  auto start_tick = std::chrono::high_resolution_clock::now();
+  if (NvAFX_Run(handle, input, output, num_input_samples_per_frame_, num_input_channels_) != NVAFX_STATUS_SUCCESS) {
+    std::cerr << "NvAFX_Run() failed" << std::endl;
+    return false;
+  }
+  auto run_end_tick = std::chrono::high_resolution_clock::now();
+  total_run_time_ += (std::chrono::duration<float>(run_end_tick - start_tick)).count();
+  return true;
+}
+
+void logger_cb(LoggingSeverity level, const char* log, void* userdata) {
+  std::cout << "LOG" << '(' << LogSeverityToString(level) << ") " << log << '\n';
+}
+
+inline LoggingSeverity StringToLogSeverity(std::string &severity) {
+  if ("ERROR" == severity) return LOG_LEVEL_ERROR;
+  if ("WARNING" == severity) return LOG_LEVEL_WARNING;
+  if ("INFO" == severity) return LOG_LEVEL_INFO;
+  return LOG_LEVEL_ERROR;
+}
+
+inline LoggingTarget StringToLogTarget(std::string &severity) {
+  if ("NONE" == severity) return LOG_TARGET_NONE;
+  if ("STDERR" == severity) return LOG_TARGET_STDERR;
+  if ("FILE" == severity) return LOG_TARGET_FILE;
+  if ("CALLBACK" == severity) return LOG_TARGET_CALLBACK;
+  return LOG_TARGET_NONE;
+}
+
+bool EffectsDemoApp::run(const ConfigReader& config_reader)
+{
+  if (validateConfig(config_reader) == false)
+    return false;
+
+  std::vector<std::string> log_targets;
+  if (config_reader.IsConfigValueAvailable(kConfigLogTarget)) {
+    log_targets = config_reader.GetConfigValueList(kConfigLogTarget);
+  }
+  LoggingSeverity severity = LOG_LEVEL_INFO;
+  int target = LOG_TARGET_STDERR;
+  std::string log_file(kConfigLogTargetFileDefault);
+
+  if (!log_targets.empty()) {
+    target = LOG_TARGET_NONE;
+    for (auto& item : log_targets) {
+      target |= StringToLogTarget(item);
+    }
+  }
+
+  if (target & LOG_TARGET_FILE) {
+    if (config_reader.IsConfigValueAvailable(kConfigLogTargetFile)) {
+      log_file = config_reader.GetConfigValue(kConfigLogTargetFile);
+    }
+  }
+
+  if (config_reader.IsConfigValueAvailable(kConfigLogLevel)) {
+    auto log_level = config_reader.GetConfigValue(kConfigLogLevel);
+    if (!log_level.empty()) {
+      severity = StringToLogSeverity(log_level);
+    }
+  }
+  NvAFX_Status log_status;
+  log_status = NvAFX_InitializeLogger(severity, target, log_file.c_str(),
+                                      target & LOG_TARGET_CALLBACK ? logger_cb : nullptr,
+                                      nullptr);
+
+  if (log_status != NVAFX_STATUS_SUCCESS) {
+    std::cerr << "NvAFX_InitializeLogger() failed" << std::endl;
+    return false;
+  }
+
+  input_wav_list_ = config_reader.GetConfigValueList(kConfigFileInputVariable);
+  output_wav_list_ = config_reader.GetConfigValueList(kConfigFileOutputVariable);
+  if (input_wav_list_.size() != output_wav_list_.size()) {
+    std::cout << "Error: Input and output wav files list size mismatch found" << std::endl;
+    return false;
+  }
+
+  reset_list_.resize(input_wav_list_.size(), false);
+  if (config_reader.IsConfigValueAvailable(kConfigResetVariable)) {
+    auto config_list = config_reader.GetConfigValueList(kConfigResetVariable);
+    for (auto& item : config_list) {
+      char* p;
+      unsigned int num = strtol(item.c_str(), &p, 10);
+      if (*p != 0) {
+        // Invalid?
+        continue;
+      }
+      if (num < 1 || num > input_wav_list_.size()) {
+        std::cerr << "Error: Invalid stream specified for reset" <<std::endl;
+        return false;
+      }
+      reset_list_[num-1] = true;
+    }
+  }
+
+  const unsigned num_streams = input_wav_list_.size();
+
+  // Get the stream ids for delayed streams
+  std::vector<uint32_t> active_streams, one_step_delay_streams, two_step_delay_streams;
+  auto val = config_reader.GetConfigValueList(kConfigOneStepDelayStreams);
+  if (val[0] != "none") {
+    one_step_delay_streams = ConvertStrVectorToUINT32Vector(val);
+  }
+  val = config_reader.GetConfigValueList(kConfigTwoStepDelayStreams);
+  if (val[0] != "none") {
+    two_step_delay_streams = ConvertStrVectorToUINT32Vector(val);
+  }
+  if (!ValidateDelayedStreams(one_step_delay_streams, two_step_delay_streams, num_streams)) {
+    std::cout << "Delayed streams validation failed." << std::endl;
+    return false;
+  }
+  // Create active_streams.
+  for (unsigned i = 0; i < num_streams; ++i) {
+    if (std::find(one_step_delay_streams.begin(), one_step_delay_streams.end(), i) == 
+        one_step_delay_streams.end() &&
+        std::find(two_step_delay_streams.begin(), two_step_delay_streams.end(), i) == 
+        two_step_delay_streams.end()) {
+      active_streams.push_back(i);
+    }
+  }
+ 
+  if (config_reader.IsConfigValueAvailable(kConfigFrameSize)) {
+    auto config_value = config_reader.GetConfigValue(kConfigFrameSize);
+    unsigned frame_size = std::strtoul(config_value.c_str(), nullptr, 0);
+    // frame_size is in milliseconds.
+    num_input_samples_per_frame_ = (input_sample_rate_ * frame_size) / 1000;
+  }
+
+  int num_effects;
+  NvAFX_EffectSelector* supported_effects;
+  if (NvAFX_GetEffectList(&num_effects, &supported_effects) != NVAFX_STATUS_SUCCESS) {
+    std::cerr << "NvAFX_GetEffectList() failed" << std::endl;
+    return false;
+  }
+
+  std::cout << "Total Effects supported: " << num_effects << std::endl;
+  for (int i = 0; i < num_effects; ++i) {
+    std::cout << "(" << i + 1 << ") " << supported_effects[i] << std::endl;
+  }
+
+  NvAFX_Handle handle;
+  std::vector<std::string> effects = config_reader.GetConfigValueList(kConfigEffectVariable);
+  std::vector<std::string> sample_rate_str = config_reader.GetConfigValueList(kConfigSampleRateVariable);
+  std::vector<uint32_t> sample_rates;
+  for (auto& s: sample_rate_str) {
+    sample_rates.push_back(std::strtoul(s.c_str(), nullptr, 0));
+  }
+
+  std::string effect_name;
+  if (effects.size() == 1) {
+    // Single effect
+    if (sample_rates.size() != effects.size()) {
+      std::cerr << "Expected single sample rate for single effect" << std::endl;
+      return false;
+    }
+    input_sample_rate_ = sample_rates[0];
+    if (std::find(kAllowedSampleRates.begin(), kAllowedSampleRates.end(), input_sample_rate_) ==
+        kAllowedSampleRates.end()) {
+      std::cerr << "Sample rate " << input_sample_rate_ << " not supported" << std::endl;
+      return false;
+    }
+    NvAFX_Status status = NVAFX_STATUS_FAILED;
+    if (effects[0] == "denoiser") {
+      status = NvAFX_CreateEffect(NVAFX_EFFECT_DENOISER, &handle);
+    } else if (effects[0] == "dereverb") {
+      status = NvAFX_CreateEffect(NVAFX_EFFECT_DEREVERB, &handle);
+    } else if (effects[0] == "dereverb_denoiser") {
+      status = NvAFX_CreateEffect(NVAFX_EFFECT_DEREVERB_DENOISER, &handle);
+    } else if (effects[0] == "aec") {
+      status = NvAFX_CreateEffect(NVAFX_EFFECT_AEC, &handle);
+      is_aec_ = true;
+    } else if (effects[0] == "superres") {
+      status = NvAFX_CreateEffect(NVAFX_EFFECT_SUPERRES, &handle);
+    } else {
+      std::cerr << "NvAFX_CreateEffect() failed. Invalid Effect Value : " << effects[0] << std::endl;
+      return false;
+    }
+
+    if (status == NVAFX_UNSUPPORTED_RUNTIME) {
+      float version = (CUDA_SUPPORTED_RUNTIME / 1000) + (CUDA_SUPPORTED_RUNTIME%100)/100.f;
+      std::cerr << "Unsupported CUDA runtime found (requires >= " <<  version << "). "
+                   "Please ensure that a driver supporting the required CUDA version is installed (or if using FCU, library path "
+                   "contains the correct CUDA compat libraries). For more details, please refer to the "
+                   "programming guide." << std::endl;
+      return false;
+    } else if (status != NVAFX_STATUS_SUCCESS) {
+      std::cerr << "NvAFX_CreateEffect() failed" << std::endl;
+      return false;
+    }
+    const std::set<std::string> kVadSupportedEffects = {"denoiser", "dereverb_denoiser"};
+    vad_supported_ = (kVadSupportedEffects.find(effects[0]) != kVadSupportedEffects.end()) &&
+        config_reader.IsConfigValueAvailable(kConfigVadEnable) &&
+        std::strtoul(config_reader.GetConfigValue(kConfigVadEnable).c_str(), nullptr, 0);
+
+    if (vad_supported_) {
+      std::cout << "Enabling VAD" << std::endl;
+      if (NvAFX_SetU32(handle, NVAFX_PARAM_ENABLE_VAD, 1) != NVAFX_STATUS_SUCCESS) {
+        std::cerr << "Could not enable VAD" << std::endl;
+        return false;
+      }
+    }
+
+    status = NvAFX_SetU32(handle, NVAFX_PARAM_INPUT_SAMPLE_RATE, input_sample_rate_);
+    if (status == NVAFX_STATUS_INVALID_PARAM) {
+      // Try depreciated param
+      status = NvAFX_SetU32(handle, NVAFX_PARAM_SAMPLE_RATE, input_sample_rate_);
+    }
+    if (status!= NVAFX_STATUS_SUCCESS) {
+      std::cerr << "NvAFX_SetU32(Sample Rate: " << input_sample_rate_ << ") failed" << std::endl;
+      return false;
+    }
+    effect_name = effects[0];
+  } else {
+    const std::map<std::tuple<std::string, std::string, uint32_t, uint32_t>, NvAFX_EffectSelector> supported_configs =
+    {
+        // 16k Effect + Superres 16k-48k
+        {std::make_tuple(std::string("denoiser"), std::string("superres"), 16000, 16000), NVAFX_CHAINED_EFFECT_DENOISER_16k_SUPERRES_16k_TO_48k},
+        {std::make_tuple(std::string("dereverb"), std::string("superres"), 16000, 16000), NVAFX_CHAINED_EFFECT_DEREVERB_16k_SUPERRES_16k_TO_48k},
+        {std::make_tuple(std::string("dereverb_denoiser"), std::string("superres"), 16000, 16000),
+         NVAFX_CHAINED_EFFECT_DEREVERB_DENOISER_16k_SUPERRES_16k_TO_48k},
+
+         // Superres 8k-16k + 16k Effect
+        {std::make_tuple("superres", "denoiser", 8000, 16000), NVAFX_CHAINED_EFFECT_SUPERRES_8k_TO_16k_DENOISER_16k },
+        {std::make_tuple("superres", "dereverb", 8000, 16000), NVAFX_CHAINED_EFFECT_SUPERRES_8k_TO_16k_DEREVERB_16k },
+        {std::make_tuple("superres", "dereverb_denoiser", 8000, 16000),
+         NVAFX_CHAINED_EFFECT_SUPERRES_8k_TO_16k_DEREVERB_DENOISER_16k },
+    };
+    auto effect_config = supported_configs.find(std::make_tuple(effects[0], effects[1], sample_rates[0], sample_rates[1]));
+    if (effect_config == supported_configs.end()) {
+      std::cerr << "Unsupported effect chain" <<std::endl;
+      return false;
+    }
+    auto status = NvAFX_CreateChainedEffect(effect_config->second,&handle);
+    if (status == NVAFX_UNSUPPORTED_RUNTIME) {
+      float version = (CUDA_SUPPORTED_RUNTIME / 1000) + (CUDA_SUPPORTED_RUNTIME%100)/100.f;
+      std::cerr << "Unsupported CUDA runtime found (requires >= " <<  version << "). "
+                   "Please ensure that a driver supporting the required CUDA version is installed (or if using FCU, library path "
+                   "contains the correct CUDA compat libraries). For more details, please refer to the " 
+                   "programming guide." << std::endl;
+      return false;
+    } else if (status != NVAFX_STATUS_SUCCESS) {
+      std::cerr << "Could not create effect" << std::endl;
+    }
+    input_sample_rate_ = sample_rates[0];
+    effect_name = "Chained Effect (" + effects[0] + " + " + effects[1] + ")";
+  }
+
+  unsigned num_input_samples_per_frame = 0;
+  //Superres has more number of output samples
+  // Note: Number of samples are per channel
+  unsigned num_output_samples_per_frame = 0;
+  if (config_reader.IsConfigValueAvailable(kConfigFrameSize)) {
+    auto config_value = config_reader.GetConfigValue(kConfigFrameSize);
+    unsigned frame_size = std::strtoul(config_value.c_str(), nullptr, 0);
+    // frame_size is in milliseconds.
+    num_input_samples_per_frame = (input_sample_rate_ * frame_size) / 1000;
+  }
+
+    // Obtain farend audio if effect is AEC
+  std::vector<std::string> input_farend_wav_list;
+  if (is_aec_) {
+    input_farend_wav_list_ = config_reader.GetConfigValueList(kConfigFileInputFarendVariable);
+    if (input_farend_wav_list_.size() != input_wav_list_.size()) {
+      std::cerr << "AEC effect requires farend audio as input in addition to nearend audio."
+                   "Please ensure that the config value \"" << kConfigFileInputFarendVariable <<
+                   "\" is present and has correct number of files" << std::endl;
+      return false;
+    }
+  }
+
+  NvAFX_Status status;
+
+  std::vector<std::string> model_files = config_reader.GetConfigValueList(kConfigFileModelVariable);
+  // Note: For single effect, model can be passed in as a single string or as a list of strings with size 1
+  std::unique_ptr<char*[]> model_files_param(new char*[model_files.size()]);
+  for (int i = 0; i < model_files.size(); i++) {
+    model_files_param[i] = (char*) model_files[i].data();
+  }
+  if (NvAFX_SetStringList(handle, NVAFX_PARAM_MODEL_PATH, (const char**)model_files_param.get(),
+                          model_files.size())
+      != NVAFX_STATUS_SUCCESS) {
+    std::cerr << "NvAFX_SetString() failed" << std::endl;
+    return false;
+  }
+
+  if (NvAFX_SetU32(handle, NVAFX_PARAM_NUM_STREAMS, num_streams) != NVAFX_STATUS_SUCCESS) {
+    std::cerr << "NvAFX_SetU32(NVAFX_PARAM_NUM_STREAMS) failed" << std::endl;
+    return false;
+  }
+
+  unsigned int list_size = 0;
+  std::unique_ptr<unsigned int[]> supported_list = nullptr;
+  auto ret = NvAFX_GetU32List(handle, NVAFX_PARAM_SUPPORTED_NUM_SAMPLES_PER_FRAME,
+                              supported_list.get(), &list_size);
+  if (ret != NVAFX_STATUS_OUTPUT_BUFFER_TOO_SMALL) {
+    std::cerr << "NvAFX_GetU32List(NVAFX_PARAM_SUPPORTED_NUM_SAMPLES_PER_FRAME) failed."
+              << std::endl;
+    return false;
+  }
+  supported_list.reset(new unsigned int[list_size]);
+  if (NvAFX_GetU32List(handle, NVAFX_PARAM_SUPPORTED_NUM_SAMPLES_PER_FRAME,
+                       supported_list.get(), &list_size) != NVAFX_STATUS_SUCCESS) {
+    std::cerr << "NvAFX_GetU32List(NVAFX_PARAM_SUPPORTED_NUM_SAMPLES_PER_FRAME) failed."
+    << std::endl;
+    return false;
+  }
+  // If config specifies certain value check if it is in supported list
+  if (config_reader.IsConfigValueAvailable(kConfigFrameSize)) {
+    auto pointer = std::find(supported_list.get(), supported_list.get() + list_size,
+                             num_input_samples_per_frame_);
+    if (pointer == supported_list.get() + list_size) {
+      std::ostringstream oss;
+      std::string separator("");
+      oss << "'";
+      for (unsigned i = 0; i < list_size; ++i) {
+        oss << separator << (supported_list[i] * 1000) / input_sample_rate_;
+        separator = ", ";
+      }
+      oss << "'.";
+      std::cerr << "Supplied value for " << kConfigFrameSize << " is not supported. Supplied value: "
+                << config_reader.GetConfigValue(kConfigFrameSize) << "." << " Supported values: "
+                << oss.str() << std::endl;
+      return false;
+    }
+  } else {
+    num_input_samples_per_frame_ = supported_list[0];
+  }
+
+  status = NvAFX_SetU32(handle, NVAFX_PARAM_NUM_SAMPLES_PER_INPUT_FRAME, num_input_samples_per_frame_);
+  if (status == NVAFX_STATUS_INVALID_PARAM) {
+    status = NvAFX_SetU32(handle, NVAFX_PARAM_NUM_SAMPLES_PER_FRAME, num_input_samples_per_frame_);
+  }
+  if (status != NVAFX_STATUS_SUCCESS) {
+    std::cerr << "NvAFX_SetU32(NVAFX_PARAM_NUM_SAMPLES_PER_FRAME) failed" << std::endl;
+    return false;
+  }
+
+  std::cout << "Loading effect" << " ... ";
+  if (NvAFX_Load(handle) != NVAFX_STATUS_SUCCESS) {
+    std::cerr << "NvAFX_Load() failed" << std::endl;
+    return false;
+  }
+  std::cout << "Done" << std::endl;
+
+  // Try to get output number of samples per frame (valid only with new SDK)
+  status = NvAFX_GetU32(handle, NVAFX_PARAM_NUM_SAMPLES_PER_OUTPUT_FRAME,
+                        &num_output_samples_per_frame_);
+  if (status != NVAFX_STATUS_SUCCESS) {
+    if (status == NVAFX_STATUS_INVALID_PARAM) {
+      // Old SDK, output samples = input samples
+      num_output_samples_per_frame_ = num_input_samples_per_frame_;
+    } else {
+      std::cerr << "NvAFX_GetU32() failed: NVAFX_PARAM_NUM_SAMPLES_PER_OUTPUT_FRAME" << std::endl;
+      return false;
+    }
+  }
+
+  // Try to get output sample rate (valid only with new SDK)
+  status = NvAFX_GetU32(handle, NVAFX_PARAM_OUTPUT_SAMPLE_RATE, &output_sample_rate_);
+  if (status != NVAFX_STATUS_SUCCESS) {
+    if (status == NVAFX_STATUS_INVALID_PARAM) {
+      // Old SDK, output sample rate = input sample rate
+      output_sample_rate_ = input_sample_rate_;
+    } else {
+      std::cerr << "NvAFX_GetU32() failed: NVAFX_PARAM_OUTPUT_SAMPLE_RATE" << std::endl;
+      return false;
+    }
+  }
+
+  // Try to get input/output channels, if that fails (old SDK?), try depreciated num_channels
+  status = NvAFX_GetU32(handle, NVAFX_PARAM_NUM_INPUT_CHANNELS, &num_input_channels_);
+  if (status  != NVAFX_STATUS_SUCCESS) {
+    if (status == NVAFX_STATUS_INVALID_PARAM) {
+      if (NvAFX_GetU32(handle, NVAFX_PARAM_NUM_CHANNELS, &num_input_channels_) != NVAFX_STATUS_SUCCESS) {
+        std::cerr << "NvAFX_GetU32(NVAFX_PARAM_NUM_CHANNELS) failed" << std::endl;
+        return false;
+      } else {
+        // For older SDKs, output channels = input channels = 1
+        num_output_channels_ = num_input_channels_;
+      }
+    } else {
+      std::cerr << "NvAFX_GetU32() failed" << std::endl;
+      return false;
+    }
+  } else if (NvAFX_GetU32(handle, NVAFX_PARAM_NUM_OUTPUT_CHANNELS, &num_output_channels_) != NVAFX_STATUS_SUCCESS) {
+    std::cerr << "NvAFX_GetU32() failed" << std::endl;
+    return false;
+  }
+
+  std::cout << "Effect properties:" << std::endl
+            << "  Effect                   : " << effect_name << std::endl
+            << "  Input Channels           : " << num_input_channels_ << std::endl
+            << "  Output Channels          : " << num_output_channels_ << std::endl
+            << "  Input Sample Rate        : " << input_sample_rate_ << std::endl
+            << "  Output Sample Rate       : " << output_sample_rate_ << std::endl
+            << "  Input samples per frame  : " << num_input_samples_per_frame_ << std::endl
+            << "  Output samples per frame : " << num_output_samples_per_frame_ << std::endl
+            << "  Number of streams        : " << num_streams << std::endl;
+
+  size_t max_num_samples = 0;
+  // read the noisy input wav file data and cache it in RAM.
+  for (unsigned i = 0; i < num_streams; ++i) {
+    StreamData data;
+    data.input_wav_file = input_wav_list_[i];
+
+    if (!ReadWavFile(input_wav_list_[i], input_sample_rate_, &data.input_wav_samples,
+                     &data.num_samples, &data.file_end_offsets, num_input_samples_per_frame_)) {
+      std::cerr << "Unable to read wav file: " << input_wav_list_[i] << std::endl;
+      return false;
+    }
+
+    // max_num_samples should be aligned to 'num_input_samples_per_frame_' automatically
+    if (max_num_samples < data.input_wav_samples->size()) {
+      max_num_samples = data.input_wav_samples->size();
+    }
+
+    if (is_aec_) {
+      unsigned int num_samples = 0;
+      std::vector<int> end_offsets;
+
+      if (!ReadWavFile(input_farend_wav_list_[i], input_sample_rate_, &data.input_farend_wav_samples,
+                       &num_samples, &end_offsets, num_input_samples_per_frame_)) {
+        std::cerr << "Unable to read wav file: " << input_farend_wav_list_[i] << std::endl;
+        if (errno == EMFILE) {
+          std::cerr << "Open file limit reached. Please increase file limit using the ulimit "
+                       "utility (for example, \"ulimit -n 20000\"). Please refer to the "
+                       "documentation of the ulimit utility for more details." << std::endl;
+        }
+        return false;
+      }
+
+      if (num_samples != data.num_samples || end_offsets != data.file_end_offsets) {
+        std::cerr << "Input farend file specification does not match nearend file specification."
+                     "Farend and Nearend files must have the same number of samples";
+        return false;
+      }
+    }
+    data.output_wav_file = output_wav_list_[i];
+    data.wav_write =
+        std::unique_ptr<CWaveFileWrite>(new CWaveFileWrite(output_wav_list_[i], output_sample_rate_,
+                                                              num_output_channels_, 32, true));
+    if (!data.wav_write->initFile()) {
+      std::cerr << "Could not open file for writing: " << output_wav_list_[i] << std::endl;
+      return false;
+    }
+    data.output_file_num = 0;
+
+    stream_data_.push_back(std::move(data));
+#ifndef ENABLE_PERF_DUMP
+    std::cout << "Input wav file: " << input_wav_list_[i] << std::endl
+              << "Total " << data.num_samples << " samples read" << std::endl;
+#endif  // ENABLE_PERF_DUMP
+  }
+
+  // make all sizes same to ease effect run loop's work
+  for (auto& v : stream_data_) {
+    v.input_wav_samples->resize(max_num_samples);
+  }
+
+  float frame_in_secs = static_cast<float>(num_input_samples_per_frame_) /
+                        static_cast<float>(input_sample_rate_);
+  float total_audio_duration = 0.f;
+  float checkpoint = 0.1f;
+  float expected_audio_duration = static_cast<float>(max_num_samples) /
+                                  static_cast<float>(input_sample_rate_);
+  std::vector<float> input_frame(num_input_channels_ * num_input_samples_per_frame_ * num_streams);
+  std::vector<float> output_frame(num_output_channels_ * num_output_samples_per_frame_ * num_streams);
+
+  std::string progress_bar = "[          ] ";
+  std::cout << "Processed: " << progress_bar << "0%\r";
+  std::cout.flush();
+
+  uint32_t current_iteration = 0;
+  activity_map_.resize(input_wav_list_.size(), NVAFX_FALSE);
+  reset_map_.resize(input_wav_list_.size(), NVAFX_FALSE);
+  std::vector<uint32_t> current_active_streams;
+  std::vector<uint32_t> delayed_streams;
+  // wav data is already padded to align to num_input_samples_per_frame_ by ReadWavFile()
+  for (size_t offset = 0; offset < max_num_samples; offset += num_input_samples_per_frame_) {
+    // Run the delayed streams that have arrived now.
+    current_active_streams = active_streams;
+    delayed_streams = one_step_delay_streams;
+    if ((current_iteration + 1) % 3 == 0 && two_step_delay_streams.size()) {
+      delayed_streams = two_step_delay_streams;
+      runEffect(handle, delayed_streams, input_frame, output_frame);
+      for (const auto& stream_id : delayed_streams) {
+        if (!writeOutputWav(&output_frame[stream_id * num_output_samples_per_frame_],
+                            num_output_samples_per_frame_, stream_id)) {
+          return false;
+        }
+      }
+      if (current_iteration % 2 != 0 && one_step_delay_streams.size()) {
+        delayed_streams.insert(delayed_streams.end(), one_step_delay_streams.begin(),
+                               one_step_delay_streams.end());
+        current_active_streams.insert(current_active_streams.end(), one_step_delay_streams.begin(),
+                                      one_step_delay_streams.end());
+      }
+      runEffect(handle, delayed_streams, input_frame, output_frame);
+      for (const auto& stream_id : delayed_streams) {
+        if (!writeOutputWav(&output_frame[stream_id * num_output_samples_per_frame_],
+                            num_output_samples_per_frame_, stream_id)) {
+          return false;
+        }
+      }
+      current_active_streams.insert(current_active_streams.end(), two_step_delay_streams.begin(),
+                                    two_step_delay_streams.end());
+    } else if (current_iteration % 2 != 0 && one_step_delay_streams.size()) {
+      runEffect(handle, delayed_streams, input_frame, output_frame);
+      for (const auto& stream_id : delayed_streams) {
+        if (!writeOutputWav(&output_frame[stream_id * num_output_samples_per_frame_],
+                            num_output_samples_per_frame_, stream_id)) {
+          return false;
+        }
+      }
+      current_active_streams.insert(current_active_streams.end(), one_step_delay_streams.begin(),
+                                    one_step_delay_streams.end());
+    }
+    // Run the streams which are active for current iteration
+    runEffect(handle, current_active_streams, input_frame, output_frame);
+    total_audio_duration += frame_in_secs;
+    if ((total_audio_duration / expected_audio_duration) > checkpoint) {
+      progress_bar[checkpoint * 10] = '=';
+      std::cout << "Processed: " << progress_bar << checkpoint * 100.f << "% ";
+      std::cout << (checkpoint >=1 ? "\n" : "\r");
+      std::cout.flush();
+      checkpoint += 0.1f;
+    }
+
+    for (const auto& stream_id : current_active_streams) {
+      if (!writeOutputWav(&output_frame[stream_id * num_output_samples_per_frame_],
+                          num_output_samples_per_frame_, stream_id)) {
+        return false;
+      }
+    }
+    ++current_iteration;
+  }
+
+  std::cout << "Processing time " << std::setprecision(2) << total_run_time_ << " secs for "
+            << total_audio_duration << std::setprecision(2) << " secs audio file (" << total_run_time_ / total_audio_duration
+            << " secs processing time per sec of audio)" << std::endl;
+
+  for (auto& v : stream_data_) {
+    v.wav_write->commitFile();
+  }
+
+  std::cout << "Output wav files written. " << std::endl;
+  if (NvAFX_DestroyEffect(handle) != NVAFX_STATUS_SUCCESS) {
+    std::cerr << "NvAFX_Release() failed" << std::endl;
+    return false;
+  }
+
+  if (NvAFX_UninitializeLogger() != NVAFX_STATUS_SUCCESS) {
+    std::cerr << "NvAFX_UninitializeLogger() failed" << std::endl;
+    return false;
+  }
+
+  return true;
+}
+
+void ShowHelpAndExit(const char* szBadOption) {
+  std::ostringstream oss;
+  bool bThrowError = false;
+  if (szBadOption) {
+    bThrowError = false;
+    oss << "Error parsing \"" << szBadOption << "\"" << std::endl;
+  }
+  std::cout << "Command Line Options:" << std::endl
+            << "-c           Config file" << std::endl;
+
+  if (bThrowError) {
+    throw std::invalid_argument(oss.str());
+  } else {
+    std::cout << oss.str();
+    exit(0);
+  }
+}
+
+void ParseCommandLine(int argc, char* argv[], std::string* config_file) {
+  if (argc == 1) {
+    ShowHelpAndExit(nullptr);
+  }
+
+  for (int i = 1; i < argc; i++) {
+    if (!strcasecmp(argv[i], "-h")) {
+      ShowHelpAndExit(nullptr);
+    }
+    if (!strcasecmp(argv[i], "-c")) {
+      if (++i == argc || !config_file->empty()) {
+        ShowHelpAndExit("-f");
+      }
+      config_file->assign(argv[i]);
+      continue;
+    }
+
+    ShowHelpAndExit(argv[i]);
+  }
+}
+
+int main(int argc, char *argv[]) {
+  std::string config_file;
+  ParseCommandLine(argc, argv, &config_file);
+
+  ConfigReader config_reader;
+  if (config_reader.Load(config_file) == false) {
+    std::cerr << "Config file load failed" << std::endl;
+    return -1;
+  }
+
+  EffectsDemoApp app;
+  if (app.run(config_reader))
+    return 0;
+  else return -1;
+}