# Guitar Tuner (C)

Utilisation de Gtk+ et de GStreamer pour construire une application d'accordeur de guitare simple pour GNOME. Explications sur la manière d'utiliser le concepteur d'interface.
Projet de Documentation GNOME
gnome-doc-list@gnome.org
Johannes Schmid
jhs@gnome.org

# Accordeur de guitare

      Dans ce tutoriel, nous allons écrire un programme qui émet des sons servant à accorder une guitare. Nous allons apprendre comment :

        créer un projet basique dans Anjuta,
        créer une interface graphique simple avec le concepteur d'interface utilisateur d'Anjuta,
        utiliser GStreamer pour émettre des sons.

      Vous avez besoin de ce qui suit pour pouvoir suivre ce tutoriel :

        l'installation du paquet Anjuta IDE,
        des connaissances de base de la programmation en langage C

# Création d'un projet dans Anjuta

Avant de commencer à programmer, vous devez ouvrir un nouveau projet dans Anjuta. Ceci crée tous les fichiers qui vous sont nécessaires pour construire et exécuter votre programme plus tard. C'est aussi utile pour tout regrouper en un seul endroit.

Lancez Anjuta et cliquez sur Fichier Nouveau Projet pour ouvrir l'assistant de création de projet.

Sélectionnez Gtk+ (Simple) dans l'onglet C, cliquez sur Continuer et saisissez vos informations sur les pages suivantes. Utilisez guitar-tuner comme nom de projet et de répertoire.

Assurez-vous que Configuration des paquets externes est basculée sur I. Sur la page suivante, choisissez gstreamer-0.10 dans la liste pour inclure la bibliothèque GStreamer à votre projet.

Cliquez sur Appliquer et votre projet est créé. Ouvrez src/main.c depuis l'onglet Projet ou l'onglet Fichiers. Vous devez voir apparaître du code commençant par les lignes :

#include <config.h> #include <gtk/gtk.h>

# Première construction du programme

« C » est un langage plutôt verbeux, donc ne soyez pas surpris par la quantité de code que contient le fichier. La plupart du code est générique. Il charge une fenêtre (vide) à partir du fichier de description de l'interface et l'affiche. Vous trouverez plus de détails ci-dessous ; passez cette liste si vous comprenez les bases :

Les trois lignes `#include` du haut incorporent les bibliothèques `config` (définitions utiles pour la construction autoconf), `gtk` (interface utilisateur) et `gi18n` (pour internationalisation). Les fonctions de ces bibliothèques seront utilisées dans le reste du programme.

La fonction `create_window` crée une nouvelle fenêtre en ouvrant un fichier GtkBuilder (src/guitar-tuner.ui, défini quelques lignes plus haut), en connectant ses signaux et en l'affichant dans une fenêtre. Le fichier GtkBuilder contient une description de l'interface utilisateur et de tous ses éléments. Vous pouvez utiliser l'éditeur d'Anjuta pour concevoir des interfaces utilisateur GtkBuilder.

Connecter des signaux, c'est décider de ce qui doit se passer quand on appuie sur un bouton ou quand quelque chose d'autre se produit. Ici, la fonction `destroy` est appelée (et quitte l'application) quand la fenêtre est fermée.

La fonction `main` est exécutée par défaut quand vous lancez une application C. Elle appelle d'autres fonctions qui configurent puis lancent l'application. La fonction `gtk_main` démarre la boucle principale de GTK, qui lance l'interface utilisateur et commence à écouter les événements (comme des clics de souris ou des appuis sur des touches).

La définition conditionnelle `ENABLE_NLS` configure `gettext` qui est un environnement pour la traduction des applications. Ces fonctions définissent la façon dont les objets de traduction doivent prendre en charge votre application quand vous l'exécutez.

Le programme est prêt à être utilisé, donc vous pouvez le compiler en cliquant sur Construire Construire le projet ou en appuyant sur Maj F7.

Cliquez sur Exécuter dans la fenêtre suivante pour configurer une construction avec débogage. Vous ne devez le faire qu'une seule fois, lors de la première exécution.

# Création de l'interface utilisateur

Une description de l'interface utilisateur est contenue dans le fichier GtkBuilder. Pour la modifier, ouvrez le fichier src/guitar_tuner.ui. Ceci vous bascule vers le concepteur d'interface. La fenêtre de conception se trouve au centre ; les éléments graphiques et leurs propriétés sont sur la gauche et la palette des composants graphiques disponibles est sur la droite.

La disposition de toute interface utilisateur dans GTK+ est organisée à l'aide de boîtes et de tableaux. Dans cet exemple, prenons une GtkButtonBox verticale pour y mettre six GtkButtons, un pour chacune des six cordes de la guitare.

Choisissez une GtkButtonBox (Boîte) dans la section Conteneurs de la Palette à droite et mettez-la dans la fenêtre. Dans l'onglet Propriétés, définissez le nombre d'éléments à 6 (pour les six cordes) et l'orientation à verticale.

Ensuite, choisissez un GtkButton (Bouton) dans la palette et mettez-le dans la première partie de la boîte.

Pendant que le bouton est encore sélectionné, modifiez la propriété Étiquette dans l'onglet Composants graphiques à E. C'est la corde E du bas.

Passez à l'onglet Signaux (dans l'onglet Composants graphiques) et recherchez le signal `clicked` du bouton. Vous pouvez l'utiliser pour connecter un gestionnaire de signal qui sera appelé quand le bouton est cliqué. Pour cela, cliquez sur le signal et saisissez `on_button_clicked` dans la colonne Gestionnaire et appuyez sur Entrée.

Répétez cette procédure pour les autres boutons, ce qui ajoute les 5 autres cordes nommées A, D, G, B et e.

Enregistrez le fichier de conception de l'interface utilisateur (en cliquant sur Fichier Enregistrer) et laissez-le ouvert.

# Création du gestionnaire de signal

Dans le concepteur d'interface utilisateur, il a été fait en sorte que tous les boutons appellent la même fonction, on_button_clicked quand ils sont cliqués. Nous devons ajouter cette fonction dans notre fichier source.

Pour cela, ouvrez main.c pendant que le fichier de l'interface utilisateur est encore ouvert. Allez au même onglet Signaux que vous aviez déjà utilisé pour nommer le signal. Prenez la ligne où vous aviez défini le signal clicked et faites la glisser quelque part à l'extérieur d'une fonction dans le fichier source. Le code suivant s'ajoute à votre fichier source :

void on_button_clicked (GtkWidget* button, gpointer user_data) {

}

Ce récepteur de signal a deux arguments : un pointeur vers le `GtkWidget` qui a appelé la fonction (dans notre cas, toujours un `GtkButton`) et un pointeur sur des « données utilisateur » (user_data) que vous pouvez définir, mais que nous n'utilisons pas ici (les données utilisateur peuvent être définies par un appel à la fonction `gtk_builder_connect_signals` ; il sert normalement à transmettre un pointeur à une structure de données auxquelles vous pouvez avoir besoin d'accéder à l'intérieur du gestionnaire de signal).

Laissons le gestionnaire de signal vide pour l'instant et écrivons le code qui produit les sons.

# Les pipelines GStreamer

GStreamer est l'architecture multimédia de GNOME — vous pouvez vous en servir pour des jeux, des enregistrements, pour traiter des flux vidéo, audio, de webcam entre autres. Ici, nous allons nous en servir pour émettre des tonalités à une seule fréquence.

Le concept de GStreamer est le suivant : il y a création d'un pipeline contenant plusieurs éléments de traitement en provenance d'une source à destination d'un collecteur (sortie). La source peut être un fichier image, une vidéo ou un fichier musical, par exemple, et la sortie un élément graphique ou une carte son.

Entre la source et le collecteur, vous pouvez appliquer différents filtres et convertisseurs pour prendre en charge les effets, les conversions de format et ainsi de suite. Chaque élément du pipeline possède des propriétés pouvant être utilisées pour modifier son comportement.

Un exemple de pipeline GStreamer.

# Configuration du pipeline

Dans ce petit exemple, nous utilisons une source génératrice de son de fréquence pure appelée `audiotestsrc` et envoyons sa sortie au périphérique son par défaut du système, `autoaudiosink`. Il nous faut seulement configurer la fréquence du générateur accessible depuis la propriété `freq` de `audiotestsrc`.

Insérez la ligne suivante dans le fichier main.c, juste en dessous de la ligne `#include <gtk/gtk.h>` :

#include <gst/gst.h>

Cela inclut la bibliothèque de GStreamer. Ajoutez aussi une ligne pour initialiser GStreamer ; mettez le code suivant dans la ligne au-dessus de `gtk_init` dans la fonction `main` :

gst_init (&argc, &argv);

Ensuite, copiez la fonction suivante dans le fichier main.c au-dessus de la fonction vide `on_button_clicked` :

static void play_sound (gdouble frequency) { GstElement *source, *sink; GstElement *pipeline;

pipeline = gst_pipeline_new ("note"); source = gst_element_factory_make ("audiotestsrc", "source"); sink = gst_element_factory_make ("autoaudiosink", "output");

/* set frequency */ g_object_set (source, "freq", frequency, NULL);

gst_bin_add_many (GST_BIN (pipeline), source, sink, NULL); gst_element_link (source, sink);

gst_element_set_state (pipeline, GST_STATE_PLAYING);

/* stop it after 500ms */ g_timeout_add (LENGTH, (GSourceFunc) pipeline_stop, pipeline); }

Les cinq premières lignes créent les éléments GStreamer source et sink (collecteur) et un élément pipeline (qui sera utilisé comme conteneur pour les deux autres éléments). Le pipeline est nommé « note » ; la source est nommée « source » et définie comme étant le connecteur `audiotestsrc` et le collecteur est nommé « output » et défini comme étant le connecteur `autoaudiosink` (qui est la sortie par défaut de la carte son).

L'appel à `g_object_set` définit la propriété `freq` de l'élément source à `frequency` qui est transmis comme argument de la fonction `play_sound`. Il s'agit simplement de la fréquence de la note de musique en Hertz ; certaines fréquences utiles seront définies plus tard.

`gst_bin_add_many` place la source et le collecteur dans le pipeline. Le pipeline est un `GstBin` qui est juste un élément qui peut contenir beaucoup d'autres éléments GStreamer. En général, vous pouvez ajouter autant d'éléments que vous voulez au pipeline en ajoutant d'autres d'arguments à `gst_bin_add_many`.

Ensuite, `gst_element_link` est utilisé pour connecter les éléments ensemble, de sorte que la sortie de la source (une note) va à l'entrée du collecteur (et est ensuite envoyée à la carte son). `gst_element_set_state` sert enfin à démarrer la lecture en basculant l'état du pipeline à « playing » (lecture) (`GST_STATE_PLAYING`).

# Arrêt de la lecture

Comme nous ne voulons pas jouer indéfiniment une note ennuyeuse, la dernière chose que fait `play_sound` est d'appeler `g_timeout_add` qui définit un délai avant la coupure du son ; cela attend `LENGTH` millisecondes avant d'appeler la fonction `pipeline_stop` et continuera à l'appeler jusqu'à ce que `pipeline_stop` renvoie la valeur `FALSE`.

Écrivons maintenant la fonction `pipeline_stop` qui est appelée par `g_timeout_add`. Insérez le code suivant au-dessus de la fonction `play_sound` :

#define LENGTH 500 /* Length of playing in ms */

static gboolean pipeline_stop (GstElement* pipeline) { gst_element_set_state (pipeline, GST_STATE_PAUSED); g_object_unref (pipeline);

return FALSE; }

L'appel à `gst_element_set_state` met en pause la lecture du pipeline et `g_object_unref` déréférence le pipeline, le détruisant ainsi et effaçant sa mémoire.

# Définition des notes

Nous voulons jouer la note adéquate quand l'utilisateur clique sur un bouton. Avant tout, nous devons connaître la fréquence de chacune des six cordes de la guitare qui sont définies (au début du fichier main.c) ainsi :

/* Frequencies of the strings */ #define NOTE_E 369.23 #define NOTE_A 440 #define NOTE_D 587.33 #define NOTE_G 783.99 #define NOTE_B 987.77 #define NOTE_e 1318.5

Maintenant, nous allons étoffer le gestionnaire de signal `on_button_clicked` défini auparavant. Nous aurions pu connecter chaque bouton à un gestionnaire différent, mais cela aurait dupliqué beaucoup de code. Au lieu de ça, nous allons plutôt utiliser l'étiquette du bouton pour déterminer le bouton cliqué :

/* Callback for the buttons */ void on_button_clicked (GtkButton* button, gpointer user_data) { GtkWidget* label = gtk_bin_get_child (GTK_BIN (button)); const gchar* text = gtk_label_get_label (GTK_LABEL (label));

if (g_str_equal (text, _("E"))) play_sound (NOTE_E); else if (g_str_equal (text, _("A"))) play_sound (NOTE_A); else if (g_str_equal (text, _("G"))) play_sound (NOTE_G); else if (g_str_equal (text, _("D"))) play_sound (NOTE_D); else if (g_str_equal (text, _("B"))) play_sound (NOTE_B); else if (g_str_equal (text, _("e"))) play_sound (NOTE_e); }

Un pointeur vers le bouton `GtkButton` qui a été cliqué est transmis comme argument (`button`) à `on_button_clicked`. On peut obtenir l'étiquette de ce bouton en utilisant `gtk_bin_get_child` puis en extrayant le texte de cette étiquette avec `gtk_label_get_label`.

On compare ensuite le texte de cette étiquette à la note à l'aide de la fonction `g_str_equal` et `play_sound` est appelée avec la fréquence appropriée à cette note. Cela joue la note ; nous avons un accordeur de guitare opérationnel !

# Construction et lancement de l'application

À ce stade, tout le programme est fonctionnel. Cliquez sur Construire Construire le projet pour tout reconstruire et faites Exécuter Exécuter pour lancer l'application.

Si ce n'est déjà fait, choisissez l'application Debug/src/guitar-tuner dans la boîte de dialogue qui s'affiche. Enfin, cliquez sur Exécuter et amusez-vous !

# Implémentation de référence

Si vous rencontrez des difficultés avec ce tutoriel, comparez votre programme à ce programme de référence.

# Les étapes suivantes

Voici quelques idées sur la manière d'étendre ce simple exemple :

Faire que le programme joue automatiquement les notes de manière cyclique.

Faire que le programme lise des enregistrements de vraies cordes de guitare pincées.

Pour y parvenir, vous devrez configurer un pipeline GStreamer un peu plus sophistiqué qui vous permette de charger et lire des fichiers musicaux. Vous devrez choisir des éléments GStreamer décodeur et démuxeur basés sur le format des sons enregistrés — par exemple, les MP3 utilisent des éléments différents de ceux des fichiers Ogg Vorbis.

Il vous faudra aussi peut-être connecter les éléments de façon plus complexe. Vous aurez sans doute besoin de consulter les concepts GStreamer que nous ne couvrons pas dans ce tutoriel, comme les pads. La commande gst-inspect peut également vous être utile.

Analyser automatiquement les notes jouées par l'utilisateur.

Vous pourriez branchez un microphone et enregistrez les sons obtenus en utilisant l'entrée source. Peut-être qu'une espèce d'analyseur de spectre peut vous aider à trouver les notes jouées ?