From f40af6f0cb3dc1f1cb5ea433119539ee42afa83f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?= Date: Sat, 24 Oct 2026 10:46:33 -0400 Subject: [PATCH 01/29] processes: audio looper layers, takes, capture and sync; MIDI looper Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Qr9WkcUjEGCueg7eG1KxSr --- .../reference/processes/audio_looper.png | Bin 7430 -> 22031 bytes .../reference/processes/midi_looper.png | Bin 0 -> 19230 bytes .../processes/library/audio_looper.md | 89 +++++++++++++++--- .../processes/library/midi_looper.md | 64 +++++++++++++ 4 files changed, 138 insertions(+), 15 deletions(-) create mode 100644 assets/images/reference/processes/midi_looper.png create mode 100644 docs/reference-manual/processes/library/midi_looper.md diff --git a/assets/images/reference/processes/audio_looper.png b/assets/images/reference/processes/audio_looper.png index 7404bd2710e9bb5f2f3a5fbb5122cad00175e7ed..e36a52d3f8dd6102f212085a00bbd4665b534936 100644 GIT binary patch literal 22031 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 p63&uOkca<&!e{?Sgl^*z1m*b@CSB{{ux0co+Zx diff --git a/assets/images/reference/processes/midi_looper.png b/assets/images/reference/processes/midi_looper.png new file mode 100644 index 0000000000000000000000000000000000000000..6b6fa689cbe60eda801f0d486d7ce65c00ee0982 GIT binary patch literal 19230 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

9jjMX;t&TTi3BEZfLj%YPvbS z9HR=2yvc;51c!#D1yN74p?GLSf{}R6%d*ZOZ8d)c%E+RkqLvokxWOEY#L?YZI#K17 z@1GN7c69our)ye6^V{T)KP$2fr~b~Q#5I4Rw%*Na>^S_4med(24N?kkj;Ux?2OS=1 zJpQ{_*E*Zi@6yomGj2Dws(F*F6?Iv1dB#nyd(Mp?aoCyxsaT{|DkCX*fAV;GxWv!J z_0VQL+qzgk4k9N2Qj4a=L`4Gv18rAp!$|u zE3ofhe0&ytp2p|q?z;G2fe0lp6wW) zoa%aKVrmL&I=?mBZ@$Ze9p~_mp|a9>FVr{H)wQtDNR>wo6pA$T;_tsZ6R(ZGK zPv61KP5)l7XxgGi_2UW;enhW19}Q)Q%>#=%I{HOONXSh1`w7bg#ZQ3go*8i#eBZOO ztVUCo&tTO7uj?4lAwY~ysp!3i{ar4*h;m%@s>`z5`kMztx@vSsK`iB^;IKr1_gQ3G z8hu&bBaw8e0uV>yEI@rj+4r*sqPui%dJ_pn6(Cl7cesizmn4NM7!0p}+XO@{5DSbN zhKuS00EikGgnIiXt+(^T4`Rt0F=Lp^>00=hzO%1w|D6KQFV?D1YPp~^`Od zx7zY_{6V|&h4#OJ@IZJA79=nWtEM$Z z2oJHh@K3blO#SY_U~v@=X9arIr`)~2`wguG7Mm8n$=b8|q7;Nq{G44QGxG24oZ zRJ#g+8}o?SD9_4?G*_sb1QJ|3SFaumo8^-~kXW6bn=9cKqnxlrUAshdB` ziR`b&d5mOyKXYM~Jd5rg|Mb4(G9>QUP}-m7c6KDwVh)0V|Lcra`}|2WL#T{jzWIgc ze1r{8$YOxOW`XkLnZ<1M!sE{uHbzD)Mx(BN!^?K&-?>}EWG|{u*@pO0Y z#m5iOJRN(6piV56{h|3P7$OP^ip0!^o8wRhm5rl#hDIU74O$gIhck>dfOn3I!}IIS@~Jw3)^5ujnC`y=Jf zlPZ_Dd3i4%Gu}haz@VU@*)ynKx|cV&?RZTCt{Kz<*}gmKS>ME7kqx$hK$8sYtqz3T zgvG>TW46sf!}t0~7~QbU-qs@7(Y!RgZxMLkLS-wc2%;7vB2k>o&Mrrkx5l;?k{o2z z<3l5_oM?(}icg=wwE@~Dm4iZ*tw0Hyeq21_ znjnFl9ek&omyeazLFuY*T)zoEKK?&Oqfg)GnU$G2dYS)dXIS6&k(QP9+Ezs+44z%5 z6BIfCauW`MFId@FKcPc|xgp>k%BJK}5rZ$Ty2cIbi>X#!< zarC%xY`lqsu@sSoe(b8+bb4_mSoD(dX-3&lB|nyhLf)iU3lEQnJBQ5+xKA)dK%=Zr zKmh*vj{&bihlP@4l#!JM50e#JR@1!!5TLS?tUU&U=&&VfNii`~gR|>*@s}Kj@&< z#sDPh*#3>pP2tWC7*J`~AVg>h0>X=jmls%NzLg39~cB2YYyl{18iZ32b);bBr- zoa_BS>_Tuj0Y82(19k=oEivj7{5=2T9`LwKekv6d^Zw;#rTTi-Ia3NE9cAT=j7aY~6{2BdFU(`@H?VoNoIfL~)wxoen66HTcB#bs%PB5{Qa`)N=0Sm!BwbXygNR(%jbw*?Piny#nWcg zTy{JLpp-}Yf?KSisrg)CJ_`E1m#57L)*|(!1l3Xq6@Gn!G}jfMCQZpbf{l}tR+nLH z6F1OfGke70Fx zqS%qKiJ$8*+8&72_r0DD{D?DCY+FU8v&cG1E4EgzR-{@q4LF?!clRRo5^N?n2BDwN zZGL{8^xQ5_-gjrEDcs`WpW5-6zzhp-lPhTA{*I2WTg)Jq2m1hLDn*#ti)y= zW3ziVVl4#0nAlj^G)Ck55Ok&l8z8&g8pecDs5ET`5F=cIh4vPJDcPvcC>se%x(E%iDqpfc7AQRsa|B z+b#w!NIY&gu+r(a{@T22e+OOrd}j;-R;gYKm(iAlzXH%TAPEU&l;`JL+$3`*vDxX> z+Y<@p1E~@iP10{M8;(-fmz9#TIz4&=@r~$4)8QgV%|?;<7u`@7Z|cOyw8H0mT|+Y= z)uql-yP!=Dz=j=SF`LPxvILX%cY=2NWQo(0yNT6$mWzvH2{dvS+k>5fAGsZ#?f{U$ z_GM)#^-X8FzRM9(Xt!j4KhQtd$dD&78ux&f_}=RU^YxLSN?7zZZ_sPRDurmEft zG~f$76s%D*Wq)Op*hf9?x2cqKDbYgGd|vKBoH`=ZG9-h7y zF%|CvRNJ!W%@|9Ge!f36B7oI^dv|U-`jN}zm;S!#lMKsdW@av;DYwhnrcsk1jRF8h z>-kR75fONLC70OKnxg>$0fXwr_Rh{vTbmJ^s3?w(@$QMVw6vkrZJ*~KU%*wJK1ui9qM}SuYQPE%7QTH7#Ls}DmO-g7-M&PdwR~o#70Lqhc!fJlU7B)062Kb z`o>1)v;{0I99781^{{N0sW>5@^3zePRBxRYCp+vM@v`dCPFL7f+Vps&x(VWIjS z4#VbdCn+il1*m=d`XmZe5|iREac~ZI4m@~CyCxwcpAZ| z_LSy72zB*zTh=U8UtL+xmT7|#HaV!ycvlr=G&D3IU{rgpH@~&L0k>e;X_xUJwOs0M z`w>hly?WnoXZS(udtR&FB+NFftx-i&=r=g#j64I_4F?(de7Ps=@%H!-OdUdRfh^K^ zW04Lj-EZF@DgpvhO1^+!O-@WoMlCg)4w@g%jwbLn3DLP0ZUJh}yKgTqO-@E8nc4Lu zGE01ZvFrOgXf18+OE;cK3DW3(D*`3%*oC?zJoruq+}?!lihHlbOe-|0G@k$!Ux(TZ zY{^4)1Mmc8WQICKLvu&tD=f~9QsmURr5|SVM?BcT?gPjekh*~Jx`6?sQ3VYZlN?O> za`o?oFgH-)n>BE@mX?}2I!iGq-OFuuL>SPJkSrB_tSds-v5mTyOW2^Y1N~SkpK(tJ z`w9#qqWP+drKKg%Di3X>OG+L^EBKEsxnIs?+&ZvY0PSb%HP^?6gx`Rvw zW+dn4=5A+8!7S(taPE0wAz@+lGCl9THNhOE2G`YAz{x(`-+R|NWGPTCRen7LsB$4< z!3mKfckBU$NQ#hn6lkGARs|Ar(Bjk{FH%KK(Z{@u0GJtg<^lbPnxl)08G#Uyzgmgj z^9lE<3Pp}eZ&jx+EwFjt`uW;}mkF-xS#QO8D+7PJXx*=2A^|JzZ* zi!?Z3U~+kZN|6KNSkUD(is{lvT|P6&q*57x)Bj{!e3Vpwq>g!52ia*DlfmTQw#YbI z?rJ;66=iB_>a=&V^{4-h41(FX`It+1Y!3UazR2V8wtCG*omBS!YOw{IEf;TUf-A;# z!U%0vx?lh5vE~~&%x`q<*>Ux=6vBfWp{T7er$^17AWPJ;rq!-D^uqNgLse!5$>mx~ZF~k^zh35XZKj<1b`9zRG zsr4$%JEpX9gdrm8uN$fNvEm2uc9O=%#+N-iyI&AlWPxS}$8BXn zH1X5_xHD%u7&UArhXS)Jnd1O{cdT=NC;E$qdu;#mXnsaPBk0u`^-hAYSk|rPnqXV~ zzjVW0=K1br>krx&a_n~ahQ_BvJ$imxPJuJl-uUqA@FlanQid?;_zQsZyWW5skB>{B zA9QMpr|)~r7($x)3zc};wYS4rZ>XA?+xQsY z1xX0x?Knj&Gx!+BKLxC#H;pFMniD0)vHOoX$x~rO(1%K4OvPzy!!5^Tgdn;|Kk2fR z$^G_jtXrPlvR-^U;-0HRPQk}dNLQd!P&gSndG=%Ld2~kAv^|4#g*{F0+ z#%(|!p(?3p;iR#a(|h*|Jok%~+CjzLt^faHqk*E)3!e+Wh2cZoma5=2m(+yXaMb1w z>}X#})rEQAS^o3q&!d5_-bn##_H&|oR}KdY`4Ll$o$@26JJYELezCeDCYX%MQ`tLC zq`C4#cPr%B_48j?>^=qd@a6FMiko~9n~qytDP8y(^dy9JuK(*Sc6Y!XS4)|btv(iP zt}u+TiC-QkRAi!A>4G8rbn#0vNY%LG&)Y>^1npCuLxFsQ z|D#GAE~cn*l&DaG|EXFYh7$6`!y2*h>0+gNf8pb${Z>#=U@*I~0293cj9RqRTp4}DXq;3IKInS*_<(k3qdOD~8F4YE zt7R4keO$)%T(C~_mb$-x!+2o-aVso$Jjj!@H9WCE82x&CMnmEcReYxLJ@^hi#4g z{!8KQ0(YI*onVMT6%kr|{h3)=5_Ln&lb>>dI29SA;#E?~B{jFsdv$ei;X&AG4a3EG zw2VZU@Bbv=DC;0_q1&RNs88qr%Yj;tJPLUUO)@tGkL_BeBFuc#a*rbH4lsendmb!! zYr|f|o*V}K^I=P0xi~nob91R-8KGHYxnvBkUK8<)VR1hkQ?v({lELA#*?P+^Bh$VQuMRo zGsg9QY;hGjUQ(m{fJ%faYxIc;d1594B7&Z%7 zTS?fWB1;G;G0GMPgb0KsXcPsaP!S_V3t(EHF;zB^^%feb$@r7iRm)P3 zm#Ceo#({%HDG|opd-p(_0ZzHFs0iR-bANv8@dxzE%6=r~-%xM7n`Px5d_*w4lZ0vt zhyYLcpN1S7kCKs)1reC=T+$0T&vZx-LB{@=(=yVR8OzJIY|IIJb};|i&0EiBW@^so z$YKqwb+7hm#Y}2f$%IK`cunKgA7}?Yj999+y-?-fydbs`_v@m}>hG{778I4^1c&wn z#Swhb#2)BD(H0-(iB?hFmh zZM8)96+E-3b{a5tAk;b68d%0eeyR^tW)cg{!Dwt{p1EBa*kPliorZx#qEs#~EG-qx zyL+LunpaoBMLvGeC#6#l=s;k+w?MI5l7R$wel$*}HZ_y8d$)EC7?~+*TaXi0R3~Q$_xyx(t?92! zCjKPev1@R4Mk&pIaLT{9q^kP#bIo%dt_3$l?+KAEYpkJN#`M*yhIbVQKurSk#0e1N z4R2|-#UC7=%bEqg0myw%19FLw5aVUZ! zIzG>FVKyRKMXCCBow8#)%jdhxL`7>d-v?%>SjhA5jbl6ua^QrM?y_H9xrOznFZs4J z{Q~yeHs&xee&=@-3~vHanS98H=GqHI=!%2seR7_>V!h`QrX zDEASkQP-pq(J9xDdc*U@Bl6Gyr$zpzTb%;l>W1BVe7pE0r(Jkm9xVr#ICKCmtNAHS z40;w`UyM?NWb?q6`!>D2&n&dZ8h5q0rIZZx7dx8Wa-JUPt*@o2i+ls9I6!14uJgbD zbQmDimq6bR51H70vr`Zlf0$IPRy$W_h_j7xSufy`m1edhhWvt>LlI^GEpFqpM!%57 ze?a1Iy2{YNJ}TjZ7Tc?&Btx)i4&ptuuNi)*`jRWU3WKmlzw9LGqcS?Ywd2^07leyn zzHYs|N5ey7CSMcu|LnLQvi>idTLyI$W$L{E{r!AMrc|S?lJww5;I&RS!ZM1LC>TJH zLqkE#Frt%*STE;D_`8S!q5gLU`=zO2pdI^4y8AguNDZBG11xCo;R#F;)ku9`qN6Ip zDYv>FNj)2V_YsiY^9`Z0ZQIQ*Mx&wK%GeT)r5_V)CzPmZpkJrF5ti#&?P(gAZwh`k zu&-K8i<&C+hJO$UetuW(`l7eHl{M)P23u#->%O%Wlo}L-EdoyyQ!6TnHTLEf5Kq;I z=`iC-4xN026aM^oPu=xg!c!efE$=g@N1%k4d#48|6?eN{z#!TN2Qo*b5_;!By0 zg>Xl8_0r19A;=v7T2F;|%V7ouUOA0`tWvn#uf4UPvi9}0OTJA3^<+-iLO0kH2=Y8Q f76oslPvx%~#nsGXwyu;1t}nYec^u;4DM^0-@oNG+ literal 0 HcmV?d00001 diff --git a/docs/reference-manual/processes/library/audio_looper.md b/docs/reference-manual/processes/library/audio_looper.md index 893b5eaa..f3bda9e4 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,86 @@ 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. -## Play +## Modes -Play what the looper recorded. +**Loop** chooses what the looper does: -## Recording +| Mode | Behavior | +|---|---| +| **Play** | Plays the loop. | +| **Record** | Records a new loop, replacing the current one and all its layers. | +| **Overdub** | Records a new layer on top of the loop while it plays. | +| **Stop** | Outputs no loop. The loop is kept. | -Record the actual sound the looper is going to loop to. +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. -## Overdub +## Timing -Record on top of the already recorded sound. +**Quantif** makes a mode change wait for the next point of a grid, so that a loop starts and ends in time. Whole is a bar; None changes at once. See [quantization]({{ site.baseurl }}/in-depth/musical.html#quantization). -## Stop +**Bars** and **Post-action** make a recording end on its own: after Bars bars, recording gives way to the post-action, Play or Overdub. With Bars at 0, a recording lasts until the mode is changed by hand. -Output nothing. \ No newline at end of file +**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. The default is 120 ms; 0 turns it off. + +**Restart** chooses where playback starts after a mode change: from the beginning of the loop (Always), or, except after a recording, from where it was (Recording). + +## 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. 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. + +**Max layers** is the number of passes kept apart. When it is reached, the two oldest passes are merged into one, and that undo step is lost. + +## 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. **Send** in the view, or the **Send to timeline** control, 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 from the looper's view into the timeline, or anywhere a sound file can be dropped. + +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...** sets aside the takes in the score's folder that it no longer uses. + +## Capture + +**Capture** makes a loop out of what was just played, even when the looper was not recording. It takes the last **Capture bars** bars of the input and plays them at once, ending on the last grid point when that was just passed, like a late stop. + +Capture needs **Keep last (s)**, the number of seconds of input the looper keeps at all times. It is 0 by default, which keeps nothing and uses no memory. + +## Sync groups + +**Sync** puts loopers in a group, A to D. The first looper of a group to record sets the group's loop. The loops recorded after it are rounded to a whole number of that loop, or to a half, a quarter or an eighth of it, and play in phase with it. Clearing the looper that set the loop frees the group. + +## Monitoring + +**Passthrough** chooses when the input is heard: + +| Choice | Behavior | +|---|---| +| **None** | The input is never heard. | +| **Record** | 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, and the post-action takes over; 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. + +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. + +## 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 made before the layers keep their looper and its settings. Their Loop, Quantif, Passthrough, Post-action, Bars and Restart behave as before. 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..80057657 --- /dev/null +++ b/docs/reference-manual/processes/library/midi_looper.md @@ -0,0 +1,64 @@ +--- +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, sync groups, capture and timeline features with the [audio looper]({{ site.baseurl }}/processes/audio-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. + +## Passes and overdubs + +Each recording or overdub is a pass. **Undo** hides the last pass, **Redo** shows it again, **Clear** forgets everything. + +**Overdub** 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. + +## 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. + +A note held on the input is never sent twice when the loop plays the same note. + +## Quantize + +**Grid** and **Quantize** pull the notes towards a grid when they are played back. At a Quantize of 0 the notes play as recorded; at 1 they play on the grid. **Quantize ends** pulls the ends of the notes too. + +## 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 or clearing ends the notes the loop was playing. + +## 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 120 BPM so that a quarter note is half a second of score's time, and ending exactly at the end of the loop. **Send**, **Send to timeline**, or a drag from the view places it in the timeline as a MIDI clip that holds the notes, where the take was recorded. The file can also be opened in any other MIDI editor. + +## Capture + +**Capture** makes a loop out of the last **Capture bars** bars played, recorded or not, and plays it at once. The MIDI looper always keeps the last few thousand events it received, so there is nothing to set up. + +## 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. From 9693efbd26fc63fa8327c31fa71ef239b1a44b39 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?= Date: Sat, 24 Oct 2026 10:58:44 -0400 Subject: [PATCH 02/29] audio looper: engine latency Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Qr9WkcUjEGCueg7eG1KxSr --- docs/reference-manual/processes/library/audio_looper.md | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/reference-manual/processes/library/audio_looper.md b/docs/reference-manual/processes/library/audio_looper.md index f3bda9e4..0bccc5f6 100644 --- a/docs/reference-manual/processes/library/audio_looper.md +++ b/docs/reference-manual/processes/library/audio_looper.md @@ -84,6 +84,7 @@ Capture needs **Keep last (s)**, the number of seconds of input the looper keeps - **Max length (s)**, default 60, is the longest loop. A recording that reaches it ends, and the post-action takes over; 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. From ae9d11bdc2ef6b4f7cacd7399394d1e57eeeb54c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?= Date: Sat, 24 Oct 2026 11:44:57 -0400 Subject: [PATCH 03/29] audio looper: loading a file Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Qr9WkcUjEGCueg7eG1KxSr --- docs/reference-manual/processes/library/audio_looper.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/docs/reference-manual/processes/library/audio_looper.md b/docs/reference-manual/processes/library/audio_looper.md index 0bccc5f6..918b846d 100644 --- a/docs/reference-manual/processes/library/audio_looper.md +++ b/docs/reference-manual/processes/library/audio_looper.md @@ -49,7 +49,7 @@ Each overdub pass is a layer of its own. The view shows one lane per layer. - **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. -**Max layers** is the number of passes kept apart. When it is reached, the two oldest passes are merged into one, and that undo step is lost. +**Max layers**, 2 to 32, is the number of passes kept apart. When it is reached, the two oldest passes are merged into one, and that undo step is lost. ## Takes and the timeline @@ -59,6 +59,10 @@ The take can also be dragged from the looper's view into the timeline, or anywhe 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...** sets aside the takes in the score's folder that it no longer uses. +## Loading a file + +Dropping a sound file on the looper, or choosing it in **Loop file**, replaces the loop with it, up to Max length, and plays it. A file at another sample rate is converted. A mono file goes to every channel. + ## Capture **Capture** makes a loop out of what was just played, even when the looper was not recording. It takes the last **Capture bars** bars of the input and plays them at once, ending on the last grid point when that was just passed, like a late stop. From 015e557eab5a165cdecaa71a9516d80520ed2b74 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?= Date: Sat, 24 Oct 2026 13:56:26 -0400 Subject: [PATCH 04/29] loopers: takes as layers, overdub on an empty loop, tempo changes Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Qr9WkcUjEGCueg7eG1KxSr --- docs/reference-manual/processes/library/audio_looper.md | 8 +++++++- docs/reference-manual/processes/library/midi_looper.md | 8 +++++++- 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/docs/reference-manual/processes/library/audio_looper.md b/docs/reference-manual/processes/library/audio_looper.md index 918b846d..5b489e6d 100644 --- a/docs/reference-manual/processes/library/audio_looper.md +++ b/docs/reference-manual/processes/library/audio_looper.md @@ -25,7 +25,7 @@ The [MIDI looper]({{ site.baseurl }}/processes/midi-looper.html) works the same |---|---| | **Play** | Plays the loop. | | **Record** | Records a new loop, replacing the current one and all its layers. | -| **Overdub** | Records a new layer on top of the loop while it plays. | +| **Overdub** | Records a new layer on top of the loop while it plays. On an empty loop, records the loop first: until the mode changes, or for Bars bars after which overdubbing starts. | | **Stop** | Outputs no loop. The loop is kept. | 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. @@ -57,6 +57,8 @@ When a recording or an overdub ends, the loop is written to a WAV file: 32-bit f The take can also be dragged from the looper's view into the timeline, or anywhere a sound file can be dropped. +**Takes** chooses what a take is written as: **Mix**, 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 or dragging a take places every one of its files, each on a lane of its own. + 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...** sets aside the takes in the score's folder that it no longer uses. ## Loading a file @@ -92,6 +94,10 @@ Capture needs **Keep last (s)**, the number of seconds of input the looper keeps 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 + +A loop keeps the speed it was recorded at: after a tempo change it plays as before, and no longer falls on the bars. Mode changes and the post-action follow the new tempo. 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. + ## Outputs **Phase** goes from 0 to 1 as the loop plays, to drive anything that should follow the loop, such as video. diff --git a/docs/reference-manual/processes/library/midi_looper.md b/docs/reference-manual/processes/library/midi_looper.md index 80057657..d5702579 100644 --- a/docs/reference-manual/processes/library/midi_looper.md +++ b/docs/reference-manual/processes/library/midi_looper.md @@ -51,9 +51,15 @@ A note held on the input is never sent twice when the loop plays the same note. Changing the transposition or the output channel, stopping, undoing or clearing ends the notes the loop was playing. +Overdubbing an empty loop records it, as with the audio looper. + +## Tempo changes + +A loop keeps the speed and the beats it was recorded at: after a tempo change, the quantize grid stays on the loop's own beats, and its takes have its own tempo. + ## 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 120 BPM so that a quarter note is half a second of score's time, and ending exactly at the end of the loop. **Send**, **Send to timeline**, or a drag from the view places it in the timeline as a MIDI clip that holds the notes, where the take was recorded. The file can also be opened in any other MIDI editor. +When a recording or an overdub ends, what is heard of the loop is written to a Standard MIDI File, at 120 BPM so that a quarter note is half a second of score's time, and ending exactly at the end of the loop. **Send**, **Send to timeline**, or a drag from the view places it in the timeline as a MIDI clip that holds the notes, where the take was recorded. The file can also be opened in any other MIDI editor. **Takes** writes what is heard of the whole loop (**Mix**), each pass in a file of its own (**Layers**), or both; each file becomes a clip on a lane of its own. ## Capture From 41852763224abb6728525b0cbca96f772279b905 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?= Date: Sat, 24 Oct 2026 14:26:35 -0400 Subject: [PATCH 05/29] loopers: extending overdubs, MIDI follow tempo, free-length recording Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Qr9WkcUjEGCueg7eG1KxSr --- docs/reference-manual/processes/library/audio_looper.md | 4 +++- docs/reference-manual/processes/library/midi_looper.md | 4 +++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/docs/reference-manual/processes/library/audio_looper.md b/docs/reference-manual/processes/library/audio_looper.md index 5b489e6d..b4ada210 100644 --- a/docs/reference-manual/processes/library/audio_looper.md +++ b/docs/reference-manual/processes/library/audio_looper.md @@ -34,7 +34,7 @@ Every control is a port with an address, so the looper can be driven by OSC, MID **Quantif** makes a mode change wait for the next point of a grid, so that a loop starts and ends in time. Whole is a bar; None changes at once. See [quantization]({{ site.baseurl }}/in-depth/musical.html#quantization). -**Bars** and **Post-action** make a recording end on its own: after Bars bars, recording gives way to the post-action, Play or Overdub. With Bars at 0, a recording lasts until the mode is changed by hand. +**Bars** and **Post-action** make a recording end on its own: after Bars bars, recording gives way to the post-action, Play or Overdub. With 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. The default is 120 ms; 0 turns it off. @@ -49,6 +49,8 @@ Each overdub pass is a layer of its own. The view shows one lane per layer. - **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 passes kept apart. When it is reached, the two oldest passes are merged into one, and that undo step is lost. ## Takes and the timeline diff --git a/docs/reference-manual/processes/library/midi_looper.md b/docs/reference-manual/processes/library/midi_looper.md index d5702579..7b836a94 100644 --- a/docs/reference-manual/processes/library/midi_looper.md +++ b/docs/reference-manual/processes/library/midi_looper.md @@ -55,7 +55,9 @@ Overdubbing an empty loop records it, as with the audio looper. ## Tempo changes -A loop keeps the speed and the beats it was recorded at: after a tempo change, the quantize grid stays on the loop's own beats, and its takes have its own tempo. +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 From dd000582d5846ae7fc302ae437b9ce4f59023a26 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?= Date: Sat, 24 Oct 2026 14:50:28 -0400 Subject: [PATCH 06/29] audio looper: follow tempo Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Qr9WkcUjEGCueg7eG1KxSr --- .../reference-manual/processes/library/audio_looper.md | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/docs/reference-manual/processes/library/audio_looper.md b/docs/reference-manual/processes/library/audio_looper.md index b4ada210..5238a4b2 100644 --- a/docs/reference-manual/processes/library/audio_looper.md +++ b/docs/reference-manual/processes/library/audio_looper.md @@ -98,7 +98,15 @@ The memory for these is reserved when playback starts, so changes to Max length, ## Tempo changes -A loop keeps the speed it was recorded at: after a tempo change it plays as before, and no longer falls on the bars. Mode changes and the post-action follow the new tempo. 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. +**Follow tempo** 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. | + +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 post-action 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. ## Outputs From 5082de54768714fef1e5e3f2737e9f7c485baa6b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?= Date: Sat, 24 Oct 2026 18:58:15 -0400 Subject: [PATCH 07/29] midi filter and sync: note-offs follow their notes, first clock with Start Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Qr9WkcUjEGCueg7eG1KxSr --- docs/reference-manual/processes/library/midi-filter.md | 4 ++++ docs/reference-manual/processes/library/midi-sync.md | 2 ++ 2 files changed, 6 insertions(+) diff --git a/docs/reference-manual/processes/library/midi-filter.md b/docs/reference-manual/processes/library/midi-filter.md index 8c4a2cc2..49754e6d 100644 --- a/docs/reference-manual/processes/library/midi-filter.md +++ b/docs/reference-manual/processes/library/midi-filter.md @@ -34,6 +34,10 @@ routing. The running-note collection is indexed by pitch rather than by channel/pitch, so identical pitches from multiple channels are not tracked independently. +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 diff --git a/docs/reference-manual/processes/library/midi-sync.md b/docs/reference-manual/processes/library/midi-sync.md index 93605a66..336dac6a 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 From c0cfa66dd37d51a3c2ed2700df3cae0bf62e7e62 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?= Date: Sat, 24 Oct 2026 19:32:42 -0400 Subject: [PATCH 08/29] midi sync: what a seek or a loop sends Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Qr9WkcUjEGCueg7eG1KxSr --- .../reference-manual/processes/library/midi-sync.md | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/docs/reference-manual/processes/library/midi-sync.md b/docs/reference-manual/processes/library/midi-sync.md index 336dac6a..dfe16e8a 100644 --- a/docs/reference-manual/processes/library/midi-sync.md +++ b/docs/reference-manual/processes/library/midi-sync.md @@ -47,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 From 07fd206e80f3d1fe3f59ab438097ebe6717761ec Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?= Date: Sat, 24 Oct 2026 20:38:03 -0400 Subject: [PATCH 09/29] loopers: MIDI layers view, erasing a pass Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Qr9WkcUjEGCueg7eG1KxSr --- .../processes/library/audio_looper.md | 11 +++++++++++ .../processes/library/midi_looper.md | 12 +++++++++++- 2 files changed, 22 insertions(+), 1 deletion(-) diff --git a/docs/reference-manual/processes/library/audio_looper.md b/docs/reference-manual/processes/library/audio_looper.md index 5238a4b2..6e20b594 100644 --- a/docs/reference-manual/processes/library/audio_looper.md +++ b/docs/reference-manual/processes/library/audio_looper.md @@ -53,6 +53,17 @@ Each overdub pass is a layer of its own. The view shows one lane per layer. **Max layers**, 2 to 32, is the number of passes kept apart. When it is reached, the two oldest passes are merged into one, and that undo step is 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. The view shows up to eight lanes; with more passes than that, the oldest share the first lane, which has no **x**. +- with **Layer** and **Erase layer**: Layer says which pass, counting from the oldest one, and Erase layer erases it. 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. **Send** in the view, or the **Send to timeline** control, 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. diff --git a/docs/reference-manual/processes/library/midi_looper.md b/docs/reference-manual/processes/library/midi_looper.md index 7b836a94..e9919a9b 100644 --- a/docs/reference-manual/processes/library/midi_looper.md +++ b/docs/reference-manual/processes/library/midi_looper.md @@ -30,6 +30,16 @@ Each recording or overdub is a pass. **Undo** hides the last pass, **Redo** show 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. +## The view + +The view shows one lane per pass, as the audio looper does: up to eight lanes, the oldest passes sharing the first lane when there are more. 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**. 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 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. @@ -49,7 +59,7 @@ A note held on the input is never sent twice when the loop plays the same note. - **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 or clearing ends the notes the loop was playing. +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. From 54b01ed9da7fb104288672b660946568daa5a861 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?= Date: Sat, 24 Oct 2026 21:03:11 -0400 Subject: [PATCH 10/29] loopers: a take goes in one box Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Qr9WkcUjEGCueg7eG1KxSr --- docs/reference-manual/processes/library/audio_looper.md | 2 +- docs/reference-manual/processes/library/midi_looper.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/reference-manual/processes/library/audio_looper.md b/docs/reference-manual/processes/library/audio_looper.md index 6e20b594..0f0ec6ec 100644 --- a/docs/reference-manual/processes/library/audio_looper.md +++ b/docs/reference-manual/processes/library/audio_looper.md @@ -70,7 +70,7 @@ When a recording or an overdub ends, the loop is written to a WAV file: 32-bit f The take can also be dragged from the looper's view into the timeline, or anywhere a sound file can be dropped. -**Takes** chooses what a take is written as: **Mix**, 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 or dragging a take places every one of its files, each on a lane of its own. +**Takes** chooses what a take is written as: **Mix**, 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 all its files in one box named after the take, a slot each, the mix first; dragging it drops them all. 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...** sets aside the takes in the score's folder that it no longer uses. diff --git a/docs/reference-manual/processes/library/midi_looper.md b/docs/reference-manual/processes/library/midi_looper.md index e9919a9b..4cdc0859 100644 --- a/docs/reference-manual/processes/library/midi_looper.md +++ b/docs/reference-manual/processes/library/midi_looper.md @@ -71,7 +71,7 @@ With **Follow tempo**, on by default, the loop plays at the tempo of the score: ## 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 120 BPM so that a quarter note is half a second of score's time, and ending exactly at the end of the loop. **Send**, **Send to timeline**, or a drag from the view places it in the timeline as a MIDI clip that holds the notes, where the take was recorded. The file can also be opened in any other MIDI editor. **Takes** writes what is heard of the whole loop (**Mix**), each pass in a file of its own (**Layers**), or both; each file becomes a clip on a lane of its own. +When a recording or an overdub ends, what is heard of the loop is written to a Standard MIDI File, at 120 BPM so that a quarter note is half a second of score's time, and ending exactly at the end of the loop. **Send**, **Send to timeline**, or a drag from the view places it in the timeline as a MIDI clip that holds the notes, where the take was recorded. The file can also be opened in any other MIDI editor. **Takes** writes what is heard of the whole loop (**Mix**), each pass in a file of its own (**Layers**), or both; the files go in one box, a looping clip each, the mix first. ## Capture From 0b57401a14f1ac1e6b0dbc2c77d1efd9312041a9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?= Date: Sat, 24 Oct 2026 23:05:15 -0400 Subject: [PATCH 11/29] loopers: reverse and speed, comping, restart in phase Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Qr9WkcUjEGCueg7eG1KxSr --- .../processes/library/audio_looper.md | 44 ++++++++++++++++++- .../processes/library/midi_looper.md | 23 +++++++++- 2 files changed, 64 insertions(+), 3 deletions(-) diff --git a/docs/reference-manual/processes/library/audio_looper.md b/docs/reference-manual/processes/library/audio_looper.md index 0f0ec6ec..39b30eb4 100644 --- a/docs/reference-manual/processes/library/audio_looper.md +++ b/docs/reference-manual/processes/library/audio_looper.md @@ -38,7 +38,7 @@ Every control is a port with an address, so the looper can be driven by OSC, MID **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. The default is 120 ms; 0 turns it off. -**Restart** chooses where playback starts after a mode change: from the beginning of the loop (Always), or, except after a recording, from where it was (Recording). +**Restart** chooses where playback starts after a mode change: from the beginning of the loop (Always), or, except after a recording, from where it was (Recording). **In phase** keeps the loop on the timeline, see [Restart In phase](#restart-in-phase). ## Layers @@ -58,7 +58,7 @@ Each overdub pass is a layer of its own. The view shows one lane per layer. 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. The view shows up to eight lanes; with more passes than that, the oldest share the first lane, which has no **x**. -- with **Layer** and **Erase layer**: Layer says which pass, counting from the oldest one, and Erase layer erases it. 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. +- with **Layer** and **Erase layer**: Layer says which pass, counting from the oldest one, and Erase layer erases it. **Mute layer** mutes it instead, see [Comping](#comping). 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. @@ -119,6 +119,46 @@ The memory for these is reserved when playback starts, so changes to Max length, 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 post-action 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 Play 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: Quantif, Bars and the post-action, Late stop and sync groups 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 + +**Passes**, in the Comp tab, is for keeping the best of several rounds of an overdub: + +| Choice | Behavior | +|---|---| +| **Whole** (default) | An overdub is one pass, from when it starts to when it stops. | +| **Per cycle** | An overdub that goes round the loop several times makes a pass of each round, each starting at the start of the loop. | + +A pass per cycle is a pass like any other: it has its own lane, and can be undone or erased on its own. Rounds follow each other without a fade, so all of them together sound as one long overdub would, Feedback included. An overdub that goes round after a recording, with the post-action Overdub or when Overdub was asked on an empty loop, makes a pass per round as well. + +To keep the best round, mute the others: the **m** left of the **x** of a lane mutes its pass, and pressing it again unmutes it. **Mute layer**, in the Comp tab, does the same for the pass **Layer** says, from a port. A muted pass is kept but not heard, as if it were erased: it takes nothing from the passes under it with its feedback, and it is drawn dimmed. Muted passes are left out of the mix of a take; a take written as layers still has a file for every pass, the muted ones included, as they would be heard, so that the rounds can be spliced in the timeline. + +When the two oldest passes are merged to make room, past **Max layers**, a muted one is left out of the merged pass, and lost. + +## Restart In phase + +With **Restart** set to **In phase**, the loop stays in phase with the timeline. Playing and overdubbing carry on from where they were, as with Recording; 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. + ## Outputs **Phase** goes from 0 to 1 as the loop plays, to drive anything that should follow the loop, such as video. diff --git a/docs/reference-manual/processes/library/midi_looper.md b/docs/reference-manual/processes/library/midi_looper.md index 4cdc0859..70e888a6 100644 --- a/docs/reference-manual/processes/library/midi_looper.md +++ b/docs/reference-manual/processes/library/midi_looper.md @@ -19,7 +19,7 @@ The recording keeps its own timing: quantize, transpose and channel changes only ## Passes and overdubs -Each recording or overdub is a pass. **Undo** hides the last pass, **Redo** shows it again, **Clear** forgets everything. +Each recording or overdub is a pass. **Undo** hides the last pass, **Redo** shows it again, **Clear** forgets everything. **Restart** is in the Play tab, with Follow tempo. **Overdub** chooses what a pass does to the notes of the passes under it: @@ -73,6 +73,27 @@ With **Follow tempo**, on by default, the loop plays at the tempo of the score: When a recording or an overdub ends, what is heard of the loop is written to a Standard MIDI File, at 120 BPM so that a quarter note is half a second of score's time, and ending exactly at the end of the loop. **Send**, **Send to timeline**, or a drag from the view places it in the timeline as a MIDI clip that holds the notes, where the take was recorded. The file can also be opened in any other MIDI editor. **Takes** writes what is heard of the whole loop (**Mix**), each pass in a file of its own (**Layers**), or both; the files go in one box, a looping clip each, the mix first. +## Reverse and speed + +**Reverse** and **Speed**, in the Play 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 + +**Passes**, in the Comp tab, makes a pass of each round of an overdub with **Per cycle**, as for the [audio looper]({{ site.baseurl }}/processes/audio-looper.html#comping). A note held across the start of the loop belongs to the round it started in. + +The **m** of a lane, or **Mute layer** with **Layer**, mutes a pass: its 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 a later pass replaces them as well. Muted passes 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 pass is muted or unmuted. + +## Restart In phase + +**Restart** set to **In phase** keeps the loop in phase with the timeline, as for the [audio looper]({{ site.baseurl }}/processes/audio-looper.html#restart-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 **Capture** makes a loop out of the last **Capture bars** bars played, recorded or not, and plays it at once. The MIDI looper always keeps the last few thousand events it received, so there is nothing to set up. From 62760aef504a43dc8a05a8c421287be42756b66c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?= Date: Sun, 25 Oct 2026 11:52:14 -0400 Subject: [PATCH 12/29] loopers: late stop into an overdub; Send in the view only Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Qr9WkcUjEGCueg7eG1KxSr --- docs/reference-manual/processes/library/audio_looper.md | 4 ++-- docs/reference-manual/processes/library/midi_looper.md | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/reference-manual/processes/library/audio_looper.md b/docs/reference-manual/processes/library/audio_looper.md index 39b30eb4..34581baa 100644 --- a/docs/reference-manual/processes/library/audio_looper.md +++ b/docs/reference-manual/processes/library/audio_looper.md @@ -36,7 +36,7 @@ Every control is a port with an address, so the looper can be driven by OSC, MID **Bars** and **Post-action** make a recording end on its own: after Bars bars, recording gives way to the post-action, Play or Overdub. With 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. The default is 120 ms; 0 turns it off. +**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. **Restart** chooses where playback starts after a mode change: from the beginning of the loop (Always), or, except after a recording, from where it was (Recording). **In phase** keeps the loop on the timeline, see [Restart In phase](#restart-in-phase). @@ -66,7 +66,7 @@ Erasing the pass being overdubbed is the same as Undo: the pass is dropped and o ## 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. **Send** in the view, or the **Send to timeline** control, 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. +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. **Send** in 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 from the looper's view into the timeline, or anywhere a sound file can be dropped. diff --git a/docs/reference-manual/processes/library/midi_looper.md b/docs/reference-manual/processes/library/midi_looper.md index 70e888a6..676b98e1 100644 --- a/docs/reference-manual/processes/library/midi_looper.md +++ b/docs/reference-manual/processes/library/midi_looper.md @@ -44,7 +44,7 @@ What only the erased pass replaced is heard again. What a later pass replaced as **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. +**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. @@ -71,7 +71,7 @@ With **Follow tempo**, on by default, the loop plays at the tempo of the score: ## 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 120 BPM so that a quarter note is half a second of score's time, and ending exactly at the end of the loop. **Send**, **Send to timeline**, or a drag from the view places it in the timeline as a MIDI clip that holds the notes, where the take was recorded. The file can also be opened in any other MIDI editor. **Takes** writes what is heard of the whole loop (**Mix**), each pass in a file of its own (**Layers**), or both; the files go in one box, a looping clip each, the mix first. +When a recording or an overdub ends, what is heard of the loop is written to a Standard MIDI File, at 120 BPM so that a quarter note is half a second of score's time, and ending exactly at the end of the loop. **Send** in the looper's view, or a drag from it, places it in the timeline as a MIDI clip that holds the notes, where the take was recorded. The file can also be opened in any other MIDI editor. **Takes** writes what is heard of the whole loop (**Mix**), each pass in a file of its own (**Layers**), or both; the files go in one box, a looping clip each, the mix first. ## Reverse and speed From 7587c40cd10b29d9f921fb6425d03bc8fdbb7745 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?= Date: Sun, 25 Oct 2026 12:33:32 -0400 Subject: [PATCH 13/29] loopers: Comp mode and the Switches tab Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Qr9WkcUjEGCueg7eG1KxSr --- .../processes/library/audio_looper.md | 40 ++++++++++++++++++- .../processes/library/midi_looper.md | 10 ++++- 2 files changed, 46 insertions(+), 4 deletions(-) diff --git a/docs/reference-manual/processes/library/audio_looper.md b/docs/reference-manual/processes/library/audio_looper.md index 34581baa..283a6a83 100644 --- a/docs/reference-manual/processes/library/audio_looper.md +++ b/docs/reference-manual/processes/library/audio_looper.md @@ -27,6 +27,9 @@ The [MIDI looper]({{ site.baseurl }}/processes/midi-looper.html) works the same | **Record** | Records a new loop, replacing the current one and all its layers. | | **Overdub** | Records a new layer on top of the loop while it plays. On an empty loop, records the loop first: until the mode changes, or for Bars bars after which overdubbing starts. | | **Stop** | Outputs no loop. The loop is kept. | +| **Comp** | Overdubs as Overdub does, but taking it up always starts a new layer, even from Overdub. Leaving it ends the layer, as leaving Overdub does. See [Comping](#comping). | + +Loop always shows what the looper is asked to do: when an action of the Switches tab, the post-action or a full loop changes the mode, Loop changes with it. 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. @@ -40,6 +43,37 @@ Every control is a port with an address, so the looper can be driven by OSC, MID **Restart** chooses where playback starts after a mode change: from the beginning of the loop (Always), or, except after a recording, from where it was (Recording). **In phase** keeps the loop on the timeline, see [Restart In phase](#restart-in-phase). +## Footswitches + +Loop is a value: setting it to the mode it already has does nothing. A footswitch mapped to Loop can say "overdub" but not "overdub again in a new layer", "go back to the start" or "end this recording into the post-action". The **Switches** tab has actions for that: buttons that act each time they are pressed, made to be mapped to footswitches, MIDI notes or OSC messages. What they change waits for the next point of the grid, as a change of Loop does, and Late stop applies to them; the controls they change (Loop, 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 or comping, 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. | +| **Record** | Records a new loop, in place of the one there is, from any mode. While recording, ends the recording into what After record says. | +| **Overdub** | Overdubs, from any mode. Pressed while overdubbing, does nothing: the layer goes on. | +| **Comp next** | Ends the layer being overdubbed and starts a new one, without stopping. From Play or Stop, starts comping; while recording, ends the recording and starts the first layer over it. | +| **Play**, **Stop** | Play or stop, from any mode. | +| **Restart loop** | Goes back to the start of the loop and stays in the same mode. An overdub goes on from the start in the same layer; a recording starts again. | +| **Undo**, **Redo**, **Clear** | As described in [Layers](#layers). | +| **Erase last** | Erases the newest layer. While overdubbing, that is the layer being overdubbed: as with Undo, it is dropped and overdubbing goes on in a new one. | +| **Mute last** | Mutes the newest layer, or unmutes it. | +| **Previous layer**, **Next layer** | Change **Layer**, the selected layer, at once, from the oldest to the newest. The view outlines the selected lane. | +| **Mute layer**, **Erase layer** | Mute or erase the selected layer, at once. | +| **Solo layer** | Mutes every layer but the selected one. Pressed again, the layers get back the mutes they had, unless a mute or an erase changed them in between. | +| **Toggle reverse** | Turns **Reverse** on or off. | +| **Half speed**, **Double speed** | Set **Speed** to x1/2 or x2, or back to x1 when it already is. | +| **Capture** | See [Capture](#capture). | + +Three settings choose what the actions do: + +| Setting | Choices | +|---|---| +| **After record** | What Rec / Play / Dub and Record go to when they end a recording. **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. **Comp** does the same in a layer of its own each time. A recording that ends on its own after Bars goes to **Post-action** instead. | +| **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 Comp next does, for building a loop layer by layer with one switch. | +| **Stop at** | When Stop, Play / Stop and Loop set to Stop stop the loop. **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. @@ -58,7 +92,7 @@ Each overdub pass is a layer of its own. The view shows one lane per layer. 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. The view shows up to eight lanes; with more passes than that, the oldest share the first lane, which has no **x**. -- with **Layer** and **Erase layer**: Layer says which pass, counting from the oldest one, and Erase layer erases it. **Mute layer** mutes it instead, see [Comping](#comping). 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. +- with **Layer** and **Erase layer**, in the Switches tab: Layer says which pass, counting from the oldest one, and Erase layer erases it. **Mute layer** mutes it instead, see [Comping](#comping). 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. @@ -145,7 +179,9 @@ The view's playhead has an arrow pointing the way the loop plays, and the header A pass per cycle is a pass like any other: it has its own lane, and can be undone or erased on its own. Rounds follow each other without a fade, so all of them together sound as one long overdub would, Feedback included. An overdub that goes round after a recording, with the post-action Overdub or when Overdub was asked on an empty loop, makes a pass per round as well. -To keep the best round, mute the others: the **m** left of the **x** of a lane mutes its pass, and pressing it again unmutes it. **Mute layer**, in the Comp tab, does the same for the pass **Layer** says, from a port. A muted pass is kept but not heard, as if it were erased: it takes nothing from the passes under it with its feedback, and it is drawn dimmed. Muted passes are left out of the mix of a take; a take written as layers still has a file for every pass, the muted ones included, as they would be heard, so that the rounds can be spliced in the timeline. +**Comp**, the mode, and **Comp next**, in the Switches tab, are for keeping the best of several takes played one after the other: each press of Comp next ends the layer being overdubbed and starts a new one on the next grid point, without stopping, so three presses leave three layers. Entering Comp starts a new layer whatever the mode was, Overdub included. Undo while comping drops the layer in progress, and comping goes on in a new one. + +To keep the best round, mute the others: the **m** left of the **x** of a lane mutes its pass, and pressing it again unmutes it. **Mute layer**, in the Switches tab, does the same for the pass **Layer** says, from a port; **Solo layer** mutes all the others at once. A muted pass is kept but not heard, as if it were erased: it takes nothing from the passes under it with its feedback, and it is drawn dimmed. Muted passes are left out of the mix of a take; a take written as layers still has a file for every pass, the muted ones included, as they would be heard, so that the rounds can be spliced in the timeline. When the two oldest passes are merged to make room, past **Max layers**, a muted one is left out of the merged pass, and lost. diff --git a/docs/reference-manual/processes/library/midi_looper.md b/docs/reference-manual/processes/library/midi_looper.md index 676b98e1..e87321f0 100644 --- a/docs/reference-manual/processes/library/midi_looper.md +++ b/docs/reference-manual/processes/library/midi_looper.md @@ -30,13 +30,19 @@ Each recording or overdub is a pass. **Undo** hides the last pass, **Redo** show 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. +## Comp mode and the Switches tab + +**Loop** has a **Comp** mode, and the **Switches** tab has the actions made for footswitches, with **After record**, **After overdub** and **Stop at**, all as for the [audio looper]({{ site.baseurl }}/processes/audio-looper.html#footswitches): see there for why actions rather than values of Loop, and what each one does. + +With After record set to Overdub or Comp, 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. + ## The view The view shows one lane per pass, as the audio looper does: up to eight lanes, the oldest passes sharing the first lane when there are more. 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**. 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. +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**, or the newest one with **Erase last**. 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 the second leaves the first one's C silent, because the third still replaces it. @@ -88,7 +94,7 @@ The notes the loop was playing end when it turns round. **Passes**, in the Comp tab, makes a pass of each round of an overdub with **Per cycle**, as for the [audio looper]({{ site.baseurl }}/processes/audio-looper.html#comping). A note held across the start of the loop belongs to the round it started in. -The **m** of a lane, or **Mute layer** with **Layer**, mutes a pass: its 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 a later pass replaces them as well. Muted passes 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 pass is muted or unmuted. +**Comp next** starts a new pass at each press without stopping, as for the audio looper. The **m** of a lane, **Mute layer** with **Layer**, or **Mute last**, mutes a pass, and **Solo layer** mutes all but one: its 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 a later pass replaces them as well. Muted passes 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 pass is muted or unmuted. ## Restart In phase From 4c52717764658970d87a1c6b55169d181552960c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?= Date: Sun, 25 Oct 2026 13:49:38 -0400 Subject: [PATCH 14/29] loopers: quantize changes, takes on demand Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Qr9WkcUjEGCueg7eG1KxSr --- docs/reference-manual/processes/library/audio_looper.md | 4 ++++ docs/reference-manual/processes/library/midi_looper.md | 6 ++++-- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/docs/reference-manual/processes/library/audio_looper.md b/docs/reference-manual/processes/library/audio_looper.md index 283a6a83..5c754e19 100644 --- a/docs/reference-manual/processes/library/audio_looper.md +++ b/docs/reference-manual/processes/library/audio_looper.md @@ -104,6 +104,10 @@ When a recording or an overdub ends, the loop is written to a WAV file: 32-bit f The take can also be dragged from the looper's view into the timeline, or anywhere a sound file can be dropped. +While a recording or an overdub goes on, the last take does not have it yet. Send, or a press in the view that starts a drag, 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 Send button says **Saving** until the take is written. Send places it as soon as it is there. A drag 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. + +When the score stops while a recording or an overdub goes on, the loop as it is heard is written as a take of its own, its mix only, even if the looper is removed right after. + **Takes** chooses what a take is written as: **Mix**, 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 all its files in one box named after the take, a slot each, the mix first; dragging it drops them all. 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...** sets aside the takes in the score's folder that it no longer uses. diff --git a/docs/reference-manual/processes/library/midi_looper.md b/docs/reference-manual/processes/library/midi_looper.md index e87321f0..b97759c5 100644 --- a/docs/reference-manual/processes/library/midi_looper.md +++ b/docs/reference-manual/processes/library/midi_looper.md @@ -21,7 +21,7 @@ The recording keeps its own timing: quantize, transpose and channel changes only Each recording or overdub is a pass. **Undo** hides the last pass, **Redo** shows it again, **Clear** forgets everything. **Restart** is in the Play tab, with Follow tempo. -**Overdub** chooses what a pass does to the notes of the passes under it: +**Overdub mode**, in the Overdub tab, chooses what a pass does to the notes of the passes under it: | Choice | Behavior | |---|---| @@ -56,7 +56,7 @@ A note held on the input is never sent twice when the loop plays the same note. ## Quantize -**Grid** and **Quantize** pull the notes towards a grid when they are played back. At a Quantize of 0 the notes play as recorded; at 1 they play on the grid. **Quantize ends** pulls the ends of the notes too. +**Grid** and **Quantize** pull the notes towards a grid when they are played back. At a Quantize of 0 the notes play as recorded; at 1 they play on the grid. **Quantize 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 @@ -79,6 +79,8 @@ With **Follow tempo**, on by default, the loop plays at the tempo of the score: When a recording or an overdub ends, what is heard of the loop is written to a Standard MIDI File, at 120 BPM so that a quarter note is half a second of score's time, and ending exactly at the end of the loop. **Send** in the looper's view, or a drag from it, places it in the timeline as a MIDI clip that holds the notes, where the take was recorded. The file can also be opened in any other MIDI editor. **Takes** writes what is heard of the whole loop (**Mix**), each pass in a file of its own (**Layers**), or both; the files go in one box, a looping clip each, the mix first. +While a recording or an overdub goes on, Send or a drag 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 loop as it is heard is written as a take of its own, its mix only. + ## Reverse and speed **Reverse** and **Speed**, in the Play tab, work as for the [audio looper]({{ site.baseurl }}/processes/audio-looper.html#reverse-and-speed). From f99252360b6c22d6bad7fc4c93cbb0a8367adc03 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?= Date: Sun, 25 Oct 2026 20:54:04 -0400 Subject: [PATCH 15/29] loopers: the control model, footswitches, settings Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Qr9WkcUjEGCueg7eG1KxSr --- .../processes/library/audio_looper.md | 123 +++++++++++------- .../processes/library/midi_looper.md | 32 +++-- 2 files changed, 93 insertions(+), 62 deletions(-) diff --git a/docs/reference-manual/processes/library/audio_looper.md b/docs/reference-manual/processes/library/audio_looper.md index 5c754e19..1a5b61fb 100644 --- a/docs/reference-manual/processes/library/audio_looper.md +++ b/docs/reference-manual/processes/library/audio_looper.md @@ -25,74 +25,99 @@ The [MIDI looper]({{ site.baseurl }}/processes/midi-looper.html) works the same |---|---| | **Play** | Plays the loop. | | **Record** | Records a new loop, replacing the current one and all its layers. | -| **Overdub** | Records a new layer on top of the loop while it plays. On an empty loop, records the loop first: until the mode changes, or for Bars bars after which overdubbing starts. | +| **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. | -| **Comp** | Overdubs as Overdub does, but taking it up always starts a new layer, even from Overdub. Leaving it ends the layer, as leaving Overdub does. See [Comping](#comping). | -Loop always shows what the looper is asked to do: when an action of the Switches tab, the post-action or a full loop changes the mode, Loop changes with it. +Loop 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. -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. +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 Loop itself, at the end of a recording for instance, the cable does not ask again and the mode does not flip back. + +## Record, Overdub and layers + +| | What it is for | What it does to the loop | How layers are cut | +|---|---|---|---| +| **Record** | Making a loop, or making it again. | Replaces the loop and every layer; the loop is as long as the recording, or **Bars** bars. | 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. | + +A recording ends in one of three ways, and **After record** says what it gives way to whichever it is: its **Bars** running out, the loop reaching **Max length**, or **Rec / Play / Dub**. Setting Loop to another mode during a recording ends it into that mode. ## Timing -**Quantif** makes a mode change wait for the next point of a grid, so that a loop starts and ends in time. Whole is a bar; None changes at once. See [quantization]({{ site.baseurl }}/in-depth/musical.html#quantization). +**Quantif** makes a mode change wait for the next point of a grid, so that a loop starts and ends in time. Whole is a bar; None changes at once. See [quantization]({{ site.baseurl }}/in-depth/musical.html#quantization). Every action waits for it as well, except Undo, Redo and Clear, which act at once, and selecting a layer. -**Bars** and **Post-action** make a recording end on its own: after Bars bars, recording gives way to the post-action, Play or Overdub. With Bars at 0, a recording lasts as long as wanted, until the mode is changed. +**Bars** makes a recording end on its own after that many bars, into what **After record** says. With 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. -**Restart** chooses where playback starts after a mode change: from the beginning of the loop (Always), or, except after a recording, from where it was (Recording). **In phase** keeps the loop on the timeline, see [Restart In phase](#restart-in-phase). +**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 -Loop is a value: setting it to the mode it already has does nothing. A footswitch mapped to Loop can say "overdub" but not "overdub again in a new layer", "go back to the start" or "end this recording into the post-action". The **Switches** tab has actions for that: buttons that act each time they are pressed, made to be mapped to footswitches, MIDI notes or OSC messages. What they change waits for the next point of the grid, as a change of Loop does, and Late stop applies to them; the controls they change (Loop, Layer, Reverse, Speed) show what they changed them to. +The **Switches** tab has buttons made to be mapped to footswitches, MIDI notes or OSC messages. Play, Stop, Record and Overdub set Loop, exactly as setting it by hand does. The others say what Loop 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 Loop does, and Late stop applies to them; the controls they change (Loop, 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 or comping, does what **After overdub** says; plays a stopped loop. | +| **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. | -| **Record** | Records a new loop, in place of the one there is, from any mode. While recording, ends the recording into what After record says. | -| **Overdub** | Overdubs, from any mode. Pressed while overdubbing, does nothing: the layer goes on. | -| **Comp next** | Ends the layer being overdubbed and starts a new one, without stopping. From Play or Stop, starts comping; while recording, ends the recording and starts the first layer over it. | -| **Play**, **Stop** | Play or stop, from any mode. | -| **Restart loop** | Goes back to the start of the loop and stays in the same mode. An overdub goes on from the start in the same layer; a recording starts again. | -| **Undo**, **Redo**, **Clear** | As described in [Layers](#layers). | -| **Erase last** | Erases the newest layer. While overdubbing, that is the layer being overdubbed: as with Undo, it is dropped and overdubbing goes on in a new one. | -| **Mute last** | Mutes the newest layer, or unmutes it. | -| **Previous layer**, **Next layer** | Change **Layer**, the selected layer, at once, from the oldest to the newest. The view outlines the selected lane. | -| **Mute layer**, **Erase layer** | Mute or erase the selected layer, at once. | -| **Solo layer** | Mutes every layer but the selected one. Pressed again, the layers get back the mutes they had, unless a mute or an erase changed them in between. | -| **Toggle reverse** | Turns **Reverse** on or off. | -| **Half speed**, **Double speed** | Set **Speed** to x1/2 or x2, or back to x1 when it already is. | +| **Play**, **Stop**, **Record**, **Overdub** | Set Loop to that mode. 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). | -Three settings choose what the actions do: +**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. + +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 Loop, 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 Rec / Play / Dub and Record go to when they end a recording. **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. **Comp** does the same in a layer of its own each time. A recording that ends on its own after Bars goes to **Post-action** instead. | -| **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 Comp next does, for building a loop layer by layer with one switch. | -| **Stop at** | When Stop, Play / Stop and Loop set to Stop stop the loop. **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. | +| **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. Undoing the first recording empties the loop. +- **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 passes kept apart. When it is reached, the two oldest passes are merged into one, and that undo step is lost. +**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. The layer it replaces is gone: undo removes the pass, not the replacement. | + +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. The view shows up to eight lanes; with more passes than that, the oldest share the first lane, which has no **x**. -- with **Layer** and **Erase layer**, in the Switches tab: Layer says which pass, counting from the oldest one, and Erase layer erases it. **Mute layer** mutes it instead, see [Comping](#comping). 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. +- in the view, with the **x** at the right of its lane, on the next grid point. The view shows up to eight lanes; with more passes than that, the oldest share the first lane, which has no **x**. +- with **Layer** and **Erase layer**, in the Switches 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. @@ -106,7 +131,7 @@ The take can also be dragged from the looper's view into the timeline, or anywhe While a recording or an overdub goes on, the last take does not have it yet. Send, or a press in the view that starts a drag, 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 Send button says **Saving** until the take is written. Send places it as soon as it is there. A drag 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. -When the score stops while a recording or an overdub goes on, the loop as it is heard is written as a take of its own, its mix only, even if the looper is removed right after. +When the score stops while a recording or an overdub goes on, the overdub's layer is closed as any, and the loop as it is heard is written as a take of its own, its mix only, even if the looper is removed right after. **Takes** chooses what a take is written as: **Mix**, 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 all its files in one box named after the take, a slot each, the mix first; dragging it drops them all. @@ -114,11 +139,11 @@ Takes of a saved score go into a **Takes** folder next to the score. Takes of a ## Loading a file -Dropping a sound file on the looper, or choosing it in **Loop file**, replaces the loop with it, up to Max length, and plays it. A file at another sample rate is converted. A mono file goes to every channel. +Dropping a sound file on the looper, or choosing it in **Loop file**, replaces the loop with it, up to Max length, and plays it: Loop shows Play. A file at another sample rate is converted. A mono file goes to every channel. ## Capture -**Capture** makes a loop out of what was just played, even when the looper was not recording. It takes the last **Capture bars** bars of the input and plays them at once, ending on the last grid point when that was just passed, like a late stop. +**Capture** makes a loop out of what was just played, even when the looper was not recording. It takes the last **Capture bars** bars of the input and plays them at once, ending on the last grid point when that was just passed, like a late stop. Loop shows Play, so Stop stops it. Capture needs **Keep last (s)**, the number of seconds of input the looper keeps at all times. It is 0 by default, which keeps nothing and uses no memory. @@ -138,7 +163,7 @@ Capture needs **Keep last (s)**, the number of seconds of input the looper keeps ## Memory and latency -- **Max length (s)**, default 60, is the longest loop. A recording that reaches it ends, and the post-action takes over; the view shows the loop as full. +- **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. @@ -155,7 +180,7 @@ The memory for these is reserved when playback starts, so changes to Max length, | **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. | -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 post-action 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. +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 @@ -166,7 +191,7 @@ Following applies to a loop that is playing. A loop being recorded or overdubbed 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: Quantif, Bars and the post-action, Late stop and sync groups 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. +Speed and Reverse change how the loop is read, not the score's time: Quantif, Bars, Late stop and sync groups 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. @@ -174,24 +199,22 @@ The view's playhead has an arrow pointing the way the loop plays, and the header ## Comping -**Passes**, in the Comp tab, is for keeping the best of several rounds of an overdub: +There is no comp mode: comping is overdubbing with layers cut where wanted, then keeping the best. -| Choice | Behavior | -|---|---| -| **Whole** (default) | An overdub is one pass, from when it starts to when it stops. | -| **Per cycle** | An overdub that goes round the loop several times makes a pass of each round, each starting at the start of the loop. | - -A pass per cycle is a pass like any other: it has its own lane, and can be undone or erased on its own. Rounds follow each other without a fade, so all of them together sound as one long overdub would, Feedback included. An overdub that goes round after a recording, with the post-action Overdub or when Overdub was asked on an empty loop, makes a pass per round as well. +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. -**Comp**, the mode, and **Comp next**, in the Switches tab, are for keeping the best of several takes played one after the other: each press of Comp next ends the layer being overdubbed and starts a new one on the next grid point, without stopping, so three presses leave three layers. Entering Comp starts a new layer whatever the mode was, Overdub included. Undo while comping drops the layer in progress, and comping goes on in a new one. - -To keep the best round, mute the others: the **m** left of the **x** of a lane mutes its pass, and pressing it again unmutes it. **Mute layer**, in the Switches tab, does the same for the pass **Layer** says, from a port; **Solo layer** mutes all the others at once. A muted pass is kept but not heard, as if it were erased: it takes nothing from the passes under it with its feedback, and it is drawn dimmed. Muted passes are left out of the mix of a take; a take written as layers still has a file for every pass, the muted ones included, as they would be heard, so that the rounds can be spliced in the timeline. +| 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. | -When the two oldest passes are merged to make room, past **Max layers**, a muted one is left out of the merged pass, and lost. +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. -## Restart In phase +## Start from In phase -With **Restart** set to **In phase**, the loop stays in phase with the timeline. Playing and overdubbing carry on from where they were, as with Recording; and whenever the loop is heard again after being stopped, it starts where it would be had it kept playing since it was recorded: +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; @@ -205,4 +228,4 @@ The position comes from where the loop was recorded on the timeline. Without Fol ## Older scores -Scores made before the layers keep their looper and its settings. Their Loop, Quantif, Passthrough, Post-action, Bars and Restart behave as before. +Scores made before the layers keep their looper and its settings. Their Loop, Quantif, Passthrough and Bars behave as before; 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, In phase is In phase. diff --git a/docs/reference-manual/processes/library/midi_looper.md b/docs/reference-manual/processes/library/midi_looper.md index b97759c5..9f505fd6 100644 --- a/docs/reference-manual/processes/library/midi_looper.md +++ b/docs/reference-manual/processes/library/midi_looper.md @@ -19,7 +19,7 @@ The recording keeps its own timing: quantize, transpose and channel changes only ## Passes and overdubs -Each recording or overdub is a pass. **Undo** hides the last pass, **Redo** shows it again, **Clear** forgets everything. **Restart** is in the Play tab, with Follow tempo. +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, with Follow tempo. **Overdub mode**, in the Overdub tab, chooses what a pass does to the notes of the passes under it: @@ -30,11 +30,19 @@ Each recording or overdub is a pass. **Undo** hides the last pass, **Redo** show 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. -## Comp mode and the Switches tab +## Record, Overdub and the Switches tab -**Loop** has a **Comp** mode, and the **Switches** tab has the actions made for footswitches, with **After record**, **After overdub** and **Stop at**, all as for the [audio looper]({{ site.baseurl }}/processes/audio-looper.html#footswitches): see there for why actions rather than values of Loop, and what each one does. +**Loop**, the **Switches** tab and the settings **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): Loop 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 Loop can. See there for what each one does and when it is taken up. -With After record set to Overdub or Comp, 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. +| | What it is for | What it does to the loop | How layers are cut | +|---|---|---|---| +| **Record** | Making a phrase, or making it again. | Replaces every pass; the loop is as long as the recording, or **Bars** bars. | 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 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. | + +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. + +**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. 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 @@ -42,9 +50,9 @@ The view shows one lane per pass, as the audio looper does: up to eight lanes, t ## 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**, or the newest one with **Erase last**. 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. +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 the second leaves the first one's C silent, because the third still replaces it. +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 @@ -79,7 +87,7 @@ With **Follow tempo**, on by default, the loop plays at the tempo of the score: When a recording or an overdub ends, what is heard of the loop is written to a Standard MIDI File, at 120 BPM so that a quarter note is half a second of score's time, and ending exactly at the end of the loop. **Send** in the looper's view, or a drag from it, places it in the timeline as a MIDI clip that holds the notes, where the take was recorded. The file can also be opened in any other MIDI editor. **Takes** writes what is heard of the whole loop (**Mix**), each pass in a file of its own (**Layers**), or both; the files go in one box, a looping clip each, the mix first. -While a recording or an overdub goes on, Send or a drag 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 loop as it is heard is written as a take of its own, its mix only. +While a recording or an overdub goes on, Send or a drag 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, and the loop as it is heard is written as a take of its own, its mix only. ## Reverse and speed @@ -94,17 +102,17 @@ The notes the loop was playing end when it turns round. ## Comping -**Passes**, in the Comp tab, makes a pass of each round of an overdub with **Per cycle**, as for the [audio looper]({{ site.baseurl }}/processes/audio-looper.html#comping). A note held across the start of the loop belongs to the round it started in. +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. -**Comp next** starts a new pass at each press without stopping, as for the audio looper. The **m** of a lane, **Mute layer** with **Layer**, or **Mute last**, mutes a pass, and **Solo layer** mutes all but one: its 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 a later pass replaces them as well. Muted passes 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 pass is muted or unmuted. +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. -## Restart In phase +## Start from In phase -**Restart** set to **In phase** keeps the loop in phase with the timeline, as for the [audio looper]({{ site.baseurl }}/processes/audio-looper.html#restart-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. +**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 -**Capture** makes a loop out of the last **Capture bars** bars played, recorded or not, and plays it at once. The MIDI looper always keeps the last few thousand events it received, so there is nothing to set up. +**Capture** makes a loop out of the last **Capture bars** bars played, recorded or not, and plays it at once; Loop shows Play. The MIDI looper always keeps the last few thousand events it received, so there is nothing to set up. ## Capacity From 36ca77a33703cf2f62d83bb50c2d1a67d7cadbb7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?= Date: Sun, 25 Oct 2026 21:43:01 -0400 Subject: [PATCH 16/29] loopers: presets Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Qr9WkcUjEGCueg7eG1KxSr --- .../processes/library/audio_looper.md | 23 ++++++++++++++++ .../processes/library/midi_looper.md | 26 +++++++++++++++++++ 2 files changed, 49 insertions(+) diff --git a/docs/reference-manual/processes/library/audio_looper.md b/docs/reference-manual/processes/library/audio_looper.md index 1a5b61fb..bc879795 100644 --- a/docs/reference-manual/processes/library/audio_looper.md +++ b/docs/reference-manual/processes/library/audio_looper.md @@ -222,6 +222,29 @@ With **Start from** set to **In phase**, the loop stays in phase with the timeli 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, 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; a stop lets the loop play to its end. | +| **One footswitch, song form** | The same from Rec / Play / Dub alone, 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. | +| **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 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, for Capture to make a loop of its last four bars. | +| **Takes for editing** | Takes are written as a mix and as a file for each layer. | +| **Second loop of group A** | Sync group A, for a loop recorded after another one of the group. | + ## Outputs **Phase** goes from 0 to 1 as the loop plays, to drive anything that should follow the loop, such as video. diff --git a/docs/reference-manual/processes/library/midi_looper.md b/docs/reference-manual/processes/library/midi_looper.md index 9f505fd6..b75c9887 100644 --- a/docs/reference-manual/processes/library/midi_looper.md +++ b/docs/reference-manual/processes/library/midi_looper.md @@ -114,6 +114,32 @@ A muted layer's notes and controllers are not heard, and it replaces nothing, so **Capture** makes a loop out of the last **Capture bars** bars played, recorded or not, and plays it at once; Loop shows Play. The MIDI looper always keeps the last few thousand events it received, so there is nothing to set up. +## 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; a stop lets the loop play to its end. | +| **One footswitch, song form** | The same from Rec / Play / Dub alone, 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. | +| **Comping, a layer per round** | One overdub, a layer each time round the loop; takes are written as a mix and as layers. | +| **Four bar phrase** | 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 phrase** | No grid, no 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 pitch played replacing that pitch in the passes under it. | +| **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. | +| **Capture what I played** | Capture makes a loop of the last four bars played. | +| **Takes for editing** | Takes are written as a mix and as a MIDI file for each layer. | +| **Second loop of group A** | Sync group A, for a loop recorded after another one of the group. | + ## 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. From efeacd2957c537b633ce929ec46e0e19ca54e4c9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?= Date: Sun, 25 Oct 2026 22:37:45 -0400 Subject: [PATCH 17/29] Arpeggiator page rewritten; looper pages: Export, undoable Replace, Layer across merges, defaults, older scores Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Qr9WkcUjEGCueg7eG1KxSr --- .../processes/library/arpeggiator.md | 70 ++++++++++++++++--- .../processes/library/audio_looper.md | 28 +++++--- .../processes/library/midi-utilities.md | 6 +- .../processes/library/midi_looper.md | 12 ++-- 4 files changed, 89 insertions(+), 27 deletions(-) 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 bc879795..2db89531 100644 --- a/docs/reference-manual/processes/library/audio_looper.md +++ b/docs/reference-manual/processes/library/audio_looper.md @@ -44,7 +44,7 @@ A recording ends in one of three ways, and **After record** says what it gives w ## Timing -**Quantif** makes a mode change wait for the next point of a grid, so that a loop starts and ends in time. Whole is a bar; None changes at once. See [quantization]({{ site.baseurl }}/in-depth/musical.html#quantization). Every action waits for it as well, except Undo, Redo and Clear, which act at once, and selecting a layer. +**Quantif** makes a mode change wait for the next point of a grid, so that a loop starts and ends in time. The default is a quarter note (**4th**); Whole is a bar; None changes at once. See [quantization]({{ site.baseurl }}/in-depth/musical.html#quantization). Every action waits for it as well, except Undo, Redo and Clear, which act at once, and selecting a layer. **Bars** makes a recording end on its own after that many bars, into what **After record** says. With Bars at 0, a recording lasts as long as wanted, until the mode is changed. @@ -79,7 +79,7 @@ The **Switches** tab has buttons made to be mapped to footswitches, MIDI notes o | **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. +**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 Loop, or pressing Play, Stop, Record or Overdub, replaces whatever was waiting. @@ -108,7 +108,7 @@ Each overdub pass is a layer of its own. The view shows one lane per layer. |---|---| | **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. The layer it replaces is gone: undo removes the pass, not the replacement. | +| **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. @@ -133,13 +133,13 @@ While a recording or an overdub goes on, the last take does not have it yet. Sen When the score stops while a recording or an overdub goes on, the overdub's layer is closed as any, and the loop as it is heard is written as a take of its own, its mix only, even if the looper is removed right after. -**Takes** chooses what a take is written as: **Mix**, 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 all its files in one box named after the take, a slot each, the mix first; dragging it drops them all. +**Export** chooses what a take writes: **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 all its files in one box named after the take, a slot each, the mix first; dragging it drops them all. -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...** sets aside the takes in the score's folder that it no longer uses. +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, or choosing it in **Loop file**, replaces the loop with it, up to Max length, and plays it: Loop shows Play. A file at another sample rate is converted. A mono file goes to every channel. +Dropping a sound file on the looper replaces the loop with it, up to Max length, and plays it: Loop 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 @@ -158,7 +158,7 @@ Capture needs **Keep last (s)**, the number of seconds of input the looper keeps | Choice | Behavior | |---|---| | **None** | The input is never heard. | -| **Record** | The input is heard while recording and overdubbing only. | +| **Record** (default) | The input is heard while recording and overdubbing only. | | **Full** | The input is always heard, mixed over the loop. | ## Memory and latency @@ -180,7 +180,7 @@ The memory for these is reserved when playback starts, so changes to Max length, | **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. | -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. +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 @@ -242,7 +242,7 @@ The library has presets for the usual ways of looping. Each one sets every setti | **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, for Capture to make a loop of its last four bars. | -| **Takes for editing** | Takes are written as a mix and as a file for each layer. | +| **Takes for editing** | **Export** on Both: takes are written as a mix and as a file for each layer. | | **Second loop of group A** | Sync group A, for a loop recorded after another one of the group. | ## Outputs @@ -251,4 +251,12 @@ The library has presets for the usual ways of looping. Each one sets every setti ## Older scores -Scores made before the layers keep their looper and its settings. Their Loop, Quantif, Passthrough and Bars behave as before; 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, In phase is In phase. +Scores made before the layers keep their looper and the settings they had: Loop, Quantif, Passthrough and Bars mean what they meant. 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. The settings added since come up at their defaults, and these change what such a looper does: + +- **Overdub on an empty loop** records it, then goes on overdubbing; it used to only pass the input through. +- **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. +- **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 the mode Loop shows is taken up again when the score plays again. It used to stay in the mode it was in, the playhead where it was. diff --git a/docs/reference-manual/processes/library/midi-utilities.md b/docs/reference-manual/processes/library/midi-utilities.md index 5eac3cb3..74e99667 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 diff --git a/docs/reference-manual/processes/library/midi_looper.md b/docs/reference-manual/processes/library/midi_looper.md index b75c9887..e53ecbaa 100644 --- a/docs/reference-manual/processes/library/midi_looper.md +++ b/docs/reference-manual/processes/library/midi_looper.md @@ -15,7 +15,7 @@ permalink: /processes/midi-looper.html 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, sync groups, capture and timeline features with the [audio looper]({{ site.baseurl }}/processes/audio-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. +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 @@ -42,7 +42,7 @@ Controllers always replace their own earlier values over the part of the loop a 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. -**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. 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. +**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 @@ -64,7 +64,7 @@ A note held on the input is never sent twice when the loop plays the same note. ## Quantize -**Grid** and **Quantize** pull the notes towards a grid when they are played back. At a Quantize of 0 the notes play as recorded; at 1 they play on the grid. **Quantize 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. +**Grid** (default a quarter note, **4th**) and **Quantize** (default 0) pull the notes towards a grid when they are played back. At a Quantize of 0 the notes play as recorded; at 1 they play on the grid. **Quantize 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 @@ -85,7 +85,9 @@ With **Follow tempo**, on by default, the loop plays at the tempo of the score: ## 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 120 BPM so that a quarter note is half a second of score's time, and ending exactly at the end of the loop. **Send** in the looper's view, or a drag from it, places it in the timeline as a MIDI clip that holds the notes, where the take was recorded. The file can also be opened in any other MIDI editor. **Takes** writes what is heard of the whole loop (**Mix**), each pass in a file of its own (**Layers**), or both; the files go in one box, a looping clip each, the mix first. +When a recording or an overdub ends, what is heard of the loop is written to a Standard MIDI File, at 120 BPM so that a quarter note is half a second of score's time, and ending exactly at the end of the loop. **Send** in the looper's view, or a drag from it, places it in the timeline as a MIDI clip that holds the notes, where the take was recorded. The file can also be opened in any other MIDI editor. **Export** chooses what a take writes: 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 has the notes where the loop plays them: **Quantize**, **Grid** and **Quantize 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 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, and the loop as it is heard is written as a take of its own, its mix only. @@ -137,7 +139,7 @@ As for the [audio looper]({{ site.baseurl }}/processes/audio-looper.html#presets | **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** | Capture makes a loop of the last four bars played. | -| **Takes for editing** | Takes are written as a mix and as a MIDI file for each layer. | +| **Takes for editing** | **Export** on Both: takes are written as a mix and as a MIDI file for each layer. | | **Second loop of group A** | Sync group A, for a loop recorded after another one of the group. | ## Capacity From c3bb255c191f56497db299be1c2b8d29450be074 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?= Date: Sun, 25 Oct 2026 23:50:05 -0400 Subject: [PATCH 18/29] Loopers: Quantif units, Loop and its empty-loop fallback, old values Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Qr9WkcUjEGCueg7eG1KxSr --- .../processes/library/audio_looper.md | 14 ++++++++++++-- .../processes/library/midi_looper.md | 4 +++- 2 files changed, 15 insertions(+), 3 deletions(-) diff --git a/docs/reference-manual/processes/library/audio_looper.md b/docs/reference-manual/processes/library/audio_looper.md index 2db89531..4115a48d 100644 --- a/docs/reference-manual/processes/library/audio_looper.md +++ b/docs/reference-manual/processes/library/audio_looper.md @@ -44,7 +44,16 @@ A recording ends in one of three ways, and **After record** says what it gives w ## Timing -**Quantif** makes a mode change wait for the next point of a grid, so that a loop starts and ends in time. The default is a quarter note (**4th**); Whole is a bar; None changes at once. See [quantization]({{ site.baseurl }}/in-depth/musical.html#quantization). Every action waits for it as well, except Undo, Redo and Clear, which act at once, and selecting a layer. +**Quantif** 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: **Bars** bars, or one bar when Bars is 0 (2x loop is twice that). In a sync group, Loop is still the looper's own loop. **Bars** makes a recording end on its own after that many bars, into what **After record** says. With Bars at 0, a recording lasts as long as wanted, until the mode is changed. @@ -251,12 +260,13 @@ The library has presets for the usual ways of looping. Each one sets every setti ## Older scores -Scores made before the layers keep their looper and the settings they had: Loop, Quantif, Passthrough and Bars mean what they meant. 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. The settings added since come up at their defaults, and these change what such a looper does: +Scores made before the layers keep their looper and the settings they had: Loop, Passthrough and Bars mean what they meant. 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. The settings added since come up at their defaults, and these change what such a looper does: - **Overdub on an empty loop** records it, then goes on overdubbing; it used to only pass the input through. - **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). +- **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. - **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. - **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 the mode Loop shows is taken up again when the score plays again. It used to stay in the mode it was in, the playhead where it was. diff --git a/docs/reference-manual/processes/library/midi_looper.md b/docs/reference-manual/processes/library/midi_looper.md index e53ecbaa..9e8f0632 100644 --- a/docs/reference-manual/processes/library/midi_looper.md +++ b/docs/reference-manual/processes/library/midi_looper.md @@ -32,7 +32,7 @@ Controllers always replace their own earlier values over the part of the loop a ## Record, Overdub and the Switches tab -**Loop**, the **Switches** tab and the settings **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): Loop 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 Loop can. See there for what each one does and when it is taken up. +**Loop**, the **Switches** tab and the settings **Quantif**, **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): Loop 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 Loop can. 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 | |---|---|---|---| @@ -64,6 +64,8 @@ A note held on the input is never sent twice when the loop plays the same note. ## Quantize +**Quantif** 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 **Bars** bars, or one bar when Bars is 0. A score or a preset made when Quantif was a list of note values gets the grid it waited for: Whole is **1 bar**, None is None, and the others are the same note values. The rest of this section is about the notes, not the mode changes. + **Grid** (default a quarter note, **4th**) and **Quantize** (default 0) pull the notes towards a grid when they are played back. At a Quantize of 0 the notes play as recorded; at 1 they play on the grid. **Quantize 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 From 30e213e08a0c3eea4f6a7e45618dd62385ca5cf2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?= Date: Mon, 26 Oct 2026 00:37:59 -0400 Subject: [PATCH 19/29] Loopers: song form presets wait for the loop to come round Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Qr9WkcUjEGCueg7eG1KxSr --- docs/reference-manual/processes/library/audio_looper.md | 2 +- docs/reference-manual/processes/library/midi_looper.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/reference-manual/processes/library/audio_looper.md b/docs/reference-manual/processes/library/audio_looper.md index 4115a48d..5b7195ea 100644 --- a/docs/reference-manual/processes/library/audio_looper.md +++ b/docs/reference-manual/processes/library/audio_looper.md @@ -237,7 +237,7 @@ The library has presets for the usual ways of looping. Each one sets every setti | Preset | What it is for | |---|---| -| **Song form** | Record, Play, Overdub and Play again, for verses and choruses; a stop lets the loop play to its end. | +| **Song form** | Record, Play, Overdub and Play again, for verses and choruses. Quantif 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, 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. | diff --git a/docs/reference-manual/processes/library/midi_looper.md b/docs/reference-manual/processes/library/midi_looper.md index 9e8f0632..c2d26c8a 100644 --- a/docs/reference-manual/processes/library/midi_looper.md +++ b/docs/reference-manual/processes/library/midi_looper.md @@ -124,7 +124,7 @@ As for the [audio looper]({{ site.baseurl }}/processes/audio-looper.html#presets | Preset | What it is for | |---|---| -| **Song form** | Record, Play, Overdub and Play again; a stop lets the loop play to its end. | +| **Song form** | Record, Play, Overdub and Play again. Quantif 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, 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. | From f923a74eb0f801ba0c916182d40b066dc964fab1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?= Date: Mon, 26 Oct 2026 09:03:06 -0400 Subject: [PATCH 20/29] Loopers: no sync groups, Record overdubs, new names; MIDI takes keep their tempo, MIDI files placed by beats Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Qr9WkcUjEGCueg7eG1KxSr --- docs/examples/audio/looper.md | 2 +- docs/in-depth/midi.md | 2 + .../processes/library/audio_looper.md | 58 ++++++++++--------- .../processes/library/midi_looper.md | 35 ++++++----- .../processes/library/piano-roll.md | 2 + 5 files changed, 59 insertions(+), 40 deletions(-) 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/audio_looper.md b/docs/reference-manual/processes/library/audio_looper.md index 5b7195ea..fac9dcce 100644 --- a/docs/reference-manual/processes/library/audio_looper.md +++ b/docs/reference-manual/processes/library/audio_looper.md @@ -19,32 +19,32 @@ The [MIDI looper]({{ site.baseurl }}/processes/midi-looper.html) works the same ## Modes -**Loop** chooses what the looper does: +**Mode** chooses what the looper does: | Mode | Behavior | |---|---| | **Play** | Plays the loop. | -| **Record** | Records a new loop, replacing the current one and all its layers. | +| **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. | -Loop 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. +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. -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 Loop itself, at the end of a recording for instance, the cable does not ask again and the mode does not flip back. +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, Overdub and layers | | What it is for | What it does to the loop | How layers are cut | |---|---|---|---| -| **Record** | Making a loop, or making it again. | Replaces the loop and every layer; the loop is as long as the recording, or **Bars** bars. | The recording is the first layer. | +| **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. | -A recording ends in one of three ways, and **After record** says what it gives way to whichever it is: its **Bars** running out, the loop reaching **Max length**, or **Rec / Play / Dub**. Setting Loop to another mode during a recording ends it into that mode. +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 -**Quantif** 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: +**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 | |---|---|---| @@ -53,9 +53,9 @@ A recording ends in one of three ways, and **After record** says what it gives w | **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: **Bars** bars, or one bar when Bars is 0 (2x loop is twice that). In a sync group, Loop is still the looper's own loop. +**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). -**Bars** makes a recording end on its own after that many bars, into what **After record** says. With Bars at 0, a recording lasts as long as wanted, until the mode is changed. +**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. @@ -71,13 +71,13 @@ A recording always starts at the loop's start. ## Footswitches -The **Switches** tab has buttons made to be mapped to footswitches, MIDI notes or OSC messages. Play, Stop, Record and Overdub set Loop, exactly as setting it by hand does. The others say what Loop 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 Loop does, and Late stop applies to them; the controls they change (Loop, Layer, Reverse, Speed) show what they changed them to. +The **Switches** tab has buttons made to be mapped to footswitches, MIDI notes or OSC messages. 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 Loop to that mode. Record while recording, or Overdub while overdubbing, does nothing. | +| **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). | @@ -90,7 +90,7 @@ The **Switches** tab has buttons made to be mapped to footswitches, MIDI notes o **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 Loop, or pressing Play, Stop, Record or Overdub, replaces whatever was waiting. +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: @@ -140,7 +140,7 @@ The take can also be dragged from the looper's view into the timeline, or anywhe While a recording or an overdub goes on, the last take does not have it yet. Send, or a press in the view that starts a drag, 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 Send button says **Saving** until the take is written. Send places it as soon as it is there. A drag 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. -When the score stops while a recording or an overdub goes on, the overdub's layer is closed as any, and the loop as it is heard is written as a take of its own, its mix only, even if the looper is removed right after. +When the score stops while a recording or an overdub goes on, the overdub's layer is closed as any, and the loop as it is heard is written as a take of its own, its mix only, even if the looper is removed right after. 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. **Export** chooses what a take writes: **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 all its files in one box named after the take, a slot each, the mix first; dragging it drops them all. @@ -148,18 +148,14 @@ Takes of a saved score go into a **Takes** folder next to the score. Takes of a ## Loading a file -Dropping a sound file on the looper replaces the loop with it, up to Max length, and plays it: Loop 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. +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 -**Capture** makes a loop out of what was just played, even when the looper was not recording. It takes the last **Capture bars** bars of the input and plays them at once, ending on the last grid point when that was just passed, like a late stop. Loop shows Play, so Stop stops it. +**Capture** makes a loop out of what was just played, even when the looper was not recording. It takes the last **Capture bars** bars of the input and plays them at once, ending on the last grid point when that was just passed, like a late stop. Mode shows Play, so Stop stops it. Capture needs **Keep last (s)**, the number of seconds of input the looper keeps at all times. It is 0 by default, which keeps nothing and uses no memory. -## Sync groups - -**Sync** puts loopers in a group, A to D. The first looper of a group to record sets the group's loop. The loops recorded after it are rounded to a whole number of that loop, or to a half, a quarter or an eighth of it, and play in phase with it. Clearing the looper that set the loop frees the group. - ## Monitoring **Passthrough** chooses when the input is heard: @@ -200,7 +196,7 @@ A change of Follow tempo applies from the next start of playback, as the time-st 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: Quantif, Bars, Late stop and sync groups 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. +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. @@ -237,14 +233,14 @@ The library has presets for the usual ways of looping. Each one sets every setti | Preset | What it is for | |---|---| -| **Song form** | Record, Play, Overdub and Play again, for verses and choruses. Quantif 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. | +| **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, 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. | | **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 Bars, no Late stop: the loop is as long as it was played for. | +| **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. | @@ -252,7 +248,6 @@ The library has presets for the usual ways of looping. Each one sets every setti | **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, for Capture to make a loop of its last four bars. | | **Takes for editing** | **Export** on Both: takes are written as a mix and as a file for each layer. | -| **Second loop of group A** | Sync group A, for a loop recorded after another one of the group. | ## Outputs @@ -260,13 +255,24 @@ The library has presets for the usual ways of looping. Each one sets every setti ## Older scores -Scores made before the layers keep their looper and the settings they had: Loop, Passthrough and Bars mean what they meant. 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. The settings added since come up at their defaults, and these change what such a looper does: +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). -- **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. - **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. -- **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 the mode Loop shows is taken up again when the score plays again. It used to stay in the mode it was in, the playhead where it was. diff --git a/docs/reference-manual/processes/library/midi_looper.md b/docs/reference-manual/processes/library/midi_looper.md index c2d26c8a..27db9233 100644 --- a/docs/reference-manual/processes/library/midi_looper.md +++ b/docs/reference-manual/processes/library/midi_looper.md @@ -13,7 +13,7 @@ permalink: /processes/midi-looper.html ![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, sync groups, capture and timeline features with the [audio looper]({{ site.baseurl }}/processes/audio-looper.html); this page describes what is particular to MIDI. +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); 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). @@ -32,11 +32,11 @@ Controllers always replace their own earlier values over the part of the loop a ## Record, Overdub and the Switches tab -**Loop**, the **Switches** tab and the settings **Quantif**, **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): Loop 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 Loop can. See there for what each one does and when it is taken up. +**Mode**, the **Switches** tab 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, or making it again. | Replaces every pass; the loop is as long as the recording, or **Bars** bars. | The recording is the first layer. | +| **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 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. | @@ -62,11 +62,11 @@ What only the erased pass replaced is heard again. What a later pass replaced as A note held on the input is never sent twice when the loop plays the same note. -## Quantize +## Quantize and Note grid -**Quantif** 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 **Bars** bars, or one bar when Bars is 0. A score or a preset made when Quantif was a list of note values gets the grid it waited for: Whole is **1 bar**, None is None, and the others are the same note values. The rest of this section is about the notes, not the mode changes. +**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. -**Grid** (default a quarter note, **4th**) and **Quantize** (default 0) pull the notes towards a grid when they are played back. At a Quantize of 0 the notes play as recorded; at 1 they play on the grid. **Quantize 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. +**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 @@ -87,11 +87,11 @@ With **Follow tempo**, on by default, the loop plays at the tempo of the score: ## 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 120 BPM so that a quarter note is half a second of score's time, and ending exactly at the end of the loop. **Send** in the looper's view, or a drag from it, places it in the timeline as a MIDI clip that holds the notes, where the take was recorded. The file can also be opened in any other MIDI editor. **Export** chooses what a take writes: 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. +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. **Send** in the looper's view, or a drag from it, places it in the timeline as a MIDI clip that holds the notes, where the take was recorded. The file can also be opened in any other MIDI editor. **Export** chooses what a take writes: 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 has the notes where the loop plays them: **Quantize**, **Grid** and **Quantize 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. +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 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, and the loop as it is heard is written as a take of its own, its mix only. +While a recording or an overdub goes on, Send or a drag 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, and the loop as it is heard is written as a take of its own, its mix only. Mode then shows Play, and playing the score again plays the loop without recording over it. ## Reverse and speed @@ -116,7 +116,7 @@ A muted layer's notes and controllers are not heard, and it replaces nothing, so ## Capture -**Capture** makes a loop out of the last **Capture bars** bars played, recorded or not, and plays it at once; Loop shows Play. The MIDI looper always keeps the last few thousand events it received, so there is nothing to set up. +**Capture** makes a loop out of the last **Capture bars** bars played, recorded or not, and plays it at once; Mode shows Play. The MIDI looper always keeps the last few thousand events it received, so there is nothing to set up. ## Presets @@ -124,14 +124,14 @@ As for the [audio looper]({{ site.baseurl }}/processes/audio-looper.html#presets | Preset | What it is for | |---|---| -| **Song form** | Record, Play, Overdub and Play again. Quantif 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. | +| **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, 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. | | **Comping, a layer per round** | One overdub, a layer each time round the loop; takes are written as a mix and as layers. | | **Four bar phrase** | 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 phrase** | No grid, no Bars, no Late stop: the loop is as long as it was played for. | +| **Free phrase** | 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 pitch played replacing that pitch in the passes under it. | @@ -142,7 +142,16 @@ As for the [audio looper]({{ site.baseurl }}/processes/audio-looper.html#presets | **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** | Capture makes a loop of the last four bars played. | | **Takes for editing** | **Export** on Both: takes are written as a mix and as a MIDI file for each layer. | -| **Second loop of group A** | Sync group A, for a loop recorded after another one of the group. | + +## 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 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. From 5b22c2f8ae5e759fdc4eceeb15d037b2691c6abf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?= Date: Mon, 26 Oct 2026 11:41:09 -0400 Subject: [PATCH 21/29] Audio looper: takes keep their Follow tempo in the timeline Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Qr9WkcUjEGCueg7eG1KxSr --- docs/reference-manual/processes/library/audio_looper.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/docs/reference-manual/processes/library/audio_looper.md b/docs/reference-manual/processes/library/audio_looper.md index fac9dcce..d894a176 100644 --- a/docs/reference-manual/processes/library/audio_looper.md +++ b/docs/reference-manual/processes/library/audio_looper.md @@ -138,6 +138,8 @@ When a recording or an overdub ends, the loop is written to a WAV file: 32-bit f The take can also be dragged from the looper's view into the timeline, or anywhere a sound file can be dropped. +Sent or dragged, the sound file plays the way the loop did when the take was made: 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. Send, or a press in the view that starts a drag, 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 Send button says **Saving** until the take is written. Send places it as soon as it is there. A drag 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. When the score stops while a recording or an overdub goes on, the overdub's layer is closed as any, and the loop as it is heard is written as a take of its own, its mix only, even if the looper is removed right after. 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. From 03d101b3271a0ca8670e22ac38590a6ba36bc9ff Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?= Date: Mon, 26 Oct 2026 14:04:45 -0400 Subject: [PATCH 22/29] Value looper page Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Qr9WkcUjEGCueg7eG1KxSr --- .../processes/library/audio_looper.md | 2 +- .../processes/library/midi_looper.md | 2 +- .../processes/library/value_looper.md | 114 ++++++++++++++++++ 3 files changed, 116 insertions(+), 2 deletions(-) create mode 100644 docs/reference-manual/processes/library/value_looper.md diff --git a/docs/reference-manual/processes/library/audio_looper.md b/docs/reference-manual/processes/library/audio_looper.md index d894a176..c43edb55 100644 --- a/docs/reference-manual/processes/library/audio_looper.md +++ b/docs/reference-manual/processes/library/audio_looper.md @@ -15,7 +15,7 @@ permalink: /processes/audio-looper.html 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. -The [MIDI looper]({{ site.baseurl }}/processes/midi-looper.html) works the same way with notes and controllers. +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. ## Modes diff --git a/docs/reference-manual/processes/library/midi_looper.md b/docs/reference-manual/processes/library/midi_looper.md index 27db9233..cfed86b4 100644 --- a/docs/reference-manual/processes/library/midi_looper.md +++ b/docs/reference-manual/processes/library/midi_looper.md @@ -13,7 +13,7 @@ permalink: /processes/midi-looper.html ![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); this page describes what is particular to MIDI. +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). 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..4c82975c --- /dev/null +++ b/docs/reference-manual/processes/library/value_looper.md @@ -0,0 +1,114 @@ +--- +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. + +**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** tab 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 eight lanes, 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 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 a take writes: what is heard of the whole loop (**Mix**, the default), each pass in a file of its own (**Layers**), or both. + +When every value of a take is a number, a boolean, or a vector of as many numbers, **Send** in the view, or a drag from it, places it in the timeline as automations: one for each number of the values, so three for a vector of three, in one box, where the take was recorded. Each automation holds each value until the next, in steps, its minimum and maximum those of the take; it loops as the box is made longer, and can be edited, given an address or cabled as any automation. One undo removes the box. + +A take with impulses, text, lists or maps is kept as a file only: the button of the view says **File** instead of Send, and nothing is placed in the timeline. 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 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, and the loop as it is heard is written as a take of its own. + +## Reverse and speed + +**Reverse** and **Speed**, in the Play 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, 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 + +**Capture** makes a loop out of the last **Capture bars** bars of values that came in, recorded or not, and plays it at once; Mode shows Play. The loop starts with the value the input held just before those bars. The value looper always keeps the last few thousand values it received, so there is nothing to set up. + +## 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. | +| **Capture what moved** | Capture makes a loop of the last four bars of values. | +| **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. From a68b769f52b3221343a7c2f0d8c1547786f918fc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?= Date: Mon, 26 Oct 2026 14:13:52 -0400 Subject: [PATCH 23/29] Loopers: Layers tab Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Qr9WkcUjEGCueg7eG1KxSr --- docs/reference-manual/processes/library/audio_looper.md | 4 ++-- docs/reference-manual/processes/library/midi_looper.md | 2 +- docs/reference-manual/processes/library/value_looper.md | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/reference-manual/processes/library/audio_looper.md b/docs/reference-manual/processes/library/audio_looper.md index c43edb55..00d36b58 100644 --- a/docs/reference-manual/processes/library/audio_looper.md +++ b/docs/reference-manual/processes/library/audio_looper.md @@ -71,7 +71,7 @@ A recording always starts at the loop's start. ## Footswitches -The **Switches** tab has buttons made to be mapped to footswitches, MIDI notes or OSC messages. 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. +The **Switches** and **Layers** tabs have buttons made to be mapped to footswitches, MIDI notes or OSC messages: Switches holds the transport and play actions, Layers holds Undo, Redo, Clear, Layer and what acts on the selected layer. 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 | |---|---| @@ -126,7 +126,7 @@ A muted layer that is merged is left out of the merged one, and lost. 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 up to eight lanes; with more passes than that, the oldest share the first lane, which has no **x**. -- with **Layer** and **Erase layer**, in the Switches 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. +- 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. diff --git a/docs/reference-manual/processes/library/midi_looper.md b/docs/reference-manual/processes/library/midi_looper.md index cfed86b4..521f56d4 100644 --- a/docs/reference-manual/processes/library/midi_looper.md +++ b/docs/reference-manual/processes/library/midi_looper.md @@ -32,7 +32,7 @@ Controllers always replace their own earlier values over the part of the loop a ## Record, Overdub and the Switches tab -**Mode**, the **Switches** tab 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. +**Mode**, the **Switches** and **Layers** 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 | |---|---|---|---| diff --git a/docs/reference-manual/processes/library/value_looper.md b/docs/reference-manual/processes/library/value_looper.md index 4c82975c..37cb1150 100644 --- a/docs/reference-manual/processes/library/value_looper.md +++ b/docs/reference-manual/processes/library/value_looper.md @@ -49,7 +49,7 @@ When nothing changes, nothing is sent: stopping and playing again from where it ## Record, Overdub and the Switches tab -**Mode**, the **Switches** tab 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. +**Mode**, the **Switches** and **Layers** 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 From 9c40a5744ee3078a037db49daa85db661329a8a2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?= Date: Mon, 26 Oct 2026 17:28:14 -0400 Subject: [PATCH 24/29] Loopers: layer drag, Send drag, lazy layers, Speed tab, Capture in Length Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Qr9WkcUjEGCueg7eG1KxSr --- .../processes/library/audio_looper.md | 20 ++++++++--------- .../processes/library/midi_looper.md | 18 ++++++++------- .../processes/library/value_looper.md | 22 +++++++++++-------- 3 files changed, 33 insertions(+), 27 deletions(-) diff --git a/docs/reference-manual/processes/library/audio_looper.md b/docs/reference-manual/processes/library/audio_looper.md index 00d36b58..72ebd683 100644 --- a/docs/reference-manual/processes/library/audio_looper.md +++ b/docs/reference-manual/processes/library/audio_looper.md @@ -71,7 +71,7 @@ A recording always starts at the loop's start. ## Footswitches -The **Switches** and **Layers** tabs have buttons made to be mapped to footswitches, MIDI notes or OSC messages: Switches holds the transport and play actions, Layers holds Undo, Redo, Clear, Layer and what acts on the selected layer. 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. +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 | |---|---| @@ -125,7 +125,7 @@ A muted layer that is merged is left out of the merged one, and lost. 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 up to eight lanes; with more passes than that, the oldest share the first lane, which has no **x**. +- 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. @@ -134,17 +134,17 @@ Erasing the pass being overdubbed is the same as Undo: the pass is dropped and o ## 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. **Send** in 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. +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 from the looper's view into the timeline, or anywhere a sound file can be dropped. +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 the whole take, all its files. 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, the sound file plays the way the loop did when the take was made: 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. +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. Send, or a press in the view that starts a drag, 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 Send button says **Saving** until the take is written. Send places it as soon as it is there. A drag 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. +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 or stopped, 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 the loop as it is heard is written as a take of its own, its mix only, even if the looper is removed right after. 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. -**Export** chooses what a take writes: **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 all its files in one box named after the take, a slot each, the mix first; dragging it drops them all. +**Export** chooses what a take writes: **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 all its files in one box named after the take, a slot each, the mix first; dragging it from the Send button drops them all. 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. @@ -156,7 +156,7 @@ Dropping a sound file on the looper replaces the loop with it, up to Max length, **Capture** makes a loop out of what was just played, even when the looper was not recording. It takes the last **Capture bars** bars of the input and plays them at once, ending on the last grid point when that was just passed, like a late stop. Mode shows Play, so Stop stops it. -Capture needs **Keep last (s)**, 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 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. ## Monitoring @@ -179,7 +179,7 @@ The memory for these is reserved when playback starts, so changes to Max length, ## Tempo changes -**Follow tempo** chooses how a loop follows the tempo of the score, with the same methods as sound files: +**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 | |---|---| @@ -191,7 +191,7 @@ A change of Follow tempo applies from the next start of playback, as the time-st ## Reverse and speed -**Reverse** and **Speed**, in the Play tab, play the loop as a tape would be. +**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. diff --git a/docs/reference-manual/processes/library/midi_looper.md b/docs/reference-manual/processes/library/midi_looper.md index 521f56d4..66fcdd1f 100644 --- a/docs/reference-manual/processes/library/midi_looper.md +++ b/docs/reference-manual/processes/library/midi_looper.md @@ -19,7 +19,7 @@ The recording keeps its own timing: quantize, transpose and channel changes only ## 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, with Follow tempo. +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: @@ -32,21 +32,23 @@ Controllers always replace their own earlier values over the part of the loop a ## Record, Overdub and the Switches tab -**Mode**, the **Switches** and **Layers** 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. +**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 when it starts to when it stops; with **Passes** on Per cycle, one each time round; **New layer** cuts one where it is pressed. | +| **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 eight lanes, the oldest passes sharing the first lane when there are more. 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. +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 @@ -87,15 +89,15 @@ With **Follow tempo**, on by default, the loop plays at the tempo of the score: ## 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. **Send** in the looper's view, or a drag from it, places it in the timeline as a MIDI clip that holds the notes, where the take was recorded. The file can also be opened in any other MIDI editor. **Export** chooses what a take writes: 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. +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; when the take has no file of that layer, 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 a take writes: 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 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 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, and the loop as it is heard is written as a take of its own, its mix only. Mode then shows Play, and playing the score again plays the loop without recording over it. +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, and the loop as it is heard is written as a take of its own, its mix only. Mode then shows Play, and playing the score again plays the loop without recording over it. ## Reverse and speed -**Reverse** and **Speed**, in the Play tab, work as for the [audio looper]({{ site.baseurl }}/processes/audio-looper.html#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. @@ -116,7 +118,7 @@ A muted layer's notes and controllers are not heard, and it replaces nothing, so ## Capture -**Capture** makes a loop out of the last **Capture bars** bars played, recorded or not, and plays it at once; Mode shows Play. The MIDI looper always keeps the last few thousand events it received, so there is nothing to set up. +**Capture**, in the Length tab next to **Capture bars**, makes a loop out of the last Capture bars bars played, recorded or not, and plays it at once; Mode shows Play. The MIDI looper always keeps the last few thousand events it received, so there is nothing to set up. ## Presets diff --git a/docs/reference-manual/processes/library/value_looper.md b/docs/reference-manual/processes/library/value_looper.md index 37cb1150..84ce58f9 100644 --- a/docs/reference-manual/processes/library/value_looper.md +++ b/docs/reference-manual/processes/library/value_looper.md @@ -35,6 +35,8 @@ Impulses of every pass are heard: an overdub adds its impulses to the ones under 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 @@ -49,7 +51,7 @@ When nothing changes, nothing is sent: stopping and playing again from where it ## Record, Overdub and the Switches tab -**Mode**, the **Switches** and **Layers** 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. +**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 @@ -57,9 +59,9 @@ When nothing changes, nothing is sent: stopping and playing again from where it ## The view -The view shows one lane per pass, as the other loopers do: up to eight lanes, the oldest passes sharing the first lane when there are more. Each lane draws what its pass holds: +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 by its first number; +- 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. @@ -69,25 +71,27 @@ What the loop does not play there, e.g. what a later pass holds over, is dimmed. 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 a take writes: what is heard of the whole loop (**Mix**, the default), each pass in a file of its own (**Layers**), or both. -When every value of a take is a number, a boolean, or a vector of as many numbers, **Send** in the view, or a drag from it, places it in the timeline as automations: one for each number of the values, so three for a vector of three, in one box, where the take was recorded. Each automation holds each value until the next, in steps, its minimum and maximum those of the take; it loops as the box is made longer, and can be edited, given an address or cabled as any automation. One undo removes the box. +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; it loops as the box is made longer, and 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, lists or maps is kept as a file only: the button of the view says **File** instead of Send, and nothing is placed in the timeline. The file is plain JSON, and can be read by any other tool. +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 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, and the loop as it is heard is written as a take of its own. +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, and the loop as it is heard is written as a take of its own. ## Reverse and speed -**Reverse** and **Speed**, in the Play 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. +**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, 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. +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 -**Capture** makes a loop out of the last **Capture bars** bars of values that came in, recorded or not, and plays it at once; Mode shows Play. The loop starts with the value the input held just before those bars. The value looper always keeps the last few thousand values it received, so there is nothing to set up. +**Capture**, in the Length tab next to **Capture bars**, makes a loop out of the last Capture bars bars of values that came in, recorded or not, and plays it at once; Mode shows Play. The loop starts with the value the input held just before those bars. The value looper always keeps the last few thousand values it received, so there is nothing to set up. ## Comping and Start from In phase From 9e195272b7b7fd77250b3d910e5d5a075d8f36b4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?= Date: Tue, 27 Oct 2026 09:25:33 -0400 Subject: [PATCH 25/29] MIDI objects: filter selection, values out, Glide modes, Chord memory rows, Midi scale ranges Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Qr9WkcUjEGCueg7eG1KxSr --- .../processes/library/midi-filter.md | 23 +++++++ .../processes/library/midi-utilities.md | 60 +++++++++++++++++++ 2 files changed, 83 insertions(+) diff --git a/docs/reference-manual/processes/library/midi-filter.md b/docs/reference-manual/processes/library/midi-filter.md index 49754e6d..802616e9 100644 --- a/docs/reference-manual/processes/library/midi-filter.md +++ b/docs/reference-manual/processes/library/midi-filter.md @@ -34,6 +34,24 @@ 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. @@ -59,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-utilities.md b/docs/reference-manual/processes/library/midi-utilities.md index 74e99667..0100ecba 100644 --- a/docs/reference-manual/processes/library/midi-utilities.md +++ b/docs/reference-manual/processes/library/midi-utilities.md @@ -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. From 06ecb0b834d160bdfc9a49371eb87c2f5af338e0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?= Date: Tue, 27 Oct 2026 09:25:51 -0400 Subject: [PATCH 26/29] Value looper page: its image Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Qr9WkcUjEGCueg7eG1KxSr --- .../images/reference/processes/value_looper.png | Bin 0 -> 24383 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 assets/images/reference/processes/value_looper.png diff --git a/assets/images/reference/processes/value_looper.png b/assets/images/reference/processes/value_looper.png new file mode 100644 index 0000000000000000000000000000000000000000..fef7017edde8ded0893903c6af2ecc0e8fec4f17 GIT binary patch literal 24383 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

{?YsU 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 literal 0 HcmV?d00001 From 8ff6e6ee7429cf424cec048661ec2440baee39c0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?= Date: Tue, 27 Oct 2026 20:26:41 -0400 Subject: [PATCH 27/29] MIDI file scaler: MTS selects the tuning program on every channel; Send tuning; sysex reaches plug-ins whole Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Qr9WkcUjEGCueg7eG1KxSr --- .../processes/library/midi-file-scaler.md | 12 ++++++++++++ 1 file changed, 12 insertions(+) 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: From d27a60bef67fe615711652163ac85e958847a82a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?= Date: Wed, 28 Oct 2026 11:09:06 -0400 Subject: [PATCH 28/29] loopers: Capture adds a layer, takes loop wherever placed, presets renamed Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Qr9WkcUjEGCueg7eG1KxSr --- .../processes/library/audio_looper.md | 19 ++++++++++----- .../processes/library/midi_looper.md | 24 ++++++++++++------- .../processes/library/value_looper.md | 14 ++++++++--- 3 files changed, 40 insertions(+), 17 deletions(-) diff --git a/docs/reference-manual/processes/library/audio_looper.md b/docs/reference-manual/processes/library/audio_looper.md index 72ebd683..71d32e34 100644 --- a/docs/reference-manual/processes/library/audio_looper.md +++ b/docs/reference-manual/processes/library/audio_looper.md @@ -154,9 +154,16 @@ Dropping a sound file on the looper replaces the loop with it, up to Max length, ## Capture -**Capture** makes a loop out of what was just played, even when the looper was not recording. It takes the last **Capture bars** bars of the input and plays them at once, ending on the last grid point when that was just passed, like a late stop. Mode shows Play, so Stop stops it. +**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. -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. +- **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 @@ -231,14 +238,14 @@ The position comes from where the loop was recorded on the timeline. Without Fol ## Presets -The library has presets for the usual ways of looping. Each one sets every setting of the looper, so loading one after another leaves nothing of the one before. They are quantized to the bar unless said otherwise. +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, with a Late stop of 250 ms for a foot that is a little late on the downbeat. | +| **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. | +| **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. | @@ -248,7 +255,7 @@ The library has presets for the usual ways of looping. Each one sets every setti | **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, for Capture to make a loop of its last four bars. | +| **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 diff --git a/docs/reference-manual/processes/library/midi_looper.md b/docs/reference-manual/processes/library/midi_looper.md index 66fcdd1f..63f9679a 100644 --- a/docs/reference-manual/processes/library/midi_looper.md +++ b/docs/reference-manual/processes/library/midi_looper.md @@ -89,7 +89,7 @@ With **Follow tempo**, on by default, the loop plays at the tempo of the score: ## 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; when the take has no file of that layer, 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 a take writes: 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. +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 a take writes: 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 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. @@ -118,7 +118,16 @@ A muted layer's notes and controllers are not heard, and it replaces nothing, so ## Capture -**Capture**, in the Length tab next to **Capture bars**, makes a loop out of the last Capture bars bars played, recorded or not, and plays it at once; Mode shows Play. The MIDI looper always keeps the last few thousand events it received, so there is nothing to set up. +**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 @@ -127,22 +136,21 @@ As for the [audio looper]({{ site.baseurl }}/processes/audio-looper.html#presets | 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, with a Late stop of 250 ms. | +| **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. | +| **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 bar phrase** | A recording of four bars, then plays it. | +| **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 phrase** | No grid, no Record bars, no Late stop: the loop is as long as it was played for. | +| **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 pitch played replacing that pitch in the passes under it. | +| **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. | -| **Capture what I played** | Capture makes a loop of the last four bars played. | | **Takes for editing** | **Export** on Both: takes are written as a mix and as a MIDI file for each layer. | ## Older scores diff --git a/docs/reference-manual/processes/library/value_looper.md b/docs/reference-manual/processes/library/value_looper.md index 84ce58f9..b949a005 100644 --- a/docs/reference-manual/processes/library/value_looper.md +++ b/docs/reference-manual/processes/library/value_looper.md @@ -71,7 +71,7 @@ What the loop does not play there, e.g. what a later pass holds over, is dimmed. 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 a take writes: what is heard of the whole loop (**Mix**, the default), each pass in a file of its own (**Layers**), or both. -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; it loops as the box is made longer, and can be edited, given an address or cabled as any automation. One undo removes the box. +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. @@ -91,7 +91,16 @@ With **Follow tempo**, on by default and in the Speed tab, the loop plays at the ## Capture -**Capture**, in the Length tab next to **Capture bars**, makes a loop out of the last Capture bars bars of values that came in, recorded or not, and plays it at once; Mode shows Play. The loop starts with the value the input held just before those bars. The value looper always keeps the last few thousand values it received, so there is nothing to set up. +**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 @@ -106,7 +115,6 @@ Each preset sets every setting; mode changes wait for the bar unless said otherw | **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. | -| **Capture what moved** | Capture makes a loop of the last four bars of values. | | **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 From 4dc0f96810be0fd8a1e51568add9df339dcaf1eb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Micha=C3=ABl=20Celerier?= Date: Wed, 28 Oct 2026 16:23:49 -0400 Subject: [PATCH 29/29] loopers: Export chooses what Send places; takes are whole once the score stops Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01Qr9WkcUjEGCueg7eG1KxSr --- docs/reference-manual/processes/library/audio_looper.md | 8 ++++---- docs/reference-manual/processes/library/midi_looper.md | 4 ++-- docs/reference-manual/processes/library/value_looper.md | 4 ++-- 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/docs/reference-manual/processes/library/audio_looper.md b/docs/reference-manual/processes/library/audio_looper.md index 71d32e34..99c0908a 100644 --- a/docs/reference-manual/processes/library/audio_looper.md +++ b/docs/reference-manual/processes/library/audio_looper.md @@ -136,15 +136,15 @@ Erasing the pass being overdubbed is the same as Undo: the pass is dropped and o 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 the whole take, all its files. 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. +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 or stopped, nothing is being taken in any more, and Send and the drags give the last take there is. +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 the loop as it is heard is written as a take of its own, its mix only, even if the looper is removed right after. 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. +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 a take writes: **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 all its files in one box named after the take, a slot each, the mix first; dragging it from the Send button drops them all. +**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. diff --git a/docs/reference-manual/processes/library/midi_looper.md b/docs/reference-manual/processes/library/midi_looper.md index 63f9679a..9c06dd88 100644 --- a/docs/reference-manual/processes/library/midi_looper.md +++ b/docs/reference-manual/processes/library/midi_looper.md @@ -89,11 +89,11 @@ With **Follow tempo**, on by default, the loop plays at the tempo of the score: ## 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 a take writes: 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. +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, and the loop as it is heard is written as a take of its own, its mix only. Mode then shows Play, and playing the score again plays the loop without recording over it. +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 diff --git a/docs/reference-manual/processes/library/value_looper.md b/docs/reference-manual/processes/library/value_looper.md index b949a005..dc5fa122 100644 --- a/docs/reference-manual/processes/library/value_looper.md +++ b/docs/reference-manual/processes/library/value_looper.md @@ -69,7 +69,7 @@ What the loop does not play there, e.g. what a later pass holds over, is dimmed. ## 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 a take writes: what is heard of the whole loop (**Mix**, the default), each pass in a file of its own (**Layers**), or both. +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. @@ -77,7 +77,7 @@ Dragging a lane places that layer alone, as automations in a box of its own, whe 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, and the loop as it is heard is written as a take of its own. +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