Skip to content

CORE Architecture Overview

Arquitectura completa del sistema 04_CORE y cómo fluyen los datos

🏗️ Vista General

04_CORE está organizado en 5 capas arquitectónicas con 16 subsistemas totales.

┌─────────────────────────────────────────────────────┐
│           LAYER 5: Cross-Cutting (12-15)            │
│  Error Recovery | Platform | Testing | Config       │
└─────────────────────────────────────────────────────┘
                          ▲
┌─────────────────────────────────────────────────────┐
│       LAYER 4: Plugin Infrastructure (08-11)         │
│  Parameters | Lifecycle | Processor | Serialization │
└─────────────────────────────────────────────────────┘
                          ▲
┌─────────────────────────────────────────────────────┐
│        LAYER 3: Audio Processing (05-07)             │
│  Buffers | Threading | Events                       │
└─────────────────────────────────────────────────────┘
                          ▲
┌─────────────────────────────────────────────────────┐
│       LAYER 2: Memory & Safety (03-04)              │
│  Memory Management | RT-Safety                      │
└─────────────────────────────────────────────────────┘
                          ▲
┌─────────────────────────────────────────────────────┐
│          LAYER 1: Foundation (00-02)                │
│  Types | Interfaces | Math                         │
└─────────────────────────────────────────────────────┘

📚 Layer 1: Foundation (00-02)

Base fundacional - zero dependencies externas

04_00_type_system

// Tipos básicos para audio
Sample<float> sample;
AudioBuffer<float, 2> stereoBuffer;
SIMDVector<float, 4> simdData;  // AVX2/NEON

04_01_core_interfaces

// Interfaces puras (contratos)
class IAudioProcessor { virtual void process(...) = 0; };
class IActivatable { virtual void activate() = 0; };

04_02_math_primitives

// DSP math optimizado
float y = fast_sin(x);     // 1000x faster than std::sin
float db = linear_to_db(gain);

Usado por: Todas las capas superiores

🔒 Layer 2: Memory & Safety (03-04)

Garantías RT-safe y gestión de memoria

04_03_memory_management

// Allocators RT-safe
PoolAllocator<128> voices(64);      // Voice pool
RingBuffer<float> delay(48000);     // Delay line
TripleBuffer<float> param;          // Lock-free updates

04_04_realtime_safety

// Primitivas lock-free
WaitFreeSPSC<Event, 256> queue;
RT_SAFE void process() { /* verified */ }
RTWatchdog watchdog;  // Hang detection

Usado por: Layer 3 (buffers, events, threads)

🎵 Layer 3: Audio Processing (05-07)

Infraestructura de procesamiento audio

04_05_buffer_management

// Buffers multi-canal
AudioBuffer<float> buffer(numChannels, blockSize);
buffer.applyGain(0.5f);

04_06_threading_architecture

// Threading RT-safe
AudioThread audioThread;
thread_local Storage<float> cache;

04_07_event_dispatcher

// GUI ↔ Audio communication
EventDispatcher::instance().dispatch(event);
enqueue_deferred(event);  // RT-safe

Usado por: Layer 4 (plugins)

🔌 Layer 4: Plugin Infrastructure (08-11)

Sistema completo de plugins

04_08_parameter_system

Parameter<float> gain("Gain", 0, 10, 1);
gain.set(5.0f);  // GUI thread
float value = gain.get();  // Audio thread (smoothed)

04_09_plugin_lifecycle

// State machine
Uninitialized → Initialized → Active → Suspended

04_10_audio_processor (⭐ Más usado)

class MyPlugin : public AudioProcessor {
protected:
    void on_prepare(const ProcessorConfig& config) override {
        // Allocate here
    }

    void on_process(...) noexcept override {
        // DSP here (RT-safe)
    }
};

04_11_state_serialization

// Save/load presets
State state;
state.serialize(file);
state.deserialize(file);

Usado por: Tus plugins y módulos

🛠️ Layer 5: Cross-Cutting (12-15)

Servicios transversales

04_12_error_recovery

  • Error handling strategies
  • Recovery mechanisms

04_13_platform_abstraction

  • Windows/Mac/Linux/ARM abstraction
  • Platform-specific optimizations

04_14_audio_test_utilities

  • Test generators
  • Audio analysis tools

04_15_core_config

  • Build-time configuration
  • Feature flags

🔄 Flujo de Datos Típico

1. Inicialización

DAW/Host
    │
    ├─> prepareToPlay(sampleRate, bufferSize)
    │       └─> on_prepare()
    │           ├─> Allocate RingBuffer (Layer 2)
    │           ├─> Create Parameters (Layer 4)
    │           └─> Initialize AudioBuffer (Layer 3)
    │
    └─> activate()
            └─> on_activate()
                └─> Prime buffers

2. Processing Loop

Audio Thread (RT-critical)
    │
    └─> processBlock(buffer)
        ├─> Read Parameters (Layer 4)
        │   └─> Uses: TripleBuffer (Layer 2)
        │
        ├─> on_process(inputs, outputs, numSamples)
        │   ├─> Read: RingBuffer (Layer 2)
        │   ├─> Math: fast_sin() (Layer 1)
        │   └─> Write: outputs
        │
        └─> Enqueue events (Layer 3)
            └─> Uses: WaitFreeSPSC (Layer 2)

3. GUI Updates

GUI Thread (Non-RT)
    │
    ├─> User moves slider
    │   └─> parameter.set(value)
    │       └─> TripleBuffer::write() (Lock-free)
    │
    └─> Timer (30ms)
        └─> process_deferred_events()
            └─> EventDispatcher (Layer 3)
                └─> Update meters, displays

📊 Dependency Graph

graph TD
    TuPlugin[Tu Plugin]

    TuPlugin --> L4_10[AudioProcessor]
    TuPlugin --> L4_08[Parameter]

    L4_10 --> L3_05[AudioBuffer]
    L4_10 --> L3_07[EventDispatcher]
    L4_08 --> L2_03[TripleBuffer]

    L3_05 --> L1_00[Sample Types]
    L3_07 --> L2_04[WaitFreeSPSC]
    L2_03 --> L1_00

    L2_04 --> L1_01[Interfaces]

Regla clave: Las flechas siempre van hacia abajo (capas superiores usan inferiores)

🎯 Patrones de Uso Comunes

Plugin Simple (Gain, Pan)

Usa: Layer 1 (types) + Layer 4 (AudioProcessor, Parameter)

Plugin con Delay (Delay, Reverb)

Usa: Layer 1 + Layer 2 (RingBuffer) + Layer 4

Plugin Complejo (Synth)

Usa: Todas las capas
- Layer 1: SIMD types
- Layer 2: PoolAllocator (voices), RingBuffer (effects)
- Layer 3: Threading (voice rendering)
- Layer 4: Full plugin infrastructure

🔗 Ver También