Let’s not get too far ahead of ourselves, though. What exactly is LinuxSampler, what’s it useful for, and perhaps most importantly, how do we use it?

LinuxSampler handles large sampled instruments with ease

LinuxSampler basics

LinuxSampler is a sample-based synth that lets you use very large sampled instruments. Rather than loading the entire instrument in to RAM, LinuxSampler loads just the start of each sample, and then reads the rest from disk as it’s needed. Because of this, it can load instruments much larger than your system would be able to handle with other software, such as Hydrogen or Fluidsynth/Qsynth.

Realistic piano sounds are perhaps the classic use for LinuxSampler — a good piano, like the Salamander Grand Piano, can reach 2GB or more in size — but it works just as well for electric pianos, guitars, violins, trumpets, drum kits (a personal favourite), or any other instrument that calls for large samples, or a lot of samples, to provide a realistic result.

LinuxSampler can be run standalone — it supports ALSA and JACK for both MIDI input and audio output, and can handle an arbitrary number of inputs and outputs mapped to different instruments. It can also run as a plugin; the LV2 plugin runs well under both Ardour 3 and Qtractor.

File formats

The inspiration for LinuxSampler was a Windows app called Gigasampler, which was the first sampler to incorporate on-demand streaming of sample data. It’s a standard feature in professional samplers today, and Gigasampler itself has been defunct for some time, but its legacy lives on in the “.gig” file format, which is also LinuxSampler’s primary file format.

You can still find some great commercial sample libraries in .gig format, but it’s definitely falling out of favour today. To address that, the development branch of LinuxSampler has added support for a new format called SFZ. It’s a young format, but it’s growing in popularity thanks to the availability of free SFZ plugins across all platforms. Also, because of its design (the SFZ file itself is a simple text file, separate from the actual sample data), you can download third-party SFZ mappings for some commercial instruments.

Even though .gig is fading away commercially, it’s still useful for bundling your own sounds. The LinuxSampler project includes a .gig editor called “gigedit”, which you can use to create your own instruments.

Hopefully you now have an idea of what LinuxSampler is and what it can do for you. Now all that remains is to learn how to install and configure it!

• Setting up Jconvolver
• Connecting Jconvolver in to Ardour as an insert effect
• Using sends effects within Ardour

There’s a lot to get through, so let’s get cracking!

Setting up Jconvolver

There are two ways to run Jconvolver: on the command-line with a config file, or using the Jcgui GUI tool. If you already have a config file, then the command-line tool is very easy to use — just specify the config file:

jconvolver pneuman-stairs.conf


The config itself looks like this:

/cd /home/lsd/music/impulses
/convolver/new   2    2    512  87296
/impulse/read    1    1    0.2  0    0    0    1 pneuman-stairs.wav
/impulse/copy    2 2  1 1

This creates a two-channel (ie: stereo) convolver setup, loading the “pneuman-stairs.wav” impulse response (IR) file from the “/home/lsd/music/impulses” directory. Because the IR file is in mono, it’s simply copied from the first channel to the second. For your own similar files, just change the IR file name, and possibly the “87296″ value — this is the maximum allowed length of the IR file (in samples), and it must be increased if a longer IR file is used.

Once running, Jconvolver just appears as a set of JACK ports — route some audio in to it, and it will output the reverb-processed version.

If that’s all a bit much, you can try Jcgui — it lets you load an IR file and then launch Jconvolver with an appropriate configuration. Jcgui also adds a bit of its own audio processing: there are tone controls, separate left and right delay controls, and a dry/wet control, so you can mix in some dry signal if you want (Jconvoler itself is always 100% wet). The delay controls can be used to add pre-delay on both channels, or if the delays are set to slightly different values, it can add some false, but potentially interesting, spatial effects.

Jcgui lets you configure Jconvolver interactively, with nary a text editor in sight

One problem with Jconvolver is that the only way to change its configuration is to restart it, which forces you to reconnect its JACK inputs and outputs. Jcgui actually gets around this quite nicely — it opens its own JACK inputs and outputs for you to connect your apps to, and automatically connects itself to Jconvolver when it launches it, so your can change your reverb settings as much as you like without having to reconnect anything manually.

Inserts effects in Ardour

Even if you’re not familiar with the term, you should be familiar with the behavour of an insert effect. An insert is an effect that takes a feed from a signal chain, processes the audio, and then returns the processed audio back in to the same point in the original signal chain. Whenever you add an EQ, a compressor, or any other plugin to a track, it acts as an insert effect, since the original audio signal is replaced in the signal chain by the plugin’s processed audio.

Adding an insert in Ardour (or any other DAW), then, is much like adding an external effect just as if it was a plugin — the insert takes the audio from the signal path, sends it out to some kind of external processing device, receives it back in after processing, and then feeds it back in to the original signal path. That external device could actually be a hardware effects unit, if it’s hooked up to your sound card, but thanks to the magic of JACK, it can just as easily be standalone JACK app, like Jconvoler.

Setting up an insert within Ardour to work with Jconvoler

Thankfully, adding an insert is easier than trying to describe what one is. Right-click in the effects list of your track’s mixer strip and select the “New Insert” option; the new insert should appear in the effects list. Double-click on that to open the insert dialog, which lets you specifiy the JACK ports that the insert will send to and read from.

In our case, we’re working with Jconvolver, so select the “jconvolver” tab on the left-side of the window and left-click on both the “In-1″ and “In-2″ ports to add them to the Ouputs section. Then, do the same for the Inputs section on the right-side of the window. Close the dialog, and either middle-click on the insert, or right-click on it and select “Activate”, to enable it.

Now, when you play the track, you should hear its audio processed through Jconvolver. It might sound a little odd, though, since unless you’re using Jcgui and you’ve adjusted the wet/dry control, you’ll hear just the reverb signal, with none of the original signal. Fixing that requires a trip in to the world of send effects.

Sharing a reverb, using sends

When you use a reverb plugin, you never (or at least very rarely) want to hear just the reverb signal — you want to hear the original dry signal, with some of the reverb mixed in at a lower volume. This is done within the plugin itself: it takes a copy of the original signal, applies the reverb, reduces the volume of the reverb signal, and then mixes that with the original signal (this isn’t entirely accurate, but it’s close enough for our needs). There’s another way to do that attenuation and mixing, though, and that’s within the DAW itself.

Imagine a reverb plugin that produces only the reverb signal, with no original signal mixed in. Instead of adding this to the track that we want reverb on, we add it to a separate bus, and then send a copy of the track’s audio to that bus for processing. Then, instead of reducing the volume of the reverbed signal, imagine we reduce the volume of the copy of the track’s signal that’s sent to the reverb.

What we’ve built here produces the same result as the plugin — we have our 100% dry original signal, and a quiet, reverb-processed copy of that signal — but we’ve produced it in a more flexible way. We’ve created a reverb bus, and then used a “send” from our track to effectively add reverb for that track to our mix.

There are numerous advantages to this approach, but the biggest is that the one reverb bus can be used to provide reverb for as many tracks as you like, just by adding a send to each track that routes audio to the reverb bus. You can adjust the amount of reverb that’s included in the mix for each track by adjusting the volume level on each track’s send.

This is especially handy with Jconvolver, given the complexity and raw CPU demands of running several Jconvolver instances, but it works just as well with any other reverb that can be set to a 100% wet setting, like the CALF Reverb below. Besides using less CPU power, sharing a reverb among tracks can produce a more cohesive-sounding mix, by placing all of your tracks within the same virtual “space”. You can also experiement with other types of shared effects — delays, for instance, can work just as well.

CALF Reverb, an LV2 reverb plugin, configured with no dry signal for use on a reverb bus

Using sends within Ardour

Thankfully, as with inserts, using this stuff is easier than trying to explain it. The first step is to add your reverb bus; if you haven’t worked with busses in Ardour, just think of them as tracks that don’t have any audio data of their own. In fact, they’re added the same way you’d add a track, using the “Track/Add Track/Bus” menu option. Add a single stereo bus, and once you’ve added it, name it something useful (“reverb” will do), and then add your Jconvolver insert to it from the mixer.

Adding a send to a track is very similar to adding an insert, just without the inputs

To add a send, open the mixer, find the audio track that you want to add some reverb to, right-click in its post-fader effects list, and select “New Send…”. The send dialog should appear automatically — it looks much like the left-side of the Insert dialog, and it’s used in the same way.

Open the “ardour” tab on the right and find the inputs for your reverb bus, hopefully named “reverb/in 1″ and “reverb/in 2″. Click on each of those inputs in turn, and they should appear under the “out 1″ and “out 2″ banners in the “Ouputs” section, or possibly under just the “out 1″ section if the track is mono. If the “out 1″ and “out 2″ sections don’t appear for some reason, use the “Add” button to create them. Once your outputs have been added, close the dialog, and activate the send by either middle-clicking on it in the effect list, or right-clicking on it and selecting “Activate”.

When you create a send, its volume defaults to 0dB; that is, the send has the same volume as the original signal, which usually isn’t what you want for a reverb send. If you double-click on the send in the effects list, the send dialog appears again, but now it will have a fader on the left — just adjust this down to reduce the send’s volume level, and hence the amount of reverb added to the mix for your track.

Repeat the send setup on each track that needs reverb, adjusting the fader on each send as appropriate for the track, and your reverb setup will be complete!

This project has a shared reverb and a shared delay, with sends to one (or both) of them from just about every track

Wrap-up

Jconvolver gives you access to a world of pro-quality reverb sounds, so knowing how to use it, and how to add it to your Ardour projects, is definitely very useful, but sends and inserts have a multitude of uses beyond just working with Jconvolver. Shared reverbs and delays can give your track a more unified sound, and inserts can add Rakarrack to your guitar tracks, JAMin to your master bus, or let you plug hardware effects in to your virtual studio.

FluidSynth is a synth that plays SoundFonts; in the studio it’s usually used through the Qsynth GUI, or as a DSSI plugin in a sequencer like Qtractor, but you can also use it stand-alone, through the “fluidsynth” command-line tool. To use it, you’ll need at least one SoundFont, and there’s a good General MIDI SoundFont called “Fluid” (which, despite the similar name, is unrelated to FluidSynth) that’s packaged in most distros.

This will install both the “fluidsynth” tool and the Fluid SoundFont on an Ubuntu or Debian system:

sudo apt-get install fluidsynth fluid-soundfont-gm

Then, just run the “fluidsynth” tool, specifying the SoundFont file to use and the MIDI file to play, and adding the “-F” option to dump the output to a file:

fluidsynth -F out.wav /usr/share/sounds/sf2/FluidR3_GM.sf2 myfile.mid

If you want the result in MP3, you can transcode it using LAME:

lame --preset standard out.wav out.mp3

or in to Ogg Vorbis using oggenc:

oggenc -q 5 out.wav


The great thing about using FluidSynth, apart from its simplicity, is that you can easily substitute whatever SoundFont you want. For instance, if you find Fluid too big to work with, you can user a smaller alternative, like the GeneralUser GS SoundFont, or if the piece is a solo work, you could use a higher-quality solo instrument SoundFont, like jRhodes3, which is a great Rhodes sound.

• Advanced pattern triggering techniques: queuing and snapshots
• Basic note editing: copying/pasting notes and changing velocities
• MIDI CC automation
• Background patterns
• MIDI note entry (step-sequencing) and MIDI recording

It’s a little longer than I’d have liked, but there’s a lot in there! If you’d prefer smaller, shorter tutorials in future, feel free to leave a comment and let me know.

For downloaders, there’s also a 720p WebM version available (107MB).

There’s an unspoken “step zero” here — get yourself a working copy of seq24. I’m not sure about other distributions, but on Ubuntu, especially 64-bit, the packaged version seems very unstable. The best thing to do is to grab the 0.9.1 version from the seq24 Launchpad and install that — this new release includes a bunch of bug-fixes, and a few new features, too.

The original plan was for a straight screencast, like my earlier synth tutorials, but I was so impressed by Kdenlive that I decided to have a bit of fun with it — hopefully the fun I had comes through in the finished product.

For downloaders, there’s also a 720p WebM version available.

Here, then, is a “performance” of my track tiny droplets — the various MIDI loops used are all pre-sequenced, but I’m triggering them all in realtime using my QWERTY keyboard. In this case, seq24 is driving Hydrogen and my Blofeld, and I’m using Ardour as a live mixer to process and mix the audio from those synths in to a stereo stream.

UPDATE: If you’d prefer to download the video rather than streaming it on YouTube, I’ve uploaded a WebM version of it. WebM is still quite new, but current versions of VLC and MPlayer support it.

On a brief side note, I have to give a shout-out to my good friend AutoStatic for describing his new video capture process using Xephyr and FFmpeg — I used it here, and the results look great. The audio was captured with JACK TimeMachine, and in another first for me, I edited it all together using the brilliant Kdenlive.

FingerPlay gives you a selection of controllers — sliders, X/Y controllers, and drum pads — all of which send MIDI messages via Wi-Fi to a tiny Java-based server app on a PC. There, you can connect the MIDI output to whatever app you like, just as you would with any other MIDI controller gear. The controls are set up in separate “pages”; a scroll bar on the right switches between the pages.

I did some quick testing, using the drum pads to trigger drum pads in Hydrogen, and using the sliders and pads to control the gain and muting of individual loops within SooperLooper, and it did a great job, responding quickly and smoothly to my input.

FingerPlay MIDI's pad page

FingerPlay MIDI's slider page

Here are the steps I followed to get it up and running:

1. Install the FingerPlay MIDI app on your device, and download and extract the server app from the FingerPlay MIDI site
2. Load the ALSA “virmidi” driver:
   sudo modprobe snd-virmidi
3. Launch the server app:
   java -jar FingerPlayServer.jar
4. Connect the “Virtual Raw MIDI 1-0″ ALSA MIDI device up to whatever app you want to control.
5. On the phone, launch FingerPlay MIDI, and hit the icon in the top right corner to open the settings screen. Set the “Server Address” to your PC’s IP address (or hostname), and click the “Connect to Server” button.
6. Scroll further down on the settings page and open the “MIDI Out Device” option. In the list, select the top “VirMIDI” option — in my case, it’s “[hw:1,0,0]“.
7. Exit the settings and start hitting some controls!

You can use the usual tools of choice to see what MIDI messages are actually coming out for each control — I tend to use QMidiRoute, since it also lets you remap or process the messages if you need to. As you’d expect, the sliders and X/Y controls send MIDI CCs, while the pads send notes. With Hydrogen, I had to transpose the pads up an octave to match what Hydrogen was expecting, but when I did, tapping out drum lines seemed quite responsive.

One thing to watch out for with tools that have MIDI learn features, like SooperLooper, is that the sliders and X/Y controls send “trigger” CCs when they’re touched in any way, as well as the CCs you’d expect. I had better luck with SooperLooper when I set up the bindings manually instead. My bindings file is available here.

After a bit of a wait, what’s perhaps the ultimate free piano sample library, the Salamander Grand Piano is available! One of the guys on the linux-audio-user spent I’d-hate-to-think-how-long recording every note on a Yamaha C5 grand at 16 different volume levels with a pair of stereo mics, and the result — all 1.9GB of it — sounds lovely.

Getting it running, however, is a bit fiddly right now. Due partly to its heft, it’s distributed in SFZ format, instead of the more common GigaSample “.GIG” format. Linuxsampler supports SFZ in CVS, but it’s buggy, and the instrument needs to be set up just right to load without crashing Linuxsampler. Once you’ve installed Linuxsampler from CVS — a bit of effort, but fairly straightforward, especially since it comes with Debian package scripts — follow these steps, in order, to get the Salamander up and running:

1. Launch Linuxsampler and the Fantasia GUI as usual — so far, so good!
2. Create a new sampler channel in the middle of the window. Click the “GIG engine” text in your new channel, and select the “SFZ engine” option
   
3. Set up your MIDI and audio devices on the right — I use ALSA for MIDI and JACK for audio, but you can use whatever you prefer here.
4. Click on the “OPTIONS” button on your sampler channel, and select your newly-created MIDI input and audio output. Your window should now look like this:
   
5. Click the “Load Instrument…” link on your sampler channel and load the “SalamanderGrandPiano.sfz” file

If you follow those steps in order, and cross your fingers, you should have a working Salamander Grand Piano setup! Once you have a working setup, make sure you export it to a file (Actions/Export/Sampler Configuration…); you’ll then be able to fire up your new piano next time by using that export (with the Actions/Run Script…) option.

Hi-res Ogg Theora version is here, or watch the Youtube version after the jump!

Modulation can produce effects ranging from subtle vibrato through to sweeping soundscapes and alien sound effects. Either way, it’s a powerful way to breathe life and movement in to what might otherwise be a dull sound.

High-res Ogg Theora version is here, or watch the Youtube version after the jump!

Due to the length of it all, the Youtube version is in two parts: