sound_sampler.hpp

#pragma once
#include <ossia/dataflow/graph_node.hpp>
#include <ossia/dataflow/nodes/sound.hpp>
#include <ossia/dataflow/nodes/sound_utils.hpp>
 
namespace ossia::nodes
{
 
struct sound_sampler
{
  void set_start(std::size_t v) { start = v; }
 
  void set_upmix(std::size_t v) { upmix = v; }
 
  [[nodiscard]] std::size_t channels() const { return m_data.size(); }
 
  [[nodiscard]] std::size_t duration() const
  {
    return m_data.empty() ? 0 : m_data[0].size();
  }
 
  void transport(time_value date)
  {
    // No transport info: the live tempo is unknown, but the stretching seek
    // only needs the file's own tempo (see file_sample_for_model_time).
    info->m_resampler.transport(
        info->file_sample_for_model_time(date, 0., m_dataSampleRate));
  }
 
  void transport(time_value date, const ossia::tick_transport_info& tinfo)
  {
    info->m_resampler.transport(info->file_sample_for_model_time(
        date, tinfo.current_tempo, m_dataSampleRate));
  }
 
  // Used for testing only
  void set_sound(audio_array data)
  {
    m_handle = std::make_shared<audio_data>();
    m_handle->data = std::move(data);
    m_data.clear();
    {
      m_dataSampleRate = 44100;
      m_data.assign(m_handle->data.begin(), m_handle->data.end());
      info->m_resampler.reset(
          0, audio_stretch_mode::None, m_handle->data.size(), m_dataSampleRate,
          m_dataSampleRate);
    }
  }
 
  void set_sound(const audio_handle& hdl, int channels, int sampleRate)
  {
    m_handle = hdl;
    m_data.clear();
    if(hdl)
    {
      m_dataSampleRate = sampleRate;
      m_data.assign(m_handle->data.begin(), m_handle->data.end());
    }
  }
 
  template <typename T>
  void fetch_audio(
      const int64_t start, const int64_t samples_to_write,
      T** const audio_array) const noexcept
  {
    read_audio_from_buffer(
        m_data, start, samples_to_write, info->m_start_offset_samples,
        info->m_loop_duration_samples, info->m_loops, audio_array);
  }
 
  template <typename T>
  void fetch_audio_backward(
      const int64_t start, const int64_t samples_to_write,
      T** const audio_array) const noexcept
  {
    read_audio_from_buffer_backward(
        m_data, start, samples_to_write, info->m_start_offset_samples,
        info->m_loop_duration_samples, info->m_loops, audio_array);
  }
 
  void run(const ossia::token_request& t, ossia::exec_state_facade e) noexcept
  {
    if(m_data.empty())
      return;
 
    const std::size_t chan = m_data.size();
    const std::size_t len = m_data[0].size();
    ossia::audio_port& ap = *audio_out;
    ap.set_channels(std::max(this->upmix, chan));
 
    const auto [samples_to_read, samples_to_write]
        = snd::sample_info(e.bufferSize(), e.modelToSamples(), t);
    // Only the write count decides whether there is anything to do, as in
    // sound_mmap and sound_libav. The read count is a floor over absolute model
    // time while the write count is a floor over the offset into the buffer, so
    // a tick can legitimately cover a sample without consuming a whole new one;
    // bailing here left a hole and a stale m_prev_date.
    if(samples_to_write <= 0)
      return;
 
    assert(samples_to_write > 0);
 
    const auto samples_offset = t.physical_start(e.modelToSamples());
 
    if(t.forward())
    {
      if(t.prev_date < info->m_prev_date)
      {
        // First run after add_time_process() left the stretcher already
        // primed; calling transport() again would reset it.
        if(info->m_prev_date == ossia::time_value{ossia::time_value::infinite_min})
          info->m_prev_date = t.prev_date;
        else
          transport(t.prev_date);
      }
    }
    else
    {
      if(t.prev_date > info->m_prev_date)
      {
        if(info->m_prev_date == ossia::time_value{ossia::time_value::infinite_min})
          info->m_prev_date = t.prev_date;
        else
          transport(t.prev_date);
      }
    }
 
    for(std::size_t i = 0; i < chan; ++i)
    {
      ap.channel(i).resize(e.bufferSize());
    }
 
    const double rate_ratio = snd::rate_ratio(m_dataSampleRate, e.sampleRate());
    const double stretch_ratio = info->update_stretch(t, e, rate_ratio);
    const double abs_stretch_ratio = std::abs(stretch_ratio);
 
    info->m_resampler.run(
        *this, t, e, stretch_ratio, rate_ratio, chan, len, samples_to_read,
        samples_to_write, samples_offset, ap);
 
    const bool start_discontinuous = t.start_discontinuous || (m_last_stretch > 70.);
    const bool end_discontinuous = t.end_discontinuous || (abs_stretch_ratio > 70.);
    if(abs_stretch_ratio > 70. && m_last_stretch > 70.)
    {
      [[unlikely]];
      for(std::size_t i = 0; i < chan; i++)
      {
        ossia::snd::do_zero(ap.channel(i), samples_offset, samples_to_write);
      }
    }
    else
    {
      [[likely]];
      for(std::size_t i = 0; i < chan; i++)
      {
        ossia::snd::do_fade(
            start_discontinuous, end_discontinuous, ap.channel(i), samples_offset,
            samples_to_write);
      }
    }
 
    ossia::snd::perform_upmix(this->upmix, chan, ap);
    ossia::snd::perform_start_offset(this->start, ap);
 
    info->m_prev_date = t.date;
    m_last_stretch = abs_stretch_ratio;
  }
 
  sound_processing_info* info{};
  ossia::audio_port* audio_out{};
 
  audio_span<float> m_data{};
 
  std::size_t start{};
  std::size_t upmix{};
 
  std::size_t m_dataSampleRate{};
  audio_handle m_handle{};
  double m_last_stretch{1.0};
};
}