June 29, 2015

Linux Audio Announcements -

[LAA] OSC2MIDI Version 0.2.1 Released

With many many bugfix and improvement patches from Albert Graef, it's time
for a new release! We absolutely recommend updating to take advantage of
the new features.

Notable improvements include:
-OSC messages can now "remember" variable values when an incoming MIDI
message only contains part of the data (i.e.converting 2 different CCs to
an OSC message for an XY controller)
-MIDI values are now limited if they attempt to exceed max or below min
-better handling of "exotic" types like 'm'
-more consistent printing formatting in verbose mode
-better feedback on parse errors in mapping files
-inclusion of maps for all the default interfaces of touchOSC
-project move to github
-sundry bugfixes

Please download and give it a try:
(note the link has changed since last release)

_Spencer Jackson

by at June 29, 2015 04:33 PM

June 27, 2015

Linux Audio Announcements -

[LAA] Ardour 4.1 released

The Ardour project is pleased to announce the release of version 4.1.

Full details of the new features, fixes and so on can be found at:

and the program can be downloaded as usual from
Linux-audio-announce mailing list

by at June 27, 2015 11:20 PM

[LAA] OSC2MIDI Version 0.2.0 Released!

With many many bugfixes and improvements from Albert Graef, it's time for a
new release! We absolutely recommend updating to take advantage of these
new features.

Notable improvements include:
-OSC messages can now "remember" variable values when an incoming MIDI
message only contains part of the data (i.e.converting 2 different CCs to
an OSC message for an XY controller)
-MIDI values are now limited if they attempt to exceed max or below min
-better handling of "exotic" types like 'm'
-more consistent printing formatting in verbose mode
-better feedback on errors in mapping files
-inclusion of maps for all the default interfaces of touchOSC
-project move to github
-sundry bugfixes

Please download and give it a try:
(note the link has changed since last release)

Spencer Jackson

by at June 27, 2015 10:22 AM

June 26, 2015

GStreamer News

GStreamer development release binary builds

Pre-built binary images of the 1.5.2 development release of GStreamer are now available for Windows 32/64-bit, iOS and Mac OS X and Android.

The builds are available for download from: Android, iOS, Mac OS X and Windows.

June 26, 2015 10:30 PM

Libre Music Production - Articles, Tutorials and News

Ardour 4.1 is released!

Ardour 4.1 has just been released. This release sees the addition of some interesting new features, along with the usual bug fixes.

Here's a rundown of some of the new features -

Input gain control - Audio and bus mixer strips now have an input gain control, allowing you to increase or attenuate the input signal by up to 20 dB.

by Conor at June 26, 2015 12:35 AM

June 25, 2015


Ardour 4.1 released

The Ardour project is pleased to announce the release of 4.1 with a great line-up of new features such as input gain control, Save As for projects, click-free changes to processor order and meter position, relative snapping, faster waveform rendering, Hi-DPI/Retina support and more! As usual, quite a few bugs have been mercilessly slayed. Encouragingly, we also have one of our longest ever contributor lists for this release.

read more

by paul at June 25, 2015 04:09 PM

June 24, 2015

GStreamer News

GStreamer Core, Plugins, RTSP Server, Python, Editing Services, Validate 1.5.2 development release

The GStreamer team is pleased to announce the second release of the unstable 1.5 release series. The 1.5 release series is adding new features on top of the 1.0, 1.2 and 1.4 series and is part of the API and ABI-stable 1.x release series of the GStreamer multimedia framework. The unstable 1.5 release series will lead to the stable 1.6 release series in the next weeks, and newly added API can still change until that point.

Binaries for Android, iOS, Mac OS X and Windows will be provided separately during the unstable 1.5 release series.

Check out the release notes for GStreamer core, gst-plugins-base, gst-plugins-good, gst-plugins-ugly, gst-plugins-bad, gst-libav, gst-rtsp-server, gst-python, gst-editing-services, or gst-validate, or download tarballs for gstreamer, gst-plugins-base, gst-plugins-good, gst-plugins-ugly, gst-plugins-bad, gst-libav, gst-rtsp-server, gst-python, gst-editing-services, gst-validate, or

Check the release announcement mail for details and the release notes above for a list of changes.

June 24, 2015 11:59 PM

June 23, 2015

Linux Audio Announcements -

[LAA] [ANN] Radium 3.1.3

Radium is a music editor with a new type of interface. It's inspired by
trackers, but uses graphics to show musical data.

Most important changes between 3.0 and 3.1.3:
* Many stability issues fixed
* Fixed automation
* Pianoroll
* Option to record MIDI line by line and monophonic in the MIDI menu. (as
* Add options to multiply the number of lines to scroll by the "Edit lines"
* MIDI: Option to always record velocity
* A new sound object called "Midi Messages" which can be used to send MIDI
messages to other sound objects. Can for instance be used to send pitch
bend changes to VST plugins.
* Option to show line numbers instead of bars/beats
* Sort notes by pitch for same-positioned notes.
* VST: Fix for plugins using "main" instead of "VSTPluginMain".

by at June 23, 2015 10:47 PM

June 19, 2015 »

Raspberry Pi Revisited

When the Raspberry Pi 2 was released I certainly got curious. Would it be really better than it's little brother? As soon as it got available in The Netherlands I bought it and sure this thing flies compared to the Raspberry Pi 1. The four cores and 1GB of memory are certainly an improvement. The biggest improvement though is the shift from ARMv6 to ARMv7. Now you can really run basically anything on it and thus I soon parted from Raspbian and I'm now running plain Debian Jessie armhf on the RPi.

So is everything fine and dandy with the RPi2? Well, no. It still uses the poor USB implementation and audio output. And it was quite a challenge to prepare it for its intended use: a musical instrument. To my great surprise a new version of the Wolfson Audio Card was available too for the new Raspberry Pi board layout so as soon as people reported they got it to work with the RPi2 I ordered one too.

Cirrus Logic Audio Card for Raspberry Pi

One of the first steps to make the device suitable for use as a musical device was to build a real-time kernel for it. Building the kernel itself was quite easy as the RT patchset of the kernel being used at the moment by the Raspberry Foundation (3.18) applied cleanly and it also booted without issues. But after a few minutes the RPi2 would lock up without logging anything. Fortunately there were people on the same boat as me and with the help of the info and patches provided by the Emlid community I managed to get my RPi2 stable with a RT kernel.

Next step was to get the right software running so I dusted off my RPi repositories and added a Jessie armhf repo. With the help of fundamental the latest version of ZynAddSubFX now runs like charm with very acceptable latencies, when using not all too elaborate instrument patches Zyn is happy with an internal latency of 64/48000=1.3ms. I haven't measured the total round-trip latency but it probably stays well below 10ms. LinuxSampler with the Salamander Grand Piano sample pack also performs a lot better than on the RPi1 and when using ALSA directly I barely get any underruns with a slightly higher buffer setting.

I'd love to get Guitarix running on the RPi2 with the Cirrus Logic Audio Card so that will be the next challenge.

by Jeremy at June 19, 2015 07:07 AM

June 18, 2015

Pid Eins

The new sd-bus API of systemd

With the new v221 release of systemd we are declaring the sd-bus API shipped with systemd stable. sd-bus is our minimal D-Bus IPC C library, supporting as back-ends both classic socket-based D-Bus and kdbus. The library has been been part of systemd for a while, but has only been used internally, since we wanted to have the liberty to still make API changes without affecting external consumers of the library. However, now we are confident to commit to a stable API for it, starting with v221.

In this blog story I hope to provide you with a quick overview on sd-bus, a short reiteration on D-Bus and its concepts, as well as a few simple examples how to write D-Bus clients and services with it.

What is D-Bus again?

Let's start with a quick reminder what D-Bus actually is: it's a powerful, generic IPC system for Linux and other operating systems. It knows concepts like buses, objects, interfaces, methods, signals, properties. It provides you with fine-grained access control, a rich type system, discoverability, introspection, monitoring, reliable multicasting, service activation, file descriptor passing, and more. There are bindings for numerous programming languages that are used on Linux.

D-Bus has been a core component of Linux systems since more than 10 years. It is certainly the most widely established high-level local IPC system on Linux. Since systemd's inception it has been the IPC system it exposes its interfaces on. And even before systemd, it was the IPC system Upstart used to expose its interfaces. It is used by GNOME, by KDE and by a variety of system components.

D-Bus refers to both a specification, and a reference implementation. The reference implementation provides both a bus server component, as well as a client library. While there are multiple other, popular reimplementations of the client library – for both C and other programming languages –, the only commonly used server side is the one from the reference implementation. (However, the kdbus project is working on providing an alternative to this server implementation as a kernel component.)

D-Bus is mostly used as local IPC, on top of AF_UNIX sockets. However, the protocol may be used on top of TCP/IP as well. It does not natively support encryption, hence using D-Bus directly on TCP is usually not a good idea. It is possible to combine D-Bus with a transport like ssh in order to secure it. systemd uses this to make many of its APIs accessible remotely.

A frequently asked question about D-Bus is why it exists at all, given that AF_UNIX sockets and FIFOs already exist on UNIX and have been used for a long time successfully. To answer this question let's make a comparison with popular web technology of today: what AF_UNIX/FIFOs are to D-Bus, TCP is to HTTP/REST. While AF_UNIX sockets/FIFOs only shovel raw bytes between processes, D-Bus defines actual message encoding and adds concepts like method call transactions, an object system, security mechanisms, multicasting and more.

From our 10year+ experience with D-Bus we know today that while there are some areas where we can improve things (and we are working on that, both with kdbus and sd-bus), it generally appears to be a very well designed system, that stood the test of time, aged well and is widely established. Today, if we'd sit down and design a completely new IPC system incorporating all the experience and knowledge we gained with D-Bus, I am sure the result would be very close to what D-Bus already is.

Or in short: D-Bus is great. If you hack on a Linux project and need a local IPC, it should be your first choice. Not only because D-Bus is well designed, but also because there aren't many alternatives that can cover similar functionality.

Where does sd-bus fit in?

Let's discuss why sd-bus exists, how it compares with the other existing C D-Bus libraries and why it might be a library to consider for your project.

For C, there are two established, popular D-Bus libraries: libdbus, as it is shipped in the reference implementation of D-Bus, as well as GDBus, a component of GLib, the low-level tool library of GNOME.

Of the two libdbus is the much older one, as it was written at the time the specification was put together. The library was written with a focus on being portable and to be useful as back-end for higher-level language bindings. Both of these goals required the API to be very generic, resulting in a relatively baroque, hard-to-use API that lacks the bits that make it easy and fun to use from C. It provides the building blocks, but few tools to actually make it straightforward to build a house from them. On the other hand, the library is suitable for most use-cases (for example, it is OOM-safe making it suitable for writing lowest level system software), and is portable to operating systems like Windows or more exotic UNIXes.

GDBus is a much newer implementation. It has been written after considerable experience with using a GLib/GObject wrapper around libdbus. GDBus is implemented from scratch, shares no code with libdbus. Its design differs substantially from libdbus, it contains code generators to make it specifically easy to expose GObject objects on the bus, or talking to D-Bus objects as GObject objects. It translates D-Bus data types to GVariant, which is GLib's powerful data serialization format. If you are used to GLib-style programming then you'll feel right at home, hacking D-Bus services and clients with it is a lot simpler than using libdbus.

With sd-bus we now provide a third implementation, sharing no code with either libdbus or GDBus. For us, the focus was on providing kind of a middle ground between libdbus and GDBus: a low-level C library that actually is fun to work with, that has enough syntactic sugar to make it easy to write clients and services with, but on the other hand is more low-level than GDBus/GLib/GObject/GVariant. To be able to use it in systemd's various system-level components it needed to be OOM-safe and minimal. Another major point we wanted to focus on was supporting a kdbus back-end right from the beginning, in addition to the socket transport of the original D-Bus specification ("dbus1"). In fact, we wanted to design the library closer to kdbus' semantics than to dbus1's, wherever they are different, but still cover both transports nicely. In contrast to libdbus or GDBus portability is not a priority for sd-bus, instead we try to make the best of the Linux platform and expose specific Linux concepts wherever that is beneficial. Finally, performance was also an issue (though a secondary one): neither libdbus nor GDBus will win any speed records. We wanted to improve on performance (throughput and latency) -- but simplicity and correctness are more important to us. We believe the result of our work delivers our goals quite nicely: the library is fun to use, supports kdbus and sockets as back-end, is relatively minimal, and the performance is substantially better than both libdbus and GDBus.

To decide which of the three APIs to use for you C project, here are short guidelines:

  • If you hack on a GLib/GObject project, GDBus is definitely your first choice.

  • If portability to non-Linux kernels -- including Windows, Mac OS and other UNIXes -- is important to you, use either GDBus (which more or less means buying into GLib/GObject) or libdbus (which requires a lot of manual work).

  • Otherwise, sd-bus would be my recommended choice.

(I am not covering C++ specifically here, this is all about plain C only. But do note: if you use Qt, then QtDBus is the D-Bus API of choice, being a wrapper around libdbus.)

Introduction to D-Bus Concepts

To the uninitiated D-Bus usually appears to be a relatively opaque technology. It uses lots of concepts that appear unnecessarily complex and redundant on first sight. But actually, they make a lot of sense. Let's have a look:

  • A bus is where you look for IPC services. There are usually two kinds of buses: a system bus, of which there's exactly one per system, and which is where you'd look for system services; and a user bus, of which there's one per user, and which is where you'd look for user services, like the address book service or the mail program. (Originally, the user bus was actually a session bus -- so that you get multiple of them if you log in many times as the same user --, and on most setups it still is, but we are working on moving things to a true user bus, of which there is only one per user on a system, regardless how many times that user happens to log in.)

  • A service is a program that offers some IPC API on a bus. A service is identified by a name in reverse domain name notation. Thus, the org.freedesktop.NetworkManager service on the system bus is where NetworkManager's APIs are available and org.freedesktop.login1 on the system bus is where systemd-logind's APIs are exposed.

  • A client is a program that makes use of some IPC API on a bus. It talks to a service, monitors it and generally doesn't provide any services on its own. That said, lines are blurry and many services are also clients to other services. Frequently the term peer is used as a generalization to refer to either a service or a client.

  • An object path is an identifier for an object on a specific service. In a way this is comparable to a C pointer, since that's how you generally reference a C object, if you hack object-oriented programs in C. However, C pointers are just memory addresses, and passing memory addresses around to other processes would make little sense, since they of course refer to the address space of the service, the client couldn't make sense of it. Thus, the D-Bus designers came up with the object path concept, which is just a string that looks like a file system path. Example: /org/freedesktop/login1 is the object path of the 'manager' object of the org.freedesktop.login1 service (which, as we remember from above, is still the service systemd-logind exposes). Because object paths are structured like file system paths they can be neatly arranged in a tree, so that you end up with a venerable tree of objects. For example, you'll find all user sessions systemd-logind manages below the /org/freedesktop/login1/session sub-tree, for example called /org/freedesktop/login1/session/_7, /org/freedesktop/login1/session/_55 and so on. How services precisely label their objects and arrange them in a tree is completely up to the developers of the services.

  • Each object that is identified by an object path has one or more interfaces. An interface is a collection of signals, methods, and properties (collectively called members), that belong together. The concept of a D-Bus interface is actually pretty much identical to what you know from programming languages such as Java, which also know an interface concept. Which interfaces an object implements are up the developers of the service. Interface names are in reverse domain name notation, much like service names. (Yes, that's admittedly confusing, in particular since it's pretty common for simpler services to reuse the service name string also as an interface name.) A couple of interfaces are standardized though and you'll find them available on many of the objects offered by the various services. Specifically, those are org.freedesktop.DBus.Introspectable, org.freedesktop.DBus.Peer and org.freedesktop.DBus.Properties.

  • An interface can contain methods. The word "method" is more or less just a fancy word for "function", and is a term used pretty much the same way in object-oriented languages such as Java. The most common interaction between D-Bus peers is that one peer invokes one of these methods on another peer and gets a reply. A D-Bus method takes a couple of parameters, and returns others. The parameters are transmitted in a type-safe way, and the type information is included in the introspection data you can query from each object. Usually, method names (and the other member types) follow a CamelCase syntax. For example, systemd-logind exposes an ActivateSession method on the org.freedesktop.login1.Manager interface that is available on the /org/freedesktop/login1 object of the org.freedesktop.login1 service.

  • A signature describes a set of parameters a function (or signal, property, see below) takes or returns. It's a series of characters that each encode one parameter by its type. The set of types available is pretty powerful. For example, there are simpler types like s for string, or u for 32bit integer, but also complex types such as as for an array of strings or a(sb) for an array of structures consisting of one string and one boolean each. See the D-Bus specification for the full explanation of the type system. The ActivateSession method mentioned above takes a single string as parameter (the parameter signature is hence s), and returns nothing (the return signature is hence the empty string). Of course, the signature can get a lot more complex, see below for more examples.

  • A signal is another member type that the D-Bus object system knows. Much like a method it has a signature. However, they serve different purposes. While in a method call a single client issues a request on a single service, and that service sends back a response to the client, signals are for general notification of peers. Services send them out when they want to tell one or more peers on the bus that something happened or changed. In contrast to method calls and their replies they are hence usually broadcast over a bus. While method calls/replies are used for duplex one-to-one communication, signals are usually used for simplex one-to-many communication (note however that that's not a requirement, they can also be used one-to-one). Example: systemd-logind broadcasts a SessionNew signal from its manager object each time a user logs in, and a SessionRemoved signal every time a user logs out.

  • A property is the third member type that the D-Bus object system knows. It's similar to the property concept known by languages like C#. Properties also have a signature, and are more or less just variables that an object exposes, that can be read or altered by clients. Example: systemd-logind exposes a property Docked of the signature b (a boolean). It reflects whether systemd-logind thinks the system is currently in a docking station of some form (only applies to laptops …).

So much for the various concepts D-Bus knows. Of course, all these new concepts might be overwhelming. Let's look at them from a different perspective. I assume many of the readers have an understanding of today's web technology, specifically HTTP and REST. Let's try to compare the concept of a HTTP request with the concept of a D-Bus method call:

  • A HTTP request you issue on a specific network. It could be the Internet, or it could be your local LAN, or a company VPN. Depending on which network you issue the request on, you'll be able to talk to a different set of servers. This is not unlike the "bus" concept of D-Bus.

  • On the network you then pick a specific HTTP server to talk to. That's roughly comparable to picking a service on a specific bus.

  • On the HTTP server you then ask for a specific URL. The "path" part of the URL (by which I mean everything after the host name of the server, up to the last "/") is pretty similar to a D-Bus object path.

  • The "file" part of the URL (by which I mean everything after the last slash, following the path, as described above), then defines the actual call to make. In D-Bus this could be mapped to an interface and method name.

  • Finally, the parameters of a HTTP call follow the path after the "?", they map to the signature of the D-Bus call.

Of course, comparing an HTTP request to a D-Bus method call is a bit comparing apples and oranges. However, I think it's still useful to get a bit of a feeling of what maps to what.

From the shell

So much about the concepts and the gray theory behind them. Let's make this exciting, let's actually see how this feels on a real system.

Since a while systemd has included a tool busctl that is useful to explore and interact with the D-Bus object system. When invoked without parameters, it will show you a list of all peers connected to the system bus. (Use --user to see the peers of your user bus instead):

$ busctl
NAME                                       PID PROCESS         USER             CONNECTION    UNIT                      SESSION    DESCRIPTION
:1.1                                         1 systemd         root             :1.1          -                         -          -
:1.11                                      705 NetworkManager  root             :1.11         NetworkManager.service    -          -
:1.14                                      744 gdm             root             :1.14         gdm.service               -          -
:1.4                                       708 systemd-logind  root             :1.4          systemd-logind.service    -          -
:1.7200                                  17563 busctl          lennart          :1.7200       session-1.scope           1          -
org.freedesktop.NetworkManager             705 NetworkManager  root             :1.11         NetworkManager.service    -          -
org.freedesktop.login1                     708 systemd-logind  root             :1.4          systemd-logind.service    -          -
org.freedesktop.systemd1                     1 systemd         root             :1.1          -                         -          -
org.gnome.DisplayManager                   744 gdm             root             :1.14         gdm.service               -          -

(I have shortened the output a bit, to make keep things brief).

The list begins with a list of all peers currently connected to the bus. They are identified by peer names like ":1.11". These are called unique names in D-Bus nomenclature. Basically, every peer has a unique name, and they are assigned automatically when a peer connects to the bus. They are much like an IP address if you so will. You'll notice that a couple of peers are already connected, including our little busctl tool itself as well as a number of system services. The list then shows all actual services on the bus, identified by their service names (as discussed above; to discern them from the unique names these are also called well-known names). In many ways well-known names are similar to DNS host names, i.e. they are a friendlier way to reference a peer, but on the lower level they just map to an IP address, or in this comparison the unique name. Much like you can connect to a host on the Internet by either its host name or its IP address, you can also connect to a bus peer either by its unique or its well-known name. (Note that each peer can have as many well-known names as it likes, much like an IP address can have multiple host names referring to it).

OK, that's already kinda cool. Try it for yourself, on your local machine (all you need is a recent, systemd-based distribution).

Let's now go the next step. Let's see which objects the org.freedesktop.login1 service actually offers:

$ busctl tree org.freedesktop.login1
  │ ├─/org/freedesktop/login1/seat/seat0
  │ └─/org/freedesktop/login1/seat/self
  │ ├─/org/freedesktop/login1/session/_31
  │ └─/org/freedesktop/login1/session/self

Pretty, isn't it? What's actually even nicer, and which the output does not show is that there's full command line completion available: as you press TAB the shell will auto-complete the service names for you. It's a real pleasure to explore your D-Bus objects that way!

The output shows some objects that you might recognize from the explanations above. Now, let's go further. Let's see what interfaces, methods, signals and properties one of these objects actually exposes:

$ busctl introspect org.freedesktop.login1 /org/freedesktop/login1/session/_31
NAME                                TYPE      SIGNATURE RESULT/VALUE                             FLAGS
org.freedesktop.DBus.Introspectable interface -         -                                        -
.Introspect                         method    -         s                                        -
org.freedesktop.DBus.Peer           interface -         -                                        -
.GetMachineId                       method    -         s                                        -
.Ping                               method    -         -                                        -
org.freedesktop.DBus.Properties     interface -         -                                        -
.Get                                method    ss        v                                        -
.GetAll                             method    s         a{sv}                                    -
.Set                                method    ssv       -                                        -
.PropertiesChanged                  signal    sa{sv}as  -                                        -
org.freedesktop.login1.Session      interface -         -                                        -
.Activate                           method    -         -                                        -
.Kill                               method    si        -                                        -
.Lock                               method    -         -                                        -
.PauseDeviceComplete                method    uu        -                                        -
.ReleaseControl                     method    -         -                                        -
.ReleaseDevice                      method    uu        -                                        -
.SetIdleHint                        method    b         -                                        -
.TakeControl                        method    b         -                                        -
.TakeDevice                         method    uu        hb                                       -
.Terminate                          method    -         -                                        -
.Unlock                             method    -         -                                        -
.Active                             property  b         true                                     emits-change
.Audit                              property  u         1                                        const
.Class                              property  s         "user"                                   const
.Desktop                            property  s         ""                                       const
.Display                            property  s         ""                                       const
.Id                                 property  s         "1"                                      const
.IdleHint                           property  b         true                                     emits-change
.IdleSinceHint                      property  t         1434494624206001                         emits-change
.IdleSinceHintMonotonic             property  t         0                                        emits-change
.Leader                             property  u         762                                      const
.Name                               property  s         "lennart"                                const
.Remote                             property  b         false                                    const
.RemoteHost                         property  s         ""                                       const
.RemoteUser                         property  s         ""                                       const
.Scope                              property  s         "session-1.scope"                        const
.Seat                               property  (so)      "seat0" "/org/freedesktop/login1/seat... const
.Service                            property  s         "gdm-autologin"                          const
.State                              property  s         "active"                                 -
.TTY                                property  s         "/dev/tty1"                              const
.Timestamp                          property  t         1434494630344367                         const
.TimestampMonotonic                 property  t         34814579                                 const
.Type                               property  s         "x11"                                    const
.User                               property  (uo)      1000 "/org/freedesktop/login1/user/_1... const
.VTNr                               property  u         1                                        const
.Lock                               signal    -         -                                        -
.PauseDevice                        signal    uus       -                                        -
.ResumeDevice                       signal    uuh       -                                        -
.Unlock                             signal    -         -                                        -

As before, the busctl command supports command line completion, hence both the service name and the object path used are easily put together on the shell simply by pressing TAB. The output shows the methods, properties, signals of one of the session objects that are currently made available by systemd-logind. There's a section for each interface the object knows. The second column tells you what kind of member is shown in the line. The third column shows the signature of the member. In case of method calls that's the input parameters, the fourth column shows what is returned. For properties, the fourth column encodes the current value of them.

So far, we just explored. Let's take the next step now: let's become active - let's call a method:

# busctl call org.freedesktop.login1 /org/freedesktop/login1/session/_31 org.freedesktop.login1.Session Lock

I don't think I need to mention this anymore, but anyway: again there's full command line completion available. The third argument is the interface name, the fourth the method name, both can be easily completed by pressing TAB. In this case we picked the Lock method, which activates the screen lock for the specific session. And yupp, the instant I pressed enter on this line my screen lock turned on (this only works on DEs that correctly hook into systemd-logind for this to work. GNOME works fine, and KDE should work too).

The Lock method call we picked is very simple, as it takes no parameters and returns none. Of course, it can get more complicated for some calls. Here's another example, this time using one of systemd's own bus calls, to start an arbitrary system unit:

# busctl call org.freedesktop.systemd1 /org/freedesktop/systemd1 org.freedesktop.systemd1.Manager StartUnit ss "cups.service" "replace"
o "/org/freedesktop/systemd1/job/42684"

This call takes two strings as input parameters, as we denote in the signature string that follows the method name (as usual, command line completion helps you getting this right). Following the signature the next two parameters are simply the two strings to pass. The specified signature string hence indicates what comes next. systemd's StartUnit method call takes the unit name to start as first parameter, and the mode in which to start it as second. The call returned a single object path value. It is encoded the same way as the input parameter: a signature (just o for the object path) followed by the actual value.

Of course, some method call parameters can get a ton more complex, but with busctl it's relatively easy to encode them all. See the man page for details.

busctl knows a number of other operations. For example, you can use it to monitor D-Bus traffic as it happens (including generating a .cap file for use with Wireshark!) or you can set or get specific properties. However, this blog story was supposed to be about sd-bus, not busctl, hence let's cut this short here, and let me direct you to the man page in case you want to know more about the tool.

busctl (like the rest of system) is implemented using the sd-bus API. Thus it exposes many of the features of sd-bus itself. For example, you can use to connect to remote or container buses. It understands both kdbus and classic D-Bus, and more!


But enough! Let's get back on topic, let's talk about sd-bus itself.

The sd-bus set of APIs is mostly contained in the header file sd-bus.h.

Here's a random selection of features of the library, that make it compare well with the other implementations available.

  • Supports both kdbus and dbus1 as back-end.

  • Has high-level support for connecting to remote buses via ssh, and to buses of local OS containers.

  • Powerful credential model, to implement authentication of clients in services. Currently 34 individual fields are supported, from the PID of the client to the cgroup or capability sets.

  • Support for tracking the life-cycle of peers in order to release local objects automatically when all peers referencing them disconnected.

  • The client builds an efficient decision tree to determine which handlers to deliver an incoming bus message to.

  • Automatically translates D-Bus errors into UNIX style errors and back (this is lossy though), to ensure best integration of D-Bus into low-level Linux programs.

  • Powerful but lightweight object model for exposing local objects on the bus. Automatically generates introspection as necessary.

The API is currently not fully documented, but we are working on completing the set of manual pages. For details see all pages starting with sd_bus_.

Invoking a Method, from C, with sd-bus

So much about the library in general. Here's an example for connecting to the bus and issuing a method call:

#include <stdio.h>
#include <stdlib.h>
#include <systemd/sd-bus.h>

int main(int argc, char *argv[]) {
        sd_bus_error error = SD_BUS_ERROR_NULL;
        sd_bus_message *m = NULL;
        sd_bus *bus = NULL;
        const char *path;
        int r;

        /* Connect to the system bus */
        r = sd_bus_open_system(&bus);
        if (r < 0) {
                fprintf(stderr, "Failed to connect to system bus: %s\n", strerror(-r));
                goto finish;

        /* Issue the method call and store the respons message in m */
        r = sd_bus_call_method(bus,
                               "org.freedesktop.systemd1",           /* service to contact */
                               "/org/freedesktop/systemd1",          /* object path */
                               "org.freedesktop.systemd1.Manager",   /* interface name */
                               "StartUnit",                          /* method name */
                               &error,                               /* object to return error in */
                               &m,                                   /* return message on success */
                               "ss",                                 /* input signature */
                               "cups.service",                       /* first argument */
                               "replace");                           /* second argument */
        if (r < 0) {
                fprintf(stderr, "Failed to issue method call: %s\n", error.message);
                goto finish;

        /* Parse the response message */
        r = sd_bus_message_read(m, "o", &path);
        if (r < 0) {
                fprintf(stderr, "Failed to parse response message: %s\n", strerror(-r));
                goto finish;

        printf("Queued service job as %s.\n", path);


        return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;

Save this example as bus-client.c, then build it with:

$ gcc bus-client.c -o bus-client `pkg-config --cflags --libs libsystemd`

This will generate a binary bus-client you can now run. Make sure to run it as root though, since access to the StartUnit method is privileged:

# ./bus-client
Queued service job as /org/freedesktop/systemd1/job/3586.

And that's it already, our first example. It showed how we invoked a method call on the bus. The actual function call of the method is very close to the busctl command line we used before. I hope the code excerpt needs little further explanation. It's supposed to give you a taste how to write D-Bus clients with sd-bus. For more more information please have a look at the header file, the man page or even the sd-bus sources.

Implementing a Service, in C, with sd-bus

Of course, just calling a single method is a rather simplistic example. Let's have a look on how to write a bus service. We'll write a small calculator service, that exposes a single object, which implements an interface that exposes two methods: one to multiply two 64bit signed integers, and one to divide one 64bit signed integer by another.

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <systemd/sd-bus.h>

static int method_multiply(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
        int64_t x, y;
        int r;

        /* Read the parameters */
        r = sd_bus_message_read(m, "xx", &x, &y);
        if (r < 0) {
                fprintf(stderr, "Failed to parse parameters: %s\n", strerror(-r));
                return r;

        /* Reply with the response */
        return sd_bus_reply_method_return(m, "x", x * y);

static int method_divide(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
        int64_t x, y;
        int r;

        /* Read the parameters */
        r = sd_bus_message_read(m, "xx", &x, &y);
        if (r < 0) {
                fprintf(stderr, "Failed to parse parameters: %s\n", strerror(-r));
                return r;

        /* Return an error on division by zero */
        if (y == 0) {
                sd_bus_error_set_const(ret_error, "net.poettering.DivisionByZero", "Sorry, can't allow division by zero.");
                return -EINVAL;

        return sd_bus_reply_method_return(m, "x", x / y);

/* The vtable of our little object, implements the net.poettering.Calculator interface */
static const sd_bus_vtable calculator_vtable[] = {
        SD_BUS_METHOD("Multiply", "xx", "x", method_multiply, SD_BUS_VTABLE_UNPRIVILEGED),
        SD_BUS_METHOD("Divide",   "xx", "x", method_divide,   SD_BUS_VTABLE_UNPRIVILEGED),

int main(int argc, char *argv[]) {
        sd_bus_slot *slot = NULL;
        sd_bus *bus = NULL;
        int r;

        /* Connect to the user bus this time */
        r = sd_bus_open_user(&bus);
        if (r < 0) {
                fprintf(stderr, "Failed to connect to system bus: %s\n", strerror(-r));
                goto finish;

        /* Install the object */
        r = sd_bus_add_object_vtable(bus,
                                     "/net/poettering/Calculator",  /* object path */
                                     "net.poettering.Calculator",   /* interface name */
        if (r < 0) {
                fprintf(stderr, "Failed to issue method call: %s\n", strerror(-r));
                goto finish;

        /* Take a well-known service name so that clients can find us */
        r = sd_bus_request_name(bus, "net.poettering.Calculator", 0);
        if (r < 0) {
                fprintf(stderr, "Failed to acquire service name: %s\n", strerror(-r));
                goto finish;

        for (;;) {
                /* Process requests */
                r = sd_bus_process(bus, NULL);
                if (r < 0) {
                        fprintf(stderr, "Failed to process bus: %s\n", strerror(-r));
                        goto finish;
                if (r > 0) /* we processed a request, try to process another one, right-away */

                /* Wait for the next request to process */
                r = sd_bus_wait(bus, (uint64_t) -1);
                if (r < 0) {
                        fprintf(stderr, "Failed to wait on bus: %s\n", strerror(-r));
                        goto finish;


        return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;

Save this example as bus-service.c, then build it with:

$ gcc bus-service.c -o bus-service `pkg-config --cflags --libs libsystemd`

Now, let's run it:

$ ./bus-service

In another terminal, let's try to talk to it. Note that this service is now on the user bus, not on the system bus as before. We do this for simplicity reasons: on the system bus access to services is tightly controlled so unprivileged clients cannot request privileged operations. On the user bus however things are simpler: as only processes of the user owning the bus can connect no further policy enforcement will complicate this example. Because the service is on the user bus, we have to pass the --user switch on the busctl command line. Let's start with looking at the service's object tree.

$ busctl --user tree net.poettering.Calculator

As we can see, there's only a single object on the service, which is not surprising, given that our code above only registered one. Let's see the interfaces and the members this object exposes:

$ busctl --user introspect net.poettering.Calculator /net/poettering/Calculator
NAME                                TYPE      SIGNATURE RESULT/VALUE FLAGS
net.poettering.Calculator           interface -         -            -
.Divide                             method    xx        x            -
.Multiply                           method    xx        x            -
org.freedesktop.DBus.Introspectable interface -         -            -
.Introspect                         method    -         s            -
org.freedesktop.DBus.Peer           interface -         -            -
.GetMachineId                       method    -         s            -
.Ping                               method    -         -            -
org.freedesktop.DBus.Properties     interface -         -            -
.Get                                method    ss        v            -
.GetAll                             method    s         a{sv}        -
.Set                                method    ssv       -            -
.PropertiesChanged                  signal    sa{sv}as  -            -

The sd-bus library automatically added a couple of generic interfaces, as mentioned above. But the first interface we see is actually the one we added! It shows our two methods, and both take "xx" (two 64bit signed integers) as input parameters, and return one "x". Great! But does it work?

$ busctl --user call net.poettering.Calculator /net/poettering/Calculator net.poettering.Calculator Multiply xx 5 7
x 35

Woohoo! We passed the two integers 5 and 7, and the service actually multiplied them for us and returned a single integer 35! Let's try the other method:

$ busctl --user call net.poettering.Calculator /net/poettering/Calculator net.poettering.Calculator Divide xx 99 17
x 5

Oh, wow! It can even do integer division! Fantastic! But let's trick it into dividing by zero:

$ busctl --user call net.poettering.Calculator /net/poettering/Calculator net.poettering.Calculator Divide xx 43 0
Sorry, can't allow division by zero.

Nice! It detected this nicely and returned a clean error about it. If you look in the source code example above you'll see how precisely we generated the error.

And that's really all I have for today. Of course, the examples I showed are short, and I don't get into detail here on what precisely each line does. However, this is supposed to be a short introduction into D-Bus and sd-bus, and it's already way too long for that …

I hope this blog story was useful to you. If you are interested in using sd-bus for your own programs, I hope this gets you started. If you have further questions, check the (incomplete) man pages, and inquire us on IRC or the systemd mailing list. If you need more examples, have a look at the systemd source tree, all of systemd's many bus services use sd-bus extensively.

by Lennart Poettering at June 18, 2015 10:00 PM

June 17, 2015

Libre Music Production - Articles, Tutorials and News

setBfree v0.8 is released!

Version 0.8 of setBfree, the DSP Tonewheel Organ emulator, has just been released. setBfree is designed to "imitate the sound and properties of the electromechanical organs and sound modification devices that brought world-wide fame to the names and products of Laurens Hammond and Don Leslie." setBfree is available as an LV2 plugin. There is also a JACK standalone version available.

by Conor at June 17, 2015 09:39 AM

Linux Audio Announcements -

[LAA] [ANN] setBfree v0.8


setBfree is a MIDI-controlled, software synthesizer designed to imitate
the sound and properties of the electromechanical organs and sound
modification devices that brought world-wide fame to the names and
products of Laurens Hammond and Don Leslie.

It's been over 18 months since the last release and setBfree just
reached another major milestone: It now features a proper GUI that
allows to configure various aspects that have previously only been
accessible via text config files (the config and program file-format
itself has not changed). The GUI is available as LV2 and standalone jack
application and the old tcl/tk prototype UI was removed for good.

visit for a demo.

The 2nd big change was reworking the Leslie: The horn now spins
counter-clockwise (same as the real thing) and we finally managed to
track down the aliasing noise that was audible during acceleration and
deceleration. Since various users play guitar and some even cello
through it, an animated LV2 GUI was added for the whirl-speaker
emulation and it has also been made available as standalone jack client.
Advanced settings such as microphone angle, position, horn radius, etc
are now also exposed (both for the organ as well as the LV2). The UI
looks like

Other notable changes include new addition of presets for Kurzweil and
Korg CX3 and updates to portability (ARM-CPU/RPi, Windows + OSX
versions). The full list of over 300 changes since 0.7.5 is available as
git log.

Binaries for Intel platform, GNU/Linux, OSX and Windows are available
though for Linux most distros will pick this up as usual.

Many thanks to Axel 'the C.L.A.' M?ller and Jean-Luc Nest who provided
valuable feedback and inspiring music during the development cycle.

happy playing,
robin + will
Linux-audio-announce mailing list

by at June 17, 2015 03:11 AM

June 16, 2015

Linux Audio Announcements -

[LAA] Vamp plugin SDK v2.6 now available

Version 2.6 of the Vamp plugin SDK is now available.

Vamp is a plugin API for audio analysis and feature extraction plugins
written in C or C++. Its SDK features an easy-to-use set of C++ classes
for plugin and host developers, a reference host implementation, example
plugins, and documentation. It is supported across Linux, OS/X, and

A documentation guide to writing plugins using the Vamp SDK can be found

Version 2.6 is a bugfix and minor enhancement release. For more details,
see the changelog at

Linux-audio-announce mailing list

by at June 16, 2015 02:14 PM


Notstandskomitee remix and concert Karlsruhe 18.6.

Notstandskomitee performs in Karlsruhe the 18.June 2015 at AKK on the festival Angewandte Elektronik TV, along with Circuit Noise, Blood Vault and Benoît & the Mandelbrots:

Just released is a remix for Bitemap from Barcelona which can be heard on Bandcamp:

by herrsteiner ( at June 16, 2015 01:07 AM

June 14, 2015


Sonar+D and MOD UIs

Sonar+D and MOD UIs

MOD and Sonar + D OpenAV will be attending the Sonar+D event in Barcelona with MOD. The Sonar event brings together people interested in “music creativity & technology” – and that’s pretty much exactly what MOD, OpenAV and Linux-Audio are about. Needless to say, I’m very excited about this! Anybody living in Barcelona interested in OpenAV stuff – email me… Read more →

by harry at June 14, 2015 07:30 PM

June 13, 2015

Hackaday » digital audio hacks

Update: Battlezone on Vector Display Step-by-Step

When we ran the story of Battlezone played on tube displays earlier this week there were immediately questions about recreating the hack. At the time the software wasn’t available, and there is also a bit of hardware hacking necessary to get the audio working. You asked and [Eric] from Tubetime delivered. He’s posted a pair of articles that show how to get an STM32F4 Discovery board to play the classic game, along with instructions to build the firmware.

The hardware hack in this case is untangling the pinout used on the discovery board. It seems that one of the lines needed to get sound working for this hack is tied to one of the two DACs. If you read the original coverage you’ll remember that both of the DACs are used to drive X and Y on the vector display. The image above shows a cut trace on the bottom of the board. You’ll then need to route that signal to an alternate pin by soldering a jumper wire from the chip to a resistor on the board.

This (as well as one other alteration that bridges two of the chip pins) is a great example of work you should be unafraid to do on your own dev boards. We’ve had to do it with the Launchpad boards to get at the functionality we needed. We’d like to hear your own epic stories of abusing dev boards to do your bidding. Let us know in the comments.

Filed under: digital audio hacks, Microcontrollers

by Mike Szczys at June 13, 2015 11:01 AM

June 11, 2015

Nothing Special

Using LV2 atom:Path (or how to get files safely in a plugin without a GUI)

The end of last month marked 2 years since my initial commit to my first lv2 plugins. I've learned some things, but still am picking up more little by little. I was recently reminded that I don't know it all, when falkTX pointed out another stupid mistake I'd been making that prevented my GUIs from resizing correctly.

Water under the bridge though. I'm going to try to explain out how to use lv2 to have the host make a file selection dialog for you. I want all my plugins to work purely with host generated GUIs and loading files became necessary for porting the rakarrack *tron effects. The LV2 official documentation has improved a lot, but I was still struggling, so I thought I'd post this. The example to be used is rakarrack's reverbtron. Its a sort of convolution using very simplified impulse response files (which are actually text files). Instead of a constant sample rate in the IR, you just keep the most important samples and interpolate between them.

Regardless of the details, I have a module that needs files. All I need is to pass the file's path to the modules setfile() function and it takes care of the rest. How do I get that path? The whole process involves several extensions, and the most confusing part to me was figuring out what was what. But I got it, so read on...

So lets start with the ttl. Quick recap, ttl is static data that the host loads to figure out what your plugin is all about (see the official examples for some more info). So we need to indicate to the host in this ttl that we need files. Lets create a new statement that defines our .rvb files that hold the IR data. I usually just take the URI for the plugin and tack on some extra stuff with colons. Even though its not an actual website, the whole point of a URI is to keep it universally unique so its pretty unlikely any other plugin will name anything this same string:

      a lv2:Parameter ;
      rdfs:label "rvb file" ;
      rdfs:range atom:Path ;

As you probably know already, this "sentence" in the ttl says, "I declare an lv2 parameter, labeled 'rvb file', and can be any value as long as its an atom containing a path." This is all done with URIs, but most of them are shortened using prefixes at the top of the file. Because these URIs are universal, the host knows what they mean and can interpret that as "ok, they have a parameter that will be a path" (roughly).

Now we need a port for this parameter to be passed into. Its not too different than other ports we've seen before, but we'll use an atom port like just we do for midi ports. So we have inside the plugin declaration we add:

     lv2:port [
              a lv2:InputPort, atom:AtomPort ;
              lv2:index 4 ;
              lv2:symbol "CONTROL" ;
              lv2:name "Control" ;
              atom:bufferType atom:Sequence ;
              lv2:designation lv2:control ;
              atom:supports patch:Message ;
      ] ;

This says the 4th port is an atom input. It has name and symbol "control". The host will hand us a pointer to a buffer full of a sequence of atoms (which are just structures of data). Its a designated port for the host to pass any control messages to (such as data for bpm sync, or our .rvb files). Finally, the port supports atoms carrying something called patch:message. What?

Patch is another extension that is used to read or manipulate properties between the host and plugin. I'm not extremely familiar with it, so I don't have any examples of what else you can do with it. Say for example is if the host wants to change the file path property of our plugin...

If you expand the prefix for patch the message URI is The docs here aren't very verbose, but feel free to see what possibilities are there. The idea is that you can pass several properties without needing different message types for everything.

We want the host to know what property they can manipulate, so in our plugin declaration ttl we add:

   patch:writable <> ;

saying that the plugin has a ".rvb file" property that the host can write. The host knows that URI means the .rvb file because we declared it before we declared the plugin.

See? This ttl stuff is pretty readable once you get the hang of it. You can see the full ttl but everything else in it, we've done before. 

So lets jump to the code. Assuming we've got the port connecting correctly, we just need to pull the atoms out of the buffer the host gives us, make sure they're the type of atom we want, then just grab the data (which should be the file path). So the action all happens in the run() part of the plugin, but we need a few things setup first. 

We need a way to recognize the URIDs that the atoms carry, and thats through the URID:map. I've described the map before, but I didn't really understand it then. Basically the host takes the URIs and says, "ok, how about from now on instead of calling that '' we'll say its 4. So now whenever I pass an atom marked type 4, we both know what I mean." This mapping is generated arbitrarily by the host, they will call whatever URI any unique integer value, but you can count on it remaining unique this whole session. So always pay attention whether a function needs a URI (string) or a URID (int).

Anyway so its our plugin's responsibility to look through the host_features passed into our initialization function to get and save the mapping:

 for(i=0; host_features[i]; i++)
            urid_map = (LV2_URID_Map *) host_features[i]->;data;
                plug->URIDs.atom_Float = urid_map->map(urid_map->handle,LV2_ATOM__Float);
                plug->URIDs.atom_Int = urid_map->map(urid_map->handle,LV2_ATOM__Int);
                plug->URIDs.atom_Object = urid_map->map(urid_map->handle,LV2_ATOM__Object);
                plug->URIDs.atom_Path = urid_map->map(urid_map->handle,LV2_ATOM__Path);
                plug->URIDs.atom_URID = urid_map->map(urid_map->handle,LV2_ATOM__URID);
                plug->URIDs.patch_Set = urid_map->map(urid_map->handle,LV2_PATCH__Set);
                plug->URIDs.patch_property = urid_map->map(urid_map->handle,LV2_PATCH__property);
                plug->URIDs.patch_value = urid_map->map(urid_map->handle,LV2_PATCH__value);
                plug->URIDs.filetype_rvb = urid_map->map(urid_map->handle,RVBFILE_URI);

There in the last line I use a #define I created for the URI string (for readability):

#define RVBFILE_URI ""

See how that matches the URI in the ttl? One thing not shown here is that if the host does not give you a urid_map you need to abort the instantiation and return a 0 to the host. Now that we have that done (along with our other instantiation tasks not shown) then we're ready for the signal processing function, run(). When we're running the signal processing, we can look through the atom sequence and use the URIDs to find the atoms with data we want. This uses several LV2 macros, but they're pretty readable:

   LV2_ATOM_SEQUENCE_FOREACH(plug->atom_in_p, ev)
       if (ev->body.type == plug->URIDs.atom_Object)
           const LV2_Atom_Object* obj = (const LV2_Atom_Object*)&ev->body;
           if (obj->body.otype == plug->URIDs.patch_Set)
               // Get the property the set message is setting
               const LV2_Atom* property = NULL;
               lv2_atom_object_get(obj, plug->URIDs.patch_property, &property,  0);
               if (property && property->type == plug->URIDs.atom_URID)
                   const uint32_t key = ((const LV2_Atom_URID*)property)->body;
                   if (key == plug->URIDs.filetype_rvb)
                       // a new file! Get file path from message (the value of the set message)
                       const LV2_Atom* file_path = NULL;
                       lv2_atom_object_get(obj, plug->URIDs.patch_value, &file_path, 0);
                       if (file_path)
                           // Load sample. 
                       }//got file
                   }//property is rvb file
               }//property type is a URID
           }//if object is patch set
       }//if atom is abject
   }//each atom in sequence

So you see we go through each atom in the sequence. If the atom is an object containing a a patch:Set message, check if the property the patch message is setting matches our file URID. If it does then get the value the patch message is setting it to (which is really .rvb file's path the user selected).

Really thats all there is to it. Except...

File IO is NOT realtime safe. It could be reading off a USB 1.0 drive. Or an i2c drive. One thats networked over a dial-up connection. You never know. So unless the Reverbtron class's setfile() function handles it through multi-threading (and it doesn't) then this plugin is not realtime safe if we leave it like this.  If you need motivation on why you should worry about being RT safe go read the classic blogpost on the subject of realtime audio programming

So LV2 conveniently has an easy way for you to do file operations or any other non-RT stuff you want safely. Its called the worker extension. You can use it to calculate Fibonacci sequences or fractals, or download the internet, or whatever you want and it won't stop your RT code. Hey, we could make it calculate PI to n decimal places... I digress. The key here is that you schedule some function to be run by the "worker" (which is really just a separate thread, but you don't need to worry about it too much). This scheduling sends it off to another "place" to calculate whatever in however much time it will take. You can pass atoms to the work function for data or to indicate why the it is being run. This way you can do different tasks even though the worker always runs the same function. Once the work is complete the worker can execute a response function that can change your plugin. This second function must be RT safe. So the worker function will load the file into a struct or some useable form (not RT), then the worker response will put the struct into the plugin (RT). All you have to do is write these two functions then the host will handle the rest.
Well, good luck! 

Just kidding. I wouldn't leave you hangin! Lets go through it together. First we need to revisit our ttl to tell the host when they load this plugin that it needs the worker extension:

    lv2:requiredFeature urid:map , worker:schedule ;
    lv2:optionalFeature lv2:hardRTCapable ;
    lv2:extensionData worker:interface ;

The first line gets work:schedule added as the new required feature, optional features haven't changed, but we now need an extensionData struct for the worker (don't forget to add the necessary prefixes at the beginning of your ttl!). The work:interface indicates to the host that we'll use the extension_data() function of our plugin to hand over a struct called an LV2_Worker_Interface (surprise!). This struct has function pointers for the function you want the worker to run that doesn't have to be RT safe and the response function that does. Before now I haven't used the extension data in the dsp part of the plugin (just in the GUI), but it doesn't change too much. We need to define the struct, the functions, and put them in the plugin descriptor:

//forward declarations
static LV2_Worker_Status revwork(LV2_Handle handle, LV2_Worker_Respond_Function respond,
 LV2_Worker_Respond_Handle rhandle, uint32_t size, const void* data);
static LV2_Worker_Status revwork_response(LV2_Handle handle, uint32_t size, const void* data);

static const LV2_Worker_Interface worker = { revwork, revwork_response, NULL };

static const void* revtron_extension_data(const char* uri)
    if (!strcmp(uri, LV2_WORKER__interface)) {
            return &worker;
    return NULL;

static const LV2_Descriptor revtronlv2_descriptor={

We'll get into what the work and response functions do in a bit, but for now suffice it to say they are defined, we put them in a constant struct, and pass return that when requested by the host (when the host calls revtron_extension_data(LV2_WORKER__interface);). Thats not too crazy, especially if you've read my posts on UIs where I used several extensions with extension data.

We next need to add an LV2_Worker_Schedule* member to our plugin for this will be the way to schedule the non-RT work to run. We also need to get the LV2_Worker_Schedule* that will come from the host during initialization. So:

   for(i=0; host_features[i]; i++)
            plug->;scheduler = (LV2_Worker_Schedule*)host_features[i]->;data;
        else if(!strcmp(host_features[i]->URI,LV2_URID__map))
            //urid map stuff from earlier

Now that we have that, we can use it in the run() function. The code is the same part as above but in the deepest part of the if tree it changes to:
//going through the atoms in the sequence 
lv2_atom_object_get(obj, plug->URIDs.patch_property, &property, 0); 
if (property && property->type == plug->URIDs.atom_URID) 
     const uint32_t key = ((const LV2_Atom_URID*)property)->;body;
     if (key == plug->URIDs.filetype_rvb)
          // a new file! pass the atom to the worker thread to load it
          plug->scheduler->schedule_work(plug->scheduler->handle, lv2_atom_total_size(&ev->body), &ev->t;body);)
     }//property is rvb file 
}//property is URID

So instead of pulling the file path string out of the atom and calling setfile(),  we just pass the atom to the worker. Now though, we have to be careful of multi-threading issues. If the worker is in the middle of loading the new file data while the run() executes, you might get some crazy behavior, reading half written variables etc. So I have to change the Reverbtron class to have 2 functions: loadfile() and applyfile(). The first will do the file operations and create a struct with the important data. applyfile() in turn will take the new struct and swap out the old one. loadfile() will be used in the work function, and the other in the RT-safe worker reply. This keeps everything clean and threadsafe. I'm not puting the load and apply code here because its very application specific, but thats the general idea. You can go look at the repo for the full code.

Once I have that in place I can write the function that the worker will run:

static LV2_Worker_Status revwork(LV2_Handle handle, LV2_Worker_Respond_Function respond, 
LV2_Worker_Respond_Handle rhandle, uint32_t size, const void* data)

    RKRLV2* plug = (RKRLV2*)handle;
    LV2_Atom_Object* obj = (LV2_Atom_Object*)data;
    const LV2_Atom* file_path;

    //work was scheduled to load a new file
    lv2_atom_object_get(obj, plug->URIDs.patch_value, &file_path, 0);
    if (file_path && file_path->type == plug->URIDs.atom_Path)
        // Load file.
        char* path = (char*)LV2_ATOM_BODY_CONST(file_path);
        RvbFile filedata = plug->revtron->loadfile(path);
    }//got file
        return LV2_WORKER_ERR_UNKNOWN;
    return LV2_WORKER_SUCCESS;

So we take that atom and just pull out the patch value, run it through loadfile() which returns a struct that holds all the important data from the file. We then pass the struct to the respond function, which looks like so:

static LV2_Worker_Status revwork_response(LV2_Handle handle, uint32_t size, const void* data)
    RKRLV2* plug = (RKRLV2*)handle;
    return LV2_WORKER_SUCCESS;

This simply takes the struct with the filedata and applies it. This response function is actually run between run() calls of your plugin so you will have predictable results (you don't have to worry about the worker finishing and changing things in the middle of your signal processing). Originally I was trying to allocate the struct in loadfile() so that applyfile() just has to swap pointers, but then you must schedule the worker thread again to delete the old struct (delete/free() are not RT safe either). The other obstacle is that when the host is running these functions it copies the data that you pass, so you have to make take care you are manipulating the data you think you are when you try to pass pointers. It can be done (the official example does this), but I realized it made the code more complex than it needs to be. Premature optimization is the root of all evil. If profiling shows the extra memory copying is too expensive I'll worry about it then. For this example and many cases, just use plain old data (POD).

So, we're done, right? Unfortunately, no. If you want the user to be able to use your plugin, they'll need to be able to load it up in their session and when they reload the session it has the same file selected. This has to be done through yet another extension: state.

The state extension mechanics are similar to the worker extension, the host will pass in the state URI to extension_data() and we must return a special struct that tells the host what function to call to save and to restore the current state. Since the only state of the plugin that's not controlled by the usual controlPorts is the .rvb file thats all we need to save. So first we change the .ttl:

    lv2:requiredFeature urid:map, worker:schedule ;
    lv2:optionalFeature lv2:hardRTCapable, state:loadDefaultState ;
    lv2:extensionData worker:interface, state:interface ;

And in the extension data, add the state interface below what we did for worker:

static const LV2_Worker_Interface worker = { revwork, revwork_response, NULL };
static const LV2_State_Interface state_iface = { revsave, revrestore };

static const void* revtron_extension_data(const char* uri)
    if (!strcmp(uri, LV2_STATE__interface))
        return &state_iface;
    else if (!strcmp(uri, LV2_WORKER__interface))
        return &worker;
    return NULL;

for this extension we won't need any special mappings or anything in initialization. This is pretty much stuff we've done before, but what does the save function do? Well, something like:

static LV2_State_Status revsave(LV2_Handle handle, LV2_State_Store_Function  store, LV2_State_Handle state_handle,
        uint32_t flags, const LV2_Feature* const* features)
    RKRLV2* plug = (RKRLV2*)handle;
    LV2_State_Map_Path* map_path = NULL;
    for (int i = 0; features[i]; ++i)
        if (!strcmp(features[i]->URI, LV2_STATE__mapPath))
            map_path = (LV2_State_Map_Path*)features[i]->data;

    char* abstractpath = map_path->abstract_path(map_path->handle, plug->revtron->File.Filename);

    store(state_handle, plug->URIDs.filetype_rvb, abstractpath, strlen(plug->revtron->File.Filename) + 1,


    return LV2_STATE_SUCCESS;

File paths are a little unique because you don't want to store an absolute path, otherwise it won't be very portable (i.e. a preset on your machine probably won't work on mine). So there's a special part of the state extension that generates an abstract path that is more portable. Finally the big moment is calling store which comes from the state extension. You just pass in the URID for whatever you are saving, then the data you are saving, followed by the size and data type URID. The rest is just boilerplate code that you can more or less just paste and forget in most cases.

From save, restore ends up being pretty predictable:

static LV2_State_Status revrestore(LV2_Handle handle, LV2_State_Retrieve_Function retrieve,
        LV2_State_Handle state_handle, uint32_t flags, const LV2_Feature* const* features)
    RKRLV2* plug = (RKRLV2*)handle;

    size_t   size;
    uint32_t type;
    uint32_t valflags;

    const void* value = retrieve( state_handle, plug->URIDs.filetype_rvb, &size, &type, &valflags);

    if (value)
        char* path = (char*)value;
        RvbFile f = plug->revtron->loadfile(path);

    return LV2_STATE_SUCCESS;

On this side, just a call to retrieve which will find the data that was saved with our URID and return it.

So FINALLY we've gone from not being able to have users load files to an unsafe way to load files (patch extension), to a safe way (worker extension), to a way that allows us to reload the previous setting (state extension). Not too bad.

Hopefully this was as helpful to you as it was to me as I was writing it. I was looking through the examples, but couldn't really parse out what parts applied to my plugin and what parts were for this extension or that one. I had to break it down like this to really understand whats going on.

by Spencer ( at June 11, 2015 10:59 AM

June 10, 2015

Linux Audio Announcements -

[LAA] Wanted before July: Ambisonics art works for Auditory Virtual Environments ...

Ambisonics has a strong community using Linux, therefore I ask the community
herein for art works:

"Pure Ambisonics" == "Ambisonics as an art form" is the hypotheses

We are searching for different works, which need not be recent ones, also
historic ones are of interest. Preferring higher order 3D, we take any order
3D or 2D as long it represents a wave-field as a spatial audio work ready for
concert. To test this thesis a concert is scheduled:

- PURE Ambisonics Concert & the Night of Ambisonics -

September 18th at ICSA 2015 in Graz

Preferring the AmbiX format, we also take other formats as long the
description has enough information to convert them to this domain.

More INFO on the CALL:


Ritsch, Winfried, Ao.Univ.Prof. Dipl.-Ing.
Institut 17 Elektronische Musik und Akustik
8010 Graz, Inffeldgasse 10/III
Mobil ++436642439369

Linux-audio-announce mailing list

by at June 10, 2015 12:46 PM

June 09, 2015

Linux Audio Announcements -

[LAA] latest Yoshimi developments

V 1.3.5-rc

I don't usually post here about release candidates, but there have been a lot
of changes since V 1.3.4

Some, like vector control were demomstrated to a handful of people at LAC 2015,
others are a direct response to suggestions there, and there is a roadmap we're
following too.

Before making a full release I'd very much like comments. What you like, what
you don't and what's just 'meh'. So please grab the current snapshot.

In brief:

User interface

Visual identification of use of any/all three synth engines

Part number and name added to all editing window title bars
Also voice number to AddSynth oscillator editor

Scroll wheel control of all rotary knobs +Ctrl for very fine control

Horizontal as well as vertical drag of rotary knobs

Revised some layouts and removed redundant controls and refreshes


On demand jack port creation for part outputs

NRPNs inc 14bit & increment/decrement
Also Zyn compatible ones (with some extensions)

16, 32 or 64 semi-independent parts

Vector control

Direct part control


The 'docs' directory now gets installed, although still scrappy text files

There is a new historical branch (currently with versions 0.010 to 0.038)

Yoshimi is now mirrored

Of course the original is still

Will J Godfrey
Say you have a poem and I have a tune.
Exchange them and we can both have a poem, a tune, and a song.
Linux-audio-announce mailing list

by at June 09, 2015 04:59 PM

June 08, 2015

Create Digital Music » open-source

7 Ways SONAR+D is Asking Bigger Questions About Music Tech

Lineup Sónar+D 2015 from Sónar on Vimeo.

There’s nothing inherently wrong with asking the same questions repeatedly. Cyclical inquiries are necessary in any practice. And over time, you refine answers.

But this year’s SONAR+D program promises something different.

SONAR+D is the younger, digital discourse alongside Barcelona’s massive electronic music festival. SONAR itself deserves a lot of credit for helping create the template a lot of digital music and media festivals follow today. And as that has since blurred into a parade of headliners, SONAR+D added a lot of dimension. There were good talks, hacklabs, workshops, and a showcase of makers.

Speaking as someone who either follows or participates in a lot of these things, though, I can’t wait for this year’s lineup. It seems uniquely ambitious and relevant, and I hope it sets the tone for the rest of this year.

Here are the threads I hope to follow – and why I’m glad CDM is a media partner of SONAR this year.

1. It’s not afraid to ask some hard questions. First up, I’m really curious what will come out of the discussion I’m joining, “De-westernalizing music through technology.” It’s a conversation I hope will spill over far past SONAR.

Xavi Serra is a leading researcher from one of the world’s hottest programs in music tech, the Music Technology Group at Pompeu Fabra University. And he’s in a fascinating new area, examining computational models for the world’s music. That includes delving into music from India, Turkey, Maghreb (Arabic-Andalusian), and Chinese Peking Opera idioms. Israeli producer Ariel Tagar is re-releasing rare Middle Eastern vinyl, and went to Jamaica to produce a record – sans computers, Jamaican style. Watch the trailer for a documentary that tracked them from Tel Aviv to the Kingston ghettos:

Congo Beat The Drum – Kalbata & Mixmonster // Trailer from kalbata on Vimeo.

Given the assumptions and defaults made by many music software tools are narrow even in the context of Western Classical practice, I think there’s plenty to explore here.

Speaking of asking tough questions, Holly Herndon is asking a lot of particularly timely ones. Without a hint of cynicism, her work digs into the profound interactions our computers have with privacy, surveillance, and politics – all the while keeping matters musical and personal. I’m particularly keen to hear what she’ll talk about to veteran music journalist Kate Hutchinson (The Guardian). This is a great chance to catch her live at SONAR, too.


2. It’s highlighting some of our favorite music. Apart from Holly, SONAR+D is honing in on some of the music I can say at least I most love. Editions Mego, Resident Advisor meeting up with Voices from the Lake, and XL Recordings are all in the spotlight. All that and sonic reflections on Mies van der Rohe.


3. It’s directly celebrating open technologies. There’s very little discussion of open tech at these sort of events. Not so, SONAR. Arduino co-founder David Cuartielles is directly engaging open source hardware. And this is a timely moment for Arduino, given the traction of new (sometimes competing) platforms, Arduino’s entrance into MOMA, and challenges around branding. There’s a workshop with a Theremin and step sequencer, too.

littleBits are on-hand, too, complete with a workshop featuring a performance by FEZ co-developer Renaud Bédard, playing live. littleBit’s industrial design lead Jordi Borràs is a Barcelona native, since transplanted to that company’s home in New York, and will talk about how the platform can “snap into the Internet” with the Cloud bit. That should be Internet of Things buzzword-compliant, as should an appearance by Bruce Sterling, hosted by WIRED Italy.


4. It just might break some new DJ tech. DJing’s two biggest titans are each coming to show their latest stuff. In this corner, Pioneer: their PLX-100 and XDJ are the company’s latest play for the booth, covering their bases for both vinyl and computer control. Meanwhile, with the tech just about to hit users, Native Instruments are showing Stems, flanked by none other than Carl Craig, Luciano, and Kerri Chandler.

5. It could help European entrepreneurship and innovation. When I first came to SONAR, Spain was still reeling from the economic crisis. The entire European arts community was sorting out where to go next. Now, it seems, we’re getting some answers – and SONAR is unique in embracing DIY initiative as part of the solution. There’s talk of a href=””>how Barcelona is making startups work

, and Google Creative Lab is talking about how they work.

There’s also an active role by Kickstarter, including the opening keynote – and no accident that you’ll get to see a Kickstarter-funded futuristic digital handpan as part of the event, too.

But this isn’t just about the startup-style, fend-for-yourself American model. European policy has a role, as well – one that can be more targeted and effective than perhaps it was in the past. The European Commission is a platform for neurotechnology, and in a massive talk will discuss open digital science ranging from NGOs to researchers to academics to EC wonks.


6. You might learn to build something.As in past years, there’s a 24-hour Hack Day sure to yield new stuff. As to the last point, though, this now includes European-funded building blocks to accelerate development to a new level.

Even if you’re not hacking, you can build the new synth project coming out of Mute Records.

7. It’s just generally got some cool stuff. Moldover, he of controllerism fame, is in town. Motionographer is showing eye candy. The creators of the beautiful indie game Monomument Valley are talking about their work, and Aaron Koblin and Chris Milk are going VR. The 808 movie is screening, with Arthur Baker (who’s also performing). And there’s lots more, even before we get to the artists playing the festival.

We’ll be reporting back. But:

If you’re going to Barcelona…

Discover Sónar and Sónar+D with your accreditation at a reduced price:

Thanks to the partnership between Create Digital Music and Sónar+D to promote networking opportunities among related communities around the Creative Industries, we are offering 10 professional accreditations -first come first serve- with an exclusive discount deal to attend Sónar 2015 only until 12th of June 2015

Promotional Price:

250€ – Day and Night accreditation. Price without promotion 310 euros

Find all the accreditation benefits:

Ask for your promotional pass by contacting

And no, we’re not getting paid for this piece – these are my opinions.

Believe me, otherwise I would happily just show up for my panel and sneak away to the beach the rest of the time!

I’m really excited! I’ll be chugging Red Bulls and trying to absorb as much as I can!

The post 7 Ways SONAR+D is Asking Bigger Questions About Music Tech appeared first on Create Digital Music.

by Peter Kirn at June 08, 2015 02:58 PM

June 06, 2015

Hackaday » digital audio hacks

ESP8266 As A Networked MP3 Decoder

Support libraries, good application notes, and worked examples from a manufacturer can really help speed us on our way in making cool stuff with new parts. Espressif Systems has been doing a good job with their ESP8266 product (of course, it doesn’t hurt that the thing makes a sub-$5 IOT device a reality). Only recently, though, have they started publishing completed, complex application examples. This demo, a networked MP3 webradio player, just popped up in Github, written by the man better known to us as Sprite_tm. We can’t wait to see more.

The MP3 decoder itself is a port of the MAD MP3 library, adapted for smaller amounts of SRAM and ported to the ESP8266. With a couple external parts, you can make an internet-connected device that you can point to any Icecast MP3 stream, for instance, and it’ll decode and play the resulting audio.

What external parts, you ask? First is something to do the digital-to-analog conversion. The application, as written, is build for an ES9023 DAC, but basically anything that speaks I2S should be workable with only a little bit of datasheet-poking and head-scratching. Of course, you could get rid of the nice-sounding DAC chip and output 5-bit PWM directly from the ESP8266, but aside from being a nice quick demo, it’s going to sound like crap.

The other suggested external IC is an SPI RAM chip to allow for buffering of the incoming MP3 file. WiFi — and TCP networks in general — being what they are, you’re going to want to buffer the MP3 files to prevent glitching. As with the dedicated DAC, you could get away without it (and there are defines in the “playerconfig.h” file to do so) but you’ll probably regret it.

In sum, an ESP8266 chip, a cheap I2S DAC, and some external RAM and you’ve got a webradio player. OK, maybe we’d also add an amplifier chip, power supply, and a speaker. Hmmm…. and a display? Or leave it all configurable over WiFi? Point is, it’s a great worked code example, and a neat DIY device to show your friends.

The downsides? So far, only the mono version of the libMAD decoder / synth has been ported over to ESP8266. The github link is begging for a pull request, the unported code is just sitting there, and we think that someone should take up the task.

Other Resources

In our search for other code examples for the ESP8266, we stumbled on three repositories that appear to be official Espressif repositories on Github: espressif, EspressifSystems, and EspressifApp (for mobile apps that connect to the ESP8266). The official “Low Power Voltage Measurement” example looks like a great place to start, and it uses the current version of the SDK and toolchain.

There’s also an active forum, with their own community Github repository, with a few “Hello World” examples and a nice walkthrough of the toolchain.

And of course, we’ve reported on a few in the past. This application keeps track of battery levels, for instance. If you’ve got the time, have a look at all the posts tagged ESP8266 here on Hackaday.

You couldn’t possibly want more resources for getting started with your ESP8266 project. Oh wait, you want Arduino IDE support?

Thanks [Sprite_tm] for the tip.

Filed under: digital audio hacks, Microcontrollers

by Elliot Williams at June 06, 2015 02:00 PM

June 05, 2015

Linux Audio Announcements -

[LAA] io GNU/Linux 2015.03 released

Hi all,

New images are ready for testing ;)

io GNU/Linux is a Live DVD/USB based on Debian Sid and focused on multimedia.

Kernel 4.0.4 and 4.0.4-rt, Jack2+AlsaLoop as default sound server (can be
easily changed to Jack2+ZitaBridge, Jack2+PulseAudio, PulseAudio or Alsa)

e18 as desktop environment and a big collection of installed software... Full
persistence for USB install (with encryption) and more stuff...

For more infos: manual, packages list, screenshots, video etc... Visit:


Installer has been rewritten, and a lot of work has been done to improve
security of live persistent users.

Feedbacks welcome, enjoy :)


by at June 05, 2015 01:09 PM

June 04, 2015

Nothing Special

How to Boycott SourceForge

I was finally convinced to leave I was holding out, trying to be true to a service that once was the best and most dedicated to free license and open source software, but finally, due largely to this editorial, have decided to join the boycott. Since I don't like doing things half-way I'm taking everything down and trying to make it as easy as possible for others to do the same.

If you are using git already, it won't take much to move your repositories to Github. Bitbucket will pretty much be the same commands. I already had an account so I won't describe how to sign up, but its pretty easy. Once signed in you can create a repository by clicking the little plus sign in the top right corner. Name the repo whatever your project name is and opt to leave it empty (I presume you already have the project hosted at You should make sure you're up to date on every branch from first. Once that is done you can just go to your local repo and issue the command:

git push[USERNAME]/[PROJECTNAME].git master

and repeat for every branch besides master.

You can then delete the local repo and re-clone it using the URL github give you, or just edit .git/config to update what URL origin points to, or there's some git command to do it that I can't remember. You can also go delete your project from BUT I decided to leave the skeleton of the project with links to the new home at github.

To do so make sure you haven't pointed your repo's origin to github yet. If you have substitute the project git URL for origin. Go delete every branch but master on by entering:

 git push origin :branch

Then on master branch do (carefully):

rm -rf *
echo moved to [github project URL] to boycott sourceforge >> README
git commit -a -m "boycott sourceforge"
git push origin master

Careful, because rm -rf * deletes everything in the current directory. This makes it so your repository is now empty except a nice little statement of what we think of the new

I only had source tarballs in the files section so I deleted them all and added the same readme as is in the repo. If you use this feature of it will be harder to find a substitute. This blogger subjectively goes through 14 alternatives and decides to stick with sourceforge. Hopefully you can find one of the alternatives workable.  I also edited the project description to say that the project had moved.

 If your project has a website you can move it to github quite easily too. Just go to your repo that is now using github for the origin and type:

git checkout -b gh-pages
rm -rf *

The name of the branch (gh-pages) is very important. Download the site source from the sourceforge ftp if you need or if you have a local copy just copy it all into the repo. Make sure you have an index.html and then just:

git add *
git commit -a -m "adding site"
git push origin gh-pages

Your new site is at http://[USERNAME][PROJECTNAME]
Not too bad!

I wish I had a good answer about binaries. If you use other features like mailing lists you might have to do some more homework too. If you have found good solutions, spread the word, leave a comment.

Now, as a commentary, SourceForge hasn't done anything illegal. The GPL of most open software allows them completely to package it with adware, malware or whatever. But is that cool? Heck no! So on grounds of ethics, it has come time to boycott. Do not visit, do not download from there, and do not give them your code to host. I avoided Github for a long time because I felt they weren't as dedicated to open source, since their site code is not open (and partially because I tend to kick back when something seems trendy). But honestly it seems they've found a business model that is working for them and allows us more freedom for free software projects. SourceForge is not what it once was, and we owe the current management of it no loyalty. I don't really mind which service you move to, but don't stay.

by Spencer ( at June 04, 2015 11:44 PM

June 02, 2015

Create Digital Music » Linux

Novation’s Launchpad Grid, Now in Color, for Ableton or iPad


Novation’s Launchpad has seen slimmer and smaller versions. And upcoming is a Pro version with pressure/velocity and MIDI in and out.

But if you just want the grid, you can now get the base model with RGB color. It’s officially called the Launchpad mk2. No availability or pricing yet (damn you, unstable Euro), but you can sign-up for notification.

The update has the same basic design as the original, but updated with styling from its Pro sibling, and RGB color behind the pads for more visual feedback.

Here’s the obligatory video of the new model, which gets a very cute studio setup and a live performance by Buddy Peace:

That basic model does quite a lot.

Beginners: For beginners, you get a lot of bundles. Live Lite, a gig of samples, and the Bass Station plug-in are included.

Ableton Live users: In Ableton Live, you’re pre-mapped to Drum Racks, mixing, and Max for Live.

iPad owners: And this is a grid that works with just about anything. Ableton Live is the original use case, but the driverless model plugs into an iPad, too. There’s official support for Novation’s own Launchpad app.

Advanced users, customization: Linux, Windows, other apps, all work, too, because the Launchpad has class-compliant drivers. This hardware has also been well supported by the community for apps ranging from Bitwig to Renoise, partly because of its low cost. Because it’s simple to program, it’s a great choice for Max and Pd and Reaktor patchers, too.

But that’s all true of the whole family at the moment.

So, is this the Launchpad I’d get? Absolutely not.

Wait, what?

Yeah, I have to admit, I think Novation has nailed it with two models. The Launchpad Mini is incredibly small, so for a dead-simple grid to just toss in a bag, I’d opt for that model – partly because I don’t need all those colors. The Pro, meanwhile, is brilliant in that it works with MIDI, and much to my surprise will support standalone operation. It’s not necessarily the most responsive controller in terms of pressure sensitivity (I still like Push and Maschine for that, or the Linnstrument if I want to get really serious). But it may prove to be the most versatile. There’s more to say about the Pro, but expect our review as they arrive this summer. (I got to play with a prototype, alongside our own MeeBlip, this summer.)

All that said, I’m sure the RGB Launchpad will be perfect for some. And Novation has done a superb job of rounding out their lineup with options for every use case, rather than a one-size-fits-all approach. That lets you be modular and carry just what you need, and that, I think, is a very good thing.

Plus, I still can’t kill my original Launchpad (serial #7, believe it or not), even after copious amounts of abuse. So I think putting your faith in this line isn’t a big risk.

Ableton’s Push remains the hardware to beat as an expressive instrument with lots of other features. But it’s not much use outside of Ableton, it’s not available in anything other than the flagship model, and it’s heavy (which may be a good or bad thing, depending on whether you’re next DJ gig involves Ryanair).

Novation at the moment has pretty much every other possible base covered.

Now I just have to bide my time waiting for that Pro model.

The post Novation’s Launchpad Grid, Now in Color, for Ableton or iPad appeared first on Create Digital Music.

by Peter Kirn at June 02, 2015 10:31 AM

May 30, 2015

Linux Audio Announcements -

[LAA] [ANN] x42-plugins-20150530

Hash: SHA1


Spring cleaning is over and before the summer heat takes over here's
something to shake off the winter from the previous release.

x42-plugins is a collection of cross platform LV2 audio/midi plugins,
currently featuring over 80 plugins from 11 repositories.
(sha1sum 1a16a8ceff1f279ba92b9ca5c12aeb668725794b)


Significant changes since the last release (20141101)

* fil4.lv2 [new] (equalizer)
- 4 Band Parametric with additional High/Low shelfs and Hi/Lo Pass
and graphical display. Based on Fons Adriaensen LADSPA fil-plugins
- equivalent analog gain (zero phase shift) at nyquist
- zero latency

* meters.lv2 (measurement & visualization)
- new BBC M6 (mid/side) meter
- fix port label for true-peak meter
- combined GUI shared lib (dramatic reduction of deployment size)

* balance.lv2 (stereo conditioner)
- fix texture clamping (issues with some graphics card)
- add multisampling (nicer graphics)

* convo.lv2 (zero latency convolution)
- remember display (and announce) last/currently used IR
- tweak GUI-less mode (allows host to set/query IR file;
- reset channel assignment when replacing the IR file
(mono, stereo, true-stereo modes)

* midifilter.lv2
- fix potential overflow of midi-delaylines

* all plugins:
- update GUI font-scaling where applicable
- various openGL fixes (GL context separation)
- portability issues all plugins now run on Linux, OSX, Windows
and various CPU architectures.
- gtk variant has been deprecated (needs explicit BUILDGTK=yes)

For a complete list of changes, please see the individual repositories:
Version: GnuPG v1.4.12 (GNU/Linux)

Linux-audio-announce mailing list

by at May 30, 2015 09:25 PM

[LAA] MIDI programmed music box

At the Linux Audio Conference 2014 in Karlsruhe [1] there was an excursion
to the museum of mechanical music instruments in Bruchsal. [2] In the
museum they sold music boxes as a souvenir that can be programmed by punch
tapes. [3] I wrote a simple Haskell program that converts a MIDI file to
the punch tape. [4] As an example I arranged a song of a colleague for the
music box. [5,6,7]

Unfortunately, the music box is restricted to whole tones (i.e. no "black
keys") and it cannot play the same note again in a short time interval. My
prefered solution would be to print the graphics on an empty punch tape,
but I could not obtain an empty one. They are only sold with a printed
grid. Furthermore the original punch tapes are not made of paper but of
plastic. I do not know whether you can print on it using a plain laser or
ink jet. I might try thick paper instead but I suspect that it will wear
out quickly. However I already know that my laser printer cannot handle
the length of the original stripes. Thus I printed the graphics with
original width but shrunken length to regular paper and transfered the
dots from there to the punch tape manually.

Linux-audio-announce mailing list

by at May 30, 2015 08:16 PM

May 29, 2015

Linux Audio Announcements -

[LAA] LazyLimiter released.

Hi everybody,

I'm announcing the first release of my lookahead limiter: LazyLimiter v0.3.01

This is my attempt of a clean yet fast brick-wall limiter.

Thanks to Sampo Savolainen for providing the initial inspiration.

Very special thanks to Yann Orlarey, who spent an evening at LAC2015
with me, to optimize the algorithm and make this thing actually usable.

I'm looking forward to your feedback!


Linux-audio-announce mailing list

by at May 29, 2015 09:17 AM

May 28, 2015

Linux Audio Announcements -

[LAA] Qtractor 0.6.7 - The Lepton Acid beta release!

It's alive!

Qtractor 0.6.7 (lepton acid beta) is out!

Release highlights:

* MIDI instrument rendering on audio export (NEW)
* MIDI clip editor view/event criteria persistence (NEW)
* MIDI clip editor resilience on record/overdub (FIX)
* Generic plugin form position persistence (NEW)
* JACK Transport/Timebase master option (NEW)

and yet more tiny lurking critters swatted ;)

Well, the major highlight to this release is in fact this brand new and
way long overdue feature, seamlessly integrated to the faithful and
regular audio track export function: MIDI track instrument plug-in
rendering and mix-down (aka. freeze) is now real, as long their audio
output goes onto selected buses, aka. stems, mix-groups, whatever a
mix/mastering head would name it! nb. on the (very esquisite) Qtractor
arch-model parlance, those are just called "audio output buses" and that
ain't gonna change, any time soon, so stop it! A word of caution must be
told by now: dedicated (JACK) audio output ports are off-the-grid, so

Maybe this silently makes a notch towards the DAW epitome, though
Qtractor still claims to be just a plain and honest sequencer--with yet
another DAW-like feature addition--the same as it ever was.

Nuff said.

Qtractor [1] is an audio/MIDI multi-track sequencer application written
in C++ with the Qt framework [2]. Target platform is Linux, where the
Jack Audio Connection Kit (JACK [3]) for audio and the Advanced Linux
Sound Architecture (ALSA [4]) for MIDI are the main infrastructures to
evolve as a fairly-featured Linux desktop audio workstation GUI,
specially dedicated to the personal home-studio.


Project page:


- source tarball:

- source package (openSUSE 13.2):

- binary packages (openSUSE 13.2):

- wiki (help wanted!):

Weblog (upstream support):

Qtractor is free, open-source software, distributed under the terms of
the GNU General Public License (GPL [5]) version 2 or later.

- MIDI clip editor (aka. piano-roll) position, size, and view/event type
criteria are now persistent, across session and user preferences
application state.
- Generic plugin form widget position is now also preserved across
open/save session cycles.
- MIDI clip editor resilience is about to get an improvement, fe. it
doesn't close on stopping record/overdub anymore.
- Introducing (JACK) Timebase master setting as an option to Transport
mode (cf. View/Options.../General/Transport/Timebase).
- LV2 plug-in MIDI/Event support now slanted for deprecation.
- Spanish (es) translation added, by avid Reyes Pucheta.
- It's live: audio track export (cf. Track/Export Tracks/Audio...) has
been deeply refactored to finally include MIDI track/instrument plugins
rendering (aka. freeze) on selected audio output buses on mix-down.
- MIDI file player now does (N)RPN 14-bit controller events.
- Track properties dialog output bus switch fix/optimization; also fixed
multiple DSSI instance reference count on close.
- Fixed for some strict tests for Qt4 vs. Qt5 configure builds.
- German (de) translation update (by Guido Scholz, thanks).


[1] Qtractor - An audio/MIDI multi-track sequencer

[2] Qt framework, C++ class library and tools for
cross-platform application and UI development

[3] JACK Audio Connection Kit

[4] ALSA, Advanced Linux Sound Architecture

[5] GPL - GNU General Public License

See also:

Enjoy && keep the fun.
rncbc aka. Rui Nuno Capela

Linux-audio-announce mailing list

by at May 28, 2015 03:22 PM

May 27, 2015

Create Digital Music » open-source

zMors Puts a Modular on Your iPad – Now with Pd Patch Support


There are lots of one-off apps for iPad – a synth here, an effect there. zMors is something else: a complete modular patching environment.

And that doesn’t just mean putting some virtual patch cables onscreen. zMors does MIDI input. It works with hardware modulars (via audio and control voltage). And now, it adds Inter App Audio for use with other apps – and it loads Pd patches.

That’s right: you can put a modular patching environment inside your modular patching environment. Load a Pd patch from your computer into zMors, and combine it via other modules. That looks simply amazing for live performance.

First off, if you haven’t seen zMors yet, you do get a whole bunch of modules:

OSC, MultimodeFilter, WaveTable, ADSR, Slew, VCA, DSP, Combiner, Oscilloscope, Chords, CV Sequencer, Step Sequencer, Midi Keyboard, XYPad, Delay, Reverb, BPM CLock,4×4 MatrixMixer, Macro for complex setups

With the version released last week, zMors has added MIDI sequencing, a sampler, a MIDI filter, a motion module for making CV signals for outputs, a physical modeling (Karplus-Strong) oscillator, iCloud support (which is how you’ll load Pd patches), recording into WAV, Bluetooth MIDI support, and more.

If you know how to use Pd – even as far as downloading the odd patch – you know how to use the Pd bit. Pd patches work the way they always do, but here can be inter-connected with those other modules. You can thank libpd for making this possible – and, perhaps, ask why your favorite software doesn’t do something similar.

Here’s a short video showing what the software can do, from its fall launch (so obviously, it’s added more since then). And yes, you can customize that video:

For more:
a href=””>

The post zMors Puts a Modular on Your iPad – Now with Pd Patch Support appeared first on Create Digital Music.

by Peter Kirn at May 27, 2015 07:50 PM

Qtractor 0.6.7 - The Lepton Acid beta release!

It's alive!

Qtractor 0.6.7 (lepton acid beta) is out!

Release highlights:

  • MIDI instrument rendering on audio export (NEW)
  • MIDI clip editor view/event criteria persistence (NEW)
  • MIDI clip editor resilience on record/overdub (FIX)
  • Generic plugin form position persistence (NEW)
  • JACK Transport/Timebase master option (NEW)
  • and yet more tiny lurking critters swatted ;)

Well, the major highlight to this release is in fact this brand new and way long overdue feature, seamlessly integrated to the faithful and regular audio track export function: MIDI track instrument plug-in rendering and mix-down (aka. freeze) is now real, as long their audio output goes onto selected buses, aka. stems, mix-groups, whatever a mix/mastering head would name it! nb. on the (very exquisite) Qtractor arch-model parlance, those are just called "audio output buses" and that ain't gonna change, any time soon, so stop it! A word of caution must be told by now: dedicated (JACK) audio output ports are off-the-grid, so sorry.

Maybe this silently makes a notch towards the DAW epitome, though Qtractor still claims to be just a plain and honest sequencer--with yet another DAW-like feature addition--the same as it ever was.

Nuff said.

Qtractor is an audio/MIDI multi-track sequencer application written in C++ with the Qt framework. Target platform is Linux, where the Jack Audio Connection Kit (JACK) for audio and the Advanced Linux Sound Architecture (ALSA) for MIDI are the main infrastructures to evolve as a fairly-featured Linux desktop audio workstation GUI, specially dedicated to the personal home-studio.

Flattr this


Project page:



Qtractor is free, open-source software, distributed under the terms of the GNU General Public License (GPL) version 2 or later.


  • MIDI clip editor (aka. piano-roll) position, size, and view/event type criteria are now persistent, across session and user preferences application state.
  • Generic plugin form widget position is now also preserved across open/save session cycles.
  • MIDI clip editor resilience is about to get an improvement, fe. it doesn't close on stopping record/overdub anymore.
  • Introducing (JACK) Timebase master setting as an option to Transport mode (cf. View/Options.../General/Transport/Timebase).
  • LV2 plug-in MIDI/Event support now slanted for deprecation.
  • Spanish (es) translation added, by David Reyes Pucheta.
  • It's live: audio track export (cf. Track/Export Tracks/Audio...) has been deeply refactored to finally include MIDI track/instrument plugins rendering (aka. freeze) on selected audio output buses on mix-down. (EXPERIMENTAL)
  • MIDI file player now does (N)RPN 14-bit controller events.
  • Track properties dialog output bus switch fix/optimization; also fixed multiple DSSI instance reference count on close.
  • Fixed for some strict tests for Qt4 vs. Qt5 configure builds.
  • German (de) translation update (by Guido Scholz, thanks).

Enjoy && keep the fun.

by rncbc at May 27, 2015 06:30 PM

May 22, 2015

Create Digital Music » Linux

Cool Things Chrome Can Do Now, Thanks to Hardware MIDI


Plugging a keyboard or drum pads into your Web browser is now a thing.

One month ago, we first saw hardware MIDI support in Chrome. That was a beta; this week, Google pushed it out to all Chrome users.

So, what can you actually do with this stuff? Well, you can open a Web tab and play a synth on actual hardware, which is pretty nifty.

Support is still a little dicey, but the available examples are growing fast. Here are some of the coolest, in addition to the MIDI example and demo code we saw last month.

The examples are certainly promising, but you may want to temper expectations. Users of browser-based solutions built on Flash will find some of this old news. Audiotool, for one, has already had a really sophisticated (semi-modular, even) production tool running for some years. (It’s relevant here that Audiotool is coming to the HTML5/MIDI support, but it isn’t here yet.) And while open standards are supposed to mean more compatibility, in practice, they are presently meaning far less. Even though Safari and Chrome are pretty close to one another in rendering pages, I couldn’t get any of these examples working properly in any browser other than Chrome. And while I could get pretty low-latency functionality, none of this is anywhere near as solid in terms of sound performance as any standalone music software.

So, that leaves two challenges. One, the implementation is going to have to improve if non-developers are going to start to use this. And two, if this stuff is going to see the light of day beyond music hackathons, it’ll need some applications. That said, I could imagine educational applications, demos of apps, collaborative possibilities, and more – and those expand if the tech improves. And, of course, this also gets really interesting on inexpensive Chromebooks – which it seems are selling in some numbers these days.

But that’s the future. Here are some of the things you can do right now:


Audiotool is coming to HTML5, and Heisenberg is here now. Heisenberg is I think the coolest option yet – more than just a tech demo, you can plug in a MIDI keyboard and it’s a really fun, free browser synth. Given the amount of pleasure we’ve gotten out of the odd Web time-waster, this is serious business.

But that’s just the appetizer. The team behind Audiotool are working on porting it to HTML5. That should be an excellent test of just how mature this technology is. Audiotool is great and – Flash or not – it’s worth having a play with if you are the kind of person who gets some inspiration from new software toys. (And if you’re reading this far, I suspect you are.) [Flash for now, including screenshot above]


Revisit Roland. Steven Goldberg’s 106.js reimagines the classic Roland Juno-106 in JavaScript. And it’s just added MIDI support. Plus you can check the code out, free.



Play a 60s Yamaha combo organ. The oddest of this bunch is also my favorite sonically, just because it’s so quirky. The Foo YC20 is an emulation of Yamaha’s 1969 organ, the YC-20 combo – “features and flaws” all included. And now it feels more like an organ, since you can connect a MIDI keyboard.

Users should like it: if you’re not fond of running it in your browser, you can also run it as a VST plug-in for Mac or Windows or standalone or as an LV2 plug-in on Linux.

Developers will like it, too: apart from some surprisingly authentic open source recreations, it’s all coded in the Faust programming language, a functional language for DSP.


Run a full modular DAW. No need to wait on Audiotool: is already a full-featured semi-modular DAW built in HTML5 with MIDI support (and audio input). It’s got a full assortment of instruments and effects, too – and some interesting ones, so it complements Audiotool.


Run a bunch of microtonal synths. Mitch Wells’ Web Synths is a deep microtonal instrument, capable of some unique sound designs, and perhaps the richest actual synth of this bunch. Patch sharing shows one powerful feature of putting browsers on the Web – the ability to share with others.


Live-code your own synth. Maybe this is the application that makes the most sense. While it’s tough for the other proof-of-concept toys to compete with your desktop instruments, it’s kind of tough to beat the ability to live-code with Web tech in a browser.

And by “code,” you hardly have to be a hard-core coder. The coding is radically simplified here, spitting out JavaScript from basic commands – fun for even the most entry-level hacker to play around with.

Vult by Leonardo Laguna Ruiz was built at MIDIHACK, the hackathon I was part of here in Berlin this month.


Play a synth – with colored lights and more. is a three-oscillator synth with some interesting extras. There’s a tracker-sequencer built in, and you can play a “live” mode with color output.

The nerdy stuff behind the scenes demonstrates some potential for other projects. Apart from the new MIDI mode, the server mode offers up other possibilities. (, Node.js, live server, NeDB database holding patterns, if you’re curious.)

What does that mean in practice? Developer Filip Hnízdo writes in comments:

“One of the features I’m most proud of is the live websocket server so any pattern that gets pushed to it is played live to a page where anyone can hear what anyone else has created in realtime. Especially fun with MIDI routed into soft synths or hardware. If enough people pushed patterns in you could just leave it on in your bedroom and constantly hear new music as it arrives. The patterns are all encoded as URLS too so easy to share.”

Having just read a history of the first networked, first first-person shooter in the 70s, it’s worth saying: this stuff can lead to unexpected places. And Filip is looking for collaborators.

Got more for us? Let us know in comments.

And if you have any tips on audio performance or how this is developing (since I complained about that), or likely applications (since I mused about that), we’d love to hear that, too.

The post Cool Things Chrome Can Do Now, Thanks to Hardware MIDI appeared first on Create Digital Music.

by Peter Kirn at May 22, 2015 05:24 PM

May 13, 2015

Linux Audio Users & Musicians Video Blog

John Option – Where’s my Car?

Well executed Sonic Rock from John Option. Video edited in Kdenlive.

by DJ Kotau at May 13, 2015 10:02 AM

May 12, 2015

Nothing Special

Infamous Plugins are Tiling!

I'm very very excited to say this:

1000 words

Thanks to falktx helping me understand what he told me months ago, the infamous plugins are all now 100% resizable. Which means I can use them comfortably in my beloved i3.

These just may be the first rumblings of an early release... stay tuned.

by Spencer ( at May 12, 2015 04:34 PM

May 09, 2015

Linux Audio Announcements -

[LAA] [ANN] Vee One Suite 0.6.3 - A sixth beta release

[UPDATE] As a micro dot release override, the current sixth beta release
is out and crunching the earlier fifth to oblivion ;)


The 'Vee One Suite' of 'old-school' software instruments, aka. the 'gang
of three' have bumped over another tiny notch: synthv1 [1], as one
polyphonic synthesizer, samplv1 [2], a polyphonic sampler and drumkv1
[3], as one drum-kit sampler, are now being released to the masses. Again ;)

There's no big audible changes, if any at all, yet this fifth beta
release is rather a probable bug fix drumkv1 LV2 on Ardour.

Anyway, it's all gone as follows:

- Sample file drag-and-drop support has been added to the note element
list widget (drumkv1 [3] only).
- Main widget layout changed as much to allow sampler display and
element list to expand or grow vertically as needed (samplv1 [2] and
drumkv1 [3]).
- Sample file path mapping has been fixed for LV2 plugin state
restoration, which were preventing Ardour to reload any of the saved
session or preset sample files in particular (drumkv1 [3] only).
- Custom knob/dial behavior mode options are now introduced: linear and
angular (aka. radial) as far to avoid abrupt changes on first mouse
click (still the default behavior).
- Fixed for some strict tests for Qt4 vs. Qt5 configure builds.

We're still available in dual form, as business as usual:

- a pure stand-alone JACK [4] client with JACK-session, NSM [5] (Non
Session management) and both JACK MIDI and ALSA [6] MIDI input support;
- a LV2 [7] instrument plug-in.

Enough to tell, the Vee One Suite are free and open-source Linux Audio
software, distributed under the terms of the GNU General Public License
(GPL) [8] version 2 or later.

As always, have (lots of) fun :)

**synthv1 - an old-school polyphonic synthesizer [1]**

synthv1 0.6.3 (sixth official beta) is out!

synthv1 is an old-school all-digital 4-oscillator subtractive
polyphonic synthesizer with stereo fx.




- source tarball:

- source package:

- binary packages:

**samplv1 - an old-school polyphonic sampler [2]**

samplv1 0.6.3 (sixth official beta) is out!

samplv1 is an old-school polyphonic sampler synthesizer with stereo fx.




- source tarball:

- source package:

- binary packages:

**drumkv1 - an old-school drum-kit sampler [3]**

drumkv1 0.6.3 (sixth official beta) is out!

drumkv1 is an old-school drum-kit sampler synthesizer with stereo fx.




- source tarball:

- source package:

- binary packages:


[1] synthv1 - an old-school polyphonic synthesizer

[2] samplv1 - an old-school polyphonic sampler

[3] drumkv1 - an old-school drum-kit sampler

[4] JACK Audio Connection Kit

[5] NSM, Non Session Management

[6] ALSA, Advanced Linux Sound Architecture

[7] LV2, Audio Plugin Standard, the extensible successor of LADSPA

[8] GNU General Public License

See also:

Enjoy && keep the fun ;)
rncbc aka. Rui Nuno Capela
Linux-audio-announce mailing list

by at May 09, 2015 11:11 AM

Vee One Suite 0.6.3 - A sixth beta release

[UPDATE] As a micro dot release override, the current sixth beta release is out and crunching the earlier fifth to oblivion ;)


The Vee One Suite of old-school software instruments, aka. the gang of three have bumped over another tiny notch: synthv1, as one polyphonic synthesizer, samplv1, a polyphonic sampler and drumkv1, as one drum-kit sampler, are now being released to the masses. Again ;)

There's no big audible changes, if any at all, yet this sixth beta release is rather a probable bug fix for drumkv1 LV2 on Ardour (v3 and v4).

Anyway, it's all gone as follows:

  • Sample file drag-and-drop support has been added to the note element list widget (drumkv1 only).
  • Main widget layout changed as much to allow sampler display and element list to expand or grow vertically as needed (samplv1 and drumkv1).
  • Sample file path mapping has been fixed for LV2 plugin state restoration, which were preventing Ardour to reload any of the saved session or preset sample files in particular (re. drumkv1 only).
  • Custom knob/dial behavior mode options are now introduced: linear and angular (aka. radial) as far to avoid abrupt changes on first mouse click (still the default behavior).
  • Fixed for some strict tests for Qt4 vs. Qt5 configure builds.

We're still available in dual form, as business as usual:

  • a pure stand-alone JACK client with JACK-session, NSM (Non Session management) and both JACK MIDI and ALSA MIDI input support;
  • a LV2 instrument plug-in.

Enough to tell, the Vee One Suite are free and open-source Linux Audio software, distributed under the terms of the GNU General Public License (GPL) version 2 or later.

As always, have (lots of) fun :)

synthv1 - an old-school polyphonic synthesizer

synthv1 0.6.3 (sixth official beta) is out!

synthv1 is an old-school all-digital 4-oscillator subtractive polyphonic synthesizer with stereo fx.


Flattr this

samplv1 - an old-school polyphonic sampler

samplv1 0.6.3 (sixth official beta) is out!

samplv1 is an old-school polyphonic sampler synthesizer with stereo fx.


Flattr this

drumkv1 - an old-school drum-kit sampler

drumkv1 0.6.3 (sixth official beta) is out!

drumkv1 is an old-school drum-kit sampler synthesizer with stereo fx.


Flattr this

Enjoy && keep the fun ;)

by rncbc at May 09, 2015 10:30 AM

May 08, 2015


Fabla 2 – Berlin Progress (no release yet..)

Fabla 2 – Berlin Progress (no release yet..)

  Fabla2 – Berlin Progress Lots of progress made in the last few days – bugs fixed, features added and so much more. Follow development of the 2.0 release milestone on Github. So what is the current release date? “Soon”. Checkout the youtube video – it shows the current capabilities! Stay tuned, -OpenAV Read more →

by harry at May 08, 2015 04:27 PM


Another Great LibreMusicProduction article: hardware inserts

Conor McCormack just posted another amazingly good tutorial for Ardour over at Libre Music Production, this time on using hardware inserts. Read the whole thing:

by paul at May 08, 2015 02:45 AM

May 04, 2015

Linux Audio Announcements -

[LAA] [ANN] Radium 3

Radium is a music editor with a new type of interface. It's inspired by
trackers, but uses graphics to show musical data.

Most important changes between 1.9 and 3.0:

* Smooth scrolling.
* Enhanced graphics and user interface.
* MIDI Sequencing.
* Lots of bugs removed and features added.



by at May 04, 2015 06:15 PM

May 03, 2015

Linux Audio Announcements -

[LAA] Stoat 1.1 Released

The 1.1 version release of stoat is now available.

Stoat is a STatic (LLVM) Object Analysis Tool which is used to perform
static analysis on C/C++ projects involving realtime constraints.
The analysis traces feasible callgraphs within a program and detects
cases where it may be possible to invoke a non-realtime function such as
malloc from a realtime context.
Hopefully this will help developers find possible bugs which other tools
or manual code review might miss.

New from the 1.0 release
- Basic Dump Output
- Support For Try{}Catch{}
- Support For Rtosc Callbacks
- Wildcard Support For Function Specs
- stoat-compile/stoat-compile++ utility
- Parallel Analysis
- Namespace Support
- Translation Unit Local Template Alias Support
- Multiple Inheritance Vtable Support

To get the source or to report any issues, just see the github page:

--Mark McCurry

by at May 03, 2015 02:33 AM

May 01, 2015

Linux Audio Announcements -

[LAA] QJackRcd 1.1.0 released


QJackRcd 1.1.0 released

QJackRcd is a simple QT application to record JACK server outputs with
native "turnkey" features as automatic pause/split on silence and
background sound file processing

1.1.0 archive here:

In this release:
- QT5 dependency upgrade
- Output directory choice (not only home)
- Jack transport / auto-connect in options

Existing translations for EN / FR are up to date.
Existing translations for IT / CZ / DE are outdated, thank you in
advance if anyone can help to update them and send me back.
Do not hesitate to create tickets for any problem on SF.

Good recordings.
Olivier Rouits.
Linux-audio-announce mailing list

by at May 01, 2015 11:39 PM

[LAA] QJackRcd 1.1.0 released --


QJackRcd 1.1.0 released

QJackRcd is a simple QT application to record JACK server outputs with
native "turnkey" features as automatic pause/split on silence and
background sound file processing

1.1.0 archive here:

In this release:
- QT5 dependency upgrade
- Output directory choice (not only home)
- Jack transport / auto-connect in options

Existing translations for EN / FR are up to date.
Existing translations for IT / CZ / DE are outdated, thank you in
advance if anyone can help to update them and send me back.
Do not hesitate to create tickets for any problem on SF.

Good recordings.
Olivier Rouits.
Linux-audio-announce mailing list

by at May 01, 2015 11:39 PM

[LAA] QJackRcd 1.1.0 released --


QJackRcd 1.1.0 released

QJackRcd is a simple QT application to record JACK server outputs with
native "turnkey" features as automatic pause/split on silence and
background sound file processing

1.1.0 archive here:

In this release:
- QT5 dependency upgrade
- Output directory choice (not only home)
- Jack transport / auto-connect in options

Existing translations for EN / FR are up to date.
Existing translations for IT / CZ / DE are outdated, thank you in
advance if anyone can help to update them and send me back.
Do not hesitate to create tickets for any problem on SF.

Good recordings.
Olivier Rouits.
Linux-audio-announce mailing list

by at May 01, 2015 11:39 PM

Ubuntu Studio » News

Precise and linux-lowlatency-3.2 EOL

Since 3 years has become a new standard as the support period for Ubuntu flavor LTS releases, we decided to end support for Ubuntu Studio 12.04 Precise Pangolin after 3 years. While we do that, we also end support for linux-lowlatency 3.2. The most recent update will be the last one. If you are still […]

by Kaj Ailomaa at May 01, 2015 06:17 AM

April 23, 2015

Ubuntu Studio » News

Ubuntu Studio 15.04 Vivid Vervet released!

Another short term release is out. Not much is new, but some of the most obvious changes are: new meta package: ubuntustudio-audio-core (includes all the core stuff for an audio oriented installation) XFCE 4.12 If you want to know more, please have a look at our release notes. You can find the downloads at our […]

by Kaj Ailomaa at April 23, 2015 07:31 PM

April 21, 2015

Scores of Beauty

„Der Rosenkavalier“ – Chamber Version with Berlin Philharmonic Orchestra

This post is partly an advertisment and partly a success story of creating Beautiful Scores with LilyPond which I had the opportunity to experience recently.

2015, April 26th, 3pm and 5pm we will play a children’s version of Richard Strauss’ „Der Rosenkavalier“ in the Philharmonie of Berlin, commissioned and played by the Berlin Philharmonic Orchestra. I made the arrangement, the engraving, and I will conduct these performances.

Since 2013, the Berlin Philharmonic Orchestra is the orchestra in residence for the Easter Festival of Baden-Baden. Besides a large opera production in the biggest opera hall of Germany, there are numerous symphonic concerts, chamber music concerts, a chamber opera in the historical Theatre of Baden-Baden and a children’s version of the main opera. This is a cooperation between the Festspielhaus Baden-Baden, the Berlin Philharmonic Orchestra and the Academy „Musiktheater heute“ of the Deutsche Bank Foundation.

In 2015 the main opera was „Der Rosenkavalier“ (1911) by Richard Strauss, and so the children’s opera became „Der kleine Rosenkavalier“ (The little Knight of the Rose), a one-hour version for children aged 5 to 10 – and the first approved children’s arrangement of the opera. Last summer I was appointed with the arrangement of the music for 13 musicians and 4 singers. We chose the excerpts with director Hersilie Ewald and the dramatic adviser Sophie Borchmeyer. We planned a total duration of one hour, so that we only kept 40 minutes of the 3,45 hours opera – but the most beautiful ones!

The original orchestra of Strauss has over 100 musicians and it has to be reduced to… 13!
The instrumentation of our version is:

  • 1 flute (piccolo)
  • 1 oboe (english horn)
  • 1 clarinet
  • 1 bassoon (contrabassoon)
  • 1 french horn
  • 1 harp
  • 1 harmonium / celesta
  • 1 percussion player
  • 2 violins
  • 1 viola
  • 1 violoncello
  • 1 contrabass

This chamber orchestra is very near of the one Schoenberg used for his version of „Das Lied von der Erde“ of Gustav Mahler – except I didn’t use the piano.

I tried to preserve the orchestral colors as much as possible, and almost all the wind soli remained unchanged. The harmonium has a very useful filling function. The bassoon plays often melodically in a high register, the french horn must play both deep and high and generally the orchestra parts are slightly more difficult than the original – which is already a challenge for every orchestra musician!

I first wrote the whole score by hand. In a second work phase I copied it in LilyPond. I used TextMate as my editor because of the possibility of using shortcuts for highly user-settable commands I use often.
The LilyPond input was quite quick: on good days I could enter 20 pages of orchestral music. LilyPond still has some bugs… For example the standard setting doesn’t avoid collision of accidentals and slurs:
Walzer with collision
which should be corrected to
Capture d’écran 2015-04-20 à 16.17.58
I looked for examples and rules in the reference engraving books but I couldn’t find precise instructions… If someone has an idea?

And I got mad with the annoying issue 3287: when a clef change occurs at the end of a staff, the slurs in others staves are displayed wrong, while ties aren’t!

These are all little details but I got most of them corrected – some others not. With a lot of work and constant check up of Gould’s “Behind bars”, I produced nice scores and received very positive feedback from the musicians.

I would be very happy to see many LilyPond users in the hall to celebrate a glorious milestone in the LilyPond history: one of the best orchestras in the world playing with LilyPond scores – and enjoying it a lot!

More details and tickets

by Aurélien Bello at April 21, 2015 02:33 PM

April 20, 2015

Scores of Beauty

“Defining a Music Function”

It’s been about a year since I started a category with Scheme tutorials, and back then I declared them as a “documentation of my own thorny learning path”. By now I’ve experienced a significant boost in Scheme “fluency” which was triggered by (and at the same time enabled) a number of projects and enhancements, for example the ScholarLY package and the jump into a fundamental redesign of openLilyLib. I thought it would be a good idea to pick up the tradition of these tutorials before I forget too much about the difficulties of finding my way around LilyPond’s Scheme. This is of course not a carefully crafted “curriculum” but it will always be a random collection of (hopefully) useful snippets of information, each one written with the goal of explaining a single topic in more depth and at the same time more casually than the LilyPond reference can do.

Today I’m writing a tutorial that I would have needed a year ago ;-) about one thing that always vaguely confused me. I usually managed to just get around it by either routinely “doing it as always” or by getting some ready-to-use code snippets from a friendly soul on lilypond-user. This is the topic of defining music-/scheme- and void-functions in Scheme. I will analyze a music function I introduced in last years’ posts and explain what is going on there. Understanding this gave me surprising insights, and I think knowing this kind of stuff is really helpful when trying to get more familiar with using Scheme in LilyPond.

So this is the simple music function we’re going to dissect, it takes a color? argument and applies that color to the next note’s note head and stem:

colorNote =
#(define-music-function (parser location my-color)
     \once \override NoteHead.color = #my-color
     \once \override Stem.color = #my-color

  c' \colorNote #red d' c'

(See the other post for the output of that example.)

This is something I knew how to put together for quite some time, but I’ve always wondered about a few things here (just managed to suppress the questions, because it did work), particularly the relation between the colorNote = and the #(define-music-function part and the parser location arguments. But to be honest, I wasn’t really clear about the part returning the “music expression” either.

In the current post I will go into quite some detail about the declaration/definition of the music function and the topic of “return values”. However, I’ll skip the third issue because that’s somewhat unrelated to the other two and because the post is already quite long without it.

Defining the Music Function

Let’s start with looking at it from the perspective of the “user” or “caller”. colorNote is a “music function” that returns a “music expression”. This is the part enclosed in the #{ #} brackets, containing two overrides (yes, overrides are also “music”) and applying the #my-color argument passed into the function. So when writing \colorNote #red it’s quite obvious that I call the function colorNote, passing it the argument #red.

But the syntax of how this “function” is defined somehow always startled me, and I’m sure there are many others who could write such a function too, without really knowing what they are doing. Let’s have a look at a comparable function definition in Python (for those who know Python):

def colorNote(parser location color):
    return some_music_expression

Here the syntax is clear that we are defining colorNote to be a function object, taking some arguments and returning a value. When we use that function later in the code the program execution will jump right into the body of that function definition. But what do we actually do when “defining a music function” in LilyPond?

From the LilyPond documentation (and last year’s posts) we learn that the following expressions are equivalent:

myVariable = 5

#(define myVariable 5)

Both define a variable myVariable and set its value to the integer number 5. Or, expressed the other way round, they take the value of 5 and bind it to the name myVariable. Later in the program (or the LilyPond file) one can refer to this name and get the value back.

We can rewrite the definition using the #(define syntax like this:

#(define colorNote
   (define-music-function (parser location my-color)
     ; ...

So what is the value we are binding to the name colorNote in our example?

Intuitively I would expect that we bind a function’s implementation to the name colorNote, similar to what the Python example seems to do. But here we don’t seem to assign a function or function body but define-music-function instead. If you start thinking about it this seems very strange. Fortunately you can continue thinking about it and it becomes clear, so stay tuned…

Maybe you notice a small but important difference to the above definition of myVariable: define-music-function is enclosed in parentheses, while 5 was not. Parens (usually) indicate we are calling a procedure in Scheme, and this call evaluates to something. Whenever you want to use a value you can instead call a procedure, and the value this procedure evaluates to is then used as your value. (You may want to read this paragraph again… or consider the following mathematical examples. In Scheme (+ 3 2) evaluates to 5, (- 3 2) evaluates to 1, and (+ 3 (+ 1 1)) evaluates to (+ 3 2) which then evaluates to 5.)

So what we really do with our music function is call define-music-function which evaluates to a “music function” and bind this result to the name colorNote. Later in the LilyPond file when we call \colorNote we do not execute the code after \colorNote = (which is what would happen in the Python example) but instead we call the music function that has been created when \colorNote has been initially parsed. (For a more detailed and technical discussion you may read the Wikipedia article about “first class functions”).

define-music-function <argument-list> <argument-predicates> <body> itself takes three arguments, each enclosed in its own parenthesis (here the parens are used for grouping items to a list and not for a procedure call):

  • the list of argument names:
    (parser location my-color)
  • a list of argument predicates (types that the arguments have to have)
  • the actual implementation body

my-color is an arbitrary name that has been chosen for an argument. It lets you access the value that has been passed into the music function at that position. Note that this is the only argument that the user has to supply when calling the music function, parser and location are passed implicitly. According to the manual parser location simply has to be copied literally, which is also confusing – but we won’t go into this detail today.

color? is the type of the (single) value that can be passed to the function, so you can’t for example write \colorNote #'thisIsNotAColor (which would pass a Scheme symbol to the function).

Side note: You also can define music functions that don’t have such arguments, so the first element in define-music-function would be (parser location). It has always startled me why I’d have to add () in such cases, but now this becomes clear: define-music-function expects a list of argument predicates as its second argument, and if there are no arguments to be type-checked then this second argument is still expected, and an empty list has to be passed as the <argument-predicates>.

The “Return Value” – Music-, Scheme- and Void Functions

Digression: “Procedures” and “Functions”

Before going into the topic of the different function types I have to dwell on a certain fuzziness in terminology: procedures and functions. When reviewing this post I realized that I wasn’t completely clear about the distinction and used them interchangeably. My request on the lilypond-user mailing list raised a discussion showing that it actually isn’t a trivial topic. So while in the end it is more or less neglectable there are things you may want to digest in order not to get confused when people use these terms in the LilyPond/Scheme context.

Some programming languages make a distinction between procedures and functions, some don’t. If a language distinguishes, it is mostly the question of a return value: functions return a value, procedures don’t. This means that while both are separate blocks of code that can be called from within a program, functions produce a value that can be worked with while procedures just “do” something which doesn’t directly affect the calling code.

Other languages don’t make a distinction and call both types procedures or functions and usually have a syntactic way to clarify the behaviour. However, it’s quite common that people distinguish although their programming language doesn’t. If you notice this just try to ignore that and don’t be confused.

The implementation of the Scheme programming language that is used by LilyPond is Guile 1.8. In this basically everything is considered a procedure, regardless of having a return value or not. Take the following expression:

(car '(1 2 3 4 5))

This expression is a procedure call, namely the call to the procedure car. The list '(1 2 3 4 5) is passed as the argument to car, which evaluates to 1, the first element of the list. So the “return value” that is then used in the program is 1. Other procedures, for example (display '(1 2 3 4 5)) do not evaluate to anything, so the “value” in the place of the procedure call is <unspecified>.

Both are called “procedure” in Guile’s terminology although one returns a value and the other does not. However, you will often encounter the naming convention of calling the “returning” versions “function”. This is actually against the official naming convention of the Scheme dialect that LilyPond uses, but it is quite common and doesn’t pose a real-world problem. And – as far as I can see – this is also true for the terms “music function”, “scheme function” and “void function”.

OK, let’s get back on track and consider the “return value” of our music function. Above I wrote that colorNote returns a music expression containing two overrides. But what does that actually mean?

The body of a procedure in Scheme is a sequence of expressions, and each expression can be either a value or a procedure call. The value of the last expression in the body is the value the whole function evaluates to – or, more colloquially, is the return value of the function. In the case of \colorNote this last expression is not a Scheme expression but a LilyPond music expression, as indicated by the #{ #}. From Scheme’s perspective this is a single value (of type ly:music?), but from LilyPond’s (or rather a user’s) perspective this music expression can also be a grouped sequence of music elements – in our example we have two consecutive overrides.

To conclude we can say that a “music function” is a procedure whose last expression evaluates to LilyPond-music. It can be called everywhere that you can write a music expression in LilyPond – just like in our initial example at the top of this post.

Now, what are scheme- and void-functions then?

The whole subject of defining these functions/procedures is identical to the definition and calling of music functions, the only (but crucial) difference is the return value. A procedure defined using define-scheme-function can return any valid Scheme value, and it can be used anywhere the respective Scheme value can be used. The following example takes a string as its argument and returns sort of a palindrome version (just for the sake of the example). The type of the return value is string?, and this can for example be used to set a header field.

addPalindrome =
#(define-scheme-function (parser location my-string)
     (ly:message "We will add the reverse of the string to itself")
     (string-append my-string (string-reverse my-string))

\header {
  title = \addPalindrome "OT"


The “body” of this procedure is a sequence of two expressions. The first one (ly:message prints something to the console output but doesn’t evaluate to a value, the second is the call to string-append, which is a procedure call that evaluates to a string.

Side note 1: Here again you can see an example of nested procedure calls and their evaluations: string-append here takes two arguments, the first being a value (namely the argument my-string), while the second argument is again a procedure call. The operations that Scheme actually performs one after another are:

(string-append my-string (string-reverse my-string))
(string-append my-string (string-reverse "OT"))
(string-append my-string "TO")
(string-append "OT" "TO")

So the nested expression in the first line of this example eventually evaluates to “OTTO”. And as this is the last expression in the procedure body its value will be the return value of the procedure as a whole, which in this example is used as the title of the score.

Side note 2: You can see that there is a single closing parenthesis on the last line of the procedure. This matches the opening paren in #(define-scheme-function. Scheme’s coding guidelines suggest not to place parens on their own lines but rather concatenate them at the end of previous lines. As you can already see in these simple examples nesting procedure calls can quickly build up, so it’s not uncommon to encounter Scheme procedures with, say, ten closing parens in the last line. However, I laid it out like this to explicitly show that each line in the example is one expression. Temporarily reformatting is a very useful tool for debugging procedures or to understand the structure of existing procedures you are looking at. Don’t hesitate to insert line breaks and make use of your editor’s assistance to re-indent the code as this will make things much clearer. Once everything is ready it’s advisable to re-compress the procedure again, even if you are used to other layouts that are common in other programming languages.

Probably you can by now guess what a void-function is – basically the same as the other two, but without a return value. So you will want to use define-void-function when you want the procedure to actually do something (also known as “side effects”) but don’t need any return value. The following example will print out a message to the console:

displayLocation =
#(define-void-function (parser location)
     (ly:input-message location "This was called from a 'void-function'")

There is just one expression in the function body, printing a message. In the case of define-void-function it doesn’t matter if this (respectively the last) expression evaluates to something or not, the function won’t return any value at all. This also has the effect that you can actually call void functions from anywhere. The parser won’t try to use them as a value but will simply execute its code. So the following example is equally valid and working.

displayLocation =
#(define-void-function (parser location)()
   (ly:input-message location "This was called from a 'void-function'"))


I hope this post helped you understanding a few basic things about how music, scheme, and void functions work and how they are integrated in LilyPond documents. This is only a tiny start, but understanding these concepts thoroughly definitely helps with proceeding to more complex and more powerful functions. As a final “assignment” I’ll leave it to you to figure out what the location does in the last example, how it is used and how its value actually got into the function.

by Urs Liska at April 20, 2015 12:54 PM

April 10, 2015


Learning With Memory Mapping or Mind Mapping

Memory mapping is a powerful technique to stimulate your thoughts, and a memory power boost.
The technique starts by drawing associations on a piece of paper. first start with the key idea or word in the center and write close by the sub ideas, then connect these with a line.

This is a powerful memory enhancing technique because it operates on a number of levels at once

Diagramming information coverts the incoming mass of data into concepts and images that are meaningful to you.
It draws on the left-brain verbal, analytic abilities and the right brain spatial, visual abilities, reinforcing facts and data simultaneously in the memory circuits on both sides of the brain.
By jotting down key ideas and indicating connections between them, you personalize the data, arranging them in a way that is meaningful to you.
Because there is always space for further ideas and connections you are prodded to keep looking in new directions.
Since the key elements are all right there on one sheet it’s easier for you to see important connections.
Consciously processing the information– rather than passively listening or reading– makes it more likely you will remember it.

Conclusion: Memory or Mind mapping is a very efficient memory boosting technique that works by involving all senses. I used it in college where I had only one class C grade and mostly B+ and A+

by pete0verse at April 10, 2015 01:27 PM

April 08, 2015


Rubik’s Cube and Memory Techniques, Little Journey,Loci

As a Rubik’s cube fan there is the need to memorize algorithms to solve the blessed cube. I used the loci and little journey memory techniques to memorize this algorithm for solving the top corners of the cube. The algorithm goes like this U R Ui Li U Ri Ui L, first the upper layer is turned one twist, then a right side move is needed followed by a top inverse then proceed by turning the left side counterclockwise one twist. The second part of the algorithm is the same as the first all for the second right inverse move and last move which is a left turn. Now you could say” why is it so hard to remember 8 moves?” Well,I guess it is not, but the point of this experiment was to apply some learned memory techniques and put them to the test. I decided to take a little journey through the apartment as such, by the door of the office look up U to the vent, Look right into the bathroom R, look down to the basket Ui, Walk left backwards into the hall way Li, Look up to the vent U, Look at Dusty’s cage Ri, Look down, Look at the table L. This completes the algorithm which is the standard method for solving the top corners as explained in the booklet 7 step solution that is sold with the 3x3x3 cube. Myself, I combine two methods the one in the booklet and one I picked up from You tube on the net by some Chinese dude. Ni hao!
have fun !

by pete0verse at April 08, 2015 01:07 PM

April 02, 2015


Do Something!

I'm a very opinionated person and I don't think that there is much I can do about that. Most of the time I try to not force my personal opinions on people, some of my friends and family might disagree, but I do honestly try. I like to think most people arrive at their opinions honestly and they represent a perspective, however different than mine, that is informed by things I might not be able to understand. I do know that my opinions on things have changed or maybe even evolved with time and I'd like to think we are all on a path headed towards our dreams. Maybe at different points on the path but still on a path. If I can help someone down the path with me, I try to do it. What I won't do is push someone to make ground on something by force.

In my own head I don't think I have a single personal philosophy that guides my life. Most of the time I feel like I'm drowning in my own self doubt. However, I do get put into the position of offering advice on peoples lives more than I'm comfortable with. Most of the time I just try my best to nudge people in a positive direction.

Lately however, I've been giving more and more thought to what I would call my personal brand of guiding wisdom. Now I obviously don't have the answer to eternal happiness, world peace or even how to not annoy the crap out of everyone by accident. The reality is, I'm pretty useless at making other peoples lives better most of the time, despite my grand ideas for changing the world.

What I do know is that when I'm at my most depressed or discouraged that I can always dig myself out. Even if it feels at the time like I never will. I don't have a magic silver bullet but I do know that every day I can chose to do at least one thing that makes my life or the life of those around me better and I think that mostly sums up my approach. As I've thought about it, I've boiled it down to something fairly concise.

"Do Something"

What I mean by that is you might not be able to control everything that happens to you and you also might not be able to control the way you feel about it. What you can do is move yourself down the path. Sometimes it's a moon surface leap and sometimes it's crawling through glass, but progress is progress. No, this won't guarantee your bills will get paid, you will save your marriage or heal a childhood pain. It might not even make you feel better. What it will do is put you a little closer, bit by bit.

If you are like me, most things feel overwhelming. I can be pretty hard on myself. I once told someone, "You can't say anything to me more hurtful than what I've said to myself." I think it might be one of the most honest things I've ever said. What I have found though that helps me more than anything, is doing something. Anything. As long as it's a positive step in the right direction. Even if it's just one small step with a million more to go, it's one step closer to my final destination.

No matter how small the gesture it can at least help you get into a better head space. It could be something for yourself, like getting chores you've been avoiding knocked out or something huge like finally telling someone how you care about them. You don't even have to do it for yourself. Sometimes when I'm at my lowest it helps to think about the things I wish others where doing for me at that moment and do it for someone else. One example is, for my own narcissistic reasons, I really like things I post to social media to get liked by my friends and family. Sometimes a post that I feel really strongly about or connected to will get almost completely ignored and it will send me into a tailspin of self doubt. In all likely hood there are multitudes of reasons people didn't take the time to click "like", and most are probably not related to me or my personal feelings. So, even in this silliest of first world problem situations, I try to reach out to others, click like on things my friends post or leave a positive comment. I would never do this disingenuously. I'm always clicking like or give a positive comment to something I actually like. I'm just trying to go a little more out of the way to make someone else feel good.

Now, does this achieve anything measurable. Most of the time no. Most of my friends are likely unaware I do this. Does it suddenly make all my neurotic obsession over whether people like me go away? not at all. What it does though is put me at least half a step closer to feeling better and more often than not it's enough to give me a clear head to see the next step I need to take. Sometimes that next step is one of those moon surface leaps that I can't believe I didn't take before.

Don't get me wrong, I don't hinge my day to day feelings on these silly little acts. Mostly I've learned about myself that I really like the feeling of creating something so I try to focus on those kinds of activities. I have loads of hobbies and things that I do that keep me moving forward. I think those count too. What I try not to do is sit around and think of all the things I should be doing and know for sure I won't do. I'd rather focus on the things I can do than the things I can't.

So now I think I can feel a tiny bit more comfortable in offering someone advice. Just "Do Something." As long as it's positive progress, it's worth it. No matter your situation, you can at least do something to make it better. No matter how insignificant it might seem at the time. I even keep a small daily journal where I try to write down the positive things I did that day. I also write some of the negatives but as long as there is at least one positive, it helps.


Do Something!

That's the best I've got.

by Daniel Worth ( at April 02, 2015 07:45 PM

April 01, 2015

Nothing Special

What a difference a new release makes (or: LTS vs Latest)

I've been sticking with Ubuntu's LTS releases since I got out of school mostly because I don't have the time anymore to do a monolithic upgrade and then fix everything it breaks afterward.  I've actually been championing them, because changing your whole system every 6 months is just asking for trouble. But I've been running 14.04 on this new Mac Book Pro at work and haven't been wowed by the hardware support. I think LTS is perfect for my 6 year old Thinkpad that has had full linux hardware support OOTB for 5 years or so, but with the latest greatest hardware, you need the latest greatest software.

As usual the kernel has a lot of driver improvements already, but using 3.13 or whatever kernel 14.04 was stuck on didn't have them. The machine was working enough to get my tasks done but I had wifi disconnects very very frequently, I can't hot swap mini-display ports for my second monitor, and several other inconveniences reign. I'd tried just updating the kernel in 14.04 but I think I needed to recompile glibc and/or a whole bunch of other things for it to really work and I haven't had time to go figure that out either. Amazing what I'll put up with just so I can use i3wm.

So yesterday I couldn't take it any more. I wanted some of those fixes in the recent kernels. So I did the monolithic upgrade to "Utopic". I did it through the terminal (sudo do-release-upgrade) and everything went quite smoothly. It took most of the day, but already I feel like it's better (placebo effect?). 14.10 is using kernel 3.16 and next month I'll go to 15.04 when its realeased which will have kernel 3.19 (which should at least fix thunderbolt/midi display hot swapping if I understand correctly).

Oops, spoke too soon. Wifi just dropped. (Which, by the way, happens to the guys actually running OSX on theirs too, we've got weird wifi issues at the office). So here's hoping 3.19 will be the bee's knees. Fingers crossed.

by Spencer ( at April 01, 2015 11:08 AM

March 29, 2015

Recent changes to blog

J Hendrix Fuzz Face

Today is raining here, so I play around with our Ampsim toolkit.
Well, lets try to emulate the Fuzz Face of J. Hendrix, I said to myself.
First step is to create the schematic of the unit.
Here it is:

Fuzz Face

Now, create a (python) build script to generate faust source code
with our DK simulator in our Ampsim toolkit.

import os
from analog import *

schema = "Fuzzface2.sch"
path = "tmp"
module_id = "fuzzface"
mod = os.path.join(path, module_id+".so")

# create plugin
c1 = Circuit()
c1.plugindef = dk_simulator.PluginDef(module_id) = "Fuzz Face"
c1.plugindef.description = "J Hendrix Fuzz Face simulation"
c1.plugindef.category = "Distortion" = "fuzzface"

and yep, start guitarix and found the new plug in the Distortion category. Wow, sounds great. That will be enough for me to play with today. :D

Maybe the one or the other will try it, no problem, it's in the guitarix git repository allready.
And for those how use faust by themselves, here is the resulting faust source:

 // generated automatically
declare id "fuzzface";
declare name "Fuzz Face";
declare category "Distortion";
declare description "J Hendrix Fuzz Face simulation";


process = pre : iir((b0/a0,b1/a0,b2/a0,b3/a0,b4/a0,b5/a0),(a1/a0,a2/a0,a3/a0,a4/a0,a5/a0)) with {
    LogPot(a, x) = if(a, (exp(a * x) - 1) / (exp(a) - 1), x);
    Inverted(b, x) = if(b, 1 - x, x);
    s = 0.993;
    fs = float(SR);
    pre = _;

        Volume = 1.0 - vslider("Volume[name:Volume]", 0.5, 0, 1, 0.01) : Inverted(0) : LogPot(0) : smooth(s);

        Fuzz = 1.0 - vslider("Fuzz[name:Fuzz]", 0.5, 0, 1, 0.01) : Inverted(0) : LogPot(0) : smooth(s);

    b0 = Fuzz*(Fuzz*(Volume*pow(fs,3)*(4.76991513499346e-20*fs + 5.38351707988916e-15) + pow(fs,3)*(-4.76991513499346e-20*fs - 5.38351707988916e-15)) + Volume*pow(fs,3)*(-4.76991513499346e-20*fs + 5.00346713698171e-13) + pow(fs,3)*(4.76991513499346e-20*fs - 5.00346713698171e-13)) + Volume*pow(fs,2)*(-5.05730339185222e-13*fs - 1.16162215422261e-12) + pow(fs,2)*(5.05730339185222e-13*fs + 1.16162215422261e-12);

    b1 = Fuzz*(Fuzz*(Volume*pow(fs,3)*(-1.43097454049804e-19*fs - 5.38351707988916e-15) + pow(fs,3)*(1.43097454049804e-19*fs + 5.38351707988916e-15)) + Volume*pow(fs,3)*(1.43097454049804e-19*fs - 5.00346713698171e-13) + pow(fs,3)*(-1.43097454049804e-19*fs + 5.00346713698171e-13)) + Volume*pow(fs,2)*(5.05730339185222e-13*fs - 1.16162215422261e-12) + pow(fs,2)*(-5.05730339185222e-13*fs + 1.16162215422261e-12);

    b2 = Fuzz*(Fuzz*(Volume*pow(fs,3)*(9.53983026998693e-20*fs - 1.07670341597783e-14) + pow(fs,3)*(-9.53983026998693e-20*fs + 1.07670341597783e-14)) + Volume*pow(fs,3)*(-9.53983026998693e-20*fs - 1.00069342739634e-12) + pow(fs,3)*(9.53983026998693e-20*fs + 1.00069342739634e-12)) + Volume*pow(fs,2)*(1.01146067837044e-12*fs + 2.32324430844522e-12) + pow(fs,2)*(-1.01146067837044e-12*fs - 2.32324430844522e-12);

    b3 = Fuzz*(Fuzz*(Volume*pow(fs,3)*(9.53983026998693e-20*fs + 1.07670341597783e-14) + pow(fs,3)*(-9.53983026998693e-20*fs - 1.07670341597783e-14)) + Volume*pow(fs,3)*(-9.53983026998693e-20*fs + 1.00069342739634e-12) + pow(fs,3)*(9.53983026998693e-20*fs - 1.00069342739634e-12)) + Volume*pow(fs,2)*(-1.01146067837044e-12*fs + 2.32324430844522e-12) + pow(fs,2)*(1.01146067837044e-12*fs - 2.32324430844522e-12);

    b4 = Fuzz*(Fuzz*(Volume*pow(fs,3)*(-1.43097454049804e-19*fs + 5.38351707988916e-15) + pow(fs,3)*(1.43097454049804e-19*fs - 5.38351707988916e-15)) + Volume*pow(fs,3)*(1.43097454049804e-19*fs + 5.00346713698171e-13) + pow(fs,3)*(-1.43097454049804e-19*fs - 5.00346713698171e-13)) + Volume*pow(fs,2)*(-5.05730339185222e-13*fs - 1.16162215422261e-12) + pow(fs,2)*(5.05730339185222e-13*fs + 1.16162215422261e-12);

    b5 = Fuzz*(Fuzz*(Volume*pow(fs,3)*(4.76991513499346e-20*fs - 5.38351707988916e-15) + pow(fs,3)*(-4.76991513499346e-20*fs + 5.38351707988916e-15)) + Volume*pow(fs,3)*(-4.76991513499346e-20*fs - 5.00346713698171e-13) + pow(fs,3)*(4.76991513499346e-20*fs + 5.00346713698171e-13)) + Volume*pow(fs,2)*(5.05730339185222e-13*fs - 1.16162215422261e-12) + pow(fs,2)*(-5.05730339185222e-13*fs + 1.16162215422261e-12);

    a0 = Fuzz*(Fuzz*fs*(fs*(fs*(fs*(-3.73292075290073e-29*fs - 1.05633134620746e-20) - 3.11506369039915e-14) - 2.30719916990074e-11) - 1.07493164710329e-9) + fs*(fs*(fs*(fs*(3.73292075290073e-29*fs + 1.01643277726662e-20) + 2.91602352831988e-14) + 2.29636966370042e-11) + 1.07449105454163e-9)) + fs*(fs*(fs*(3.98985774247549e-22*fs + 1.99042653510896e-15) + 1.83615604104971e-13) + 5.31230624730483e-11) + 2.44402781742033e-9;

    a1 = Fuzz*(Fuzz*fs*(fs*(fs*(fs*(1.86646037645036e-28*fs + 3.16899403862238e-20) + 3.11506369039915e-14) - 2.30719916990074e-11) - 3.22479494130986e-9) + fs*(fs*(fs*(fs*(-1.86646037645036e-28*fs - 3.04929833179984e-20) - 2.91602352831988e-14) + 2.29636966370042e-11) + 3.22347316362488e-9)) + fs*(fs*(fs*(-1.19695732274265e-21*fs - 1.99042653510896e-15) + 1.83615604104971e-13) + 1.59369187419145e-10) + 1.22201390871017e-8;

    a2 = Fuzz*(Fuzz*fs*(fs*(fs*(fs*(-3.73292075290073e-28*fs - 2.11266269241492e-20) + 6.2301273807983e-14) + 4.61439833980148e-11) - 2.14986329420657e-9) + fs*(fs*(fs*(fs*(3.73292075290073e-28*fs + 2.03286555453323e-20) - 5.83204705663976e-14) - 4.59273932740084e-11) + 2.14898210908325e-9)) + fs*(fs*(fs*(7.97971548495099e-22*fs - 3.98085307021793e-15) - 3.67231208209942e-13) + 1.06246124946097e-10) + 2.44402781742033e-8;

    a3 = Fuzz*(Fuzz*fs*(fs*(fs*(fs*(3.73292075290073e-28*fs - 2.11266269241492e-20) - 6.2301273807983e-14) + 4.61439833980148e-11) + 2.14986329420657e-9) + fs*(fs*(fs*(fs*(-3.73292075290073e-28*fs + 2.03286555453323e-20) + 5.83204705663976e-14) - 4.59273932740084e-11) - 2.14898210908325e-9)) + fs*(fs*(fs*(7.97971548495099e-22*fs + 3.98085307021793e-15) - 3.67231208209942e-13) - 1.06246124946097e-10) + 2.44402781742033e-8;

    a4 = Fuzz*(Fuzz*fs*(fs*(fs*(fs*(-1.86646037645036e-28*fs + 3.16899403862238e-20) - 3.11506369039915e-14) - 2.30719916990074e-11) + 3.22479494130986e-9) + fs*(fs*(fs*(fs*(1.86646037645036e-28*fs - 3.04929833179984e-20) + 2.91602352831988e-14) + 2.29636966370042e-11) - 3.22347316362488e-9)) + fs*(fs*(fs*(-1.19695732274265e-21*fs + 1.99042653510896e-15) + 1.83615604104971e-13) - 1.59369187419145e-10) + 1.22201390871017e-8;

    a5 = Fuzz*(Fuzz*fs*(fs*(fs*(fs*(3.73292075290073e-29*fs - 1.05633134620746e-20) + 3.11506369039915e-14) - 2.30719916990074e-11) + 1.07493164710329e-9) + fs*(fs*(fs*(fs*(-3.73292075290073e-29*fs + 1.01643277726662e-20) - 2.91602352831988e-14) + 2.29636966370042e-11) - 1.07449105454163e-9)) + fs*(fs*(fs*(3.98985774247549e-22*fs - 1.99042653510896e-15) + 1.83615604104971e-13) - 5.31230624730483e-11) + 2.44402781742033e-9;

by brummer at March 29, 2015 01:12 PM

March 28, 2015 »

Wolfson Audio Card for Raspberry Pi

Just ordered a Wolfson Audio Card for Raspberry Pi via RaspberryStore. I asked them about this audio interface at their stand during the NLLGG meeting where I did a presentation about doing real-time audio with the RPi and they told me they would ship it as soon as it would become available. They kept their word so I'm hoping to mount this buddy on my RPi this very week. Hopefully it will be an improvement and allow me to achieve low latencies with a more stable RPi so that I can use it in more critical environments (think live on stage). It has a mic in so I can probably set up the RPi with the Wolfson card quite easily as a guitar pedal. Just a pot after the line output, stick it in a Hammond case, put guitarix on it and rock on.

Wolfson Audio Card for Raspberry Pi

by Jeremy at March 28, 2015 05:18 PM

March 18, 2015


Requiem for a Hero: Part II

A politician is a fickle thing, it changes allegiances as quickly as a wind blown $5 bill changes hands. Ownership means nothing to it. The crime bosses liked the systems of prohibition on certain common street drugs, it allowed their prices and profits to reach almost limitless heights. It fed the machinery that really ruled the world. The machinery, however, still has not found a solution to the problem it finds most troublesome. In spite of all it's efforts it still relies on the fickle voter to vote against their own best interest as they have done since they where given the gift of voting. Thankfully most the time the voter seems to have a deep-seated need to self sabotage, and only in very rare circumstances will they vote against the machinery that really runs the world. So it was a very rare case with the legalization of a certain common street drug. Enough voters had grown tired of the oppression and crime the drug's prohibition brought on the world and voted for the legalization. In response to the change in voter sentiment , and because a politician can change their allegiances in response to anything, the politicians all had very important meetings and collectively came to the conclusion it would be in everyone's best interest, mostly their own, to not fight the law. The result was a lot of temporarily unhappy criminals and a lot of tax revenue. The wind of popular opinion had blown the politicians into their own dark alley and on top of their own trash pile and they always did their best work in these types of situations.

The tax revenue from the now legal common street drug was, as decided by the voters, allotted to be used for the city's underfunded schools. This, of course, did not happen. The machinery that really ran the world hated schools. Schools teach people to vote in their own best interest. This is something that the machinery would never let happen. So the politicians found clever ways to divert the money to the recently upset criminals as a way to make up for having not prevented the voters from voting in their own best interest and so everyone, who mattered to the machinery, was happy.

Who wasn't happy where the future voters and current children at the local underfunded school. One of whom was the daughter of a recently deceased local hero that had been killed, unbeknownst to her, by a local crime boss. The daughter didn't even know her father was a hero. To her he was just another parent, preoccupied with the machinery that really ran the world and not very interested in the day to day dealings of his family's operation.

The daughter of the recently deceased local hero did well in her underfunded school. She always tried her hardest in everything she did. She was a good student, athlete, friend and daughter. She ate healthy, and in contrast to the other future voters and current children at the local underfunded school, she didn't drink sugary soda made from the chemically processed byproducts of inedible corn. She in every way lived up to the impeccable moral code of her recently deceased local hero father. She worried about the environment, and because of this she didn't  use disposable water bottles. She had written a report for a class at her underfunded school that the plastic from the disposable water bottles would pollute the local waterways of the city and that as an alternative everyone, like her, should carry a reusable water bottle with them. She took her ecologically friendly water bottle with her every where and filled it during the short period of time between classes at the water fountains in her underfunded school.

Unfortunately for the daughter of the recently deceased local hero, and the city, it was too late for the local waterways. They had all ready been polluted by the toxic and unfortunate side effect of a local business. The CEO of the company responsible for the dumping of the toxic and unfortunate side effect had recently been arrested and convicted of violating EPA regulations by illegally dumping substance and thus polluting city's local waterways. The representatives for the machinery that really ran the world asked him nicely to step down as CEO, pay a fine and spend 3 months in a local minimum security prison. The minimum security prison was much nicer than the other prison in the city that was mostly filled with the users of a formerly illegal common street drug. Most of whom suffered from formerly treatable chemical imbalances in their brain that had, at one time, been easily treated with prescription medication.

Little did the daughter of the recently deceased local hero know that her body didn't seem able to deal with the  toxic and unfortunate byproduct of a local business that had been dumped, illegally, into the local water ways and was now present in the drinking fountains of the underfunded school with which she filled the ecologically friendly water bottle she always had with her. Her young and athletic body was rapidly turning weak and frail like that of an old woman. She now possessed the kind of body that $5 worth of calories would make the difference between another week of living and escaping into the dark abyss of non-existence.

When the chief of police had told the daughter of the recently deceased local hero that her father was missing and presumed dead the daughter cried her toxic laden tears, fainted and crumpled out of her chair onto the floor. It was all too much for her frail body to take. The chief didn't even have time to give his well rehearsed speech about how they didn't have any solid leads in the case but that he would personally see to solving the matter and bring peace and justice to her and her family. Instead an ambulance took the daughter to a local hospital where she was placed on life support in a room next to a homeless man being treated for a variety of afflictions related to his homelessness.

The homeless man had an imbalance of brain chemicals that he self medicated with a now legal common street drug. While it was now legal to buy and use the common street drug it was not legal to use it in the street where the homeless man lived. So he had been arrested by the local police. He was being cleaned up and treated for his medical conditions, except of course the brain chemical imbalance, and would soon be transferred to a holding cell while he awaited conviction and sentencing to a local prison. He had no chance of going to the prison where the former CEO was serving his 3 month sentence for the illegally dumping of a toxic and unfortunate side effect of his former company's business.

The imbalanced chemicals in the homeless man's brain told him he would never make it in prison and that he would be better off in the dark abyss of non-existence. So when the nurse turned out the light and left him alone in his room to sleep he used a cord from the lamp in his hospital room to make his transition. So too did the girl in the the next room who was the daughter of the now deceased local hero and who's  frail body could no longer stand the strains of the toxic and unfortunate substance it had running through it. She joined the homeless man and her hero father in the dark abyss of non-existence.

A journalist, in contrast to a politician, doesn't simply change allegiances. They simply try to make the best of a bad situation. They are the hapless victims of changing times and a dying industry. The machinery that really runs the world was working hard on solving another problem that had caused voters to vote in their own best interest, newspapers. The machinery had invent all sorts of new devices and systems to distract voters and keep them from voting in their own self interest or reading pesky newspapers. In spite of the machinery's efforts, journalists have become reasonably good at doing their job with the bad hand the machinery ensured they where dealt.

In this specific case and with this specific journalist, the best that could be made of the situation was printing the story that would make his career. It had been handed to him by a local hero who had disappeared without a trace or police lead. The journalist knew nothing of the hero. Just that a package that contained all the information he'd been trying to coax out of the machinery about a local crime boss and all the proof of the illegal activity.

The story the journalist produced with this information could not have been better written. The case against the local crime boss could not have been better presented. The story however was not the most important to the editor of the newspaper that day. The most important story was that of a beautiful and smart young girl who had died of an unknown condition right after hearing the news that her father was missing and presumed dead. The story of the crime boss was pushed further back into the newspaper where no one read it, except frail old women, heroes and villains.

After being released from minimum security prison the former CEO was hired as a consultant by a former crime boss who was in the process of turning his criminal operation into a legal enterprise specializing in the sale of a now legal and formerly common street drug. The former CEO helped the former crime boss turn the former criminal enterprise into a highly profitable and publicly traded company. A local stock broker made a prudent investment in the now legal company shortly after the company's initial public offering and made a sizeable fortune when he later sold the stock to other representatives of the machinery that really ran the world. The three men, all fine representatives of the machinery that really ran the world in their own right, met regularly at a local pub a few doors down from a successful local company, to discuss the now legal business of selling a formerly common street drug and to eat ham sandwiches. They really loved those ham sandwiches.

by Daniel Worth ( at March 18, 2015 04:45 PM

KXStudio News

Carla 2.0 beta4 is here!

Hello again everyone, we're glad to bring you the 4th beta of the upcoming Carla 2.0 release.
This release is mostly focused on bug-fixing, so there aren't many splashy new features to show compared to previous ones.
Still, here's the highlights:



Updated plugin skins

The plugin skins received some updates once again.
They can now be collapsed in order to take less space.
More to come soon.


New experimental plugins

Some of the best linux-standalone tools are now working as internal Carla plugins.
And because Carla exports its internal plugins as LV2, you'll also get them as LV2.
Note that this is still experimental!
Also, there's no support whatsoever from the original authors...


MOD GUI Support

Carla can now show LV2 MOD GUIs, handled like a regular LV2 UI type.
Note that this only works on the right setups (you need MOD-UI to be working first).
It's not available on pre-compiled binaries, but you can get it via the KXStudio repositories.

More changes

  • LinuxSampler code has been reworked and it's working better, it now exposes 2 output parameters.
  • The plugin bridge code has been reworked; bridges are much more stable and MIDI-out is working.
  • NSM code has also been reworked, testers welcome.
  • OSC ports can be static by using CARLA_OSC_TCP_PORT and CARLA_OSC_UDP_PORT environment variables.
  • Time panel can be shown/hidden as needed.
  • DISTRHO-based internal plugins are back, specifically 3BandEQ/Splitter, PingPongPan, Nekobi, MVerb, VectorJuice and WoobleJuice.
  • carla-single script is back, allowing you to quickly test and run all plugins.
  • Carla as plugin allows new, open and save-as (export) menu actions.
  • Start of new midi-sequencer plugin, still experimental and Linux-only for now.
  • MIDI file internal plugin now saves the contents, so you can share projects without worrying if the file exists on the other system.
  • Added 6 basic parameters to the ZynAddSubFX internal plugin.
  • New MIDI channel filter plugin.
  • LV2 and AU plugins are cached and automatically updated when needed, no need for scanning.
  • Patchbay mode is now working for non-JACK drivers.
  • Carla saves internal and external connections, specially useful in patchbay mode.
  • Lots and lots of bug fixes.

Special Notes

  • Renaming plugins currently is not safe (unless using Rack mode).
  • GIG/SF2/SFZ skin still to be done, and some others...
  • Plugin bridges only work on Linux right now. They used to be working for OSX but stopped due to a OS limitation.
  • Windows 64bit builds a shows small console windows when discovering plugins. This is not intended and will hopefully be fixed soon.


To download Carla binaries or source code, jump into the KXStudio downloads section.
If you're using the KXStudio repositories, you can simply install "carla-git" instead (plus "carla-lv2" and "carla-vst" if you're so inclined).
Bug reports and feature requests are welcome! Jump into the Carla's GitHub project page for those.

by falkTX at March 18, 2015 09:26 AM

March 16, 2015


My first short story as an adult: An ode to Kurt Vonnegut

Requiem for a Hero Part I:

The satisfaction the hero felt in carrying out his personal brand of justice was scientifically comparable to the chemical reaction in the brain of an Olympic competitor winning a gold metal in their respective sport. He could, in many scientific circles, be described as an adrenaline junky. He was constantly chasing the natural rush of brain chemicals that came from delivering a quick and satisfying conclusion to the injustices of the world, no matter how minor.

He took great pride in himself and his impeccable morality. He did the right thing even if most people would think the ingression he was correcting was silly at best. One time he used his powers of deduction and reason to locate the owner of a $5 bill that he found windblown against a trash pile in an alley he happen to be in while surveilling an opportunity at getting those brain chemicals he so desperately needed. He had dreamed up a story while he searched for the owner of the cash. In his brain's narrative the person who lost the money was a little old lady on a fixed income who had out lived the rest of her family and the return of the cash would mean the difference between eating enough calories for her frail body to make another week and going hungry, risking escape into the dark abyss of non-existence. The hero imagined the old lady had been given the bill as change while filling a prescription at the local drug store and being too week to place it back into her billfold had opted to try and hold it feebly while still operating her walker and making her way slowly to the bus stop. He could see it clearly in his heroic minds eye that a burst of wind had torn the bill out of the old lady's age weakened hand and it landed neatly on the trash pile in the alley where he had found it.

The reality, as the hero soon found out, was that the owner of the bill was a stock broker who had given the bill to a homeless man holding a cardboard sign with a long and sad story about the various hardships that had befallen him written in black permanent marker. The stock broker hadn't read the sign, he'd simply dropped the bill on the top of the slouching man who had passed out from too much of his drug of choice, a common street drug sold to him by the low level employees of a local crime boss. The stock broker had given the money to the homeless man as a way of feeling slightly better about the large income he drew out of manipulating the worlds economy. He felt instantly better about himself and his place in the world and decided to treat himself to a beer and maybe a ham sandwich at a local pub as a reward for being so selfless. The stock broker had in fact played a small roll in the hardships listed on the homeless man's sign.

The homeless man had a minor mental disorder that was easily treated with prescription medication, but owing to a downsizing at his previous employer, he had been laid off, lost his health benefits and could not afford the medication his malfunctioning brain required. This event sent him into a spiral of self medicating with an addiction to a common street drug that worsened his brain's condition beyond the reach of modern medicine and led to his eventual homelessness. The cheap street drug released, temporarily, some chemicals in the homeless man's brain that made him forget that other brain chemicals where out of balance.The broker knew none of this because, as mentioned, he didn't read the sign the homeless man had propped against his unconscious body.

The downsizing at the homeless man's company had been triggered when the stock broker, seizing an opportunity at a large payday, had sold a very large portion of stock in the company based on a rumor he had heard from a colleague while peeing in an trough urinal at a baseball game. The colleague had told him that the companies earnings would be below market expectations. The large sell off of stock by the broker caused the machinery that actually operated the markets to view this trade as a trigger to sell more stock in the company and several other companies that did similar business. The drastic and sudden drop in the company's stock price triggered a panic in their upper management. The management thought they where doing a great job and in fact where in the process of preparing the annual earnings report that would inform the world that they had done such a great job at managing the company that it would, in spite of rumors to the contrary, be meeting market expectations. That didn't seem to matter to the stock market, and the CEO of the company in a very prudent and decisive move issued an order to downsize the corporate offices to ensure to the stock holders that management was making good use of their money and not wasting it on corporate excesses. None of the upper management where laid off, of course, and the company's stock quickly rebounded with the news of reduction in corporate overhead and solid earnings. They didn't rehire any of the employees that where laid off. They simply found a way to be just as profitable without them.

The bill the stock broker had dropped on the homeless man had simply blown away in one of the cities many and sporadic gusts caused by it's impossibly tall buildings. Neither of the last two owners of the bill had missed it's absence at all but the hero delivered it just the same, after all, it was the right thing to do.

The hero's next brain chemical fix, he hoped, would come from a taking down a local high level crime boss. This was the biggest and riskiest operation he'd ever taken on. It had taken him two years to gather the evidence and plan the villains take down. He could have finished the job six months earlier, but because of his impeccable morality he wanted to make absolute sure that the crime boss would end up, without a doubt, convicted by a jury of the his peers. His evidence was, at this moment, rock solid. There where indisputable pictures, audio recordings and video that was beyond the police's resources to acquire, but our hero, in his relentless determination and need for brain chemicals, had taken the time to prudently and legally amass an iron clad case the police would have in hand upon his single handed apprehension of the villain. He could see the accolades in his head now, the news stories, the adulation, maybe even a parade, and, of course, the sweet flood of endorphins and adrenaline he so desperately required.

The crime boss was an old hat at organized crime. He was handed the business by his father who had built it up from a local street gang in the decades previous. The crime boss had grown up in the crime business and was taught well by his successful criminal father in the day to day workings of such a complex and diversified crime organization. Much like the CEO of the homeless man's former employer, he didn't spend much time dwelling in the mundane day to day dealings of the criminals he employed. His job was to look at trends in the markets of the various criminal enterprises the crime family was involved in. He was very good at his job. There was no one better at crime than him. He would spend endless hours reading newspapers, looking for opportunities for his business in the headlines. He knew people at every company in town, including the homeless man's former employer, that gave him keen insight into how the city actually functioned. He knew every shipping container that could be exploited. How much inventory he could take off of it without making too many problems for himself. The exact amount of drugs and stolen goods he could place on the same ship as it headed towards it's outbound destination.

The crime boss had enough of the politicians and police force on his payroll to make his dealings all but invisible to the outside world. He even knew, in contrast to the CEO of the homeless man's former employer, how to deal with the unfortunate side effects of his criminal business. There was not a man in the city who's lifeless body could not be disposed of with shocking efficiency by employees of the crime boss. The CEO of the homeless man's former employer did not know how to deal with the unfortunate side effects of his business, the massive amounts of industrial waste that his company produced, so he simply ordered it dumped into the local waterways of the city. The crime boss not only knew of the CEO, he had extorted money from him to keep his secrets. The hero knew of the crime bosses connection with politics and law enforcement. He did not know of the CEO's existence or his illegal dumping of hazardous waste into the waterways thanks to the hush money paid to the crime boss by the CEO.

The CEO was completely unaware that he would soon be brought down by the EPA for these violations. The crime boss knew of the EPA's case against the CEO because he informed the police himself in order to keep pressure off his own criminal business. The crime boss was mostly unaware of the hero's plans to bring him to justice. He had heard some rumblings from his underlings of someone snooping around so he had hidden a gun in a pop up compartment in his desk as a precaution. The crime boss did not know about the hero. The hero did not know about the gun.

The hero had rehearsed the speech he would triumphantly deliver to the crime boss upon his apprehension. He knew every word and the exact emphasis he would deliver on each syllable. It would be the culmination of all his life's purpose. He would finally be on the map as true hero of the people. He revelled in the anticipation of his moment in the sun. He craved the release of chemicals that this event would release into his brain.

The indisputable evidence that was the fruit of the hero's two years of near obsessive work was all ready in the police stations mailbox as well as the mailbox of a local investigative reporter who also was working on writing the story that would make his career. The story of a crime family that ran the city . The reporter just lacked the evidence, that was now sitting in his mailbox thanks to the hero, to pull everything together.

The hero made his way undetected through the building where the crime boss ran his enterprise. He knew every security measure in the building, except for the gun in the crime boss's desk. He burst through the door of the crime boss's office and, having trapped his quarry and entered so elegantly undetected, began his well rehearsed speech. "Your time as a cancer on the underbelly of this city...." his voice was stopped abruptly by a bullet that burst out of the back of the his skull. The hero's brain had been distracted by the anticipation of the chemicals it so desperately desired that it did not react at all to the crime boss triggering of the hidden compartments release mechanism with his foot, his surprising speed at grabbing and discharging the gun and the accuracy of the his shot. The organ that the hero had hoped would release the chemicals he so desperately desired into his brain where now spread across the back wall of the crime bosses office. The hero made his escape into the dark abyss of non-existence.

The crime boss called over an intercom to his secretary and asked for her to get the employees who dealt with this sort of thing to come up and do their job. The crime boss had an important meeting with the chief of police in two hours and felt it a minor inconvenience to have to explain the mess. He also asked her to order him a ham sandwich from the local pub that was two doors down from the office. The crime boss really loved those sandwiches.

by Daniel Worth ( at March 16, 2015 05:13 PM

March 04, 2015


It's got a big mouth, just like me.

I am at least self aware enough to understand that a water bottle is a pretty strange thing to write a blog post about, but I'm nothing if not a man with strong feelings, sometimes about inane things like water bottles.

For years I was in love with Nalgene brand wide mouth, and even narrow mouth water bottles but then the BPA débâcle happened and I gave them up. I switched, much to my dismay, to stainless steel but I missed my Nalgene bottles more than is healthy for an adult male.

When they came out with the BPA free versions I switched back and I have to say, it's one of my favourite accessories. For those of you that know me, you also know that I'm very rarely without my Nalgene in tow.

So why do I love my Nalgene so much?

 First, they are cheap and available pretty much anywhere for under $10 and it comes in many different colors. I very rarely lose my water bottle, but when I do I can replace it with a visit to just about any store anywhere.

It's virtually indestructible. I've dropped them thousands of times and they hold up to my years of abuse.

The wide mouth means I can load it up with ice easily and I like a lot of ice in my water.

Accessories, there are a surprising amount of accessories available for them, my two favourites are the GSI Outdoors H2OH! Percolator and the Outdoor Research Bottle Parka.

It's made of Lexan and that means it can handle temperatures up to the boiling point of water. I first heard about this on the website where people where talking about using them as hot water bottles on chilly nights to squeeze a few more degrees of comfort out of their sleeping systems, since then I've used them quite regularly as a hot water bottle to help sooth my chronic shoulder pain. I even sewed my own cover filled with rice to insulate myself from the high temps and make the heat last longer. It's really amazing at putting the right amount of heat right where I need it. I also have a crazy story, that I won't share right, now about saving a couple friends life on the side of a mountain by making hot water bottles in cold temps.

I really do view my Nalgene bottle as one of the few things I really can't do without.

by Daniel Worth ( at March 04, 2015 06:05 PM

March 02, 2015

PipeManMusic and New Blog

Just realizing that there are some of you that follow this blog that don't necessarily follow me in other places. So I thought I'd post a quick update to say, any farm related stuff has been moved off this blog and onto and if you want to check out the new website I'd love to hear some feedback on it.

by Daniel Worth ( at March 02, 2015 06:13 PM

February 26, 2015


Jury Duty

Here is an account of my recent trip to the county court house to fulfill my civic duty right up until I was selected and served on a jury. Enjoy!

First observation, great place to people watch. 

Only one of the the security lines running, very long line, I doubt other two x-ray machines are even plugged in, they are just there to torment me with the possibility. While in line I discover wood chips in my hoody pocket, hope I don't have to explain that in a pat down.

Only place on earth there are people grumpier than me. Lady on phone behind me would rather clean a dirty toilet than be here or so she says loudly to the person on the other end of the conversation. I'd rather not do either or here about it from her.
They miss pronounced my last name over intercom. It's a common English word, go judicial/educational system. 

We are all Given a name tag that just says "Juror", everyone obediently wearing them like sheep, I judge them. I'm just wearing mine to be ironic so it looks cool on me. I still don't really know what ironic means. That song really fucked me up. 

The sign on fancy automatic coffee maker, just above dispensing nozzle says, not a drain. Must be an interesting story there. Size options on machine are as follows, coffee bean, cup, coffee bean, I chose cup, but secretly wished I tried coffee bean. Later, tried coffee bean option, said "invalid option" on LCD screen, at least the machine is aware of the paradox even if it's incapable of changing it. Chairs designed to not let a cup sit flat, no where to set cup, another well thought out form of torture.

Selected in the first round to move on, I finally found what I'm lucky at. Yay.

Questionnaire asked my favorite t.v. show, author and type of music. I think the people who wrote the form got tired of where people work. They are people watchers too. I think I miss spelled Vonnegut, attempt to seem smart backfired on me again, go educational system.
More newspapers than tablets, more hardback books than tablets. Like they are all from a different universe. Old people still not using smart phones when bored, I don't know how to solve this problem but I imagine it involves hard candy in some way. 

Saw guy that looks like Kurt Vonnegut, not the best celebrity to look like. I didn't tell him he looked like him, I'm sure he gets told that a lot. 

They let us have a fifteen minute break, only options are smoking and eating junk food at a bad cafeteria, go society. I chose writing this on my tablet and looking smug. 

Got called to a court room in first round, go universe that is constantly against me.
Took stairs to fourth floor court room instead of elevator to feel superior to everyone else, instead I'm just breathing heavily like a creeper. More cardio could be in order. 

Everyone is sitting on one side of benches, when I ask "Is the other side is off limits?" everyone smiles politely and shrugs, they are sheep, I sit on the other side and everyone after me follows my lead, I'm a trailblazer. 

Felony vehicular eluding, sounds fun.

Just found out, Jehovah's witness don't serve on jury's, a tiny upside to religion. 

I can't seem to win at anything in life ever, except getting selected to be a juror. I don't know what message the universe is trying to send me but I suspect it's just drunk dialing

by Daniel Worth ( at February 26, 2015 01:09 PM

February 18, 2015

Recent changes to blog

Working on the design

Some people claim about that they didn't like the design of the guitarix rack/units.
I've tried to find designers who like to create new interfaces for us, but, up to now, I'm failed. So, even if I'm not a designer, I try to improve the view of the GUI a bit. Here is with what I'm coming up so far, a single rack-unit, done in cairo.

Here is how it looks in the rack:

Comments are welcome,

by brummer at February 18, 2015 04:59 AM

January 31, 2015


vamp-aubio-plugins 0.5.0

A new version of the vamp-aubio-plugins is now available for download. Originally created by Chris Cannam, the set of Vamp plugins for aubio have recently been updated with three new plugins:

  • Aubio Mel-frequency Band Energy Detector
    • Low Level Features
    • Computes Energy in each Mel-Frequency Bands.
  • Aubio Mfcc Detector
    • Low Level Features
    • Computes Mel-Frequency Cepstrum Coefficients.
  • Aubio Spectral Descriptor
    • Low Level Features
    • Computes spectral descriptor.

Additionally, two new outputs have been added to the Onset detection plug-in: the output of the onset detection function before and after peak-picking.

More information is available at the new vamp-aubio-plugins home page.

vamp-aubio-plugins 0.5.0 source

Binary for Linux amd64

Binary for Mac OS X

Binary for Windows

January 31, 2015 04:52 PM

January 29, 2015


Aubio meets R

Martin started a new open source project called Vocobox - a voice controller for digital instruments. He started putting together a human voice dataset that provides multiple short samples of human sung notes in various way (different notes, voyels, etc).

R Logo

R, a free software environment for statistical computing and graphics

For this project, Martin created the R binding to aubio, that will allow you to gather data using aubio command line tools directly from within R.

January 29, 2015 04:51 PM

January 25, 2015

Arch Linux Pro Audio

Interview with CrocoDuck

In the last month here at ArchAudio we learned of CrocoDuck, making music ranging from Neo-Soul to Electronic and Acoustic music. Who is this mysterious duck? We find out in this interview, but first checkout his laid-back funky track Ducky Jam:

Hi CrocoDuck! Who are you, and what are your interests?

I am a physicist crazy in love with science (that I still like to call natural philosophy like 200 years ago), waves, waves propagation, music and Linux. I am attending a master in acoustics right now that cover a broad range of these topics.

Why did you choose Arch as your distro?

Well, It has been a long quest for me. I started with Gentoo linux when I was a teenager with the help of my brother, a software engineer, and I think it is a great distro. But it requires way too much manual work to my taste. I moved to ubuntu – ubuntu studio during the 8 years of high-school and bachelor degree. It is all good but I found myself reinstalling the system every year to keep updated, but also because, after my crazy experiments, my system was kinda unstable. Then I found Arch (ArchBang to be honest) and I think it is a perfect balance. It requires you to go deep in the configuration, which is cool because you take control over your system, and it is very simple to keep your system as clean as possible thanks to the amazing tools you have, pacman first of all.

So the rolling release is a key point for you?

Yep, as it is a rolling distro and you never need to reinstall! I have been running my Arch box continuously for 3 years now and I feel like my computer is responsive and stable as the very first day I installed the system. You have some regression here and there sometimes, but the documentation is so well written and the community so helpful that the solution for any problem one could have it is usually found after some search. I would suggest Arch to anybody who:

  • Wants control over the system
  • Wants the latest software
  • Wants to maintain a system as clean as possible
  • Wants a rolling release
  • Wants to access a huge crazy amount of readily installable software (through repos or AUR)
  • It is willing to take care of the system and keep track of the changes he/she does (that implies that the system will stay stable)

So what tools do you use to make CrocoDuck’s music?

I am an old school guy. I use mostly just Ardour and Guitarix, which I think is getting insanely better at each release cycle. In my opinion, it is way better than any commercial piece of amp modelling software I ever tried. I also like Yoshimi, it is extremely powerful, and Calf plugins are my favourite ones. I also use sometimes some experimental software like fastbreeder and freqtweak. All my drum loops are made with Hydrogen, which is amazingly simple and intuitive to use and Jamin is a must for mastering.

That’s a list of only open source projects. Is that important to you?

The main reason why I use Linux and open source software: the Freedom! Nowadays the market is evolving giving to the consumer readily usable products over which the user have almost no control. Most of the commercial software it is engineered for marketing goals first, for doing its job second. Commercial OSes are more and more intended to mine data out of you than to work good. As a scientist I cannot stand the use of commercial software: it is a black box. You don’t have the source code, then you don’t know how your data are being processed. Science has not been invented to trust companies. I have to use MatLab at uni but I seriously cannot understand why not octave, elmer, scilab, R or root just to name a few. Only open source software gives to you the tools to build a system for yourself, not for other people to make money out of you. For me, Linux (but also any other open source system) is the only thing that turn a product you buy into something that it is really yours and free to be used as you want.

Don’t get me wrong, I don’t think that all the commercial software is bad. Some nice examples are Pianoteq and Renoise, very good pieces of software. Try the demos!

Thanks go to CrocoDuck for taking the time to talk to us here at, checkout the CrocoDuck soundcloud page for more music!

by harryhaaren at January 25, 2015 02:49 PM

January 16, 2015

Nothing Special

JACK Midi Control from your Android Phone over WiFi

Since my fundraising for my plugin GUIs is more or less bust, I've been thinking more about making music. I can't really stop developing, cause I'm fairly addicted, but I'm trying to ween myself back to just making whatever I want, rather than trying to develop stuff that will change the world. The world doesn't care that much. Anyhow, this blog is no place for bitterness.

But I have been playing with synths a bit more lately and still am really missing my expression controls. Now I could try to use the old touchmidi app I developed, but it only works with my laptop, and I now have a dedicated desktop in the studio to host my synths so I don't have a touchpad to use. I do have several android devices though. They should be great input interfaces. They can display whatever they like on the screen and have a touch interface so you can have arbitrary configurations of buttons, sliders, knobs, whatever. So I decided to figure out how.

There are a few tools you need, but first: an overview. The key to sending control information from one device to another is OSC (Open Sound Control), which in a nutshell is a way to send data over a network, designed for media applications. We need something to interpret touch input on the phone or tablet and send an OSC message. Then something needs to receive the message, interpret it, convert it to a midi message and send it out a JACK midi port. Well, we aren't inventing the wheel, there are several programs that can do these or related tasks.

One closed source system is TouchOSC. They have a free desktop app and the android app is a few dollars. But its closed source and doesn't actually work on linux. UNACCEPTABLE.
There are really several other apps, many of them free and none of them have had updates in the last few years. Ardroid is an OSC controller, but it is meant for ardour, you can't make custom interfaces like you can with TouchOSC.

What we want is Control. It hasn't been updated for a few years and its kinda buggy, but its OPEN. I could go fix it from the github source (but it would take me a bit of research on android stuff and I'm not a java fan) but its good enough as it is to get by. It uses customizable interface layouts written in JSON and you can add scripting to the interface through javascripts, so no crazy new formats. The real bugs are just in the landscape and portrait mode switching, so I have to open and close the interface a couple times before it gets it right. It's also cross platform.

I was able to make an interface after a few infuriating late night hours of trying to edit one of the examples (that I'm pretty sure had a lot of iOS specific JSON tags), then trying again next morning using the blank template and getting it done in about an hour. I never learn. Its a little involved to make a custom interface but there are good examples and decent documentation. It seems after a while of development the author focused much more on iOS and neglected the Android side, so there are several tags like color that don't work on android and make the interface much buggier if you attempt to use them. If someone wants to be super rad they would take this app and fix it up, make it a bit more robust and report json errors found in layouts etc... But its good enough that I'll just keep using it as it is.

For starters, you can just use the interfaces the app comes with. Go ahead and install it from google play. They have a pretty good variety of interesting interfaces that aren't all exactly conducive to midi control (remember apps CAN have built in OSC support like ardour and non-mixer do) but any of the interfaces built into Control will work. I'll tell you a bit about some other interfaces later.

UPDATE: Since I started writing this, another open source android app has come up: andrOSC. Its much simpler but allows you to edit everything in the app. Its a great option for anyone who wants a custom interface without any sort of file editing or extra uploading. Its a little too simple for what I want so I'm going to stick with Control for now.

Now we just need someplace to send the OSC data that the Control interface will output. Well I thought mididings was the tool for this job but it only accepts a few arbitrary OSC commands and there is no way to change the filtering through OSC aside from making scenes and switching between them. So that was a dead end.

But, the libraries used by mididings are openly available, so I figured I'd just make a python script to do the same thing. Except I've only edited a few python scripts and this is a few steps beyond that. The libraries used are actually c libraries anyway, so c wins. Hold on a sec, I'll just whip up a C program.

(Months go by)

Ah that was quick, right? Wait, Christmas is in how many days?!
Oh well. It works. And its completely configurable (and more features on the way). This gives you the flexibility to change the mapping wherever its easiest, in your OSC client app (i.e. our Control interface), in the osc2midi converter map file, or in the midi of the target program. In another post I'll describe how to use osc2midi more fully (with custom mappings) for now the default one works (because I wrote it to work with all the example interfaces that come with Control).

Download a snapshot, (EDIT: I just released the first beta, from now on, download the files) extract them, and install them:
cd osc2midi
cd build
cmake ..
sudo make install

Then run:

Not too bad (if it didn't work cmake should help you, or just check the README for the dependencies). This gives you a jack midi client and opens an OSC host at 192.168.X.X:57120 (Your computer's IP address : Default port). If you don't know your ip address you can get it with the terminal command ipconfig. Connect the jack midi out port to Carla or whatever you like (I'll proceed with assuming you are using Carla).

Now we need to connect the Control app to the OSC server. Click the destinations tab and the plus sign at the top to enter in the address of the OSC host. From there go back to the interfaces tab and select whatever interface sounds like it will tickle your fancy. For this exercise we'll go ahead and use the mixer interface. If it looks squashed or doesn't fit on the screen you probably have to go back to the menu and open the interface one more time. I always have to open it twice like that (obnoxious, right? you should really go fix that!).

In Carla, load a plugin. Simple amplifier is perfect. First connect the osc2midi output port to the simple amplifier events input port. Open the editing dialog for the plugin and click the parameters tab at the bottom. Simple amplifier only has a single parameter (gain) and so you'll see a single horizontal slider and 2 spinboxes right of it. These numbers select the midi control number (CC) and channel.

Since we called osc2midi without arguments it defaults to channel 1 (or 0 if you prefer 0 indexing) and the first slider in the mixer interface on your android device will send midi CC 1 so select "cc #1" in the middle numeric box. You just bound that midi control to change the amplifier gain. If your jack ports are all set up correctly you should be able to change the first slider on your phone/tablet and watch the slider in Carla wiggle up and down with it. You have CONTROL!!!

The setup
 The other sliders are just sequentially mapped through CC 12. You can figure out what anything is mapped to by either using kmidimon to look at the midi output or running osc2midi in verbose mode (osc2midi -v). You can add other plugins and control them by the same method. Get creative with it.

For my next trick, we'll make some sounds with Control. Hit the menu button on Control and select the Conway's Game of Life interface. The default mapping works but I include a better one with the installation. So in the terminal hit Ctl+C to stop osc2midi. We'll start it again specifying a different map file. Type in:
osc2midi -m gameOfLife.omm
And the server will be restarted on the same port so you won't need to change anything else.

Now lets load an instrument plugin into Carla. I like amsynth but you can use any you like (though a polyphonic one will probably be more fun for this exercise). With an instrument plugin loaded just connect the midi-in port of the instrument to the osc2midi output the the audio output from your plugin/carla to your soundcard. Click several of the buttons on the grid in Control and you should hear some notes start playing. They will stay on till you click it again. Or click the start button and the notes start toggling themselves and you have a nice random sequencer.

This isn't quite enough for simulating all the expression you can get out of a good synthesizer or midi controller, but its a start. The best part is these open tools are all highly configurable, so we have a working system with just using all the defaults. But we can also setup very powerful and custom configurations by tweaking the interface in Control, the mapping in osc2midi, and often the midi bindings in your destination program (like Carla). But we'll save the rest for another post. In the mean time, try all the templates and get creative with these tools.

by Spencer ( at January 16, 2015 01:06 PM

January 13, 2015 »

Packaging Python Stuff

While packaging Tuna I ran into an issue for which I couldn't easily find a workaround on the ubiquitous search engine. Tuna depends on some unavailable Python applications so those had to be packaged too. After having successfully tested the packages locally with pbuilder I uploaded them to Launchpad and noticed that they failed to build. Apparently the Python installer wants to install in /usr/lib/python2.7/site-packages and while that worked fine locally with pbuilder, Launchpad had an issue with that:

Found files in /usr/lib/python2.7/site-packages (must be in dist-packages for python2.7).
dh_builddeb.pkgbinarymangler: dpkg-deb --build debian/python-schedutils .. returned exit code 1
make: *** [binary-arch] Error 1
dpkg-buildpackage: error: /usr/bin/fakeroot debian/rules binary-arch gave error exit status 2

Apparently the files had to be installed in /usr/lib/python2.7/dist-packages but how to instruct the installer to do so without having to resort to ugly hacks? As I couldn't find any useful answers on the web I asked falkTX on #kxstudio. He said the installer has a flag to install to dist-packages instead of site-packages, --install-layout deb. So I added that to the debian/rules file and gave it another spin:

#!/usr/bin/make -f
# -*- makefile -*-
# Sample debian/rules that uses debhelper.
# This file was originally written by Joey Hess and Craig Small.
# As a special exception, when this file is copied by dh-make into a
# dh-make output file, you may use that output file without restriction.
# This special exception was added by Craig Small in version 0.37 of dh-make.

# Uncomment this to turn on verbose mode.
#export DH_VERBOSE=1

dh $@

python build

python install --skip-build --prefix /usr --root $(CURDIR) --install-layout deb

Now both pbuilder and Launchpad built the package without any issues.

by Jeremy at January 13, 2015 01:06 PM

January 04, 2015

Talk Unafraid

A brief foray into explosions

Every year, myself, my family and some friends get together on New Year’s Eve, have a lovely meal and at midnight, let off the obligatory fireworks. Their house is surrounded by farmland so we have a huge amount of space, making operation of larger fireworks possible, but we’ve in past years stuck to firing the larger end of garden fireworks (category 2).

This year, tired of the inevitable mucking around with unreliable gas lighters at midnight, we decided to take a look at electronic ignition systems and upgrade to category 3 “display” fireworks.

We picked up a 12 cue electronic firing system from Wireless Fireworks, who kindly got next-day delivery sorted out on zero notice so we could get everything before NYE. We also grabbed a box of 50 Talon igniters with 4 metre cables, to let us wire the whole display (which ended up only using ~20 igniters, so we have some for next time). As well as being wireless the main advantage of this box over the cheaper/distributed ones (in my mind at least) was that it had a continuity test function, along with a real keyed safety switch – which is a requirement if you ask me. The labelling leaves a lot to be desired – I’ve modified ours so the safety switch is labelled “SAFE” and “ARM” instead of the ambiguous “OFF” and “ON” (safety on = safe? Nope! Safety on = armed…).

The Talon igniters are just bits of fuse wire and a well-designed clip. They clip onto the green/pink fuses you’ll find on any cat2/3 firework and just get very hot – the lack of pyro in the igniters is a huge plus. We had one failure out of our 18 effects which looks to have been a continuity issue. Which brings me to the box that doesn’t exist yet but someone really should make…

You might notice that I said we used 18 effects but that we only have 12 channels. The box is designed to let you pair up effects – we didn’t try more than 2 in a channel but I suspect 3 would work fine. But our one failure was one of these paired effects – probably just the connector not making a good contact with the wire for that effect. In future I plan to solder the ends together for paired effects to make a solid connection between the two fired effects, such that if any continuity check passes, it’s a pass for everything. Ideally you’d have a box that had one wire out to the main box, then two connectors for igniters with switches to let you do continuity checks per-igniter once it’s all wired.

This has all lead me to think it might be a fun project to try making a firing box of my own using the Talon igniters. All it really needs is a battery, some relays or other switches capable of handling the load, continuity test functionality and some safety mechanics around when the current-unrestricted battery connection is made, but that’s all quite straightforward – it’d be nice to have a larger system that could scale up to higher channel counts, but commercial offerings over about 12 channels are all quite expensive! The wireless functionality is nice, but I’d rather have something secure – much to my surprise, the wireless system in these firing boxes is a classic 433MHz type of the sort you’d find in remote controlled switches/mains plugs. Replacing this with WPA2 encrypted 5GHz wifi or a 433/896MHz encrypted wireless system would be nice.

Still, the end result was great – being able to let everything off within seconds of each other (and hitting midnight with a volley of big rockets) was fantastic, and while there was about 4 hours spent setting it all up, I could for the first time stand with friends and family to let everything off. Lots of fun and much safer to boot!

Of course, no fireworks post would be complete without some pictures of the end result – I tried taking my pictures this year with CHDK running on a Canon Powershot G10 with a motion detection script. It almost worked flawlessly…


by James Harrison at January 04, 2015 03:38 PM

December 30, 2014

Arch Linux Pro Audio

Interview with Hlynur – Arch based Glitch DnB producer

December passes, with the holiday season and lots of time off… Here at we talk to 18 year old programmer / sys-admin / producer Hlynur about using linux to create glitch music.

Hi, thanks for taking time to chat to! Who are you, and what
are your interests?

Hey! My name is Hlynur, and I’m a 18 year old programmer from Iceland. My interest include Competitive Programming, Linux, All things Glitch (Music, Art, etc) and Electronic Dance Music (my favorite sub-genres include Glitch / Glitch Hop / Dubstep / Drum and Bass)

Wow competitive programming, what does that involve? And what are your
favorite tools?

You need to solve various problems (Mathematical or the like) computationally under a time constraint, it’s really fun. My favorite programming language is Python and vim is the best editor ever. Ofcourse, I can’t forget the window manager i3!

You mentioned a lot of electronic and glitch music, are you a musician?

That’s the funny part… I have no musical talents, but I listen to a lot of music. I just started playing around with LMMS last week and have been getting way better results than I thought I was capable of!

So you’re impressed with LMMS and the Linux Audio eco-system? Is there any
synth or feature of LMMS in particular you’re fond of?

Really impressed, I was pleasently surprised when I found LMMS and just had to try it out. I still have a lot to learn about LMMS and music in general, so I’m still just experimenting and trying to find my sound

Any closing notes you’d like to add?

I tried to get into EDM back when I used Windows, But I just was having a hard time finding help and support at the time. But I feel as the LMMS community does an amazing job with helping beginners get their footing in their software and in music.

Thanks to Hlynur for talking to!

by harryhaaren at December 30, 2014 05:06 PM

December 21, 2014

Talk Unafraid

Setting up the Taranis X9D+ and OpenTX

With more complex stuff on my quad comes an increased need for a more complex radio, so I opted to upgrade from an aging Turnigy 9X to a FrSky Taranis X9D+ with an X8R receiver – this nets me not only 16 channels via S.BUS on the receiver and a telemetry link, but a fancy programmable transmitter!

It’s a bit daunting to get it all set up but pretty easy once you get the hang of it. This is going to be a quick writeup of how I went about setting it up, configuring the transmitter for the Pixhawk flight controller and flight modes, and some nice things to know that aren’t that clear from the docs.

So the first thing you want is the OpenTX Companion. The companion will handle downloading and flashing firmware for you. On Windows 7 you’ll also need the zadig utility; plug your radio in (switched off) and then open zadig, find STM32 BOOTLOADER and hit the big button. That’ll get your drivers set up right.

When you start the Companion will ask if you want to go ahead and flash the radio – don’t yet. You want to dive into Settings -> Settings, tell it which radio you’re using, and check “noheli” and “lua” options. Other stuff it’s worth setting in there include the automatic backup path in application settings, and the SD structure path. The SD structure path points at a local copy of the SD card so you can get sounds etc.

Which brings us to the SD card. Pop it out, back up the contents somewhere, wipe it clean and replace the contents with this copy off the FrSky website. This includes an extensive sound set and is generally up-to-date. You’ll also want to keep a copy of this (with any changes you make) on your PC for the simulator and settings dialogs.

Flash, aaa-ah! Saviour of the universe!

Now we should have a radio with a newly-filled miniSD card, but some old firmware. Plug the radio in on USB with the radio powered down, and then hit the “Download” button in OpenTX Companion. Download the latest firmware somewhere and then hit Read/Write -> Write Firmware. Once it’s done you can reboot and check it all works.

Once you’ve done that, power down the radio again, unplug it, and start it up while pressing the two bottom trim switches towards the power switch. This gets you into the bootloader. Plug in your USB cable and your SD card will show up in Windows – but most importantly you can go ahead and hit “Read models from radio”. This gets you a copy of everything in your radio to start with. You can then proceed to start tweaking! You need to go back to this mode to be able to write stuff, too.

Mixing it up

Let’s open a model up and take a look. For starters we’ve got the setup page. This has simple stuff like what radio system to use, switch and pot warnings, and timers. Timers are helpful for keeping track of battery usage (though if you get telemetry set up, that’s good too) – I have one set up to count down my expected battery life using the THs counter.

Next we have the flight modes. Skip this tab for now. Briefly, though, a little aside on terminology.

The Taranis has a bunch of inputs. Throttle, elevator, rudder etc are named what you’d expect but other physical controls are things like SA, SB, etc. There’s also S1/S2, and L1/L2. The latter four are pots – S1/2 on the front, L1/2 on the sides. The former are switches – you have $MANY on the X9D+. Where you see things like an arrow pointing up/down next to a switch, that’s going to evaluate to “on” if that’s the state the switch is in.

In inputs we can assign each physical control to an input channel. I’ve done this for four switches. The benefit of adding these here rather than directly in the mixer is that we can apply things like curves to them. This is actually very useful for the Pixhawk. The Pixhawk/PX4 expects 3 two-position switches and a single 3-position switch for selecting your flight mode. The Taranis is overequipped with three-position switches, so I’ve set up a curve that treats positions 2 and 3 identically. To do this, go into Curves, pick a Curve (eg Curve 2), select 4 points, and set them at -100,-100;-50,-100;-1,100;100,100. Then you can pick Curve 2 for that input.

But back to the mixer. What’s it all about? The mixer is what actually produces the output values. In most cases for multirotors you just want to pass through your input channels, but you might want to do something fancier. For that Pixhawk setup, simply set channels 5-8 to correspond to inputs 5-8 where you’ve put your switches.

It seems logical, captain

Logical switches are kinda neat. Let’s say you have, as in our example, a 3 position switch with some 2 position switches cascaded from the output. In each combination we derive a logical state and it’d be nice to announce that, since the Taranis has audio playback.

I used the festival tts “text2wave” utility to generate some WAV files, and then used ffmpeg to resample them to mono 32kHz files. This is required for playback to work. Sounds simply drop into the SOUNDS/en/ folder. Note there’s an 8 character file name limit, though, not counting the .wav! Very long filenames won’t show up in the radio and will get truncated in settings.

In logical switches, we can take, for instance, L1, and set the function a<x. The OpenTX documentation lists the functions and what they do; this is a simple less than comparison.  We can point V1 at a channel in the mixer, for instance CH5, and set V2 to a constant like 0.  L1 being on now corresponds to the default (up) state of my 3-position switch being on.

This particular thing you can do by looking at the SA booleans, but logical switches have an AND switch function, too. This means we can, for all our two-position switches, only turn on our logical switches if the top-level switch is in the right position.

Special Functions are on the next tab. In here we can set actions for each switch or logical switch, like “Play track” to play some audio. I’ve got my radio set up to play the right bit of speech to tell me which flight mode I’m now in, eg “Full auto”, “RTLS”, “Manual”, “Position hold” etc.

This really is the tip of the iceberg – you could much more easily (in theory) do my Pixhawk flight mode announcement in Lua, as the radio supports scripting, but I’ve not had the time to figure out how to just yet! Combined with telemetry you can do automated warnings and announcements for altitude, speed, battery and more. It’s a very cool bit of kit and worth persevering with to get it set up just right for your use-case.

by James Harrison at December 21, 2014 09:41 PM

December 19, 2014

Sam Tuke » Audio

My Linux Audio interview in Ubuntu User

It was months in the making, finally reached news stands last month, and now it’s free to read online. That’s right, you can read my five page interview with Harry van Haaren on the Ubuntu User website. The printed copy looks much prettier however, and also includes a three page guide to using Harry’s suite […]

by samtuke at December 19, 2014 02:45 PM

December 18, 2014

Nothing Special

Easy(ish) Triple Boot on 2014 Macbook Pro

Nothing is easy. Or perhaps everything is. Regardless, here is how I did it, but first a little backstory:

I got a macbook pro 11,3 from work. I wanted a lenovo, but the boss wants me to do some iOS stuff eventually. Thats fine, cause I can install linux just as easily on whatever. Oh wait.. There are some caveats. Boot Camp seems to be a little picky. Just as well. MIS clowns set up boot camp so I had windows 7 and Yosemite working, but they told me I'm on my own for linux. It seems from the posts I've read about triple booting is that you have to plan it out from the get-go of partitioning, not just add it in as an afterthought. But I also found suggestions about wubi.

I've used wubi and didn't really understand what it did, but its actually perfect for setting up a triple boot system in my situation (where it's already dual boot and I want to tack on linux and ignore the other two). There is a lot of misunderstanding that wubi is abandoned and no longer supported bla bla. The real story is that the way wubi works doesn't play nicely with windows 8. Therefore if it doesn't work for everybody Ubuntu doesn't want to advertise it as an option. Its there, but they'd rather have everyone use the most robust method known: full install from the live cd/usb. Not that wubi is rickety or anything, but only works in certain situations (windows 7 or earlier). The reality is its on every desktop ISO downloaded, including latest versions (more on that later).

The way wubi works is important to note too (and its the reason that its perfect for this situation). Wubi creates a virtual disk inside the NTSC (windows) partition of the disk. So instead of dividing the hard drive space into two sections (one for linux, one for windows, and/or a third for OSX if triple boot) it doesn't create disk partitions at all,  just a disk file inside the existing windows partition. The windows bootloader is configured to open the windows partition then mount this file as another disk in whats called a loopback mode. This is distinctly contrasted to a virtualized environment where often a virtual disk is running on virtual hardware. You are using your actual machine, just your disk is kinda configured in a unique but clever way.

The main downside it sounds like is that you could have poor disk performance. It sounds like in extreme cases, VERY poor performance. Since this machine was intended for development its maxed out with 16GB ram, so I'm not even worrying about swap, and the 1TB hdd has plenty of space for all 3 OSes and its a fresh install so shouldn't be too fragmented. These are the best conditions for wubi. So far it seems to be working great. Install took a little trial and error though.

So I had to at least TRY to teach you something before giving you the recipe, but here goes:

  1. I had to install bootcamp drivers in windows. MIS should have done that but they're clowns. You'll have to learn that on your own. There are plenty of resources for those poor mac users. This required a boot into OSX.
  2. Boot into windows.
  3. Use the on screen keyboard in the accessibility options of the windows to be able to hit ctl+alt+delete to make up for the flaw that macbooks have no delete key (SERIOUSLY?) Also don't get me started on how I miss my lenovo trackpoints.
  4. I installed sharpkeys to remap the right alt to be a delete key so I could get around this in the future. I know sooner or later Cypress will make me boot into windoze.
  5. Download the Ubuntu desktop live CD ISO (I did the most recent LTS. I'm not in school any more, gone are the days where I had time to change everything every 6 months).
  6. In windows install something that will let you mount the ISO in a virtual cd drive. You could burn it to CD or make a live USB, but this was the quickest. I used WinCDEmu as it's open source.
  7. Mount the ISO and copy wubi.exe off of the ISO's contents and into whatever directory the ISO is actually in (i.e. Downloads).
  8. Unmount the ISO. This was not obvious to me and caused an error in my first attempt.
  9. Disable your wifi. This was not obvious to me and caused an error in my second attempt. This forces wubi to look around and find the ISO that is in the same folder rather than try to re-download another ISO.
  10. Run wubi.exe .
  11. Pick your install size, user name, all that. Not that it matters but I just did vanilla ubuntu since I was going to install i3 over the Unity DE anyway. Historically I always like to do it with xubuntu, but I digress.
  12. Hopefully I haven't forgotten any steps, but that should run and ask you to reboot. (I'd re-enable the wifi before you do reboot, or else you'll forget like I did and wonder why its broken next windows boot).
  13. The reboot should complete the install and get you into ubuntu.
  14. I believe the next time you reboot it will not work. For me it did not. Its due to a grub2 bug I understand. Follow the solutions in these two threads: 
  15. To roughly summarise the process, hit the e key to edit the grub config that will try to load ubuntu. Edit the line
    linux /boot/vmlinuz-3.13.0-24-generic root=UUID=bunchofhexidec loop=/ubuntu/disks/root.disk ro

    ro should be changed to rw. This will allow you to boot. The first post tells you to edit an auto-generated file. Thats silly. what happens when it gets auto-generated and again and overwrites your fix? It even says not to edit it in the header. Instead you need to make a similar change to the file that causes it to have that error and then generate those files again as described in the second link.
  16. Once that is sorted out you'll probably notice that the wifi is not working. You can either use an ethernet port adapter or a USB wifi card (or figure out another way) but get internet somehow and install bcmwl-kernel-source and it should start working (maybe after a logout. I don't remember).
  17. Another tweak you will need is that this screen has a rediculously high DPI so the default fonts are all teensy-tiny. The easiest workaround is just to lower the screen resolution in the displays setting of unity-command-center, but you can also edit the font sizes in that dialog and/or using unity-tweak-tool. I'm still ironing that out. Especially since my secondary monitors are still standard definition. xrandr --scale is my only hope. Or just lower the resolution.
  18. You might find that the touchpad click doesn't work as you expect. Try running the command:
    synclient ClickPad=0
    and see if you like it better. I sure do. Also enable two finger scrolling in the unity-control-center.
  19. Also, importantly, wubi only allows up to 30GB of virtual disk to be created. I wanted a lot more than that. So I booted off a USB live stick I had laying around and followed the instructions here to make it a more reasonable 200GB.
  20. Finally install i3-wm, vifm, eclipse, the kxstudio repos and everything else you love about linux.
So I love my macbook. Because its a linux box.

by Spencer ( at December 18, 2014 04:14 PM

December 05, 2014

2015 Csound Conference in St. Petersburg, Russia

Screen Shot 2014-12-05 at 1.07.09 AM

ICSC 2015

The 3rd International Csound Conference


Join us for The 3 rd International Csound Conference!
Three days of concerts, papers, workshops and meetings.
Get in touch with the global community of composers, sound designers and programmers.

 The Conference Will Be Held At

The Bonch-Bruevich St.Petersburg
State University of Telecommunications

The region biggest training and scientific complex specialized in information technologies and communications


For any questions, please contact us by email:

Conference Chair

Gleb RogozinskyScreen Shot 2014-12-05 at 1.07.09 AM


Copyright © [2015 Csound Conference in St. Petersburg, Russia], All Right Reserved. 2015.

by Richard Boulanger at December 05, 2014 06:09 AM

December 03, 2014

CsoundQt 0.9.0 Released


This version includes:

  • A new virtual MIDI keyboard
  • Visual display of matching (or un-matching) parenthesis
  • Correct highlighting of type marks for functional opcodes (e.g. oscil:a)
  • Put back status bar
  • Added template list in file menu. Template directory can be set from the environment options
  • Added home and opcode buttons to help dock widget
  • Removed dependency on libsndfile (now using Csound’s perfThread record facilities
  • Fixed tab behavior
  • Updated version of Stria Synth (thanks to Emilio Giordani)
  • Dock help now searches as user types (not only when return is pressed)

Download HERE




Copyright © [CsoundQt 0.9.0 Released], All Right Reserved. 2015.

by Richard Boulanger at December 03, 2014 08:51 AM

November 29, 2014


Save the kiwis

A few months ago, Lukasz Tracewski explained his project on the aubio-user mailing list. Using aubio's onset detection from his custom Python code, he is able to process very large amounts of recordings from New Zealand wilderness to monitor the populations of kiwis and improve their protection.

Kiwi and its egg

A kiwi and its egg, by Shyamal (own work), CC-BY-3.0, via Wikimedia Commons

Here is how Lukasz describes the challenge:

The project is to support efforts in kiwi protection, famous flightless bird from New Zealand. We count their calls (and also determine gender) in each file and use this information to understand ecosystem health and how well protection efforts are working.

As you can imagine finding that there is something worth interest in a recording is crucial: if there are too many false positives, then noise reduction by spectral subtraction becomes inefficient. The other way risk is even greater: if bird call goes undetected, then it will be included in noise-only regions and then subtracted from a whole sample, effectively eliminating many possible candidates.

Processing time becomes important when there are truly many sample. As mentioned before, there are 10000 hours of recordings. To get them identified we will probably buy time on Amazon Web Services EC2 compute-optimized instance (something with 32 virtual CPUs). Time is money in this case, so keeping it short is crucial.

Interestingly, Lukasz found that the energy onset detection method, which often generates a lot of false positives on music signals, was, in his case, the one giving the best result for the detection of bird calls.

Find out more about Lukasz project on the Ornithokrites web page.

November 29, 2014 10:46 PM

November 21, 2014

Nothing Special

Common Synthesizer Envelope Types

The term "infographic" seems like such a marketing buzzword it makes me want to ignore whomever says it. But I'm all for the presentation of information in a logical and clear manner. As I was pondering on how to increase interest in my audio plugins I thought about my ADBSSR envelopes that I love in the cellular automaton synth. I wanted some way to present quickly both how to use them and why they offer advantage over traditional ADSR envelope generators.They do add complexity but there's really no way to add a swell as we horn players do all the time to a patch without it. It even can look exactly like an ADHR when the Breakpoint is set to 1. Anyway I thought a diagram with explanatory text would do the trick. So I made one:

Figure 1: Not an infographic
This isn't an infographic though. I don't really know why I think that word is so stupid. Probably just because I tend to hate on anything trendy and hyped. Anyhow. Now you know how I feel. This image is in the public domain though I would appreciate citation.

by Spencer ( at November 21, 2014 03:39 PM

Making an LV2 plugin GUI (yes, in Inkscape)

Told you I'd be back.

So I made this pretty UI last post but I never really told you how to actually use it (I'm assuming you've read the previous 2 posts, this is the 3rd in the series). Since I'm "only a plugin developer," that's what I'm going to apply it to. Now I've been making audio plugins for longer than I can hold my breath, but I've never bothered to make one with a GUI. GUI coding seems so boring compared to DSP and it's so subjective (user: "that GUI is so unintuitive/natural/cluttered/inefficient/pretty/ugly/slow etc. etc....") and I actually like the idea of using your ears rather than a silly visual curve, but I can't deny, a pretty GUI does increase usership. Look at the Calf plugins...

Anyhow, regardless of whether its right or wrong I'm going to make GUIs (that are completely optional, you can always use the host generated UI). I think with the infamous cellular automaton synth I will actually be able to make it easier to use, so the GUI is justifiable, but other than that they're all eye candy, so why not make 'em sweet? So I'll draw them first, then worry about making them an actual UI. I've been trying to do this drawing-first strategy for years but once I started toying with svg2cairo I thought I might actually be able to do it this time. Actually as I'm writing this paragraph the ball is still up in the air, so it might not pan out, but I'm pretty confident by the time you read the last paragraph in this almost-tutorial I'll have a plugin with a GUI.

So lets rip into it:

One challenge I have is that I really don't like coding C++ much. I'm pretty much a C purist. So why didn't I use gtk? Well, cause it didn't have AVTK. Or ntk-fluid. With that fill-in-the-blank development style fluid lends to, I barely even notice that its C++ going on in back. Its a pretty quick process too. I had learned a fair bit of QT, but was forgoing that anyway, but with these new (to me) tools I had a head start and got to where I am relatively quickly (considering my qsvg widgets are now 3 years old and unfinished).

The other good news is that the DSP and UI are separate binaries and can have completely separate codebases, so I can still do the DSP in my preferred language. This forced separation is very good practice for realtime signal processing. DSP should be the top priority and should never ever ever have to wait for the GUI for anything.

But anyway, to make an LV2 plugin gui we'll need to add some extra .ttl stuff. So in manifest.ttl:
@prefix lv2:  <> .
@prefix rdfs: <> .
@prefix ui:   <> .
a lv2:Plugin, lv2:DelayPlugin ;
lv2:binary <> ;
rdfs:seeAlso <stuck.ttl> .
        a ui:X11UI;
        ui:binary <>
        lv2:extensionData ui:idle; . 

Thats not a big departure from the no-UI version, but we'd better make a to back it up. We've got a .cxx and .h from ntk-fluid that we made in the previous 2 posts, but its not going to be enough. The callbacks need to do something. But what? Well, they will be passing values into the control ports of the plugin DSP somehow. OpenAVproductions genius Harry Haaren wrote a little tutorial on it. The thing is called a write function. Each port has an index assigned by the .ttl and the dsp source usually has an enum to keep these numbers labeled. So include (or copy) this enum in the UI code, declare an LV2UI_Write_Function and also an LV2UI_Controller that will get passed in as an argument to the function. Both of these will get initialized with arguments that get passed in from the host when the UI instantiate function is called. The idea is the LV2_Write_Function is a function pointer that will call something from the host that stuffs data into the port. You don't need to worry about how that function works, just feel comfort knowing that where ever that points, it'll take care of you. In a thread safe way even.

Another detail (that I forgot when I first posted this yesterday) is declaring that this plugin will use the UI you define in the manifest.ttl. What that means is in the stuck.ttl you add the ui extension and declare the STUCKURI as the UI for this plugin:
@prefix doap:  <> .
@prefix foaf: <> .
@prefix rdf: <> .
@prefix rdfs: <> .

@prefix lv2: <> .
@prefix ui: <> .

a lv2:Plugin, lv2:DelayPlugin ;
doap:name "the infamous stuck" ;
doap:maintainer [
foaf:name "Spencer Jackson" ;
foaf:homepage <> ;
foaf:mbox <> ;
] ;
lv2:requiredFeature <> ;
lv2:optionalFeature lv2:hardRTCapable ;
ui:ui <> ;

lv2:port [

So enough talk. Lets code.
For LV2 stuff we need an additional header. So in an extra code box (I used the window's):
#include "lv2/"

It will be convenient to share a single source file for which port is which index. That eliminates room for error if anything changes. So in an additional code box (the Aspect Group's since the window's are all full):
We also will need 2 additional members in our StuckUI class. Do this by adding 2 "declarations" in fltk. The code is:
LV2UI_Write_Function write_function;

LV2UI_Controller controller;

And finally in each callback add something along the lines of (i.e. for the Stick It! port):

This is calling the write function with the controller object, port number, "buffer" size (usually the size of float), protocol (usually 0, for float), and pointer to a "buffer" as arguments. So now when the button is clicked it will pass the new value on to the DSP in a threadsafe way. The official documentation of write functions is here. The floatvalue member of dials and buttons is part of ffffltk (which was introduced in the other parts of this series) which was added exclusively for LV2 plugins. Cause they always work in floats. Or in atoms, which is a whole other ball of wax. Really though, its really easy to do this as long as you keep it to simple float data like a drone gain.

Another important thing you must add to the fluid design is a function called void idle(). In this function add a code block that has these 2 lines:

To help clarify everything here's a screenshot of ntk-fluid once I've done all this. Its actually a pretty good overview what we've done so far:

Possibly the biggest departure from what we've done previously is now the program will not be a stand-alone binary, but a library that has functions to get called by the host (just like in the DSP). This means some major changes in our stuck_ui_main.cxx code.

For the GUI the most important functions are the instantiation, cleanup, and port event. To use NTK/fltk/ffffltk you will need to use some lv2 extensions requiring another function called extension_data but we'll discuss it later. The instantiation is obviously where you create your window or widget and pass it back to the host, cleanup deallocates it, and the port event lets you update the GUI if the host changes a port (typically with automation). We'll present them here in reverse order since the instantiation with NTK ends up being the most complex. So port event is fairly straightforward:
void stuckUI_port_event(LV2UI_Handle ui, uint32_t port_index, uint32_t buffer_size, uint32_t format, const void * buffer)
    StuckUI *self = (StuckUI*)ui;
      float val = *(float*)buffer;
        case STICKIT:
        case DRONEGAIN:
        case RELEASE:

The enlightening thing about doing a UI is that you get to see both sides of what the LV2 functions do. So just like in the widget callbacks you send a value through the write_function, this is like what the write function does on the other side, first you recast the handle as your UI object so you can access what you need, then make sure its passing the format you expect (0 for float, remember?). Then assign the data corresponding to the index to whatever the value is. This keeps your UI in sync if the host changes a value. Nice and easy.

Next up is the simplest: Cleanup:
void cleanup_stuckUI(LV2UI_Handle ui)
    StuckUI *self = (StuckUI*)ui;

    delete self;

No explanation necessary. So that leaves us with instantiation. This one is complex enough I'll give it to you piece by piece. So first off is the setup, checking that we have the right plugin (this is useful when you have a whole bundle of plugins sharing code), then dynamically allocating a UI object that will get returned as the plugin handle that all the other functions use, and declaring a few variables we'll need temporarily:
static LV2UI_Handle init_stuckUI(const struct _LV2UI_Descriptor * descriptor,
        const char * plugin_uri,
        const char * bundle_path,
        LV2UI_Write_Function write_function,
        LV2UI_Controller controller,
        LV2UI_Widget * widget,
        const LV2_Feature * const * features)
    if(strcmp(plugin_uri, STUCK_URI) != 0)
        return 0;

    StuckUI* self = new StuckUI();
    if(!self) return 0;
    LV2UI_Resize* resize = NULL;

Then we save the write_function and controller that got passed in from the host so that our widgets can use them in thier callbacks:
    self->controller = controller;
    self->write_function = write_function;

Next stop: checking features the host has. This is where using NTK makes it a bit more complicated. The host should pass in a handle for a parent window and we will be "embedding" our window into the parent. Another feature we will be hoping the host has is a resize feature that lets us tell the host what size the window for our plugin should be. So we cycle through the features and when one of them matches what we're looking for we temporarily store the data associated with that feature as necessary:
    void* parentXwindow = 0;
    for (int i = 0; features[i]; ++i)
        if (!strcmp(features[i]->URI, LV2_UI__parent))
           parentXwindow = features[i]->data;
    else if (!strcmp(features[i]->URI, LV2_UI__resize))
           resize = (LV2UI_Resize*)features[i]->data;

Now we go ahead and startup our UI window, call the resize function with our UI's width and height as arguments and call a special NTK function called fl_embed() to set our window into the parent window. It seems this function was created specially for NTK. I haven't found it in the fltk source or documentation so I really don't know much about it or how you'd do it using fltk instead of NTK. But it works. (You can see the NTK source and just copy that function).  Once that's done we return our instance of the plugin UI object:
    self->ui = self->show();
    // set host to change size of the window
    if (resize)
       resize->ui_resize(resize->handle, self->ui->w(), self->ui->h());
    fl_embed( self->ui,(Window)parentXwindow);

    return (LV2UI_Handle)self;

Ok. Any survivors? No? Well I'll just keep talking to myself then. We mentioned the extension_data function. This function gets called and can do various special functions if the host supports them. Similar to the port event, the same extension_data function gets called with different indexed functions and we can return a pointer to a function that does what we want when an extension we care about gets called. Once again we get to see both sides of a function we called. The resize stuff we did in instantiate can be used as a host feature like we did before or as extension data. As extension data you can resize your UI object according to whatever size the host requests. This extension isn't necessary for an NTK GUI but since the parent window we embedded our UI into is a basic X window, its not going to know to call our fltk resize functions when its resized.

In contrast, a crucial extension for an NTK GUI is the idle function. Because similarly the X window doesn't know anything about fltk and will never ask it to redraw when something changes. So this LV2 extension exists for the host to call a function that will check if something needs to get updated and redrawn on the screen. We made an idle function already to call in our StuckUI object through fluid, but we need to set up the stuff to call it. Our extension_data function will need some local functions to call:
static int
idle(LV2UI_Handle handle)
  StuckUI* self = (StuckUI*)handle;
  return 0;

static int
resize_func(LV2UI_Feature_Handle handle, int w, int h)
  StuckUI* self = (StuckUI*)handle;
  return 0;

Hopefully its obvious what they are doing. The LV2 spec has some stucts that are designed to interface  between these functions and the extension_data function, so we declare those structs as static constants, outside of any function, with pointers to the local functions :
static const LV2UI_Idle_Interface idle_iface = { idle };
static const LV2UI_Resize resize_ui = { 0, resize_func };

And now we are finally ready to see the extension_data function:
static const void*
extension_data(const char* uri)
  if (!strcmp(uri, LV2_UI__idleInterface))
    return &idle_iface;
  if (!strcmp(uri, LV2_UI__resize))
    return &resize_ui;
  return NULL;

You see we just check the URI to know if the host is calling the extension_data function for an extension that we care about. Then if it is we pass back the struct corresponding to that extension. The host will know how these structs are formed and use them to call the functions to redraw or resize our GUI when it thinks its necessary. We aren't really guaranteed timing for these but most hosts are gracious enough to call it at a frequency that gives pretty smooth operation. Thanks hosts!

So, its now time for the ugly truth to rear its head. Full disclosure: this implementation of the resizing extension code doesn't work at all. The official documentation describes this feature as being 2 way, host to plugin or plugin to host. We've already used it as plugin to host and that works perfectly, but when trying to go the other way I can't get it to work. The trouble is when we declare and initialize the LV2UI_Resize object. The first member of the struct is type LV2UI_Feature_Handle which is really just a void* which should really just be a pointer to whatever data the plugin will want to use when the function in the 2nd member of the struct gets called. Well for us when resize_func gets called we want our instance of the StuckUI that we created in init_stuckUI(). That would allow us to call the resize function. But we can't because its out of scope, and the struct must be a constant so it can't be assigned in the instantiate function. So I just have a 0 as that first argument and actually have the call to size() commented out.

Perhaps there's a way to do it, but I can't figure it out. I included that information because I hope to figure out how and someday make my UI completely resizable. The best way to find out, I figure, is to post fallacious information on the Internet and pretty soon those commenters will come tell me how wrong and stupid I am. Then I can fix it.

As a workaround you can put in your manifest.ttl this line:
lv2:optionalFeature ui:noUserResize ;

Which will at least make it not stupidly sit there the same size all the time even when the window is resized. If the host supports it.

"So if its not even resizable why in the world did you drag us through 3 long detailed posts on how to make LV2  GUIs out of SCALABLE vector graphics?!" you ask. Well, you can still make perfectly scalable guis for standalone programs, and just having a WYSIWYG method of customized UI design is hopefully worth something to you. It is to me, though I really hope to make it resizable soon. It will be nice to be able to enlarge a UI and see all the pretty details, then as you get familiar with it shrink it down so you can just use the controls without needing to read the text. Its all about screen real estate. And tiling window managers for me.

So importantlyin LV2 we need to have a standard function that passes to the host all these functions so the host can call them as necessary. Similar to the DSP side you declare a descriptor which is really a standard struct that has the URI and function pointers to everything:
static const LV2UI_Descriptor stuckUI_descriptor = {

And lastly the function that passes it back. Its form seems silly for a single plugin, but once again you can have a plugin bundle (or a bundle of UIs) sharing source that passes the correct descriptor for whichever plugin is requested (by index). It looks like this:
const LV2UI_Descriptor* lv2ui_descriptor(uint32_t index)
    switch (index) {
    case 0:
        return &stuckUI_descriptor;
        return NULL;

As a quick recap, here are the steps to go from Inkscape to Carla (or your favorite LV2 plugin host):
1. Draw a Gui in Inkscape
2. Save the widgets as separate svg files
3. Convert to cairo code header files
4. Edit the draw functions to animate dials, buttons, etc. as necessary.
5. Create the GUI in ntk-fluid with the widgets placed according to your inkscape drawing
6. Include the ffffltk.h and use ffffltk:: widgets
7. Assign them their respective draw_functions() and callbacks
8. Add the write_function, controller members, and the idle() function
9. Export the source files from fluid and write a ui_main.cxx
10. Update your ttl
11. Compile, install, and load in your favorite host.

Our plugin in Jalv.gtk

So you now have the know-how to create your own LV2 plugin GUIs using Inkscape, svg2cairo, ffffltk, ntk-fluid, and your favorite editor. In 11 "easy" steps. You can see the source for the infamous Stuck that I developed this workflow through in my infamous repository. And soon all the plugins will be ffffltk examples. I'll probably refine the process and maybe I'll post about it. Feel free to ask questions. I'll answer to the best of my ability. Enjoy and good luck.

As an aside, in order to do this project. I ended up switching build systems. Qmake worked well, but I mostly just copied the script from Rui's synthv1 source and edited it for each plugin. Once I started needing to customize it more to generate separate dsp and ui binaries I had a hard time. I mostly arbitrarily decided to go with cmake. The fact that drmr had a great cmake file to start from was a big plus. And the example waf file I saw freaked me out so I didn't use waf. I guess I don't know python as much as I thought. Cmake seemed more like a functional programming language, even if it is a new syntax. I was surprised that in more or less a day I was able to get cmake doing exactly what I wanted. I had to fight with it to get it to install where I wanted (read: obstinate learner), but now its ready for whatever plugins I can throw at it. So that's what I'm going to use going forward. I'll probably leave the .pro files for qmake so if you want to build without a GUI you can. But maybe I won't. Complain loudly in the comments if you have an opinion.

by Spencer ( at November 21, 2014 01:57 PM

November 18, 2014


Bitwig ships aubio, and shouldn't

On March 27th, the first public release of Bitwig, a digital audio workstation often compared to Ableton Live, was announced. Bitwig had made a bit of noise for the past few years as a promising software for music composers and producers.

That same day, a good friend of mine gave me the news that, a binary version of the Vamp plugin for aubio, was included in the first public demo of Bitwig, along with an old binary version of the entire aubio library.

It seems they decided to use aubio's onset detection to automatically slice their samples. Now, in the default configuration, aubio is not used. But Bitwig is a commercial software, and should not include GPL code in any sort of way.

After being asked, Bitwig publicly confirmed that they were not using [aubio] anymore, and just forgot to remove the file. I also wrote to them asking them to do so and received a mail from their side confirming they would do remove it as soon as possible.

Version 1.1 was released a few days ago, and still ships aubio's binary. From version 1.0.2 to version 1.1, all of them contained aubio's binary code. How could someone possibly forget to run rm -f in no less than eight months and several releases?

November 18, 2014 09:27 PM

November 11, 2014

Pid Eins

systemd For Administrators, Part XXI

Container Integration

Since a while containers have been one of the hot topics on Linux. Container managers such as libvirt-lxc, LXC or Docker are widely known and used these days. In this blog story I want to shed some light on systemd's integration points with container managers, to allow seamless management of services across container boundaries.

We'll focus on OS containers here, i.e. the case where an init system runs inside the container, and the container hence in most ways appears like an independent system of its own. Much of what I describe here is available on pretty much any container manager that implements the logic described here, including libvirt-lxc. However, to make things easy we'll focus on systemd-nspawn, the mini-container manager that is shipped with systemd itself. systemd-nspawn uses the same kernel interfaces as the other container managers, however is less flexible as it is designed to be a container manager that is as simple to use as possible and "just works", rather than trying to be a generic tool you can configure in every low-level detail. We use systemd-nspawn extensively when developing systemd.

Anyway, so let's get started with our run-through. Let's start by creating a Fedora container tree in a subdirectory:

# yum -y --releasever=20 --nogpg --installroot=/srv/mycontainer --disablerepo='*' --enablerepo=fedora install systemd passwd yum fedora-release vim-minimal

This downloads a minimal Fedora system and installs it in in /srv/mycontainer. This command line is Fedora-specific, but most distributions provide similar functionality in one way or another. The examples section in the systemd-nspawn(1) man page contains a list of the various command lines for other distribution.

We now have the new container installed, let's set an initial root password:

# systemd-nspawn -D /srv/mycontainer
Spawning container mycontainer on /srv/mycontainer
Press ^] three times within 1s to kill container.
-bash-4.2# passwd
Changing password for user root.
New password:
Retype new password:
passwd: all authentication tokens updated successfully.
-bash-4.2# ^D
Container mycontainer exited successfully.

We use systemd-nspawn here to get a shell in the container, and then use passwd to set the root password. After that the initial setup is done, hence let's boot it up and log in as root with our new password:

$ systemd-nspawn -D /srv/mycontainer -b
Spawning container mycontainer on /srv/mycontainer.
Press ^] three times within 1s to kill container.
systemd 208 running in system mode. (+PAM +LIBWRAP +AUDIT +SELINUX +IMA +SYSVINIT +LIBCRYPTSETUP +GCRYPT +ACL +XZ)
Detected virtualization 'systemd-nspawn'.

Welcome to Fedora 20 (Heisenbug)!

[  OK  ] Reached target Remote File Systems.
[  OK  ] Created slice Root Slice.
[  OK  ] Created slice User and Session Slice.
[  OK  ] Created slice System Slice.
[  OK  ] Created slice system-getty.slice.
[  OK  ] Reached target Slices.
[  OK  ] Listening on Delayed Shutdown Socket.
[  OK  ] Listening on /dev/initctl Compatibility Named Pipe.
[  OK  ] Listening on Journal Socket.
         Starting Journal Service...
[  OK  ] Started Journal Service.
[  OK  ] Reached target Paths.
         Mounting Debug File System...
         Mounting Configuration File System...
         Mounting FUSE Control File System...
         Starting Create static device nodes in /dev...
         Mounting POSIX Message Queue File System...
         Mounting Huge Pages File System...
[  OK  ] Reached target Encrypted Volumes.
[  OK  ] Reached target Swap.
         Mounting Temporary Directory...
         Starting Load/Save Random Seed...
[  OK  ] Mounted Configuration File System.
[  OK  ] Mounted FUSE Control File System.
[  OK  ] Mounted Temporary Directory.
[  OK  ] Mounted POSIX Message Queue File System.
[  OK  ] Mounted Debug File System.
[  OK  ] Mounted Huge Pages File System.
[  OK  ] Started Load/Save Random Seed.
[  OK  ] Started Create static device nodes in /dev.
[  OK  ] Reached target Local File Systems (Pre).
[  OK  ] Reached target Local File Systems.
         Starting Trigger Flushing of Journal to Persistent Storage...
         Starting Recreate Volatile Files and Directories...
[  OK  ] Started Recreate Volatile Files and Directories.
         Starting Update UTMP about System Reboot/Shutdown...
[  OK  ] Started Trigger Flushing of Journal to Persistent Storage.
[  OK  ] Started Update UTMP about System Reboot/Shutdown.
[  OK  ] Reached target System Initialization.
[  OK  ] Reached target Timers.
[  OK  ] Listening on D-Bus System Message Bus Socket.
[  OK  ] Reached target Sockets.
[  OK  ] Reached target Basic System.
         Starting Login Service...
         Starting Permit User Sessions...
         Starting D-Bus System Message Bus...
[  OK  ] Started D-Bus System Message Bus.
         Starting Cleanup of Temporary Directories...
[  OK  ] Started Cleanup of Temporary Directories.
[  OK  ] Started Permit User Sessions.
         Starting Console Getty...
[  OK  ] Started Console Getty.
[  OK  ] Reached target Login Prompts.
[  OK  ] Started Login Service.
[  OK  ] Reached target Multi-User System.
[  OK  ] Reached target Graphical Interface.

Fedora release 20 (Heisenbug)
Kernel 3.18.0-0.rc4.git0.1.fc22.x86_64 on an x86_64 (console)

mycontainer login: root

Now we have everything ready to play around with the container integration of systemd. Let's have a look at the first tool, machinectl. When run without parameters it shows a list of all locally running containers:

$ machinectl
MACHINE                          CONTAINER SERVICE
mycontainer                      container nspawn

1 machines listed.

The "status" subcommand shows details about the container:

$ machinectl status mycontainer
       Since: Mi 2014-11-12 16:47:19 CET; 51s ago
      Leader: 5374 (systemd)
     Service: nspawn; class container
        Root: /srv/mycontainer
          OS: Fedora 20 (Heisenbug)
        Unit: machine-mycontainer.scope
              ├─5374 /usr/lib/systemd/systemd
                │ └─5414 /bin/dbus-daemon --system --address=systemd: --nofork --nopidfile --systemd-act...
                │ └─5383 /usr/lib/systemd/systemd-journald
                │ └─5411 /usr/lib/systemd/systemd-logind
                  └─5416 /sbin/agetty --noclear -s console 115200 38400 9600

With this we see some interesting information about the container, including its control group tree (with processes), IP addresses and root directory.

The "login" subcommand gets us a new login shell in the container:

# machinectl login mycontainer
Connected to container mycontainer. Press ^] three times within 1s to exit session.

Fedora release 20 (Heisenbug)
Kernel 3.18.0-0.rc4.git0.1.fc22.x86_64 on an x86_64 (pts/0)

mycontainer login:

The "reboot" subcommand reboots the container:

# machinectl reboot mycontainer

The "poweroff" subcommand powers the container off:

# machinectl poweroff mycontainer

So much about the machinectl tool. The tool knows a couple of more commands, please check the man page for details. Note again that even though we use systemd-nspawn as container manager here the concepts apply to any container manager that implements the logic described here, including libvirt-lxc for example.

machinectl is not the only tool that is useful in conjunction with containers. Many of systemd's own tools have been updated to explicitly support containers too! Let's try this (after starting the container up again first, repeating the systemd-nspawn command from above.):

# hostnamectl -M mycontainer set-hostname "wuff"

This uses hostnamectl(1) on the local container and sets its hostname.

Similar, many other tools have been updated for connecting to local containers. Here's systemctl(1)'s -M switch in action:

# systemctl -M mycontainer
UNIT                                 LOAD   ACTIVE SUB       DESCRIPTION
-.mount                              loaded active mounted   /
dev-hugepages.mount                  loaded active mounted   Huge Pages File System
dev-mqueue.mount                     loaded active mounted   POSIX Message Queue File System
proc-sys-kernel-random-boot_id.mount loaded active mounted   /proc/sys/kernel/random/boot_id
[...]                     loaded active active    System Time Synchronized                        loaded active active    Timers
systemd-tmpfiles-clean.timer         loaded active waiting   Daily Cleanup of Temporary Directories

LOAD   = Reflects whether the unit definition was properly loaded.
ACTIVE = The high-level unit activation state, i.e. generalization of SUB.
SUB    = The low-level unit activation state, values depend on unit type.

49 loaded units listed. Pass --all to see loaded but inactive units, too.
To show all installed unit files use 'systemctl list-unit-files'.

As expected, this shows the list of active units on the specified container, not the host. (Output is shortened here, the blog story is already getting too long).

Let's use this to restart a service within our container:

# systemctl -M mycontainer restart systemd-resolved.service

systemctl has more container support though than just the -M switch. With the -r switch it shows the units running on the host, plus all units of all local, running containers:

# systemctl -r
UNIT                                        LOAD   ACTIVE SUB       DESCRIPTION
boot.automount                              loaded active waiting   EFI System Partition Automount
proc-sys-fs-binfmt_misc.automount           loaded active waiting   Arbitrary Executable File Formats File Syst
sys-devices-pci0000:00-0000:00:02.0-drm-card0-card0\x2dLVDS\x2d1-intel_backlight.device loaded active plugged   /sys/devices/pci0000:00/0000:00:02.0/drm/ca
[...]                                                                                       loaded active active    Timers
mandb.timer                                                                                         loaded active waiting   Daily man-db cache update
systemd-tmpfiles-clean.timer                                                                        loaded active waiting   Daily Cleanup of Temporary Directories
mycontainer:-.mount                                                                                 loaded active mounted   /
mycontainer:dev-hugepages.mount                                                                     loaded active mounted   Huge Pages File System
mycontainer:dev-mqueue.mount                                                                        loaded active mounted   POSIX Message Queue File System
[...]                                                                        loaded active active    System Time Synchronized                                                                           loaded active active    Timers
mycontainer:systemd-tmpfiles-clean.timer                                                            loaded active waiting   Daily Cleanup of Temporary Directories

LOAD   = Reflects whether the unit definition was properly loaded.
ACTIVE = The high-level unit activation state, i.e. generalization of SUB.
SUB    = The low-level unit activation state, values depend on unit type.

191 loaded units listed. Pass --all to see loaded but inactive units, too.
To show all installed unit files use 'systemctl list-unit-files'.

We can see here first the units of the host, then followed by the units of the one container we have currently running. The units of the containers are prefixed with the container name, and a colon (":"). (The output is shortened again for brevity's sake.)

The list-machines subcommand of systemctl shows a list of all running containers, inquiring the system managers within the containers about system state and health. More specifically it shows if containers are properly booted up, or if there are any failed services:

# systemctl list-machines
delta (host) running      0    0
mycontainer  running      0    0
miau         degraded     1    0
waldi        running      0    0

4 machines listed.

To make things more interesting we have started two more containers in parallel. One of them has a failed service, which results in the machine state to be degraded.

Let's have a look at journalctl(1)'s container support. It too supports -M to show the logs of a specific container:

# journalctl -M mycontainer -n 8
Nov 12 16:51:13 wuff systemd[1]: Starting Graphical Interface.
Nov 12 16:51:13 wuff systemd[1]: Reached target Graphical Interface.
Nov 12 16:51:13 wuff systemd[1]: Starting Update UTMP about System Runlevel Changes...
Nov 12 16:51:13 wuff systemd[1]: Started Stop Read-Ahead Data Collection 10s After Completed Startup.
Nov 12 16:51:13 wuff systemd[1]: Started Update UTMP about System Runlevel Changes.
Nov 12 16:51:13 wuff systemd[1]: Startup finished in 399ms.
Nov 12 16:51:13 wuff sshd[35]: Server listening on port 24.
Nov 12 16:51:13 wuff sshd[35]: Server listening on :: port 24.

However, it also supports -m to show the combined log stream of the host and all local containers:

# journalctl -m -e

(Let's skip the output here completely, I figure you can extrapolate how this looks.)

But it's not only systemd's own tools that understand container support these days, procps sports support for it, too:

# ps -eo pid,machine,args
 PID MACHINE                         COMMAND
   1 -                               /usr/lib/systemd/systemd --switched-root --system --deserialize 20
2915 -                               emacs contents/projects/
3403 -                               [kworker/u16:7]
3415 -                               [kworker/u16:9]
4501 -                               /usr/libexec/nm-vpnc-service
4519 -                               /usr/sbin/vpnc --non-inter --no-detach --pid-file /var/run/NetworkManager/ -
4749 -                               /usr/libexec/dconf-service
4980 -                               /usr/lib/systemd/systemd-resolved
5006 -                               /usr/lib64/firefox/firefox
5168 -                               [kworker/u16:0]
5192 -                               [kworker/u16:4]
5193 -                               [kworker/u16:5]
5497 -                               [kworker/u16:1]
5591 -                               [kworker/u16:8]
5711 -                               sudo -s
5715 -                               /bin/bash
5749 -                               /home/lennart/projects/systemd/systemd-nspawn -D /srv/mycontainer -b
5750 mycontainer                     /usr/lib/systemd/systemd
5799 mycontainer                     /usr/lib/systemd/systemd-journald
5862 mycontainer                     /usr/lib/systemd/systemd-logind
5863 mycontainer                     /bin/dbus-daemon --system --address=systemd: --nofork --nopidfile --systemd-activation
5868 mycontainer                     /sbin/agetty --noclear --keep-baud console 115200 38400 9600 vt102
5871 mycontainer                     /usr/sbin/sshd -D
6527 mycontainer                     /usr/lib/systemd/systemd-resolved

This shows a process list (shortened). The second column shows the container a process belongs to. All processes shown with "-" belong to the host itself.

But it doesn't stop there. The new "sd-bus" D-Bus client library we have been preparing in the systemd/kdbus context knows containers too. While you use sd_bus_open_system() to connect to your local host's system bus sd_bus_open_system_container() may be used to connect to the system bus of any local container, so that you can execute bus methods on it.

sd-login.h and machined's bus interface provide a number of APIs to add container support to other programs too. They support enumeration of containers as well as retrieving the machine name from a PID and similar.

systemd-networkd also has support for containers. When run inside a container it will by default run a DHCP client and IPv4LL on any veth network interface named host0 (this interface is special under the logic described here). When run on the host networkd will by default provide a DHCP server and IPv4LL on veth network interface named ve- followed by a container name.

Let's have a look at one last facet of systemd's container integration: the hook-up with the name service switch. Recent systemd versions contain a new NSS module nss-mymachines that make the names of all local containers resolvable via gethostbyname() and getaddrinfo(). This only applies to containers that run within their own network namespace. With the systemd-nspawn command shown above the the container shares the network configuration with the host however; hence let's restart the container, this time with a virtual veth network link between host and container:

# machinectl poweroff mycontainer
# systemd-nspawn -D /srv/mycontainer --network-veth -b

Now, (assuming that networkd is used in the container and outside) we can already ping the container using its name, due to the simple magic of nss-mymachines:

# ping mycontainer
PING mycontainer ( 56(84) bytes of data.
64 bytes from mycontainer ( icmp_seq=1 ttl=64 time=0.124 ms
64 bytes from mycontainer ( icmp_seq=2 ttl=64 time=0.078 ms

Of course, name resolution not only works with ping, it works with all other tools that use libc gethostbyname() or getaddrinfo() too, among them venerable ssh.

And this is pretty much all I want to cover for now. We briefly touched a variety of integration points, and there's a lot more still if you look closely. We are working on even more container integration all the time, so expect more new features in this area with every systemd release.

Note that the whole machine concept is actually not limited to containers, but covers VMs too to a certain degree. However, the integration is not as close, as access to a VM's internals is not as easy as for containers, as it usually requires a network transport instead of allowing direct syscall access.

Anyway, I hope this is useful. For further details, please have a look at the linked man pages and other documentation.

by Lennart Poettering at November 11, 2014 11:00 PM

Nothing Special


One of my mission companions would say that a lot. He threatened (jokingly) to fix people. He was Tongan and barely spoke English or Filipino but we had fun and got some good work done.

Regardless of that, my Presonus Firebox had been making a strange whining sound for a while. I started a session a few weeks ago to finally begin a new song but (as usual) didn't get very far before fatherly duty called and the session sat for at least 2 weeks or so. This happens as regularly as I record which is roughly every few weeks. I eventually passed through the studio to grab something out of our food storage in the next room and realized that the firebox was completely dark. "Strange," I thought so I went and tried to restart JACK. The firebox wheezed and whined and eventually the blue LED slowly lit up. "Not good," I thought (I usually think very tersely), but I had to get that food upstairs and get dinner on for the kids.

I didn't read too much into it at first since I was pretty busy. But when I came back to it after a few days, I tried it again with the wall power. It powered up more quickly but still not anything like the instant blue light it used to bring up and it was still very audibly whining during operation. I tried plugging the firewire cable into the other ports on the computer and the interface. I tried changing some jack settings and eventually came to the discovery that it was making this audible noise even when nothing was plugged into it except AC power, not even attached to the computer. It sounded like some communication noise I've heard before, like a uart running at 9600 baud or something, but I reaffirmed that it wasn't a good thing. I had noticed it making this noise quietly for the last few months but now it was very noticeable. Playing with my condenser mic a little showed that whatever had changed raised my noise floor significantly.

The firebox works just fine in Linux using the FFADO drivers. It's not feature complete since I can't do the hardware monitoring that I'm pretty sure the firebox is capable of, but it's plenty good for me and my one man band recording methods. It has clean preamps (relative to the internal sound card of my laptop) and is useable at whatever rates I need (usually just 24bit 44.1khz though). And finding a new audio interface that works on linux is no small task. It was especially painful to think of needing to replace it because I'm finally about to have enough money in the budget to buy my first studio monitors, and even just meeting another guy in some middle school parking lot to buy a replacement interface for $60 again would threaten putting off the monitors for some time more.

So with heavy heart I pulled it apart this morning. Actually I had already fixed a broken chair I'd been meaning to get to and a tape measure that I dropped off the roof while re-shingling a few months ago, so I was on a roll. But I pulled it apart without too much trouble and tried to see what was going on. Luckily the damage was fairly noticeable. The insulation on the wire that connects the headphone jack to the upper PCB had melted to the cap on the lower board.

Most of the info I could find about problems with the firebox had a cap completely blow with some charring etc. This seemed much less dramatic and I was concerned that this one slightly marred cap wasn't fully the problem. But it was the best I had to go off of.
The damaged capacitor, Notice the melted plastic and the top seems slightly bubbled

I had a Nicholsen PW(M) cap that was 470uF but it was 25V instead of the 10V that the Chang cap I was replacing. The PW series aren't audio grade but I think the Chang wasn't either since this was near the power section anyway. I was glad to be upgrading the rated voltage of the cap, but this meant the new one was much larger. I had to get creative with the placement to keep it out of the way of the headphone jack and not touch the chassis or other components.

The new capacitor in place. You can also see the slightly melted insulation on the middle white headphone jack wire.

 The soldering was fairly trivial. Wick the old solder, pull the part, solder in the new one. I put some electrical tape on the headphone jack wires to help prevent them getting further compromised. I got lucky because I had left one of the leads just a bit too long and the first time I plugged it in they were shorting to the chassis, so when I plugged it in I got no power light at all. In retrospect I was lucky it didn't blow up something, but it was very disappointing. I took it all apart trying to figure out what had gone wrong and ohmed out all the transistors I could find to see if any had shorted.

When that proved fruitless I plugged it in without the chassis and it worked! I then just added one screw at a time and tested if it still turned on. Next screw. Test. Etc. When I got to the front part of the chassis attached, thats when I realized I didn't have good clearance on that lead of the new cap. I trimmed it and put the front on. Test. SUCCESS! I continued doing this through the rest of the assembly to be safe but in the end I had it running perfectly silently, fully assembled, there on the workbench.

I think this is the first time I've had a complex electronic item, took it apart, and was able to fix it without a schematic. It felt so awesome! Fixing the house, the chair, my remote control helicopter motor... mechanical issues are easy to diagnose and fix. Electronics though take either detailed documentation and knowledge, or a little luck. So when it works, fix is very sweet.

I took it home and just as a test hooked up my condenser, cranked the gain and added a simple amplifier plugin for more gain. Silence. I am back to my original noise floor! From now on I think I'll shut down my computer between sessions and use the AC power instead of just bus power.

Now I just need to actually make a recording again.

by Spencer ( at November 11, 2014 12:57 PM

November 06, 2014


For The Love Of Dogs

I'm a dog lover.
When I say that, I don't mean that I have some teen girl relationship with dogs w
here I feel the need to collect them like porcelain dolls. I don't have a sweate
r with my dogs likeness lovingly stitched into it. I don't have a coffee cup with a witty quip about dogs. I don't even own anything that would indicate I have a dog other than the necessities of dog ownership, e.g., bowl, leash, brush, dog food storage bin.
What I mean by saying I'm a dog lover is that I think there is something in the relationship with a dog that can bring on a symbiosis of spirit. There is a raw connection with the animal that goes beyond words. We have co-evolved to have, use and love dogs as part of our family. When our rudimentary ancestors needed to survive cold winters and hunt game beyond the limits of their tools they turned to their dogs and vise verse the dogs looked to us for their provision. Even today looking into our primate relatives this connection lives on. This video shows baboons capturing feral dog puppies and raising them as part of their family to protect their group in African trash heaps. They lovingly groom them as part of their bond as one of the family.

I've had dogs my entire life. I love nothing more than taking my relationship with my dogs to a level where neither of us is ever in doubt as to what is needed from each other. We both enjoy doing things together and we feel no stress over being apart. It's not just me wanting to be confident in my dog I want him to be confident in with me. If you knew the dog I have now then you would know how enjoyable a perfectly behaved and loving dog can be. He is envied by just about everyone. Not just because of his calm demeanor or the fact that he almost never shows signs of stress or distrust, but also because he is big, fluffy and loveable. He treats everyone with the same affection as he shows me.

Can I take credit for all that my dog is? of course not! We are a partnership, I have a responsibility to be a good companion in equal measure to his. Dogs should not be chosen based on how cute you think they are alone. They should not be bred to have a certain look to them. Breeds that are nothing more than an intriguing experiment into humans abilities to push genetics to their limit, in my opinion, represent a complete failure in the humans role regarding the relationship with dogs.  I have a particular lifestyle and my dog should reflects that. Breeds should be chosen based on their ability to fit in and adapt to the lifestyle of my family not because I think they are the cutest. I recently watched a TED talk and what struck me first is that most of the dogs that have this "Separation Anxiety" are from breeds originally developed to be livestock guardian dogs. It is in their soul to protect their flock an
d in the absence of livestock you become their surrogate. You leaving for work means they have failed in being able to protect you and they are driven to compulsion by their genetics. I feel it's unfair to have these breeds outside of their breeding.

We once owned a very neurotic Weimaraner who I never really related to and wasn't able to train. In retrospect I can see that there was no real failing on his part, I can firmly put any failings in our relationship on myself. He was bred to be a hunting dog, specifically water foul and I, not being a hunter, didn't relate to his compulsion. When we took him to ponds I would at first laugh, then get annoyed and then get angry that all he wanted to do was swim and chase ducks and geese. At the time I don't think I understood the connection there since I wasn't very familiar with the breed. In retrospect I should have altered my life to include his instincts instead of avoiding ponds so I didn't have to deal with him not wanting to get out when I was ready. In his mind this might be his only chance at being truly happy and he would do anything to stay as long as possible. His world was dominated by a life he didn't fit into and people who didn't understand him. I'm sure there is a very deep allegory here to parents who have disabled children but I don't think I'm qualified to make it. Maybe someone else could comment on it.

Like most things in our modern world that make me crazy is I think we spend too much time forcing things to exist out of the environment they need to thrive. We do it with our livestock, we do it with our pets and we certainly do it with ourselves. In this case I would encourage everyone to pick breeds or mixes of breeds that fit our lifestyle and if we end up with a breed that isn't a great fit trying our hardest to accommodate them. I encourage this because when the relationship is right, it's one of the most rewarding experiences a human can have. There might be a few :"bad" dogs, but there are many more bad owners, MANY MORE, and more bad situations. Let's do our best to address all the issues, not just one.

by Daniel Worth ( at November 06, 2014 04:12 PM

November 05, 2014


How I'm So Damned Productive

This could prove to be an epic blog post so if it's a TLDR I understand, but if you've ever wondered what tools other people use to keep organized then this is the post for you!

This post is about all the tools I use to crush tons of data and keep productive without losing my mind.

Tool #1 - Google Calendar:

Everyone needs a calendar and I've been using Google's offering since it's beta. There are a number of reasons I've stuck with it over the years.
  1. Shared calendar's: I share my calendar with my wife and daughter, and they share theirs with me. Since we all use Android phones it makes it much easier to keep everyone in sync with such busy schedules.
  2. "Interesting Calendars": There are curated calendars that can be added allowing me to automatically keep up with holidays and sports teams. I love this feature and I never miss a Bronco game as a result.
  3. Inviting People to Events: I've used this for years to organize podcast schedules to make sure everyone is there to podcast at the right time.
  4. Integration with Other Google Services: I love "Google Now" and if it's in my Google Calendar it's in Google Now giving me reminders and if I've included and address it let's me pull up one handed navigation. Also, when adding addresses it integrates with Google Maps make setting appointments up to specific places much easier. The other handy integration is with contacts, if the contact has a birthday entry it shows up on the calendar.
  5. Like any other cloud service, being able to edit my calendar on any device I have in my hot little hands means I actually use it and keep it up to date.
Tips for getting the most out of a calendar:
  1.  Calendars aren't just for future events. Put important events on the calendar after they've happened so you can find it later with a simple search.
  2. Put reminders to do maintenance type items so you get a simple reminder to winterize the lawn mower, clean out the gutters, change the oil in your car, etc. This saves a lot of headache and is a simple way to make sure you do your less regular chores.
  3. Want to eat out less? Make a weekly meals calendar so you can keep track of what meals you planned for what day and you have a record of previous meals you've eaten to keep everyone from getting bored. With multiple people cooking in the house with crazy schedules this helps make sure everyone is eating healthy inexpensive meals instead of fast food on busy nights.

Tool #2 - Google Keep:

This is the most recent addition to my organizational repertoire and I've been making full use of it. It's basically Google's answer to Evernote, something I've never personally used. If some of these other tools are howitzers this tool is more of a scalpel. I use it as a staging area for things that need to be filed into other tools. It's main usefulness is for quick notes, check lists and lists like virtual sticky notes. Also, since it's a Google product it's synced with all my devices all the time helping make better use of my other organizational tools. I mostly use it like you would a note pad to jot quick notes down. Don't overuse it for detailed info or it gets overwhelming quick.

Tips of getting the most out of Keep:
  1. Great for meeting notes to jot down things you need to follow up on.
  2. You can set reminders on the desktop that will pop up on your phone or tablet.
  3. It's great for check lists.
  4. Archive done items so you can search them later but they don't show up in the main view.
  5. You can attach pictures to things to help remind you of what it is you need.

Tool #3 - and Greader:

I do tons of research from a large variety of web sources and keeping track of everything requires a powerful tool.....RSS. I was in the private beta on Google Reader and was heart broken when it closed down. offered importing of the OML file from Google Reader and it strived to emulate the original Google Reader interface. It looked a little touch and go for a while whether it was going to stick around but it seems to have stabilized and now offers premium memberships, $3 a month that I happily pay, that ensure it's long term success.

What is an RSS reader? It's a place that checks for updates to some of your favorite sites on the net and puts them all into one nice interface. Blogs, podcasts (although I use another tool for those), Craigslist searches, the list goes on and on and you can keep up to date on things by just adding the RSS feed URL into the Reader client and read it, archive it, tag it and share it all at your leisure, it's what the web promised to be. There seems to be waning interest in RSS but I assure you, if you invest a very small amount of time into it, it's a very rewarding experience. I won't provide a step by step guide to RSS but you can Google it and find plenty of great info on how to make use of it.

Also, TOR includes integration with another of my favorite tools "Pocket", see below. That makes it easier to save things you are going to want later.

Greader is the Android client that I use to actually read on. It is a pretty nice way to read my favorite sites all in a nice dark theme that lets me read after dark without making the wife too angry at me.

Tips for getting the most out of Theoldreader:
  1. If you visit a site more than once a year, find it's RSS feed and get it into the RSS Reader.
  2. Follow news sites, but use the "Mark Items Older Than a Week" or the "Older than a Day" tools to keep from getting overwhelmed by old news.
  3. Find funny things to follow to give you a relief from the stress of being so darn organized.
  4. In Greader use the Text to Speach(TTS) to turn long articles into books on tape.
  5. Learn to let old items go, if you haven't got to them in a month or two, mark it as read, move on and breath easier.

Tool #4 - Pocket(formerly Read It Later):

I've been a heavy user of bookmarks over the years and they fall short in a number of ways. The biggest is that they are managed in the old folder structure paradigm and that creates a problem for finding things that may have made sense to live in multiple locations. Also, links break over time and the data is lost with just a bookmark, unless of course you can find it on Pocket bests bookmarks for single web items. First it compliments TOR/Greader for sites you don't want all their stuff just a specific article but would like a nice easy to read layout with a dark theme. It has a nice browser plugin that gives a single place to click to add it to pocket for later consumption. It also includes a TTS engine for making long articles digestible on the go. Pocket has it's own Android App that is very robust and easy to use.

Tips for getting the most out of Pocket:
  1. Archive articles when you are done reading them.
  2. Use TTS on long articles.
  3. Use tags to sort items and make them easier to find later.
  4. Again, use a dark theme to keep the wife happy with late night reading.
  5. Consider Pocket premium, a bit pricey but worth it if you are crushing large amounts of research, for a permanent archive of important info and sources.

Tool #5 - Gmail:

 O.K., this isn't an organizational tool by itself, in fact I'd bet your inbox is a nightmare, but using some advanced tools inside Gmail it can be a way of keeping organized. I won't go into a ton of detail on these, you can Google if any catch your eye, but I'll list my tips for crushing the deluge of Email.

Tips for getting the most out of Gmail:
  1. Make heavy use of labels, they are a powerful tool.
  2. Use the "Filter Messages Like This" feature to automatically put labels on e-mails from sources.
  3. Archive things that have labels on them.
  4. Delete advertisements older than a day.
  5. Turn on all the "Tabs" in "Configure Inbox" and drag items in the wrong folder to the right one to teach Google where they go. This will help you divide an conquer e-mail.
  6. Turn on two factor authentication to make your email safer. Remember almost all your passwords can be reset with access to your email account. Keep it safe people!

Tool #6 -  BeyondPod:

 If you aren't listening to Podcasts then you are seriously missing out. Podcasts are to talk radio what .MP3s where to music. There is a podcast out there to meet any taste and more likely 1000s for every taste. I listen to massive amounts of podcasts, in fact I listen to them at 3x speed. Why? it helps me get through the huge amount of great shows I want to listen to. How? Beyondpod. It's a fantastic app and worth paying the nominal fee for the pro version. I've used it for years now, everyday, all day, and I can honestly say it's my favorite app.

Tips for getting the most out of Beyondpod:

  1. Organize your podcast from the start, the better organized the easier to find what you want.
  2. Setup an update schedule to download new Podcasts when on wifi at home. This saves your data and keeps you stocked up. I set mine to download while I sleep.
  3. Lock episodes you want to re-listen to so they don't get deleted.
  4. Crank up the speed to get more listening in, seriously there is so much great content out there.
  5. Have video Podcasts you don't really need to watch to enjoy? Use the "Play Video as Audio" feature to just listen to the audio track.
  6. Use a bluetooth headset so you can pause it on the headset instead of digging in a pocket for your phone. Also great for activities like running and riding a bike so your device can stay in a nice safe place instead of in your hand.
  7. Make your fist subscription my Podcast Alpha Geeks!

Tool #7 - Keypass:

There are scores of reasons to use a password keeper not least of which is security, but it also helps you be more productive. Instead of reusing insecure passwords that put you at risk of losing data, time and money, let the password keeper do the work so you don't have to. It will create a safe and secure password and store it with top notch encrypted security. Stop forgetting what crappy half effort password you used on a site by storing it somewhere safe and sound. It's very handy for seldom used but important accounts. Stop putting yourself at risk and wasting time resetting accounts because you can't remember a password that was insecure in the first place. Also, this is a free and open source tool!

Tips for getting the most out of Keypass:

  1. Use the Android App to keep your passwords with you everywhere you go.
  2. Use one great password to secure you database and let it be the only tough one you have to remember.
  3. Sync it with Dropbox (see below) to always have an up to date database.
  4. Don't be tempted to skip using it and throwing a crappy password at it, the more you use it the less of a pain it is, the safer you data is.
  5. Store credit card info in the database so you have the numbers in case your card gets stolen.
  6. Save you bike lock and combo locks in it so you don't forget it when you are taking a break from the gym.
  7. Save your code to a security system with instructions in the notes so the three or four times a year you go into work when no else is there you don't look like an idiot or a thief.

Tool #8 - Dropbox:

Stop messing around with thumb drives to get data around. Stop losing family photos when you lose your phone. Stop sending massive attachments in your emails. Using Dropbox will save you from worrying about computer crashes because all your data is synced to the cloud. Just remember to not sync sensitive data to it unless you've used trust no one encryption.

Tips for getting the most out of Dropbox:
  1. Set up accounts for everyone in the family so documents can be shared around. It helps with the older kids homework or if you, like me, only use the printer at work because your kids burn through ink like we used to go through crayons.
  2. Use selective sync to only sync certain folders to certain devices. I only sync my school folders to my school computer.
  3. Use the public folder to host simple static webpages and media for things like lessons plans for classes you teach.
  4. Turn on the automatic photo backup so you never lose those important family memories. Your kids will thank you when they are older.

Tool #9 - Pinterest:

This is my newest tool and I almost hate to say how handy it is. I find lots of interesting things to try and articles to read and it's pretty damn easy to organize it all for later consumption, plus the social part of it is well designed. It's also the easiest tool to share cool things with other people you know even if it's on another social media site. It's to stuff what facebook is to people.

Tips for getting the most out of Pinterest:
  1. It has the ability to pin things to different boards for a reason, use them.
  2. There are tons of keywords that aggregate pretty much anything you could be interested in use them to find cool things that fit your interest.
  3. Recipes might be one of the strongest features. You could learn to cook with just recipes on here. Pin the recipes to boards like, "Things to Cook" and after you've made them move them to "Things I loved" or delete them if you didn't like them. This makes the weekly groceries easier.

Tool #10 - Amazon Wishlists:

I know it sounds strange but if you are like me, don't use credit cards at all, you need to only buy things when funds are available and sometimes its hard to keep track of everything you've heard about and though you wanted to buy at some point. I stick to a strict weekly budget and this helps me find the things I want at a later time, even if I don't buy it on Amazon.

Tips for getting the most out of Amazon Wishlists:
  1. Make different lists for different interests and use them.
  2. Use it as a reading list for books you come across. I'd go broke if I just bought every book I want to read but if they are on my book wishlist I can find them later.
  3. Share the list with friends or family so you can actually get relevant Birthday and Christmas gifts.

Tool #11 - Bookmarks:

I used to use this as my main way of keeping track of things on the internet but as better tools have come along I try to stay away from them if I can, but they still have their place.

Tips for getting the most out of Bookmarks:
  1. Use Google Chrome's or Firefox's sync features to keep them up to date on all your devices and at your fingertips when you need them.
  2. Make heavy use of folders and nested folders.
  3. Do an annual purge, I use this as a staging area for other tools sometimes when I don't have a better place to put things but if I don't purge it gets overwhelming quick.

Tool #12 - Orgmode and Emacs:

This is my last but most useful tool for keeping organized. It's also has the steepest learning curve. It's not intuitive at all and requires some honest investment in learning to be useful. Once you get over the hump with it though it's staggering how powerful a tool it is. It's basically a text editor(emacs) with some tools for organizing things (Orgmode) but that doesn't really do it justice. It has time tracking, todo lists, agendas, calendars, tags, you can do in line spread sheets including calculations. Also, moving things around as things get more complicated is where I fell in love with it. At the start of projects things make sense in one order but as things progress things need shuffled around and the rigidity of other solutions mean that upkeep with the data is more work than it is useful. With Orgmode however, you can move things up and down, tuck them in sub-trees, ad data to them, sort them, mark them done, hide them and crush large amounts of data.

Tips for getting the most out of Orgmode:
  1.  Use Orgmode as the final destination for research so everything is available when you need it.
  2. Track your time on specific tasks to cover your butt or get paid for out of scope work.
  3. Keep record of the time and date of things like emails so you can back things up when needed. 
  4. Keep track of verbal agreements so you can follow them up with emails for backup if things get hairy.
  5. Put notes on projects you are researching, make lists of materials, make todo lists of each step and execute the hell out of things.
  6. Store data on things that give you that competitive edge.
  7. Export notes to html, put them in your Dropbox and share the link with your team to keep everyone's productivity high. I use this a lot and to Great Effect. I even do this with my school assignments for my students.
  8. Learn the markdown language so you can include images in the HTML export.

To wrap things up, productivity tools only work if you use them, and most of the time it just takes practice to actually make use of them. Don't use tools you see zero benefit in off the bat but invest the time to learn them if it can help. Each tool is a stepping stone to getting more done and being less stressed. Trust me.

    by Daniel Worth ( at November 05, 2014 07:36 AM