Krad Radio

Remote TCP based control with native IPC clients now possible.

ex.
Remote Machine:
$ krad_radio_cmd panda1 remoteon 33333
Local Machine:
$ krad_radio_cmd 192.168.1.10:33333 mix
$ krad_radio_gtk 192.168.1.10:33333

Remote Web control using Websockets + JSON<->native IPC translator working as well.

$ krad_radio_cmd radio1 webon 42000 42001

Please notice that http and websockets servers are built into the daemon, as well as all needed HTML and JS. No additional BS required. Thanks for noticing that.

JSON API is evolving, but the end result will be full control over all visual presentation, no design will be imposed.

The other notable remote control method that will be included is OSC (Open Sound Control)

Everyone’s got two arms, by that I mean CPU’s. x86_64 isn’t the only game in town. Exactly most percent of all 1.2 zillion phones, tabs and friends are running Linux on arm cpus. Krad Radio will be at that party. The revolution will be televised, by you!

Each instance of the krad_radio daemon represents “a station”. This could be your online radio or tv station for example, or perhaps just a part of your global network. When you launch the daemon, it takes a single argument, in Krad Radio jargon this is known as the system name, in legacy systems it might be called the callsign, essentially a unique identifier (within the context of the user account on the server you are using) with some restrictions on format. For example, if your station was called “Coconut Funworld” you may choose coconut as the system name.

$ krad_radio coconut

The station daemon is now running. All interaction with it is done by remote control. The command:

$ krad_radio_cmd coconut mix

Would give you a printout of your current audio mixer configuration.

For the technically inclined, on a Linux system, the daemon is listening on an unix abstract socket called @krad_radio_coconut, on other systems it will use a filesystem path.

If you want to connect to the daemon remotely to control it there is two options, one is to enable IPC connections on a TCP port, the other is to enable the built in http and websockets server which provide a JSON based API. Create the web interface of your dreams, or using someone else’s. And there is always the command line, ncurses, GTK or whatever else suits you.

There are three core components inside of Krad Radio, the mixer, the compositor and the linker. The mixer enables you to set and monitor audio levels, apply DSP effects such as EQ or tape/tube distortion. The compositor allows you to work with video, text and graphical overlays, and audio visualizations. The linker enables you to send and receive live audio/video streams, record your station and hook directly into local audio/video sources such as camera’s and microphones.

One of the key concepts of Krad Radio is that it does away with the old thinking of having a ridged client/server model. For example, long ago in the dark ages you may have had a phone, and your friend who is far away does as well. Both of you can send and receive calls, but only through the operator, and only the operator can route calls in an arbitrary way, for example connecting three people together on a single call. With Krad Radio everyone has the power of the operator. It is a decentralized system.

Lacking an ability to degrok at the moment , I must resort to pointing.

[oneman@rawdod4::~/kode/krad_radio/krad_apps]$ ./krad_radio_cmd radio1 input Music1
[oneman@rawdod4::~/kode/krad_radio/krad_apps]$ ./krad_radio_cmd radio1 input Music2
[oneman@rawdod4::~/kode/krad_radio/krad_apps]$ ./krad_radio_cmd radio1 output Main
[oneman@rawdod4::~/kode/krad_radio/krad_apps]$ ./krad_radio_cmd radio1 mix

Input name: Music1
Channels: 2
Type: Jack
Volume: 90.000000
Bus: Master

Input name: Music2
Channels: 2
Type: Jack
Volume: 90.000000
Bus: Master
[oneman@rawdod4::~/kode/krad_radio/krad_apps]$ ./krad_radio_cmd radio1 xfade Music1 Music2

[oneman@rawdod4::~/kode/krad_radio/krad_apps]$ ./krad_radio_cmd radio1 mix
Received KRAD_MIXER_MSG 111 bytes of data.

Input name: Music1
Channels: 2
Type: Jack
Volume: 90.000000
Bus: Master
Crossfade With: Music2
Crossfade: -100.000000

Input name: Music2
Channels: 2
Type: Jack
Volume: 90.000000
Bus: Master
[oneman@rawdod4::~/kode/krad_radio/krad_apps]$ jack_lsp | grep radio1
radio1:Music1_Left
radio1:Music1_Right
radio1:Music2_Left
radio1:Music2_Right
radio1:Main_Left
radio1:Main_Right
[oneman@rawdod4::~/kode/krad_radio/krad_apps]$

In the image you see above, there is two instances of a Krad Radio GTK based interface. They are both connected to the same station, and are always in sync. You can run any number of interfaces, locally or remotely, and they are always in sync, even if they have a quite different look and feel. Strait up GTK interfaces tend to be somewhat sterile, but that’s good, they serve as a good example.

The interface as seen above, and any other interface is dynamically generated, only the general layout is what is set in the GTK code. This is only showing the current mixer configuration as setup in the commands above. Any input or bus can be tied to another one to create a crossfade group, for example, if an Aux input was created, one could crossfade between the Music and Aux bus’s.

I’ve been working on Krad Radio essentially full time since November of 2010, and its in its third architecture if you will. The first version was never intended to be a perfect and holy architecture, the second one was, and it was pretty good, but its been remolded into a third architecture, which I have recently arrived at in the last months. I expect a release version of it is actually close at hand. No good code or idea from an earlier version has been lost, this is and will be the best version possible. A brief overview.

The first version was based on the combination of a few things, Jack for routing audio, a modified edcast2 for streaming, and multiple instances of ecasound for mixing and effects, and XMMS2 for music. All of this was remote controlled via a Rails app using PostgreSQL for a database. It worked, but it was somewhat of a close, but no cigar to what I really wanted. ecasound was imperfect and crashable, edcast2 was really a quite dirty chunk of software, and Rails + Ajax was fast, but it wasn’t “instantly responsive”. This version did prove the concept clearly to me, you can make a remote controlled radio station, and it can be really awesome, and you can run a large number of them on one server that doesn’t even have a sound card. I also experimented with using mumble (Celt codec) to send in voice-over in real time.

Version two kept Jack and XMMS2 , but got rid of edcast2, ecasound and mumble in favour of custom coded per-purpose daemons. It also combined Websockets based control with Rails. Thus was born quite a number of daemons, Krad Cast, Krad Mixer, Krad Recorder, Krad Sampler, Krad Link.. Krad Cast replaced edcast2. Krad Mixer handled mixing and some effects such as side chain compression and EQ. Krad Recorder recorded things to FLAC. Krad Sampler was a basic sampler/looper for effects, Krad Link was designed to connect to a client side Krad Link to send lossless FLAC or lowlatency Celt streams back and forth to remote DJ’s. All of this worked quite well actually, except for a few things that became more painful at scale and over time. Each daemon was controlled via an IPC that was essentially quite arbitrary, and whenever I had to send a new kind of data across it, it just got more and more dirty. Also at this point, each station had about…

( to be continued later tonight…. )

I created this logo, complete with Helvetian font and drop shadow to explain what Krad Radio is about technically in the most condensed tl;dr way. It’s not a very good logo, and I don’t think I’ll use it again, perhaps you can create a better one. Now that you have read this far I can tell you its incomplete, KR also has capture and broadcast functionality. Its primary purpose is to provide the core software infrastructure of live internet-based radio and television stations.

Shocking! I am beside myself!

The thing I have been waiting for my whole life maybe coming around to existing in an hour and half, it could all be an elaborate rick roll, but I am an optimist.

http://www.planetaryresources.com/

I would have re-read my copy of mining the sky, but I don’t re-read things and I didn’t forget a single fact in it. http://www.amazon.com/Mining-The-Sky-Asteroids-Planets/dp/0201328194

I spent some other untold hours turning the hexdriver on my other vehicular, and its finally together minus the computer components. I drove it for a few minutes with the normal remote and managed to break a hardened steel screw right off it. I’ve got a bunch of titanium screws now so I’ll be replacing them as things go along. Turning the hexdriver is alot different than the usual hex editor, its a welcome break to work on something physical for a while. Here are some more pictures incase it blows up on the next test run, which I intend to video, before putting the computer inside it, because I have a feeling its going to be a real roll of the dice even with the best shock mounting I can come up with at this moment.

Couldn’t help but throw this together in the quickest ghetto way possible to see if it was as easy as I thought it would be, it was.

Now just need to do it nicely.