Pipeline de transformation (ancien)

Documentation d'ancienne version

Cette page décrit une idée initiale de graphe visuel de nœuds ("Pipeline de transformation").

Neurode MIDI v2 utilise le code source NeuroScript 2.0 comme encodage canonique pour le routage/les transformations.

La compilation se fait hors des threads en temps réel vers un plan immuable.
L'activation du plan est un échange atomique ; les échecs retournent à passage direct et l'interface montre l'erreur de compilation.
Il n'y a pas de besoin de runtime TransformGraph/DAG.

Si vous avez atterri ici depuis d'autres documents, traitez le reste de cette page comme historique.

Aperçu

Dans le design ancien, au lieu d'un routage linéaire simple (Source → Destination), le Pipeline de transformation permettait des chaînes de traitement complexes :

[MIDI In] → [Filter] → [Transpose] → [Split] → [Output 1]
                                       └──────→ [Output 2]

Chaque nœud traite les événements MIDI, et les connexions (arêtes) définissent le flux entre les nœuds.

Concepts de base

Nœuds

Les nœuds sont des unités de traitement. Chaque nœud a :

Type : Détermine le comportement (filtre, transformation, script, etc.)
Entrées/Sorties : Points de connexion (ports)
Paramètres : Configuration spécifique au type de nœud
État activé : Peut être contourné sans suppression

Connexions (Arêtes)

Les connexions relient les nœuds ensemble :

Source : Port de sortie d'un nœud
Cible : Port d'entrée d'un autre nœud
Une entrée par port : Chaque entrée ne peut recevoir qu'une source
Plusieurs sorties : Une sortie peut se diviser vers plusieurs nœuds

Graphes

Un graphe est un pipeline complet :

Collection de nœuds
Ensemble de connexions
Métadonnées (nom, date de création, etc.)

Catégories de nœuds

1. Entrée/Sortie

Entrée MIDI — Point d'entrée pour les événements MIDI entrants

Entrées : Aucune
Sorties : 1 (tous les événements)
Utilisation : Créée automatiquement pour chaque route

Sortie MIDI — Point de sortie envoyant les événements vers la destination

Entrées : 1 (événements à envoyer)
Sorties : Aucune
Utilisation : Créée automatiquement pour chaque route

Entrée/Sortie virtuelle — Pour le routage interne

Fonctionnalité planifiée pour des configurations multi-route complexes

2. Filtres

Les filtres sélectionnent les événements qui passent :

Filtre de note — Passer/bloquer les événements de note

Paramètres : Plage de notes (ex. C3-C5), mode passer/bloquer
Utilisation : Isoler des zones spécifiques du clavier

Filtre de canal — Passer/bloquer par canal MIDI

Paramètres : Sélection des canaux 1-16, mode passer/bloquer
Utilisation : Router des canaux spécifiques différemment

Filtre de vélocité — Filtre par vélocité de note

Paramètres : Plage de vélocité (0-127), mode passer/bloquer
Utilisation : Séparer les couches de jeu fort/faible

Filtre CC — Filtre les messages de changement de contrôle

Paramètres : Plage de numéro CC, mode passer/bloquer
Utilisation : Supprimer les données CC indésirables

Filtre de type d'événement — Filtre par type d'événement

Paramètres : Note, CC, Changement de programme, Pitch Bend, etc.
Utilisation : Supprimer tous les CC, garder uniquement les notes

Filtre en temps réel — Filtre les messages de synchronisation

Paramètres : Aucun (vérification automatique)
Utilisation : Gérer les conflits de synchronisation

3. Transformations

Les transformations modifient les événements :

Transposeur — Événements de note transposés

Paramètres : Octaves à transposer, mode de transposition
Utilisation : Adapter les notes à des instruments ou styles

Modulateur — Événements de contrôle modifiés

Paramètres : Valeurs de modulation, type de modulation
Utilisation : Créer des effets dynamiques

Échantillonneur — Événements de son modifiés

Paramètres : Fréquence d'échantillonnage, format de sortie
Utilisation : Créer des sons personnalisés

4. Scripts

Les nœuds de script exécutent du code personnalisé :

Neuroscript — DSL basé sur les lignes

Paramètres : Code Neuroscript
Utilisation : Opérations MIDI standard (voir Référence Neuroscript)

Lua — Scripting léger

Paramètres : Code Lua
Utilisation : Code personnalisé critique pour les performances

Construction d'un Pipeline

Étape 1 : Commencer avec un Modèle

Toute route commence avec un pipeline par défaut :

[MIDI Input] → [MIDI Output]

C'est un pass-through — les événements circulent directement de la source à la destination.

Étape 2 : Insérer des Nœuds

Ajoutez des nœuds entre l'entrée et la sortie :

Ouvrez l'éditeur de Pipeline de transformation pour la route
Cliquez sur Ajouter un nœud (+)
Sélectionnez le type de nœud depuis la catégorie
Placez le nœud sur la canvas
Connectez en traçant depuis le port de sortie vers le port d'entrée

Exemple : Ajouter un nœud de transposition :

[MIDI Input] → [Transpose] → [MIDI Output]

Étape 3 : Configurer les Paramètres

Sélectionnez le nœud et ajustez les paramètres :

Transpose : Définissez les demi-tons à +12 (une octave plus haut)
Mode : Choisissez "clamp" (sécurisé pour les performances en direct)

Étape 4 : Tester avec un Moniteur

Ajoutez un nœud Moniteur pour observer le flux d'événements :

[MIDI Input] → [Monitor] → [Transpose] → [MIDI Output]

Le Moniteur affiche les événements passant à travers en temps réel.

Étape 5 : Ajouter de la Complexité

Insérez plus de nœuds, créez des branches :

[MIDI Input] → [Channel Filter: CH 1] → [Transpose +12] → [Output 1]
               [Channel Filter: CH 2] → [Transpose -12] → [Output 2]

Cela divise le canal 1 (une octave plus haut) et le canal 2 (une octave plus bas) vers des destinations différentes.

Modèle d'Exécution

Tri Topologique

Les graphes s'exécutent en ordre topologique — les nœuds sont traités selon les dépendances, pas la position visuelle :

A → B → D
A → C → D

Ordre d'exécution : A → (B, C in parallel) → D

Flux d'Exécution du Pipeline

mermaid

graph LR
    A[MIDI Input] --> B[Note Filter]
    B --> C[Transpose +12]
    C --> D[Velocity Scale]
    D --> E[Script Node]
    E --> F[MIDI Output]
    
    style A fill:#10b981,stroke:#059669,stroke-width:2px,color:#fff
    style B fill:#f59e0b,stroke:#d97706,stroke-width:2px,color:#fff
    style C fill:#8b5cf6,stroke:#7c3aed,stroke-width:2px,color:#fff
    style D fill:#8b5cf6,stroke:#7c3aed,stroke-width:2px,color:#fff
    style E fill:#ec4899,stroke:#db2777,stroke-width:2px,color:#fff
    style F fill:#3b82f6,stroke:#2563eb,stroke-width:2px,color:#fff

Types de Nœuds : Entrée (vert), Filtres (orange), Transformations (violet), Scripts (rose), Sortie (bleu). Les événements circulent de gauche à droite à travers le pipeline.

Détection de Cycle

Les graphes ne peuvent pas contenir de cycles — les boucles de rétroaction sont invalides :

A → B → C
    ↑   ↓
    └───┘

Cela créerait une boucle infinie et serait rejeté lors de la validation.

Flux d'Événement

L'événement MIDI arrive au nœud MIDI Input
L'événement est transmis aux nœuds connectés
Chaque nœud traite et modifie éventuellement l'événement
Les événements traités continuent vers les prochains nœuds
Les événements finaux sortent par le nœud MIDI Output

Clé : Les nœuds peuvent :

Ignorer les événements (filtre bloquant)
Transmettre sans modification (transparent)
Transformer (modifier les propriétés)
Générer (créer des événements supplémentaires)

Branches Parallèles

Lorsqu'un nœud sort vers plusieurs connexions, les événements sont dupliqués :

[Input] → [Split] → [Transpose +12] → [Output 1]
                 → [Transpose -12] → [Output 2]

Même événement traité deux fois, chaque sortie reçoit une copie indépendante.

Visualisation de la Chaîne de Branchement

mermaid

graph TD
    A[MIDI Input] --> B[Split Node]
    B --> C[Transpose +12]
    B --> D[Transpose -12]
    C --> E[Velocity Scale 80-127]
    D --> F[Velocity Scale 40-80]
    E --> G[Output 1: Lead Synth]
    F --> H[Output 2: Bass Synth]
    
    style A fill:#10b981,stroke:#059669,stroke-width:2px,color:#fff
    style B fill:#f59e0b,stroke:#d97706,stroke-width:2px,color:#fff
    style C fill:#8b5cf6,stroke:#7c3aed,stroke-width:2px,color:#fff
    style D fill:#8b5cf6,stroke:#7c3aed,stroke-width:2px,color:#fff
    style E fill:#8b5cf6,stroke:#7c3aed,stroke-width:2px,color:#fff
    style F fill:#8b5cf6,stroke:#7c3aed,stroke-width:2px,color:#fff
    style G fill:#3b82f6,stroke:#2563eb,stroke-width:2px,color:#fff
    style H fill:#3b82f6,stroke:#2563eb,stroke-width:2px,color:#fff

Nœud de Division duplique les événements vers les deux branches. Chaque branche applique des transformations indépendantes avant d'atteindre les sorties séparées.

Exemples de Chaînes

1. Zone de Sol avec Amplification

Objectif : Conserver les notes sur le canal 1, transposer vers le haut, atténuer les notes fortes.

[MIDI Input]
    ↓
[Channel Filter: CH 1]
    ↓
[Transpose: +12 clamp]
    ↓
[Velocity Curve: Compress]
    ↓
[MIDI Output]

Équivalent Neuroscript :

neuroscript

keep note, ch 1
transpose +12 clamp
vel clamp 50..110
pass

2. Division du Clavier (Basse + Mélodie)

Objectif : Les touches basses → synthétiseur basse, les touches hautes → synthétiseur mélodie.

[MIDI Input]
    ↓
[Split]
    ├─→ [Note Filter: C1-B3] → [Channel Remap: CH 1→2] → [Output: Bass]
    └─→ [Note Filter: C4-C7] → [Channel Remap: CH 1→3] → [Output: Lead]

3. Routage par vélocité

Objectif : Les notes douces → pad, les notes fortes → mélodie.

[MIDI Input]
    ↓
[Split]
    ├─→ [Velocity Filter: 0-70] → [Output: Pad Synth]
    └─→ [Velocity Filter: 71-127] → [Output: Lead Synth]

4. Nettoyage MIDI (Supprimer le Temps)

Objectif : Supprimer les messages de temps, standardiser les CC.

[MIDI Input]
    ↓
[Realtime Filter: Block Clock/Start/Stop]
    ↓
[CC Remap: 1→74]
    ↓
[MIDI Output]

5. Harmoniseur Dynamique (À venir)

Objectif : Ajouter une harmonie basée sur la vélocité.

[MIDI Input]
    ↓
[Split]
    ├─→ [Pass Through] → [Merge] → [Output]
    └─→ [Conditional: vel > 90]
            ↓
        [Harmonizer: +7 semitones] → [Merge]

Lorsque la vélocité dépasse 90, ajouter une harmonie d'une quinte au-dessus.

Linéarisation

Certains graphes peuvent être linéarisés — représentés comme une liste simple d'étapes (sans branche).

Graphe Linéaire

[Input] → [A] → [B] → [C] → [Output]

Ce graphe linéaire devient : [A, B, C] — traitement séquentiel simple.

Graphe Non Linéaire (Branché)

[Input] → [Split] → [A] → [Merge] → [Output]
                 → [B] ─────┘

Ce ne peut pas être linéarisé — nécessite un traitement par branche.

Limitations

Aucun Boucle de Retour

Les graphes ne peuvent pas contenir de cycles :

A → B → C
    ↑   ↓
    └───┘  ❌ Invalid

Pour les effets de délai, utiliser le nœud Echo (à venir).

Aucun Contrôle Temporel

Les nœuds traitent les événements immédiatement — pas de planification ou de retards dans le graphe.

Pour les effets temporels :

Utiliser plusieurs routes avec un contrôle temporel au niveau de routage (à venir)
Utiliser des scripts avec un état interne (limité)

Aucune Branchement Conditionnel (Encore)

Le nœud Split actuel duplique vers toutes les sorties. Le nœud Conditionnel (à venir) permettra :

[Input] → [Conditional: vel > 90] → [Output A]
                                  → [Output B (else)]

Aucun État Externe

Les nœuds ne peuvent pas partager d'état entre traitements :

Chaque événement est traité indépendamment
Aucun "souviens de la note précédente" ou logique croisée (sauf dans les scripts)

Avancé : Types de Nœuds Personnalisés

Actuellement, les nœuds personnalisés ne sont pas supportés via l'API Swift.

Pour la logique personnalisée, utiliser des nœuds Script (Neuroscript, Lua).

À venir : Types de nœuds Swift personnalisés avec des performances natives.

Comparaison : Chaîne vs. Routage Simple

Caractéristique	Routage Simple	Chaîne de Transformation
Facilité d'Utilisation	Facile	Moyen
Flexibilité	Limitée	Élevée
Branchement	Non	Oui
Visualisation	Liste	Graphe de nœuds
Performance	Le plus rapide	Très rapide
Meilleur Pour	Routes basiques	Traitement complexe

Quand utiliser le Routage Simple :

Passage MIDI direct
Une seule transformation (transposition, remappage de canal)

Quand utiliser la Chaîne de Transformation :

Plusieurs transformations en séquence
Branchement/splitting
Logique conditionnelle
Débogage de traitement complexe

Étapes Suivantes

Référence des Types de Transformation — Catalogue complet des types de nœuds
Langage Neuroscript — Référence des nœuds Script
Optimisation de Performance — Maintenir des chaînes efficaces

Ce concept de chaîne de transformation était une exploration précoce pour Neurode MIDI (iOS/macOS).

Pipeline de transformation (ancien) ​

Aperçu ​

Concepts de base ​

Nœuds ​

Connexions (Arêtes) ​

Graphes ​

Catégories de nœuds ​

1. Entrée/Sortie ​

2. Filtres ​

3. Transformations ​

4. Scripts ​

Construction d'un Pipeline ​

Étape 1 : Commencer avec un Modèle ​

Étape 2 : Insérer des Nœuds ​

Étape 3 : Configurer les Paramètres ​

Étape 4 : Tester avec un Moniteur ​

Étape 5 : Ajouter de la Complexité ​

Modèle d'Exécution ​

Tri Topologique ​

Flux d'Exécution du Pipeline ​

Détection de Cycle ​

Flux d'Événement ​

Branches Parallèles ​

Visualisation de la Chaîne de Branchement ​

Exemples de Chaînes ​

1. Zone de Sol avec Amplification ​

2. Division du Clavier (Basse + Mélodie) ​

3. Routage par vélocité ​

4. Nettoyage MIDI (Supprimer le Temps) ​

5. Harmoniseur Dynamique (À venir) ​

Linéarisation ​

Graphe Linéaire ​

Graphe Non Linéaire (Branché) ​

Limitations ​

Aucun Boucle de Retour ​

Aucun Contrôle Temporel ​

Aucune Branchement Conditionnel (Encore) ​

Aucun État Externe ​

Avancé : Types de Nœuds Personnalisés ​

Comparaison : Chaîne vs. Routage Simple ​

Étapes Suivantes ​