Guitar tuner

Before you start coding, you'll need to set up a new project in Anjuta. This will create all of the files you need to build and run the code later on. It's also useful for keeping everything together.

This is a very basic C++ code setting up GTKmm. More details are given below; skip this list if you understand the basics:

This code is ready to be used, so you can compile it by clicking Build ▸ Build Project (or press Shift+F7).

Press Execute on the next window that appears to configure a debug build. You only need to do this once, for the first build.

A description of the user interface (UI) is contained in the GtkBuilder file. To edit the user interface, open src/guitar_tuner.ui. This will switch to the interface designer. The design window is in the center; widgets and widgets' properties are on the left, and the palette of available widgets is on the right.

The layout of every UI in GTK+ is organized using boxes and tables. Let's use a vertical GtkButtonBox here to assign six GtkButtons, one for each of the six guitar strings.

GStreamer is GNOME's multimedia framework — you can use it for playing, recording, and processing video, audio, webcam streams and the like. Here, we'll be using it to produce single-frequency tones. GStreamermm is the C++ binding to GStreamer which we will use here.

Conceptually, GStreamer works as follows: You create a pipeline containing several processing elements going from the source to the sink (output). The source can be an image file, a video, or a music file, for example, and the output could be a widget or the soundcard.

Between source and sink, you can apply various filters and converters to handle effects, format conversions and so on. Each element of the pipeline has properties which can be used to change its behaviour.

To use GStreamermm, it has to be initialised. We do that by adding the following line of code next to the Gtk::Main kit(argc, argv); line in main.cc:

	Gst::init (argc, argv);

While we are on it, also make sure that the gstreamermm.h is included in main.cc properly.

In this simple example we will use a tone generator source called audiotestsrc and send the output to the default system sound device, autoaudiosink. We only need to configure the frequency of the tone generator; this is accessible through the freq property of audiotestsrc.

To simplify the handling of the pipeline we will define a helper class Sound. We do that in main.cc in order to keep this example simple, whereas you might usually want to use a separate file:

class Sound
{
	public:
		Sound();

		void start_playing(double frequency);
		bool stop_playing();

	private:
		Glib::RefPtr<Gst::Pipeline> m_pipeline;
		Glib::RefPtr<Gst::Element> m_source;
		Glib::RefPtr<Gst::Element> m_sink;
};

Sound::Sound()
{
	m_pipeline = Gst::Pipeline::create("note");
	m_source = Gst::ElementFactory::create_element("audiotestsrc",
	                                               "source");
	m_sink = Gst::ElementFactory::create_element("autoaudiosink",
	                                             "output");
	m_pipeline->add(m_source);
	m_pipeline->add(m_sink);
	m_source->link(m_sink);
}

void Sound::start_playing (double frequency)
{
	m_source->set_property("freq", frequency);
	m_pipeline->set_state(Gst::STATE_PLAYING);

	/* stop it after 200ms */
	Glib::signal_timeout().connect(sigc::mem_fun(*this, &Sound::stop_playing),
	                               200);
}

bool Sound::stop_playing()
{
	m_pipeline->set_state(Gst::STATE_NULL);
	return false;
}

The code has the following purpose:

We want to play the correct sound when the user clicks a button. That means that we have to connect to the signal that is fired when the user clicks the button. We also want to provide information to the called function which tone to play. GTKmm makes that quite easy as we can easily bind information with the sigc library.

The function that is called when the user clicks a button can be pretty simple, as all the interesting stuff is done in the helper class now:

static void
on_button_clicked(double frequency, Sound* sound)
{
	sound->start_playing (frequency);
}

It only calls the helper class we defined before to play the correct frequencies. With some more clever code we would also have been able to directly connect to the class without using the function but we will leave that to use as an exercise.

The code to set up the signals should be added to the main() function just after the builder->get_widget("main_window", main_win); line:

Sound sound;
Gtk::Button* button;

builder->get_widget("button_E", button);
button->signal_clicked().connect (sigc::bind<double, Sound*>(sigc::ptr_fun(&on_button_clicked),
                                              329.63, &sound));

Now that we have set up the E button we also need to connect the other buttons according to their frequencies: 440 for A, 587.33 for D, 783.99 for G, 987.77 for B and 1318.5 for the high E. This is done in the same way, just passing a different frequency to the handler.

All of the code should now be ready to go. Click Build ▸ Build Project to build everything again, and then Run ▸ Run to start the application.

If you haven't already done so, choose the Debug/src/guitar-tuner application in the dialog that appears. Finally, hit Run and enjoy!

If you run into problems with the tutorial, compare your code with this reference code.

Many of the things shown above are explained in detail in the GTKmm book which also covers a lot more key concept for using the full power of GTKmm. You might also be interested in the GStreamermm reference documentation.

Here are some ideas for how you can extend this simple demonstration: