@audiofab-io/fv1-core 0.2.2 → 0.4.0

package/blocks/effects/lo-fi/chiptune.atl

@@ -0,0 +1,311 @@
+---
+{
+  "type": "effects.novelty.chiptune",
+  "name": "Chip Tune",
+  "category": "Effects",
+  "subcategory": "Lo-Fi",
+  "description": "Commodore 64 SID chip emulator: Transforms your guitar into 8-bit chiptune glory with bit crushing, square-wave shaping, ring modulation, white noise, and the legendary SID resonant filter.",
+  "color": "#4466BB",
+  "width": 180,
+  "inputs": [
+    {
+      "id": "in",
+      "name": "Input",
+      "type": "audio",
+      "required": true
+    },
+    {
+      "id": "crushCV",
+      "name": "Crush",
+      "type": "control",
+      "required": false,
+      "parameter": "crush"
+    },
+    {
+      "id": "squareCV",
+      "name": "Square",
+      "type": "control",
+      "required": false,
+      "parameter": "square"
+    },
+    {
+      "id": "cutoffCV",
+      "name": "Cutoff",
+      "type": "control",
+      "required": false,
+      "parameter": "cutoff"
+    },
+    {
+      "id": "resoCV",
+      "name": "Resonance",
+      "type": "control",
+      "required": false,
+      "parameter": "resonance"
+    }
+  ],
+  "outputs": [
+    {
+      "id": "out",
+      "name": "Output",
+      "type": "audio"
+    }
+  ],
+  "parameters": [
+    {
+      "id": "crush",
+      "name": "Crush Depth",
+      "type": "number",
+      "default": 0.2,
+      "min": 0.005,
+      "max": 0.25,
+      "step": 0.005,
+      "description": "Sample-rate reduction intensity. Higher = more lo-fi 8-bit crunch."
+    },
+    {
+      "id": "square",
+      "name": "Square Drive",
+      "type": "number",
+      "default": 0.5,
+      "min": 0.0,
+      "max": 1.99,
+      "step": 0.01,
+      "description": "Blend from clean (0) to hard-clipped square pulse waveform (max)."
+    },
+    {
+      "id": "ring_freq",
+      "name": "Ring Mod",
+      "type": "number",
+      "default": 0.0,
+      "min": 0.0,
+      "max": 1.0,
+      "step": 0.01,
+      "description": "Ring modulator frequency. 0 = off. Adds metallic SID harmonics."
+    },
+    {
+      "id": "noise",
+      "name": "Noise Level",
+      "type": "number",
+      "default": 0.5,
+      "min": 0.0,
+      "max": 1.0,
+      "step": 0.01,
+      "description": "White noise generator level. Classic SID noise channel for hi-hats, snares, and static textures."
+    },
+    {
+      "id": "cutoff",
+      "name": "Filter Cutoff",
+      "type": "number",
+      "default": 3000,
+      "min": 60,
+      "max": 6000,
+      "step": 10,
+      "conversion": "SVFFREQ",
+      "description": "SID-style resonant low-pass filter cutoff frequency."
+    },
+    {
+      "id": "resonance",
+      "name": "Filter Resonance",
+      "type": "number",
+      "default": 4.0,
+      "min": 0.5,
+      "max": 20.0,
+      "step": 0.1,
+      "conversion": "SVF_DAMP",
+      "description": "Filter Q. Crank it for that classic SID filter sweep character."
+    },
+    {
+      "id": "mix",
+      "name": "Dry/Wet Mix",
+      "type": "number",
+      "default": 1.0,
+      "min": 0.0,
+      "max": 1.0,
+      "step": 0.01,
+      "description": "Blend between dry and SID-processed signal."
+    }
+  ],
+  "registers": [
+    "counter",
+    "held",
+    "squared",
+    "ring_sin",
+    "ring_cos",
+    "f_ring",
+    "ringmod",
+    "noise_reg",
+    "noise_dc",
+    "lp_state",
+    "bp_state",
+    "damp_reg",
+    "dry",
+    "wet",
+    "mix_val"
+  ]
+}
+---
+@section header
+  equ damp_target (${param.resonance})
+
+@section init
+  ; Seed the ring mod oscillator (cos=0.5, sin=0)
+  ; Without this, the magic circle stays at zero forever!
+  sof 0.0, 0.5
+  wrax ${reg.ring_cos}, 0.0
+
+  ; Seed the noise LFSR with a non-zero, non-one starting value
+  sof 0.0, 0.3
+  wrax ${reg.noise_reg}, 0.0
+
+@section main
+  @if pinConnected(in)
+
+  ; ======================================================
+  ; Stage 0: Save dry signal for mix
+  ; ======================================================
+  rdax ${input.in}, 1.0
+  wrax ${reg.dry}, 0.0
+
+  ; ======================================================
+  ; Stage 1: Sample-Rate Reduction (SID S&H Bit Crush)
+  ; ======================================================
+  skp run, ${local.SKIP_INIT}
+  rdax ${input.in}, 1.0
+  wrax ${reg.held}, 0.0
+  ${local.SKIP_INIT}:
+
+  ; Counter increment: inverted crush so higher = more crushed
+  ; step = 0.255 - crush_value (smaller step = slower S&H = more lo-fi)
+  rdax ${reg.counter}, 1.0
+  wrax ${reg.counter}, 0.0
+  @cv crushCV                      ; ACC = crush depth (0.005..0.25)
+  sof -1.0, 0.255                  ; ACC = 0.255 - crush = step size
+  rdax ${reg.counter}, 1.0         ; ACC = counter + step
+  wrax ${reg.counter}, 1.0
+
+  sof 1.0, -0.99
+  skp neg, ${local.SKIP_SAMPLE}
+
+  clr
+  rdax ${input.in}, 1.0
+  wrax ${reg.held}, 0.0
+  sof 0.0, 0.0
+  wrax ${reg.counter}, 0.0
+
+  ${local.SKIP_SAMPLE}:
+
+  ; ======================================================
+  ; Stage 2: Square Wave Shaping (SID Pulse Oscillator)
+  ; ======================================================
+  clr
+  rdax ${reg.held}, 1.0
+  sof 1.99, 0.0
+  sof -1.99, 0.0
+  sof -1.99, 0.0
+  sof 0.5, 0.0
+  wrax ${reg.squared}, 0.0
+
+  ; Crossfade: out = held + (squared - held) * squareDrive
+  rdax ${reg.squared}, 1.0
+  rdax ${reg.held}, -1.0
+  wrax ${reg.mix_val}, 0.0         ; Save (squared - held), clear ACC
+  @cv squareCV                     ; ACC = square drive value
+  mulx ${reg.mix_val}              ; ACC = (squared - held) * drive
+  rdax ${reg.held}, 1.0            ; ACC = held + (squared - held) * drive
+  wrax ${reg.squared}, 0.0
+
+  ; ======================================================
+  ; Stage 3: Ring Modulation (SID Ring Mod)
+  ; ======================================================
+  sof 0.0, ${param.ring_freq}
+  sof 0.15, 0.0
+  wrax ${reg.f_ring}, 0.0
+
+  ; Magic circle sine oscillator (seeded in init!)
+  rdax ${reg.ring_sin}, -1.0
+  mulx ${reg.f_ring}
+  rdax ${reg.ring_cos}, 1.0
+  wrax ${reg.ring_cos}, 1.0
+  mulx ${reg.f_ring}
+  rdax ${reg.ring_sin}, 1.0
+  wrax ${reg.ring_sin}, 0.0
+
+  ; Ring mod = squared * carrier
+  rdax ${reg.squared}, 1.0
+  mulx ${reg.ring_sin}
+  sof 1.99, 0.0
+  wrax ${reg.ringmod}, 0.0
+
+  ; Crossfade by ring_freq: 0 = all squared, 1 = all ring
+  sof 0.0, ${param.ring_freq}
+  wrax ${reg.mix_val}, 0.0
+  rdax ${reg.ringmod}, 1.0
+  rdax ${reg.squared}, -1.0
+  mulx ${reg.mix_val}
+  rdax ${reg.squared}, 1.0
+  wrax ${reg.wet}, 0.0
+
+  ; ======================================================
+  ; Stage 3.5: SID Noise Channel (Tent Map + DC Blocker)
+  ; ======================================================
+  ; Tent map: x_next ≈ 1 - 2|x|  (chaotic noise source)
+  ; FV-1 can't represent exact coefficients 2/1, so the raw
+  ; output has a slight positive mean. A DC-blocking LP filter
+  ; tracks and removes it for guaranteed zero-mean noise.
+  rdax ${reg.noise_reg}, 1.0       ; ACC = x
+  absa                              ; ACC = |x|
+  sof -1.99, 0.999                  ; ACC ≈ 1 - 2|x| — tent map
+  wrax ${reg.noise_reg}, 0.0       ; Save x_next, ACC = 0
+
+  ; DC blocker: track running average with ultra-slow LP
+  rdax ${reg.noise_dc}, 1.0        ; ACC = old DC estimate
+  rdfx ${reg.noise_reg}, 0.001     ; ACC = DC_old*0.999 + noise*0.001
+  wrax ${reg.noise_dc}, -1.0       ; Save new DC estimate, ACC = -DC
+  rdax ${reg.noise_reg}, 1.0       ; ACC = noise - DC = zero-mean noise
+
+  ; Scale by noise level and add to wet signal
+  ; Noise needs ~12dB pre-boost because the SID filter downstream
+  ; heavily attenuates high-frequency content where most noise energy lives
+  sof 1.99, 0.0
+  sof 1.99, 0.0
+  sof ${param.noise}, 0.0
+  rdax ${reg.wet}, 1.0
+  wrax ${reg.wet}, 0.0
+
+  ; ======================================================
+  ; Stage 4: SID Filter (Resonant SVF Low-Pass)
+  ; ======================================================
+  ; Load damping coefficient (resonance CV or fixed parameter)
+  @cv resoCV
+  wrax ${reg.damp_reg}, 0.0
+
+  ; Load cutoff coefficient
+  @cv cutoffCV
+  wrax ${reg.mix_val}, 0.0
+
+  ; Chamberlin SVF: HP → BP → LP
+  rdax ${reg.wet}, 1.0
+  rdax ${reg.lp_state}, -1.0
+  wrax ${reg.wet}, 0.0              ; Reuse wet as temp = (input - lp_old)
+  rdax ${reg.bp_state}, 1.0
+  mulx ${reg.damp_reg}              ; ACC = bp_old * damp
+  rdax ${reg.wet}, -1.0             ; ACC = -(input - lp_old) + bp_old * damp = -(HP)
+  sof -1.0, 0.0                    ; ACC = HP
+  mulx ${reg.mix_val}               ; ACC = F * HP
+  rdax ${reg.bp_state}, 1.0         ; ACC = bp_old + F * HP = bp_new
+  wrax ${reg.bp_state}, 1.0         ; Save bp, keep in ACC
+  mulx ${reg.mix_val}               ; ACC = F * bp_new
+  rdax ${reg.lp_state}, 1.0         ; ACC = lp_old + F * bp_new = lp_new
+  wrax ${reg.lp_state}, 0.0
+
+  ; ======================================================
+  ; Stage 5: Dry/Wet Mix
+  ; ======================================================
+  rdax ${reg.lp_state}, 1.0
+  rdax ${reg.dry}, -1.0
+  sof ${param.mix}, 0.0
+  rdax ${reg.dry}, 1.0
+  wrax ${output.out}, 0.0
+
+  @else
+  ; Bypassed
+  @endif

package/blocks/effects/lo-fi/tape_degrade.atl

@@ -0,0 +1,181 @@
+---
+{
+  "type": "fx.tape_degrade",
+  "name": "Tape Degrader",
+  "category": "Effects",
+  "subcategory": "Lo-Fi",
+  "description": "Simulates tape wow, flutter, and top-end age loss.",
+  "color": "#24F2F2",
+  "width": 180,
+  "inputs": [
+    {
+      "id": "in",
+      "name": "Input",
+      "type": "audio",
+      "required": true
+    },
+    {
+      "id": "wow_rate_cv",
+      "name": "Wow Rate",
+      "type": "control",
+      "required": false,
+      "parameter": "wow_rate"
+    },
+    {
+      "id": "wow_depth_cv",
+      "name": "Wow Depth",
+      "type": "control",
+      "required": false,
+      "parameter": "wow_depth"
+    },
+    {
+      "id": "flutter_rate_cv",
+      "name": "Flutter Rate",
+      "type": "control",
+      "required": false,
+      "parameter": "flutter_rate"
+    },
+    {
+      "id": "flutter_depth_cv",
+      "name": "Flutter Depth",
+      "type": "control",
+      "required": false,
+      "parameter": "flutter_depth"
+    }
+  ],
+  "outputs": [
+    {
+      "id": "out",
+      "name": "Output",
+      "type": "audio"
+    }
+  ],
+  "parameters": [
+    {
+      "id": "wow_rate",
+      "name": "Wow Rate (Hz)",
+      "type": "number",
+      "default": 0.5,
+      "min": 0.1,
+      "max": 2.0,
+      "step": 0.01,
+      "conversion": "HZ_TO_LFO_RATE"
+    },
+    {
+      "id": "wow_depth",
+      "name": "Wow Depth (ms)",
+      "type": "number",
+      "default": 1.5,
+      "min": 0,
+      "max": 5.0,
+      "step": 0.1,
+      "conversion": "MS_TO_LFO_RANGE"
+    },
+    {
+      "id": "flutter_rate",
+      "name": "Flutter Rate (Hz)",
+      "type": "number",
+      "default": 12.0,
+      "min": 5.0,
+      "max": 20.0,
+      "step": 0.1,
+      "conversion": "HZ_TO_LFO_RATE"
+    },
+    {
+      "id": "flutter_depth",
+      "name": "Flutter Depth (ms)",
+      "type": "number",
+      "default": 0.2,
+      "min": 0,
+      "max": 1.5,
+      "step": 0.01,
+      "conversion": "MS_TO_LFO_RANGE"
+    },
+    {
+      "id": "age",
+      "name": "Tape Age (Tone)",
+      "type": "number",
+      "default": 0.3,
+      "min": 0.01,
+      "max": 1.0,
+      "step": 0.01,
+      "description": "1.0 is bright, lower is darker (aged tape)."
+    }
+  ],
+  "memories": [
+    {
+      "id": "tape_buffer",
+      "size": 4096
+    }
+  ],
+  "registers": [
+    "wow_temp",
+    "lpf_lp"
+  ]
+}
+---
+@section init
+  skp run, init_tape
+  wlds SIN0, ${wow_rate}, ${wow_depth}
+  wlds SIN1, ${flutter_rate}, ${flutter_depth}
+  init_tape:
+
+@section main
+  ; CV Modulation for Wow/Flutter 
+  ; Since rates are HZ_TO_LFO_RATE, we must scale them manually
+  @if pinConnected(wow_rate_cv)
+    rdax ${input.wow_rate_cv}, ${wow_rate} / 511.0
+    wrax SIN0_RATE, 0.0
+  @endif
+  
+  ; Depths are MS_TO_LFO_RANGE which goes up to 32767. So scale / 32767.0
+  @if pinConnected(wow_depth_cv)
+    rdax ${input.wow_depth_cv}, ${wow_depth} / 32767.0
+    wrax SIN0_RANGE, 0.0
+  @endif
+
+  @if pinConnected(flutter_rate_cv)
+    rdax ${input.flutter_rate_cv}, ${flutter_rate} / 511.0
+    wrax SIN1_RATE, 0.0
+  @endif
+  
+  @if pinConnected(flutter_depth_cv)
+    rdax ${input.flutter_depth_cv}, ${flutter_depth} / 32767.0
+    wrax SIN1_RANGE, 0.0
+  @endif
+
+  ; Write to Tape
+  rdax ${input.in}, 1.0
+  wra ${mem.tape_buffer}, 0.0
+
+  ; Read Wow Tape Head (SIN0)
+  @equals center ${mem.tape_buffer} + 2048
+  cho rda, SIN0, SIN | REG | COMPC, ${center}
+  cho rda, SIN0, SIN, ${center} + 1
+  
+  ; Modulate with Flutter (SIN1) off the same base, summing them creates composite warble
+  ; Actually, FV-1 CHO adds to ACC! So we just do another CHO RDA but without REG tracking?
+  ; To maintain unity volume, we shouldn't add audio signals, we should add address offsets.
+  ; But we can't add address offsets in SpinASM dynamically easily. 
+  ; Instead, we just read from the buffer with Flutter and average the two reads!
+  ; Multiply Wow read by 0.5
+  sof 0.5, 0.0
+  wrax ${reg.wow_temp}, 0.0 ; Hold Wow audio separately from LPF state
+
+  ; Read Flutter Tape Head (SIN1)
+  cho rda, SIN1, SIN | REG | COMPC, ${center}
+  cho rda, SIN1, SIN, ${center} + 1
+  sof 0.5, 0.0
+
+  ; Combine Wow and Flutter audio signals
+  rdax ${reg.wow_temp}, 1.0
+
+  ; Tape Age Degradation (1-Pole Lowpass: L_new = L_old + Age * (I - L_old))
+  ; ACC = composite warble (wow*0.5 + flutter*0.5)
+  rdax ${reg.lpf_lp}, -1.0          ; ACC = I - L_old
+  sof ${param.age}, 0.0             ; ACC = Age * (I - L_old)
+  rdax ${reg.lpf_lp}, 1.0           ; ACC = L_old + Age * (I - L_old) = L_new
+  wrax ${reg.lpf_lp}, 1.0           ; Save new state and keep L_new in ACC
+
+  ; Export
+  wrax ${output.out}, 0.0

package/blocks/effects/modulation/chorus.atl

@@ -0,0 +1,141 @@
+---
+{
+  "type": "fx.chorus",
+  "name": "Chorus",
+  "category": "Effects",
+  "subcategory": "Modulation",
+  "description": "Classic chorus with LFO-modulated delay",
+  "color": "#24f2f2",
+  "width": 180,
+  "inputs": [
+    {
+      "id": "in",
+      "name": "Input",
+      "type": "audio",
+      "required": true
+    },
+    {
+      "id": "lfo_rate",
+      "name": "LFO Rate",
+      "type": "control",
+      "required": false
+    },
+    {
+      "id": "lfo_width",
+      "name": "LFO Width",
+      "type": "control",
+      "required": false
+    }
+  ],
+  "outputs": [
+    {
+      "id": "out",
+      "name": "Output",
+      "type": "audio"
+    }
+  ],
+  "parameters": [
+    {
+      "id": "baseDelay",
+      "name": "Base Delay (ms)",
+      "type": "number",
+      "default": 15,
+      "min": 1,
+      "max": 50,
+      "conversion": "MS_TO_SAMPLES",
+      "description": "Base delay time (center of modulation) in ms.",
+      "step": 0.1
+    },
+    {
+      "id": "rate",
+      "name": "LFO Rate (Hz)",
+      "type": "number",
+      "default": 1.0,
+      "min": 0.05,
+      "max": 10,
+      "conversion": "HZ_TO_LFO_RATE",
+      "description": "Frequency of the chorus modulation in Hz.",
+      "step": 0.01
+    },
+    {
+      "id": "width",
+      "name": "LFO Width (ms)",
+      "type": "number",
+      "default": 1,
+      "min": 0,
+      "max": 10,
+      "conversion": "MS_TO_LFO_RANGE",
+      "description": "The width of modulation in ms.",
+      "step": 0.1
+    },
+    {
+      "id": "lfoSel",
+      "name": "LFO Select",
+      "type": "select",
+      "default": 0,
+      "options": [
+        {
+          "value": 0,
+          "label": "LFO 0"
+        },
+        {
+          "value": 1,
+          "label": "LFO 1"
+        }
+      ]
+    }
+  ],
+  "memories": [
+    {
+      "id": "delayl",
+      "size": "${baseDelay} * 2"
+    }
+  ],
+  "registers": [
+  ]
+}
+---
+@if isequalto lfoSel 0
+@equals lfoNum SIN0
+@equals lfoRateReg SIN0_RATE
+@equals lfoRange SIN0_RANGE
+@else
+@equals lfoNum SIN1
+@equals lfoRateReg SIN1_RATE
+@equals lfoRange SIN1_RANGE
+@endif
+
+@section init
+; Initialize LFO
+skp run, done_lfo
+wlds ${lfoNum}, ${rate}, ${width}
+done_lfo:
+
+@section main
+@multiplyDouble lfo_depth_delay width 0.5
+@multiplyDouble delay_mem_size baseDelay 2.0
+@assert lfo_depth_delay < delay_mem_size, "Maximum LFO depth exceeds delay memory bounds. Increase base delay or decrease LFO depth."
+
+; Chorus
+rdax ${input.in}, 1.0
+wra ${mem.delayl}, 0.0
+
+@if pinConnected(lfo_rate)
+rdax ${input.lfo_rate}, ${param.rate.max} / 511.0
+sof 1.0, ${param.rate.min} / 511.0
+wrax ${lfoRateReg}, 0.0
+@endif
+
+@if pinConnected(lfo_width)
+rdax ${input.lfo_width}, ${param.width.max} / 32767.0
+sof 1.0, ${param.width.min} / 32767.0
+wrax ${lfoRange}, 0.0
+@endif
+
+; Read modulated tap (wet signal)
+; center offset from start of delay line
+@equals center ${mem.delayl} + ${baseDelay}
+cho rda, ${lfoNum}, SIN | REG | COMPC, ${center}
+cho rda, ${lfoNum}, SIN, ${center} + 1
+
+wrax ${output.out}, 0.0