SoloDallas Storm VST3

Stage 01 Data Capture & Preparation Weeks 1–2

Record 27 impulse responses from the physical Storm at various parameter settings using log chirp sweeps. The recording matrix covers the full parameter space of the pedal.

Recording Matrix — 3 × 3 × 3 = 27 Files

Naming Convention

storm_drive-[0-50-100]_tone-[0-50-100]_vol-[30-60-100].wav

# Examples:
storm_drive-0_tone-0_vol-30.wav      # minimum settings
storm_drive-100_tone-100_vol-100.wav  # maximum settings
storm_drive-50_tone-50_vol-60.wav     # midpointShell

Stage 1 Deliverables

• 27 .wav files organized in data/raw_recordings/
• recording_log.csv tracking peak levels for each file
• Preprocessed audio: normalized peaks to -1 dB, silence trimmed → data/normalized/

Stage 02 Dataset Creation Weeks 2–3

Extract impulse responses from the recorded sweeps and prepare the data for PyTorch training. Overlapping audio chunks ensure the model learns transient behavior effectively.

Stage 03 Model Training Weeks 3–5

Implement and train a Temporal Convolutional Network (TCN) — the standard architecture for audio modeling tasks. Dilated convolutions give the model a large receptive field with manageable compute.

Model Architecture

class StormTCN(nn.Module):
    """Base model: dilated TCN, 4 dilation levels"""
    # Receptive field grows exponentially with depth
    # Level 1: dilation=1, Level 2: dilation=2, ...

class StormConditionedTCN(nn.Module):
    """Conditioned model: accepts drive/tone/volume as side info"""
    # Injects parameter values via FiLM conditioning layers
    # Allows single model to cover all 27 recording conditionsPython

Training Configuration

Stage 04 Model Export & C++ Wrapper Weeks 5–7

Export the trained PyTorch model to ONNX format and write a C++ inference class that JUCE can call at audio rate.

ONNX Export

# export_onnx.py
torch.onnx.export(
    model,
    dummy_input,
    "models/storm_tcn.onnx",
    opset_version=14,
    dynamic_axes={
        'input': {0: 'batch', 2: 'time'},   # dynamic batch & time
        'output': {0: 'batch', 2: 'time'}
    }
)

# Validate: test inference with ONNX Runtime Python
# Verify output shapes & values match PyTorch modelPython

C++ Inference Class Interface

// storm_inference.h
class StormInference {
public:
    StormInference(const std::string& model_path);

    // Process one audio chunk with parameter values
    std::vector<float> process(
        const std::vector<float>& audio_chunk,
        float drive,   // 0.0 – 1.0
        float tone,    // 0.0 – 1.0
        float volume   // 0.0 – 1.0
    );

private:
    Ort::Session session_;
    Ort::Env env_;
};C++

Stage 05 JUCE Plugin Integration Weeks 7–8

Integrate the C++ inference class into a JUCE AudioProcessor and build a minimal but functional VST3 plugin.

AudioProcessor Integration

// PluginProcessor.h
class StormAudioProcessor : public juce::AudioProcessor {
public:
    void processBlock(juce::AudioBuffer<float>&, juce::MidiBuffer&) override {
        // For each buffer chunk:
        // 1. Extract audio samples
        // 2. Get current drive/tone/volume parameter values
        // 3. Call inference.process(chunk, drive, tone, volume)
        // 4. Write output back to buffer
    }

private:
    std::unique_ptr<StormInference> inference_;
    juce::AudioProcessorValueTreeState apvts;
};C++

Parameters

Stage 06 UI Polish & Testing Weeks 8+

• Custom UI design: Sketch mockup → implement with JUCE Graphics or web-based approach
• Preset system: Save/load parameter states. Create factory presets.
• Advanced metering: Input/output spectrum analyzer, gain reduction indicator
• Optimization: Profile CPU & latency. Use Instruments (macOS) or Perfetto (Linux).
• Cross-DAW testing: Reaper, Logic, Ableton, Studio One. Verify latency compensation, automation, MIDI.
• Blind A/B tests: Record plugin output vs. hardware. 3–5 listeners. Target: >70% correct identification suggests good accuracy.

Reference File Structure