torchaudio 0.4.1 → 0.5.0

data/ext/torchaudio/csrc/sox.cpp

@@ -1,361 +0,0 @@
-#include <torchaudio/csrc/sox.h>
-
-#include <algorithm>
-#include <cstdint>
-#include <stdexcept>
-#include <vector>
-
-namespace torch {
-namespace audio {
-namespace {
-/// Helper struct to safely close the sox_format_t descriptor.
-struct SoxDescriptor {
-  explicit SoxDescriptor(sox_format_t* fd) noexcept : fd_(fd) {}
-  SoxDescriptor(const SoxDescriptor& other) = delete;
-  SoxDescriptor(SoxDescriptor&& other) = delete;
-  SoxDescriptor& operator=(const SoxDescriptor& other) = delete;
-  SoxDescriptor& operator=(SoxDescriptor&& other) = delete;
-  ~SoxDescriptor() {
-    if (fd_ != nullptr) {
-      sox_close(fd_);
-    }
-  }
-  sox_format_t* operator->() noexcept {
-    return fd_;
-  }
-  sox_format_t* get() noexcept {
-    return fd_;
-  }
-
- private:
-  sox_format_t* fd_;
-};
-
-int64_t write_audio(SoxDescriptor& fd, at::Tensor tensor) {
-  std::vector<sox_sample_t> buffer(tensor.numel());
-
-  AT_DISPATCH_ALL_TYPES(tensor.scalar_type(), "write_audio_buffer", [&] {
-    auto* data = tensor.data_ptr<scalar_t>();
-    std::copy(data, data + tensor.numel(), buffer.begin());
-  });
-
-  const auto samples_written =
-      sox_write(fd.get(), buffer.data(), buffer.size());
-
-  return samples_written;
-}
-
-void read_audio(
-    SoxDescriptor& fd,
-    at::Tensor output,
-    int64_t buffer_length) {
-  std::vector<sox_sample_t> buffer(buffer_length);
-
-  int number_of_channels = fd->signal.channels;
-  const int64_t samples_read = sox_read(fd.get(), buffer.data(), buffer_length);
-  if (samples_read == 0) {
-    throw std::runtime_error(
-        "Error reading audio file: empty file or read failed in sox_read");
-  }
-
-  output.resize_({samples_read / number_of_channels, number_of_channels});
-  output = output.contiguous();
-
-  AT_DISPATCH_ALL_TYPES(output.scalar_type(), "read_audio_buffer", [&] {
-    auto* data = output.data_ptr<scalar_t>();
-    std::copy(buffer.begin(), buffer.begin() + samples_read, data);
-  });
-}
-} // namespace
-
-std::tuple<sox_signalinfo_t, sox_encodinginfo_t> get_info(
-    const std::string& file_name
-  ) {
-  SoxDescriptor fd(sox_open_read(
-      file_name.c_str(),
-      /*signal=*/nullptr,
-      /*encoding=*/nullptr,
-      /*filetype=*/nullptr));
-  if (fd.get() == nullptr) {
-    throw std::runtime_error("Error opening audio file");
-  }
-  return std::make_tuple(fd->signal, fd->encoding);
-}
-
-int read_audio_file(
-    const std::string& file_name,
-    at::Tensor output,
-    bool ch_first,
-    int64_t nframes,
-    int64_t offset,
-    sox_signalinfo_t* si,
-    sox_encodinginfo_t* ei,
-    const char* ft) {
-
-  SoxDescriptor fd(sox_open_read(file_name.c_str(), si, ei, ft));
-  if (fd.get() == nullptr) {
-    throw std::runtime_error("Error opening audio file");
-  }
-
-  // signal info
-
-  const int number_of_channels = fd->signal.channels;
-  const int sample_rate = fd->signal.rate;
-  const int64_t total_length = fd->signal.length;
-
-  // multiply offset and number of frames by number of channels
-  offset *= number_of_channels;
-  nframes *= number_of_channels;
-
-  if (total_length == 0) {
-    throw std::runtime_error("Error reading audio file: unknown length");
-  }
-  if (offset > total_length) {
-    throw std::runtime_error("Offset past EOF");
-  }
-
-  // calculate buffer length
-  int64_t buffer_length = total_length;
-  if (offset > 0) {
-      buffer_length -= offset;
-  }
-  if (nframes > 0 && buffer_length > nframes) {
-      buffer_length = nframes;
-  }
-
-  // seek to offset point before reading data
-  if (sox_seek(fd.get(), offset, 0) == SOX_EOF) {
-    throw std::runtime_error("sox_seek reached EOF, try reducing offset or num_samples");
-  }
-
-  // read data and fill output tensor
-  read_audio(fd, output, buffer_length);
-
-  // L x C -> C x L, if desired
-  if (ch_first) {
-    output.transpose_(1, 0);
-  }
-
-  return sample_rate;
-}
-
-void write_audio_file(
-    const std::string& file_name,
-    const at::Tensor& tensor,
-    sox_signalinfo_t* si,
-    sox_encodinginfo_t* ei,
-    const char* file_type) {
-  if (!tensor.is_contiguous()) {
-    throw std::runtime_error(
-        "Error writing audio file: input tensor must be contiguous");
-  }
-
-#if SOX_LIB_VERSION_CODE >= 918272 // >= 14.3.0
-  si->mult = nullptr;
-#endif
-
-  SoxDescriptor fd(sox_open_write(
-      file_name.c_str(),
-      si,
-      ei,
-      file_type,
-      /*oob=*/nullptr,
-      /*overwrite=*/nullptr));
-
-  if (fd.get() == nullptr) {
-    throw std::runtime_error(
-        "Error writing audio file: could not open file for writing");
-  }
-
-  const auto samples_written = write_audio(fd, tensor);
-
-  if (samples_written != tensor.numel()) {
-    throw std::runtime_error(
-        "Error writing audio file: could not write entire buffer");
-  }
-}
-
-int build_flow_effects(const std::string& file_name,
-                       at::Tensor otensor,
-                       bool ch_first,
-                       sox_signalinfo_t* target_signal,
-                       sox_encodinginfo_t* target_encoding,
-                       const char* file_type,
-                       std::vector<SoxEffect> pyeffs,
-                       int max_num_eopts) {
-
-  /* This function builds an effects flow and puts the results into a tensor.
-     It can also be used to re-encode audio using any of the available encoding
-     options in SoX including sample rate and channel re-encoding.              */
-
-  // open input
-  sox_format_t* input = sox_open_read(file_name.c_str(), nullptr, nullptr, nullptr);
-  if (input == nullptr) {
-    throw std::runtime_error("Error opening audio file");
-  }
-
-  // only used if target signal or encoding are null
-  sox_signalinfo_t empty_signal;
-  sox_encodinginfo_t empty_encoding;
-
-  // set signalinfo and encodinginfo if blank
-  if(target_signal == nullptr) {
-    target_signal = &empty_signal;
-    target_signal->rate = input->signal.rate;
-    target_signal->channels = input->signal.channels;
-    target_signal->length = SOX_UNSPEC;
-    target_signal->precision = input->signal.precision;
-#if SOX_LIB_VERSION_CODE >= 918272 // >= 14.3.0
-    target_signal->mult = nullptr;
-#endif
-  }
-  if(target_encoding == nullptr) {
-    target_encoding = &empty_encoding;
-    target_encoding->encoding = SOX_ENCODING_SIGN2; // Sample format
-    target_encoding->bits_per_sample = input->signal.precision; // Bits per sample
-    target_encoding->compression = 0.0; // Compression factor
-    target_encoding->reverse_bytes = sox_option_default; // Should bytes be reversed
-    target_encoding->reverse_nibbles = sox_option_default; // Should nibbles be reversed
-    target_encoding->reverse_bits = sox_option_default; // Should bits be reversed (pairs of bits?)
-    target_encoding->opposite_endian = sox_false; // Reverse endianness
-  }
-
-  // check for rate or channels effect and change the output signalinfo accordingly
-  for (SoxEffect se : pyeffs) {
-    if (se.ename == "rate") {
-      target_signal->rate = std::stod(se.eopts[0]);
-    } else if (se.ename == "channels") {
-      target_signal->channels = std::stoi(se.eopts[0]);
-    }
-  }
-
-  // create interm_signal for effects, intermediate steps change this in-place
-  sox_signalinfo_t interm_signal = input->signal;
-
-#ifdef __APPLE__
-  // According to Mozilla Deepspeech sox_open_memstream_write doesn't work
-  // with OSX
-  char tmp_name[] = "/tmp/fileXXXXXX";
-  int tmp_fd = mkstemp(tmp_name);
-  close(tmp_fd);
-  sox_format_t* output = sox_open_write(tmp_name, target_signal,
-                                        target_encoding, "wav", nullptr, nullptr);
-#else
-  // create buffer and buffer_size for output in memwrite
-  char* buffer;
-  size_t buffer_size;
-  // in-memory descriptor (this may not work for OSX)
-  sox_format_t* output = sox_open_memstream_write(&buffer,
-                                                  &buffer_size,
-                                                  target_signal,
-                                                  target_encoding,
-                                                  file_type, nullptr);
-#endif
-  if (output == nullptr) {
-    throw std::runtime_error("Error opening output memstream/temporary file");
-  }
-  // Setup the effects chain to decode/resample
-  sox_effects_chain_t* chain =
-    sox_create_effects_chain(&input->encoding, &output->encoding);
-
-  sox_effect_t* e = sox_create_effect(sox_find_effect("input"));
-  char* io_args[1];
-  io_args[0] = (char*)input;
-  sox_effect_options(e, 1, io_args);
-  sox_add_effect(chain, e, &interm_signal, &input->signal);
-  free(e);
-
-  for(SoxEffect tae : pyeffs) {
-    if(tae.ename == "no_effects") break;
-    e = sox_create_effect(sox_find_effect(tae.ename.c_str()));
-    e->global_info->global_info->verbosity = 1;
-    if(tae.eopts[0] == "") {
-      sox_effect_options(e, 0, nullptr);
-    } else {
-      int num_opts = tae.eopts.size();
-      char* sox_args[max_num_eopts];
-      for(std::vector<std::string>::size_type i = 0; i != tae.eopts.size(); i++) {
-        sox_args[i] = (char*) tae.eopts[i].c_str();
-      }
-      if(sox_effect_options(e, num_opts, sox_args) != SOX_SUCCESS) {
-#ifdef __APPLE__
-        unlink(tmp_name);
-#endif
-        throw std::runtime_error("invalid effect options, see SoX docs for details");
-      }
-    }
-    sox_add_effect(chain, e, &interm_signal, &output->signal);
-    free(e);
-  }
-
-  e = sox_create_effect(sox_find_effect("output"));
-  io_args[0] = (char*)output;
-  sox_effect_options(e, 1, io_args);
-  sox_add_effect(chain, e, &interm_signal, &output->signal);
-  free(e);
-
-  // Finally run the effects chain
-  sox_flow_effects(chain, nullptr, nullptr);
-  sox_delete_effects_chain(chain);
-
-  // Close sox handles, buffer does not get properly sized until these are closed
-  sox_close(output);
-  sox_close(input);
-
-  int sr;
-  // Read the in-memory audio buffer or temp file that we just wrote.
-#ifdef __APPLE__
-  /*
-     Temporary filetype must have a valid header.  Wav seems to work here while
-     raw does not.  Certain effects like chorus caused strange behavior on the mac.
-  */
-  // read_audio_file reads the temporary file and returns the sr and otensor
-  sr = read_audio_file(tmp_name, otensor, ch_first, 0, 0,
-                       target_signal, target_encoding, "wav");
-  // delete temporary audio file
-  unlink(tmp_name);
-#else
-  // Resize output tensor to desired dimensions, different effects result in output->signal.length,
-  // interm_signal.length and buffer size being inconsistent with the result of the file output.
-  // We prioritize in the order: output->signal.length > interm_signal.length > buffer_size
-  // Could be related to: https://sourceforge.net/p/sox/bugs/314/
-  int nc, ns;
-  if (output->signal.length == 0) {
-    // sometimes interm_signal length is extremely large, but the buffer_size
-    // is double the length of the output signal
-    if (interm_signal.length > (buffer_size * 10)) {
-      ns = buffer_size / 2;
-    } else {
-      ns = interm_signal.length;
-    }
-    nc = interm_signal.channels;
-  } else {
-    nc = output->signal.channels;
-    ns = output->signal.length;
-  }
-  otensor.resize_({ns/nc, nc});
-  otensor = otensor.contiguous();
-
-  input = sox_open_mem_read(buffer, buffer_size, target_signal, target_encoding, file_type);
-  std::vector<sox_sample_t> samples(buffer_size);
-  const int64_t samples_read = sox_read(input, samples.data(), buffer_size);
-  assert(samples_read != nc * ns && samples_read != 0);
-  AT_DISPATCH_ALL_TYPES(otensor.scalar_type(), "effects_buffer", [&] {
-    auto* data = otensor.data_ptr<scalar_t>();
-    std::copy(samples.begin(), samples.begin() + samples_read, data);
-  });
-  // free buffer and close mem_read
-  sox_close(input);
-  free(buffer);
-
-  if (ch_first) {
-    otensor.transpose_(1, 0);
-  }
-  sr = target_signal->rate;
-
-#endif
-  // return sample rate, output tensor modified in-place
-  return sr;
-}
-} // namespace audio
-} // namespace torch

data/ext/torchaudio/csrc/sox.h

@@ -1,71 +0,0 @@
-#include <sox.h>
-
-#include <string>
-#include <tuple>
-#include <vector>
-#include <unistd.h>
-
-// same as <torch/extension.h> without <torch/python.h>
-#include <torch/all.h>
-
-namespace at {
-struct Tensor;
-} // namespace at
-
-namespace torch { namespace audio {
-
-/// Reads an audio file from the given `path` into the `output` `Tensor` and
-/// returns the sample rate of the audio file.
-/// Throws `std::runtime_error` if the audio file could not be opened, or an
-/// error occurred during reading of the audio data.
-int read_audio_file(
-    const std::string& file_name,
-    at::Tensor output,
-    bool ch_first,
-    int64_t nframes,
-    int64_t offset,
-    sox_signalinfo_t* si,
-    sox_encodinginfo_t* ei,
-    const char* ft);
-
-/// Writes the data of a `Tensor` into an audio file at the given `path`, with
-/// a certain extension (e.g. `wav`or `mp3`) and sample rate.
-/// Throws `std::runtime_error` when the audio file could not be opened for
-/// writing, or an error occurred during writing of the audio data.
-void write_audio_file(
-    const std::string& file_name,
-    const at::Tensor& tensor,
-    sox_signalinfo_t* si,
-    sox_encodinginfo_t* ei,
-    const char* file_type);
-
-/// Reads an audio file from the given `path` and returns a tuple of
-/// sox_signalinfo_t and sox_encodinginfo_t, which contain information about
-/// the audio file such as sample rate, length, bit precision, encoding and more.
-/// Throws `std::runtime_error` if the audio file could not be opened, or an
-/// error occurred during reading of the audio data.
-std::tuple<sox_signalinfo_t, sox_encodinginfo_t> get_info(
-    const std::string& file_name);
-
-// Struct for build_flow_effects function
-struct SoxEffect {
-  SoxEffect() : ename(""), eopts({""})  { }
-  std::string ename;
-  std::vector<std::string> eopts;
-};
-
-/// Build a SoX chain, flow the effects, and capture the results in a tensor.
-/// An audio file from the given `path` flows through an effects chain given
-/// by a list of effects and effect options to an output buffer which is encoded
-/// into memory to a target signal type and target signal encoding.  The resulting
-/// buffer is then placed into a tensor.  This function returns the output tensor
-/// and the sample rate of the output tensor.
-int build_flow_effects(const std::string& file_name,
-                       at::Tensor otensor,
-                       bool ch_first,
-                       sox_signalinfo_t* target_signal,
-                       sox_encodinginfo_t* target_encoding,
-                       const char* file_type,
-                       std::vector<SoxEffect> pyeffs,
-                       int max_num_eopts);
-}} // namespace torch::audio

data/ext/torchaudio/csrc/sox_effects.cpp

@@ -1,54 +0,0 @@
-#include <sox.h>
-#include <torchaudio/csrc/sox_effects.h>
-
-using namespace torch::indexing;
-
-namespace torchaudio {
-namespace sox_effects {
-
-namespace {
-
-enum SoxEffectsResourceState { NotInitialized, Initialized, ShutDown };
-SoxEffectsResourceState SOX_RESOURCE_STATE = NotInitialized;
-
-} // namespace
-
-void initialize_sox_effects() {
-  if (SOX_RESOURCE_STATE == ShutDown) {
-    throw std::runtime_error(
-        "SoX Effects has been shut down. Cannot initialize again.");
-  }
-  if (SOX_RESOURCE_STATE == NotInitialized) {
-    if (sox_init() != SOX_SUCCESS) {
-      throw std::runtime_error("Failed to initialize sox effects.");
-    };
-    SOX_RESOURCE_STATE = Initialized;
-  }
-};
-
-void shutdown_sox_effects() {
-  if (SOX_RESOURCE_STATE == NotInitialized) {
-    throw std::runtime_error(
-        "SoX Effects is not initialized. Cannot shutdown.");
-  }
-  if (SOX_RESOURCE_STATE == Initialized) {
-    if (sox_quit() != SOX_SUCCESS) {
-      throw std::runtime_error("Failed to initialize sox effects.");
-    };
-    SOX_RESOURCE_STATE = ShutDown;
-  }
-}
-
-std::vector<std::string> list_effects() {
-  std::vector<std::string> names;
-  const sox_effect_fn_t* fns = sox_get_effect_fns();
-  for (int i = 0; fns[i]; ++i) {
-    const sox_effect_handler_t* handler = fns[i]();
-    if (handler && handler->name)
-      names.push_back(handler->name);
-  }
-  return names;
-}
-
-} // namespace sox_effects
-} // namespace torchaudio

data/ext/torchaudio/csrc/sox_effects.h

@@ -1,18 +0,0 @@
-#ifndef TORCHAUDIO_SOX_EFFECTS_H
-#define TORCHAUDIO_SOX_EFFECTS_H
-
-#include <torch/script.h>
-
-namespace torchaudio {
-namespace sox_effects {
-
-void initialize_sox_effects();
-
-void shutdown_sox_effects();
-
-std::vector<std::string> list_effects();
-
-} // namespace sox_effects
-} // namespace torchaudio
-
-#endif

data/ext/torchaudio/csrc/sox_io.cpp

@@ -1,170 +0,0 @@
-#include <sox.h>
-#include <torchaudio/csrc/sox_io.h>
-#include <torchaudio/csrc/sox_utils.h>
-
-using namespace torch::indexing;
-using namespace torchaudio::sox_utils;
-
-namespace torchaudio {
-namespace sox_io {
-
-SignalInfo::SignalInfo(
-    const int64_t sample_rate_,
-    const int64_t num_channels_,
-    const int64_t num_frames_)
-    : sample_rate(sample_rate_),
-      num_channels(num_channels_),
-      num_frames(num_frames_){};
-
-int64_t SignalInfo::getSampleRate() const {
-  return sample_rate;
-}
-
-int64_t SignalInfo::getNumChannels() const {
-  return num_channels;
-}
-
-int64_t SignalInfo::getNumFrames() const {
-  return num_frames;
-}
-
-c10::intrusive_ptr<SignalInfo> get_info(const std::string& path) {
-  SoxFormat sf(sox_open_read(
-      path.c_str(),
-      /*signal=*/nullptr,
-      /*encoding=*/nullptr,
-      /*filetype=*/nullptr));
-
-  if (static_cast<sox_format_t*>(sf) == nullptr) {
-    throw std::runtime_error("Error opening audio file");
-  }
-
-  return c10::make_intrusive<SignalInfo>(
-      static_cast<int64_t>(sf->signal.rate),
-      static_cast<int64_t>(sf->signal.channels),
-      static_cast<int64_t>(sf->signal.length / sf->signal.channels));
-}
-
-c10::intrusive_ptr<TensorSignal> load_audio_file(
-    const std::string& path,
-    const int64_t frame_offset,
-    const int64_t num_frames,
-    const bool normalize,
-    const bool channels_first) {
-  if (frame_offset < 0) {
-    throw std::runtime_error(
-        "Invalid argument: frame_offset must be non-negative.");
-  }
-  if (num_frames == 0 || num_frames < -1) {
-    throw std::runtime_error(
-        "Invalid argument: num_frames must be -1 or greater than 0.");
-  }
-
-  SoxFormat sf(sox_open_read(
-      path.c_str(),
-      /*signal=*/nullptr,
-      /*encoding=*/nullptr,
-      /*filetype=*/nullptr));
-
-  validate_input_file(sf);
-
-  const int64_t num_channels = sf->signal.channels;
-  const int64_t num_total_samples = sf->signal.length;
-  const int64_t sample_start = sf->signal.channels * frame_offset;
-
-  if (sox_seek(sf, sample_start, 0) == SOX_EOF) {
-    throw std::runtime_error("Error reading audio file: offset past EOF.");
-  }
-
-  const int64_t sample_end = [&]() {
-    if (num_frames == -1)
-      return num_total_samples;
-    const int64_t sample_end_ = num_channels * num_frames + sample_start;
-    if (num_total_samples < sample_end_) {
-      // For lossy encoding, it is difficult to predict exact size of buffer for
-      // reading the number of samples required.
-      // So we allocate buffer size of given `num_frames` and ask sox to read as
-      // much as possible. For lossless format, sox reads exact number of
-      // samples, but for lossy encoding, sox can end up reading less. (i.e.
-      // mp3) For the consistent behavior specification between lossy/lossless
-      // format, we allow users to provide `num_frames` value that exceeds #of
-      // available samples, and we adjust it here.
-      return num_total_samples;
-    }
-    return sample_end_;
-  }();
-
-  const int64_t max_samples = sample_end - sample_start;
-
-  // Read samples into buffer
-  std::vector<sox_sample_t> buffer;
-  buffer.reserve(max_samples);
-  const int64_t num_samples = sox_read(sf, buffer.data(), max_samples);
-  if (num_samples == 0) {
-    throw std::runtime_error(
-        "Error reading audio file: empty file or read operation failed.");
-  }
-  // NOTE: num_samples may be smaller than max_samples if the input
-  // format is compressed (i.e. mp3).
-
-  // Convert to Tensor
-  auto tensor = convert_to_tensor(
-      buffer.data(),
-      num_samples,
-      num_channels,
-      get_dtype(sf->encoding.encoding, sf->signal.precision),
-      normalize,
-      channels_first);
-
-  return c10::make_intrusive<TensorSignal>(
-      tensor, static_cast<int64_t>(sf->signal.rate), channels_first);
-}
-
-void save_audio_file(
-    const std::string& file_name,
-    const c10::intrusive_ptr<TensorSignal>& signal,
-    const double compression) {
-  const auto tensor = signal->getTensor();
-  const auto sample_rate = signal->getSampleRate();
-  const auto channels_first = signal->getChannelsFirst();
-
-  validate_input_tensor(tensor);
-
-  const auto filetype = get_filetype(file_name);
-  const auto signal_info =
-      get_signalinfo(tensor, sample_rate, channels_first, filetype);
-  const auto encoding_info =
-      get_encodinginfo(filetype, tensor.dtype(), compression);
-
-  SoxFormat sf(sox_open_write(
-      file_name.c_str(),
-      &signal_info,
-      &encoding_info,
-      /*filetype=*/filetype.c_str(),
-      /*oob=*/nullptr,
-      /*overwrite_permitted=*/nullptr));
-
-  if (static_cast<sox_format_t*>(sf) == nullptr) {
-    throw std::runtime_error("Error saving audio file: failed to open file.");
-  }
-
-  auto tensor_ = tensor;
-  if (channels_first) {
-    tensor_ = tensor_.t();
-  }
-
-  const int64_t frames_per_chunk = 65536;
-  for (int64_t i = 0; i < tensor_.size(0); i += frames_per_chunk) {
-    auto chunk = tensor_.index({Slice(i, i + frames_per_chunk), Slice()});
-    chunk = unnormalize_wav(chunk).contiguous();
-
-    const size_t numel = chunk.numel();
-    if (sox_write(sf, chunk.data_ptr<int32_t>(), numel) != numel) {
-      throw std::runtime_error(
-          "Error saving audio file: failed to write the entier buffer.");
-    }
-  }
-}
-
-} // namespace sox_io
-} // namespace torchaudio