<!DOCTYPE book PUBLIC  "-//KDE//DTD DocBook V3.1-Based Variant V1.0//EN" [
  <!ENTITY kappname "&arts;" >
  <!ENTITY % addindex "IGNORE">
  <!ENTITY % French "INCLUDE" >
  <!ENTITY % ents PUBLIC "-//KDE//ENTITIES Documentation V2.0//EN">
  %ents;
]>
<!-- Note: I am temporarily obligated to revert this file back to DocBook 3.1
     We'll switch to DocBook 4.1 probably after KDE 2.1
     When it happens, please remove the "DocBook 4.1:" comments from the document
	(E.B. 2001-02-08)
-->

<book lang="&language;">
<bookinfo>
<title>Le manuel de &arts;</title>
<authorgroup>

<author>
<firstname>Stefan</firstname>
<surname>Westerfeld</surname>
<affiliation>
<address><email>stefan@space.twc.de</email></address>
</affiliation>
</author>

<author>
<firstname>Jeff</firstname>
<surname>Tranter</surname>
<affiliation>
<address><email>tranter@kde.org</email></address>
</affiliation>
</author>

<othercredit role="translator">
<firstname>Ludovic</firstname>
<surname>Grossard</surname>
<affiliation>
<address><email>ludovic.grossard@libertysurf.fr</email></address>
</affiliation>
<contrib>Traduction française</contrib>
</othercredit>
</authorgroup>

<copyright>
<year>1999-2001</year>
<holder>Stefan Westerfeld &amp; Jeff Tranter</holder>
</copyright>
<legalnotice>&FDLNotice;</legalnotice>

<date>04/01/2001</date>
<releaseinfo>1.0.8</releaseinfo>

<abstract><para>Ce manuel déscrit &arts;, le synthétiseur analogique en temps-réel.</para>

</abstract>

<keywordset>
<keyword>aRts</keyword>
<keyword>artsbuilder</keyword>
<keyword>synthetiseur</keyword>
<keyword>multimédia</keyword>
<keyword>structure</keyword>
<keyword>musique</keyword>
<keyword>son</keyword>
<keyword>KDE</keyword>
</keywordset>
</bookinfo>

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

<sect1 id="what-is-arts">
<title>Qu'est-ce que &arts;?</title>

<para>Le Synthétiseur Analogique en Temps-Réel (Analog Real-Time
Synthesizer), ou &arts;, est un système modulaire de synthèse sonore sur
ordinateur. À l'aide de petits blocs appelés modules, l'utilisateur peut
construire facilement des outils de traitement audio évolués. Les modules
fournissent des fonctions telles que la génération de formes d'onde, des
filtres, des effets, des mixeurs, et des lecteurs audio dans différents formats
de fichiers.</para>

<para>Le serveur sonore <application>artsd</application> mixe le son provenant
de différentes sources, permettant ainsi à plusieurs applications sonores
de partager de manière transparente l'accès au matériel multimédia.</para>

<para>En utilisant <acronym>MCOP</acronym>, le protocope de communication
multimédia (Multimedia Communication Protocol), les applications sont
transparentes vis-à-vis du réseau, authentifiées au niveau sécurité, et
multi-plateformes grâce à des interfaces définies de manière indépendante du
langage avec <acronym>IDL</acronym>.  La compatibilité est aussi fournie
pour les applications non basées sur arts. En tant que composant de base de
l'environnement de bureau &kde;&nbsp;2, &arts; fournit les bases de
l'architecture multimédia de &kde;, et gèrera dans le futur plus de types de
supports y compris la vidéo. Tout comme &kde;, &arts; fonctionne sur plusieurs
systèmes d'exploitation, comme &Linux; ou les différents BSD. Il peut aussi être
utilisé indépendamment de &kde;</para>

</sect1>

<sect1 id="using-this-manual">
<title>Utiliser ce Manuel</title>

<para>Ce manuel a été écrit de façon à fournir une documentation de
&arts; utilisable quel que soit votre niveau. Si vous êtes utilisateur
occasionnel d'applications multimédia qui font usage de &arts;, ou bien un
développeur d'applications multimédia, vous emprunterez des chemins différents
dans ce manuel.</para>

<para>Je vous suggère de lire d'abord le chapitre <link
linkend="installation">Téléchargement et compilation de &arts;</link> si vous
devez installer &arts;. Si vous avez déjà un système qui fonctionne, de
préférence livré avec votre distribution, vous pouvez passer cette
section.</para>

<para>Lisez ensuite les sections du chapitre <link linkend="arts-tools">outils
de &arts;</link>, tout spécialement <application>artsd</application>,
<application>artscontrol</application>, <application>artsshell</application>,
et <application>artsdsp</application>. Ceci va vous aider à tirer le meilleur de
&arts;.</para>

<para>Si vous souhaitez aller plus loin, lisez le chapitre <link
linkend="artsbuilder">artsbuilder</link> et parcourez son tutoriel. Ça vous
donnera une idée des possibilités de &arts; ainsi que les modules fournis qui
peuvent être utilisés sans avoir besoin d'être programmeur.</para>

<para>Si vous voulez en savoir plus sur les entrailles de &arts;, soit pour
développer des applications multimédia, ou pour étendre &arts; lui-même, lisez
le chapitre <link linkend="arts-in-detail">&arts; en détail</link>. Cela va vous
aider à comprendre tous les concepts nécessaires au développement de logiciels
avec &arts;.</para>

<para>Si vous vous intéressez spécifiquement aux capacités de &arts; en ce qui
concerne le <acronym>MIDI</acronym>, lisez le chapitre <link
linkend="midi"><acronym>MIDI</acronym></link>.</para>

<para>Pour en savoir plus sur les éléments graphiques de &arts;, soit comme
utilisateur avancé de artsbuilder ou pour créer de nouveaux éléments, lisez la
section sur les <link linkend="gui-elements">Éléments de
l'interface graphique</link>.</para>

<para>Si vous voulez développer des applications multimédia compatibles avec
&arts;, le chapitre <link
linkend="arts-apis">Application Programming Interfaces de &arts;</link> couvre
les différentes <acronym>API</acronym> en détail.</para>

<para>Si vous voulez étendre &arts; en créant de nouveaux modules, lisez le
chapitre <link linkend="arts-modules">Modules de &arts;</link>.</para>

<para>Si vous modifiez une application déjà existante pour la faire fonctionner
avec &arts;, lisez le chapitre sur le <link linkend="porting">Portage
des applications vers &arts;</link>.</para>

<para>La façon dont vous pourriez aider le projet &arts; se trouve dans le
chapitre <link linkend="contributing">Contribuer à &arts;</link>, et les
développements à venir de &arts; se trouvent dans le chapitre <link
linkend="future-work">Travaux à venir</link>, enfin vous obtiendrez des
informations suplémentaires en suivant les liens dans la section <link
linkend="references">Références</link>.</para>

<para>Nous avons aussi enrichi ce manuel d'un certain nombre de choses, comme
par exemple les <link linkend="faq">réponses aux questions fréquemment
posées</link>, une <link linkend="contributors">liste des participants</link>,
les détails sur le <link linkend="copyright-and-licenses">copyright et la
licence</link> de arts, et des informations sur l'<link
linkend="intro-digital-audio">audionumérique</link> et le <link
linkend="midi-introduction"><acronym>MIDI</acronym></link>. Un <link
linkend="glossary">glossaire</link> a ausi été ajouté.</para>

<note>
<para>
Ce manuel est encore en cours d'écriture. Vous êtes le bienvenu pour contribuer
à son écriture, mais si vous souhaitez le faire, contactez d'abord Jeff
Tranter <email>tranter@kde.org</email> pour éviter de faire le travail en
double. </para>
</note>

</sect1>

<sect1 id="history">
<title>Historique</title>

<para>
À la fin de l'année 1997, Stephan Westerfeld a commencé à travailler sur un
système modulaire dédié à la synthèse sonore en temps réel. Le code fonctionnait
initialement sur un PowerPC sous &AIX;. Cette première implantation était
plutôt simple mais gérait un système de flux de données qui pouvait lire des
fichiers mp3 ou bien diriger un flux audio vers des modules d'effet.
</para>


<para>L'étape suivante a consisté à implanter une interface graphique
(<acronym>GUI</acronym>) de façon à manipuler les modules de manière graphique.
Stefan connaissait bien &kde; et l'a utilisé comme outils de développement de
l'interface graphique (tout en sachant qu'une interface Gnome/gtk était aussi
nécessaire), ce qui l'a amené plus tard à utiliser &Linux; comme plateforme de
développement principale. Nommé à l'origine <application>ksynth</application>,
le projet a été renommé &arts; et le développement s'est accéléré. Le projet à
ce niveau était à peu près complet, avec un protocol de communication basé sur
<acronym>CORBA</acronym>, une douzaine de modules, un outil d'édition graphique
des modules, des <acronym>API</acronym> C et C++, de la documentation, des
utilitaires, et une liste de discussion avec un petit groupe de développeurs. Le
projet à beaucoup avancé après seulement un peu plus d'un an de
développement.</para>

<para>Alors que l'équipe &kde; commençait à planifier &kde; 2.0, il devenait
clair que &kde; nécessitait une infrastructure plus puissante pour le son et
autres formats multimédia. Il a été décidé d'adapter &arts;, étant bien adapté à
cela et possédant une architecture ayant fait ses preuves. De gros efforts de
développement ont alors été menés sur cette nouvelle version de &arts;,
notamment au niveau du remplacement du code <acronym>CORBA</acronym> avec un
sous-système entièrement nouveau, <acronym>MCOP</acronym>, optimisé pour le
multimédia. La version 0.4 de &arts; a fait partie de &kde; 2.0.</para>

<para>Le travail continue sur &arts;, en améliorant les performances et en
ajoutant de nouvelles fonctionnalités. Notez que bien que &arts; soit un
composant de base de &kde;, il peut être aussi utilisé sans &kde;, et est aussi
utilisé par des applications qui vont au-delà du multimédia traditionnel. Le
projet a suscité un intérêt de la part de l'équipe Gnome, ouvrant ainsi la
possibilité qu'il devienne un jour le standard multimédia des environnements de
bureau pour &UNIX;.</para>

</sect1>

</chapter>

<chapter id="arts-tools">
<title>Outils de &arts;</title>

<para>&arts; est livré avec plusieurs outils pour contrôler et configurer son
comportement. Ces outils doivent vous être familiers pour utiliser &arts; de
façon efficace. Cette section décrit chaque utilitaire et ses options.</para>

<sect1 id="kde-control-center">
<title>&kcontrol;</title>

<para>Lorsque vous exécutez &arts; sous &kde;, le module &kcontrol; fournit un
groupe de réglages du centre de configuration dans la catégorie
<guilabel>Son</guilabel>. Certains de ces réglages sont utilisés par &arts;. Vous
pouvez aussi associer des sons avec des événements de &kde; et du gestionnaire
de fenêtres en utilisant <menuchoice><guilabel>Apparence et
ergonomie</guilabel><guilabel>Notifications du système</guilabel></menuchoice>.
Lisez le manuel de &kcontrol; pour avoir des informations sur l'utilisation de
ces réglages.</para>

</sect1>

<sect1 id="artsd">
<title><application>artsd</application></title>

<para>L'accès au ressources matérielles pour le son est contrôlé par
<application>artsd</application>, le démon de &arts;. Ceci permet à différentes
applications d'envoyer simultanément des requêtes au serveur, où elles peuvent
être mixées puis jouées. Sans un serveur sonore centralisé, une application
utilisant le périphérique son empêche toutes les autres de l'utiliser.</para>

<para>Pour utiliser &arts;, il doit y avoir une copie et une seule de
<application>artsd</application> en fonctionnement. C'est typiquement le cas
lorsque &kde; démarre si cela est activé dans <guilabel>Serveur de
son</guilabel> dans le centre de configuration.</para>

<para>Le programme accepte les arguments suivants&nbsp;:</para>

<!-- LW: FIX THIS -->

<cmdsynopsis>
<command>artsd</command>
<group choice="opt">
<option>-n</option>
<option>-p</option>
<option>-u</option>
</group>
<group choice="opt">
<option>-a <replaceable>méthode audio </replaceable></option>
<option>-r <replaceable>taux d'échantillonnage </replaceable></option>
<option>-b <replaceable>bits </replaceable></option>
<option>-d </option>
<option>-D <replaceable>nom du périphérique </replaceable></option>
<option>-F <replaceable>fragments </replaceable></option>
<option>-S <replaceable>taille</replaceable></option>
</group>
<group choice="opt">
<option>-h</option>
<option>-A</option>
<option>-l <replaceable>niveau</replaceable></option>
</group>
</cmdsynopsis>

<variablelist>

<varlistentry>
<term><option>-r <replaceable>taux
d'échantillonnage</replaceable></option></term> <listitem>
<para>Règle le taux d'échantillonnage utilisé.</para>
</listitem>
</varlistentry>

<varlistentry>
<term><option>-h</option></term>
<listitem>
<para>Affiche l'utilisation des commandes.</para>
</listitem>
</varlistentry>

<varlistentry>
<term><guilabel>-n</guilabel></term>
<listitem>
<para>Active la transparence réseau.</para>
</listitem>
</varlistentry>

<varlistentry>
<term><option>-p <replaceable>port</replaceable></option>
</term>
<listitem>
<para>Règle le port <acronym>TCP</acronym> à utiliser (implique
<option>-n</option>).</para>
</listitem>
</varlistentry>

<varlistentry>
<term><option>-u</option></term>
<listitem>
<para>Public, pas d'authentification (dangeureux).</para>
</listitem>
</varlistentry>

<varlistentry>
<term><option>-d</option></term>
<listitem>
<para>Active le mode full duplex.</para>
</listitem>
</varlistentry>

<varlistentry>
<term><option>-D <replaceable>nom du périphérique</replaceable></option></term>
<listitem>
<para>Spécifie le périphérique audio (habituellement
<filename>/dev/dsp</filename>).</para> </listitem>
</varlistentry>

<varlistentry>
<term><option>-F <replaceable>fragments</replaceable></option></term>
<listitem>
<para>Règle le nombre de fragments.</para>
</listitem>
</varlistentry>

<varlistentry>
<term><option>-S <replaceable>taille</replaceable></option></term>
<listitem>
<para>Règle la taille des fragments, en octets.</para>
</listitem>
</varlistentry>

<varlistentry>
<term><option>-l <replaceable>niveau</replaceable></option></term>
<listitem>
<para>Règle le niveau d'information - 3 (muet), 2 (alertes), 1 (info), 0
(déboguage).</para>
</listitem>
</varlistentry>

</variablelist>

<para>Dans la plupart des cas, exécuter simplement <command>artsd</command>
suffira.</para>


</sect1>

<sect1 id="artswrapper">
<title><application>artswrapper</application></title>

<para>Pour avoir un bon temps de réponse, <application>artsd</application> est
souvent exécuté en tant que processus temps-réel (sur les plateformes gérant la
priorité temps-réel). Ceci nécessite les droits administrateur, donc pour
minimiser les problèmes de sécurité, <application>artsd</application> peut être
lancé à l'aide d'un petit programme encapsulant,
<application>artswrapper</application>, qui actionne simplement la priorité
temps-réel (s'exécutant en tant qu'<systemitem <!-- DocBook 4.1:
class="username"-->administrateur</systemitem>) et exécute ensuite
<command>artsd</command> en tant qu'utilisateur non administrateur.</para>

</sect1>

<sect1 id="artsshell">
<title><application>artsshell</application></title>

<para>La commande <command>artsshell</command> est dédiée à exécuter des
fonctions diverses liées au serveur de son. Cet utilitaire devrait être étendu
dans le futur par l'ajout de nouvelles commandes (voir les commentaires dans le
source).</para>

<para>La commande s'utilise comme suit&nbsp;:</para>

<!-- LW: FIX THIS -->

<cmdsynopsis>
<command>artsshell</command>
<group>
<arg>suspend</arg>
<arg>status</arg>
</group>
<group>
<option>-h</option>
<option>-q</option>
</group>
</cmdsynopsis>

<para>artsshell [options] <replaceable>command</replaceable> [<replaceable>command-options</replaceable>] </para>

<para>
Les options suivantes sont disponibles&nbsp;:
</para>

<variablelist>

<varlistentry>
<term><option>-q</option></term>
<listitem>
<para>Supprime toute sortie.</para>
</listitem>
</varlistentry>

<varlistentry>
<term><option>-h</option></term>
<listitem>
<para>Affiche l'utilisation des commandes.</para>
</listitem>
</varlistentry>

</variablelist>

<para>Les commandes suivantes sont disponibles&nbsp;:</para>

<variablelist>

<varlistentry>
<term><option>suspend</option></term>
<listitem>
<para>
Suspend le serveur de son.
</para>
</listitem>
</varlistentry>

<varlistentry>
<term><option>status</option></term>
<listitem>
<para>Affiche les informations sur l'état du serveur de son.</para>
</listitem>
</varlistentry>

</variablelist>

</sect1>

<sect1 id="artsplay">
<title><application>artsplay</application></title>

<para>La commande <application>artsplay</application> est un simple utilitaire
pour jouer un fichier son. Elle accepte un seul argument correspondant au nom du
son qui est envoyé au serveur de son pour être joué. Le fichier son peut être
n'importe quel type de fichier son commun tel que <literal
role="extension">wav</literal> ou <literal role="extension">au</literal>. Cet
utilitaire permet de tester que le serveur de son fonctionne bien. En exécutant
deux commandes en parallèles ou très vite de manière successive, vous pouvez
mettre en évidence le mixage de plusieurs sources sonores par le serveur
sonore.</para>

</sect1>

<sect1 id="artsdsp">
<title><application>artsdsp</application></title>

<para>Le serveur de son ne gère que les applications compatibles avec &arts;.
Beaucoup d'applications héritées accèdent directement au
périphérique son. La commande <command>artsdsp</command> fournit une solution
intermédiaire qui permet à la plupart de ces applications de fonctionner sans
changements.</para>

<para>Lorsqu'une application est exécutée sous
<application>artsdsp</application>, tous les accès au périphérique audio
<filename>/dev/dsp</filename> sont interceptés et transformés en appels aux
<acronym>API</acronym> de &arts;. Cette émulation n'est pas parfaite, mais la
plupart des applications fonctionnent de cette manière, avec une diminution des
performances et des coupures.</para>

<para>La commande <command>artsdsp</command> s'utilise comme suit&nbsp;:
</para>

<!-- LW: FIX THIS -->

<para>
artsdsp [<replaceable>options</replaceable>]
<replaceable>arguments</replaceable> </para>

<para>
Les options suivantes sont disponibles&nbsp;:
</para>

<variablelist>

<varlistentry>
<term><option>-h</option>,  <option>--help</option></term>
<listitem>
<para>De l'aide succinte.</para>
</listitem>
</varlistentry>

<varlistentry>
<term><option>-n</option> <option>--name</option> =
<replaceable>nom</replaceable></term> <listitem>
<para>Utilisez <replaceable>nom</replaceable> pour identifier le lecteur auprès
de <command>artsd</command>.</para>

</listitem>
</varlistentry>

<varlistentry>
<term><option>-m</option> <option>--mmap</option></term>
<listitem>
<para>Émule le memory mapping (par exemple pour
<application>Quake</application>).</para> </listitem>
</varlistentry>

<varlistentry>
<term><option>-v</option> <option>--verbose</option></term>
<listitem>
<para>Affiche des paramètres.</para>
</listitem>
</varlistentry>

</variablelist>

<para>
Une invocation typique serait&nbsp;:
</para>

<para>
<userinput><command>artsdsp</command> <option>-v</option> <option>-m realplay <replaceable>song.mp3</replaceable></option></userinput>
</para>

<para>Certaines applications fonctionnent mieux avec l'option
<option>--mmap</option>. Les caractéristiques du périphérique sonore ne sont pas
toutes émulées, mais la plupart des applications devrait fonctionner. Si vous
trouvez une application qui ne fonctionne pas, envoyez un rapport de bogue
détaillé et le développeur devrait être en mesure de régler le problème. Encore
une fois, souvenez-vous que c'est une solution intermédiaire et peu
élégante, la meilleure solution serait d'ajouter la gestion native de
&arts; dans les applications multimédia. Si votre application favorite ne
reconnaît pas &arts;, demandez au développeur d'y ajouter cette gestion.</para>

</sect1>

<sect1 id="artscat">
<title><application>artscat</application></title>

<para>C'est un simple utilitaire pour envoyer des données audio vers le serveur
de son. Vous devez spécifier le format des données (taux d'échantillonnage,
taille de l'échantillon, et nombre de canaux). Vous ne l'utiliserez probablement
pas souvent, mais il peut rendre service pour certains tests. La syntaxe de la
commande est la suivante&nbsp;: </para>

<!-- LW: FIX THIS -->

<para>
artscat [ <replaceable>options</replaceable> ] [
<replaceable>fichier</replaceable> ] </para>

<para>Si aucun nom de fichier n'est spécifié, l'entrée standard est lue. Les
options suivantes sont disponibles&nbsp;: </para>

<variablelist>

<varlistentry>
<term><option>-r <replaceable>taux
d'échantillonnage</replaceable></option></term> <listitem>
<para>Règle le taux d'échantillonnage.</para>
</listitem>
</varlistentry>

<varlistentry>
<term><option>-b <replaceable>bits</replaceable></option></term>
<listitem>
<para>Règle la taille des échantillons (8 bits ou 16 bits).</para>
</listitem>
</varlistentry>

<varlistentry>
<term><option>-c <replaceable>canaux</replaceable></option></term>
<listitem>
<para>Règle le nombre de canaux (1 ou 2).</para>
</listitem>
</varlistentry>

<varlistentry>
<term><option>-h</option></term>
<listitem>
<para>Affiche l'utilisation de la commande et quitte.</para>
</listitem>
</varlistentry>

</variablelist>

</sect1>

<sect1 id="artscontrol">
<title><application>artscontrol</application></title>

<para>C'est un utilitaire graphique pour réaliser un certain nombre de tâches en
rapport avec le serveur de son. La fenêtre par défaut affiche deux indicateurs
de niveau de volume et une glissière pour contrôler le volume principal. À
partir du menu <guimenu>Affichage</guimenu>, vous pouvez sélectionner d'autres
fonctions&nbsp;: </para>

<variablelist>

<varlistentry>
<term><guimenuitem>FFT</guimenuitem></term>
<listitem>
<para>Ouvre une fenêtre qui affiche un analyseur de spectre en temps réel.</para>
</listitem>
</varlistentry>

<varlistentry>
<term><guimenuitem>Gestionnaire audio</guimenuitem></term>
<listitem>
<para>Affiche les sources sonores actives et vous permet de les connecter aux
bus disponibles.</para>
</listitem>
</varlistentry>

<varlistentry>
<term><guimenuitem>Statut de aRts</guimenuitem></term>
<listitem>
<para>Montre si le serveur sonore est actif et s'il s'exécute avec la priorité
temps-réel. Il indique lorsque le serveur est suspendu automatiquement, et
permet de le suspendre immédiatement.</para>
</listitem>
</varlistentry>

<varlistentry>
<term><guimenuitem>Gestionnaire Midi</guimenuitem></term>
<listitem>
<para>Affiche les entrées et sorties Midi actives et vous permet de faire des
connexions [à faire&nbsp;: Est-ce que ça marche ? Besoin de plus de détails].</para>
</listitem>
</varlistentry>

<varlistentry>
<term><guimenuitem>FreeVerb</guimenuitem></term>
<listitem>
<para>Connecte une réverbération FreeVerb à la pile des effets de sortie de
&arts; et vous permet de contrôler les paramètres de l'effet de manière
graphique.</para>
</listitem>
</varlistentry>

<varlistentry>
<term><guimenuitem>Affichage du volume sous forme de LED</guimenuitem></term>
<listitem>
<para>Utilise des diodes électroluminescentes (<acronym>LED</acronym>) colorées
pour les indicateurs de volume de la fenêtre principale à la place des barres de
progression.</para>
</listitem>
</varlistentry>

</variablelist>

</sect1>

<sect1 id="artsc-config">
<title><application>artsc-config</application></title>

<para>C'est un utilitaire pour aider les développeurs à utiliser les
<acronym>API</acronym> C de &arts;. Il donne les options du lieur et du
compilateur nécessaires pour compiler et lier du code avec &arts;. Il est
destiné à être utilisé dans des makefiles pour favoriser la portabilité. La
commande accepte trois options&nbsp;: </para>

<variablelist>
<varlistentry>
<term><option>--cflags</option></term>
<listitem>
<para>Affiche les options de compilation nécessaires pour compiler
avec les <acronym>API</acronym> C de &arts;..</para>
</listitem>
</varlistentry>
<varlistentry>
<term><option>--libs</option></term>
<listitem>
<para>Affiche les options de compilation du lieur nécessaires pour compiler avec les
<acronym>API</acronym> C de &arts;..</para>
</listitem>
</varlistentry>
<varlistentry>
<term><acronym>--version</acronym></term>
<listitem>
<para>Affiche la version de la commande <command>artsc-config</command>.</para>
</listitem>
</varlistentry>
</variablelist>

<para>Voici la sortie typique de la commande&nbsp;: </para>

<screen width="40"><prompt>%</prompt> <userinput><command>artsc-config</command> <option>--cflags</option></userinput>
<computeroutput>-I/usr/local/kde2/include/artsc</computeroutput>
<prompt>%</prompt> <userinput><command>artsc-config</command> <option>--libs</option></userinput>
<computeroutput>-L/usr/local/kde2/lib -ldl -lartsc -DPIC -fPIC -lpthread</computeroutput>
<prompt>%</prompt> <userinput><command>artsc-config</command> <option>--version</option></userinput>
<computeroutput>0.9.5</computeroutput>
</screen>

<para>Vous auriez pu utiliser cet utilitaire dans un makefile en utilisant une
règle telle que&nbsp;: </para>

<programlisting>
artsc: artsc.c
        gcc `artsc-config --cflags` -o artsc artsc.c `artsc-config --libs`
</programlisting>

</sect1>

<sect1 id="mcopidl">
<title><command>mcopidl</command></title>

<para>La commande <command>mcopidl</command> est le compilateur
<acronym>IDL</acronym> pour <acronym>MCOP</acronym>, le protocole de
communication multimédia utilisé par &arts;. Les interfaces dans &arts; sont
définies en <acronym>IDL</acronym>, un langage de définition d'interface
(Interface Definition Language) indépendant du langage. L'utilitaire
<command>mcopidl</command> accepte en entrée un fichier <acronym>IDL</acronym>
et génère des fichiers d'entête et de sources C++ pour une classe implantant
l'interface. La commande a la syntaxe suivante&nbsp;: </para>

<!-- LW: FIX THIS -->

<para>mcopidl [ <replaceable>options</replaceable> ]
<replaceable>fichier</replaceable> </para>

<para>Les options disponibles sont&nbsp;: </para>

<variablelist>
<varlistentry>
<term><option>-I <replaceable parameter>dossier</replaceable></option></term>
<listitem>
<para>Cherche les fichiers d'inclusion dans
<replaceable>dossier</replaceable>.</para>
</listitem>
</varlistentry>
<varlistentry>
<term><option>-e <replaceable>nom</replaceable></option></term>
<listitem>
<para>Exclut le type de struct, interface, ou enum
<replaceable>nom</replaceable> de la génération du code.</para>
</listitem>
</varlistentry>
<varlistentry>
<term><option>-t</option></term>
<listitem>
<para>Crée aussi les fichiers .mcoptype/.mcopclass contenant les informations de
type pour le fichier <acronym>IDL</acronym>.</para> </listitem>
</varlistentry>
</variablelist>

<para>Vous trouverez plus d'information à propos de <acronym>MCOP</acronym> et
<acronym>IDL</acronym> dans la section <link linkend="interfaces">Interfaces et
<acronym>IDL</acronym></link>.</para>

</sect1>

</chapter>

<chapter id="artsbuilder">
<title>&artsbuilder;</title>

<sect1 id="overview">
<title>Aperçu</title>

<para>Hélas, avec la réécriture de la documentation pour &kde; 2.0, je n'ai pas
le temps d'adapter complètement cette documentation. Donc pour l'instant, vous
devrez vous contenter de cette brève introduction sur la façon dont
&artsbuilder; fonctionne, puis vous êtes livrés à vous même.</para>

<para>Tout d'abord, avant de lancer &artsbuilder;, vous devez aussi lancer le
serveur de son (&artsd;). Habituellement, lorsque vous utilisez &kde; 2.0,
&artsd; devrait déjà être en fonctionnement. Si ce n'est pas le cas, vous pouvez
configurer le lancement automatique du serveur de son dans le
<menuchoice><guimenu>Centre de configuration de kde</guimenu>
<guilabel>Son</guilabel><guilabel>Serveur de son</guilabel>
</menuchoice>.</para>

<para>Lorsque vous exécutez &arts;, il lance toujours de petits modules.
&artsbuilder; est maintenant un outil pour créer de nouvelles structures
composées de petits modules interconnectés. Vous placez simplement sur les
modules dans la grille. Pour ce faire, choisissez-les dans le menu
<guimenu>Modules</guimenu>, et cliquez quelque part dans la zone
gris-vert.</para>

<para>Les modules ont généralement des ports (dans lesquels les flux audio
transitent). Pour connecter deux ports, cliquez sur le premier, ce qui le rend
orange, puis cliquez sur le second. Vous ne pouvez que connecter un port
d'entrée (en haut du module) avec un port de sortie (en bas du module). Si vous
voulez assigner une valeur constante à un port (ou le déconnecter),
double-cliquez sur le port.</para>

<para>Voici un exemple simple pour commencer.</para>

<procedure>

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

<step>
<para>Vous avez besoin d'un module Synth_AMAN_PLAY pour entendre ce que vous
créez (lorsque artsd est utilisé comme serveur de son). Créez alors un module
Synth_AMAN_PLAY en sélectionnant <menuchoice><guimenu>Modules</guimenu>
<guisubmenu>Synthèse</guisubmenu> <guisubmenu>Entrée/Sortie son</guisubmenu>
<guimenuitem>Synth_AMAN_PLAY</guimenuitem></menuchoice> 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>
</step>

<step>
<para>Vous pouvez double-cliquer sur les deux premiers paramètres
(<guilabel>title</guilabel> et <guilabel>autorestoreid</guilabel>), et donner un
nom à votre sortie audio (qui sera visible plus tard dans
<application>artscontrol</application> par exemple). Double-cliquez dessus (les
deux ports les plus à gauche du module), sélectionnez valeur constante et
saisissez <userinput>hello_arts</userinput> ou quelque chose du genre dans la
boîte d'édition. Cliquez sur OK pour appliquer vos changements.</para>
</step>

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

<step>
<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'oscillation à partir d'une fréquence, un
module Synth_FREQUENCY est utilisé.</para>
</step>

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

<step>
<para>Cliquez sur <menuchoice><guimenu>Fichier</guimenu> <guimenuitem>Exécuter
la structure</guimenuitem></menuchoice>. Vous entendrez une onde sinusoïdale à
440 Hz sur l'un de vos haut-parleurs. Je vous laisse deviner ce que vous devez
faire pour l'entendre aussi sur l'autre haut-parleur&nbsp;?&nbsp;;)</para>
</step>
</procedure>

</sect1>

<sect1 id="artsbuilder-tutorial">
<title>Tutoriel</title>

<para>
</para>

</sect1>

</chapter>

<chapter id="arts-in-detail">
<title>&arts; en détail</title>

<sect1 id="architecture">
<title>Architecture</title>

<mediaobject>
<imageobject>
<imagedata fileref="arts-structure.png" format="PNG">
</imageobject>
</mediaobject>

</sect1>

<sect1 id="structures">
<title>Structures</title>
<para>
</para>
</sect1>

<sect1 id="streams">
<title>Flux</title>
<para>
</para>
</sect1>

<sect1 id="latency">
<title>Temps de latence</title>
<para>
</para>
</sect1>

<sect1 id="dynamic-nstantiation">
<title>Instanciation dynamique</title>
<para>
</para>
</sect1>

<sect1 id="busses">
<title>Bus</title>
<para>
</para>
</sect1>

<sect1 id="network-ransparency">
<title>Transparence réseau</title>
<para>
</para>
</sect1>

<sect1 id="security">
<title>Sécurité</title>
<para>
</para>
</sect1>


<sect1 id="effects">
<title>Effets et piles d'effets</title>
<para>
</para>
</sect1>


<sect1 id="trader">
<title>Sélecteur dynamique d'application (Trader)</title>
<para>
</para>
</sect1>

<sect1 id="midi-synthesis">
<title>Synthèse <acronym>MIDI</acronym></title>
<para>
</para>
</sect1>

<sect1 id="instruments">
<title>Instruments</title>
<para>
</para>
</sect1>

<sect1 id="mapped-instruments">
<title>Instruments mappés</title>
<para>
</para>
</sect1>

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

<sect1 id="full-duplex">
<title>Audio full duplex</title>
<para>
</para>
</sect1>

<sect1 id="detail-gui-elements">
<title>Éléments de l'interface graphique</title>
<para>
</para>
</sect1>

</chapter>

<chapter id="midi">
<title><acronym>MIDI</acronym></title>

<sect1 id="midi-overview">
<title>Aperçu</title>
<!-- what-to-say-here: aRts has three roles
  * moving midi events around between applications
  * abstracting the hardware
  * synthesizer -->
<para>La gestion du midi dans aRts permet de faire beaucoup de choses. Tout
d'abord, elle permet la <emphasis>communication</emphasis> entre différentes
parties d'un logiciel qui produit ou utilise des événements MIDI. Si par exemple
vous avez un séquenceur et un échantillonneur qui sont compatibles avec aRts,
aRts peut envoyer des événements MIDI du séquenceur vers l'échantillonneur.
</para>

<para>
D'un autre côté, aRts peut aussi aider des applications à <emphasis>interagir
avec le matériel</emphasis>. Si une partie d'un logiciel (par exemple
l'échantillonneur) travaille avec aRts, il sera capable de reçevoir des
événements MIDI depuis un clavier MIDI externe aussi.
</para>

<para>
Finallement, aRts constitue un <emphasis>synthétiseur modulaire</emphasis>
sympatique. Il est exactement conçu pour cela. Vous pouvez donc construire des
instruments à partir de petits modules en utilisant artsbuilder, puis ensuite
les réutiliser pour composer et jouer de la musique. Synthèse ne signifie pas
forcément synthèse pure, il y a des modules qui vous permettent de jouer des
échantillons. Arts peut donc être un échantillonneur, un synthétiseur, etc. et
étant entièrement modulaire, il est très facile de l'étendre, facile à prendre
en main, puissant et flexible.
</para>
</sect1>

<sect1 id="midi-manager">
<title>Le gestionnaire Midi</title>
<!-- what-to-say-here:
  * how to use artscontrol - view midimanager
  * what does autorestore do? (not yet implemented - so not yet documented) -->
<para>
Le composant central de aRts qui garde une trace de quelles applications sont
connectées et comment les événements midi doivent circuler entre elles est le
gestionnaire midi. Pour voir ou modifier ce qu'il fait, démarrez artscontrol.
Ensuite, choisissez <menuchoice><guilabel>Affichage</guilabel><guilabel>Voir
le gestionnaire Midi</guilabel></menuchoice> dans le menu.
</para>
<para>
Sur la gauche, vous verrez <guilabel>Entrées Midi</guilabel>. Ici, tous les
objets qui produisent des événements midi, comme un port midi externe qui envoie
des données depuis un clavier midi, un séquenceur qui joue un morceau, etc. sont
listés. Sur la droite, vous verrez <guilabel>Sorties Midi</guilabel>. Ici, vous
trouverez la liste de tous ce qui utilise les événements midi, comme un
échantillonneur logiciel, ou un port midi externe sur lequel un échantillonneur
matériel peut être connecté. Les nouvelles applications, comme les séquenceurs,
s'enregistrent toutes seules de telle sorte que cette liste est susceptible de
changer au cours du temps.
</para>
<para>
Vous pouvez connecter les entrées aux sorties si vous marquez l'entrée à droite
et la sortie à gauche, et choisissez <guilabel>Connecter...</guilabel> avec le
bouton en bas. <guilabel>Déconnecter</guilabel> fonctionne de la même manière.
Vous verrez ce qui est connecté grace à de petites lignes entre les entrées et
les sorties, au milieu de la fenêtre. Notez que vous pouvez connecter un
émetteur vers plus d'un récepteur (et vice versa).
</para>
<para>
Certains programmes (comme le séquenceur Brahms) s'ajouterons d'eux même
lorsqu'ils démarrent et seront enlevés de la liste lorsqu'ils s'arrêtent. Vous
pouvez toutefois ajouter de nouveaux items avec le menu
<guilabel>ajouter</guilabel>&nbsp;:
<variablelist>

<varlistentry>
<term><guimenuitem>Port Midi (OSS)</guimenuitem></term>
<listitem>
<para>Ceci va créer un nouvel objet aRts qui converse avec un port midi externe.
Comme les ports midi peuvent à la fois envoyer et reçevoir des données, choisir
cette option ajoutera une entrée midi et une sortie midi. Sous linux, vous
devriez avoir soit un OSS (ou OSS/Free, qui est fourni avec le noyau de linux)
ou un pilote ALSA permettant de faire fonctionner votre carte son. On vous
demandera le nom du périphérique. Habituellement, il s'agit de /dev/midi ou
/dev/midi00. Cependant, si vous avez plus d'un périphérique midi ou un pilote
midi loopback installé, vous devriez avoir plus de choix. Pour
voir les informations sur les ports midi, démarrez le centre de configuration de
KDE, et choisissez <menuchoice><guilabel>Information</guilabel>
<guilabel>Son</guilabel></menuchoice>.
</para>
</listitem>
</varlistentry>

<varlistentry>
<term><guimenuitem>Sortie Midi du synthétiseur aRts</guimenuitem></term> <listitem>
<para>Ceci va ajouter une nouvelle sortie midi avec un instrument synthétisé par
aRts. Si vous choisissez cette entrée du menu, une boîte de dialogue va
apparaître, vous permettant de choisir un instrument. Vous pouvez créer de
nouveaux instruments en utilisant artsbuilder. Tous les noms de fichiers aRts
dont le nom commençe par "instrument_" apparaitront ici.
</para>
</listitem>
</varlistentry>
</variablelist>
</para>
</sect1>

<sect1 id="brahms">
<title>Utiliser &arts; &amp; Brahms</title>
<para>
En réalité, c'est facile de débuter. Vous avez besoin d'une version de Brahms
pour KDE2.1, qui se trouve dans le module CVS kmusic. Il y a aussi des
informations sur la façon de se procurer Brahms sur le <ulink
url="http://www.arts-project.org/">site web de aRts</ulink> dans la section
Download.
</para>
<para>
Lorsque vous le démarrez, il affichera le gestionnaire midi. Si vous voulez
faire de la synthèse, ajoutez simplement un instrument midi synthétisé via
 <menuchoice><guilabel>Ajouter</guilabel><guilabel>Sortie Midi du
synthétiseur d'aRts</guilabel></menuchoice>. Choisissez un instrument (par
exemple organ2). Connectez-les en utilisant le bouton
<guilabel>Connecter...</guilabel>. Enfin, vous pouvez commencer à composer avec
Brahms, et la sortie sera synthétisée avec aRts. C'est en général une bonne idée
de laisser ouverte la fenêtre de artscontrol, afin de vérifier que le volume
n'est pas trop fort (la qualité est moins bonne lorsque les indicateurs
atteignent la limite supérieure). Maintenant, vous pouvez commencer à travailler
sur un nouveau morceau de démonstration de aRts, et lorsque c'est fait, vous
pouvez le publier sur aRts-project.org ;-).</para>
<!-- TODO: how to do more than one instrument in Brahms (hm, not implemented
     yet, not documented yet), how to use samples, mapping and so on. These
  	 things need to be implemented, too. -->
</sect1>

<sect1 id="midisend">
<title>midisend</title>
<para>
Midisend est une petite application qui vous permet d'envoyer des événements
midi en utilisant le shell. Il va s'enregistrer comme client comme toutes les
autres applications. La façon la plus simple de l'utiliser est de faire
<screen>
<prompt>&percnt;</prompt> <userinput><command>midisend</command> <option>-f</option> <option><replaceable>/dev/midi00</replaceable></option>
</userinput>
</screen>
ce qui est équivalent à ajouter un port midi système dans artscontrol (pas tout
à fait, car midisend ne fait qu'envoyer des événements). La différence est qu'il
est facile par exemple de démarrer midisend sur différents ordinateurs (et donc
d'utiliser la transparence réseau). Midisend peut aussi envoyer des données
depuis l'entrée standard (stdin), que vous pouvez utiliser pour faire un tube
avec des données ne reconnaissant pas aRts, comme suit
<screen><prompt>&percnt;</prompt> <userinput><command><replaceable>applicationwhichproducesmidieventsonstdout</replaceable></command> | <command>midisend</command> <option>-f</option> <option><replaceable>-</replaceable></option></userinput>
</screen>
<!-- TODO: document all options -->
</para>
</sect1>

<sect1 id="midi-creating-instruments">
<title>Création de nouveaux instruments</title>
<para>
A FAIRE - juste quelques notes&nbsp;:
<itemizedlist>
<listitem><para>un instrument est une structure</para></listitem>
<listitem><para>il a besoin de trois entrées (audio), frequency, velocity et
pressed, où pressed vaut 1 si la touche est toujours enfoncée
</para></listitem>
<listitem><para>il a trois sorties (audio), left, right et done, où done passe à
1 dès que le son est terminé, 0 sinon (les enveloppes adsr sont un moyen d'y
parvenir)</para></listitem>
<listitem><para>
chaque fois qu'un événement noteOn arrive, une nouvelle structure midi pour ce
nouveau son est créée
</para></listitem>
<listitem><para>
Ouvrez un instrument existant avec
<menuchoice><guilabel>Fichier</guilabel><guilabel>ouvrir un
exemple</guilabel></menuchoice> pour voir comment ça marche ;)</para></listitem>
</itemizedlist>
</para>
</sect1>

<!-- TODO: Maybe helpful
 * using an external keyboard
 * midi maps (not implemented yet)
 * loopback midi device

<sect1 id="quick-start">
<title>Quick Start</title>
<para>
</para>
</sect1>

<sect1 id="internal-details">
<title>More Internal Details</title>
<para>
</para>
</sect1>

<sect1 id="other-considerations">
<title>Other Considerations</title>
<para>
</para>
</sect1>
-->

</chapter>

<chapter id="gui-elements">
<title>Éléments de l'interface graphique</title>

<sect1 id="gui-introduction">
<title>Introduction</title>
<para>
</para>
</sect1>

<sect1 id="parents">
<title>Parents</title>
<para>

</para>
</sect1>

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

</chapter>


<chapter id="mcop">
<title>MCOP&nbsp;: modèle object et streaming</title>

<sect1 id="mcop-overview">

<title>Aperçu</title>

<para><acronym>MCOP</acronym> est utilisé dans &arts; pour&nbsp;: </para>

<itemizedlist>
<listitem><para>la communication entre objets</para></listitem>
<listitem><para>la transparence réseau</para></listitem>
<listitem><para>décrire les interfaces objet</para></listitem>
<listitem><para>l'indépendance du langage</para></listitem>
</itemizedlist>

<para>Un aspect majeur de <acronym>MCOP</acronym> est l'<emphasis>interface
description language</emphasis>, <acronym>IDL</acronym>, dans laquelle les
interfaces de &arts; et les <acronym>API</acronym> sont définies dans un langage
indépendant. Pour utiliser les interfaces IDL avec C++, le code IDL est compilé
par le compilateur <acronym>IDL</acronym> en code C++. Lorsque vous implantez
une interface, vous dérivez à partir de la classe squelette que le
compilateur <acronym>IDL</acronym> a généré. Lorsque vous utilisez une
interface, vous utilisez ainsi un wrapper. De cette façon,
<acronym>MCOP</acronym> peut utiliser un protocole si l'objet auquel vous vous
adressez n'est pas local - vous bénéficiez de la transparence réseau.</para>

<para>Ce chapitre est supposé décrire les caractéristiques de base du modèle
objet qui résulte de l'utilisation de <acronym>MCOP</acronym>, le protocole,
comment utiliser <acronym>MCOP</acronym> en C++ (language binding),
etc.</para>

</sect1>

<sect1 id="interfaces">

<title>Interfaces et <acronym>IDL</acronym></title>

<para> </para>

</sect1>

<sect1 id="attribute-change-notify">
<title>notifications de changement d'attribut</title>

<!-- TODO: This should be embedded better into the context - I mean: the context
 should be written ;-). -->

<para>Les notifications de changement d'attribut sont un moyen de savoir
lorsqu'un attribut a changé. C'est un peu semblable aux signaux et slots de
&Qt;'s ou Gtk. Par exemple, si vous avez un élément d'interface graphique, une
glissière, qui sélectionne un nombre entre 0 et 100, vous avez certainement un
objet qui fait quelque chose avec ce nombre (par exemple, ce peut être
contrôler le volume d'un signal audio). Donc vous voudrez que chaque fois que la
glissière change de position, l'objet qui gère le volume soit mis au courant.
Une connexion entre un émetteur et un récepteur.</para>

<para><acronym>MCOP</acronym> gère cela en fournissant des notifications lorsque
des attributs changent. Tout ce qui est déclaré comme <quote>attribut</quote>
dans l'<acronym>IDL</acronym> peut émettre de telles notifications de
changement, et devrait le faire chaque fois qu'il est modifié. Tout ce qui est
déclaré comme <quote>attribut</quote> peut aussi reçevoir de telles
notifications de changement. Donc par exemple si vous avez deux interfaces
<acronym>IDL</acronym>, comme celles-ci&nbsp;: </para>

<programlisting>
 interface Slider {
         attribute long min,max;
         attribute long position;
 };
 interface VolumeControl : Arts::StereoEffect {
     attribute long volume; // 0..100
 };
</programlisting>

<para>Vous pouvez les connecter en utilisant les notifications de changement.
Il utilise les opérations habituelles de connexion d'événements" . Dans ce
cas, le code C++ pour connecter deux objets ressemblerait à ceci&nbsp;: </para>

<programlisting>
#include &lt;connect.h&gt;
using namespace Arts;
[...]
connect(slider,"position_changed",volumeControl,"volume");
</programlisting>

<para>Comme vous pouvez le voir, chaque attribut offre deux flux,
un pour envoyer cette notification de changement, appelé
<function><replaceable>attributename</replaceable>_changed</function>,

<!-- TODO - how do I markup code that is an example - you wouldn't write
 attributename in the source, but the name of some attribute

 LW: I'm guessing
 here, because I know how to markup QT code, but your stuff is different.
 Hopefully this will give you inspiration, and we can work out later the fine
 tuning if I have it wrong.  The line above in the code sample, if it were qt
 stuff, I would mark up this way (linebreaks for clarity of markup only, yes I
 know it's incorrect!):

 <function>connect(<classname>slider</classname>,
 <function><replaceable>position</replaceable>_changed</function>,
 <classname>volumeControl</classname>,
 <function>volume</function>);</function>

 You can use <function><replaceable>attributename</function> and even
 <function><replaceable>attributename</replaceable>_changed</function>.

 If I have the above totally wrong (which is entirely possible!) Some other
 elements you might find handy:

 <varname>, <type>, <returnvalue>, <constant>, <methodname>
  There's also a markup guide at http://madmax.atconnex.net/kde/ that might
  help, although unfortunately the programming section is still incomplete. -->

et un pour reçevoir les notifications de changement, appelé
<function>attributename</function>.</para>

<para>Il est important de savoir que ces notifications de changement et
flux asynchrones sont compatibles. Ils sont aussi transparents
vis-à-vis du réseau. Vous pouvez donc connecter une notification de changement
d'un attribut de type flottant d'un widget de l'interface à un
flux asynchrone d'un module de synthèse exécuté sur un autre
ordinateur. Ceci implique bien sûr que les notifications de changement ne soient
pas <emphasis>synchrones</emphasis>, ceci signifie qu'après avoir envoyé une
notification de changement, il faut un certain temps avant qu'elle soit
réellement reçue.</para>

<sect2 id="sending-change-notifications">

<title>Envoi de notifications de changement</title>

<para>Lorsque vous implantez des objets qui ont des attributs, vous devez
envoyer des notifications de changement chaque fois qu'un attribut est modifié.
Le code correspondant ressemble à ceci&nbsp;: </para>

<programlisting>
 void KPoti_impl::value(float newValue)
 {
     if(newValue != _value)
     {
         _value = newValue;
         value_changed(newValue); // <- send change notification
     }
 }
</programlisting>
 
<para>Il est fortement recommandé d'utiliser ce genre de code pour tous les
objets que vous implantez, de façon à ce que les notifications de changement
puissent être réutilisées par d'autres personnes.  Il est préférable d'éviter d'envoyer des notifications trop
fréquemment. Ainsi, si vous faites du traitement du signal, il est
surement mieux de mémoriser les dernières notifications envoyées, afin
de ne pas en envoyer une avec chaque échantillon traité.</para>

</sect2>

<sect2 id="change-notifications-apps">

<title>Applications pour les notifications de changement</title>

<para>Il est tout particulièrement intéressant d'utiliser les notifications de
changement en conjonction avec des oscilloscopes (pour visualiser les données
audio par exemple), éléments de l'interface, widgets de contrôle, et monitoring.
Le code pour utiliser ceci se trouve dans kdelibs/arts/tests, et dans
l'implantation expérimentale de artsgui, que vous pouvez trouver dans <filename
class="directory">kdemultimedia/arts/gui</filename>.</para>

<!-- TODO: can I markup links into the source code - if yes, how? -->

<!-- LW: Linking into the source is problematic - we can't assume people are
reading this on a machine with the sources available, or that they aren't
reading it from a website. We're working on it! -->

</sect2>

</sect1>
</chapter>

<chapter id="arts-apis">
<title>&arts; Application Programming Interfaces</title>

<sect1 id="api-overview">
<title>Overview</title>
<para>
aRts is not only a piece of software, it also provides a variety of APIs
for a variety of purposes. In this section, I will try to describe the "big
picture", a brief glance what those APIs are supposed to do, and how they
interact.
</para>

<para>
There is one important distinction to make: most of the APIs are <emphasis>
language and location independant</emphasis> because they are specified as
<emphasis>mcopidl</emphasis>.
That is, you can basically use the services they offer from any language,
implement them in any language, and you will not have to care whether you
are talking to local or remote objects. Here is a list of these first:
</para>


<variablelist>
<!-- --------------------------------------------------------------------- -->
<varlistentry>
<term>core.idl</term>

  <listitem><para>
  Basic definitions that form the core of the MCOP functionality, such as
  the protocol itself, definitions of the object, the trader, the flow
  system and so on.
  </para></listitem>

</varlistentry>

<varlistentry>
<term>artsflow.idl</term>

  <listitem><para>
  These contain the flow system you will use for connecting audio streams, the
  definition of <emphasis>Arts::SynthModule</emphasis> which is the base for
  any interface that has streams, and finally a few useful audio objects
  </para></listitem>

</varlistentry>

<varlistentry>
<term>kmedia2.idl</term>

  <listitem><para>
  Here, an object that can play a media, <emphasis>Arts::PlayObject</emphasis>
  gets defined. Media players such as the KDE media player noatun will be able
  to play any media for which a PlayObject can be found. So it makes sense to
  implement PlayObjects for various formats (such as mp3, mpg video, midi, wav,
  ...) on that base, and there are a lot already.
  </para></listitem>

</varlistentry>

<varlistentry>
<term>soundserver.idl</term>

  <listitem><para>
  Here, an interface for the system wide sound server artsd is defined. The
  interface is called <emphasis>Arts::SoundServer</emphasis>, which implements
  functionality like accepting streams from the network, playing samples,
  creating custom other aRts objects and so on. Network transparency is
  implied due to the use of MCOP (as for everything else here).
  </para></listitem>

</varlistentry>

<varlistentry>
<term>artsbuilder.idl</term>

  <listitem><para>
  This module defines basic flow graph functionality, that is, combining
  simpler objects to more complex ones, by defining a graph of them. It defines
  the basic interface <emphasis>Arts::StructureDesc</emphasis>,
  <emphasis>Arts::ModuleDesc</emphasis> and <emphasis>Arts::PortDesc</emphasis>
  which contain a description of a structure, module, and port. There is also
  a way to get a "living network of objects" out of these connection and value
  descriptions, using a factory.
  </para></listitem>

</varlistentry>

<varlistentry>
<term>artsmidi.idl</term>

  <listitem><para>
  This module defines basic midi functionality, like objects that produce
  midi events, what is a midi event, an <emphasis>Arts::MidiManager</emphasis>
  to connect the producers and consumers of midi events, and so on. As always
  network transparency implied.
  </para></listitem>

</varlistentry>

<varlistentry>
<term>artsmodules.idl</term>

  <listitem><para>
  Here are various additional filters, oscillators, effects, delays and
  so on, everything required for real useful signal processing, and to
  build complex instruments and effects out of these basic building blocks.
  </para></listitem>

</varlistentry>

<varlistentry>
<term>artsgui.idl</term>

  <listitem><para>
  This cares about visual objects. It defines the basic type <emphasis>
  Arts::Widget</emphasis> from which all GUI modules derive. This will produce
  toolkit independency, and ... visual GUI editing, and serializable GUIs.
  Also, as the GUI elements have normal attributes, their values can be
  straight forward connected to some signal processing modules. (I.e. the
  value of a slider to the cutoff of a filter). As always: network transparent.
  </para></listitem>

</varlistentry>

</variablelist>

<para>
Where possible, aRts itself is implemented using IDL. On the other hand, there
are some <emphasis>language specific</emphasis> APIs, using either plain C++ or
plain C. It is usually wise to use IDL interfaces where possible, and the
other APIs where necessary. Here is a list of language specific APIs:
</para>

<variablelist>

<varlistentry>
<term>KNotify, KAudioPlayer (included in libkdecore)</term>

  <listitem><para>
  These are convenience KDE APIs for the simple and common common case, where
  you just want to play a sample. The APIs are plain C++, Qt/KDE optimized,
  and as easy as it can get.
  </para></listitem>

</varlistentry>

<varlistentry>
<term>libartsc</term>

  <listitem><para>
  Plain C interface for the sound server. Very useful for porting legacy
  applications.
  </para></listitem>

</varlistentry>

<varlistentry>
<term>libmcop</term>

  <listitem><para>
  Here all magic for MCOP happens. The library contains the basic things you
  need to know for writing a simple MCOP application, the dispatcher, timers,
  iomanagement, but also the internals to make the MCOP protocol itself work.
  </para></listitem>

</varlistentry>

<varlistentry>
<term>libartsflow</term>

  <listitem><para>
  Besides the implementation of artsflow.idl, some useful utilities like
  sampling rate conversion.
  </para></listitem>

</varlistentry>

<varlistentry>
<term>libqiomanager</term>

  <listitem><para>
  Integration of MCOP into the Qt event loop, when you write Qt applications
  using MCOP.
  </para></listitem>

</varlistentry>

</variablelist>


</sect1>
<sect1 id="knotify">
<title>knotify</title>
<para>
</para>
</sect1>

<sect1 id="kaudioplayer">
<title>kaudioplayer</title>
<para>
</para>
</sect1>

<sect1 id="libkmid">
<title>libkmid</title>
<para>
</para>
</sect1>

<sect1 id="kmedia2">
<title>kmedia2</title>
<para>
</para>
</sect1>

<sect1 id="soundserver">
<title>sound server</title>
<para>
</para>
</sect1>

<sect1 id="artsflow">
<title>artsflow</title>
<para>
</para>
</sect1>

<sect1 id="capi">
<title>C <acronym>API</acronym></title>

<sect2 id="capiintro">
<title>Introduction</title>

<para> The &arts; C <acronym>API</acronym> was designed to make it easy to
writing and port plain C applications to the &arts; sound server. It provides
streaming functionality (sending sample streams to
<application>artsd</application>), either blocking or non-blocking. For most
applications you simply remove the few system calls that deal with your audio
device and replace them with the appropriate &arts; calls.</para>

<para>I did two ports as a proof of concept: <application>mpg123</application>
and <application>quake</application>. You can get the patches from <ulink
url="http://space.twc.de/~stefan/kde/download/artsc-patches.tar.gz">here</ulink>.
Feel free to submit your own patches to the maintainer of &arts; or of
multimedia software packages so that they can integrate &arts; support into
their code.</para>

</sect2>

<sect2 id="capiwalkthru">
<title>Quick Walkthrough</title>

<para>Sending audio to the sound server with the <acronym>API</acronym> is very
simple:</para>

<procedure>
<step><para>include the header file using <userinput>#include
&lt;artsc.h&gt;</userinput></para></step>
<step><para>initialize the <acronym>API</acronym> with
<function>arts_init()</function></para></step>
<step><para>create a stream with
<function>arts_play_stream()</function></para></step>
<step><para>configure specific parameters with
<function>arts_stream_set()</function></para></step>
<step><para>write sampling data to the stream with
<function>arts_write()</function></para></step>
<step><para>close the stream with
<function>arts_close_stream()</function></para></step>
<step><para>free the <acronym>API</acronym> with
<function>arts_free()</function></para></step>
</procedure>

<para>Here is a small example program that illustrates this:</para>

<programlisting>
#include &lt;stdio.h&gt;
#include &lt;artsc.h&gt;

int main()
{
    arts_stream_t stream;
    char buffer[8192];
    int bytes;
    int errorcode;

    errorcode = arts_init();
    if (errorcode &lt; 0)
    {
        fprintf(stderr, "arts_init error: %s\n", arts_error_text(errorcode));
        return 1;
    }

    stream = arts_play_stream(44100, 16, 2, "artsctest");

    while((bytes = fread(buffer, 1, 8192, stdin)) &gt; 0)
    {
        errorcode = arts_write(stream, buffer, bytes);
        if(errorcode &lt; 0)
        {
            fprintf(stderr, "arts_write error: %s\n", arts_error_text(errorcode));
            return 1;
        }
    }

    arts_close_stream(stream);
    arts_free();

    return 0;
}
</programlisting>

</sect2>

<sect2 id="capiartscconfig">
<title>Compiling and Linking: <application>artsc-config</application></title>

<para>To easily compile and link programs using the &arts; C
<acronym>API</acronym>, the <application>artsc-config</application> utility is
provided which knows which libraries you need to link and where the includes
are. It is called using</para>

<screen>
<userinput><command>artsc-config</command> <option>--libs</option></userinput>
</screen>

<para>to find out the libraries and </para>

<screen>
<userinput><command>artsc-config</command> <option>--cflags</option></userinput>
</screen>

<para>to find out additional C compiler flags. The example above could have been
compiled using the command line:</para>

<screen>
<userinput><command>cc</command>
<option>-o artsctest artsctest.c `artsc-config --cflags` `artsc-config --libs`</option></userinput>

<userinput><command>cc</command>
<option>-o artsctest</option>
<option>artsctest.c</option>
<option>`artsc-config --cflags`</option> <option>`artsc-config --libs`</option></userinput>
</screen>

</sect2>

<sect2 id="c-api-reference">
<title>Library Reference</title>

<para>
[TODO: generate the documentation for artsc.h using kdoc]
</para>

</sect2>

</sect1>

</chapter>

<chapter id="arts-modules">
<title>Modules de &arts;</title>

<sect1 id="modules-introduction">
<title>Introduction</title>
<para>
</para>
</sect1>

<sect1 id="synth-modules-reference">
<title>Manuel de référence des modules de synthèse</title>
<para>
</para>

<sect2 id="mcat-synth-arithmetic-mixing">
<title>Arithmétique + Mixage</title>
<para>
</para>

<sect3 id="mref-synth-add">
<title>Synth&lowbar;ADD</title>

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

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

<sect3 id="mref-synth-mul">
<title>Synth&lowbar;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>
</sect3>

<sect3 id="mref-synth-multi-add">
<title>Synth&lowbar;MULTI&lowbar;ADD</title>

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

<para>Ajoute un nombre arbitraire de signaux. Si vous devez effectuer la somme
des formes d'ondes produites par quatre oscillateurs différents, vous pouvez par
exemple connecter toutes leurs sorties à un module
Synth&lowbar;MULTI&lowbar;ADD. C'est plus efficace que d'utiliser trois modules
Synth&lowbar;ADD.</para>
</sect3>

<sect3 id="mref-synth-xfade">
<title>Synth&lowbar;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 ont 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>
</sect3>

<sect3 id="mref-synth-autopanner">
<title>Synth&lowbar;AUTOPANNER</title>

<para>Il prend un signal mono et crée un signal stéréo&nbsp;: ceci est utilisé pour régler automatiquement
la panoramique du signal d'entrée entre les sorties droite et gauche. 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&nbsp;: oscillateur basse
fréquence), une onde sinusoïdale ou en dents de scie par exemple au port
<quote>inlfo</quote> 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>
</sect3>


</sect2>

<sect2 id="mcat-synth-busses">
<title>Bus</title>
<para>
</para>

<sect3 id="mref-synth-bus-uplink">
<title>Synth&lowbar;BUS&lowbar;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 apparaitra sur chaque downlink
sur ce "bus".</para>
</sect3>

<sect3 id="mref-synth-bus-downlink">
<title>Synth&lowbar;BUS&lowbar;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").</para>
</sect3>

</sect2>

<!-- TODO AFTER KDE2.1: move freeverb into delays, and rename category to
     Delays & reverbs -->

<sect2 id="mcat-synth-delays">
<title>Délais</title>
<para>
</para>

<sect3 id="mref-synth-delay">
<title>Synth&lowbar;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 1 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 CDELAY 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>
</sect3>

<sect3 id="mref-synth-cdelay">
<title>Synth&lowbar;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&lowbar;DELAY).</para>
</sect3>

</sect2>

<sect2 id="mcat-synth-envelopes">
<title>Enveloppes</title>
<para>
</para>

<sect3 id="mref-synth-envelope-adsr">
<title>Synth&lowbar;ENVELOPE&lowbar;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&nbsp;:
<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 ceci pour fournir la sortie "done" d'un instrument (qui
entraînera la suppression de la structure par le routeur midi une fois que la
phase <quote>release</quote> est terminée).</para>
</sect3>

<sect3 id="mref-synth-pscale">
<title>Synth&lowbar;PSCALE</title>

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

<para>Le module Synth&lowbar;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&lowbar;SEQUENCE). La position où le pic survient est donnée par le
paramètre pos.</para>

<para>Exemple&nbsp;:
placer le maximum à 0.1 signifie que lorsque 10&percnt; de la note ont été
joués, le volume a atteind son maximum, et commence à diminuer.</para>
</sect3>


</sect2>

<sect2 id="mcat-synth-effects">
<title>Effets</title>
<para>
</para>

<sect3 id="mref-synth-freeverb">
<title>Synth&lowbar;FREEVERB</title>

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

<para>C'est un effet de réverbération. Dans l'implantation actuelle, il est
conçu pour passer un signal stéréo dans la réverbération, et il ajoute le signal
réverbéré au signal initial (note&nbsp;: ceci signifie qu'il peut aussi être
utilisé dans un StereoEffectStack). Le signal d'entrée doit être connecté à
(inleft,inright), le signal de sortie se trouve sur (outleft, outright).
</para>

<para>
Les paramètres de configuration sont&nbsp;:
<variablelist>
<varlistentry>
<term>roomsize</term>
<listitem>
<para>Taille de la pièce simulée par la réverbération (plage&nbsp;: 0..1 où 1
est la plus grande pièce possible)</para>
</listitem>
</varlistentry>
<varlistentry>
<term>damp</term>
<listitem>
<para>Ceci spécifie un filtre qui simule l'absorption des hautes fréquences par
la pièce (plage&nbsp;: 0..1, où 1 correspond à une absorption des hautes
fréquences plutôt agressive)</para>
</listitem>
</varlistentry>
<varlistentry>
<term>wet</term>
<listitem>
<para>quantité de sigal réverbéré (c'est-à-dire la quantité de signal qui
devrait être modifié par les filtres, résultant en un "son réverbéré"</para>
</listitem>
</varlistentry>
<varlistentry>
<term>dry</term>
<listitem>
<para>quantité de signal pur transmis, résultant d'un écho (ou délai combiné)
plutôt que d'un effet de révebération (plage&nbsp;: 0..1)</para>
<!-- TODO: do some measurements to show that this documentation -is- correct,
I am not sure if it is echo, or really pure (non-delayed), or multiple delay
or whatever -->
</listitem>
</varlistentry>
<varlistentry>
<term>width</term>
<listitem>
<para>quantité de magie stéréo que l'algorithme de réverbération ajoute à
l'effet, rendant le son réverbéré plus ample dans l'espace stéréo (plage&nbsp;:
0..1)</para>
</listitem>
</varlistentry>
<varlistentry>
<term>mode</term>
<listitem>
<para>[ TODO: I think if mode is 1, the reverb holds the current image of the
sound, whereas 0 is normal operation ]</para>
</listitem>
</varlistentry>
</variablelist>
</para>
</sect3>

<sect3 id="mref-synth-tremolo">
<title>Synth&lowbar;TREMOLO</title>

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

<para>Il module l'amplitude du son avec un LFO. En général, vous utilisez une
onde sinusoïdale, mais pourquoi vous limiter à ça&nbsp;? Vous obtenez un effet intense
qui  ressort des arrangements à cause de sa dynamique élevée.
L'effet de trémolo est toujours un des effets préférés des guitaristes, bien
qu'il ne soit pas aussi populaire que dans les années 60.
</para>

<para>
[ TODO: currently this is implemented as invalue + abs(inlfo) - maybe it would
make more sense to implement it as invalue * (1+inlfo*depth), where depth
would be a parameter between 0..1 - decide this after KDE2.1 ; if you have
a comment, send a mail to the aRts list ;). ]
</para>

</sect3>

<sect3 id="mref-synth-fx-cflanger">
<title>Synth&lowbar;FX&lowbar;CFLANGER</title>

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

<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&nbsp;:
<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&nbsp;: essayez quelque chose comme 1 ms. 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&nbsp;: essayez quelque chose comme 5 ms.
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&nbsp;: vous pouvez l'utilisez comme base pour un effet de chorus.
</para>
</sect3>

</sect2>

<sect2 id="mcat-synth-filters">
<title>Filtres</title>
<para>
</para>

<sect3 id="mref-synth-pitch-shift">
<title>Synth&lowbar;PITCH&lowbar;SHIFT</title>

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

<para>L'effet de pitch modifie la fréquence du signal d'entrée sans en modifier
la vitesse. Par exemple, vous pouvez changer la hauteur de votre voix lors de
l'enregistrement (et lors de la lecture) en temps réel.</para>

<para>Le paramètre <emphasis>vitesse</emphasis> est la vitesse relative avec
laquelle le signal sera rejoué. Une vitesse de deux rend le son deux fois plus
haut (par exemple, une fréquence d'entrée de 440 Hz résultera en une sortie à
880 Hz).</para>

<para>Le paramètre <emphasis>fréquence</emphasis> est utilisé de manière
interne pour changer le grain du signal. Il est accordable, et selon votre
choix, le changement de hauteur semblera plus ou moins réaliste. Une bonne
valeur de départ est quelque chose comme 5 ou 10.</para>

</sect3>

<sect3 id="mref-synth-shelve-cutoff">
<title>Synth&lowbar;SHELVE&lowbar;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>
</sect3>

<sect3 id="mref-synth-brickwall-limiter">
<title>Synth&lowbar;BRICKWALL&lowbar;LIMITER</title>

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

<para>Ce module écrète un signal pour le faire entrer dans la plage [-1;1]. Il
ne fait rien pour éviter les distorsions dues à l'écrètage de signaux trop
forts. Vous pouvez l'utiliser comme effet (par exemple pour créer une onde
sinusoïdale un peu écrétée). Cependant, il est préférable d'envoyer ensuite le
signal dans un filtre passe-bas pour rendre le son moins agressif.</para>
</sect3>

<sect3 id="mref-synth-std-equalizer">
<title>Synth&lowbar;STD&lowbar;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>
</sect3>

<sect3 id="mref-synth-rc">
<title>Synth&lowbar;RC</title>

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

<para>Filtre résonant amorti&nbsp;: 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&nbsp;:
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>
</sect3>

<sect3 id="mref-synth-moog-vcf">
<title>Synth&lowbar;MOOG&lowbar;VCF</title>

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

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

</sect2>

<sect2 id="mcat-synth-midi-sequencing">
<title>Midi + Séquenceur</title>
<para>
</para>

<sect3 id="mref-synth-midi-test">
<title>Synth&lowbar;MIDI&lowbar;TEST</title>

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

<para>Ce module charge une structure d'instrument depuis un fichier, et
s'enregistre comme sortie midi après du gestionnaire midi de aRts. Les notes
envoyées vers cette sortie entraineront la création de voix avec cet instrument.
Note&nbsp;: vous pouvez faire la même chose mais de manière beaucoup plus
facilement dans artscontrol que manuellement dans artsbuilber.</para>
</sect3>

<sect3 id="mref-synth-sequence">
<title>Synth&lowbar;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&nbsp;: 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&nbsp;;)</para>

<para>Le module Synth&lowbar;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&lowbar;PSCALE (voir
plus bas).</para>
</sect3>

</sect2>

<sect2 id="mcat-synth-samples">
<title>Échantillons</title>
<para>
</para>

<sect3 id="synthplaywav">
<title>Synth&lowbar;PLAY&lowbar;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. 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 "finished"
passera alors à 1. Le paramètre "speed" est utilisé pour jouer le fichier plus
ou moins vite, où 1.0 est la vitesse normale.</para>
<!-- TODO: KDE2.2: check that this really works together in instruments with
the done parameter things ;) -->
</sect3>

</sect2>

<sect2 id="mcat-synth-soundio">
<title>Entrées/sorties son</title>
<para>
</para>

<sect3 id="mref-synth-play">
<title>Synth&lowbar;PLAY</title>

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

<para><emphasis>Vous n'aurez normalement pas besoin de ce module, tant que vous
écrivez des applications autonomes. Dans artsd, il y a normalement déjà un
module Synth&lowbar;PLAY, et en créer un nouveau ne fonctionnera
pas.</emphasis>.</para>

<para>Le module Synth&lowbar;PLAY dirige vos données audio vers la carte son.
Les canaux droit et gauche devraient contenir les entrées
<emphasis>normalisées</emphasis>. Si votre entrée n'est pas entre -1 et 1, le
signal sera écrété.</para>

<para>Comme mentionné précédemment, on ne peut utiliser qu'un module
Synth&lowbar;PLAY, puisqu'il accède directement à la carte son. Utilisez des bus
si vous voulez mélanger plusieurs sources audio avant de les jouer. Utilisez un
module Synth&lowbar;AMAN&lowbar;PLAY pour obtenir une sortie dans artsd.</para>

<para>Notez que Synth&lowbar;PLAY joue aussi le rôle de référence temporelle
pour toute la structure. Cela signifie&nbsp;: pas de module Synth&lowbar;PLAY =
pas de référence temporelle = pas de son. Vous avez donc besoin d'(exactement)
un objet Synth&lowbar;PLAY.</para>
</sect3>

<sect3 id="mref-synth-record">
<title>Synth&lowbar;RECORD</title>

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

<para><emphasis>Vous n'aurez normalement pas besoin de ce module, tant que vous
écrivez des applications autonomes. Dans artsd, il y a normalement déjà un
module Synth&lowbar;RECORD, et en créer un nouveau ne fonctionnera
pas.</emphasis>.</para>

<para>Le module Synth&lowbar;RECORD enregistre un signal depuis la carte son.
Les canaux droit et gauche devraient contenir l'entrée pour les canaux (entre -1
et 1).</para>

<para>Comme mentionné précédemment, on ne peut utiliser qu'un module
Synth&lowbar;RECORD, puisqu'il accède directement à la carte son. Utilisez des
bus si vous voulez enregistrer plusieurs sources audio.
Utilisez un module Synth&lowbar;AMAN&lowbar;RECORD pour obtenir une entrée dans
artsd. Pour que ça fonctionne, artsd doit fonctionner en mode <emphasis>full
duplex</emphasis></para>
</sect3>

<sect3 id="mref-synth-aman-play">
<title>Synth&lowbar;AMAN&lowbar;PLAY</title>

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

<para>Le module Synth&lowbar;AMAN&lowbar;PLAY constitue une sortie audio.
Il est préférable (mais pas obligatoire) que votre sortie soit normalisée (entre -1 et 1).
</para>

<para>Ce module utilise le gestionnaire audio pour déterminer où le signal sera
joué. Le gestionnaire audio peut être contrôlé depuis artscontrol. Pour le
rendre encore plus intuitif à utiliser, il est préférable de donner un nom au
signal. Vous pouvez le faire avec <emphasis>title</emphasis>. Une autre
caractéristique du gestionnaire audio est qu'il se souvient où a été joué un
signal pour la dernière fois. Pour cela, il doit pouvoir distinguer les
signaux. C'est pourquoi vous devez aussi assigner quelque chose d'unique à
<emphasis>autoRestoreID</emphasis>.</para>
</sect3>

<sect3 id="mref-synth-aman-record">
<title>Synth&lowbar;AMAN&lowbar;RECORD</title>

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

<para>Le module Synth&lowbar;AMAN&lowbar;RECORD enregistre le signal audio
depuis une source extérieure (ligne/microphone) à travers artsd. La sortie est
normalisée (entre -1 et 1).</para>

<para>Ce module utilise le gesionnaire audio pour déterminer où le signal sera
joué. Le gestionnaire audio peut être contrôlé depuis artscontrol. Pour le
rendre encore plus intuitif à utiliser, il est préférable de donner un nom au
signal enregistré. Vous pouvez le faire avec <emphasis>title</emphasis>. Une
autre caractéristique du gestionnaire audio est qu'il se souvient où a été
enregistré un signal pour la dernière fois. Pour cela, il doit pouvoir
distinguer les signaux. C'est pourquoi vous devez aussi assigner quelque chose
d'unique à <emphasis>autoRestoreID</emphasis>.</para>

</sect3>

<sect3 id="mref-synth-capture">
<title>Synth&lowbar;CAPTURE</title>

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

<para>Le module Synth&lowbar;CAPTURE enregistre un signal audio dans un fichier.
Le fichier s'appelera toujours
/tmp/mcop-<replaceable>usename</replaceable>/capture.wav</para>
</sect3>

</sect2>

<sect2 id="mcat-synth-tests">
<title>Tests</title>
<para>
</para>

<sect3 id="mref-synth-nil">
<title>Synth&lowbar;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>
</sect3>

<sect3 id="mref-synth-debug">
<title>Synth&lowbar;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>
</sect3>

<sect3 id="mref-synth-midi-debug">
<title>Synth&lowbar;MIDI&lowbar;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&lowbar;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&lowbar;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.
[ TODO: this does not work currently, make it work, and do it via midi manager
].</para>

</sect3>

<sect3 id="mref-synth-data">
<title>Synth&lowbar;DATA</title>

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

<para>Crée un signal avec une valeur constante.</para>
<!-- TODO: this doesn't really belong in test, does it? -->
</sect3>
</sect2>

<sect2 id="mcat-synth-osc-mod">
<title>Oscillateurs et Modulation</title>
<para>
</para>
<sect3 id="mref-synth-frequency">
<title>Synth&lowbar;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&lowbar;WAVE&lowbar;SIN standard sur la plage 0..2*pi.
Pour générer un signal oscillant à partir d'une fréquence, un module
Synth&lowbar;FREQUENCY est utilisé.</para>
</sect3>


<sect3 id="mref-synth-fm-source">
<title>Synth&lowbar;FM&lowbar;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&lowbar;FM&lowbar;SOURCE (vous devez
le relier à un oscillateur puisqu'il ne joue que le rôle d'un module
Synth&lowbar;FREQUENCY) et d'un autre signal pour obtenir de bons résultats.
</para>

<para>Ça fonctionnne bien en combinaison avec des oscillateurs
Synth&lowbar;WAVE&lowbar;SIN.</para>

</sect3>

</sect2>

<sect2 id="mcat-synth-waveforms">
<title>Formes d'ondes</title>
<para>
</para>

<sect3 id="mref-synth-wave-sin">
<title>Synth&lowbar;WAVE&lowbar;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&lowbar;FREQUENCY ou Synth&lowbar;FM&lowbar;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>
</sect3>

<sect3 id="mref-synth-wave-tri">
<title>Synth&lowbar;WAVE&lowbar;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&lowbar;FREQUENCY ou Synth&lowbar;FM&lowbar;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>
</sect3>

<sect3 id="mref-synth-noise">
<title>Synth&lowbar;NOISE</title>

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

<para>Générateur de bruit. Génère un signal aléatoire entre -1 et 1.</para>
</sect3>


<sect3 id="mref-synth-wave-square">
<title>Synth&lowbar;WAVE&lowbar;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&lowbar;FREQUENCY ou Synth&lowbar;FM&lowbar;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>
</sect3>

<sect3 id="mref-synth-wave-softsaw">
<title>Synth&lowbar;WAVE&lowbar;SOFTSAW</title>

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

<para>Oscillateur dents de scie adoucies, similaire à l'oscillateur
Synth&lowbar;WAVE&lowbar;TRI. Envoyez un signal "pos" d'un module
Synth&lowbar;FREQUENCY ou Synth&lowbar;FM&lowbar;SOURCE en entrée. Vous
obtiendrez une onde en forme de dents de scies adoucies. 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>
</sect3>

<sect3 id="mref-synth-wave-pulse">
<title>Synth&lowbar;WAVE&lowbar;PULSE</title>

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

<para>Oscillateur générant un signal de type impulsion - ce module est semblable
dans l'esprit à l'oscillateur rectangulaire (Synth&lowbar;WAVE&lowbar;RECT),
mais il permet de configurer le rapport haut/bas, grâce au paramètre
<emphasis>dutycycle</emphasis> (rapport cyclique). Envoyez un signal "pos" d'un module
Synth&lowbar;FREQUENCY ou Synth&lowbar;FM&lowbar;SOURCE en entrée. Vous
obtiendrez une onde en forme d'impulsions carrées. 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>
</sect3>
</sect2>
</sect1>

<sect1 id="visual-modules-reference">
<title>Manuel de référence des modules d'interface</title>
<para>
TODO when visual modules are more "finished".
</para>
</sect1>

</chapter>

<chapter id="porting">
<title>Portage d'applications vers &arts;</title>

<sect1 id="using-artsdsp">
<title>En utilisant <application>artsdsp</application></title>
<para>
</para>
</sect1>

<sect1 id="adding-native-arts-support">
<title>Ajout du support natif de &arts;</title>
<para>
</para>
</sect1>

</chapter>

<chapter id="contributing">
<title>Contribuer à &arts;</title>

<sect1 id="how-to-help">
<title>Comment nous aider</title>

<para>Le projet &arts; peut profiter de l'aide de développeurs pour rendre les
applications multimédia existantes compatibles avec &arts;, pour écrire de
nouvelles applications multimédia, et pour améliorer les fonctionnalités de
&arts;. Cependant, vous pouvez contribuer sans être développeur. Nous avons
besoin de l'aide de testeurs qui nous soumettent des rapports de bogue, de
traducteurs pour l'application et la documentation dans d'autres langues (NdT
n'hésitez pas à me contacter pour me donner un coup de main ;o), d'artistes pour
réaliser les graphismes (particulièrement pour les modules de
<application>artsbuilder</application>), de musiciens pour créer de nouveaux
modules pour &arts;, et de rédacteurs pour écrire ou améliorer la documentation.
</para>
</sect1>

<sect1 id="mailing-lists">
<title>Listes de discussion</title>
<para>
</para>
</sect1>

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

<para>Pour obtenir un code source homogène, il est important de garder un style
de programmation dans tous les sources de aRts. Même si vous écrivez simplement
un module, essayez d'écrire et formater votre source en conséquence, de façon à
faciliter le travail de différentes personnes dans la gestion des sources, et
faciliter la copie de morceaux de codes d'un source vers un autre.
</para>

<variablelist>
<varlistentry>
<term>Nom des fonctions membres</term>
<listitem>
<para>Style Qt/Java, ce qui signifie une majuscule au début de chaque mot, et la
première lettre toujours en minuscule&nbsp;; 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.</para>
<para>
Lorsqu'il y a des fonctions d'accès, le standard devrait être celui de MCOP,
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 &lowbar;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 qui appartiennent aux
librairies doivent utiliser les espaces de noms de Arts, comme
Arts::Soundserver.</para>
<para>Les implantations des classes MCOP doivent être appelées
Class&lowbar;impl, comme par exemple SoundServer&lowbar;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>
<varlistentry>
<term>Noms des fichiers sources</term>
<listitem>
<para>Les fichiers sources sont en minuscule. Ils doivent porter le nom de la
classe lorsqu'ils implantent une classe unique. Leur extension est .cc s'ils
contiennent du code indépendant de Qt/GUI, et .cpp s'ils contiennent du code
dépendant de Qt/GUI. Les fichiers d'implantation pour les interfaces doivent
être appelés <replaceable>foo</replaceable>_impl, si Foo est le nom de
l'interface.
</para>
<para>
Les fichiers IDL doivent être appelés de manière descriptive pour l'ensemble des
interfaces qu'ils contiennent, aussi tout en minuscule. En particulier, il est
déconseillé de donner à un fichier idl le nom de la classe elle même,
car le sélecteur de fichiers .mcopclass (.mcopclass trader) et les
informations de type entreront en conflit.
</para>
</listitem>
</varlistentry>
</variablelist>
</sect1>

</chapter>

<chapter id="future-work">
<title>Travaux futurs</title>
<para>
</para>

</chapter>

<chapter id="references">
<title>Références</title>

<para>
Site internet du projet &arts;
</para>

<para>
Site internet &kde; Multimedia
</para>

<para>Chapter 14 (Multimedia) du &kde; 2.0 Development book, disponible
pour commander ou en lecture en ligne à <ulink
url="http://www.andamooka.org/">http://www.andamooka.org</ulink></para>
</chapter>

<chapter id="faq">
<title>Questions et réponses</title>

<para>Cette section répond aux questions les plus fréquemment posées à propos de
&arts;.</para>

<sect1 id="faq-general">
<title>Généralités</title>

<qandaset id="faqlist">
<qandaentry>
<question>
<para>&kde; reconnaît-il ma carte son&nbsp;? </para>
</question>
<answer>
<para>
&kde; utilise &arts; pour le son, et &arts; utilise les pilotes sonores du loyau
de &Linux;, soit <acronym>OSS</acronym>, soit <acronym>ALSA</acronym> (en
utilisant l'émulation <acronym>OSS</acronym>). Si votre carte son est reconnue
par <acronym>ALSA</acronym> ou <acronym>OSS</acronym> et correctement configurée
(c'est-à-dire que les autres applications &Linux; l'utilisent sans problème), ça
marchera.
</para>
</answer>
</qandaentry>

<qandaentry>
<question>
<para>
Le son est-il géré sur d'autres plateformes que &Linux;&nbsp;?
</para>
</question>
<answer>
<para>
Il n'y a pour l'instant que la gestion des pilotes pour <acronym>OSS</acronym>
(ou compatible) sur d'autres plateformes (par exemple FreeBSD). Vous êtes
encouragés à contribuer en ajoutant la gestion du son pour d'autres plateformes.
Le code source correspondant est
<filename>kdelibs/arts/flow/audiosubsys.cc</filename>.
</para>
</answer>
</qandaentry>

<qandaentry>
<question>
<para>
Je ne peux pas lire de fichiers <literal role="extension">wav</literal> avec
<application>artsd</application>&nbsp;!
</para>
</question>
<answer>
<para>
Vérifiez que <application>artsd</application> est lié à
<filename>libaudiofile</filename> (<userinput><command>ldd</command>
<option>artsd</option></userinput>). Si ce n'est pas le cas, téléchargez
kdesupport, recompilez tout et ça devrait marcher.
</para>
</answer>
</qandaentry>

<qandaentry>
<question>
<para>
J'entend  un son lorsque je me connecte en <systemitem <!-- DocBook 4.1:
class="username" -->root</systemitem> mais les autres utilisateurs n'ont pas
le son&nbsp;!</para>
</question>
<answer>
<para>
Les permission du fichier <filename <!-- DocBook 4.1: class="devicefile" -->
/dev/dsp</filename> déterminent quels utilisateurs ont accès au son. Pour
permettre à tout le monde de l'utiliser, faites ceci&nbsp;: </para>

<procedure>
<step><para>Connectez-vous en <systemitem <!-- DocBook 4.1: class="username" -->
root</systemitem></para></step>

<step><para>ouvrez une fenêtre &konqueror;</para></step>

<step><para>allez dans le dossier <filename class="directory">/dev</filename>
</para></step>

<step><para>cliquez sur le fichier <filename>dsp</filename> avec le bouton
<mousebutton>droit</mousebutton> de la souris, et choisissez
propriétés.</para></step>

<step><para>cliquez sur l'onglet <guilabel>Permissions</guilabel>
</para></step>

<step><para>cochez les cases <guilabel>Lecture</guilabel> et
<guilabel>Écriture</guilabel> dans toutes les sections.</para></step>

<step><para>cliquez sur <guibutton>OK</guibutton></para></step>

</procedure>

<para>Vous pouvez obtenir le même effet dans un terminal en utilisant la
commande <userinput><command>chmod</command> <option>666
<replaceable>/dev/dsp</replaceable></option></userinput>.</para>

<para>Pour restreindre l'accès au son à certains utilisateurs, vous pouvez
utiliser les permissions de groupe. Avec certaines distributions &Linux;, par
exemple Debian/Potato, <filename>/dev/dsp</filename> appartient déjà au groupe
<systemitem <!-- DocBook 4.1: class="groupname" --> >audio</systemitem>,
donc vous devez juste ajouter les utilisateurs à ce groupe.</para>
</answer>
</qandaentry>

<qandaentry>
<question>
<para>Ça fonctionne pour <application>artsd</application>, mais pour les
autres applications comme &kmix;, &kmid;, &kscd;,&etc;&nbsp;?</para>
</question>
<answer>

<para>
Il y a d'autres périphériques qui fournissent des fonctionnalités auxquelles
accèdent des applications multimédia. Vous pouvez les traiter de la même
manière, soit en les rendant acessibles à tout le monde, soit en utilisant des
groupes pour contrôler les accès. Voici une liste, qui est vraisemblablement
incomplète (s'il y a plusieurs périphériques de la forme midi0, midi1, etc.,
seule la version avec le zéro est listée ici)&nbsp;:
</para>

<para>
<filename <!-- DocBook 4.1: class="devicefile" --> >/dev/admmidi0</filename>
<filename <!-- DocBook 4.1: class="devicefile" --> >/dev/adsp0</filename>
<filename <!-- DocBook 4.1: class="devicefile" --> >/dev/amidi0</filename>
<filename <!-- DocBook 4.1: class="devicefile" --> >/dev/amixer0</filename>
<filename <!-- DocBook 4.1: class="devicefile" --> >/dev/audio</filename>
<filename <!-- DocBook 4.1: class="devicefile" --> >/dev/audio0</filename>
<filename <!-- DocBook 4.1: class="devicefile" --> >/dev/cdrom</filename>
<filename <!-- DocBook 4.1: class="devicefile" --> >/dev/dmfm0</filename>
<filename <!-- DocBook 4.1: class="devicefile" --> >/dev/dmmidi0</filename>
<filename <!-- DocBook 4.1: class="devicefile" --> >/dev/dsp</filename>
<filename <!-- DocBook 4.1: class="devicefile" --> >/dev/dsp0</filename>
<filename <!-- DocBook 4.1: class="devicefile" --> >/dev/midi0</filename>
<filename <!-- DocBook 4.1: class="devicefile" --> >/dev/midi0</filename>
<filename <!-- DocBook 4.1: class="devicefile" --> >/dev/midi00</filename>
<filename <!-- DocBook 4.1: class="devicefile" --> >/dev/midi00</filename>
<filename <!-- DocBook 4.1: class="devicefile" --> >/dev/mixer</filename>
<filename <!-- DocBook 4.1: class="devicefile" --> >/dev/mixer0</filename>
<filename <!-- DocBook 4.1: class="devicefile" --> >/dev/mpu401data</filename>
<filename <!-- DocBook 4.1: class="devicefile" --> >/dev/mpu401stat</filename>
<filename <!-- DocBook 4.1: class="devicefile" --> >/dev/music</filename>
<filename <!-- DocBook 4.1: class="devicefile" --> >/dev/rmidi0</filename>
<filename <!-- DocBook 4.1: class="devicefile" --> >/dev/rtc</filename>
<filename <!-- DocBook 4.1: class="devicefile" --> >/dev/sequencer</filename>
<filename <!-- DocBook 4.1: class="devicefile" --> >/dev/smpte0</filename>
<filename <!-- DocBook 4.1: class="devicefile" --> >/dev/sndstat</filename>
</para>

</answer>
</qandaentry>

</qandaset>

</sect1>

<sect1 id="faq-non-arts">
<title>Applications non-Arts</title>

<qandaset>

<qandaentry>
<question>
<para>
Dès que &kde; fonctionne, les autres applications ne peuvent plus accéder au
périphérique son&nbsp;!</para>
</question>
<answer>
<para>
Lorsque le serveur sonore de &arts; est utilisé par &kde;, il utilise le
périphérique sonore. Si le serveur ne fait rien pendant 60 secondes, il est
suspendu automatiquement et libère le périphérique.
</para>
</answer>
</qandaentry>

<qandaentry>
<question>
<para>
Vous dites qu'il est suspendu après 60 secondes, mais ça ne marche pas chez
moi&nbsp;!
</para>
</question>
<answer>
<para>
Actuellement, il n'est pas suspendu si le mode full duplex est activé.
Désactivez-le depuis &kcontrol;. Il est conseillé généralement de désactiver le
mode full duplex si vous utilisez &arts; pour lire de l'audio et pas pour
enregistrer.
</para>
</answer>
</qandaentry>


<qandaentry>
<question>
<para>
Comment exécuter de vieilles applications qui ne reconnaissent pas &arts;&nbsp;?
</para>
</question>
<answer>
<para>
Exécutez-les avec <application>artsdsp</application>. Par exemple, si vous
aviez écrit en temps normal&nbsp;:
</para>
<screen><prompt>&percnt;</prompt> <userinput><command>mpg123</command> <option>foo.mp3</option></userinput></screen>

<para>utilisez plutôt&nbsp;:</para>

<screen><prompt>&percnt;</prompt> <userinput><command>artsdsp</command> <option>mpg123 foo.mp3</option></userinput></screen>

<para>
Ceci redirigera la sortie son vers &arts;. Cette méthode ne nécessite pas de
modifications de l'application. Ce n'est pas très élégant, et ne gère pas toutes
les caractéristiques de la carte son donc il est possible que ça ne
fonctionne pas pour certaines applications.
</para>
</answer>
</qandaentry>

<qandaentry>
<question>
<para>
Je ne peux exécuter <application>artsdsp</application> avec aucune
application, il plante à tous les coups&nbsp;!
</para> </question>
<answer>
<para>
Vous avez besoin d'une version récente des librairies glibc&nbsp;;
<command>artsdsp</command> ne fonctionnera pas de manière sûre sur certaines
vieilles distributions de &Linux;. Par exemple, avec une Debian 2.1 (basée sur
glibc 2.0), ça ne fonctionnera pas, tandis que ça fonctionnera avec une Debian
2.2 (basée sur glibc 2.1.3).
</para>
</answer>
</qandaentry>

<qandaentry>
<question>
<para>
Y a-t-il des limitations théoriques avec certaines applications qui
m'empêcheraient de les utiliser avec <application>artsdsp</application>&nbsp;?
</para>
</question>
<answer>
<para>
Non, utiliser <command>artsdsp</command> peut entraîner des temps de latence et
une augmentation légère de l'utilisation du <acronym>CPU</acronym> par rapport à
l'utilisation directe des <acronym>API</acronym> de &arts;. À part ça, si
ça ne fonctionne pas pour une application, il faut considérer ça comme un bogue
dans <application>artsdsp</application>. La technique utilisée par
<application>artsdsp</application> devrait, si elle est implantée correctement,
permettre à <emphasis>toute</emphasis> application de fonctionner avec
(y-compris les grosses applications comme <application>Quake</application> 3).
</para>
</answer>
</qandaentry>

<qandaentry>
<question>
<para>
Que puis-je faire si une application ne fonctione pas avec
<command>artsdsp</command>&nbsp;?
</para>
</question>
<answer>
<para>
Vous pouvez attendre que <application>artsd</application> se suspende
automatiquement, ou utiliser la commande <userinput><command>artsshell</command>
<option>suspend</option></userinput> pour demander au serveur de se suspendre.
Vous ne pourrez le suspendre que si plus aucune application reconnaissant &arts;
ne l'utilise, et ensuite plus aucune de ces applications ne pourra le réutiliser
lorsqu'il sera suspendu.</para>

<para>Si le serveur est occupé, un moyen un peu rude, mais efficace de s'en
débarrasser est&nbsp;:
</para>


<screen>
<prompt>&percnt;</prompt> <userinput><command>killall</command> <option>artsd</option> ; <command>killall</command> <option>artswrapper</option></userinput> <lineannotation>Now start your own application.</lineannotation>
<prompt>&percnt;</prompt> <userinput><command>kcminit</command> <option>arts</option></userinput> </screen>

<para>Une fois que vous avez tué le serveur, toute application reconnaissant
&arts; et en fonctionnement est alors susceptible de planter.</para>
</answer>
</qandaentry>

<qandaentry>
<question>
<para>
Et les applications écrite pour KDE1&nbsp;?
</para>
</question>
<answer>
<para>
Si vous exécutez des applications KDE1, qui dirige le son vers le serveur audio
de KDE1, vous devez exécuter kaudioserver pour les faire fonctionner. Vous
pouvez démarrer ce programme de la même façon que pour les applications ne
reconnaissant pas &arts;&nbsp;:
<screen>
<prompt>&percnt;</prompt> <userinput><command>artsdsp</command>
<option>kaudioserver</option></userinput>
</screen>
Vous devez avoir installé kaudioserver (à partir du même endroit où vous avez
récupéré les sources de votre application KDE1) - il appartient à KDE1, pas
KDE2.</para>
</answer>
</qandaentry>

<qandaentry>
<question>
<para>
Et les applications utilisant le <quote>enlightened sound daemon</quote>,
ESD&nbsp;?
</para>
</question>
<answer>
<para>
La méthode est similaire à celle pour kaudioserver. De telles applications
nécessitent que le serveur esd fonctionne. Vous pouvez le démarrer via artsdsp,
et chaque application utilisant ESD devrait fonctionner correctement, comme
ceci&nbsp;:
<screen>
<prompt>&percnt;</prompt> <userinput><command>artsdsp</command> <option>esd</option></userinput>
</screen>
</para>
</answer>
</qandaentry>

</qandaset>

</sect1>

<sect1 id="faq-latency">
<title>Temps de latence</title>

<qandaset>

<qandaentry>
<question>
<para>
J'entends parfois de courtes pauses lorsque j'écoute de la musique. C'est un
bogue&nbsp;?
</para>
</question>
<answer>
<para>
Ce n'est probablement pas un bogue, mais dû au fait que le noyau de &Linux;
n'est pas adapté à l'ordonnancement temps-réel. Il y a des situations où &arts;
ne pourra pas continuer à jouer. Vous pouvez cependant activer les droits
temps-réel (via &kcontrol;), et utiliser un temps de réponse important (comme
<guilabel>250ms</guilabel> ou <guilabel>le plus grand possible</guilabel>),
ce qui devrait améliorer la situation.</para>
</answer>
</qandaentry>

<qandaentry>
<question>
<para>
Quel est l'effet du réglage du temps de réponse&nbsp;?
</para>
</question>
<answer>
<para>
Le texte d'aide pour ce réglage dans &kcontrol; peut être trompeur. Un valeur
faible signifie que &arts; aura moins de temps pour réponde à un événement
extérieur (par exemple le temps qui sépare le moment ou une fenêtre est fermée,
et le moment ou un son est joué par <application>artsd</application>). Plus de
ressources <acronym>CPU</acronym> seront aussi utilisées, ce qui peut entrainer
des interruptions brèves du son.</para>
</answer>
</qandaentry>

<qandaentry>
<question>
<para>
Est-ce que je peux faire autre chose pour éviter ces interruptions&nbsp;?
</para>
</question>
<answer>
<para>
Pour les utilisateurs de lecteurs <acronym>IDE</acronym>, vous pouvez utiliser
la commande <command>hdparm</command> pour placer votre lecteur
<acronym>IDE</acronym> en mode <acronym>DMA</acronym>. Attention, ça ne
fonctione pas avec tous les matériels, et peut vous obliger à redémarrer la
machine, ou plus rare, peut entrainer des pertes de données. Lisez la
documentation sur la commande <command>hdparm</command> pour de plus amples
informations. J'ai utilisé avec succès la commande suivante&nbsp;: </para>

<screen>
<prompt>&percnt;</prompt> <userinput><command>hdparm</command> <option>-c1 -d1 -k1 -K1 /dev/hda</option></userinput>
</screen>

<para>Vous devez lancer ceci après chaque démarrage, donc placez-le dans un
script de démarrage de votre système (la façon de procéder dépend de votre
distribution, sur une Debian &Linux;, la commande est souvent ajoutée dans
<filename>/etc/rc.boot</filename>).</para>
</answer>
</qandaentry>

<qandaentry>
<question>
<para>
Pourquoi <application>artsd</application> consomme-il autant de temps
<acronym>CPU</acronym>&nbsp;?
</para>
</question>
<answer>
<para>
Vérifiez le réglage du temps de réponse. Cependant, la version actuelle n'est
pas encore vraiment optimisée. Ça devrait s'améliorer, mais jusque là, aucune
estimation sur la vitesse de <application>artsd</application>  ne peut vraiment
être faite.</para>
</answer>
</qandaentry>

</qandaset>

</sect1>

<sect1 id="faq-network">
<title>Transparence réseau</title>

<qandaset>

<qandaentry>
<question>
<para>
De quoi ai-je besoin pour utiliser la transparence réseau&nbsp;?
</para>
</question>
<answer>
<para>
Activez-la à partir de <guilabel>Serveur de son</guilabel> dans le &kcontrol;
(<guilabel>Échanger les informations de sécurité  et de référence sur le serveur
X11</guilabel> et <guilabel>Activer la transparence réseau</guilabel>). Copiez
ensuite votre fichier <filename>.mcoprc</filename> sur toutes les machines à
partir desquelles vous voulez utiliser la transparence réseau. Connectez-vous à
nouveau. Assurez-vous que les hôtes mis en jeu se connaissent bien entre eux
(c'est-à-dire qu'ils ont des noms résolvables ou qu'ils sont dans
<filename>/etc/hosts</filename>).
</para>

<para>
Ce devrait être tout ce que vous avez à faire. Cependant, si ça ne fonctionne
toujours pas, il y a quelques détails supplémentaires. Le processus du serveur
de son de &arts;, <application>artsd</application>, ne doit être exécuté que sur
un hôte, celui contenant la carte son qui va être utilisée. Ce processus peut
être démarré automatiquement à la connexion à &kde; (vous configurez ceci dans
&kcontrol;), ou manuellement en utilisant quelque chose comme&nbsp;:
</para>

<screen>
<prompt>&percnt;</prompt> <userinput><command>artsd</command> <option>-n -F 5 -S 8192</option></userinput>
</screen>

<para>Le paramètre <option>-n</option> correspond à la transparence réseau, et
les autres paramètres configurent le temps de réponse.</para>

<para>
Votre fichier <filename>.mcoprc</filename> devrait contenir l'entrée&nbsp;:
</para>

<screen>
<userinput>GlobalComm=Arts::X11GlobalComm</userinput>
</screen>

<para>sur toutes les machines mises en jeu, afin de faire fonctionner la
transparence réseau. C'est ce qui est activé par le réglage <guilabel>Échanger
les informations de sécurité  et de référence sur le serveur X11</guilabel> du
centre de configuration de &kde;.
</para>

<para>Enfin, dans toutes les versions de &kde; de la série 2.0.x, un bogue
apparaît si vous n'avez pas de nom de domaine. Les clients de
<application>artsd</application> essaient de trouver où se connecter via la
combinaison
<replaceable>hostname</replaceable>.<replaceable>domainname</replaceable>. Si
votre nom de domaine est vide, ils essairont de se connecter à
<replaceable>hostname</replaceable>. (notez le point supplémentaire). Il est
possible de contourner ce problème en ajoutant une entrée à
<filename>/etc/hosts</filename> (c'est-à-dire <userinput>orion.</userinput> si
votre nom d'hôte est <systemitem class="systemname">orion</systemitem>).
</para>
</answer>
</qandaentry>

<qandaentry>
<question>
<para>
Comment déboguer la transparence réseau si ça ne fonctionne pas&nbsp;?
</para>
</question>
<answer>
<para>
Si vous avez le code source de &kde;, allez dans <filename
class="directory">kdelibs/arts/examples</filename>, et exécutez
<userinput><command>make</command> <option>check</option></userinput> pour
compiler certains programmes, dont <application>referenceinfo</application>.
Exécutez ensuite</para>

<screen>
<prompt>&percnt;</prompt> <userinput><command>./referenceinfo</command> <option>global:Arts&lowbar;SimpleSoundServer</option></userinput>
</screen>

<para>
La sortie indiquera le nom d'hôte et le port en cours d'utilisation par &arts;.
Par exemple, <computeroutput>tcp:orion:1698</computeroutput> signifierait que
tout client essayant d'utiliser la transparence réseau devrait savoir comment
atteindre l'hôte <systemitem class="systemname">orion</systemitem>.
</para>
</answer>
</qandaentry>

</qandaset>

</sect1>

<sect1 id="faq-other">
<title>Divers</title>

<qandaset>

<qandaentry>
<question>
<para>Je ne peux pas utiliser <application>artsbuilder</application>. Il plante
chaque fois que j'exécute un module&nbsp;!</para>
</question>
<answer>
<para>La cause la plus probable est que vous utilisez de vieilles structures ou
de vieux modules qui ne sont pas reconnus pas la version pour &kde; 2.
Malheureusement, la documentation disponible sur internet se réfère à
&arts;-0.3.4.1 qui est une ancienne version. Le plantage le plus souvent
rencontré est l'apparition du message d'erreur <errorname>[artsd] Synth_PLAY:
audio subsystem is already used.</errorname> dans
<application>artsbuilder</application> lorsqu'une structure est exécutée.
</para>

<para>Utilisez un module Synth_AMAN_PLAY plutôt qu'un module Synth_PLAY et le
problème disparaîtra. Voyez aussi l'aide de
<application>artsbuilder</application> en appuyant sur <keycap>F1</keycap> depuis
<application>artsbuilder</application>).
</para>

<para>
Les versions récentes de <application>artsbuilder</application> (&kde; 2.1 beta
1 et suivantes) sont livrées avec plusieurs exemples.</para>
</answer>
</qandaentry>

</qandaset>

</sect1>
</chapter>

<chapter id="copyright-and-licenses">

<title>Licence et  Copyright de &arts;</title>

<para>&arts; software copyright 1998-2001 Stefan Westerfeld
<email>stefan@space.twc.de</email></para>

<para><anchor id="contributors">
Documentation copyright 1999-2001
Stefan Westerfeld <email>stefan@space.twc.de</email> et
Jeff Tranter <email>tranter@kde.org</email>.
</para>

&underFDL;

<para>
Toutes les librairies de &arts; sont distribuées selon les termes de la licence
<acronym>GNU</acronym> Lesser General Public license. La grande majorité du code de &arts;
se trouve dans les librairies, incluant <acronym>MCOP</acronym> et ArtsFlow en totalité. Ceci permet
d'utiliser les librairies pour des applications non libres ou non open source si vous le souhaitez.
</para>

<para>
Il y a quelques programmes (comme  <application>artsd</application>), qui sont distribués selon les
termes de la <acronym>GNU</acronym> General Public
License. Comme il y a eu des discussions sur la légalité de lier des programmes <acronym>GPL</acronym>
avec &Qt;, j'ai aussi ajouté une notice explicite qui ajoute, en plus de la GPL&nbsp;: permission est accordée
de lier ce programme avec les librairies &Qt;, considérant &Qt; comme une librairie
qui accompagne normalement le noyau du système d'exploitation, que ce soit le
cas ou non en réalité.</para>

</chapter>

<chapter id="intro-digital-audio">
<title>Introduction à l'audionumérique</title>

<para>échantillonnage, filtres, effets, &etc;</para>

</chapter>

<chapter id="midi-introduction">
<title>Introduction au <acronym>MIDI</acronym></title>
<para>
</para>
</chapter>


<glossary id="glossary">

<glossentry id="gloss-alsa">
<glossterm><acronym>ALSA</acronym></glossterm>
<glossdef>
<para>Advanced &Linux; Sound Architecture&nbsp;; a &Linux; pilote de carte
son&nbsp; il n'est pas inclus actuellement dans le code source du noyau
standard.</para> </glossdef>
</glossentry>

<glossentry id="gloss-arts">
<glossterm>&arts;</glossterm>
<glossdef>
<para>Analog Real-Time Synthesizer&nbsp;; le nom de
l'architecture/librairie/toolkit multimédia utilisés dans le projet &kde; (notez
les majuscules) </para>
</glossdef>
</glossentry>

<glossentry id="gloss-bsd">
<glossterm><acronym>BSD</acronym></glossterm>
<glossdef>
<para>Berkeley Software Distribution&nbsp;; se réfère à l'un des multiples
systèmes d'exploitation compatibles &UNIX; dérivés de &UNIX;
<acronym>BSD</acronym>. </para>
</glossdef>
</glossentry>

<glossentry id="gloss-corba">
<glossterm><acronym>CORBA</acronym></glossterm>
<glossdef>
<para>Common Object Request Broker Architecture&nbsp;; un standard pour
l'implantation d'exécution à distance orientée objet..</para>
</glossdef>
</glossentry>

<glossentry id="gloss-cvs">
<glossterm><acronym>CVS</acronym></glossterm>
<glossdef>
<para>
Concurrent Versions System&nbsp;; un système de gestion de versions de fichiers
utilisé dans beaucoup de projets, y-compris KDE et &arts;.
</para>
</glossdef>
</glossentry>

<glossentry id="glos-fft">
<glossterm><acronym>FFT</acronym></glossterm>
<glossdef>
<para>Fast Fourier Transform ou tranfsormée de Fourier rapide&nbsp;; un
algorithme pour convertir des données de l'espace des temps vers l'espace des
fréquences&nbsp;; souvent utilisé en traitement du signal.</para> </glossdef>
</glossentry>

<glossentry id="gloss-full-duplex">
<glossterm>Full Duplex</glossterm>
<glossdef>
<para>
Capacité d'une carte son à enregistrer et lire des données audio de manière
simultanée.
</para>
</glossdef>
</glossentry>

<glossentry id="gloss-gpl">
<glossterm><acronym>GPL</acronym></glossterm>
<glossdef>
<para><acronym>GNU</acronym> General Public License&nbsp;; une licence pour
logiciel crée par la  Free Software Foundation et définissant les termes de la
distribution des logiciels libres.</para>
</glossdef>
</glossentry>

<glossentry id="gloss-gui">
<glossterm><acronym>GUI</acronym></glossterm>
<glossdef><para>Graphical User Interface ou interface
graphique utilisateur</para></glossdef> </glossentry>

<glossentry id="gloss-idl">
<glossterm><acronym>IDL</acronym></glossterm>
<glossdef>
<para>Interface Definition Language&nbsp;; un langage de programmation
indépendant du format pour spécifier des interaces (méthodes et données).</para>
</glossdef>
</glossentry>

<glossentry id="gloss-kde">
<glossterm>&kde;</glossterm>
<glossdef>
<para>K Desktop Environment&nbsp;; un projet visant à développer un
environnement de bureau graphique et libre pour les systèmes compatibles &UNIX;.
</para>
</glossdef>
</glossentry>

<glossentry id="gloss-lgpl">
<glossterm><acronym>LGPL</acronym></glossterm>
<glossdef>
<para><acronym>GNU</acronym> Lesser General Public License&nbsp;; une licence
pour logiciel créée par la  Free Software Foundation et définissant les termes
de la distribution de logiciels libres&nbsp;; plus restrictif que la licence
<acronym>GPL</acronym> et souvent utilisée pour les librairies.</para>
</glossdef>
</glossentry>

<glossentry id="gloss-mcop">
<glossterm><acronym>MCOP</acronym></glossterm>
<glossdef>
<para>Multimedia COmmunication Protocol&nbsp;; protocole utilisé pour la
communication entre &arts;, les modules logiciels&nbsp;; similaire à
<acronym>CORBA</acronym> mais plus simple et optimisé pour le multimédia.
</para>
</glossdef>
</glossentry>

<glossentry id="gloss-midi">
<glossterm><acronym>MIDI</acronym></glossterm>
<glossdef>
<para>Musical Instrument Digital Interface&nbsp;; protocole standard pour la
communication entre instruments de musique électroniques&nbsp;; aussi utilisé
pour désigner le format des fichiers comportant des commandes
<acronym>MIDI</acronym>.
</para>
</glossdef>
</glossentry>

<glossentry id="gloss-oss">
<glossterm><acronym>OSS</acronym></glossterm>
<glossdef>
<para>
Open Sound System&nbsp;; pilotes sonores inclus dans le noyau de &Linux; (appelé
aussi parfois <acronym>OSS</acronym>/Free) ou une version commerciale vendue par
4Front Technologies.
</para>
</glossdef>
</glossentry>

</glossary>

<appendix id="installation">
<title>Installer &arts;</title>

<para>
In order to use &arts; you obviously need to have it installed and running on
your system. There are two approaches for doing this, which are described in the
next sections.
</para>

<sect1 id="binary-install">
<title>Installer une distribution de binaires précompilés</title>

<para>
La façon la plus rapide et la plus simple pour disposer d'une version
fonctionnelle de &arts; est d'installer les paquetages de binaires précompilés
pour votre système. Les distributions les plus récentes de &Linux; fournissent
&kde;, et s'il s'agit de &kde; 2.0 ou supérieur, elles fournissent également
&arts;. Si &kde; n'est pas présent sur le support d'installation, vous pouvez le
télécharger depuis le distributeur du système d'exploitation. Alternativement,
il devrait être aussi rendu disponible par des contributeurs. Assurez-vous que
vous utilisez des paquetages compatibles avec la version de votre système
d'exploitation.
</para>

<para>
Une installation typique de &kde; inclu le serveur sonore, permettant à la
plupart des application de jouer des sons. Si vous voulez l'ensemble des outils
et applications multimédia, vous devrez installer des paquetages
supplémentaires.
</para>

<para>
L'inconvénient d'utiliser des binaires précompilés est que vous ne disposez
probablement pas de la dernière version de &arts;. Ceci est particulièrement
vrai s'ils sont fournis sur &CD-ROM;, étant donné que la vitesse de
développement de &arts; et &kde; est telle que les supports &CD-ROM; ne peuvent
pas suivre. Il est possible aussi que les paquetages de binaires précompilés ne
soient pas disponibles si vous utilisez une architecture ou un système
d'exploitation peu communs. Vous devrez utilisez dans ce cas la seconde méthode
d'installation décrite ci-après.
</para>

</sect1>

<sect1 id="source-install">
<title>Installation à partir des sources</title>

<para>
Bien que gourmand en temps de calcul, la façon la plus flexible pour installer
&arts; est de le compiler vous-même à partir des sources. Ceci vous assure que
vous disposez de la version compilée optimale pour votre la configuration
de votre système et vous permet d'installer les versions les plus récentes.
</para>

<para>
Vous avez ici deux possibilités&nbsp;--&nbsp;vous pouvez soit installer la
version stable la plus récente fournie avec &kde; ou installer la version la
plus récente (mais peut-être instable) direcement depuis le référentiel
<acronym>CVS</acronym> du projet &kde;. La plupart des utilisateurs qui ne
participent pas au développement de &arts; utilisent la version stable. Vous
pouvez la télécharger depuis <ulink
url="ftp://ftp.kde.org">ftp://ftp.kde.org</ulink> ou l'un de ses sites miroirs.
Si vous participez au développement de &arts;, utilisez la version
<acronym>CVS</acronym>.
</para>

<para>
Notez qu'à l'heure où est écrite cette documentation, la version la plus récente
de &arts; n'était fournie que comme une partie de &kde;. Si vous voulez une
version indépendante de &arts;, vous ne devrez compiler et installer
manuellement que les parties de &kde; relatives à &arts;.
</para>

<para>
Notez également que si vous compilez à partir du <acronym>CVS</acronym>,
certains composants de &arts; (&ie; les composantes de bases y-compris le
serveur sonore) se trouvent dans le module <acronym>CVS</acronym> kdelibs,
tandis que les composants additionnels (&eg;
<application>artsbuilder</application>) sont inclus dans le. Ceci changera
certainement dans le futur. Vous en trouverez aussi une version dans le module
kmusic&nbsp;; il s'agit d'une vieille version (pre-&kde; 2.0) qui est maintenant
obsolète.
</para>

<para>
Les pré-requis pour compiler &arts; sont principalement les mêmes que pour
compiler &kde;. Les scripts de configuration devraient détecter la configuration
de votre système et indique s'il manque certains composants. Assurez-vous que
vous disposez d'un pilote sonore en état de fonctionnement (soit le pilote
<acronym>OSS</acronym>/Free dans le noyau, le pilote <acronym>OSS</acronym>
de 4Front Technologies, soit le pilote <acronym>ALSA</acronym> avec l'émulation
<acronym>OSS</acronym>).
</para>

<para>Des informations complémentaires sur le téléchargement et l'installation
de &kde; (y-compris &arts;) peuvent être trouvées dans la <ulink
url="http://www.kde.org/documentation/faq/index.html">&kde;
&FAQ;</ulink>.</para>

</sect1>

</appendix>

</book>
<!--
Local Variables:
mode: sgml
sgml-omittag:nil
sgml-shorttag:t
sgml-namecase-general:t
sgml-general-insert-case:lower
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:0
sgml-indent-data:nil
End:
-->
