L'expérimentation prendra place à partir d'un nouveau programme de test prog_note.c dans le même répertoire de travail.
Ce nouveau programme et les précédents peuvent cohabiter sans problème ; les anciens resteront inchangés alors que le nouveau sera modifié progressivement.

Nous commençons par préparer un nouveau module matérialisé par la paire de fichiers instrument.h/instrument.c selon une forme similaire à votre premier module.

La première notion que devra exposer le fichier instrument.h est un nouveau type.
Ce type sera une structure nommée Instrument et constituée de six membres :

Nous fournissons immédiatement une fonction Instrument_init() qui sert à fabriquer un instrument par défaut (d'autres instruments viendront ultérieurement).
Elle n'attend aucun paramètre et renvoie comme résultat une structure Instrument.
Elle initialise une structure Instrument avec les valeurs 0.0, 0.05, 0.7, 0.25 pour les membres attack_duration, decay_duration, sustain_level et release_duration.
Elle invoque également RealArray_init() pour les membres freq_factor et amplitude.
La fonction RealArray_resize() doit être utilisée pour que les deux membres précédents puissent mémoriser 6 valeurs.
Six itérations seront alors effectuées pour les renseigner ainsi : La fonction renvoie alors comme résultat la structure Instrument ainsi initialisée.

Puisque l'usage d'une structure Instrument implique l'usage de deux structures RealArray, il est nécessaire de les détruire quand un tel instrument devient inutile.
Fournissez alors une fonction Instrument_destroy() attendant en paramètre un pointeur vers une structure Instrument et ne renvoyant aucun résultat.
Elle se contente d'invoquer RealArray_destroy() sur les membres freq_factor et amplitude de la structure Instrument désignée par le pointeur.

Le programme de test prog_note.c se contente pour l'instant de créer un instrument avec Instrument_init(), d'afficher lisiblement toutes ses propriétés✍ puis de le détruire avec Instrument_destroy().

Nous cherchons dorénavant à jouer des notes de musique avec l'instrument préparé.
Dans un premier temps nous le ferons de manière extrêmement simplifiée en ignorant l'enveloppe sonore de l'instrument (nous y reviendrons juste après).

Ajoutez au module instrument.h/instrument.c une fonction play_note() ne renvoyant aucun résultat mais attendant les paramètres suivants : La démarche consiste à passer en revue les partiels de l'instrument pour produire la sinusoïde correspondante pour chacun d'eux.
À chaque itération on considère un élément du membre freq_factor et un élément du membre amplitude :

Le programme de test peut être complété en préparant samples et sample_rate comme à cette étape.
Invoquez alors la fonction play_note() en exploitant l'instrument créé précédemment pour jouer avec un volume de 0.25 : Complétez par une sauvegarde dans le fichier "output_note.samples" en suivant la démarche utilisée à cette étape.
Après production du fichier sonore équivalent, vous devriez entendre des notes qui démarrent et s'arrêtent abruptement.

La combinaison des partiels réalisée à l'étape précédente est très loin d'être suffisante pour représenter une note jouée par un instrument.
La contribution de l'enveloppe sonore doit maintenant être introduite pour améliorer significativement la qualité de ces notes.

Pour prendre en compte l'enveloppe sonore de l'instrument, il est nécessaire de générer la séquence des amplitudes qui concernent chaque échantillon à produire pour décrire la note à jouer.
Pour cela, il faut étudier avec attention la signification des paramètres A, D, S et R de l'enveloppe.
Remarquons en particulier que :

Nous aurons besoin de compléter le module instrument.h/instrument.c avec une fonction make_envelope().
Elle doit renvoyer comme résultat une structure RealArray contenant la séquence des amplitudes décrivant l'enveloppe sonore attendue, en fonction des paramètres suivants :

La fonction play_note() doit maintenant être remaniée pour exploiter la fonction make_envelope().
Elle n'utilisera plus du tout la fonction add_sine() mais devra en reproduire quelques portions.
En voici les étapes :

Le test précédemment réalisé doit pouvoir être réutilisé tel quel.
Il permet maintenant de percevoir l'effet des enveloppes sonores de l'instrument sur les quelques notes jouées.
Au delà de l'écoute, l'utilisation d'un outil graphique tel que audacity permet de visualiser clairement la contribution de l'enveloppe sonore dans le signal généré.

L'instrument que nous avons utilisé jusqu'alors avait des propriétés fournies par défaut afin d'effectuer nos premiers essais pour produire des notes de musique.
Nous envisageons désormais de charger les propriétés d'un instrument depuis un fichier qui les décrit.
À cette fin, commencez par placer les fichiers suivants dans votre répertoire de travail : Étudiez le contenu de ces fichiers afin de constater que nous y trouvons exactement les informations qui permettent de renseigner les membres d'une structure Instrument.

Complétez le module instrument.h/instrument.c avec une fonction Instrument_load() qui sert à fabriquer un instrument à partir des propriétés inscrites dans un fichier.
Elle attend un unique paramètre filename de type const char * et renvoie comme résultat une structure Instrument.
La lecture du contenu d'un fichier textuel est décrite dans cette section.
La démarche pour réaliser notre fonction est la suivante :

Pour tester cette nouvelle fonctionnalité, il suffit de remplacer, dans le programme de test, l'usage de Instrument_init() par celui de Instrument_load() en précisant un nom de fichier de votre choix parmi ceux que vous venez de télécharger.
Modifiez ce choix à plusieurs reprises afin d'entendre la différence dans les fichiers sonores générés.

Nous envisageons maintenant de donner à notre programme la possibilité d'exploiter des consignes passées comme des mots supplémentaires sur sa ligne de commande lorsque nous le lançons.
Nous cherchons alors à préciser une fréquence et le nom du fichier décrivant l'instrument devant jouer une note à cette fréquence.

L'accès à la séquence de mots qui constitue la ligne de commande du programme en cours d’exécution est décrit dans cette section.
Ajoutez alors à la fonction main() de votre programme de test les paramètres argc et argv conformes à cette description.

La première vérification à effectuer concerne le nombre de mots sur la ligne de commande.
Après le nom du programme lui même, nous attendons un mot correspondant à la fréquence et un autre désignant le fichier d'instrument, ce qui fait trois mots en tout.
Si argc (argument counter) ne vaut pas trois, il faut afficher un message d'erreur explicite et mettre fin au programme.

Le mot qui décrit la fréquence est l'élément numéro 1 du tableau argv (argument values).
Seulement, il s'agit d'une chaîne de caractère et non d'une valeur réelle.
Nous devons donc analyser cette chaîne dans l'espoir d'y retrouver la description textuelle d'une valeur réelle.
Vous trouverez dans cette section l'usage de la fonction standard sscanf() adaptée à cette tâche ; son fonctionnement est très proche de la fonction fscanf() déjà utilisée lors de la lecture d'un fichier.
La chaîne à analyser sera argv[1], la chaîne de format sera "%lg" et il faudra mettre à jour une variable réelle frequency préalablement déclarée.
Puisqu'une seule valeur est à extraire, le résultat 1 est attendu.
Si le résultat est autre ou si la fréquence extraite est négative ou nulle, il faut afficher un message d'erreur explicite et mettre fin au programme.

Le mot qui indique le nom du fichier décrivant l'instrument à utiliser est l'élément numéro 2 du tableau argv.
Il suffit donc de passer argv[2] comme paramètre à la fonction Instrument_load().
Si l'instrument obtenu n'indique aucun élément pour son membre freq_factor, cela signifie que le chargement a échoué ; il faut alors afficher un message d'erreur explicite et mettre fin au programme.
En cas de succès du chargement de l'instrument, il sera intéressant d'afficher ses propriétés comme nous le faisions aux étapes précédentes.

Il ne reste plus qu'à préparer sample_rate et samples comme nous en avons l'habitude désormais afin de jouer la note choisie.
Pour cela, nous utiliserons à nouveau play_note() pour jouer la note avec l'instrument et la fréquence choisis, le volume 0.25, pendant 0.75 secondes à partir de l'instant 0.0.
Complétez, comme précédemment, par une sauvegarde dans le fichier "output_note.samples" puis libérez les ressources.

Ce programme s'utilisera de la façon suivante, par exemple : Après la production du fichier sonore équivalent à "output_note.samples", vous devriez entendre la note choisie.

Si vous le souhaitez, vous pouvez reproduire le même motif musical de quelques notes que nous utilisions à partir de cette étape.
Il suffit d'utiliser, pour la deuxième note, la fréquence choisie multipliée par 0.6674 et pour la troisième note, la fréquence choisie multipliée par 0.8409.

La dernière étape consiste en une réutilisation des manières de faire précédentes pour fournir un programme fonctionnant de cette façon : Après le nom du programme, les arguments de la ligne de commande s'interprètent de cette façon : Ce fichier nous servira de partie musicale : scale.part✎.
Étudiez-en le contenu afin de constater que nous y retrouvons, de manière répétée, les informations habituelles qui nous servent à décrire une note de musique.

Commencez par créer un nouveau programme prog_part.c qui prendra place dans le même répertoire de travail.
De manière très similaire au précédent :

La portion centrale du programme qui doit être remaniée consistera en un appel à un nouvelle fonction play_part() du module instrument.h/instrument.c.
Elle renvoie comme résultat un booléen indiquant son succès.
Les paramètres qu'elle attend sont les suivants : Les quatre premiers paramètres s'interprètent comme nous en avons l'habitude désormais.
Le cinquième indique le nom d'un fichier qui décrit la succession de notes à jouer avec l'instrument et le volume choisis.

Pour ce qui est de la lecture d'informations depuis un fichier, il suffit de s'inspirer de ce qui a été effectué dans la fonction Instrument_load() :

Le programme invoqué d'une manière similaire à ce qui est indiqué au tout début de cette section, doit produire un fichier qui, une fois transformé en fichier sonore vous permettra d'entendre la partie musicale.