rm errorlogger console

Reviewed-on: https://codeberg.org/uzu/strudel/pulls/1532

packages/core/logger.mjs

@@ -6,7 +6,7 @@ let debounce = 1000,
 
 export function errorLogger(e, origin = 'cyclist') {
   //TODO: add some kind of debug flag that enables this  while in dev mode
-  console.error(e);
+  // console.error(e);
   logger(`[${origin}] error: ${e.message}`);
 }
 

packages/osc/superdirtoutput.js

@@ -6,5 +6,5 @@ const trigger = /* isTauri() ? oscTriggerTauri : */ oscTrigger;
 
 export const superdirtOutput = (hap, deadline, hapDuration, cps, targetTime) => {
   const currentTime = performance.now() / 1000;
-  return trigger(null, hap, currentTime, cps, targetTime);
+  return trigger(hap, currentTime, cps, targetTime);
 };

packages/sampler/sample-server.mjs

@@ -1,14 +1,20 @@
 #!/usr/bin/env node
 
 import cowsay from 'cowsay';
-import { createReadStream, existsSync } from 'fs';
+import { createReadStream, existsSync, writeFileSync } from 'fs';
 import { readdir } from 'fs/promises';
 import http from 'http';
-import { join, sep } from 'path';
+import { join, resolve, sep } from 'path';
+import readline from 'readline';
 import os from 'os';
 
-// eslint-disable-next-line
 const LOG = !!process.env.LOG || false;
+const VALID_AUDIO_EXTENSIONS = ['wav', 'mp3', 'ogg'];
+
+const isAudioFile = (f) => {
+  const ext = f.split('.').slice(-1)[0].toLowerCase();
+  return VALID_AUDIO_EXTENSIONS.includes(ext);
+};
 
 async function getFilesInDirectory(directory) {
   let files = [];
@@ -21,32 +27,32 @@ async function getFilesInDirectory(directory) {
         continue;
       }
       try {
-        const subFiles = (await getFilesInDirectory(fullPath)).filter((f) =>
-          ['wav', 'mp3', 'ogg'].includes(f.split('.').slice(-1)[0].toLowerCase()),
-        );
+        const subFiles = (await getFilesInDirectory(fullPath)).filter(isAudioFile);
         files = files.concat(subFiles);
         LOG && console.log(`${dirent.name} (${subFiles.length})`);
       } catch (err) {
         LOG && console.warn(`skipped due to error: ${fullPath}`);
       }
     } else {
-      files.push(fullPath);
+      isAudioFile(fullPath) && files.push(fullPath);
     }
   }
   return files;
 }
 
-async function getBanks(directory) {
+async function getBanks(directory, flat = false) {
   let files = await getFilesInDirectory(directory);
   let banks = {};
   directory = directory.split(sep).join('/');
   files = files.map((path) => {
     path = path.split(sep).join('/');
-    const [bank] = path.split('/').slice(-2);
+    const subDir = path.replace(directory, '');
+    const subDirFlat = subDir.replaceAll('/', '_').slice(1); // remove initial underscore
+    const subDirFlatStem = subDirFlat.replace(/\.[^.]+$/, ''); // remove extension
+    let bank = flat ? subDirFlatStem : path.split('/').slice(-2)[0];
     banks[bank] = banks[bank] || [];
-    const relativeUrl = path.replace(directory, '');
-    banks[bank].push(relativeUrl);
-    return relativeUrl;
+    banks[bank].push(subDir);
+    return subDir;
   });
   banks._base = `http://localhost:5432`;
   return { banks, files };
@@ -54,14 +60,44 @@ async function getBanks(directory) {
 
 const args = process.argv.slice(2);
 
-// eslint-disable-next-line
-const directory = process.cwd();
+function getArgValue(flag) {
+  const i = args.indexOf(flag);
+  if (i !== -1) {
+    const nextIsFlag = args[i + 1]?.startsWith('--') ?? true;
+    if (nextIsFlag) return true;
+    return args[i + 1];
+  }
+}
 
+function getInput(query) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) =>
+    rl.question(query, (response) => {
+      rl.close();
+      resolve(response);
+    }),
+  );
+}
+
+let directory = getArgValue('--dir') || process.cwd();
+directory = resolve(directory);
 if (args.includes('--json')) {
-  const { banks, files } = await getBanks(directory);
+  const { banks } = await getBanks(directory, getArgValue('--flat'));
   const json = JSON.stringify(banks);
-  console.log(json);
-  process.exit(0);
+  const outFile = resolve(directory, 'strudel.json');
+  if (existsSync(outFile)) {
+    const answer = await getInput(`Warning: File already exists at ${outFile}. Overwrite? (y/N): `);
+    if (answer.toLowerCase() !== 'y') {
+      console.log('Aborted.');
+      process.exit(0);
+    }
+  }
+  writeFileSync(outFile, json, 'utf8');
+  console.log(`Wrote json to ${outFile}`);
 }
 
 console.log(
@@ -74,7 +110,7 @@ console.log(
 
 const server = http.createServer(async (req, res) => {
   res.setHeader('Access-Control-Allow-Origin', '*');
-  const { banks, files } = await getBanks(directory);
+  const { banks, files } = await getBanks(directory, getArgValue('--flat'));
   if (req.url === '/') {
     res.setHeader('Content-Type', 'application/json');
     return res.end(JSON.stringify(banks));
@@ -82,7 +118,7 @@ const server = http.createServer(async (req, res) => {
   let subpath = decodeURIComponent(req.url);
   const filePath = join(directory, subpath.split('/').join(sep));
 
-  //console.log('GET:', filePath);
+  // console.log('GET:', filePath);
   const isFound = existsSync(filePath);
   if (!isFound) {
     res.statusCode = 404;

website/src/pages/learn/effects.mdx

@@ -11,6 +11,129 @@ import { JsDoc } from '../../docs/JsDoc';
 Whether you're using a synth or a sample, you can apply any of the following built-in audio effects.
 As you might suspect, the effects can be chained together, and they accept a pattern string as their argument.
 
+# Signal chain
+
+<img src="/img/strudel-signal-flow.png"></img>
+
+The signal chain in Strudel is as follows:
+
+- An sound-generating event is triggered by a pattern
+  - This has a start time and a duration, which is usually
+    controlled by the note length and ADSR parameters
+  - If we exceed the max polyphony, old sounds begin to die off
+  - Muted sounds (one whose `s` value is `-`, `~`, or `_`) are skipped
+- A sound is produced (through, say, a sample or an oscillator)
+  - This is where detune-based effects (like `detune`, `penv`, etc. occur)
+- The following will occur _in order_ and only if they've been called in the pattern. Note that all of these are
+  single use effects, meaning that multiple occurrences of them in a pattern will simply override the values
+  (e.g. you can't do `s("bd").lpf(100).distort(2).lpf(800)` to lowpass, distort, and then lowpass
+  again)
+  - Phase vocoder (`stretch`)
+  - Gain is applied (`gain`)
+    - This is where the main (volume) ADSR happens
+  - A lowpass filter (`lpf`)
+  - A highpass filter (`hpf`)
+  - A bandpass filter (`bandpass`)
+  - A vowel filter (`vowel`)
+  - Sample rate reduction (`coarse`)
+  - Bit crushing (`crush`)
+  - Waveshape distortion (`shape`)
+  - Normal distortion (`distort`)
+  - Tremolo (`tremolo`)
+  - Compressor (`compressor`)
+  - Panning (`pan`)
+  - Phaser (`phaser`)
+  - Postgain (`post`)
+- The sound is then split into multiple destinations
+  - Dry output (amount controlled by `dry` parameter)
+  - The sends
+    - Analyzers
+      - These are used for tooling like `scope` and `spectrum` and their setup usually happens behind the scenes
+    - Delay (amount controlled by `delay` parameter)
+    - Reverb (amount controlled by `room` parameter)
+- The dry output, delay, and reverb are joined into what is called the "orbit" of the pattern (see more in the section below)
+  - The `duck` effect affects the volume of all signals in the orbit
+  - The orbit is then sent to the mixer
+
+## Orbits
+
+Orbits are the way in which outputs are handled in Strudel. They also prescribe which delay and reverb to associate with the dry signal.
+By default, all orbits are mixed down to channels `1` and `2` in stereo, however with the "Multi Channel Orbits" setting
+(under Settings at the right) you can use them as individual 2 channel stereo outs (orbit `i` will be mapped to
+to channels `2i` and `2i + 1`). You can then use routers like Blackhole 16 to retrieve and record all of the channels in a DAW for later processing.
+
+The default orbit is `1` and it is set with `orbit`. You may send a sound to multiple orbits via mininotation
+
+<MiniRepl client:visible tune={`s("white").orbit("2,3,4").gain(0.2)`} />
+
+but please be careful as this will create three copies of the sound behind the scenes, meaning that if they are mixed
+down to a single output, they will triple the volume. We've reduced the gain here to save your ears.
+
+⚠️ There is only one delay and reverb per orbit, so please be aware that if you attempt to change the parameters on two
+patterns pointing to the same orbit, it can lead to unpredictable results. Compare, for example, this pretty pluck
+with a large reverb:
+
+<MiniRepl
+  client:visible
+  tune={`
+$: s("triangle*4").decay(0.5).n(irand(12)).scale('C minor')
+  .room(1).roomsize(10)`}
+/>
+
+versus the same pluck with a muted kick drum coming in and overwriting the `roomsize` value:
+
+<MiniRepl
+  client:visible
+  tune={`
+$: s("triangle*4").decay(0.5).n(irand(12)).scale('C minor')
+  .room(1).roomsize(10)
+
+$: s("bd\*4").room(0.01).roomsize(0.01).postgain(0)`}
+/>
+
+This is due to them sharing the same orbit: the default of `1`. It can be corrected simply by updating the orbits to be
+distinct:
+
+<MiniRepl
+  client:visible
+  tune={`
+$: s("triangle*4").decay(0.5).n(irand(12)).scale('C minor')
+  .room(1).roomsize(10).orbit(2)
+
+$: s("bd\*4").room(0.01).roomsize(0.01).postgain(0)`}
+/>
+
+## Continuous changes
+
+As all of the above is triggered by a _sound occurring_, it is often the case that parameters may not be
+modified continuously in time. For example,
+
+<MiniRepl
+  client:visible
+  tune={`
+s("supersaw").lpf(tri.range(100, 5000).slow(2))`}
+/>
+
+Will not produce a continually LFO'd low-pass filter due to the `tri` only being sampled every time the note hits
+(in this case the default of once per cycle). You can fake it by introducing more sound-generating events, e.g.:
+
+<MiniRepl
+  client:visible
+  tune={`
+s("supersaw").seg(16).lpf(tri.range(100, 5000).slow(2))`}
+/>
+
+Some parameters _do_ induce continuous variations in time, though:
+
+- The ADSR curve (governed by `attack`, `sustain`, `decay`, `release`)
+- The pitch envelope curve (governed by `penv` and its associated ADSR)
+- The FM curve (`fmenv`)
+- The filter envelopes (`lpenv`, `hpenv`, `bpenv`)
+- Tremolo (`tremolo`)
+- Phaser (`phaser`)
+- Vibrato (`vib`)
+- Ducking (`duckorbit`)
+
 # Filters
 
 Filters are an essential building block of [subtractive synthesis](https://en.wikipedia.org/wiki/Subtractive_synthesis).

website/src/pages/learn/mini-notation.mdx

@@ -168,6 +168,20 @@ Using "!" we can repeat without speeding up:
 
 <MiniRepl client:idle tune={`note("<[g3,b3,e4]!2 [a3,c3,e4] [b3,d3,f#4]>*2")`} punchcard />
 
+## Randomness
+
+Events with a "?" placed after them will have a 50% chance of being removed from the pattern:
+
+<MiniRepl client:idle tune={`note("[g3,b3,e4]*8?")`} punchcard />
+
+Adding a number between 0 and 1 after the "?" will affect the likelihood of the event being removed. For example, events with "?0.1" placed after them will have a 10% chance of being removed:
+
+<MiniRepl client:idle tune={`note("[g3,b3,e4]*8?0.1")`} punchcard />
+
+Events separated by a "|" will be chosen from at random:
+
+<MiniRepl client:idle tune={`note("[g3,b3,e4] | [a3,c3,e4] | [b3,d3,f#4]")`} punchcard />
+
 ## Mini-notation review
 
 To recap what we've learned so far, compare the following patterns:
@@ -179,6 +193,8 @@ To recap what we've learned so far, compare the following patterns:
 <MiniRepl client:idle tune={`note("<[g3,b3,e4] _ [a3,c3,e4] [b3,d3,f#4]>*2")`} />
 <MiniRepl client:idle tune={`note("<[g3,b3,e4]@2 [a3,c3,e4] [b3,d3,f#4]>*2")`} />
 <MiniRepl client:idle tune={`note("<[g3,b3,e4]!2 [a3,c3,e4] [b3,d3,f#4]>*2")`} />
+<MiniRepl client:idle tune={`note("<[g3,b3,e4]? [a3,c3,e4] [b3,d3,f#4]>*2")`} />
+<MiniRepl client:idle tune={`note("<[g3|b3|e4] [a3,c3,e4] [b3,d3,f#4]>*2")`} />
 
 ## Euclidian rhythms