Detailed Description

What a looper shows of itself, sent about thirty times a second. Trivial, so that it is copied as it is to the UI.

Public Types
enum	value_flag : uint8_t { flag_number = 1 , flag_other = 2 , flag_heard = 4 , flag_impulse = 8 , flag_mark = 16 , flag_heard_mark = 32 }

Public Member Functions
void	set_take (std::string_view base, std::string_view ext, bool mix, int layers, halp::clip_stretch stretch=halp::clip_stretch::automatic, bool placeable=true) noexcept

void	set_part (std::string_view base, int first, int last, int request, halp::clip_stretch stretch, bool placeable) noexcept

std::vector< std::string >	layer_files (const char *base_chars, int first, int last) const
	UI thread: the files of passes `first` to `last` of a take of `base`.

std::vector< std::string >	take_files () const
	UI thread: the paths of the last take's files, the mix first.

std::vector< std::string >	part_files () const
	UI thread: the files of the part last written.

Public Attributes
int	mode

int	requested

int	wanted

int	layers

int	redo

int	lanes

int	take
	Takes written so far; the files of the last one are take_files().

int	notes

bool	empty

bool	full

bool	writing

bool	midi

bool	values

float	position

float	length_seconds

float	max_seconds

float	tempo

double	take_date
	Where the last take was recorded, in seconds from the process' start.

std::array< float, max_lanes *bins >	peaks

std::array< view_note, max_notes >	note

std::array< uint8_t, max_lanes *bins >	value_flags

std::array< char, 512 >	take_base

std::array< char, 8 >	take_ext

bool	take_mix

int	take_layers

bool	take_placeable

halp::clip_stretch	take_stretch

bool	reverse
	The loop plays backwards, and at this speed.

float	speed

std::array< uint8_t, max_lanes >	muted
	Lanes of a single pass that is muted.

int	selected
	The pass Layer says, from the oldest one, which the layer actions act on.

bool	restart_pending

bool	new_pass_pending

int	answered

int	version

int	take_version

std::array< char, 512 >	part_base

int	part_answered

int	part_first

int	part_last

int	part_answer

bool	part_placeable

halp::clip_stretch	part_stretch

bool	stopped

uint64_t	looper

int	stops

Static Public Attributes
static constexpr int	max_lanes = 32

static constexpr int	bins = 192

static constexpr int	max_notes = 768

Member Enumeration Documentation

◆ value_flag

enum Nodes::Looper::view_message::value_flag : uint8_t

Enumerator
flag_number	A number is held, at the height in peaks.
flag_other	Something else is held: text, a list, a map.
flag_heard	What is held is what the loop plays there.
flag_impulse	An impulse fires in the bin.
flag_mark	A value that is not a number starts in the bin.
flag_heard_mark	The impulse is heard.

Member Data Documentation

◆ answered

int Nodes::Looper::view_message::answered

The last take the view asked for that is written, or that there was no loop to make: the last take is the one it asked for, or a later one.

◆ mode

int Nodes::Looper::view_message::mode

LoopMode the looper is in, the one it has taken up, and the one asked for, which it may still be waiting for the grid to take up.

◆ part_base

std::array<char, 512> Nodes::Looper::view_message::part_base

The files of some passes alone, written when the view asked for them: <part_base>-layer<k>.<take_ext> for k from part_first + 1 to part_last + 1. part_answer is the request they answer, part_answered the last request answered, with them or with nothing.

◆ restart_pending

bool Nodes::Looper::view_message::restart_pending

Waiting for the grid point besides a mode: back to the loop's start, a new pass.

◆ stopped

bool Nodes::Looper::view_message::stopped

Sent once the looper stopped with the score, from the worker that wrote the take its stop left: what it showed then, that take in it. Messages the looper sent before, stops being lower, may come after it: they are older. looper tells the looper that sent a message.

◆ take_base

std::array<char, 512> Nodes::Looper::view_message::take_base

The last take's files: <base>.<ext> for the mix if there is one, <base>-layer<k>.<ext> for its layers.

◆ take_placeable

bool Nodes::Looper::view_message::take_placeable

The host places the take in the timeline. A value take that is not all numbers is a file only.

◆ take_stretch

halp::clip_stretch Nodes::Looper::view_message::take_stretch

How the take asks the timeline to follow the tempo: as the audio looper played it when it was taken.

◆ values

bool Nodes::Looper::view_message::values

A value loop: peaks holds, for each bin of each lane, the number its passes hold there, from 0 to 1 over the numbers the lane holds, and value_flags what else is there.

◆ version

int Nodes::Looper::view_message::version

Counts the changes of the passes: the last take has the passes as they are when the two are the same, and no pass is taken in.

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

LooperView.hpp