Spectral Effects Suite — User Guide

Spectral‑domain audio processing: creates complex time‑varying effects through frequency‑domain manipulations—pitch wobbles, underwater muffling, spectral filtering, and amplitude modulation—applied directly in the time domain via creative waveform indexing.

Technique: Time‑Domain Spectral Processing Implementation: Praat Script Category: Audio Effects/Processing Version: 1.0 (2025) License: MIT License

Contents:

What this does Quick start Spectral Processing Theory Effect Types Preset Intensities Envelope Types Parameters Sonic Applications

What this does

This script implements a spectral effects suite — a collection of six distinctive audio processing effects that manipulate sound in musically interesting ways. Unlike traditional time‑domain effects (reverb, delay) or frequency‑domain effects (EQ, filtering), these techniques use creative waveform indexing in Praat's formula language to achieve spectral transformations. The effects include: Wobble (dual frequency modulation with tremolo decay), Wobbling Shift (simpler wobble with turbulent decay), Oscillating Decay (spectral filtering with oscillation), Underwater (multi‑band muffling with bubbling), Reverse Crescendo (spectral filtering with fade‑in), and Pulsing Reversal (spectral reversal with rhythmic decay). Each effect combines spectral manipulation with an amplitude envelope to create complex, evolving transformations.

Key Features:

6 Spectral Effects — Distinct processing algorithms with unique sonic characters
4 Intensity Presets — Subtle, Moderate, Strong, Extreme (plus Custom)
6 Envelope Types — Exponential decay/crescendo, tremolo, random bubbling, turbulent Gaussian, rhythmic pulsing
Dual‑Stage Processing — Spectral manipulation followed by amplitude envelope shaping
Non‑Destructive — Works on copy of selected sound, preserves original
Real‑time Processing — All effects applied via Praat's Formula command (no FFT required)
Interactive Control — Fine‑tune spectral depth, cycles, modulation parameters

What is "waveform indexing" spectral processing? Traditional spectral processing uses FFT → manipulation → inverse FFT. This script uses a clever trick: in Praat's formula language, self[col/factor] reads the waveform at a different time index, effectively time‑stretching/compressing the signal. When combined with oscillating factors (sin(cycles×t)), this creates frequency modulation‑like effects. The subtraction of differently indexed versions (self[col/f1] - self[col/f2]) creates comb‑filtering and spectral nulls. This approach allows spectral‑domain effects without actual frequency‑domain transforms, running entirely in Praat's efficient formula interpreter.

Technical Implementation: The script works in two stages: (1) Spectral Manipulation: Applies a Formula that indexes into the waveform with time‑varying factors (e.g., self[col/(1.1 + 0.3×sin(50×t))] - self[col×(1.1 + 0.3×cos(50×t))]). This creates complex frequency‑domain transformations. (2) Amplitude Envelope: Multiplies the result by an envelope function (e.g., exponential decay: 10^(-t/duration)). Parameters are automatically adjusted based on selected preset (Subtle → Extreme) and effect type. The result is a processed sound with the original's name plus effect and preset tags.

Quick start

In Praat, select exactly one Sound object to process.
Run script… → spectral_effects_suite.praat.
Choose an Effect type (Wobble, Underwater, etc.).
Select a Preset (Subtle, Moderate, Strong, Extreme) or Custom.
Optionally adjust spectral/amplitude/modulation parameters.
Choose an Envelope_type (defaults are effect‑appropriate).
Set Scale_peak (0.99 default) and Play_after (yes/no).
Click OK — script processes sound, renames output, plays if selected.
Output appears in Objects list as: originalName_effectName_presetName.

Quick tip: Start with Wobble effect, Moderate preset — this gives a classic "wobble bass" type effect. Try Underwater with Strong preset for instant aquatic transformation. For rhythmic effects, use Pulsing Reversal with Rhythmic Pulsing envelope. Experiment with different source material: drums work well with Wobbling Shift, vocals with Oscillating Decay, full mixes with Underwater. Watch the Info window for processing steps. The script creates a copy — your original sound remains untouched. For extreme effects, try Extreme preset but beware of potential distortion/aliasing.

Important: SELECT A SOUND FIRST — script will exit with error if no Sound object selected. MONO PROCESSING ONLY — stereo sounds will be processed as mono (Praat's Formula works per channel, but effects designed for mono). DESTRUCTIVE PROCESSING — while original is preserved, the processed copy replaces the original's spectral content entirely. PARAMETER INTERACTIONS — spectral_cycles and modulation_cycles interact; high values (>100) can cause aliasing/artifacts. EXTREME PRESETS may produce very distorted results or even silence if spectral manipulation cancels all signal. REAL‑TIME LIMITATIONS — complex formulas on long sounds (>60 s) may cause Praat slowdown.

Spectral Processing Theory

Waveform Indexing as Spectral Manipulation

🔢 The Core Technique: self[col/factor]

Basic operation: In Praat's formula language, self[col] refers to the current sample, self[col/factor] reads the waveform at a different time position.

# Time‑compression/stretch: self[col/1.1] # Reads waveform 10% faster → pitch up 10% self[col/0.9] # Reads waveform 11% slower → pitch down 11% # With oscillation: factor = 1.0 + 0.3 * sin(50 * t) self[col/factor] # Pitch oscillates ±30% at 50 Hz # Subtraction creates spectral cancellation: self[col/1.1] - self[col/1.2] # Creates comb filter with nulls at frequencies where # the two time‑scaled versions are in anti‑phase # The magic formula (Wobble effect): self[col/(base + depth*sin(cycles*t))] - self[col*(base + depth*cos(cycles*t))]

Frequency Domain Interpretation

📊 From Time‑Indexing to Spectral Effects

Time‑scaling ↔ Frequency scaling:

Original signal: f(t) with spectrum F(ω)
  
Indexed version: f(t/α) where α = 1 + δ·sin(Ωt)
  
Frequency domain: becomes complicated!
  • Time‑varying scaling factor α(t)
  • Creates frequency modulation: ω → ω/α(t)
  • Also amplitude modulation (from derivative)
  • Sidebands appear at ω ± kΩ
  
Subtraction of two differently scaled versions:
  f(t/α₁) - f(t/α₂)
  Creates spectral nulls where α₁/α₂ = rational ratio
  Result: moving comb filter with oscillating teeth

Practical outcome: The ear perceives this as "spectral wobble" — frequencies seem to move up/down, with certain frequency bands being emphasized/cancelled rhythmically.

Effect Categories

1. Wobble Effects (1‑2): • Dual sinusoidal indexing (sin and cos) • Creates complex, evolving spectral motion • Like resonant filter with oscillating cutoff 2. Spectral Filtering (3,5,6): • Static or simple indexing • Creates fixed spectral coloration • Like comb filter or spectral tilt 3. Multi‑band Processing (4): • Multiple indexing factors averaged • Creates "smearing" or "blurring" • Like low‑resolution spectral representation 4. Combined with Envelopes: All spectral manipulations are then multiplied by amplitude envelopes that add temporal character: • Exponential decay/growth • Tremolo (periodic AM) • Random fluctuations • Rhythmic gating

Two‑Stage Processing Pipeline

STAGE 1: SPECTRAL MANIPULATION (Effect‑specific) Input: original sound samples s(t) Wobble (Effect 1): α₁ = base + depth*sin(cycles*t) α₂ = base + depth*cos(cycles*t) s₁(t) = s(t/α₁) - s(t*α₂) Underwater (Effect 4): α₁ = base, α₂ = base+0.03, α₃ = base+0.07, α₄ = base+0.2 s₁(t) = [s(t/α₁) + s(t/α₂) + s(t/α₃)]/3 - s(t/α₄) etc. for other effects... STAGE 2: AMPLITUDE ENVELOPE (Envelope_type) Input: spectrally manipulated signal s₁(t) Exponential Decay (Type 1): s₂(t) = s₁(t) * strength^(-t/duration) Tremolo with Decay (Type 3): s₂(t) = s₁(t) * strength^(-t/duration) * (center + depth*sin(mod_cycles*t)) Random Bubbling (Type 4): s₂(t) = s₁(t) * strength^(-t/duration) * (center + depth*randomUniform(-1,1)) etc. for other envelopes... OUTPUT: s₂(t) scaled to peak value

Parameter Interactions

⚙️ How Parameters Affect Results

Spectral_shift_base (typically 1.0‑1.2):

1.0: No pitch shift (original timing)
1.1: 10% faster reading → pitch up ~10%
0.9: 11% slower reading → pitch down ~11%
Values >1 create brighter sound; <1 create darker sound

Spectral_depth (0‑0.7):

0.0: No oscillation (static effect)
0.3: Moderate pitch wobble (±30%)
0.7: Extreme wobble (may cause artifacts)
Higher depth = more pronounced spectral motion

Spectral_cycles (10‑100):

20: Slow wobble (0.3 Hz for 3 s sound)
50: Medium wobble (0.8 Hz)
100: Fast wobble (1.6 Hz)
Cycles = number of oscillations over sound duration

Effect Types

Effect 1: Wobble

🌀 Dual Frequency Modulation with Tremolo Decay

Formula:

self[col/(base + depth*sin(cycles*t))] - self[col*(base + depth*cos(cycles*t))]

Mechanism: Creates two time‑scaled versions of the signal with 90°‑phase‑shifted scaling factors, then subtracts them. The sine‑cosine relationship ensures the two versions are maximally different at all times, creating complex interference patterns.

Sonic character: Classic "wobble bass" or "LFO‑filter" sound. Creates rhythmic spectral motion where frequencies seem to pump up and down. The tremolo decay envelope adds natural amplitude decay.

Best for: Bass lines, synth leads, drum loops. Creates movement in static sounds.

Default envelope: Tremolo with Decay (Type 3)

Effect 2: Wobbling Shift

🌊 Simplified Wobble with Turbulent Decay

Formula: Same as Wobble but with reduced spectral_depth (×0.3).

Mechanism: Less extreme version of Wobble, combined with Gaussian random envelope (turbulent decay) that adds noise‑like amplitude fluctuations.

Sonic character: Gentler wobble with chaotic amplitude variations. Sounds like underwater machinery or unstable electrical signals. More organic/less synthetic than pure Wobble.

Best for: Sound design textures, ambient backgrounds, glitch effects.

Default envelope: Turbulent Decay (Gaussian) (Type 5)

Effect 3: Oscillating Decay

📉 Spectral Filtering with Oscillation

Formula:

self[col/low_factor] - self[col*high_factor] # where low_factor = high_factor = spectral_shift_base

Mechanism: Simple spectral filtering via subtraction of two differently time‑scaled versions. With base=1.1, this creates a comb‑filter effect that emphasizes/cancels certain frequencies.

Sonic character: Metallic, resonant filtering that decays exponentially. Like striking a metal object that rings with specific resonances. The exponential decay envelope gives natural decay tail.

Best for: Percussive sounds, impacts, metallic textures. Can turn drum hits into bell‑like tones.

Default envelope: Exponential Decay (Type 1)

Effect 4: Underwater

🌊 Multi‑band Averaging + High‑Frequency Removal

Formula:

(self[col/f1] + self[col/f2] + self[col/f3]) / 3 - self[col*hf] # where f1=base, f2=base+0.03, f3=base+0.07, hf=base+0.2

Mechanism: Averages three slightly different time‑scaled versions (smearing/blurring the spectrum), then subtracts a high‑frequency‑shifted version (removing high frequencies). This mimics underwater sound propagation: low‑pass filtering plus multipath/time‑smearing.

Sonic character: Muffled, bubbly, aquatic. Sounds like listening through water. The random bubbling envelope adds irregular amplitude fluctuations like air bubbles.

Best for: Creating underwater environments, processing dialogue for aquatic scenes, dream sequences.

Default envelope: Random Bubbling (Type 4)

Effect 5: Reverse Crescendo

🎚️ Spectral Filtering with Fade‑In

Formula: Same as Oscillating Decay (simple spectral filtering).

Mechanism: The spectral filtering effect (comb filter) is combined with an exponential crescendo envelope that makes the sound fade IN rather than out.

Sonic character: Filtered sound that emerges from silence, grows to full intensity, then stops abruptly. Unusual reverse‑decay effect. Creates tension or "rising" sensations.

Best for: Transitions, build‑ups, reverse‑like effects without actual time reversal.

Default envelope: Exponential Crescendo (Type 2)

Effect 6: Pulsing Reversal

💥 Spectral Reversal with Rhythmic Pulsing

Formula: Same as Oscillating Decay but with higher base (1.2).

Mechanism: Strong spectral filtering (base=1.2 creates more extreme comb filtering) combined with absolute‑value sine envelope that creates sharp, rhythmic pulses.

Sonic character: Punchy, rhythmic filtering with strong pulsations. Like a gate effect combined with spectral processing. Very energetic, percussive.

Best for: Rhythmic elements, glitch percussion, side‑chain‑like effects.

Default envelope: Rhythmic Pulsing (abs sin) (Type 6)

Effect Comparison Table

Effect	Formula Type	Default Envelope	Spectral Depth	Base Shift	Character
Wobble	Dual oscillating	Tremolo+Decay	Full	1.1	Classic wobble bass
Wobbling Shift	Dual oscillating	Turbulent Decay	30% of Wobble	1.1	Gentle, chaotic wobble
Oscillating Decay	Simple subtraction	Exp. Decay	N/A	1.1	Metallic filtering decay
Underwater	Multi‑band average	Random Bubbling	N/A	1.1‑1.15	Aquatic, muffled
Reverse Crescendo	Simple subtraction	Exp. Crescendo	N/A	1.1	Filtered fade‑in
Pulsing Reversal	Simple subtraction	Rhythmic Pulsing	N/A	1.2	Punchy rhythmic filter

Preset Intensities

Preset 1: Custom

🎛️ User‑Defined Parameters

Parameters: All parameters remain at their form values or effect defaults.

Use case: When you want full manual control. The script applies effect‑specific adjustments (like envelope type selection) but doesn't modify spectral_depth, modulation_depth, or envelope_strength.

Output name: originalName_effectName_Custom

Preset 2: Subtle

🌱 Gentle Processing

Parameter adjustments:

Spectral_depth: 0.1 (low)
Modulation_depth: 0.2 (low)
Envelope_strength: 5 (gentle)

Effect character: Minimal processing that adds character without overwhelming the source. The original sound remains recognizable with subtle spectral motion or filtering.

Best for: Adding slight interest to sounds, subtle mix enhancements, when you want "effect but not too much".

Output name: originalName_effectName_Subtle

Preset 3: Moderate

⚖️ Balanced Processing

Parameter adjustments:

Spectral_depth: 0.3 (medium)
Modulation_depth: 0.5 (medium)
Envelope_strength: 10 (moderate)

Effect character: Clear but not extreme processing. The effect is audible and distinctive but doesn't dominate. Good default for most applications.

Best for: General sound design, adding character to elements in a mix, when you want the effect to be clearly heard but not overpowering.

Output name: originalName_effectName_Moderate

Preset 4: Strong

💪 Pronounced Processing

Parameter adjustments:

Spectral_depth: 0.5 (high)
Modulation_depth: 0.7 (high)
Envelope_strength: 15 (strong)

Effect character: Strong, pronounced effects that significantly transform the source. The original may become less recognizable; the effect character dominates.

Best for: Sound design where transformation is desired, creating new sounds from sources, experimental music.

Output name: originalName_effectName_Strong

Preset 5: Extreme

🔥 Maximum Processing

Parameter adjustments:

Spectral_depth: 0.7 (very high)
Modulation_depth: 0.9 (very high)
Envelope_strength: 25 (extreme)
Spectral_cycles: 80 (increased)
Modulation_cycles: 40 (increased)

Effect character: Extreme transformation that may push into distortion, aliasing, or complete spectral reconstruction. The original may be unrecognizable. Creates wild, unpredictable results.

Best for: Experimental sound design, noise art, extreme music genres, when you want "destroyed" sounds.

Output name: originalName_effectName_Extreme

Preset Interaction with Effects

Effect‑specific preset adjustments: Underwater (Effect 4): • Strong/Extreme presets increase spectral_shift_base to 1.15 • Creates more pronounced pitch‑down effect (deeper underwater) Pulsing Reversal (Effect 6): • Custom preset sets modulation_cycles = 15 (if at default) • Other presets use their values All effects: Preset modifies three core parameters: • spectral_depth (affects spectral manipulation intensity) • modulation_depth (affects envelope modulation depth) • envelope_strength (affects envelope overall level) Preset names in output: Script uses preset_name$ for labeling: "Subtle", "Moderate", "Strong", "Extreme", or "Custom"

Envelope Types

Type 1: Exponential Decay

📉 Classic Decay Shape

Formula: strength^(-t/duration)

Characteristics: Smooth decay from full amplitude to near‑silence. The strength parameter controls decay steepness: higher = faster decay.

Example: strength=10, duration=3 s → at t=1.5 s: 10^(-0.5) ≈ 0.316 (32% amplitude).

Use case: Natural‑sounding decays for percussive or transient sounds. Default for Oscillating Decay effect.

Visual shape: Rapid initial drop, long tail approaching zero.

Type 2: Exponential Crescendo (Reverse)

📈 Reverse Decay (Fade‑In)

Formula: strength^(t/duration - 1)

Characteristics: Starts near silence, grows to full amplitude. Mirror image of exponential decay.

Example: strength=10, duration=3 s → at t=1.5 s: 10^(0.5-1) = 10^(-0.5) ≈ 0.316.

Use case: Reverse‑like effects, build‑ups, emerging sounds. Default for Reverse Crescendo effect.

Visual shape: Starts near zero, gradual rise to maximum at end.

Type 3: Tremolo with Decay

🎵 Amplitude Modulation + Decay

Formula: strength^(-t/duration) * (center + depth*sin(cycles*t))

Parameters:

center: Typically 1.0 (modulation centered around unity)
depth: 0‑1 (modulation depth, 0.5 = ±50%)
cycles: Number of oscillations over duration

Characteristics: Exponential decay with superimposed sine‑wave tremolo. Creates rhythmic pulsation that fades out.

Use case: Adding life/motion to decaying sounds. Default for Wobble effect.

Type 4: Random Bubbling

🎲 Stochastic Amplitude Variations

Formula: strength^(-t/duration) * (center + depth*randomUniform(-1,1))

Characteristics: Exponential decay with random amplitude fluctuations at each sample. Creates "bubbly" or "gurgling" effect.

Note: randomUniform(-1,1) generates new random value for each sample, creating white‑noise modulation.

Use case: Organic, irregular amplitude variations. Default for Underwater effect (simulates bubbles).

Type 5: Turbulent Decay (Gaussian)

🌪️ Noise‑Like Fluctuations

Formula: strength^(-t/duration) * (center + depth*randomGauss(0,1))

Characteristics: Exponential decay with Gaussian random fluctuations. Similar to Random Bubbling but with normal distribution (more small variations, occasional large spikes).

Use case: Chaotic, turbulent amplitude changes. Default for Wobbling Shift effect.

Type 6: Rhythmic Pulsing (abs sin)

💥 Absolute‑Value Sine Pulsing

Formula: abs(sin(cycles*t)) * strength^(-t/duration)

Characteristics: Sharp, pulsing envelope from absolute value of sine wave. Creates strong rhythmic gating with exponential decay.

Visualization: |sin(ωt)| creates "bumpy" waveform with peaks at 0, π, 2π... Creates twice‑frequency pulsing compared to regular sine.

Use case: Strong rhythmic effects, gate‑like processing. Default for Pulsing Reversal effect.

Envelope Comparison

Type	Formula	Modulation	Regularity	Default For
Exp. Decay	strength^(-t/T)	None	Smooth	Oscillating Decay
Exp. Crescendo	strength^(t/T-1)	None	Smooth	Reverse Crescendo
Tremolo+Decay	Decay × (c+d×sin)	Sinusoidal	Regular	Wobble
Random Bubbling	Decay × (c+d×randU)	Random uniform	Irregular	Underwater
Turbulent Decay	Decay × (c+d×randG)	Random Gaussian	Irregular	Wobbling Shift
Rhythmic Pulsing	Decay × \|sin\|	Absolute sine	Regular sharp	Pulsing Reversal

Parameters & Controls

Form Parameters

🎛️ User‑Adjustable Settings

Parameter	Type	Default	Range	Description
Effect	optionmenu	Wobble	1‑6	Type of spectral effect
Preset	optionmenu	Custom	1‑5	Intensity preset
Spectral_shift_base	positive	1.1	0.5‑2.0	Base time‑scaling factor
Spectral_depth	positive	0.3	0‑1.0	Depth of spectral oscillation
Spectral_cycles	positive	50	1‑200	Cycles of spectral oscillation
Envelope_type	optionmenu	Exp. Decay	1‑6	Type of amplitude envelope
Envelope_strength	positive	10	1‑100	Strength of envelope effect
Modulation_center	positive	1.0	0‑2.0	Center of modulation (for tremolo)
Modulation_depth	positive	0.5	0‑1.0	Depth of modulation
Modulation_cycles	positive	20	1‑100	Cycles of modulation
Scale_peak	positive	0.99	0.1‑1.0	Output peak amplitude
Play_after	boolean	1	0/1	Auto‑play after processing

Derived & Internal Parameters

Parameter	Source	Typical Values	Description
preset_name$	Preset selection	"Custom","Subtle","Moderate","Strong","Extreme"	Text label for output naming
effect_name$	Effect selection	"Wobble","WobblingShift", etc.	Text label for output naming
original_name$	Selected sound name	Varies	Name of input sound
duration	Sound object duration	Varies	Length of selected sound
xmin, xmax	Sound object bounds	0‑duration	Time range in formulas

Parameter Guidelines

Spectral_shift_base: • 0.9‑1.0: Pitch down effects (darker) • 1.0: No pitch shift (neutral) • 1.0‑1.2: Pitch up effects (brighter) • >1.2: Extreme pitch up (may cause aliasing) Spectral_depth (for wobble effects): • 0‑0.2: Subtle spectral motion • 0.2‑0.4: Moderate wobble (good for bass) • 0.4‑0.6: Strong wobble (transformative) • 0.6‑0.8: Extreme wobble (may distort) • 0.8‑1.0: Potentially unstable Spectral_cycles: • cycles ≈ desired_Hz × duration • Example: 3 s sound, want 2 Hz wobble → cycles=6 • Typical: 10‑100 (0.3‑3 Hz for 3 s sound) • High cycles (>100) create fast modulation (may alias) Envelope_strength: • 2‑5: Very gentle decay • 5‑10: Moderate decay • 10‑20: Strong decay • 20‑50: Very strong decay (quick to silence) • 50‑100: Extreme decay (near‑instant) Modulation_cycles (for envelopes): • Similar calculation to spectral_cycles • For tremolo: cycles ≈ tremolo_Hz × duration • Example: 3 s sound, want 4 Hz tremolo → cycles=12

Sonic Applications

Music Production

🎵 Creative Sound Design

Wobble basslines: Apply Wobble effect to synth bass with Moderate preset, spectral_cycles=8‑15 (slow LFO). Creates classic dubstep/glitch hop wobble.

Drum processing:

Kick drums: Wobbling Shift with Subtle preset adds subtle movement
Snares: Oscillating Decay with Strong preset creates metallic ringing tails
Hi‑hats: Pulsing Reversal with fast cycles creates rhythmic gating

Vocal effects: Underwater effect with Moderate preset for "telephone" or "aquatic" vocal texture. Reverse Crescendo for reverse‑vocal‑like builds.

Sound Design for Media

Sci‑fi interfaces: Wobble effect with Extreme preset on synthetic blips and beeps. Creates "unstable technology" sounds.

Horror atmospheres: Underwater effect on whispers or breaths with Random Bubbling envelope. Creates unsettling, submerged sounds.

Magic/spells: Oscillating Decay on metallic recordings (bells, chimes) with long duration. Creates enchanted object resonances.

Vehicle sounds: Wobbling Shift on engine recordings with Turbulent Decay. Creates malfunctioning or strained machinery.

Experimental Audio Art

Granular‑like textures: Apply Extreme Wobble with very high spectral_cycles (>150) to create pseudo‑granular smearing.

Spectral painting: Process same sound with different effects/presets, layer results for complex spectral evolution.

Feedback systems: Process sound, re‑process output, repeat chain for evolving feedback textures.

Practical Workflow Examples

🎬 Film: "Abandoned Submarine Scene"

Sound layers:

Background hum: Original engine rumble → Underwater (Strong) → creates submerged machinery
Metal creaks: Recorded metal stress → Wobbling Shift (Moderate) → adds unstable, wavering quality
Sonar pings: Synthetic ping → Oscillating Decay (Subtle) → adds metallic resonance tail
Voice (radio): Dialogue → Underwater (Moderate) → processed through "water"

Mix: Layer with bubble foley, reverb matching submarine interior.

🎵 Track: "Glitch Hop Production"

Processing chain:

Bass synth: Wobble effect, Moderate preset, spectral_cycles=12 (4 Hz wobble)
Drum loop: Pulsing Reversal, Strong preset, modulation_cycles=24 (8 Hz pulse)
Vocal sample: Reverse Crescendo, 2 s duration → reversed‑like effect without actual reversal
FX sweeps: Wobbling Shift with Extreme preset, automated spectral_depth

Arrangement: Use effects on specific sections (drops, breaks) for variation.

🔬 Educational: "Spectral Effect Demonstrations"

Lesson plan:

Start with simple sine wave (440 Hz)
Apply Wobble with spectral_cycles=5 (slow) → hear pitch modulation
Increase spectral_depth gradually 0→0.7 → hear increasing modulation
Change to square wave → hear harmonic interactions
Try different envelopes → hear how temporal shaping changes perception
Compare with traditional LFO‑filter (if available) → discuss differences

Learning outcome: Understand time‑domain vs frequency‑domain processing, hear parameter effects.

Advanced Techniques & Customization

Creating Custom Effects

Modify existing effects: Edit the formula sections in the script to create variations:

# Example: Triple wobble (more complex) self[col/(base + d*sin(c*t))] - self[col*(base + d*cos(c*t))] + 0.5*self[col/(base + d*sin(2*c*t))] # Example: Spectral chorus (multiple delayed versions) (sum from i=1 to 5: self[col/(base + i*0.02)]) / 5

Parameter Automation

Time‑varying parameters: Modify script to make parameters functions of time instead of constants:

# Instead of constant spectral_depth: depth(t) = 0.1 + 0.4 * (t/duration) # Ramp up # In formula: self[col/(base + depth(t)*sin(cycles*t))] - ...

Multi‑Stage Processing

Chain effects: Process sound with one effect, then process result with another:

# Pseudocode: sound1 = original → Wobble (Subtle) sound2 = sound1 → Underwater (Moderate) sound3 = sound2 → Reverse Crescendo (Strong) # Creates complex, evolving transformation

Stereo Enhancement

Create stereo from mono: Process left and right channels differently:

# For stereo sound, process each channel separately: selectObject: stereo_sound Extract one channel: 1 # Left # Apply effect... Extract one channel: 2 # Right # Apply slightly different parameters... Combine to stereo

Troubleshooting

Problem: Output is silent or very quiet
Causes: Spectral manipulation cancelled all signal, envelope_strength too high causing near‑zero values
Solutions: Try different effect, reduce spectral_depth, reduce envelope_strength

Problem: Output is distorted/noisy
Causes: Extreme parameter values causing aliasing, random envelopes with high depth
Solutions: Reduce spectral_depth/modulation_depth, use lower preset, try different envelope

Problem: Processing is very slow
Causes: Long sound duration, complex formula (multiple self[] references)
Solutions: Process shorter segments, simplify formula, increase Praat memory allocation

Problem: Effect doesn't sound as expected
Causes: Source material unsuitable, parameter interactions
Solutions: Try different source (simple tones first to understand effect), reset to Moderate preset