# Συντονιστής κιθάρας (C)

Χρησιμοποιήστε GTK+ και GStreamer για να φτιάξετε ένα απλό πρόγραμμα συντονιστή κιθάρας για το GNOME. Αναδεικνύει πώς να χρησιμοποιήσετε τον σχεδιαστή διεπαφών.
Έργο τεκμηρίωσης GNOME
gnome-doc-list@gnome.org
Johannes Schmid
jhs@gnome.org
Marta Maria Casetti
mmcasetti@gmail.com 2013
Ελληνική μεταφραστική ομάδα GNOME
team@gnome.gr 2012-2015
Δημήτρης Σπίγγος
dmtrs32@gmail.com 2012, 2013
Μαρία Θουκιδίδου
marablack3@gmail.com 2014
Θάνος Τρυφωνίδης
tomtryf@gmail.com 2014, 2015

# Συντονιστής κιθάρας

      Σε αυτόν τον οδηγό, θα φτιάξουμε ένα πρόγραμμα που παίζει μουσικούς τόνους και μπορεί να συντονίσει μια κιθάρα. Θα μάθετε να:

        Ρυθμίζετε το κύριο έργο στο Anjuta
        Δημιουργείτε απλό GUI με τον σχεδιαστή UI του Anjuta
        Χρησιμοποιείτε το GStreamer για να παίζετε ήχους

      Θα χρειαστείτε τα παρακάτω για να μπορέσετε να ακολουθήσετε αυτό το μάθημα:

        Ένα εγκατεστημένο αντίγραφο του Anjuta IDE
        Βασική γνώση της γλώσσας προγραμματισμού C

# Δημιουργία έργου με το Anjuta

Πριν ξεκινήσετε να προγραμματίζετε, πρέπει να δημιουργήσετε ένα καινούργιο έργο στο Anjuta. Έτσι θα δημιουργηθούν όλα τα απαραίτητα αρχεία που χρειάζονται για την εκτέλεση του κώδικα αργότερα. Επίσης θα ήταν χρήσιμο να τα κρατάτε όλα μαζί.

Ξεκινήστε το Anjuta και πατήστε αρχείο νέο έργο για να ανοίξετε τον οδηγό του έργου.

Επιλέξτε GTK+ (απλό) από την καρτέλα C, πατήστε συνέχεια, και συμπληρώστε τις λεπτομέρειές σας στις επόμενες λίγες σελίδες. Χρησιμοποιήστε το guitar-tuner ως όνομα του έργου και του καταλόγου.

Βεβαιωθείτε ότι το ρύθμιση εξωτερικών πακέτων είναι ενεργό. Στην επόμενη σελίδα, επιλέξτε gstreamer-0.10 από τη λίστα για συμπερίληψη της βιβλιοθήκης GStreamer στο έργο σας.

Πατήστε εφαρμογή και το έργο θα δημιουργηθεί για σας. Ανοίξτε το src/main.c από τις καρτέλες έργο ή αρχείο. Θα πρέπει να δείτε κάποιο κώδικα που ξεκινάει με τις γραμμές:

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

# Κατασκευάστε τον κώδικα για πρώτη φορά

Η C είναι μια μάλλον αναλυτική γλώσσα, έτσι μην εκπλαγείτε που το αρχείο περιέχει πολύ κώδικα. Ο περισσότερος κώδικας είναι πρότυπο κώδικα. Φορτώνει ένα (κενό) παράθυρο από την περιγραφή διεπαφής χρήστη και το εμφανίζει. Περισσότερες λεπτομέρειες δίνονται πιο κάτω· προσπεράστε αυτή τη λίστα αν καταλαβαίνετε τα βασικά:

Οι τρεις γραμμές `#include` στην κορυφή περιλαμβάνουν τον `config` (ορίζει χρήσιμη κατασκευή του autoconf), `gtk` (διεπαφή χρήστη) και βιβλιοθήκες `gi18n` (διεθνοποίηση). Συναρτήσεις από αυτές τις βιβλιοθήκες χρησιμοποιούνται στον υπόλοιπο κώδικα.

Ο συνάρτηση `create_window` δημιουργεί ένα νέο παράθυρο ανοίγοντας ένα αρχείο GtkBuilder (src/guitar-tuner.ui, που ορίζεται λίγες γραμμές παραπάνω), συνδέοντας τα σήματά του και έπειτα εμφανίζοντας τα σε παράθυρο. Αυτό το αρχείο GtkBuilder περιέχει μια περιγραφή μιας διεπαφής χρήστη και όλων των στοιχείων του. Μπορείτε να χρησιμοποιήσετε τον επεξεργαστή του Anjuta για σχεδίαση διεπαφών χρήστη GtkBuilder.

Σύνδεση σημάτων είναι πώς καθορίζετε τι συμβαίνει όταν πατάτε ένα κουμπί, ή όταν συμβεί κάποιο άλλο συμβάν. Εδώ, καλείται η συνάρτηση `destroy` (και τερματίζει την εφαρμογή) όταν κλείνετε το παράθυρο.

Η συνάρτηση `main` τρέχει από προεπιλογή όταν ξεκινάτε μια εφαρμογή C. Καλεί λίγες συναρτήσεις που ρυθμίζουν και έπειτα εκτελούν την εφαρμογή. Η συνάρτηση `gtk_main` ξεκινά τον κύριο βρόχο του GTK, που εκτελεί τη διεπαφή χρήστη και ξεκινά την απάντηση για συμβάντα (όπως κλικ και πατήματα κουμπιών).

Ο υπό όρους ορισμός `ENABLE_NLS` εγκαθιστά `gettext`, που είναι ο σκελετός για μετάφραση εφαρμογών. Αυτές οι συναρτήσεις ορίζουν πώς τα εργαλεία μετάφρασης θα χειριστούν την εφαρμογή σας όταν τις εκτελείτε.

Αυτός ο κώδικας είναι έτοιμος να χρησιμοποιηθεί, οπότε μπορείτε να τον μεταγλωττίσετε με κλικ κατασκευή κατασκευή έργου (ή πιέζοντας Shift F7).

Πατήστε Execute στο επόμενο παράθυρο που εμφανίζεται για ρύθμιση κατασκευής αποσφαλμάτωσης. Χρειάζεται να το κάνετε αυτό μόνο μια φορά, για την πρώτη κατασκευή.

# Δημιουργία της διεπαφής χρήστη

Μια περιγραφή της διεπαφής χρήστη (UI) περιέχεται στο αρχείο GtkBuilder. Για να επεξεργαστείτε τη διεπαφή χρήστη, ανοίξτε το src/guitar_tuner.ui. Θα βρεθείτε στο σχεδιαστή διεπαφής. Το παράθυρο σχεδίασης είναι στο κέντρο· τα γραφικά στοιχεία και οι ρυθμίσεις τους είναι στα αριστερά, η παλέτα με τα διαθέσιμα γραφικά στοιχεία στα δεξιά.

Η διάταξη κάθε διεπαφής χρήστη σε Gtk+ οργανώνεται σε κουτιά και πίνακες. Ας χρησιμοποιήσουμε εδώ ένα κάθετο GtkButtonBox για να τοποθετήσουμε έξι GtkButtons, ένα για κάθε μία από τις χορδές της κιθάρας.

Διαλέξτε ένα GtkButtonBox από το τμήμα Container στην Παλέτα στο δεξιά και προσθέστε το στο παράθυρο. Στο φάτνωμα Ιδιότητες καθορίστε τον αριθμό των στοιχείων σε 6 (για τις έξι χορδές της κιθάρας) και τον προσανατολισμό σε κάθετο.

Τώρα, διαλέξτε ένα GtkButton από την παλέτα και βάλτε το στο πρώτο μέρος του κουτιού.

Έχοντας το κουμπί ακόμα επιλεγμένο, αλλάξτε την Ετικέτα στην καρτέλα Γραφικά στοιχεία σε E. Αυτή θα είναι η χαμηλή χορδή Ε.

Πηγαίνετε στην καρτέλα Σήματα (μέσα στην καρτέλα Γραφικά στοιχεία) και βρείτε το σήμα `clicked` του κουμπιού. Μπορείτε να το χρησιμοποιήσετε για να συνδέσετε έναν χειριστή σημάτων που θα καλείται όταν πατηθεί το κουμπί από τον χρήστη. Για να το κάνετε αυτό, πατήστε πάνω στο σήμα και πληκτρολογήστε `on_button_clicked` στη στήλη χειριστής και πατήστε Επιστροφή.

Επαναλάβετε τα παραπάνω βήματα για τα υπόλοιπα κουμπιά, προσθέστε τις επόμενες 5 χορδές με τα ονόματα A, D, G, B, και e.

Αποθηκεύστε τη σχεδίαση UI (πατώντας αρχείο αποθήκευση) και κρατήστε το ανοιχτό.

# Δημιουργία χειριστή σημάτων

Στον σχεδιαστή διεπαφών χρήστη, κάνατε όλα τα κουμπιά να καλούν την ίδια συνάρτηση, on_button_clicked, όταν πατηθούν. Πρέπει να προσθέσουμε αυτή την συνάρτηση στο πηγαίο κώδικα.

Για να το κάνετε αυτό, ανοίξτε το main.c, έχοντας ανοιχτό και το αρχείο της διεπαφής χρήστη. Πηγαίνετε στην καρτέλα σήματα που ήδη χρησιμοποιήσατε για να ορίσετε το όνομα του σήματος. Τώρα πάρτε τη γραμμή όπου είχατε ορίσει το σήμα πατημένο και σύρετε την στο πηγαίο αρχείο σε μια θέση που είναι έξω από κάθε συνάρτηση. Ο ακόλουθος κώδικας θα προστεθεί στο πηγαίο αρχείο:

void on_button_clicked (GtkWidget* button, gpointer user_data) {

}

Αυτός ο χειριστής σήματος έχει δύο ορίσματα: ένα δείκτη στο `GtkWidget` που κάλεσε τη συνάρτηση (στην περίπτωση μας, πάντοτε ένα `GtkButton`) και ένα δείκτη στο κάποια "δεδομένα χρήστη" που μπορείτε να ορίσετε, αλλά τα οποία δεν θα χρησιμοποιήσουμε εδώ. (Μπορείτε να ορίσετε τα δεδομένα χρήστη καλώντας `gtk_builder_connect_signals`; χρησιμοποιείται κανονικά για το πέρασμα ενός δείκτη σε μια δομή δεδομένων που ίσως χρειαστείτε να προσπελάσετε στο χειριστή σήματος.)

Για την ώρα, θα αφήσουμε το χειριστή σημάτων άδειο καθώς θα ασχοληθούμε με το γράψιμο του κώδικα που θα παράγει τους ήχους.

# Διοχετεύσεις GStreamer

Το Gtreamer είναι ο σκελετός πολυμέσων του GNOME — μπορείτε να το χρησιμοποιήσετε για να αναπαράγετε, ηχογραφήσετε, και να επεξεργαστείτε βίντεο, ήχο, ροές βίντεο και τα λοιπά. Εδώ, θα το χρησιμοποιήσουμε για να παράγουμε μονές-συχνότητες τόνων.

Εννοιολογικά, το GStreamer λειτουργεί ως εξής: δημιουργείς μια διοχέτευση που περιέχει διάφορα επεξεργαζόμενα στοιχεία που πηγαίνουν από την πηγή στην έξοδο. Η πηγή μπορεί να είναι ένα αρχείο εικόνας, βίντεο, ή και μουσικής, για παράδειγμα, και η έξοδος μπορεί να είναι ένα γραφικό στοιχείο ή η κάρτα ήχου.

Ανάμεσα στην πηγή και στην έξοδο, μπορείτε να εφαρμόσετε διάφορα φίλτρα και οι μετατροπείς να χειριστούν εφέ, μετατροπές μορφών και λοιπά. Κάθε στοιχείο της διοχέτευσης έχει ιδιότητες που μπορούν να χρησιμοποιηθούν για να αλλάξουν τη συμπεριφορά τους.

Ένα παράδειγμα διοχέτευσης GStreamer.

# Ρύθμιση της διοχέτευσης

Σε αυτό το απλό παράδειγμα θα χρησιμοποιήσουμε μια πηγή παραγωγής τόνων, την `audiotestsrc` και θα στείλουμε την έξοδο στην προεπιλεγμένη συσκευή ήχου του συστήματος, `autoaudiosink`. Πρέπει μόνο να ρυθμίσουμε την συχνότητα της παραγωγής τόνου· αυτό είναι εφικτό μέσα από την ρύθμιση `freq` του `audiotestsrc`.

Εισάγετε την παρακάτω γραμμή στο main.c, ακριβώς κάτω από τη γραμμή `#include <gtk/gtk.h>`:

#include <gst/gst.h>

Αυτό περιλαμβάνει τη βιβλιοθήκη του GStreamer. Χρειάζεται επίσης να προσθέσουμε μια γραμμή για αρχικοποίηση του GStreamer· βάλτε τον παρακάτω κώδικα στην γραμμή πάνω από την κλήση `gtk_init` στη συνάρτηση `main`:

gst_init (&argc, &argv);

Μετά, αντιγράψτε την ακόλουθη συνάρτηση στην main.c πάνω από την κενή συνάρτηση `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); }

Οι τρεις πέντε γραμμές δημιουργούν τα στοιχεία πηγή και έξοδος του GStreamer (`GstElement`) και ένα στοιχείο διοχέτευσης (το οποίο θα χρησιμοποιηθεί ως περιέκτης για τα δυο άλλα στοιχεία). Δίνουμε το όνομα "note" στη διοχέτευση· ονομάζουμε την πηγή "source" και το ρυθμίζετε στην πηγή `audiotestsrc`· και ονομάζουμε την έξοδο "output" και την ρυθμίζετε στην έξοδο `autoaudiosink` (προεπιλεγμένη έξοδος κάρτας ήχου).

Το κάλεσμα του `g_object_set` ορίζει την ιδιότητα `freq` του στοιχείου πηγή σε `frequency`, η οποία έχει περαστεί ως όρισμα στη συνάρτηση `play_sound`. Αυτή είναι μόνο η συχνότητα της νότας σε Hertz· μερικές χρήσιμες συχνότητες θα οριστούν αργότερα.

Ο `gst_bin_add_many` βάζει την πηγή και την έξοδο στη διοχέτευση. Η διοχέτευση είναι ένας `GstBin`, που είναι μόλις ένα στοιχείο που μπορεί να περιέχει πολλαπλά άλλα στοιχεία GStreamer. Γενικά, μπορείτε να προσθέσετε όσα στοιχεία θέλετε στη διοχέτευση προσθέτοντας περισσότερα ορίσματα στον `gst_bin_add_many`.

Κατόπιν, ο `gst_element_link` χρησιμοποιείται για σύνδεση των στοιχείων μαζί, έτσι η έξοδος του `source` (ένας τόνος) πηγαίνει στην είσοδο της `sink` (που είναι έπειτα έξοδος στην κάρτα ήχου). Το `gst_element_set_state` χρησιμοποιείται έπειτα για έναρξη αναπαραγωγής, ορίζοντας την κατάσταση της διοχέτευσης να παίξει (`GST_STATE_PLAYING`).

# Διακοπή αναπαραγωγής

Δεν θέλουμε να παίζουμε έναν ενοχλητικό ήχο για πάντα, οπότε το τελευταίο πράγμα που κάνει η `play_sound` είναι να καλεί το `g_timeout_add`. Αυτό ορίζει ένα χρονικό περιθώριο που θα σταματήσει τον ήχο· περιμένει για `LENGTH` ms πριν καλέσει τη συνάρτηση `pipeline_stop`, και θα συνεχίσει να την καλεί μέχρι η `pipeline_stop` να επιστρέψει `False`.

Τώρα θα γράψουμε τη συνάρτηση `pipeline_stop`, η οποία καλείται από το `g_timeout_add`. Προσθέστε τον ακόλουθο κώδικα πάνω από τη συνάρτηση `play_sound`:

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

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

return FALSE; }

Η κλήση σε `gst_element_set_state` σταματά την αναπαραγωγή της διοχέτευσης και ο `g_object_unref` σταματά την αναφορά στη διοχέτευση, καταστρέφοντας την και ελευθερώνοντας τη μνήμη της.

# Ορισμός των τόνων

Θέλουμε να παίζουμε το σωστό ήχο όταν ο χρήστης πατά ένα κουμπί. Πρώτα από όλα, θέλουμε να ξέρουμε τις συχνότητες για τις έξι χορδές της κιθάρας, οι οποίες ορίζονται (στην αρχή του main.c) ως ακολούθως:

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

Για να δούμε τον χειριστή σημάτων που ορίσαμε πριν, `on_button_clicked`. Θα μπορούσαμε να είχαμε συνδέσει όλα τα κουμπιά σε διαφορετικό χειριστή σημάτων, αλλά αυτό θα οδηγούσε σε πολλές επαναλήψεις του κώδικα. Αντί αυτού, μπορούμε να χρησιμοποιήσουμε τις ετικέτες στα κουμπιά για να δούμε ποιο πατήθηκε:

/* Callback for the buttons */ void on_button_clicked (GtkButton* button, gpointer user_data) { const gchar* text = gtk_button_get_label (button);

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); }

Ο δείκτης στο `Gtk.Button` που πατήθηκε περνά ως όρισμα (`button`) στο `on_button_clicked`. Μπορούμε να πάρουμε το κείμενο αυτού του κουμπιού χρησιμοποιώντας `gtk_button_get_label`.

Το κείμενο έπειτα συγκρίνεται με τις νότες που έχουμε χρησιμοποιήσει `g_str_equal` και `play_sound` καλείται με την κατάλληλη συχνότητα για αυτήν την νότα. Αυτό παίζει τον τόνο· ο συντονιστής κιθάρας είναι έτοιμος!

# Κατασκευή και εκτέλεση της εφαρμογής

Όλος ο κώδικας πρέπει να είναι έτοιμος τώρα. Κλικ κατασκευή κατασκευή έργου για ανακατασκευή των πάντων και έπειτα τρέξιμο εκτέλεση για έναρξη της εφαρμογής.

Εάν δεν το έχετε ήδη κάνει, επιλέξτε την εφαρμογή Debug/src/guitar-tuner στον διάλογο που εμφανίζεται. Τελικά, πατήστε τρέξιμο και απολαύστε!

# Υλοποίηση αναφοράς

Αν αντιμετωπίσετε προβλήματα με το μάθημα, συγκρίνετε τον κώδικά σας με αυτόν τον κώδικα αναφοράς.

# Επόμενα βήματα

Εδώ είναι κάποιες ιδέες για το πώς μπορείτε να επεκτείνετε αυτή την απλή παρουσίαση:

Βάλτε το πρόγραμμα να περνάει αυτόματα μέσα από τις νότες.

Κάντε το πρόγραμμα να αναπαράγει ηχογραφήσεις από αληθινές χορδές κιθάρας που έχουν εισαχθεί.

Για να το κάνετε αυτό, πρέπει να ρυθμίσετε μια πιο περίπλοκη διοχέτευση GStreamer που θα σας επιτρέπει να φορτώνετε και να αναπαράγετε αρχεία ήχου. Θα πρέπει να διαλέξετε τα στοιχεία GStreamer decoder και demuxer με βάση τον τύπο του αρχείου των ηχογραφημένων ήχων — για παράδειγμα το MP3 χρησιμοποιεί διαφορετικά στοιχεία από το Ogg Vorbis.

Ίσως χρειαστεί να συνδέσετε τα στοιχεία με πιο περίπλοκους τρόπους. Αυτό μπορεί να συμπεριλαμβάνει τη χρήση Εννοιών GStreamer που δεν καλύπτουμε σε αυτόν τον οδηγό, όπως και pad. Ίσως βρείτε χρήσιμη και την εντολή gst-inspect.

Αυτόματη ανάλυση νότων που παίζει ο χρήστης.

Μπορείτε να συνδέσετε μικρόφωνο και να ηχογραφήσετε από αυτό χρησιμοποιώντας την πηγή εισόδου. Ίσως κάποια μορφή της ανάλυσης φάσματος θα σας βοηθούσε να καταλάβετε ποια νότα παίζει;