time_process.hpp

Go to the documentation of this file.

#pragma once
 
#include <ossia/detail/config.hpp>
 
#include <ossia/dataflow/token_request.hpp>
#include <ossia/dataflow/transport.hpp>
#include <ossia/editor/scenario/time_value.hpp>
 
#include <memory>
#include <string>
 
namespace ossia
{
class graph_node;
class time_interval;
class OSSIA_EXPORT time_process
{
public:
#if defined(OSSIA_SCENARIO_DATAFLOW)
  std::shared_ptr<ossia::graph_node> node;
#endif
  virtual ~time_process();
 
  void offset(ossia::time_value date);
 
  void transport(ossia::time_value date);
  void transport(
      ossia::time_value date, const ossia::tick_transport_info& transport_info);
 
  virtual void state(const ossia::token_request&) = 0;
 
  virtual void start();
 
  virtual void stop();
 
  virtual void pause();
 
  virtual void resume();
 
  void mute(bool m);
 
  [[nodiscard]] bool unmuted() const;
 
  void enable(bool m);
 
  [[nodiscard]] bool enabled() const;
 
  void set_loops(bool b);
 
  void set_start_offset(time_value v);
 
  void set_loop_duration(time_value v);
 
protected:
  virtual void mute_impl(bool);
  virtual void offset_impl(ossia::time_value date) = 0;
 
  virtual void transport_impl(ossia::time_value date) = 0;
 
  // Tempo-aware overload; sound_process reimplements this.
  virtual void transport_impl(
      ossia::time_value date, const ossia::tick_transport_info& transport_info)
  {
    (void)transport_info;
    transport_impl(date);
  }
 
  time_value m_loop_duration{};
  time_value m_start_offset{};
  bool m_loops = false; // TODO bitfields ?
  bool m_unmuted = true;
  bool m_enabled = true;
};
 
template <typename T>
class looping_process : public time_process
{
public:
  using time_process::time_process;
  void state(const ossia::token_request& tok) override
  {
    if(!this->m_loops)
    {
      if(this->m_start_offset == 0_tv)
        static_cast<T*>(this)->state_impl(tok);
      else
        static_cast<T*>(this)->state_impl(tok.add_offset(this->m_start_offset));
    }
    else
    {
      tok.loop(
          this->m_start_offset, this->m_loop_duration,
          [this](const token_request& tr) { static_cast<T*>(this)->state_impl(tr); },
          [this](const time_value& t) { static_cast<T*>(this)->transport_impl(t); });
    }
  }
};
 
enum class sync_status
{
  NOT_READY,
  RETRY,
  DONE
};
 
}