diff --git a/assets/images/reference/processes/audio_looper.png b/assets/images/reference/processes/audio_looper.png index 7404bd27..e36a52d3 100644 Binary files a/assets/images/reference/processes/audio_looper.png and b/assets/images/reference/processes/audio_looper.png differ diff --git a/assets/images/reference/processes/midi_looper.png b/assets/images/reference/processes/midi_looper.png new file mode 100644 index 00000000..6b6fa689 Binary files /dev/null and b/assets/images/reference/processes/midi_looper.png differ diff --git a/assets/images/reference/processes/value_looper.png b/assets/images/reference/processes/value_looper.png new file mode 100644 index 00000000..fef7017e Binary files /dev/null and b/assets/images/reference/processes/value_looper.png differ diff --git a/docs/examples/audio/looper.md b/docs/examples/audio/looper.md index ed9b878b..5fb088c9 100644 --- a/docs/examples/audio/looper.md +++ b/docs/examples/audio/looper.md @@ -21,7 +21,7 @@ The Looper captures the main audio input, not the internally generated drums, so 1. Open the ZIP directly in a score build with Kaboom support. The current score uses synthesized drums and needs no sample kit. Configure a working audio input and output. 2. Use headphones or isolated monitoring to avoid feeding loudspeaker output back into a microphone. Begin at a low listening level. 3. Start playback and supply audio to the input. The initial cue requests `Stop`, the cue at 4 seconds requests `Record`, and the cue at 12 seconds requests `Play`. -4. Listen for the captured phrase repeating against the drums. Quantif is set to 1, so mode changes wait for the next quantized boundary instead of switching freely between beats. +4. Listen for the captured phrase repeating against the drums. Quantize is set to one bar, so mode changes wait for the next bar line instead of switching freely between beats. 5. Trigger the end of `Loop`, drawn at 14.5 seconds, or stop the transport. The end is interactive: its position is not an automatic stop. ## Shape the phrase diff --git a/docs/in-depth/midi.md b/docs/in-depth/midi.md index 42591415..b2972df0 100644 --- a/docs/in-depth/midi.md +++ b/docs/in-depth/midi.md @@ -31,6 +31,8 @@ The most important processes are: Simply drag'n'drop a MIDI file in the score, either on a scenario or on the interval, from the user library or from your file explorer ! +A MIDI file is placed by its beats: a file of two bars lasts two bars of the score whatever tempo it was saved at, and plays at the tempo of the score. + # MIDI processing * See [[MIDI utilities]] for a list of processes that can alter MIDI data: arpeggiator, etc. diff --git a/docs/reference-manual/processes/library/arpeggiator.md b/docs/reference-manual/processes/library/arpeggiator.md index ecf8287b..efa8cd80 100644 --- a/docs/reference-manual/processes/library/arpeggiator.md +++ b/docs/reference-manual/processes/library/arpeggiator.md @@ -11,27 +11,79 @@ permalink: /processes/arpeggiator.html --- # Arpeggiator -The **Arpeggiator** takes held notes at its MIDI **in** port and produces a repeating note pattern at MIDI **out**. Connect a MIDI keyboard or MIDI-generating process to the input and a synthesizer to the output. Release the input notes to remove them from the pattern. +The **Arpeggiator** takes held notes at its MIDI **in** port and produces a repeating note pattern at MIDI **out**. Connect a MIDI keyboard or MIDI-generating process to the input and a synthesizer to the output. Release the input notes to remove them from the pattern, unless a **Latch** keeps them. This page describes version 2, whose **Rate** uses the [time chooser]({{ site.baseurl }}/reference/time-chooser.html). -## Controls +## Pattern | Control | Choices or range | Behavior | |---|---|---| -| **Arpeggios** | Forward, Backward, F->B, B->F, Chord, Random | Ascending, descending, alternating-direction, simultaneous-chord or random selection. Default: Forward. | -| **Octave** | 1–7; default **1** | Adds octave copies; 1 uses the original notes only. Copies outside MIDI pitches 0–127 are omitted. | -| **Octave mode** | Both, Above, Below | Chooses where octave copies are added. Default: Both. | -| **Repeat** | 1–8; default **1** | Repeats each step before proceeding. Chord mode instead plays the expanded chord together. | +| **Arpeggios** | see below; default **Forward** | The order of the steps. | | **Rate** | Free duration 0.01–4 seconds; default **0.125 seconds** | Time between steps, or a synchronized straight, dotted or triplet note value. | +| **Gate** | 0.01–2; default **1** | Length of a note as a proportion of a step. At 1 a note lasts until the next step starts; below, it ends earlier; above, it overlaps the next step. A pitch played again by the next step ends first. | +| **Swing** | 0–1; default **0** | Delays every second step, counted from the bar line: 0.5 puts it on the triplet, 1 at 5/6 of the pair of steps. | +| **Octave** | 1–7; default **1** | Adds octave copies; 1 uses the original notes only. Copies outside MIDI pitches 0–127 are omitted. | +| **Octave mode** | Both, Above, Below; default **Both** | Where the octave copies are added. | + +The patterns, for held notes 1-2-3 from the lowest: + +| Pattern | Steps | +|---|---| +| **Forward** | 1-2-3 | +| **Backward** | 3-2-1 | +| **F->B** | 1-2-3-3-2-1: the top and the bottom twice | +| **B->F** | 3-2-1-1-2-3 | +| **Chord** | every held note at each step | +| **Random** | a step picked at random each time | +| **Up/Down** | 1-2-3-2: the top and the bottom once | +| **Down/Up** | 3-2-1-2 | +| **Converge** | 1-3-2: from the outside in | +| **Diverge** | 2-3-1: from the inside out | +| **Low Up** | 1-2-1-3: the lowest note between each of the others | +| **High Up** | 3-1-3-2: the highest note between each of the others | +| **As played** | the notes in the order their keys were pressed | + +With **Octave** above 1, Forward, Backward, F->B, B->F, Random and As played play the whole pattern, then the whole pattern again in each added octave: above first, then below with **Both**. Up/Down, Down/Up, Converge, Diverge, Low Up and High Up instead run through all the notes of all the octaves as one set, from the lowest; a pitch that is both a held note and an octave copy of another plays once. **Chord** adds the octave copies to the chord. Despite its label, **Rate** is a duration, not hertz. In synchronized mode, steps fall on the musical grid. In free mode, the duration is converted to a grid spacing at the current tempo; this process still schedules its steps through the musical-grid mechanism rather than acting as an independent wall-clock timer. -At each step, the previous output notes end and the next note or chord starts. **Chord** includes the octave expansion and sounds its notes together; **Random** selects from the expanded pattern at each step. +## Steps + +| Control | Choices or range | Behavior | +|---|---|---| +| **Repeat** | 1–8; default **1** | Plays each step this many times before the next. It has no effect on **Chord**, which already plays the whole chord at every step. | +| **Retrigger** | Off, Note, Beat; default **Off** | Starts the pattern again from its first step on each newly pressed key (**Note**) or on each beat (**Beat**). The velocity decay starts over as well. | +| **Seed** | 0–10000; default **0** | For **Random**: at 0 the choices are free; any other value gives the same sequence each time the process starts, and each time the seed is set. | + +## Velocity + +| Control | Choices or range | Behavior | +|---|---|---| +| **Accent every** | 0–16; default **0** | Every Nth step, counting from the first step of the chord, plays at **Accent vel.**; 0 turns accents off. | +| **Accent vel.** | 1–127; default **127** | The velocity of the accented steps. | +| **Vel. decay** | 0–1; default **0** | At each step since the chord started, the velocity moves this proportion of the remaining way towards **Decay target**. 0 keeps the played velocity. | +| **Decay target** | 1–127; default **1** | The velocity the decay tends towards. | +| **Pressure** | Off, Channel, Poly, Both; default **Off** | Lets aftertouch set the velocity of the following steps: channel pressure for every note, poly pressure for its own key. The latest kind of pressure received wins. A new chord, started with no note left playing, goes back to the key velocities. | + +A step's velocity is the key's velocity, or the pressure's, then decayed, then replaced on accented steps. For a note repeat, choose **Chord**, a **Rate** and a **Pressure** mode: the held notes repeat at the rate, at the velocity of the key pressure. + +## Latch + +| Control | Choices or range | Behavior | +|---|---|---| +| **Latch** | Off, Toggle, Momentary; default **Off** | **Toggle**: released notes keep playing until a key is pressed while none is held, which starts a new chord. **Momentary**: released notes keep playing while **Latch hold** is on. | +| **Latch hold** | on / off | With the **Momentary** latch: keeps the released notes playing while on. Turning it off stops the notes no longer held. | + +## MIDI messages + +Notes are played on **channel 1**, whatever channel they came in on; held notes are tracked by pitch, not by channel. + +Everything that is not a note passes through to the output at the time it came in: controllers, program changes, pitch bend and the rest. Pressure messages are the exception while **Pressure** uses them: channel pressure with Channel or Both, poly pressure with Poly or Both are taken by the arpeggiator and not forwarded. -## MIDI limitations +**All Notes Off** and **All Sound Off** (controllers 123 and 120) end every note the arpeggiator plays, forget the held and latched notes, start the pattern again from its first step, and are forwarded. -The current engine tracks held notes by pitch, not by input MIDI channel, and generates notes on **channel 1**. It is not a transparent MIDI router: do not rely on it to forward controllers, program changes or other non-note messages. Route those separately if your instrument needs them. +Stopping the score, or the process, does the same: notes end, held and latched notes are forgotten, and the pattern starts from its first step. ## Older saved processes diff --git a/docs/reference-manual/processes/library/audio_looper.md b/docs/reference-manual/processes/library/audio_looper.md index 893b5eaa..99c0908a 100644 --- a/docs/reference-manual/processes/library/audio_looper.md +++ b/docs/reference-manual/processes/library/audio_looper.md @@ -2,7 +2,7 @@ layout: default title: Audio looper -description: "Recording and playing back audio in a live setting" +description: "Record audio in layers, play it back in time, and turn the loop into a clip of the timeline" parent: Processes grand_parent: Reference @@ -11,27 +11,277 @@ permalink: /processes/audio-looper.html --- # Audio Looper -![Audio looper]({{ site.img }}/reference/processes/audio_looper.png "Audio looper example") +![Audio looper]({{ site.img }}/reference/processes/audio_looper.png "The audio looper playing a two bar loop") -Different options are available when you use the audio looper: the operation mode and the passthrough. +The process named **Looper (audio)** records the audio it receives at **in** into a loop and plays it back at **out**. Each overdub is kept as a layer of its own, so it can be undone, and every take is written to a file that can be placed in the timeline as a regular sound clip. -- If passthrough is enabled, while recording and overdubbing, the input audio will be copied to the output of the looper. -- The looper's state change can be [quantized]({{ site.baseurl }}/in-depth/musical.html#quantization). -- In the inspector, it is possible to make the looper automatically change mode after a fixed amount of bars instead of waiting - on an automated change: the second "loop" parameter will control the state on which the looper moves after N bars in the initial state. +The [MIDI looper]({{ site.baseurl }}/processes/midi-looper.html) works the same way with notes and controllers, and the [value looper]({{ site.baseurl }}/processes/value-looper.html) with any stream of values. -## Play +## Modes -Play what the looper recorded. +**Mode** chooses what the looper does: -## Recording +| Mode | Behavior | +|---|---| +| **Play** | Plays the loop. | +| **Record** | Records an empty loop. On a loop that has something in it, overdubs it, as on a looper pedal: to record a new loop, **Clear** it first. | +| **Overdub** | Records a new layer on top of the loop while it plays. On an empty loop, it is a recording, as Record makes, which then gives way to overdubbing. | +| **Stop** | Outputs no loop. The loop is kept. | -Record the actual sound the looper is going to loop to. +Mode is the state of the looper: it always shows what the looper is doing, or what it is about to do on the next grid point, whatever changed it: an action of the Switches tab, a recording ending after its bars, a full loop, Capture, a file loaded. -## Overdub +Every control is a port with an address, so the looper can be driven by OSC, MIDI or a footswitch mapping as well as by the mouse. A cable or an automation that sends the same mode on every tick asks for it once, when it changes: when the looper changes Mode itself, at the end of a recording for instance, the cable does not ask again and the mode does not flip back. -Record on top of the already recorded sound. +## Record, Overdub and layers -## Stop +| | What it is for | What it does to the loop | How layers are cut | +|---|---|---|---| +| **Record** | Making a loop. | Makes the loop: it is as long as the recording, or **Record bars** bars. On a loop that has something in it, Record overdubs: Clear first to make the loop again. | The recording is the first layer. | +| **Overdub** | Playing over the loop. | Adds what is played on top of the loop, each round fading the layers under it by **Feedback**; with **Past the end** on Extend, makes it longer. | One layer from when it starts to when it stops; with **Passes** on Per cycle, one each time round; **New layer** cuts one where it is pressed. | +| **Play**, **Stop** | Listening, or not. | Nothing. | None. | -Output nothing. \ No newline at end of file +A recording ends in one of three ways, and **After record** says what it gives way to whichever it is: its **Record bars** running out, the loop reaching **Max length**, or **Rec / Play / Dub**. Setting Mode to another mode during a recording ends it into that mode. + +## Timing + +**Quantize** makes a mode change wait for the next point of a grid, so that a loop starts and ends in time. Every action waits for it as well, except Undo, Redo and Clear, which act at once, and selecting a layer. Dragging the knob goes through the values of a unit; clicking its readout chooses the unit: + +| Unit | Values | The grid | +|---|---|---| +| **Free time** | None, or up to 8 seconds | Every that many seconds, counted from the loop's start once there is a loop. **None** changes at once. | +| **Note value** | 1/64 to 4/1, straight, dotted or triplet | A note value, whatever the signature: **1/4** is a quarter note (the default), **1/1** a whole note, four quarters, which is not a bar in 3/4. Shorter than a bar, the grid starts again on every bar line. See [quantization]({{ site.baseurl }}/in-depth/musical.html#quantization). | +| **Bars** | 1 to 16 bars | Whole bars of the current signature: **3 bars** is a phrase of three bars. | +| **Loop** | 1/4 loop to 8x loop | The loop itself: **Loop** waits for the loop to come round to its start, **2x loop** for every other time, **1/2 loop** for its start and its middle. | + +**Loop** follows the loop as it plays: its length whatever it is, on the bar grid or not, its speed and its direction. An overdub that makes the loop longer waits for the end of the loop as long as it is so far. A stopped loop goes by where it would be had it kept playing since it was recorded. Before there is a loop, while it is empty or being recorded, Loop waits for the length the recording will have: **Record bars** bars, or one bar when Record bars is 0 (2x loop is twice that). + +**Record bars** makes a recording end on its own after that many bars, into what **After record** says. With Record bars at 0, a recording lasts as long as wanted, until the mode is changed. + +**Late stop (ms)** handles a recording that is asked to stop a little after a grid point, for example a footswitch pressed just after the downbeat: the recording ends on that grid point instead of a whole grid step later, and playback carries on in time. When it gives way to an overdub, what was played since the grid point is the start of the overdub. The default is 120 ms; 0 turns it off. + +**Start from** chooses where the loop is read from when the mode changes: + +| Choice | Behavior | +|---|---| +| **Loop start** | Every change of mode reads the loop from its beginning again. | +| **Where it was** (default) | Playing, overdubbing and stopping carry on from where the playhead is: Play, Overdub and Play again stay in time. | +| **In phase** | As Where it was, and a loop heard again keeps to the timeline, see [Start from In phase](#start-from-in-phase). | + +A recording always starts at the loop's start. + +## Footswitches + +The **Switches**, **Layers** and **Speed** tabs have buttons made to be mapped to footswitches, MIDI notes or OSC messages: Switches holds the one-button actions and the transport, Layers holds Undo, Redo, Clear, Layer and what acts on the selected layer, and Speed holds Speed, Reverse and Follow tempo with Toggle reverse, Half speed and Double speed. **Capture** is in the Length tab, next to Capture bars. Play, Stop, Record and Overdub set Mode, exactly as setting it by hand does. The others say what Mode cannot: "the next thing", "a new layer", "from the start", "this layer". What they change waits for the next point of the grid, as a change of Mode does, and Late stop applies to them; the controls they change (Mode, Layer, Reverse, Speed) show what they changed them to. + +| Action | What it does | +|---|---| +| **Rec / Play / Dub** | One button for everything: records an empty loop; while recording, ends the recording into what **After record** says; overdubs a playing loop; while overdubbing, does what **After overdub** says; plays a stopped loop. | +| **Play / Stop** | Plays a stopped loop; stops it in any other mode. Does nothing on an empty loop. | +| **Play**, **Stop**, **Record**, **Overdub** | Set Mode to that mode. Record on a loop that has something in it overdubs it, and Mode shows Overdub. Record while recording, or Overdub while overdubbing, does nothing. | +| **New layer** | While overdubbing, ends the layer and goes on overdubbing in a new one on the grid, without the playhead moving. Does nothing otherwise. | +| **Retrigger** | Goes back to the start of the loop on the grid, in the same mode: an overdub goes on from the start in the same layer. While recording, starts the recording again, its bars and its tempo counted from there. | +| **Undo**, **Redo**, **Clear** | At once, see [Layers](#layers). | +| **Previous layer**, **Next layer** | Change **Layer**, the selected layer, at once, from the oldest to the newest. The view outlines it. | +| **Mute layer**, **Erase layer** | Mute, unmute or erase the selected layer, on the grid. | +| **Solo layer** | Mutes every layer but the selected one, on the grid. Pressed again on that layer, the layers get back the mutes they had, unless a mute or an erase changed them in between. Pressed on another layer, solos that one. | +| **Toggle reverse** | Turns **Reverse** on or off, on the grid. | +| **Half speed**, **Double speed** | Set **Speed** to x1/2 or x2, or back to x1 when it already is, on the grid. | +| **Capture** | See [Capture](#capture). | + +**Layer** moves to each new layer as it is added, so Mute layer, Erase layer and Solo layer act on the newest layer unless Previous layer stepped back. When layers are merged, erased or brought back, Layer keeps naming the layer it named: the merged one when it named one of the two merged. + +Rec / Play / Dub and Play / Stop act on the mode the looper will be in once what waits for the grid is taken up. Pressed twice before the grid point, each press is taken up on a grid point of its own: on an empty loop, two presses of Rec / Play / Dub record one grid step and play it. Setting Mode, or pressing Play, Stop, Record or Overdub, replaces whatever was waiting. + +Three settings choose what the one-button actions do: + +| Setting | Choices | +|---|---| +| **After record** | What a recording gives way to when it ends, by its bars, a full loop or Rec / Play / Dub. **Play** (default) hears the loop at once, the usual choice. **Overdub** goes on overdubbing from the very frame the recording ends on: nothing played across the end of the loop is cut, for pads and sustained textures. A recording made by Overdub on an empty loop always gives way to overdubbing. | +| **After overdub** | What Rec / Play / Dub does while overdubbing. **Play** (default) goes back to playing, as single-switch loopers do. **New layer** goes on overdubbing in a new layer, as New layer does, for building a loop layer by layer with one switch. | +| **Stop at** | When a stop is taken up. **Grid** (default) waits for the next point of the grid, as any change of mode. **Loop end** lets the loop play to its end, for ending a song on a whole loop. **Now** stops at once, ignoring the grid, for a stop that must not wait. | + +## Layers + +Each overdub pass is a layer of its own. The view shows one lane per layer. + +- **Undo** removes the last pass. Pressed during an overdub, it drops the pass in progress and overdubbing carries on in a new one. Pressed during a recording, or **Clear**, starts the recording again at once, its bars and tempo counted from there. Undoing the first recording empties the loop. +- **Redo** brings back the last pass undone. A new overdub after an undo replaces what redo would have brought back. +- **Clear** empties the loop and forgets every pass. +- **Feedback** is how much of the loop is kept each time an overdub goes round it. At 1 nothing fades; below 1, older passes fade a little more at each round. Undoing a pass gives the passes under it back the level it took from them. + +**Past the end** chooses what an overdub does when it reaches the end of the loop: **Wrap** goes round the loop again; **Extend** makes the loop longer by its length, each time the end is reached, and the passes under it play again over the new part. The extended loop ends when overdubbing stops: on a one-bar loop, overdubbing for four bars makes a four-bar loop, and a shorter overdub after that leaves it as it is. Stopping just after the loop grew, within Late stop, does not add the last length. Undo gives the loop its length back. + +**Max layers**, 2 to 32, is the number of layers kept apart. **At max layers** says what a pass does once there are that many: + +| Choice | Behavior | +|---|---| +| **Merge into newest** (default) | The pass is merged into the newest layer when it ends: the oldest layers stay as they are. Undo right after takes the pass out of the newest layer again; once another pass starts, the merge is final. | +| **Merge oldest** | The two oldest layers are merged into one, and that undo step is lost. | +| **Replace a muted layer** | The pass takes the place of the oldest muted layer, or of the newest layer when none is muted. Undo right after takes the pass out and puts the replaced layer back where it was, muted as it was; Redo replaces it again. Once another pass starts, the replacement is final. | + +A muted layer that is merged is left out of the merged one, and lost. + +### Erasing a pass + +Any pass can be taken out of the loop while it plays, not only the last one: + +- in the view, with the **x** at the right of its lane, on the next grid point. The view shows a lane per pass, up to 32, sharing its height between them; with more passes than that, the oldest share the first lane, which has no **x**. +- with **Layer** and **Erase layer**, in the Layers tab: Layer says which pass, counting from the oldest one, and Erase layer erases it on the grid. Layer 1 is the top lane of the view when every pass has a lane of its own, and the file ending in `-layer1` of a take written as layers. Both are ports, so a footswitch or an OSC message can erase a pass. + +The passes over the erased one stay where they are and the loop keeps its length, even when the erased pass had extended it. The passes under it get back the level its feedback took from them, as when it is undone. Undo and Redo go on with the passes left, and what Redo would bring back is kept. Erasing is not itself undone by Undo. + +Erasing the pass being overdubbed is the same as Undo: the pass is dropped and overdubbing carries on in a new one. Erasing the only pass empties the loop, as Clear does. + +## Takes and the timeline + +When a recording or an overdub ends, the loop is written to a WAV file: 32-bit float, with its tempo and length in bars stored in the file, and marked as a loop. A click on **Send**, the button at the top right of the looper's view, places the last take in the timeline as a looping sound file, in a new box starting where the take was recorded, below the looper's box. This is one undoable action. + +The take can also be dragged into the timeline, or anywhere a sound file can be dropped: dragging from the Send button, which has a grip for it, drags what Send would place, the files **Export** says. Dragging a lane drags that layer alone, its own file, which lands as a box of its own. A muted layer is dragged as well: it was chosen. When the last take has no file of that layer, because Export is Mix or the layers changed since, the file is written when the drag starts: the lane says **Preparing** meanwhile, and the drag goes on as soon as it is there. + +Sent or dragged, a take or a layer plays the way the loop did when it was written: its stretch mode follows the **Follow tempo** the looper was playing with. **Timestretch** gives the take the melodic time-stretch mode, **Timestretch percussive** the rhythmic one, **Repitch** and **Repitch fast** the matching repitch modes. With **Off**, the take is not stretched: it plays at the speed it was recorded at, and its box and its loop are as long as the recording itself, at the tempo where it is placed. A change of Follow tempo applies to the loop from the next start, and so to the takes made after that. The stretch mode can be changed afterwards in the sound file's inspector. A take dropped from a file browser has no such information, and gets a stretch mode chosen from its name, as any sound file. + +While a recording or an overdub goes on, the last take does not have it yet. A press on Send then asks for a take of the loop as it is heard at that moment, the pass in progress included as far as it went, without stopping it; the button says **Saving** until the take is written. A click places it as soon as it is there. A drag from the button starts with the next move of the mouse once it is there, if the button is still held; let go before, the take is the one the next drag or Send gives. A lane dragged meanwhile gives its layer as far as it went. When the score is paused, nothing is being taken in any more, and Send and the drags give the last take there is. + +When the score stops while a recording or an overdub goes on, the overdub's layer is closed as any, and Mode then shows Play: when the score plays again, the loop plays, and nothing is recorded over it until Record or Overdub is asked for again. The looper goes with the score's stop, and its view has nothing to ask of it any more: so the score's stop leaves a take of its own, with the mix and a file for each layer, whenever the last take does not have them all as the loop is, which it does not after a recording or an overdub that went on until the stop, or with Export on Mix. It is written even though the looper is gone by then, and the view keeps it, saying **Stopped with the score**: each lane still drags its layer, and Send and the drag from its button still place what Export says, whatever it is changed to once the score is stopped. + +**Export** chooses what Send places, and the files the take written when a recording or an overdub ends has: **Mix** (default), the loop as it is heard; **Layers**, each pass in a file of its own, as it is heard in the loop; or **Both**. Sending a take places those files in one box named after the take, a slot each, the mix first; dragging it from the Send button drops the same files. A take that Send or a drag asks for, or that the score's stop leaves, has all of them, so that Export can be changed afterwards. While the score plays, a Send for files the last take does not have, Export having been changed since it was written, asks for a take that has them, as during a pass. + +Takes of a saved score go into a **Takes** folder next to the score. Takes of a score that has not been saved yet go into score's data folder, where they stay until removed. **File > Project files > Consolidate project...** copies the takes a score uses next to it. **File > Project files > Remove unused files...** finds the takes the score no longer uses only with **Look through the whole project folder** checked: by default it looks only in the folders score sorts media into (Audio, Video, ...), and the Takes folder is not one of them. It then moves them to an Unused folder of the project, or deletes them. + +## Loading a file + +Dropping a sound file on the looper replaces the loop with it, up to Max length, and plays it: Mode shows Play. **Loop file** is the port this sets: it is not in the looper's own view, but it is in the inspector, and a file path sent to it, by a cable or an address, loads the file the same way. A file at another sample rate is converted. A mono file goes to every channel. + +## Capture + +**Record** starts taking in when it is pressed, or on the next grid point. **Capture** works backwards: it takes what was already played, recorded or not, from the input the looper keeps. You play first, and decide afterwards that it was worth keeping. + +- **With no loop**, Capture makes one: the last **Capture bars** bars of the input become the loop, and it plays at once. Mode shows Play, so Stop stops it. +- **Over a loop**, Capture adds what was played over the last round of the loop as a new layer on top, as if that round had been an overdub pass. Each part of it lands where it was played in the loop, and the loop keeps its length: Capture bars does not apply, one round is taken. A stopped loop is taken as going round where it would be had it kept playing, as In phase has it, and it plays from there. The layer is like any other: Max layers and At max layers make room for it as for an overdub pass, the layers that are muted stay muted, it is faded at its ends, moved by the latency, and the layers under it fade by the Feedback once, as for one round of overdub. A take is written as for any pass that closes. + +Capture is undone like a pass: **Undo** takes the captured layer out, **Redo** brings it back. On an empty loop, Undo empties the loop as it does after a first recording, and Redo brings it back. + +Pressed shortly after a point of the grid, within **Late stop**, Capture ends on that point, as a late stop would. Capture does nothing while a recording or an overdub is going on. + +Capture and Capture bars are in the Length tab. Capture needs **Keep last (s)**, in the Memory tab, the number of seconds of input the looper keeps at all times. It is 0 by default, which keeps nothing and uses no memory: Capture then does nothing. It also takes no more than Keep last holds, so a loop longer than Keep last is captured in part. + +## Monitoring + +**Passthrough** chooses when the input is heard: + +| Choice | Behavior | +|---|---| +| **None** | The input is never heard. | +| **Record** (default) | The input is heard while recording and overdubbing only. | +| **Full** | The input is always heard, mixed over the loop. | + +## Memory and latency + +- **Max length (s)**, default 60, is the longest loop. A recording that reaches it ends into what After record says; the view shows the loop as full. +- **Channels**, default 2, is the number of channels recorded. +- **Latency (ms)** moves what is recorded earlier in the loop, to make up for the time the input takes to reach the looper. +- **Engine latency** adds the input and output latency the audio driver reports, for a performer playing from the sound card along with the loop. JACK and PortAudio report it; with other drivers, set Latency by hand. Leave it off for input made inside score, which has no such delay. + +The memory for these is reserved when playback starts, so changes to Max length, Max layers, Channels and Keep last apply from the next start. + +## Tempo changes + +**Follow tempo**, in the Speed tab, chooses how a loop follows the tempo of the score, with the same methods as sound files: + +| Choice | Behavior | +|---|---| +| **Off** (default) | The loop keeps the speed it was recorded at, and no longer falls on the bars after a tempo change. | +| **Repitch**, **Repitch fast** | The loop is resampled: it keeps to the bars, and its pitch goes up and down with the tempo. | +| **Timestretch**, **Timestretch percussive** | The loop is time-stretched: it keeps to the bars and to its pitch. | + +A change of Follow tempo applies from the next start of playback, as the time-stretching is set up then. Following applies to a loop that is playing. A loop being recorded or overdubbed plays at its own speed, and a tempo change is heard from the next round of the loop. Mode changes and the end of a recording after its bars always follow the tempo of the score. A take is written with the tempo the loop was recorded at, so a clip made from it follows the tempo of the score like any sound file. + +## Reverse and speed + +**Reverse** and **Speed**, in the Speed tab, play the loop as a tape would be. + +- **Reverse** plays the loop backwards, from where the playhead is. Turned off, the loop plays forwards again from there. Nothing is changed in the loop: reversing is only how it is read. +- **Speed** plays the loop at x1/4, x1/2, x1, x2 or x4. The pitch follows the speed: at x1/2 the loop is an octave down and takes twice as long, at x2 an octave up and half as long. + +An overdub writes where the playhead goes, as on tape. What is played over the reversed loop sounds reversed once the loop plays forwards again; what is played at x1/2 sounds an octave up, and twice as fast, at x1; at x2, an octave down. + +Speed and Reverse change how the loop is read, not the score's time: Quantize, Record bars and Late stop go by the score as before, and a loop keeps its length. A recording is always made forwards at x1: it is what makes the loop. With **Follow tempo**, Speed applies on top of the tempo: at x2, a loop recorded over two bars plays in one bar whatever the tempo, its pitch up an octave even when time-stretched. + +**Past the end** set to Extend only extends an overdub going forwards: backwards, the playhead reaches the start of the loop and goes round. + +The view's playhead has an arrow pointing the way the loop plays, and the header says when it plays backwards or at another speed than x1. **Phase** goes down from 1 to 0 while the loop plays backwards. + +## Comping + +There is no comp mode: comping is overdubbing with layers cut where wanted, then keeping the best. + +1. Overdub, and cut the takes into layers: **New layer** on each new attempt, or **Passes** on **Per cycle**, in the Play tab, for a layer each time round the loop, or **After overdub** on **New layer** for Rec / Play / Dub to do it from one switch. The playhead goes on all along. +2. Listen to each: **Previous layer** and **Next layer** select one, **Solo layer** hears it alone, Solo layer again hears them all again. +3. Keep the best: **Mute layer** mutes a layer, **Erase layer** removes it. The **m** and **x** of a lane do the same in the view. + +| Passes | Behavior | +|---|---| +| **Whole** (default) | An overdub is one layer, from when it starts to when it stops, unless New layer cuts it. | +| **Per cycle** | An overdub that goes round the loop several times makes a layer of each round, cut on the start of the loop. With Past the end on Extend, a layer is cut each time the loop grows by its length. | + +A layer cut by New layer or Per cycle is closed like any: faded at its ends, and written in a take. It has its own lane, and can be undone or erased on its own. A muted layer is kept but not heard, as if it were erased: it takes nothing from the layers under it with its feedback, and it is drawn dimmed. Muted layers are left out of the mix of a take; a take written as layers still has a file for every layer, the muted ones included, as they would be heard, so that the rounds can be spliced in the timeline. + +## Start from In phase + +With **Start from** set to **In phase**, the loop stays in phase with the timeline. Playing and overdubbing carry on from where they were, as with Where it was; and whenever the loop is heard again after being stopped, it starts where it would be had it kept playing since it was recorded: + +- after Stop, then Play or Overdub; +- when the score is played again, from wherever it starts; +- when the score jumps to another date while the loop plays. + +The position comes from where the loop was recorded on the timeline. Without Follow tempo, it is counted in the score's time: a loop of a second stopped for half a second comes back half a loop on. With Follow tempo, it is counted in quarter notes, so the loop comes back on the bars it was recorded on even after a tempo change. Speed and Reverse are taken into account: the loop comes back where it would be at its speed, going its way. + +## Presets + +The library has presets for the usual ways of looping. Each one sets every setting of the looper but **Channels**, which is the input's, so loading one after another leaves nothing of the one before. They are quantized to the bar unless said otherwise. + +| Preset | What it is for | +|---|---| +| **Song form** | Record, Play, Overdub and Play again, for verses and choruses. Quantize is Loop: the first recording ends on a bar, then every change waits for the loop to come round, and a stop lets it play to its end. | +| **One footswitch, song form** | The same from Rec / Play / Dub alone, a stop also letting the loop play to its end, with a Late stop of 250 ms for a foot that is a little late on the downbeat. | +| **One footswitch, layering** | Rec / Play / Dub records, goes straight on overdubbing, and each press after that starts a new layer. Play / Stop stops. | +| **Comping, a layer per press** | Each press of Rec / Play / Dub while overdubbing starts a new take in a layer of its own; mute the ones to drop, and once there are 16, a new take replaces a muted one; takes are written as a mix and as layers. | +| **Comping, a layer per round** | One overdub, a layer each time round the loop, for trying a part again and again; takes are written as a mix and as layers, to splice the rounds in the timeline. | +| **Four bars, then play** | A recording of four bars, then plays it. | +| **Four bars, then overdub** | A recording of four bars, then goes on overdubbing. | +| **Free loop** | No grid, no Record bars, no Late stop: the loop is as long as it was played for. | +| **Ambient decay** | Four bars, then overdubbing with no gap and Feedback at 0.7, so that older layers fade away; the input is always heard. | +| **Half speed** | The loop plays an octave down and twice as long; what is overdubbed sounds an octave up once played at x1. | +| **Played backwards** | The loop plays backwards, and overdubs over it sound reversed once it plays forwards. | +| **Grows as you overdub** | A bar long recording, and Past the end on Extend: overdubbing over several bars makes the loop that long. | +| **In phase with the timeline** | Start from In phase: a loop played again after a stop, or when the score starts or jumps, is where it would be had it kept playing. | +| **Capture what I played** | Keeps the last minute of input, which Capture needs: press it to make a loop of the last four bars played, or, over a loop, to add its last round as a layer. | +| **Takes for editing** | **Export** on Both: takes are written as a mix and as a file for each layer. | + +## Outputs + +**Phase** goes from 0 to 1 as the loop plays, to drive anything that should follow the loop, such as video. + +## Older scores + +Scores and presets made with older versions of the looper load with the settings they had. Controls renamed since keep their values: + +- **Loop** is now **Mode**, **Quantif** is now **Quantize**, and **Bars** is now **Record bars**. +- **Post-action** is now **After record**, with the same choices, and **Restart** is now **Start from**: Always is Loop start, Recording is Where it was. A score older than Restart gets Start from's default, Where it was, where the looper of the time read the loop from its start on every change of mode: set Loop start for that. +- **Takes** is now **Export**. +- **Quantif** was a list of note values, read as fractions of a bar: a score or a preset made with it gets the grid it waited for. **None** is None, **Whole** is **1 bar**, and the other values are the same note values: **4th** is **1/4**, **Dotted 8th** is **1/8.** In a signature other than 4/4, these note values are now note values, a quarter being a quarter, where they used to divide the bar. +- **Sync** is gone: a looper saved in a sync group plays on its own, and keeps its other settings and its cables. + +These change what an older looper does: + +- **Record on a loop** that has something in it overdubs it. It used to record a new loop in its place: clear the loop first for that. +- **Stopping the process or the score** stops the looper: what was being recorded or overdubbed is closed as a pass and written as a take, the playhead goes back to the loop's start, and a recording or an overdub gives way to Play, which Mode shows; any other mode is taken up again when the score plays again. The looper used to stay in the mode it was in, the playhead where it was. +- **Overdub on an empty loop** records it, then goes on overdubbing; it used to only pass the input through. + +The settings added since come up at their defaults, and these change what such a looper does: + +- **Layers**: each overdub is a layer of its own, with undo. Past 8 layers (**Max layers**), a pass is merged into the newest layer when it ends. +- **Channels** is 2: a looper used to record as many channels as its input had. Set it for an input of more channels. +- **Max length (s)** is 60: a recording that reaches it ends into what After record says. The looper used to grow its buffer for as long as it recorded. +- **Take files**: every recording and every overdub writes a WAV file, in a Takes folder next to the score, see [Takes and the timeline](#takes-and-the-timeline). +- **Late stop (ms)** is 120: a recording asked to stop within 120 ms after a grid point ends on that point. Set it to 0 to end on the next point, as before. diff --git a/docs/reference-manual/processes/library/midi-file-scaler.md b/docs/reference-manual/processes/library/midi-file-scaler.md index c4d66cbd..265d9df2 100644 --- a/docs/reference-manual/processes/library/midi-file-scaler.md +++ b/docs/reference-manual/processes/library/midi-file-scaler.md @@ -31,6 +31,18 @@ Maps which scale degrees appear on which MIDI keys, allowing complex retuning sc **Frequency scale** (0.5x to 2.0x) - Global frequency scaling for transposition +## MIDI output + +Besides the frequencies, the notes come out retuned on the **MIDI** output, in one of two ways chosen with **MIDI output**: + +**Pitch bend** - Each note gets a channel of its own and a pitch bend that moves it to its tuned pitch. Set **Bend range** to the pitch bend range of the receiving synth (2 for most synths, 48 for MPE synths). Works with any synth that responds to pitch bend. + +**MTS sysex** - The notes pass unchanged, and the tuning of the 128 keys is sent as MIDI Tuning Standard messages (real-time single note tuning change, tuning program 0, 32 messages of 4 keys each). A synth applies a tuning only to the channels that selected it, so every tuning send is followed, on all 16 channels, by the tuning bank select (RPN 0 4) and the tuning program select (RPN 0 3), both set to 0, then by the null RPN (controllers 101 and 100 set to 127) so that later data entry changes nothing. + +The tuning is sent when it changes (a new SCL or KBM file, **Frequency adjust**, **Frequency scale**), when playback starts, and when **Send tuning** is pressed. Press **Send tuning** when the synth was started, reset or connected after playback began: score does not know when a destination connects. + +FluidSynth, and plug-ins that read MIDI Tuning Standard messages, retune with **MTS sysex**. The messages reach a MIDI output device, and VST, VST 3, CLAP (MIDI dialect) and LV2 plug-ins, as complete system-exclusive messages. + ## Understanding Scala files **SCL files** define scales as mathematical relationships: diff --git a/docs/reference-manual/processes/library/midi-filter.md b/docs/reference-manual/processes/library/midi-filter.md index 8c4a2cc2..802616e9 100644 --- a/docs/reference-manual/processes/library/midi-filter.md +++ b/docs/reference-manual/processes/library/midi-filter.md @@ -34,6 +34,28 @@ routing. The running-note collection is indexed by pitch rather than by channel/pitch, so identical pitches from multiple channels are not tracked independently. +## Selecting messages + +The **Select** tab keeps or rejects messages; what is rejected goes to the +**Rejected** outlet, so the filter also splits a stream. + +| Control | Meaning | +| --- | --- | +| **Types** | One toggle per kind of message: Note on, Note off, CC, Program, Bend, Pressure (channel aftertouch), Poly, Sysex, MTC, SPP, Song, Tune, Clock, Start, Continue, Stop, Sensing (active sensing) and Reset. With every toggle off, **Filter type** decides. Messages of no kind (undefined status bytes) are kept only when every toggle is on. | +| **Channels** | One toggle per channel; all on selects nothing. | +| **Notes** | Rows of note ranges, **From** and **To** (60 is C4). **+** adds a row, **x** removes one. No rows: every note. | +| **CCs** | Rows of controller number ranges. No rows: every controller. | +| **Invert ranges** | Reject what Channels, Notes and CCs match instead of keeping it. | +| **Value range** / **Value mode** | Keep second data bytes inside or outside a range such as `1-63`. | + +A right-click on Types or Channels sets all, none, or inverts them, and edits +them as text. Scores and presets saved when Types, Notes and CCs were typed as +text (`note, cc, -sysex`, `C-1-B2, C4`, `64-69`) load with the same selection. + +A note-off always goes to the outlet its note-on went to, so that a note that +was kept is always ended. When note-offs are selected, the note-offs of notes +that were rejected only for their kind go to the MIDI outlet as well. + Because Index 0 means “all”, this control cannot isolate only CC 0 or note 0. ## Outputs @@ -55,6 +77,11 @@ the receiving hardware requires that wire representation. For a CC control, use **CC**, **Channel 0**, **Index 74** and **Mode Value**. Cable **Normalized value** to a suitable parameter or a mapping process. +To extract a pitch bend or channel aftertouch, set **Filter type** to +PitchBend or AfterTouch the same way. [Midi transform]({{ site.baseurl }}/processes/midi-utilities.html#midi-transform) +and [Midi value shaper]({{ site.baseurl }}/processes/midi-utilities.html#midi-value-shaper) +also give the value of each message they produce, on their **Value** outlet. + For a single-channel chord stream, use **NoteRunning** and **Mode Both** to obtain held note/velocity pairs. Enable **Zero to note off** if the source encodes releases as note-ons with velocity zero. Stop or restart the source carefully: diff --git a/docs/reference-manual/processes/library/midi-sync.md b/docs/reference-manual/processes/library/midi-sync.md index 93605a66..dfe16e8a 100644 --- a/docs/reference-manual/processes/library/midi-sync.md +++ b/docs/reference-manual/processes/library/midi-sync.md @@ -38,6 +38,8 @@ score interval to external MIDI equipment. Clock expresses musical tempo; MTC expresses a time position. They are different protocols, so enabling both is only useful when the receiver understands both. The output controls start disabled until enabled by the user. +When playback starts on a clock pulse, the first clock goes out together with +Start, so that the receiver counts its first beat from there. ## Limitations @@ -45,8 +47,17 @@ This process sends synchronization; it does not make score a slave to an externa transport. Use [MIDI Sync In]({{ site.baseurl }}/processes/midi-timecode-input.html) to extract incoming timing values. MIDI transmission and receiver behavior add latency and jitter; test the actual devices rather than assuming sample-accurate -lock. The current explicit seek/transport callback does not send a relocation -message, so verify seeking and restart behavior with the receiver. +lock. + +## Seeking and looping + +After a seek, a loop or a resume in the middle of the score, MIDI Sync Out sends +Stop, a Song Position and Continue. A Song Position counts 16th notes, so the +clock starts again on the first 16th note at or after the new position, and +nothing is sent until then: the receiver's first clock is where the score is. +With a clock rate other than x1, the 16th notes are the receiver's: at x2, a +score quarter is two quarters for the receiver. Positions past 1024 bars of 4/4 +cannot be sent as a Song Position. In the current implementation the displayed 29.97/30 choices use the opposite numerical rates for frame calculation; use 24 or 25 fps when possible, and do not diff --git a/docs/reference-manual/processes/library/midi-utilities.md b/docs/reference-manual/processes/library/midi-utilities.md index 5eac3cb3..0100ecba 100644 --- a/docs/reference-manual/processes/library/midi-utilities.md +++ b/docs/reference-manual/processes/library/midi-utilities.md @@ -19,14 +19,14 @@ permalink: /processes/midi-utilities.html The classic arpeggiator effect. Play a chord on your keyboard and let the process create new notes from it. -The currently implemented modes are: +Some of its patterns: - Forward: plays the notes in order (1-2-3-1-2-3) -- Backwards: plays the notes in reverse order (3-2-1-3-2-1) +- Backward: plays the notes in reverse order (3-2-1-3-2-1) - F->B: first forward then backwards (1-2-3-3-2-1) - B->F: first backwards then forward (3-2-1-1-2-3) - Chord: repeats the chord currently being held -See [Arpeggiator]({{ site.baseurl }}/processes/arpeggiator.html) for its current timing and pattern controls. +See [Arpeggiator]({{ site.baseurl }}/processes/arpeggiator.html) for all its patterns and its timing, velocity and latch controls. ## Chord @@ -36,12 +36,30 @@ This process transforms an input note into a chord. For instance, if "Major" is selected: C3 -> C3 E3 G3 +Its Mode picks where the chord comes from: +- Chord: the chord type chosen in the list, with up to Num. Notes notes. +- Harmonizer: the Intervals list, in semitones from the played note. +- Memory: a chord of its own for each key, from the Memory list. + +The Memory list has one row per key: the key, then the semitones of each note +from that key, e.g. `C4: 0 4 7` (C4 is MIDI note 60; `60: 0 4 7` works too). +Rows are added with "+", removed with "x", and edited by double-clicking them; a +key without a row plays itself. To fill it from a keyboard, turn on Learn, play +a chord, release it, then press the key that will trigger it: the row for that +key appears in the list. + ## MIDI scale ![MIDI scale]({{ site.img }}/reference/processes/midi-scale.png "MIDI scale example") This process allows to transpose and make the input MIDI fit into predetermined scales, to prevent wrong notes for instance. +Lowest and Range limit it to part of the keyboard: only the notes from Lowest +to Lowest + Range are scaled and transposed, the others pass unchanged. For +instance the preset "Fifth up above C4 only" has Lowest at 60 (C4) and +Transpose at 7: C4 plays G4 and E4 plays B4, while every key below C4 plays +itself. + ## Quantifier ![Quantifier]({{ site.img }}/reference/processes/quantifier.png "Quantifier example") @@ -66,6 +84,48 @@ This process allows to convert input signals into MIDI. * If the input is of type int, then it is used as pitch and the velocity is set with the default velocity. * If the input is of type vec2, then the first element is the pitch, the second is the velocity. +## Midi Glide + +Midi Glide makes a stream monophonic: one note sounds at a time, chosen among +the keys held as a monophonic synthesizer does. + +| Control | Meaning | +| --- | --- | +| **Priority** | The held key that sounds: **Last** pressed, **Low**est or **High**est. A key that does not win is remembered. | +| **On release** | When the sounding key is released while others are held: **Stop** ends the note and forgets the keys still held; **Return** goes back to the held key that wins, at the velocity it was played with. | +| **Transition** | **Retrigger** ends a note before starting the next. **Legato** starts the next one first, which a synthesizer in legato ("fingered") mode plays as a slide: glide, and no new attack. | +| **Latch** | **Toggle**: the note keeps sounding when its key is released, until another key takes over. **Momentary**: the same while **Hold** is pressed; the latched note ends when Hold is let go. | + +The defaults (Last, Stop, Retrigger, no latch) are a plain monophonic legato. + +## Midi transform + +Midi transform turns one kind of MIDI message into another. Its **Value** +outlet gives the value of each message it produces, at the time of the message: + +* note on and note off: the velocity; CC: the controller value; poly + pressure: the pressure (0 to 127); +* program change, channel pressure, MTC quarter frame, song select: the data + byte (0 to 127); +* pitch bend: -1 to 1, 0 at the center; +* song position: 0 to 16383, in sixteenth notes; +* tune request and real-time messages: no value. + +Messages that pass through untransformed have no value. With **Into** set to +Note on, the note-off that ends a produced note gives 0. + +## Midi value shaper + +Midi value shaper reshapes velocities, controllers, pitch bend or pressure. Its +**Value** outlet gives each shaped value as it is sent, at its time: 0 to 127 +for velocities, controllers and pressure, -1 to 1 for pitch bend. + +## Midi sustain + +Midi sustain holds notes after their key is released, like a sustain pedal: CC +64 of each channel, or the **Pedal** button, which holds every channel while it +is pressed. + ## MIDI Envelope [MIDI Envelope]({{ site.baseurl }}/processes/midi-envelope.html) turns note-on/off events into control envelopes. Choose staged or drawn shapes, mono/poly voicing and a voice-combination mode, then connect Out to the parameter to animate. diff --git a/docs/reference-manual/processes/library/midi_looper.md b/docs/reference-manual/processes/library/midi_looper.md new file mode 100644 index 00000000..9c06dd88 --- /dev/null +++ b/docs/reference-manual/processes/library/midi_looper.md @@ -0,0 +1,168 @@ +--- +layout: default + +title: MIDI looper +description: "Record notes and controllers in passes, play them back in time, and turn the loop into a MIDI clip of the timeline" + +parent: Processes +grand_parent: Reference + +permalink: /processes/midi-looper.html +--- +# MIDI Looper + +![MIDI looper]({{ site.img }}/reference/processes/midi_looper.png "The MIDI looper playing a two bar phrase") + +The process named **Looper (MIDI)** records the notes, controllers, pitch bend and pressure it receives at **in** into a loop, and plays them back at **out**. It shares its transport, timing, undo, capture and timeline features with the [audio looper]({{ site.baseurl }}/processes/audio-looper.html) and the [value looper]({{ site.baseurl }}/processes/value-looper.html); this page describes what is particular to MIDI. + +The recording keeps its own timing: quantize, transpose and channel changes only apply on playback, and can be changed at any time without losing anything. A take is what the loop plays with the quantize of the moment, but not transposed and on the recorded channels, see [Takes and the timeline](#takes-and-the-timeline). + +## Passes and overdubs + +Each recording or overdub is a pass, kept as a layer of its own. **Undo** hides the last pass, **Redo** shows it again, **Clear** forgets everything; Undo or Clear during a recording starts it again at once, its bars counted from there. **Start from** is in the Play tab; Follow tempo is in the Speed tab. + +**Overdub mode**, in the Overdub tab, chooses what a pass does to the notes of the passes under it: + +| Choice | Behavior | +|---|---| +| **Merge** (default) | Every pass is heard. | +| **Replace** | A pitch played in a pass silences that pitch in earlier passes, over the part of the loop the pass went through. The rest of the loop is untouched. | + +Controllers always replace their own earlier values over the part of the loop a pass went through: a pass that moves CC 74 replaces the earlier CC 74 curve there, and leaves CC 1 and pitch bend alone. Two curves of one controller never fight. + +## Record, Overdub and the Switches tab + +**Mode**, the **Switches**, **Layers** and **Speed** tabs and the settings **Quantize**, **After record**, **After overdub**, **Start from** and **Stop at** work as for the [audio looper]({{ site.baseurl }}/processes/audio-looper.html#record-overdub-and-layers): Mode is the state of the looper, Play, Stop, Record and Overdub set it, and Rec / Play / Dub, Play / Stop, New layer, Retrigger and the layer actions do what no value of Mode can. Record on a loop that has something in it overdubs it, as on a looper pedal: **Clear** the loop first to record a new phrase. See there for what each one does and when it is taken up. + +| | What it is for | What it does to the loop | How layers are cut | +|---|---|---|---| +| **Record** | Making a phrase. | Makes the loop: it is as long as the recording, or **Record bars** bars. On a loop that has something in it, Record overdubs: Clear first to make the phrase again. | The recording is the first layer. | +| **Overdub** | Playing over the phrase. | Adds what is played, replacing earlier controllers, and notes with Replace, where it goes; with **Past the end** on Extend, makes the loop longer. | One layer from where it starts to where it stops, made when its first event comes in; with **Passes** on Per cycle, one each time round that gets something; **New layer** cuts one where it is pressed. | +| **Play**, **Stop** | Listening, or not. | Nothing. | None. | + +With After record set to Overdub, or with Overdub on an empty loop, the overdub starts on the very frame the recording ends on. A note held across the end of the recording is one note of the recording, which wraps round the end of the loop to where it was let go; a note played on the first frame of the overdub is the first note of the new layer. + +An overdub pass becomes a layer when its first note or controller comes in, not when the overdub starts: until then the overdub runs, the playhead going round as it records nothing, but there is no new layer, no lane for it in the view, and Undo still takes out the last layer there is. The layer starts where the overdub began, and goes as far as the overdub went. An overdub that gets nothing writes no take, adds no layer, and merges nothing; with Passes on Per cycle, a round that gets nothing is no layer either. Past Max layers, the room for the new layer (merging the oldest, or setting a muted layer aside) is made when its first event comes in, and Merge into newest merges only a layer there is. + +**Max layers**, 2 to 32, default 8, and **At max layers**, in the Overdub tab, work as for the audio looper: past Max layers, a pass is merged into the newest layer when it ends (the default, which undo can take out again until the next pass), the two oldest layers are merged, or the pass replaces the oldest muted layer, else the newest (which undo puts back, and redo replaces again, until the next pass). Merging moves the notes and controllers of a layer into the other; what either of them replaced stays replaced, muted or erased as the merged layer. + +## The view + +The view shows one lane per pass, as the audio looper does: up to 32 lanes, sharing the height of the view, the oldest passes sharing the first lane when there are more. A lane is added when a pass gets its first event; until then the header shows the overdub running. Each lane is a small piano roll of its own pass, over the pitches that pass played. Notes a later pass replaced are drawn dimmed. + +## Erasing a pass + +As with the [audio looper]({{ site.baseurl }}/processes/audio-looper.html#erasing-a-pass), any pass can be erased while the loop plays, with the **x** of its lane or with **Layer** and **Erase layer**, on the grid. Layer is on the newest layer unless it was stepped back. Its notes and controllers go; the passes over it stay where they are, and the loop keeps its length. Erasing the pass being overdubbed is the same as Undo, and erasing the only pass empties the loop. The notes the loop was playing end, as with Undo. + +What only the erased pass replaced is heard again. What a later pass replaced as well stays replaced: if the second pass and the third both played a C over the C of the first one, erasing or muting the second leaves the first one's C silent, because the third still replaces it. + +## Notes at the edges of the loop + +**Held notes** chooses what a note held across the end of the loop does: **Wrap** (default) carries it on from the start of the loop, **Truncate** ends it with the loop. + +**Grace (ms)**, default 60, is for a note played slightly before a recording or an overdub starts: it is recorded on the first beat instead of being lost. The other way round, a recording asked to stop a little after a grid point, within **Late stop (ms)**, ends on that point; when it gives way to an overdub, the notes played since the point are the overdub's, where they were played. + +A note held on the input is never sent twice when the loop plays the same note. + +## Quantize and Note grid + +**Quantize** is when a mode change is taken up: a time, a note value, a number of bars, or the loop itself, as for the [audio looper]({{ site.baseurl }}/processes/audio-looper.html#timing). With **Loop**, a change waits for the loop to come round to its start, wherever that falls in the bar; before there is a loop, it waits for **Record bars** bars, or one bar when Record bars is 0. The rest of this section is about the notes, not the mode changes. + +**Note grid** (default a quarter note, **1/4**) and **Strength** (default 0), in the Note grid tab, pull the notes towards a note value when they are played back. Note grid is a note value only, straight, dotted or triplet: it waits for nothing, and only says where the notes go. At a Strength of 0 the notes play as recorded; at 1 they play on the grid. **Note ends** pulls the ends of the notes too. A note sounding when one of them changes ends where it was going to: the change applies from its next start, and a note moved to where the playhead has yet to go plays there once it has ended. + +## Notes and channels + +- **Transpose** moves the notes of the loop by semitones. +- **In channel** chooses the channel recorded; 0 records them all. +- **Out channel** plays the loop on one channel; 0 keeps the recorded ones. +- **Passthrough** chooses when the input is heard, as for the audio looper. It is Full by default. + +Changing the transposition or the output channel, stopping, undoing, erasing a pass or clearing ends the notes the loop was playing. + +Overdubbing an empty loop records it, as with the audio looper. + +## Tempo changes + +With **Follow tempo**, on by default, the loop plays at the tempo of the score: a loop recorded over two bars lasts two bars whatever the tempo becomes. Off, it keeps the speed it was recorded at. Either way the quantize grid stays on the loop's own beats, and its takes have the tempo it was recorded at. + +**Past the end** works as for the audio looper: an overdub can make the loop longer, the passes under it repeating. + +## Takes and the timeline + +When a recording or an overdub ends, what is heard of the loop is written to a Standard MIDI File, at the tempo and in the time signature it was recorded in, and ending exactly at the end of the loop. score places a MIDI file by its beats, so a take of two bars is a clip of two bars whatever its tempo. A click on **Send** in the looper's view, or a drag from that button, places it in the timeline as a MIDI clip that holds the notes, where the take was recorded. Dragging a lane drops that layer alone, as a clip in a box of its own, muted or not. A take is a loop wherever it goes: its clip loops at the length of the loop, so that a take of four bars is a box of four bars, and making the box longer plays it round again. Dropped on a box that is already there, the looper's own box for instance, the clip is as long as that box and plays the loop round over it. A MIDI file dragged from a file browser is not a take, and is not looped. When the take has no file of the layer dragged, it is written when the drag starts, the lane saying **Preparing** until it is there, as for the [audio looper]({{ site.baseurl }}/processes/audio-looper.html#takes-and-the-timeline). The file can also be opened in any other MIDI editor. **Export** chooses what Send, and a drag from its button, place, and the files the take written when a recording or an overdub ends has: what is heard of the whole loop (**Mix**, the default), each pass in a file of its own (**Layers**), or both; the files go in one box, a looping clip each, the mix first. A take that Send or a drag asks for, or that the score's stop leaves, has all of them, so that Export can be changed afterwards, as for the audio looper. + +A take has the notes where the loop plays them: **Note grid**, **Strength** and **Note ends** are applied to it, and so is **Held notes**. **Transpose** and **Out channel** are not: the notes are at the pitch and on the channel they were played, so that the clip can be transposed or routed again in the timeline. + +While a recording or an overdub goes on, Send or a drag from it asks for a take of the loop as it is heard at that moment, the pass in progress included, a key still held lasting up to the playhead; the Send button says **Saving** until it is written, as for the audio looper. When the score stops while a pass is taken in, the pass is closed as any; Mode then shows Play, and playing the score again plays the loop without recording over it. The score's stop leaves a take with the mix and a file for each layer whenever the last take does not have them all as the loop is, even though the looper is gone by then: the view, saying **Stopped with the score**, still drags each lane's layer, and Send still places what Export says, Export being changed once the score is stopped too. + +## Reverse and speed + +**Reverse** and **Speed**, in the Speed tab, work as for the [audio looper]({{ site.baseurl }}/processes/audio-looper.html#reverse-and-speed). + +- Played backwards, a note plays where it ended: a note over the first quarter of a one-bar loop plays over its last quarter. A note held across the end of the loop wraps or is truncated as it was forwards: truncated, what was heard of it at the end of the loop is heard at its start. A controller, pitch bend or pressure goes back the way it came: going back over a point where it changed, it takes the value it had before, so a sustain pedal held over a part of the loop is held over that part backwards. +- **Speed** plays the loop at x1/4 to x4: at x2, a phrase takes half as long. With **Follow tempo**, Speed applies on top of the tempo. + +An overdub records where the playhead goes. A phrase played over the reversed loop plays reversed when the loop goes forwards again, its notes starting where they were let go; a phrase played at x1/2 plays twice as fast at x1. A recording is always made forwards at x1. + +The notes the loop was playing end when it turns round. + +## Comping + +As for the [audio looper]({{ site.baseurl }}/processes/audio-looper.html#comping), there is no comp mode: overdub, cut the takes into layers with **New layer**, with **Passes** on **Per cycle** (in the Overdub tab) or with **After overdub** on **New layer**, then step through them with **Previous layer** and **Next layer**, hear one with **Solo layer**, and keep the best with **Mute layer** and **Erase layer**, or the **m** and **x** of the lanes. A note held across the start of the loop belongs to the round it started in. Each layer cut is closed like any, and written in a take. + +A muted layer's notes and controllers are not heard, and it replaces nothing, so with Replace the notes it replaced are heard again while it is muted, unless another layer replaces them as well. Muted layers are left out of the mix of a take, and still have their own file in a take written as layers. The notes the loop was playing end when a layer is muted or unmuted. + +## Start from In phase + +**Start from** set to **In phase** keeps the loop in phase with the timeline, as for the [audio looper]({{ site.baseurl }}/processes/audio-looper.html#start-from-in-phase). With Follow tempo, on by default, the position is counted in quarter notes, so the loop comes back on its bars after a tempo change. + +## Capture + +**Record** starts taking in when it is pressed, or on the next grid point. **Capture**, in the Length tab next to **Capture bars**, works backwards: it takes what was already played, recorded or not. You play first, and decide afterwards that it was worth keeping. + +- **With no loop**, the last Capture bars bars played become the loop, and it plays at once; Mode shows Play. +- **Over a loop**, what was played over the last round of the loop becomes a new layer on top, as if that round had been an overdub pass: each note lands where it was played in the loop, and the loop keeps its length. Capture bars does not apply, one round is taken. A stopped loop is taken as going round where it would be had it kept playing, as In phase has it, and it plays from there. Max layers and At max layers make room for the layer as for an overdub pass, muted layers stay muted, Overdub mode applies to what it plays over, and a take is written as for any pass that closes. When nothing was played over that round, no layer is made, as for an overdub that gets nothing. + +**Undo** takes the captured layer out and **Redo** brings it back, as for any pass. On an empty loop, Undo empties the loop as it does after a first recording. + +Pressed shortly after a point of the grid, within **Late stop**, Capture ends on that point, as a late stop would: a note held across that point ends there. Capture does nothing while a recording or an overdub is going on. + +The MIDI looper always keeps the last 8192 messages it received, so there is nothing to set up; a busy input only lets Capture look back as far as those messages go. + +## Presets + +As for the [audio looper]({{ site.baseurl }}/processes/audio-looper.html#presets), each preset sets every setting, quantized to the bar unless said otherwise, and what is played is always heard. + +| Preset | What it is for | +|---|---| +| **Song form** | Record, Play, Overdub and Play again. Quantize is Loop: the first recording ends on a bar, then every change waits for the loop to come round, and a stop lets it play to its end. | +| **One footswitch, song form** | The same from Rec / Play / Dub alone, a stop also letting the loop play to its end, with a Late stop of 250 ms. | +| **One footswitch, layering** | Rec / Play / Dub records, goes straight on overdubbing, and each press after that starts a new layer. | +| **Comping, a layer per press** | Each press of Rec / Play / Dub while overdubbing starts a new take in a layer of its own; once there are 16, a new take replaces a muted one; takes are written as a mix and as layers. | +| **Comping, a layer per round** | One overdub, a layer each time round the loop; takes are written as a mix and as layers. | +| **Four bars, then play** | A recording of four bars, then plays it. | +| **Four bars, then overdub** | A recording of four bars, then goes on overdubbing: a chord held across the end of the loop is not cut. | +| **Free loop** | No grid, no Record bars, no Late stop: the loop is as long as it was played for. | +| **Overdub drums** | Two bars, then overdubbing; notes end with the loop. | +| **Drum pattern on channel 10** | Records channel 10 only, two bars then overdubbing; a hit replaces the hits of that pitch under it, notes end with the loop, and play back on the sixteenth. | +| **Replace as you play** | Four bars, then overdubbing, a layer each time round the loop: a pitch played replaces that pitch in the rounds before it, so each round played over replaces the one before. | +| **Sixteenths, 70 percent** | Notes pulled 70 percent of the way to the sixteenth on playback; mode changes on the quarter note. | +| **Octave up** | The loop plays an octave above what was played. | +| **Half speed** | The loop plays twice as slow; what is overdubbed plays twice as fast at x1. | +| **Grows as you overdub** | A bar long recording, and Past the end on Extend: overdubbing over several bars makes the loop that long. | +| **In phase with the timeline** | Start from In phase: a loop played again after a stop, or when the score starts or jumps, is where it would be had it kept playing. | +| **Takes for editing** | **Export** on Both: takes are written as a mix and as a MIDI file for each layer. | + +## Older scores + +A score or a preset made with an older MIDI looper loads with the settings it had, as for the [audio looper]({{ site.baseurl }}/processes/audio-looper.html#older-scores): **Loop** is now **Mode**, **Quantif** is now **Quantize**, **Bars** is now **Record bars**, and Sync is gone. The settings of the notes have new names as well: + +- **Grid** is now **Note grid**. Its list of note values gives the same note value; its **None** did what a Strength of 0 does, and gives the default note value, a quarter. +- **Quantize**, the strength, is now **Strength**, with the same value. The control now named Quantize is the grid of the mode changes, which was Quantif. +- **Quantize ends** is now **Note ends**. + +Record on a loop that has something in it now overdubs it, and stopping the score during a recording or an overdub leaves Mode on Play, as for the audio looper. + +## Capacity + +A loop holds up to 4096 notes and 8192 controller values. When it is full, the view says so and further events are not recorded. diff --git a/docs/reference-manual/processes/library/piano-roll.md b/docs/reference-manual/processes/library/piano-roll.md index 9d6ed403..35c3c2ae 100644 --- a/docs/reference-manual/processes/library/piano-roll.md +++ b/docs/reference-manual/processes/library/piano-roll.md @@ -18,6 +18,8 @@ The piano roll allows to output MIDI notes according to a score. MIDI files can be loaded by drag'n'drop, either on a scenario, interval, or on the piano roll process directly. +A MIDI file is placed by its beats, not by its duration in seconds: two bars of the file are two bars of the score, whatever tempo the file was saved at, and the score's own tempo sets how fast they play. Dropped on an existing piano roll, the notes are placed the same way from its start. + Adding a note is done by double-clicking ; the note can be stretched with the mouse. When dropping a MIDI file, if {% include shortcut.html content="Shift" %} is held, the tracks are put in sequence instead of in parallel. diff --git a/docs/reference-manual/processes/library/value_looper.md b/docs/reference-manual/processes/library/value_looper.md new file mode 100644 index 00000000..dc5fa122 --- /dev/null +++ b/docs/reference-manual/processes/library/value_looper.md @@ -0,0 +1,126 @@ +--- +layout: default + +title: Value looper +description: "Record a stream of values in passes, play it back in time, and turn the loop into automations of the timeline" + +parent: Processes +grand_parent: Reference + +permalink: /processes/value-looper.html +--- +# Value Looper + +![Value looper]({{ site.img }}/reference/processes/value_looper.png "The value looper playing a two second LFO loop") + +The process named **Looper (values)** records the values it receives at **in** into a loop, and plays them back at **out**: numbers, booleans, vectors, text, lists, maps and impulses, from any source, such as an LFO, a sensor, a controller or another process. It shares its transport, timing, undo, capture and timeline features with the [audio looper]({{ site.baseurl }}/processes/audio-looper.html) and the [MIDI looper]({{ site.baseurl }}/processes/midi-looper.html); this page describes what is particular to values. + +## Held values and impulses + +A value is **held** until the next one, as a parameter keeps the last value it was sent: playing the loop sends each value where it came, and nothing in between. At the end of the loop, the value held carries on into its start; nothing is sent again unless it changes. + +An **impulse** is not held: it fires where it came, as a note would, every time round. + +Only a new value is recorded: a value equal to the one before it is left out, so a source that sends the same value over and over takes no room in the loop. Two values of the same type are equal when they hold the same thing, a list or a map element by element; an int and a float are never equal. Of several values that come on the same sample, the last one is kept. Every impulse counts, one a sample. + +A recording starts with the value the input held when it starts: a value that does not move during the first beat is in the loop all the same. + +## Passes and overdubs + +Each recording or overdub is a pass, kept as a layer of its own. **Undo** hides the last pass, **Redo** shows it again, **Clear** forgets everything; Undo or Clear during a recording starts it again at once. + +An overdub **holds** the value from its first new value to its end: before it is touched, the passes under it are heard; from the first new value on, what the overdub recorded is heard instead, and the value it holds while nothing new comes in is the last one it recorded; after the end of the pass, the passes under it are heard again, from the value they hold there. An overdub that only listens, without the input moving, leaves the loop as it was. + +Impulses of every pass are heard: an overdub adds its impulses to the ones under it. + +An overdub that goes round the loop more than once writes over what it recorded the round before, as a tape would: the second time round, the value it holds is the value of the input, whether it moves or not. With **Passes** on **Per cycle**, each round is a layer of its own instead. + +An overdub pass becomes a layer when its first value comes in, not when the overdub starts: until then the overdub runs but there is no new layer, no lane for it in the view, and Undo still takes out the last layer there is. The layer starts where the overdub began. An overdub that gets nothing writes no take, adds no layer and merges nothing; with Per cycle, a round that gets nothing is no layer either. Past Max layers, the room for the new layer is made when its first value comes in. + +**Max layers**, 2 to 32, default 8, and **At max layers**, in the Overdub tab, work as for the other loopers. Two merged passes are heard as they were: the newer one still holds the value where it did, and the older one elsewhere. + +## Chasing + +Whenever what the loop holds where the playhead is changes for another reason than a value of the loop, the value now held is sent at once: + +- playing the loop, retriggering it, or the playhead jumping, e.g. with Start from on Loop start or In phase; +- muting, unmuting, soloing or erasing a layer, Undo and Redo: a layer that held the value hands it back to the ones under it, and the other way round; +- the end of an overdub, where the layers under it are heard again. + +When nothing changes, nothing is sent: stopping and playing again from where it was sends nothing if the value held is the same. + +## Record, Overdub and the Switches tab + +**Mode**, the **Switches**, **Layers** and **Speed** tabs and the settings **Quantize**, **After record**, **After overdub**, **Start from** and **Stop at** work as for the [audio looper]({{ site.baseurl }}/processes/audio-looper.html#record-overdub-and-layers). Record on a loop that has something in it overdubs it: **Clear** the loop first to record a new one. **Late stop (ms)** works as for the other loopers: a recording asked to stop a little after a grid point ends on that point, and what came in since belongs to the overdub that follows. + +## Passthrough + +**Passthrough**, in the Play tab, chooses when the input goes out as well as the loop: never, while recording or overdubbing only, or always (**Full**, the default). With Full, the input wins while it moves: a value that comes in goes out, and the loop does not send anything of its own for the next 0.2 seconds; once the input has stopped moving, the loop takes over again from the value it holds there. + +## The view + +The view shows one lane per pass, as the other loopers do: up to 32 lanes, sharing the height of the view, the oldest passes sharing the first lane when there are more. Each lane draws what its pass holds: + +- numbers and booleans as steps, scaled to the numbers that lane holds; a vector, or a list of numbers, by its first number; +- text, lists and maps as a line across the middle of the lane, a tick where each one starts; +- impulses as ticks across the lane. + +What the loop does not play there, e.g. what a later pass holds over, is dimmed. The **m** and **x** of each lane mute and erase it, on the grid. + +## Takes and the timeline + +When a recording or an overdub ends, what is heard of the loop is written to a small file of its own, a `.values` file, which keeps every value where it is heard, with its type. **Export** chooses what Send, and a drag from its button, place, and the files the take written when a recording or an overdub ends has: what is heard of the whole loop (**Mix**, the default), each pass in a file of its own (**Layers**), or both, a box for each file. A take that Send or a drag asks for, or that the score's stop leaves, has all of them, so that Export can be changed afterwards. + +When every value of a take is a number, a boolean, a vector, or a list of numbers and booleans, a click on **Send** in the view, or a drag from that button, places it in the timeline as automations: one for each number of the values, so three for a vector of three, four for lists of four floats such as Arraygen sends, in one box, where the take was recorded. Values of different sizes can be mixed: the take has as many automations as the longest value has numbers, at most 32. A value that has fewer numbers leaves the others where they were, and before an index first has a number, its first number holds. The automations of a vector are named by its axes, x, y, z and w; those of lists by their index, from 0. Each automation holds each value until the next, in steps, its minimum and maximum those of the take; the box is as long as the loop, in bars, whatever the tempo it was played at, and the automations loop as the box is made longer; dropped on a box that is already there, they are as long as that box and play the loop round over it. They can be edited, given an address or cabled as any automation. One undo removes the box. + +Dragging a lane places that layer alone, as automations in a box of its own, when its values are all numbers as above; its file is written when the drag starts if the take has none, the lane saying **Preparing** meanwhile. + +A take with impulses, text, maps, lists holding anything but numbers and booleans, or more than 32 numbers, is kept as a file only: the button of the view says **File** instead of Send, nothing is placed in the timeline, and its lanes drag nothing. The file is plain JSON, and can be read by any other tool. + +While a recording or an overdub goes on, Send or a drag from it asks for a take of the loop as it is at that moment; the Send button says **Saving** until it is written. When the score stops while a pass is taken in, the pass is closed as any. The score's stop leaves a take with the mix and a file for each layer whenever the last take does not have them all as the loop is, even though the looper is gone by then: the view, saying **Stopped with the score**, still drags each lane's layer, and Send still places what Export says, Export being changed once the score is stopped too. + +## Reverse and speed + +**Reverse** and **Speed**, in the Speed tab, work as for the other loopers. Played backwards, a value goes back to the one it had before: going back over a point where the value changed, the loop sends the value it held before that point. Impulses fire where they came. At **Speed** x2, the values come twice as often. + +An overdub records where the playhead goes: what is played over the reversed loop plays reversed when it goes forwards again. + +## Tempo changes + +With **Follow tempo**, on by default and in the Speed tab, the loop plays at the tempo of the score: a loop recorded over two bars lasts two bars whatever the tempo becomes. Off, it keeps the speed it was recorded at. **Past the end** works as for the other loopers: an overdub can make the loop longer, the passes under it repeating. + +## Capture + +**Record** starts taking in when it is pressed, or on the next grid point. **Capture**, in the Length tab next to **Capture bars**, works backwards: it takes the values that already came in, recorded or not. You move things first, and decide afterwards that it was worth keeping. + +- **With no loop**, the last Capture bars bars of values become the loop, and it plays at once; Mode shows Play. The loop starts with the value the input held just before those bars. +- **Over a loop**, the values that came in over the last round of the loop become a new layer on top, as if that round had been an overdub pass: each value lands where it came in the loop, and holds from its first new value to where the round ended. The loop keeps its length: Capture bars does not apply, one round is taken. A stopped loop is taken as going round where it would be had it kept playing, as In phase has it, and it plays from there. Max layers and At max layers make room for the layer as for an overdub pass, muted layers stay muted, and a take is written as for any pass that closes. When no new value came in over that round, no layer is made, as for an overdub that gets nothing. + +**Undo** takes the captured layer out and **Redo** brings it back, as for any pass. On an empty loop, Undo empties the loop as it does after a first recording. + +Pressed shortly after a point of the grid, within **Late stop**, Capture ends on that point, as a late stop would. Capture does nothing while a recording or an overdub is going on. + +The value looper always keeps the last 4096 values it received, so there is nothing to set up; a busy input only lets Capture look back as far as those values go. + +## Comping and Start from In phase + +Comping with **New layer**, **Passes** on **Per cycle**, **Solo layer**, **Mute layer** and **Erase layer**, and **Start from** on **In phase**, work as for the [audio looper]({{ site.baseurl }}/processes/audio-looper.html#comping). + +## Presets + +Each preset sets every setting; mode changes wait for the bar unless said otherwise, and the input always goes out. + +| Preset | What it is for | +|---|---| +| **Two bar gesture** | A recording of two bars, then plays it. | +| **Free gesture** | No grid, no Record bars, no Late stop: the loop is as long as it was played for. | +| **A layer per round** | Two bars, then one overdub, a layer each time round the loop; once there are 16, a new layer replaces a muted one. | +| **Takes for automation** | Four bars; **Export** on Both: takes are written as a mix and as a file for each layer, to place them in the timeline as automations. | + +## What it does not have + +The value looper loops one stream of values. It has no Feedback, no Held notes, Note grid, Strength or Note ends, no Transpose and no channels, which are about sound or notes, and no Overdub mode: impulses always merge, other values are always held by the pass that last moved them. It has no Grace either: a recording starts with the value held, which is what a value played just before it is. + +## Capacity + +A loop holds up to 8192 values, whatever their type. When it is full, the view says so and further values are not recorded. Numbers, booleans, vectors and impulses take no other memory; text, lists and maps take what they hold.