November 26, 2014

Arch Linux Pro Audio

Interview MOD : Arch based FX pedal!

After talking JazzyEagle about ArchAudio last month, we catch up with a recently Kickstarted project; the MOD! The MOD project brings the arch audio ecosystem to a hardware FX unit for use on stage.

Interview with MOD

What is the MOD project?

The MOD is a hardware audio plugin processor based on Arch Linux, JACK and the LV2 plugin standard. MOD devices are autonomous processing units that have an embedded ARM CPU running an Arch Linux based OS. Users can connect remotely to their MODs and assemble virtual pedalboards with the plugins. There is also a Social Network where users can exchange their pedalboards.

Editing a pedalboard using the HTML5 based interface

Awesome! So why did you choose Arch as the distro?

The choice of Arch Linux is based on a few key points. The assembly of the OS starting from a very minimal install and building the pieces on top of it based on features demand, using a very modular approach. The system philosophy is not targeted towards automation but to performance. Our system needs to be as lean possible, so easily customizing the install is necessary. The flexible and practical package management provides this ease to create and manage .tar.gz packages, and this is very valuable to the MOD.

Question: How can Arch developers get involved with MOD?

Both the plugins as the OS can have involvement from the community. All our code is open source and it is possible to run the MOD software in desktops machines. It is all hosted at  We have an SDK to create the HTML plugin interfaces so DSP coders can publish their plugins with beautiful and appealing graphic interfaces.

Cool! Thanks for talking to Where can interested readers find out more?

Our website has the details, theres a pre-order store online, and you can subscribe for email updates, twitter and facebook to keep up to date!

by harryhaaren at November 26, 2014 01:53 PM

November 25, 2014


OpenAV : Events Autumn 2014

In the past months, OpenAV has attended various events promoting open-source projects and collaboration. Since the LAC, we’ve attended the VLC Developer-Days, Science Hack Day Dublin, Open Developers Meetup Limerick, and the Startup Weekend Limerick. These events have given us fantastic experience in working with various new teams, gaining business experience, learning new skills in domains like video encoding, all while meeting fantastic people at… Read more →

by harry at November 25, 2014 06:51 PM

November 24, 2014

Linux Audio Announcements -

[LAA] Qtractor 0.6.4 - The Baryon Throne beta release!

From: Rui Nuno Capela <rncbc@...>
Subject: [LAA] Qtractor 0.6.4 - The Baryon Throne beta release!
Date: Nov 24, 7:48 pm 2014

Aw, snap!

Wait, there's no big deal (nor chromium's) cosmic (mis)alignment
being announced here now. Rest calm. Sorry to delude some of you :)

But, there's one (notable) leap on this tiny side and part of the
universe... (or is it a multiverse? move along...) What I really want to
tell is all about this happening and none else's freaking business:

Qtractor 0.6.4 (baryon throne beta) is released!

Release highlights:
* Punch-in/out over loop-recording/take modes (NEW)
* Latch/momentary MIDI Controllers toggle mode (NEW)
* JACK client/port pretty-name (metadata) support (NEW)
* Custom style and color themes (NEW)
* Mixer strip multi-row layout (NEW)
* Muted audio tracks monitoring on playback (FIX)
* Clip fade-in/out resize on time-stretch (FIX)

As for the clueless (as if there's any):

Qtractor is an audio/MIDI multi-track sequencer application written
in C++ with the Qt4 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.

Well, although this being yet another milestone--if one may call it
that way--it also makes it official (yes, deeply engraved in stone) and
definitive as a migration to Git can be, as for source-code control and
management (it's a dirty job I know, but someone has to do it, right?).
Nevermind. It's done.

Meanwhile, please, don't ever hesitate to ask whether any of the
above does affect you some way or another. Or maybe anything else, yay?
Indeed, the puzzled you feel, the better :)


Project page:


- source tarball:

- source package (openSUSE 13.2):

- binary packages (openSUSE 13.2):

- quick start guide & user manual (see also: the wiki):

- wiki (help wanted!):

Weblog (upstream support):

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

- Fixed some old loop-recording clip drawing glitches.
- Current assigned track/channel instrument definition names for MIDI
controllers, note keys, RPN and NRPN, are now in effect on the MIDI clip
editor drop-down lists, whether available.
- Clip/Take/Range... input dialog values are now properly sanitized as
long to prevent invalid take/folding ranges.
- Audio capture/export file type default now set to "wav".
- Extending punch-in/out over loop-recording/takes modes.
- Make audio tracks monitoring always flow while playback is rolling,
independently of their mute/solo state.
- Fixed undo/redo conversion of audio clip offsets under (automatic)
time-stretching eg. due on tempo changes. (ticket by Holger Marzen, thanks).
- Latch/momentary MIDI Controllers toggle mode introduced (a request by
AutoStatic aka. Jeremy Jongepier, thanks).
- JACK client/port p [message continues]

read more

November 24, 2014 08:00 PM

Qtractor 0.6.4 - The Baryon Throne beta release!

Aw, snap!

Wait, there's no big deal (nor chromium's) cosmic (mis)alignment being announced here now. Rest calm. Sorry to delude some of you :)

But, there's one (notable) leap on this tiny side and part of the universe... (or is it a multiverse? move along...) What I really want to tell is all about this happening and none else's freaking business:

Qtractor 0.6.4 (baryon throne beta) is released!

Release highlights:

  • Punch-in/out over loop-recording/take modes (NEW)
  • Latch/momentary MIDI Controllers toggle mode (NEW)
  • JACK client/port pretty-name (metadata) support (NEW)
  • Custom style and color themes (NEW)
  • Mixer strip multi-row layout (NEW)
  • Muted audio tracks monitoring on playback (FIX)
  • Clip fade-in/out resize on time-stretch (FIX)

As for the clueless (as if there's any):

Qtractor is an audio/MIDI multi-track sequencer application written in C++ with the Qt4 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.

Well, although this being yet another milestone--if one may call it that way--it also makes it official (yes, deeply engraved in stone) and definitive as a migration to Git can be, as for source-code control and management (it's a dirty job I know, but someone has to do it, right?). Nevermind. It's done.

Meanwhile, please, don't ever hesitate to ask whether any of the above does affect you some way or another. Or maybe anything else, yay? Indeed, the puzzled you feel, the better :)

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.


  • Fixed some old loop-recording clip drawing glitches.
  • Current assigned track/channel instrument definition names for MIDI controllers, note keys, RPN and NRPN, are now in effect on the MIDI clip editor drop-down lists, whether available.
  • Clip/Take/Range... input dialog values are now properly sanitized as long to prevent invalid take/folding ranges.
  • Audio capture/export file type default now set to "wav".
  • Extending punch-in/out over loop-recording/takes modes.
  • Make audio tracks monitoring always flow while playback is rolling, independently of their mute/solo state.
  • Fixed undo/redo conversion of audio clip offsets under (automatic) time-stretching eg. due on tempo changes. (ticket by Holger Marzen, thanks).
  • Latch/momentary MIDI Controllers toggle mode introduced (a request by AutoStatic aka. Jeremy Jongepier, thanks).
  • JACK client/port pretty-name (metadata) support is being seamlessly introduced. (EXPERIMENTAL)
  • Audio frame/MIDI time drift correction is now an option on View/Options.../MIDI/Playback/Enable MIDI queue time drift correction.
  • Transport auto-backward feature now honoring last position playback was started.
  • Introducing brand new application user preferences on View/Options.../Display/Options/Custom style and color themes (eg. "KXStudio", by Filipe Coelho aka. falkTX).
  • Mixer widget gets automatic multi-row strip layout.
  • Clip fade-in/out now follows time-stretch resizing, via shift/ctrl+click and drag one of its edges.
  • Fixed a typo causing FTBFS when VST plug-in support is explicitly disabled (./configure --disable-vst).

Enjoy && Have plenty of fun.

by rncbc at November 24, 2014 06:30 PM

Libre Music Production - Articles, Tutorials and News

November 21, 2014

Linux Audio Announcements -

[LAA] [LAU] [LAD] Guitarix 0.32.0 released

From: hermann meyer <brummer-@...>
Subject: [LAA] [LAU] [LAD] Guitarix 0.32.0 released
Date: Nov 21, 12:51 am 2014

This is a multi-part message in MIME format.
Content-Type: text/plain; charset=ISO-8859-1; format=flowed
Content-Transfer-Encoding: 7bit

The Guitarix developers proudly present

Guitarix release 0.32.0

For the uninitiated, Guitarix is a tube amplifier simulation for
jack (Linux), with an additional mono and a stereo effect rack.
Guitarix includes a large list of plugins[*] and support LADSPA / LV2
plugs as well.

The guitarix engine is designed for LIVE usage, and feature ultra fast,
glitch and click free, preset switching, full Midi and/or remote
controllable (Web UI not included in the distributed tar ball).

Here is the " Ultimate Guide to Getting Started With Guitarix

This release fix the bug #16 "empty effect menu with clear-skin option",
add new tuning scales (19- and 31-TET) to guitarix and Gxtuner.lv2,
add Midi Clock and Jack Transport support to guitarix and move a couple
of controllers from
unit:ms|hz to unit:bpm, so that they could easy synced with the Midi
Beat Clock.
and introduce a new LV2 plug:
* GxMultiBandReverb

Please refer to our project page for more information:

Download Site:


Please consider visiting our forum or leaving a message on


Content-Type: text/html; charset=ISO-8859-1
Content-Transfer-Encoding: 7bit

charset=ISO-8859-1" />

The Guitarix developers proudly present

Guitarix release 0.32.0

For the uninitiated, Guitarix is a tube amplifier simulation

jack (Linux), with an additional mono and a stereo effect

Guitarix includes a large list of plugins[*] and support LADSPA
/ LV2 plugs as well.

The guitarix engine is designed for LIVE usage, and feature
ultra fast, glitch and click free,  preset switching, full Midi
and/or remote controllable (Web UI not included in the
distributed tar ball).

Here is the "
rel="nofollow">Ultimate Guide to Getting Started With Guitarix

This release fix the bug #16 "empty effect menu with clear-skin

add new tuning scales (19- and 31-TET) to guitarix and

add Midi Clock and Jack Transport support to guitarix and move a
couple of controllers from

unit:ms|hz to unit:bpm, so that they could easy synced with the
Midi Beat Clock.

and introduce a new LV2 plug:

                * GxMultiBandReverb

Please refer to our project page for more information:

November 21, 2014 10:00 PM

Create Digital Music » open-source

ROLI, Makers of Seaboard Instrument, Just Bought The Leading C++ Audio Framework

Processed with VSCOcam with j6 preset

Here’s some important news that might impact you – even though you may never have heard of either the instrument maker or know anything about code libraries. Bear with us. But an experimental instrument builder and design shop just acquired the most popular framework used by audio developers, a set of free and open source gems.

The film explaining the announcement:

First, there’s ROLI. Now, to most of us in the music world, ROLI are the Dalston, London firm that make an alternative keyboard called the Seaboard – a sort of newer cousin to the Haken Continuum Fingerboard that uses foam that you press with your fingers to add expression and bend pitches. But ROLI wants you to think of them as a design shop focused on interaction. So they don’t just say “we’re going to go make weird instruments”; whether you buy the pitch or not, they say they want nothing less than to transform all human machine interaction.

And yes, there’s a film for that, too. (Those of you playing the startup drinking game, fair warning: the words “design” and “artisanal” appear in the opening moments, so you could wind up a bit unhealthy.)

ROLI isn’t a company forged in the mold of most music manufacturers. They’re most definitely a startup. They have an in-house chef and a Wellness Manager, even before they’re widely shipping their product. That’s in stark contrast to the steady growth rate of traditional music gear makers. (I’ve seen both Native Instruments and Ableton put up charts that show linear hiring over a period of many years. Many other makers were bootstrapped.) The difference: record US$12.8 million in round A funding. And as the Wall Street Journal noted at the time, that comes at a time when some big players (Roland) are seeing diminished sales.

With that additional funding, ROLI are being more aggressive. If it pays off, it could transform the industry. (And I’d say that’s true even – maybe especially if – they manage to use a musical instrument as a gateway to other non-musical markets.)

Processed with VSCOcam with se3 preset

So, they’re buying JUCE. JUCE is an enormous library that allows developers to easily build audio plug-ins (VST, VST3, AU, RTAS and AAX are supported), design user interfaces quickly with standard libraries, and handle audio tasks (MIDI, sound, and so on), networking, data, and other tasks with ease. A million lines of code and modular support for these features give those developers a robust toolkit of building blocks, saving them the chore of reinventing the wheel.

Just as importantly, the results can run across desktop and mobile platforms – OS X, Windows, Linux, iOS, and Android all work out of the box.

I couldn’t get solid stats in time for this story on how many people use JUCE, but it’s a lot. KORG, Pioneer, AKAI, and Arturia are just a few names associated with it. You almost certainly have used JUCE-powered software, whether you’re aware of it or not.

But ROLI aren’t just acquiring a nifty code toolkit for audio plug-in makers. JUCE’s capabilities cover a range of non-audio tasks, too, and include an innovative real-time C++ compiler. And they acquire not just the code, but its creator Julian Storer, who will become Head of Software Architecture for ROLI.

What does this mean for JUCE? Well, in the short term, it means more investment. Previously the work of Jules alone, a solitary genius of C++, JUCE will now have a team of people contributing, say ROLI. They will add staff to focus on developing the framework as Jules is named “Editor-in-Chief” of JUCE – a sort of project lead / curator for the tools. For that reason, it’s hard to see this as anything but good news for JUCE developers, for the time being. In fact, Jules is very clear about his ongoing role – and not much changes:

And for the foreseeable future, it’s still going to be me who either writes or approves every line of code that gets into the library. I’m hoping that within a couple of years we’ll have a team of brilliant coders who are all pumping out code that perfectly matches the quality and style of the JUCE codebase. But in the meantime, I’ll be guarding the repository with an iron fist, and nothing will be released until I’ve checked, cleaned and approved it myself. But even in the short-term, by having a team behind the scenes working on features, and with me acting as more of an “editor-in-chief” role to ensure that the code meets the required standard, we’ll be able to be a lot more productive without losing the consistency and style that is so important to JUCE’s success.

Read his full letter on the JUCE forum.

JUCE’s source is already open – most modules are covered by the GPL (v2 or v3, depending). You therefore pay only if you want to release closed-source code (or, given Apple’s restrictions, anything for iOS); commercial licenses are not expensive.

The murkier question is actually how this will evolve at ROLI. The word I heard was immediately “ecosystem.” In the Apple-centered tech world, it seems, everything needs to have an SDK – even new rubber keyboards – so ROLI may hope to please its investors with the move. And that makes some practical sense, too. In order to communicate with software instruments, the Seaboard needs to send high-resolution expression data; ROLI use System Exclusive MIDI. It’s now a no-brainer to wrap that directly into JUCE’s library in the hopes plug-in and software instrument makers bite and add support. What’s interesting about this is that it might skirt the usual chicken and egg problem – if adding compatibility is easy enough, instrument makers (always fans of curiosities anyway) may add compatibility before the Seaboard has a big installed base.

In fact, that in turn could be good for makers of other alternative instruments, too; ROLI are working on standardizing on methods for this kind of data.

Of course, that still depends on people liking the Seaboard instrument. And ROLI say their ambitions don’t stop at futuristic pianos. CEO/Founder Roland Lamb (that’s no relation to Roland the Japanese musical instrument company) paints a broader picture:

“At ROLI, our larger vision is to reshape interaction. To do that, we need to transform every technological link from where people create inputs, to where computers create outputs. That’s a tall order, but acquiring and investing in JUCE is our most significant step towards this challenging goal since we invented and developed the Seaboard.“

Now, I am frequently in public appearances making just this argument, that musical instrument interaction can lead to innovative design solutions in other areas. But in this case, I don’t know what it means. Whatever ROLI is working on beyond the Seaboard, we haven’t seen it. At least as far as JUCE, they’re building competency and assets that enable human/hardware communication in the software frameworks themselves. We’ll just have to see how that’s applied.

In coming weeks, I hope to look a little closer at how the Seaboard and other similar devices handle communication, and whether there’s a chance to make that area smarter for a variety of hardware. And I’ll also let you know what more we learn about ROLI and JUCE.

If you’re a developer, there are ongoing JUCE meetups planned, so you can check out the framework yourself or meet other existing users. These aren’t limited to London – Paris and Helsinki were recent tour stops, with Berlin (in Ableton HQ, no less) upcoming.

JUCE Meetup

JUCE site

JUCE Acquisition Press Release

The post ROLI, Makers of Seaboard Instrument, Just Bought The Leading C++ Audio Framework appeared first on Create Digital Music.

by Peter Kirn at November 21, 2014 05:07 PM


MOD and OpenAV talks (flashback)

In October, towards the end of the MOD kickstarter campaign, Gianfranco from the MOD project and Harry from OpenAV talked about the MOD at Trinity College Dublin and the University of Limerick. We showcased the MOD to the audience: who were generally blown away by its capabilities and also its build-quality!

Apart from the talks, we discussed details of building plugins, and OpenAV demo-ed some projects that have not been released yet… These discussions led to great ideas of integration for MOD and OpenAV plugins. The developers at OpenAV have a MOD Quadra, and we are currently writing and testing plugins on the hardware. Expect more posts about the MOD!

Cheers, -Harry

PS: Some pictures of the MOD demos in TCD and UL.



by harry at November 21, 2014 04:07 PM

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


New site online!


OpenAV has been relatively quiet the last few weeks: not for lack of things happening here though! This new site has been designed, and OpenAV has attended a lot of events to promote linux-audio and the OpenAV software.

Now that the new site is in place, expect to see regular updates of the status of OpenAV, and some changes in terms of how software will be released, financed, and shared with the community.

We live in exciting times! Cheers, -OpenAV

by harry at November 21, 2014 01:33 PM

Hackaday » digital audio hacks

Speaker Cabinet Boom Box Build

When you get that itch to build something, it’s difficult to stop unless you achieve a feeling of accomplishment. And that’s how it was with [Rohit’s] boombox build.

He started out with a failing stereo. He figured he could build a replacement himself that played digital media but his attempts at mating microcontrollers and SD cards was thwarted. His backup plan was to hit DX for a cheap player and he was not disappointed. The faceplate he found has slots for USB and SD card, 7-segment displays for feedback, and both buttons and a remote for control. But this little player is meant to feed an amplifier. Why buy one when you can build one?

[Rohit] chose ST Micro’s little AMP called the TDA2030 in a Pentawatt package (this name for a zig-zag in-line package is new to us). We couldn’t find stocked chips from the usual suspects but there are distributors with singles in the $3.50-5 range. [Rohit] tried running it without a heat sink and it gets hot fast! If anyone has opinions on this choice of chip (or alternatives) we’d love to hear them.

But we digress. With an amp taken care of he moved onto sourcing speakers. A bit of repair work on an upright set got them working again. The bulky speaker box has more than enough room for the amp and front-end, both of which are pretty tiny. The result is a standalone music player that he can be proud of having hacked it together himself.

Filed under: digital audio hacks

by Mike Szczys at November 21, 2014 09:01 AM

November 20, 2014

Create Digital Music » Linux

Bitwig Studio 1.1 Adds Lots of Details; Can It Escape Ableton’s Shadow?


Bitwig Studio has been quietly plugging along in development, adding loads of engineering improvements under the hood. Version 1.1 is the largest update yet.

Here’s the summary of the update:

Minus the marketing speak, the exhaustive changelog (here, for Mac):

It’s an impressively long list of enhancements in quantity, though most of the changes are fixes and enhanced hardware and plug-in compatibility. For instance, you can side-chain VSTs, and there are new options for routing multiband effects and multi-channel plug-ins.

The big enhancements:

  • More routing for audio and MIDI
  • VST multi-out sidechain support and multi-channel effect hosts
  • Updated controller API
  • New Audio Receiver, Note Receiver, Note MOD, De-Esser devices

And you can genuinely deactivate devices to save CPU, something Live lacks, as well as take advantage of “true latency compensation.” (Whatever that means – that will require some testing. Bitwig’s explanation of what makes their tech different is that it actually works. That sounds good.) Some other features play catch-up with Ableton Live – tap tempo and crossfader, modulation and timestretching. But it’s a welcome update.

And as we’ve tangled recently with Ableton Live’s spotty controller support and the weird gymnastics required to make controllers work, it’s worth scolding Ableton for not making their hardware integration work better. Bitwig, with a sliver of the development resources and very little incentive for hardware makers to add support, is quickly adding controller support simply because it’s easier to do. This could be a model for Ableton, particularly as its user base and the diversity of hardware for it continue to expand.

If you’re on desktop Linux (yes, I’m sure someone is out there), the choice is easy: Bitwig is a terrific, fun piece of software with lots of rather nice effects and instruments. It’s fast and ready to go out of the box. And there isn’t much else native on Linux that can say that (Renoise springs to mind, but it has a very different workflow).

The problem is, if you’re not on Linux, I still can’t work out a reason I’d recommend Bitwig Studio over other tools. And, of course, the elephant in the room is Ableton Live. I reviewed Bitwig Studio for Keyboard, and found plenty to like. But the problem was, Bitwig Studio has competition, and as I wrote for that magazine, to me it comes a bit too close to Live to be able to differentiate itself:

While Bitwig Studio improves upon Live’s editing functionality, it replicates even some of Live’s shortcomings: There’s no surround audio support, nor any track comping facility…

Compared to Ableton Live Standard, Bitwig Studio’s offerings are fairly comparable. But at that price, Ableton gives you 11GB of sound content, more complete plug-in support, more extensive routing, more controller compatibility, and video support.

Since writing that review, two of these has changed. Controller compatibility is a narrowing advantage for Ableton because of Bitwig’s superb scripting facility and aggressive hardware support. And routing MIDI between tracks has been fixed, which combined with the new modular devices, allows for more flexible routing in Bitwig than in Ableton in certain cases.

The problem is, if you want a change from Live, you likely want software that works differently (Cubase and the like for traditional DAWs, Maschine for drum machine workflows, Renoise for a tracker, and so on). If you want a Live-style workflow, you’re likely to choose Ableton Live.

You can read my whole review for Keyboard and see if you reach a different conclusion, though:

Bitwig Studio reviewed [Keyboard Magazine]

And as I’ve seen a handful of people start to use Bitwig, I’d be curious to hear from you: what was the deal maker that convinced you to switch? What is Bitwig offering you that rivals don’t?

The DAW market remains a competitive one, and it’s clear there’s always room for choice. Bitwig’s development pace at least continues moving forward. But I’ll keep repeating: I’d like to see this tool stray from its rivals.

And for me, the main thing is: once that review was done, I found myself returning to Ableton Live and finishing tracks, and not Bitwig Studio – even if I sometimes cursed Live’s shortcomings. Even if that is simply force of habit, it seems I’ll need more to kick that habit. And, unfortunately, you can’t judge software based on its forthcoming features.

Update: I’ve heard from some fairly vocal Bitwig users (well, I did ask). Some of them I can’t parse into specific feedback or use cases (“it’s just better” wasn’t what I was hoping for). But I have heard three themes, apart from Linux use, wheree, as I said, Bitwig Studio is a no-brainer:

1. Dynamic routing. Because routing is more flexible, and can operate dynamically, some of you are using Bitwig Studio as a kind of modular sound design environment. It seems to me this advantage would become more radical if Bitwig can ship their promised forthcoming open modular environment – then, it’s a whole different game, as that tool is integrated with the DAW rather than being grafted on top as with Max for Live. But I do see a use case here.

2. Workflow/usability with sessions. I found that the ability to open multiple projects at once and to have side-by-side session (clip) and arrangement views made less of an impact in my work than I expected. But to some of you, it’s important. Now, in my case, I otherwise found Bitwig’s UI more rigid than Live’s. They don’t look identical, though, and that becomes a matter of taste.

3. Performance. Live can be sluggish at certain tasks; Bitwig has a new from-scratch engine and operations like opening projects is definitely snappier.

Combine this with Bitwig Studio’s suite of effects and instruments – though it has to stack up against Live gems like Simpler, Operator, and physical modelling instruments, for instance. This wouldn’t convince me to switch, but at least it provides and insight into those who have. Keep the feedback coming.

The post Bitwig Studio 1.1 Adds Lots of Details; Can It Escape Ableton’s Shadow? appeared first on Create Digital Music.

by Peter Kirn at November 20, 2014 04:40 PM

Libre Music Production - Articles, Tutorials and News

Guitarix 0.32.0 released

The Guitarix developers have just announced the release of Guitarix version 0.32.0. For the uninitiated, Guitarix is a tube amplifier simulation for JACK, with an additional mono and a stereo effect rack. Guitarix includes a large list of plugins and also supports LADSPA/LV2 plugins.
This release fixes some bugs. It adds new tuning scales (19- and 31-TET) to guitarix and Gxtuner.lv2 and also includes a new LV2 plugin, GxMultiBandReverb.

by Conor at November 20, 2014 03:50 PM

Recent changes to blog

Guitarix 0.32.0 released

The Guitarix developers proudly present

Guitarix release 0.32.0

alternate text

For the uninitiated, Guitarix is a tube amplifier simulation for
jack (Linux), with an additional mono and a stereo effect rack.
Guitarix includes a large list of plugins[*] and support LADSPA / LV2 plugs as well.

The guitarix engine is designed for LIVE usage, and feature ultra fast, glitch and click free, preset switching, full Midi and/or remote controllable (Web UI not included in the distributed tar ball).

Here is the "Ultimate Guide to Getting Started With Guitarix"

This release fix the bug #16 "empty effect menu with clear-skin option",
add new tuning scales (19- and 31-TET) to guitarix and Gxtuner.lv2,
add Midi Clock and Jack Transport support to guitarix and move a couple of controllers from
unit:ms|hz to unit:bpm, so that they could easy synced with the Midi Beat Clock.
and introduce a new LV2 plug:
* GxMultiBandReverb

Please refer to our project page for more information:

Download Site:


Please consider visiting our forum or leaving a message on


by brummer at November 20, 2014 03:47 PM

November 19, 2014

Create Digital Music » open-source

Meet KORG’s New Sample Sequencing volca – And its SDK for Sampling


The KORG volca sample is here – and it’s more open than we thought.

We’ve seen KORG’s affordable, compact, battery-powered volca formula applied to synths (BASS and KEYS) and a drum machine (BEATS). I’m especially partial to the booming kick of the BASS, the sound of the KEYS (which despite the name also works as a bass synth), and the clever touch sequencing interface.

Well, now having teased the newest addition to the family, we’re learning about the details of the KORG sample. It’s not a sampler per se – there’s no mic or audio input – but what KORG calls a “sample sequencer.”

We’ll have a unit in to test soon, but my impression is that sample sequencing isn’t a bad thing at all. Sequencing has always been a strong suit for the volca, and here, it’s the main story. Every parameter of a sample is ready to step sequence, from the way the sample is sliced, to its playback speed and amplitude envelope, to pitch.

Additional features:

  • Reverse samples
  • Per-part reverb (ooh)
  • Active step / step jump (for editing steps)
  • “A frequency isolator, which has become a powerful tool in the creation of numerous electronic genres.” Or, um, to make that understandable, there are treble and bass analog filters.
  • Swing
  • Song mode – 16 patterns x 6 songs

That leaves only how to get samples into the volca sample, beyond the 100 samples already built in.

It has exactly the same complement of jacks on the top as the synth and drum machine volcas – sync signal in and out, MIDI in, headphone out, and … nothing else. So, instead, KORG wants you to use an iOS handheld to record samples first. You transfer them into the unit via one of the sync jacks. Initially, that came as a bit of a shock, and judging by comments, at least some of you readers didn’t like the decision much. Frankly, looking at the unit, it looks like like there just wasn’t room; KORG dedicated the jacks to their usual function and used up the whole panel on sampling and sequencing controls.


Since then, though, we’ve had two developments that might get your interest back.

First, we’ve seen the iOS app, and it looks really cool. Brace yourself for cute video of designer Tatsuya Takahashi’s kid!

Okay, so the transfer process is a bit of a pain, but cutting samples on the iPhone is convenient, since you can see what you’re doing. It also solves the problem of needing to have a mic handy.

Here’s the surprise second development: KORG is releasing a free SDK for talking to the volca sample:

Basically, the volca sample’s trick is to encode binary data as audio signal, in the same way dial-up modems once did. (The technique is QAM – quadrature amplitude modulation – in case you’re interested.) The SDK helps you encode that data yourself. The software gives you several features:

1. You can encode audio samples to transfer – individually or as an entire 16-step sequence.
2. You can manage samples on the sample (delete them individually or delete all of them).

The SDK and library is written in C, but that means it could be used just about anywhere. I expect an Android app from a volca lover will be one of the first applications. It doesn’t have to stop there, though. You could build interesting sample-generating desktop apps – the KORG site suggests possibilities:

“Auto-slice a song to generate a sample set?
Turn photos of patterns into sequences?
algorithmic sample music generator?
generate random sequence from quantum effects?”


And, oh yeah, you could even make your own sampling hardware with the library, though… if you’re savvy enough to do that, you might just go ahead and make your own sampling hardware.

Speaking of your own hardware, unfortunately there isn’t any decode capability, though I don’t see why someone couldn’t make their own. (QAM decoding is already something that’s widely available.)

What you get in the SDK source:

  • The “syro” library, the bit that does the encoding.
  • A project sample with examples, ready to build with gcc, clang, and Visual Studio 2010 or later.
  • Definitions for patterns.
  • Factory preset / reset data.

So, if someone wants to make a bare-bones sample project for the iOS SDK or Android SDK, for instance, let us know!

The whole project is covered under a BSD license, so highly permissive. Have a look, developers (or, um, Android users who aren’t developers, keep your fingers crossed, start buying beers and nice Christmas presents for your Android dev friends, whatever):

volca sample is shipping it seems in small quantities, but isn’t yet widely available. Stay tuned.


This is the heart of this beast – sequencing, sequencing, sequencing of … everything, actually, as the list below is identical to the list of sample parameters.

Parameters that can be used with Motion Sequence:
・ Start Point (Playback start location)
・ Length (Playback length)
・ Hi Cut (Cutoff frequency)
・ Speed (Playback speed)
・ Pitch EG Int (Pitch EG depth)
・ Pitch EG Attack (Pitch EG attack time)
・ Pitch EG Decay (Pitch EG Decay time)
・ Amp Level
・ Pan
・ Amp EG Attack (Amp EG Attack time)
・ Amp EG Decay (Amp EG Decay time)

And full specs:

100 sample slots (you can overwrite these)
4 MB (65 seconds) sample memory total (of course, divided across those 100 slots)
31.25 kHZ, 16 bit
Digital Reverb
Analogue Isolator
10 parts, 16 steps
Sync In (3.5mm monaural mini jack, Maximum input level: 20V)
Sync Out(3.5mm monaural mini jack, Maximum Output level: 5V)
10 hour estimated battery life on 6 AA batteries or optional 9V AC adapter
372 g / 13.12 oz. (Excluding batteries)
193 × 115 ×45 mm / 7.60” x 4.53” x 1.77”

The post Meet KORG’s New Sample Sequencing volca – And its SDK for Sampling appeared first on Create Digital Music.

by Peter Kirn at November 19, 2014 11:24 AM

Hackaday » digital audio hacks

‘Nutclough’ Circuit Board Design is Stylishly Amplified

Though there is nothing wrong with the raw functionality of a plain rectangular PCB, boards that work an edge of aesthetic flare into their layout leave a lasting impression on those who see them. This is the philosophy of circuit artist [Saar Drimer] of Boldport, and the reason why he was commissioned by Calrec Audio to create the look for their anniversary edition amplifier kit. We’ve seen project’s by [Saar] before and this ‘Nutclough18’ amplifier is another great example of his artistic handy work.

nutclough2For the special occasion of their 50th anniversary, Calrec Audio contacted [Saar] requesting he create something a bit more enticing than their standard rectangular design from previous years. With their schematic as a starting point, [Saar] used cardboard to mock-up a few of his ideas in order to get a feel for the placement of the components. Several renditions later, [Saar] decided to implement the exact proportions of the company’s iconic Apollo desk into the heart of the design as an added nod back to the company itself. In the negative space between the lines of the Apollo desk there is a small perforated piece depicting the mill where the Calrec offices are located. The image of the mill makes use of different combinations of copper, silk and solder mask either absent or present to create shading and depth as the light passes through the board. This small piece that would have otherwise been removed as scrap can be snapped off from the body of the PCB and used as a commemorative keychain.

With the battery and speaker mounted behind the completed circuit board, [Saar’s] design succeeds in being a unique memento with a stylish appeal. There is a complete case study with detailed documentation on the Nutclough from cardboard to product on the Boldport website. Here you can also see some other examples of their gorgeous circuit art, or checkout their opensource software to help in designing your own alternative PCBs.

Filed under: digital audio hacks

by Sarah Petkus at November 19, 2014 03:01 AM

November 18, 2014

This old donkey's learning new languages...

pretty slowly...

that is to say we're (gosh! I mean) I am (one has to be honest, ain't we? never mind, I say), moving all our (dang, my) projects source code control to Git.

Yeah, finally. Never is too late, somehow.

And the time is now, or is it?

Anyway, in the meanwhile, the official Subversion (SVN) repositories are moving no matter what,

the old paths,

are from this moment now being migrated to:

and that's it.

Or in some old dead and wrong latin: ego dixit*, whatever ;)

nuff said.

* ps. the ego particle is the wrong one: in (old) latin, verbs don't get pronouns pre-pended, whatever again x)

[UPDATE:] the new respective Git repositories will be from now on referred as follows:

pps. regarding post caption: it's a literal translation to an old saying around here (pt_PT)--many should reckon it vaguely related to old dogs and new tricks ;)

by rncbc at November 18, 2014 06:30 PM

Create Digital Music » open-source

Hack Biology, Body, and Music: Open Call for MusicMakers Hacklab


For the past two winters, CDM has joined with Berlin’s CTM Festival to invite musical participants to grow beyond themselves. Working in freshly-composed collaborations, they’ve built new performances in a matter of days, then presented them to the world – as of last year, in a public, live show.

This year, they will work even more deeply inside themselves, finding the interfaces between body and music, biology and sound.

And that means we’re inviting everyone from choreographers to neuroscientists to apply, as much as musicians and code makers. Playing with the CTM theme of “Un Tune,” the project will this year encourage participants to imagine biology as sonic system, sound in its bodily effects, and otherwise connect embodiment to physical reality.

Joining me is Baja California-born Leslie Garcia, a terrific sound artist and maker who has already gone from participating in last year’s lab to organizing her own in her native Mexico. You can glimpse her below looking like a space sorceress of some kind, and hear the collaborative work she made last winter.

The 2014 hacklab's output, all wired up for the performance. Photo: CTM Festival.

The 2014 hacklab’s output, all wired up for the performance. Photo: CTM Festival.

We don’t know what people will propose or what meaning they will find out of that theme, but it might include stuff like this:

  • Human sensors (Galvanic Skin Response, EKG, EEG, eye movement, blood pressure, resporation and mechanomyogram or MMG)
  • Biofeedback systems
  • Movement sensors
  • Electrical stimulation
  • Aural and optical stimulation
  • Data sonification
  • Novel physical controllers
  • Dance performance, breathing techniques, and other physical practices

Or as CTM puts it, they will navigate “the spectrum between bio-acoustics, field recordings, ambient, flicker, brainwave entrainment, binaural beats, biofeedback, psychoacoustics, neo-psychedelia, hypnotic repetition, noise, and sub-bass vibrations” to both address and disturb the body.

And what I do know is, the most effective work will come out of new collaborations, new unexpected partnerships across fields – because that’s been my consistent experience with hacklabs past, as with the spatial sound project we did last month in Amsterdam or the CTM collaboration 2014, which I’ll document a little later this month.

Leslie is a great example of that. She initiated a collaboration with Stefano Testa at the hacklab in January/February. They produced, in a few short days, “Symphony for Small Machine” – exactly the sort of irreverent project we hoped would spring out of the week. Have a look:

And check out lots of other work talking to plants and bacteria and harnessing free and open source software:


Apply to this year’s open call:

December 12 is the deadline – yep, I know what a big part of my Christmas season will be about this year, and I couldn’t be more pleased.

And hope to see some of you in Berlin.

Follow the MusicMakers project on Facebook – I’ve been lax about updating this page, but will do so again!

The post Hack Biology, Body, and Music: Open Call for MusicMakers Hacklab appeared first on Create Digital Music.

by Peter Kirn at November 18, 2014 02:46 PM

November 17, 2014

Scores of Beauty

Restoring Deleted LilyPond Files

There are plenty of opportunities to delete important files, and even cases where you deliberately do it and only some time later notice that it was a stupid mistake. However, if you are using version control you’re lucky because that doesn’t make you worry at all. No need to hope that some undelete tool can be applied in time before something else irreversibly overwrites the bytes on disk etc.

Well, this is neither new nor specific to music editing, but I thought it a good idea to write a short post about it anyway. It will increase the chance that someone involved in music stumbles over the information, and it is yet another spotlight on the potential of versioned workflows for music editing.


In a previous post I explained that in our crowd engraving challenge to collaboratively engrave a huge orchestral score we delete files for segments of the music where instruments actually play nothing. Going through a part deleting such files makes you feel good because it’s the fastest way to proceed the “completion status” of our status reports. But I have to admit that it’s also a quite error-prone process where you can easily do too much and delete files which you shouldn’t. For example there are numerous segments that only contain a finishing note of a phrase, after which the instrument disappears in frenched (suppressed) staves. It’s easy to overlook that fragment … The next person who is then working on that part sill stumble over it and wonder why there is no empty segment template in which to enter the music.

Fortunately it is dead easy to restore that file, no matter how much work has been done in the meantime. Actually this involves only two steps.

Identifying Where the File Has Been Deleted

git log has plenty of options that you can use to start trying to pin down the problem. However, the seemingly natural approach won’t work:

.../das-trunkne-lied$ git log parts/clarinetI/01.ily
fatal: ambiguous argument 'parts/clarinetI/01.ily': unknown revision or path not in the working tree.
Use '--' to separate paths from revisions

Well, it’s somewhat logical that you cannot retrieve the history of something that isn’t there anymore, isn’t it? But Git wouldn’t be Git if it wouldn’t assist you gracefully with such trivial tasks. And actually it tells you immediately what to do: use --. This will tell LilyPond that yes, it is a file you are looking for and asks it to look in its history if there isn’t such a file in the current working tree. You can even tell Git to return only the commit that deleted the file:

.../das-trunkne-lied$ git log --diff-filter=D -- parts/clarinetI/01.ily
commit 50e62d87cf2dc3e1b0c39812f0b001d85e388712
Author: Urs Liska <>
Date:   Tue Sep 30 14:19:15 2014 +0200
    clarinetI: Remove empty segments

Well, oops, it was myself. Good that it’s me who noticed ;-)

OK, now we have identified the commit where the file was deleted, but what next? Basically we need to find the commit that immediately precedes that one because that is the last commit where the interesting file had been present, so it also represents the file’s last state before deletion. To do this we first modify the previous request to only show the commit hash:

.../das-trunkne-lied$ git log --pretty=format:%H --diff-filter=D -- parts/clarinetI/01.ily

Using the $(...) notation we will now retrieve the Git log from that commit backwards, restricting it to the previous commit:

/das-trunkne-lied$ git log -1 --pretty=format:%H $(git log --pretty=format:%H --diff-filter=D -- parts/clarinetI/01.ily)~1

What does this do?
Well, first we retrieve (as above) the commit hash deleting the file. This is enclosed in $(...) and used as input to yet another git command. Actually it’s the same git log command with two modifications: The first option is -1, restricting the output to just one commit while the ~1 at the end of the command tells Git to use “one commit before” the one we retrieved from inside the $(). So eventually our call returns the commit ID of the last commit where our file was present.

Restoring the File

Restoring the file is surprisingly simple:

.../das-trunkne-lied$ git checkout 8da631a9d92129479867a2c876bbdd9fe1ccfbe0 parts/clarinetI/01.ily
.../das-trunkne-lied$ git status
# On branch staging
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#   new file:   parts/clarinetI/01.ily

Why on earth does this work, isn’t git checkout used for switching between branches? Well, yes, but not exclusively. According the man page git checkout “Updates files in the working tree to match the version in the index or the specified tree”. When you use it for switching branches this is actually what it does. But you can also use it to “update” any file in the working tree to any state that can be referenced by a commit, branch or tag. So what we did was update parts/clarinetI/01.ily to the last state of the repository that contained that file, effectively restoring it from the Git history.

Now the file is present in the working tree and staged, so we can simply commit it and have it ready for music entry. I won’t do this now because the file I used for this example has actually been deleted correctly and I don’t want it to be restored. So I simply do what Git suggest: git reset HEAD parts/clarinetI/01.ily and then delete it from disk. This last exercise can be taken as yet another example for how easy your life can be with version control when you don’t have to worry about messing up your working directory through processes such as deleting or restoring arbitrary files.


Maybe this looks overly complicated and even daunting to someone not very familiar with Git. But basically you can work your way towards such a solution by building it step by step. There are many solutions out there that give you parts of the solution from which you can work your way onwards.

If we’d expect to have this problem regularly we could even go one step further and don’t call that last git checkout command manually but feed it with the output of the previously developed commands. But I think that would be overkill – because then we’d run into the 80/20 rule saying that the last 20% of a programming task require 80% of the time. I wouldn’t feel pretty safe having such a nested command that would try to restore a file with one call of, say, git-restore parts/clarinetI/01.ily without implementing quite some safety infrastructure.

by Urs Liska at November 17, 2014 06:12 PM

Libre Music Production - Articles, Tutorials and News

Non Mixer, now with LV2 support!

falkTX from KXStudio has just added LV2 support to Non Mixer. This is not upstream at the moment but is available in the KXStudio repositories. This will hopefully be accepted upstream and become part of Non Mixer. In the meantime, you can try out the LV2 supported version if you are using KXStudio by simply updating your system. 

by Conor at November 17, 2014 02:07 PM

November 14, 2014


Email issues (now resolved)

For about a day from 15:40 GMT on November 13th, all outbound email from was being rejected by our outbound email server. The time on had drifted more than 5 minutes from the email server's own time. I have corrected the time and installed an NTP client to ensure that this does not happen again.

If you were expecting email from in connection with a new account, attempt to reset your password and you will get a new email.

If you were expecting email from in connection with a download, please contact me ( and I'll get you the information you need.

Apologies for the problems.

read more

by paul at November 14, 2014 06:07 PM

November 13, 2014

Create Digital Music » Linux

Lemur is Now on Android, Supports Cabled Connections; You Want This Touch App


Before there even was an iPad or iPhone, there was Lemur. The touch-based controller device was theoretically the first-ever consumer multi-touch hardware. Early adopters connected the pricey smart display via Ethernet to a computer, and wowed friends with flying faders and bouncing balls and new ways of doing everything from manipulating spatial audio to playing instruments.

Then, the iPad arrived, and Lemur had a new life as an iOS-only app. For many of us, it’s alone reason enough to own an Apple tablet.

But Apple tablets are pricey. Android tablets are cheap. And Android tablets are increasingly available in more sizes. So, maybe you want to run Lemur on Android. Maybe it’s your only tablet. Or maybe you’re just worried that now your live performance set depends on an iPad mini, and if it dies, you’re out hundreds more – so Android is an appealing backup.

Well, now, Lemur has come to Android. It wasn’t easy; it required lots of additional testing because of the variety of devices out there and weird peculiarities of making Android development work properly. (Disclosure: I was one of Lemur’s testers, and was gratified when it suddenly started working on my Nexus 7, which is a fairly excellent low-cost device.)

But now it’s here. And it’s fantastic. Nick from Liine came to our monthly mobile music app meetup in Berlin and showed us just how easy it is to code your own custom objects using the canvas – more on that soon. But combine that with a stable app for hosting your own creations, and Lemur is simply indispensable. It’s US$24.99 on the Google Play store.

Oh, and one more thing: wires.

Yes, sure, part of the appeal of tablets is wireless control. That allows you to walk around a performance venue, for instance, whilst controlling sounds and mixing. But in live situations, it sure is nice to avoid wifi connection problems and depend on a conventional wire. On both Android and iOS, this requires a special driver – at least if you want to connect directly via USB. But there’s already a free and open source Mac driver for Android, and it works really nicely with Lemur:

I am absolutely going to start carrying both my Nexus 7 and my iPad mini – I now never have to worry that one tablet will die or the iPad WiFi will decide to stop working int he middle of a show. I might even put them in different bags. You know – redundancy. And for Android lovers, this is great news. (They’ve been getting a handful of excellent apps lately, which, while nowhere near the iOS ecosystem, still mean you can get a lot of use out of an Android tablet. But that’s a story for another day.)

More on Lemur:


And grab it from the Google Play store:

Lemur @ Google Play

The post Lemur is Now on Android, Supports Cabled Connections; You Want This Touch App appeared first on Create Digital Music.

by Peter Kirn at November 13, 2014 02:01 PM

Linux Audio Announcements -

[LAA] AV Linux 6.0.4 'Diehard' Released!

From: MGV-AV Linux <info@...>
Subject: [LAA] AV Linux 6.0.4 'Diehard' Released!
Date: Nov 13, 12:55 pm 2014

Hello fellow Linux Audio peeps!

Apologies for this slightly delayed announcement, I wanted to sort out
some server issues before posting this ...

AV Linux 6.0.4 is released... before I get to the good stuff I want to
take a brief moment to say how thrilling it was to meet so many of the
luminaries in the Linux Audio universe at LAC 2014. It was truly the
experience of a lifetime and it is so great to remember your faces when
your various projects and release announcements come through on this
mailing list... AV Linux is merely a frame for your masterpieces and the
quality and depth of your art continues to amaze and inspire!

With sincere thanks, Glen MacArthur - AV Linux Maintainer

OK, on with it then

Full release announcement here:

Changelog from AV Linux 6.0.3-6.0.4:


- Updated Ardour3 builds to a special preview 3.5-3368 to prevent possible
MIDI/Audio data loss (thanks Paul Davis and Robin Gareus!)
- Reverted JACK 0.124.1 utility scripts to utilize A2JMIDID because
'alsa_midi' doesn't hotplug when new MIDI hardware is plugged in...
- Removed 'broadcom-sta-common' and it's blacklist file to facilitate more
Broadcom devices to work OOTB
- Added menu button to reload XFWM in 'Settings' Menu in the rare event it
crashes on login
- Disabled default Auto-mounting of HDD Partitions in a Live Session
(thanks Zensub!)
- Addition of Squeeze LTS Repositories for security updates including
patched BASH for the 'shellshock' bug
- Installer no longer offers non-English locales since they seem to be
broken, however non-English keyboards can still be set up.
- Replaced Iceweasel with Firefox and added 'Ubuntuzilla' repos for an
up-to-date browser option..


- Updated to 3.12..19 lowlatency PAE default Kernel ( Thanks Trulan Martin!)
**An optional full RT Preempt Kernel is provided but is not compatible
with proprietary nVidia/Ati Video Drivers**
- Updated Harrison Mixbus Demo to version 2.5 including new LV2 Plugins
bundled systemwide to /usr/lib/lv2 (Thanks Ben Loftis!)
- Updated Adobe Flash Browser plugin for security fixes
- Updated AmSynth to 1.5.1 (Thanks Nick Dowell!)
- Updated Guitarix to 0.31(Thanks Hermann Meyer!)
- Updated OpenAV ArtyFX LV2 Plugins to 1.2 (thanks Harry for OpenAV updates!)
- Updated Luppp to 1.0.1
- Updated QmidiArp to 0.6.1
- Updated Qtractor to 0.6.3 (Thanks to Rui for all new Q-stuff below!)
- Updated Qjackctl to 0.3.12
- Updated Qmidinet to 0.2.0
- Updated VeeOne LV2 Plugins to 0.5.1
- Updated Carla Plugin Host to 2.0beta3b plus new VST Plugin (Thanks falkTX!)
- Updated LMMS to 1.0.95 + Carla Plugin host support... yep, LV2 synths in
LMMS! (Thanks diizy and falkTX!)
- Updated Drumgizmo LV2 to 0.9.6 (Thanks you wild and crazy Danes!)
- Updated LV2 Stack to most recent releases (Thanks drobilla!)
- Updated Xjadeo to 0.8.0 binary (Thanks Robin Gareus!)
- Updated HarVid binaries to 0.7.5 (Thanks Robin Gareus!)
- Updated Renoise Demo to 3.0.0
- Updated Pianoteq Demo to 5.1.1
- Updated Patchage to 1.0.0 (Thanks drobilla!)
- Updated Yoshimi to 1.2.4 (Thanks Will Godfrey!) *note as always banks
are in /usr/local/share/yoshimi
- Updated FFADO to 2.2.1
- Updated GCC and G++ to 4.7
- Updated libgtk2.0 from 2.20 to 2.24 to hopefully prolong ability to
compile GTK2 apps
- Updated Cinelerra-CV to recent GIT CVA build ...MAJOR IMPROVEMENTS!
(Thanks Paolo Rampino!)
- Updated entire LinuxSampler stack to recent SVN (Thanks rockhopper!)
- Udated LiVES Video Editor to 2.2.6 (Thanks salsaman!)
- Updated DISTRHO Plugins (many new improvements/additions... Thanks falkTX!)
- Upda [message continues]

read more

November 13, 2014 01:00 PM

Libre Music Production - Articles, Tutorials and News

Caps plugins, version 0.9.24 released

The popular LADSPA plugin suite has just seen a new release, version 0.9.24. This release includes "a number of bug fixes and improvements as well as changes intended to make it more suitable for low-power systems."
There is also a new/resurrected plugin, CabinetIII, which implements a "simplistic linear emulation of several guitar amplifier loudspeaker cabinets with reduced computational complexity".

by Conor at November 13, 2014 08:42 AM

November 12, 2014

Hackaday » digital audio hacks

Protocol Snooping Digital Audio

More and more clubs are going digital. When you go out to hear a band, they’re plugging into an ADC (analog-to-digital converter) box on stage, and the digitized audio data is transmitted to the mixing console over Ethernet. This saves the venue having to run many audio cables over long distances, but it’s a lot harder to hack on. So [Michael] trained popular network analysis tools on his ProCo Momentum gear to see just what the data looks like.

[Michael]’s writeup of the process is a little sparse, but he name-drops all the components you’d need to get the job done. First, he simply looks at the raw data using Wireshark. Once he figured out how the eight channels were split up, he used the command-line version (tshark) and a standard Unix command-line tool (cut) to pull the data apart. Now he’s got a text representation for eight channels of audio data.

Using xxd to convert the data from text to binary, he then played it using sox to see what it sounded like. No dice, yet. After a bit more trial and error, he realized that the data was unsigned, big-endian integers.  He tried again, and everything sounded good. Success!

While this is not a complete reverse-engineering tutorial like this one, we think that it hits the high points: using a bunch of the right tools and some good hunches to figure out an obscure protocol.

Filed under: digital audio hacks, Network Hacks

by Elliot Williams at November 12, 2014 09:01 PM

Libre Music Production - Articles, Tutorials and News

Modular set ups, concepts and practices, using Non Session Manager

What is Session Management?

Session management is used to solve the problems involved in managing modular set ups. Ultimately, it allows you to reopen multiple programs, their session files and instantly recall all connections between them.

by Conor at November 12, 2014 09:16 AM

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

Hackaday » digital audio hacks

Teensys and Old Synth Chips, Together At Last

The ancient computers of yesteryear had hardware that’s hard to conceive of today; who would want a synthesizer on a chip when every computer made in the last 15 years has enough horsepower to synthesize sounds in software and output everything with CD quality audio? [Brian Peters] loves these old synth chips and decided to make them all work with a modern microcontroller.

Every major sound chip from the 80s is included in this roundup. The Commodore SID is there with a chip that includes working filters. The SN76489, the sound chip from the TI99 and BBC Micro are there, as is the TIA from the Atari consoles. Also featured is the Atari POKEY, found in the 8-bit Atari computers. The POKEY isn’t as popular as the SID, but it should be.

[Brian] connected all these chips up with Teensy 2.0 microcontrollers, and with the right software, was able to control these via MIDI. It’s a great way to listen to chiptunes the way they’re meant to be heard. You can check out some sound samples in the videos below.

Thanks [Wybren] for the tip.

Filed under: classic hacks, digital audio hacks

by Brian Benchoff at November 11, 2014 12:00 AM

November 10, 2014

Create Digital Music » open-source

Reviews Weigh in on Our MeeBlip anode Synth; Here’s What They Said


MeeBlip anode, our ready-to-play bass synth with an analog filter, is now shipping and in dealers worldwide. We knew we wanted to make something that was accessible to those new to hardware synths, but had enough personality to surprise advanced users, too – even in a small box, for US$139.95 list.

And we also now know what the critics think.

It’s always easy to explain what you wanted a creation to be. It’s a different, if exciting, experience when you read someone else’s take on what resulted. But that makes me all the more pleased to share a round-up of reviews of the anode, reviews that we’ve found exceptionally thoughtful and thorough, that connect to what we were trying to do.

If you like what you read, anode is on sale now, including fine dealers worldwide.


Keyboard Magazine gave MeeBlip anode its Key Buy award (our second, following the first-generation MeeBlip), saying: “after a day in the studio it becomes clear that nothing else sounds like it.”

MeeBlip Anode reviewed [Keyboard]


Resident Advisor recommended the anode to first-time synthesists and enthusiasts alike, and gave the synth high marks for having a unique sound:

“The Anode doesn’t sound like a Volca … It’s fatter and nastier, and it also feels like more of a staple. It has a grittier, arguably more analogue character than anything in its price range, and it’s simple yet proficient.”

RA Reviews: MeeBlip anode [Resident Advisor]


MusicRadar (or Future Music in print) reviewed anode, writing “If you’re itching to get your hands on some physical knobs and make a few filthy sounds, the anode is a fantastic buy.”

“The filter’s unique selling point is its phat, filthy sound, and MeeBlip have pulled a blinder in this department”

Reviews: MeeBlip anode [MusicRadar / Future Music]

You can read that review in French, if you prefer (hey, it sounds cooler):
MeeBlip anode: Un synthé open-source mono au son massif et saturé

And there’s an accompanying video review:


Here in Germany, Sound&Recording‘s Martha Plachetka (a talented synthesist, by the way), had generous words for us in German, by way of your neighborhood Späti / Kiosk / Bahnhof. “Kompakt, günstig, Open Source”:

Testbericht: MeeBlip anode im Test [musikmachen / Sound & Recording]

Ready to get your MeeBlip?

Most importantly, if these reviews have won you over, you can at last get your hands on MeeBlip easily and quickly. We are in stock and can ship quickly in North America, but we’re also in dealers near you, in North America, Australia, and Europe and the UK. That means if you’re ordering from Vienna or London, you can get rapid shipping from your favorite dealer, or you can walk into stores like Schneidersladen in Berlin, Robotspeak in San Francisco, or Control Voltage in Portland and pick one up. That was our original goal with anode, and seeing it come to fruition this fall is something we’re really thankful for, because we hate delays as much as you do.

Order direct and ship right away:
MeeBlip: Get One

Or via select dealers (and if your favorite dealer isn’t on this list and you want it there, call us and tell them to get in touch with us or ALEX4 in Europe:
Dealers Near You

Previously, more creative uses of anode from our friend Diego:

Transform Sounds for Free, with Tools Made with MeeBlip anode by Diego Stocco

And don’t forget, MeeBlip is open source hardware – ready to use right out of the box, but with code and schematics freely available on GitHub. We’re posting new updates there. A review of why that’s important:

Come and Git It: MeeBlip anode Circuits and Code, Open Source on GitHub

The post Reviews Weigh in on Our MeeBlip anode Synth; Here’s What They Said appeared first on Create Digital Music.

by Peter Kirn at November 10, 2014 07:22 PM

GStreamer News

GStreamer Core, Plugins and RTSP server 1.4.4 stable release

The GStreamer team is pleased to announce a bugfix release of the stable 1.4 release series. The 1.4 release series is adding new features on top of the 1.2 series and is part of the API and ABI-stable 1.x release series of the GStreamer multimedia framework that contains new features. The 1.4.x bugfix releases only contain important bugfixes compared to 1.4.0.

Binaries for Android, iOS, Mac OS X and Windows are provided by the GStreamer project for this release. The Android binaries are now built with the r10c NDK and as such binary compatible again with all NDK and Android releases. Additionally now binaries for Android ARMv7 and Android X86 are provided. This binary release features the first 1.4 releases of GNonLin and the GStreamer Editing Services.

The 1.x series is a stable series targeted at end users. It is not API or ABI compatible with the 0.10.x series. It can, however, be installed in parallel with the 0.10.x series and will not affect an existing 0.10.x installation.

The stable 1.4.x release series is API and ABI compatible with 1.0.x and any other 1.x release series in the future. Compared to 1.0.x it contains some new features and more intrusive changes that were considered too risky as a bugfix.

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

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

Also available are binaries for Android, iOS, Mac OS X and Windows.

November 10, 2014 09:00 AM

Linux Audio Users & Musicians Video Blog

LMMS Promo Video

Check out this new promo video for the LMMS DAW.

by DJ Kotau at November 10, 2014 02:24 AM

Hydrogen Swing Test

A simple and effective demonstration of the swing feature in Hydrogen drum machine by Lorenzo Sutton.

Hydrogen swing test from Lorenzo Sutton on Vimeo.

by DJ Kotau at November 10, 2014 02:22 AM

November 09, 2014

Libre Music Production - Articles, Tutorials and News

Newsletter for November out now - Interviews, tutorials and LMP features in Linux Format

Our newsletter for November is now sent to our subscribers. If you have not yet subscribed, you can do that from our start page.

You can also read the latest issue online. In it you will find:

  • LMP article features in Linux Format magazine
  • Second installment of 'LMP Asks', with Hermann Meyer of the Guitarix project
  • New software demos
  • More tutorials
  • New software release announcements

and more!

by admin at November 09, 2014 06:02 PM

November 07, 2014

Libre Music Production - Articles, Tutorials and News

Yoshimi 1.2.5 is now out!

Yoshimi 1.2.5 is now available. As noted by developer Will Godfrey, there are “a lot of changes underneath but very little to see".
Most notably Yoshimi supports multiple instances now without having to re-load from file.

by Conor at November 07, 2014 09:44 PM

Linux Audio Announcements -

[LAA] Yoshimi 1.2.5

From: Will Godfrey <willgodfrey@...>
Subject: [LAA] Yoshimi 1.2.5
Date: Nov 7, 7:20 pm 2014

If we were using project code names I think this one should be called "Iceberg".
There are a lot of changes underneath but very little to see.

Most notably Yoshimi supports multiple instances now without having to re-load
from file.

The GUI now correctly tracks MIDI bank and program changes, and you never see an
empty text field.

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

read more

November 07, 2014 08:00 PM

November 06, 2014

Libre Music Production - Articles, Tutorials and News

Dexed updated, including GUI overhaul

Dexed version 0.8.0 is now available and it has just received a GUI overhaul. Dexed is a plugin synth that is closely modeled on the Yamaha DX7. The goal of this synth is to be a tool/companion for the original DX7.

by Conor at November 06, 2014 11:18 PM


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

Libre Music Production - Articles, Tutorials and News

AV Linux, version 6.0.4, 'Diehard' is now available

The latest release of AV Linux, version 6.0.4, 'Diehard' has just been announced. It been called "the most stable and 'production-ready' release to date" by it's maintainer, Glen MacArthur

by Conor at November 06, 2014 07:27 AM

November 05, 2014

Linux Audio Announcements -

[LAA] Rivendell v2.10.1

From: Frederick Gleason <fredg@...>
Subject: [LAA] Rivendell v2.10.1
Date: Nov 5, 8:35 am 2014

On behalf of the entire Rivendell development team, I'm pleased to announce the availability of Rivendell v2.10.1. Rivendell is a full-featured radio automation system targeted for use in professional broadcast environments. It is available under the GNU General Public License.

>From the NEWS file:
*** snip snip ***
RDHpiInfo Enhancements. Added DSP utilization and profiling data
readouts for AudioScience audio adapters to rdhpiinfo(8).

RDLogEdit Enhancements. Added an 'EXT DATA' column to the Edit Log
screen in rdlogedit(1) to allow visibility of ELR GUID data when
making edits.

Various other bug fixes. See the ChangeLog for details.

Database Update:
This version of Rivendell uses database schema version 242, and will
automatically upgrade any earlier versions. To see the current schema
version prior to upgrade, see RDAdmin->SystemInfo.

As always, be sure to run RDAdmin immediately after upgrading to allow
any necessary changes to the database schema to be applied.
*** snip snip ***

Further information, screenshots and download links are available at:


| Frederick F. Gleason, Jr. | Chief Developer |
| | Paravel Systems |
| Patch griefs with proverbs. |
| -- William Shakspeare |
| "Much Ado About Nothing" |

Linux-audio-announce mailing list

read more

November 05, 2014 09:00 AM


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

    November 04, 2014

    Create Digital Music » Linux

    Novation’s LaunchControl XL Has the Faders and Knobs You Need for Ableton, MIDI [Obsessive Review]

    Faders. Knobs. Done.

    Faders. Knobs. Done.

    Sometimes, you just want to grab a fader.

    Maybe it’s not about elaborate custom parameter assignment, or clip launching, or playing an in-tune Phrygian scale on a colored, light-up grid as you solo on a bowed marimba sample. You know, you just want to fade a track.

    There are surprisingly few controllers out there tailored to this application. So, that makes the new LaunchControl XL from Novation a potential stand-out. It’s just faders and pots: 8 faders, with three knobs each. Each column also gets two triggers; these are switchable when used with Ableton Live to control mute, solo, and record arm functions. As on the Launchpad, Novation also provides separate user/factory templates you can access with a push-button, and switches for selecting tracks and sends, all mapped to Ableton Live.

    The upshot is, you’ve got a MIDI controller that makes it exceptionally easy to mix eight tracks. And this being a Novation controller, it’s also lightweight and compact: the footprint is the same as the Launchpad, and it weighs in at under a kilogram. You can use it anywhere, because it’s bus-powered and driverless, so it works with iOS, Windows, OS X, and Linux.

    I expect Ableton Live will be the most popular use case, though, so let’s begin with how Live integration works.


    Ableton Live Control

    It’s hard to remember, but a few short years ago when Novation unveiled the original Launchpad, there weren’t any mass-market controllers dedicated to the software. (Boutique maker Faderfox, for instance, was a pioneer.) Now, they’re all over the place. In addition to Ableton’s deep and beautifully-made Push hardware, Akai alone has three new additions to its APC family introduced just this year. Ableton works in collaboration with some of these vendors to make integration work so well, and it shows.

    When you want dedicated mix controls, however, many of these devices disappoint. Ableton’s Push is a great example: you can adjust track parameters, but only on encoders (not faders), and it requires switching modes. That can be confusing if you’re in the middle of playing and just want to reach for a send or volume. Others will provide faders and knobs but in combination with clip launching. If you use an iPad for clips, or you have another hardware controller, or you focus on instrumental playing, that’s overkill.

    That’s where the LaunchControl XL hits a sweet spot. Its main selling point is its eight 60mm faders. These aren’t the fanciest faders you’ll ever encounter – they’re single-rail and so you’ll feel some slight wobble, as on nearly all controllers in this price range – but there’s enough resistance to mix with some accuracy. Each strip is coupled with three rotary pots. These have center detents so you can use them for pan (oddly, all three of them, not just the one labeled pan). That detent is subtle enough that you can also ignore it – for example, if using as a send – though that makes me worry slightly about wear over time. There are simple LED indicators below each to see which is active.

    Each strip also has a Track Focus switch for quickly moving Live’s display to a particular track, plus a second trigger that mutes, solos, or record arms tracks. For device control, there’s also a Device switch, useful in conjunction with Instrument, Drum, and Effect Racks.

    One obvious pairing is the LaunchControl XL with a Launchpad, though it's just one option.

    One obvious pairing is the LaunchControl XL with a Launchpad, though it’s just one option.

    There’s no Ableton logo on the LaunchControl XL as on the Launchpad, but it definitely feels like a Live controller when used with that software. There’s literally no setup whatsoever for Live. Plug in the hardware, start a compatible version of Live, and you’ll instantly be in control. There’s not even so much as an installation; you only need to download something to use the custom editor.

    I love Ableton’s Push, but the LaunchControl XL quickly addresses some of its shortcomings – particularly when used live. You’re never more than one button away from selecting a track you need, or two buttons away from quickly record enabling. (The latter is essential to me as a keyboardist for switching instruments.) And until Ableton comes up with its own mixing-friendly controller (Ableton Fade, perhaps?), LaunchControl XL is essential.

    The LaunchControl XL isn’t limited to mixing, either. Thanks to the User/Factory template switch, you can assign one layout to something like a custom instrument or Max for Live device, and another to the main mixing functions, then toggle between them easily.

    For studio work, then, I like having the Novation kit alongside Push as much as the obvious application of sitting it alongside a Launchpad. For live performance, since I don’t necessarily need to play on a grid, it’s quickly become the one thing I always put in my bag, just because it’s light, it’s rugged, and it does something you almost always want. For Launchpad owners, too, it’s likely to be a no-brainer, and you can fit this and a Launchpad into a bag with less weight and girth than a Push. Not to offend Ableton here; Push is great. But I’m sure I’m not alone in wanting to leave Push on my desk for starting tracks, and take along something more basic for live gigs, especially since I sometimes focus my performance on hardware or a keyboard. It’s just another example of how diverse live rigs can be.

    A live rig application - the LaunchControl XL joins keyboards, Faderfox UC3 in a collaborative setup with me and Robert Lippok on the 4DSOUND system at Amsterdam Dance Event.

    A live rig application – the LaunchControl XL joins keyboards, Faderfox UC3 in a collaborative setup with me and Robert Lippok on the 4DSOUND system at Amsterdam Dance Event.

    Dude, Where’s My Track?

    There’s just one feature missing, and it’s a big one: the absence of a display means it’s too easy to get lost. If you have more than two sends, you have to toggle using the Send Select up and down buttons. If you have more than eight tracks, you use the Track Select buttons. (You can only move by one at a time, too, not “pages” of eight at a time.) In each case, the only feedback on the hardware is the colored LEDs that show send and track state, which don’t give you very clear bearings.

    Onscreen, things aren’t much better. You can tell which sends, pan, or volume mostly only by twiddling knobs or moving faders – and then, it means looking at the computer display rather than the hardware.

    A Ring Focus Box, the colored rectangular outline that provides a visual indication of which clips are currently mapped to a controller, might help. It would still mean looking at your computer screen, and the LaunchControl XL is selecting tracks, not clips. But currently the Ring Focus Box is made available to hardware out of the box for the APC and Launchpad devices as part of a support collaboration with Ableton. (iPad apps use their own custom installers.) CDM is working on possibly providing a custom hacked script to those who want it unsupported.

    This is what Ableton Live shows you so you know which track you're on, in place of the

    This is what Ableton Live shows you so you know which track you’re on, in place of the “red box.” Not… remotely helpful.

    This isn’t just a LaunchControl XL issue, though; it’s generally an issue with keeping track of larger sets, visually and mentally. And it’s compounded when you have more than one person playing (I now work in several projects that are collaborative). For now, my approach has been to limit some live performances to eight tracks, which is conceptually simpler as well as solving control issues. If you have thoughts, I’d love to hear them.

    If you are using the LaunchControl XL with another piece of kit – like the Launchpad – there’s an excellent solution, so long as you have Max for Live (included in Live Suite). It’s called LaunchSync, and it moves multiple controllers in tandem. So, if you change which clips are active on one controller – via Push, APC, Launchpad, or even Livid Base – everything else moves. This solves both the visual feedback problem and the question of getting confused with multiple controllers.
    Free Launchsync Max for Live plugin [Isotonik]

    From comments – yes, you can combine more than one LCXL for fixed assignment (for instance, 2x LCXL = 16 tracks).

    As a Generic MIDI Controller

    Another reason to buy the LaunchControl XL is that its usefulness isn’t limited to Live’s own interface. It’s also a terrific generic MIDI controller, which opens up both custom control applications in Live and giving it utility with other software.

    To be honest, at first I didn’t realize there even was an editor for the hardware’s mappings because it’s pretty useful out of the box. Without any drivers, you can connect to a computer and start sending MIDI, or even connect to an iOS device with a Camera Connection Kit.

    The LaunchControl XL is especially nice in that nearly everything is MIDI-assignable. The send and track toggles on the right send MIDI messages away from Live (or in Live, with the User template). Once you do open the editor, each assignment is customizable.

    The LCXL's editor is huge and exhaustive - and means you might consider the hardware even if you never touch Ableton Live. If you want hardware to do double-duty rather than be a single-tasker, it's perfect.

    The LCXL’s editor is huge and exhaustive – and means you might consider the hardware even if you never touch Ableton Live. If you want hardware to do double-duty rather than be a single-tasker, it’s perfect.

    Novation has gone one better, too. Not only have they made every single colored LED addressable via MIDI, but they’ve done two implementations (one with MIDI notes and one with System Exclusive data), and written a handy programming guide that clearly explains how to do it:

    Launch Control XL User Guides

    This is the way hardware should work; I’d love to see more manufacturers adopt this approach, and the only way to convince them to do so is to loudly reward those who do.

    If you can spare some extra weight and cost, the DS1 from Livid is the other gear to consider. The biggest advantage: enough dedicated sends/EQs that you don't need bank controls.

    If you can spare some extra weight and cost, the DS1 from Livid is the other gear to consider. The biggest advantage: enough dedicated sends/EQs that you don’t need bank controls.

    The Competition

    I had to double-check that I hadn’t lost my mind and forgotten something, but in fact there aren’t many direct rivals that do what the XL does. That said, the number are rapidly growing.

    The Akai APC is probably what most people will consider. An APC40 does the job reasonably well already, even before looking at the recent mk II model (hint: it’s flatter). And if you just want faders, there’s the inexpensive APC mini, though the build is much more satisfying on the (more expensive) Novation gear. But what you won’t get is sends right next to the channel strip, which for a lot of us is hugely desirable. The APC line wins on all-in-one functionality with clip launching, but the LaunchControl XL is a better mixing surface.

    Ableton’s Push, as I said, is brilliant stuff. But it’s too complicated to use as a generic programmable controller, and mixing means twisting encoders and using toggles to get at the settings you need. It’s just hardware that solves a different set of problems.

    If it’s only faders you want, there’s the Faderfox UC3, which is tiny and has a brilliant build quality, plus encoders with pages of assignments. You could even use that crossfader as a master fader and ignore the fact that it’s sideways. But you only get eight encoders, and no toggles for Live integration, so I like the UC3 better as a controller for devices and synths and so on rather than Live’s mixer.

    Livid has a couple of offerings to look at, too. The Alias 8 is a great solution, and has a master fader, which the LaunchControl XL lacks. The faders are shorter-throw, but feel really good. You’ll mainly sacrifice the convenient toggles on the LaunchControl XL for Ableton Live integration.

    Livid’s DS1, made in collaboration with Dubspot, is probably the most robust competition as a mixing control interface, with both a master fader and tons and tons of knobs. In fact, the DS1 is the only controller I know of that allows either a bunch of sends or dedicated EQs for each strip. It was designed specifically for this digital mixer use case I describe. But I’m not getting one. Why? Apart from cost, I’m just happy having something lighter and smaller, so I’m willing to make some sacrifices to use the Novation.

    Behringer’s BCF2000 is of course major competition, with motorized faders, though it doesn’t have the dedicated send controls of the DS1. Again, it does add weight. I would choose the extra sends of the DS1 over the single rotaries on the BCF, but the motorization is convenient and street prices of the BCF are around US$200. It lacks faders, but with tons of rotaries, there’s also the BCR2000, made more appealing by the recent availability of a terrific step sequencer.

    Behringer’s newer controllers also have something to offer though I haven’t gotten my hands on them yet; in particular, the X-TOUCH Compact refreshes the BCF2000 notion with more controls than are available on the Novation and motorized faders. And while, like the BCF, you get just one encoder per channel strip, a new bank of eight endless encoders on the right should more than make up for that – especially with LED feedback on all the encoders.

    Finally, there’s Novation’s own original LaunchControl. If you just need some knobs for sends and/or device control and toggling track state, it’s cheap and tiny. But, of course, the XL is for those of you who wanted faders, so that’s no question.

    Cats love it. From a session with my Alchemic Harm project.

    Cats love it. From a session with my Alchemic Harm project.


    I didn’t really appreciate how much I wanted the LaunchControl XL until I lived with it for a while. Sends plus faders plus track toggles plus lightweight and small equals stays on my desk and in my bag and doesn’t go on my Shelf of Lost Gear.

    It’s not perfect. Finding which track you’re on is a chore, which makes me long for displays – though the Max for Live sync plug-in is certainly helping. And there’s hardware that feels a bit better (Livid, Push, Faderfox).

    US$249.95 list is a bit high by Launchpad standards, though that’s hitting a street of about US$200. (Similar street pricing is available in Europe and the UK.)

    All in all, the LaunchControl XL might not be alone, but it’s for me uniquely perfect. Never underestimate the value of faders you can easily drop in a bag.

    LaunchControl XL product page

    The post Novation’s LaunchControl XL Has the Faders and Knobs You Need for Ableton, MIDI [Obsessive Review] appeared first on Create Digital Music.

    by Peter Kirn at November 04, 2014 04:45 PM

    Hackaday » digital audio hacks

    A Custom Control Surface for Audio/Video Editing

    Control surfaces (input devices with sliders, encoders, buttons, etc) are often used in audio and video editing, where they provide an easy way to control editing software. Unfortunately even small control surfaces are fairly expensive. To avoid shelling out for a commercial control surface, [Victor] developed his own custom control surface that sends standard MIDI commands which can be interpreted by nearly any DAW software.

    [Victor]’s control surface includes several buttons, a display, and a rotary encoder. His firmware sends MIDI commands whenever a button is pressed or the rotary encoder is turned. [Victor] plans on adding menu functionality to the currently unused LCD display which will allow the user to change the scrubbing speed and other various settings.

    One advantage of making your own control surface is that you can customize it to your own needs. [Victor] has posted a model of his 3d-printed enclosure and his source code on the project page so you can easily modify his design with any button configuration you might want.

    Filed under: digital audio hacks

    by Ethan Zonca at November 04, 2014 09:00 AM » LAD

    LV2 Plugin Control Units in Ardour

    LV2 has had a “units” extension since the beginning, which allows plugins to specify units like Hz or dB for their controls. To date this information has not been used very widely by hosts, so I’ve done some work in Ardour to use this information for better UI generation and intelligent plugin control.

    Units can specify a format string which describes how to print a value in that unit. This is now used to draw the text on control sliders:

    An Ardour control dialog for an LV2 plugin.

    An Ardour control dialog for an LV2 plugin.

    The same controls are used in automation lane headers. If the control is a note number, then right-clicking will present a menu with an option to pop up a note selector dialog where the value can be chosen on a piano keyboard:

    The select note menu on a note number port.

    The select note menu on a note number port.

    The Ardour note selector dialog.

    The Ardour note selector dialog.

    Similarly, numeric frequency controls have a context menu which can set the value to a specific number of beats in the current tempo, if the frequency range is low:

    Setting a low frequency port in beats.

    Setting a low frequency port in beats.

    If the frequency range is high, then numeric frequency ports can be set with the note selector dialog just like note numbers:

    Setting an audible frequency port by note.

    Setting an audible frequency port by note.

    In the future, it would be nice to have this idea applied more extensively so automation lanes can “pretend” a port is in the desired unit, for example allowing the user to automate an LFO frequency in beats, or a cutoff frequency in notes. Until then, being able to at least easily set controls to musically sensible values makes many production tasks easier, particularly in electronic music where it’s often desirable to set plugin controls based on key or tempo.

    Up next is setting time ports based on tempo, for cases like setting delay lines to a certain number of beats, but many plugins are missing the unit information required to make this possible. Hopefully better and more widespread host support will provide some incentive for plugin authors to specify the units of their ports. It is very simple to do so, see the LV2 units documentation for examples.

    flattr this!

    by David Robillard at November 04, 2014 01:09 AM

    November 02, 2014

    Midichlorians in the blood

    Drumstick Metronome (kmetronome 1.0.0) and Drumstick 1.0.0 Libraries in the Whole Picture

    I've released in the past weeks some things labeled "Drumstick" and also labeled "1.0.0". What is all this about?

    Drumstick is the name of a set of Qt based libraries for MIDI processing. Current major version of the Qt Frameworks is 5, which are binary incompatible with the older Qt4 libraries. Latest Qt4 based drumstick release was 0.5.0 published in 2010. Newest Qt5 based release is 1.0.0, published on August 30 2014.

    Drumstick 1.0.0 is not binary compatible with the older one, nor even fully source compatible. In addition, it contains a new "drumstick-rt" library which is a cross-platform MIDI input-output abstraction. Based on Drumstick 1.0.0 I've released two more applications: vmpk 0.6.0 and kmetronome 1.0.0 (now renamed as "Drumstick Metronome").

    There are other applications based on the old drumstick 0.5.0 libraries out there: kmid2 and kmidimon. I'm no longer the kmid2 maintainer, but I will release (time permitting) a "Drumstick Karaoke" application replacing kmid2, and of course also a new kmidimon (naming it as Drumstick-Whatever). Meanwhile, Linux distributions may have a problem here shipping the old and new programs together. Not a big problem, though, because the runtime libraries are intended to co-exist together on the same system. The runtime dependencies are:
    • vmpk-0.6.0 and kmetronome-1.0.0 depend on drumstick-1.0.0
    • kmidimon-0.7.5 and kmid2-2.4.0 depend on drumstick-0.5.0
    If you want to distribute all kmidimon, kmid2, vmpk and kmetronome latest releases for the same system, you need to distribute also two sets of drumstick runtime libraries. This is possible because the old and new  drumstick libraries have a different SONAME. What is needed is to also rename the packages accordingly.

    $ objdump -p /usr/lib64/ | grep SONAME

    $ objdump -p /usr/local/lib64/ | grep SONAME

    For instance, you may name your old drumstick package as "drumstick0" and the new one "drumstick1", or append the Qt name like in "drumstick-qt4" and "drumstick-qt5", or keep the old one as plain "drumstick" and rename only  the new one. Whatever makes you happier. These suggestions are for people packaging drumstick for Linux distributions. If you are compiling drumstick yourself and installing from sources, then you don't need to worry. You can use the same prefix (usually /usr/local/) without conflicts, except only one set of headers (usually the latest) can be available at the same time in your system. This also applies to the "-devel" packages from distributions.

    There is only one thing left now. The whole picture :-)

    by Pedro Lopez-Cabanillas ( at November 02, 2014 01:36 PM

    November 01, 2014

    Libre Music Production - Articles, Tutorials and News

    Libre Music Production article features in Linux Format!

    Libre Music Production's article, "Demystifying JACK – A Beginners Guide to Getting Started with JACK" is featured in this months issue of Linux Format, out now! (Issue 191, December)
    Thanks to Neil Mohr and all at Linux Format. We're thrilled to grace your pages!

    by Conor at November 01, 2014 01:00 PM

    October 31, 2014


    Compressor Plug-ins in Linux Audio Part 1

    It’s easy to get lost in the bombardment of new plugins. Sometimes spending hours looking on you tube at new stuff, proprietary or not. Ah common you know you do so…. painstakingly fiddling with settings ad nausea to make our tracks sound more like what you would hear on the radio or cd’s and vinyl. Much is achieved by using compressors, re verb, and EQ’s.

    The right compressor and settings can help you get a punchier kick a fatter snare, etc.. by altering the dynamic range. Look at it as a volume fader which you can slide down on high peaks a couple of DB and bring the quieter parts up a bit to even out the dynamics and make it sit better over all in the mix.

    Before exploring which compressor plug-ins are available let’s look at the analog compressor types of olden days. Four electronic building blocks were used to build them, each giving them their character and functional use.

    >Optical >>> Compression is achieved by the lag between the light bulb and a photocell, giving it a distinctive attack and release time. For example an LA-2A comes to mind.

    >FET >>> With invention of the Field Effect Transistor quicker response was attained. Universal Audio 1176

    >VCA >>> in the 80’s DBX came out with the 160 series giving you more control over the compression parameters, some models however does not give you many options to control their parameters.

    >Vari Gain >>> as it implies various ways to achieve compression FC670, Manley Vari Mu.

    In part 2 next week we will check out our Linux equivalents.

    by pete0verse at October 31, 2014 05:52 PM

    The Penguin Producer | The Penguin Producer

    Breaking Silence

    Yes, it’s been silent.  No, I have not gone away. For those who have been wondering, I was laid off last year, and took advantage of the situation to go back to school.  As of right now, I am studying telecommunications, which include audio and video production, and minoring in …

    by Lampros Liontos at October 31, 2014 02:13 AM

    October 30, 2014 »

    LAC2014: submission accepted!

    My submission for the Linux Sound Night at LAC2014 with The Infinite Repeat has been accepted. The Call for Papers page mentions the term "danceable" so I'm going to focus on that. Making danceable music is quite a challenge for me but it should definitely be doable to produce a solid set, especially now that I'm the proud owner of a Korg Volca Keys. I'm definitely going to integrate it in my current setup as the Volca reacts great on MIDI sent from my workstation. It has some fat sounds that just scream dance floor.

    Korga Volca Keys

    I'm really looking forward to this year's LAC. It seems falkTX and avlinux are going too, it'd be great to meet these guys in real life!

    by Jeremy at October 30, 2014 07:19 PM


    Get Started Making Music With Linux On Your Desktop or Laptop Now.

    Making music on the PC has been ongoing en devour of mine. Many an hour I have spend on pursuing some way to record my own musical ideas. PC’s always stuck with me because Macs were just too expensive for a limited budget to justify breaking the bank so where portable tape machines or 8 tracks.

    A 486 dx 66mhz was about the only pc in the house at the time. Circa 1994, I had saved up money to buy anSound_Blaster_AWE32 sound card and thanks to my dad and his work connections landed one of my first DAW/ sequencers Cubase by Steinberg on Windows 95.

    Before that around 1985 it was the Commodore 64 with some long forgotten sequencer program .300px-Commodore-64-Computer I mostly played around with using the synthesis module then, I didn’t play an instrument then yet but it all seemed quite fascinating to me, and still does. Now if you like to tinker and take a byte or two out of technology bits (intended), get your music on now; follow along on how to gather you a decent setup to start recording tonight.

    You may already have a machine that has at least 2gb of memory, the more memory you have the better with 4gb memory being a reasonably good amount. a core duo or newer Intel I3,5,7 CPU’ s are great for this, check it off the list.

    By the way new Mac book pro’s use the same chips, no kidding! you probably run windows on your computer right now, but in a minute you could experience what it is like to run Linux for audio and video applications.

    Go ahead and download the ISO image from do follow along the well written manual, GMaq the developer no doubt spend hours on writing it up, provided on site on you how to transfer this image onto a 4gb USB stick or writable DVD with which you can boot up a real Linux OS prepared for our musical needs without changing your original Windows install. AV/linux is fairly light on resources and can be run right from the dvd or USB key LIVE!!! Sweet deal yes!?>

    If you already run Linux even better, you can use gparted to make at least a 75 gb partition and perhaps use the same LIVE ISO DVD or USB memory stick to install it next to your work OS. I really like to keep my partitions with OS’s dedicated to one or two activities.

    Boot up with F 12 or what key you need for the boot setup and start exploring the great Open Source World in music production yours to conquer!

    As always have fun!

    Update 11/10/2014: I should have checked before but there was a newer lower latency pae kernel version with updated packages ISO out, younger than the one I had on a stick. so check it out here

    by pete0verse at October 30, 2014 12:47 AM

    October 29, 2014

    Libre Music Production - Articles, Tutorials and News

    Creating Modular Synths using Ingen and ams-lv2

    Ingen is a modular synth that runs under JACK. It uses LADSPA and LV2 plugins for its processing. It can be used to create modular synths by using synth plugin modules.

    by Conor at October 29, 2014 10:12 AM

    Linux Audio Announcements -

    [LAA] Rivendell v2.10.0

    From: Frederick Gleason <fredg@...>
    Subject: [LAA] Rivendell v2.10.0
    Date: Oct 29, 8:49 am 2014

    On behalf of the entire Rivendell development team, I'm pleased to announce the availability of Rivendell v2.10.0. Rivendell is a full-featured radio automation system targeted for use in professional broadcast environments. It is available under the GNU General Public License.

    >From the NEWS file:
    *** snip snip ***hanges:
    Updated Translation. A new French translation has applied, courtesy
    of the good folks at Tryphon [].

    Log Tools Enhancements. Added various UI enhancements in RDLogManager
    and RDLogEdit.

    GPIO Logging. Added an event viewer in RDGpiMon to allow GPIO events
    to be logged and viewed.

    Music Scheduler Enhancements. Added the ability to utilize a second
    Scheduler Code in music events in RDLogManager.

    Report Generation Enhancements. Added the ability to specify a
    post-export script when generating reports (analogous to pre-import
    scripts for log imports).

    RDImport Enhancements. Added -set-marker-start-*=',
    '--set-marker-end-*=', '--set-marker-fadeup*=' '--set-marker-fadedown*=',
    '--set-string-*=' and '--set-datetimes' options for rdimport(1).

    Various other bug fixes. See the ChangeLog for details.

    Database Update:
    This version of Rivendell uses database schema version 242, and will
    automatically upgrade any earlier versions. To see the current schema
    version prior to upgrade, see RDAdmin->SystemInfo.

    As always, be sure to run RDAdmin immediately after upgrading to allow
    any necessary changes to the database schema to be applied*** snip snip ***

    Further information, screenshots and download links are available at:


    | Frederick F. Gleason, Jr. | Chief Developer |
    | | Paravel Systems |
    | Focus on the dream, not the competition. |
    | -- Nemesis Racing Team motto |

    Linux-audio-announce mailing list

    read more

    October 29, 2014 09:01 AM

    October 28, 2014


    Spoons! A Love Affair with Wood.

    I've loved wood since I was a child. I got my first pocket knife when I was 7 and for the following years I spent a lot of time carving wood. There is a zen in it for me. It's an interesting combination of the freedom of thought and intense focus that draws me in. I love the smell of wood, I love the texture of wood, I love the feel of wood in my hands.

    Spoon at the
    end of the class
    Since I was very young I've loved watching "The Woodright's Shop" with Roy Underhill on PBS. It's the longest running PBS show and is all about traditional woodworking, the kind of thing that is 100% devoid of electrically powered tools. There is a romanticism in traditional woodworking. You can see in the traditional tools the evolution of man's relationship with it's environment. The burst of activity in the Industrial Revolution changed the landscape of our relationship with the forests. In many ways we turned our back on them. We tore forests down to make room for other enterprises and insulated ourselves from that connection with our ecosystem even further.

    Finished Spoon
     from the class
    Like many things in life, the struggle of a young family and developing a paying career led me to put aside my love affair with wood and focus on keeping a roof over my head and food on my table. Now, however, good fortune has allowed me to dip my toe back into the waters.

    My Second Spoon
    There is a very talented woodworker and teacher who has been featured on a number of episodes of the "The Woodright's Shop" named Peter Follansbee who did an episode on traditional Swedish spoon carving and I was very intrigued by them. I started following Mr. Follansbee's blog and keeping an eye on his spoon work. It seemed a cheap and easy way to get back into woodworking without too much expense. I didn't take the plunge till I saw a meetup posted on the Greater Denver Urban Homesteaders page about a spoon carving class taught by Drover through the Sarquit Outdoor Living School. The class was fun and gave me the bug to give it a try. Drover was a great guy to learn from and very enthusiastic in his work. When I got home, I decided to order a hook knife for carving the bowl of the spoon and finished the knife. The bug for carving is strong for me so I ordered two more knives a short bladed and a long bladed strait knife. I also grabbed a cheap hatchet for doing rough out and splitting chores.

    The Third Spoon
    I needed wood for more spoons and when driving by a nearby location I saw what I though was an apple tree, saw a brush pile of wind fallen branches and hiked up with my middle daughter holding a hand saw to see if I could get some good carving wood. Turns out it was a pear tree and we had fun picking some fruit and collecting some branches.

    The first spoon that came out of the wood ended up a little more utilitarian looking than I'd hoped but I really enjoyed how easy green pear is to work with. I timed my first 3 spoons to see how long it took to completer using an android app, like a true geek and found it takes around 4 hours to produce one.
    Baby Spoon Traded
     for More Wood

    My next spoon still didn't turn out to be what I wanted but it was better than the first. With this spoon I really started figuring out more of the techniques and rebuilding the muscle memory for carving. By the third spoon I'd gotten most of the technique down and was really starting to enjoy the art of it all.

    The "Haul" and
     My Handsome Nephew
    After finishing the third spoon I had a mishap with the hatchet splitting out the blank for the fourth and did some pretty decent damage to my left hand, in fact I couldn't close my thumb across my hand for almost 2 weeks afterwards. By this time I was pretty much out of wood to work with and needed to source some more. I put out a call on social media but didn't turn up anything. So a quick Google search turned up the nearest tree trimmer to my house and I sent as concise and polite an e-mail as I could. Sure enough a few days later I got a response saying he'd trade all the wood I could handle for a spoon for his soon to be born first granddaughter. I set to work with some of the last of the pear wood making my first baby spoon. After marking it out and showing it to my wife, the expert in all things baby, she suggested some changes to the size and shape of the bowl and I went ahead with carving it out. I think it turned out fantastic, in fact maybe the best thing I've ever carved. After a few phone converstions setting up a meet time we got together at a time I could bring my nephew along. He was a great help loading up all the wood and when we got it all back home we both worked on some spoons.

    I'm having a great time carving and I think cute baby spoons might be my current muse for carving. I can't wait to crank out a few more to give to new or soon to be parents in my life.
    My Latest Spoon

    by Daniel Worth ( at October 28, 2014 08:01 PM

    Create Digital Music » open-source

    Windows 93 OS in Your Browser Comes with LSDJ, Pd, Nanoloop Music Apps


    It’s a nostalgia trip. It’s a net art piece. It’s a parallel dimension.

    It’s also working music apps running (sort of) in your browser. It feels a little bit like playing with an elaborate doll house where you can open the fridge and add tiny food and the oven pretends to work. But in case you haven’t already been infected with the quantum distraction power of the Windows 93 browser yet, it might interest you to know that there are music apps inside.

    There’s Pd – kinda. (Double-click the icon and it spawns a non-editable patch running in your browser.)

    There’s also LSDJ, the quintessential Game Boy tracker. And there’s Nanoloop, the classic, beautifully-minimal Game Boy music maker that later migrated to iOS and Android (though that takes out the fun of buying weird hardware from Japan to hack our Nintendo handhelds). Those both appear to be running in a Nintendo emulation layer in-browser.

    Play that and a glitched-out Pokemon plus get and disinfect yourself from computer viruses before you watch an ASCII Star Wars.

    It says something about the evolution of net art, here as it’s steeped in layers of history and nerd-hipster irony. (Can I re-launch my campaign to make “nerdster” a thing?) It also might say something practical about how more-powerful browsers really could change the way we share music tools. Native software still seems perfectly safe from the browser; we still use native tools for desktop and mobile. But I’ve yet to see someone make good use of the Web as a teaching tool, or to share work. This is a reminder of what’s possible, hyperlinked to loads of tools and code for developers to explore themselves.

    And I bet they would make something absolutely amazing, if I didn’t just destroy their productivity for the rest of the week by sharing … this. Wait, I may have just explained why we haven’t seen more Web tools. You read it here firs– hey, stop double-clicking that dolphin and read, darn it!

    Details, and links to some JavaScript goodness (and another appearance of the Web Audio API):

    Jankenpopp & Zombectro are running the thing,
    the Mighty Doctor House is hosting the thing.


    animate.css | CSS animations
    GameBoy-Online | GameBoy Color emulator written in JavaScript | Pixel Art and Animated Sprites editor | JavaScript 3D library | text editor implemented in JavaScript for the browser | Canvas Oldshool Demo Effect Framework | Star Wars Asciimation
    jGravity | A jQuery Gravity Plugin
    howler.js | Modern Web Audio Javascript Library

    Many are still missing… we’ll try to credit everyone soon :)
    If we forgot you, we’re sorry, you can ask us a link at

    The post Windows 93 OS in Your Browser Comes with LSDJ, Pd, Nanoloop Music Apps appeared first on Create Digital Music.

    by Peter Kirn at October 28, 2014 11:31 AM


    Security And Your Favorite Linux Install

    Thought I’d do a quick AV Linux experiences post this week on security. Now I must admit I’m a very trusting person in general, but also a bit paranoid about what services I have running on my machine I’m using. This week I was poking around to see what all makes this particular distribution run better for Audio and Video applications. Some things I will share in other posts as time progresses, but one thing that caught my eye was security, or the lack thereof. To me any machine connected to a network should have some way of wielding off port scans and run some kind of iptables script. Now if you are running AV/Linux or any other compilation of Linux do a quick

    #netstat -tunlp
    #lsof -i

    you will notice, as in this case, quite a lot of open ports and services running and listening for connections to outbound networks.

    I can say with conviction that you won’t need a inetd or xinitd super server running portmap or nfs
    unless you wish to do so on purpose.

    It is safe to close port 22 by either
    #service sshd stop for a quick shutdown of the port, but only temporary so till next reboot.
    Or if you really don’t need to remotely log in remove it all together with apt or synaptic package manager. # apt-get purge ssh

    this is my apt history.log showing which daemons I removed

    Start-Date: 2014-10-25 20:37:11
    Commandline: apt-get purge openbsd-inetd
    Purge: openbsd-inetd:i386 (0.20080125-6)
    End-Date: 2014-10-25 20:37:18

    Start-Date: 2014-10-25 20:38:11
    Commandline: apt-get purge portmap
    Install: libtirpc1:i386 (0.2.0-2, automatic), rpcbind:i386 (0.2.0-4.1, automatic)
    Purge: portmap:i386 (6.0.0-2), nfs-common:i386 (1.2.2-4squeeze2)
    End-Date: 2014-10-25 20:38:22

    Start-Date: 2014-10-25 20:39:20
    Commandline: apt-get purge rpcbind
    Purge: rpcbind:i386 (0.2.0-4.1)
    End-Date: 2014-10-25 20:39:23

    NFS >? I thought even Samba was installed. That’s all nice if you need to transfer files to another machine running Windows variants or such. Myself I prefer to use a portable hard drive for plug ins, track stems, and other important files I don’t want to lose. My one Terabyte USB drive is filling up nicely already with backups. Check into rsync the handy command line tool to backup into the same directory every time while only checking for the new files to add to the backup drive, very dandy that is!

    So I got to strip out services and daemons not needed in my case and when I do I will. I find this the best way to approach security on Linux, server and hobby machine alike.

    If you use another Debian or Ubuntu based install you can probably apply this simple tip to your benefit. Most of the time developers will aim at supporting protocols that go far beyond the needs of regular users. Don’t just blindly use or run what is offered, explore!! and as always have fun!!! laters

    by pete0verse at October 28, 2014 12:13 AM

    October 26, 2014

    Libre Music Production - Articles, Tutorials and News

    New LP from Little Pony released, produced by Red Plastic Label

    Little Pony have just released their new LP titled "WE ALL FALL DOWN: Strade, Rane, Principi e Dame". Little Pony are a band from Naples, Italy. Their sound is not easily defined but they draw influences from rock, funk, jazz and blues.

    by Conor at October 26, 2014 03:13 PM

    October 25, 2014

    Libre Music Production - Articles, Tutorials and News

    Carla 2.0 beta3 is here!

    Carla 2.0 beta3 has arrived. There have been quite a few nice features implemented since beta2.
    • Internal patchbay mode
    • Carla as VST plugin (Linux only)
    • Carla LMMS plugin
    • New and updated skins
    • Old non-skin mode
    • New time panel

    by Conor at October 25, 2014 01:45 PM

    Nothing Special

    My First Linux Audio Tutorial Video

    I like that title. It makes me think of chunky toys and blocky characters with big eyes. But this is much less cute than my kids playthings: I made a video to introduce my infamous plugins. Here is the video. How I did it is below.
    (if you can't see the embeded player here's the link: )
    EDIT: The second one is done now too. See

    This example isn't perfect, since I had to do a little editing in kdenlive and chose a poor output resolution and format (720p mp4). It looks ok in small screens but full screen looks pretty rough. But the point is that it is perfectly synchronized to the jack audio. The raw clips look great. This can only be accomplished through ffmpeg. With a patch. But it IS possible and here's how (using kxstudio):

    #get tools and source
    sudo apt-get install yasm libvorbis-dev libx263-dev libxfixes-dev
    tar -xvf ffmpeg-2.4.2.tar.bz2

    #patch the source
    cd ffmpeg-2.4.2/libavdevice/
    mv ffmpeg-2.4.2-jack.patch?format=raw ffmpeg-2.4.2-jack.patch
    patch < ffmpeg-2.4.2-jack.patch

    #build ffmpeg
    cd ..
    ./configure --enable-x11grab --enable-libvorbis --enable-libx264 --enable-indev=jack
    sudo make install
    sudo ln -s /usr/local/bin/ffmpeg /usr/local/bin/ffmpeg_harvid

    #record a screencast using the current screen
    ffmpeg -fflags +genpts+igndts -f x11grab -vsync 0 -r 30 -s 1440x900 -i :0 -vcodec h264 -f jack -ac 2 -r:a 48000 -i screencast -acodec pcm_s16le -r:v 30 -vsync 2 -async 1 -map 0:0,1,0 -map 1:0 -preset ultrafast -qp 0 "thisisonlyatest.mkv"

    #compress it for youtube
    ffmpeg -i "thisisonlyatest.mkv" -acodec mp3 -ab 160000 -vcodec h264 "thisisonlyatest-final.mkv"

    The nice thing is that ubuntu 14.04 and variants use avconv so installing an ffmpeg binary shouldn't get in the way of anything. Alternatively to that last command to record if you use kxstudio or the ppa's use the kxstudio scripts as falkTX described here.

    I wrote the patch, but the solution really comes from a patch made by male last year. The patch was incorporated into the 12.04 ppas ffmpeg build, but I am running 14.04 so it no longer applied. Necessity is the mother of invention. And updates. So I just adapted the changes to ffmpeg 2.4.2 (the current release) and figured out how to make it work so that I could start making videos about my plugins.  Anyway the patch should apply to any distro and hopefully this will open the floodgates for many beautiful, perfectly sync'd linux audio tutorials and demo videos.

    by Spencer ( at October 25, 2014 10:12 AM

    KXStudio News

    Carla 2.0 beta3 is here!

    Hello again everyone, we're glad to bring to you the 3rd beta of the upcoming Carla 2.0 release.
    There have been quite a few nice features implemented since beta2; here are the highlights.



    Internal Patchbay

    This new engine processing mode is similar to what JACK does for all clients and what other modular applications do.
    Every plugin gets its own canvas group and ports allowing you to interconnect plugin audio and MIDI.
    You can use this mode to build complex plugin routing scenarios, perhaps involving several layers of rack and patchbays.

    Note that this is currently not available for non-JACK drivers; but for those you can use the internal carla-patchbay plugin.
    There's no support for LV2 Control-Voltage ports as of yet, this will be implemented in the next beta together with MIDI-OSC.


    Carla as VST plugin (Linux only)

    With the first beta of Carla 2.0 we introduced Carla as a plugin, which worked as both internal and LV2.
    Now Carla is available as a VST plugin too, allowing you to load it all DAWs released for Linux.
    There are 4 variants: Rack-Synth, Rack-FX, Patchbay-Synth and Patchbay-FX.


    Carla LMMS Plugin

    Carla has an LMMS plugin too, as Carla-Patchbay and Carla-Rack instruments.
    So finally you can use native softsynths within LMMS!
    The carla-lmms plugin code is already in LMMS and will be part of its 1.1 release.

    If you're using the KXStudio repositories and feel like giving it a try simply install carla-git and lmms.


    AU Plugins (MacOS only)

    AU plugins are working in Carla now.
    Carla's plugin compatibility increases once more.


    New and updated skins

    There's a new OpenAV-style plugin slot skin.
    Calf and ZynFX have been updated.
    More to come soon.


    Old non-skin mode

    You can now use the old non-skin mode from Carla 1.x series.
    This saves space if you load lots of plugins at once.

    More stuff

    • New time panel added, but it's very incomplete.
    • LV2 plugin discovery is now automatic, but without plugin checks or testing.
    • LV2 plugins are fully working on MacOS and Windows, including their native UIs (Cocoa and HWND respectively).

    There will still be 1 or 2 more beta releases before going for a release candidate, so expect more cool stuff 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 October 25, 2014 12:23 AM

    October 23, 2014

    Ubuntu Studio » News

    Ubuntu Studio 14.10 Utopic Unicorn Released (supported for 9 months)

    This release will only be supported for 9 months. Beginning with this release we are recommending our users to stick with the latest LTS release (currently 14.04), since we will be focusing our support on the LTS releases. Nevertheless, we continue to publish a new release every six months. And a new LTS every two […]

    by Kaj Ailomaa at October 23, 2014 09:48 PM

    Libre Music Production - Articles, Tutorials and News

    NASA posts a huge library of space sounds, and you’re free to use them!

    NASA has posted a large collection of sounds from historic spaceflights and current missions on their soundcloud account.

    For full details, check out Create Digital Music.

    NASA's soundcloud account can be at

    by Conor at October 23, 2014 07:59 AM

    October 22, 2014

    Arch Linux Pro Audio

    Update and Interview with JazzyEagle

    After a time of silence here on, we’re back with lots of news about Arch and using Arch for audio purposes. Actually, we’re gonna do a few little features on users, developers and companies interested in Arch linux for audio projects. Up to date packages for a variety of popular audio programs are available in the ArchAudio repositories.

    Interview #1, JazzyEagle

    Today we talk to JazzyEagle, an Arch user and enthusiast packager who’s been intrested in Linux since the late 90’s.

    ArchAudio: Tell us a bit about yourself?

    JazzyEagle: I’m Jason Harrer (pronounced like Harper without the “p”) and I live in the US, around Denver, CO. I work in the HealthCare industry as a Manager of a Medical Claims processing unit. My hobbies are playing/writing music and programming computers.

    I got interested in Linux way back in the late 90’s, but thanks to a modem with no Linux support at all, I couldn’t really do anything with Linux, so I gave it up. I tried it again probably about 4 – 5 years ago after someone showed me Ubuntu, and, despite accidentally reformatting the hard drive multiple times when the intent was dual boot, I’ve been running various *buntu distros until I found Arch and fell in love with it.

    ArchAudio: How about your musical interests?

    JazzyEagle: I listen to all genres, but the ones I like the most are in the grunge/hard rock zone. I do play guitar, bass, keyboards and even accordion. Although I don’t claim to be able to play other stringed instruments, I have been known to pick them up and fiddle with them enough to play what I needed to on rare occasion.

    ArchAudio: Wow, that’s a lot of instruments! So where does Arch come into all this?

    JazzyEagle: I like the ability to create the system to the way I want it without installing a bunch of stuff I don’t want, as well as the cutting/bleeding edge rolling release philosophy of Arch. I tried Parabola, but I’ve determined that there are some non-free things I like, and so it didn’t quite fit my needs.


    That’s all for now, stay tuned for the next update: about the MOD LV2 guitar pedal, and how it utilizes Arch linux on the inside!

    by harryhaaren at October 22, 2014 10:42 PM

    Create Digital Music » open-source

    NASA Posts a Huge Library of Space Sounds, And You’re Free To Use Them


    Space is the place. Again.

    And SoundCloud is now a place you can find sounds from the US government space agency, NASA. In addition to the requisite vocal clips (“Houston, we’ve had a problem” and “The Eagle has landed”), you get a lot more. There are rocket sounds, the chirps of satellites and equipment, lightning on Jupiter, interstellar plasma and radio emissions. And in one nod to humanity, and not just American humanity, there’s the Soviet satellite Sputnik (among many projects that are international in nature).

    Many of these sounds were available before; I’ve actually used a number of them in my own music. But putting them on SoundCloud makes them much easier to browse and find, and there are download links. Have a listen below.

    Another thing: you’re free to use all of these sounds as you wish, because NASA’s own audio isn’t copyrighted. It’s meant to be a public service to the American people of their taxpayer-funded government program, but that extends to everyone. There are some restrictions – not everything NASA publishes is covered by the same license, though it appears to be on SoundCloud. And you aren’t free to use NASA’s name or logo or imply commercial endorsement. (The Eagle didn’t land on a bag of Doritos.) But that means just about any imaginable musical application is fair game. They do ask you to list NASA as source, but that’s only reasonable. Read their content guidelines for full details.

    Let the space remixing begin.

    European Space Agency, your move.

    Thanks to everyone who sent this in. If you want more, NASA centres all have archival libraries, and the agency has routinely worked with artists and composers to interpret the work they do. See also other research centers around the world. And yes, that’s my Saturn V photo at the top, because, and I’m sure this will come as a huge shock to everyone who reads this site, I’m a big nerd.

    Have you made music with space sounds? Let us know in comments.

    More Sounds

    Want more?

    It’s slower to browse, but there’s an even bigger library on

    NASA Audio Collection

    They’re all marked public domain (which is almost certainly the correct license for the above, not Non-Commercial Creative Commons).

    It gets weird. For instance, here’s a 1970 comedy skit, produced in-house. And it gets obscure – like briefing audio from a recent ISS mission. But there are some gems in there, too.

    NASA also has a small page of sounds that seems to be the basis of the above, but the collection is bigger.

    The European Space Agency has its own set of sounds, though like NASA, ESA could do some more archival work! (Some of these come from NASA, too.)

    The University of Iowa has a selection of space sounds:
    Space Audio

    The “space sounds” phenomenon here is fascinating: these are radio emissions, but in the audible spectrum – that is, there’s no remapping. You’re listening to a direct recording of those radio signals at their real frequencies, which happen to be ones you can hear. NASA explains how Iowa’s instruments work:

    Sounds of Space: New ‘Chorus’ Recording By RBSP’s EMFISIS Instrument

    This same technique is the topic of a TED talk (as Professor Donald Gurnett had championed at Iowa):

    Artist-technologist Honor Harger listens to the weird and wonderful noises of stars and planets and pulsars. In her work, she tracks the radio waves emitted by ancient celestial objects and turns them into sound, including “the oldest song you will ever hear,” the sound of cosmic rays left over from the Big Bang.


    And yes, in response to comments:

    1. Almost certainly, the Creative Commons Non-Commercial license is a mistake – a misunderstanding of how CC works, or confusion with the SoundCloud metadata, or both. (I’m guessing they chose Non-Commercial because NASA doesn’t allow commercial endorsement, but that’s not actually what the CC license is dealing with – and these sounds were already released into the public domain. CC licenses require copyright, which they lack.)

    2. Higher-quality audio would be nice. NASA has it, but uploading archival materials requires lots of resources the agency doesn’t have. Research grant, someone? Or should CDM just publish from Houston for a few months and I’ll work on it?

    The post NASA Posts a Huge Library of Space Sounds, And You’re Free To Use Them appeared first on Create Digital Music.

    by Peter Kirn at October 22, 2014 06:38 PM

    Scores of Beauty

    Annotating scores

    (This is a post in a series about the “Crowd engraving” project “Oskar Fried: Das trunkne Lied”)

    For quite some time I had been thinking (and to some extent writing) about the potential LilyPond’s plain text approach offers for implementing in-score annotations. The idea got stuck in a state of initial drafts because it requires Scheme skills that I don’t really have, but our crowd engraving project with the huge score was an incentive for me to implement at least a “working draft”, and as it turned out this was a priceless addition already in this initial state.

    The Idea

    LilyPond’s music input is stored in plain text files and therefore it is possible (and recommended) to add source comments in the files to document them and make them easier to read and maintain. The most obvious targets for these comments are usually formal hints (measure numbers or structural items like “coda”, “3rd verse” etc.) but one can of course also annotate the content (“is this really a g' or is there a flat missing?”) or issues with LilyPond coding (“I don’t see how to align these two notes properly”). A typical use case are also “todo” comments (“Check this again when line breaking is fixed”). However, the concept of code annotation can be extended by implementing comments that actually do something.

    The Implementation

    A characteristic of code comments (actually that’s their inherent benefit) is that they are completely ignored by the “compiler” (i.e. LilyPond), and therefore the user can insert arbitrary text there without worrying what the compiler will think about it. But in a way this is also a limitation. Code comments are good to document code for someone who is reading through the specific spot in the code, but they are not useful when you want to actively point others to an annotation.

    For this purpose we had already created a few functions in our earlier Oskar Fried project and called the library “in-source-communication”. Basically these were commands that highlight something in the score and produce a message in the console output of LilyPond. That way we had a convenient way to announce things to the collaborators and have these items be tied directly to the music input. For the current project I then implemented some functionality that doesn’t do much more yet but that can hopefully be developed into a really useful feature for scholarly use of LilyPond in the future.

    There is a function \annotate that can be used like this:

      \annotate \with { type = "musical-issue"
        context = "bassoon 1"
        source = "OE"
        author = "Urs Liska"
        date = "2014-09-13"
        message = "Hairpin missing in OE but present in contrabassoon"
      f2. ~ \< |
      f1 \!

    This will highlight the affected grob (here: the hairpin on the f) through coloring (if switched on) and produce a clickable message in the console (if switched on). Through this the compiled score immediately reveals problematic spots in the score, and the compilation output in the console “invites” to browse through issues. There is much more this should/could do, but for now I’m happy that we can at least enter annotations and have these comments as obvious as e.g. an issue tracker while being directly tied to the actual music input.

    Practical Implications

    As mentioned earlier the original score of Oskar Fried’s “Das trunkne Lied” contains numerous errors or questionable notations. While we are not commissioned a scholarly review our contributors are encouraged to annotate and/or fix anything they notice along the way. This means: If someone notices an obvious error he should fix it – but document that with a critical-remark annotation. If a dubious notation is encountered (e.g. a hairpin that is missing from a voice but present in others) a musical-issue annotation can be added, so the question can be discussed later. In the end all musical-issue annotations should either be turned into critical remarks or discarded. Usually in the workflow the above musical-issue annotation would be processed during review and probably be changed to a critical-remark annotation.

    So far (that is with about 60 % of the instrumental parts and none of the vocal parts entered and reviewed) we already have more than 880 annotations in our files! Among these 515 are labeled critical-remark and 300 refer to open musical questions – all of them already peer-reviewed. This means we will probably identify far more than 1.000 errors in the score during music entry alone. I find this is a remarkable number, given that our team has few professional musicologists and that we didn’t even start doing something like an explicit scholarly review.
    I’m quite sure these wouldn’t help us as much if they were entered as plain code comments. Having them encapsulated in explicit commands instead makes them ready for further elaboration and processing.

    Need for a GUI

    Apart from many new functions that I would like to have there is one thing that makes working with \annotate still somewhat unsatisfactory: it’s quite verbose. I mean as you can see above adding an annotation implies writing quite some code, a lot of which is actually redundant. The musical context could be determined from the file, the author and date could be retrieved from the version control commit. In theory one could even write the annotation text in the commit message. Not all of this would be equally useful or practical, but in the end it’s tedious and somewhat error-prone to enter lots of annotations. I’m sure if it were more straightforward to add an annotation we’d have an even lower threshold and higher number.

    One solution to this which I want to develop (but I doubt I’ll be ready with it in our current project) is a graphical interface to annotations to be used in Frescobaldi. This will then provide right-click access to an annotation editor where things like annotation type or author can be chosen from a dropdown, while date and context will be inferred from the actual environment. Having annotations directly in the music input is a conceptual advantage over other approaches where one has to maintain the music and the scholarly review separately, but having graphical access directly from the score view will make that unbeatably natural.


    I will only touch the potentials of \annotate, but if someone is interested in this kind of functionality and has the necessary Scheme skills available at his fingertips I’d be more than happy about assistance in developing this further.

    One of the next things to do is making the function aware of the annotation type. Depending on that it could then respond individually. E.g. musical-issue annotations would be colored only while developing the score while critical-remark annotations would call an “editorial function” on the affected grob, so that for example slurs annotated with a critical remark are dashed automatically. It would also be great if annotations could directly create footnotes or print annotations directly in the score, possibly on a separate PDF layer.

    Another wish is outputting annotations to separate files, together with the position in the score which should be retrieved by LilyPond when it compiles the score. This would result in viewable files with annotations, grouped by type and sorted by measure, which provide point-and-click support to directly navigate to the annotated music.

    Finally the output of critical remarks should possibly be done in a way that it can directly be used from a LaTeX document and used in a critical report. If that’s possible I could finally edit the critical report directly in the score, with everything documented and maintained in version control’s safety net. This would (will?) really be a killer application for scholarly edition!

    [Edit (2014-11-14):]
    In the meantime the usability of the function has been improved. The musical context is determined automatically, and there are a number of wrapper functions that
    remove the need to specify the type separately. The function can now be used like this, which is much less redundant and more informative:

    \criticalRemark \with {
      author = "Malte Meyn"
      message = "There is only one hairpin plus pp between bcl and horn 1.
                Probably it is meant for both instruments."
    e4. \>

    Now the different types of annotation cause different highlighting colors so it will be much easier to spot those annotations that still have to be discussed. And an additional improvement is that annotations can now also be used as \tweaks so that it is possible to annotate one note head or one accidental from within a chord or similar things. The other wishes are still open, though …

    BTW: we’re already at 680 critical remarks and 350 musical issues …

    by Urs Liska at October 22, 2014 12:22 PM

    Linux Audio Users & Musicians Video Blog

    The Passion of Raul

    Raul is a Vampire who is driven by his unquenchable passion in the dead of night.

    This is a re-edit of an earlier private work titled “Rauls Redemption” by Volker Allert, a renown physical effects creator for the Hollywood film industry.

    All audio recorded with Linux tools and edited in Blender on Linux of course.

    by DJ Kotau at October 22, 2014 08:01 AM

    October 21, 2014

    Linux Audio Announcements -

    [LAA] ANN: SEAMUS 2015 -- Call for submissions

    From: Ivica Bukvic <ico@...>
    Subject: [LAA] ANN: SEAMUS 2015 -- Call for submissions
    Date: Oct 21, 6:34 pm 2014

    Content-Type: text/plain; charset=UTF-8

    Apologies for x-posting:

    The SEAMUS 2015 conference will be held at Virginia Tech during March
    26-28, 2015. The conference theme is "Emotion and Electroacoustic Music."
    The submission deadline is October 31, 2014. Please see http://
    for further details on the conference, and http://
    for further information about SEAMUS.

    Any questions regarding the conference may be directed to seamus@ .



    Content-Type: text/html; charset=UTF-8
    Content-Transfer-Encoding: quoted-printable

    Apologies for x-posting:

    The SEAMUS 2015 conference will be held at Virginia Tech dur=
    ing March 26-28, 2015. The conference theme is "Emotion and Electroaco=
    ustic Music." The submission deadline is October 31, 2014. Please see =
    for further details on the conference, and

    =C2=A0for further information about SEAMUS.

    Any questions regarding the conference may be directed to=C2=




    read more

    October 21, 2014 07:00 PM


    Parsing ID3 tags using taglibs with Ruby

    I wrote this little script in Ruby a couple years ago to solve the problem of scrambled mp3’s in a large set of +4000 files. It’s quick dirty, simple, and taglib does all the lifting.


    require 'taglib'

    path = "your path"

    Dir.foreach("#{path}") do |file|"#{path}#{file}") do |fileref|
    tag = fileref.tag

    if file =~ /mp3/


    by pete0verse at October 21, 2014 05:37 PM

    Libre Music Production - Articles, Tutorials and News

    Synthtopia launch their "What's The Best Desktop Daw" of 2014 poll

    A few days ago, Synthtopia put out their annual poll to find out what users think the best DAW is. Ardour is in the list amongst others, but there is also a "Other" option where you can submit software not already included in the list.

    by Conor at October 21, 2014 07:12 AM

    October 20, 2014

    Scores of Beauty

    “Segmented Workflows”

    OK, the title of this post seems to be a cheap pun because it refers to the previous post about the “Segment Grid” approach. But in a way it is quite appropriate because that approach allows us to split our workflow into similarly arbitrary segments as the segment grid in the score suggests.

    As described in the previous post we have sliced our score into pieces, more concretely a grid of segments containing one “voice” for the length of one rehearsal mark each. Any segment that has been entered will automatically be placed in the score, replacing a previously empty spot. I have already mentioned a few of the advantages this approach provides:

    • It’s straightforward to distribute work on any number of contributors.
    • The complexity of the file an individual contributor has to deal with at a time is dramatically reduced.
    • The contributor doesn’t have to worry about a consistent stream of music throughout the whole part (i.e. he doesn’t have to worry about breaking anything when editing the individual file).
    • If timing errors are introduced they are immediately noticed (when compiling a whole part or the score) and can be easily tracked down and fixed.

    But of course there is much more to it than that, particularly because we also have version control at our disposition.

    Constant Peer Review

    It is not possible to produce a score of such dimensions without making errors. We can also see that from the original score, in which numerous errors have even survived until today. And even the most scrupulous contributor will be faced with musical issues in the score that he or she wouldn’t want to decide alone. Deferring evertyhing to the “one grand proof-reading” after music entry is completed looks like hara-kiri, and it turns out that two decisions have been extremely valuable: implementing an annotation infrastructure and integrating permanent peer review in our workflow. The first item will get its own post, today I’ll talk about the latter.

    As usual in versioned workflows all work happens in the context of working branches. That means there is an “official” state of the project which is represented by the master branch, and work of the contributors will only be included in this official state when it has been completed. So the public surface of the project is always in a consistent state but it doesn’t reflect all the latest work that has already been done.
    To improve quality control we have installed a workflow of continuous peer review. Anyone who has finished some work is not allowed to merge that into master alone, instead someone else has to review the material first. This guarantees that everything in the official score has been seen by at least two pairs of eyes, and it has become clear that it is much easier to manage and to maintain that paradigm if peer review is going on constantly, in digestible chunks of 1-10 segments each.

    The peer review process has also proven to be an appropriate place to discuss musical issues with the original score. We are not commissioned to do a scholarly review (so far), but it became apparent that it is not practically possible to copy a flawed score literally. People tend to spot many of the more and of the less apparent issues with the manuscript. The level of detail and attention is of course varying but I have been very positively surprised about the quality and amount of annotations that have been made to the score, by contributors who are only partially musicians or musicologists! As said I’ll go into detail about the annotations in a later post, but annotations are inserted in the textual input file (of course) and are highlighted by coloring the affected items in the score. That way it becomes natural to have a second look on them during peer review, so many of these annotations can be approved, discussed or rejected at a very early stage, before the respective material is even merged into the master branch.

    Keeping Cool With Project Progress

    Doing constant peer review and having the music entry encapsulated in working branches not only improves the quality of the musical text we produce, it also makes us much more comfortable with the progress we make. As said entering the music in segments takes the pressure out of keeping the “document” consistent, but doing that also in branches is a highly efficient safety net for the project management as a whole. An open branch indicates some work going on, and the list of open branches tells exactly what is being done currently. The same way anyone can pick any segment of music to enter anyone can also pick some work to be reviewed, and we don’t have to worry about missing anything. We have imposed a rule that any branch that is put up for review should be renamed to start with review/, so listing all open branches with that keyword tells us what is available for review:

    $  git branch -a | grep origin/review | sed 's/remotes\/origin//'
    $ git branch -a | grep review | wc -l

    So we know that currently there are 46 tasks ready-for-review. Some more Git trickery discloses that they contain more than 300 segments of music, so obviously review is currently somewhat lagging behind. This is due to the fact that reviewing is felt to be a task with more responsibility so the majority of contributors prefers entering music. I have always done more review than music entry, but recently I have been quite busy with programming Python tools for our project (that hopefully are generically usable for future projects too) so there has been some accumulation of review tasks. But the point is that this is no reason to worry about since everything is reliably stuffed and organized in branches. Anyone can pick any task to shorten the task list, and when it’s done it will be neatly included in master. The most severe “downside” of the current situation is that the master branch is proceeding slower than the actual work could warrant.

    Demonstrating the Stability of the Approach With a Bug

    Let me finish this post with an incident we experienced. It was a bug but ironically it’s perfectly suitable to demonstrate the reliability of our segmented approach.

    One day a contributor noticed that the score didn’t compile correctly anymore. All of a sudden LilyPond threw tons of error messages about failed bar checks on us, but the actual PDF didn’t show more than one duplicated rehearsal mark and three extra “end” barlines on the last page. Thanks to the Git history it was easy to determine when this issue was introduced, but it was very hard to see why because nothing in that place seemed to be related to such an issue at all. It took us about 24 hours to track down the problem, and it turned out that it actually was a LilyPond bug. In newer versions of LilyPond you can enter “unpitched notes”, that is plain rhythmic values to be used with percussion instruments. We discovered that such notes can – in combination with ties and manual breaks – cause an error in the timing, which caused our score to break without any wrong input that we could have identified. We reported the issue as a bug to the LilyPond developers, and one day later it was already fixed.

    While this can serve as a nice example for efficient bug tracking and really snappy “support” and fixing, that’s not the main point in telling that story. The miracle around it is that the whole episode did not affect the work on music entry and review at all. Everybody who wasn’t directly involved in finding the bug could simply continue to work as usual. I admit it has been a very long time since I worked with graphical score editors, but I’d never want to imagine the impact of such a situation if our score would be developed in a huge Finale or Sibelius document.

    Next time I will tell you about our system of in-file annotations. This is very much a work in progress, and I would love to have it developed much further, but it serves us really well already in its present state.

    by Urs Liska at October 20, 2014 03:15 PM

    GStreamer News

    gst-validate, gst-editing-services, gst-python and gnonlin 1.4.0 stable release

    The GStreamer team is pleased to announce the new the stable 1.4 release of gst-editing-services, gst-python, gnonlin, and GstValidate. The 1.4 release series is adding new features on top of the 1.0 and 1.2 series and is part of the API and ABI-stable 1.x release series of the GStreamer multimedia framework.

    Check out the release notes for gst-editing-services, gnonlin, gst-python, gst-validate, and download tarballs for gst-editing-services, gnonlin, gst-python. gst-validate.

    October 20, 2014 01:00 PM

    Linux Audio Announcements -

    [LAA] QjackCtl 0.3.12 released, feat. JACK Pretty-names aliasing

    From: Rui Nuno Capela <rncbc@...>
    Subject: [LAA] QjackCtl 0.3.12 released, feat. JACK Pretty-names aliasing
    Date: Oct 20, 7:44 am 2014

    Again, a classic needs no introduction...

    QjackCtl 0.3.12 is now released!

    - JACK client/port pretty-name (metadata) support is being introduced
    and seamlessly integrated with old Connections client/port aliases
    editing (rename) (refactored from an original patch by Paul Davis,
    thanks). (EXPERIMENTAL)
    - Application close confirm warning is now raising the main window as
    visible and active for due top level display, especially applicable when
    minimized to the system tray.
    - Messages standard output capture has been slightly improved as for
    non-blocking i/o, whenever available.
    - Translations install directory change.
    - Allow the build system to include an user specified LDFLAGS.
    - Missing input/output-latency parameter settings now settled for the
    D-BUS controlled JACK server and firewire back-end driver.


    Project page:

    - source tarball:
    - source package (openSUSE 13.1):
    - binary packages (openSUSE 13.1):

    Weblog (upstream support):

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

    See also:

    Enjoy && Have fun!
    rncbc aka Rui Nuno Capela
    Linux-audio-announce mailing list

    read more

    October 20, 2014 08:00 AM

    Libre Music Production - Articles, Tutorials and News

    QjackCtl 0.3.12 released

    Qjackctl version 0.3.12 has just been announced. This release includes the following changes -

    by Conor at October 20, 2014 07:45 AM

    October 19, 2014


    Time Is A Musicians Best Friend

    “Sometimes we get caught offbeat,
    and as tempo changes with the season.
    So do memories of a dark and traumatizing cadenza.”

    I need to get back to creating, it is good for the soul.
    For a while I was lost to worrying about what could be, and forgot to live in the now.

    What motivates you to create music?



    by pete0verse at October 19, 2014 08:35 PM

    QjackCtl 0.3.12 released, feat. JACK Pretty-names aliasing

    Again, a classic needs no introduction...

    QjackCtl 0.3.12 is now released!


    • JACK client/port pretty-name (metadata) support is being introduced and seamlessly integrated with old Connections client/port aliases editing (rename) (refactored from an original patch by Paul Davis, thanks). (EXPERIMENTAL)
    • Application close confirm warning is now raising the main window as visible and active for due top level display, especially applicable when minimized to the system tray.
    • Messages standard output capture has been slightly improved as for non-blocking i/o, whenever available.
    • Translations install directory change.
    • Allow the build system to include an user specified LDFLAGS.
    • Missing input/output-latency parameter settings now settled for the D-BUS controlled JACK server and firewire back-end driver.

    Flattr this


    Project page:


    Weblog (upstream support):


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

    Enjoy && Have fun!

    by rncbc at October 19, 2014 08:00 PM

    Recent changes to blog

    Linux Audio Announcements -

    [LAA] 2015 ASCAP/SEAMUS Student Commission Competition

    From: Per Bloland <per.bloland@...>
    Subject: [LAA] 2015 ASCAP/SEAMUS Student Commission Competition
    Date: Oct 19, 9:49 am 2014

    Content-Transfer-Encoding: quoted-printable
    Content-Type: text/plain;

    (apologies for cross-postings)

    The Society for Electro-Acoustic Music in the United States (SEAMUS) is =
    pleased to announce the 2015 ASCAP/SEAMUS Student Composer Commissioning =

    The purpose of this program is to stimulate student participation in =
    SEAMUS activities, and to encourage young composers to pursue creative =
    endeavors in electro-acoustic music. The program is administered by =
    SEAMUS and funded by the American Society of Composers, Authors and =
    Publishers (ASCAP) .

    The submission deadline is October 31, 2014.

    For more information, please visit the ASCAP/SEAMUS Competition =
    information page .
    To submit via the online application, please visit the current =
    submission site.

    Please note that you must be a current member of SEAMUS to submit to the =
    competition. You can join or renew your membership at the newly =
    redesigned SEAMUS website, Joining takes =
    only a few minutes. You must supply your seamusonline username to =
    complete your submission. (Your seamusonline username is independent of =
    your Start Conference, submission username.)

    If you submitted to the 2014 SEAMUS Conference at Wesleyan, your Start =
    Conference submission username and password are still valid.


    All submissions are to be made online, through the submission site. =
    Only one work of electroacoustic music may be submitted, which must =
    adhere to the following guidelines:

    =95 Audio Files: music submissions should include a representative audio =
    recording of the work. If a concert work, it must be the complete =
    composition. Installations may be represented by an excerpted recording =
    not to exceed 10 minutes in length. Judging of music submissions for =
    ASCAP/SEAMUS Student Competition will be from audio files in the MP3 =
    format. Multichannel works will be judged from a stereo mix, also MP3. =
    Please assist us by submitting in MP3 format. Audio files must be =
    prepared as a single LastnameFirstname_audio.MP3.=20
    =95 Scores: for submissions involving a score, please submit an =
    anonymized PDF score for review. Please do not mail in printed scores. =
    Score submissions must be prepared as LastnameFirstname_score.PDF.
    =95 Video Submissions: note that for works involving video, only the =
    audio portion will be considered for judging purposes. You must be the =
    composer of the music for the video. Please submit an MP3 of the music =
    as specified above.
    =95 Only one (1) entry per student.=20

    Other than the filename, please make sure to remove your name from all =
    files, including MP3 metadata and PDF scores. Please limit the total =
    size of all files to 40MB.

    This same work may be submitted to the SEAMUS 2014 National Conference =
    via the conference submission page. All finalists in the ASCAP/SEAMUS =
    Student Commission Competition must attend the SEAMUS 2014 National =
    Conference. Submissions by High School and Undergraduate students will =
    automatically be considered for the Allen Strange Memorial Award as =


    A maximum of two prizes may be awarded. The decision of the judges will =
    be final.

    First Prize

    =95 Commission of $1250 for a new work of electro-acoustic music
    =95 Performance of commissioned work at the 2016 SEAMUS National =
    =95 Recording of the commissioned work in the SEAMUS Compact Disc Series
    =95 Certificate of recognition

    message continues]

    read more

    October 19, 2014 10:00 AM

    Recent changes to blog

    Faust to LV2

    Creating LV2 bundles from faust source files within guitarix.

    You would find the script in guitarix/src/LV2/
    Usage is simple, just run

    ./ -p path/to/source/ sourcefile.dsp

    to create a LV2 bundle from a faust source file.
    The bundle will appear in the guitarix/src/LV2 directory and comes with a included makefile to build the bundle independent, as well it include a wscript to include the bundle into the guitarix build environment.

    To test your plug you could install it as user to (~/.lv2) (make install) remove it with make uninstall.

    The LV2 plug wouldn't have a GUI, but it is prepared for the use within the MOD SDK to add a MOD UI.

    by brummer at October 19, 2014 03:51 AM

    October 18, 2014

    Linux Audio Announcements -

    [LAA] Drumstick Metronome 1.0.0 released

    From: Pedro Lopez-Cabanillas <pedro.lopez.cabanillas@...>
    Subject: [LAA] Drumstick Metronome 1.0.0 released
    Date: Oct 18, 7:52 am 2014

    Drumstick Metronome is a MIDI metronome with Qt5 user interface, based on the
    ALSA sequencer, formerly named KMetronome.

    Changes in 1.0.0
    * Migrated to Qt5, removing KDE dependencies.

    Copyright (C) 2005-2014, Pedro Lopez-Cabanillas
    License: GPL v2

    More info


    Linux-audio-announce mailing list

    read more

    October 18, 2014 08:00 AM