LooperNode.hpp

#pragma once
#include <Fx/Looper/LooperView.hpp>
#include <Fx/Looper/Switches.hpp>
#include <Fx/Looper/TakeWriter.hpp>
#include <Fx/Looper/Transport.hpp>
 
#include <ossia/dataflow/token_request.hpp>
 
#include <algorithm>
#include <atomic>
#include <cmath>
#include <cstdint>
#include <utility>
 
namespace Nodes::Looper
{
struct capture_window
{
  int64_t end{};
  int64_t n{};
  int64_t length{};
  double y_end{};
  double rate{1.};
  bool backwards{};
 
  static int64_t wrap(int64_t k, int64_t len) noexcept
  {
    k %= len;
    return k < 0 ? k + len : k;
  }
  int64_t positions() const noexcept
  {
    return std::clamp<int64_t>(std::llround(double(n) * rate), 0, length);
  }
  int64_t start() const noexcept
  {
    const auto y = int64_t(std::floor(y_end));
    return backwards ? wrap(length - y, length) : wrap(y - positions(), length);
  }
  int64_t position(int64_t t) const noexcept
  {
    double y = std::fmod(y_end - double(end - t) * rate, double(length));
    if(y < 0.)
      y += double(length);
    const int64_t k = std::min(int64_t(y), length - 1);
    return backwards ? wrap(length - k, length) : k;
  }
  int64_t progress(int64_t t) const noexcept
  {
    return std::clamp<int64_t>(int64_t(double(t - (end - n)) * rate), 0, positions());
  }
  bool contains(int64_t t) const noexcept { return t >= end - n && t < end; }
};
 
template <typename Node>
struct looper_node
{
  using LoopMode = Looper::LoopMode;
  using tick = ossia::token_request;
 
  Looper::transport transport;
 
  void loop_arrived() noexcept { m_loop.arrived = true; }
 
  // The transport's engine
  void looper_close_take(
      const ossia::token_request& tk, LoopMode mode, bool ended_by_postaction);
  int64_t looper_trim_extension(int64_t max_frames);
  void looper_rephase(const ossia::token_request& tk);
  int64_t looper_frames_to_end() const noexcept;
  Looper::loop_period looper_period(const ossia::token_request& tk) const noexcept;
  void looper_point()
  {
    m_switches.apply(self().inputs, self());
    m_speed = Looper::clamp_speed(self().inputs.speed.value);
    m_reverse = self().inputs.reverse.value;
  }
 
  // The switches' engine
  int looper_passes() const noexcept { return stack().count; }
  bool looper_muted(int pass) const noexcept { return stack().layers[pass].muted; }
  void looper_set_muted(int pass, bool muted)
  {
    if(stack().layers[pass].muted == muted)
      return;
    passes_changing();
    stack().set_muted(pass, muted);
  }
  void looper_mute(int pass) { mute_pass(pass); }
  void looper_erase(int pass) { erase_pass(pass); }
 
protected:
  static constexpr bool lazy_passes() noexcept
  {
    if constexpr(requires { Node::passes_wait_for_material; })
      return Node::passes_wait_for_material;
    else
      return false;
  }
 
  bool pass_pending() const noexcept { return m_pass_pending; }
  bool pass_open() const noexcept { return transport.is_taking() && !m_pass_pending; }
 
  void material_arriving()
  {
    if(!std::exchange(m_pass_pending, false))
      return;
    begin_pass_now(m_pending_start);
    // Undoing it gives back the loop as it was when the overdub began, before
    // it grew.
    if(auto* top = stack().top())
      top->loop_before = m_pending_length;
    if constexpr(lazy_passes())
      if(m_pending_progress > 0.)
        stack().advance_pass(m_pending_progress, m_pending_backwards);
  }
  void pass_advanced(double frames, bool backwards)
  {
    if(m_pass_pending)
    {
      m_pending_progress += frames;
      m_pending_backwards = backwards;
    }
    else if constexpr(lazy_passes())
      stack().advance_pass(frames, backwards);
  }
  double pass_progress() const noexcept
  {
    if(m_pass_pending)
      return m_pending_progress;
    if constexpr(lazy_passes())
      return stack().pass_progress;
    else
      return 0.;
  }
 
  void passes_changing()
  {
    m_version++;
    self().layers_changing();
  }
 
  Node& self() noexcept { return static_cast<Node&>(*this); }
  const Node& self() const noexcept { return static_cast<const Node&>(*this); }
  auto& stack() noexcept { return self().stack(); }
  const auto& stack() const noexcept { return self().stack(); }
 
  void view_request(const Looper::erase_request& r) noexcept
  {
    if(r.take > 0 && r.last >= 0)
    {
      m_part_request = r;
      return;
    }
    if(r.take > 0)
    {
      m_take_request = std::max(m_take_request, r.take);
      return;
    }
    m_erase_request = r;
    m_erase_requested = true;
  }
 
  void run_tick(const tick& tk);
  void apply_buttons();
  void follow_merges() { m_switches.follow_merges(self().inputs, stack().merged_passes); }
 
  void clear_loop();
  void drop_taken_pass();
  void undo_pass();
  void erase_pass(int pass);
  void mute_pass(int pass);
  int make_room();
  void begin_pass(int64_t start);
  void begin_pass_now(int64_t start);
  void close_pass(bool cycle = false);
  void merge_extra_pass();
  void capture(const tick& tk);
  void capture_layer(const tick& tk, int64_t now, int64_t end);
  void stop_score();
 
  double rounds_since_made(const ossia::token_request& tk) const noexcept
  {
    const double len = double(stack().length);
    const auto now = transport.timeline(tk);
    const double rounds
        = self().by_quarters()
              ? (now.quarters - m_origin.quarters) / (len / m_rate * m_loop_tempo / 60.)
              : (now.frames - m_origin.frames) / len;
    return rounds * m_speed;
  }
 
  void run_export();
  void take_written(int slot, int number, bool ok, bool alone);
  bool last_take_whole() const noexcept
  {
    return m_view.take > 0 && m_view.take_mix && m_view.take_layers >= stack().count
           && m_view.take_version == m_version && !m_export_pending
           && !self().view_writing();
  }
  void prepare_stop_notice(Looper::stop_take_notice& n, double date);
  static uint64_t next_looper_id() noexcept
  {
    static std::atomic<uint64_t> ids{};
    return ++ids;
  }
  int claim_take_slot() noexcept
  {
    const int slot = m_next_take_slot;
    m_next_take_slot = (slot + 1) % Looper::take_writer::slots;
    return slot;
  }
 
  bool view_due(int64_t frames) noexcept
  {
    if(!self().send_message)
      return false;
    m_view_countdown -= frames;
    if(m_view_countdown > 0)
      return false;
    m_view_countdown = int64_t(m_rate / 30.);
    return true;
  }
  void fill_view(Looper::view_message& v) const noexcept;
  bool placeable_take() const noexcept
  {
    if constexpr(requires(const Node& n) { n.take_placeable(); })
      return self().take_placeable();
    else
      return true;
  }
 
  double m_rate{48000.};
  double m_tempo{120.};
  ossia::time_signature m_signature{4, 4};
  LoopMode m_mode{LoopMode::Stop};
  Looper::loop_input m_loop;
  Looper::switches m_switches;
 
  double m_speed{1.};
  bool m_reverse{};
  Looper::transport::timeline_point m_origin{};
  double m_loop_tempo{120.};
  int64_t m_extend_unit{};
  bool m_extended{};
  bool m_cycle_pending{};
 
  // The takes: one is made each time a pass closes, and when the view asks
  // for one. Each file of it is written by the worker, one after the other
  // under one take number: the mix (item -1), then the layers.
  bool m_export_pending{};
  bool m_writing{};
  double m_export_date{};
  double m_job_date{};
  double m_export_tempo{120.};
  ossia::time_signature m_export_signature{4, 4};
  int m_export_item{};
  int m_export_layers{};
  bool m_export_mix{};
  int m_export_number{};
  int m_export_slot{};
  halp::clip_stretch m_job_stretch{};
  halp::clip_stretch m_stop_stretch{};
  int m_takes_written{};
  int m_take_request{};
  int m_job_request{};
  Looper::erase_request m_part_request{.pass = -1, .layers = -1};
  bool m_job_part{};
  int m_export_first{};
  int m_version{};
  int m_job_version{};
  bool m_pass_pending{};
  int64_t m_pending_start{};
  int64_t m_pending_length{};
  double m_pending_progress{};
  bool m_pending_backwards{};
  int m_next_take_slot{};
 
  int64_t m_view_countdown{};
  uint64_t m_id{next_looper_id()};
  int m_stops{};
  Looper::view_message m_view{};
  Looper::erase_request m_erase_request{};
  bool m_erase_requested{};
};
 
template <typename Node>
void looper_node<Node>::run_tick(const tick& tk)
{
  auto& in = self().inputs;
  auto& st = stack();
  const auto state = self().ossia_state;
  m_rate = state.sampleRate();
  m_tempo = tk.tempo;
  m_signature = tk.signature;
  m_speed = Looper::clamp_speed(in.speed.value);
  m_reverse = in.reverse.value;
  self().tick_started(tk);
 
  apply_buttons();
  follow_merges();
  if(in.capture.value)
    capture(tk);
  self().prepare_loop();
 
  const bool empty = st.empty() || self().busy();
  Looper::read_loop(in.mode, transport, m_loop, empty);
  m_switches.read(in, transport, self(), empty);
  transport.settle(empty);
 
  m_mode = transport.wanted;
  const Looper::transport_settings settings{
      .mode = m_mode,
      .quantif = in.quantif.value,
      .after_record = in.after_record,
      .postaction_bars = in.postaction_bars,
      .start_from = in.start_from,
      .late_seconds = in.late.value / 1000.,
      .stop_at = in.stop_at.value};
  transport(tk, state, settings, self());
  // Only a pass that starts with the take closing gets what it cut off.
  self().forget_carried();
  Looper::show_loop(in.mode, transport, m_loop);
  follow_merges();
  m_switches.follow(in, st.count);
 
  self().tick_finished(tk);
  follow_merges();
  run_export();
 
  self().outputs.phase.value
      = st.length > 0 ? float(transport.playbackPos % st.length) / float(st.length) : 0.f;
}
 
template <typename Node>
void looper_node<Node>::apply_buttons()
{
  auto& in = self().inputs;
  if(in.clear.value)
    clear_loop();
 
  // The m and x of a lane are layer actions as any: on the grid.
  if(std::exchange(m_erase_requested, false))
    m_switches.add(
        {m_erase_request.mute ? Looper::layer_action::mute : Looper::layer_action::erase,
         m_erase_request.pass, m_erase_request.layers},
        transport);
 
  if(in.undo.value || in.redo.value)
    m_switches.soloed.forget();
  if(in.undo.value)
  {
    if(pass_open())
      drop_taken_pass();
    else
    {
      passes_changing();
      undo_pass();
    }
  }
 
  if(in.redo.value && !pass_open())
  {
    passes_changing();
    const int out = stack().leaves_on_redo();
    if(stack().redo())
    {
      if(out >= 0)
        m_switches.removed(in, out);
      merge_extra_pass();
    }
  }
}
 
template <typename Node>
void looper_node<Node>::clear_loop()
{
  m_switches.soloed.forget();
  passes_changing();
  self().cleared();
  stack().clear();
  m_pass_pending = false;
  transport.playbackPos = 0;
  // Whatever was being taken in is gone with the rest.
  if(transport.is_taking())
    transport.taking(LoopMode::Stop);
  transport.restart_recording();
}
 
template <typename Node>
void looper_node<Node>::drop_taken_pass()
{
  passes_changing();
  if(transport.actualMode == LoopMode::Record)
  {
    stack().clear();
    transport.playbackPos = 0;
    transport.restart_recording();
  }
  else
  {
    self().pass_dropped();
    undo_pass();
    stack().drop_redo();
  }
  transport.taking(LoopMode::Stop);
}
 
template <typename Node>
void looper_node<Node>::undo_pass()
{
  const int back = stack().returns_on_undo();
  if(stack().undo() && back >= 0)
    m_switches.inserted(self().inputs, back, stack().count);
}
 
template <typename Node>
void looper_node<Node>::erase_pass(int pass)
{
  auto& st = stack();
  if(pass < 0 || pass >= st.count || self().busy())
    return;
  m_switches.soloed.forget();
  if(st.count == 1)
    clear_loop();
  else if(pass_open() && pass == st.count - 1)
    drop_taken_pass();
  else
  {
    passes_changing();
    if(st.erase(pass))
      m_switches.removed(self().inputs, pass);
  }
}
 
template <typename Node>
void looper_node<Node>::mute_pass(int pass)
{
  auto& st = stack();
  if(pass < 0 || pass >= st.count || self().busy())
    return;
  m_switches.soloed.forget();
  passes_changing();
  st.set_muted(pass, !st.layers[pass].muted);
}
 
template <typename Node>
int looper_node<Node>::make_room()
{
  auto& st = stack();
  if(self().inputs.at_max_layers.value != Looper::AtMaxLayers::ReplaceMuted
     || st.count < self().max_layers() || st.count < 2)
    return -1;
  int pass = st.count - 1;
  for(int i = 0; i < st.count; i++)
    if(st.layers[i].muted)
    {
      pass = i;
      break;
    }
  m_switches.soloed.forget();
  passes_changing();
  m_switches.removed(self().inputs, pass);
  return pass;
}
 
template <typename Node>
void looper_node<Node>::begin_pass(int64_t start)
{
  if constexpr(lazy_passes())
  {
    m_pass_pending = true;
    m_pending_start = start;
    m_pending_length = stack().length;
    m_pending_progress = 0.;
    m_pending_backwards = false;
    return;
  }
  begin_pass_now(start);
}
 
template <typename Node>
void looper_node<Node>::begin_pass_now(int64_t start)
{
  m_version++;
  const int replaced = make_room();
  self().begin_overdub(
      start, self().inputs.at_max_layers.value == Looper::AtMaxLayers::MergeOldest,
      replaced);
}
 
template <typename Node>
void looper_node<Node>::close_pass(bool cycle)
{
  // Nothing came in: there is no pass to close.
  if(std::exchange(m_pass_pending, false))
  {
    if(!cycle)
      m_extended = false;
    return;
  }
  auto* top = stack().top();
  if(!top)
    return;
  // A loop grown by the cycle that ended can still be cut back by a late
  // stop.
  if(!cycle)
    m_extended = false;
  m_version++;
  m_export_pending = true;
  if(!self().pass_closing())
    return;
  top->loop_after = stack().length;
  self().pass_closed();
  merge_extra_pass();
}
 
template <typename Node>
void looper_node<Node>::merge_extra_pass()
{
  if(self().inputs.at_max_layers.value == Looper::AtMaxLayers::MergeIntoNewest
     && stack().count > self().max_layers() && self().can_merge_newest())
  {
    passes_changing();
    self().merge_newest();
  }
}
 
template <typename Node>
void looper_node<Node>::looper_close_take(
    const ossia::token_request& tk, LoopMode mode, bool ended_by_postaction)
{
  auto& st = stack();
  if(st.count == 0)
    return;
 
  if(mode == LoopMode::Record)
  {
    m_loop_tempo = transport.loop_tempo(tk, st.length);
    const double bar_frames = m_rate * 4. * (double(tk.signature.upper) / tk.signature.lower)
                              * (60. / tk.tempo);
    const auto bars = int64_t(std::floor(transport.postaction_bars * bar_frames));
 
    // The bar count says when the post-action takes over, so it is the length
    // of a recording the post-action ended: what was recorded past the bars,
    // e.g. the tempo having dropped while it went on, is cut off as a late
    // stop cuts it, for the overdub that follows. A recording stopped by hand
    // is as long as it was played for.
    const bool to_bars = ended_by_postaction && transport.quantized()
                         && transport.postaction_bars > 0 && bars > 0;
    if(to_bars && bars < st.length)
      self().looper_trim_recording(st.length - bars);
    self().close_recording(to_bars ? bars : 0);
    m_export_date = transport.recordStartDate.impl / double(ossia::flicks_per_second<int64_t>);
 
    // Position 0 of the loop on the timeline: the loop plays on from
    // playbackPos at the point the take closes.
    const auto at = double(transport.playbackPos % std::max<int64_t>(1, st.length));
    m_origin = transport.timeline(tk);
    m_origin.frames -= at;
    m_origin.quarters -= at / m_rate * m_loop_tempo / 60.;
  }
  else
  {
    // An overdub that got nothing leaves no take.
    if(m_pass_pending)
    {
      self().close_overdub();
      m_extended = false;
      return;
    }
    self().close_overdub();
  }
  m_version++;
  m_extended = false;
  m_export_pending = true;
}
 
template <typename Node>
int64_t looper_node<Node>::looper_trim_extension(int64_t max_frames)
{
  auto& st = stack();
  if(!m_extended || m_extend_unit <= 0 || st.count == 0)
    return -1;
  const int64_t end = st.length - m_extend_unit;
  const int64_t into_last = transport.playbackPos - end;
  if(into_last < 0 || into_last > max_frames || end < m_extend_unit)
    return -1;
  if(m_pass_pending)
  {
    // The pass after the cut got nothing: it was never a layer.
    m_pass_pending = false;
    self().cut_pass_dropped();
    st.length = end;
    if(auto* t = st.top())
      t->loop_after = end;
  }
  else if(st.count > 1 && self().cut_after(end))
  {
    // A pass per cycle cut the overdub on the old end: the pass after the cut
    // has nothing left, and goes as undo takes a pass out. The one before it
    // ends on the old end, closed already.
    self().pass_dropped();
    undo_pass();
    st.drop_redo();
    self().cut_pass_dropped();
    st.length = end;
    if(auto* t = st.top())
      t->loop_after = end;
  }
  else
  {
    self().trim_top_pass(end);
    st.length = end;
  }
  m_version++;
  m_extended = false;
  self().head_moved(into_last);
  return into_last;
}
 
template <typename Node>
int64_t looper_node<Node>::looper_frames_to_end() const noexcept
{
  const LoopMode m = transport.actualMode;
  const auto& st = stack();
  if(st.empty() || self().busy() || (m != LoopMode::Play && m != LoopMode::Overdub))
    return -1;
  if(m == LoopMode::Overdub && self().inputs.past_end.value == Looper::PastEnd::Extend
     && !m_reverse)
    return -1;
  return Looper::frames_to_loop_end(self().head_y(st.length), st.length, self().rate_for(m));
}
 
template <typename Node>
Looper::loop_period
looper_node<Node>::looper_period(const ossia::token_request& tk) const noexcept
{
  const LoopMode m = transport.actualMode;
  const auto& st = stack();
  if(st.empty() || self().busy() || st.length <= 0 || m == LoopMode::Record)
    return {};
  const double rate = self().rate_for(m);
  const int64_t round = Looper::loop_round(st.length, rate);
  if(m == LoopMode::Stop)
    return {
        round, int64_t(std::floor(rounds_since_made(tk) * double(round) + 1e-6)), false};
  const int64_t to_end = Looper::frames_to_loop_end(self().head_y(st.length), st.length, rate);
  return {round, std::clamp<int64_t>(round - to_end, 0, round), true};
}
 
template <typename Node>
void looper_node<Node>::looper_rephase(const ossia::token_request& tk)
{
  const auto& st = stack();
  if(st.empty())
    return;
  const double rounds = rounds_since_made(tk);
  // A whole position: what is left of a frame is rounding.
  self().set_head(
      std::floor((rounds - std::floor(rounds)) * double(st.length) + 1e-6), st.length);
}
 
template <typename Node>
void looper_node<Node>::capture(const tick& tk)
{
  if(transport.is_taking() || self().busy())
    return;
  auto& in = self().inputs;
  const double bar = m_rate * 4. * (double(tk.signature.upper) / tk.signature.lower)
                     * (60. / std::max(1., tk.tempo));
  const int64_t now = self().capture_clock();
  int64_t end = now;
  if(transport.quantized() && transport.lastPointFrame)
  {
    const int64_t late = transport.frame - *transport.lastPointFrame;
    if(late >= 0 && late <= int64_t(in.late.value * m_rate / 1000.))
      end -= late;
  }
  if(!stack().empty())
  {
    capture_layer(tk, now, end);
    return;
  }
  const int64_t n = std::min<int64_t>(
      {int64_t(in.capture_bars.value * bar), end, self().capture_limit()});
  if(n <= 0)
    return;
 
  passes_changing();
  m_switches.soloed.forget();
  self().capture_into(end, n);
 
  transport.play_captured((now - end) % n);
  m_loop_tempo = tk.tempo;
  m_origin = Looper::timeline_start(tk, self().ossia_state);
  m_origin.frames -= double(transport.playbackPos);
  m_origin.quarters -= double(transport.playbackPos) / m_rate * tk.tempo / 60.;
  const double model_per_frame = self().ossia_state.samplesToModel();
  m_export_date = (tk.prev_date.impl - (now - end + n) * model_per_frame)
                  / double(ossia::flicks_per_second<int64_t>);
  m_export_pending = true;
  self().captured();
}
 
template <typename Node>
void looper_node<Node>::capture_layer(const tick& tk, int64_t now, int64_t end)
{
  auto& st = stack();
  const int64_t len = st.length;
  const LoopMode m = transport.actualMode;
  const bool stopped = m != LoopMode::Play;
  const double rate = self().rate_for(m);
  if(len <= 0 || !(rate > 0.))
    return;
  double y_now{};
  if(stopped)
  {
    const double rounds = rounds_since_made(tk);
    y_now = std::floor((rounds - std::floor(rounds)) * double(len) + 1e-6);
  }
  else
    y_now = self().head_y(len);
 
  const auto round = int64_t(std::ceil(double(len) / rate - 1e-9));
  double y_end = std::fmod(y_now - double(now - end) * rate, double(len));
  if(y_end < 0.)
    y_end += double(len);
  Looper::capture_window w{
      .end = end,
      .n = std::min<int64_t>({round, end, self().capture_limit()}),
      .length = len,
      .y_end = y_end,
      .rate = rate,
      .backwards = m_reverse};
  if(w.n <= 0 || w.positions() <= 0 || !self().capture_layer_ready(w))
    return;
 
  passes_changing();
  const auto pushes = st.pushes;
  begin_pass_now(w.start());
  if(st.pushes == pushes)
    return;
  self().capture_layer_into(w);
  close_pass();
 
  if(stopped)
  {
    self().set_head(y_now, len);
    transport.play_captured(transport.playbackPos);
    self().captured();
  }
}
 
template <typename Node>
void looper_node<Node>::stop_score()
{
  auto& st = stack();
  // A pass that got nothing is no take.
  const bool taking = pass_open();
  m_pass_pending = false;
  const bool recording = taking && transport.actualMode == LoopMode::Record;
  const double date
      = recording ? transport.recordStartDate.impl / double(ossia::flicks_per_second<int64_t>)
                  : m_export_date;
  const int64_t pos = st.length > 0 ? transport.playbackPos % st.length : 0;
  self().stopping();
  if(taking)
    self().close_on_stop(recording);
  const bool take = !st.empty() && (taking || !last_take_whole());
  transport.reset();
  m_switches.reset();
  transport.stopped(st.empty());
  Looper::show_loop(self().inputs.mode, transport, m_loop);
  m_stops++;
  if(take)
  {
    m_stop_stretch = self().take_stretch();
    self().write_stop_take(recording, date, pos);
  }
  m_view_countdown = 0;
}
 
template <typename Node>
void looper_node<Node>::prepare_stop_notice(Looper::stop_take_notice& n, double date)
{
  n.view = m_view;
  self().fill_message(n.view);
  n.view.stopped = true;
  n.take = m_takes_written + 1;
  n.date = date;
  n.stretch = m_stop_stretch;
  n.extension = Node::take_extension;
}
 
template <typename Node>
void looper_node<Node>::run_export()
{
  auto& st = stack();
  const bool asked = m_take_request > m_view.answered;
  if(asked && st.empty())
  {
    // Nothing to take: the last take is what there is.
    m_view.answered = m_take_request;
    m_view_countdown = 0;
  }
  // Passes asked for alone, of the loop the view showed: one that changed
  // since has nothing to give.
  auto& part = m_part_request;
  const bool part_asked = part.take > m_view.part_answered;
  if(part_asked
     && (st.empty() || part.layers != st.count || part.pass < 0 || part.last < part.pass
         || part.last >= st.count))
  {
    m_view.part_answered = part.take;
    part.take = 0;
    m_view_countdown = 0;
  }
  else if(
      part_asked && !m_writing && self().writer && self().export_ready())
  {
    // The files of the passes as they are now, the one taken in as far as it
    // went, under a take number of their own.
    m_job_part = true;
    m_job_request = part.take;
    part.take = 0;
    const bool open = pass_open();
    const bool recording = open && transport.actualMode == LoopMode::Record;
    m_job_stretch = self().take_stretch();
    m_export_tempo = recording ? m_tempo : m_loop_tempo;
    m_export_signature = m_signature;
    m_export_mix = false;
    m_export_first = part.pass;
    m_export_layers = part.last + 1;
    m_export_number = 0;
    m_export_slot = claim_take_slot();
    self().start_export(st.count, open, recording);
  }
  else if(
      (m_export_pending || asked) && !m_writing && self().writer && !st.empty()
      && self().export_ready())
  {
    m_export_pending = false;
    m_job_part = false;
    m_job_request = m_take_request;
    m_job_version = m_version;
    const bool open = asked && pass_open();
    const bool recording = open && transport.actualMode == LoopMode::Record;
    if(recording)
      m_export_date = transport.recordStartDate.impl / double(ossia::flicks_per_second<int64_t>);
    m_job_date = m_export_date;
    m_job_stretch = self().take_stretch();
    m_export_tempo = recording ? m_tempo : m_loop_tempo;
    m_export_signature = m_signature;
    const int passes
        = open || !pass_open() ? st.count : std::max(1, st.count - 1);
    // A take the view asks for has every file, which Export only chooses
    // from; one a pass closing makes has the ones Export says.
    const auto files = self().inputs.exported.value;
    m_export_mix = asked || files != Looper::TakeFiles::Layers;
    m_export_layers = asked || files != Looper::TakeFiles::Mix ? passes : 0;
    m_export_first = m_export_mix ? -1 : 0;
    m_export_number = 0;
    m_export_slot = claim_take_slot();
    self().start_export(passes, open, recording);
  }
  self().continue_export();
}
 
template <typename Node>
void looper_node<Node>::take_written(int slot, int number, bool ok, bool alone)
{
  auto& writer = self().writer;
  if(alone)
  {
    self().stop_take_written();
    if(!ok || !writer)
      return;
    // The views were told of it from the worker: a looper that plays on
    // after its stop shows it in its own messages as well.
    const auto& v = self().stop_notice().view;
    m_takes_written++;
    m_view.set_take(
        v.take_base.data(), v.take_ext.data(), v.take_mix, v.take_layers, v.take_stretch,
        v.take_placeable);
    m_view.take = m_takes_written;
    m_view.take_version = v.take_version;
    m_view.take_date = v.take_date;
    m_view_countdown = 0;
    return;
  }
  m_writing = false;
  if(self().take_cancelled() || !ok || !writer)
  {
    // What was being written changed, or the file could not be: the take
    // stops there.
    self().take_released();
    auto& answered = m_job_part ? m_view.part_answered : m_view.answered;
    answered = std::max(answered, m_job_request);
    m_view_countdown = 0;
    return;
  }
 
  m_export_number = number;
  if(m_export_item + 1 < m_export_layers)
  {
    self().export_item(m_export_item + 1);
    return;
  }
 
  self().take_released();
  if(m_job_part)
  {
    m_view.set_part(
        writer->take_base(slot), m_export_first, m_export_layers - 1, m_job_request,
        m_job_stretch, placeable_take());
    m_view.part_answered = std::max(m_view.part_answered, m_job_request);
    m_view_countdown = 0;
    return;
  }
  m_takes_written++;
  m_view.take_version = m_job_version;
  m_view.set_take(
      writer->take_base(slot), Node::take_extension, m_export_mix, m_export_layers,
      m_job_stretch, placeable_take());
  m_view.take = m_takes_written;
  m_view.take_date = m_job_date;
  m_view.answered = std::max(m_view.answered, m_job_request);
  // Force a view update with the new take.
  m_view_countdown = 0;
}
 
template <typename Node>
void looper_node<Node>::fill_view(Looper::view_message& v) const noexcept
{
  const auto& st = stack();
  v.empty = st.empty();
  v.mode = int(transport.actualMode);
  v.requested = int(transport.quantizedPlayMode);
  v.wanted = int(m_mode);
  v.layers = st.count;
  v.redo = st.total - st.count;
  v.full = self().view_full();
  v.length_seconds = float(st.length / m_rate);
  v.position
      = st.length > 0 ? float(transport.playbackPos % st.length) / float(st.length) : 0.f;
  v.tempo = float(m_tempo);
  v.writing = self().view_writing();
  v.version = m_version;
  v.reverse = m_reverse;
  v.speed = float(m_speed);
  v.selected = self().inputs.layer.value - 1;
  v.stopped = false;
  v.looper = m_id;
  v.stops = m_stops;
  v.restart_pending = transport.restart_pending();
  v.new_pass_pending = transport.new_pass_pending();
  const int lanes = std::min(st.count, Looper::view_message::max_lanes);
  const int merged = st.count - lanes;
  v.muted.fill(0);
  for(int l = merged > 0 ? 1 : 0; l < lanes; l++)
    v.muted[l] = st.layers[l + merged].muted;
}
}