<!DOCTYPE book PUBLIC "-//KDE//DTD DocBook V3.1-Based Variant V1.0//EN">
<book lang="fr">

<bookinfo>
<title>aRts - Synthétiseur analogique en temps réel</title>
<authorgroup>
<author>
<firstname>Stefan</firstname>
<surname>Westerfeld</surname>
<affiliation>
<address><email>stefan@space.twc.de</email></address>
</affiliation>
</author>
</authorgroup>
<date>29/09/1999</date>
<releaseinfo>0.03.04</releaseinfo>
<abstract>
<para>Ce document décrit aRts - le synthétiseur analogique en temps
réel.</para>
</abstract>
<keywordset>
<keyword>analogique</keyword>
<keyword>temps réel</keyword>
<keyword>synthésiseur</keyword>
<keyword>midi</keyword>
<keyword>bus midi</keyword>
<keyword>audio</keyword>
<keyword>son</keyword>
<keyword>effet</keyword>
<keyword>filtre</keyword>
</keywordset>
</bookinfo>

<chapter id="Introduction">
<title>Introduction</title>

<sect1 id="Qu-est-ce-que-aRts">
<title>Qu'est-ce que aRts ?</title>

<para>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... </para>

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

<para>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.</para>

<para>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.</para>

<para>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 !</para>
</sect1>

<sect1 id="Au-coeur-de-aRts">
<title>Au coeur de aRts</title>
<para>Alors qu'il doit déjà exister plusieurs synthétiseurs logiciels, aRts a
été conçu sur une idée directrice : <emphasis>la
flexibilité.</emphasis></para>
<para>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.</para>

<para>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.</para>

<para>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.</para>


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

<para><emphasis remap="bf">Plus de flexibilité avec CORBA :</emphasis></para>

<para>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.</para>
</sect1> </chapter>

<chapter id="Installation">
<title>Installation</title>
<sect1 id="Comment-obtenir-aRts">
<title>Comment obtenir aRts</title> <para><variablelist>
<varlistentry>
<term>Distributions de binaires</term>
<listitem>
<para>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.</para>
<para>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.</para>
<para>La partie suivante porte cependant sur l'installation classique à
partir des sources.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Versions stables des sources</term>
<listitem>
<para>La meilleure chose à faire est de se rendre sur le site internet de aRts
: <ulink url="http://linux.twc.de/arts">http://linux.twc.de/arts</ulink>,
et de le télécharger depuis là (où depuis un site miroir). Une autre
possibilité est de regarder sur ftp
<ulink
url="ftp://ftp.kde.org/pub/kde/unstable/apps/multimedia/sound">
ftp://ftp.kde.org/pub/kde/unstable/apps/multimedia/sound</ulink>
pour une archive récente de arts-x.y.z.tgz.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>versions de développement les plus récentes</term><listitem>
<para>Arts est développé dans le CVS KDE dans le module kmusic. Donc si vous y
avez accès, utilisez simplement <literal remap="tt">cvs checkout
kmusic</literal> et vous aurez la dernière version.</para>
<para>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 à <ulink
url="http://www.kde.org">http://www.kde.org</ulink>.</para> </listitem>
</varlistentry> </variablelist> </para>
</sect1>

<sect1 id="Fichiers-necessaires">
<title>Fichiers nécessaires</title>

<para>Actuellement, aRts se compile et fonctionne avec les logiciels suivants
(mais ça marche aussi avec les versions plus récentes ;) :
<itemizedlist>
<listitem>
<para>Linux 2.0.30 - <ulink url="http://www.linux.org">http://www.linux.org</ulink></para>
</listitem>
<listitem>
<para>Qt 1.32 - <ulink url="http://www.troll.no">http://www.troll.no</ulink></para>
</listitem>
<listitem>
<para>KDE 1.0 - <ulink url="http://www.kde.org">http://www.kde.org</ulink></para>
</listitem>
<listitem>
<para>mico 2.2.3, 2.2.7 or 2.3.0 - <ulink url="http://www.mico.org">http://www.mico.org</ulink></para>

<para><emphasis>IMPORTANT!! Vous devez compiler mico avec --disable-mini-stl
!! Sinon vous ne pouvez pas compiler aRts</emphasis>
</para>
<para>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.</para>
</listitem>
<listitem>
<para>egcs 1.0.2 - <ulink url="http://egcs.cygnus.com">http://egcs.cygnus.com</ulink></para>
</listitem>
<listitem>
<para>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)</para> </listitem>
</itemizedlist> </para>
<para><variablelist>
<varlistentry>
<term>Remarques importantes pour les systèmes libc5</term><listitem>
<para>(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.</para>
<para>Vous pouvez obtenir une version précompilée ici : </para>
<para><ulink
url="http://www.tu-harburg.de/~semk2104/soundtracker/threadedxlibs.tar.bz2">
http://www.tu-harburg.de/~semk2104/soundtracker/threadedxlibs.tar.bz2</ulink>
</para>
<para>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) :</para>
<para><screen>export LD_LIBRARY_PATH=/path/to/threadedxlibs/directory</screen>
</para> <para>sous csh/tcsh :</para>
<para><screen>setenv LD_LIBRARY_PATH
/path/to/threadedxlibs/directory</screen></para>
<para>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.</para>
</listitem> </varlistentry> <varlistentry>
<term>Compiler avec audiofile 0.1.6</term> <listitem>
<para>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 :</para>
<para>
<screen>error: wav.cc: h:21 parse error before
'&rcub;'</screen> </para>
<para>lorsqu'on essaie de compiler le support wave dans src/synthesizer. Pour
corriger ça, vous pouvez : <itemizedlist>
<listitem><para>soit aller à /usr/include/aupvlist.h et supprimer une des
deux accolades fermées ressemblant à :
<programlisting>
#ifdef __cplusplus } #endif </programlisting> qui se trouve ligne 59 sur mon
système.</para> </listitem> <listitem>
<para>ou mettre à jour libaudiofile vers une version plus récente.</para> </listitem>
</itemizedlist>

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.</para> </listitem>
</varlistentry> <varlistentry>
<term>Problèmes lors de l'exécution d'idl sur certains systèmes</term>
<listitem>
<para>Sur certains systèmes (comme dans les versions récentes de la
distribution Redhat 6), vous aurez un message d'erreur du genre :
<programlisting> /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
</programlisting>
Pour corriger cela, ajoutez /usr/local/lib dans le fichier /etc/ld.so.conf en
tant que root, puis lancez ldconfig.</para> </listitem>
</varlistentry>
<varlistentry>
<term>Compiler sans egcs</term>
<listitem>
<para>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).</para>
<para>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.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Compiler sans linux</term>
<listitem>
<para>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.</para>
<para>Cela a été fait uniquement pour linux jusqu'ici. En tout cas, certaines
personnes ont dit que aRts tournait sous FreeBSD.</para> </listitem>
</varlistentry> <varlistentry>
<term>Compiler sans KDE et Qt</term>
<listitem>
<para>Vous pouvez compiler aRts sans KDE et Qt. Utilisez</para>
<para><screen>configure --disable-kde</screen>
</para>
<para>Artsbuilder ne sera alors pas compilé (l'éditeur graphique de
structure du synthétiseur). Arts n'est pas vraiment sympa sans cet
éditeur.</para>
<para>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 <itemizedlist>
<listitem>
<para>Gtk, Gnome et OrbIt</para>
</listitem>
<listitem>
<para>Java et le support Java de mico</para>
</listitem>
<listitem>
<para>n'importe quelle autre interface</para>
</listitem>
</itemizedlist>
</para>
</listitem>
</varlistentry>
</variablelist>
</para>
</sect1>

<sect1 id="Compilation-et-installation">
<title>Compilation et installation</title>

<para>Si vous avez obtenu les sources sur le CVS, commencez par :
<itemizedlist>
<listitem>
<para><literal remap="tt">make -f Makefile.dist</literal></para>
</listitem>
</itemizedlist>
Pour démarrer réellement la compilation (ceci est vrai pour les utilisateurs
du CVS et pour les utilisateurs des fichiers sources standards), utilisez
<itemizedlist> <listitem>
<para><literal remap="tt">./configure</literal></para>
</listitem>
<listitem>
<para><literal remap="tt">make</literal></para>
</listitem>
<listitem>
<para><literal remap="tt">make install</literal></para>
</listitem>
</itemizedlist>
</para>
</sect1>

<sect1 id="A-propos-des-droits-administrateur">
<title>	À propos des droits administrateur</title>

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

<variablelist>
<varlistentry>
<term>Donnez au programme encapsulant (wrapper) "artswrapper" les droits
appropriés
</term>
<listitem>

<orderedlist>
<listitem>
<para>Ouvrez une fenêtre terminal X, devenez administrateur (tapez su et
entrez votre mot de passe administrateur).</para>
</listitem>
<listitem>
<para>
Donnez à artsserver.bin les droits :
<programlisting>   cd /usr/local/kde/bin
   chown root artswrapper
   chmod u+s artswrapper</programlisting>

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

<para>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.</para>

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

</listitem>
</varlistentry>
<varlistentry>
<term>Démarrer le serveur en tant qu'administrateur à chaque fois</term> <listitem>
<para>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).</para>
</listitem> </varlistentry>
<varlistentry>
<term>Ne pas utiliser les droits administrateurs.</term> <listitem>
<para>Ce n'est pas terrible, parce que le son subira des clics et des
arrêts lorsque vous utiliserez l'interface graphique.</para>
</listitem> </varlistentry>
</variablelist>
</para>
</sect1>

<sect1 id="Demarrage-de-artsbuilder">
<title>Démarrage de artsbuilder</title>

<para>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.</para>
<para>Et maintenant, vous devriez pouvoir jouer avec.</para> </sect1>
</chapter>

<chapter id="Concepts">
<title>Concepts</title>

<para>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.</para>
<para>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.</para>

<sect1 id="Modules-et-ports">
<title>Modules et ports</title>

<para>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.</para>
<para>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.</para> </sect1>

<sect1 id="Structures">
<title>Structures</title>
<para>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.</para>
<para>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).</para>
<para>Vous entendrez probablement un son, si vous avez tout fait comme il le
fallait.</para>
</sect1>

<sect1 id="Publication-et-instanciation-dynamique">
<title>Publication et instanciation dynamique</title>

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

<para>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".</para>

<para>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é.</para>

<para>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.</para>

<para>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.</para>

<para>Les points suivants traitent de ce problème.</para> </sect1>

<sect1 id="Bus">

<title>Bus</title>

<para>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.</para>

<para>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.</para>

<para>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.</para>

<para>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.</para>

<para>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.</para>

<para>(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.)</para> </sect1>

<sect1 id="Fermeture-des-structures">
<title>Fermeture des structures</title>

<para>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  &gt; 0.5 (lu :
1).</para>

<para>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.</para>

<para>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.</para>

<para>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).</para>
</sect1>

<sect1 id="Interfaces">
<title>Interfaces</title>

<para>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.</para>

<para>On dit qu'une structure fournit une interface si elle contient un module
d'interface.</para>

<para>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.</para>

<para>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.</para> </sect1>

<sect1 id="Synthese-midi">
<title>Synthèse contrôlée par midi (nouveau style ; Arts &gt;= 0.3.0)</title>

<para>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.</para>

<para>Pour créer et utiliser une telle structure, faites comme suit :
<itemizedlist>

<listitem><para>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".</para></listitem>

<listitem><para>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 !</para></listitem>

<listitem><para>Vous devrez publier votre structure sous un
nom.</para></listitem>

<listitem><para>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.</para></listitem>

<listitem><para>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.</para></listitem>
</itemizedlist>
</para>
</sect1>


<sect1 id="Reutiliser-les-structures">
<title>Réutiliser les structures comme de nouveaux modules</title>

<para>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.</para>

<para>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.</para>

<para>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
&lt;nom_de_structure&gt;.arts). Voir "Autochargement au démarrage".</para>

</sect1>

<sect1 id="Instruments-Arts0.3.2">
<title>Instruments (Arts &gt;= 0.3.2)</title>

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

<para>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).</para>

<para>Il y a plusieurs conditions à vérifier pour pouvoir le réutiliser.</para>

<para>
<itemizedlist>

<listitem><para>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).</para></listitem>

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

<listitem><para>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.</para></listitem>

<listitem><para>L'instrument doit être nommé instrument_nombienchoisi,
il est important que le nom commence par instrument_.
</para></listitem>
</itemizedlist>
</para>

<para>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 :</para>

<para>
<itemizedlist>
<listitem><para>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.</para></listitem>

<listitem><para>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).</para></listitem>

<listitem><para>La structure "control panel" doit s'appeler
instrument_nombienchoisi_GUI.</para></listitem>

<listitem><para>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.</para></listitem>

<listitem><para>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".</para></listitem>
</itemizedlist></para>

<para>Ç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.</para> </sect1>

<sect1 id="Autochargement-au-demarrage">
<title>Autochargement au démarrage</title>

<para>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).</para>

<para>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.</para>

<para>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.</para>

<para>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.</para>
</sect1>

<sect1 id="Mixeurs">
<title>Mixeurs</title>

<para>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.</para>
</sect1>

<sect1 id="Gestion-des-sessions">
<title>Gestion des sessions</title>

<para>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.</para>

<para>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.</para>

<para>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.</para>

<para>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).</para>

<para>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).</para>
</sect1>

<sect1 id="Traitement-audio-full-duplex">
<title>Traitement audio full duplex</title>

<para>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.</para>
<para>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.</para>

<para>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.</para>

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

<para>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).</para>

<para>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.</para>
</sect1>

<sect1 id="Instruments-mappes">
<title>Instruments mappés(drum maps, etc.)</title>

<para>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.</para>

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

<para>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.</para>

<para>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.</para>

<para>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 :</para>

<para><programlisting>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
}
</programlisting></para>

<para>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).</para>

<para>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).</para>

<para><programlisting>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
}</programlisting>
</para>

<para>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).</para>

</sect1>
</chapter>

<chapter id="TheMidiBusstandard">
<title>Le standard du bus midi</title>

<sect1 id="Qu-est-ce-que-midisend">
<title>Qu'est-ce que midisend ?</title>

<para>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).</para>

<para>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.</para>

<para>Il nécessite :
<itemizedlist>
<listitem>
<para>que le synthétiseur fonctionne</para>
</listitem>
<listitem>
<para>qu'il y ait une structure qui traite les événements midi dans le
synthétiseur (ça marche sans, mais vous n'entendrez rien).</para>
</listitem>
</itemizedlist>
</para>

<para>Il est aussi capable d'envoyer des données midi à partir d'autres
périphériques, lorsque vous utilisez <literal remap="tt">midisend
/dev/some_autre_périphérique</literal>.</para>

<para>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.</para>
</sect1>

<sect1 id="Utilisation-de-aRts-et-Brahms">
<title>Utilisation de aRts et Brahms</title>
<para>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).</para>

<para>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.</para>

<para>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.</para>

<para>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.</para>

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

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

<sect1 id="Lancement-rapide">
<title>Lancement rapide</title>

<para>Ceci fonctionne pour Brahms et Cantor (remplacez simplement Brahms par
Cantor si vous essayez Cantor).</para>

<para><itemizedlist>
<listitem>
<para>compilez et installez aRts</para>
</listitem>
<listitem>
<para>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
<ulink url="http://linux.twc.de/arts">http://linux.twc.de/arts</ulink>)</para>
</listitem>
<listitem><para>compilez-le, normalement il devrait détecter que vous avez
installé aRts et il devrait inclure le support du bus midi automatiquement.</para>
</listitem>
<listitem>
<para>installez-le</para>
</listitem>
<listitem>
<para>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).</para>
</listitem>
<listitem>
<para>démarrez artsbuilder</para>
</listitem>
<listitem>
<para>utilisez "File/Retrieve server" et choisissez des structures de mappage
midi utilisables, comme example_mixer_eqfx</para></listitem>
<listitem>
<para>lancez-le avec "File/Execute Structure"</para>
</listitem>
<listitem>
<para>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.</para></listitem>
<listitem><para>démarrez Brahms (ou cantor à partir des sous-répertoires
exemples de cantor)</para> </listitem> <listitem>
<para>composez (ou chargez un fichier)</para>
</listitem>
<listitem>
<para>réglez le port de sortie des pistes que vous voulez jouer avec aRts
vers les bus midi.</para></listitem>
<listitem>
<para>appuyez sur le bouton "play"</para>
</listitem>
</itemizedlist>
</para>

<para>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 <literal
remap="tt">midisend</literal> 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 ;)</para>

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

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

<sect1 id="Plus-de-details-internes">
<title>Plus de détails internes</title>

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

<orderedlist><listitem>
<para>Une interface graphique utilisée pour relier les modules entre
eux.</para></listitem>
<listitem><para>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.</para>
</listitem></orderedlist>

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.</para>

<para>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).</para>

<para>Voici ce que vous avez avec aRts :</para>

<para><mediaobject><imageobject><imagedata fileref="images/schema1.png" format="png"></imageobject></mediaobject></para>

<para>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) :</para>

<para><mediaobject><imageobject><imagedata fileref="images/schema2.png" format="png"></imageobject></mediaobject></para>

<para>Ainsi, voilà ce que je voudrais logiquement avoir :</para>

<para><mediaobject><imageobject><imagedata fileref="images/schema3.png" format="png"></imageobject></mediaobject></para>

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

<para><mediaobject><imageobject><imagedata fileref="images/schema4.png" format="png"></imageobject></mediaobject></para>

<para>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).</para>

<para>Voici les trucs liés à idl qui peuvent vous intéresser : </para>

<para>arts.idl : (qui n'est pas si intéressant dans le contexte de cette
discussion). midibus.idl :</para>
<para><programlisting>
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.</programlisting>
</para>
</sect1>

<sect1 id="Autres-considerations">
<title>Autres considérations</title>

<para>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.</para>

<para>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.</para>

<para>Nous travaillons là-dessus, et sur l'interface CORBA de aRts.Tenez-vous
informé.</para>
</sect1>
</chapter>

<chapter id="GUIElements">
<title>Élements de l'interface graphique</title>

<sect1 id="Le-but">
<title>Le but</title>

<para>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).</para>

<para>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.</para>

<para>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.</para>

<para>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.</para>

<para>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.</para>
</sect1>

<sect1 id="introduction-ce-que-vous-trouverez">
<title>Introduction : ce que vous trouverez ici</title>

<para>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.</para>

<para>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.</para>

<para>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.</para></sect1>

<sect1 id="Elements-graphiques-parents">
<title>Éléments graphiques parents</title>

<para>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.</para>

<para>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.</para>
</sect1>

<sect1 id="La-magie-du-GUIMIXER">
<title>La magie du GUI_Mixer</title>

<para>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.</para>

<para>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).</para>

<para>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 <emphasis
remap="bf">un</emphasis> 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).</para>

<para>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.</para>

<para>É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é.</para>

<para>Voir le manuel de référence des modules pour plus de détails.</para></sect1>
</chapter>

<chapter id="Tutorial">
<title>Tutoriel</title>

<sect1 id="Etape1">
<title>Étape 1</title>

<para>Démarrez artsbuilder.</para>

<para>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.</para>

<para>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.</para>

<para>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.</para> </sect1>

<sect1 id="Etape2">
<title>Étape 2</title>

<para>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.</para>

<para>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é.</para>

<para>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.</para>

<para>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.</para>
</sect1>

<sect1 id="Etape3">
<title>Étape 3</title>

<para>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.</para>

<para>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.</para>

<para>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).</para>

<para>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.</para>

<para>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.</para>

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

<sect1 id="Etape4">
<title>Étape 4</title>

<para>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</para>
<para><itemizedlist>
<listitem>
<para>La sortie du SIN à l'entrée de PSCALE</para>
</listitem>
<listitem>
<para>La sortie de PSCALE au PLAY gauche</para>
</listitem>
<listitem>
<para>La sortie de PSCALE au PLAY droit</para>
</listitem>
<listitem>
<para>Le "pos" de SEQUENCE au "pos" de PSCALE</para>
</listitem>
</itemizedlist>
</para>

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

<para>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.</para>

<para>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</para>
</sect1>

<sect1 id="Etape5">
<title>Étape 5: début d'échange de données ;)</title>

<para>Démarrez un autre artsbuilder.</para>

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

<itemizedlist><listitem>
<para>Mettez la valeur constante 8 à l'entrée "clie" (clients) du module
Synth_BUS_DOWNLINK (nous en aurons besoin plus tard).</para>
</listitem>
<listitem>
<para>Placez l'entrée bus de ce module à audio (c'est juste un nom,
appelez-le Fred si ça vous fait plaisir).</para>
</listitem>
<listitem>
<para>connectez la sortie left du module Synth_BUS_DOWNLINK à
l'entrée left du module Synth_PLAY</para>
</listitem>
<listitem>
<para>connectez la sortie right du module Synth_BUS_DOWNLINK à
l'entrée right du module Synth_PLAY</para>
</listitem>
</itemizedlist>
</para>

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

<para>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)</para>

<para>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.</para>

<para>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.</para></sect1>

<sect1 id="Etape6">
<title>Étape 6: échange de données pour les utilisateurs avancés.</title>

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

<para>Choisissez "File/Publish"</para>

<para>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à.</para>

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

<para>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.</para>

<para>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.</para> </sect1>

<sect1 id="Etape7">
<title>Étape 7: Synthèse contrôlée par midi</title>

<para>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.</para>

<para>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".</para>

<para>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).</para>

<para>Cela signifie que l'objet Synth_PSCALE doit lui aussi être
remplacé maintenant. Reliez un objet Synth_ENVELOPE_ADSR à la
place. Connectez
<itemizedlist><listitem>
<para>La sortie "pressed" du module MIDI_NOTE à l'entrée "active" du
module ADSR</para></listitem>
<listitem><para>La sortie "out" du module SIN à l'entrée "in" du module ADSR
</para></listitem>
<listitem><para>La sortie "out" du module ADSR à l'entrée "left" du module
UPLINK</para></listitem>
<listitem><para>La sortie "out" du module ADSR à l'entrée "right" du module
UPLINK</para></listitem></itemizedlist>

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

<para>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.</para>

<para>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.</para>

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

<para>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.</para>

<para>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).</para>

<para>Ouvrez un terminal et tapez <literal remap="tt">midisend</literal>.
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.</para></sect1>

<sect1 id="Faire-un-vrai-instrument">
<title>Faire un vrai instrument</title>

<para>...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...</para></sect1>

<sect1 id="Suggetions">
<title>Suggestions</title>

<para>Vous êtes maintenant capable de vous servir de arts. Voici quelques
astuces que vous pouvez tester pour améliorer vos structures.
<itemizedlist>
<listitem>
<para>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).</para>
</listitem>
<listitem>
<para>Essayez d'utiliser plusieurs oscillateurs. Le module Synth_XFADE
peut être utilisé pour mixer les deux signaux, et
Synth_ADD pour les additionner.</para>
</listitem>
<listitem>
<para>Essayez de ne pas donner exactement les mêmes fréquences à tous les
oscillateurs, ça donne des oscillations sympathiques (NdT effet de
chorus).</para>
</listitem>
<listitem>
<para>Essayez d'utiliser plusieurs enveloppes.</para>
</listitem>
<listitem>
<para>Essayez de synthétiser des instruments avec des sorties différentes à
gauche et à droite.</para>
</listitem>
<listitem>
<para>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.</para>
</listitem>
<listitem>
<para>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).</para></listitem>
<listitem>
<para>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).</para></listitem>
<listitem>
<para>...</para>
</listitem>
</itemizedlist>
</para>

<para>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 ;).</para>
</sect1>
</chapter>

<chapter id="A-propos-des-exemples">
<title>À propos des exemples</title>

<sect1 id="Conseils-d-ordre-general">
<title>Conseils d'ordre général</title>

<para>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_.</para>

<para>Tous les instruments synthétisés sont disponibles dans chaque
exemple.</para>

<para>L'instrument flexible_slide fournit sa propre interface
graphique.</para>

<para>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.</para>

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

<para>Vous pouvez les utiliser en conjonction avec midisend de la façon
suivante :</para>

<para><itemizedlist>
<listitem>
<para>démarrez artsbuilder</para>
</listitem>
<listitem>
<para>choisissez "File/Retrieve" from server</para> </listitem>
<listitem>
<para>choisissez soit example_instrument_fx soit
example_instrument_pure : example_instrument_fx
possède en plus un effet d'écho.</para>
</listitem> <listitem>
<para>allez à "File/Execute Module"</para>
</listitem>
<listitem>
<para>choisissez "add" et ajoutez un instrument sur un canal midi</para> </listitem>
<listitem>
<para>il s'exécute maintenant et va synthétiser les événements qui arrivent
sur le bus midi, alors on va en créer ;)</para>
</listitem> <listitem>
<para>démarrez midisend dans une fenêtre console
</para> </listitem>
<listitem>
<para>Vous devriez pouvoir jouer sur votre clavier maintenant</para> </listitem>
<listitem>
<para>vous pouvez changer d'instrument à la volée avec le mapper d'instrument</para>
</listitem> <listitem>
<para>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</para> </listitem>
</itemizedlist> </para>

<para>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.</para></sect1></chapter>

<chapter id="Possibilites-avancees-avec-les-utilitaires">
<title>Possibilités avancées avec les utilitaires</title>
<sect1 id="Scinder-le-clavier-avec-midisend">
<title>Scinder le clavier avec midisend</title>

<para>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.</para>

<para>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.</para>

<para>Avec cela vous pouvez par exemple scinder votre clavier.</para>

<para>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.</para>

<para>Glossaire :
<variablelist>
<varlistentry>
<term>Pitch</term>
<listitem>
<para>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</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Channel</term>
<listitem>
<para>spécifie l'instrument. Dans aRts, vous assignez un canal à un
instrument.</para> </listitem> </varlistentry>
</variablelist>
</para>

<para>Vous pouvez utiliser les commandes suivantes pour configurer midisend :</para>
<para><variablelist>
<varlistentry>
<term>PitchRange to Channel</term>
<listitem>
<para>Lorsqu'une hauteur arrive sur le canal &lt;Channel&gt;, et se situe
dans une plage donnée, le canal du message midi sera changé en &lt;ToChannel&gt;.</para>
<para>Syntaxe : PRC
&lt;Channel&gt;,&lt;FromPitch&gt;,&lt;ToPitch&gt;,&lt;ToChannel&gt;</para>
</listitem> </varlistentry> <varlistentry>
<term>PitchRange Difference addition</term>
<listitem>
<para>Lorsqu'une hauteur arrive sur le canal &lt;Channel&gt;, et se situe
dans une plage donnée, &lt;PitchDifference&gt; est ajouté à la hauteur.</para>
<para>Syntaxe : PRD
&lt;Channel&gt;,&lt;FromPitch&gt;,&lt;ToPitch&gt;,&lt;PitchDifference&gt;
</para> </listitem> </varlistentry> <varlistentry>
<term>Pitch To Channel</term>
<listitem>
<para>Lorsqu'une hauteur &lt;Pitch&gt; arrive sur le canal &lt;Channel&gt;, la
hauteur sera modifiée en &lt;ToChannel&gt;.</para>
<para>Syntaxe : PTC &lt;Channel&gt;,&lt;Pitch&gt;,&lt;ToChannel&gt;</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Pitch To Pitch</term>
<listitem>
<para>Lorsqu'une hauteur &lt;Pitch&gt; arrive sur le canal &lt;Channel&gt;, la
hauteur sera modifiée en &lt;ToPitch&gt;</para>
<para>Syntaxe : PTP &lt;Channel&gt;,&lt;Pitch&gt;,&lt;ToPitch&gt;</para>
</listitem>
</varlistentry>
</variablelist>
</para>

<para><emphasis remap="bf">Exemples : </emphasis>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 :</para>
<para><programlisting>PRC 0, 1, 59,  1
PRD 0, 1, 59, 24</programlisting>
</para>

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

<para><literal remap="code">PRD 0, 1, 59, -12</literal></para>
</sect1>

<sect1 id="Recuperation-d-echantillons">
<title>Récupération d'échantillons sur les CD AKAI avec akaiparse</title>

<para>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.</para>

<para>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.</para>

<para>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 <literal remap="code">dd if=/dev/cdrom
of=&lt;nom_de_votre_image&gt;</literal>

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

<para>Vous pouvez alors faire les choses suivantes avec akaiparse :</para>
<para><variablelist>
<varlistentry>
<term>Lister le contenu d'une partition (ou d'un répertoire spécifique)</term>
<listitem>
<para><itemizedlist>
<listitem>
<para>akaiparse &lt;fichier&gt; &lt;partition&gt; ls</para>
</listitem>
<listitem>
<para>akaiparse &lt;fichier&gt; &lt;partition&gt; ls &lt;répertoire&gt;</para>
</listitem>
</itemizedlist>
</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Extraire les échantillons d'une partition (ou d'un répertoire
spécifique)</term> <listitem> <para><itemizedlist>
<listitem>
<para>akaiparse &lt;fichier&gt; &lt;partition&gt; get</para>
</listitem>
<listitem>
<para>akaiparse &lt;fichier&gt; &lt;partition&gt; get
&lt;répertoire&gt;</para> </listitem>
</itemizedlist>
</para>
</listitem>
</varlistentry>
</variablelist>

&lt;fichier&gt; 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).</para>

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

<sect1 id="achanger4">

<title>Construction de fichiers de mappage AKAI avec akaikggen</title>

<para>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.</para>

<para>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.</para>

<para>Pour cela, ouvrez une fenêtre terminal et entrez quelque chose
comme</para>

<para><screen>akaikggen leftsample = BOE_LD_*-L
rightsample = BOE_LD_*-R</screen></para>

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

<para><screen>akaikggen leftsample = BOE_LD_*-L rightsample =
BOE_LD_*-R &gt; boe_ld.arts-map</screen></para>

<para>Une solution simple consiste à placer la ligne
<literal remap="code">structure=play_akai_stereo</literal>
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.</para>
</sect1>
<sect1 id="Configuration-avancee-du-serveur">
<title>Configuration avancée du serveur avec artsshell</title>

<para>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.</para>
<para>Vous pouvez régler quelques options de configuration utiles avec
artsshell.</para>

<para><variablelist><varlistentry>
<term>Obtention de l'information de status</term>
<listitem>
<para>Entrez</para>
<para><screen>artsshell -i</screen>
</para>
<para>pour obtenir des informations de status utiles à propos de
l'utilisation du cache, le nombre de modules actifs, etc.</para>
<para><screen>artsshell -s</screen></para>
<para>vous donnera des informations sur les réglages du temps réel de
aRts.</para></listitem></varlistentry>
<varlistentry>
<term>Taille du cache</term>
<listitem>
<para>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</para>

<para><screen>artsshell -C &lt;taille du cache en Ko&gt;</screen>
</para></listitem></varlistentry>

<varlistentry>

<term>Paramètres du temps réel (temps de réponse)</term><listitem>

<para>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.</para>

<para>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 <ulink
url="http://www.4front-tech.com/pguide/audio2.html">http://www.4front-tech.com
/pguide/audio2.html</ulink></para>

<para>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.</para>
<para>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</para>

<para><screen>artsshell -F &lt;fragments&gt;:&lt;taille&gt;
-S &lt;échantillons_du_cycle_d_ordonnancement&gt;</screen></para>

<para>pour configurer ces paramètres.</para>
</listitem></varlistentry>
<varlistentry>
<term>Information de déboguage</term>

<listitem>
<para>Si vous développez aRts ou si vous cherchez un bogue, vous pouvez
utiliser</para>

<para><screen>artsshell -D 1</screen></para>

<para>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").</para></listitem></varlistentry></variablelist></para></sect1>

<sect1 id="Fonctionnalites-du-serveur">
<title>Fonctionnalités du serveur audio avec artscat</title>

<para>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).</para>

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

<para><variablelist>
<varlistentry>
<term>Jouer les données</term>
<listitem>
<para>Utilisez</para>
<para><screen>artscat -t &lt;type&gt; -d &lt;description&gt; -p</screen>
</para>
<para>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.</para></listitem></varlistentry>

<varlistentry>
<term>Enregistrer les données</term>
<listitem><para>Utilisez</para>

<para><screen>artscat -t &lt;type&gt; -d &lt;description&gt; -r</screen></para>

<para>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.</para>

<para>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.</para>
</listitem></varlistentry></variablelist></para>

<para>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).</para></sect1></chapter>

<chapter id="manuel-de-reference-des-modules">
<title>Manuel de référence des modules</title>

<sect1 id="Synth-NIL">
<title>Synth_NIL</title>

<para><mediaobject><imageobject><imagedata fileref="images/Synth_NIL.png" format="png"></imageobject></mediaobject></para>

<para>Ne fait rien. Il est juste utile à des fins de test.</para></sect1>

<sect1 id="Synth-XFADE">
<title>Synth_XFADE</title>

<para><mediaobject><imageobject><imagedata fileref="images/Synth_XFADE.png" format="png"></imageobject></mediaobject></para>

<para>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.</para>
<para>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.</para></sect1>

<sect1 id="Synth-AUTOPANNER">
<title>Synth_AUTOPANNER</title>

<para>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.</para>
<para>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.</para></sect1>

<sect1 id="Synth-MUL">
<title>Synth_MUL</title>

<para><mediaobject><imageobject><imagedata fileref="images/Synth_MUL.png" format="png"></imageobject></mediaobject></para>

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

<sect1 id="Synth-ADD">
<title>Synth_ADD</title>

<para><mediaobject><imageobject><imagedata fileref="images/Synth_ADD.png" format="png"></imageobject></mediaobject></para>

<para>Ajoute deux signaux.</para>
</sect1>

<sect1 id="Synth-DELAY">
<title>Synth_DELAY</title>

<para><mediaobject><imageobject><imagedata fileref="images/Synth_DELAY.png" format="png"></imageobject></mediaobject></para>

<para>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.</para>

<para>Ce genre de retard <emphasis>ne devrait pas être utilisé</emphasis>
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.</para>

<para>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.</para>

<para>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.</para></sect1>

<sect1 id="Synth-CDELAY">
<title>Synth_CDELAY</title>

<para><mediaobject><imageobject><imagedata fileref="images/Synth_CDELAY.png" format="png"></imageobject></mediaobject></para>

<para>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é.</para>

<para>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).</para></sect1>

<sect1 id="Synth-FX-CFLANGER">
<title>Synth_FX_CFLANGER</title>

<para>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.</para>

<para>Il a les ports suivants :

<variablelist><varlistentry>
<term>invalue</term>
<listitem>
<para>Le signal que vous voulez traiter.</para></listitem>
</varlistentry>
<varlistentry>
<term>lfo</term>
<listitem>
<para>De préférence une onde sinusoïdale qui module le retard dans
le flanger (-1 .. 1).</para></listitem>
</varlistentry>
<varlistentry>
<term>mintime</term>
<listitem>
<para>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 &lt; 1000 ms.</para></listitem></varlistentry>

<varlistentry>
<term>maxtime</term>
<listitem>
<para>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 &lt; 1000 ms.</para></listitem></varlistentry>

<varlistentry>
<term>outvalue</term>
<listitem>
<para>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é.</para></listitem>
</varlistentry>

</variablelist>

Conseil : vous pouvez l'utilisez comme base pour un effet de chorus.</para></sect1>

<sect1 id="Synth-FREQUENCY">
<title>Synth_FREQUENCY</title>

<para><mediaobject><imageobject><imagedata fileref="images/Synth_FREQUENCY.png" format="png"></imageobject></mediaobject></para>

<para>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é.</para></sect1>

<sect1 id="Synth-FMSOURCE">
<title>Synth_FM_SOURCE</title>

<para><mediaobject><imageobject><imagedata fileref="images/Synth_FM_SOURCE.png" format="png"></imageobject></mediaobject></para>

<para>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.</para>

<para>Ça fonctionnne bien en combinaison avec des oscillateurs
Synth_WAVE_SIN.</para></sect1>

<sect1 id="Synth-WAVESIN">
<title>Synth_WAVE_SIN</title>

<para><mediaobject><imageobject><imagedata fileref="images/Synth_WAVE_SIN.png" format="png"></imageobject></mediaobject></para>

<para>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</para></sect1>

<sect1 id="Synth-WAVETRI">
<title>Synth_WAVE_TRI</title>

<para><mediaobject><imageobject><imagedata fileref="images/Synth_WAVE_TRI.png" format="png"></imageobject></mediaobject></para>

<para>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.</para></sect1>

<sect1 id="Synth-WAVESQUARE">
<title>Synth_WAVE_SQUARE</title>

<para><mediaobject><imageobject><imagedata fileref="images/Synth_WAVE_SQUARE.png" format="png"></imageobject></mediaobject></para>

<para>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.</para></sect1>

<sect1 id="Synth-PLAY">
<title>Synth_PLAY</title>

<para><mediaobject><imageobject><imagedata fileref="images/Synth_PLAY.png" format="png"></imageobject></mediaobject></para>

<para>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 <emphasis>normalisée</emphasis> 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.</para>

<para>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.</para>

<para>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.</para></sect1>

<sect1 id="Synth-FILEPLAY">
<title>Synth_FILEPLAY</title>

<para><mediaobject><imageobject><imagedata fileref="images/Synth_FILEPLAY.png" format="png"></imageobject></mediaobject></para>

<para>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 : </para>

<para>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.</para>

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

<sect1 id="Synth-DEBUG">
<title>Synth_DEBUG</title>

<para><mediaobject><imageobject><imagedata fileref="images/Synth_DEBUG.png" format="png"></imageobject></mediaobject></para>

<para>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.</para></sect1>

<sect1 id="Synth-PLAYWAV">
<title>Synth_PLAY_WAV</title>

<para><mediaobject><imageobject><imagedata fileref="images/Synth_PLAY_WAV.png" format="png"></imageobject></mediaobject></para>

<para>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).</para></sect1>

<sect1 id="Synth-PLAYAKAI">
<title>Synth_PLAY_AKAI</title>

<para><mediaobject><imageobject><imagedata fileref="images/Synth_PLAY_AKAI.png" format="png"></imageobject></mediaobject></para>

<para>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).</para>

<para>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.</para></sect1>

<sect1 id="Synth-PLAY-AKAIS">
<title>Synth_PLAY_AKAIS</title>

<para><mediaobject><imageobject><imagedata fileref="images/Synth_PLAY_AKAIS.png" format="png"></imageobject></mediaobject></para>

<para>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.</para></sect1>

<sect1 id="Synth-BUS-UPLINK">
<title>Synth_BUS_UPLINK</title>

<para><mediaobject><imageobject><imagedata fileref="images/Synth_BUS_UPLINK.png" format="png"></imageobject></mediaobject></para>

<para>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.</para></sect1>

<sect1 id="Synth-BUS-DOWNLINK">
<title>Synth_BUS_DOWNLINK</title>

<para><mediaobject><imageobject><imagedata fileref="images/Synth_BUS_DOWNLINK.png" format="png"></imageobject></mediaobject></para>

<para>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.</para></sect1>

<sect1 id="Synth-SHELVE-CUTOFF">
<title>Synth_SHELVE_CUTOFF</title>

<para><mediaobject><imageobject><imagedata fileref="images/Synth_SHELVE_CUTOFF.png" format="png"></imageobject></mediaobject></para>

<para>Filtre toutes les fréquences supérieures à la fréquence de
coupure.</para></sect1>

<sect1 id="Synth-MOOG-VCF">
<title>Synth_MOOG_VCF</title>

<para>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).</para></sect1>

<sect1 id="Synth-RC">
<title>Synth_RC</title>

<para><mediaobject><imageobject><imagedata fileref="images/Synth_RC.png" format="png"></imageobject></mediaobject></para>

<para>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.</para>
<para>Essayez quelque chose comme b=5, f=5 ou b=10, f=10 ou b=15,
f=15.</para></sect1>

<sect1 id="Synth-STD-EQUALIZER">
<title>Synth_STD_EQUALIZER</title>

<para><mediaobject><imageobject><imagedata fileref="images/Synth_STD_EQUALIZER.png" format="png"></imageobject></mediaobject></para>

<para>Un égaliseur paramétrique sympathique. Ses paramètres sont</para>
<para><variablelist>
<varlistentry>
<term>invalue, outvalue</term>
<listitem>
<para>Signal filtré par l'égaliseur.</para> </listitem>
</varlistentry>
<varlistentry>
<term>low</term>
<listitem>
<para>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.</para></listitem>
</varlistentry> <varlistentry>
<term>mid</term>
<listitem>
<para>Comment sont modifiées les fréquences médium par l'égaliseur en dB
(voir plus haut).</para></listitem></varlistentry>
<varlistentry>
<term>high</term>
<listitem>
<para>Comment sont modifiées les fréquences aiguës par l'égaliseur en dB
(voir plus haut).</para> </listitem>
</varlistentry>
<varlistentry>
<term>frequency</term>
<listitem>
<para>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.</para></listitem></varlistentry>
<varlistentry>
<term>q</term>
<listitem>
<para>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.</para>

</listitem>
</varlistentry>
</variablelist>
</para>
</sect1>

<sect1 id="Synth-SEQUENCE">
<title>Synth_SEQUENCE</title>

<para><mediaobject><imageobject><imagedata fileref="images/Synth_SEQUENCE.png" format="png"></imageobject></mediaobject></para>

<para>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 <literal
remap="tt">A-3;C-4;E-4;C-4;</literal>. 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).</para>

<para>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
<literal remap="tt">A-3:2;C-4:0.5;D-4:0.5;E-4;</literal>. Comme vous pouvez le
voir, les séquenceurs midi sont beaucoup plus confortables ;)</para>

<para>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).</para></sect1>

<sect1 id="Synth-PSCALE">
<title>Synth_PSCALE</title>

<para><mediaobject><imageobject><imagedata fileref="images/Synth_PSCALE.png" format="png"></imageobject></mediaobject></para>

<para>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".</para>

<para>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.</para></sect1>

<sect1 id="Synth-ENVELOPE-ADSR">
<title>Synth_ENVELOPE_ADSR</title>

<para><mediaobject><imageobject><imagedata fileref="images/Synth_ENVELOPE_ADSR.png" format="png"></imageobject></mediaobject></para>

<para>C'est une enveloppe ADSR classique. Vous devez spécifier :
<variablelist> <varlistentry>
<term>active</term>
<listitem>
<para>si la note est pressée par l'utilisateur</para></listitem>
</varlistentry>
<varlistentry>
<term>invalue</term>
<listitem>
<para>signal d'entrée</para>
</listitem>
</varlistentry>
<varlistentry>
<term>attack</term>
<listitem>
<para>durée entre le moment où l'utilisateur presse une note et celui où le
signal atteind son amplitude maximale (secondes)</para></listitem></varlistentry>
<varlistentry>
<term>decay</term>
<listitem>
<para>durée entre le moment où le signal atteind son amplitude maximale et
où le signal revient à un niveau constant (en secondes)</para></listitem>
</varlistentry> <varlistentry>
<term>sustain</term>
<listitem>
<para>niveau constant auquel le signal est maintenu après, jusqu'à ce que
l'utilisateur relâche la touche.</para></listitem>
</varlistentry>
<varlistentry>
<term>release</term>
<listitem>
<para>durée entre le moment où l'utilisateur relâche la note et celui où le
signal atteind une valeur nulle (en secondes)</para></listitem></varlistentry>
</variablelist>
</para>

<para>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.</para></sect1>

<sect1 id="Synth-STRUCT-KILL">
<title>Synth_STRUCT_KILL</title>

<para><mediaobject><imageobject><imagedata fileref="images/Synth_STRUCT_KILL.png" format="png"></imageobject></mediaobject></para>

<para>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.</para></sect1>

<sect1 id="Synth-MIDI-ROUTER">
<title>Synth_MIDI_ROUTER</title>

<para><mediaobject><imageobject><imagedata fileref="images/Synth_MIDI_ROUTER.png" format="png"></imageobject></mediaobject></para>

<para>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.</para>

<para>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.</para>

<para>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-&gt;instruments
pour plus de détails.</para></sect1>

<sect1 id="Synth-MIDI-DEBUG">
<title>Synth_MIDI_DEBUG</title>
<para><mediaobject><imageobject><imagedata fileref="images/Synth_MIDI_DEBUG.png" format="png"></imageobject></mediaobject></para>

<para>Vous pouvez l'utiliser pour déboguer l'arrivée des événements midi dans
aRts.</para>
<para>Lorsqu'un MIDI_DEBUG fonctionne, artsserver affichera une
ligne comme

<screen>201 100753.837585 on 0 42 127</screen>
<screen>202 101323.128355 off 0 42</screen>

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.</para></sect1>

<sect1 id="Synth-ATAN-SATURATE">
<title>Synth_ATAN_SATURATE</title>

<para><mediaobject><imageobject><imagedata fileref="images/Synth_ATAN_SATURATE.png" format="png"></imageobject></mediaobject></para>

<para>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)</para>
</sect1>

<sect1 id="Interfaces-MIDI-NOTE">
<title>Interface_MIDI_NOTE</title>

<para><mediaobject><imageobject><imagedata fileref="images/Interface_MIDI_NOTE.png" format="png"></imageobject></mediaobject></para>

<para>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.</para>
</sect1>

<sect1 id="modules-de-parametres-internes">
<title>Modules de paramètres internes Synth_PARAM_&lt;quelque
chose&gt;</title>

<para>N'utilisez pas <emphasis remap="bf">Synth_PARAM_GET, Synth_PARAM_SET,
Synth_PARAM_SGET et Synth_PARAM_SSET</emphasis> (sauf pour tester ou si
vous avez lu le fichier source). Ils disparaîtront dans les prochaines
versions de aRts.</para></sect1>

<sect1 id="support-du-serveur-audio-interne">
<title>Support du serveur audio interne</title>

<para>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.</para>
</sect1></chapter>

<chapter id="VisualModulesReference">
<title>Manuel de référence des modules d'interface</title>

<sect1 id="GUI-PANEL">
<title>Gui_PANEL</title>

<para><mediaobject><imageobject><imagedata fileref="images/Gui_PANEL.png" format="png"></imageobject></mediaobject></para>

<para>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).</para>

<para>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.</para>
</sect1>

<sect1 id="Gui-SUB-PANEL">
<title>Gui_SUB_PANEL</title>

<para><mediaobject><imageobject><imagedata fileref="images/Gui_SUBPANEL.png" format="png"></imageobject></mediaobject></para>

<para>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.</para>
</sect1>

<sect1 id="Gui-POTI">
<title>Gui_POTI</title>

<para><mediaobject><imageobject><imagedata fileref="images/Gui_POTI.png" format="png"></imageobject></mediaobject></para>

<para>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.</para> </sect1>

<sect1 id="Gui-SLIDER">
<title>Gui_SLIDER</title>

<para><mediaobject><imageobject><imagedata fileref="images/Gui_SLIDER.png" format="png"></imageobject></mediaobject></para>

<para>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.</para>
</sect1>

<sect1 id="Gui-WINDOW">
<title>Gui_WINDOW</title>

<para><mediaobject><imageobject><imagedata fileref="images/Gui_WINDOW.png" format="png"></imageobject></mediaobject></para>

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

<sect1 id="Gui-LABEL">
<title>Gui_LABEL</title>

<para><mediaobject><imageobject><imagedata fileref="images/Gui_LABEL.png" format="png"></imageobject></mediaobject></para>

<para>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.</para></sect1>

<sect1 id="Gui-INSTRUMENT-MAPPER">
<title>Gui_INSTRUMENT_MAPPER</title>

<para><mediaobject><imageobject><imagedata fileref="images/Gui_INSTRUMENT_MAPPER.png" format="png"></imageobject></mediaobject></para>

<para>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.</para>
</sect1>

<sect1 id="Gui-AUDIO-MANAGER">
<title>Gui_AUDIO_MANAGER</title>

<para><mediaobject><imageobject><imagedata fileref="images/Gui_AUDIO_MANAGER.png" format="png"></imageobject></mediaobject></para>

<para>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.</para>

<para>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.</para>
</sect1>

<sect1 id="Gui-MIXER">
<title>Gui_MIXER</title>

<para><mediaobject><imageobject><imagedata fileref="images/Gui_MIXER.png" format="png"></imageobject></mediaobject></para>

<para>Crée un mixeur. Vous devez fournir les paramètres suivants :</para>
<para><variablelist>
<varlistentry>
<term>parent</term>
<listitem>
<para>où le mélangeur doit apparaître. Vous devrez probablement lui
donner une fenêtre.</para></listitem></varlistentry>
<varlistentry>
<term>channels</term>
<listitem>
<para>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.</para></listitem></varlistentry>
<varlistentry>
<term>structure</term>
<listitem>
<para>à quoi doit un canal doit ressembler. Voir plus bas.</para>
</listitem></varlistentry>
<varlistentry>
<term>name</term>
<listitem>
<para>nom du mixeur. Les canaux individuels s'appeleront  &lt;nom&gt;01,
&lt;nom&gt;02, &lt;nom&gt;03,...</para></listitem>
</varlistentry>
<varlistentry>
<term>output</term>
<listitem>
<para>bus de sortie utilisé.</para>
</listitem>
</varlistentry>
</variablelist>
</para>

<para>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 :</para>

<para><variablelist>
<varlistentry>
<term>input (IN string property)</term>
<listitem>
<para>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.</para> </listitem> </varlistentry> <varlistentry>
<term>parent (IN audio signal)</term>
<listitem>
<para>Spécification d'un parent dans lequel le panneau de contrôle sera
affiché. Placez ici un élément graphique Gui_SUB_PANEL.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>output (IN string property)</term>
<listitem>
<para>Bus vers lequel les canaux individuels envoient les données. Vous devez
vous-même envoyer les données avec un Synth_BUS_UPLINK.</para>
</listitem>
</varlistentry>
</variablelist>
</para>
</sect1>
</chapter>

<chapter
id="utilisation-de-arts-comme-serveur">
<title>Utilisation de aRts comme "serveur audio générique"</title>
<sect1 id="l-idee-qu-est-ce-qu-un-serveur">
<title>L'idée - qu'est-ce qu'un "serveur audio générique ?"</title>

<para>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.</para>

<para>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.</para>

<para>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.</para>
</sect1>

<sect1 id="esd-audioserver-et-autres">
<title>ESD/KAudioServer et autres</title>

<para>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 ?</para>

<para>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.</para>

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

<para>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 <emphasis
remap="bf">ensemble</emphasis>. Ils n'ont pas de concepts de gestion,
d'interaction, de synchronisation, de midi, de filtres (ou seulement de
petites parties sont implantées),...</para></sect1>


<sect1 id="l-alternative-utiliser-arts-comme-serveur">
<title>L'alternative : utiliser aRts comme "serveur audio générique"</title>

<para>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.</para>

<para>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 :
<itemizedlist>
<listitem> <para>temps réel</para>
</listitem>
<listitem>
<para>graphiques de flux</para>
</listitem>
<listitem>
<para>parallélisme</para>
</listitem>
<listitem>
<para>effets</para>
</listitem>
<listitem>
<para>communication avec une interface graphique</para>
</listitem>
<listitem>
<para>interface pour plusieurs clients</para>
</listitem>
<listitem>
<para>technologie midi</para>
</listitem>
</itemizedlist>
</para>

<para>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.</para>

<para>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.</para>
</sect1>

<sect1 id="artscat-les-premiers-pas">
<title>artscat : les premiers pas</title>

<para>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".</para>

<para>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.</para>

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

<para>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.</para>

<para>Les nouvelles versions de aRts (&gt;= 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 :</para>

<para><screen>artscat -d &lt;description&gt; -t &lt;type&gt;</screen></para>

<para>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...</para>

<para>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</para>

<para><screen>artsmp3 &lt;nom du fichier&gt;</screen>
</para>

<para>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.</para>

<para>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.</para>

<para>L'enregistrement est maintenant supporté aussi, comme dans
aRts-0.3.4.</para></sect1>

<sect1
id="etape-suivante-artsrec-artsmon">
<title>Étape suivante : artsrec, artsmon, échantillons, api client,
compatibilité</title>

<para>Comme artscat est écrit, les étapes suivantes seraient :
<variablelist>
<varlistentry>
<term>enregistrement (implanté maintenant)</term><listitem>
<para>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.
</para>
</listitem>
</varlistentry>
<varlistentry>
<term>monitoring (implanté maintenant)</term>
<listitem>
<para>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.
</para>
</listitem>
</varlistentry>
<varlistentry>
<term>échantillons</term>
<listitem>
<para>À 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.
</para>
</listitem>
</varlistentry>
<varlistentry>
<term>api client et compatibilité</term>
<listitem>

<para>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.</para>

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

<para>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.</para></sect1>
</chapter>

<chapter id="Developpement">
<title>Développement</title>

<sect1 id="la-tasklist-officielle-de-arts">
<title>Liste des tâches officielle de aRts</title>

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

<para>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.</para>

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

<para>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...</para>

<sect2>
<title>Tâches qui ne demandent pas de connaissances en programmation</title>
<para><variablelist>
<varlistentry>
<term>Peut être plus de documentation d'ordre générale sur la synthèse
</term><listitem>
<para>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.</para>

<para>Juste pour en citer quelques uns, je pense que beaucoup de personnes qui
veulent apprendre à utiliser aRts ont besoin d'introductions sur<itemizedlist>
<listitem>
<para>Qu'est-ce que la modulation de fréquence ?</para></listitem>
<listitem>
<para>Qu'est-ce que la modulation en anneau ?</para>
</listitem>
<listitem>
<para>Comment fonctionnent les oscillateurs ?</para>
</listitem>
<listitem>
<para>Que font ces filtres ?</para>
</listitem>
<listitem>
<para>Comment créer un vocoder ?</para>
</listitem>
<listitem>
<para>Comment créer un son analogique qui sonne bien ?</para></listitem>
<listitem>
<para>Comment fonctionnent les vieux synthétiseurs tels que les 303, 909, mini
moog, ... ?</para></listitem><listitem>
<para>Comment faire tout ça avec aRts ?</para>
</listitem>
</itemizedlist>
</para>
<para>Ce serait bien si tout ça était au format sgml ou html ou n'importe quel
format lisible par tout le monde.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Exemples de aRts</term>
<listitem>
<para>Même choses que pour la documentation. Les gens doivent
voir que ce programme est vraiment puissant !</para>
</listitem> </varlistentry>
<varlistentry>
<term>Morceaux de démonstration</term>
<listitem>
<para>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.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Maintenance des structures (important !)</term>
<listitem>
<para>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.</para>

<para>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.</para>
</listitem> </varlistentry>
<varlistentry>
<term>Normalisation des modules</term>
<listitem>
<para>C'est un gros travail, mais certainement intéressant et en tout cas
un vrai challenge.</para>

<para>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.</para>

<para>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.</para>

<para>Ç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.</para>

<para>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 =&gt;
Synthesis/Busses/Uplink ou Synth_SHELVE_CUTOFF =&gt; 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).</para>

<para>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.</para> </listitem></varlistentry></variablelist>
</para>
</sect2>

<sect2>
<title>Tâches qui ne nécessitent pas de connaissances particulières en
programmation/écriture de scripts.</title><para><variablelist>
<varlistentry>
<term>modules externes (plugins)</term>
<listitem>
<para>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.</para>

<para>En particulier pour les synthétiseurs, on ne peut pas se permettre
d'avoir des pertes de performances lors de l'ordonancement ;)</para>
</listitem>
</varlistentry>
<varlistentry>
<term>bus midi : généralités</term>
<listitem>
<para>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.</para>

<para>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.)</para>

<para>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 ;)</para>
</listitem> </varlistentry>

<varlistentry> <term>bus midi : améliorations</term>
<listitem>
<para>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 :</para>

<para><itemizedlist>
<listitem>
<para>Le programme client demande au serveur d'ouvrir un canal</para></listitem>
<listitem>
<para>Le programme client envoie les événements pour les dix premières
secondes (avec des messages de synchronisation ou "time stamp")
</para></listitem> <listitem>
<para>Le programme client dit au serveur de démarrer</para></listitem>
<listitem>
<para>Le serveur notifie au programme client lorsqu'il a besoin de plus
d'événements</para>
</listitem> </itemizedlist>

ou
<itemizedlist>
<listitem>
<para>Le programme client décale la position dans le morceau</para></listitem>
<listitem>
<para>Le programme client envoie plus d'événements lorsque cela est
nécessaire.</para> </listitem>
</itemizedlist>
</para>

<para>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.</para>

<para>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.</para> </listitem>

</varlistentry>
<varlistentry>
<term>bus midi : pas de bus midi</term>
<listitem>
<para>Il y aura peut-être quelque chose d'autre... voir la section bus
midi/autres considérations.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>éditeur graphique</term>
<listitem>
<para>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.</para>

<para>Bref, il y a des choses qui fonctionnent, mais bien sûr beaucoup de
choses à améliorer.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>amélioration des performances</term>
<listitem>
<para>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</para>

<para>PS : le support multiprocesseur (SMP) serait une bonne
chose.</para></listitem></varlistentry><varlistentry>

<term>Écriture des modules</term>
<listitem>
<para>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.</para>

<para>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. ;)</para>
</listitem>
</varlistentry>
<varlistentry>
<term>lire des CD d'échantillons</term>
<listitem>
<para>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.</para>

<para>Résolu en grande partie.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>système de flux : passage d'événements</term>
<listitem>
<para>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.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>serveur audio</term>
<listitem>
<para>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.</para>

<para>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.</para> </listitem></varlistentry>
<varlistentry>
<term>Construction des structures de haut niveau</term><listitem>

<para>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).</para>
<para>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...).</para>

<para>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 :<itemizedlist><listitem>

<para>Démarrer le séquenceur</para> </listitem>
<listitem>
<para>Dire hmmm, je veux une table de mixage</para>
</listitem>
<listitem>
<para>En sélectionner une dans la liste</para>
</listitem>
<listitem>
<para>Avoir des boutons pour ajouter et enlever des canaux</para></listitem>
<listitem>
<para>Régler le nombre de canaux à 4</para>
</listitem>
<listitem>
<para>Charger des effets (délai, réverb, chorus et aucun)</para></listitem>
<listitem>
<para>Charger des instruments (piano, kit de batterie, cordes)</para> </listitem>
<listitem>
<para>Assigner les instruments aux canaux</para> </listitem>
<listitem>
<para>Utiliser la table de mixage pour calibrer les canaux</para> </listitem>
<listitem>
<para>Utiliser les panneaux d'effets pour les configurer</para> </listitem>
<listitem>
<para>Commencer à composer</para>
</listitem>
</itemizedlist>
</para>
<para>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</para>

<para>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.</para>

<para>Pensez-y.</para></listitem></varlistentry>
<varlistentry>

<term>architecture d'économie du processeur</term><listitem>

<para>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.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>implantation commune des serveurs</term>
<listitem>
<para>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
</para></listitem></varlistentry> <varlistentry>

<term>nouvelle architecture de transfert</term> <listitem>
<para>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.</para>

<para>Utiliser la mémoire partagée ou TCP serait probablement une bonne idée.
</para></listitem></varlistentry>
<varlistentry>

<term>Petites tâches (ou comment occuper sa journée)</term>
<listitem> <para><itemizedlist> <listitem>
<para>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.</para></listitem><listitem>

<para>Synth_WAVE_PULSE devrait être une onde carrée avec des temps de
montée/descente configurables. Faites des exemples.</para></listitem>
<listitem>
<para>Utiliser une structure appelée "foo" dans une structure "foo", et
exécuter le résultat donne un plantage.</para>
</listitem>
<listitem>
<para>Considérer l'écriture d'un module qui lit directement /dev/midi (pas par
midisend)=&gt; plus rapide.</para> </listitem>
<listitem>
<para>Transposition de la hauteur des fichiers d'échantillons (même
implantation que dans les modules AKAI, peut être beaucoup de code
commun à convert.cc).</para></listitem>
<listitem>
<para>Refaire la structure des répertoires (si vous voulez le faire,
demandez d'abord). Les modules devraient être séparés.</para>
</listitem> <listitem>
<para>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.</para> </listitem><listitem>
<para>Essayez d'intégrer le support des polices de partition de façon
intelligente - le code est par exemple disponible dans timidity.
</para></listitem> <listitem>

<para>Ajouter le support ALSA natif.</para>
</listitem>
<listitem>
<para>Implanter le chargement progressif des échantillons, ce qui
devrait conduire à de meilleures performances sur le premier
échantillon joué.</para></listitem>
<listitem>
<para>Éliminer Interface_MIDI_NOTE et le remplacer par des ports standards
(éventuellement compliqués).</para></listitem>
<listitem>
<para>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é).</para>
</listitem><listitem>
<para>Chaque module devrait avoir son propre fichier (cette idée est proche du
nettoyage de la structure du répertoire)</para></listitem>
<listitem>
<para>Les modules devraient être des librairies partagées.</para></listitem>
<listitem>
<para>Éviter d'appeler kvt s'il n'est pas présent (appeler autre chose
comme xterm à la place).</para></listitem>
<listitem>
<para>Enlever chaque "Calculate" et le remplacer par "CalculateBlock" -
après cela, enlever complètement "Calculate" de SynthModule et
mettre "CalculateBlock".</para></listitem>
<listitem>
<para>Introduction de kdoc</para>
</listitem>
<listitem>
<para>Les boutons d'aide devraient faire quelque chose (le mieux serait
d'afficher une page d'aide, en fonction du contexte).</para>
</listitem> </itemizedlist>
</para>
</listitem>
</varlistentry>
</variablelist>
</para>
</sect2>
</sect1>

<sect1 id="style-de-programmation">
<title>Style de programmation</title>

<para>Ces styles de programmation arrivent tard, je sais ;), j'ai
commencé sans eux. De toute façon, à l'avenir, essayez de vous y
tenir.<variablelist>
<varlistentry>
<term>Nom des fonctions membres</term>
<listitem>
<para>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</para>
<para>Voici un exemple
<programlisting> createStructureDesc()
updateWidget();    start(); </programlisting>
</para>
</listitem>
</varlistentry>
<varlistentry>
<term>membres de classes</term>
<listitem>
<para>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.</para>

<para>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</para>
<para>
<programlisting> Foo(long new_value); long Foo();
</programlisting>
</para>
<para>pour récupérer et envoyer les valeurs. Dans ce cas, la valeur
réelle de foo devrait être stockée dans  _Foo.</para>
</listitem> </varlistentry>
<varlistentry>
<term>nom des classes</term>
<listitem>
<para>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.</para>

<para>Les implantations des classes CORBA devraient être appelées Class_impl,
comme par exemple Synthesizer_impl.</para></listitem> </varlistentry>
<varlistentry>
<term>Paramètres</term>
<listitem>
<para>Les paramètres sont toujours en minuscule.</para> </listitem>
</varlistentry>
<varlistentry>
<term>Variables locales</term>
<listitem>
<para>Les variables locales sont toujours en minuscule, et ont des noms
comme i, p, x, etc.</para></listitem>
</varlistentry>
<varlistentry>
<term>Largeur de tabulation (largeur du décalage)</term>
<listitem>
<para>Une tabulation correspond à 4 espaces.</para></listitem>
</varlistentry>
</variablelist>
</para>
</sect1>

<sect1 id="quelques-mots-sur-corba">
<title>Quelques mots sur CORBA</title>

<para>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</para>

<para>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é.</para>

<para>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.</para>

<para>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.</para>

<para>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.</para>

<para>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 ;)</para>

<para>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.</para>
</sect1>

<sect1 id="portage-ecrire-d-autres-gui-builder">
<title>Portage - écrire d'autres éditeurs graphiques pour aRts</title>

<para>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.</para>

<para>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).</para>

<para>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.</para>

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

<para><variablelist>
<varlistentry>
<term>Connecter l'instance du synthétiseur :</term>
<listitem>
<para>
<programlisting>
// Vous devrez appeler orb-&gt;bind, le code mico pour cela est  :

CORBA::Object_var obj =         orb-&gt;bind
("IDL:Arts/Synthesizer:1.0","inet:localhost:8888");
</programlisting>
</para>
</listitem> </varlistentry>
<varlistentry>
<term>Création d'une description de structure de synthèse</term>
<listitem>
<para>Appelez Synthesizer-&gt;createStructureDesc(). Vous aurez une
description de structure.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Creation de modules</term>
<listitem>
<para>Utilisez Synthesizer-&gt;getModuleCount() et
Synthesizer-&gt;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).</para>

<para>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.</para>

<para>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.</para></listitem></varlistentry>
<varlistentry>
<term>Affichage des modules</term>
<listitem>
<para>Les modules devraient ressembler à ça :</para>
<para><mediaobject><imageobject><imagedata fileref="images/Doc_MODUL.png" format="png"></imageobject></mediaobject></para>
<para>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).</para>
<para>Les modules sont positionnés dans l'éditeur de façon à ne pas se
recouvrir.</para></listitem>
</varlistentry>
<varlistentry>
<term>Connexion des ports, réglages des paramètres</term>
<listitem>
<para>Vous pouvez maintenant régler les paramètres de votre module en
utilisant la séquence ModuleDesc-&gt;Ports, qui contient les références sur
les ports d'un module. Vous pouvez appeler connectTo, disconnect,...</para>
<para>On peut soit connecter un port, soit lui assigner une valeur, ou le
laisser non connecté.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Exécution des modules</term>
<listitem>
<para>Utilisez Synthesizer-&gt;createStructure(StructureDesc) pour créer une
instance de cette structure, qui sera synthétisée.</para>
<para>Gardez l'id et passez-le à freeStructure ensuite.</para></listitem>
</varlistentry>
<varlistentry>
<term>Enregistrement des fichiers</term>
<listitem>
<para>Enregistrez votre StructureDesc avec saveToList(),
et écrivez le contenu du Arts::StringSeq résultant dans un fichier texte.
Donnez lui l'extension .arts.</para></listitem>
</varlistentry>
<varlistentry>
<term>Ouverture de fichiers</term>
<listitem>
<para>Ouvrez un fichier arts dans un Arts::StringSeq. Allez vers un
StructureDesc que vous avez déjà et appelez
StructureDesc-&gt;loadFromList(theStringSeq).</para>
</listitem>
</varlistentry>
</variablelist>

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.</para>

<para>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.</para>

<para>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.</para>

<para><variablelist>
<varlistentry>
<term>Caractéristiques avancées</term>
<listitem>
<para>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").</para>

<para>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.</para>

<para>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).</para> </listitem>
</varlistentry>
</variablelist>
</para>
</sect1>
</chapter>

<chapter id="Epilogue">
<title>Épilogue</title>

<sect1 id="auteurs">
<title>Auteurs</title>

<para>aRts est sous le Copyright &copy; 1998-1999 Stefan Westerfeld
(<ulink url="mailto:stefan@space.twc.de">stefan@space.twc.de</ulink>)</para>

<para>Une partie du code est sous de copyright de leurs auteurs respectifs,
voir les fichiers sources.</para>
</sect1>

<sect1 id="thanks-to">
<title>Remerciements</title>

<para>Le projet Arts n'aurait pas été ce qu'il est sans (dans le désordre)
<variablelist>
<varlistentry>
<term>L'équipe KDE</term>
<listitem>
<para>sans leur travail, il n'aurait peut-être pas été commencé du
tout</para>
</listitem> </varlistentry>
<varlistentry>
<term>Harald Lapp</term>
<listitem>
<para>conception du site internet <ulink
url="http://linux.twc.de/arts">http://linux.twc.de/arts</ulink> et
conception des icônes</para> </listitem>
</varlistentry>
<varlistentry>
<term>Paul Leonard
(<ulink url="mailto:P.J.Leonard@bath.ac.uk">P.J.Leonard@bath.ac.uk</ulink> )</term>
<listitem>
<para>qui a écrit Cantor, le séquenceur sympathique qui travaille maintenant
avec Arts via les bus midi</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Juhana Sadeharju
(<ulink url="mailto:kouhia@nic.funet.fi">kouhia@nic.funet.fi</ulink> )</term>
<listitem>
<para>qui a écrit une partie des filtres utilisés dans aRts</para> </listitem>
</varlistentry>
<varlistentry>
<term>Jens Hahn
(<ulink url="mailto:Jens.Hahn@t-online.de">Jens.Hahn@t-online.de</ulink> )</term>
<listitem>
<para>qui a écrit une partie des modules utilisés dans aRts</para></listitem>
</varlistentry>
<varlistentry>
<term>Emmeran Seehuber
(<ulink url="mailto:the_emmy@gmx.de">the_emmy@gmx.de</ulink> )</term>
<listitem>
<para>pour le code du partage de clavier/mapping de midisend</para>
</listitem>
</varlistentry>
<varlistentry>
<term>Martin Lorenz
(<ulink url="mailto:lorenz@ch.tum.de">lorenz@ch.tum.de</ulink> )</term>
<listitem>
<para>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.</para>
</listitem>
</varlistentry>
<varlistentry>
<term>David G. Slomin 
(<ulink url="mailto:dgslomin@alumni.princeton.edu">dgslomin@alumni.princeton.edu</ulink> )</term>
<listitem>
<para>qui a contribué au code d'analyse midi pour les données midi compressées</para>
</listitem>
</varlistentry>
</variablelist>
</para>

<para>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.</para>

<para>La traduction française a été réalisée par 
<ulink url="mailto:ludovic.grossard@libertysurf.fr">Ludovic
Grossard</ulink></para> 
</sect1>

<sect1 id="copyright">
<title>Copyright & Licensing</title>

<para><screen>
                    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
</screen>
</para>
</sect1>

<sect1 id="licence-of-the-sound-drivers">
<title>License of the sound drivers</title>

<para><programlisting>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 &lt;Johan.Hagman@mailbox.swipnet.se&gt;

[...]

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

   Tim Newsome &lt;drz@froody.bloke.com&gt;		   Linux
   Damien Clermonte &lt;clermond@esiee.fr&gt;		   HPUX
   Troels Walsted Hansen &lt;troels@stud.cs.uit.no&gt;   Amiga
   Terje Malmedal &lt;terje.malmedal@usit.uio.no&gt;	   AIX
   Dan Nelson &lt;dnelson@emsphone.com&gt;		   FreeBSD
   Michael Cheng &lt;mcheng@faraday.dialix.com.au&gt;    Amiga
   Fredrik Hubinette &lt;hubbe@lysator.liu.se&gt;        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.</programlisting>
</para>
</sect1>
</chapter>
</book>
<!--
Local Variables:
mode: sgml
sgml-omittag: nil
sgml-shorttag: t
End:
-->
