Nodes::MidiLooper::Node Struct Reference

Inheritance diagram for Nodes::MidiLooper::Node:

Classes
struct	ins
struct	ui
struct	worker_t

Public Types
using	LoopMode = Looper::LoopMode
using	Passthrough = Looper::Passthrough
using	OverdubMode = Looper::OverdubMode
using	HeldNotes = Looper::HeldNotes
Public Types inherited from Nodes::Looper::looper_node< Node >
using	LoopMode = Looper::LoopMode
using	tick = ossia::token_request

Public Member Functions
	halp_meta (name, "Looper (MIDI)") halp_meta(c_name
midi_looper	halp_meta (category, "Midi/Sequencers") halp_meta(author
midi_looper ossia score	halp_meta (manual_url, "https://ossia.io/score-docs/processes/midi-looper.html") halp_meta(description
midi_looper ossia score Loop notes and controllers in and turn the loop into a MIDI clip of the timeline	halp_meta (uuid, "0c0b7d3e-5a52-4b8f-9d1f-6e3a2b8c4f71")
	halp_meta (recommended_height, 200)
	halp_flag (process_exec)
void	process_message (const Looper::erase_request &r)
	From the view: applied at the start of the next tick.
void	prepare (halp::setup s)
void	stop ()
	~Node ()
int64_t	looper_run (int64_t start, int64_t length)
void	looper_trim_recording (int64_t frames)
void	operator() (const tick &tk)
Public Member Functions inherited from Nodes::Looper::looper_node< Node >
void	loop_arrived () noexcept
	A value came in on Mode.
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
	An extending overdub grows the loop at its end instead of reaching it.
Looper::loop_period	looper_period (const ossia::token_request &tk) const noexcept
void	looper_point ()
int	looper_passes () const noexcept
int	looper_pass_of (uint32_t id) const noexcept
bool	looper_muted (int pass) const noexcept
void	looper_set_muted (int pass, bool muted)
void	looper_mute (int pass, int muted=-1)
void	looper_erase (int pass)
void	looper_begin_actions () noexcept
void	looper_end_actions () noexcept

Static Public Member Functions
static constexpr std::array< int, 1 >	removed_inlets () noexcept

Public Attributes
midi_looper ossia score Loop notes and controllers in	passes
struct Nodes::MidiLooper::Node::ins	inputs
struct {
halp::midi_out_bus<"out", libremidi::message >   midi
phase
}	outputs
struct Nodes::MidiLooper::Node::worker_t	worker
std::function< void(Looper::view_message)>	send_message
std::function< void(Looper::view_message)>	send_message_from_worker
const score::DocumentContext *	ossia_document_context {}
ossia::exec_state_facade	ossia_state
Looper::midi_loop	loop
std::shared_ptr< Looper::take_writer >	writer
std::shared_ptr< Looper::midi_export >	export_data
std::shared_ptr< Looper::midi_stop_take >	stop_take
Public Attributes inherited from Nodes::Looper::looper_node< Node >
Looper::transport	transport

Static Public Attributes
static constexpr double	max_loop_seconds = 3600.
	Longest loop an extending overdub makes, as the audio looper's longest.

Friends
struct	Looper::looper_node< Node >

Additional Inherited Members
Protected Member Functions inherited from Nodes::Looper::looper_node< Node >
bool	pass_pending () const noexcept
bool	pass_open () const noexcept
	A pass is open in the stack.
bool	may_redo () const noexcept
Looper::undo_mark	undo_mark () const noexcept
	Where the passes and the actions undo goes back through are.
void	material_arriving ()
void	pass_advanced (double frames, bool backwards)
	The pass being taken in went over frames more frames of the loop.
double	pass_progress () const noexcept
	The frames the pass being taken in went over.
void	passes_changing ()
	The passes, or what is heard of them, are about to change.
Node &	self () noexcept
const Node &	self () const noexcept
auto &	stack () noexcept
const auto &	stack () const noexcept
void	view_request (const Looper::erase_request &r) noexcept
	From the view: applied at the start of the next tick.
void	run_tick (const tick &tk)
void	apply_buttons ()
void	follow_merges ()
void	clear_loop ()
void	drop_taken_pass ()
void	undo_pass ()
void	drop_top_pass ()
	The newest pass goes, as undo hides it, and redo does not bring it back.
void	erase_pass (int pass)
void	mute_pass (int pass, int muted=-1)
	Mutes a pass, or lets it be heard: muted says which, or it toggles.
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
void	run_export ()
void	take_written (int slot, int number, bool ok, bool alone)
bool	last_take_whole () const noexcept
	The last take has the mix and every pass as they are now.
void	prepare_stop_notice (Looper::stop_take_notice &n, double date)
int	claim_take_slot () noexcept
bool	view_due (int64_t frames) noexcept
	Whether the view is due a message: some 30 a second.
void	fill_view (Looper::view_message &v) const noexcept
bool	placeable_take () const noexcept
Static Protected Member Functions inherited from Nodes::Looper::looper_node< Node >
static constexpr bool	lazy_passes () noexcept
static uint64_t	next_looper_id () noexcept
Protected Attributes inherited from Nodes::Looper::looper_node< Node >
double	m_rate {48000.}
double	m_tempo {120.}
ossia::time_signature	m_signature {4, 4}
LoopMode	m_mode {LoopMode::Stop}
	The mode asked for, as the transport takes it up.
Looper::loop_input	m_loop
	What came in on Mode, and what it shows.
Looper::switches	m_switches
double	m_speed {1.}
	The playhead goes at m_speed, backwards when m_reverse is set.
bool	m_reverse {}
Looper::transport::timeline_point	m_origin {}
double	m_loop_tempo {120.}
	Tempo the loop was recorded at: the loop keeps its own speed.
int64_t	m_extend_unit {}
bool	m_extended {}
bool	m_cycle_pending {}
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()}
	Tells this looper's messages from another's, and counts its stops.
int	m_stops {}
Looper::view_message	m_view {}
std::array< Looper::erase_request, 16 >	m_erase_requests {}
	The m and x the view sent since the last tick.
int	m_erase_count {}

Constructor & Destructor Documentation

~Node()

Nodes::MidiLooper::Node::~Node ( )

inline

The score stopping takes the looper away before that tick: it stops as it goes, and leaves its take.

Member Function Documentation

removed_inlets()

static constexpr std::array< int, 1 > Nodes::MidiLooper::Node::removed_inlets ( )

inlinestaticconstexprnoexcept

Inlets that presets which do not name their controls count in their indices, and that the looper does not have: Sync.

stop()

void Nodes::MidiLooper::Node::stop ( )

inline

The notes the loop plays end on the next tick, which a box ending still runs.

Member Data Documentation

send_message_from_worker

std::function<void(Looper::view_message)> Nodes::MidiLooper::Node::send_message_from_worker

What the take the score's stop leaves is told to the views with, from its worker.

stop_take

std::shared_ptr<Looper::midi_stop_take> Nodes::MidiLooper::Node::stop_take

What the take the score's stop leaves is made of: the node may be gone before it is written.

---

The documentation for this struct was generated from the following file:

• MidiLooper.hpp