Inheritance diagram for Nodes::AudioLooper::Node:

Classes
struct	ins

struct	ui

struct	worker_t

Public Types
using	LoopMode = Looper::LoopMode

using	Passthrough = Looper::Passthrough

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 (audio)") halp_meta(c_name

	Looper (audio)") halp_meta(category

Audio Utilities	halp_meta (author, "ossia score") halp_meta(manual_url

Audio Utilities Loop audio in and turn the loop into a clip of the timeline	halp_meta (uuid, "a0ad4227-ac3d-448b-a19b-19581ed4e2c6")

	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	prepare_stretch (double rate, int frames)

void	allocate_ring (int channels, int64_t frames)
	Main thread only.

int64_t	looper_run (int64_t start, int64_t length)

int64_t	run_mode (int64_t start, int64_t length)

void	looper_trim_recording (int64_t frames)

void	operator() (const tick &tk)

void	stop ()
	Stopping the process keeps the loop: only the transport starts over.

const float *	layer_data (int layer, int chan) const noexcept

template<typename T >
void	fetch_audio (int64_t start, int64_t frames, T **out) noexcept
	What the stretchers read: the loop as it is heard, round and round.

template<typename T >
void	fetch_audio_backward (int64_t, int64_t frames, T **out) noexcept

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
Audio Utilities	https: halp_meta( description

Audio Utilities Loop audio in	layers

struct Nodes::AudioLooper::Node::ins	inputs

struct {

halp::mimic_audio_bus<"out", &ins::audio > audio

phase

}	outputs

struct Nodes::AudioLooper::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::audio_layers	layers

std::shared_ptr< Looper::take_writer >	writer

std::shared_ptr< Looper::export_buffer >	export_audio

std::shared_ptr< Looper::audio_stop_take >	stop_take

Public Attributes inherited from Nodes::Looper::looper_node< Node >
Looper::transport	transport

Static Public Attributes
static constexpr int64_t	work_per_tick = 262144

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 {}

Member Function Documentation

◆ prepare_stretch()

void Nodes::AudioLooper::Node::prepare_stretch	(	double	rate,
		int	frames
	)

inline

Main thread only: the stretcher allocates. It is run once here over the longest span it will be given, on silence, so that the buffers it sizes on its first run are sized before the audio thread runs it.

◆ removed_inlets()

static constexpr std::array< int, 1 > Nodes::AudioLooper::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.

Member Data Documentation

◆ send_message_from_worker

std::function<void(Looper::view_message)> Nodes::AudioLooper::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::audio_stop_take> Nodes::AudioLooper::Node::stop_take

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

◆ work_per_tick

constexpr int64_t Nodes::AudioLooper::Node::work_per_tick = 262144

staticconstexpr

Samples the looper's background work – merging passes, flattening a take, drawing the overview – goes through in one tick at most.

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

AudioLooper.hpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Friends