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

Audio_Effects_SDK/samples/effects_demo/effects_demo.cpp

@@ -0,0 +1,882 @@
+/*
+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 <algorithm>
+#include <chrono>
+#include <cstring>
+#include <iostream>
+#include <iomanip>
+#include <memory>
+#include <set>
+#include <sstream>
+#include <thread>
+#include <tuple>
+
+#include "utils/wave_reader/waveReadWrite.hpp"
+#include "utils/ConfigReader.hpp"
+
+#include <nvAudioEffects.h>
+#include <map>
+
+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 kConfigFileRTVariable[] = "real_time";
+const char kConfigResetVariable[] = "reset";
+const char kConfigFrameSize[] = "frame_size";
+const char kConfigUseDefaultGpu[] = "use_default_gpu";
+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 kConfigIntensityRatioVariable[] = "intensity_ratio";
+const char kConfigVadEnable[] = "enable_vad";
+const char kConfigChainedEffectGpuList[] = "chained_effect_gpu_list";
+
+/* allowed sample rates */
+const std::vector<uint32_t> kAllowedSampleRates = { 8000, 16000, 48000 };
+
+}  // 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;
+  // 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::vector<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 std::vector<float*>& output_samples, size_t num_samples_per_channel,
+                      int stream_index);
+  // sample rate config
+  uint32_t input_sample_rate_ = 0;
+  // output sample rate config
+  uint32_t output_sample_rate_ = 0;
+  // stream data
+  std::vector<StreamData> stream_data_;
+  // GPU selection flag - by default set to false
+  uint32_t use_default_gpu_ = 0;
+  // inited from configuration
+  bool real_time_ = false;
+  // intensity_ratio_ config, lies between 0 (no effect applied) to 1 (fully turned on)
+  float intensity_ratio_ = 1.0f;
+  // VAD support (denoiser/dereverb+denoiser only)
+  bool vad_supported_ = false;
+
+  unsigned int output_channels_ = 1;
+};
+
+bool EffectsDemoApp::validateConfig(const ConfigReader& config_reader) {
+  if (config_reader.IsConfigValueAvailable(kConfigEffectVariable) == false) {
+    std::cerr << "No " << kConfigEffectVariable << " 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;
+  }
+
+  std::string real_time;
+  if (config_reader.GetConfigValue(kConfigFileRTVariable, &real_time) == false) {
+    std::cerr << "No " << kConfigFileRTVariable << " variable found" << std::endl;
+    return false;
+  }
+
+  if (real_time[0] != '0') {
+    real_time_ = true;
+  }
+
+  if (config_reader.IsConfigValueAvailable(kConfigResetVariable)) {
+    std::cout << "Reset available" << std::endl;
+  }
+
+  std::string use_default_gpu;
+  if (config_reader.IsConfigValueAvailable(kConfigUseDefaultGpu) &&
+      config_reader.GetConfigValue(kConfigUseDefaultGpu, &use_default_gpu)) {
+    use_default_gpu_ = std::strtoul(use_default_gpu.c_str(), nullptr, 0);
+    std::cout << "Use default GPU: " << use_default_gpu_ << std::endl;
+  }
+
+  std::string intensity_ratio;
+  float intensity_ratio_local;
+  if (config_reader.GetConfigValue(kConfigIntensityRatioVariable, &intensity_ratio)) {
+    intensity_ratio_local = std::strtof(intensity_ratio.c_str(), nullptr);
+    if (intensity_ratio_local < 0.0f || intensity_ratio_local > 1.0f) {
+      std::cerr << kConfigIntensityRatioVariable << " not supported" << std::endl;
+      return false;
+    }
+  } else {
+    intensity_ratio_local = 1.0f;
+  }
+
+  intensity_ratio_ = intensity_ratio_local;
+  std::cout << "intensity ratio is ::" << intensity_ratio_ << "!!" << std::endl;
+  return true;
+}
+
+bool EffectsDemoApp::writeOutputWav(const std::vector<float*>& output_samples,
+                                    size_t num_samples_per_channel, int stream_index) {
+  size_t to_write = num_samples_per_channel;
+  size_t max_allowed = stream_data_[stream_index].num_samples *
+      (output_sample_rate_/input_sample_rate_);
+  size_t already_written = stream_data_[stream_index].already_written;
+  size_t can_write = static_cast<size_t>(max_allowed - already_written);
+  if (can_write == 0) { return true; }
+  size_t will_write = std::min(to_write, can_write);
+
+  for (int i = 0; i < output_channels_; i++) {
+    if (!stream_data_[stream_index].wav_write[i]->writeChunk(output_samples[i],
+                                                             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 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;
+  }
+
+  auto input_wav_list = config_reader.GetConfigValueList(kConfigFileInputVariable);
+  auto output_wav_list = config_reader.GetConfigValueList(kConfigFileOutputVariable);
+  // Support 1024 max inputs to simplify
+  const int kMaxSupportedInputs = 1024;
+  if (input_wav_list.size() > kMaxSupportedInputs) {
+    std::cerr << "This sample application supports a maximum of " << kMaxSupportedInputs <<
+                 " input files (although more may be supported by the SDK depending on GPU,"
+                 " please refer to the programming guide for limits and procedure for"
+                 " setting batch size in SDK)." << std::endl;
+    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);
+    }
+  }
+
+  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;
+  }
+
+  std::vector<bool> reset_list(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();
+
+  if (real_time_) {
+    std::cout << "App will run in real time mode ..." << std::endl;
+  }
+
+  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;
+  }
+
+  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;
+  }
+
+  bool is_aec = false;
+
+  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 (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;
+    }
+
+    effect_name = effects[0];
+    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;
+      }
+    }
+
+    // If the system has multiple supported GPUs, then the application can either
+    // use CUDA driver APIs or CUDA runtime APIs to enumerate the GPUs and select one based on the
+    // application's requirements or offload the responsibility to SDK to select the GPU by setting
+    // NVAFX_PARAM_USE_DEFAULT_GPU as 1
+    if (NvAFX_SetU32(handle, NVAFX_PARAM_USE_DEFAULT_GPU, use_default_gpu_) != NVAFX_STATUS_SUCCESS) {
+      std::cerr << "NvAFX_SetBool(NVAFX_PARAM_USE_DEFAULT_GPU " << ") failed" << std::endl;
+    }
+
+    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;
+    }
+
+  } 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 (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;
+      return false;
+    }
+    input_sample_rate_ = sample_rates[0];
+
+    effect_name = "Chained Effect (" + effects[0] + " + " + effects[1] + ")";
+
+    if (config_reader.IsConfigValueAvailable(kConfigChainedEffectGpuList)) {
+      std::vector<std::string> gpu_list = config_reader.GetConfigValueList(kConfigChainedEffectGpuList);
+      std::vector<uint32_t> gpus;
+      for (auto& s: gpu_list) {
+        gpus.push_back(std::strtoul(s.c_str(), nullptr, 0));
+      }
+
+      NvAFX_SetU32List(handle, NVAFX_PARAM_CHAINED_EFFECT_GPU_LIST, gpus.data(), gpus.size());
+    }
+
+  }
+
+  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) {
+    // Try previous version
+    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;
+  }
+
+  // Intensity ratio may not be supported for some effects, ignore if status is invalid param
+  status = NvAFX_SetFloat(handle, NVAFX_PARAM_INTENSITY_RATIO, intensity_ratio_);
+  if (status != NVAFX_STATUS_SUCCESS && status != NVAFX_STATUS_INVALID_PARAM) {
+    std::cerr << "NvAFX_SetFloat(NVAFX_PARAM_INTENSITY_RATIO) failed" << std::endl;
+  }
+
+  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
+  unsigned num_input_channels, num_output_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 {
+        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(NVAFX_PARAM_NUM_OUTPUT_CHANNELS) failed" << std::endl;
+    return false;
+  }
+
+  output_channels_ = num_output_channels;
+
+  std::cout << "Effect properties:" << std::endl
+            << "  Effect             : " << effect_name << std::endl
+            << "  Input Channels     : " << num_input_channels << std::endl
+            << "  Input Sample Rate  : " << input_sample_rate_ << std::endl
+            << "  Output Sample Rate : " << output_sample_rate_ << std::endl
+            << "  Samples per frame  : " << num_input_samples_per_frame << std::endl
+            << "  Number of streams  : " << num_streams << std::endl;
+
+  size_t max_num_input_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;
+      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;
+    }
+
+    // max_num_samples should be aligned to 'num_input_samples_per_frame' automatically
+    if (max_num_input_samples < data.input_wav_samples->size()) {
+      max_num_input_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];
+    if (output_channels_ > 1) {
+      auto filename_wo_ext = output_wav_list[i].substr(0, output_wav_list[i].find_last_of("."));
+
+      for (int ch = 0; ch < output_channels_; ch++) {
+        std::string filename = filename_wo_ext + "_ch" + std::to_string(ch + 1) + ".wav";
+        data.wav_write.emplace_back(
+            std::unique_ptr<CWaveFileWrite>(new CWaveFileWrite(filename,
+                                                               output_sample_rate_,
+                                                               1, 32, true)));
+
+      }
+    } else {
+      data.wav_write.emplace_back(std::unique_ptr<CWaveFileWrite>(new CWaveFileWrite(output_wav_list[i], output_sample_rate_,
+                                                                                     1, 32, true)));
+    }
+    for (int ch = 0; ch < num_output_channels; ch++) {
+      if (!data.wav_write[ch]->initFile()) {
+        std::cerr << "Unable to open file for writing: "
+                  << data.wav_write[ch]->getFileName() << 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;
+      }
+
+    }
+    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& data : stream_data_) {
+    data.input_wav_samples->resize(max_num_input_samples);
+  }
+
+  float frame_in_secs = static_cast<float>(num_input_samples_per_frame) /
+                        static_cast<float>(input_sample_rate_);
+  float total_run_time = 0.f;
+  float total_audio_duration = 0.f;
+  float checkpoint = 0.1f;
+  float expected_audio_duration = static_cast<float>(max_num_input_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();
+
+  std::vector<NvAFX_Bool> bitmap(input_wav_list.size(), NVAFX_FALSE);
+
+  // wav data is already padded to align to num_input_samples_per_frame by ReadWavFile()
+  for (size_t offset = 0; offset < max_num_input_samples; offset += num_input_samples_per_frame) {
+    // prepare input data
+    bool should_reset = false;
+    for (unsigned i = 0; i < num_streams; ++i) {
+      float *in = stream_data_[i].input_wav_samples->data() + offset;
+      std::copy(in, in + num_input_samples_per_frame, &input_frame[i * num_input_samples_per_frame]);
+      if (is_aec) {
+        in = stream_data_[i].input_farend_wav_samples->data() + offset;
+        std::copy(in, in + num_input_samples_per_frame, &input_frame[(num_streams + i) * num_input_samples_per_frame]);
+      }
+
+      // Check if this file finished, if so, start a new file
+      if (stream_data_[i].file_end_offsets.size() &&
+          offset == static_cast<unsigned>(stream_data_[i].file_end_offsets[0])) {
+        stream_data_[i].file_end_offsets.erase(stream_data_[i].file_end_offsets.begin());
+        if (stream_data_[i].file_end_offsets.size()) {
+          // Open a new file only if this isn't the last one
+
+          if (output_channels_ > 1) {
+            uint32_t output_num = ++stream_data_[i].output_file_num;
+            auto filename_wo_ext = output_wav_list[i].substr(0, output_wav_list[i].find_last_of("_"));
+            for (int ch = 0; ch < output_channels_; ch++) {
+              stream_data_[i].wav_write[ch]->commitFile();
+              std::string filename = filename_wo_ext + + "_" + std::to_string(output_num) +
+                  "_ch" + std::to_string(ch + 1) + ".wav";
+              stream_data_[i].wav_write[ch] = std::unique_ptr<CWaveFileWrite>(new CWaveFileWrite(filename, output_sample_rate_,
+                                                                     1, 32, true));
+              if (!stream_data_[i].wav_write[ch]->initFile()) {
+                std::cerr << "Unable to open file for writing: " << filename;
+                return false;
+              }
+            }
+          } else {
+            auto ext = output_wav_list[i].find_last_of(".");
+            std::string filename = output_wav_list[i].substr(0, ext) + "_" +
+                std::to_string(++stream_data_[i].output_file_num) + ".wav";
+            stream_data_[i].wav_write[0] = std::unique_ptr<CWaveFileWrite>(new CWaveFileWrite(filename, output_sample_rate_,
+                                                                   1, 32, true));
+
+            if (!stream_data_[i].wav_write[0]->initFile()) {
+              std::cerr << "Unable to open file for writing: " << filename;
+              return false;
+            }
+          }
+
+
+          if (reset_list[i]) {
+            should_reset = true;
+            bitmap[i] = NVAFX_TRUE;
+          }
+        }
+      }
+    }
+
+    if (should_reset) {
+      if (NvAFX_Reset(handle, bitmap.data(), input_wav_list.size()) != NVAFX_STATUS_SUCCESS) {
+        std::cerr << "Reset failed" << std::endl;
+        return false;
+      }
+      memset(bitmap.data(), NVAFX_FALSE, sizeof(NvAFX_Bool) * bitmap.size());
+    }
+
+    const float* input[2];
+    float* output[2];
+    input[0] = input_frame.data();
+    if (is_aec) {
+      input[1] = &input_frame[input_frame.size() / num_input_channels];
+    }
+
+    output[0] = output_frame.data();
+    if (num_output_channels > 1) {
+      output[1] = output_frame.data() + output_frame.size()/2;
+    }
+
+    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();
+    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 (unsigned i = 0; i < num_streams; ++i) {
+      unsigned idx = i * num_output_samples_per_frame;
+      std::vector<float*> outputs = {};
+      unsigned size_per_channel = output_frame.size()/output_channels_;
+      for (int ch = 0; ch < output_channels_; ch++) {
+        outputs.push_back(&output_frame[idx + ch * size_per_channel]);
+      }
+      if (!writeOutputWav(outputs, num_output_samples_per_frame, i)) {
+        return false;
+      }
+    }
+
+    if (real_time_) {
+      auto end_tick = std::chrono::high_resolution_clock::now();
+      std::chrono::duration<float> elapsed = end_tick - start_tick;
+      float sleep_time_secs = frame_in_secs - elapsed.count();
+      std::this_thread::sleep_for(std::chrono::milliseconds(static_cast<int>(sleep_time_secs * 1000)));
+    }
+  }
+
+  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;
+  if (real_time_) {
+    std::cout << "Note: App ran in real time mode i.e. simulated the input data rate of a mic" << std::endl
+              << "'Processing time' could be less then actual run time" << std::endl;
+  }
+
+  for (auto& data : stream_data_) {
+    for (int ch = 0; ch < output_channels_; ch++) {
+      data.wav_write[ch]->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* bad_option) {
+  std::ostringstream oss;
+  if (bad_option) {
+    oss << "Error parsing \"" << bad_option << "\"" << std::endl;
+  }
+  std::cout << "Command Line Options:" << std::endl
+            << "-c           Config file" << std::endl;
+
+  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; }
+}