time_interval.hpp

Go to the documentation of this file.

#pragma once
#include <ossia/detail/config.hpp>
 
#include <ossia/dataflow/transport.hpp>
#include <ossia/detail/flat_map.hpp>
#include <ossia/detail/flicks.hpp>
#include <ossia/detail/optional.hpp>
#include <ossia/detail/ptr_container.hpp>
#if defined(OSSIA_SCENARIO_DATAFLOW)
#include <ossia/editor/curve/curve.hpp>
#endif
#include <ossia/editor/scenario/execution_log.hpp>
#include <ossia/editor/scenario/time_signature.hpp>
#include <ossia/editor/scenario/time_value.hpp>
 
#include <smallfun.hpp>
 
#include <memory>
 
namespace ossia
{
struct token_request;
class time_event;
class time_process;
class graph_node;
 
using time_signature_map = ossia::flat_map<ossia::time_value, time_signature>;
 
#if defined(OSSIA_SCENARIO_DATAFLOW)
using tempo_curve = ossia::curve<int64_t, double>;
#endif
 
class OSSIA_EXPORT time_interval
{
public:
#if defined(OSSIA_SCENARIO_DATAFLOW)
  const std::shared_ptr<ossia::graph_node> node;
#endif
 
  auto get_date() const noexcept { return m_date; }
  auto get_offset() const noexcept { return m_offset; }
  double get_internal_speed() const noexcept { return m_speed; }
 
  double get_speed(time_value date) const noexcept;
 
  double local_time_factor(const ossia::token_request& parent_request) const noexcept;
 
  int64_t
  advance_for(ossia::time_value, const ossia::token_request& parent_request) const noexcept;
 
  int64_t take_backward_step(
      ossia::time_value, const ossia::token_request& parent_request) noexcept;
 
  void set_offset(ossia::time_value g) noexcept { m_offset = g; }
 
  void set_speed(double g) noexcept { m_speed = g; }
 
  void set_parent_speed(double sp) noexcept { m_parentSpeed = sp; }
  tick_transport_info current_transport_info() const noexcept;
 
  void
  tick_current(ossia::time_value offset, const ossia::token_request& parent_request);
 
  void tick(
      ossia::time_value, const ossia::token_request& parent_request, double ratio = 1.0);
 
  void tick_offset(
      ossia::time_value, ossia::time_value offset,
      const ossia::token_request& parent_request, int32_t start_sample = -1,
      int32_t length_sample = -1);
  void tick_offset_speed_precomputed(
      ossia::time_value, ossia::time_value offset,
      const ossia::token_request& parent_request, int32_t start_sample = -1,
      int32_t length_sample = -1);
 
  using exec_callback
      = std::optional<smallfun::function<void(bool, ossia::time_value), 32>>;
 
  static std::shared_ptr<time_interval> create(
      time_interval::exec_callback, time_event&, time_event&, time_value = Infinite,
      ossia::time_value = Zero, ossia::time_value = Infinite);
 
  time_interval(
      time_interval::exec_callback, time_event&, time_event&, time_value = Infinite,
      ossia::time_value = Zero, ossia::time_value = Infinite);
 
  ~time_interval();
 
  void start();
  void start_and_tick();
 
  void stop();
 
  void pause();
 
  void resume();
 
  void offset(ossia::time_value);
 
  void transport(ossia::time_value);
 
  void set_callback(exec_callback);
  void set_callback(smallfun::function<void(bool, ossia::time_value), 32>);
 
  const time_value& get_nominal_duration() const;
 
  time_interval& set_nominal_duration(ossia::time_value);
 
  const time_value& get_min_duration() const;
 
  time_interval& set_min_duration(ossia::time_value);
 
  const time_value& get_max_duration() const;
 
  time_interval& set_max_duration(ossia::time_value);
 
  time_event& get_start_event() const;
 
  time_event& get_end_event() const;
 
  void add_time_process(std::shared_ptr<time_process>);
 
  void remove_time_process(time_process*);
 
  void reserve_processes(std::size_t sz);
 
  const std::vector<std::shared_ptr<time_process>>& get_time_processes() const
  {
    return m_processes;
  }
 
  bool running() const noexcept { return m_running; }
  void cleanup();
  void mute(bool);
 
#if defined(OSSIA_SCENARIO_DATAFLOW)
  void set_tempo_curve(std::optional<tempo_curve> curve);
#endif
  void set_time_signature_map(std::optional<time_signature_map> map);
  void set_quarter_duration(double tu);
 
#if defined(OSSIA_EXECUTION_LOG)
  std::string name;
#endif
 
  bool graphal{};
 
private:
  time_interval(const time_interval&) = delete;
  time_interval(time_interval&&) = delete;
  time_interval& operator=(const time_interval&) = delete;
  time_interval& operator=(time_interval&&) = delete;
 
  void state(ossia::time_value from, ossia::time_value to);
 
  time_signature
  signature(time_value date, const ossia::token_request& parent_request) const noexcept;
  double
  tempo(time_value date, const ossia::token_request& parent_request) const noexcept;
  double tempo(time_value date) const noexcept;
 
  void tick_impl(
      ossia::time_value old_date, ossia::time_value new_date, ossia::time_value offset,
      const ossia::token_request& parent_request);
 
  ossia::time_value
  to_local_offset(ossia::time_value offset, double factor) const noexcept;
 
  int64_t take_step(double exact) noexcept;
 
  std::vector<std::shared_ptr<time_process>> m_processes;
  time_interval::exec_callback m_callback;
 
  time_event& m_start;
  time_event& m_end;
 
  time_value m_nominal{};
  time_value m_min{};
  time_value m_max{};
 
  time_value m_date{};
  time_value m_offset{}; 
 
  time_value m_tick_offset{}; 
 
  int32_t m_tick_start_sample{-1};
  int32_t m_tick_length_sample{-1};
 
  double m_current_tempo{};
 
  time_signature_map m_timeSignature{};
#if defined(OSSIA_SCENARIO_DATAFLOW)
  tempo_curve m_tempoCurve{};
#endif
 
  ossia::quarter_note m_musical_start_last_signature{};
 
  ossia::quarter_note m_musical_start_last_bar{};
  ossia::quarter_note m_musical_start_position{};
 
  ossia::quarter_note m_musical_end_last_bar{};
  ossia::quarter_note m_musical_end_position{};
 
  double m_speed{1.}; 
  double m_date_residue{}; 
  double m_globalSpeed{1.};
  double m_parentSpeed{1.};
  time_signature m_current_signature{};
  double m_quarter_duration{ossia::quarter_duration<double>};
  bool m_running{false};
  bool m_hasTempo{false};
  bool m_hasSignature{false};
};
}