# aRts - Synthétiseur analogique en temps réel

Stefan
Westerfeld

    stefan@space.twc.de

Version 0.3.4, Sep 29 1999

Ce document décrit aRts - le synthétiseur analogique en temps réel.

aRts - synthétiseur analogique en temps réel

analogique
temps réel
synthésiseur
midi
bus midi
audio
son
effet
filtre

## Introduction

### Qu'est-ce que aRts ?

Arts est l'abréviation de "analog realtime synthesizer" (synthétiseur analogique en temps réel), mais peut-être le saviez-vous déjà avant de lire cette documentation...

Ce projet s'appelait Ksynth et a été renommé aRts entre les versions 0.2.5 et 0.2.6.

aRts simule un "synthétiseur analogique modulaire" complet sur votre ordinateur. Créez des sons et de la musique en utilisant de petits modules comme les oscillateurs pour créer des formes d'ondes, des filtres, des modules pour jouer des données sur vos haut-parleurs, des mixeurs, des potentiomètres (faders)... Vous pouvez construire votre synthétiseur complet en utilisant l'interface graphique du système, en utilisant les modules - générateurs, effets et sorties - connectés entre eux.

Au cours du temps, il a évolué pour être utile pour un vaste ensemble d'applications, pas seulement pour la synthèse analogique. Arts est parti pour devenir un logiciel audio médiateur, qui devrait accomplir de multiples tâches, comme le traitement d'effets full duplex, la synthèse contrôlée par midi, les fonctions de serveur audio, l'émulation d'un échantillonneur... D'autres caractéristiques comme l'enregistrement sur disque dur devraient suivre.

Ce programme est distribué sous la licence GPL (Gnu Public License). Lisez attentivement le fichier COPYING qui se trouve dans l'archive. Si vous n'acceptez pas la licence GPL, vous n'êtes pas autorisé à utiliser et modifier ce programme !

### Au coeur de aRts

Alors qu'il doit déjà exister plusieurs synthétiseurs logiciels, aRts a été conçu sur une idée directrice : la flexibilité.

Il n'a donc pas été conçu pour être un programme où vous avez deux (ou dix) instruments prêts qui se contentent de bien sonner, et fournissent quelques paramètres. Même pas trois effets et un mixeur.

Tout - du plus petit bloc de base jusqu'aux structures complexes (c'est-à-dire des tables de mixages avec des égaliseurs, des banques d'effets, des centaines de boutons et de paramètres à l'écran) - peut être construit à partir des petits modules qui constituent aRts. Il ne devrait rien y avoir qui ne soit recombiné, reconfiguré, reconnecté, redirigé ou remodelé. Un studio virtuel où tout peut être placé là où vous le voulez.

Bien sûr il y aura des librairies d'instruments et d'effets, des ensembles de mixeurs, de filtres complexes, d'unités de traitement midi, etc. Mais ils ne sont pas codé "en dur", tout est écrit avec aRts lui-même, de telle sorte que tout soit accessible via aRtsbuilder. Beaucoup de choses restent cependant à faire - mais nous y travaillons.

Bien sûr, de nouveaux modules de synthèse peuvent être écrits facilement et intégrés dans le système aRts.

Plus de flexibilité avec CORBA :

Le synthétiseur est à la base constitué de deux éléments - une interface graphique où vous pouvez connecter les modules - et un synthétiseur de bas niveau qui exécute les modèles. Le synthétiseur et l'interface graphique communiquent à l'aide de CORBA. Cette technique permet à plusieurs applications audio de partager le même espace pour la synthèse. Cela signifie que vous avez - outre le bus midi qui connecte toutes vos applications - une sorte de serveur audio où différents calculs en temps réel peuvent être effectués simultanément.

## Installation

### Comment obtenir aRts

Distributions de binaires

  Bien sûr, la méthode la plus commode pour installer aRts est d'utiliser un paquetage de binaires. À la base, votre distribution linux devrait en comporter une, sinon, plaignez vous :). Suse linux par exemple en fournit une.

  Cependant, il y a une solution si votre distribution ne contient pas aRts, et que vous voulez absolument un paquetage binaire quoi qu'il arrive, peut être parce que vous ne pouvez pas compiler les sources, ou si le résultat de la compilation ne fonctionne pas du tout. À partir de aRts 0.3.3, il y aura une distribution binaire statique sur le site internet de aRts. L'avantage est que les librairies statiques devraient fonctionner sur presque tous les linux, indépendamment de la distribution. Mais aRts fait environ 8 Mo, donc si vous trouvez un autre moyen d'installer aRts, faites le.

  La partie suivante porte cependant sur l'installation classique à partir des sources.

Versions stables des sources

  La meilleure chose à faire est de se rendre sur le site internet de aRts : http://linux.twc.de/arts, et de le télécharger depuis là (où depuis un site miroir). Une autre possibilité est de regarder sur ftp ftp://ftp.kde.org/pub/kde/unstable/apps/multimedia/sound pour une archive récente de arts-x.y.z.tgz.

versions de développement les plus récentes

  Arts est développé dans le CVS KDE dans le module kmusic. Donc si vous y avez accès, utilisez simplement `cvs checkout kmusic` et vous aurez la dernière version.

  Vous pouvez aussi récupérer les archives quotidiennes de la branche de développement (snapshots) si vous n'avez pas accès à CVS en utilisant cvsup. La procédure détaillée est documentée à http://www.kde.org.

### Fichiers nécessaires

Actuellement, aRts se compile et fonctionne avec les logiciels suivants (mais ça marche aussi avec les versions plus récentes ;) :

- Linux 2.0.30 - http://www.linux.org

- Qt 1.32 - http://www.troll.no

- KDE 1.0 - http://www.kde.org

- mico 2.2.3, 2.2.7 or 2.3.0 - http://www.mico.org

  IMPORTANT!! Vous devez compiler mico avec --disable-mini-stl !! Sinon vous ne pouvez pas compiler aRts

  Mico-2.2.6 contient un bogue dans son compilateur idl qui introduit des erreurs dans les compteurs de références. Arts fonctionnera avec, mais le serveur continuera de tourner lorsque vous quittez ArtsBuilder, et peut être quelques pertes de mémoire se produiront - donc si vous voulez l'éviter, utilisez une autre version de mico.

- egcs 1.0.2 - http://egcs.cygnus.com

- libc6/glibc2 ou libc5 avec les bibliothèques X11 threadsafe (NdT : bibliothèques X11 garantissant une exécution sûre des threads (unités d'exécution au sein d'un programme)). (voir ci-dessous)

Remarques importantes pour les systèmes libc5

  (Extrait du fichier readme de sountracker, qui a le même problème) : ce programme utilise beaucoup les threads. Ceci peut être source de problèmes si vous utilisez un système libc5. Vous avez besoin des librairies X11 thread-safe dans ce cas. Si ArtsBuilder continue de planter dès que vous le démarrez (avec d'étranges erreurs d'entrée/sortie de X), vous ne les avez pas.

  Vous pouvez obtenir une version précompilée ici :

  http://www.tu-harburg.de/~semk2104/soundtracker/threadedxlibs.tar.bz2

  Il est préférable de ne pas les installer par dessus les anciennes librairies X, mettez-les plutôt dans un répertoire séparé et définissez les variables d'environnement (sous bash) :

      export LD_LIBRARY_PATH=/path/to/threadedxlibs/directory

  sous csh/tcsh :

      setenv LD_LIBRARY_PATH
      /path/to/threadedxlibs/directory

  Il a aussi été rapporté que compiler avec qt-1.42 a aidé un utilisateur d'un système libc5 qui ne pouvait pas faire fonctionner aRts avec qt-1.44. Ce serait bien si quelqu'un pouvait me confirmer ou corriger ça.

Compiler avec audiofile 0.1.6

  Libaudiofile est livré avec un fichier d'entête incomplêt (avec une accolade non fermée quand __cplusplus est défini), qui entraîne l'erreur suivante :

      error: wav.cc: h:21 parse error before
      '&rcub;'

  lorsqu'on essaie de compiler le support wave dans src/synthesizer. Pour corriger ça, vous pouvez :

  - soit aller à /usr/include/aupvlist.h et supprimer une des deux accolades fermées ressemblant à :

        #ifdef __cplusplus } #endif

    qui se trouve ligne 59 sur mon système.

  - ou mettre à jour libaudiofile vers une version plus récente.

  Le fichier libaudiofile 0.1.6 défectueux est livré par exemple avec la Debian 2.1 ou la RedHat 6.0, donc sur ces systèmes, attendez-vous à rencontrer ce problème.
Problèmes lors de l'exécution d'idl sur certains systèmes

  Sur certains systèmes (comme dans les versions récentes de la distribution Redhat 6), vous aurez un message d'erreur du genre :

       /usr/local/bin/idl --query-server-for-narrow synth.idl
      /usr/local/bin/idl: error in loading shared libraries:       libmico2.2.7.so:
      cannot open shared object file:       No such file or directory

  Pour corriger cela, ajoutez /usr/local/lib dans le fichier /etc/ld.so.conf en tant que root, puis lancez ldconfig.
Compiler sans egcs

  Je suppose que vous pouvez utiliser le logiciel si vous avez gcc-2.7.x ou gcc-2.8.x aussi, mais il est possible que vous vouliez optimiser un peu le fichier de configuration. (Dites moi ce qui n'a pas fonctionné si vous n'arrivez pas à le compiler, je devrais pouvoir vous aider).

  Si vous utilisez un compilateur non-GNU, vous devez au moins avoir un bon support STL. Si vous arrivez à compiler Mico et KDE avec, vous pourrez alors probablement compiler aRts.

Compiler sans linux

  Pour les autres systèmes d'exploitation, vous devez fournir un autre pilote audio. Normalement il devrait être possible de récupérer les sources correspondantes à partir de mpeg3play version 0.9.6 (la gestion du son du synthétiseur est basée sur ces routines, voir README.sound pour de plus amples informations) et d'ajouter alors des capacités de traitement en temps réel.

  Cela a été fait uniquement pour linux jusqu'ici. En tout cas, certaines personnes ont dit que aRts tournait sous FreeBSD.

Compiler sans KDE et Qt

  Vous pouvez compiler aRts sans KDE et Qt. Utilisez

      configure --disable-kde

  Artsbuilder ne sera alors pas compilé (l'éditeur graphique de structure du synthétiseur). Arts n'est pas vraiment sympa sans cet éditeur.

  Si vous voulez vraiment le faire, je vous recommande de lire la section Portage ci-dessous, et de démarrer une nouvelle interface graphique, par exemple avec

  - Gtk, Gnome et OrbIt

  - Java et le support Java de mico

  - n'importe quelle autre interface

### Compilation et installation

Si vous avez obtenu les sources sur le CVS, commencez par :

- `make -f Makefile.dist`

Pour démarrer réellement la compilation (ceci est vrai pour les utilisateurs du CVS et pour les utilisateurs des fichiers sources standards), utilisez

- `./configure`

- `make`

- `make install`

### À propos des droits administrateur

Le synthétiseur a besoin de la priorité temps réel (realtime priority) pour fonctionner correctement. Il y a trois possibilités :

Donnez au programme encapsulant (wrapper) "artswrapper" les droits appropriés

  1. Ouvrez une fenêtre terminal X, devenez administrateur (tapez su et entrez votre mot de passe administrateur).

  2. Donnez à artsserver.bin les droits :

            cd /usr/local/kde/bin
            chown root artswrapper
            chmod u+s artswrapper

     Artserver pourra alors prendre les droits administrateur tout seul, vous n'avez donc pas à vous en occuper.

     Ce programme encapsulant a été ajouté dans aRts-0.3.4 car certaines personnes avaient quelques soucis de sécurité en faisant fonctionner tout le synthétiseur en root ou suid root. Le programme encapsulant rendra les droits immédiatement après avoir donné le degré de priorité "temps réel" à l'ordonnanceur.

     J'apprécierais beaucoup que vous me disiez si cette solution/implantation est vraiment sûre.

Démarrer le serveur en tant qu'administrateur à chaque fois

  Si vous démarrez artsserver manuellement en tant qu'administrateur, vous pourrez utiliser artsbuilder avec la configuration temps réel appropriée (vous pouvez alors lancer artsbuilder en tant qu'utilisateur).

Ne pas utiliser les droits administrateurs.

  Ce n'est pas terrible, parce que le son subira des clics et des arrêts lorsque vous utiliserez l'interface graphique.

### Démarrage de artsbuilder

Maintenant vous pouvez démarrer artsbuilder. Sous KDE, l'application devrait apparaître dans la section multimédia du menu K (ArtsBuilder). Si elle n'y est pas encore, vous pouvez essayer de redémarrer le panneau de KDE.

Et maintenant, vous devriez pouvoir jouer avec.

## Concepts

Arts possède tout un ensemble de concepts. Certains d'entre eux sont nouveaux dans Arts-0.3.0, d'autres sont là depuis pas mal de temps maintenant.

Une chose importante est que vous comprendrez probablement mieux comment la synthèse contrôlée par midi fonctionne si vous connaissez les concepts qui pilotent Arts. Vous serez alors en mesure de faire beaucoup plus de choses avec aRts en sachant comment il fonctionne.

### Modules et ports

La philosophie de aRts est que la synthèse peut être effectuée en utilisant de petits modules, qui ne font qu'un chose, et en les recombinants en structures complexes. Ces petits modules ont normalement des entrées, à partir desquelles ils peuvent obtenir des signaux ou des paramètres, et des sorties, vers lesquelles ils produisent des signaux.

Un module (Synth_ADD) par exemple, collecte juste les deux signaux à ses entrées, et les additionne. Le résultat est envoyé vers la sortie. Les endroits où les modules fournissent leurs signaux d'entrée/sortie sont appelés ports.

### Structures

Une structure est une combinaison de modules connectés, certains d'entre eux peuvent avoir des paramètres codés directement sur leurs ports d'entrée, d'autres peuvent être connectés, et d'autres pas connectés du tout.

Ce que vous pouvez faire avec artsbuilder est de définir les structures. Vous choisissez quel module vous voulez connecter, avec quels autres. Lorsque vous avez terminé, vous pouvez enregistrer cette définition de structure dans un fichier, ou dire à Arts de créer la structure que vous avez défini (Execute).

Vous entendrez probablement un son, si vous avez tout fait comme il le fallait.

### Publication et instanciation dynamique

Si vous voulez, vous pouvez donner un nom à votre structure, qui peut être utilisée comme référence. (Utilisez "File/Rename" dans artsbuilder).

Vous pouvez alors choisir de publier la définition de votre structure sur le serveur de Arts. Une copie de cette structure sera placée dans Arts et rendue disponible pour les autres "utilisateurs".

Le but est d'avoir des modules qui peuvent créer des structures lorsqu'elles sont nécessaires. Par exemple, vous voulez créer une structure qui synthétise un son de percussion. Alors, des handler midi (NdT : composant logiciel qui gère les événements midi) peuvent créer une telle structure chaque fois qu'un certain événement est envoyé au synthétiseur. Ainsi, pour chaque événement midi entrant, vous devriez entendre le son de percussion synthétisé.

Bien sûr, cela nécessite que vos données audio soient mixées avec les autres sorties audio et jouées. Cela nécessite aussi que votre structure sache comment disparaître, sinon vous aurez de plus en plus de structures synthétisées.

Et finalement, vous devriez avoir les moyens d'obtenir plus de données concernant les événements midi entrants, comme le volume ou la fréquence, si vous voulez aussi synthétiser de "vrais" instruments.

Les points suivants traitent de ce problème.

### Bus

Les bus sont des connexions construites de façon dynamique qui transfèrent le signal audio. Fondamentalement, il y a des uplinks (NdT : canal sur lequel on envoie des données) et des downlinks (NdT : canal sur lequel on reçoit des données). Tous les signaux des uplinks sont additionnées et envoyées vers les downlinks.

Les bus sont actuellement implantés pour travailler en stéréo, donc vous ne pouvez transférer que des données stéréo par les bus. Si vous voulez des données mono, transférez les sur un seul canal et laissez l'autre à zéro. Ce que vous avez à faire est de créer un ou plusieurs objets Synth_BUS_UPLINK, et donnez leur le nom d'un bus, avec lequel ils communiquent (par exemple "audio" ou "percussions"). Envoyez simplement les données là-dedans.

Vous aurez alors besoin de créer un ou plusieurs objets Synth_BUS_DOWNLINK, et donnez leur le nom d'un bus ("audio" ou "percussions" ... si ça correspond, les données transiterons dedans), et les données mixées sortiront de nouveau.

Les uplinks et downlinks peuvent résider dans différentes structures, vous pouvez même avoir différents artsbuilder en cours et démarrer un uplink dans un et reçevoir les données d'un autre avec une liaison downlink.

Ce qui est sympathique avec les bus, c'est qu'ils sont totalement dynamiques. Vous pouvez brancher et débrancher en temps réel. Il ne devrait alors pas y avoir de clics ou de bruit.

(Bien sûr, vous ne devriez pas débrancher un client qui joue un signal, puisque son niveau ne sera probablement pas à zéro lorsque vous le débrancherez, vous entendrez alors un clic.)

### Fermeture des structures

Maintenant, un second point pour les instruments évolués est de fermer automatiquement les structures. Il y a un objet Synth_STRUCT_KILL pour cela, qui enlèvera une structure dès qu'il reçoit un signal d'entrée > 0.5 (lu : 1).

Bien sûr les autres modules ont été configurés pour générer de tels signaux dans des situations raisonnables : à la fois Synth_ENVELOPE_ADSR et Synth_PLAY_WAV ont un paramètre de sortie "done" (terminé), qui sera égal à un dès qu'ils sont prêts.

Cela signifie que si vous voulez un instrument (par exemple un son de percussion) qui soit juste un échantillon, il sera probablement suffisant d'avoir un objet Synth_PLAY_WAV, qui joue un échantillon, et de connecter le paramètre "done" à un objet Synth_STRUCT_KILL.

La structure sera alors retirée dès que l'échantillon est joué (et plus aucun signal d'amplitude nulle ne sera généré quoi qu'il arrive).

### Interfaces

Les interfaces sont un moyen de passer les données aux structures. Elles ressemblent aux modules, mais elles n'ont normalement que des sorties (ou que des entrées). Leurs sorties viennent du monde extérieur à la structure, et les entrées y retournent.

On dit qu'une structure fournit une interface si elle contient un module d'interface.

Par exemple, les routeurs midi s'attendent à ce que les structures des instruments fournissent une interface pour les données midi. Alors, ils peuvent passer les données midi, et les structures peuvent utiliser ces données pour travailler.

Notez que dans les versions récentes de aRts, les interfaces ne sont là que parce qu'elles permettent quelques astuces internes - mais elles vont probablement disparaître et être remplacées par des ports d'entrée et sortie conventionnels pour les structures. (Voir "Réutiliser les structures comme de nouveaux modules" ci-dessous). Ainsi la seule interface qui est supportée par aRts est Interface_MIDI_NOTE, et si elle est remplacée, ce ne sera pas par de nouvelles interfaces. Mais actuellement, vous en avez besoin.

### Synthèse contrôlée par midi (nouveau style ; Arts >= 0.3.0)

L'idée est que vous avez des structures qui fournissent une interface Interface_MIDI_NOTE. Il y aura une fréquence, une vélocité (volume) et un paramètre qui vous sera passé, si la touche est toujours pressée. Votre structure devrait maintenant synthétiser exactement telle note avec tel volume et réagir au paramètre "pressed" (enfoncé), où pressed=1 signifie que l'utilisateur appuie toujours sur la touche et pressed=0 signifie que la touche est relâchée.

Pour créer et utiliser une telle structure, faites comme suit :

- Pour traiter le paramètre "pressed", il est commode d'utiliser un module Synth_ENVELOPE_ADSR, ou, pour les sons de percussion, jouez-le simplement et ignorez le paramètre "pressed".

- La structure devrait se détruire elle même dès lors qu'elle n'est plus nécessaire, et à la fois les échantillons et les enveloppes génèrent le paramètre "done" lorsque le son est fini. Facile !

- Vous devrez publier votre structure sous un nom.

- Vous pouvez dire à un objet Synth_MIDI_ROUTER qu'il doit créer une telle structure pour chaque événement midi qui arrive sur le canal 1 par exemple.

- Oh, et bien sûr votre structure doit probablement jouer les données audio qu'elle génère vers un bus, ce qui est commode pour un post-traitement avec des effets, et finalement les diriger vers les haut-parleurs.

### Réutiliser les structures comme de nouveaux modules

Il est possible de réutiliser une structure complexe comme nouveau module. Pour rendre cela encore plus intéressant, vous pouvez donner des ports à ces structures, de telle sorte qu'elles puissent traiter les signaux comme n'importe quel autre module. Imaginons que vous ayez trouvé un moyen de produire une réverb fantastique. Vous pouvez alors mettre cette réverb seule dans une structure et lui donner des ports, comme deux ports d'entrée (stéréo), un autre pour la profondeur de réverb, et deux ports de sortie pour les signaux traités par cette réverb.

Maintenant vous pouvez lui donner un nom sympathique (comme Synth_COOL_REVERB), et la publier. Au même moment, elle apparaîtra comme nouveau module dans un menu module, et vous pouvez l'utiliser comme nouveau module dans les autres structures.

Si vous pensez que vous voulez la conserver, enregistrez-la sous le nom Synth_COOL_REVERB.arts dans votre répertoire $HOME/arts/structures, et aRts la chargera automatiquement à chaque démarrage. (Il est important que le nom du fichier soit du type <nom_de_structure>.arts). Voir "Autochargement au démarrage".

### Instruments (Arts >= 0.3.2)

La philosophie de conception d'un instrument est la suivante : faites-le une fois, et réutilisez-le.

Fondamentalement, la création d'un composant dans arts, comme un égaliseur, un effet, un appareil comme une table de mixage... est basée sur cette philosophie. (Bon, il reste beaucoup à faire).

Il y a plusieurs conditions à vérifier pour pouvoir le réutiliser.

- Le premier point important est que votre instrument est une structure, qui contient un module Interface_MIDI_NOTE (voir ci-dessous : Synthèse contrôlée par midi).

- La structure doit se terminer toute seule lorsque c'est nécessaire (voir Synthèse contrôlée par midi).

- La structure doit avoir un bus qui porte le nom d'un port, qui est une propriété de type "chaîne de caractères". Ce port doit être connecté à un Synth_BUS_UPLINK, qui collecte les données que votre instrument produit.

- L'instrument doit être nommé instrument_nombienchoisi, il est important que le nom commence par instrument_.

Si vous voulez avoir des paramètres ajustables qui peuvent être modifiés en temps réel par l'utilisateur, vous avez besoin de plus de choses :

- Votre instrument doit avoir un port d'entrée par paramètre modifiable pour le signal audio. Si vous pouvez par exemple modifier les paramètres "attack","decay" et "cutoff", votre structure doit avoir trois ports audio.

- Pour votre structure d'instrument, il doit y avoir une autre structure qui sera le "control panel" (panneau de contrôle) pour l'instrument. Il devrait y avoir trois ports d'entrée (parent, qui est le signal audio entrant, et x et y, qui sont les propriétés audio).

- La structure "control panel" doit s'appeler instrument_nombienchoisi_GUI.

- La structure "control panel" doit s'afficher toute seule à la position x,y dans l'élément graphique parent. Utilisez simplement un Gui_SUB_PANEL pour faire cela.

- La structure "control panel" doit avoir une sortie pour chaque paramètre nécessaire à l'instrument, dans notre exemple il y aurait trois ports de sortie de signaux audio, "attack","decay" et "cutoff".

Ça vous semble compliqué ? Et bien - oui - un peu, mais l'instrument créé est vraiment réutilisable. Si vous avez vu les exemples avec l'INSTRUMENT_MAPPER, vous savez de quoi je parle.

### Autochargement au démarrage

Lorsque Arstbuilder démarre, il tente de charger et de publier chaque structure qui se trouve dans votre répertoire $HOME/arts/structures. Il ne les publiera que si elles ont le même nom que le nom du fichier correspondant. (Par exemple, la structure qui se trouve dans le fichier $HOME/arts/structures/test.arts devrait s'appeler test).

Cela signifie que vous n'aurez pas à charger les 20 instruments que vous avez créé récemment et leur panneaux de contrôle et les 10 effets que vous aimez à tel point que presque à chaque fois vous commencez à travailler avec aRts. Enregisrtez-les simplement dans ce répertoire et ils seront déjà là chaque fois que vous chargez aRts.

Notez que c'est aussi la seule façon d'utiliser les structures comme modules. Supposons que vous ayez créé une structure Synth_SPECIAL_FX et que vous l'ayez utilisé dans une autre structure (par exemple dans un instrument). Pour charger cet instrument, vous aurez besoin préalablement de charger et de publier Synth_SPECIAL_FX manuellement. Au lieu de faire ça, enregistrez simplement la structure dans $HOME/arts/structures (c'est ici que ArtsBuilder sauvegarde par défaut de toute façon) et ça va marcher automagiquement.

Vous pouvez aussi utiliser "retrieve from server", si vous voulez éditer Synth_SPECIAL_FX de nouveau, puisqu'il a déjà été chargé au démarrage du programme.

### Mixeurs

Ils sont documentés en tant qu'éléments de l'interface graphique. Ils sont d'une conception sympathique pour faire un mixeur 16 canaux, en décrivant un canal et en disant "j'en veux 16 comme ça". On utilise pour cela la publication, l'instanciation dynamique et tout ce qui va avec pour faire cela, mais nous en reparlerons quand vous aurez acqui les bases de l'utilisation de l'interface graphique.

### Gestion des sessions

Si vous utilisez réellement aRts, par exemple si vous composez un morceau avec aRts et Brahms, vous réglez sans doute beaucoup de paramètres après avoir démarré votre structure. Vous assignez tel instrument à tel canal, ajustez les paramètres de la table de mixage, fignolez les instruments configurables et programmez les effets.

La gestion des sessions est là pour enregistrer toutes ces configurations dont vous avez besoin pour votre nouveau morceau créé avec Brahms. Donc si vous enregistrez le morceau, et voulez travailler dessus plus tard, appuyez sur le bouton "Save..." de aRts _aussi_ (le morceau ne sera bien sûr pas enregistré dans Brahms). Enregistrez le réglage actuel avec un nom finissant par .arts-session.

Si vous voulez travailler sur le même morceau le jour suivant, démarrez artsbuilder et choisissez simplement "Open Session..." à partir du menu. Ouvrez de nouveau votre session - et tout se remet dans l'état ou vous l'aviez laissé. Chaque réglage de la table de mixage - chaque paramètre d'instrument.

C'est pour cela que les studios professionnels paient des milliers de francs ;) (mais ils ont bien sûr de vrais potentiomètres, qui reviennent réellement à leur position initiale à l'aide de petits moteurs).

Important : la gestion des sessions ne fonctionne que si vous ne modifiez pas les structures utilisées. Dès que vous ajoutez un module (ou un potentiomètre) à un des instruments/mixeurs/etc. il n'y a aucune garantie quant à la bonne restitution des sessions enregistrées précédemment. Il y aura un jour peut-être une correction de bogue (comme par exemple la sauvegarde de toutes les structures utilisées avec la session).

### Traitement audio full duplex

Il est possible d'utiliser aRts pour des traitements audio Full duplex. Cela signifie que vous pouvez enregistrer des données (depuis l'entrée ligne ou micro de la carte son), les traiter dans aRts, et les rejouer avec un temps de latence très court. De cette façon, vous pouvez utiliser aRts comme processeur d'effet.

Il est cependant nécessaire que vous décidiez ce que vous voulez faire avec aRts lorsque vous concevez la structure qui aura accès à la carte son.

Soit vous utilisez Synth_PLAY comme dernier module, qui envoie les données à la carte son. Vous avez alors décidé d'utiliser aRts en lecture seulement. Soit vous utilisez les modules Synth_FULL_DUPLEX_PLAY et Synth_FULL_DUPLEX_RECORD pour accéder à la carte son. Si vous faites ça, vérifiez que les deux modules sont contenus dans la même structure, de sorte qu'ils soient démarrés simultanément.

Si vous voulez avoir accès aux données enregistrées ou à d'autres choses extérieures à la structure, utilisez les bus, comme toujours.

Malheureusement, il y a beaucoup de cartes son qui supportent mal le full duplex. Par exemple, la plupart des SoundBlasters 16, AWE et compatibles peuvent uniquement faire un enregistrement sur 16 bits, ou une lecture sur 16 bits. La réponse se fera sur 8 bits lors d'un fonctionnement full duplex, et le son sera mauvais (présence de bruit).

L'enregistrement full duplex peut aussi être utilisé pour enregistrer des données à partir de la carte son, même pendant que aRts fonctionne - par exemple en tant que serveur audio.

### Instruments mappés(drum maps, etc.)

Les instruments mappés sont des instruments qui se comportent différemment suivant la hauteur. Vous pourriez par exemple construire un piano sur 5 octaves, en utilisant un échantillon pour chaque octave (en le transposant en conséquence). Ca sonne beaucoup mieux qu'avec l'utilisation d'un seul échantillon.

Vous pourriez aussi construire un drum map qui joue un échantillon de batterie spécifique par touche.

Pour obtenir ces paramètres, votre structure d'instrument doit être incomplète, par exemple, cela doit être un instrument normal qui joue un échantillon, mais l'échantillon n'est pas donné dans la structure. Au lieu de cela, il devrait y avoir un port qui accepte une chaîne de caractères qui se connecte au nom de fichier du lecteur d'échantillon. De cette façon, la structure est paramétrée.

Je sais que cela semble compliqué. Jetez simplement un coup d'oeil à play_wav, play_akai ou play_akai_stereo pour voir ce que je veux dire.

Maintenant, supposons que vous utilisiez un play_wav pour votre instrument, alors votre structure a le paramètre d'échantillon précédent. Vous pouvez maintenant créer un fichier nommé 909drums.arts-map, qui contient les lignes suivantes :

    structure=play_wav
    keygroup=35-35
    {
    sample=/usr/local/samples/909select/bt0a0a7.wav
    }
    keygroup=36-36
    {
    sample=/usr/local/samples/909select/bt0a0da.wav
    }
    keygroup=37-37
    {
    sample=/usr/local/samples/909select/bt3a0da.wav
    }
    keygroup=38-38
    {
    sample=/usr/local/samples/909select/bt7a0d7.wav
    }
    keygroup=39-39
    {
    sample=/usr/local/samples/909select/btaa0d0.wav
    }

Comme vous pouvez le voir, le paramètre manquant est spécifié différemment pour différents groupes de touches (ici les groupes de touches sont seulement d'une touche vers la même touche, mais vous pouvez facilement dire keygroup=30-50 pour spécifier la plage de touches).

Si vous avez plusieurs paramètres, ça fonctionne de la même façon, à ceci près que vous mettez plus d'une ligne dans les définitions des groupes de touches. Voici un petit extrait d'un fichier de mappage akai (pour un piano).

    structure=play_akai_stereo
    keygroup=0-30
    {
    rightsample=/var/samples/BOESEND.LOUD/BOE_LD_F#0-R
    leftsample=/var/samples/BOESEND.LOUD/BOE_LD_F#0-L
    }
    keygroup=31-33
    {
    rightsample=/var/samples/BOESEND.LOUD/BOE_LD_G#0-R
    leftsample=/var/samples/BOESEND.LOUD/BOE_LD_G#0-L
    }
    keygroup=34-34
    {
    rightsample=/var/samples/BOESEND.LOUD/BOE_LD_A#0-R
    leftsample=/var/samples/BOESEND.LOUD/BOE_LD_A#0-L
    }
    keygroup=35-36
    {
    rightsample=/var/samples/BOESEND.LOUD/BOE_LD_C1_-R
    leftsample=/var/samples/BOESEND.LOUD/BOE_LD_C1_-L
    }
    keygroup=37-38
    {
    rightsample=/var/samples/BOESEND.LOUD/BOE_LD_D1_-R
    leftsample=/var/samples/BOESEND.LOUD/BOE_LD_D1_-L
    }
    keygroup=39-39
    {
    rightsample=/var/samples/BOESEND.LOUD/BOE_LD_D#1-R
    leftsample=/var/samples/BOESEND.LOUD/BOE_LD_D#1-L
    }
    keygroup=40-40
    {
    rightsample=/var/samples/BOESEND.LOUD/BOE_LD_E1_-R
    leftsample=/var/samples/BOESEND.LOUD/BOE_LD_E1_-L
    }

Ces fichiers "map" apparaîtront automatiquement dans le "mapper" de l'instrument, dès que vous le copiez dans le répertoire arts/map (dans votre répertoire utilisateur).

## Le standard du bus midi

### Qu'est-ce que midisend ?

Le bus midi universel pour les applications audio n'est pas encore terminé. Il est en cours (je pense que tous les développeurs seront d'accord sur le fait que le projet doit être réalisé), mais cela va prendre du temps (voir plus bas).

Pour pouvoir jouer avec aRts et tester ses possibilités, j'ai écrit midisend. C'est un programme qui prend ce qui arrive sur /dev/midi00 et qui l'envoie vers aRts.

Il nécessite :

- que le synthétiseur fonctionne

- qu'il y ait une structure qui traite les événements midi dans le synthétiseur (ça marche sans, mais vous n'entendrez rien).

Il est aussi capable d'envoyer des données midi à partir d'autres périphériques, lorsque vous utilisez `midisend /dev/some_autre_périphérique`.

Finalement, vous pouvez jouer sur un clavier midi externe et écouter le son généré par aRts. Sur mon système, je n'ai rencontré aucun problème de ralentissement, on a la sensation de jouer sur un clavier traditionnel.

### Utilisation de aRts et Brahms

La réincarnation de kooBase, Brahms, supporte maintenant les bus midi. Il fonctionne plutôt bien, et peut être utilisé avec d'autres ports midi de sortie (comme par exemple la sortie standard de la SoundBlaster).

Brahms interagit beaucoup plus avec aRts, pas seulement au niveau du midi. Jouer des pistes d'échantillons est déjà implanté, l'enregistrement sur disque dur et d'autres choses devraient suivre.

Pour résumer, nous voulons que le couple Brahms/aRts ait autant de fonctionnalités que CuBase/VST, tandis que la relation entre Brahms et aRts sera à peu près la même que celle entre CuBase et VST.

Pour avoir une version de Brahms compatible aRts (il se compile sans), installez d'abord aRts, puis Brahms. Vous pouvez obliger Brahms à inclure le support aRts avec --enable-arts, mais normalement il devrait détecter automatiquement la présence de aRts.

Cantor - un autre séquenceur basé sur Qt, supporte aussi le bus midi, mais Brahms semble être actuellement le meilleur choix pour les musiciens.

D'autres séquenceurs devraient suivre, contactez moi si vous en écrivez un et si vous voulez avoir le support du bus midi.

### Lancement rapide

Ceci fonctionne pour Brahms et Cantor (remplacez simplement Brahms par Cantor si vous essayez Cantor).

- compilez et installez aRts

- prenez une version de Brahms avec le support du bus midi, toutes les versions récentes devraient l'avoir (il devrait être disponible à l'adresse http://linux.twc.de/arts)

- compilez-le, normalement il devrait détecter que vous avez installé aRts et il devrait inclure le support du bus midi automatiquement.

- installez-le

- démarrez artsbuilder (si vous n'avez pas donné les privilèges administrateurs à artswrapper, démarrez-le en tant qu'administrateur, sinon le temps réel ne fonctionnera pas, et la musique sera bruitée).

- démarrez artsbuilder

- utilisez "File/Retrieve server" et choisissez des structures de mappage midi utilisables, comme example_mixer_eqfx

- lancez-le avec "File/Execute Structure"

- cliquez sur le bouton "add" pour ajouter un instrument (ou plusieurs) - il y a un conflit au niveau de la numérotation des canaux midi. aRts commence à compter à 1, Brahms à 0. Donc si par exemple vous avez assigné la batterie au canal 10 dans aRts, cela correspond au canal 9 de Brahms.

- démarrez Brahms (ou cantor à partir des sous-répertoires exemples de cantor)

- composez (ou chargez un fichier)

- réglez le port de sortie des pistes que vous voulez jouer avec aRts vers les bus midi.

- appuyez sur le bouton "play"

Voilà, ça joue... comment ça sonne dépend évidemment du modèle de synthèse que vous utilisez. Si vous voulez, vous pouvez démarrer `midisend` aussi, pour faire quelques improvisations sympa sur votre clavier, pendant que vous utilisez le séquenceur... donc maintenant vous pouvez composer un morceau de démonstration, et si ça sonne vraiment bien, faites un mp3 et envoyez-le moi, pour que l'on puisse montrer sur le site internet à quel point aRts est cool ;)

PS : Merci aux deux auteurs Jan (Brahms) et Paul (Cantor), les deux programmes m'ont vraiment aidé pendant le développement de aRts.

PS2 : Arts et Cantor sont disponibles sur le CVS de KDE dans le module kmusic. Brahms suivra probablement bientôt.

### Plus de détails internes

Le code d'Arts est déjà du code distribué. Cela signifie que vous avez

1. Une interface graphique utilisée pour relier les modules entre eux.

2. Le synthétiseur (qui fonctionne sur un autre processus), qui s'occupe de la synthèse. Il est capable de construire une structure quelconque de modules interconnectés, et de l'exécuter.

Les processus 1 et 2 communiquent en permanence. En fait, le processus 1 ne peut exister sans le processus 2, tandis que le processus 2 peut exister sans le processus 1.

Il y a même un programme sans interface graphique, artsshell, qui peut entre autre donner l'ordre au synthétiseur de se mettre au travail (donc si vous n'avez pas KDE, vous pouvez quand même utiliser les modèles de synthèse, mais c'est bien sûr moins pratique quand on ne peut pas les éditer).

Voici ce que vous avez avec aRts :

Maintenant, ce que fait fondamentalement midisend, c'est ajouter un nouveau processus (processus 3), qui envoie les données midi au synthétiseur (en utilisant CORBA aussi) :

Ainsi, voilà ce que je voudrais logiquement avoir :

Physiquement (suivant la façon dont vous l'implantez), ça devrait ressembler à ça :

Notez que tous les rectangles sont ici des processus distincts, et vous pouvez brancher de nouveaux processus comme vous le voulez (par exemple un clavier virtuel sur l'écran, qui vous permet d'envoyer des données midi en cliquant dessus).

Voici les trucs liés à idl qui peuvent vous intéresser :

arts.idl : (qui n'est pas si intéressant dans le contexte de cette discussion). midibus.idl :

    interface MidiChannel {
        oneway void noteOn(in octet channel, in octet note, in octet volume);
        oneway void noteOff(in octet channel, in octet note);
    };

    // This of course doesn't look finished ;) where are parameter, such as
    // echo depth, where is midi mapping, where is instrument changing, where
    // is...
    //
    // I hope to complete that later.

### Autres considérations

Il y a des travaux en cours qui pourraient mener à un autre standard. L'idée de bus midi est plutôt bonne, mais il n'est pas garanti que les événements midi arrivent à temps. Pour les données en temps réel (jeu en public), il n'y a probablement aucun moyen d'y parvenir de toute façon, mais pour les données séquencées, ce n'est pas optimal.

Un autre point est que le standard ne nous donne pas de moyens faciles de faire du direct-to-disk, qui peut être intéressant.

Nous travaillons là-dessus, et sur l'interface CORBA de aRts.Tenez-vous informé.

## Élements de l'interface graphique

### Le but

Les éléments de l'interface graphique sont utilisés pour permettre aux structures de synthèse d'interagir avec l'utilisateur. Dans le cas le plus simple, l'utilisateur peut modifier directement les paramètres d'une structure (comme un facteur de gain qui est utilisé avant le module de lecture final).

Dans des réglages plus complexes, on pourrait imaginer que l'utilisateur modifie les paramètres d'un groupe de structures et/ou de structures ne fonctionnant pas encore, comme par exemple modifier l'enveloppe ADSR de l'instrument midi actif. Une autre chose serait le réglage du nom de fichier d'instrument basés sur des échantillons.

D'un autre côté, l'utilisateur aimerait peut être visualiser ce que fait le synthétiseur. Cela pourrait être des oscilloscopes, des analyseurs de spectre, des potentiomètres de volume et quelques visualisateurs "expérimentaux" qui calculent les fonctions de transfert de certains modules de filtrage.

Enfin, les éléments de l'interfage graphique devraient pouvoir contrôler l'ensemble de la structure de ce qui fonctionne à l'intérieur de Arts et la façon dont ça fonctionne. L'utilisateur devrait pouvoir assigner des instruments à des canaux midi, démarrer de nouveaux processeurs d'effets, configurer la sortie principale du mixeur (qui est lui-même construit à partir de structures de aRts) pour ajouter un canal et utiliser une autre stratégie pour ses égaliseurs.

Vous voyez, les éléments de l'interface graphique devraient apporter toutes les possibilités des studios virtuels que aRts devrait simuler pour l'utilisateur. Bien sûr, ils doivent aussi interagir avec élégance avec les entrées midi (par exemple les potentiomètres qui bougent s'ils reçoivent des messages midi qui ne changent qu'un paramètre), et probablement générer eux-même des événements midi pour permettre d'enregistrer les mouvements que l'utilisateur donne aux potentiomètres via un séquenceur.

### Introduction : ce que vous trouverez ici

Encore expérimental. La plupart des choses sont écrites dans le manuel de référence des modules qui devrait suffire (regardez les exemples). Donc seules des choses un peu plus complexes sont expliquées ci-dessous.

Vous pouvez créer des panneaux, des sous-panneaux, des potentiomètres, des boutons rotatifs, des fenêtres et le fameux mapper d'instruments, qui fait tout à lui tout seul. Nous pouvons donc produire de belles interfaces graphiques avec, les sous-panneaux et les spécifications des objets parents vous permettent de combiner de façon très flexible les interfaces des structures.

Comme vous pouvez le voir, c'est expérimental, et juste là pour vous encourager à expérimenter, et - plus important - avoir vos impressions en retour ! ;) N'hésitez pas à lancer vos idées/codes dans le processus de développement... Veuillez lire aussi "the gui challenge" publié sur le site internet de aRts.

### Éléments graphiques parents

Arts utilise une technique à la mode qui consiste à mettre des élements graphiques dans d'autres éléments graphiques. Chaque élément graphique pouvant contenir d'autres éléments graphiques a un port de sortie appelé id. Par exemple, comme on s'attend à pouvoir mettre des contôles dans une fenêtre, elle aura un port de sortie id.

D'un autre côté, chaque élément graphique qui peut (doit) être placé dans d'autres éléments graphique a un port d'entrée appelé parent. Cela va vous permettre par exemple de mettre un Gui_SUB_PANEL dans une fenêtre.

### La magie du GUI_Mixer

Un des composants importants pour faire de la musique est le mixeur. Bien sûr, avec aRts, vous pouvez construire des mixeurs en utilisant simplement des centaines de modules, qui prennent quelques Synth_BUS_DOWNLINK, les mixent ensemble (éventuellement en fournissant un panneau de contrôle), et les envoient vers un uplink ou vers la carte son.

De toute façon, cela signifierait qu'étendre votre structure de 10 à 16 canaux de mixage représenterait beaucoup de travail (puisque vous auriez à en construire 6 autres à la main).

Pour résoudre ce problème, Gui_MIXER a été créé. Vous lui donnez une fenêtre, et une structure qui décrit à quoi ressemble un canal du mixeur. Vous lui dites comment les bus doivent s'appeler, d'où il prend les données, et vous lui précisez où il doit les mettre (un autre bus).

Et maintenant, une chose importante : vous lui dites combien de canaux vous voulez. À son lancement, votre Gui_MIXER créera simplement une de vos structure de canaux pour chaque canal que vous voulez. Vous pouvez donc passer d'un mélangeur à 10 canaux à un mélangeur à 16 canaux en changeant un paramètre.

Évidemment, vous avez besoin de savoir quel paramètre prend un canal : c'est simplement un élément graphique parent (donc vous pouvez placer votre panneau quelque part), et le nom du bus où vous mettez les données. Les paramètres doivent être appelés parent, input et output. Le Gui_MIXER numérotera simplement les canaux de 01 à la valeur maximale de canaux que vous avez spécifié.

Voir le manuel de référence des modules pour plus de détails.

## Tutoriel

### Étape 1

Démarrez artsbuilder.

Vouz aurez besoin d'un module Synth_PLAY pour entendre ce que vous créez. Le troisième paramètre (canaux) doit être réglé à 1 ou 2 pour sélectionner un son mono ou stéréo. Créez un module Synth_PLAY en sélectionnant "Modules/Synth_PLAY" et cliquez sur l'espace libre réservé aux modules. Placez-le sous la cinquième ligne ou plus, parce que nous ajouterons des choses au dessus.

Pour sélectionner le nombre de voix, double-cliquez sur "channels" (canaux, le plus à droite du module), sélectionnez "constant value" (valeur constante) et tapez 2 dans la boîte d'édition. Cliquez sur Okay pour appliquer les changements.

Cliquez sur "File/Execute structure". Vous n'entendrez absolument rien. Le module de jeu a besoin encore de quelque chose en entrée... ;) Écoutez le silence pendant un moment et passez à l'étape 2.

### Étape 2

Créez un module Synth_WAVE_SIN et placez-le au dessus du module Synth_PLAY (laissez une ligne vide entre). Comme vous pouvez le voir, il produit quelque chose en sortie, mais nécessite un paramètre "pos" en entrée. Tout d'abord, relions la sortie aux haut-parleurs. Cliquez sur le port "out" (sortie) du Synth_WAVE_SIN et ensuite sur le port "left" (gauche) du Synth_PLAY. Voilà, vous avez connecté deux modules.

Dans aRts, les oscillateurs ne nécessitent pas une fréquence en entrée, mais une position dans l'échantillon. Cette position doit être comprise entre 0 et 1, ce qui correspond pour un objet Synth_WAVE_SIN standard à la plage 0..2*pi. Pour générer des valeurs d'oscillations à partir d'une fréquence, un module Synth_FREQUENCY est utilisé.

Créez un module Synth_FREQUENCY et connectez sa sortie "pos" à l'entrée "pos" de votre module Synth_WAVE_SIN. Spécifiez une valeur constante de 440 au port fréquence du générateur FREQUENCY.

Cliquez sur "File/Execute structure". Vous entendrez une onde sinusoïdale à 440 Hz sur l'un de vos haut-parleurs. Lorsque vous l'aurez écouté pendant un moment, passez à l'étape 3.

### Étape 3

OK, ce serait mieux si vous pouviez entendre une onde sinusoïdale sur les deux haut-parleurs. Connectez le port droit du Synth_PLAY au port "outvalue" (valeur de sortie) du Synth_WAVE_SIN aussi.

Créez un objet Synth_SEQUENCE. Il devrait se trouver en haut de l'écran. Si vous avez besoin de plus de place, vous pouvez déplacer les autres modules en les sélectionnant (pour en sélectionner plusieurs, cliquez sur MAJ) et déplacez-les.

Maintenant, connectez la sortie "frequ" (fréquence) du module Synth_SEQUENCE à l'entrée "frequ" du module Synth_FREQUENCY. Spécifiez alors la valeur constante 0,13 pour la vitesse de la séquence (la vitesse est le port le plus à gauche).

Puis allez au port le plus à droite (sequence) du Synth_SEQUENCE et entrez comme valeur constante A-3;C-4;E-4;C-4; ceci spécifie une séquence. Vous trouverez plus d'informations dans le manuel de référence des modules.

Remarque : Synth_SEQUENCE a _vraiment_ besoin d'une séquence et une vitesse. Sans ces données, vous aurez certainement des fichiers core générés.

Cliquez sur "File/Execute structure". Vous entendrez jouer une séquence sympathique. Si vous avez aimé, passez à l'étape 4.

### Étape 4

Créez un module Synth_PSCALE. Déconnectez la sortie de l'onde sinusoïdale en double cliquant dessus et en choisissant "not connected" (non connecté). Connectez

- La sortie du SIN à l'entrée de PSCALE

- La sortie de PSCALE au PLAY gauche

- La sortie de PSCALE au PLAY droit

- Le "pos" de SEQUENCE au "pos" de PSCALE

Finalement, placez le port "top" de PSCALE à une certaine valeur, par exemple 0.1.

Voyons maintenant comment ça marche : le Synth_SEQUENCE donne une information supplémentaire sur la position de la note qu'il est en train de jouer, 0 signifie juste commencé et 1 signifie finie.Le module Synth_PSCALE va modifier l'amplitude du flux audio qui le traverse d'un volume 0 (silence) à un volume 1 (volume d'origine) puis de nouveau 0 (silence), d'après la position. La position où le pic doit apparaître peut être donné sur le port "pos". 0,1 signifie que lorsque 10% de la note ont été joués, le volume a atteind son maximum, et diminue ensuite.

Cliquez sur "File/Execute structure". Vous entendrez la séquence avec les notes avec le volume modifié. Si vous avez aimé, passez à l'étape 5

### Étape 5: début d'échange de données ;)

Démarrez un autre artsbuilder.

Placez un module Synth_PLAY dedans, et configurez-le pour deux canaux. Placez aussi un module Synth_BUS_DOWNLINK et

- Mettez la valeur constante 8 à l'entrée "clie" (clients) du module Synth_BUS_DOWNLINK (nous en aurons besoin plus tard).

- Placez l'entrée bus de ce module à audio (c'est juste un nom, appelez-le Fred si ça vous fait plaisir).

- connectez la sortie left du module Synth_BUS_DOWNLINK à l'entrée left du module Synth_PLAY

- connectez la sortie right du module Synth_BUS_DOWNLINK à l'entrée right du module Synth_PLAY

Exécutez le module. Comme on pouvait s'y attendre, on n'entend rien, ... pas encore.

Revenez à la structure avec le module Synth_WAVE_SIN et remplacez le module Synth_PLAY par un module Synth_BUS_UPLINK, et configurez le nom à "audio" (ou à Fred si vous voulez). Pour effacer les modules, sélectionnez-les et cliquez sur edit/delete dans le menu (ou appuyez sur la touche Suppr)

Cliquez sur "File/Execute structure". Vous entendrez la séquence avec les notes dont le volume est modifié, transportées par le bus, et qui n'est pas aussi forte qu'avant car le bus peut accueillir 8 clients.

Si vous voulez vous rendre compte de l'intérêt réel d'une telle chose, cliquez sur OK (dans le artsbuilder qui exécute le module Synth_SEQUENCE, vous pouvez laisser tourner l'autre) et passez à l'étape 6.

### Étape 6: échange de données pour les utilisateurs avancés.

Sélectionnez "Choose File/Rename structure" dans le menu de artsbuilder qui contient le module Synth_SEQUENCE, et appelez-le tutoriel. Cliquez sur OK.

Choisissez "File/Publish"

Hmm ? Qu'est-ce qui s'est passé maintenant ? Le serveur de aRts contient un dépôt central de structures connues (ou mieux, leur description, comment les modules doivent être connectés pour obtenir une telle structure). Dans les versions futures de aRts, vous aurez probablement la description de plusieurs centaines de structures, des instruments d'orchestre, jusqu'à divers processeurs d'effets, des tables de mixage, des synthétiseurs autonomes, etc. disponibles dans le serveur, et disponibles depuis un programme de composition... mais nous n'en sommes pas encore là.

De toute façon, votre structure a été stockée sur le dépôt central.

Pour vérifier si c'est bien le cas, démarrez un autre artsbuilder et choisissez "File/Retrieve". Vous verrez votre structure réalisée lors du tutoriel disponible. Choisissez-la et regardez : cet artsbuilder a désormais la même structure dans cet éditeur que dans l'autre.

Cliquez sur "File/Execute structure" dans les deux artsbuilders contenant cette structure. Vous entendrez alors deux fois la même chose. Suivant l'instant où vous avez lancé l'exécution, le son sera plus ou moins bon.

### Étape 7: Synthèse contrôlée par midi

Enfin, vous êtes maintenant en mesure de transformer votre onde sinusoïdale en instrument proprement dit. Ceci ne prend son sens que si vous avez quelque chose de bricolé qui puisse envoyer des événements midi vers aRts. Je vais décrire maintenant comment vous pouvez utiliser des claviers midi externes, mais un séquenceur compatible avec les bus midi comme Brahms fonctionnera aussi.

Tout d'abord, nettoyez votre bureau pour n'obtenir que les deux fenêtres de artsbuilder (les deux n'étant pas en cours d'exécution), une avec le tutoriel, l'autre avec la structure de jeu (on l'appellera structure de base). Allez alors à la structure tutoriel et remplacez le module Synth_SEQUENCE par un module Interface_MIDI_NOTE. Connectez sa fréquence à l'objet Synth_FREQUENCY. Vous verrez que celui-ci, cependant, n'a pas de sortie "pos".

Ceci est dû au fait qu'il n'existe aucun algorithme au monde capable de prédire quand l'utilisateur va relâcher la note qu'il vient juste d'enfoncer sur le clavier midi. Donc à la place, il y a un paramètre "pressed" (pressé) qui indique juste si l'utilisateur maintient la touche enfoncée (pressed = 1 : touche maintenue enfoncée, pressed = 0 : touche relâchée).

Cela signifie que l'objet Synth_PSCALE doit lui aussi être remplacé maintenant. Reliez un objet Synth_ENVELOPE_ADSR à la place. Connectez

- La sortie "pressed" du module MIDI_NOTE à l'entrée "active" du module ADSR

- La sortie "out" du module SIN à l'entrée "in" du module ADSR

- La sortie "out" du module ADSR à l'entrée "left" du module UPLINK

- La sortie "out" du module ADSR à l'entrée "right" du module UPLINK

Réglez les paramètres attack à 0.1, decay à 0.2, sustain à 0.7 et release à 0.1.

Une autre chose à laquelle nous devons penser est que la structure de l'instrument, d'une manière ou d'une autre, doit maintenant savoir quand elle est prête à jouer, et alors elle doit se fermer, car sinon, ça ne s'arrêtera jamais, même si la note a été relachée. Heureusement, l'enveloppe ADSR sait lorsqu'il n'y aura plus rien à entendre puisque de toute façon elle fixe le signal à zéro un certain temps après que la touche ait été enfoncée.

Ceci est indiqué en passant la sortie "done" à 1. Prenez un module Synth_STRUCT_KILL et connectez-le à la sortie "done" de l'enveloppe ADSR. Cela va fermer la structure dès que la sortie "done" passe à 1.

Publiez votre structure d'instrument sur le serveur (il s'appelle toujours tutoriel et l'ancien sera écrasé).

Allez à l'autre artsbuilder et insérez un module Synth_MIDI_ROUTER. Mettez "channel" à 0, son maximum à 4 et sa structure à tutoriel. Il sera alors à l'écoute des événements midi sur le canal 0, et chaque fois qu'il en reçoit un, il crée une structure tutoriel, qui va à son tour créer des ondes sinusoïdales et les envoyer sur le bus. Pendant que j'y pense : réglez le paramètre "bus" du MIDI_ROUTER à une valeur quelconque, disons "audio", j'expliquerai ça plus tard. Donc ignorez les autres points comme x, y, parent.

Cliquez sur "File/Execute structure" (dans le artsbuilder avec la structure de base seulement, puisque exécuter un instrument sans en donner la fréquence ne rime à rien).

Ouvrez un terminal et tapez `midisend`. Prenez votre clavier et commencez à jouer (il doit bien sûr être connecté à l'ordinateur). Si vous voyez que le processeur n'est pas surchargé, vous pouvez essayer de passer le paramètre "max" du MIDI_ROUTER à 8, permettant à 8 voix ou peut être même encore plus d'être calculées.

### Faire un vrai instrument

...A_FAIRE... Bon ok, cette section doit être écrite. Si vous êtes curieux de connaître la façon de faire un "vrai" instrument qui est accepté par le mapper d'instruments (et probablement qui a son propre panneau de contrôle pour cela), lisez la partie "instruments" dans la section concepts. ...FIN A_FAIRE...

### Suggestions

Vous êtes maintenant capable de vous servir de arts. Voici quelques astuces que vous pouvez tester pour améliorer vos structures.

- Essayez d'utiliser d'autres choses que des ondes sinusoïdales. Si vous connectez une onde triangulaire, vous penserez probablement que le son n'est pas terrible. Mais essayez d'associer un filtre SHELVE_CUTOFF avec une onde triangulaire pour couper les fréquences supérieures à une certaine limite (essayez quelque chose comme 1000 Hz, ou encore mieux deux fois la fréquence d'entrée, ou la fréquence d'entrée + 200 Hz ou quelque chose comme ça).

- Essayez d'utiliser plusieurs oscillateurs. Le module Synth_XFADE peut être utilisé pour mixer les deux signaux, et Synth_ADD pour les additionner.

- Essayez de ne pas donner exactement les mêmes fréquences à tous les oscillateurs, ça donne des oscillations sympathiques (NdT effet de chorus).

- Essayez d'utiliser plusieurs enveloppes.

- Essayez de synthétiser des instruments avec des sorties différentes à gauche et à droite.

- Essayez un post-traitement du signal en sortie du downlink. Vous pouvez par exemple mixer une version retardée du signal avec l'original pour obtenir un effet d'écho.

- Essayez d'utiliser le réglage de la vélocité proposé par le module Interface_MIDI_NOTE (c'est la force avec laquelle la touche a été frappée, vous pouvez aussi dire volume). L'effet est toujours intéressant lorsque la vélocité n'influe pas uniquement sur le volume du signal résultant, mais aussi sur le son de l'instrument (par exemple la fréquence de coupure).

- Lisez la section sur les éléments de l'interface graphique et regardez ce que vous pouvez faire avec (n'essayez pas de les utiliser dans un instrument, mais plutôt comme post-traitement).

- ...

Si vous avez créé quelque chose de bien, envoyez moi s'il vous plaît un échantillon au format mpg (et/ou la structure elle même) à l'administrateur de notre site web, histoire de montrer quelque chose sur nos pages ;).

## À propos des exemples

### Conseils d'ordre général

Virtuellement tous les exemples sont désormais munis d'une interface graphique, utilisant principalement le mapper d'instruments. Pour jeter un coup d'oeil sur les exemples, utilisez "File/Retrieve from server". Vous pouvez éditer et exécuter tous les exemples qui commencent par example_.

Tous les instruments synthétisés sont disponibles dans chaque exemple.

L'instrument flexible_slide fournit sa propre interface graphique.

example_stereo_beep est un petit exemple qui génère une onde sinusoïdale à 440 Hz sur le haut-parleur gauche, et une onde sinusoïdale à 880 Hz sur le droit.

Tous les autres sont des exemples de synthèse contrôlée par midi. Heureusement, ils sont assez commodes à utiliser à ce jour...

Vous pouvez les utiliser en conjonction avec midisend de la façon suivante :

- démarrez artsbuilder

- choisissez "File/Retrieve" from server

- choisissez soit example_instrument_fx soit example_instrument_pure : example_instrument_fx possède en plus un effet d'écho.

- allez à "File/Execute Module"

- choisissez "add" et ajoutez un instrument sur un canal midi

- il s'exécute maintenant et va synthétiser les événements qui arrivent sur le bus midi, alors on va en créer ;)

- démarrez midisend dans une fenêtre console

- Vous devriez pouvoir jouer sur votre clavier maintenant

- vous pouvez changer d'instrument à la volée avec le mapper d'instrument

- pour séquencer, vous devrez probablement installer un séquenceur qui supporte le bus midi (vois la section bus midi) - Brahms (qui était autrefois appelé kooBase) par exemple est un bon outil pour travailler avec aRts

Soyez prudent sur le nombre maximum de voix du mapper d'instrument dans la structure principale. Peut être que votre ordinateur peut calculer plus de voix que le nombre par défaut (8) avec certains instruments, peut être même que 8 sont déjà trop... Regardez la charge de votre processeur pour voir comment se comporte votre ordinateur.

## Possibilités avancées avec les utilitaires

### Scinder le clavier avec midisend

Midisend est capable d'utiliser un fichier de mappage spécial. Ceci est une solution intermédiaire tant que aRts ne pourra pas gérer le traitement du midi d'une façon aussi similaire et modulaire que le traitement de l'audio.

Avec ce fichier, vous pouvez dire à midisend de modifier les messages midi qui arrivent sur votre port midi. Le message midi est changé avant d'être envoyé à aRts.

Avec cela vous pouvez par exemple scinder votre clavier.

Ce fichier est un simple fichier ascii. Il est constitué de commentaires (qui commencent par un ´#´) et de commandes. Les lignes vides sont ignorées. Les espaces et tabulations supplémentaires sont aussi ignorés.

Glossaire :

Pitch

  est le numéro de note de la touche. Pour connaître quelle hauteur (pitch) est assignée à chaque touche de votre clavier, démarrez midisend avec -v

Channel

  spécifie l'instrument. Dans aRts, vous assignez un canal à un instrument.

Vous pouvez utiliser les commandes suivantes pour configurer midisend :

PitchRange to Channel

  Lorsqu'une hauteur arrive sur le canal <Channel>, et se situe dans une plage donnée, le canal du message midi sera changé en <ToChannel>.

  Syntaxe : PRC <Channel>,<FromPitch>,<ToPitch>,<ToChannel>

PitchRange Difference addition

  Lorsqu'une hauteur arrive sur le canal <Channel>, et se situe dans une plage donnée, <PitchDifference> est ajouté à la hauteur.

  Syntaxe : PRD <Channel>,<FromPitch>,<ToPitch>,<PitchDifference>

Pitch To Channel

  Lorsqu'une hauteur <Pitch> arrive sur le canal <Channel>, la hauteur sera modifiée en <ToChannel>.

  Syntaxe : PTC <Channel>,<Pitch>,<ToChannel>

Pitch To Pitch

  Lorsqu'une hauteur <Pitch> arrive sur le canal <Channel>, la hauteur sera modifiée en <ToPitch>

  Syntaxe : PTP <Channel>,<Pitch>,<ToPitch>

Exemples : admettons que vous ayez un clavier à 49 touches. Pour scinder le clavier en deux, où chacune des deux zones est assignée à un canal différent, mais se situe sur la même octave, vous utiliserez :

    PRC 0, 1, 59,  1
    PRD 0, 1, 59, 24

Si vous voulez seulement que la première zone du clavier se situe une octave en dessous, vous utiliserez :

`PRD 0, 1, 59, -12`

### Récupération d'échantillons sur les CD AKAI avec akaiparse

Arts peut lire les CD d'échantillons AKAI grâce à l'utilitaire akaiparse. Il ne fonctionne pour l'instant qu'avec les CD d'échantillons du S1000. Si vous avez des CD d'échantillons d'autres modèles AKAI, et de bonnes compétences en programmation, vous pouvez étendre les fonctionnalités de l'utilitaire pour les prendre en compte aussi.

Les CD contiennent généralement deux types de fichiers : les échantillons et les programmes. Les programmes contiennent les informations sur l'échantillon (les échantillons) à jouer et comment le (les) jouer pour une hauteur midi et une certaine vélocité. Actuellement, aRts ne peut lire que les échantillons que vous avez extrait du CD, pas les programmes.

Il y a deux façons d'accéder au CD. Soit vous commencez par créer une image du CD complet (environ 650 Mo pour un CD complet), et ensuite vous utilisez akaiparse pour extraire des échantillons de l'image. Pour créer l'image, lancez `dd if=/dev/cdrom of=<nom_de_votre_image>`

Soit vous accédez au CD directement à chaque fois, en spécifiant /dev/cdrom comme source à akaiparse.

Vous pouvez alors faire les choses suivantes avec akaiparse :

Lister le contenu d'une partition (ou d'un répertoire spécifique)

  - akaiparse <fichier> <partition> ls

  - akaiparse <fichier> <partition> ls <répertoire>

Extraire les échantillons d'une partition (ou d'un répertoire spécifique)

  - akaiparse <fichier> <partition> get

  - akaiparse <fichier> <partition> get <répertoire>

<fichier> peut être soit un nom de fichier de l'image du CD AKAI ou du lecteur CDRom (comme /dev/cdrom, /dev/scd0 ou /dev/scr0).

<partition> peut être soit une lettre de partition comme A ou B ou le paramètre "all" pour afficher (extraire) toutes les partitions.

### Construction de fichiers de mappage AKAI avec akaikggen

Lorsque vous aurez extrait, disons un piano complet avec peut-être environ une centaine d'échantillons, vous voudrez probablement que aRts joue l'échantillon BOE_LD_F#3-L sur le canal gauche et l'échantillon BOE_LD_F#3-R sur le canal droit si vous enfoncez la touche F#3. Si vous avez seulement un échantillon BOE_LD_F#3-* et un échantillon BOE_LD_G#3-*, mais pas d'échantillon BOE_LD_G-3-*, vous voudrez alors certainement que aRts joue l'échantillon BOE_LD_F#3-* (ou BOE_LD_G#3-*) à la place, mais transposé vers le haut/vers le bas en conséquence.

Pour faire cela (sans passer trop de temps à écrire le fichier de mappage), il y a un utilitaire appelé akaikggen. Il fonctionne en définissant des groupes d'échantillons, comme left_channel et right_channel. Vous assignez alors tous les échantillons eu canal gauche avec -L, et tous les échantillons au canal droit avec -R.

Pour cela, ouvrez une fenêtre terminal et entrez quelque chose comme

    akaikggen leftsample = BOE_LD_*-L
    rightsample = BOE_LD_*-R

Si le résultat vous plaît, vous pouvez le rediriger dans un fichier avec

    akaikggen leftsample = BOE_LD_*-L rightsample =
    BOE_LD_*-R > boe_ld.arts-map

Une solution simple consiste à placer la ligne `structure=play_akai_stereo` au début du fichier. Vous pouvez alors copier le fichier résultant dans votre répertoire arts/maps (dans votre répertoire utilisateur), et l'utiliser.

### Configuration avancée du serveur avec artsshell

Artsshell est un utilitaire qui accède directement à l'interface CORBA de artsserver - donc il ne fonctionne que si artsserver est en cours d'exécution.

Vous pouvez régler quelques options de configuration utiles avec artsshell.

Obtention de l'information de status

  Entrez

      artsshell -i

  pour obtenir des informations de status utiles à propos de l'utilisation du cache, le nombre de modules actifs, etc.

      artsshell -s

  vous donnera des informations sur les réglages du temps réel de aRts.

Taille du cache

  Si vous travaillez avec des échantillons, vous trouverez utile le fait d'utiliser automatiquement un cache pour ces données. Cependant, pour certaines applications (comme charger un piano complet de 100 échantillons à partir d'un CD AKAI), la taille du cache préconfigurée à 8 Mo est tout simplement trop petite. Pour l'augmenter, utilisez

      artsshell -C <taille du cache en Ko>

Paramètres du temps réel (temps de réponse)

  Pour certains ordinateurs ou certaines applications, le temps de réponse préconfiguré peut ne pas être optimal. Par exemple, si vous voulez "juste" utiliser aRts comme serveur audio, et écouter quelques mp3, des temps de réponses de 10 ms ne sont pas vraiment nécessaires. Lorsque vous cliquez sur le bouton stop de votre lecteur, ce n'est pas gênant que le mp3 s'arrête un peu après, par exemple une demi-seconde plus tard.

  Il y a trois paramètres pour cela : le nombre de fragments, la taille de chaque fragment, et la taille du cycle d'ordonnancement. La mémoire tampon du pilote du son est constitué de fragments*(taille de chaque fragment) octets qui, divisé par 2 (16 bits) et le nombre de canaux, donne le temps de réponse. Une documentation détaillée sur la façon dont cela est implanté par l'OSS (NdT : Open Source System : pilote son distribué de manière commerciale pour plusieurs systèmes Unix par 4Front Technologies. La version gratuite, connue sous le nom d'OSS/Free, continuera d'être disponible gratuitement pour Linux) se trouve à l'adresse http://www.4front-tech.com /pguide/audio2.html

  La taille du cycle d'ordonnancement est le nombre d'échantillons calculés par aRts quand il détecte que la mémoire tampon de la carte son n'est pas vide.

  Pour obtenir des résultats utiles, le retard du cycle d'ordonnancement doit être plus petit que celui des fragments. Rêgle : le retard d'un ou deux fragments doit probablement correspondre au retard du cycle d'ordonnancement. Utilisez

      artsshell -F <fragments>:<taille>
      -S <échantillons_du_cycle_d_ordonnancement>

  pour configurer ces paramètres.

Information de déboguage

  Si vous développez aRts ou si vous cherchez un bogue, vous pouvez utiliser

      artsshell -D 1

  pour permettre l'affichage des informations de déboguage. Pour afficher une telle information depuis artsserver (ou un des modules), utilisez simplement artsdebug comme vous auriez utilisé printf (vous devez inclure "debug.h").

### Fonctionnalités du serveur audio avec artscat

Lisez aussi la section sur le serveur audio s'il vous plaît. Comme dans aRts-0.3.4, artscat peut enregistrer des données depuis aRts (avec une carte full duplex, vous pouvez enregistrer des données du monde extérieur - dans tous les cas, vous pouvez bien sûr enregistrer ce que fait aRts).

D'un autre côté, vous pouvez rejouer les données à travers aRts.

Jouer les données

  Utilisez

      artscat -t <type> -d <description> -p

  pour jouer les données avec aRts, et fournir ce que vous voulez jouer sur l'entrée standard (stdin). Nous supposons que les données sont au format 44100 Hz, raw, 16 bits, stéréo, signé, le (little endian). Bon, juste à titre d'exemple, ce que produit le pilote de la sortie standard de mpg123 -s ou mikmod est à ce format.

Enregistrer les données

  Utilisez

      artscat -t <type> -d <description> -r

  pour enregistrer des données de aRts, et vous aurez l'enregistrement résultant sur la sortie standard. Les données seront au format 44100 Hz, raw, 16 bits, stéréo, signé, le.

  Attendez-vous à des coupures ici. En interne, aRts traite les données en flottant, et par conséquent ne fait pas attention si vous transférez par exemple des données dans la plage [-4..4] sur un bus. Mais si vous enregistrez ces données avec artscat, elles seront coupées (ou je pense qu'il y aura de méchants dépassements de capacité). Donc assurez vous que vous enregistrez des données dans une plage raisonnable à partir des bus. Synth_SATURATE_ATAN est votre ami dans ce cas.

Toutes ces opérations avec artscat sont assignées à un bus par l'interaction de l'utilisateur. Le fait de démarrer simplement artscat ne fera rien - vous devez encore lui assigner un bus. Faites ceci soit avec artsshell -c et -d, soit en utilisant une structure d'interface graphique qui a un gestionnaire audio actif (comme par exemple example_mixer_eqfx et semblables).

## Manuel de référence des modules

### Synth_NIL

Ne fait rien. Il est juste utile à des fins de test.

### Synth_XFADE

Mélange deux signaux. Si le taux entré est -1, seul le canal de gauche sera entendu, et si c'est 1, seul le canal de droite sera entendu. Lorsqu'il vaut zéro, les deux signaux auront le même volume.

Ceci permet de vous assurer que le signal restera dans une certaine plage bien définie. Si vous aviez deux signaux qui étaient entre -1 et 1 avant le mélange, ils seront dans la même plage après.

### Synth_AUTOPANNER

L'opposé d'un "crossfader". Il prend un signal mono et le divise en un signal stéréo : ceci est utilisé pour régler automatiquement la panoramique du signal d'entrée entre les sorties droites et gauches. Cela rend les mixages plus vivants. On applique cet effet par exemple sur une guitare ou un son solo.

Connectez un LFO (NdT Low Frequency Oscillator : oscillateur basse fréquence), une onde sinusoïdale ou en dents de scie par exemple au port "inlfo" et sélectionnez une fréquence entre 0.1 et 5 Hz pour un effet traditionnel ou même pour un effet spécial.

### Synth_MUL

Multiplie un signal par un facteur. Vous pouvez l'utiliser pour atténuer des signaux (0 < facteur < 1), pour les amplifier (facteur > 1) ou pour les inverser (facteur < 0). Notez que le facteur peut être un signal et peut ne pas être constant (comme une enveloppe ou un signal réel).

### Synth_ADD

Ajoute deux signaux.

### Synth_DELAY

Retarde le signal d'entrée d'une certaine quantité. Cette durée doit être spécifiée entre 0 et 1 pour un retard entre 0 et une seconde.

Ce genre de retard ne devrait pas être utilisé dans les structures avec des boucles de contre-réaction. Ceci est dû au fait que c'est un retard variable. Vous pouvez modifier sa longueur alors qu'il est en fonctionnement, et même mis à zéro. Mais comme dans une structure en boucle la sortie est nécessaire pour calculer l'échantillon suivant, un délai avec une valeur qui tombe à zéro lors de la synthèse peut aboutir à une situation où plus rien ne se passe.

Utilisez alors plutôt CDELAYs dans ce cas, combinez peut-être une valeur constante petite (de l'ordre de 0.001 seconde) avec une valeur variable.

Vous pouvez aussi combiner un CDELAY et un DELAY pour obtenir un retard de durée variable avec une valeur minimale dans une boucle à contre-réaction. Assurez vous que vous avez un CDELAY.

### Synth_CDELAY

Retarde le signal d'entrée d'une certaine durée. Cette durée doit être comprise entre 0 et 1 pour un délai allant de 0 seconde à 1 seconde. Le délai est constant lors du calcul, ce qui signifie qu'il ne peut pas être modifié.

Il permet de gagner en temps de calcul puisqu'aucune interpolation n'est effectuée, et il est utile dans les structures récursives. Voir la description précédente (Synth_DELAY).

### Synth_FX_CFLANGER

Un flanger est un effet de retard variable dans le temps. Pour simplifier, ce module est fourni et contient le code d'un flanger sur un seul canal.

Il a les ports suivants :

invalue

  Le signal que vous voulez traiter.

lfo

  De préférence une onde sinusoïdale qui module le retard dans le flanger (-1 .. 1).

mintime

  La valeur minimale du retard dans le flanger en millisecondes. Valeurs suggérées : essayez quelque chose comme 1 ms. S'il vous plaît, utilisez des valeurs < 1000 ms.

maxtime

  La valeur maximale pour le retard dans le flanger en millisecondes.Valeurs suggérées : essayez quelque chose comme 5 ms. S'il vous plaît, utilisez des valeurs < 1000 ms.

outvalue

  Le signal de sortie. Il est important que vous le mélangiez avec le signal d'origine (non flangé) pour obtenir l'effet désiré.

Conseil : vous pouvez l'utilisez comme base pour un effet de chorus.

### Synth_FREQUENCY

Dans aRts, les oscillateurs ne nécessitent pas une fréquence en entrée, mais une position dans l'onde. La position doit être comprise entre 0 et 1 qui positionne un objet Synth_WAVE_SIN standard sur la plage 0..2*pi. Pour générer un signal oscillant à partir d'une fréquence, un module Synth_FREQUENCY est utilisé.

### Synth_FM_SOURCE

Utilisé pour la modulation de fréquence. Mettez votre fréquence à l'entrée qui lui est dédiée, et envoyez un autre signal dans l'entrée du modulateur. Réglez alors le niveau de modulation, par exemple 0,3. La fréquence sera alors modulée par le modulateur. Essayez simplement. Ça sonne bien si vous y mettez une contre-réaction, ce qui signifie que vous prenez une combinaison du signal de sortie retardé d'un module Synth_FM_SOURCE (vous devez le relier à un oscillateur puisqu'il ne joue que le rôle d'un module Synth_FREQUENCY) et d'un autre signal pour obtenir de bons résultats.

Ça fonctionnne bien en combinaison avec des oscillateurs Synth_WAVE_SIN.

### Synth_WAVE_SIN

Oscillateur sinusoïdal. Envoyez un signal "pos" d'un module Synth_FREQUENCY ou Synth_FM_SOURCE en entrée. Vous obtiendrez une onde sinusoïdale en sortie. Le signal "pos" spécifie une position dans l'onde, la plage 0..1 est modifiée en 0..2*pi de manière interne

### Synth_WAVE_TRI

Oscillateur triangulaire. Envoyez un signal "pos" d'un module Synth_FREQUENCY ou Synth_FM_SOURCE en entrée. Vous obtiendrez une onde triangulaire. Le signal "pos" spécifie une position dans l'onde, la plage 0..1 est modifiée en 0..2*pi de manière interne. Soyez prudent. Le signal d'entrée *DOIT* se situer dans la plage 0..1 pour que le signal de sortie donne de bons résultats.

### Synth_WAVE_SQUARE

Oscillateur générant un signal carré. Envoyez un signal "pos" d'un module Synth_FREQUENCY ou Synth_FM_SOURCE en entrée. Vous obtiendrez une onde carrée. Le signal "pos" spécifie une position dans l'onde, la plage 0..1 est modifiée en 0..2*pi de manière interne. Soyez prudent. Le signal d'entrée *DOIT* se situer dans la plage 0..1 pour que le signal de sortie donne de bons résultats.

### Synth_PLAY

Vous avez besoin d'un module Synth_PLAY pour entendre ce que vous créez. Le troisième paramètre (canaux) doit être fixé à 1 ou 2 pour sélectionner un son mono ou stéréo. Les canaux droit et gauche devraient contenir l'entrée normalisée pour les canaux. En mono, seul le côté gauche est utilisé. Si votre signal d'entrée n'est pas entre -1 et 1, vous obtenez du bruit. Vous pouvez par exemple utiliser Synth_ATAN_SATURATE pour vous assurer que le signal se situe dans la bonne plage.

Il ne devrait y avoir qu'un seul module Synth_PLAY en action, puisqu'il accède directement à votre carte son. Utilisez les bus si vous voulez mélanger plusieurs signaux audio avant de les jouer.

Notez que le module Synth_PLAY sert aussi de référence temporelle pour toute la structure. Cela signifie pas de module Synth_PLAY = pas de référence temporelle = pas de son. Vous avez donc besoin d'(exactement) un objet Synth_PLAY.

### Synth_FILEPLAY

Si vous voulez échantillonner ce que produit aRts, vous pouvez désormais le faire. Utilisez le module Synth_FILEPLAY. La syntaxe est la même que pour le module Synth_PLAY :

Vous devez connecter le canal gauche si vous travaillez en mono et les deux canaux si vous travaillez en stéréo. Ensuite vous spécifiez le nombre de canaux sur le port dédié à cela, soit 1 (mono), soit 2 (stéréo). Arts envoie alors ce qui est joué vers le fichier /tmp/arts.wav. Il écrase le fichier s'il existe.

IMPORTANT : utilisez-le toujours en conjonction avec un module Synth_PLAY, car sinon même la synthèse ne fonctionnera pas correctement.

### Synth_DEBUG

Vous pouvez l'utiliser pour déboguer. Il affiche les valeurs en entier à intervalles réguliers (par exemples une seconde), combiné avec un commentaire que vous avez spécifié. Vous pouvez ainsi vérifier que votre signal reste confiné dans une certaine plage, ou tout simplement s'il est présent.

### Synth_PLAY_WAV

Interprète un fichier wav. Il ne sera présent que si vous avez installé libaudiofile (je réécrirai probablement le code). La lecture de l'échantillon débutera dès la création de la structure. Elle s'arrêtera à la fin de l'échantillon, et le paramètre "done" passera alors à 1 (par exemple pour fermer la structure).

### Synth_PLAY_AKAI

Joue un échantillon akai. La lecture de l'échantillon démarre dès que la structure est crée. Elle s'arrête dès que c'est fini, et le paramètre "done" passe à 1 (par exemple pour fermer la structure).

Comme les fichiers d'échantillons AKAI contiennent une hauteur de base et une fréquence d'enregistrement, vous pouvez transposer les échantillons akai. Vous pouvez donc spécifier la fréquence désirée, et le résultat sera transposé en conséquence. Cette transposition affectera aussi la longueur de l'échantillon.

### Synth_PLAY_AKAIS

Identique à Synth_PLAY_AKAI, mais joue deux échantillons simultanément, un à gauche et un à droite. Ceci est utile car les échantillons AKAI ne supportent pas la vraie stéréo - utiliser deux Synth_PLAY_AKAI serait possible aussi, mais ceci sollicite plus le processeur. Ici, la transposition de la hauteur n'est calculée qu'une fois - les échantillons doivent être enregistrés avec la même fréquence d'échantillonnage et la même hauteur, sinon évidemment ça ne fonctionnera pas.

### Synth_BUS_UPLINK

Lien vers un bus. Envoyez les signaux sur les ports gauche et droit, et le nom d'un bus où les données doivent aller sur le port "bus". Le signal constitué de tous les uplink avec ce nom apparaîtra sur chaque downlink sur ce bus.

### Synth_BUS_DOWNLINK

Collecte (la somme de) toutes les données qui sont placées sur un certain bus (avec le nom que vous spécifiez sur le port "bus"). Pour éviter que le signal soit hors-plage, donnez le nombre de clients sur le port "client". Le signal sera alors divisé par ce nombre.

### Synth_SHELVE_CUTOFF

Filtre toutes les fréquences supérieures à la fréquence de coupure.

### Synth_MOOG_VCF

Filtre toutes les fréquences supérieures à la fréquence de coupure (c'est un filtre 24 dB, 4 pôles, qui filtre avec une pente de -24 dB par octave au dessus de la fréquence de coupure), mais offre un paramètre supplémentaire pour régler la résonance du filtre, 0 signifie pas de résonance, et 4 correspond à des oscillations auto-entretenues (self oscillation).

### Synth_RC

Filtre résonant amorti : il filtre toutes les fréquences autour d'une valeur centrale. Il n'y a aucun moyen de spécifier la fréquence centrale (qui ne sera pas coupée), puisque les entrées sont deux constantes étranges f et b. Le code est très vieux, il doit dater de l'époque des premiers synthétiseurs, et sera probablement remplacé par un nouveau filtre qui aura deux paramètres : fréquence et résonance.

Essayez quelque chose comme b=5, f=5 ou b=10, f=10 ou b=15, f=15.

### Synth_STD_EQUALIZER

Un égaliseur paramétrique sympathique. Ses paramètres sont

invalue, outvalue

  Signal filtré par l'égaliseur.

low

  Comment sont modifiées les basses fréquences. La valeur est en dB, et 0 signifie pas de changement sur les basses fréquences, -6 les atténue de 6 dB et +6 les amplifie de 6 dB.

mid

  Comment sont modifiées les fréquences médium par l'égaliseur en dB (voir plus haut).

high

  Comment sont modifiées les fréquences aiguës par l'égaliseur en dB (voir plus haut).

frequency

  Fréquence centrale de l'égaliseur en Hz, les fréquences médium se situent autour de cette valeur, les graves et les aiguës sont respectivement avant et après cette fréquence. Notez que cette fréquence ne doit pas être supérieure à la moitié de la fréquence d'échantillonnage, habituellement 22050 Hz, et ne doit pas être inférieure à 1 Hz.

q

  Influence la largeur du spectre des médiums. Ce doit être une valeur strictement positive. 1 est une valeur raisonnable, des valeurs supérieures signifient un spectre de fréquences médium plus fin. Des valeurs inférieures à 1 signifient un spectre plus large.

### Synth_SEQUENCE

Joue une séquence de notes en boucle. Les notes sont données en notation "tracker", et sont séparées par des point-virgules. Par exemple `A-3;C-4;E-4;C-4;`. La vitesse est donnée en secondes par note, donc si vous voulez un tempo de 120, choisissez 0.5 seconde/note, puisque 60 secondes/0.5 seconde par note = 120 bpm (NdT : bpm = beat per minute = pulsations par minute ou tempo).

Vous pouvez donner à chaque note une durée relative à la vitesse en utilisant le symbole deux points après la note, suivi de la durée, par exemple `A-3:2;C-4:0.5;D-4:0.5;E-4;`. Comme vous pouvez le voir, les séquenceurs midi sont beaucoup plus confortables ;)

Le module Synth_SEQUENCE donne des informations supplémentaires sur la position de la note qu'il joue, 0 signifie juste démarrée, et 1 signifie terminée. Vous pouvez utiliser cette information avec Synth_PSCALE (voir plus bas).

### Synth_PSCALE

Le module Synth_PSCALE va échelonner le signal audio qui lui est envoyé d'une valeur 0 (silence) jusqu'à 1 (volume original) puis 0 (silence), en tenant compte de la position (récupérée à partir d'un module Synth_SEQUENCE). La position où le pic survient est donné par le paramètre "pos".

Exemple : placer le maximum à 0.1 signifie que lorsque 10% de la note ont été joués, le volume a atteind son maximum, et commence à diminuer.

### Synth_ENVELOPE_ADSR

C'est une enveloppe ADSR classique. Vous devez spécifier :

active

  si la note est pressée par l'utilisateur

invalue

  signal d'entrée

attack

  durée entre le moment où l'utilisateur presse une note et celui où le signal atteind son amplitude maximale (secondes)

decay

  durée entre le moment où le signal atteind son amplitude maximale et où le signal revient à un niveau constant (en secondes)

sustain

  niveau constant auquel le signal est maintenu après, jusqu'à ce que l'utilisateur relâche la touche.

release

  durée entre le moment où l'utilisateur relâche la note et celui où le signal atteind une valeur nulle (en secondes)

Vous obtiendrez le signal alors modulé par l'enveloppe sur le port "outvalue". Si l'enveloppe ADSR est terminée, le port "done" passera à 1. Vous pouvez utiliser Synth_STRUCT_KILL avec, pour fermer la structure.

### Synth_STRUCT_KILL

Supprime la structure actuelle lorsque le signal "ready" (prêt) est supérieur à 0.5 (prêt : quand il arrive à 1). Utile pour les enveloppes ADSR ou les modules PLAY_WAV dans les structures d'instruments.

### Synth_MIDI_ROUTER

Crée la structure spécifiée chaque fois qu'il reçoit un événement midi sur le bon canal. Pour vous éviter de surcharger le processeur, vous pouvez spécifier un nombre maximum de structures actives simultanément.

Si la structure contient un module Interface_MIDI_NOTE (normalement, elle devrait), le MIDI_ROUTER passera la fréquence et d'autres informations à la structure.

Si pour la structure que vous avez spécifié il existe un panneau de contrôle, qui doit s'appeler nom_de_la_structure_GUI, il sera fourni avec les paramètres x,y et parent et même créé avant que la première touche soit enfoncée. Jetez un coup d'oeil à la section concepts->instruments pour plus de détails.

### Synth_MIDI_DEBUG

Vous pouvez l'utiliser pour déboguer l'arrivée des événements midi dans aRts.

Lorsqu'un MIDI_DEBUG fonctionne, artsserver affichera une ligne comme

    201 100753.837585 on 0 42 127

    202 101323.128355 off 0 42

La première ligne vous dirait que 100753 ms (c'est-à-dire 100 secondes) après le démarrage de MIDI_DEBUG, un événement midi est arrivé sur le canal 0. Ce message midi "on" avait une vélocité (volume) de 127, le plus fort possible. La ligne suivante montre l'événement de fin de note.

### Synth_ATAN_SATURATE

Utilisé pour normaliser le signal d'entrée entre -1 et 1 pour pouvoir être lu par Synth_PLAY. Plus le signal d'entrée est fort, plus il va subir de distorsions. Pour de faibles signaux d'entrée, le signal de sortie est quasiment celui en entrée (pas de changements)

### Interface_MIDI_NOTE

Une fréquence, une vélocité (volume) et un paramètre vous seront passés, si cette touche est toujours pressée. Cette information n'est donnée que si la structure a été créée par un module Synth_MIDI_ROUTER.

### Modules de paramètres internes Synth_PARAM_<quelque chose>

N'utilisez pas Synth_PARAM_GET, Synth_PARAM_SET, Synth_PARAM_SGET et Synth_PARAM_SSET (sauf pour tester ou si vous avez lu le fichier source). Ils disparaîtront dans les prochaines versions de aRts.

### Support du serveur audio interne

Synth_AMAN_INJECT est utilisé pour injecter des données audio à partir de clients de serveurs audio dans le système de flux. Ne l'utilisez pas dans les structures, il est utilisé de manière interne (regardez audioman_impl.cc pour plus de détails). Susceptible de changer/disparaître sans préavis.

## Manuel de référence des modules d'interface

### Gui_PANEL

Panneau dans lequel vous pouvez mettre d'autres éléments de contrôle. Vous devez spécifier une largeur (width) et une hauteur (height) (par pas de 10 points, donc spécifier un panneau de largeur 10 et de hauteur 10 va générer un objet de 100 * 100 points à l'écran).

Le panneau a une sortie appelée "id" (identificateur), que vous pouvez connecter au port "parent" d'autres contrôles pour les mettre dans le panneau.

### Gui_SUB_PANEL

width, height, pixmap ont la même signification que pour le panneau. Mais vous pouvez mettre un sous-panneau dans un panneau en connectant le port "parent". Vous pouvez alors aussi choisir une position relative (si le parent le permet), en spécifiant x et y.

### Gui_POTI

C'est un bouton rotatif pour régler les paramètres. Parent, x, y ont la même signification que pour le sous-panneau. "color" spécifie une couleur (essayez aussi des noms comme red (rouge) ou darkgrey (gris foncé), ou utilisez la notation #rrggbb). "caption" spécifie le titre du buton. "min" et "max" sont les valeurs minimale et maximale du paramètre. Le bouton démarrera avec la position donnée sur le port "initial". Connectez "value" partout où vous voulez utiliser cette valeur.

### Gui_SLIDER

Ressemble au bouton rotatif. Il a deux textures pour le personnaliser (expérimental), la première sur la partie qui se déplace, l'autre pour le fond.

### Gui_WINDOW

Le paramètre "window - caption" spécifie le titre de la fenêtre. Placez des panneaux ou des sous-panneaux dedans.

### Gui_LABEL

Le paramètre "label - caption" spécifie le texte, "parent" spécifie le parent, x,y la position et "pixmap" la texture de fond. Le paramètre "color" spécifie la couleur. Des chaînes comme "blue" sont permises tout comme des spécifications de couleurs sous la forme #rrggbb.

### Gui_INSTRUMENT_MAPPER

Le truc magique pour assigner des instruments à des canaux midi avec l'interaction de l'utilisateur. Placez-le dans un panneau ou un sous-panneau et il sera heureux.

### Gui_AUDIO_MANAGER

Aussi un contrôle complet (comme le mapper d'instruments). Il affichera les clients audio qui sont connectés au serveur audio (voir la section suivante), et permet à l'utilisateur de les connecter à des bus. Il est important de savoir que sans assigner un client à un bus, il ne commencera même pas à jouer.

C'est à peu près le même concept qu'avec les gestionnaires de fenêtres qui n'ouvrent une fenêtre seulement après avoir laissé l'utilisateur choisir une position sur le bureau, comme on le voit dans de nombreux gestionnaires de fenêtres.

### Gui_MIXER

Crée un mixeur. Vous devez fournir les paramètres suivants :

parent

  où le mélangeur doit apparaître. Vous devrez probablement lui donner une fenêtre.

channels

  nombre de canaux que vous désirez. Notez que le mélangeur travaille sur des canaux stéréo, donc en spécifiant 8 ici, vous aurez en réalité 16 canaux audio mono.

structure

  à quoi doit un canal doit ressembler. Voir plus bas.

name

  nom du mixeur. Les canaux individuels s'appeleront <nom>01, <nom>02, <nom>03,...

output

  bus de sortie utilisé.

La structure que vous donnez au mixeur doit contenir un canal de mixage (stéréo), avec un panneau de contrôle. Elle doit avoir les paramètres suivants :

input (IN string property)

  Bus depuis lequel les canaux individuels doivent collecter les données. Vous devez récupérer les données vous-même avec un Synth_BUS_DOWNLINK.

parent (IN audio signal)

  Spécification d'un parent dans lequel le panneau de contrôle sera affiché. Placez ici un élément graphique Gui_SUB_PANEL.

output (IN string property)

  Bus vers lequel les canaux individuels envoient les données. Vous devez vous-même envoyer les données avec un Synth_BUS_UPLINK.

## Utilisation de aRts comme "serveur audio générique"

### L'idée - qu'est-ce qu'un "serveur audio générique ?"

Vous n'avez qu'une carte son, mais vous avez un système d'exploitation qui vous permet d'exécuter 50 applications à la fois. Dans un environnement classique, seule l'une d'elle peut lire/écrire sur le matériel audio, puisqu'il n'y a qu'un port /dev/dsp fourni par linux.

Toutefois, ce problème a été résolu de manière élégante dans d'autres domaines. Vous avez probablement une seule carte graphique, mais vous pouvez lancer 50 applications simultanément, chacune dans sa propre fenêtre. Vous avez un gestionnaire de fenêtre pour choisir ce que vous voulez voir, à quel endroit, vous avez un panneau qui vous aide à démarrer de nouvelles choses, vous avez un gestionnaire de fenêtres, probablement des bureaux virtuels et d'autres choses encore. Comme vous pouvez le voir, un système de fenêtrage comme X11 résoud le problème vraiment élégamment.

L'idée d'un "serveur audio générique" comme je l'appelle se présente comme une solution similaire à X11 pour l'audio. Cela signifie qu'un serveur devrait avoir accès à la carte son, tandis que toutes les autres applications lisent et écrivent sur la carte son par ce serveur.

### ESD/KAudioServer et autres

Mais stop. Quoi encore ? On vous a probablement déjà dit que esd fait ça, ou que kaudioserver règle justement ce problème. Pourquoi réinventer la roue ?

Fondamentalement, ce qu'ils font est ajouter tous les flux audio qui arrivent, et peuvent enregistrer et jouer des échantillons. Alors qu'ils sont bons pour cela (et raisonnablement optimisés pour cette tâche particulière), leurs concepts ne vont pas suffisamment loin pour proposer leurs services à des applications plus complexes.

Des logiciels comme AudioLogic ne pourraient tout simplement pas utiliser ESD ou KAudioServer pour accomplir leurs tâches.

Pour utiliser l'analogie avec X11, ces serveurs audio "simples", c'est comme avoir plusieurs consoles linux avec SVGALib. Alors que ça règle le problème de lancer plusieurs applications simultanément, ils ne fournissent pas de moyens simples de les utiliser ensemble. Ils n'ont pas de concepts de gestion, d'interaction, de synchronisation, de midi, de filtres (ou seulement de petites parties sont implantées),...

### L'alternative : utiliser aRts comme "serveur audio générique"

D'un autre côté, aRts ne manque pas de fonctionnalités pour en faire un "serveur audio générique" de la même façon que ESD ou KAudioserver.

L'avantage de faire cela est que dans aRts, beaucoup de problèmes ont déjà été résolus et beaucoup de technologies sont disponibles. Par exemple :

- temps réel

- graphiques de flux

- parallélisme

- effets

- communication avec une interface graphique

- interface pour plusieurs clients

- technologie midi

Ainsi l'idée d'essayer de rendre aRts adapté pour être un serveur audio générique à plein temps, qui serait capable tour à tour d'offrir des services à des applications plus complexes qu'un simple lecteur mp3, comme par exemple AudioLogic ou Cubase.

aRts pourrait à long terme devenir une alternative à DirectSound pour les plateformes pour lesquelles il fonctionne, permettant à plusieurs applications d'interagir en temps réel grâce à un système de flux partagés.

### artscat : les premiers pas

Bien sûr, sans compter les applications complexes, aRts doit être principalement capable de remplir les tâches que faisaient bien ESD/KAudioServer. Jetons un coup d'oeil à un lecteur mp3, et comment le très récemment écrit artscat essaie de fournir ici les premiers services de "serveur audio générique".

Dans un monde parfait, le serveur audio (aRts) saurait de toute façon ce que sont les mp3, et de plus, dans un monde parfait, une architecture de lecture multimédia pour des données comme les mp3 existerait à l'intérieur du serveur audio, et il n'y aurait tout simplement pas de lecteur mp3 puisque aRts lui-même pourrait afficher un écran sympathique avec des contrôles et jouer le mp3.

Hélas ce monde parfait n'est pas tout à fait celui dans lequel nous vivons. Donc nous avons besoin d'autres choses en attendant.

Heureusement, un lecteur mp3 n'a pas besoin de grand chose pour fonctionner. Il lit un fichier, affiche peut-être une fenêtre (ou pas), et finalement envoie le flux audio à la carte son. Ce que nous pouvons faire ici est de le laisser envoyer les données plutôt à aRts. Ainsi aRts peut récupérer ces données, et les rediriger vers des mixeurs, des effets, des bus, des boucles à contre-réaction etc., et finalement les envoyer vers la carte son.

Les nouvelles versions de aRts (>= 0.3.3) permettent cela. Il y a un petit utilitaire appelé artscat, qui récupère un flux d'octets depuis l'entrée standard (stdin) et l'envoie à aRts via TCP (pas CORBA pour le transport car ce serait trop lent). Artscat a la syntaxe suivante :

    artscat -d <description> -t <type>

tandis que type et description sont utilisés pour que l'utilisateur voie ce qu'il se passe et seront peut-être utilisé dans les versions futures de aRts pour assigner automatiquement des canaux à certains services...

De l'autre côté, les données seront récupérées. L'utilisateur peut choisir avec un élément graphique Gui_AUDIO_MANAGER à quel bus envoyer les données (jetez un coup d'oeil aux options -c et -d de artsshell si vous voulez savoir comment obtenir les mêmes fonctionnalités de tâches assignées depuis la ligne de commande plutôt que depuis artsbuilder). Pour fournir un test pratique, un script shell artsmp3 a été écrit. Si vous avez installé mpg123, vous pouvez maintenant simplement taper

    artsmp3 <nom du fichier>

Il utilisera artscat pour envoyer votre flux de données au serveur. Il ouvrira une fenêtre "konsole" pour afficher sa sortie. Ça fonctionne bien si vous avez un mixeur à l'écran (essayez l'exemple example_mixer_eq), donc vous pouvez mixer votre mp3 avec quelque chose d'autre, par exemple avec une improvisation en direct que vous jouez sur votre clavier.

Où avec un autre mp3. J'ai réussi à jouer 9 mp3 en même temps avec aRts sur un PII/350. Peut-être que ce n'est pas vraiment utile, mais ça montre que la technologie qu'il y a derrière est stable. Il n'y avait pas de clics ou de coupures. Mais je dois avouer que je n'ai pas utilisé de mixeur pour économiser le processeur... avec un mixeur, le nombre de canaux possibles est certainement inférieur.

L'enregistrement est maintenant supporté aussi, comme dans aRts-0.3.4.

### Étape suivante : artsrec, artsmon, échantillons, api client, compatibilité

Comme artscat est écrit, les étapes suivantes seraient :

enregistrement (implanté maintenant)

  Support de l'enregistrement dans aRts. La difficulté principale est ici que aRts aurait besoin de lire/écrire sur une carte son full duplex, tout en étant capable d'évaluer ses flux de données. Bref - c'est désormais possible.

monitoring (implanté maintenant)

  Bon, esd supporte le monitoring de ce qui a été mixé ensemble, mais comme artscat devrait être capable d'enregistrer des données depuis n'importe quel point dans le système de flux, il pourrait aussi enregistrer les données brièvement avant de les jouer. artscat dans sa version actuelle peut faire cela.

échantillons

  À la fois esd et KAudioserver permettent aux programmes de stocker des échantillons dans le serveur audio, qui peuvent alors être rejoués par une commande courte. Ce ne devrait vraiment pas être un problème pour l'implanter, puisque aRts peut déjà lire des échantillons.

api client et compatibilité

  Alors que l'interface CORBA convient à certaines personnes, pour la plupart elle sera trop laide. Il y aura donc une bibliothèque encapsulante (wrapper) autour d'elle qui accèdera facilement à aRts.

  D'un autre côté ce serait bien d'avoir une compatibilité ascendante avec les vieilles API, peut-être même avec le protocole.

Bref, et si c'est fait, on peut essayer d'ajouter des cloches supplémentaires et des sifflets puisque aRts peut faire beaucoup plus de choses que de mixer des flux audio. L'équaliseur fourni avec la version actuelle de aRts donne une idée de ce qui est possible.

## Développement

### Liste des tâches officielle de aRts

[ Ne demandez pas ce que aRts peut faire pour vous, mais ce que vous pouvez faire pour aRts ;) ]

Peut-être voulez-vous participer à l'amélioration de aRts, mais vous ne savez pas quels sont les besoins. Peut-être que vous n'êtes pas à l'aise avec la programmation C++ ou Qt.

Tout d'abord, inscrivez-vous à la liste de diffusion, jetez un coup d'oeil à http://linux.twc.de/arts pour plus de détails. La liste des tâches de cette documentation ne sera certainement pas toujours à jour.

J'ai créé une liste de tâches qui me semblent importantes pour un développement rapide du projet. Si vous voulez, choisissez une tâche qui vous intéresse et contactez-moi...

#### Tâches qui ne demandent pas de connaissances en programmation

Peut être plus de documentation d'ordre générale sur la synthèse

  Ce serait bien d'avoir une documentation/des tutoriels (éventuellement illustrés) qui décriraient réellement les différents types de synthèse, les effets, les instruments.

  Juste pour en citer quelques uns, je pense que beaucoup de personnes qui veulent apprendre à utiliser aRts ont besoin d'introductions sur

  - Qu'est-ce que la modulation de fréquence ?

  - Qu'est-ce que la modulation en anneau ?

  - Comment fonctionnent les oscillateurs ?

  - Que font ces filtres ?

  - Comment créer un vocoder ?

  - Comment créer un son analogique qui sonne bien ?

  - Comment fonctionnent les vieux synthétiseurs tels que les 303, 909, mini moog, ... ?

  - Comment faire tout ça avec aRts ?

  Ce serait bien si tout ça était au format sgml ou html ou n'importe quel format lisible par tout le monde.

Exemples de aRts

  Même choses que pour la documentation. Les gens doivent voir que ce programme est vraiment puissant !

Morceaux de démonstration

  Si vous avez créé quelque chose de bien, contactez-moi simplement ;) On devrait voir grossir une collection de mp3 sur le site web de aRts, afin que tout le monde puisse juger à l'écoute ce que ça donne quand on utilise aRts.

Maintenance des structures (important !)

  Comme aRts grossit lentement, il va atteindre son but : virtuellement, chaque synthétiseur, appareil de studio et effet peut être construit à partir de petits modules.

  Mais cela signifie aussi que quelqu'un maintienne un jeu de structures standards qui seront livrées avec la distribution de aRts, comme des mixeurs, des égaliseurs, des synthétiseurs, des effets, des panneaux de contrôle, des applet incrustable dans le tableau de bord etc. Tout comme la partie aujourd'hui la plus importante de emacs n'est certainement pas le code de base, mais toutes les choses emacs-lisp livrées avec emacs (de la coloration syntaxique à la "dunnet dungeon" (jeux d'aventure en mode texte sous emacs) et autres jeux), une grande partie de la facilité d'utilisation pour l'utilisateur final dépendra du grand ensemble de structures qui seront livrées avec aRts.

Normalisation des modules

  C'est un gros travail, mais certainement intéressant et en tout cas un vrai challenge.

  Nous avons environ trente modules maintenant. Nous en aurons besoin de 50 au moins, pour que ça vaille vraiment le coup. Ils doivent être catégorisés et triés, décrits et écrits.

  Ce qui est tout particulièrement important est qu'ils doivent suivre le même concept. Par exemple, ça n'aurait pas de sens si on devait spécifier les fréquences de certains modules par 1/f, alors que d'autres attendraient qu'elles soient données par f.

  Ça ferait avancer les choses si vous écriviez vos propres modules (vous n'avez besoin que d'un peu de C++), mais ce n'est certainement pas nécessaire.

  Un bon point de départ serait de créer une hiérarchie de noms, où tous les modules seraient répertoriés, comme par exemple Synth_BUS_UPLINK => Synthesis/Busses/Uplink ou Synth_SHELVE_CUTOFF => Synthesis/Filters/Shelve Cutoff. Les noms donnés aux modules est une sorte de hiérarchie, mais comme ils ne changent jamais, utiliser une autre hiérarchie serait une bonne idée (ceci nous permettrait aussi de traduire cette hiérarchie pour les versions internationalisées).

  Tous les modules non-structurés comme Synth_PLAY ou Synth_MUL ou Synth_CDELAY devraient tout de même trouver une place dans cette hiérarchie.

#### Tâches qui ne nécessitent pas de connaissances particulières en programmation/écriture de scripts.

modules externes (plugins)

  Imaginez comment l'interface graphique et le système de synthèse pourraient être étendus en temps réel avec les modules externes chargeables dynamiquement. Il y a quelque chose dans koffice2, mais je ne sais pas si ça peut nous être utile.

  En particulier pour les synthétiseurs, on ne peut pas se permettre d'avoir des pertes de performances lors de l'ordonancement ;)

bus midi : généralités

  Comment Arts et le reste du monde communiquent ? Comment les événements midi peuvent être acheminés ? OK, il y a une solution facile, mais ce n'est pas recommandé si vous avez dix appareils sur votre bus midi. Pas encore. Dans tous les cas, ceci doit être discuté en public (sur la liste de diffusion KDE correspondante), pour rendre les choses compatibles à l'avenir.

  En tout cas ce serait bien si plus de programmes (outre Cantor) pouvaient supporter les bus midi. Peut-être quelques "trakers" (voodoo tracker, soundtracker, kegtracker), ou quelques séquenceurs (jazz, koobase, gseq, etc.)

  PS : je ne me focaliserai pas à faire de aRts (et le bus midi et ce qui va avec) un projet KDE uniquement, mais écrire une interface graphique KDE était pour moi le meilleur moyen de faire fonctionner les choses rapidement et de les rendre utilisables. Je veux FAIRE DE LA MUSIQUE avec bientôt, et pas de la conception pendant deux ans ;)

bus midi : améliorations

  Le bus midi devient lent sous une forte sollicitation (un millier d'événements par seconde). Ce n'est pas sympathique. Je pense qu'il serait possible de remédier totalement à ce problème s'il y avait un standard pour passer les événements par le bus mais pas en temps réel. Ça pourrait fonctionner comme suit :

  - Le programme client demande au serveur d'ouvrir un canal

  - Le programme client envoie les événements pour les dix premières secondes (avec des messages de synchronisation ou "time stamp")

  - Le programme client dit au serveur de démarrer

  - Le serveur notifie au programme client lorsqu'il a besoin de plus d'événements

  ou

  - Le programme client décale la position dans le morceau

  - Le programme client envoie plus d'événements lorsque cela est nécessaire.

  Puisque transférer plusieurs événements d'une séquence simultanément devrait être beaucoup plus rapide que les transférer un par un, on devrait pouvoir utiliser CORBA.

  Une autre option serait de transférer les événements en utilisant des sockets TCP, UDP ou IPC à mémoire partagée. Toutes ces solutions seront plus rapides que CORBA.

bus midi : pas de bus midi

  Il y aura peut-être quelque chose d'autre... voir la section bus midi/autres considérations.

éditeur graphique

  Cette partie est aussi un vrai challenge. Nous avons besoin de quelque chose qui montre ce qui se passe - et bien sûr tous ces boutons que l'on peut bidouiller pour modifier le son. Peut-être pouvons-nous aussi réutiliser quelque chose de koffice, pour avoir des composants qui peuvent être simplement chargés en cours d'exécution.

  Bref, il y a des choses qui fonctionnent, mais bien sûr beaucoup de choses à améliorer.

amélioration des performances

  Tout ce qui peut accélérer les choses est le bienvenu. Vous aurez à essayer, vous arrêter un instant et réfléchir un peu ici. aRts est déjà beaucoup plus rapide à partir de la version 0.3.0 en raison du calcul multi-échantillons

  PS : le support multiprocesseur (SMP) serait une bonne chose.

Écriture des modules

  C'est proche de la normalisation des modules (voir plus haut). Nous en avons besoin... maintenant, parce que sans modules sympathiques et qui travaillent ensemble à merveille, aRts ne vaut rien.

  Vous n'avez pas besoin de grandes connaissances en programmation (C ou C++), puisque les modules qui mélangent deux échantillons ou ceux qui retardent des données audio sont relativement simples. ;)

lire des CD d'échantillons

  La synthèse n'est certainement pas le moyen idéal pour tout faire. Si vous voulez un Steinway, vous devez peut-être en acheter un en échantillons et l'utiliser. Ce serait bien si aRts pouvait simplement lire les CD d'échantillons dans des formats habituels, comme AKAI. Cela rendrait la composition avec aRts vraiment plus facile. C'est aussi beaucoup de travail en moins que d'utiliser un piano complet échantillonné avec des commutations sur la vélocité, plutôt que de les configurer à la main dans des boîtes de dialogue.

  Résolu en grande partie.

système de flux : passage d'événements

  Ce serait bien si le système de flux de aRts pouvait, outre traiter les signaux audio, supporter aussi les événements. Cela signifierait que vous pourriez avoir des modules qui transposent, combinent, modifient et filtrent les messages midi tout comme les modules qui font la même chose sur les signaux.

serveur audio

  Personnellement, je pense que ce serait une bonne idée de rendre aRts capable de remplacer esd, kaudioserver, nas et d'autres à l'avenir. aRts devrait devenir un mélange de DirectX et DirectShow, Generator et le sous-système audio CuBase VST/Logic audio.

  En tous cas cela nécessite de travailler sur l'intégration avec les autres et de s'assurer que aRts peut réellement supporter toutes les tâches qui sont actuellement aussi supportées par les serveurs audio classiques.

Construction des structures de haut niveau

  Considérons le problème suivant : vous voulez décrire une table de mixage virtuelle. Cette table a un certain nombre de canaux, et un certain nombre d'effets. Sur chaque canal, vous avez un préamplificateur, et ensuite un égaliseur. Alors, une certaine quantité du signal est acheminée à travers les différents processeurs d'effets (y-compris un processeur d'effet nul, correspondant à un jeu direct).

  Il devrait être possible de décrire la table de mixage virtuelle dans aRts, puis les effets (délai, réverb, chorus...) puis les instruments (piano, kit de batterie, cordes...).

  Après cela, les caractéristiques devraient être placées dans une sorte de base de donnée de structures. Finalement, l'utilisateur final devrait uniquement faire les choses suivantes :

  - Démarrer le séquenceur

  - Dire hmmm, je veux une table de mixage

  - En sélectionner une dans la liste

  - Avoir des boutons pour ajouter et enlever des canaux

  - Régler le nombre de canaux à 4

  - Charger des effets (délai, réverb, chorus et aucun)

  - Charger des instruments (piano, kit de batterie, cordes)

  - Assigner les instruments aux canaux

  - Utiliser la table de mixage pour calibrer les canaux

  - Utiliser les panneaux d'effets pour les configurer

  - Commencer à composer

  Les structures qui peuvent être utilisées comme modules (comme dans la version 0.3.1) résolvent probablement une partie du problème, mais ces structures ne sont pas vraiment un concept complet. Il y a déjà eu des travaux sur ce problème, mais encore plus de travaux sont probablement nécessaires

  Par exemple, le fait qu'il y ait un exemple example_mixer_simple, example_mixer_eqfx, example_mixer_eq, example_mixer_eqfx8, ... devrait vous faire réfléchir. Pourquoi autant ? Et pourquoi le comptage des canaux est codé en dur ? Il devrait y avoir un moyen plus modulaire pour résoudre cela dès que de nouveaux effets vont apparaître.

  Pensez-y.

architecture d'économie du processeur

  Arts ne devrait pas consommer du processeur tant que rien n'est calculé - ceci implique des changements significatifs dans l'ordonnanceur pour que cela fonctionne.

implantation commune des serveurs

  Le serveur de l'interface graphique et du flux devraient partager une quantité plus importante de leur implantation - ce serait parfait s'ils utilisaient aussi des modules externes communs

nouvelle architecture de transfert

  Le transfert entre l'interface graphique et le serveur de synthèse avec CORBA est une mauvaise idée dès que le nombre d'événements augmente. Un nouveau logiciel médiateur de transfert a besoin d'être écrit, par exemple pour être capable de supporter les analuseurs de spectres graphiques, dans un soucis d'économie du processeur.

  Utiliser la mémoire partagée ou TCP serait probablement une bonne idée.

Petites tâches (ou comment occuper sa journée)

  - Synth_WAVE_TRI devrait s'appeler Synth_WAVE_SAW, et Synth_WAVE_TRI devrait être réimplantés comme sur tous les autres synthétiseurs. Changez les exemples pour cela.

  - Synth_WAVE_PULSE devrait être une onde carrée avec des temps de montée/descente configurables. Faites des exemples.

  - Utiliser une structure appelée "foo" dans une structure "foo", et exécuter le résultat donne un plantage.

  - Considérer l'écriture d'un module qui lit directement /dev/midi (pas par midisend)=> plus rapide.

  - Transposition de la hauteur des fichiers d'échantillons (même implantation que dans les modules AKAI, peut être beaucoup de code commun à convert.cc).

  - Refaire la structure des répertoires (si vous voulez le faire, demandez d'abord). Les modules devraient être séparés.

  - Ajouter le code d'un écran d'accueil lors du chargement au lieu de ce laid "should I start the server now". Contactez Harald pour les graphiques.

  - Essayez d'intégrer le support des polices de partition de façon intelligente - le code est par exemple disponible dans timidity.

  - Ajouter le support ALSA natif.

  - Implanter le chargement progressif des échantillons, ce qui devrait conduire à de meilleures performances sur le premier échantillon joué.

  - Éliminer Interface_MIDI_NOTE et le remplacer par des ports standards (éventuellement compliqués).

  - Les instruments qui nécessitent un nom de fichier devraient être capables d'avoir un panneau de contrôle où vous pouvez entrer cela (éventuellement compliqué).

  - Chaque module devrait avoir son propre fichier (cette idée est proche du nettoyage de la structure du répertoire)

  - Les modules devraient être des librairies partagées.

  - Éviter d'appeler kvt s'il n'est pas présent (appeler autre chose comme xterm à la place).

  - Enlever chaque "Calculate" et le remplacer par "CalculateBlock" - après cela, enlever complètement "Calculate" de SynthModule et mettre "CalculateBlock".

  - Introduction de kdoc

  - Les boutons d'aide devraient faire quelque chose (le mieux serait d'afficher une page d'aide, en fonction du contexte).

### Style de programmation

Ces styles de programmation arrivent tard, je sais ;), j'ai commencé sans eux. De toute façon, à l'avenir, essayez de vous y tenir.

Nom des fonctions membres

  Style Qt, ce qui signifie une majuscule au début de chaque mot, et la première lettre toujours en minuscule ; aucun caractère de soulignement

  Voici un exemple

       createStructureDesc()
      updateWidget();    start();

membres de classes

  Les membres de classes s'écrivent en minuscule, comme par exemple menubar ou button, _mais_ les pointeurs faisant référence à des objets distants *commencent par une majuscule*, comme Synthesizer.

  Lorsqu'il y a des fonctions d'accès, le standard devrait être celui de CORBA, c'est-à-dire lorsque vous avez un membre foo de type long, qui ne doit pas être visible directement, vous créez les fonctions

       Foo(long new_value); long Foo();

  pour récupérer et envoyer les valeurs. Dans ce cas, la valeur réelle de foo devrait être stockée dans _Foo.

nom des classes

  Toutes les classes doivent s'écrire avec une majuscule au début de chaque mot, par exemple ModuleView, SynthModule. Les classes de CORBA ont normalement un nom avec mention explicite de l'espace de nom , comme Arts::Synthesizer.

  Les implantations des classes CORBA devraient être appelées Class_impl, comme par exemple Synthesizer_impl.

Paramètres

  Les paramètres sont toujours en minuscule.

Variables locales

  Les variables locales sont toujours en minuscule, et ont des noms comme i, p, x, etc.

Largeur de tabulation (largeur du décalage)

  Une tabulation correspond à 4 espaces.

### Quelques mots sur CORBA

Le futur de KDE (et d'autres systèmes comme GNOME) et leur interaction dépend fortement de leur processus de communication interne. Les scripts, l'encapsulation, l'interaction, le confort, la réutilisation de composants... tout dépend de ça. CORBA est la solution

Il fournit ces fonctionnalités au dessus du réseau, ce qui permet d'oublier toutes les astuces et protocoles baveux, les solutions basées sur les IPC et les solutions spécifiques qui ont été utilisées dans le passé.

Maintenant le temps est venu où les gens (moi y-compris) doivent apprendrent à utiliser ces technologies, de sorte que l'évolution de logiciels toujours meilleurs puisse se produire sous des systèmes d'exploitation libres comme linux, dans des projets libres comme KDE etc.

Ainsi j'ai commencé à écrire aRts (un projet qui m'intéresse depuis longtemps) en utilisant CORBA. Je devrai apprendre ce qu'il est possible de faire avec, d'autres devront l'apprendre, et CORBA doit devenir un outil au même titre qu'un shell, C++, Qt ou gtk etc.

Bien sûr, il y a des problèmes, et votre outil CORBA ne bénéficiera pas de la large utilisation et le test que ceux qu'a subi votre shell, mais il est important d'y parvenir bientôt.

De plus - j'ai vraiment envie de faire de la MUSIQUE - je n'ai pas windows ou quelque chose du genre car je n'accepte pas de travailler avec chez moi, il y a de meilleures choses à faire ;)

Donc aRts sera ce dont j'ai besoin (et ce dont d'autres ont besoin j'espère). Un outil pour faire de la musique, un moyen d'apprendre CORBA & Co, un projet cool, et quelque chose qui a - en opposition avec certaines de ces applications laides là bas - une interface graphique sympathique et qui peut communiquer avec d'autres applications dans la rêgle de l'art.

### Portage - écrire d'autres éditeurs graphiques pour aRts

Arts a une architecture très flexible. Il est susceptible d'être utilisé à partir de beaucoup d'autres applications comme serveur de synthèse en même temps.

Je suis sûr que certaines personnes n'aiment pas Artsbuilder aussi (qui fonctionne actuellement sous KDE). En fait, Arts a été conçu pour simplifier le portage de cette partie du programme, dans le but d'avoir plus tard des interfaces graphiques Gnome (ou d'autres).

Alors que ce guide décrit principalement l'interaction entre Artsbuilder et le synthétiseur aRts, il sera aussi utile pour faire communiquer d'autres applications simples ou plus complexes avec Arts.

Donc, qu'est-ce que vous devez faire avec votre interface graphique ?

Connecter l'instance du synthétiseur :

      // Vous devrez appeler orb->bind, le code mico pour cela est  :

      CORBA::Object_var obj =         orb->bind
      ("IDL:Arts/Synthesizer:1.0","inet:localhost:8888");

Création d'une description de structure de synthèse

  Appelez Synthesizer->createStructureDesc(). Vous aurez une description de structure.

Creation de modules

  Utilisez Synthesizer->getModuleCount() et Synthesizer->getModuleInfo() pour obtenir des enregistrements ModuleInfo. Ils ont un nom de membre, qui contient le nom du module. Affichez cela à l'utilisateur, pour éviter d'utiliser d'autres informations (qui ne sont pas sûres de rester dans cet enregistrement dans les prochaines versions).

  Allez à votre StructureDesc et passez-lui le module info, si vous ne voulez pas créer une telle description de module. Ce sera mis dans la structure.

  Vous pouvez alors maintenant l'afficher visuellement. Vous devrez déplacer le module vers un emplacement correct (moveTo(x,y)) avant d'enregistrer la structure.

Affichage des modules

  Les modules devraient ressembler à ça :

  Ce module aurait les ports d'entrée A B C, et un port de sortie a, et s'appelerait label. Ainsi, le module aurait la hauteur l dans le motif de grille, et la largeur width=1+max(inports.size(),outports.size()+1).

  Les modules sont positionnés dans l'éditeur de façon à ne pas se recouvrir.

Connexion des ports, réglages des paramètres

  Vous pouvez maintenant régler les paramètres de votre module en utilisant la séquence ModuleDesc->Ports, qui contient les références sur les ports d'un module. Vous pouvez appeler connectTo, disconnect,...

  On peut soit connecter un port, soit lui assigner une valeur, ou le laisser non connecté.

Exécution des modules

  Utilisez Synthesizer->createStructure(StructureDesc) pour créer une instance de cette structure, qui sera synthétisée.

  Gardez l'id et passez-le à freeStructure ensuite.

Enregistrement des fichiers

  Enregistrez votre StructureDesc avec saveToList(), et écrivez le contenu du Arts::StringSeq résultant dans un fichier texte. Donnez lui l'extension .arts.

Ouverture de fichiers

  Ouvrez un fichier arts dans un Arts::StringSeq. Allez vers un StructureDesc que vous avez déjà et appelez StructureDesc->loadFromList(theStringSeq).

Bien sûr Arts est encore en cours de construction, des choses fondamentales comme la construction d'interfaces graphiques pour les synthétiseurs manquent et ne sont pas spécifiées dans l'interface.

Donc l'interface de Arts va grandir dans le futur. Mais je pense que si nous avons au moins deux interfaces graphiques pour améliorer cette interopérabilité, cela nous aiderait beaucoup pour en faire une bonne solution.

Théoriquement, vous pouvez aussi facilement porter arts vers d'autres systèmes d'exploitation. Tant que mico se compile sur la plateforme cible, le synthétiseur devrait se compiler aussi. Vous devrez peut-être modifier du code dans Synth_PLAY, mais c'est à peu près tout. Vous pouvez créer alors une nouvelle interface graphique en utilisant les outils natifs de votre système d'exploitation, ou peut-être Java, et vous avez un portage de arts.

Caractéristiques avancées

  Bien sûr, aRts n'est pas resté aussi simple que ce qui est décrit plus haut. La nouvelle la plus importante est peut-être que vous pouvez utiliser des modules visuels maintenant. Ils sont implantés de manière interne dû à l'interface CORBA ArtsServeur fournie par le processus interface graphique, cette interface pouvant instancier des structures (tout comme le serveur de synthèse principal). L'idée est que l'interface graphique aussi devrait être composée des mêmes modules et suivre les mêmes règles que la base de la synthèse (synthesis "play-ground").

  Ceci rend le portage plus difficile, et suggère de le faire simplement en prenant artsbuilder dans sa totalité, et en remplaçant les appels à Qt par des appels à Gtk-- (ou autre chose). De toute façon, si vous avez l'intention de le faire, gardez à l'esprit qu'il devrait être intégré dans la version principale de artsbuilder, afin que les deux restent compatibles.

  Si vous voulez faire autrement (implanter une interface pour ArtsServer n'est pas non plus trop difficile), assurez-vous de coordonner l'interface avec l'interface graphique, afin que les structures comprises par Qt/KDE-Artsbuilder le soient aussi par votre programme, et vice-versa. Développez peut-être un modèle de composant croisé (pour pouvoir réutiliser le composant visuel qui fonctionne avec Artsbuilder dans vos logiciels et réciproquement).

## Épilogue

### Auteurs

aRts est sous le Copyright © 1998-1999 Stefan Westerfeld (stefan@space.twc.de)

Une partie du code est sous de copyright de leurs auteurs respectifs, voir les fichiers sources.

### Remerciements

Le projet Arts n'aurait pas été ce qu'il est sans (dans le désordre)

L'équipe KDE

  sans leur travail, il n'aurait peut-être pas été commencé du tout

Harald Lapp

  conception du site internet http://linux.twc.de/arts et conception des icônes

Paul Leonard (P.J.Leonard@bath.ac.uk )

  qui a écrit Cantor, le séquenceur sympathique qui travaille maintenant avec Arts via les bus midi

Juhana Sadeharju (kouhia@nic.funet.fi )

  qui a écrit une partie des filtres utilisés dans aRts

Jens Hahn (Jens.Hahn@t-online.de )

  qui a écrit une partie des modules utilisés dans aRts

Emmeran Seehuber (the_emmy@gmx.de )

  pour le code du partage de clavier/mapping de midisend

Martin Lorenz (lorenz@ch.tum.de )

  qui a écrit l'élément graphique KPoti que j'ai simplement intégré dans le Gui_POTI avec quelques lignes de code ;) - et bien sûr le Synth_STD_EQUALIZER que j'ai pu simplement extraire de khdrec.

David G. Slomin (dgslomin@alumni.princeton.edu )

  qui a contribué au code d'analyse midi pour les données midi compressées

Merci ! et bien sûr merci à tous ceux qui l'ont testé, qui n'ont pas craqué quand il a crashé, quand il ne s'est pas compilé, ... et qui ont écrit beaucoup de courriers avec une description détaillées de ce qui n'allait pas, participant ainsi à l'amélioration de aRts.

La traduction française a été réalisée par Ludovic Grossard

### Copyright & Licensing

                        GNU GENERAL PUBLIC LICENSE
                           Version 2, June 1991

     Copyright (C) 1989, 1991 Free Software Foundation, Inc.
     59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
     Everyone is permitted to copy and distribute verbatim copies
     of this license document, but changing it is not allowed.

                                Preamble

      The licenses for most software are designed to take away your
    freedom to share and change it.  By contrast, the GNU General Public
    License is intended to guarantee your freedom to share and change free
    software--to make sure the software is free for all its users.  This
    General Public License applies to most of the Free Software
    Foundation's software and to any other program whose authors commit to
    using it.  (Some other Free Software Foundation software is covered by
    the GNU Library General Public License instead.)  You can apply it to
    your programs, too.

      When we speak of free software, we are referring to freedom, not
    price.  Our General Public Licenses are designed to make sure that you
    have the freedom to distribute copies of free software (and charge for
    this service if you wish), that you receive source code or can get it
    if you want it, that you can change the software or use pieces of it
    in new free programs; and that you know you can do these things.

      To protect your rights, we need to make restrictions that forbid
    anyone to deny you these rights or to ask you to surrender the rights.
    These restrictions translate to certain responsibilities for you if you
    distribute copies of the software, or if you modify it.

      For example, if you distribute copies of such a program, whether
    gratis or for a fee, you must give the recipients all the rights that
    you have.  You must make sure that they, too, receive or can get the
    source code.  And you must show them these terms so they know their
    rights.

      We protect your rights with two steps: (1) copyright the software, and
    (2) offer you this license which gives you legal permission to copy,
    distribute and/or modify the software.

      Also, for each author's protection and ours, we want to make certain
    that everyone understands that there is no warranty for this free
    software.  If the software is modified by someone else and passed on, we
    want its recipients to know that what they have is not the original, so
    that any problems introduced by others will not reflect on the original
    authors' reputations.

      Finally, any free program is threatened constantly by software
    patents.  We wish to avoid the danger that redistributors of a free
    program will individually obtain patent licenses, in effect making the
    program proprietary.  To prevent this, we have made it clear that any
    patent must be licensed for everyone's free use or not licensed at all.

      The precise terms and conditions for copying, distribution and
    modification follow.

                        GNU GENERAL PUBLIC LICENSE
       TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

      0. This License applies to any program or other work which contains
    a notice placed by the copyright holder saying it may be distributed
    under the terms of this General Public License.  The "Program", below,
    refers to any such program or work, and a "work based on the Program"
    means either the Program or any derivative work under copyright law:
    that is to say, a work containing the Program or a portion of it,
    either verbatim or with modifications and/or translated into another
    language.  (Hereinafter, translation is included without limitation in
    the term "modification".)  Each licensee is addressed as "you".

    Activities other than copying, distribution and modification are not
    covered by this License; they are outside its scope.  The act of
    running the Program is not restricted, and the output from the Program
    is covered only if its contents constitute a work based on the
    Program (independent of having been made by running the Program).
    Whether that is true depends on what the Program does.

      1. You may copy and distribute verbatim copies of the Program's
    source code as you receive it, in any medium, provided that you
    conspicuously and appropriately publish on each copy an appropriate
    copyright notice and disclaimer of warranty; keep intact all the
    notices that refer to this License and to the absence of any warranty;
    and give any other recipients of the Program a copy of this License
    along with the Program.

    You may charge a fee for the physical act of transferring a copy, and
    you may at your option offer warranty protection in exchange for a fee.

      2. You may modify your copy or copies of the Program or any portion
    of it, thus forming a work based on the Program, and copy and
    distribute such modifications or work under the terms of Section 1
    above, provided that you also meet all of these conditions:

        a) You must cause the modified files to carry prominent notices
        stating that you changed the files and the date of any change.

        b) You must cause any work that you distribute or publish, that in
        whole or in part contains or is derived from the Program or any
        part thereof, to be licensed as a whole at no charge to all third
        parties under the terms of this License.

        c) If the modified program normally reads commands interactively
        when run, you must cause it, when started running for such
        interactive use in the most ordinary way, to print or display an
        announcement including an appropriate copyright notice and a
        notice that there is no warranty (or else, saying that you provide
        a warranty) and that users may redistribute the program under
        these conditions, and telling the user how to view a copy of this
        License.  (Exception: if the Program itself is interactive but
        does not normally print such an announcement, your work based on
        the Program is not required to print an announcement.)

    These requirements apply to the modified work as a whole.  If
    identifiable sections of that work are not derived from the Program,
    and can be reasonably considered independent and separate works in
    themselves, then this License, and its terms, do not apply to those
    sections when you distribute them as separate works.  But when you
    distribute the same sections as part of a whole which is a work based
    on the Program, the distribution of the whole must be on the terms of
    this License, whose permissions for other licensees extend to the
    entire whole, and thus to each and every part regardless of who wrote it.

    Thus, it is not the intent of this section to claim rights or contest
    your rights to work written entirely by you; rather, the intent is to
    exercise the right to control the distribution of derivative or
    collective works based on the Program.

    In addition, mere aggregation of another work not based on the Program
    with the Program (or with a work based on the Program) on a volume of
    a storage or distribution medium does not bring the other work under
    the scope of this License.

      3. You may copy and distribute the Program (or a work based on it,
    under Section 2) in object code or executable form under the terms of
    Sections 1 and 2 above provided that you also do one of the following:

        a) Accompany it with the complete corresponding machine-readable
        source code, which must be distributed under the terms of Sections
        1 and 2 above on a medium customarily used for software interchange; or,

        b) Accompany it with a written offer, valid for at least three
        years, to give any third party, for a charge no more than your
        cost of physically performing source distribution, a complete
        machine-readable copy of the corresponding source code, to be
        distributed under the terms of Sections 1 and 2 above on a medium
        customarily used for software interchange; or,

        c) Accompany it with the information you received as to the offer
        to distribute corresponding source code.  (This alternative is
        allowed only for noncommercial distribution and only if you
        received the program in object code or executable form with such
        an offer, in accord with Subsection b above.)

    The source code for a work means the preferred form of the work for
    making modifications to it.  For an executable work, complete source
    code means all the source code for all modules it contains, plus any
    associated interface definition files, plus the scripts used to
    control compilation and installation of the executable.  However, as a
    special exception, the source code distributed need not include
    anything that is normally distributed (in either source or binary
    form) with the major components (compiler, kernel, and so on) of the
    operating system on which the executable runs, unless that component
    itself accompanies the executable.

    If distribution of executable or object code is made by offering
    access to copy from a designated place, then offering equivalent
    access to copy the source code from the same place counts as
    distribution of the source code, even though third parties are not
    compelled to copy the source along with the object code.

      4. You may not copy, modify, sublicense, or distribute the Program
    except as expressly provided under this License.  Any attempt
    otherwise to copy, modify, sublicense or distribute the Program is
    void, and will automatically terminate your rights under this License.
    However, parties who have received copies, or rights, from you under
    this License will not have their licenses terminated so long as such
    parties remain in full compliance.

      5. You are not required to accept this License, since you have not
    signed it.  However, nothing else grants you permission to modify or
    distribute the Program or its derivative works.  These actions are
    prohibited by law if you do not accept this License.  Therefore, by
    modifying or distributing the Program (or any work based on the
    Program), you indicate your acceptance of this License to do so, and
    all its terms and conditions for copying, distributing or modifying
    the Program or works based on it.

      6. Each time you redistribute the Program (or any work based on the
    Program), the recipient automatically receives a license from the
    original licensor to copy, distribute or modify the Program subject to
    these terms and conditions.  You may not impose any further
    restrictions on the recipients' exercise of the rights granted herein.
    You are not responsible for enforcing compliance by third parties to
    this License.

      7. If, as a consequence of a court judgment or allegation of patent
    infringement or for any other reason (not limited to patent issues),
    conditions are imposed on you (whether by court order, agreement or
    otherwise) that contradict the conditions of this License, they do not
    excuse you from the conditions of this License.  If you cannot
    distribute so as to satisfy simultaneously your obligations under this
    License and any other pertinent obligations, then as a consequence you
    may not distribute the Program at all.  For example, if a patent
    license would not permit royalty-free redistribution of the Program by
    all those who receive copies directly or indirectly through you, then
    the only way you could satisfy both it and this License would be to
    refrain entirely from distribution of the Program.

    If any portion of this section is held invalid or unenforceable under
    any particular circumstance, the balance of the section is intended to
    apply and the section as a whole is intended to apply in other
    circumstances.

    It is not the purpose of this section to induce you to infringe any
    patents or other property right claims or to contest validity of any
    such claims; this section has the sole purpose of protecting the
    integrity of the free software distribution system, which is
    implemented by public license practices.  Many people have made
    generous contributions to the wide range of software distributed
    through that system in reliance on consistent application of that
    system; it is up to the author/donor to decide if he or she is willing
    to distribute software through any other system and a licensee cannot
    impose that choice.

    This section is intended to make thoroughly clear what is believed to
    be a consequence of the rest of this License.

      8. If the distribution and/or use of the Program is restricted in
    certain countries either by patents or by copyrighted interfaces, the
    original copyright holder who places the Program under this License
    may add an explicit geographical distribution limitation excluding
    those countries, so that distribution is permitted only in or among
    countries not thus excluded.  In such case, this License incorporates
    the limitation as if written in the body of this License.

      9. The Free Software Foundation may publish revised and/or new versions
    of the General Public License from time to time.  Such new versions will
    be similar in spirit to the present version, but may differ in detail to
    address new problems or concerns.

    Each version is given a distinguishing version number.  If the Program
    specifies a version number of this License which applies to it and "any
    later version", you have the option of following the terms and conditions
    either of that version or of any later version published by the Free
    Software Foundation.  If the Program does not specify a version number of
    this License, you may choose any version ever published by the Free Software
    Foundation.

      10. If you wish to incorporate parts of the Program into other free
    programs whose distribution conditions are different, write to the author
    to ask for permission.  For software which is copyrighted by the Free
    Software Foundation, write to the Free Software Foundation; we sometimes
    make exceptions for this.  Our decision will be guided by the two goals
    of preserving the free status of all derivatives of our free software and
    of promoting the sharing and reuse of software generally.

                                NO WARRANTY

      11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
    FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
    OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
    PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
    OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
    MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
    TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
    PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
    REPAIR OR CORRECTION.

      12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
    WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
    REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
    INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
    OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
    TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
    YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
    PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
    POSSIBILITY OF SUCH DAMAGES.

                         END OF TERMS AND CONDITIONS

### License of the sound drivers

    The sound support for the synthesizer is based on routines of
    mpeg3play version 0.9.6. That software is based on a mpeg
    decoder source from Frauenhofer - IIS.

    Therefore, the following copyright notices and disclaimers apply
    to the sound routines:

    1. From the public mpeg source from Frauenhofer - IIS:
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    This directory contains the MPEG-1 public source code for the Audio decoder
    layer 1, 2 and 3 as per printing of CD 11172-5 in April 1994.

    The version number is 4.1.

    As you can read in the source files work on these files is still in
    progress and they have not officially been released for public distribution.
    Nevertheless we at Fraunhofer Institute have tested the layer 3 part of
    the Decoder and believe that it is reasonably bug free.
    So feel free to evaluate the source code but keep in mind, that no
    warranties are associated with this software.

    While we believe that this software is reasonably bug free and well behaved,
    we are in no way responsible if this software does not work the way you
    would expect it to work. No matter if it locks up your computer, garbles
    your floppy disks or does any other harmful things to your computer - it
    is entirely your problem.
    Fraunhofer - IIS and the authors of this software are not liable for
    any infringments or damages of third parties' rights in consequence
    of your use of this software. Fraunhofer - IIS or the authors are in no
    event liable for, respectively do not warrant the trustworthiness,
    quality, industrial exploitability, serviceability of this
    software for the supposed purposeor any other purposes.

    2. From mpeg3play version 0.9.6:
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    			mpeg3play version 0.9.6
    			     April 6, 1997

    Home page:  The Solaris Helpers Page at
                http://home1.swipnet.se/%7Ew-10694/helpers.html

    Authors:    ISO/MPEG working groups, Fraunhofer Institute and
    	    Johan Hagman <Johan.Hagman@mailbox.swipnet.se>

    [...]

    Many thanks to the following people for their suggestions, optimizations
    and porting efforts

       Tim Newsome <drz@froody.bloke.com>		   Linux
       Damien Clermonte <clermond@esiee.fr>		   HPUX
       Troels Walsted Hansen <troels@stud.cs.uit.no>   Amiga
       Terje Malmedal <terje.malmedal@usit.uio.no>	   AIX
       Dan Nelson <dnelson@emsphone.com>		   FreeBSD
       Michael Cheng <mcheng@faraday.dialix.com.au>    Amiga
       Fredrik Hubinette <hubbe@lysator.liu.se>        Linux

    [...]

    The original source code for the decoder can be found in the file
    ftp://ftp.tnt.uni-hannover.de/pub/MPEG/audio/mpeg2/software/
    technical_report/dist08.tar.gz

    [...]

    ----------------------------------------------------------------------

       Copyright (C) 1996, 1997 by Johan Hagman

    mpeg3play is distributed "as is" at no additional charge. It can
    be used freely for any purpose, but may not be sold commercially.

    Johan Hagman disclaims all warranties with regard to this software,
    including all implied warranties of merchantability and fitness.
    In no event will Johan Hagman be liable for direct, incidental or
    consequential damages resulting from loss of data or business
    opportunities, resulting from mpeg3play, or any part of same,
    either alone or in conjunction with other programs.