Légendes images, traitement problème des listes et diverses corrections essentiellement de mise en forme.

Author: fxdole

book/15-e-GS-fr-01.md

@@ -9,19 +9,17 @@
 - Qu’est-ce qu’une **partition/score** Csound
 
 ## Qu’est-ce qu’un oscillateur sinusoïdal / sine oscillator
-
 Une onde sinusoïdale peut être considérée comme l’élément sonore le plus élémentaire au monde. Quand nous dessinons une onde sinusoïdale comme un graphique montrant son amplitude au cours du temps, elle ressemble à ça :
 
-![alt text](../resources/images/01-GS-01-sine.png)
+![Onde sinusoïdale serpent](../resources/images/01-GS-01-sine.png)
+
 
-_Onde sinusoïdale serpent_
 
 Pour produire une onde sinusoïdale, Csound utilise un oscillateur. Un oscillateur nécessite certaines entrées pour fonctionner :
 1. Une amplitude maximum de sortie. Ce qui résultera en un son plus ou moins fort.
 2. Le nombre de périodes (cycles) par seconde à générer. Ce qui résultera en un son plus ou moins aigüe ou grave. L’unité est le _Hertz(Hz)_. 1000 Hz signifie qu’une sinusoïde comporte 1000 périodes par seconde.
 
 ## Un oscillateur sinusoïdal dans Csound : Opcode et Arguments
-
 Csound dispose de nombreux oscillateurs différents. (vous pouvez trouver [ici](https://flossmanual.csound.com/how-to/opcodes) quelques descriptions et comparaisons.) Dans cet exemple, nous utilisons l’opcode `poscil`, qui signifie _precise oscillator_.
 
 Un **opcode** est une unité de traitement dans Csound, comparable à un _object_ dans PureData ou Max, ou un _UGen_ dans SuperCollider. Si vous êtes familier des langages de programmation, vous pouvez considérer un opcode comme une _building fonction / fonction intégrée_.
@@ -33,7 +31,7 @@ Les entrées d’un opcode sont appelées **arguments** et sont écrites entre p
 La signification des arguments en entrée dépend de la façon dont l’opcode a été implémenté. Pour `poscil`, la première entrée est l’amplitude et la seconde entrée est la fréquence. Le [Manuel de Référence Csound](https://csound.com/docs/manual-fr/index.html) contient toutes les informations à son sujet. Nous apporterons quelques éclaircissements dans notre [Tutoriel 08](15-l-GS-fr-08.md) pour aider à son utilisation.
 
 Cette manière d’écrire du code est commune à de nombreux langages de programmation, comme `range(13)` en Python, ou `printf("no no")` en C, ou `Date.now()` en JavaScript (dans ce cas les parenthèses sont vides, ce qui signifie : pas d’argument en entrée).
-> Note : Il existe une autre manière d’écrire du code Csound. Si vous voulez en apprendre plus sur ce sujet, voyez la section "Deux façons d’écrire du code dans Csound" à la fin de ce tutoriel.
+    Note : Il existe une autre manière d’écrire du code Csound. Si vous voulez en apprendre plus sur ce sujet, voyez la section "Deux façons d’écrire du code dans Csound" à la fin de ce tutoriel.
 
 ## Le flux d’un signal et son code
 Nous créons maintenant une onde sinusoïdale d’une amplitude de 0.2 et de 400 cycles par seconde (Hz).  
@@ -56,8 +54,7 @@ Notez que le signal _aSine_ est d’abord la sortie de l’oscillateur, puis dev
 
 Nous pouvons dessiner le flux de ce programme comme ceci :
 
-![alt text](../resources/images/01-GS-01-a.png){width=80%}  
-_Flux de signal et code Csound pour un oscillateur sinusoïdal et une sortie._
+![Flux de signal et code Csound pour un oscillateur sinusoïdal et une sortie.](../resources/images/01-GS-01-a.png){width=80%}  
 
 Au milieu, vous voyez le flux du signal, avec des symbols pour l’oscillateur et la sortie. Vous pouvez les imaginer comme les modules d’un synthétiseur, connectés par un cable nommé _aSine_.
 
@@ -66,7 +63,6 @@ Sur le côté gauche, vous voyez la chaine entre les entrées, l’opcode et la
 À droite, vous voyez le code Csound correspondant. Chaque ligne de code représente une chaine _entrée -> opcode -> sortie_, dans la forme _sortie = opcode(entrée)_. La ligne `outall(aSine)` n’a pas de sortie vers Csound, car elle envoie l’audio au matériel (comme l’objet `dac~` dans PD ou Max).
 
 ## Votre premier instrument Csound
-
 Dans Csound, tous les oscillateurs, filtres, lecteurs d’échantillons / sample players, et autres unités de traitement sont encapsulés dans un **instrument**. Un instrument comporte les mots-clé :
 - `instr` à son début
 - et `endin` à sa fin.
@@ -124,15 +120,23 @@ C’est la section **Partition / Score** du fichier .csd. Elle commence par la b
 i "Bonjour" 0 2
 ```
 Chaque colonne (champ de paramètre / parameter field) spécifie une certaine information :
+
 - `"Bonjour"` : L’instrument auquel cette ligne de partition se réfère.
+
 - `0` : L’heure de départ de cet instrument : `0` (= départ immédiat).
+
 - `2` : La durée du son venant de l’instrument : `2` (secondes).
 
 #### Essayez vous-même
+
 (Vous pouvez éditer l’exemple juste en tapant à l’intérieur)
+
 - Changez la durée de l’instrument
+
 - Changez l’heure de départ de l’instrument
+
 - Changez la fréquence de l’oscillateur
+
 - Changez l’amplitude de l’oscillateur
 
 ## Opcodes, Mots-Clés et termes que vous avez appris dans ce tutoriel
@@ -152,7 +156,8 @@ Avec le tutoriel suivant : [02_Bonjour Fréquences](15-f-GS-fr-02.md)
 
 ## Ou lisez quelques informations supplémentaires ici
 
-### Pourquoi le sinus est-il « le son le plus élémentaire au monde » ?
+### Pourquoi l’onde sinusoïdale est-elle « le son le plus élémentaire au monde » ?
+
 Pour être honnête, j'aime les sons sinusoïdaux. Je sais que beaucoup de gens les trouvent ennuyeux. J'aime leur simplicité, alors contre tous les bons conseils, je vais consacrer les dix premiers tutoriels uniquement aux sons sinusoïdaux. Désolé de vous en faire subir les conséquences...
 
 Mais revenons à la question : qu'y a-t-il d'élémentaire dans les ondes sinusoïdales ?
@@ -181,7 +186,7 @@ Vous pouvez sans problème continuer d’écrire le code Csound ainsi. Les raiso
 3. Le style fonctionnel d’écrire du code Csound a toujours existé dans des expressions comme `ampdb(-10)` ou `ftlen(giTable)`. Ce n’est donc pas totalement nouveau, mais plutôt une extension.
 4. Chaque fois que nous voulons utiliser une expression comme argument (vous en apprendrez plus à ce sujet dans le [tutoriel 6](15-j-GS-fr-06.md)), nous devons écrire le code de cette manière. Il est donc bon de l’utiliser en permanence pour plus de cohérence.
 
-> NOTE DU TRADUCTEUR pour les francophones : Sauf dans le commentaires où ça ne pose aucun problème, n’utilisez que des caractères ASCII dans vos programmes. J’ai essayé et chez moi ça plante. Donc pas de lettres accentuées, pas de œ et autres signes propres au français.
+    NOTE DU TRADUCTEUR pour les francophones : Sauf dans les commentaires où ça ne pose aucun problème, n’utilisez que des caractères ASCII dans vos programmes. J’ai essayé et chez moi ça plante. Donc pas de lettres accentuées, pas de œ et autres signes propres au français.
 
 ## Au sujet de ces tutoriels
 Ce _Guide de démarrage_ a été écrit par Joachim Heintz en 2023. Il est basé sur de nombreuses expériences d’enseignement de Csound auprès de jeunes compositeurs.

book/15-f-GS-fr-02.md

@@ -1,48 +1,57 @@
 # 02 Bonjour Fréquences
 
 ## Ce que vous apprendrez dans ce tutoriel
+
 - Comment créer un glissement/sliding de fréquence, ou **glissando**.
+
 - Ce que **k-rate** ou **control rate / fréquence de contrôle** signifient, et
 - que sont les **k-variables** dans Csound.
+
 - Comment un **document .csd** Csound est structuré :
+
     - Que sont les **CsOptions** et
+
     - Qu’est-ce que la section **CsInstruments** ou **orchestra**.
 
 ## Une ligne pour la fréquence
 
 Dans les sons naturels, la fréquence est rarement fixe. Habituellement, par exemple quand nous parlons, la hauteur de notre voix varie constamment à l’intérieur d’une certaine plage.
 
 Le cas le plus simple de ce genre de mouvement est une ligne. Nous avons besoin de trois valeurs pour construire cette ligne :
+
 1. Une valeur de commencement.
+
 2. Une durée pour nous déplacer de cette valeur vers une valeur cible.
+
 3. La valeur-cible elle-même.
 
 Voici une ligne qui se déplace de 500 à 400 en 0.5 secondes, et qui reste à 400 pendant 1.5 secondes :
 
-![alt text](../resources/images/01-GS-02-a.png)  
-_Ligne de fréquence._
+![Ligne de fréquence.](../resources/images/01-GS-02-a.png)  
+
 
-> Note : Acoustiquement, cette façon d’appliquer un _glissando_ est discutable. Nous en parlerons dans le [Tutoriel 05](15-i-GS-fr-05.md).
+    Note : Acoustiquement, cette façon d’appliquer un _glissando_ est discutable. Nous en parlerons dans le [Tutoriel 05](15-i-GS-fr-05.md).
 
-> Note 2 : Ne devrions-nous pas dire : "Voici une ligne qui se déplace depuis 500 Hz jusqu’à 400 Hz, en 0.5 secondes", plutôt que "Voici une ligne qui se déplace depuis 500 jusqu’à 400 en 0.5 secondes" ? Non. La ligne produit des nombres. Ces nombres peuvent être utilisés pour des fréquences, mais peuvent avoir une signification différente dans un autre contexte.
+    Note 2 : Ne devrions-nous pas dire : "Voici une ligne qui se déplace depuis 500 Hz jusqu’à 400 Hz, en 0.5 secondes", plutôt que "Voici une ligne qui se déplace depuis 500 jusqu’à 400 en 0.5 secondes" ? Non. La ligne produit des nombres. Ces nombres peuvent être utilisés pour des fréquences, mais peuvent avoir une signification différente dans un autre contexte.
 
 ## Une ligne Dessinée avec l’opcode 'linseg'
 
- Dans Csound, nous créons ce genre de ligne avec l’opcode `linseg`, qui signifie "linear segments / segments linéaires". Ici, nous n’avons besoin que d’un seul segment qui se déplace de 500 à 400 en 0.5 secondes.
+Dans Csound, nous créons ce genre de ligne avec l’opcode `linseg`, qui signifie "linear segments / segments linéaires". Ici, nous n’avons besoin que d’un seul segment qui se déplace de 500 à 400 en 0.5 secondes.
 
 Voici le code Csound pour ce mouvement linéaire :
 ```
 kFreq = linseg:k(500, 0.5, 400)
 ```
-## Signal k-rate, à la fréquence de contrôle
+## Signal k-rate (à la fréquence de contrôle)
+
 Un signal est quelque chose dont les valeurs changent au cours du temps. Mais qu’est-ce que le temps dans une application audio comme Csound ?
 
 Le temps fondamental est donné par la **sample rate / fréquence d’échantillonnage**. Elle détermine le nombre d’échantillons/samples que nous avons par seconde. Nous avons vu le signal _aSine_ dans le premier tutoriel, dont les valeurs changent à la **fréquence d’échantillonnage / audio rate** ; calculant une nouvelle valeur à chaque sample/échantillon.
 
 La seconde résolution temporelle possible dans Csound est moins fine. Elle ne calcule pas une nouvelle valeur à chaque échantillon, mais seulement par **groupe d’échantillons**. Cette résolution temporelle est appelée **control rate / fréquence de contrôle**.
 
-![alt text](../resources/images/01-GS-02-b.png)  
-_audio rate vs control rate_
+![audio rate vs control rate](../resources/images/01-GS-02-b.png)  
+
 
 Les variable Csound qui comportent un **k** comme premier caractère, utilisent la fréquence de contrôle / control rate. Leurs valeurs sont mises à jour à la fréquence de contrôle. C’est la raison pour laquelle nous écrivons _**k**Freq_.
 
@@ -93,10 +102,10 @@ i "Bonjour" 0 2
 
 Si vous examinez le code de notre instrument, vous constaterez qu’il existe un schéma commun :
 
-![alt text](../resources/images/01-GS-02-c.png)  
-_Input output insertions_
+![Input output insertions](../resources/images/01-GS-02-c.png)  
 
 - La première ligne produit un signal et le stocke dans la variable _kFreq_. Cette variable est ensuite utilisée comme entrée dans la seconde ligne.
+
 - La seconde ligne produit un signal et le stocke dans la variable _aSine_. Cette variable est ensuite utilisée comme entrée dans la troisième ligne.
 
 ## La structure d’un document Csound (.csd)
@@ -107,28 +116,41 @@ Le document Csound complet consiste en trois parties :
 
 2. Entre les balises \<CsInstruments> et \</CsInstruments>. C’est le lieu où sont placés tous les instruments. Le code Csound réside à cet emplacement, qu’on appelle également "Orchestra".
 
-2. Entre les balises \<CsScore> et \</CsScore>, partie qui a été discutée dans la section précédente.
+3. Entre les balises \<CsScore> et \</CsScore>, partie qui a été discutée dans la section précédente.
 
 Comme vous pouvez le voir, ces trois paires de balises sont englobées entre une autre paire de balises :
+
 ```
 <CsoundSynthesizer>...</CsoundSynthesizer>
 ```
 Cette dernière paire de balises définit les limites d’écriture pour le programme Csound. En d’autre termes : Ce que nous écrivons hors de ces limites est ignoré par Csound.
 
 ## Essayez-le vous-même
+
 - Rendez la ligne de fréquences ascendante plutôt que descendante.
+
 - Utilisez `linseg` pour créer une fréquence constante de 400 ou de 500 Hz.
+
 - Rendez la durée de la rampe du glissando plus longue ou plus courte.
+
 - Ajoutez un autre segment en ajoutant une valeur supplémentaire de durée, et une valeur supplémentaire pour la seconde valeur-cible.
+
 - Restaurez les arguments originaux de linseg. Puis remplacez `linseg` par `line`, et écoutez la différence.
 
 ## Opcodes, balises et termes que vous avez appris dans ce tutoriel
+
 ### Opcodes
+
 - `linseg:k(Value1,Duration1,Value2,Duration2,…)` génère des segments de lignes droites.
+
 ### Balises
+
 - \<CsoundSynthesizer>...\</CsoundSynthesizer> déterminent le début et la fin du fichier Csound.
+
 - \<CsOptions>...\</CsOptions> déterminent le début et la fin des [Options Csound]().
+
 - \<CsInstruments>... \</CsInstruments> déterminent le début et la fin de l’espace réservé à la définition des instruments Csound.
+
 - \<CsScore>...\</CsScore> déterminent le début et la fin de la partition Csound.
 
 ### Termes
@@ -146,6 +168,7 @@ Avec le tutoriel suivant : [03 Bonjour Amplitude](15-g-GS-fr-03.md)
 Csound a un opcode `line` que nous pouvons utiliser à la place de `linseg`.
 
 Nous pouvons remplacer `linseg` dans notre code par `line` :
+
 ```
 instr Bonjour
     kFreq = line:k(500,0.5,400)
@@ -156,63 +179,83 @@ endin
 
 Si vous exécutez ce code, vous entendrez que `line` comporte une importante différence par rapport à `linseg` : il ne s’arrête pas à la valeur-cible, mais continue son mouvement :
 
-![alt text](../resources/images/01-GS-02-d.png)  
-_line vs linseg_
+![line vs linseg](../resources/images/01-GS-02-d.png)  
 
 Les cas d’utilisation de `line` ne sont pas courants. Je recommande donc toujours d’utiliser `linseg`, sauf exception.
 
 ### Conventions de codage
+
 Quand vous appuyez sur le bouton _Run/Exécuter_, Csound "lit" le code que vous avez écrit. Peut-être avez-vous déjà expérimenté avoir écrit quelque chose qui aboutit à une erreur, parce que quelque chose est "illégal".
 
 Par exemple, ce code :
+
 ```
 kFreq = linseg:k(500 0.5 400)
 ```
+
 Qu’est-ce qui est illégal ici ? Nous avons séparé les trois argument pour `linseg` avec des espaces plutôt que des virgules. Csound attend des virgules, et s’il n’y en a pas, il retourne une erreur de syntaxe, et le code ne peut pas être compilé :
+
 ```
 error: syntax error, unexpected NUMBER_TOKEN,
 expecting ',' or ')' (token "0.5")
 ```
+
 Ceci n’est pas une convention. C’est une syntaxe que nous **devons** respecter si nous voulons que notre code soit compilé et exécuté par Csound.
 
 Par contre, dans la syntaxe, il existe de nombreuses façons d’écrire du code d’une manière ou d’une autre.
 
 Voyons quelques exemples :
 
 1. `kFreq = linseg:k(500,0.5,400)`
+
 2. `kFreq=linseg:k(500,0.5,400)`
+
 3. `kFreq = linseg:k(500, 0.5, 400)`
+
 4. `kFreq = linseg:k(500,.5,400)`
+
 5. `kFreq        =       linseg:k(500,   0.5,    400)`
 
 Explications :
+
 1. C’est la manière dont j’écris le code ici dans ces tutoriels. Je mets un espace à gauche et à droite du signe `=`, mais je ne mets pas d’espace après la virgule.
+
 2. On peut le faire, mais je pense que vous serez d’accord pour dire que cette façon est moins facile à lire.
 3. C’est autant utilisé que la manière (1.), voire plus. Je me souviens que lorsque j’ai lu pour la première fois le tutoriel Python de Guido van Rossum, dans lequel il recommande d’écrire comme dans (1.), je n’ai pas aimé du tout. Il m’a fallu vingt ans pour être d’accord.
+
 4. C’est une abréviation commune qui est possible dans Csound et quelques autres langages de programmation : Plutôt qu’écrire `0.5`, on peut juste écrire `.5`. Je l’utilise pour mes programmes, mais je ne l’utiliserai pas dans ces tutoriels car c’est un peu moins clair.
+
 5. Vous êtes autorisés à utiliser des tabulations plutôt que des espaces, ainsi que n’importe quelle combinaison des deux, et autant de tabulations ou d’espaces que vous voulez. Mais habituellement, nous ne souhaitons pas qu’une ligne soit plus longue que nécessaire.
 
-Une autre convention est d’écrire les mots-clé `instr` et `endin` au début de la ligne, puis le code indenté par deux espaces :
+Une autre convention consiste à écrire les mots-clé `instr` et `endin` au début de la ligne, puis le code indenté par deux espaces :
+
 ```
 instr Bonjour
   kFreq = linseg:k(500,0.5,400)
   aSine = poscil:a(0.2,kFreq)
   outall(aSine)
 endin
 ```
+
 La raison de cette convention est à nouveau de formater le code en faveur d’un maximum de clarté. Dans _Csound Book_, nous utilisions un espace, mais je pense que deux espaces sont préférables.
 
 Pour résumer : Vous avez de nombreuses différentes options pour écrire du code Csound. Vous pouvez adopter celle que vous voulez, mais il est sage de respecter quelques conventions qui permettent une compréhension optimale. Le but est la lisibilité et la transparence du code.
 
 ### Quand choisir a-rate ou k-rate ?
+
 La principale raison de l’introduction de _k-rate_ est une économie de puissance pour le CPU. C’était essentiel dans les premières années de la musique sur ordinateur. Aujourd’hui c’est différent. Pour des instruments courants en musique électronique, on peut omettre les variable _k-rate_, et n’utiliser que les variables _a-rate_. Dans notre cas, nous pourrions écrire :
+
 ```
 aFreq = linseg:a(500,0.5,400)
 aSine = poscil:a(0.2,aFreq)
 outall(aSine)
 ```
 
+
 Un simple avis :
+
 - Utilisez toujours _a-rate_ quand ça améliore le son.
+
 - Utilisez _k-rate_ plutôt que _a-rate_ quand vous voulez économiser de la puissance de calcul au CPU.
+
 - Certains opcodes n’acceptent que des entrées _k-rate_, mais pas les entrées _a-rate_. Dans ce cas, vous devez utiliser des variables _k-rate_.