Public Types | |
| using | LoopMode = Looper::LoopMode |
| using | tick = ossia::token_request |
Public Member Functions | |
| 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 |
| bool | looper_muted (int pass) const noexcept |
| void | looper_set_muted (int pass, bool muted) |
| void | looper_mute (int pass) |
| void | looper_erase (int pass) |
Public Attributes | |
| Looper::transport | transport |
Protected Member Functions | |
| bool | pass_pending () const noexcept |
| bool | pass_open () const noexcept |
| A pass is open in the stack. | |
| 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 | erase_pass (int pass) |
| void | mute_pass (int pass) |
| A muted pass is kept as it is; muting it again lets it be heard. | |
| 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 | |
| static constexpr bool | lazy_passes () noexcept |
| static uint64_t | next_looper_id () noexcept |
Protected Attributes | |
| 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 {} |
| Looper::erase_request | m_erase_request {} |
| bool | m_erase_requested {} |
Member Function Documentation
◆ begin_pass()
|
protected |
Starts an overdub pass at start, room made for it as At max layers says: a layer it replaces is kept for undo until the next pass starts.
◆ capture()
|
protected |
What was heard lately, ending on the last grid point when it was just passed, as a late stop would: the last bars of it become the loop, or, over a loop, its last round becomes a layer.
◆ capture_layer()
|
protected |
The last round of the loop up to end, played over it, becomes a layer on top, as an overdub pass of that round would have: where it was played in the loop, room made for it as for any pass, undone and redone as one, written in a take when it closes. The loop keeps its length. A stopped loop goes round where it would be had it kept going, as In phase has it, and plays from there.
◆ clear_loop()
|
protected |
A recording going on starts again on the next frame, its bars and tempo counted from there.
◆ close_pass()
|
protected |
The overdub pass is over, at the end of the take or of a cycle: it is written in a take, and with Merge into newest, past Max layers, merged into the newest layer.
◆ drop_taken_pass()
|
protected |
The pass being taken in is dropped; taking in starts a new one. A recording starts again on the next frame, its bars and tempo counted from there.
◆ erase_pass()
|
protected |
Erasing the pass being taken in is undoing it, and erasing the only pass heard is clearing the loop.
◆ fill_view()
|
protectednoexcept |
What the view shows of the transport and of the passes, the oldest of which share the first lane when there are more of them than lanes.
◆ looper_period()
|
noexcept |
The loop as Quantize's Loop: the frames a round of it takes at the rate it goes, and where the playhead is in it, the way it goes. An extending overdub's round is the loop as long as it is now. A stopped loop is where it would be had it kept going since it was made, as In phase has it.
◆ looper_rephase()
| void Nodes::Looper::looper_node< Node >::looper_rephase | ( | const ossia::token_request & | tk | ) |
The loop is heard again: the playhead goes where it would be had the loop kept playing at its speed since it was made.
◆ looper_trim_extension()
| int64_t Nodes::Looper::looper_node< Node >::looper_trim_extension | ( | int64_t | max_frames | ) |
An extending pass asked to stop just after the loop grew ends on the old end, as a late stop would.
◆ make_room()
|
protected |
There are Max layers, and a pass starts: with Replace a muted layer, the oldest muted layer goes for it, else the newest. The layer that goes, or -1 for none.
◆ material_arriving()
|
inlineprotected |
Something comes in for the pass being taken in: a pass still waiting for it becomes a layer, from where the overdub began.
◆ pass_pending()
|
inlineprotectednoexcept |
An overdub pass is open that nothing came in for yet: it is not in the stack.
◆ placeable_take()
|
inlineprotectednoexcept |
Whether the host can place the take just written in the timeline: a looper says so with take_placeable(), else it can.
◆ prepare_stop_notice()
|
protected |
What the views are told once the take the score's stop leaves is written: what the looper shows now, its last take until then.
◆ rounds_since_made()
|
inlineprotectednoexcept |
Where the loop would be had it kept going since it was made: the rounds it would have gone, at its speed. Keeping to the bars, they come from the timeline's quarters, which a tempo change does not move; else from its date.
◆ run_export()
|
protected |
A take starts once the last one is written, when a pass closed or the view asked for one. Asked for while a pass is taken in, the take has every pass, that one as far as it went, and a recording is placed where it started, at the tempo it is played at. Else it is the passes that closed: one started since is not in it.
◆ stop_score()
|
protected |
The score stops: what was being taken in is a pass like any other, and Mode goes from Record or Overdub to Play. The loop is kept: only the transport starts over. The looper is most often gone with the score's stop, and its views with nothing to ask of it: the take it leaves has the mix and every pass as they are, unless the last take has them already.
◆ undo_pass()
|
protected |
Undoes the top pass: a layer it replaced comes back to its place, the one Layer says keeping its own.
Member Data Documentation
◆ m_cycle_pending
|
protected |
The overdub went round with a pass per cycle: going on starts a new pass. An overdub that stops there leaves none.
◆ m_extend_unit
|
protected |
An extending pass grows the loop by the loop it started over; it grew last on its last cycle.
◆ m_job_date
|
protected |
The date of the take being written: one closing meanwhile does not change it.
◆ m_job_stretch
|
protected |
How the take being written, and the one written on the score's stop, ask the timeline to follow the tempo.
◆ m_origin
|
protected |
Where position 0 of the loop was on the timeline: its date in frames and its musical position.
◆ m_part_request
|
protected |
The files of some passes alone the view asked for, the take being written being those, and the first file of the take.
◆ m_pass_pending
|
protected |
The overdub pass waiting for something to come in: where it began, the frames it went over and which way.
◆ m_take_request
|
protected |
The last take the view asked for, and the one the take being written answers.
◆ m_version
|
protected |
Counts the changes of the passes, and what it was when the take being written started.
The documentation for this struct was generated from the following file: