New English File Elementary Audio
Ji Kartchner
I've seen many queries lately from people looking to leave Apple/MacOS but unsure about how they can continue making music (lots of Logic and Live users) on Linux. I'm creating a series of step by step video guides to help people get a pro audio system going with Linux. Today I finished the elementary OS video (one of my favourite distros). I think it can really help and encourage those that have concerns about making music once they step away from Mac. elementary OS and Bitwig is an awesome combo!
Elementary is a JavaScript runtime for writing native audio applications, as well as a library and framework for composing audio signal processes. This is a tool heavily inspired by React.js with which you can write a complete audio DSP application, whether you're targeting web, desktop, mobile, embedded linux, or any of the various native plugin formats for integrating into a modern DAW.
I recently shared a short presentation on YouTube (which I'll show below) that describes some of the problems that I feel we commonly face when writing native audio software, and how Elementary aims to solve those problems. Rather than repeat myself here I want to share part of the story that's not covered as thoroughly in the presentation: the story of how I arrived at the idea of a declarative, functional, reactive model for writing audio DSP, and why I think it's worth betting on.
Before I started working in audio software, I spent many years working primarily in frontend web development, and primarily in JavaScript. I worked on various projects over several years in every flavor of frontend JavaScript application framework before eventually joining the Instagram team at Facebook shortly after their acquisition. There, I had the opportunity to deeply learn, invest in, and even contribute to React.js.
Taking that tradeoff means engaging a whole series of problem domains inherent to writing C++ applications, as we try to build the audio software we set out to ship. The problems that then arise from those domains take real time, and complicate the development process. This is still just part of the tradeoff that we must make when working at the layer of realtime audio rendering. But where I speak of the wrong tooling, I'm really thinking of what happens in the domains where we don't need to take such a tradeoff. It seems to me that we have something of an "everything is a nail when you have a hammer" problem in audio software: once we've committed to writing our audio rendering in C/C++ we carry on to every other edge of our application with the same tools and the same inherent complications. We spend inordinate amounts of time trying to address problems of memory management where we should really just be using a garbage collector. We invite race conditions and synchronization headaches where we should really just be using an asynchronous event-driven engine.
The fact that so many audio software user interfaces are written in C++ drives this point home for me. The types of constraints and requirements that necessitate a language like C++ at the level of realtime audio rendering simply don't exist in the user interface piece of our application. The tradeoff isn't worth it anymore without those requirements, and in my experience, our industry wastes a vast amount of time and resources developing major pieces of our applications with tools that don't make sense. This realization was a major impetus for kicking off my React-JUCE, formerly named Blueprint, project (an update on which is coming soon!).
As it regards writing audio DSP though, this way of thinking didn't start setting in for me until I found myself trying to design the right abstraction for developing my own library of easily composed audio processing blocks. The further I got into that problem, the more I realized that an object oriented approach is fundamentally incompatible with the type of abstraction I was looking for, and that managing object lifetimes compounded the difficulty of the problem drastically. Eventually it dawned on me that the task of composing audio processing blocks is itself free of those realtime performance constraints mentioned above: it's only the actual rendering step that must meet such requirements.
Once this idea took hold, the freedom to explore new abstractions for composing audio signal processes opened up immediately, and I knew right then that I wanted to arrive at an abstraction that brought with it that same perspective that I had grown to love in React.js: "Given a predefined application state X, I want the signal flow through my application to look like S." And I knew that to get there, I wanted to embrace the following ideas:
To me this is already a significant improvement over any form of signal composition I've seen in the audio DSP domain, but it's just the tip of the iceberg in Elementary. For example, if we wanted to extend our 3-band EQ into an 8-band EQ, the only thing that needs to change is to describe state for 8 filters rather than 3. If we then wanted to disable 3 of those filters in response to some hypothetical user gesture we could simply remove them from the state.
Now, to really complete this model we have to address the way that applications change over time. It's convenient to write a single static description of your audio processing pipeline and then never have to change it, and surely we already have tools that make that process nicer for the developer. But what happens when we need to address the dynamic behavior of our application? Consider again the above example, where perhaps our app initializes with 8 active filters in our EQ and then the user invokes an action that should disable one of them. What should we do? What should our tools help us do? For example, in a "modern" audio software approach we would likely set the appropriate filter node here to bypass. Personally, I wonder sometimes if the whole idea of bypassing audio processing blocks comes out of the fact that we don't have a good answer to dynamic behavior in audio DSP.
To me, this point drives home the value of working with such a functional, declarative abstraction. Whether I'm trying to write a static audio signal process that never changes or a flexible, dynamic process that needs to adapt to the user's intentions, the approach is the same. We can think only in terms of what our application should be, and defer all of the how to Elementary.
In my experience recording in both windows and mac It is no secret you need a lot of configuration prior recording anything (either audio or midi) Not to mention having decent hardware and up to date plugins to run them.
Add the KXStudio repository and install Catia for Jack connections. It's 1000x's easier to use than QJackCtrl. Besides, it is pretty much the repository that Ubuntu Studio relies on for its audio software updates. Get familiar with Audacity, Hydrogen drums, or ZynAddSubFX before doing anything complex like with Ardour. Guitarix is also a good choice for guitars and Bristrol for old-school synthesizer emulation. Hydrogen, Bristol, and ZynAddSubFX work with aconnect to get MIDI keyboard working if you don't want the headache of using Jack and just want to play around.
Not free, but based on Ardour is Mixbus by Harrison (standard or 32c). Not sure about Ardour, but Mixbus does a system check and configuration for you automatically on install. All you need to do is install the -lowlatency kernel if you require additional low latency performance/reliability. Not needed for printing VIs but IMO necessary for audio recording. Jackd is not required, as Ardour/Mixbus can grab hold of the sound card directly via ALSA. You only really need Jack if you plan on multiplexing audio from various sound sources. If you are OK with the DAW monopolizing the sound card temporarily and don't need to connect and route audio between various software, then don't worry about it too much. Monolithic DAWs such as Ardour and Mixbus and Reaper can handle everything internally, which makes jackd somewhat superfluous.
The input needs to have shielded audio cable from source to potentiometer to amplifier with the shield connected to the common and center wire as the signal in. This will eliminate stray noises on the input. Battery or good DC regulated PSU is also important.
An elementary stream (ES) as defined by the MPEG communication protocol is usually the output of an audio encoder or video encoder. An ES contains only one kind of data (e.g. audio, video, or closed caption). An elementary stream is often referred to as "elementary", "data", "audio", or "video" bitstreams or streams. The format of the elementary stream depends upon the codec or data carried in the stream, but will often carry a common header when packetized into a packetized elementary stream.
However, the barrier to entry has always seemed too much for a frontend developer such as myself to stomach. The need for mastering C++ audio programming in addition to an audio plugin framework such as JUCE has been a turn off. Not anymore. Say hello to Elementary, a JavaScript framework for audio coding.
As you can probably guess, el.in() reads incoming audio. And channel: 0 tells it to read only one channel. Then we render() channel 0 where 1 is expected and vice versa. Simple but effective and does the job.
I am running elementary OS on a Galago UltraPro laptop. Originally, some of the hardware was not working because elementary uses the Ubuntu 12.04 kernel and the Galago UltraPro uses the relatively new Haswell processor and graphics drivers. However, I managed to get the graphics drivers working properly by running the command:
I read here: =2170623, that by plugging in a 3.5mm jack into the microphone jack, the internal mic would work again. When I tried this, the microphone works somewhat for a brief moment, but then fails again. I am imagining the microphone problems have something to do with the fact that elementary OS Luna is based upon Ubuntu 12.04 because when I boot into Manjaro Linux, the internal microphone works as expected.
8d45195817